Graphics/Sprites/allocation_test/source/main.c

#include <nds.h>
#include <stdio.h>

//our very simple sprite engine...
#define  SPRITE_MAX 128

//these are placed in an array to allow for random size selection
//these are defined as part of the new sprite api
SpriteSize sizes[] = {
    SpriteSize_8x8, 
    SpriteSize_8x16,
    SpriteSize_16x8,
    SpriteSize_8x32,
    SpriteSize_16x16, 
    SpriteSize_32x8,
    SpriteSize_16x32,  
    SpriteSize_32x16, 
    SpriteSize_32x32, 
    SpriteSize_32x64, 
    SpriteSize_64x32, 
    SpriteSize_64x64,   
};

//this is our game entity. Notice it has a bit more info than
//would fit into OAM.  This method is a lot more flexible than trying
//to treat oam as a game object directly.
typedef struct {
    int x,y,z;
    int dx, dy;
    bool alive;
    u16* gfx;
    SpriteColorFormat format;
    SpriteSize size;
}mySprite;

//an array of sprites
mySprite sprites[SPRITE_MAX];

u32 spriteMemoryUsage = 0;

u32 oomCount = 0;
u32 allocationCount = 0;
u32 spriteMemSize = 128 * 1024;

bool oom = false;
OamState *oam = &oamMain;

//a sprite constructor
void createSprite(mySprite* s, int x, int y, int z, SpriteSize size, SpriteColorFormat format, int dx, int dy) {
    s->alive = true;
    s->x = x;
    s->y = y;
    s->z = z; 
    s->dx = dx;
    s->dy = dy;
    s->size = size;
    s->format = format;
    
    //api: allocate a chunk of sprite graphics memory
    s->gfx = oamAllocateGfx(oam, size, format);
    
    allocationCount++;
    if(s->gfx) {
        spriteMemoryUsage += (size & 0xFFF) << 5;
        oom = false;
    } else {
        oom = true;
        //only a failure of the allocator if there was enough room
        if(spriteMemoryUsage + ((size & 0xFFF) << 5) < spriteMemSize)
            oomCount++;
    }
}

//sprite deconstructor
void killSprite(mySprite *s) {
    s->alive = false;  
 
    //api: free the graphics
    if(s->gfx) {    
        oamFreeGfx(oam, s->gfx);
        spriteMemoryUsage -= (s->size & 0xFFF) << 5;
    }

    s->gfx = 0;
}

//a qsort function which sorts on z order
int zsort(const void* a, const void* b) {
    mySprite *first = (mySprite*)a;
    mySprite *second = (mySprite*)b;

    //the trivial case 
    if(first == second) return 0;

    //handle nulls
    if(!first && second) return -1;
    if(first && !second) return 1;

    //a dead sprite is always after a living one in the sort
    if(!first->alive && second->alive) return -1;
    if(first->alive && !second->alive) return 1;
    if(!first->alive && !second->alive) return 0;

    //finally if both are alive and not null sort them by depth
    if(first->z == second->z) return 0;
    if(first->z < second->z ) return -1;
    if(first->z > second->z) return 1;

    return 0; 
}  
  
//map our sprite to oam entries
void updateSprites(void) {
    int i;

    //sort our sprites on z
    //a more efficient way would be to keep a sorted list of sprites
    qsort(sprites, SPRITE_MAX, sizeof(mySprite), zsort);

    //set oam to values required by my sprite
    for(i = 0; i < SPRITE_MAX; i++) {
        //an api function: void oamSet(OamState* oam, int id,  int x, int y, int priority, int palette_alpha, SpriteSize size, SpriteColorFormat format, const void* gfxOffset, int affineIndex, bool sizeDouble, bool hide);
        oamSet(oam, 
            i, 
            sprites[i].x, sprites[i].y, 
            0, 
            0,
            sprites[i].size,
            sprites[i].format, 
            sprites[i].gfx, 
            -1, 
            false, 
            !sprites[i].alive,
            false,
            false, 
            false);
    }
}

//create a sprite with a random position, speed, and size 
void randomSprite(mySprite* s) {
    //pick a random color index 
    u8 c = rand() % 256;

    //two pixels at a time
    u16 color = c | (c << 8);

    //create a randomly oriented sprite going off in a random direction
    createSprite(s, rand() % 256, rand() % 192, 0, sizes[(rand() % 12)], SpriteColorFormat_256Color, rand() % 4 - 2, rand() % 4 - 2);

    //dont let sprites get stuck with 0 velocity
    if(s->dx == 0 && s->dy == 0) {   
        s->dx = rand() % 3 + 1;
        s->dy = rand() % 3 + 1;
    }

    //the size (in pixels) is encoded in the low 12 bits of the Size attribute (shifted left by 5)
    //we load new graphics each time as this is as much a test of my allocator as an example of api usage
    if(s->gfx) {
        swiCopy(&color, s->gfx, ((s->size & 0xFFF) << 4) | COPY_MODE_FILL);
    }   else {  
        s->alive = false;
    }
}

//move the sprite based on its velocity, kill it if it goes off screen and create a new random one
void moveSprites(void) {
    int i;

    for(i = 0; i < SPRITE_MAX; i++) {
        sprites[i].x += sprites[i].dx;
        sprites[i].y += sprites[i].dy;

        if(sprites[i].x >= 256 || sprites[i].x < 0 || sprites[i].y >= 192 || sprites[i].y < 0) {
            killSprite(&sprites[i]);
            randomSprite(&sprites[i]);
        }
    }
}

int main(void)  {
    int i;
    int memUsageTemp = 0xFFFFFFFF;

    videoSetMode(MODE_0_2D);
    videoSetModeSub(MODE_0_2D);
    vramSetBankA(VRAM_A_MAIN_SPRITE);
    vramSetBankB(VRAM_B_MAIN_SPRITE);
    vramSetBankD(VRAM_D_SUB_SPRITE);

    consoleDemoInit();
//  consoleDebugInit(DebugDevice_NOCASH); //send stderr to no$gba debug window

    //api: initialize OAM to 1D mapping with XX byte offsets and no external palette
    oamInit(oam, SpriteMapping_1D_128, false);

    //create some sprites
    for(i = 0; i < SPRITE_MAX; i++)
        randomSprite(&sprites[i]);

    //load a randomly colored palette
    for(i = 0; i < 256; i++) {
      SPRITE_PALETTE[i] = rand();
      SPRITE_PALETTE_SUB[i] = rand();
    }

    while(1) { 
        moveSprites();

        updateSprites();

        swiWaitForVBlank();
        
        //api: updates real oam memory 
        oamUpdate(oam);

        if(oom) {   
            memUsageTemp = memUsageTemp > spriteMemoryUsage ? spriteMemoryUsage : memUsageTemp;
        }   

        consoleClear();
        
        printf("Memory usage: %i %i%% \n",  spriteMemoryUsage, 100 * spriteMemoryUsage / (spriteMemSize));
        printf("Percentage fail: %i%% \n", oomCount * 100 / allocationCount);
        printf("Lowest Usage at fail %i %i%% \n", memUsageTemp, 100 * memUsageTemp / (spriteMemSize));              
    }

    return 0;
}