Hey guys,

"I'm thirsty" will be my entry for the Calculator Gaming Roots contest. I don't know if it'll be finished in time, but we'll see.

So basically there is a little boy who found a dragon egg in the countryside. The dragon born and is very hungry, so the little boy give him meat. Then, the little dragon is very thirsty, but the little boy can't make him drink since the dragon drinks kerosen. So instead he brings his dragon to a special laboratory, and scientists will take care of bringing kerosen to the dragon.

You are one of those scientists, and you must bring the liquid kerosen to the dragon through levels full of obstacles using the different objects of the level. The game will feature realistic water physics, among other things. Screenshots coming soon.

Stay tuned

<cross-posted from Cemetech>

Hallaw people,

I finally got something related with 3D working in ASM ! <this is a bit like a dream coming true for me >

Well, nothing too unbelievable, but I'm happy with what I have so far

So, I wrote 3 main routines, and a few other ones you can use, but these latter are not focused on 3D.

Main 3D routines :

• BuildMatrix : builds the XY composite rotation matrix given the rotation angle about X and Y axis, respectively in b and c. The advantage is that you can rotate several vertices about the same angle without recalculating the rotation for each vertex.
• ApplyMatrix : applies the matrix stored from AX to CZ (some .db in the program) to the three points stored at inX, inY and inZ and stores the result at outX, outY and outZ (more .dw). This is not necessarily a rotation matrix, but BuildMatrix writes to this area.
• ProjectVertex : does the necessary calculation to project a vertex on-screen. Takes outX, outY and outZ as parameters and outputs at outX and outY. outZ remains unchanged.

Others routines provided (only because they are used by the 3 above routines) :

• multHL_DE : performs HL*DE and stores the result in HL.
• divHL64 : I let you guess.
• mulHL64 : ↑ this.
• AextendSignDE : converts the 8-bits signed number in A to a 16-bits signed number in DE.
• getSin, getCos : retrieves the entry corresponding to the angle A in the trig look-up table (1-byte entries scaled to 64, so it goes from -64 to 64).
• HLsignedDivDE : performs signed HL/DE, result in HL.
• HLdivDE : performs unsigned HL/DE, result in HL (by Xeda112358).

Screenshot ? Yes, definitely :P



If you have any comment on the routines I described before I release the source, please tell me :)

http://luis.net/projects/processing/wormhole/

It would be oh so awesome

Although it's written for Processing, it's still Java → close to C++, so it should be feasible.

Hallaw,

When you have to draw a great part of the screen pixel by pixel (like for a game of life), the program usually become reaaally slow, since Axe is not good at pixel drawing. So I've thought of a method to greatly speed up this kind of tasks.

So, how does it work ? You know that the TI-z80-s screen (excepted the 84+ C) takes 1 byte to code 8 pixels, so that 1 bit = 1 pixel. The technique consists in calculating each pixel as we would do normally, and then turn on or off the corresponding bit of a variable instead of turning it on on the screen (which is absolutely slower). Then, when the 8 bits of the variable have been modified the way you wanted, you can directly store the variable in the corresponding byte of the buffer, thus turning on/off 8 pixels at a time. Of course, this'll only work if the width of area you want to paint is a multiple of 8.

So let's do it !

Let's say that our function is named BuildByte, since that's what it does.

First, we need a counter. This counter must send a signal every 8 times we call it.

:.Only once
:0→C
:
:Lbl BuildByte
:If C++^8
:.The counter doesn't send the signal
:Else
:.It does
:End
:...

Then, we need the variable which will contain the pixels data :
:.It must be initialized to 0 at the beginning of the program
:0→B

Say that the function BuildByte takes three arguments, the X-coordinate of the byte where the pixel must be drawn (not the pixel, so it must be a number between 0 and 11), the Y-coordinate of the pixel (between 0 and 63), then 0 if the current pixel must be white, or 1 if it must be black. We need to put this 0 or 1 to the corresponding bit of B. Then if C is a multiple of 8, then it means that the 8 bits of B have been set, and we store B in the corresponding byte of L₆.

But how do we do set the corresponding bit precisely, and not any other bit ? It's actually pretty simple : we always set the first bit, and then if C modulo 8 is not 0, we shift B left once. Why that ? After 7 shifts, the first pixel/bit you passed to the function will become the last bit → the first pixel of the byte when it's on-screen.

:Lbl BuildByte
:.r₁ is the X coordinate
:;r₂ is the Y coordinate
:.r₃ is the value of the pixel
:
:r₃ or B→B
:If C++^8
:B*2→B
:Else
:B→{r₂*12+r₁+L₆}
:0→B
:End
:Return

Remember that this will be efficient only if a relatively high number of calculations are needed for each pixel. For example, this plasma program I wrote a while ago uses this method (attached screenshot runs at 6 MHz).

Hoping that this'll help you

Hallaw people,

In my free time I like to program some small animations on my calc, and I thought it could be cool to make a topic to show you the ones that I think should be shown

[Ndless C] Plasma (I know this already exists, but it doesn't use SDL anymore, for this I reused part of a library I'm writing to deal with screen and pixels). My library handles cross-compatibility, so you can use the same *.tns file for both CX and non-CX calcs

It takes ≈ 6 seconds to start because it has to compute and store 76800 * 7 sines and 76800 * 2 square roots in a table in order to get a decent execution speed

Hallaw,

I'm stuck with a weird error when programming with Ndless. The emulated Ti-Nspire CX (not sure if CAS) crashes when executing :
int* D3_sortFaces(Vertex *vertexTable, Vertex camera, int **faces, int numberOfFaces, int *verticesPerFace)
{
int i, j, flag, intermediate;
char *order;
int *zAverage;

order = malloc(numberOfFaces * sizeof(char));
if(order == NULL)
{
printf("error with order");
return NULL;
}

zAverage = malloc(numberOfFaces * sizeof(int));
if(zAverage == NULL)
{
free(order);
printf("error with zAverage");
return NULL;
}

for(i = 0; i < numberOfFaces; i++)
{
order[i] = i;
zAverage[i] = 0;
for(j = 0; j < verticesPerFace[i]; j++)
{
printf("%d,%d\n",i,j);
zAverage[i] += vertexTable[faces[i][j]].z - camera.z; // crashes here
}
zAverage[i] /= verticesPerFace[i];
}
printf("zAverage passed");
// etcGiven :
char faces[6][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {0, 4, 7, 3}, {3, 2, 6, 7}, {0, 1, 5, 4}, {1, 5, 6, 2 } };
char *order;
int vpf[6] = { 4, 4, 4, 4, 4, 4 };


// ...
// rotated is a 8 elements-large table of bunches of 3 values
order = D3_sortFaces(rotated, (Vertex){0, 0, -150}, faces, 6, vpf);
I don't know if you understand well, but I don't want to release a complete source for now

What this does is that it displays "0,0", \n then "Reset" and → crash.

If you have any idea of what's wrong, please tell me

Hey guys,

I'm in needs of sprites for IkarugaX, so by the way I thought that I could create (if it's not done already, please tell me if it's the case) a general sprite request topic, to avoid creating several ones for each game.

So, I need a 32*24 monochrome spaceship sprite, facing down. It's intended to be the first boss, so please make it look like a villain

Also, there's something to care about : the hit box has to be as large as possible, and obligatory rectangle-shaped.

That's all, thanks by advance

Hey guys,

I'm currently adapting F-Zero to use with the hoffa and t_k' mode7 engine, but I can't make it display a simple rotoscaled map. I didn't ask them because there's been a while they didn't even log in

So, I adapted a little bit the engine to make it work with non-square maps, but it keep not working.

Original m7.c :
#include <os.h>
#include <SDL.h>

#include "m7.h"

void m7BuildLut(m7Vec_t lut[M7_SCREEN_HEIGHT]) {
    int screenRow;
    for (screenRow = 0; screenRow < M7_SCREEN_HEIGHT; ++screenRow) {
        float cameraV = (((float)screenRow / (float)M7_SCREEN_HEIGHT) * 2.0F - 1.0F);

        float rayX = M7_VIEW_PLANE_H;
        float rayY = 1.0F;
        float rayZ = M7_VIEW_PLANE_V * cameraV;

        float intersectY = (M7_VIEW_HEIGHT / rayZ) * rayY;
        float intersectX = (M7_VIEW_HEIGHT / rayZ) * rayX;

        lut[screenRow].x = M7_FLOAT_TO_FIX(intersectX);
        lut[screenRow].y = M7_FLOAT_TO_FIX(intersectY);
    }
}

void m7LoadTex(Uint8 tex[M7_NUM_TEX][M7_TEX_SIZE][M7_TEX_SIZE], ...) {
    va_list ap;
    int i, j, k;

    va_start(ap, tex);
    for (i = 0; i < M7_NUM_TEX; ++i) {
        SDL_Surface* surf = va_arg(ap, SDL_Surface*);
        for (j = 0; j < M7_TEX_SIZE; j++)
            for (k = 0; k < M7_TEX_SIZE; k++)
                tex[i][j][k] = nSDL_GetPixel(surf, k, j);
    }
    va_end(ap);
}

void m7Render(SDL_Surface *screen,
              m7Vec_t lut[M7_SCREEN_HEIGHT],
              Uint8 tilemap[M7_MAP_SIZE][M7_MAP_SIZE],
              Uint8 tex[M7_NUM_TEX][M7_TEX_SIZE][M7_TEX_SIZE],
              m7Vec_t pos,
              Sint32 heading) {
    int screenX, screenY;
    for (screenY = (M7_SCREEN_HEIGHT / 2) + 1; screenY < M7_SCREEN_HEIGHT; ++screenY) {
        m7Vec_t map = lut[screenY];
        m7Vec_t mapXStep = {-map.x / (M7_SCREEN_WIDTH / 2), 0};
       
        Sint32 sinHeading = m7SinLut(heading);
        Sint32 cosHeading = m7CosLut(heading);
       
        m7RotateVec(&map, sinHeading, cosHeading);
        m7RotateVec(&mapXStep, sinHeading, cosHeading);
       
        map.x += pos.x;
        map.y += pos.y;
       
        for (screenX = 0; screenX < M7_SCREEN_WIDTH; ++screenX) {
            Uint8 color = 0;

            if (map.x >= 0 && map.x < M7_INT_TO_FIX(M7_MAP_SIZE)
             && map.y >= 0 && map.y < M7_INT_TO_FIX(M7_MAP_SIZE))
                color = tex[(int)tilemap[map.y >> M7_TEX_SIZE]
                                        [map.x >> M7_TEX_SIZE]]
                           [(map.y & 0xFFFF) >> 12]
                           [(map.x & 0xFFFF) >> 12];

            map.x += mapXStep.x;
            map.y += mapXStep.y;

            M7_SET_PIXEL8(screenX, screenY, color);
        }
    }
    SDL_UpdateRect(screen, 0, M7_SCREEN_HEIGHT / 2, M7_SCREEN_WIDTH, M7_SCREEN_HEIGHT / 2);
}(m7.h only contains some very basic defines)

Modified m7.c :
#include <os.h>
#include <SDL.h>

#include "m7.h"

void m7BuildLut(m7Vec_t lut[M7_SCREEN_HEIGHT]) {
    int screenRow;
    for (screenRow = 0; screenRow < M7_SCREEN_HEIGHT; ++screenRow) {
        float cameraV = (((float)screenRow / (float)M7_SCREEN_HEIGHT) * 2.0F - 1.0F);

        float rayX = M7_VIEW_PLANE_H;
        float rayY = 1.0F;
        float rayZ = M7_VIEW_PLANE_V * cameraV;

        float intersectY = (M7_VIEW_HEIGHT / rayZ) * rayY;
        float intersectX = (M7_VIEW_HEIGHT / rayZ) * rayX;

        lut[screenRow].x = M7_FLOAT_TO_FIX(intersectX);
        lut[screenRow].y = M7_FLOAT_TO_FIX(intersectY);
    }
}

void m7LoadTex(Uint8 tex[M7_NUM_TEX][M7_TEX_SIZE][M7_TEX_SIZE], ...) {
    va_list ap;
    int i, j, k;

    va_start(ap, tex);
    for (i = 0; i < M7_NUM_TEX; ++i) {
        SDL_Surface* surf = va_arg(ap, SDL_Surface*);
        for (j = 0; j < M7_TEX_SIZE; j++)
            for (k = 0; k < M7_TEX_SIZE; k++)
                tex[i][j][k] = nSDL_GetPixel(surf, k, j);
    }
    va_end(ap);
}

void m7LoadTexArray(Uint8 tex[M7_NUM_TEX][M7_TEX_SIZE][M7_TEX_SIZE], SDL_Surface *src)
{
int i,j,k;
for(i = 0; i < M7_NUM_TEX; i++)
for(k = 0; k < M7_TEX_SIZE; k++)
for(j = 0; j < M7_TEX_SIZE; j++)
tex[i][k][j] = nSDL_GetPixel(src, j, i * M7_TEX_SIZE + k);
}

void m7Render(SDL_Surface *screen,
              m7Vec_t lut[M7_SCREEN_HEIGHT],
              Uint8 **tilemap,
              Uint8 tex[M7_NUM_TEX][M7_TEX_SIZE][M7_TEX_SIZE],
              m7Vec_t pos,
              Sint32 heading,
  Uint8 mapWidth,
  Uint8 mapHeight) {
    int screenX, screenY;
    for (screenY = (M7_SCREEN_HEIGHT / 2) + 1; screenY < M7_SCREEN_HEIGHT; ++screenY) {
        m7Vec_t map = lut[screenY];
        m7Vec_t mapXStep = {-map.x / (M7_SCREEN_WIDTH / 2), 0};
       
        Sint32 sinHeading = m7SinLut(heading);
        Sint32 cosHeading = m7CosLut(heading);
       
        m7RotateVec(&map, sinHeading, cosHeading);
        m7RotateVec(&mapXStep, sinHeading, cosHeading);
       
        map.x += pos.x;
        map.y += pos.y;
       
        for (screenX = 0; screenX < M7_SCREEN_WIDTH; ++screenX) {
            Uint8 color = 0;

            if (map.x >= 0 && map.x < M7_INT_TO_FIX(mapWidth)
             && map.y >= 0 && map.y < M7_INT_TO_FIX(mapHeight))
                color = tex[(int)tilemap[map.y >> M7_TEX_SIZE]
                                        [map.x >> M7_TEX_SIZE]]
                           [(map.y & 0xFFFF) >> 12]
                           [(map.x & 0xFFFF) >> 12];

            map.x += mapXStep.x;
            map.y += mapXStep.y;

            M7_SET_PIXEL8(screenX, screenY, color);
        }
    }
    SDL_UpdateRect(screen, 0, M7_SCREEN_HEIGHT / 2, M7_SCREEN_WIDTH, M7_SCREEN_HEIGHT / 2);
}
demo.c (from the engine's zip, works) :
#include <os.h>
#include <SDL/SDL.h>

#include "m7.h"
#include "gfx.h"

SDL_Surface *screen;

SDL_Surface *loadTex(unsigned short *data) {
    SDL_Surface *tex, *tmp;
    tmp = nSDL_LoadImage(data);
    tex = SDL_DisplayFormat(tmp);
    SDL_FreeSurface(tmp);
    return tex;
}

int main(void) {
    m7Vec_t lut[M7_SCREEN_HEIGHT];
    Uint8 tilemap[M7_MAP_SIZE][M7_MAP_SIZE];
    Uint8 tex[M7_NUM_TEX][M7_TEX_SIZE][M7_TEX_SIZE];
    m7Vec_t pos = {M7_INT_TO_FIX(2), M7_INT_TO_FIX(4)};
    Sint32 heading = 0;

    SDL_Surface *texMushroom, *texFB, *texCartman, *texYoshi;
    nSDL_Font *font;
    const SDL_VideoInfo *info;
    Uint32 curTime = 0;
    Uint32 oldTime = 0;
    int fps = 0;
    int num_frames = 0;
    int done = 0;
    int i, j;

    SDL_Init(SDL_INIT_VIDEO);
    screen = SDL_SetVideoMode(M7_SCREEN_WIDTH, M7_SCREEN_HEIGHT, M7_BPP, SDL_SWSURFACE);
    font = nSDL_LoadFont(NSDL_FONT_TINYTYPE, 255, 255, 255);
    texMushroom = loadTex(ntiMushroom);
    texFB = loadTex(ntiFB);
    texCartman = loadTex(ntiCartman);
    texYoshi = loadTex(ntiYoshi);
    SDL_FillRect(screen, NULL, 0);
    info = SDL_GetVideoInfo();
    nSDL_DrawString(screen, font, 0, 0, "M7 engine test\nnSDL %s\n%dx%d\n%d-bit/%d-bit",
                    NSDL_VERSION, info->current_w, info->current_h, info->vfmt->BitsPerPixel, is_cx ? 16 : 4);
    SDL_Flip(screen);

    srand(42);
    for (i = 0; i < M7_MAP_SIZE; ++i)
        for (j = 0; j < M7_MAP_SIZE; ++j)
            tilemap[i][j] = rand() % 4;

    m7BuildLut(lut);
    m7LoadTex(tex, texMushroom, texFB, texCartman, texYoshi);

    while(!done) {
        m7Vec_t moveDist = {M7_INT_TO_FIX(0), M7_FLOAT_TO_FIX(0.25)};
        SDL_Rect fpsRect = {M7_SCREEN_WIDTH - 40, 0, 40, 8};

        m7RotateVec(&moveDist, m7SinLut(heading), m7CosLut(heading));

        if (isKeyPressed(KEY_NSPIRE_8)) m7AddVec(&pos, &moveDist);
        if (isKeyPressed(KEY_NSPIRE_2)) m7SubVec(&pos, &moveDist);
        if (isKeyPressed(KEY_NSPIRE_6)) m7AddVec(&pos, m7RotateVec(&moveDist, M7_INT_TO_FIX(1), 0));
        if (isKeyPressed(KEY_NSPIRE_4)) m7SubVec(&pos, m7RotateVec(&moveDist, M7_INT_TO_FIX(1), 0));
        if (isKeyPressed(KEY_NSPIRE_9)) heading -= 0x400;
        if (isKeyPressed(KEY_NSPIRE_7)) heading += 0x400;
        if (isKeyPressed(KEY_NSPIRE_ESC)) done = 1;

        m7Render(screen, lut, tilemap, tex, pos, heading);

        SDL_FillRect(screen, &fpsRect, 0);
        nSDL_DrawString(screen, font, fpsRect.x, fpsRect.y, "%d FPS", fps);
        SDL_UpdateRect(screen, fpsRect.x, fpsRect.y, fpsRect.w, fpsRect.h);
        curTime = SDL_GetTicks();
        if(curTime - oldTime <= 993) /* Clock set to 993 Hz by nSDL */
            ++num_frames;
        else {
            fps = num_frames;
            num_frames = 0;
            oldTime = curTime;
        }
    }

    SDL_FreeSurface(texYoshi);
    SDL_FreeSurface(texCartman);
    SDL_FreeSurface(texFB);
    SDL_FreeSurface(texMushroom);
    nSDL_FreeFont(font);
    SDL_Quit();

    return 0;
}
main.c (mine, doesn't work) :
#include <os.h>
#include <SDL.h>
#include "m7.h"

SDL_Surface *loadTex(unsigned short *data)
{
SDL_Surface *tex, *temp;
temp = nSDL_LoadImage(data);
tex = SDL_DisplayFormat(temp);
SDL_FreeSurface(temp);
return tex;
}

int main(int argc, char *argv[])
{
// Mode7-relative variables
m7Vec_t lut[M7_SCREEN_HEIGHT];
#include "muteCityTilemap.h"
#include "muteCityTileset.h"
#include "blueFalcon.h"
Uint8 finalTex[M7_NUM_TEX][M7_TEX_SIZE][M7_TEX_SIZE];
m7Vec_t pos = {M7_INT_TO_FIX(1), M7_INT_TO_FIX(1)};
Sint32 heading = 0;

SDL_Surface *screen, *shipSurface, *tiles;
SDL_Rect shipRect, shipSrcRect;

shipRect.x = 136;
shipRect.y = 190;

shipSrcRect.x = (shipSrcRect.y = 0);
shipSrcRect.w = 48;
shipSrcRect.h = 31;

SDL_Init(SDL_INIT_VIDEO);

int speed = 0, rotationSpeed = 0;

screen = SDL_SetVideoMode(M7_SCREEN_WIDTH, M7_SCREEN_HEIGHT, M7_BPP, SDL_SWSURFACE);

shipSurface = nSDL_LoadImage(blueFalconSprite);
SDL_SetColorKey(shipSurface, SDL_SRCCOLORKEY, SDL_MapRGB(shipSurface->format, 0xff, 0, 0xff));

tiles = loadTex(muteCityTileset);

m7BuildLut(lut);
m7LoadTexArray(finalTex, tiles);

while(1)
{
m7Vec_t moveDist = {M7_INT_TO_FIX(0), M7_FLOAT_TO_FIX(0.25)};

m7RotateVec(&moveDist, m7SinLut(heading), m7CosLut(heading));

if(isKeyPressed(KEY_NSPIRE_ESC)) break;
if(isKeyPressed(KEY_NSPIRE_DOWN)) m7SubVec(&pos, &moveDist);
if(isKeyPressed(KEY_NSPIRE_LEFT))
{
heading -= 0x400;
shipSrcRect.y = 62;
}
if(isKeyPressed(KEY_NSPIRE_RIGHT))
{
heading += 0x400;
shipSrcRect.y = 31;
}
if(!isKeyPressed(KEY_NSPIRE_LEFT) && !isKeyPressed(KEY_NSPIRE_RIGHT)) shipSrcRect.y = 0;
if(isKeyPressed(KEY_NSPIRE_UP)) m7AddVec(&pos, &moveDist);

m7Render(screen, lut, muteCityTilemap, finalTex, pos, heading, 792, 366);

}

SDL_FreeSurface(tiles);
SDL_FreeSurface(shipSurface);
SDL_Quit();

return 0;
}

The *.h I use are always image datas.

You can download the engine here : http://ourl.ca/18123/337001

If you can help me, I'd be glad