@aguacerowx/react-native 0.0.18 → 0.0.20

package/README.md

@@ -25,6 +25,72 @@ $RNMapboxMapsVersion = '~> 11.0' # This enforces Mapbox SDK v11
 use_mapbox_maps!
 ```
 
+### Enable Modular Headers (Required for New Architecture)
+
+If you're using React Native's new architecture (`newArchEnabled: true`), you **must** enable modular headers.
+
+#### For Expo Projects (Recommended)
+
+If you're using Expo, add the `expo-build-properties` plugin to your `app.config.js` or `app.config.ts`:
+```bash
+npm install expo-build-properties
+```
+
+Then add it to your Expo config:
+```typescript
+// app.config.ts
+export default {
+  // ... other config
+  plugins: [
+    // ... other plugins
+    [
+      'expo-build-properties',
+      {
+        ios: {
+          useFrameworks: 'static',
+          useModularHeaders: true,  // Add this line
+        },
+      },
+    ],
+  ],
+};
+```
+
+Then run:
+```bash
+npx expo prebuild --clean
+```
+
+#### For Non-Expo React Native Projects
+
+**Option 1: Enable modular headers globally (Recommended)**
+
+Add this line after the `platform :ios` line in your `ios/Podfile`:
+```ruby
+platform :ios, '13.4'
+use_modular_headers!  # Add this line
+
+prepare_react_native_project!
+```
+
+**Option 2: Enable modular headers in post_install hook**
+
+Add this code inside your `post_install do |installer|` block:
+```ruby
+post_install do |installer|
+  # Enable modular headers for libzstd
+  installer.pods_project.targets.each do |target|
+    if target.name == 'libzstd'
+      target.build_configurations.each do |config|
+        config.build_settings['DEFINES_MODULE'] = 'YES'
+      end
+    end
+  end
+  
+  # ... rest of your existing post_install code
+end
+```
+
 ### Install Pods
 
 After saving the Podfile, navigate to your `ios` directory in the terminal and run a fresh pod installation.

package/aguacerowx-react-native.podspec

@@ -11,8 +11,6 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => "13.4" }
   s.source       = { :git => "https://github.com/AguaceroWx/aguacero-sdks.git", :tag => "v#{s.version}" }
   s.swift_version = "5.0"
-  
-  # Add this line to make it a dynamic framework
   s.static_framework = false
   
   s.pod_target_xcconfig = {
@@ -26,9 +24,27 @@ Pod::Spec.new do |s|
     'DEFINES_MODULE' => 'YES'
   }
   
-  s.resource_bundles = {
-    'AguaceroMetalShaders' => ['ios/**/*.metal'] 
-  }
+  s.resources = ['ios/compiled-shaders/*.metallib', 'ios/*.metal']
+  
+  s.script_phases = [
+    {
+      :name => 'Copy Metal Shaders',
+      :script => 'echo "🔨 Copying Metal shaders..."
+SHADER_DIR="${PODS_TARGET_SRCROOT}/ios/compiled-shaders"
+METAL_SOURCE="${PODS_TARGET_SRCROOT}/ios/Shaders.metal"
+
+if [ -f "$SHADER_DIR/Shaders.metallib" ]; then
+  cp -v "$SHADER_DIR/Shaders.metallib" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/" || true
+  echo "✅ Pre-compiled Metal shader copied"
+elif [ -f "$METAL_SOURCE" ]; then
+  echo "⚠️ No pre-compiled shader found, will compile from source"
+  cp -v "$METAL_SOURCE" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/" || true
+else
+  echo "❌ No Metal shaders found!"
+fi',
+      :execution_position => :before_compile
+    }
+  ]
   
   s.source_files = "ios/**/*.{h,m,mm,swift}", "ios/generated/**/*.{h,m,mm,cpp}"
   

package/android/build.gradle

@@ -1,5 +1,15 @@
 // @aguacerowx/react-native/android/build.gradle
 
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath("com.facebook.react:react-native-gradle-plugin")
+    }
+}
+
 repositories {
     google()
     mavenCentral()
@@ -17,6 +27,12 @@ repositories {
 
 apply plugin: 'com.android.library'
 
+def isNewArchEnabled = project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+
+if (isNewArchEnabled) {
+    apply plugin: "com.facebook.react"
+}
+
 android {
     namespace 'com.aguacerowx.reactnative'
     compileSdk 34 
@@ -44,6 +60,13 @@ android {
     }
 }
 
+if (isNewArchEnabled) {
+    react {
+        libraryName = "AguaceroWxReactNativeSpec"
+        codegenJavaPackageName = "com.aguacerowx.reactnative"
+    }
+}
+
 dependencies {
     implementation 'com.facebook.react:react-native:+'
     api 'org.locationtech.proj4j:proj4j:1.1.5'
@@ -51,7 +74,14 @@ dependencies {
 }
 
 project.afterEvaluate {
-    // 1. Resolve the Mapbox Version
+    // Fix Gradle 9 task dependency issue
+    if (isNewArchEnabled) {
+        tasks.named("generateCodegenArtifactsFromSchema").configure {
+            dependsOn("generateCodegenSchemaFromJavaScript")
+        }
+    }
+
+    // Mapbox version resolution
     def resolvedMapboxVersion
     if (project.rootProject.hasProperty('mapboxMapsVersion')) {
         resolvedMapboxVersion = project.rootProject.mapboxMapsVersion
@@ -61,23 +91,17 @@ project.afterEvaluate {
         println "[aguacerowx] WARNING: Could not find 'mapboxMapsVersion' property. Falling back to ${resolvedMapboxVersion}."
     }
 
-    // 2. Detect if @rnmapbox/maps is present in the user's project
-    // We check the root project to see all included modules.
     def rnMapboxIsPresent = project.rootProject.findProject(':rnmapbox_maps') != null
     def mapboxArtifact
 
-    // 3. Choose the correct Mapbox artifact based on the detection
     if (rnMapboxIsPresent) {
-        // If @rnmapbox/maps is present, we MUST use the ndk27 variant to avoid conflicts.
         mapboxArtifact = "android-ndk27"
         println "[aguacerowx] @rnmapbox/maps detected. Using Mapbox artifact: '${mapboxArtifact}' to ensure compatibility."
     } else {
-        // If it's not present, use the standard 'android' variant.
         mapboxArtifact = "android"
         println "[aguacerowx] @rnmapbox/maps not detected. Using standard Mapbox artifact: '${mapboxArtifact}'."
     }
 
-    // 4. Add the chosen Mapbox dependency using the version and artifact we just determined.
     dependencies {
         implementation "com.mapbox.maps:${mapboxArtifact}:${resolvedMapboxVersion}"
     }

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

@@ -33,7 +33,7 @@ public class GridRenderLayer implements CustomLayerHost {
     // Uniform and Attribute locations
     private int uMatrix, uDataTexture, uColormapTexture, uOpacity, uDataRange, 
                 uScale, uOffset, uMissingQuantized, uTextureSize, uConversionType, uSmoothing,
-                uScaleType;  
+                uScaleType, uIsPtype;
     private int aPosition, aTexCoord;
 
     // GPU-side resource IDs
@@ -54,6 +54,8 @@ public class GridRenderLayer implements CustomLayerHost {
     private int conversionType = 0;
     private boolean smoothingEnabled = true;
     private int scaleType = 0;
+    private boolean isPtype = false; // ADDED
+    private String currentVariable = "";
     private boolean textureParametersDirty = true; 
     private volatile boolean isVisible = true;
 
@@ -120,9 +122,22 @@ public class GridRenderLayer implements CustomLayerHost {
         uConversionType = GLES20.glGetUniformLocation(program, "u_conversion_type");
         uSmoothing = GLES20.glGetUniformLocation(program, "u_smoothing"); 
         uScaleType = GLES20.glGetUniformLocation(program, "u_scale_type");
+        uIsPtype = GLES20.glGetUniformLocation(program, "u_is_ptype");
         aPosition = GLES20.glGetAttribLocation(program, "a_position");
         aTexCoord = GLES20.glGetAttribLocation(program, "a_texCoord");
     }
+    
+    public void setVariable(String variable) {
+        if (variable == null) {
+            this.currentVariable = "";
+        } else {
+            this.currentVariable = variable;
+        }
+        // MODIFICATION: Add detailed logging here
+        this.isPtype = "ptypeRefl".equals(this.currentVariable) || "ptypeRate".equals(this.currentVariable);
+        Log.d(TAG, "setVariable called. Variable: '" + this.currentVariable + "', isPtype set to: " + this.isPtype);
+    }
+
 
     public void clearData() {
         this.isVisible = false;
@@ -243,6 +258,7 @@ public class GridRenderLayer implements CustomLayerHost {
         GLES20.glUniform1i(uConversionType, conversionType);
         GLES20.glUniform1i(uSmoothing, smoothingEnabled ? 1 : 0); 
         GLES20.glUniform1i(uScaleType, this.scaleType);
+        GLES20.glUniform1i(uIsPtype, this.isPtype ? 1 : 0); 
 
         GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
         GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, dataTextureId);

package/android/src/main/java/com/aguacerowx/reactnative/GridRenderLayerView.java

@@ -297,4 +297,9 @@ public class GridRenderLayerView extends FrameLayout {
         gridLayerImplementation.clearData();
         triggerRepaint();
     }
+
+    public void setVariable(String variable) {
+        gridLayerImplementation.setVariable(variable);
+        triggerRepaint();
+    }
 }

package/android/src/main/java/com/aguacerowx/reactnative/GridRenderManager.java

@@ -21,6 +21,7 @@ public class GridRenderManager extends SimpleViewManager<GridRenderLayerView> {
     private static final int COMMAND_UPDATE_GEOMETRY = 3;
     private static final int COMMAND_UPDATE_DATA_PARAMETERS = 4;
     private static final int COMMAND_CLEAR = 5;
+    private static final int COMMAND_SET_VARIABLE = 6;
 
     @NonNull
     @Override
@@ -68,6 +69,7 @@ public class GridRenderManager extends SimpleViewManager<GridRenderLayerView> {
         commands.put("updateGeometry", COMMAND_UPDATE_GEOMETRY);
         commands.put("updateDataParameters", COMMAND_UPDATE_DATA_PARAMETERS);
         commands.put("clear", COMMAND_CLEAR);
+        commands.put("setVariable", COMMAND_SET_VARIABLE);
         return commands;
     }
 
@@ -113,6 +115,12 @@ public class GridRenderManager extends SimpleViewManager<GridRenderLayerView> {
             case COMMAND_CLEAR:
                 view.clearData();
                 break;
+
+            case COMMAND_SET_VARIABLE:
+                if (args != null && args.size() > 0) {
+                    view.setVariable(args.getString(0));
+                }
+                break;
         }
     }
 }

package/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);
 }