Update screen rendering to use 2 backgrounds

1 files changed, 96 insertions, 128 deletions

diff --git a/src/uxn/devices/ppu.c b/src/uxn/devices/ppu.c
index 06d84bf..5894352 100644
--- a/src/uxn/devices/ppu.c
+++ b/src/uxn/devices/ppu.c
@@ -3,6 +3,8 @@
 /*
 Copyright (c) 2021 Devine Lu Linvega
 Copyright (c) 2021 Andrew Alderwick
+Copyright (c) 2021 Adrian "asie" Siekierka
+Copyright (c) 2021 Bad Diode
 
 Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
@@ -13,149 +15,115 @@ WITH REGARD TO THIS SOFTWARE.
 */
 
 static Uint8 font[][8] = {
-        {0x00, 0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c},
-        {0x00, 0x30, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10},
-        {0x00, 0x7c, 0x82, 0x02, 0x7c, 0x80, 0x80, 0xfe},
-        {0x00, 0x7c, 0x82, 0x02, 0x1c, 0x02, 0x82, 0x7c},
-        {0x00, 0x0c, 0x14, 0x24, 0x44, 0x84, 0xfe, 0x04},
-        {0x00, 0xfe, 0x80, 0x80, 0x7c, 0x02, 0x82, 0x7c},
-        {0x00, 0x7c, 0x82, 0x80, 0xfc, 0x82, 0x82, 0x7c},
-        {0x00, 0x7c, 0x82, 0x02, 0x1e, 0x02, 0x02, 0x02},
-        {0x00, 0x7c, 0x82, 0x82, 0x7c, 0x82, 0x82, 0x7c},
-        {0x00, 0x7c, 0x82, 0x82, 0x7e, 0x02, 0x82, 0x7c},
-        {0x00, 0x7c, 0x82, 0x02, 0x7e, 0x82, 0x82, 0x7e},
-        {0x00, 0xfc, 0x82, 0x82, 0xfc, 0x82, 0x82, 0xfc},
-        {0x00, 0x7c, 0x82, 0x80, 0x80, 0x80, 0x82, 0x7c},
-        {0x00, 0xfc, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfc},
-        {0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x82, 0x7c},
-        {0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x80, 0x80}};
-
-Uint8
-readpixel(Uint8 *sprite, Uint8 h, Uint8 v)
-{
-        Uint8 ch1 = ((sprite[v] >> h) & 0x1);
-        Uint8 ch2 = (((sprite[v + 8] >> h) & 0x1) << 1);
-        return ch1 + ch2;
-}
+    {0x00, 0x7c, 0x82, 0x82, 0x82, 0x82, 0x82, 0x7c},
+    {0x00, 0x30, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10},
+    {0x00, 0x7c, 0x82, 0x02, 0x7c, 0x80, 0x80, 0xfe},
+    {0x00, 0x7c, 0x82, 0x02, 0x1c, 0x02, 0x82, 0x7c},
+    {0x00, 0x0c, 0x14, 0x24, 0x44, 0x84, 0xfe, 0x04},
+    {0x00, 0xfe, 0x80, 0x80, 0x7c, 0x02, 0x82, 0x7c},
+    {0x00, 0x7c, 0x82, 0x80, 0xfc, 0x82, 0x82, 0x7c},
+    {0x00, 0x7c, 0x82, 0x02, 0x1e, 0x02, 0x02, 0x02},
+    {0x00, 0x7c, 0x82, 0x82, 0x7c, 0x82, 0x82, 0x7c},
+    {0x00, 0x7c, 0x82, 0x82, 0x7e, 0x02, 0x82, 0x7c},
+    {0x00, 0x7c, 0x82, 0x02, 0x7e, 0x82, 0x82, 0x7e},
+    {0x00, 0xfc, 0x82, 0x82, 0xfc, 0x82, 0x82, 0xfc},
+    {0x00, 0x7c, 0x82, 0x80, 0x80, 0x80, 0x82, 0x7c},
+    {0x00, 0xfc, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfc},
+    {0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x82, 0x7c},
+    {0x00, 0x7c, 0x82, 0x80, 0xf0, 0x80, 0x80, 0x80}};
 
 void
-clear(Ppu *p)
-{
-        int i, sz = p->height * p->width, rows = sz / 4;
-        for(i = 0; i < sz; ++i)
-                p->output[i] = p->colors[0];
-        for(i = 0; i < rows; i++) {
-                p->fg[i] = 0;
-                p->bg[i] = 0;
-        }
+putcolors(Ppu *p, Uint8 *addr) {
+    int i;
+    for(i = 0; i < 4; ++i) {
+        Uint8
+            r = (*(addr + i / 2) >> (!(i % 2) << 2)) & 0x0f,
+            g = (*(addr + 2 + i / 2) >> (!(i % 2) << 2)) & 0x0f,
+            b = (*(addr + 4 + i / 2) >> (!(i % 2) << 2)) & 0x0f;
+        PAL_BUFFER_BG[i] = rgb15(
+                (r << 1) | (r >> 3),
+                (g << 1) | (g >> 3),
+                (b << 1) | (b >> 3));
+    }
 }
 
 void
-putcolors(Ppu *p, Uint8 *addr)
-{
-        int i;
-        for(i = 0; i < 4; ++i) {
-                Uint8
-                        r = (*(addr + i / 2) >> (!(i % 2) << 2)) & 0x0f,
-                        g = (*(addr + 2 + i / 2) >> (!(i % 2) << 2)) & 0x0f,
-                        b = (*(addr + 4 + i / 2) >> (!(i % 2) << 2)) & 0x0f;
-                p->colors[i] = rgb15(r,g,b);
-        }
-        // p->colors[0] = COLOR_BLUE;
-        // p->colors[1] = COLOR_WHITE;
-        // p->colors[2] = COLOR_RED;
-        // p->colors[3] = COLOR_CYAN;
-}
+putpixel(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 color) {
+    if(x >= 30 * 8 || y >= 20 * 8)
+        return;
 
-void
-putpixel(Ppu *p, Uint8 *layer, Uint16 x, Uint16 y, Uint8 color)
-{
-        Uint16 row = (y % 8) + ((x / 8 + y / 8 * p->hor) * 16), col = 7 - (x % 8);
-        if(x >= p->hor * 8 || y >= p->ver * 8 || row > (p->hor * p->ver * 16) - 8)
-                return;
-        if(color == 0 || color == 2)
-                layer[row] &= ~(1UL << col);
-        else
-                layer[row] |= 1UL << col;
-        if(color == 0 || color == 1)
-                layer[row + 8] &= ~(1UL << col);
-        else
-                layer[row + 8] |= 1UL << col;
+    Uint32 pos = ((y & 7) + (((x >> 3) + (y >> 3) * 30) * 8));
+    Uint32 shift = (x & 7) << 2;
+    layer[pos] = (layer[pos] & (~(0xF << shift))) | (color << shift);
 }
 
 void
-puticn(Ppu *p, Uint8 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy)
-{
-        Uint16 v, h;
-        for(v = 0; v < 8; v++)
-                for(h = 0; h < 8; h++) {
-                        Uint8 ch1 = ((sprite[v] >> (7 - h)) & 0x1);
-                        if(ch1 == 1 || (color != 0x05 && color != 0x0a && color != 0x0f))
-                                putpixel(p,
-                                        layer,
-                                        x + (flipx ? 7 - h : h),
-                                        y + (flipy ? 7 - v : v),
-                                        ch1 ? color % 4 : color / 4);
-                }
+puticn(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy) {
+    Uint16 v, h;
+    for(v = 0; v < 8; v++)
+        for(h = 0; h < 8; h++) {
+            Uint8 ch1 = ((sprite[v] >> (7 - h)) & 0x1);
+            if(ch1 == 1 || (color != 0x05 && color != 0x0a && color != 0x0f))
+                putpixel(p,
+                    layer,
+                    x + (flipx ? 7 - h : h),
+                    y + (flipy ? 7 - v : v),
+                    ch1 ? color % 4 : color / 4);
+        }
 }
 
 void
-putchr(Ppu *p, Uint8 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy)
-{
-        Uint16 v, h;
-        for(v = 0; v < 8; v++)
-                for(h = 0; h < 8; h++) {
-                        Uint8 ch1 = ((sprite[v] >> (7 - h)) & 0x1) * color;
-                        Uint8 ch2 = ((sprite[v + 8] >> (7 - h)) & 0x1) * color;
-                        putpixel(p,
-                                layer,
-                                x + (flipx ? 7 - h : h),
-                                y + (flipy ? 7 - v : v),
-                                (((ch1 + ch2 * 2) + color / 4) & 0x3));
-                }
+putchr(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy) {
+    Uint16 v, h;
+    for(v = 0; v < 8; v++)
+        for(h = 0; h < 8; h++) {
+            Uint8 ch1 = ((sprite[v] >> (7 - h)) & 0x1) * color;
+            Uint8 ch2 = ((sprite[v + 8] >> (7 - h)) & 0x1) * color;
+            putpixel(p,
+                layer,
+                x + (flipx ? 7 - h : h),
+                y + (flipy ? 7 - v : v),
+                (((ch1 + ch2 * 2) + color / 4) & 0x3));
+        }
 }
 
-/* output */
+int
+initppu(Ppu *p, Uint8 hor, Uint8 ver, Uint8 pad) {
+    p->hor = hor;
+    p->ver = ver;
+    p->pad = pad;
+    p->width = (8 * p->hor + p->pad * 2);
+    p->height = (8 * p->ver + p->pad * 2);
 
-void
-drawpixel(Ppu *p, Uint16 x, Uint16 y, Uint8 color)
-{
-        if(x >= p->pad && x <= p->width - p->pad - 1 && y >= p->pad && y <= p->height - p->pad - 1)
-                FRAMEBUFFER[y][x] = p->colors[color];
-}
+    // Initialize display mode and bg palette.
+    DISP_CTRL = DISP_MODE_0 | DISP_BG_0 | DISP_BG_1;
 
-void
-drawppu(Ppu *p)
-{
-        Uint16 x, y;
-        for(y = 0; y < p->ver; ++y)
-                for(x = 0; x < p->hor; ++x) {
-                        Uint8 v, h;
-                        Uint16 key = (y * p->hor + x) * 16;
-                        for(v = 0; v < 8; v++)
-                                for(h = 0; h < 8; h++) {
-                                        Uint8 color = readpixel(&p->fg[key], h, v);
-                                        if(color == 0)
-                                                color = readpixel(&p->bg[key], h, v);
-                                        drawpixel(p, x * 8 + p->pad + 7 - h, y * 8 + p->pad + v, color);
-                                }
-                }
-}
+    // Initialize backgrounds.
+    u8 cb_fg = 0;
+    u8 sb_fg = 10;
+    u8 cb_bg = 2;
+    u8 sb_bg = 26;
+    BG_CTRL(0) = BG_CHARBLOCK(cb_fg) | BG_SCREENBLOCK(sb_fg) | BG_PRIORITY(1);
+    BG_CTRL(1) = BG_CHARBLOCK(cb_bg) | BG_SCREENBLOCK(sb_bg) | BG_PRIORITY(2);
 
-int
-initppu(Ppu *p, Uint8 hor, Uint8 ver, Uint8 pad)
-{
-        p->hor = hor;
-        p->ver = ver;
-        p->pad = pad;
-        p->width = (8 * p->hor + p->pad * 2);
-        p->height = (8 * p->ver + p->pad * 2);
-        if(!(p->output = malloc(p->width * p->height * sizeof(Uint16))))
-                return 0;
-        if(!(p->bg = malloc(p->width * p->height * sizeof(Uint8) / 4)))
-                return 0;
-        if(!(p->fg = malloc(p->width * p->height * sizeof(Uint8) / 4)))
-                return 0;
-        clear(p);
-        return 1;
+    // Clear tile memory.
+    p->fg = &TILE_MEM[cb_fg];
+    p->bg = &TILE_MEM[cb_bg];
+    for (size_t i = 0; i < 30 * 20 * 8; ++i) {
+        p->fg[i] = 0;
+        p->bg[i] = 0;
+    }
+
+    // Initialize memory map.
+    u16 *fg_mem = SCREENBLOCK_MEM[sb_fg];
+    u16 *bg_mem = SCREENBLOCK_MEM[sb_bg];
+    size_t k = 0;
+    for (size_t j = 0; j < 20; ++j) {
+        for (size_t i = 0; i < 30; ++i, ++k) {
+            fg_mem[i + j * 32] = k;
+            bg_mem[i + j * 32] = k;
+        }
+    }
+
+    return 1;
 }