@aguacerowx/react-native 0.0.46 → 0.0.49

package/ios/SatelliteLayer.swift

@@ -0,0 +1,716 @@
+import Foundation
+import MapboxMaps
+import Metal
+import simd
+
+/// Throttled diagnostics for the Metal satellite layer (grep console for `🛰️ [AguaceroSatellite]`).
+private enum AguaceroSatelliteDiag {
+    static let lock = NSLock()
+    static var renderSkipLogs = 0
+    static let maxRenderSkipLogs = 25
+    static var pipelineFailPrinted = false
+
+    static func logRenderSkip(_ message: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        guard renderSkipLogs < maxRenderSkipLogs else { return }
+        renderSkipLogs += 1
+        print("🛰️ [AguaceroSatellite] \(message) [diag \(renderSkipLogs)/\(maxRenderSkipLogs)]")
+    }
+
+    static func logPipelineFailureOnce(_ message: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        guard !pipelineFailPrinted else { return }
+        pipelineFailPrinted = true
+        print("🛰️ [AguaceroSatellite] \(message)")
+    }
+}
+
+/// Packed KTX transcode output (`AGS1` prefix) — matches Android {@link SatelliteKtxDecoder.Parsed}.
+struct SatelliteKtxPayload {
+    let width: Int
+    let height: Int
+    let basisFormatOrdinal: Int
+    let payload: Data
+}
+
+private struct SatelliteFragmentUniformCPU {
+    var opacity: Float
+    var is_true_color: Int32
+    var use_colormap: Int32
+    var _pad: Float
+}
+
+@objc internal final class AguaceroSatelliteRendererHost: NSObject, CustomLayerHost {
+    weak var layer: AguaceroSatelliteRenderer?
+
+    init(layer: AguaceroSatelliteRenderer) {
+        self.layer = layer
+        super.init()
+    }
+
+    func renderingWillStart(_ metalDevice: MTLDevice, colorPixelFormat: UInt, depthStencilPixelFormat: UInt) {
+        layer?.internalRenderingWillStart(
+            metalDevice,
+            colorPixelFormat: colorPixelFormat,
+            depthStencilPixelFormat: depthStencilPixelFormat
+        )
+    }
+
+    func render(
+        _ parameters: CustomLayerRenderParameters,
+        mtlCommandBuffer: MTLCommandBuffer,
+        mtlRenderPassDescriptor: MTLRenderPassDescriptor
+    ) {
+        layer?.internalRender(
+            parameters,
+            mtlCommandBuffer: mtlCommandBuffer,
+            mtlRenderPassDescriptor: mtlRenderPassDescriptor
+        )
+    }
+
+    func renderingWillEnd() {
+        layer?.internalRenderingWillEnd()
+    }
+}
+
+/// Metal port of Android `SatelliteLayer` (GOES KTX2 → custom layer).
+@objc(AguaceroSatelliteRenderer)
+public final class AguaceroSatelliteRenderer: NSObject {
+
+    private static let maxGpuCachedFrames = 128
+    private static let tfEtc2Rgba = 1
+    private static let tfAstc4x4 = 10
+    private static let tfRgba32 = 13
+
+    public struct PendingGpuUpload {
+        let unix: Int64
+        let mesh: SatelliteMeshBuilder.MeshResult
+        let decoded: SatelliteKtxPayload
+        let trueColor: Bool
+        let colormapKind: String
+        let useColormap: Bool
+
+        init(
+            unix: Int64,
+            mesh: SatelliteMeshBuilder.MeshResult,
+            decoded: SatelliteKtxPayload,
+            trueColor: Bool,
+            colormapKind: String,
+            useColormap: Bool
+        ) {
+            self.unix = unix
+            self.mesh = mesh
+            self.decoded = decoded
+            self.trueColor = trueColor
+            self.colormapKind = colormapKind
+            self.useColormap = useColormap
+        }
+    }
+
+    private final class GpuSlot {
+        let unix: Int64
+        let texture: MTLTexture
+        let vertexBuffer: MTLBuffer
+        let indexBuffer: MTLBuffer
+        let indexCount: Int
+        let trueColor: Bool
+        let useColormap: Bool
+        let colormapKind: String
+
+        init(
+            unix: Int64,
+            texture: MTLTexture,
+            vertexBuffer: MTLBuffer,
+            indexBuffer: MTLBuffer,
+            indexCount: Int,
+            trueColor: Bool,
+            useColormap: Bool,
+            colormapKind: String
+        ) {
+            self.unix = unix
+            self.texture = texture
+            self.vertexBuffer = vertexBuffer
+            self.indexBuffer = indexBuffer
+            self.indexCount = indexCount
+            self.trueColor = trueColor
+            self.useColormap = useColormap
+            self.colormapKind = colormapKind
+        }
+    }
+
+    public let id: String
+    @objc internal var hostWrapper: AguaceroSatelliteRendererHost!
+
+    private let lock = NSLock()
+    private var device: MTLDevice!
+    private var pipelineState: MTLRenderPipelineState!
+    private var depthStencilState: MTLDepthStencilState!
+    private var satSamplerNearest: MTLSamplerState!
+    private var satSamplerLinear: MTLSamplerState!
+    private var cmapSamplerLinear: MTLSamplerState!
+
+    private var defaultIrColormap: MTLTexture!
+    private var defaultWvColormap: MTLTexture!
+    private var userColormapTex: MTLTexture?
+
+    private var cache: [Int64: GpuSlot] = [:]
+    private var lruUnixOrder: [Int64] = []
+    private var pendingDelete: [GpuSlot] = []
+
+    private var pendingQueue: [PendingGpuUpload] = []
+
+    private var activeUnix: Int64?
+    private var targetUnix: Int64?
+
+    private var visible = true
+    private var opacity: Float = 1
+    private var fillSmoothing = 0
+
+    private var pendingUserColormap: Data?
+    private var pendingUserColormapDirty = false
+
+    @objc public init(id: String) {
+        self.id = id
+        super.init()
+        hostWrapper = AguaceroSatelliteRendererHost(layer: self)
+    }
+
+    @objc public func getHostWrapper() -> Any {
+        hostWrapper as Any
+    }
+
+    internal static func parsePacked(_ packed: Data?) -> SatelliteKtxPayload? {
+        guard let packed, packed.count >= 20 else { return nil }
+        let b = [UInt8](packed)
+        guard b[0] == 65, b[1] == 71, b[2] == 83, b[3] == 49 else { return nil }
+        let w =
+            Int(b[4]) | (Int(b[5]) << 8) | (Int(b[6]) << 16) | (Int(b[7]) << 24)
+        let h =
+            Int(b[8]) | (Int(b[9]) << 8) | (Int(b[10]) << 16) | (Int(b[11]) << 24)
+        let fmt =
+            Int(b[12]) | (Int(b[13]) << 8) | (Int(b[14]) << 16) | (Int(b[15]) << 24)
+        let psz =
+            Int(b[16]) | (Int(b[17]) << 8) | (Int(b[18]) << 16) | (Int(b[19]) << 24)
+        guard psz > 0, 20 + psz <= packed.count else { return nil }
+        let payload = packed.subdata(in: 20 ..< (20 + psz))
+        return SatelliteKtxPayload(width: w, height: h, basisFormatOrdinal: fmt, payload: payload)
+    }
+
+    @objc public func setVisible(_ v: Bool) {
+        visible = v
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func setOpacity(_ o: Float) {
+        opacity = max(0, min(1, o))
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func setFillSmoothing(_ s: Int) {
+        fillSmoothing = s != 0 ? 1 : 0
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func setUserColormapRgba(_ rgba: Data?) {
+        lock.lock()
+        pendingUserColormap = rgba
+        pendingUserColormapDirty = true
+        lock.unlock()
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func clearUserColormap() {
+        setUserColormapRgba(nil)
+    }
+
+    @objc public func setActiveUnix(_ unix: NSNumber?) {
+        lock.lock()
+        if let u = unix {
+            let v = u.int64Value
+            targetUnix = v
+            if cache[v] != nil {
+                activeUnix = v
+            } else {
+                activeUnix = nil
+            }
+        } else {
+            targetUnix = nil
+            activeUnix = nil
+        }
+        lock.unlock()
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func activateCachedUnix(_ unix: Int64) {
+        lock.lock()
+        targetUnix = unix
+        if cache[unix] != nil {
+            activeUnix = unix
+        }
+        lock.unlock()
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func isFrameCached(_ unix: Int64) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return cache[unix] != nil
+    }
+
+    public func queueGpuUpload(_ upload: PendingGpuUpload) {
+        lock.lock()
+        pendingQueue.append(upload)
+        let depth = pendingQueue.count
+        lock.unlock()
+        print("🛰️ [AguaceroSatellite] queueGpuUpload unix=\(upload.unix) pendingDepth=\(depth) \(upload.decoded.width)x\(upload.decoded.height) fmt=\(upload.decoded.basisFormatOrdinal)")
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func clearAll() {
+        lock.lock()
+        let pq = pendingQueue.count
+        let ck = cache.count
+        pendingQueue.removeAll()
+        for s in cache.values {
+            pendingDelete.append(s)
+        }
+        cache.removeAll()
+        lruUnixOrder.removeAll()
+        activeUnix = nil
+        targetUnix = nil
+        lock.unlock()
+        print("🛰️ [AguaceroSatellite] clearAll: removed \(ck) GPU frame(s), \(pq) pending upload(s)")
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    private func touchUnix(_ u: Int64) {
+        if let i = lruUnixOrder.firstIndex(of: u) {
+            lruUnixOrder.remove(at: i)
+        }
+        lruUnixOrder.append(u)
+    }
+
+    private func putSlotEvictLru(_ slot: GpuSlot) {
+        if let prev = cache[slot.unix] {
+            pendingDelete.append(prev)
+        }
+        cache[slot.unix] = slot
+        touchUnix(slot.unix)
+        while cache.count > Self.maxGpuCachedFrames {
+            guard let victim = lruUnixOrder.first else { break }
+            lruUnixOrder.removeFirst()
+            if let s = cache.removeValue(forKey: victim) {
+                pendingDelete.append(s)
+            }
+        }
+    }
+
+    private func drainDeletesOnMetal(_ commandEncoder: MTLCommandEncoder? = nil) {
+        _ = commandEncoder
+        pendingDelete.removeAll(keepingCapacity: false)
+    }
+
+    private func applyUserColormapIfNeeded() {
+        guard pendingUserColormapDirty else { return }
+        pendingUserColormapDirty = false
+        userColormapTex = nil
+        guard let rgba = pendingUserColormap, rgba.count >= 256 * 4 else { return }
+        guard let device else { return }
+        let td = MTLTextureDescriptor.texture2DDescriptor(
+            pixelFormat: .rgba8Unorm,
+            width: 256,
+            height: 1,
+            mipmapped: false
+        )
+        td.usage = [.shaderRead]
+        guard let tex = device.makeTexture(descriptor: td) else { return }
+        rgba.withUnsafeBytes { raw in
+            guard let base = raw.baseAddress else { return }
+            tex.replace(
+                region: MTLRegionMake2D(0, 0, 256, 1),
+                mipmapLevel: 0,
+                withBytes: base,
+                bytesPerRow: 256 * 4
+            )
+        }
+        userColormapTex = tex
+    }
+
+    private func makeSatTexture(device: MTLDevice, parsed: SatelliteKtxPayload) -> MTLTexture? {
+        let w = parsed.width
+        let h = parsed.height
+        let fmt = parsed.basisFormatOrdinal
+        let payload = parsed.payload
+
+        if fmt == Self.tfRgba32 {
+            let td = MTLTextureDescriptor.texture2DDescriptor(
+                pixelFormat: .rgba8Unorm,
+                width: max(1, w),
+                height: max(1, h),
+                mipmapped: false
+            )
+            td.usage = [.shaderRead]
+            guard let tex = device.makeTexture(descriptor: td) else { return nil }
+            payload.withUnsafeBytes { raw in
+                guard let base = raw.baseAddress else { return }
+                tex.replace(
+                    region: MTLRegionMake2D(0, 0, w, h),
+                    mipmapLevel: 0,
+                    withBytes: base,
+                    bytesPerRow: w * 4
+                )
+            }
+            return tex
+        }
+
+        if fmt == Self.tfAstc4x4 {
+            let td = MTLTextureDescriptor.texture2DDescriptor(
+                pixelFormat: .astc_4x4_ldr,
+                width: max(1, w),
+                height: max(1, h),
+                mipmapped: false
+            )
+            td.usage = [.shaderRead]
+            guard let tex = device.makeTexture(descriptor: td) else { return nil }
+            let blocksWide = (w + 3) / 4
+            let bytesPerRow = blocksWide * 16
+            payload.withUnsafeBytes { raw in
+                guard let base = raw.baseAddress else { return }
+                tex.replace(
+                    region: MTLRegionMake2D(0, 0, w, h),
+                    mipmapLevel: 0,
+                    withBytes: base,
+                    bytesPerRow: bytesPerRow
+                )
+            }
+            return tex
+        }
+
+        if fmt == Self.tfEtc2Rgba {
+            let td = MTLTextureDescriptor.texture2DDescriptor(
+                pixelFormat: .eac_rgba8,
+                width: max(1, w),
+                height: max(1, h),
+                mipmapped: false
+            )
+            td.usage = [.shaderRead]
+            guard let tex = device.makeTexture(descriptor: td) else { return nil }
+            let blocksWide = (w + 3) / 4
+            let bytesPerRow = blocksWide * 16
+            payload.withUnsafeBytes { raw in
+                guard let base = raw.baseAddress else { return }
+                tex.replace(
+                    region: MTLRegionMake2D(0, 0, w, h),
+                    mipmapLevel: 0,
+                    withBytes: base,
+                    bytesPerRow: bytesPerRow
+                )
+            }
+            return tex
+        }
+
+        print("🛰️ [AguaceroSatellite] makeSatTexture: unsupported basisFormatOrdinal=\(fmt) for \(w)x\(h) — add mapping or fix transcode target")
+        return nil
+    }
+
+    private func uploadPending(_ p: PendingGpuUpload) -> GpuSlot? {
+        guard let device else {
+            print("🛰️ [AguaceroSatellite] uploadPending: no Metal device yet unix=\(p.unix)")
+            return nil
+        }
+        guard let tex = makeSatTexture(device: device, parsed: p.decoded) else {
+            print(
+                "🛰️ [AguaceroSatellite] uploadPending: texture creation failed unix=\(p.unix) fmt=\(p.decoded.basisFormatOrdinal) \(p.decoded.width)x\(p.decoded.height)"
+            )
+            return nil
+        }
+
+        let vbLen = p.mesh.vertices.count * MemoryLayout<Float>.size
+        guard let vbuf = device.makeBuffer(bytes: p.mesh.vertices, length: vbLen, options: []) else {
+            print("🛰️ [AguaceroSatellite] uploadPending: vertex buffer alloc failed unix=\(p.unix)")
+            return nil
+        }
+        let ibLen = p.mesh.indices.count * MemoryLayout<UInt32>.size
+        guard let ibuf = device.makeBuffer(bytes: p.mesh.indices, length: ibLen, options: []) else {
+            print("🛰️ [AguaceroSatellite] uploadPending: index buffer alloc failed unix=\(p.unix)")
+            return nil
+        }
+
+        return GpuSlot(
+            unix: p.unix,
+            texture: tex,
+            vertexBuffer: vbuf,
+            indexBuffer: ibuf,
+            indexCount: p.mesh.indexCount,
+            trueColor: p.trueColor,
+            useColormap: p.useColormap,
+            colormapKind: p.colormapKind
+        )
+    }
+
+    internal func internalRenderingWillStart(
+        _ metalDevice: MTLDevice,
+        colorPixelFormat: UInt,
+        depthStencilPixelFormat: UInt
+    ) {
+        device = metalDevice
+
+        let bundle = Bundle(for: AguaceroSatelliteRenderer.self)
+        #if targetEnvironment(simulator)
+        let metallibName = "Shaders-simulator"
+        #else
+        let metallibName = "Shaders-device"
+        #endif
+
+        var defaultLibrary: MTLLibrary?
+        if let metallibUrl = bundle.url(forResource: metallibName, withExtension: "metallib") {
+            defaultLibrary = try? metalDevice.makeLibrary(URL: metallibUrl)
+        }
+        if defaultLibrary == nil,
+           let metallibUrl = bundle.url(forResource: metallibName, withExtension: "metallib", subdirectory: "compiled-shaders") {
+            defaultLibrary = try? metalDevice.makeLibrary(URL: metallibUrl)
+        }
+        if let lib = defaultLibrary,
+           lib.makeFunction(name: "satellite_vertex_main") == nil
+            || lib.makeFunction(name: "satellite_fragment_main") == nil {
+            defaultLibrary = nil
+        }
+        if defaultLibrary == nil,
+           let metalUrl = bundle.url(forResource: "Shaders", withExtension: "metal"),
+           let source = try? String(contentsOf: metalUrl),
+           let library = try? metalDevice.makeLibrary(source: source, options: nil) {
+            defaultLibrary = library
+        }
+
+        guard let library = defaultLibrary,
+              let vert = library.makeFunction(name: "satellite_vertex_main"),
+              let frag = library.makeFunction(name: "satellite_fragment_main") else {
+            AguaceroSatelliteDiag.logPipelineFailureOnce(
+                "internalRenderingWillStart: missing satellite_vertex_main / satellite_fragment_main in \(metallibName).metallib (recompile Shaders.metal → metallib)"
+            )
+            return
+        }
+
+        let vertexDescriptor = MTLVertexDescriptor()
+        vertexDescriptor.attributes[0].format = .float2
+        vertexDescriptor.attributes[0].offset = 0
+        vertexDescriptor.attributes[0].bufferIndex = 0
+        vertexDescriptor.attributes[1].format = .float2
+        vertexDescriptor.attributes[1].offset = MemoryLayout<Float>.size * 2
+        vertexDescriptor.attributes[1].bufferIndex = 0
+        vertexDescriptor.layouts[0].stride = MemoryLayout<Float>.size * 4
+        vertexDescriptor.layouts[0].stepFunction = .perVertex
+
+        let pipelineDescriptor = MTLRenderPipelineDescriptor()
+        pipelineDescriptor.vertexDescriptor = vertexDescriptor
+        pipelineDescriptor.vertexFunction = vert
+        pipelineDescriptor.fragmentFunction = frag
+        pipelineDescriptor.colorAttachments[0].pixelFormat =
+            MTLPixelFormat(rawValue: colorPixelFormat) ?? .bgra8Unorm
+        pipelineDescriptor.depthAttachmentPixelFormat =
+            MTLPixelFormat(rawValue: depthStencilPixelFormat) ?? .depth32Float_stencil8
+        pipelineDescriptor.stencilAttachmentPixelFormat =
+            MTLPixelFormat(rawValue: depthStencilPixelFormat) ?? .depth32Float_stencil8
+        pipelineDescriptor.colorAttachments[0].isBlendingEnabled = true
+        pipelineDescriptor.colorAttachments[0].rgbBlendOperation = .add
+        pipelineDescriptor.colorAttachments[0].alphaBlendOperation = .add
+        pipelineDescriptor.colorAttachments[0].sourceRGBBlendFactor = .sourceAlpha
+        pipelineDescriptor.colorAttachments[0].sourceAlphaBlendFactor = .sourceAlpha
+        pipelineDescriptor.colorAttachments[0].destinationRGBBlendFactor = .oneMinusSourceAlpha
+        pipelineDescriptor.colorAttachments[0].destinationAlphaBlendFactor = .oneMinusSourceAlpha
+
+        do {
+            pipelineState = try metalDevice.makeRenderPipelineState(descriptor: pipelineDescriptor)
+        } catch {
+            AguaceroSatelliteDiag.logPipelineFailureOnce(
+                "internalRenderingWillStart: makeRenderPipelineState failed — \(error.localizedDescription)"
+            )
+            return
+        }
+
+        let dsDesc = MTLDepthStencilDescriptor()
+        dsDesc.depthCompareFunction = .always
+        dsDesc.isDepthWriteEnabled = false
+        depthStencilState = metalDevice.makeDepthStencilState(descriptor: dsDesc)
+
+        let sn = MTLSamplerDescriptor()
+        sn.minFilter = .nearest
+        sn.magFilter = .nearest
+        sn.sAddressMode = .clampToEdge
+        sn.tAddressMode = .clampToEdge
+        satSamplerNearest = metalDevice.makeSamplerState(descriptor: sn)
+
+        let sl = MTLSamplerDescriptor()
+        sl.minFilter = .linear
+        sl.magFilter = .linear
+        sl.sAddressMode = .clampToEdge
+        sl.tAddressMode = .clampToEdge
+        satSamplerLinear = metalDevice.makeSamplerState(descriptor: sl)
+
+        let sc = MTLSamplerDescriptor()
+        sc.minFilter = .linear
+        sc.magFilter = .linear
+        sc.sAddressMode = .clampToEdge
+        sc.tAddressMode = .clampToEdge
+        cmapSamplerLinear = metalDevice.makeSamplerState(descriptor: sc)
+
+        let irData = SatelliteColormap.defaultIrColormapRgba()
+        let wvData = SatelliteColormap.defaultWvColormapRgba()
+        defaultIrColormap = makeColormapTexture(device: metalDevice, rgba: irData)
+        defaultWvColormap = makeColormapTexture(device: metalDevice, rgba: wvData)
+    }
+
+    private func makeColormapTexture(device: MTLDevice, rgba: Data) -> MTLTexture? {
+        let td = MTLTextureDescriptor.texture2DDescriptor(
+            pixelFormat: .rgba8Unorm,
+            width: 256,
+            height: 1,
+            mipmapped: false
+        )
+        td.usage = [.shaderRead]
+        guard let tex = device.makeTexture(descriptor: td) else { return nil }
+        rgba.withUnsafeBytes { raw in
+            guard let base = raw.baseAddress else { return }
+            tex.replace(
+                region: MTLRegionMake2D(0, 0, 256, 1),
+                mipmapLevel: 0,
+                withBytes: base,
+                bytesPerRow: 256 * 4
+            )
+        }
+        return tex
+    }
+
+    internal func internalRender(
+        _ parameters: CustomLayerRenderParameters,
+        mtlCommandBuffer: MTLCommandBuffer,
+        mtlRenderPassDescriptor: MTLRenderPassDescriptor
+    ) {
+        guard let pipelineState,
+              let depthStencilState,
+              let defaultIrColormap,
+              let defaultWvColormap,
+              let cmapSamplerLinear
+        else {
+            AguaceroSatelliteDiag.logPipelineFailureOnce(
+                "internalRender: GPU pipeline not initialized yet (custom layer host did not finish internalRenderingWillStart)"
+            )
+            return
+        }
+
+        lock.lock()
+
+        pendingDelete.removeAll()
+
+        while !pendingQueue.isEmpty {
+            let pu = pendingQueue.removeFirst()
+            if let slot = uploadPending(pu) {
+                putSlotEvictLru(slot)
+                if let t = targetUnix, t == slot.unix {
+                    activeUnix = slot.unix
+                } else if targetUnix == nil {
+                    // Matches JS fallback when satelliteTimestamp is omitted on first emit.
+                    targetUnix = slot.unix
+                    activeUnix = slot.unix
+                }
+            }
+        }
+
+        applyUserColormapIfNeeded()
+
+        let show = visible
+        let op = opacity
+        let smooth = fillSmoothing
+
+        let snapshotAu = activeUnix
+        let snapshotTu = targetUnix
+        let cachedFrameCount = cache.count
+
+        let drawUnix = activeUnix
+        let slot = drawUnix.flatMap { cache[$0] }
+
+        if let d = slot {
+            touchUnix(d.unix)
+        }
+
+        lock.unlock()
+
+        guard show, op > 0, let draw = slot, draw.indexCount > 0 else {
+            AguaceroSatelliteDiag.logRenderSkip(
+                "skip draw visible=\(show) op=\(String(format: "%.2f", op)) active=\(String(describing: snapshotAu)) target=\(String(describing: snapshotTu)) slot=\(slot != nil) idx=\(slot?.indexCount ?? 0) cachedFrames=\(cachedFrameCount)"
+            )
+            return
+        }
+
+        guard let encoder = mtlCommandBuffer.makeRenderCommandEncoder(descriptor: mtlRenderPassDescriptor) else {
+            AguaceroSatelliteDiag.logPipelineFailureOnce(
+                "internalRender: makeRenderCommandEncoder returned nil"
+            )
+            return
+        }
+
+        let matrixArray = parameters.projectionMatrix
+        var matrix = matrixArray.map { $0.floatValue }
+        let zoom = parameters.zoom
+        let mercatorScale = pow(2.0, zoom)
+        for i in 0 ..< 12 {
+            matrix[i] *= Float(mercatorScale)
+        }
+
+        let mvp = matrix_float4x4(
+            SIMD4<Float>(matrix[0], matrix[1], matrix[2], matrix[3]),
+            SIMD4<Float>(matrix[4], matrix[5], matrix[6], matrix[7]),
+            SIMD4<Float>(matrix[8], matrix[9], matrix[10], matrix[11]),
+            SIMD4<Float>(matrix[12], matrix[13], matrix[14], matrix[15])
+        )
+
+        var fu = SatelliteFragmentUniformCPU(
+            opacity: op,
+            is_true_color: draw.trueColor ? 1 : 0,
+            use_colormap: draw.useColormap ? 1 : 0,
+            _pad: 0
+        )
+
+        encoder.setRenderPipelineState(pipelineState)
+        encoder.setDepthStencilState(depthStencilState)
+        encoder.setVertexBuffer(draw.vertexBuffer, offset: 0, index: 0)
+        encoder.setVertexBytes([mvp], length: MemoryLayout<matrix_float4x4>.size, index: 1)
+        encoder.setFragmentBytes(&fu, length: MemoryLayout<SatelliteFragmentUniformCPU>.stride, index: 0)
+
+        encoder.setFragmentTexture(draw.texture, index: 0)
+        let cmapTex: MTLTexture
+        if draw.useColormap {
+            if let uc = userColormapTex {
+                cmapTex = uc
+            } else if draw.colormapKind == "wv" {
+                cmapTex = defaultWvColormap
+            } else {
+                cmapTex = defaultIrColormap
+            }
+        } else {
+            cmapTex = defaultIrColormap
+        }
+        encoder.setFragmentTexture(cmapTex, index: 1)
+
+        let satSamp = smooth != 0 ? satSamplerLinear : satSamplerNearest
+        encoder.setFragmentSamplerState(satSamp, index: 0)
+        encoder.setFragmentSamplerState(cmapSamplerLinear, index: 1)
+
+        encoder.drawIndexedPrimitives(
+            type: .triangle,
+            indexCount: draw.indexCount,
+            indexType: .uint32,
+            indexBuffer: draw.indexBuffer,
+            indexBufferOffset: 0
+        )
+        encoder.endEncoding()
+    }
+
+    internal func internalRenderingWillEnd() {}
+
+    deinit {
+        hostWrapper = nil
+    }
+}