From 82c5d75b2642229405a313e0917b7d5d9688273f Mon Sep 17 00:00:00 2001
From: minjaesong <alswo9628@gmail.com>
Date: Wed, 20 Apr 2022 10:34:41 +0900
Subject: [PATCH] gpu: graphics mode 2

---
 terranmon.txt                                 |  2 ++
 .../tsvm/peripheral/GraphicsAdapter.kt        | 31 ++++++++++++++++---
 2 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/terranmon.txt b/terranmon.txt
index c81645a..47bff2a 100644
--- a/terranmon.txt
+++ b/terranmon.txt
@@ -256,6 +256,8 @@ MMIO
     3: 560x448,  256 Colours, 2 layers (if bank 2 is not installed, will fall back to mode 0)
     4: 560x448, 4096 Colours, 1 layer  (if bank 2 is not installed, will fall back to mode 0)
     4096 is also known as "direct colour mode" (4096 colours * 16 transparency -> 65536 colours)
+        Two layers are grouped to make a frame, "low layer" contains RG colours and "high layer" has BA colours,
+        Red and Blue occupies MSBs
 13 RW
     Layer Arrangement
     If 4 layers are used:
diff --git a/tsvm_core/src/net/torvald/tsvm/peripheral/GraphicsAdapter.kt b/tsvm_core/src/net/torvald/tsvm/peripheral/GraphicsAdapter.kt
index e43a57b..1f1f6aa 100644
--- a/tsvm_core/src/net/torvald/tsvm/peripheral/GraphicsAdapter.kt
+++ b/tsvm_core/src/net/torvald/tsvm/peripheral/GraphicsAdapter.kt
@@ -285,7 +285,7 @@ open class GraphicsAdapter(private val assetsRoot: String, val vm: VM, val confi
             7L -> setGraphicsAttributes(byte)
             9L -> { ttyFore = bi }
             10L -> { ttyBack = bi }
-            12L -> { graphicsMode = bi }
+            12L -> { if (bi >= 3 && sgr.bankCount == 1) graphicsMode = 0 else graphicsMode = bi }
             13L -> { layerArrangement = bi }
             14L -> { framebufferScrollX = framebufferScrollX.and(0xFFFFFF00.toInt()).or(bi) }
             15L -> { framebufferScrollX = framebufferScrollX.and(0xFFFF00FF.toInt()).or(bi shl 8) }
@@ -745,8 +745,8 @@ open class GraphicsAdapter(private val assetsRoot: String, val vm: VM, val confi
         chrrom.pixels.position(0)
 
         framebuffer2.setColor(-1);framebuffer2.fill()
-        if (isRefSize && graphicsMode == 1) {
-            val layerOrder = LAYERORDERS4[layerArrangement]
+        if (isRefSize && (graphicsMode == 1 || graphicsMode == 2)) {
+            val layerOrder = (if (graphicsMode == 1) LAYERORDERS4 else LAYERORDERS2)[layerArrangement]
             for (y in 0..223) {
                 var xoff = scanlineOffsets[2L * y].toUint().shl(8) or scanlineOffsets[2L * y + 1].toUint()
                 if (xoff.and(0x8000) != 0) xoff = xoff or 0xFFFF0000.toInt()
@@ -755,8 +755,29 @@ open class GraphicsAdapter(private val assetsRoot: String, val vm: VM, val confi
                 if (xoff in -(280 - 1) until 280) {
                     for (x in xs) {
                         val colour = layerOrder.map { layer ->
-                            val colourIndex = framebuffer.pixels.get((280*224*layer) + (y * 280 + x)).toUint()
-                            Color(paletteOfFloats[4*colourIndex], paletteOfFloats[4*colourIndex+1], paletteOfFloats[4*colourIndex+2], paletteOfFloats[4*colourIndex+3])
+                            if (graphicsMode == 1) {
+                                val colourIndex = framebuffer.pixels.get((280 * 224 * layer) + (y * 280 + x)).toUint()
+                                Color(
+                                    paletteOfFloats[4 * colourIndex],
+                                    paletteOfFloats[4 * colourIndex + 1],
+                                    paletteOfFloats[4 * colourIndex + 2],
+                                    paletteOfFloats[4 * colourIndex + 3]
+                                )
+                            }
+                            else {
+                                val lowBits = framebuffer.pixels.get((280 * 224 * layer * 2) + (y * 280 + x)).toUint()
+                                val highBits = framebuffer.pixels.get((280 * 224 * (layer*2 + 1)) + (y * 280 + x)).toUint()
+                                val r = lowBits.ushr(4).and(15)
+                                val g = lowBits.and(15)
+                                val b = highBits.ushr(4).and(15)
+                                val a = highBits.and(15)
+                                Color(
+                                    r / 15f,
+                                    g / 15f,
+                                    b / 15f,
+                                    a / 15f
+                                )
+                            }
                         }.fold(Color(0)) { dest, src ->
                             // manually alpha compositing
                             // out_color = {src_color * src_alpha + dest_color * dest_alpha * (1-src_alpha)} / out_alpha