@aguacerowx/react-native 0.0.35 → 0.0.37

package/lib/module/ios/GridRenderLayer.swift

@@ -66,6 +66,7 @@ public class GridRenderLayer: NSObject {
     )
     private var isVisible = false
     private var pendingActiveFrameKey: String?
+    private var lastRequestedCacheKey: String?
     private let inspectorCache = InspectorDataCache.shared
     private struct FrameMetadata {
         let scale: Float
@@ -77,8 +78,10 @@ public class GridRenderLayer: NSObject {
         let filePath: String
         let originalScale: Float
         let originalOffset: Float
+        var processedData: Data? // Cache the final transformed bytes
     }
     private var frameCache: [String: FrameMetadata] = [:]
+    private let frameCacheQueue = DispatchQueue(label: "com.aguacero.frame-cache-queue")
     private let frameProcessingQueue = DispatchQueue(label: "com.aguacero.frame-processing", qos: .userInitiated, attributes: .concurrent)
     private let semaphore = DispatchSemaphore(value: 8)  
 
@@ -177,8 +180,12 @@ public class GridRenderLayer: NSObject {
 
     @objc(clearGpuCache)
     public func clearGpuCache() {
+        print("ℹ️ [GridRenderLayer] clearGpuCache called")
         frameProcessingQueue.async { [weak self] in
-            self?.frameCache.removeAll()
+            guard let self = self else { return }
+            self.frameCacheQueue.async {
+                self.frameCache.removeAll()
+            }
         }
     }
 
@@ -210,24 +217,29 @@ public class GridRenderLayer: NSObject {
         return texture
     }
 
-    private func updateInspectorCache(filePath: String, nx: Int, ny: Int, scale: Float, offset: Float, missing: Float, scaleType: Int) {
+    private func updateInspectorCache(filePath: String, reconstructedData: Data?, nx: Int, ny: Int, scale: Float, offset: Float, missing: Float, scaleType: Int) {
         // This is now called from frameProcessingQueue, so we can do the work synchronously
-        guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)) else {
-            print("❌ [Inspector] FATAL: Failed to read file data from path.")
-            self.inspectorCache.clear()
-            return
-        }
         
-        guard let decompressedDeltas = self.decompressZstd(data: fileData) else {
-            print("❌ [Inspector] FATAL: Failed to decompress Zstd data.")
-            self.inspectorCache.clear()
-            return
+        let finalReconstructedData: Data
+        if let data = reconstructedData {
+            finalReconstructedData = data
+        } else {
+            guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)) else {
+                print("❌ [Inspector] FATAL: Failed to read file data from path.")
+                self.inspectorCache.clear()
+                return
+            }
+            
+            guard let decompressedDeltas = self.decompressZstd(data: fileData) else {
+                print("❌ [Inspector] FATAL: Failed to decompress Zstd data.")
+                self.inspectorCache.clear()
+                return
+            }
+            finalReconstructedData = self.reconstructData(decompressedDeltas: decompressedDeltas)
         }
-
-        let reconstructedData = self.reconstructData(decompressedDeltas: decompressedDeltas)
         
         self.inspectorCache.update(
-            data: reconstructedData,
+            data: finalReconstructedData,
             nx: nx,
             ny: ny,
             scale: scale,
@@ -239,23 +251,78 @@ public class GridRenderLayer: NSObject {
 
     @objc(setActiveFrameWithCacheKey:)
     public func setActiveFrame(cacheKey: String) {
-        if let frame = frameCache[cacheKey] {
+        setActiveFrameInternal(cacheKey: cacheKey, isExternalRequest: true)
+    }
+
+    private func setActiveFrameInternal(cacheKey: String, isExternalRequest: Bool) {
+        if isExternalRequest {
+            lastRequestedCacheKey = cacheKey
+        } else {
+            // If it's an internal retry (from primeGpuCache), 
+            // only proceed if it's still the frame the user wants.
+            if lastRequestedCacheKey != cacheKey {
+                return
+            }
+        }
+        
+        var frameResult: FrameMetadata?
+        frameCacheQueue.sync {
+            frameResult = frameCache[cacheKey]
+        }
+
+        if let frame = frameResult {
             frameProcessingQueue.async { [weak self] in
                 guard let self = self else { return }
                 
-                guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: frame.filePath)),
-                    let finalTextureBytes = self.processRawData(fileData: fileData)
-                else {
-                    print("❌ [GridRenderLayer] Failed to load texture data for active frame")
-                    return
+                // Check if this frame is still the one we want
+                if self.lastRequestedCacheKey != cacheKey { return }
+                
+                let finalTextureBytes: Data
+                if let cachedData = frame.processedData {
+                    finalTextureBytes = cachedData
+                } else {
+                    guard let fileData = try? Data(contentsOf: URL(fileURLWithPath: frame.filePath)),
+                          let processed = self.processRawData(fileData: fileData)
+                    else {
+                        print("❌ [GridRenderLayer] Failed to load/process data for: \(cacheKey)")
+                        return
+                    }
+                    finalTextureBytes = processed
+                    self.frameCacheQueue.async {
+                        self.frameCache[cacheKey]?.processedData = finalTextureBytes
+                    }
                 }
                 
+                // Final check before jumping to main thread
+                if self.lastRequestedCacheKey != cacheKey { return }
+                
                 DispatchQueue.main.async { [weak self] in
-                    guard let self = self,
-                        let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: Int(frame.nx), ny: Int(frame.ny))
-                    else { return }
+                    guard let self = self else { return }
+                    
+                    // Final check on main thread
+                    if self.lastRequestedCacheKey != cacheKey { 
+                        return 
+                    }
+                    
+                    let nx = Int(frame.nx)
+                    let ny = Int(frame.ny)
+                    
+                    if let existingTexture = self.dataTexture,
+                       existingTexture.width == nx,
+                       existingTexture.height == ny {
+                        existingTexture.replace(
+                            region: MTLRegionMake2D(0, 0, nx, ny),
+                            mipmapLevel: 0,
+                            withBytes: (finalTextureBytes as NSData).bytes,
+                            bytesPerRow: nx
+                        )
+                    } else {
+                        guard let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nx, ny: ny) else {
+                            return
+                        }
+                        self.dataTexture = texture
+                    }
                     
-                    self.dataTexture = texture
                     self.uniforms.scale = frame.scale
                     self.uniforms.offset = frame.offset
                     self.uniforms.missingQuantized = frame.missing
@@ -266,12 +333,12 @@ public class GridRenderLayer: NSObject {
                     self.pendingActiveFrameKey = nil
                     NotificationCenter.default.post(name: NSNotification.Name("TriggerMapRepaint"), object: nil)
                     
-                    // Update inspector cache
                     self.frameProcessingQueue.async { [weak self] in
                         self?.updateInspectorCache(
                             filePath: frame.filePath,
-                            nx: Int(frame.nx),
-                            ny: Int(frame.ny),
+                            reconstructedData: nil,
+                            nx: nx,
+                            ny: ny,
                             scale: frame.scale,
                             offset: frame.offset,
                             missing: frame.missing,
@@ -280,16 +347,16 @@ public class GridRenderLayer: NSObject {
                     }
                 }
             }
-
         } else {
-            print("⚠️ [GridRenderLayer] setActiveFrame cache MISS for key: \(cacheKey). Will apply when primed.")
-            self.pendingActiveFrameKey = cacheKey
-            self.isVisible = false
+            if isExternalRequest {
+                self.pendingActiveFrameKey = cacheKey
+            }
         }
     }
 
     @objc(primeGpuCacheWithFrameInfo:)
     public func primeGpuCache(frameInfo: [String: [String: Any]]) {
+        print("ℹ️ [GridRenderLayer] primeGpuCache called with \(frameInfo.count) items")
         let group = DispatchGroup()
 
         for (cacheKey, info) in frameInfo {
@@ -307,7 +374,13 @@ public class GridRenderLayer: NSObject {
                     group.leave()
                 }
 
-                if self.frameCache[cacheKey] != nil { return }
+                let alreadyExists: Bool = self.frameCacheQueue.sync {
+                    return self.frameCache[cacheKey] != nil
+                }
+                if alreadyExists {
+                    print("ℹ️ [GridRenderLayer] Frame already cached: \(cacheKey)")
+                    return
+                }
                 
                 guard let filePath = info["filePath"] as? String,
                     let nx = info["nx"] as? NSNumber,
@@ -319,7 +392,7 @@ public class GridRenderLayer: NSObject {
                     let originalScale = info["originalScale"] as? NSNumber,
                     let originalOffset = info["originalOffset"] as? NSNumber
                 else {
-                    print("❌ [GridRenderLayer] Skipping prime for \(cacheKey), missing data.")
+                    print("❌ [GridRenderLayer] Skipping prime for \(cacheKey), missing data. Info keys: \(info.keys)")
                     return
                 }
                 
@@ -332,13 +405,35 @@ public class GridRenderLayer: NSObject {
                     ny: ny.floatValue,
                     filePath: filePath,
                     originalScale: originalScale.floatValue,
-                    originalOffset: originalOffset.floatValue
+                    originalOffset: originalOffset.floatValue,
+                    processedData: nil
                 )
-                self.frameCache[cacheKey] = metadata
-
-                if let pendingKey = self.pendingActiveFrameKey, pendingKey == cacheKey {
-                    DispatchQueue.main.async {
-                        self.setActiveFrame(cacheKey: pendingKey)
+                
+                // Add to cache immediately so setActiveFrame can see it
+                self.frameCacheQueue.async {
+                    self.frameCache[cacheKey] = metadata
+                    print("ℹ️ [GridRenderLayer] Primed cache key: \(cacheKey)")
+                }
+                
+                // PERFORMANCE: Pre-process the data in the background
+                if let fileData = try? Data(contentsOf: URL(fileURLWithPath: filePath)) {
+                    if let processedData = self.processRawData(fileData: fileData) {
+                        self.frameCacheQueue.async {
+                            self.frameCache[cacheKey]?.processedData = processedData
+                        }
+                    }
+                }
+                
+                DispatchQueue.main.async {
+                    if let pendingKey = self.pendingActiveFrameKey, pendingKey == cacheKey {
+                        if self.lastRequestedCacheKey == cacheKey {
+                            print("ℹ️ [GridRenderLayer] Applying pending frame: \(cacheKey)")
+                            self.setActiveFrameInternal(cacheKey: pendingKey, isExternalRequest: false)
+                        }
+                        // Clear pending key if it matches what we just processed
+                        if self.pendingActiveFrameKey == cacheKey {
+                            self.pendingActiveFrameKey = nil
+                        }
                     }
                 }
             }
@@ -359,12 +454,30 @@ public class GridRenderLayer: NSObject {
             }
 
             DispatchQueue.main.async { [weak self] in
-                guard let self = self, let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nx.intValue, ny: ny.intValue) else {
-                    print("❌ [GridRenderLayer] FAST LANE: Failed to create texture")
-                    return
+                guard let self = self else { return }
+                
+                let nxInt = nx.intValue
+                let nyInt = ny.intValue
+
+                // REUSE TEXTURE if dimensions match
+                if let existingTexture = self.dataTexture,
+                   existingTexture.width == nxInt,
+                   existingTexture.height == nyInt {
+                    existingTexture.replace(
+                        region: MTLRegionMake2D(0, 0, nxInt, nyInt),
+                        mipmapLevel: 0,
+                        withBytes: (finalTextureBytes as NSData).bytes,
+                        bytesPerRow: nxInt
+                    )
+                } else {
+                    // Create new texture only if needed
+                    guard let texture = self.createTextureFromBytes(bytes: finalTextureBytes, nx: nxInt, ny: nyInt) else {
+                        print("❌ [GridRenderLayer] FAST LANE: Failed to create texture")
+                        return
+                    }
+                    self.dataTexture = texture
                 }
                 
-                self.dataTexture = texture
                 self.uniforms.scale = scale.floatValue
                 self.uniforms.offset = offset.floatValue
                 self.uniforms.missingQuantized = missing.floatValue
@@ -376,6 +489,7 @@ public class GridRenderLayer: NSObject {
 
                 self.updateInspectorCache(
                     filePath: filePath,
+                    reconstructedData: nil,
                     nx: nx.intValue,
                     ny: ny.intValue,
                     scale: scale.floatValue,
@@ -799,19 +913,35 @@ internal func internalRenderingWillStart(_ metalDevice: MTLDevice, colorPixelFor
     #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) {
-        defaultLibrary = library
+    var defaultLibrary: MTLLibrary?
+    
+    // 1. Look in the main bundle level
+    if let metallibUrl = bundle.url(forResource: metallibName, withExtension: "metallib") {
+        print("ℹ️ [GridRenderLayer] Found pre-compiled shaders at: \(metallibUrl.lastPathComponent)")
+        defaultLibrary = try? metalDevice.makeLibrary(URL: metallibUrl)
     }
-    // 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) {
-        defaultLibrary = library
+    
+    // 2. Fall back to compiled-shaders subdirectory
+    if defaultLibrary == nil {
+        if let metallibUrl = bundle.url(forResource: metallibName, withExtension: "metallib", subdirectory: "compiled-shaders") {
+            print("ℹ️ [GridRenderLayer] Found pre-compiled shaders in subdirectory: \(metallibUrl.lastPathComponent)")
+            defaultLibrary = try? metalDevice.makeLibrary(URL: metallibUrl)
+        }
     }
+
+    // 3. Fall back to compiling from .metal source (for development with npm link)
+    if defaultLibrary == nil {
+        if let metalUrl = bundle.url(forResource: "Shaders", withExtension: "metal") {
+            print("⚠️ [GridRenderLayer] Pre-compiled shaders not found. Compiling from source: \(metalUrl.lastPathComponent)")
+            if let source = try? String(contentsOf: metalUrl),
+               let library = try? metalDevice.makeLibrary(source: source, options: nil) {
+                defaultLibrary = library
+            }
+        }
+    }
+
     // Neither worked
-    else {
+    if defaultLibrary == nil {
         print("❌ [GridRenderLayer] Could not find or compile Metal shaders")
         print("   Bundle path: \(bundle.bundlePath)")
         return
@@ -967,7 +1097,9 @@ internal func internalRenderingWillStart(_ metalDevice: MTLDevice, colorPixelFor
         print("🔴 [GridRenderLayer] deinit called for layer: \(id)")
         
         // Clean up all resources
-        frameCache.removeAll()
+        frameCacheQueue.sync {
+            frameCache.removeAll()
+        }
         vertexBuffer = nil
         indexBuffer = nil
         dataTexture = nil
@@ -983,10 +1115,11 @@ internal func internalRenderingWillStart(_ metalDevice: MTLDevice, colorPixelFor
     }
 
     internal func internalRenderingWillEnd() {
-        vertexBuffer = nil
-        indexBuffer = nil
-        dataTexture = nil
-        colormapTexture = nil
+        // DO NOT clear these here, otherwise the layer disappears during map transitions/resizing
+        // vertexBuffer = nil
+        // indexBuffer = nil
+        // dataTexture = nil
+        // colormapTexture = nil
     }
 }
 

package/lib/module/ios/GridRenderLayerBridge.swift

@@ -34,4 +34,12 @@ import Foundation
             return false
         }
     }
+
+    @objc public static func removeCustomLayer(from mapView: MapView, layerId: String) {
+        do {
+            try mapView.mapboxMap.removeLayer(withId: layerId)
+        } catch {
+            print("❌ [GridRenderLayerBridge] Failed to remove layer \(layerId): \(error)")
+        }
+    }
 }

package/lib/module/ios/GridRenderLayerView.m

@@ -178,23 +178,7 @@
 
 - (void)removeFromSuperview {
     if (self.mapView && self.isLayerAdded) {
-        id mapboxMap = [self.mapView valueForKey:@"mapboxMap"];
-        id style = [mapboxMap valueForKey:@"style"];
-        
-        SEL removeLayerSelector = NSSelectorFromString(@"removeStyleLayerWithIdentifier:completion:");
-        if ([style respondsToSelector:removeLayerSelector]) {
-            NSMethodSignature *signature = [style methodSignatureForSelector:removeLayerSelector];
-            NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
-            [invocation setTarget:style];
-            [invocation setSelector:removeLayerSelector];
-            
-            NSString *layerId = self.layerId;
-            [invocation setArgument:&layerId atIndex:2];
-            
-            id nilCompletion = nil;
-            [invocation setArgument:&nilCompletion atIndex:3];
-            [invocation invoke];
-        }
+        [GridRenderLayerBridge removeCustomLayerFrom:self.mapView layerId:self.layerId];
     }
     [super removeFromSuperview];
 }

package/lib/module/ios/Shaders.metal

@@ -68,21 +68,13 @@ float get_value(texture2d<float, access::sample> dataTexture, sampler dataSample
 // Maps a physical value to a precipitation type category
 float get_ptype_from_physical(float val, constant FragmentUniforms &uniforms) {  // ADD uniforms parameter
     if (val < 0.0) return -1.0;
-    
-    if (uniforms.isMRMS == 1) {  // ADD THIS BRANCH
-        // MRMS: 0-100 rain, 100-200 snow, 200-300 freezing rain
-        if (val < 100.0) return 0.0;
-        if (val < 200.0) return 1.0;
-        if (val < 300.0) return 2.0;
-        return -1.0;
-    } else {
-        // Models: 0-100 rain, 100-200 snow, 200-300 freezing rain, 300-400 ice pellets
-        if (val < 100.0) return 0.0;
-        if (val < 200.0) return 1.0;
-        if (val < 300.0) return 2.0;
-        if (val < 400.0) return 3.0;
-        return -1.0;
-    }
+
+    // Models: 0-100 rain, 100-200 snow, 200-300 freezing rain, 300-400 ice pellets
+    if (val < 100.0) return 0.0;
+    if (val < 200.0) return 1.0;
+    if (val < 300.0) return 2.0;
+    if (val < 400.0) return 3.0;
+    return -1.0;
 }
 
 // --- Main Fragment Shader ---