@aguacerowx/react-native 0.0.46 → 0.0.49

package/ios/NexradRadarLayer.swift

@@ -0,0 +1,743 @@
+import Foundation
+import MapboxMaps
+import Metal
+import simd
+
+@objc internal final class NexradRadarLayerHost: NSObject, CustomLayerHost {
+    weak var layer: NexradRadarLayer?
+
+    init(layer: NexradRadarLayer) {
+        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 `NexradRadarLayer`.
+@objc(NexradRadarLayer)
+public final class NexradRadarLayer: NSObject {
+
+    private static let lutSize = 256
+    private static let maxGpuCachedFrames = 64
+
+    private final class GpuFrameSlot {
+        let gateTex: MTLTexture
+        let nGates: Int
+        let nRays: Int
+        let valueScale: Float
+        let valueOffset: Float
+        let discrete: Float
+        let geomKey: String
+
+        init(
+            gateTex: MTLTexture,
+            nGates: Int,
+            nRays: Int,
+            valueScale: Float,
+            valueOffset: Float,
+            discrete: Float,
+            geomKey: String
+        ) {
+            self.gateTex = gateTex
+            self.nGates = nGates
+            self.nRays = nRays
+            self.valueScale = valueScale
+            self.valueOffset = valueOffset
+            self.discrete = discrete
+            self.geomKey = geomKey
+        }
+    }
+
+    public let id: String
+    @objc internal var hostWrapper: NexradRadarLayerHost!
+
+    private let lock = NSLock()
+
+    private var device: MTLDevice!
+    private var pipelineState: MTLRenderPipelineState!
+    private var depthStencilState: MTLDepthStencilState!
+    private var gateSamplerNearest: MTLSamplerState!
+    private var lutSamplerNearest: MTLSamplerState!
+    private var lutSamplerLinear: MTLSamplerState!
+
+    private var gateTexture: MTLTexture!
+    private var lutTexture: MTLTexture!
+    private var vertexBuffer: MTLBuffer?
+    private var activeDrawGateTex: MTLTexture!
+
+    private var gpuFrameSlots: [String: GpuFrameSlot] = [:]
+    private var lruKeys: [String] = []
+
+    private var activeVertCount = 0
+    private var anchorMercatorX: Float = 0
+    private var anchorMercatorY: Float = 0
+    private var hasFrame = false
+    private var visible = true
+
+    private var committedGeometryKey: String?
+
+    private var pendingGateBytes: Data?
+    private var pendingNGates = 0
+    private var pendingNRays = 0
+    private var pendingStationLat = 0.0
+    private var pendingStationLon = 0.0
+    private var pendingFirstGateKm: Float = 0
+    private var pendingGateWidthKm: Float = 0
+    private var pendingRayBoundaries: [Float]?
+    private var pendingLutRgba: Data?
+    private var pendingValueScale: Float = 1
+    private var pendingValueOffset: Float = 0
+    private var pendingLutMin: Float = 0
+    private var pendingLutMax: Float = 80
+    private var pendingDiscrete: Float = 0
+    private var pendingOpacity: Float = 1
+    private var pendingGateSmooth: Float = 1
+    private var pendingInterpolateLut = 1
+
+    private enum UploadKind: Int {
+        case none = 0
+        case full = 1
+        case style = 2
+        case activateCached = 4
+    }
+
+    private var pendingUploadKind: UploadKind = .none
+    private var pendingNativeGpuCacheKey: String?
+    private var pendingActivateCacheKey: String?
+    private var pendingGpuSlotsClear = false
+    private var pendingStyleAfterActivate = false
+
+    private var pendingGeomVertices: [Float]?
+    private var pendingGeomVertexCount = 0
+    private var pendingGeomAnchorX: Float = 0
+    private var pendingGeomAnchorY: Float = 0
+
+    private func nexradLogMetal(_ message: String, minInterval: CFAbsoluteTime = 2.5) {
+        _ = (message, minInterval)
+    }
+
+    @objc public init(id: String) {
+        self.id = id
+        super.init()
+        self.hostWrapper = NexradRadarLayerHost(layer: self)
+    }
+
+    private func notifyGpuFrameRegistered(_ key: String) {
+        NotificationCenter.default.post(
+            name: NSNotification.Name("AguaceroNexradGpuFrameReadyInternal"),
+            object: nil,
+            userInfo: ["nativeGpuCacheKey": key]
+        )
+    }
+
+    @objc public func getHostWrapper() -> Any {
+        hostWrapper as Any
+    }
+
+    /// FNV-1a fingerprint — must match Android {@link NexradRadarLayer#fingerprintRayBoundariesDeg}
+    /// and mapsgl {@code fingerprintRayBoundariesDegQuantized}.
+    ///
+    /// **Important:** Java `Math.round(NaN)` is `0`; Swift `Int(round(.nan))` **traps**. Canonical ray
+    /// tables can contain NaNs after resampling, so we mirror Java’s rounding semantics exactly.
+    private static func fingerprintRayBoundariesDeg(_ b: [Float], unitsPerDeg: Int) -> String {
+        if b.isEmpty { return "0" }
+        var h = Int32(bitPattern: 2166136261)
+        let n = b.count
+        let u = Float(unitsPerDeg)
+        for i in 0 ..< n {
+            let prod = b[i] * u
+            // Java: int v = Math.round(b[i] * (float) unitsPerDeg);  // NaN / Inf → 0 for round(NaN)
+            let v: Int32
+            if prod.isNaN || prod.isInfinite {
+                v = 0
+            } else {
+                let rounded = Double(prod).rounded()
+                v = Int32(truncatingIfNeeded: Int64(rounded))
+            }
+            h ^= v
+            h &*= 16777619
+        }
+        h ^= Int32(n) &* Int32(73856093)
+        let uh = UInt32(bitPattern: h)
+        return String(UInt64(uh), radix: 36)
+    }
+
+    @objc public static func buildGeometryCacheKey(
+        nRays: Int,
+        nGates: Int,
+        stationLat: Double,
+        stationLon: Double,
+        firstGateKm: Float,
+        gateWidthKm: Float,
+        rayBoundariesDeg: [Float]
+    ) -> String {
+        let base =
+            "\(stationLat),\(stationLon),\(firstGateKm),\(gateWidthKm),\(nRays),\(nGates)"
+        let rb = fingerprintRayBoundariesDeg(rayBoundariesDeg, unitsPerDeg: 1000)
+        return base + ",rb:" + rb
+    }
+
+    @objc public func isGeometryCommitted(_ geomKey: String) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return committedGeometryKey == geomKey
+    }
+
+    @objc public func setVisible(_ v: Bool) {
+        visible = v
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func requestFullFrameUpload(
+        gateBytes: Data,
+        nGates: Int,
+        nRays: Int,
+        stationLat: Double,
+        stationLon: Double,
+        firstGateKm: Float,
+        gateWidthKm: Float,
+        rayBoundariesDeg: [Float],
+        lutRgba256: Data,
+        valueScale: Float,
+        valueOffset: Float,
+        lutMin: Float,
+        lutMax: Float,
+        discreteIntegerLut: Float,
+        opacity: Float,
+        gateSmoothPolar: Float,
+        interpolateLut: Int,
+        nativeGpuCacheKey: String?,
+        geomVertices: [Float]?,
+        geomVertexCount: Int,
+        anchorMercatorX: Float,
+        anchorMercatorY: Float
+    ) {
+        lock.lock()
+        pendingGateBytes = gateBytes
+        pendingNGates = nGates
+        pendingNRays = nRays
+        pendingStationLat = stationLat
+        pendingStationLon = stationLon
+        pendingFirstGateKm = firstGateKm
+        pendingGateWidthKm = gateWidthKm
+        pendingRayBoundaries = rayBoundariesDeg
+        pendingLutRgba = lutRgba256
+        pendingValueScale = valueScale
+        pendingValueOffset = valueOffset
+        pendingLutMin = lutMin
+        pendingLutMax = lutMax
+        pendingDiscrete = discreteIntegerLut
+        pendingOpacity = opacity
+        pendingGateSmooth = gateSmoothPolar
+        pendingInterpolateLut = interpolateLut
+        pendingNativeGpuCacheKey = nativeGpuCacheKey
+        pendingGeomVertices = geomVertices
+        pendingGeomVertexCount = geomVertexCount
+        pendingGeomAnchorX = anchorMercatorX
+        pendingGeomAnchorY = anchorMercatorY
+        pendingUploadKind = .full
+        visible = true
+        lock.unlock()
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func requestActivateCachedFrame(_ nativeGpuCacheKey: String) {
+        lock.lock()
+        pendingActivateCacheKey = nativeGpuCacheKey
+        pendingUploadKind = .activateCached
+        lock.unlock()
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func requestStyleOnlyUpload(
+        lutRgba256: Data,
+        valueScale: Float,
+        valueOffset: Float,
+        lutMin: Float,
+        lutMax: Float,
+        discreteIntegerLut: Float,
+        opacity: Float,
+        gateSmoothPolar: Float,
+        interpolateLut: Int
+    ) {
+        lock.lock()
+        pendingLutRgba = lutRgba256
+        pendingValueScale = valueScale
+        pendingValueOffset = valueOffset
+        pendingLutMin = lutMin
+        pendingLutMax = lutMax
+        pendingDiscrete = discreteIntegerLut
+        pendingOpacity = opacity
+        pendingGateSmooth = gateSmoothPolar
+        pendingInterpolateLut = interpolateLut
+        if pendingUploadKind == .activateCached {
+            pendingStyleAfterActivate = true
+        } else {
+            pendingUploadKind = .style
+        }
+        lock.unlock()
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    @objc public func clearFrame() {
+        lock.lock()
+        hasFrame = false
+        activeVertCount = 0
+        pendingUploadKind = .none
+        committedGeometryKey = nil
+        pendingGpuSlotsClear = true
+        pendingStyleAfterActivate = false
+        lock.unlock()
+        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
+    }
+
+    internal func internalRenderingWillStart(
+        _ metalDevice: MTLDevice,
+        colorPixelFormat: UInt,
+        depthStencilPixelFormat: UInt
+    ) {
+        device = metalDevice
+
+        let bundle = Bundle(for: NexradRadarLayer.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)
+        }
+        // Stale pod/npm install: metallib may predate NEXRAD — it loads but has no nexrad_* symbols.
+        if let lib = defaultLibrary,
+           lib.makeFunction(name: "nexrad_vertex_main") == nil
+            || lib.makeFunction(name: "nexrad_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: "nexrad_vertex_main"),
+              let frag = library.makeFunction(name: "nexrad_fragment_main") else {
+            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 {
+            return
+        }
+
+        let dsDesc = MTLDepthStencilDescriptor()
+        nexradLogMetal("renderingWillStart OK pipeline created (nexrad shaders)", minInterval: 0)
+        dsDesc.depthCompareFunction = .always
+        dsDesc.isDepthWriteEnabled = false
+        depthStencilState = metalDevice.makeDepthStencilState(descriptor: dsDesc)
+
+        let gateDesc = MTLSamplerDescriptor()
+        gateDesc.minFilter = .nearest
+        gateDesc.magFilter = .nearest
+        gateSamplerNearest = metalDevice.makeSamplerState(descriptor: gateDesc)
+
+        let lutN = MTLSamplerDescriptor()
+        lutN.minFilter = .nearest
+        lutN.magFilter = .nearest
+        lutN.sAddressMode = .clampToEdge
+        lutN.tAddressMode = .clampToEdge
+        lutSamplerNearest = metalDevice.makeSamplerState(descriptor: lutN)
+
+        let lutL = MTLSamplerDescriptor()
+        lutL.minFilter = .linear
+        lutL.magFilter = .linear
+        lutL.sAddressMode = .clampToEdge
+        lutL.tAddressMode = .clampToEdge
+        lutSamplerLinear = metalDevice.makeSamplerState(descriptor: lutL)
+
+        makeDefaultTexturesIfNeeded()
+        activeDrawGateTex = gateTexture
+        nexradLogMetal("renderingWillStart complete — depth stencil + samplers + placeholder textures", minInterval: 0)
+    }
+
+    private func makeDefaultTexturesIfNeeded() {
+        if gateTexture != nil { return }
+        let gd = MTLTextureDescriptor()
+        gd.pixelFormat = .rg8Unorm
+        gd.width = 2
+        gd.height = 2
+        gd.usage = .shaderRead
+        gateTexture = device.makeTexture(descriptor: gd)
+
+        let ld = MTLTextureDescriptor()
+        ld.pixelFormat = .rgba8Unorm
+        ld.width = Self.lutSize
+        ld.height = 1
+        ld.usage = .shaderRead
+        lutTexture = device.makeTexture(descriptor: ld)
+    }
+
+    private func clearGpuFrameSlotsOnMetalThread() {
+        gpuFrameSlots.removeAll()
+        lruKeys.removeAll()
+        activeDrawGateTex = gateTexture
+    }
+
+    private func touchCacheKey(_ key: String) {
+        if let i = lruKeys.firstIndex(of: key) {
+            lruKeys.remove(at: i)
+        }
+        lruKeys.append(key)
+    }
+
+    private func evictOldestSlotLocked() {
+        guard let oldest = lruKeys.first else { return }
+        lruKeys.removeFirst()
+        gpuFrameSlots.removeValue(forKey: oldest)
+    }
+
+    private func obtainGateTexture(for cacheKey: String?) -> MTLTexture {
+        makeDefaultTexturesIfNeeded()
+        guard let cacheKey, !cacheKey.isEmpty else {
+            return gateTexture
+        }
+        if let existing = gpuFrameSlots[cacheKey] {
+            touchCacheKey(cacheKey)
+            return existing.gateTex
+        }
+        while gpuFrameSlots.count >= Self.maxGpuCachedFrames {
+            evictOldestSlotLocked()
+        }
+        let td = MTLTextureDescriptor()
+        td.pixelFormat = .rg8Unorm
+        td.width = max(1, pendingNGates)
+        td.height = max(1, pendingNRays)
+        td.usage = .shaderRead
+        return device.makeTexture(descriptor: td) ?? gateTexture
+    }
+
+    private func registerGpuFrameSlot(
+        cacheKey: String?,
+        tex: MTLTexture,
+        nGates: Int,
+        nRays: Int,
+        vs: Float,
+        vo: Float,
+        discrete: Float,
+        geomKey: String
+    ) {
+        guard let cacheKey, !cacheKey.isEmpty else { return }
+
+        if gpuFrameSlots.removeValue(forKey: cacheKey) != nil {
+            if let i = lruKeys.firstIndex(of: cacheKey) {
+                lruKeys.remove(at: i)
+            }
+        }
+
+        while gpuFrameSlots.count >= Self.maxGpuCachedFrames {
+            evictOldestSlotLocked()
+        }
+
+        let slot = GpuFrameSlot(
+            gateTex: tex,
+            nGates: nGates,
+            nRays: nRays,
+            valueScale: vs,
+            valueOffset: vo,
+            discrete: discrete,
+            geomKey: geomKey
+        )
+
+        gpuFrameSlots[cacheKey] = slot
+        touchCacheKey(cacheKey)
+        notifyGpuFrameRegistered(cacheKey)
+    }
+
+    private func applyLutUploadLocked() {
+        guard let lut = pendingLutRgba, lut.count >= Self.lutSize * 4 else { return }
+        makeDefaultTexturesIfNeeded()
+        lutTexture.replace(
+            region: MTLRegionMake2D(0, 0, Self.lutSize, 1),
+            mipmapLevel: 0,
+            withBytes: (lut as NSData).bytes,
+            bytesPerRow: Self.lutSize * 4
+        )
+    }
+
+    internal func internalRender(
+        _ parameters: CustomLayerRenderParameters,
+        mtlCommandBuffer: MTLCommandBuffer,
+        mtlRenderPassDescriptor: MTLRenderPassDescriptor
+    ) {
+        guard let pipelineState else {
+            nexradLogMetal("render skipped: pipelineState nil — check shader compile logs above")
+            return
+        }
+
+        lock.lock()
+        if pendingGpuSlotsClear {
+            pendingGpuSlotsClear = false
+            clearGpuFrameSlotsOnMetalThread()
+        }
+
+        let kind = pendingUploadKind
+
+        if kind != .none {
+            if kind == .activateCached {
+                let actKey = pendingActivateCacheKey
+                pendingUploadKind = .none
+                pendingActivateCacheKey = nil
+                if let actKey,
+                   let slot = gpuFrameSlots[actKey],
+                   activeVertCount > 0,
+                   committedGeometryKey == slot.geomKey {
+                    activeDrawGateTex = slot.gateTex
+                    pendingNGates = slot.nGates
+                    pendingNRays = slot.nRays
+                    pendingValueScale = slot.valueScale
+                    pendingValueOffset = slot.valueOffset
+                    pendingDiscrete = slot.discrete
+                    hasFrame = activeVertCount > 0
+                    touchCacheKey(actKey)
+                } else if let actKey {
+                }
+            }
+
+            if pendingStyleAfterActivate && hasFrame {
+                pendingStyleAfterActivate = false
+                applyLutUploadLocked()
+            }
+
+            if kind == .style && hasFrame {
+                applyLutUploadLocked()
+                pendingUploadKind = .none
+            } else if kind == .full,
+                      let gateData = pendingGateBytes,
+                      let rays = pendingRayBoundaries {
+            let expectedGateBytes = pendingNGates * pendingNRays * 2
+            if gateData.count < expectedGateBytes || rays.count < pendingNRays + 1 {
+                nexradLogMetal(
+                    "full upload ABORT invalid payload gateB=\(gateData.count) need=\(expectedGateBytes) rays=\(rays.count) needRays+1=\(pendingNRays + 1)",
+                    minInterval: 0
+                )
+                pendingUploadKind = .none
+            } else {
+            let geomKey = NexradRadarLayer.buildGeometryCacheKey(
+                nRays: pendingNRays,
+                nGates: pendingNGates,
+                stationLat: pendingStationLat,
+                stationLon: pendingStationLon,
+                firstGateKm: pendingFirstGateKm,
+                gateWidthKm: pendingGateWidthKm,
+                rayBoundariesDeg: rays
+            )
+
+            let reuseMesh =
+                hasFrame &&
+                activeVertCount > 0 &&
+                committedGeometryKey == geomKey &&
+                gateData.count == expectedGateBytes &&
+                rays.count == pendingNRays + 1
+
+
+            if !reuseMesh,
+               let gv = pendingGeomVertices,
+               gv.count >= pendingGeomVertexCount * 4 {
+                vertexBuffer = device.makeBuffer(bytes: gv, length: gv.count * MemoryLayout<Float>.size, options: [])
+                activeVertCount = pendingGeomVertexCount
+                anchorMercatorX = pendingGeomAnchorX
+                anchorMercatorY = pendingGeomAnchorY
+                committedGeometryKey = geomKey
+            } else if !reuseMesh {
+                nexradLogMetal(
+                    "full upload mesh missing: reuseMesh=false geomVerts=\(pendingGeomVertices?.count ?? 0) need=\(pendingGeomVertexCount * 4) nRays=\(pendingNRays) nGates=\(pendingNGates)"
+                )
+            }
+
+            pendingGeomVertices = nil
+
+            let cacheKeySnapshot = pendingNativeGpuCacheKey
+            pendingNativeGpuCacheKey = nil
+
+            let texTarget = obtainGateTexture(for: cacheKeySnapshot)
+
+            let region = MTLRegionMake2D(0, 0, pendingNGates, pendingNRays)
+            gateData.withUnsafeBytes { raw in
+                guard let base = raw.baseAddress else { return }
+                texTarget.replace(
+                    region: region,
+                    mipmapLevel: 0,
+                    withBytes: base,
+                    bytesPerRow: pendingNGates * 2
+                )
+            }
+
+            applyLutUploadLocked()
+
+            activeDrawGateTex = texTarget
+            hasFrame = activeVertCount > 0
+            pendingUploadKind = .none
+
+            registerGpuFrameSlot(
+                cacheKey: cacheKeySnapshot,
+                tex: texTarget,
+                nGates: pendingNGates,
+                nRays: pendingNRays,
+                vs: pendingValueScale,
+                vo: pendingValueOffset,
+                discrete: pendingDiscrete,
+                geomKey: geomKey
+            )
+            }
+            } else if kind == .full {
+                nexradLogMetal(
+                    "full upload DROPPED missing gateData or rayBoundaries — pendingGate=\(pendingGateBytes?.count ?? -1) rays=\(pendingRayBoundaries?.count ?? -1) nRays=\(pendingNRays) nGates=\(pendingNGates)",
+                    minInterval: 0
+                )
+                pendingUploadKind = .none
+            }
+        }
+
+        let interpolateLutFlag = pendingInterpolateLut
+
+        let vc = activeVertCount
+        let ax = anchorMercatorX
+        let ay = anchorMercatorY
+        let vs = pendingValueScale
+        let vo = pendingValueOffset
+        let lmin = pendingLutMin
+        let lmax = pendingLutMax
+        let disc = pendingDiscrete
+        let op = pendingOpacity
+        let gsm = pendingGateSmooth
+        let tw = pendingNGates
+        let th = pendingNRays
+        let hf = hasFrame
+        let show = visible
+
+        lock.unlock()
+
+        guard show, hf, vc > 0, let vb = vertexBuffer else {
+            return
+        }
+        guard let encoder = mtlCommandBuffer.makeRenderCommandEncoder(descriptor: mtlRenderPassDescriptor) else {
+            nexradLogMetal("draw skipped: makeRenderCommandEncoder returned nil")
+            return
+        }
+
+        let matrixArray = parameters.projectionMatrix
+        var md = matrixArray.map { Double($0.floatValue) }
+        let zoom = parameters.zoom
+        let mercatorScale = pow(2.0, zoom)
+        for i in 0 ..< 12 {
+            md[i] *= mercatorScale
+        }
+        var matrix = matrixArray.map { $0.floatValue }
+        for i in 0 ..< 12 {
+            matrix[i] *= Float(mercatorScale)
+        }
+        let shifted12 = Float(md[0] * Double(ax) + md[4] * Double(ay) + md[12])
+        let shifted13 = Float(md[1] * Double(ax) + md[5] * Double(ay) + md[13])
+        let shifted14 = Float(md[2] * Double(ax) + md[6] * Double(ay) + md[14])
+        let shifted15 = Float(md[3] * Double(ax) + md[7] * Double(ay) + md[15])
+        matrix[12] = shifted12
+        matrix[13] = shifted13
+        matrix[14] = shifted14
+        matrix[15] = shifted15
+
+        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])
+        )
+
+        // Must match `NexradFragmentUniforms` in Shaders.metal (9 logical floats + 1 padding = 40 bytes).
+        let fragUniformByteCount = MemoryLayout<Float>.size * 10
+
+        var fragUniforms: [Float] = [
+            Float(tw), Float(th),
+            vs, vo,
+            lmin, lmax,
+            disc, op, gsm,
+            0,
+        ]
+
+        encoder.setRenderPipelineState(pipelineState)
+        encoder.setDepthStencilState(depthStencilState)
+        encoder.setVertexBuffer(vb, offset: 0, index: 0)
+        encoder.setVertexBytes([mvp], length: MemoryLayout<matrix_float4x4>.size, index: 1)
+
+        fragUniforms.withUnsafeBufferPointer { ptr in
+            encoder.setFragmentBytes(ptr.baseAddress!, length: fragUniformByteCount, index: 0)
+        }
+        encoder.setFragmentTexture(activeDrawGateTex, index: 0)
+        encoder.setFragmentTexture(lutTexture, index: 1)
+        encoder.setFragmentSamplerState(gateSamplerNearest, index: 0)
+        let lutSamp = interpolateLutFlag != 0 ? lutSamplerLinear : lutSamplerNearest
+        guard let lutSamp else {
+            nexradLogMetal("draw skipped: LUT sampler nil (Metal sampler creation failed?)")
+            encoder.endEncoding()
+            return
+        }
+        encoder.setFragmentSamplerState(lutSamp, index: 1)
+
+        encoder.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: vc)
+        encoder.endEncoding()
+    }
+
+    internal func internalRenderingWillEnd() {}
+
+    deinit {
+        hostWrapper = nil
+    }
+}
+