From ae4d57665bd82a4766a7a7e497776eee2fd47464 Mon Sep 17 00:00:00 2001
From: James <james@frasca.me>
Date: Tue, 23 Jan 2024 09:51:00 -0800
Subject: [PATCH] Add nine slice API

---
 src/playdate/api.nim             |   4 +-
 src/playdate/nineslice.nim       | 160 +++++++++++++++++++++++++++++++
 tests/source/nineslice_27x3.png  | Bin 0 -> 104 bytes
 tests/source/nineslice_60x60.png | Bin 0 -> 270 bytes
 tests/source/nineslice_6x6.png   | Bin 0 -> 101 bytes
 tests/source/nineslice_9x9.png   | Bin 0 -> 150 bytes
 tests/src/playdate_tests.nim     |   4 +-
 tests/t_nineslice.nim            | 124 ++++++++++++++++++++++++
 8 files changed, 288 insertions(+), 4 deletions(-)
 create mode 100644 src/playdate/nineslice.nim
 create mode 100644 tests/source/nineslice_27x3.png
 create mode 100644 tests/source/nineslice_60x60.png
 create mode 100644 tests/source/nineslice_6x6.png
 create mode 100644 tests/source/nineslice_9x9.png
 create mode 100644 tests/t_nineslice.nim

diff --git a/src/playdate/api.nim b/src/playdate/api.nim
index 984a644..82cd981 100644
--- a/src/playdate/api.nim
+++ b/src/playdate/api.nim
@@ -7,8 +7,8 @@ import bindings/utils {.all.} as memory
 import bindings/api
 export api
 
-import graphics, system, file, sprite, display, sound, lua, json, utils, types
-export graphics, system, file, sprite, display, sound, lua, json, utils, types
+import graphics, system, file, sprite, display, sound, lua, json, utils, types, nineslice
+export graphics, system, file, sprite, display, sound, lua, json, utils, types, nineslice
 
 macro initSDK*() =
     return quote do:
diff --git a/src/playdate/nineslice.nim b/src/playdate/nineslice.nim
new file mode 100644
index 0000000..ee1aad0
--- /dev/null
+++ b/src/playdate/nineslice.nim
@@ -0,0 +1,160 @@
+import graphics
+import std/[importutils, bitops, math, strutils]
+
+privateAccess(BitmapData)
+privateAccess(LCDBitmap)
+
+type
+    NineSliceRow {.byref.} = object
+        ## The bytes for a single row within a nine slice
+        leftBytes: seq[uint8]
+        middleBytes: seq[uint8]
+        rightBytes: seq[uint8]
+        leftRightBitLen: int
+
+    NineSliceData = ref object
+        ## Stores the rows for a single nine slice bitmap
+        top: seq[NineSliceRow]
+        middle: seq[NineSliceRow]
+        bottom: seq[NineSliceRow]
+
+    NineSlice* = ref object
+        ## A precalculated nine slice
+        image: NineSliceData
+        mask: NineSliceData
+
+func copyBits(
+    source: ptr UncheckedArray[uint8];
+    target: var seq[uint8];
+    sourceStartBit, sourceOffsetBit, sourceLen, targetStartBit, targetLen: int
+) =
+    ## Copies a sequence of bits from the source to the target, where all bit positions are absolute relative to
+    ## the start of the source or target
+    let minLength = ceil((targetStartBit + targetLen) / 8).toInt
+    target.setLen(max(target.len, minLength))
+
+    for bit in 0..<targetLen:
+        let sourceBit = sourceStartBit + ((bit + sourceOffsetBit) mod sourceLen)
+        let targetBit = targetStartBit + bit
+
+        if source[sourceBit div 8].testBit(7 - sourceBit mod 8):
+            target[targetBit div 8].setBit(7 - targetBit mod 8)
+
+func fillNineSliceRow(row: var NineSliceRow; source: BitmapData; y, leftRightBitLen: int) =
+    ## Each row gets a precalculated set of data that makes it faster to apply
+    let sourceStartBit = source.rowbytes * y * 8
+    let midSectionWidth = source.width - (2 * leftRightBitLen)
+
+    # Copy the bits for the leftmost column of the row
+    copyBits(source.data, row.leftBytes, sourceStartBit, 0, leftRightBitLen, 0, leftRightBitLen)
+
+    # If the leftmost bytes don't fill in to an even 8 bits, we pad it with bits from the center stretchable section.
+    # When drawing, this allows us to just blindly draw the first byte without any bit twiddling
+    copyBits(
+        source.data,
+        row.leftBytes,
+        sourceStartBit =    sourceStartBit + leftRightBitLen,
+        sourceOffsetBit =   0,
+        sourceLen =         midSectionWidth,
+        targetStartBit =    leftRightBitLen,
+        targetLen =         8 - (leftRightBitLen mod 8),
+    )
+
+    # Fills in the bytes for the middle section. We fill until the pattern repeats to reduce the amount of bit
+    # twiddling that needs to be done during render
+    copyBits(
+        source.data,
+        row.middleBytes,
+        sourceStartBit =    sourceStartBit + leftRightBitLen,
+        # Because the left bytes are filled in with some of the middle section bytes, we need to start copying
+        # bits at an offset that reflect the values that were already written. The following parameter is a calculation
+        # of what bit we left off on
+        sourceOffsetBit =   (8 - (leftRightBitLen mod 8)) mod midSectionWidth,
+        sourceLen =         midSectionWidth,
+        targetStartBit =    0,
+        targetLen =         midSectionWidth * 8,
+    )
+
+    # Fill the bytes for the right side of the nine slice
+    copyBits(source.data, row.rightBytes, sourceStartBit + source.width - leftRightBitLen, 0, leftRightBitLen, 0, leftRightBitLen)
+    row.leftRightBitLen = leftRightBitLen
+
+func createNineSliceData(source: BitmapData): NineSliceData =
+    ## Precalculates rendering instructions for a single bitmap
+    let leftRightBitLen = source.width div 3
+    let sliceHeight = source.height div 3
+
+    result = NineSliceData(
+        top: newSeq[NineSliceRow](sliceHeight),
+        middle: newSeq[NineSliceRow](source.height - sliceHeight * 2),
+        bottom: newSeq[NineSliceRow](sliceHeight),
+    )
+
+    # Precalculate the rows for the top and bottom sections
+    for i in 0..<sliceHeight:
+        result.top[i].fillNineSliceRow(source, i, leftRightBitLen)
+        result.bottom[i].fillNineSliceRow(source, source.height - sliceHeight + i, leftRightBitLen)
+
+    # Precalculate the rows for the stretchy middle section
+    for i in 0..<(source.height - sliceHeight * 2):
+        result.middle[i].fillNineSliceRow(source, sliceHeight + i, leftRightBitLen)
+
+proc newNineSlice*(source: LCDBitmap): NineSlice =
+    ## Precalculates a drawable nine slice from an image: https://en.wikipedia.org/wiki/9-slice_scaling
+    assert(source.width >= 3)
+    assert(source.height >= 3)
+    return NineSlice(
+        image: createNineSliceData(source.getData),
+        mask: if source.getBitmapMask.resource == nil: nil else: createNineSliceData(source.getBitmapMask.getData)
+    )
+
+func overlapBytes(left, right: uint8, offset: int): uint8 =
+    ## Given two bytes, creates a new byte that is partially made up of the left byte, and partially made up of
+    ## the right hand byte. The amount taken from each is determined by the `offset`
+    let leftContribution = left shl (8 - offset)
+    let rightContribution = right shr offset
+    result = leftContribution or rightContribution
+
+func drawRow(target: var BitmapData, source: NineSliceRow, targetY: int) =
+    ## Draws a single row to a nine slice.
+    let targetOffsetByte = target.rowbytes * targetY
+
+    # Draw the left column, a byte at a time
+    for i, byteValue in source.leftBytes:
+        target.data[i + targetOffsetByte] = byteValue
+
+    # Draw the stretched out middle column
+    let imageWidthInBytes = target.width div 8
+    let middleBytesLen = imageWidthInBytes - (2 * (source.leftRightBitLen div 8))
+    for i in 0..<middleBytesLen:
+        target.data[i + targetOffsetByte + source.leftBytes.len] = source.middleBytes[i mod source.middleBytes.len]
+
+    # Draw the right column, but we need to do some twiddling to align it properly. The position of the right column
+    # isn't something we can align ahead of time, so once we draw the left and middle portions, we need to overlay the
+    # right column and adjust its alignment
+    let rightColStartByte = (target.width - source.leftRightBitLen) div 8
+    let overlapBits = (target.width - source.leftRightBitLen) mod 8
+    var existingByte = target.data[targetOffsetByte + rightColStartByte] shr (8 - overlapBits)
+    for i in 0..(imageWidthInBytes - rightColStartByte):
+        let rightByte = source.rightBytes[min(i, source.rightBytes.len - 1)]
+        target.data[targetOffsetByte + rightColStartByte + i] = overlapBytes(existingByte, rightByte, overlapBits)
+        existingByte = rightByte
+
+func drawData(target: var BitmapData; source: NineSliceData) =
+    ## Draws a nine slice to a single bitmap target
+    for i in 0..<source.top.len:
+        target.drawRow(source.top[i], i)
+
+    for i in 0..<(target.height - source.top.len - source.bottom.len):
+        target.drawRow(source.middle[i mod source.middle.len], source.top.len + i)
+
+    for i in 0..<source.bottom.len:
+        target.drawRow(source.bottom[i], target.height - source.bottom.len + i)
+
+proc draw*(target: var LCDBitmap; source: NineSlice) =
+    ## Draws a nine slice to an image
+    var data = target.getData
+    drawData(data, source.image)
+    if source.mask != nil and target.getBitmapMask.resource != nil:
+        var maskData = target.getBitmapMask.getData
+        drawData(maskData, source.mask)
\ No newline at end of file
diff --git a/tests/source/nineslice_27x3.png b/tests/source/nineslice_27x3.png
new file mode 100644
index 0000000000000000000000000000000000000000..ef0e77480083353438710f080098258819d7df7c
GIT binary patch
literal 104
zcmeAS@N?(olHy`uVBq!ia0vp^(m>42!3HFg0!tPHDaPU;cPEB*=VV?2IZB=`jv*3L
zlT#8Bew=q;`19XCfRkBSS=rIlhb1&X@WNFihLtN>SodGotN^NJ@O1TaS?83{1OTbT
B8wmga

literal 0
HcmV?d00001

diff --git a/tests/source/nineslice_60x60.png b/tests/source/nineslice_60x60.png
new file mode 100644
index 0000000000000000000000000000000000000000..700b0b21d8bbb4f73ac329aaa18019083471d25c
GIT binary patch
literal 270
zcmeAS@N?(olHy`uVBq!ia0vp^HXzKw1|+Ti+$;i8jKx9jP7LeL$-D$|PI$UFhGaCp
zon^?^Y#_k$Ug_We)a6`384VQ^=iHsy#T02C*TTDR-KxN-D4Tg(_DwI^P@nKSrpM5H
z;@wvX`vb3vPd7O9PT>vTp?5jYx8HHwTRd54dcm9xe<sem%On?=ANg3w?Z#Y-hkuuT
z{qp^d&Z=LJg!UQd{;paaS5^0P!Y|e7J6Z(G*b~bI(23>VHMfojo=&>3{3+1vBb=wL
z8N%$RbbDL){phsQwR#lJ1l9DU-lnUxLigVK6S5snKDXL|eq!)+^>bP0l+XkKid1rO

literal 0
HcmV?d00001

diff --git a/tests/source/nineslice_6x6.png b/tests/source/nineslice_6x6.png
new file mode 100644
index 0000000000000000000000000000000000000000..c241f5b83bf2bc98d274c7a25a0cb4c2f2268a12
GIT binary patch
literal 101
zcmeAS@N?(olHy`uVBq!ia0vp^Y#_`5A|IT2?*XJ3i-X*q7}lMWc?smmd%8G=aLn9$
w(vXpXfrD8g?f*IB#`SwxTDK{1O0@S!SoX1ScloXe1S)0lboFyt=akR{0DtTnNB{r;

literal 0
HcmV?d00001

diff --git a/tests/source/nineslice_9x9.png b/tests/source/nineslice_9x9.png
new file mode 100644
index 0000000000000000000000000000000000000000..6bfe6855fcc47b29a5989bd0dde0dfb870aa96f8
GIT binary patch
literal 150
zcmeAS@N?(olHy`uVBq!ia0vp^oFL4>1|%O$WD@{VjKx9jP7LeL$-D$|0z6$DLnNlQ
zPB7#<V8FqAKJefF)N+l0?xjA*4p??E1gG}9TzWCvd9N^Y(acE}g*TT+*;*KRRag5;
xeQA=IVR7`f(3jlhv#)+kmlWPuxc~nb24+E<Po@d0cLB|2@O1TaS?83{1OT9cGiv|<

literal 0
HcmV?d00001

diff --git a/tests/src/playdate_tests.nim b/tests/src/playdate_tests.nim
index cbf2adc..107cc07 100644
--- a/tests/src/playdate_tests.nim
+++ b/tests/src/playdate_tests.nim
@@ -5,13 +5,13 @@
 ##
 
 import playdate/api
-import ../t_buttons
-import ../t_graphics
+import ../[t_buttons, t_graphics, t_nineslice]
 
 proc runTests() {.raises: [].} =
     try:
         execButtonsTests()
         execGraphicsTests(true)
+        execNineSliceTests(true)
     except Exception as e:
         quit(e.msg & "\n" & e.getStackTrace)
 
diff --git a/tests/t_nineslice.nim b/tests/t_nineslice.nim
new file mode 100644
index 0000000..5c0ddca
--- /dev/null
+++ b/tests/t_nineslice.nim
@@ -0,0 +1,124 @@
+import unittest, playdate/api, strutils
+
+template assertNineSlice(nineSlice: NineSlice, width, height: int, expect: openarray[string], setMask: bool = true) =
+    var img = playdate.graphics.newBitmap(width, height, kColorWhite)
+    if setMask:
+        discard img.setBitmapMask()
+    img.draw(nineSlice)
+    let expectImg = "\n" & expect.join("\n") & "\n"
+    check(("\n" & $img) == expectImg)
+
+proc execNineSliceTests*(runnable: bool) =
+
+    suite "Nine Slice API":
+        if runnable:
+
+            let nineSlice9x9 = playdate.graphics.newBitmap("nineslice_9x9.png").newNineSlice()
+
+            test "Draw a nine slice to bitmap when the target area is larger than the nine slice":
+                nineSlice9x9.assertNineSlice(24, 12, [
+                    "███░░░░░░░░░░░░░░░░░░███",
+                    "█░░ █  █  █  █  █  █ ░░█",
+                    "█░                    ░█",
+                    "░  ░█░░█░░█░░█░░█░░█░  ░",
+                    "░█ █ ██ ██ ██ ██ ██ █ █░",
+                    "░  ░█░░█░░█░░█░░█░░█░  ░",
+                    "░  ░█░░█░░█░░█░░█░░█░  ░",
+                    "░█ █ ██ ██ ██ ██ ██ █ █░",
+                    "░  ░█░░█░░█░░█░░█░░█░  ░",
+                    "█░                    ░█",
+                    "█░░ █  █  █  █  █  █ ░░█",
+                    "███░░░░░░░░░░░░░░░░░░███",
+                ])
+
+            test "Drawing a nine slice to an image is smaller than it should be":
+                nineSlice9x9.assertNineSlice(6, 6, [
+                    "██████",
+                    "█░░░░█",
+                    "█░  ░█",
+                    "█░  ░█",
+                    "█░░░░█",
+                    "██████",
+                ])
+
+            test "Draw a nine slice to an image without a mask":
+                nineSlice9x9.assertNineSlice(9, 9, [
+                    "███░░░███",
+                    "█░░███░░█",
+                    "█░█████░█",
+                    "░██░█░██░",
+                    "░███████░",
+                    "░██░█░██░",
+                    "█░█████░█",
+                    "█░░███░░█",
+                    "███░░░███",
+                ], setMask = false)
+
+            let nineSlice6x6 = playdate.graphics.newBitmap("nineslice_6x6.png").newNineSlice()
+            for width in 4..30:
+                test "Drawing a nine slice on an image of width " & $width:
+                    let row = "██" & repeat("░", width - 4) & "██"
+                    nineSlice6x6.assertNineSlice(width, 7, [ row, row, row, row, row, row, row, ])
+
+            let nineSlice27x3 = playdate.graphics.newBitmap("nineslice_27x3.png").newNineSlice()
+            for width in 18..30:
+                test "Drawing a multi-byte nine slice on an image of width " & $width:
+                    let row = repeat("█", 9) & repeat("░", width - 18) & repeat("█", 9)
+                    nineSlice27x3.assertNineSlice(width, 3, [ row, row, row, ])
+
+            test "Drawing a large nine slice":
+                playdate.graphics.newBitmap("nineslice_60x60.png").newNineSlice().assertNineSlice(70, 50, [
+                    "████████████████████                              ████████████████████",
+                    "████████████████████                              ████████████████████",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██████████████████████████████████░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██████████████████████████████████░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██████████████████████████████████░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░██",
+                    "████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░████████████████████",
+                    "████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░████████████████████",
+                    "          ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███          ",
+                    "          ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███          ",
+                    "          ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███          ",
+                    "          ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███          ",
+                    "          ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███          ",
+                    "          ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███          ",
+                    "          ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███          ",
+                    "          ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███          ",
+                    "          ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███          ",
+                    "          ███░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░███          ",
+                    "████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░████████████████████",
+                    "████████████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░████████████████████",
+                    "██░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██████████████████████████████████░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██████████████████████████████████░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██████████████████████████████████░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "██░░░░░░░░░░░░░░░░██                              ██░░░░░░░░░░░░░░░░██",
+                    "████████████████████                              ████████████████████",
+                    "████████████████████                              ████████████████████",
+                ])
+
+when isMainModule:
+    execNineSliceTests(runnable = false)