@aguacerowx/react-native 0.0.21 → 0.0.22

package/lib/module/lib/commonjs/ios/GridRenderLayer.swift

@@ -1,995 +0,0 @@
-import Foundation
-import MapboxMaps
-import Metal
-import libzstd
-import simd
-
-// MARK: - Swift-only wrapper for CustomLayerHost conformance
-@objc internal final class GridRenderLayerHost: NSObject, CustomLayerHost {
-    weak var layer: GridRenderLayer?
-
-    init(layer: GridRenderLayer) {
-        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()
-    }
-}
-
-@objc(GridRenderLayer)
-public class GridRenderLayer: NSObject {
-    
-    // MARK: - Properties
-    
-    public var id: String
-    @objc internal var hostWrapper: GridRenderLayerHost!
-    
-    // Metal objects
-    private var device: MTLDevice!
-    private var commandQueue: MTLCommandQueue!
-    private var pipelineState: MTLRenderPipelineState!
-    private var vertexBuffer: MTLBuffer?
-    private var indexBuffer: MTLBuffer?
-    private var dataTexture: MTLTexture?
-    private var colormapTexture: MTLTexture?
-    private var dataSamplerState: MTLSamplerState!
-    private var colormapSamplerState: MTLSamplerState!
-    private var isDataSamplerLinear: Bool = false
-
-    private var pendingColormapUpdate: String?
-    private var pendingDataUpdate: (data: String, nx: NSNumber, ny: NSNumber, scale: NSNumber, offset: NSNumber, missing: NSNumber, scaleType: String)?
-    private var pendingGeometryUpdate: (corners: [String: Any], gridDef: [String: Any])?
-    
-    // Layer state
-    private var indexCount: Int = 0
-    private var uniforms = FragmentUniforms(
-        opacity: 1.0,
-        dataRange: SIMD2<Float>(0.0, 1.0),
-        scale: 1.0,
-        offset: 0.0,
-        missingQuantized: 127.0,
-        textureSize: SIMD2<Float>(0.0, 0.0),
-        smoothing: 1,
-        scaleType: 0,
-        isPtype: 0 // ADD THIS
-    )
-    private var isVisible = false
-    private var pendingActiveFrameKey: String?
-    private let inspectorCache = InspectorDataCache.shared
-    private struct FrameMetadata {
-        let texture: MTLTexture
-        let scale: Float
-        let offset: Float
-        let missing: Float
-        let scaleType: Int
-        let nx: Float
-        let ny: Float
-        let filePath: String
-        let originalScale: Float  // ADD THIS
-        let originalOffset: Float  // ADD THIS
-    }
-    private var frameCache: [String: FrameMetadata] = [:]
-    private let highPriorityTextureQueue = DispatchQueue(label: "com.aguacero.texture-processing-high-priority", qos: .userInitiated)
-
-    // The concurrent queue for background preloading all other frames.
-    private let backgroundTextureQueue = DispatchQueue(label: "com.aguacero.texture-processing-background", qos: .utility, attributes: .concurrent)
-    // MARK: - Initializer
-    private struct VertexInfo {
-        var mercX: Float
-        var mercY: Float
-        var texU: Float
-        var texV: Float
-        var index: UInt16
-    }
-    @objc
-    public init(id: String) {
-        self.id = id
-        super.init()
-        self.hostWrapper = GridRenderLayerHost(layer: self)
-        print("🟢 [GridRenderLayer] Initialized with ID: \(id)")
-    }
-
-    @objc public func getHostWrapper() -> Any {
-      return self.hostWrapper as Any
-    }
-    
-    // MARK: - Public Methods (called from Manager)
-    
-    @objc public func setOpacity(value: Float) {
-        self.uniforms.opacity = value
-        print("🟢 [GridRenderLayer] Set opacity: \(value)")
-        // ADD THIS: Force the map to repaint to show the opacity change immediately.
-        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
-    }
-
-    @objc public func setDataRange(value: [NSNumber]) {
-        self.uniforms.dataRange = SIMD2<Float>(value[0].floatValue, value[1].floatValue)
-        print("🟢 [GridRenderLayer] Set data range: \(value)")
-        // ADD THIS: Force the map to repaint to show the data range change immediately.
-        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
-    }
-
-    @objc public func setSmoothing(value: Bool) {
-        self.uniforms.smoothing = value ? 1 : 0
-        print("🟢 [GridRenderLayer] Set smoothing: \(value)")
-        // ADD THIS: Force the map to repaint to show the smoothing change immediately.
-        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
-    }
-    
-    // ADD THIS METHOD
-    @objc(setVariableWithVariable:)
-    public func setVariable(variable: String) {
-        let isPtypeVar = (variable == "ptypeRefl" || variable == "ptypeRate")
-        self.uniforms.isPtype = isPtypeVar ? 1 : 0
-        print("🟢 [GridRenderLayer] Set variable: \(variable), isPtype set to: \(self.uniforms.isPtype)")
-        NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
-    }
-
-    @objc public func clear() {
-        self.isVisible = false
-        self.inspectorCache.clear()
-        print("🟢 [GridRenderLayer] Cleared")
-    }
-    
-    @objc public func updateDataParameters(scale: NSNumber, offset: NSNumber, missing: NSNumber, scaleType: NSNumber) {  // ADD scaleType parameter
-        // Update both the inspector cache AND the rendering uniforms
-        self.uniforms.scale = scale.floatValue
-        self.uniforms.offset = offset.floatValue
-        self.uniforms.missingQuantized = missing.floatValue
-        self.uniforms.scaleType = Int32(scaleType.intValue)  // ADD THIS
-        
-        inspectorCache.update(
-            data: inspectorCache.lastDecompressedData,
-            nx: inspectorCache.nx,
-            ny: inspectorCache.ny,
-            scale: scale.floatValue,
-            offset: offset.floatValue,
-            missing: missing.floatValue,
-            scaleType: scaleType.intValue  // ADD THIS
-        )
-        
-        print("🟢 [GridRenderLayer] Updated data parameters - scale: \(scale), offset: \(offset), missing: \(missing), scaleType: \(scaleType)")
-    }
-
-    @objc public func updateColormapTexture(colormapAsBase64: String) {
-        guard let device = self.device else {
-            pendingColormapUpdate = colormapAsBase64
-            return
-        }
-        guard let data = Data(base64Encoded: colormapAsBase64) else { return }
-        let textureDescriptor = MTLTextureDescriptor()
-        textureDescriptor.pixelFormat = .rgba8Unorm
-        textureDescriptor.width = 256
-        textureDescriptor.height = 1
-        textureDescriptor.usage = .shaderRead
-        guard let texture = device.makeTexture(descriptor: textureDescriptor) else { return }
-        texture.replace(
-            region: MTLRegionMake2D(0, 0, 256, 1),
-            mipmapLevel: 0,
-            withBytes: (data as NSData).bytes,
-            bytesPerRow: 256 * 4
-        )
-        self.colormapTexture = texture
-    }
-
-    @objc(clearGpuCache) // Explicitly name the Obj-C selector
-    public func clearGpuCache() {
-        backgroundTextureQueue.async {
-            self.frameCache.removeAll()
-            print("🟢 [GridRenderLayer] GPU frame cache cleared.")
-        }
-    }
-
-    private func processRawData(fileData: Data) -> Data? {
-        guard let decompressedDeltas = self.decompressZstd(data: fileData) else {
-            print("❌ [GridRenderLayer] Failed to decompress zstd data")
-            return nil
-        }
-        let reconstructedData = self.reconstructData(decompressedDeltas: decompressedDeltas)
-        let finalTextureBytes = self.transformData(finalData: reconstructedData)
-        return finalTextureBytes
-    }
-
-    private func createTextureFromBytes(bytes: Data, nx: Int, ny: Int) -> MTLTexture? {
-        guard let device = self.device else { return nil }
-        let textureDescriptor = MTLTextureDescriptor()
-        textureDescriptor.pixelFormat = .r8Unorm
-        textureDescriptor.width = nx
-        textureDescriptor.height = ny
-        textureDescriptor.usage = .shaderRead
-
-        guard let texture = device.makeTexture(descriptor: textureDescriptor) else { return nil }
-        texture.replace(
-            region: MTLRegionMake2D(0, 0, nx, ny),
-            mipmapLevel: 0,
-            withBytes: (bytes as NSData).bytes,
-            bytesPerRow: nx
-        )
-        return texture
-    }
-
-    private func updateInspectorCache(filePath: String, nx: Int, ny: Int, scale: Float, offset: Float, missing: Float, scaleType: Int) {
-        highPriorityTextureQueue.async {
-
-            guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)) else {
-                print("❌ [Inspector] FATAL: Failed to read file data from path.")
-                self.inspectorCache.clear()
-                return
-            }
-            print("💡 [Inspector] 2. Successfully read \(fileData.count) bytes from file.")
-            
-            guard let decompressedDeltas = self.decompressZstd(data: fileData) else {
-                print("❌ [Inspector] FATAL: Failed to decompress Zstd data.")
-                self.inspectorCache.clear()
-                return
-            }
-            print("💡 [Inspector] 3. Successfully decompressed data.")
-
-            let reconstructedData = self.reconstructData(decompressedDeltas: decompressedDeltas)
-            print("💡 [Inspector] 4. Reconstructed data with \(reconstructedData.count) bytes.")
-            
-            self.inspectorCache.update(
-                data: reconstructedData,
-                nx: nx,
-                ny: ny,
-                scale: scale,
-                offset: offset,
-                missing: missing,
-                scaleType: scaleType
-            )
-            
-            print("💡 [Inspector] 5. ✅ Cache updated successfully with scaleType=\(scaleType)")
-        }
-    }
-
-    @objc(setActiveFrameWithCacheKey:)
-    public func setActiveFrame(cacheKey: String) {
-        // First, check if the frame is already in the cache.
-        if let frame = frameCache[cacheKey] {
-            print("⚡️ [GridRenderLayer] Cache HIT for key: \(cacheKey). Swapping texture.")
-            
-            self.dataTexture = frame.texture
-            self.uniforms.scale = frame.scale
-            self.uniforms.offset = frame.offset
-            self.uniforms.missingQuantized = frame.missing
-            self.uniforms.textureSize = SIMD2<Float>(frame.nx, frame.ny)
-            self.uniforms.scaleType = Int32(frame.scaleType)
-            
-            self.isVisible = true
-            self.pendingActiveFrameKey = nil // Clear any pending key
-            NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
-            
-            // --- ADD THIS ---
-            // Now that the frame is active, update the inspector cache with its data.
-            self.updateInspectorCache(
-                filePath: frame.filePath,
-                nx: Int(frame.nx),
-                ny: Int(frame.ny),
-                scale: frame.scale,
-                offset: frame.offset,
-                missing: frame.missing,
-                scaleType: frame.scaleType
-            )
-
-        } else {
-            // --- FIX: If it's a miss, store the key and wait for it to be primed. ---
-            print("⚠️ [GridRenderLayer] setActiveFrame cache MISS for key: \(cacheKey). Will apply when primed.")
-            self.pendingActiveFrameKey = cacheKey
-            self.isVisible = false // Hide the layer until the frame is ready
-        }
-    }
-
-    @objc(primeGpuCacheWithFrameInfo:)
-    public func primeGpuCache(frameInfo: [String: [String: Any]]) {
-        let group = DispatchGroup()
-        
-        if (frameInfo.count > 1) {
-            print("🟡 [GridRenderLayer] Starting to prime \(frameInfo.count) textures concurrently...")
-        }
-
-        for (cacheKey, info) in frameInfo {
-            group.enter()
-            
-            backgroundTextureQueue.async {
-                defer { group.leave() }
-                if self.frameCache[cacheKey] != nil { return }
-                
-                guard let filePath = info["filePath"] as? String,
-                    let nx = info["nx"] as? NSNumber,
-                    let ny = info["ny"] as? NSNumber,
-                    let scale = info["scale"] as? NSNumber,
-                    let offset = info["offset"] as? NSNumber,
-                    let missing = info["missing"] as? NSNumber,
-                    let scaleTypeStr = info["scaleType"] as? String,
-                    let originalScale = info["originalScale"] as? NSNumber,  // ADD THIS
-                    let originalOffset = info["originalOffset"] as? NSNumber,  // ADD THIS
-                    let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)),
-                    let finalTextureBytes = self.processRawData(fileData: fileData)
-                else {
-                    print("❌ [GridRenderLayer] Skipping prime for \(cacheKey), missing data.")
-                    return
-                }
-                
-                DispatchQueue.main.sync {
-                    if let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nx.intValue, ny: ny.intValue) {
-                        let metadata = FrameMetadata(
-                            texture: texture,
-                            scale: scale.floatValue,
-                            offset: offset.floatValue,
-                            missing: missing.floatValue,
-                            scaleType: (scaleTypeStr == "sqrt") ? 1 : 0,
-                            nx: nx.floatValue,
-                            ny: ny.floatValue,
-                            filePath: filePath,
-                            originalScale: originalScale.floatValue,  // ADD THIS
-                            originalOffset: originalOffset.floatValue  // ADD THIS
-                        )
-                        self.frameCache[cacheKey] = metadata
-                        print("   ✅ [GridRenderLayer] Primed and cached frame for key: \(cacheKey)")
-
-                        if let pendingKey = self.pendingActiveFrameKey, pendingKey == cacheKey {
-                            print("👍 [GridRenderLayer] The pending frame is now ready. Activating it.")
-                            self.setActiveFrame(cacheKey: pendingKey)
-                        }
-                    }
-                }
-            }
-        }
-        
-        group.notify(queue: .main) {
-            if (frameInfo.count > 1) {
-                print("🎉 [GridRenderLayer] All \(frameInfo.count) frames have been processed and cached to the GPU.")
-            }
-        }
-    }
-
-    @objc public func updateDataTexture(data: String, nx: NSNumber, ny: NSNumber, scale: NSNumber, offset: NSNumber, missing: NSNumber, scaleType: String) {
-        print("🚀 [GridRenderLayer] FAST LANE: updateDataTexture called for initial frame...")
-        
-        let filePath = data // Assuming 'data' is always the file path for this method.
-        
-        // USE THE HIGH-PRIORITY QUEUE
-        highPriorityTextureQueue.async {
-            guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)) else { return }
-            
-            guard let finalTextureBytes = self.processRawData(fileData: fileData) else {
-                print("❌ [GridRenderLayer] FAST LANE: Failed to process initial frame data.")
-                return
-            }
-            
-            DispatchQueue.main.async {
-                guard let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nx.intValue, ny: ny.intValue) else {
-                    return
-                }
-                
-                self.dataTexture = texture
-                self.uniforms.scale = scale.floatValue
-                self.uniforms.offset = offset.floatValue
-                self.uniforms.missingQuantized = missing.floatValue
-                self.uniforms.scaleType = Int32((scaleType == "sqrt") ? 1 : 0)
-                self.uniforms.textureSize = SIMD2<Float>(nx.floatValue, ny.floatValue)
-                
-                self.isVisible = true
-                print("✅ [GridRenderLayer] FAST LANE: Initial frame processed and displayed.")
-                NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
-                
-                // --- ADD THIS ---
-                // Update the inspector cache for the initial frame.
-                self.updateInspectorCache(
-                    filePath: filePath,
-                    nx: nx.intValue,
-                    ny: ny.intValue,
-                    scale: scale.floatValue,
-                    offset: offset.floatValue,
-                    missing: missing.floatValue,
-                    scaleType: (scaleType == "sqrt") ? 1 : 0
-                )
-            }
-        }
-    }
-
-    @objc public func updateGeometry(corners: [String: Any], gridDef: [String: Any]) {
-        print("🟢 [GridRenderLayer] updateGeometry called")
-        print("   device: \(self.device != nil)")
-        
-        guard self.device != nil else {
-            print("⚠️ [GridRenderLayer] Device not ready yet, storing geometry for later")
-            pendingGeometryUpdate = (corners: corners, gridDef: gridDef)
-            return
-        }
-        
-        print("   Device is ready, processing geometry immediately")
-        
-        DispatchQueue.global(qos: .userInitiated).async {
-            print("   🔄 Generating geometry on background thread")
-            
-            var vertices: [Float] = []
-            var indices: [UInt16] = []
-            
-            self.generateGeometryData(gridDef: gridDef, vertices: &vertices, indices: &indices)
-            
-            if vertices.isEmpty || indices.isEmpty {
-                print("❌ [GridRenderLayer] No geometry generated")
-                return
-            }
-            
-            print("   ✅ Generated \(vertices.count/4) vertices, \(indices.count/3) triangles")
-            
-            self.indexCount = indices.count
-            
-            DispatchQueue.main.async {
-                print("   🎨 Creating buffers on main thread")
-                
-                self.vertexBuffer = self.device.makeBuffer(bytes: vertices, length: vertices.count * MemoryLayout<Float>.size, options: [])
-                self.indexBuffer = self.device.makeBuffer(bytes: indices, length: indices.count * MemoryLayout<UInt16>.size, options: [])
-                
-                print("🟢 [GridRenderLayer] Geometry updated: \(vertices.count/4) vertices, \(indices.count/3) triangles")
-                print("   vertexBuffer: \(self.vertexBuffer != nil)")
-                print("   indexBuffer: \(self.indexBuffer != nil)")
-                print("   indexCount: \(self.indexCount)")
-
-                // TRIGGER A REPAINT - ADD THIS:
-                NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
-            }
-        }
-    }
-
-    private func decompressZstd(data: Data) -> Data? {
-        let decompressedSize = data.withUnsafeBytes { ptr in
-            ZSTD_getFrameContentSize(ptr.baseAddress, data.count)
-        }
-        
-        guard Int64(bitPattern: decompressedSize) > 0 else {
-            print("❌ [GridRenderLayer] Could not determine decompressed size")
-            return nil
-        }
-        
-        var decompressedData = Data(count: Int(decompressedSize))
-        
-        let result = decompressedData.withUnsafeMutableBytes { decompressedPtr -> Int in
-            data.withUnsafeBytes { compressedPtr -> Int in
-                let returnValue = ZSTD_decompress(
-                    decompressedPtr.baseAddress,
-                    Int(decompressedSize),  
-                    compressedPtr.baseAddress,
-                    data.count
-                )
-                return Int(returnValue)
-            }
-        }
-
-        guard result > 0 && result == decompressedData.count else {
-            if result > 0 {
-                let size_t_result = size_t(result)
-                if let errorName = ZSTD_getErrorName(size_t_result) {
-                    let errorString = String(cString: errorName)
-                    print("❌ [GridRenderLayer] Zstd decompression failed: \(errorString)")
-                }
-            }
-            return nil
-        }
-        return decompressedData
-    }
-    
-    // MARK: - Private Helper Methods
-    
-    private func reconstructData(decompressedDeltas: Data) -> Data {
-        guard !decompressedDeltas.isEmpty else { return Data() }
-        var reconstructedData = Data(count: decompressedDeltas.count)
-        reconstructedData[0] = decompressedDeltas[0]
-        for i in 1..<decompressedDeltas.count {
-            reconstructedData[i] = UInt8(Int8(bitPattern: reconstructedData[i-1]) &+ Int8(bitPattern: decompressedDeltas[i]))
-        }
-        return reconstructedData
-    }
-    
-    private func transformData(finalData: Data) -> Data {
-        var transformedData = Data(count: finalData.count)
-        for i in 0..<finalData.count {
-            transformedData[i] = UInt8(Int16(Int8(bitPattern: finalData[i])) + 128)
-        }
-        return transformedData
-    }
-
-    private func isLCCType(gridDef: [String: Any]) -> Bool {
-        if let type = gridDef["type"] as? String {
-            return type == "lambert_conformal_conic"
-        }
-        return false
-    }
-
-    private func generateLCCGeometry(gridDef: [String: Any], vertices: inout [Float], indices: inout [UInt16]) {
-        guard let gridParams = gridDef["grid_params"] as? [String: Any],
-            let projParams = gridDef["proj_params"] as? [String: Any],
-            let nx = gridParams["nx"] as? Int,
-            let ny = gridParams["ny"] as? Int,
-            let dx = gridParams["dx"] as? Double,
-            let dy = gridParams["dy"] as? Double,
-            let x_origin = gridParams["x_origin"] as? Double,
-            let y_origin = gridParams["y_origin"] as? Double else {
-            return
-        }
-        
-        let subdivisions = 60
-        let TILE_SIZE: Double = 512.0
-        
-        let x_min = x_origin
-        let y_max = y_origin
-        let x_max = x_origin + Double(nx - 1) * dx
-        let y_min = y_origin + Double(ny - 1) * dy
-        
-        var vertexGrid: [[VertexInfo?]] = Array(repeating: Array(repeating: nil, count: subdivisions + 1), count: subdivisions + 1)
-        var validVertexCount: UInt16 = 0
-        
-        // Generate vertices
-        for row in 0...subdivisions {
-            for col in 0...subdivisions {
-                let t_x = Double(col) / Double(subdivisions)
-                let t_y = Double(row) / Double(subdivisions)
-                
-                let proj_x = x_min + t_x * (x_max - x_min)
-                let proj_y = y_max + t_y * (y_min - y_max)
-                
-                // Convert LCC projection coordinates to lat/lon
-                if let (lon, lat) = lccToLonLat(i: proj_x, j: proj_y, gridDef: gridDef) {
-                    // Convert lat/lon to Mercator
-                    let mercX_normalized = (lon + 180.0) / 360.0
-                    let clampedLat = max(-85.05112878, min(85.05112878, lat))
-                    let sinLatitude = sin(clampedLat * .pi / 180.0)
-                    let mercY_normalized = 0.5 - log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * .pi)
-                    
-                    let mercX = mercX_normalized * TILE_SIZE
-                    let mercY = mercY_normalized * TILE_SIZE
-                    
-                    // Check for invalid values
-                    if !mercX.isFinite || !mercY.isFinite {
-                        vertexGrid[row][col] = nil
-                        continue
-                    }
-                    
-                    let tex_u = Float(t_x)
-                    let tex_v = Float(t_y)
-                    
-                    let vInfo = VertexInfo(
-                        mercX: Float(mercX),
-                        mercY: Float(mercY),
-                        texU: tex_u,
-                        texV: tex_v,
-                        index: validVertexCount
-                    )
-                    
-                    vertexGrid[row][col] = vInfo
-                    
-                    vertices.append(Float(mercX))
-                    vertices.append(Float(mercY))
-                    vertices.append(tex_u)
-                    vertices.append(tex_v)
-                    
-                    validVertexCount += 1
-                } else {
-                    vertexGrid[row][col] = nil
-                }
-            }
-        }
-        
-        if vertices.isEmpty {
-            print("❌ [LCC Geometry] No valid vertices generated")
-            return
-        }
-        
-        // Generate indices
-        for row in 0..<subdivisions {
-            for col in 0..<subdivisions {
-                guard let topLeft = vertexGrid[row][col],
-                    let topRight = vertexGrid[row][col + 1],
-                    let bottomLeft = vertexGrid[row + 1][col],
-                    let bottomRight = vertexGrid[row + 1][col + 1] else {
-                    continue
-                }
-                
-                indices.append(topLeft.index)
-                indices.append(bottomLeft.index)
-                indices.append(topRight.index)
-                
-                indices.append(topRight.index)
-                indices.append(bottomLeft.index)
-                indices.append(bottomRight.index)
-            }
-        }
-    }
-
-    private func lccToLonLat(i: Double, j: Double, gridDef: [String: Any]) -> (lon: Double, lat: Double)? {
-        guard let projParams = gridDef["proj_params"] as? [String: Any],
-            let lat_0 = projParams["lat_0"] as? Double,  // latitude of origin
-            let lon_0 = projParams["lon_0"] as? Double,  // longitude of origin
-            let lat_1 = projParams["lat_1"] as? Double,  // first standard parallel
-            let lat_2 = projParams["lat_2"] as? Double,  // second standard parallel (HRRR uses two!)
-            let r_earth = projParams["R"] as? Double else {
-            print("❌ [LCC Geometry] Failed to extract LCC parameters.")
-            return nil
-        }
-
-        let π = Double.pi
-        let toRad = π / 180.0
-        let toDeg = 180.0 / π
-        
-        let lat1_rad = lat_1 * toRad
-        let lat2_rad = lat_2 * toRad
-        let lat0_rad = lat_0 * toRad
-        let lon0_rad = lon_0 * toRad
-        
-        // Calculate cone constant (n) using two standard parallels
-        let n: Double
-        if abs(lat_1 - lat_2) < 1e-10 {
-            n = sin(lat1_rad)  // Single parallel case
-        } else {
-            n = log(cos(lat1_rad) / cos(lat2_rad)) / log(tan(π/4.0 + lat2_rad/2.0) / tan(π/4.0 + lat1_rad/2.0))
-        }
-        
-        let F = cos(lat1_rad) * pow(tan(π/4.0 + lat1_rad/2.0), n) / n
-        let rho_0 = r_earth * F * pow(tan(π/4.0 + lat0_rad/2.0), -n)
-        
-        // i, j are the x, y projection coordinates
-        let x = i
-        let y = j
-        
-        let rho = sqrt(x * x + (rho_0 - y) * (rho_0 - y))
-        if rho < 1e-10 {
-            return (lon: lon_0, lat: lat_0)
-        }
-        
-        let theta = atan2(x, rho_0 - y)
-        
-        let lon = lon0_rad + theta / n
-        let lat = 2.0 * atan(pow(r_earth * F / rho, 1.0 / n)) - π/2.0
-        
-        let lonDeg = lon * toDeg
-        let latDeg = lat * toDeg
-        
-        if !lonDeg.isFinite || !latDeg.isFinite {
-            return nil
-        }
-
-        return (lon: lonDeg, lat: latDeg)
-    }
-    
-    private func generateGeometryData(gridDef: [String: Any], vertices: inout [Float], indices: inout [UInt16]) {
-        guard let gridParams = gridDef["grid_params"] as? [String: Any] else {
-            return
-        }
-
-        // GFS Global Grid Path
-        if isGFSType(gridParams: gridParams) {
-            let subdivisions = 120
-            let verticesPerRow = (subdivisions * 3) + 1
-            let TILE_SIZE: Double = 512.0
-            
-            for row in 0...subdivisions {
-                for col in 0...(subdivisions * 3) {
-                    let v_interp = Float(row) / Float(subdivisions)
-                    let u_interp = Float(col) / Float(subdivisions)
-                    let lon = -540.0 + Double(u_interp) * 1080.0
-                    let lat = -90.0 + Double(v_interp) * 180.0
-                    
-                    let merc = lonLatToMercator(lon: lon, lat: lat, tileSize: TILE_SIZE)
-                    vertices.append(contentsOf: [merc.x, merc.y])
-                    
-                    let tex_u = Float((lon + 180.0) / 360.0)
-                    let tex_v = 1.0 - v_interp
-                    vertices.append(contentsOf: [tex_u, tex_v])
-                }
-            }
-            
-            for row in 0..<subdivisions {
-                for col in 0..<(subdivisions * 3) {
-                    let tl = UInt16(row * verticesPerRow + col)
-                    let tr = tl + 1
-                    let bl = UInt16((row + 1) * verticesPerRow + col)
-                    let br = bl + 1
-                    indices.append(contentsOf: [tl, bl, tr, tr, bl, br])
-                }
-            }
-            return
-        }
-        if isLCCType(gridDef: gridDef) {
-            generateLCCGeometry(gridDef: gridDef, vertices: &vertices, indices: &indices)
-            return
-        }
-        
-        // Generic Grid Path (MRMS, etc.)
-        let nx = gridParams["nx"] as? Int ?? 0
-        let ny = gridParams["ny"] as? Int ?? 0
-        let lon_first = gridParams["lon_first"] as? Double ?? 0.0
-        let lat_first = gridParams["lat_first"] as? Double ?? 90.0
-        let dx = gridParams["dx_degrees"] as? Double ?? 0.0
-        let dy = gridParams["dy_degrees"] as? Double ?? 0.0
-        let lon_last = gridParams["lon_last"] as? Double ?? (lon_first + Double(nx - 1) * dx)
-        let lat_last = gridParams["lat_last"] as? Double ?? (lat_first + Double(ny - 1) * dy)
-        let lat_span = lat_last - lat_first
-        let isSouthToNorth = lat_span > 0
-
-        let data_lon_first_180 = lon_first > 180 ? lon_first - 360 : lon_first
-        let data_lon_last_180 = lon_last > 180 ? lon_last - 360 : lon_last
-        let data_lon_range = data_lon_last_180 - data_lon_first_180
-
-        let subdivisions_x = 120
-        let subdivisions_y = 60
-        let verticesPerRow = subdivisions_x + 1
-        let TILE_SIZE: Double = 512.0
-
-        // 🔑 FIX: Only create ONE world copy for regional data, THREE for global data
-        let worldCopies = (data_lon_range > 300) ? [-1, 0, 1] : [0]  // Only wrap if nearly global
-        
-        for world_copy in worldCopies {
-            let vertexStartIndex = UInt16(vertices.count / 4)
-            let lon_offset = Double(world_copy) * 360.0
-
-            // Generate vertices for this world copy
-            for row in 0...subdivisions_y {
-                for col in 0...subdivisions_x {
-                    let v_interp = Float(row) / Float(subdivisions_y)
-                    let u_interp = Float(col) / Float(subdivisions_x)
-
-                    let vertex_lon = data_lon_first_180 + (Double(u_interp) * data_lon_range)
-                    let vertex_lat = lat_first + (Double(v_interp) * lat_span)
-
-                    let mercX_normalized = ((vertex_lon + lon_offset) + 180.0) / 360.0
-                    let clampedLat = max(-85.05112878, min(85.05112878, vertex_lat))
-                    let sinLatitude = sin(clampedLat * .pi / 180.0)
-                    let mercY_normalized = 0.5 - log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * .pi)
-                    let mercX = mercX_normalized * TILE_SIZE
-                    let mercY = mercY_normalized * TILE_SIZE
-
-                    vertices.append(contentsOf: [Float(mercX), Float(mercY)])
-
-                    let tex_u = u_interp
-                    let tex_v = isSouthToNorth ? (1.0 - v_interp) : v_interp
-                    
-                    vertices.append(contentsOf: [tex_u, tex_v])
-                }
-            }
-
-            // Generate indices (same as before)
-            for row in 0..<UInt16(subdivisions_y) {
-                for col in 0..<UInt16(subdivisions_x) {
-                    let tl = vertexStartIndex + row * UInt16(verticesPerRow) + col
-                    let tr = tl + 1
-                    let bl = vertexStartIndex + (row + 1) * UInt16(verticesPerRow) + col
-                    let br = bl + 1
-
-                    if isSouthToNorth {
-                        indices.append(contentsOf: [tl, bl, tr, tr, bl, br])
-                    } else {
-                        indices.append(contentsOf: [tl, tr, bl, bl, tr, br])
-                    }
-                }
-            }
-        }
-    }
-    
-    private func isGFSType(gridParams: [String: Any]) -> Bool {
-        return (gridParams["lon_first"] as? Double) == 0.0 &&
-               abs((gridParams["lat_first"] as? Double) ?? -1) == 90.0
-    }
-    
-    private func lonLatToMercator(lon: Double, lat: Double, tileSize: Double) -> (x: Float, y: Float) {
-        let mercX_normalized = (lon + 180.0) / 360.0
-        let clampedLat = max(-85.05112878, min(85.05112878, lat))
-        let sinLatitude = sin(clampedLat * .pi / 180.0)
-        let mercY_normalized = 0.5 - log((1.0 + sinLatitude) / (1.0 - sinLatitude)) / (4.0 * .pi)
-        
-        return (x: Float(mercX_normalized * tileSize), y: Float(mercY_normalized * tileSize))
-    }
-    
-    // MARK: - Internal methods for CustomLayerHost (called by wrapper)
-    
-internal func internalRenderingWillStart(_ metalDevice: MTLDevice, colorPixelFormat: UInt, depthStencilPixelFormat: UInt) {
-    print("🟢 [GridRenderLayer] renderingWillStart called")
-    self.device = metalDevice
-    self.commandQueue = metalDevice.makeCommandQueue()
-    
-    let bundle = Bundle(for: GridRenderLayer.self)
-
-    // Determine if we're running on simulator or device
-    #if targetEnvironment(simulator)
-    let metallibName = "Shaders-simulator"
-    #else
-    let metallibName = "Shaders-device"
-    #endif
-
-    // Try to load pre-compiled metallib for the current platform
-    let defaultLibrary: MTLLibrary?
-    if let metallibUrl = bundle.url(forResource: metallibName, withExtension: "metallib"),
-    let library = try? metalDevice.makeLibrary(URL: metallibUrl) {
-        print("✅ [GridRenderLayer] Loaded pre-compiled metallib (\(metallibName))")
-        defaultLibrary = library
-    }
-    // Fall back to compiling from .metal source (for development with npm link)
-    else if let metalUrl = bundle.url(forResource: "Shaders", withExtension: "metal"),
-            let source = try? String(contentsOf: metalUrl),
-            let library = try? metalDevice.makeLibrary(source: source, options: nil) {
-        print("✅ [GridRenderLayer] Compiled Metal shader from source")
-        defaultLibrary = library
-    }
-    // Neither worked
-    else {
-        print("❌ [GridRenderLayer] Could not find or compile Metal shaders")
-        print("   Bundle path: \(bundle.bundlePath)")
-        return
-    }
-
-    guard let library = defaultLibrary else {
-        print("❌ [GridRenderLayer] Failed to create Metal library")
-        return
-    }
-    
-    let vertexFunction = library.makeFunction(name: "vertex_main")
-    let fragmentFunction = library.makeFunction(name: "fragment_main")
-
-    // Set up vertex descriptor
-    let vertexDescriptor = MTLVertexDescriptor()
-    vertexDescriptor.attributes[0].format = .float2  // position (x, y)
-    vertexDescriptor.attributes[0].offset = 0
-    vertexDescriptor.attributes[0].bufferIndex = 0
-
-    vertexDescriptor.attributes[1].format = .float2  // texCoord (u, v)
-    vertexDescriptor.attributes[1].offset = MemoryLayout<Float>.size * 2
-    vertexDescriptor.attributes[1].bufferIndex = 0
-
-    vertexDescriptor.layouts[0].stride = MemoryLayout<Float>.size * 4  // 2 floats for pos + 2 for texCoord
-    vertexDescriptor.layouts[0].stepFunction = .perVertex
-
-    let pipelineDescriptor = MTLRenderPipelineDescriptor()
-    pipelineDescriptor.vertexDescriptor = vertexDescriptor
-    pipelineDescriptor.vertexFunction = vertexFunction
-    pipelineDescriptor.fragmentFunction = fragmentFunction
-    
-    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 {
-        self.pipelineState = try metalDevice.makeRenderPipelineState(descriptor: pipelineDescriptor)
-    } catch {
-        print("❌ [GridRenderLayer] Failed to create pipeline state: \(error)")
-        return
-    }
-    
-    let dataSamplerDesc = MTLSamplerDescriptor()
-    dataSamplerDesc.minFilter = .nearest
-    dataSamplerDesc.magFilter = .nearest
-    self.dataSamplerState = metalDevice.makeSamplerState(descriptor: dataSamplerDesc)
-
-    let colormapSamplerDesc = MTLSamplerDescriptor()
-    colormapSamplerDesc.minFilter = .nearest
-    colormapSamplerDesc.magFilter = .nearest
-    colormapSamplerDesc.sAddressMode = .clampToEdge
-    self.colormapSamplerState = metalDevice.makeSamplerState(descriptor: colormapSamplerDesc)
-    
-    print("🟢 [GridRenderLayer] Metal setup complete")
-    
-    // Process any pending updates that came in before Metal was ready
-    if let pendingGeometry = pendingGeometryUpdate {
-        print("🟡 [GridRenderLayer] Processing pending geometry update")
-        updateGeometry(corners: pendingGeometry.corners, gridDef: pendingGeometry.gridDef)
-        pendingGeometryUpdate = nil
-    }
-    
-    if let pendingColormap = pendingColormapUpdate {
-        print("🟡 [GridRenderLayer] Processing pending colormap update")
-        updateColormapTexture(colormapAsBase64: pendingColormap)
-        pendingColormapUpdate = nil
-    }
-    
-    if let pendingData = pendingDataUpdate {
-        print("🟡 [GridRenderLayer] Processing pending data update")
-        updateDataTexture(data: pendingData.data, nx: pendingData.nx, ny: pendingData.ny, 
-                        scale: pendingData.scale, offset: pendingData.offset, 
-                        missing: pendingData.missing, scaleType: pendingData.scaleType)
-        pendingDataUpdate = nil
-    }
-}
-    internal func internalRender(_ parameters: CustomLayerRenderParameters, mtlCommandBuffer: MTLCommandBuffer, mtlRenderPassDescriptor: MTLRenderPassDescriptor) {
-        guard isVisible,
-            let pipeline = pipelineState,
-            let vertices = vertexBuffer,
-            let indices = indexBuffer,
-            let dataTex = dataTexture,
-            let colormapTex = colormapTexture,
-            indexCount > 0,
-            let encoder = mtlCommandBuffer.makeRenderCommandEncoder(descriptor: mtlRenderPassDescriptor) else {
-            
-            // OPTIMIZATION: Change log message to be more informative and less alarming.
-            // This is an expected state during initial load.
-            if (pipelineState != nil) { // Only log if Metal is set up
-                 print("🟡 [GridRenderLayer] internalRender: Waiting for all resources to be ready before drawing.")
-            }
-            return
-        }
-        
-        print("✅ [GridRenderLayer] Past guards, about to render!")
-        print("   🎨 About to draw \(indexCount) indices (\(indexCount/3) triangles)")
-        
-        let needsLinear = (uniforms.smoothing != 0)
-        if isDataSamplerLinear != needsLinear {
-            let samplerDesc = MTLSamplerDescriptor()
-            samplerDesc.minFilter = needsLinear ? .linear : .nearest
-            samplerDesc.magFilter = needsLinear ? .linear : .nearest
-            dataSamplerState = device.makeSamplerState(descriptor: samplerDesc)
-            isDataSamplerLinear = needsLinear
-        }
-        
-        // Apply zoom scale transformation
-        let zoom = parameters.zoom
-        let scale = Float(pow(2.0, zoom))
-        
-        let matrixArray = parameters.projectionMatrix
-        var floatArray = matrixArray.map { $0.floatValue }
-        
-        floatArray[0] *= scale  // X scale
-        floatArray[1] *= scale  // X rotation
-        floatArray[4] *= scale  // Y rotation  
-        floatArray[5] *= scale 
-        
-        let mvp = matrix_float4x4(
-            SIMD4<Float>(floatArray[0], floatArray[1], floatArray[2], floatArray[3]),
-            SIMD4<Float>(floatArray[4], floatArray[5], floatArray[6], floatArray[7]),
-            SIMD4<Float>(floatArray[8], floatArray[9], floatArray[10], floatArray[11]),
-            SIMD4<Float>(floatArray[12], floatArray[13], floatArray[14], floatArray[15])
-        )
-        
-        print("   📐 MVP matrix after scaling: \(mvp)")
-        print("   📍 Zoom: \(zoom), Scale factor: \(scale)")
-        
-        // Add depth state
-        let depthStencilDescriptor = MTLDepthStencilDescriptor()
-        depthStencilDescriptor.depthCompareFunction = .always
-        depthStencilDescriptor.isDepthWriteEnabled = false
-        let depthStencilState = device.makeDepthStencilState(descriptor: depthStencilDescriptor)
-        
-        encoder.setRenderPipelineState(pipeline)
-        encoder.setDepthStencilState(depthStencilState!)
-        encoder.setVertexBuffer(vertices, offset: 0, index: 0)
-        encoder.setVertexBytes([mvp], length: MemoryLayout<matrix_float4x4>.size, index: 1)
-        
-        var mutableUniforms = uniforms
-        encoder.setFragmentBytes(&mutableUniforms, length: MemoryLayout<FragmentUniforms>.stride, index: 0)
-        encoder.setFragmentTexture(dataTex, index: 0)
-        encoder.setFragmentTexture(colormapTex, index: 1)
-        encoder.setFragmentSamplerState(dataSamplerState, index: 0)
-        encoder.setFragmentSamplerState(colormapSamplerState, index: 1)
-        
-        print("   🎨 Drawing indexed primitives now...")
-        encoder.drawIndexedPrimitives(type: .triangle, indexCount: indexCount, indexType: .uint16, indexBuffer: indices, indexBufferOffset: 0)
-        print("   ✅ Draw call completed")
-        
-        encoder.endEncoding()
-        print("   ✅ Encoder ended")
-    }
-
-    internal func internalRenderingWillEnd() {
-        print("🟢 [GridRenderLayer] renderingWillEnd called")
-        vertexBuffer = nil
-        indexBuffer = nil
-        dataTexture = nil
-        colormapTexture = nil
-    }
-}