@glassly/bluetooth-sdk 0.1.0-dev.99 → 0.2.8-dev.445

package/ios/Source/sgcs/G2CfwRenderer.swift

@@ -27,6 +27,11 @@ actor G2CfwRenderer {
         let height: Int32
     }
 
+    /// The global setting is 1...3; the firmware placement tables are zero-based.
+    static func depthLevel(forSetting depth: Int) -> Int {
+        min(max(depth, 1), 3) - 1
+    }
+
     static func lensBoxes(
         canvasWidth: Int32, canvasHeight: Int32, heightLevel: Int, depthLevel: Int
     ) -> LensBoxes {
@@ -54,13 +59,138 @@ actor G2CfwRenderer {
 
     // MARK: - Grid-exact mono glyphs (texture-cache path)
 
-    /// Texture-cache state. Modes 12/13/14 draw at absolute panel coordinates
+    /// Asset-store mirror. Modes 19/20 draw at absolute panel coordinates
     /// (no per-lens variant), so the caller only enables this path on frames
-    /// whose window is placed lens-equal. The cache model resets whenever the
-    /// caller's generation changes (lease cycled / residency unknown); the
-    /// glyph raster memo survives resets — rasters don't change.
+    /// whose window is placed lens-equal. The mirror resets whenever the
+    /// caller's generation changes (lease cycled / cache reset); the glyph
+    /// raster memo survives resets — rasters don't change.
     private let textureCache = G2CfwTextureCache()
     private var glyphRasterMemo: [String: Data] = [:]
+    /// Retained object cache (modes 37-41); shares the asset mirror with the
+    /// raster path. Two lens mirrors: while every frame is flat only the left
+    /// one is encoded and its SHOW goes to both lenses; the first frame with
+    /// global or element depth copies it into the right mirror (`stereoSplit`) and from
+    /// then on each lens gets its own SHOW whenever the two encodings differ.
+    private let scenes = [G2CfwScene(), G2CfwScene()]
+    private var stereoSplit = false
+
+    /// One frame of the object cache: the SHOWs to send, in order, each with
+    /// its lens targets, after the asset `uploads`.
+    struct StereoEncoded {
+        struct Show: Equatable {
+            let payload: Data
+            let lenses: UInt8
+        }
+        let shows: [Show]
+        let uploads: [Data]
+        /// False when the frame is the one already on screen (nothing new to send).
+        let changed: Bool
+        let puts: Int
+        let hits: Int
+        let tweens: Int
+    }
+
+    /// The panel went blank while the cache stayed: hidden objects that were
+    /// mid-animation are re-snapped on their next show.
+    func sceneHidden() {
+        for scene in scenes {
+            scene.hidden()
+        }
+    }
+
+    /// The RESET reply named the store each lens could allocate; predict against the smaller one.
+    func setStoreCapacity(bytes: Int) {
+        textureCache.storeCapacity = max(G2CfwTextureCache.granule, min(G2CfwTextureCache.storeSize, bytes))
+    }
+
+    /// A lens answered MISSING: these ids (objects or assets) are redefined on the next frame.
+    func forget(ids: [UInt32]) {
+        for scene in scenes {
+            scene.forget(objectIds: ids)
+        }
+        textureCache.forget(assetIds: ids)
+    }
+
+    /// Upload payloads that were dropped or failed: their assets may not be resident.
+    func forgetUploads(_ payloads: [Data]) {
+        textureCache.forget(assetIds: payloads.flatMap(G2CfwTextureCache.assetIds(inUploadPayload:)))
+    }
+
+    /// Encode `frame` as SHOWs of the object cache (plus the asset PUT
+    /// messages that must precede them): one SHOW for both lenses while the
+    /// lens mirrors agree, else one per lens (element `depth` shifts the two
+    /// encodings apart). `invalidate` means residency is unknown (a send
+    /// failed): every object the frame shows is redefined, and the mirrors
+    /// re-converge. Nil when the frame does not fit the object table or the
+    /// asset store.
+    func encodeVector(
+        _ frame: SceneFrame, boxes: LensBoxes, cacheGeneration: Int, invalidate: Bool, inlineText: Bool,
+        tag: Int? = nil
+    ) -> StereoEncoded? {
+        if textureCache.generation != cacheGeneration {
+            textureCache.reset(generation: cacheGeneration)
+        }
+        if scenes[0].generation != textureCache.generation {
+            for scene in scenes {
+                scene.reset(generation: textureCache.generation)
+            }
+            stereoSplit = false
+        } else if invalidate {
+            for scene in scenes {
+                scene.invalidate()
+            }
+            stereoSplit = false
+        }
+        // Both mirrors rasterize the same element pixels: do it once per frame.
+        var rasters: [String: Data?] = [:]
+        let rasterize: (SceneElement, Int, Int) -> Data? = { element, w, h in
+            let key = "\(element.id)|\(element.contentHash)|\(w)x\(h)"
+            if let hit = rasters[key] { return hit }
+            let pixels = Self.rasterize(
+                SceneFrame(
+                    appId: frame.appId, epoch: frame.epoch, replay: false,
+                    elements: [element.atOrigin()], removed: [],
+                    canvasWidth: Int32(w), canvasHeight: Int32(h)
+                ),
+                width: w, height: h
+            )
+            rasters[key] = pixels
+            return pixels
+        }
+        let mono = G2CfwScene.MonoFace(metrics: Self.monoCellMetrics) {
+            Self.monoGlyphRaster($0, fontSize: $1, cellWidth: $2, lineHeight: $3)
+        }
+        let ox = Int(boxes.left.x)
+        let oy = Int(boxes.left.y)
+        if !stereoSplit, boxes.left != boxes.right || frame.elements.contains(where: { $0.depth != 0 }) {
+            scenes[1].adopt(scenes[0])
+            stereoSplit = true
+        }
+        guard let left = scenes[0].encode(frame, originX: ox, originY: oy, inlineText: inlineText, mono: mono,
+                                          tag: tag, parallax: stereoSplit ? 1 : 0, cache: textureCache, rasterize: rasterize)
+        else { return nil }
+        guard stereoSplit else {
+            return StereoEncoded(shows: [.init(payload: left.payload, lenses: G2CfwTransport.lensBoth)],
+                                 uploads: left.uploads, changed: left.changed,
+                                 puts: left.puts, hits: left.hits, tweens: left.tweens)
+        }
+        guard let right = scenes[1].encode(frame, originX: Int(boxes.right.x), originY: Int(boxes.right.y), inlineText: inlineText, mono: mono,
+                                           tag: tag, parallax: -1, cache: textureCache, rasterize: rasterize)
+        else { return nil }
+        var shows: [StereoEncoded.Show] = []
+        if left.payload == right.payload {
+            shows.append(.init(payload: left.payload, lenses: G2CfwTransport.lensBoth))
+        } else {
+            // A lens whose frame did not change keeps quiet, unless neither changed
+            // (then both SHOWs go, so a caller that always sends stays correct).
+            let both = left.changed == right.changed
+            if both || left.changed { shows.append(.init(payload: left.payload, lenses: G2CfwTransport.lensLeft)) }
+            if both || right.changed { shows.append(.init(payload: right.payload, lenses: G2CfwTransport.lensRight)) }
+        }
+        return StereoEncoded(shows: shows, uploads: left.uploads + right.uploads, changed: left.changed || right.changed,
+                             puts: left.puts + right.puts, hits: left.hits + right.hits, tweens: left.tweens + right.tweens)
+    }
+
 
     /// Fixed cell metrics of the phone's monospaced face at `fontSize`.
     static func monoCellMetrics(fontSize: Int32) -> (cellWidth: Int, lineHeight: Int) {
@@ -259,13 +389,17 @@ actor G2CfwRenderer {
         let lensEqual = boxes.left == boxes.right
         let useTexGlyphs = textureGlyphsEnabled && lensEqual
         let useTexImages = textureImagesEnabled && lensEqual
-        // A full cache resets between frames (never mid-frame: draws already
-        // planned this frame reference the old offsets). Bumping past the
-        // caller's generation keeps the caller's own bumps monotonic.
-        if useTexGlyphs || useTexImages, textureCache.generation != cacheGeneration || textureCache.exhausted {
+        // The asset mirror follows the caller's generation (a lost or reset
+        // on-glass cache); the glasses evict by themselves otherwise.
+        if useTexGlyphs || useTexImages, textureCache.generation != cacheGeneration {
             textureCache.reset(generation: cacheGeneration)
+            for scene in scenes {
+                scene.reset(generation: cacheGeneration)
+            }
+            stereoSplit = false
         }
 
+
         var grids: [MonoGrid] = []
         let raster: Data
         if useTexGlyphs {
@@ -528,7 +662,13 @@ actor G2CfwRenderer {
             if let grid = grids.filter({ $0.covers(rect) }).max(by: { $0.z < $1.z }),
                !elementBoxes.contains(where: { $0.z > grid.z && $0.intersects(rect) }),
                let font = textureCache.font(
-                   fontSize: grid.fontSize, cellWidth: grid.cellWidth, lineHeight: grid.lineHeight
+                   fontSize: grid.fontSize, cellWidth: grid.cellWidth, lineHeight: grid.lineHeight,
+                   rasterize: { code in
+                       self.memoizedGlyphRaster(
+                           Unicode.Scalar(UInt32(code))!, fontSize: grid.fontSize,
+                           cellWidth: grid.cellWidth, lineHeight: grid.lineHeight
+                       )
+                   }
                )
             {
                 let r0 = (rect.y - grid.originY) / grid.lineHeight
@@ -562,14 +702,7 @@ actor G2CfwRenderer {
                     }
                     for col in c0 ... c1 {
                         let scalar = grid.scalar(row: row, col: col)
-                        if scalar.value >= 32, scalar.value <= 126,
-                           textureCache.ensureGlyph(font: font, char: UInt8(scalar.value), rasterize: {
-                               self.memoizedGlyphRaster(
-                                   scalar, fontSize: grid.fontSize,
-                                   cellWidth: grid.cellWidth, lineHeight: grid.lineHeight
-                               )
-                           })
-                        {
+                        if scalar.value >= 32, scalar.value <= 126, font.glyphs.contains(UInt8(scalar.value)) {
                             flushResidual(endCol: col)
                             if runChars.isEmpty { runStartCol = col }
                             runChars.append(UInt8(scalar.value))
@@ -591,7 +724,7 @@ actor G2CfwRenderer {
                     var payloads: [Data] = []
                     for run in newRuns {
                         guard let payload = G2CfwTextureCache.stringRunPayload(
-                            fontTableOffset: font.tableOffset,
+                            fontId: font.id,
                             x: Int(boxes.left.x) + run.x, y: Int(boxes.left.y) + run.y,
                             options: G2CfwTextureCache.opaqueDrawOptions, chars: run.chars
                         ) else { payloads = []; break }
@@ -627,9 +760,9 @@ actor G2CfwRenderer {
                         ))
                     }
                 }
-                if let offset = textureCache.ensureImage(hash: candidate.key, gray: gray, width: w, height: h),
+                if let asset = textureCache.ensureImage(hash: candidate.key, gray: gray, width: w, height: h),
                    let draw = G2CfwTextureCache.imageDrawPayload(
-                       offset: offset,
+                       assetId: asset,
                        x: Int(boxes.left.x) + candidate.box.x0, y: Int(boxes.left.y) + candidate.box.y0,
                        options: G2CfwTextureCache.opaqueDrawOptions
                    )
@@ -1046,12 +1179,15 @@ actor G2CfwRenderer {
                             width: sourceSize.width * imageScale,
                             height: sourceSize.height * imageScale
                         )
+                        // The ink level scales the pixels, as the texture ramp does on vector firmware.
+                        let alpha = element.color < 0 ? 1 : CGFloat(max(0, min(15, element.color))) / 15
                         source.draw(
                             in: CGRect(
                                 x: rect.midX - target.width / 2,
                                 y: rect.midY - target.height / 2,
                                 width: target.width, height: target.height
-                            )
+                            ),
+                            blendMode: .normal, alpha: alpha
                         )
                     }
 
@@ -1102,9 +1238,9 @@ actor G2CfwRenderer {
         return rendered ? grayscale : nil
     }
 
-    /// Mode 3 with the lenses-differ bit: one zlib(RLE(4bpp)) payload of the
-    /// box pixels, drawn by each lens at its own box.
-    /// `[0x83][lx/4][ly/2][w/4][h/2][rx/4][ry/2][w/4][h/2][fid lo][fid hi][zlib]`
+    /// Mode 3 with the lenses-differ bit: one RLE(4bpp) payload of the
+    /// window drawn at each lens's box (the SID-0xf0 transport compresses).
+    /// `[0x83][lx/4][ly/2][w/4][h/2][rx/4][ry/2][w/4][h/2][fid lo][fid hi][rle]`
     static func stereoFrame(pixels: Data, boxes: LensBoxes, fid: UInt16) -> Data? {
         guard pixels.count == Int(boxes.width) * Int(boxes.height) else { return nil }
         let rle = rleEncode(pack4Bpp(pixels))
@@ -1129,7 +1265,7 @@ actor G2CfwRenderer {
     private static func stereoRleFrame(
         rle: Data, lx: Int, ly: Int, rx: Int, ry: Int, w: Int32, h: Int32, fid: UInt16
     ) -> Data? {
-        guard let compressed = BinaryCodec.zlibRFC1950(rle) else { return nil }
+        guard !rle.isEmpty else { return nil }
         var payload = Data([0x83])
         for (x, y) in [(lx, ly), (rx, ry)] {
             payload.append(UInt8(x / 4))
@@ -1139,7 +1275,8 @@ actor G2CfwRenderer {
         }
         payload.append(UInt8(fid & 0xFF))
         payload.append(UInt8(fid >> 8))
-        payload.append(compressed)
+        // Plain RLE: the SID-0xf0 transport deflates the whole message.
+        payload.append(rle)
         return payload
     }
 
@@ -1190,20 +1327,16 @@ actor G2CfwRenderer {
     /// Mode 6 full-panel black: seeds the shadow mode-3 frames composite onto.
     static func blackPayload() -> Data? {
         let pixelCount = frameWidth * frameHeight
-        let rle = rleEncodeSolid(color: 0, pixelCount: pixelCount)
-        guard let compressed = BinaryCodec.zlibRFC1950(rle) else { return nil }
         var payload = Data([6])
-        payload.append(compressed)
+        payload.append(rleEncodeSolid(color: 0, pixelCount: pixelCount))
         return payload
     }
 
+    /// `[6][rle]`: plain RLE, the SID-0xf0 transport deflates the whole message.
     static func encodePixels(_ grayscale: Data) -> Data? {
         guard grayscale.count == frameWidth * frameHeight else { return nil }
-        let packed = pack4Bpp(grayscale)
-        let rle = rleEncode(packed)
-        guard let compressed = BinaryCodec.zlibRFC1950(rle) else { return nil }
         var payload = Data([6])
-        payload.append(compressed)
+        payload.append(rleEncode(pack4Bpp(grayscale)))
         return payload
     }