Apply asie's patch 3 with a PPU fix

1 files changed, 90 insertions, 73 deletions

diff --git a/src/uxn/devices/ppu.c b/src/uxn/devices/ppu.c
index 60ede0a..97b5e4f 100644
--- a/src/uxn/devices/ppu.c
+++ b/src/uxn/devices/ppu.c
@@ -143,9 +143,9 @@ static Uint32 unpack_icon_lut_flipx[256] = {
 };
 
 EWRAM_BSS
-static u32 *backbuffer_bg0[30 * 20 * sizeof(Tile) / 4];
+static u32 *backbuffer_bg0[32 * 20 * sizeof(Tile) / 4];
 EWRAM_BSS
-static u32 *backbuffer_bg1[30 * 20 * sizeof(Tile) / 4];
+static u32 *backbuffer_bg1[32 * 20 * sizeof(Tile) / 4];
 static u32 dirty_tiles[20] = {0};
 
 void
@@ -173,7 +173,7 @@ putpixel(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 color) {
     size_t tile_y = y / 8;
     size_t start_col = x % 8;
     size_t start_row = y % 8;
-    size_t pos = (start_row + ((tile_x + tile_y * 30) * 8));
+    size_t pos = (start_row + ((tile_x + tile_y * 32) * 8));
     size_t shift = start_col * 4;
     layer[pos] = (layer[pos] & (~(0xF << shift))) | (color << shift);
     dirty_tiles[tile_y] |= 1 << tile_x;
@@ -181,77 +181,96 @@ putpixel(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 color) {
 
 IWRAM_CODE
 void
-puticn(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color,
-        Uint8 flipx, Uint8 flipy) {
-    if(x >= 30 * 8 || y >= 20 * 8) {
-        return;
-    }
-    size_t tile_x = x / 8;
-    size_t tile_y = y / 8;
-    size_t start_col = x % 8;
-    size_t start_row = y % 8;
-    size_t shift_left = start_col * 4;
-    size_t shift_right = (8 - start_col) * 4;
+puticn(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Uint8 flipx, Uint8 flipy) {
+        Uint8 sprline;
+        Uint8 xrightedge = x < ((32 - 1) * 8);
+        Uint16 v;
+        Uint32 dirtyflag = (1 << (x >> 3)) | (1 << ((x + 7) >> 3));
 
-        if (flipy) {
-        flipy = 7;
-    }
+        Uint32 layerpos = ((y & 7) + (((x >> 3) + (y >> 3) * 32) * 8));
+        Uint32 *layerptr = &layer[layerpos];
+        Uint32 shift = (x & 7) << 2;
+        Uint32 *lut_expand = flipx ? unpack_icon_lut : unpack_icon_lut_flipx;
 
-    size_t pos = (start_row + ((tile_x + tile_y * 30) * 8));
-        size_t *layer_ptr = &layer[pos];
-        size_t *lut = flipx ? unpack_icon_lut : unpack_icon_lut_flipx;
-
-    // There are 4 possible cases:
-    // 1. The sprite is exactly at the tile boundary. We can just copy the
-    //    tile directly to memory.
-    // 2. The sprite covers 2 tiles horizontally.
-    // 3. The sprite covers 2 tiles vertically.
-    // 4. The sprite covers 4 tiles.
-    if (start_row == 0 && start_col == 0) {
-        for (size_t i = 0; i < 8; ++i) {
-            layer_ptr[i] = lut[sprite[i ^ flipy]] * color;
-        }
-        dirty_tiles[tile_y] |= 1 << tile_x;
-    } else {
-        u32 row_mask = 0xFFFFFFFF << shift_left;
-        for (size_t i = 0; i < (8 - start_row); ++i) {
-            u32 sprite_row = lut[sprite[i ^ flipy]] * color;
-            layer_ptr[0] = (layer_ptr[0] & ~row_mask) | (sprite_row << shift_left);
-            layer_ptr[8] = (layer_ptr[8] & row_mask) | (sprite_row >> shift_right);
-            layer_ptr++;
-        }
-        layer_ptr += 8 * 29;
-        for (size_t i = (8 - start_row); i < 8; ++i) {
-            u32 sprite_row = lut[sprite[i ^ flipy]] * color;
-            layer_ptr[0] = (layer_ptr[0] & ~row_mask) | (sprite_row << shift_left);
-            layer_ptr[8] = (layer_ptr[8] & row_mask) | (sprite_row >> shift_right);
-            layer_ptr++;
-        }
-        dirty_tiles[tile_y] |= 1 << tile_x;
-        dirty_tiles[tile_y] |= 1 << (tile_x + 1);
-        dirty_tiles[tile_y + 1] |= 1 << tile_x;
-        dirty_tiles[tile_y + 1] |= 1 << (tile_x + 1);
-    }
+        if (flipy) flipy = 7;
+
+        if (x >= 240 || y >= 160) return;
+
+        if (color != 0x05 && color != 0x0a && color != 0x0f) {
+                u64 mask = ~((u64)0xFFFFFFFF << shift);
+
+                for (v = 0; v < 8; v++, layerptr++) {
+                        if ((y + v) >= 160) break;
+
+                        sprline = sprite[v ^ flipy];
+                        u64 data = (u64)(lut_expand[sprline] * (color & 3)) << shift;
+                        data |= (u64)(lut_expand[sprline ^ 0xFF] * (color >> 2)) << shift;
+
+                        layerptr[0] = (layerptr[0] & mask) | data;
+                        if (xrightedge) layerptr[8] = (layerptr[8] & (mask >> 32)) | (data >> 32);
+
+                        if (((y + v) & 7) == 7) layerptr += (32 - 1) * 8;
+                }
+        } else {
+                for (v = 0; v < 8; v++, layerptr++) {
+                        if ((y + v) >= 160) break;
+
+                        sprline = sprite[v ^ flipy];
+                        u64 mask = ~((u64)(lut_expand[sprline] * 0xF) << shift);
+                        u64 data = (u64)(lut_expand[sprline] * (color & 3)) << shift;
+
+                        layerptr[0] = (layerptr[0] & mask) | data;
+                        if (xrightedge) layerptr[8] = (layerptr[8] & (mask >> 32)) | (data >> 32);
+
+                        if (((y + v) & 7) == 7) layerptr += (32 - 1) * 8;
+                }
+        }
+
+        dirty_tiles[y >> 3] |= dirtyflag;
+        dirty_tiles[(y + 7) >> 3] |= dirtyflag;
 }
 
 IWRAM_CODE
 void
 putchr(Ppu *p, Uint32 *layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color,
         Uint8 flipx, Uint8 flipy) {
-    if(x >= 30 * 8 || y >= 20 * 8) {
-        return;
-    }
-    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));
-        }
+        Uint8 sprline1, sprline2;
+        Uint8 xrightedge = x < ((32 - 1) * 8);
+        Uint16 v;
+        Uint32 dirtyflag = (1 << (x >> 3)) | (1 << ((x + 7) >> 3));
+
+        Uint32 layerpos = ((y & 7) + (((x >> 3) + (y >> 3) * 32) * 8));
+        Uint32 *layerptr = &layer[layerpos];
+        Uint32 shift = (x & 7) << 2;
+        Uint32 *lut_expand = flipx ? unpack_icon_lut : unpack_icon_lut_flipx;
+
+        if (flipy) flipy = 7;
+
+        if (x >= 240 || y >= 160) return;
+
+        u64 mask = ~((u64)0xFFFFFFFF << shift);
+        u32 colconst = (color >> 2) * 0x11111111;
+
+        for (v = 0; v < 8; v++, layerptr++) {
+                if ((y + v) >= 160) break;
+
+                sprline1 = sprite[v ^ flipy];
+                sprline2 = sprite[(v ^ flipy) | 8];
+
+                u32 data32 =
+                        (lut_expand[sprline1] * (color & 3))
+                        + (lut_expand[sprline2] * ((color & 1) << 1))
+                        + colconst;
+                u64 data = ((u64) (data32 & 0x33333333)) << shift;
+
+                layerptr[0] = (layerptr[0] & mask) | data;
+                if (xrightedge) layerptr[8] = (layerptr[8] & (mask >> 32)) | (data >> 32);
+
+                if (((y + v) & 7) == 7) layerptr += (32 - 1) * 8;
+        }
+
+        dirty_tiles[y >> 3] |= dirtyflag;
+        dirty_tiles[(y + 7) >> 3] |= dirtyflag;
 }
 
 IWRAM_CODE
@@ -269,8 +288,8 @@ flipbuf(Ppu *p) {
             if (dirty_tiles[j] & k) {
                 Tile *tile_fg = p->fg;
                 Tile *tile_bg = p->bg;
-                mem_fg[i + j * 30] = tile_fg[i + j * 30];
-                mem_bg[i + j * 30] = tile_bg[i + j * 30];
+                mem_fg[i + j * 32] = tile_fg[i + j * 32];
+                mem_bg[i + j * 32] = tile_bg[i + j * 32];
             }
         }
         dirty_tiles[j] = 0;
@@ -298,7 +317,7 @@ initppu(Ppu *p, Uint8 hor, Uint8 ver, Uint8 pad) {
     // Clear tile memory.
     p->fg = backbuffer_bg0;
     p->bg = backbuffer_bg1;
-    for (size_t i = 0; i < 30 * 20 * 8; ++i) {
+    for (size_t i = 0; i < 32 * 20 * 8; ++i) {
         p->fg[i] = 0;
         p->bg[i] = 0;
     }
@@ -312,10 +331,8 @@ initppu(Ppu *p, Uint8 hor, Uint8 ver, Uint8 pad) {
     // Initialize memory map.
     u16 *mem_map = SCREENBLOCK_MEM[sb_idx];
     size_t k = 0;
-    for (size_t j = 0; j < 20; ++j) {
-        for (size_t i = 0; i < 30; ++i, ++k) {
-            mem_map[i + j * 32] = k;
-        }
+    for (size_t i = 0; i < 32 * 20; ++i, ++k) {
+        mem_map[i] = k;
     }
 
     return 1;