path: root/src/main.c

#include "shorthand.h"
#include "bd-font.c"
#include "gba-buttons.c"
#include "background-tiles.c"

//
// Memory sections.
//

// Defines for the different memory sections in the GBA.
#define MEM_SROM  0x00000000
#define MEM_EW    0x02000000
#define MEM_IW    0x03000000
#define MEM_IO    0x04000000
#define MEM_PAL   0x05000000
#define MEM_VRAM  0x06000000
#define MEM_OAM   0x07000000
#define MEM_PAK   0x08000000
#define MEM_CART  0x0E000000

//
// Display modes.
//

// Display registers.
#define DISP_CTRL   *((vu32*)(MEM_IO + 0x0000))
#define DISP_STATUS *((vu16*)(MEM_IO + 0x0004))
#define DISP_VCOUNT *((vu16*)(MEM_IO + 0x0006))

// The first three bits in the DISP_CTRL are used to control the video mode.
#define DISP_MODE_0     0x0000
#define DISP_MODE_1     0x0001
#define DISP_MODE_2     0x0002
#define DISP_MODE_3     0x0003
#define DISP_MODE_4     0x0004
#define DISP_MODE_5     0x0005
#define DISP_GB         (1 << 3)
#define DISP_PAGE       (1 << 4)
#define DISP_OAM_HBLANK (1 << 5)
#define DISP_OBJ_1D     (1 << 6)
#define DISP_BLANK      (1 << 7)
#define DISP_BG_0       (1 << 8)
#define DISP_BG_1       (1 << 9)
#define DISP_BG_2       (1 << 10)
#define DISP_BG_3       (1 << 11)
#define DISP_OBJ        (1 << 12)
#define DISP_ENABLE_SPRITES DISP_OBJ | DISP_OBJ_1D

// Registers to control of BG layers.
#define BG_CTRL_0 *((vu16*)(0x04000008 + 0x0002 * 0))
#define BG_CTRL_1 *((vu16*)(0x04000008 + 0x0002 * 1))
#define BG_CTRL_2 *((vu16*)(0x04000008 + 0x0002 * 2))
#define BG_CTRL_3 *((vu16*)(0x04000008 + 0x0002 * 3))

// Bits to control the background.
#define BG_PRIORITY_0     0x0
#define BG_PRIORITY_1     0x1
#define BG_PRIORITY_2     0x2
#define BG_PRIORITY_3     0x3
#define BG_CHARBLOCK(N)   ((N) << 2)
#define BG_MOSAIC         (1 << 6)
#define BG_HIGH_COLOR     (1 << 7)
#define BG_SCREENBLOCK(N) ((N) << 8)
#define BG_AFFINE         (1 << 0xD)
#define BG_SIZE(N)        ((N) << 0xE)

// BG registers for horizontal displacement.
#define BG_H_SCROLL_0 *((vu16*)(0x04000010 + 0x0004 * 0))
#define BG_H_SCROLL_1 *((vu16*)(0x04000010 + 0x0004 * 1))
#define BG_H_SCROLL_2 *((vu16*)(0x04000010 + 0x0004 * 2))
#define BG_H_SCROLL_3 *((vu16*)(0x04000010 + 0x0004 * 3))

// BG registers for vertical displacement.
#define BG_V_SCROLL_0 *((vu16*)(0x04000012 + 0x0004 * 0))
#define BG_V_SCROLL_1 *((vu16*)(0x04000012 + 0x0004 * 1))
#define BG_V_SCROLL_2 *((vu16*)(0x04000012 + 0x0004 * 2))
#define BG_V_SCROLL_3 *((vu16*)(0x04000012 + 0x0004 * 3))

// Screen settings.
#define SCREEN_WIDTH 240
#define SCREEN_HEIGHT 160

// The GBA in mode 3 expects rbg15 colors in the VRAM, where each component
// (RGB) have a 0--31 range. For example, pure red would be rgb15(31, 0, 0).
typedef u16 Color;

//
// Tile memory access.
//

// NOTE: Only defining 4bpp tiles for now.
typedef struct Tile {
    u32 data[8];
} Tile;

typedef Tile TileBlock[512];
#define TILE_MEM ((TileBlock*) MEM_VRAM)

typedef u16 ScreenBlock[1024];
#define SCREENBLOCK_MEM ((ScreenBlock*)MEM_VRAM)

// We can treat the screen as a HxW matrix. With the following macro we can
// write a pixel to the screen at the (x, y) position using:
//
//     FRAMEBUFFER[y][x] = color;
//
typedef Color Scanline[SCREEN_WIDTH];
#define FRAMEBUFFER ((Scanline*)MEM_VRAM)
#define SCREEN_BUFFER ((vu16*) MEM_VRAM)
#define PAL_BUFFER_BG ((vu16*) MEM_PAL)
#define PAL_BUFFER_SPRITES ((vu16*) 0x05000200)

//
// Colors.
//

static inline Color
rgb15(u32 red, u32 green, u32 blue ) {
    return (blue << 10) | (green << 5) | red;
}

#define COLOR_RED   rgb15(31, 0, 12)
#define COLOR_BLUE  rgb15(2, 15, 30)
#define COLOR_CYAN  rgb15(0, 30, 30)
#define COLOR_GREY  rgb15(4, 4, 4)
#define COLOR_BLACK rgb15(0, 0, 0)
#define COLOR_WHITE rgb15(28, 28, 28)

//
// Sprites.
//

// Using macros instead of aligned structs for setting up OBJ attributes and
// affine parameters.
// TODO: Benchmark if this would be slower or the same that TONC's
// implementation.
#define OBJ_ATTR_0(N)    *((vu16*)(MEM_OAM + 0 + 8 * (N)))
#define OBJ_ATTR_1(N)    *((vu16*)(MEM_OAM + 2 + 8 * (N)))
#define OBJ_ATTR_2(N)    *((vu16*)(MEM_OAM + 4 + 8 * (N)))
#define OBJ_AFFINE_PA(N) *((vs16*)(MEM_OAM + 6 + 8 * 0 + 8 * 4 * (N)))
#define OBJ_AFFINE_PB(N) *((vs16*)(MEM_OAM + 6 + 8 * 1 + 8 * 4 * (N)))
#define OBJ_AFFINE_PC(N) *((vs16*)(MEM_OAM + 6 + 8 * 2 + 8 * 4 * (N)))
#define OBJ_AFFINE_PD(N) *((vs16*)(MEM_OAM + 6 + 8 * 3 + 8 * 4 * (N)))

// OBJ_ATTR_0 parameters
#define OBJ_Y_COORD(N)   ((N) & 0xFF)
#define OBJ_NORMAL       (0x00 << 0x8)
#define OBJ_AFFINE       (0x01 << 0x8)
#define OBJ_HIDDEN       (0x02 << 0x8)
#define OBJ_AFFINE_2X    (0x03 << 0x8)
#define OBJ_ALPHA_BLEND  (0x01 << 0xA)
#define OBJ_WINDOW       (0x02 << 0xA)
#define OBJ_SHAPE_SQUARE (0x00 << 0xE)
#define OBJ_SHAPE_WIDE   (0x01 << 0xE)
#define OBJ_SHAPE_TALL   (0x02 << 0xE)

// OBJ_ATTR_1 parameters
#define OBJ_X_COORD(N)    ((N) & 0x1FF)
#define OBJ_AFFINE_IDX(N) ((N) << 0x9)
#define OBJ_H_FLIP        (0x01 << 0xC)
#define OBJ_V_FLIP        (0x01 << 0xD)
#define OBJ_SIZE_SMALL    (0x00 << 0xE)
#define OBJ_SIZE_MID      (0x01 << 0xE)
#define OBJ_SIZE_BIG      (0x02 << 0xE)
#define OBJ_SIZE_HUGE     (0x03 << 0xE)

// OBJ_ATTR_2 parameters
#define OBJ_TILE_INDEX(N) ((N) & 0x3FF)
#define OBJ_PRIORITY(N)   ((N) << 0xA)
#define OBJ_PAL_BANK(N)   ((N) << 0xC)

// Using bd-font, an 8x8 bitmap font.
static void
put_char(int x, int y, Color clr, u8 chr) {
    for (size_t i = 0; i < 8; ++i) {
        for (size_t j = 0; j < 8; ++j) {
            if ((font[chr][i] >> (7 - j)) & 0x1) {
                FRAMEBUFFER[y + i][x + j] = clr;
            }
        }
    }
}

static void
put_text(int x, int y, Color clr, char *msg) {
    int count = 0;
    while (*msg) {
        put_char(x + count, y, clr, *msg++);
        count += 8;
    }
}

// Draws a line with the given color between (x0,y0) and (x1,y1) using the
// Bresenham's line drawing algorithm using exclusively integer arithmetic.
static void
draw_line(int x0, int y0, int x1, int y1, Color clr) {
    // Pointer to the initial position of the screen buffer where we will start
    // writing our data.
    vu16 *destination = (u16*)(SCREEN_BUFFER + y0 * SCREEN_WIDTH + x0);

    // Adjust the step direction and calculate deltas.
    int x_step;
    int y_step;
    int dx;
    int dy;
    if (x0 > x1) {
        x_step = -1;
        dx = x0 - x1;
    } else {
        x_step = 1;
        dx = x1 - x0;
    }
    if (y0 > y1) {
        y_step = -SCREEN_WIDTH;
        dy = y0 - y1;
    } else {
        y_step = +SCREEN_WIDTH;
        dy = y1 - y0;
    }

    if(dy == 0) {
        // Horizontal line.
        for(int i = 0; i <= dx; i++) {
            destination[i * x_step] = clr;
        }
    } else if(dx == 0) {
        // Vertical line.
        for(int i = 0; i <= dy; i++) {
            destination[i * y_step] = clr;
        }
    } else if (dx >= dy){
        // Positive slope.
        int diff = 2 * dy - dx;
        for (int i = 0; i <= dx; ++i) {
            *destination = clr;
            if (diff >= 0) {
                destination += y_step;
                diff -= 2 * dx;
            }
            destination += x_step;
            diff += 2 * dy;
        }
    } else {
        // Negative slope.
        int diff = 2 * dx - dy;
        for (int i = 0; i <= dy; ++i) {
            *destination = clr;
            if (diff >= 0) {
                destination += x_step;
                diff -= 2 * dy;
            }
            destination += y_step;
            diff += 2 * dx;
        }
    }
}

static inline void
draw_rect(int x0, int y0, int x1, int y1, Color clr) {
    if (x0 > x1) {
        int tmp = x0;
        x0 = x1;
        x1 = tmp;
    }
    if (y0 > y1) {
        int tmp = y0;
        y0 = y1;
        y1 = tmp;
    }
    int dx = x1 - x0;
    int dy = y1 - y0;
    for (int i = 0; i <= dx; ++i) {
        int x = x0 + i;
        FRAMEBUFFER[y0][x] = clr;
        FRAMEBUFFER[y1][x] = clr;
    }
    for (int j = 0; j <= dy; ++j) {
        int y = y0 + j;
        FRAMEBUFFER[y][x0] = clr;
        FRAMEBUFFER[y][x1] = clr;
    }
}

static inline void
draw_fill_rect(int x0, int y0, int x1, int y1, Color clr) {
    if (x0 > x1) {
        int tmp = x0;
        x0 = x1;
        x1 = tmp;
    }
    if (y0 > y1) {
        int tmp = y0;
        y0 = y1;
        y1 = tmp;
    }
    int dx = x1 - x0;
    int dy = y1 - y0;
    for (int i = 0; i <= dx; ++i) {
        for (int j = 0; j <= dy; ++j) {
            int x = x0 + i;
            int y = y0 + j;
            FRAMEBUFFER[y][x] = clr;
        }
    }
}

static inline void
wait_vsync(void) {
    while(DISP_VCOUNT >= 160);
    while(DISP_VCOUNT < 160);
}

//
// Main functions.
//

// In Mode4 the buffer is of 8 bytes per pixel instead of 16. We can't write the
// color directly, instead the color is stored in the palette memory at
// `MEM_PAL`. Note that in this mode MEM_PAL[0] is the background color. This
// plotter takes an index to a color stored in MEM_PAL[col_index]. Because the
// GBA needs to meet memory alignment requirements, we can't write a u8 into
// memory, instead we need to read a u16 word, mask and or the corresponding
// bits and wave the updated u16.
static void
put_pixel_m4(int x, int y, u8 col_index, vu16 *buffer) {
    int buffer_index = (y * SCREEN_WIDTH + x) / 2;
    vu16 *destination = &buffer[buffer_index];
    // Odd pixels will go to the top 8 bits of the destination. Even pixels to
    // the lower 8 bits.
    int odd = x & 0x1;
    if(odd) {
        *destination= (*destination & 0xFF) | (col_index << 8);
    } else {
        *destination= (*destination & ~0xFF) |  col_index;
    }
}

static void
draw_fill_rect_m4(int x0, int y0, int x1, int y1, u8 col_index, vu16 *buffer) {
    int ix, iy;
    for(iy = y0; iy < y1; iy++) {
        for(ix = x0; ix < x1; ix++) {
            put_pixel_m4(ix, iy, col_index, buffer);
        }
    }
}

static inline void
flip_page(void) {
    DISP_CTRL ^= DISP_PAGE;
}

#define SCREEN_PAGE_1 ((vu16*) MEM_VRAM)
#define SCREEN_PAGE_2 ((vu16*) (MEM_VRAM + 0xa000))

//
// Profiling.
//

#define TIMER_DATA_0  *((vu16*) (0x04000100 + 0x04 * 0))
#define TIMER_DATA_1  *((vu16*) (0x04000100 + 0x04 * 1))
#define TIMER_DATA_2  *((vu16*) (0x04000100 + 0x04 * 2))
#define TIMER_DATA_3  *((vu16*) (0x04000100 + 0x04 * 3))
#define TIMER_CTRL_0  *((vu16*) (0x04000102 + 0x04 * 0))
#define TIMER_CTRL_1  *((vu16*) (0x04000102 + 0x04 * 1))
#define TIMER_CTRL_2  *((vu16*) (0x04000102 + 0x04 * 2))
#define TIMER_CTRL_3  *((vu16*) (0x04000102 + 0x04 * 3))

// Timer control bits.
#define TIMER_CTRL_FREQ_0   0
#define TIMER_CTRL_FREQ_1   1
#define TIMER_CTRL_FREQ_2   2
#define TIMER_CTRL_FREQ_3   3
#define TIMER_CTRL_CASCADE (1 << 2)
#define TIMER_CTRL_IRQ     (1 << 6)
#define TIMER_CTRL_ENABLE  (1 << 7)

// We use timers 2 and 3 to count the number of cycles since the profile_start
// functions is called. Don't use if the code we are trying to profile make use
// of these timers.
static inline
void profile_start(void) {
    TIMER_DATA_2 = 0;
    TIMER_DATA_3 = 0;
    TIMER_CTRL_2 = 0;
    TIMER_CTRL_3 = 0;
    TIMER_CTRL_3 = TIMER_CTRL_ENABLE | TIMER_CTRL_CASCADE;
    TIMER_CTRL_2 = TIMER_CTRL_ENABLE;
}

static inline
u32 profile_stop(void) {
   TIMER_CTRL_2 = 0;
   return (TIMER_DATA_3 << 16) | TIMER_DATA_2;
}

//
// Input handling.
//

// Memory address for key input register
#define KEY_INPUTS *((vu16*) 0x04000130)

// Alias for key pressing bits.
#define KEY_A      (1 << 0)
#define KEY_B      (1 << 1)
#define KEY_SELECT (1 << 2)
#define KEY_START  (1 << 3)
#define KEY_RIGHT  (1 << 4)
#define KEY_LEFT   (1 << 5)
#define KEY_UP     (1 << 6)
#define KEY_DOWN   (1 << 7)
#define KEY_R      (1 << 8)
#define KEY_L      (1 << 9)

#define KEY_MASK 0x03FF

// Saving the previous and current key states as globals for now.
static u16 key_curr = 0;
static u16 key_prev = 0;

static inline void
poll_keys(void) {
    key_prev = key_curr;
    key_curr = ~KEY_INPUTS & KEY_MASK;
}

// Returns true if the given key has been pressed at time of calling and was not
// pressed since the previous call. For example, if a key is being held, this
// function will return `true` only on the frame where the key initially
// activated.
static inline u32
key_pressed(u32 key) {
    return (key_curr & key) & ~(key_prev & key);
}

// Check if the given key is pressed and has been since at least one frame.
static inline u32
key_hold(u32 key) {
    return (key_curr & key) & key_prev & key;
}

// Check if the given key/button is currently pressed.
#define KEY_PRESSED(key) (~(KEY_INPUTS) & key)

void
draw_logo(void) {
    int side = 60;
    int line = 35;
    int height = side * 0.5;
    int x = SCREEN_WIDTH / 2 - height / 2;
    int y = SCREEN_HEIGHT / 2;

    // Draw red triangle.
    draw_line(x + height - 1, y - side / 2, x, y - 1, COLOR_RED);
    draw_line(x + height - 1, y + side / 2, x, y + 1, COLOR_RED);
    draw_line(x + height - 1, y - side / 2 + 1, x, y, COLOR_RED);
    draw_line(x + height - 1, y + side / 2 - 1, x, y, COLOR_RED);

    // Draw white triangle.
    draw_line(x, y - side / 2, x, y + side / 2, COLOR_WHITE);
    draw_line(x + 1, y - side / 2, x + height, y - 1, COLOR_WHITE);
    draw_line(x + 1, y + side / 2, x + height, y + 1, COLOR_WHITE);

    // Draw white line at triangle tip.
    draw_line(x + height, y - side / 2, x + height, y + side / 2, COLOR_WHITE);
    draw_line(x + height + 1, y - side / 2, x + height + 1, y + side / 2, COLOR_WHITE);

    // Double triangle line.
    draw_line(x - 1, y - side / 2, x - 1, y + side / 2, COLOR_WHITE);
    draw_line(x + 1, y - side / 2 + 1, x + height, y, COLOR_WHITE);
    draw_line(x + 1, y + side / 2 - 1, x + height, y, COLOR_WHITE);

    // Draw white lines.
    draw_line(x - line, y, x, y, COLOR_WHITE);
    draw_line(x + height, y, x + height + line, y, COLOR_WHITE);
    draw_line(x - line, y + 1, x, y + 1, COLOR_WHITE);
    draw_line(x + height, y + 1, x + height + line, y + 1, COLOR_WHITE);
}

void
copy_font_to_tile_memory(Tile *tile) {
    // Hex to bits translation table.
    const u32 conversion_u32[16] = {
        0x00000000, 0x00001000, 0x00000100, 0x00001100,
        0x00000010, 0x00001010, 0x00000110, 0x00001110,
        0x00000001, 0x00001001, 0x00000101, 0x00001101,
        0x00000011, 0x00001011, 0x00000111, 0x00001111,
    };
    for (size_t i = 0; i < 250; ++i) {
        for (size_t j = 0; j < 8; ++j) {
            u8 row = font[i][j];
            u32 tile_idx = 0x00000000;
            tile_idx = conversion_u32[row & 0xF] << 16;
            tile_idx |= conversion_u32[(row >> 4) & 0xF];
            (tile + i)->data[j] = tile_idx;
        }
    }
}


u32
unpack_1bb(u8 hex) {
    const u32 conversion_u32[16] = {
        0x00000000, 0x00000001, 0x00000010, 0x00000011,
        0x00000100, 0x00000101, 0x00000110, 0x00000111,
        0x00001000, 0x00001001, 0x00001010, 0x00001011,
        0x00001100, 0x00001101, 0x00001110, 0x00001111,
    };
    u8 low = hex & 0xF;
    u8 high = (hex >> 4) & 0xF;
    return (conversion_u32[high] << 16) | conversion_u32[low];
}

typedef struct Sprite {
    // A unique sprite identifier.
    size_t id;
    // The number of tiles for a single sprite frame.
    size_t n_tiles;
    // The starting tile of this sprite.
    size_t tile_start;
    // The associated palette bank for this sprite.
    size_t pal_bank;
} Sprite;

typedef struct ButtonSprite {
    int id;
    int x;
    int y;
    int frame;
    BtnState state;
} ButtonSprite;

typedef struct MultiSprite {
    ObjState *sprites;
    AnimationEntry **animations;
    int frame;
    size_t n_obj;
    size_t n_frames;
    BtnState state;
} MultiSprite;

#define NUM_SPRITES 128

Sprite sprites[NUM_SPRITES];

// Keeping track of unique sprites and current sprite memory pointer using
// global singletons.
size_t sprite_counter = 0;
size_t sprite_tile_counter = 0;
u32 *sprite_memory = NULL;

// Loads the sprite data into video memory and initialize the Sprite structure.
size_t
load_sprite_data(u32 *sprite_data, size_t n_tiles, size_t n_frames) {
    memcpy(sprite_memory, sprite_data, 8 * n_tiles * n_frames * sizeof(u32));
    sprite_memory += 8 * n_tiles * n_frames;
    Sprite sprite = {
        .id = sprite_counter,
        .n_tiles = n_tiles,
        .tile_start = sprite_tile_counter,
    };
    sprite_tile_counter += n_tiles * n_frames;
    sprites[sprite_counter] = sprite;
    return sprite_counter++;
}

size_t
load_packed_sprite_data(u32 *sprite_data, size_t n_tiles, size_t n_frames) {
    size_t counter = 0;
    for (size_t i = 0; i < 8 * n_tiles * n_frames / 4; ++i) {
        u32 hex = sprite_data[i];
        sprite_memory[counter++] = unpack_1bb((hex >> 24) & 0xFF);
        sprite_memory[counter++] = unpack_1bb((hex >> 16) & 0xFF);
        sprite_memory[counter++] = unpack_1bb((hex >> 8) & 0xFF);
        sprite_memory[counter++] = unpack_1bb((hex) & 0xFF);
    }
    sprite_memory += 8 * n_tiles * n_frames;
    Sprite sprite = {
        .id = sprite_counter,
        .n_tiles = n_tiles,
        .tile_start = sprite_tile_counter,
    };
    sprite_tile_counter += n_tiles * n_frames;
    sprites[sprite_counter] = sprite;
    return sprite_counter++;
}

void
init_button_sprite(MultiSprite *btn) {
    for (size_t i = 0; i < btn->n_obj; ++i) {
        btn->sprites[i].id = load_packed_sprite_data(
                btn->sprites[i].data,
                btn->sprites[i].n_tiles,
                btn->sprites[i].frames);
        btn->sprites[i].base_tile = sprites[btn->sprites[i].id].tile_start;
    }
}

void
button_tick(MultiSprite *btn) {
    // Nothing to do here.
    if (btn->state == BTN_STATE_IDLE) {
        return;
    }

    // Reset animation state.
    if (btn->state == BTN_STATE_PRESSED && btn->frame != 0) {
        btn->frame = 0;
    }

    // Continue the animation.
    if (btn->state == BTN_STATE_HOLD || btn->state == BTN_STATE_PRESSED ) {
        if(btn->frame < btn->n_frames - 1) {
            btn->frame++;
        }
    }

    // Finish the animation and return to idle.
    if (btn->state == BTN_STATE_RELEASED) {
        if (btn->frame > 0 && btn->frame < btn->n_frames - 1) {
            btn->frame++;
        } else {
            btn->frame = 0;
            btn->state = BTN_STATE_IDLE;
        }
    }
    for (size_t i = 0; i < btn->n_obj; ++i) {
        AnimationEntry anim_frame = btn->animations[i][btn->frame];
        int x = btn->sprites[i].x + anim_frame.x_offset;
        int y = btn->sprites[i].y + anim_frame.y_offset;
        int base_tile = btn->sprites[i].base_tile + anim_frame.tile_offset;

        // Clear the previous x/y coordinate and base tiles.
        btn->sprites[i].obj_attr_0 &= ~0xFF;
        btn->sprites[i].obj_attr_1 &= ~0x1FF;
        btn->sprites[i].obj_attr_2 &= ~0x3FF;

        // Update x/y/tile and hidden state from the animations.
        btn->sprites[i].obj_attr_0 |= OBJ_Y_COORD(y);
        btn->sprites[i].obj_attr_1 |= OBJ_X_COORD(x);
        btn->sprites[i].obj_attr_2 |= base_tile;
        if (anim_frame.hidden) {
            btn->sprites[i].obj_attr_0 |= OBJ_HIDDEN;
        } else {
            btn->sprites[i].obj_attr_0 &= ~OBJ_HIDDEN;
        }

        // Update OBJ attributes.
        OBJ_ATTR_0(btn->sprites[i].id) = btn->sprites[i].obj_attr_0;
        OBJ_ATTR_1(btn->sprites[i].id) = btn->sprites[i].obj_attr_1;
        OBJ_ATTR_2(btn->sprites[i].id) = btn->sprites[i].obj_attr_2;
    }
}

int main(void) {

    // Add colors to the sprite color palette. Tiles with color number 0 are
    // treated as transparent.
    for (size_t i = 0; i < 16; ++i) {
        PAL_BUFFER_SPRITES[i] = COLOR_WHITE;
    }

    // Initialize all attributes by disabling rendering. If we don't do this,
    // glitches may appear.
    for (size_t i = 0; i < 128; ++i) {
        OBJ_ATTR_0(i) = (1 << 9);
    }

    sprite_tile_counter = 0;
    sprite_memory = &TILE_MEM[4][sprite_tile_counter];

    // Load background palette.
    memcpy(&PAL_BUFFER_BG[0], &bg_palette, 512);
    memcpy(&TILE_MEM[0][0], bg_data, 3168);
    memcpy(&SCREENBLOCK_MEM[30][0], bg_map, 2048);

    // Configure BG0 to use 4bpp, 64x32 tile map in charblock 0 and screenblock
    // 31.
    BG_CTRL_0 = BG_CHARBLOCK(0) | BG_SCREENBLOCK(30) | BG_SIZE(0);
    BG_H_SCROLL_0 = 0;
    BG_V_SCROLL_0 = 0;

    // Configure the display in mode 0 to show OBJs, where tile memory is
    // sequential.
    DISP_CTRL = DISP_ENABLE_SPRITES | DISP_MODE_0 | DISP_BG_0;

    // Initialize the A/B button sprites.
    int buttons_x = SCREEN_WIDTH / 2;
    int buttons_y = SCREEN_HEIGHT / 2;
    ButtonSprite btn_b = {
        .id = load_packed_sprite_data(&gba_btn_b_data, 4, 1),
        .x = buttons_x + 32,
        .y = buttons_y + 32,
        .frame = 0,
        .state = BTN_STATE_IDLE,
    };
    OBJ_ATTR_0(btn_b.id) = btn_b.y;
    OBJ_ATTR_1(btn_b.id) = btn_b.x | (1 << 0xE);
    OBJ_ATTR_2(btn_b.id) = sprites[btn_b.id].tile_start;

    ButtonSprite btn_a = {
        .id = load_packed_sprite_data(&gba_btn_a_data, 4, 1),
        .x = buttons_x + 32 + 20,
        .y = buttons_y + 32 - 16,
        .frame = 0,
        .state = BTN_STATE_IDLE,
    };
    OBJ_ATTR_0(btn_a.id) = btn_a.y;
    OBJ_ATTR_1(btn_a.id) = btn_a.x | (1 << 0xE);
    OBJ_ATTR_2(btn_a.id) = sprites[btn_a.id].tile_start;

    ButtonSprite btn_up = {
        .id = load_packed_sprite_data(&gba_btn_updown_data, 4, 1),
        .x = buttons_x - 64 - 16,
        .y = buttons_y + 32 - 18,
        .frame = 0,
        .state = BTN_STATE_IDLE,
    };
    OBJ_ATTR_0(btn_up.id) = btn_up.y;
    OBJ_ATTR_1(btn_up.id) = btn_up.x | (1 << 0xE);
    OBJ_ATTR_2(btn_up.id) = sprites[btn_up.id].tile_start;

    ButtonSprite btn_left = {
        .id = load_packed_sprite_data(&gba_btn_leftright_data, 4, 1),
        .x = buttons_x - 64 - 16 - 10,
        .y = buttons_y + 32 - 10,
        .frame = 0,
        .state = BTN_STATE_IDLE,
    };
    OBJ_ATTR_0(btn_left.id) = btn_left.y;
    OBJ_ATTR_1(btn_left.id) = btn_left.x | (1 << 0xE);
    OBJ_ATTR_2(btn_left.id) = sprites[btn_left.id].tile_start;

    ButtonSprite btn_right = {
        .id = load_packed_sprite_data(&gba_btn_leftright_data, 4, 1),
        .x = buttons_x - 64 - 16 + 11,
        .y = buttons_y + 32 - 10,
        .frame = 0,
        .state = BTN_STATE_IDLE,
    };
    OBJ_ATTR_0(btn_right.id) = btn_right.y;
    OBJ_ATTR_1(btn_right.id) = btn_right.x | (1 << 0xE) | (1 << 0xC);
    OBJ_ATTR_2(btn_right.id) = sprites[btn_right.id].tile_start;

    ButtonSprite btn_l = {
        .id = load_packed_sprite_data(&gba_btn_l_data, 2, 1),
        .x = buttons_x - 64 - 28,
        .y = buttons_y - 32 - 20,
        .frame = 0,
        .state = BTN_STATE_IDLE,
    };
    OBJ_ATTR_0(btn_l.id) = btn_l.y | (1 << 0xE);
    OBJ_ATTR_1(btn_l.id) = btn_l.x;
    OBJ_ATTR_2(btn_l.id) = sprites[btn_l.id].tile_start;

    ButtonSprite btn_r = {
        .id = load_packed_sprite_data(&gba_btn_r_data, 2, 1),
        .x = buttons_x + 32 + 20,
        .y = buttons_y - 32 - 20,
        .frame = 0,
        .state = BTN_STATE_IDLE,
    };
    OBJ_ATTR_0(btn_r.id) = btn_r.y | (1 << 0xE);
    OBJ_ATTR_1(btn_r.id) = btn_r.x;
    OBJ_ATTR_2(btn_r.id) = sprites[btn_r.id].tile_start;

    ButtonSprite btn_start = {
        .id = load_packed_sprite_data(&gba_btn_startselect_data, 2, 2),
        .x = buttons_x - 10,
        .y = buttons_y + 40,
        .frame = 0,
        .state = BTN_STATE_IDLE,
    };
    OBJ_ATTR_0(btn_start.id) = btn_start.y | (1 << 0xE);
    OBJ_ATTR_1(btn_start.id) = btn_start.x;
    OBJ_ATTR_2(btn_start.id) = sprites[btn_start.id].tile_start;

    ButtonSprite btn_select = {
        .id = load_packed_sprite_data(&gba_btn_startselect_data, 2, 2),
        .x = buttons_x - 32,
        .y = buttons_y + 40,
        .frame = 0,
        .state = BTN_STATE_IDLE,
    };
    OBJ_ATTR_0(btn_select.id) = btn_select.y | (1 << 0xE);
    OBJ_ATTR_1(btn_select.id) = btn_select.x;
    OBJ_ATTR_2(btn_select.id) = sprites[btn_select.id].tile_start;

    MultiSprite buttons[] = {
        {
            .frame = 0,
            .n_obj = 3,
            .n_frames = 8,
            .state = BTN_STATE_RELEASED,
            .animations = &btn_down_animation,
            .sprites = &(ObjState[]){
                {
                    .id = 0,
                    .x = buttons_x - 64 - 16,
                    .y = buttons_y + 29,
                    .data = &gba_btn_updown_data,
                    .n_tiles = 4,
                    .frames = 1,
                    .obj_attr_0 = 0,
                    .obj_attr_1 = OBJ_V_FLIP | OBJ_SIZE_MID,
                    .obj_attr_2 = 0
                },
                {
                    .id = 0,
                    .x = buttons_x - 64 - 16,
                    .y = buttons_y + 29,
                    .data = &gba_btn_down_shadow_data,
                    .n_tiles = 2,
                    .frames = 1,
                    .obj_attr_0 = OBJ_SHAPE_WIDE,
                    .obj_attr_1 = OBJ_SIZE_SMALL,
                    .obj_attr_2 = 0
                },
                {
                    .id = 0,
                    .x = buttons_x - 64 - 16,
                    .y = buttons_y + 29,
                    .data = &gba_btn_fx_downup,
                    .n_tiles = 4,
                    .frames = 4,
                    .obj_attr_0 = OBJ_SHAPE_WIDE,
                    .obj_attr_1 = OBJ_SIZE_MID,
                    .obj_attr_2 = 0
                },
            },
        },
    };
    for (size_t i = 0; i < sizeof(buttons) / sizeof(MultiSprite); ++i) {
        init_button_sprite(&buttons[i]);
    }

    int frame_counter = 0;
    int x = 0;
    int y = 0;
    while(true) {
        wait_vsync();
        poll_keys();

        // if (key_pressed(KEY_B)) {
        //     btn_b.frame = 0;
        //     btn_b.state = BTN_STATE_PRESSED;
        // } else if (key_hold(KEY_B)) {
        //     if (btn_b.frame < btn_b.n_frames - 1) {
        //         btn_b.frame++;
        //     }
        // } else {
        //     // Finish the animation and reset idle state.
        //     if (btn_b.frame > 0 && btn_b.frame < btn_b.n_frames - 1) {
        //         btn_b.frame++;
        //     } else {
        //         btn_b.frame = 0;
        //         btn_b.state = BTN_STATE_IDLE;
        //     }
        // }
        // if (key_pressed(KEY_A)) {
        //     btn_a.frame = 0;
        //     btn_a.state = BTN_STATE_PRESSED;
        // } else if (key_hold(KEY_A)) {
        //     size_t n_frames = animation_states[btn_a.state]->n_frames;
        //     if (btn_a.frame < n_frames - 1) {
        //         btn_a.frame++;
        //     }
        // } else {
        //     // Finish the animation and reset idle state.
        //     size_t n_frames = animation_states[btn_a.state]->n_frames;
        //     if (btn_a.frame > 0 && btn_a.frame < n_frames - 1) {
        //         btn_a.frame++;
        //     } else {
        //         btn_a.frame = 0;
        //         btn_a.state = BTN_STATE_IDLE;
        //     }
        // }
        if (key_pressed(KEY_DOWN)) {
            buttons[0].state = BTN_STATE_PRESSED;
        } else if (key_hold(KEY_DOWN)) {
            buttons[0].state = BTN_STATE_HOLD;
        } else {
            buttons[0].state = BTN_STATE_RELEASED;
        }

        if (key_hold(KEY_DOWN)) {
            y += 3;
        }
        if (key_hold(KEY_UP)) {
            y -= 3;
        }
        if (key_hold(KEY_LEFT)) {
            x -= 3;
        }
        if (key_hold(KEY_RIGHT)) {
            x += 3;
        }

        // OBJ_ATTR_2(btn_b.id) = sprites[btn_b.id].tile_start + animation_states[btn_b.state]->tile_offsets[btn_b.frame];
        // OBJ_ATTR_2(btn_a.id) = sprites[btn_a.id].tile_start + animation_states[btn_a.state]->tile_offsets[btn_a.frame];
        // OBJ_ATTR_2(btn_up.id) = sprites[btn_up.id].tile_start + animation_states[btn_up.state]->tile_offsets[btn_up.frame];
        // // OBJ_ATTR_2(btn_down.id) = sprites[btn_down.id].tile_start + animation_states[btn_down.state]->tile_offsets[btn_down.frame];
        // OBJ_ATTR_2(btn_left.id) = sprites[btn_left.id].tile_start + animation_states[btn_left.state]->tile_offsets[btn_left.frame];
        // OBJ_ATTR_2(btn_right.id) = sprites[btn_right.id].tile_start + animation_states[btn_right.state]->tile_offsets[btn_right.frame];
        // OBJ_ATTR_2(btn_l.id) = sprites[btn_l.id].tile_start + animation_states[btn_l.state]->tile_offsets[btn_l.frame];
        // OBJ_ATTR_2(btn_r.id) = sprites[btn_r.id].tile_start + animation_states[btn_r.state]->tile_offsets[btn_r.frame];
        frame_counter++;
        BG_H_SCROLL_0 = x;
        BG_V_SCROLL_0 = y;

        for (size_t i = 0; i < sizeof(buttons) / sizeof(MultiSprite); ++i) {
            button_tick(&buttons[i]);
        }
    };

    return 0;
}