path: root/src/renderer_m4.c

//
// This Mode 0 renderer provides a way of drawing directly to a framebuffer
// (similar to Mode 3 and 4) while retaining the flexibility of using other
// backgrounds if needed. It also performs double buffering to avoid tearing
// artifacts and tries to only draw tiles that changed on each frame.
//
// In addition to the frontbuffer (displayed on background 0), a tiled text
// layer is displayed on background 1, which can be used for application
// development or for debug information.
//
// These two layers occupy the first and second background charblocks, leaving
// the remaining two available for other background layers. There are 14KB of
// sprite memory available, since the backbuffer is located at the end of the
// VRAM, but if more space is needed it can be moved to the end of the BG
// charblocks instead.
//

#include "renderer.h"
#include "text_m4.h"

static u16 *backbuf = (u16 *)(MEM_VRAM ^ 0x0A000);

// Keep track of which tiles need to be copied to the frontbuffer.
static bool screen_updated = true;

// Boundchecks can be disable at compile time but this will not always improve
// the performance and can in fact make it worse. It is possible that this is
// due to some aliasing optimiztions but not sure at this moment.
#ifdef DISABLE_BOUNDCHECK_SCREEN
#define BOUNDCHECK_SCREEN(X,Y)
#else
#define BOUNDCHECK_SCREEN(X,Y) if ((X) >= SCREEN_WIDTH || (Y) >= SCREEN_HEIGHT) return;
#endif

// Make sure
#define MAYBE_SWAP(A,B) if ((A) > (B)) { size_t tmp = (A); (A) = (B); (B) = tmp; }

IWRAM_CODE
void screen_fill(u8 clr)  {
#if 0
    u32 *dst = backbuf;
    for(int i = 0; i < KB(75) / 8; i++) {
        *dst++ = 0x01010101 * clr;
    }
#else
    dma_fill(backbuf, 0x01010101 * clr, KB(75) / 2, 3);
    screen_updated = true;
#endif
}

IWRAM_CODE
void
draw_pixel(size_t x, size_t y, u8 clr) {
    BOUNDCHECK_SCREEN(x, y);
    u16 *dst = &backbuf[(x + y * SCREEN_WIDTH) / 2];
    if(x & 1) {
        *dst = (*dst &  0xFF) | (clr << 8);
    } else {
        *dst = (*dst & ~0xFF) | clr;
    }
    screen_updated = true;
}

IWRAM_CODE
static inline
void
draw_hline(size_t x0, size_t x1, size_t y0, u8 clr) {
    BOUNDCHECK_SCREEN(x0, y0);
    BOUNDCHECK_SCREEN(x1, y0);
    // Find row positions for the given x/y coordinates.
    size_t tile_x0 = x0 / 8;
    size_t tile_x1 = x1 / 8;
    size_t start_col = x0 % 8;
    size_t end_col = x1 % 8;
    // Horizontal line. There are 3 cases:
    //     1. Lines fit on a single tile.
    //     2. Lines go through 2 tiles, both require partial row updates.
    //     3. Lines go through 3 or more tiles, first and last tiles use
    //        partial row updates, rows in the middle can write the entire
    //        row.
    size_t dx = tile_x1 - tile_x0;
    u64 *dst = &backbuf[(tile_x0 * 8 + y0 * SCREEN_WIDTH) / 2];
    if (dx < 1) {
        u64 row_mask = 0xFFFFFFFFFFFFFFFF;
        row_mask >>= (7 - end_col - dx) * 8;
        row_mask &= 0xFFFFFFFFFFFFFFFF << start_col * 8;
        u64 row = (0x0101010101010101 * (u8)clr) & row_mask;
        *dst = (*dst & ~row_mask) | row;
    } else {
        size_t shift_left = start_col * 8;
        size_t shift_right = (7 - end_col) * 8;
        u64 row_mask = 0xFFFFFFFFFFFFFFFF;
        u64 row = 0x0101010101010101 * clr;
#if 0
        // No DMA.
        *dst++ = (*dst & ~(row_mask << shift_left)) | row << shift_left;
        for (size_t i = 1; i < dx; i++) {
            *dst++ = (*dst & ~row_mask) | row;
        }
        *dst = (*dst & ~(row_mask >> shift_right)) | row >> shift_right;
#else
        // DMA.
        dst[0] = (dst[0] & ~(row_mask << shift_left)) | row << shift_left;
        if (dx != 1) {
            dma_fill(&dst[1], 0x01010101 * clr, (dx - 1) * 8, 3);
        }
        dst[dx] = dst[dx] & ~(row_mask >> shift_right);
        dst[dx] |= row >> shift_right;
#endif
    }
}

IWRAM_CODE
UNROLL_LOOPS
static inline
void
draw_vline(size_t x0, size_t y0, size_t y1, u8 clr) {
    BOUNDCHECK_SCREEN(x0, y0);
    BOUNDCHECK_SCREEN(x0, y1);
    size_t tile_x0 = x0 / 8;
    size_t start_col = x0 % 8;
    u16 *dst = &backbuf[(start_col + tile_x0 * 8 + y0 * SCREEN_WIDTH) / 2];
    if(start_col & 1) {
        for (size_t i = 0; i <= y1 - y0; i++, dst += SCREEN_WIDTH / 2) {
            *dst = (*dst &  0xFF) | (clr << 8);
        }
    } else {
        for (size_t i = 0; i <= y1 - y0; i++, dst += SCREEN_WIDTH / 2) {
            *dst = (*dst & ~0xFF) | clr;
        }
    }
}

IWRAM_CODE
void
draw_line(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
    BOUNDCHECK_SCREEN(x0, y0);
    BOUNDCHECK_SCREEN(x1, y1);
    MAYBE_SWAP(x0, x1);
    MAYBE_SWAP(y0, y1);

    if (y0 == y1) {
        draw_hline(x0, x1, y0, clr);
    } else if (x0 == x1) {
        draw_vline(x0, y0, y1, clr);
    }
    // TODO: diagonal (bresengham)
    screen_updated = true;
}

IWRAM_CODE
void
draw_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
    BOUNDCHECK_SCREEN(x0, y0);
    BOUNDCHECK_SCREEN(x1, y1);
    MAYBE_SWAP(x0, x1);
    MAYBE_SWAP(y0, y1);

    draw_hline(x0, x1, y0, clr);
    draw_hline(x0, x1, y1, clr);
    draw_vline(x0, y0, y1, clr);
    draw_vline(x1, y0, y1, clr);
    screen_updated = true;
}

IWRAM_CODE
void
draw_filled_rect(size_t x0, size_t y0, size_t x1, size_t y1, u8 clr) {
    BOUNDCHECK_SCREEN(x0, y0);
    BOUNDCHECK_SCREEN(x1, y1);
    MAYBE_SWAP(x0, x1);
    MAYBE_SWAP(y0, y1);

    // Special condition. If the screen is to be completely filled, use the DMA
    // instead.
    if (x0 == 0 && x1 >= (SCREEN_WIDTH - 1) && y0 == 0 && y1 >= (SCREEN_HEIGHT - 1)) {
        screen_fill(clr);
        return;
    }

    // Drawline implementation.
    for (size_t y = y0; y <= y1; y++) {
        // NOTE: Unclear why here draw_hline is faster than draw_line.
        draw_hline(x0, x1, y, clr);
    }
    screen_updated = true;
}

IWRAM_CODE
static inline
u64
decode_tile_u64(u32 *data) {
    u64 mask =
        (((u64)*data >> 0)  * 0xF & 0xF) << 0  |
        (((u64)*data >> 4)  * 0xF & 0xF) << 8  |
        (((u64)*data >> 8)  * 0xF & 0xF) << 16 |
        (((u64)*data >> 12) * 0xF & 0xF) << 24 |
        (((u64)*data >> 16) * 0xF & 0xF) << 32 |
        (((u64)*data >> 20) * 0xF & 0xF) << 40 |
        (((u64)*data >> 24) * 0xF & 0xF) << 48 |
        (((u64)*data >> 28) * 0xF & 0xF) << 56;
    return mask;
}

static u32 dec_nibble[] = {
    0x00000000, 0x01000000, 0x00010000, 0x01010000,
    0x00000100, 0x01000100, 0x00010100, 0x01010100,
    0x00000001, 0x01000001, 0x00010001, 0x01010001,
    0x00000101, 0x01000101, 0x00010101, 0x01010101,
};

static u32 dec_nibble_flip_x[] = {
    0x00000000, 0x00000001, 0x00000100, 0x00000101,
    0x00010000, 0x00010001, 0x00010100, 0x00010101,
    0x01000000, 0x01000001, 0x01000100, 0x01000101,
    0x01010000, 0x01010001, 0x01010100, 0x01010101,
};

IWRAM_CODE
static inline
u64
decode_1bpp(u8 row, u8 flip_x) {
    if (flip_x) {
        u32 *lut = dec_nibble_flip_x;
        return (u64)lut[(row >> 4) & 0xF] << 32 | (u64)lut[(row >> 0) & 0xF];
    }
    u32 *lut = dec_nibble;
    return (u64)lut[(row >> 0) & 0xF] << 32 | (u64)lut[(row >> 4) & 0xF];
}

IWRAM_CODE
static inline
void
draw_2bpp_row(size_t x, size_t y, u8 a, u8 b, u8 flip_x) {
    BOUNDCHECK_SCREEN(x, y);

    size_t tile_x = x / 8;
    size_t start_col = x % 8;
    size_t shift_left = start_col * 8;
    size_t shift_right = (8 - start_col) * 8;

    u64 *dst = &backbuf[(y * 30 + tile_x) * 8 / 2];
    if (start_col == 0) {
        u64 clr_a = decode_1bpp(a, flip_x);
        u64 clr_b = decode_1bpp(b, flip_x);
        u64 mask_a = (clr_a * 0xF);
        u64 mask_b = (clr_b * 0xF);
        u64 mask = (mask_a | mask_b);
        u64 color = clr_a + (clr_b << 1);
        dst[0] = (dst[0] & ~mask) | color;
    } else {
        u64 clr_a = decode_1bpp(a, flip_x);
        u64 clr_b = decode_1bpp(b, flip_x);
        u64 mask_a = (clr_a * 0xF);
        u64 mask_b = (clr_b * 0xF);
        u64 mask = (mask_a | mask_b);
        u64 color = clr_a + (clr_b << 1);
        dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
        if ((x + 7) > (SCREEN_WIDTH)) {
            return;
        }
        dst[1] = (dst[1] & ~(mask >> shift_right)) | (color >> shift_right);
    }

    // TODO: different blend modes?
}

IWRAM_CODE
static inline
void
draw_1bpp_row(size_t x, size_t y, u8 a, u8 clr, u8 flip_x) {
    BOUNDCHECK_SCREEN(x, y);

    size_t tile_x = x / 8;
    size_t start_col = x % 8;
    size_t shift_left = start_col * 8;
    size_t shift_right = (8 - start_col) * 8;

    u64 *dst = &backbuf[(y * 30 + tile_x) * 8 / 2];
    if (start_col == 0) {
        u64 color = decode_1bpp(a, flip_x);
        u64 mask = (color * 0xF);
        color *= clr;
        dst[0] = (dst[0] & ~mask) | color;
    } else {
        u64 color = decode_1bpp(a, flip_x);
        u64 mask = (color * 0xF);
        color *= clr;
        dst[0] = (dst[0] & ~(mask << shift_left))  | (color << shift_left);
        if ((x + 7) > (SCREEN_WIDTH)) {
            return;
        }
        dst[1] = (dst[1] & ~(mask >> shift_right)) | (color >> shift_right);
    }

    // TODO: different blend modes?
}

IWRAM_CODE
void
draw_chr(size_t x, size_t y, u8 *sprite, u8 flip_x, u8 flip_y) {
    BOUNDCHECK_SCREEN(x, y);
    if (!flip_y) {
        for(size_t v = 0; v < 8; v++) {
            if ((y + v) >= SCREEN_HEIGHT) break;
            u8 ch1 = sprite[v + 0];
            u8 ch2 = sprite[v + 8];
            draw_2bpp_row(x, y + v, ch1, ch2, flip_x);
        }
    } else {
        for(size_t v = 0; v < 8; v++) {
            if ((y + v) >= SCREEN_HEIGHT) break;
            u8 ch1 = sprite[(7 - v) + 0];
            u8 ch2 = sprite[(7 - v) + 8];
            draw_2bpp_row(x, y + v, ch1, ch2, flip_x);
        }
    }
}

IWRAM_CODE
void
draw_icn(size_t x, size_t y, u8 *sprite, u8 clr, u8 flip_x, u8 flip_y) {
    BOUNDCHECK_SCREEN(x, y);
    if (!flip_y) {
        for(size_t v = 0; v < 8; v++) {
            if ((y + v) >= SCREEN_HEIGHT) break;
            u8 ch1 = sprite[v];
            draw_1bpp_row(x, y + v, ch1, clr, flip_x);
        }
    } else {
        for(size_t v = 0; v < 8; v++) {
            if ((y + v) >= SCREEN_HEIGHT) break;
            u8 ch1 = sprite[(7 - v)];
            draw_1bpp_row(x, y + v, ch1, clr, flip_x);
        }
    }
}

IWRAM_CODE
void
flip_buffer(void) {
    if (!screen_updated) {
        return;
    }
    backbuf = (u16*)((u32)backbuf ^ 0x0A000);
    DISP_CTRL ^= DISP_PAGE;
    screen_updated = false;
}

#include "font.h"

// Font rendering function for the text engine..
void
txt_drawc(char c, size_t x, size_t y, u8 clr) {
    u8 *tile = font_icn;
    draw_icn(x, y, tile + 8 * c, clr, 1, 0);
}

void
renderer_init(void) {
    // Initialize display mode and bg palette.
    DISP_CTRL = DISP_MODE_4 | DISP_BG_2;

    // Clear VRAM.
    dma_fill((u16 *)MEM_VRAM, 0x01010101 * 0, KB(96), 3);

    // Initialize default palette.
    PAL_BUFFER_BG[0] = COLOR_BLACK;
    PAL_BUFFER_BG[1] = COLOR_WHITE;
    PAL_BUFFER_BG[2] = COLOR_RED;
    PAL_BUFFER_BG[3] = COLOR_BLUE;
    PAL_BUFFER_BG[4] = COLOR_CYAN;
    PAL_BUFFER_BG[5] = COLOR_GREY;

    // Initialize text engine.
    txt_init(txt_drawc);
}