@aguacerowx/react-native 0.0.17 → 0.0.20

package/lib/commonjs/android/src/main/res/raw/fragment_shader.glsl

@@ -5,94 +5,148 @@ varying vec2 v_texCoord;
 
 uniform sampler2D u_data_texture;
 uniform sampler2D u_colormap_texture;
+
+// Data parameters
 uniform float u_scale;
 uniform float u_offset;
 uniform float u_missing_quantized;
+uniform int u_scale_type; // 0 for linear, 1 for sqrt
+
+// Style parameters
 uniform float u_opacity;
 uniform vec2 u_data_range;
+
+// Rendering parameters
 uniform vec2 u_texture_size;
 uniform int u_smoothing;
+uniform int u_is_ptype; // ADDED: Flag for ptype variables
 
-// --- START OF FIX: Add the new uniform ---
-uniform int u_scale_type; // 0 for linear, 1 for sqrt
-// --- END OF FIX ---
-
-// Custom bilinear filtering that respects NaN boundaries
-float sampleDataTextureSmooth(vec2 uv) {
-    float missing_in_texture_range = u_missing_quantized + 128.0;
-
-    // Get the four corner samples for bilinear interpolation
-    vec2 pixel_coord = uv * u_texture_size;
-    vec2 pixel_floor = floor(pixel_coord - 0.5) + 0.5;
-    vec2 f = pixel_coord - pixel_floor;
-
-    // Sample the 2x2 grid
-    float s00 = texture2D(u_data_texture, (pixel_floor + vec2(0.0, 0.0)) / u_texture_size).a * 255.0;
-    float s10 = texture2D(u_data_texture, (pixel_floor + vec2(1.0, 0.0)) / u_texture_size).a * 255.0;
-    float s01 = texture2D(u_data_texture, (pixel_floor + vec2(0.0, 1.0)) / u_texture_size).a * 255.0;
-    float s11 = texture2D(u_data_texture, (pixel_floor + vec2(1.0, 1.0)) / u_texture_size).a * 255.0;
-
-    // Check which samples are valid (not NaN)
-    bool valid00 = abs(s00 - missing_in_texture_range) >= 0.5;
-    bool valid10 = abs(s10 - missing_in_texture_range) >= 0.5;
-    bool valid01 = abs(s01 - missing_in_texture_range) >= 0.5;
-    bool valid11 = abs(s11 - missing_in_texture_range) >= 0.5;
-
-    // If ANY sample is NaN, return NaN (this pixel is on an edge)
-    if (!valid00 || !valid10 || !valid01 || !valid11) {
-        return missing_in_texture_range;
+// --- HELPER FUNCTIONS ---
+
+// Dequantizes a signed value (-127 to 127) into a physical value
+float dequantize_val(float q_val) {
+    if (abs(q_val - u_missing_quantized) < 0.5) {
+        return -9999.0;
+    }
+    float intermediate = q_val * u_scale + u_offset;
+    if (u_scale_type == 1) { // 1 = sqrt
+        return intermediate * abs(intermediate);
     }
+    return intermediate;
+}
 
-    // All samples are valid - do proper bilinear interpolation
-    float s0 = mix(s00, s10, f.x);
-    float s1 = mix(s01, s11, f.x);
-    return mix(s0, s1, f.y);
+// Samples texture, converts 0-255 to signed -128-127 range.
+// Returns a quantized value, or a large positive sentinel for missing data.
+float get_value(vec2 coord) {
+    float value_0_to_255 = texture2D(u_data_texture, coord).a * 255.0;
+    float val = value_0_to_255 - 128.0;
+    float missing_in_texture_range_0_255 = u_missing_quantized + 128.0;
+    if (abs(value_0_to_255 - missing_in_texture_range_0_255) < 0.5) {
+        return 99999.0; // Sentinel for "missing"
+    }
+    return val;
 }
 
-// Simple nearest-neighbor sampling
-float sampleDataTextureNearest(vec2 uv) {
-    // Snap to exact pixel center
-    vec2 snapped_coord = floor(uv * u_texture_size + 0.5) / u_texture_size;
-    return texture2D(u_data_texture, snapped_coord).a * 255.0;
+// Maps a physical value to a precipitation type category
+float get_ptype_from_physical(float val) {
+    if (val < 0.0) return -1.0;   // Missing/Invalid
+    if (val < 100.0) return 0.0; // Rain
+    if (val < 200.0) return 1.0; // Mix
+    if (val < 300.0) return 2.0; // Snow
+    return 3.0;                  // Pellets
 }
 
+
 void main() {
-    // Choose sampling method based on smoothing setting
-    float value_in_texture;
-    if (u_smoothing == 1) {
-        value_in_texture = sampleDataTextureSmooth(v_texCoord);
-    } else {
-        value_in_texture = sampleDataTextureNearest(v_texCoord);
+    float raw_value;
+    float total_weight = 1.0; // Used for alpha feathering at data edges
+
+    if (u_smoothing == 0) { // Nearest neighbor
+        float quantized_value = get_value(v_texCoord);
+        if (quantized_value >= 99999.0) {
+             discard;
+        }
+        raw_value = dequantize_val(quantized_value);
+
+    } else { // Bilinear interpolation
+        vec2 texel_size = 1.0 / u_texture_size;
+        vec2 tex_coord_in_texels = v_texCoord * u_texture_size;
+        vec2 bl_texel_index = floor(tex_coord_in_texels - 0.5);
+        vec2 f = fract(tex_coord_in_texels - 0.5); // Interpolation factors
+
+        // Coordinates of the 4 neighboring texels
+        vec2 v00_coord = (bl_texel_index + vec2(0.5, 0.5)) * texel_size;
+        vec2 v10_coord = (bl_texel_index + vec2(1.5, 0.5)) * texel_size;
+        vec2 v01_coord = (bl_texel_index + vec2(0.5, 1.5)) * texel_size;
+        vec2 v11_coord = (bl_texel_index + vec2(1.5, 1.5)) * texel_size;
+
+        if (u_is_ptype == 1) {
+            // --- PTYPE-SPECIFIC INTERPOLATION ---
+            float v00 = dequantize_val(get_value(v00_coord));
+            float v10 = dequantize_val(get_value(v10_coord));
+            float v01 = dequantize_val(get_value(v01_coord));
+            float v11 = dequantize_val(get_value(v11_coord));
+
+            float p00 = get_ptype_from_physical(v00);
+            float p10 = get_ptype_from_physical(v10);
+            float p01 = get_ptype_from_physical(v01);
+            float p11 = get_ptype_from_physical(v11);
+
+            // Determine the dominant precipitation type for this pixel
+            float dominant_ptype = -1.0;
+            if (p00 != -1.0) dominant_ptype = p00;
+            else if (p10 != -1.0) dominant_ptype = p10;
+            else if (p01 != -1.0) dominant_ptype = p01;
+            else if (p11 != -1.0) dominant_ptype = p11;
+
+            if (dominant_ptype == -1.0) discard;
+
+            // Interpolate ONLY the values that match the dominant ptype
+            float total_value = 0.0;
+            total_weight = 0.0;
+            if (p00 == dominant_ptype) { float w = (1.0-f.x)*(1.0-f.y); total_value+=v00*w; total_weight+=w; }
+            if (p10 == dominant_ptype) { float w = f.x*(1.0-f.y);       total_value+=v10*w; total_weight+=w; }
+            if (p01 == dominant_ptype) { float w = (1.0-f.x)*f.y;       total_value+=v01*w; total_weight+=w; }
+            if (p11 == dominant_ptype) { float w = f.x*f.y;             total_value+=v11*w; total_weight+=w; }
+
+            if (total_weight <= 0.0) discard;
+            raw_value = total_value / total_weight;
+
+            // Force full alpha to prevent dark borders between ptype regions
+            total_weight = 1.0;
+
+        } else {
+            // --- STANDARD INTERPOLATION ---
+            float v00_q = get_value(v00_coord);
+            float v10_q = get_value(v10_coord);
+            float v01_q = get_value(v01_coord);
+            float v11_q = get_value(v11_coord);
+
+            float total_value_q = 0.0;
+            total_weight = 0.0;
+            if (v00_q < 99999.0) { float w = (1.0-f.x)*(1.0-f.y); total_value_q+=v00_q*w; total_weight+=w; }
+            if (v10_q < 99999.0) { float w = f.x*(1.0-f.y);       total_value_q+=v10_q*w; total_weight+=w; }
+            if (v01_q < 99999.0) { float w = (1.0-f.x)*f.y;       total_value_q+=v01_q*w; total_weight+=w; }
+            if (v11_q < 99999.0) { float w = f.x*f.y;             total_value_q+=v11_q*w; total_weight+=w; }
+
+            if (total_weight <= 0.0) discard;
+            raw_value = dequantize_val(total_value_q / total_weight);
+        }
     }
 
-    float missing_in_texture_range = u_missing_quantized + 128.0;
+    // --- COMMON FINAL STEPS ---
 
-    // Check if this pixel is a predefined missing value
-    if (abs(value_in_texture - missing_in_texture_range) < 0.5) {
+    if (raw_value < u_data_range.x) {
         discard;
     }
 
-    // Step 1: Standard linear dequantization
-    float quantized_value = value_in_texture - 128.0;
-    float intermediate_value = quantized_value * u_scale + u_offset;
-    float raw_value = intermediate_value; // Default to linear
-
-    // Step 2: Apply non-linear inverse scaling if specified
-    if (u_scale_type == 1) { // 1 represents 'sqrt'
-        // Square the intermediate value while preserving its sign
-        raw_value = intermediate_value * abs(intermediate_value);
-    }
-
-    // If the data is below the specified minimum range, make it invisible.
-    if (raw_value < u_data_range.x) {
+    float colormap_coord = clamp((raw_value - u_data_range.x) / (u_data_range.y - u_data_range.x), 0.0, 1.0);
+    vec4 color = texture2D(u_colormap_texture, vec2(colormap_coord, 0.5));
+    
+    if (color.a < 0.1) {
         discard;
     }
 
-    // Normalize the value to a 0-1 coordinate for colormap lookup
-    float colormap_coord = (raw_value - u_data_range.x) / (u_data_range.y - u_data_range.x);
-    colormap_coord = clamp(colormap_coord, 0.0, 1.0);
-
-    // Sample the colormap and apply opacity
-    vec4 color = texture2D(u_colormap_texture, vec2(colormap_coord, 0.5));
-    gl_FragColor = vec4(color.rgb, color.a * u_opacity);
+    float final_alpha = color.a * u_opacity * total_weight;
+    gl_FragColor = vec4(color.rgb * final_alpha, final_alpha);
 }

package/lib/commonjs/ios/GridRenderLayer.swift

@@ -783,99 +783,120 @@ public class GridRenderLayer: NSObject {
     
     // 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)
-        guard let shadersUrl = bundle.url(forResource: "AguaceroMetalShaders", withExtension: "bundle") else {
-            print("❌ [GridRenderLayer] Could not find shader bundle")
-            return
-        }
-        guard let metalBundle = Bundle(url: shadersUrl) else {
-            print("❌ [GridRenderLayer] Could not load shader bundle")
-            return
-        }
-        guard let defaultLibrary = try? metalDevice.makeDefaultLibrary(bundle: metalBundle) else {
-            print("❌ [GridRenderLayer] Could not create Metal library")
-            return
-        }
-        
-        let vertexFunction = defaultLibrary.makeFunction(name: "vertex_main")
-        let fragmentFunction = defaultLibrary.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  // ADD THIS LINE
-        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 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,