@aguacerowx/react-native 0.0.33 → 0.0.35

package/lib/commonjs/android/build/intermediates/packaged_res/debug/packageDebugResources/raw/fragment_shader.glsl

@@ -91,7 +91,6 @@ void main() {
         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));
@@ -102,31 +101,59 @@ void main() {
             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;
+            // Calculate geometric weights
+            float w00 = (1.0 - f.x) * (1.0 - f.y);
+            float w10 = f.x * (1.0 - f.y);
+            float w01 = (1.0 - f.x) * f.y;
+            float w11 = f.x * f.y;
+
+            // 1. Calculate 'smoothing_weight' (The Raw Alpha)
+            // This is the sum of valid neighbor weights.
+            float smoothing_weight = 0.0;
+            if (p00 >= 0.0) smoothing_weight += w00;
+            if (p10 >= 0.0) smoothing_weight += w10;
+            if (p01 >= 0.0) smoothing_weight += w01;
+            if (p11 >= 0.0) smoothing_weight += w11;
+
+            if (smoothing_weight <= 0.0) discard;
+
+            // 2. Voting Logic for Color (The "Winning" Type)
+            // This preserves the sharp internal borders you liked.
+            float weight_type_0 = 0.0;
+            float weight_type_1 = 0.0;
+            float weight_type_2 = 0.0;
+            float weight_type_3 = 0.0;
+
+            if (p00 >= 0.0) { int t = int(p00); if(t==0) weight_type_0+=w00; else if(t==1) weight_type_1+=w00; else if(t==2) weight_type_2+=w00; else if(t==3) weight_type_3+=w00; }
+            if (p10 >= 0.0) { int t = int(p10); if(t==0) weight_type_0+=w10; else if(t==1) weight_type_1+=w10; else if(t==2) weight_type_2+=w10; else if(t==3) weight_type_3+=w10; }
+            if (p01 >= 0.0) { int t = int(p01); if(t==0) weight_type_0+=w01; else if(t==1) weight_type_1+=w01; else if(t==2) weight_type_2+=w01; else if(t==3) weight_type_3+=w01; }
+            if (p11 >= 0.0) { int t = int(p11); if(t==0) weight_type_0+=w11; else if(t==1) weight_type_1+=w11; else if(t==2) weight_type_2+=w11; else if(t==3) weight_type_3+=w11; }
+
+            float max_w = weight_type_0; float winning_type = 0.0;
+            if (weight_type_1 > max_w) { max_w = weight_type_1; winning_type = 1.0; }
+            if (weight_type_2 > max_w) { max_w = weight_type_2; winning_type = 2.0; }
+            if (weight_type_3 > max_w) { max_w = weight_type_3; winning_type = 3.0; }
+
+            // 3. Average value only among pixels of the winning type
+            float value_sum = 0.0;
+            float value_weight = 0.0;
+
+            if (p00 == winning_type) { value_sum += v00 * w00; value_weight += w00; }
+            if (p10 == winning_type) { value_sum += v10 * w10; value_weight += w10; }
+            if (p01 == winning_type) { value_sum += v01 * w01; value_weight += w01; }
+            if (p11 == winning_type) { value_sum += v11 * w11; value_weight += w11; }
+
+            if (value_weight <= 0.0) discard;
+            
+            raw_value = value_sum / value_weight;
+            
+            // 4. FIX FOR BLURRINESS: Sharpen the Alpha Edge
+            // Instead of a linear 0.0->1.0 fade, we use smoothstep to tighten the edge.
+            // This makes the outer border look like a smooth curve rather than a fuzzy fog.
+            total_weight = smoothstep(0.40, 0.60, smoothing_weight);
 
         } else {
-            // --- STANDARD INTERPOLATION ---
+            // ... (keep your existing standard interpolation else block here) ...
             float v00_q = get_value(v00_coord);
             float v10_q = get_value(v10_coord);
             float v01_q = get_value(v01_coord);
@@ -144,8 +171,6 @@ void main() {
         }
     }
 
-    // --- COMMON FINAL STEPS ---
-
     if (raw_value < u_data_range.x) {
         discard;
     }
@@ -158,5 +183,7 @@ void main() {
     }
 
     float final_alpha = color.a * u_opacity * total_weight;
-    gl_FragColor = vec4(color.rgb * final_alpha, final_alpha);
+    
+    // OUTPUT: Use Straight Alpha (vec4(rgb, alpha)) to prevent black halo artifacts.
+    gl_FragColor = vec4(color.rgb, final_alpha);
 }

package/lib/commonjs/android/src/main/java/com/aguacerowx/reactnative/GridRenderLayer.java

@@ -540,6 +540,12 @@ public class GridRenderLayer implements CustomLayerHost {
             Math.abs(getDouble(gridParams, "lat_first", -1)) == 90.0;
     }
 
+    private boolean isECMWFType(ReadableMap gridParams) {
+        if (gridParams == null) return false;
+        return getDouble(gridParams, "lon_first", -1) == 180.0 &&
+            getDouble(gridParams, "lat_first", -1) == 90.0;
+    }
+
     private void generateGeometryData(ReadableMap gridDefMap, ArrayList<Float> vertices, ArrayList<Short> indices) {
         ReadableMap gridParams = gridDefMap.getMap("grid_params");
         if (gridParams == null) {
@@ -592,7 +598,6 @@ public class GridRenderLayer implements CustomLayerHost {
             return;
         }
 
-        // Step 1: Extract grid parameters
         int nx = gridParams.getInt("nx");
         int ny = gridParams.getInt("ny");
         double lon_first = getDouble(gridParams, "lon_first", 0.0);
@@ -604,34 +609,45 @@ public class GridRenderLayer implements CustomLayerHost {
         double lat_span = lat_last - lat_first;
         boolean isSouthToNorth = lat_span > 0;
 
-        // Step 2: Normalize data longitudes to the -180 to +180 range for consistent placement.
-        double data_lon_first_180 = lon_first > 180 ? lon_first - 360 : lon_first;
-        double data_lon_last_180 = lon_last > 180 ? lon_last - 360 : lon_last;
+        // Step 2: Check if this is ECMWF and normalize longitudes
+        boolean isECMWF = isECMWFType(gridParams);
+        double data_lon_first_180 = lon_first;
+        double data_lon_last_180 = lon_last;
+
+        if (isECMWF) {
+            // Convert ECMWF's 180 to -180 range to -180 to 180
+            data_lon_first_180 = lon_first >= 180 ? lon_first - 360 : lon_first;
+            data_lon_last_180 = lon_last >= 180 ? lon_last - 360 : lon_last;
+        } else {
+            // For GFS and other models
+            data_lon_first_180 = lon_first > 180 ? lon_first - 360 : lon_first;
+            data_lon_last_180 = lon_last > 180 ? lon_last - 360 : lon_last;
+        }
+
         double data_lon_range = data_lon_last_180 - data_lon_first_180;
 
         // Step 3: Define mesh properties
-        int subdivisions_x = 120; // Subdivisions for a single mesh instance
+        int subdivisions_x = 120;
         int subdivisions_y = 60;
-        int verticesPerMesh = (subdivisions_y + 1) * (subdivisions_x + 1);
         int verticesPerRow = subdivisions_x + 1;
         final double TILE_SIZE = 512.0;
 
-        // Step 4: Generate three separate, non-connected meshes to prevent seam artifacts
+        // Step 4: Generate three separate meshes for wrapping
         for (int world_copy = -1; world_copy <= 1; world_copy++) {
-            short vertexStartIndex = (short) (vertices.size() / 4); // 4 floats per vertex (x,y,u,v)
+            short vertexStartIndex = (short) (vertices.size() / 4);
             double lon_offset = world_copy * 360.0;
 
-            // Generate vertices for this specific world copy
+            // Generate vertices for this world copy
             for (int row = 0; row <= subdivisions_y; row++) {
                 for (int col = 0; col <= subdivisions_x; col++) {
                     float v_interp = (float) row / subdivisions_y;
                     float u_interp = (float) col / subdivisions_x;
 
-                    // Vertex position is interpolated across the data's native bounds, then offset for the world copy
+                    // Vertex position interpolated across data's native bounds
                     double vertex_lon = data_lon_first_180 + (u_interp * data_lon_range);
                     double vertex_lat = lat_first + (v_interp * lat_span);
 
-                    // Convert to map coordinates, adding the world copy offset
+                    // Convert to map coordinates with world copy offset
                     double mercX_normalized = ((vertex_lon + lon_offset) + 180.0) / 360.0;
                     double clampedLat = Math.max(-85.05112878, Math.min(85.05112878, vertex_lat));
                     double sinLatitude = Math.sin(Math.toRadians(clampedLat));
@@ -642,7 +658,7 @@ public class GridRenderLayer implements CustomLayerHost {
                     vertices.add((float) mercX);
                     vertices.add((float) mercY);
 
-                    // Texture coordinates are always a clean 0.0 to 1.0 for each mesh instance
+                    // Texture coordinates: clean 0.0 to 1.0 for each mesh
                     float tex_u = u_interp;
                     float tex_v = isSouthToNorth ? (1.0f - v_interp) : v_interp;
                     
@@ -651,7 +667,7 @@ public class GridRenderLayer implements CustomLayerHost {
                 }
             }
 
-            // Generate indices for this specific world copy, offsetting by the starting index
+            // Generate indices for this world copy
             for (short row = 0; row < subdivisions_y; row++) {
                 for (short col = 0; col < subdivisions_x; col++) {
                     short tl = (short) (vertexStartIndex + row * verticesPerRow + col);
@@ -662,7 +678,7 @@ public class GridRenderLayer implements CustomLayerHost {
                     if (isSouthToNorth) {
                         indices.add(tl); indices.add(bl); indices.add(tr);
                         indices.add(tr); indices.add(bl); indices.add(br);
-                    } else { // North-to-South (MRMS)
+                    } else {
                         indices.add(tl); indices.add(tr); indices.add(bl);
                         indices.add(bl); indices.add(tr); indices.add(br);
                     }

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

@@ -91,7 +91,6 @@ void main() {
         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));
@@ -102,31 +101,59 @@ void main() {
             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;
+            // Calculate geometric weights
+            float w00 = (1.0 - f.x) * (1.0 - f.y);
+            float w10 = f.x * (1.0 - f.y);
+            float w01 = (1.0 - f.x) * f.y;
+            float w11 = f.x * f.y;
+
+            // 1. Calculate 'smoothing_weight' (The Raw Alpha)
+            // This is the sum of valid neighbor weights.
+            float smoothing_weight = 0.0;
+            if (p00 >= 0.0) smoothing_weight += w00;
+            if (p10 >= 0.0) smoothing_weight += w10;
+            if (p01 >= 0.0) smoothing_weight += w01;
+            if (p11 >= 0.0) smoothing_weight += w11;
+
+            if (smoothing_weight <= 0.0) discard;
+
+            // 2. Voting Logic for Color (The "Winning" Type)
+            // This preserves the sharp internal borders you liked.
+            float weight_type_0 = 0.0;
+            float weight_type_1 = 0.0;
+            float weight_type_2 = 0.0;
+            float weight_type_3 = 0.0;
+
+            if (p00 >= 0.0) { int t = int(p00); if(t==0) weight_type_0+=w00; else if(t==1) weight_type_1+=w00; else if(t==2) weight_type_2+=w00; else if(t==3) weight_type_3+=w00; }
+            if (p10 >= 0.0) { int t = int(p10); if(t==0) weight_type_0+=w10; else if(t==1) weight_type_1+=w10; else if(t==2) weight_type_2+=w10; else if(t==3) weight_type_3+=w10; }
+            if (p01 >= 0.0) { int t = int(p01); if(t==0) weight_type_0+=w01; else if(t==1) weight_type_1+=w01; else if(t==2) weight_type_2+=w01; else if(t==3) weight_type_3+=w01; }
+            if (p11 >= 0.0) { int t = int(p11); if(t==0) weight_type_0+=w11; else if(t==1) weight_type_1+=w11; else if(t==2) weight_type_2+=w11; else if(t==3) weight_type_3+=w11; }
+
+            float max_w = weight_type_0; float winning_type = 0.0;
+            if (weight_type_1 > max_w) { max_w = weight_type_1; winning_type = 1.0; }
+            if (weight_type_2 > max_w) { max_w = weight_type_2; winning_type = 2.0; }
+            if (weight_type_3 > max_w) { max_w = weight_type_3; winning_type = 3.0; }
+
+            // 3. Average value only among pixels of the winning type
+            float value_sum = 0.0;
+            float value_weight = 0.0;
+
+            if (p00 == winning_type) { value_sum += v00 * w00; value_weight += w00; }
+            if (p10 == winning_type) { value_sum += v10 * w10; value_weight += w10; }
+            if (p01 == winning_type) { value_sum += v01 * w01; value_weight += w01; }
+            if (p11 == winning_type) { value_sum += v11 * w11; value_weight += w11; }
+
+            if (value_weight <= 0.0) discard;
+            
+            raw_value = value_sum / value_weight;
+            
+            // 4. FIX FOR BLURRINESS: Sharpen the Alpha Edge
+            // Instead of a linear 0.0->1.0 fade, we use smoothstep to tighten the edge.
+            // This makes the outer border look like a smooth curve rather than a fuzzy fog.
+            total_weight = smoothstep(0.40, 0.60, smoothing_weight);
 
         } else {
-            // --- STANDARD INTERPOLATION ---
+            // ... (keep your existing standard interpolation else block here) ...
             float v00_q = get_value(v00_coord);
             float v10_q = get_value(v10_coord);
             float v01_q = get_value(v01_coord);
@@ -144,8 +171,6 @@ void main() {
         }
     }
 
-    // --- COMMON FINAL STEPS ---
-
     if (raw_value < u_data_range.x) {
         discard;
     }
@@ -158,5 +183,7 @@ void main() {
     }
 
     float final_alpha = color.a * u_opacity * total_weight;
-    gl_FragColor = vec4(color.rgb * final_alpha, final_alpha);
+    
+    // OUTPUT: Use Straight Alpha (vec4(rgb, alpha)) to prevent black halo artifacts.
+    gl_FragColor = vec4(color.rgb, final_alpha);
 }

package/lib/commonjs/ios/GridRenderLayer.swift

@@ -695,8 +695,21 @@ public class GridRenderLayer: NSObject {
         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
+        // Check if this is ECMWF and normalize longitudes
+        let isECMWF = isECMWFType(gridParams: gridParams)
+        var data_lon_first_180 = lon_first
+        var data_lon_last_180 = lon_last
+
+        if isECMWF {
+            // Convert ECMWF's 180 to -180 range to -180 to 180
+            data_lon_first_180 = lon_first >= 180 ? lon_first - 360 : lon_first
+            data_lon_last_180 = lon_last >= 180 ? lon_last - 360 : lon_last
+        } else {
+            // For GFS and other models
+            data_lon_first_180 = lon_first > 180 ? lon_first - 360 : lon_first
+            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
@@ -705,7 +718,7 @@ public class GridRenderLayer: NSObject {
         let TILE_SIZE: Double = 512.0
 
         let worldCopies = (data_lon_range > 300) ? [-1, 0, 1] : [0]
-        
+
         for world_copy in worldCopies {
             let vertexStartIndex = UInt16(vertices.count / 4)
             let lon_offset = Double(world_copy) * 360.0
@@ -755,6 +768,11 @@ public class GridRenderLayer: NSObject {
         return (gridParams["lon_first"] as? Double) == 0.0 &&
                abs((gridParams["lat_first"] as? Double) ?? -1) == 90.0
     }
+
+    private func isECMWFType(gridParams: [String: Any]) -> Bool {
+        return (gridParams["lon_first"] as? Double) == 180.0 &&
+            (gridParams["lat_first"] as? Double) == 90.0
+    }
     
     private func lonLatToMercator(lon: Double, lat: Double, tileSize: Double) -> (x: Float, y: Float) {
         let mercX_normalized = (lon + 180.0) / 360.0

package/lib/commonjs/ios/Shaders.metal

@@ -116,7 +116,7 @@ fragment float4 fragment_main(RasterizerData in [[stage_in]],
         float2 v11_coord = (bl_texel_index + float2(1.5, 1.5)) * texel_size;
 
         if (uniforms.isPtype == 1) {
-            // --- PTYPE-SPECIFIC INTERPOLATION (CATEGORICAL) ---
+            // --- ENHANCED PTYPE-SPECIFIC INTERPOLATION ---
             float v00 = dequantize_val(get_value(dataTexture, dataSampler, v00_coord, uniforms), uniforms);
             float v10 = dequantize_val(get_value(dataTexture, dataSampler, v10_coord, uniforms), uniforms);
             float v01 = dequantize_val(get_value(dataTexture, dataSampler, v01_coord, uniforms), uniforms);
@@ -127,25 +127,162 @@ fragment float4 fragment_main(RasterizerData in [[stage_in]],
             float p01 = get_ptype_from_physical(v01, uniforms);
             float p11 = get_ptype_from_physical(v11, uniforms);
 
-            // 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;
+            // Count unique valid precipitation types
+            bool has_type_0 = false;
+            bool has_type_1 = false;
+            bool has_type_2 = false;
+            bool has_type_3 = false;
+            int valid_count = 0;
             
-            if (dominant_ptype == -1.0) discard_fragment();
-
-            // Interpolate ONLY the values that match the dominant ptype
-            float total_value = 0.0;
-            float 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_fragment();
-            raw_value = total_value / total_weight;
+            if (p00 >= 0.0) { 
+                int ptype = int(p00);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p10 >= 0.0) { 
+                int ptype = int(p10);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p01 >= 0.0) { 
+                int ptype = int(p01);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p11 >= 0.0) { 
+                int ptype = int(p11);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            
+            if (valid_count == 0) discard_fragment();
+            
+            // Count how many unique types we have
+            int unique_types = 0;
+            if (has_type_0) unique_types++;
+            if (has_type_1) unique_types++;
+            if (has_type_2) unique_types++;
+            if (has_type_3) unique_types++;
+            
+            if (unique_types == 1) {
+                // ALL SAME TYPE - smooth interpolation across all valid pixels
+                float total_value = 0.0;
+                float total_weight = 0.0;
+                
+                if (p00 >= 0.0) {
+                    float weight = (1.0 - f.x) * (1.0 - f.y);
+                    total_value += v00 * weight;
+                    total_weight += weight;
+                }
+                if (p10 >= 0.0) {
+                    float weight = f.x * (1.0 - f.y);
+                    total_value += v10 * weight;
+                    total_weight += weight;
+                }
+                if (p01 >= 0.0) {
+                    float weight = (1.0 - f.x) * f.y;
+                    total_value += v01 * weight;
+                    total_weight += weight;
+                }
+                if (p11 >= 0.0) {
+                    float weight = f.x * f.y;
+                    total_value += v11 * weight;
+                    total_weight += weight;
+                }
+                
+                if (total_weight <= 0.0) discard_fragment();
+                raw_value = total_value / total_weight;
+                
+            } else {
+                // MULTIPLE TYPES - weighted voting to determine dominant type
+                float type_weight_0 = 0.0;
+                float type_weight_1 = 0.0;
+                float type_weight_2 = 0.0;
+                float type_weight_3 = 0.0;
+                
+                if (p00 >= 0.0) {
+                    float w = (1.0 - f.x) * (1.0 - f.y);
+                    int ptype = int(p00);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p10 >= 0.0) {
+                    float w = f.x * (1.0 - f.y);
+                    int ptype = int(p10);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p01 >= 0.0) {
+                    float w = (1.0 - f.x) * f.y;
+                    int ptype = int(p01);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p11 >= 0.0) {
+                    float w = f.x * f.y;
+                    int ptype = int(p11);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                
+                // Find the type with the highest weight at this pixel location
+                float max_type_weight = 0.0;
+                float winning_type = -1.0;
+                if (type_weight_0 > max_type_weight) { max_type_weight = type_weight_0; winning_type = 0.0; }
+                if (type_weight_1 > max_type_weight) { max_type_weight = type_weight_1; winning_type = 1.0; }
+                if (type_weight_2 > max_type_weight) { max_type_weight = type_weight_2; winning_type = 2.0; }
+                if (type_weight_3 > max_type_weight) { max_type_weight = type_weight_3; winning_type = 3.0; }
+                
+                if (winning_type == -1.0) discard_fragment();
+                
+                // Now smoothly interpolate only among pixels of the winning type
+                float total_value = 0.0;
+                float total_weight = 0.0;
+                
+                if (p00 == winning_type) {
+                    float weight = (1.0 - f.x) * (1.0 - f.y);
+                    total_value += v00 * weight;
+                    total_weight += weight;
+                }
+                if (p10 == winning_type) {
+                    float weight = f.x * (1.0 - f.y);
+                    total_value += v10 * weight;
+                    total_weight += weight;
+                }
+                if (p01 == winning_type) {
+                    float weight = (1.0 - f.x) * f.y;
+                    total_value += v01 * weight;
+                    total_weight += weight;
+                }
+                if (p11 == winning_type) {
+                    float weight = f.x * f.y;
+                    total_value += v11 * weight;
+                    total_weight += weight;
+                }
+                
+                if (total_weight <= 0.0) discard_fragment();
+                raw_value = total_value / total_weight;
+            }
             
             // Force full alpha to prevent dark borders between ptype regions
             alpha_multiplier = 1.0;

package/lib/commonjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/react-native",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "Native weather rendering for React Native",
   "license": "ISC",
   "author": "Michael Barletta",

package/lib/commonjs/src/WeatherLayerManager.js

@@ -726,7 +726,7 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
       run
     } = core.state;
     if (isMRMS) {
-      // --- MRMS LOGIC WITH PRE-LOADING ---
+      // --- MRMS LOGIC (Keep existing logic) ---
       const oldTimestamps = new Set(core.mrmsStatus?.[currentVariable] || []);
       const mrmsStatus = await core.fetchMRMSStatus(true);
       const newTimestamps = mrmsStatus?.[currentVariable] || [];
@@ -736,6 +736,7 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
         core.mrmsStatus = mrmsStatus;
         core._emitStateChange(); // Update UI slider without changing selection
 
+        // ... (Keep your existing preloading logic here) ...
         const {
           corners,
           gridDef
@@ -751,12 +752,7 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
           const y = frameDate.getUTCFullYear(),
             m = (frameDate.getUTCMonth() + 1).toString().padStart(2, '0'),
             d = frameDate.getUTCDate().toString().padStart(2, '0');
-
-          // --- THIS IS THE FIX ---
-          // Changed 'variable' to 'currentVariable'
           const resourcePath = `/grids/mrms/${y}${m}${d}/${frame}/0/${currentVariable}/0`;
-          // --- END FIX ---
-
           const url = `${core.baseGridUrl}${resourcePath}?apiKey=${core.apiKey}`;
           WeatherFrameProcessorModule.processFrame({
             url,
@@ -794,19 +790,10 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
         });
       }
     } else {
-      // --- MODEL LOGIC ---
       const modelStatus = await core.fetchModelStatus(true);
+      core._emitStateChange();
       const latestRun = findLatestModelRun(modelStatus, currentModel);
       if (!latestRun) return;
-      const currentRunKey = `${date}:${run}`;
-      const latestRunKey = `${latestRun.date}:${latestRun.run}`;
-      if (latestRunKey > currentRunKey) {
-        // This preserves the current forecastHour while changing the run
-        await core.setState({
-          date: latestRun.date,
-          run: latestRun.run
-        });
-      }
     }
   }, [core]);
   (0, _react.useEffect)(() => {