Move code to relevant files for organization

1 files changed, 228 insertions, 0 deletions

diff --git a/src/bitmap.h b/src/bitmap.h
new file mode 100644
index 0000000..0befe5d
--- /dev/null
+++ b/src/bitmap.h
@@ -0,0 +1,228 @@
+#ifndef GBAEXP_BITMAP_H
+#define GBAEXP_BITMAP_H
+
+#include "bd-font.c"
+#include "common.c"
+
+// 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;
+        }
+    }
+}
+
+// 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);
+        }
+    }
+}
+
+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;
+        }
+    }
+}
+
+#endif // GBAEXP_BITMAP_H