@aguacerowx/react-native 0.0.8 → 0.0.9

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

@@ -297,6 +297,15 @@ public class GridRenderLayer implements CustomLayerHost {
         }
     }
 
+    // Add this method to GridRenderLayer.java (around line 270)
+    public void updateDataParameters(float scale, float offset, float missing) {
+        synchronized (dataLock) {
+            this.scale = scale;
+            this.offset = offset;
+            this.missingQuantized = missing;
+        }
+    }
+
     // This existing method is now used by both the old JS path and our new native path
     public void updateDataTexture(byte[] bytes, int nx, int ny, float scale, float offset, float missing, String scaleType) {
         ByteBuffer dataBuffer = ByteBuffer.allocateDirect(bytes.length);
@@ -470,139 +479,134 @@ public class GridRenderLayer implements CustomLayerHost {
             Math.abs(getDouble(gridParams, "lat_first", -1)) == 90.0;
     }
 
-// packages/react-native/android/src/main/java/com/aguacerowx/reactnative/GridRenderLayer.java
-
-// ... (keep the rest of the file the same, only replace this one method)
-
-private void generateGeometryData(ReadableMap gridDefMap, ArrayList<Float> vertices, ArrayList<Short> indices) {
-    ReadableMap gridParams = gridDefMap.getMap("grid_params");
-    if (gridParams == null) {
-        Log.e(TAG, "❌ [Geometry] grid_params is null. Aborting mesh generation.");
-        return;
-    }
+    private void generateGeometryData(ReadableMap gridDefMap, ArrayList<Float> vertices, ArrayList<Short> indices) {
+        ReadableMap gridParams = gridDefMap.getMap("grid_params");
+        if (gridParams == null) {
+            Log.e(TAG, "❌ [Geometry] grid_params is null. Aborting mesh generation.");
+            return;
+        }
 
-    // --- Path 1: Specialized GFS Global Grid Logic (Working Correctly) ---
-    if (isGFSType(gridParams)) {
-        // This proven logic remains unchanged.
-        int subdivisions = 120;
-        int verticesPerRow = (subdivisions * 3) + 1;
-        final double TILE_SIZE = 512.0;
-        for (int row = 0; row <= subdivisions; row++) {
-            for (int col = 0; col <= subdivisions * 3; col++) {
-                float v_interp = (float) row / subdivisions;
-                float u_interp = (float) col / subdivisions;
-                double lon = -540.0 + u_interp * 1080.0;
-                double lat = -90.0 + v_interp * 180.0;
-                double mercX_normalized = (lon + 180.0) / 360.0;
-                double clampedLat = Math.max(-85.05112878, Math.min(85.05112878, lat));
-                double sinLatitude = Math.sin(Math.toRadians(clampedLat));
-                double mercY_normalized = 0.5 - Math.log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * Math.PI);
-                double mercX = mercX_normalized * TILE_SIZE;
-                double mercY = mercY_normalized * TILE_SIZE;
-                vertices.add((float) mercX);
-                vertices.add((float) mercY);
-                float tex_u = (float) ((lon + 180.0) / 360.0);
-                float tex_v = 1.0f - v_interp;
-                vertices.add(tex_u);
-                vertices.add(tex_v);
+        // --- Path 1: Specialized GFS Global Grid Logic (Working Correctly) ---
+        if (isGFSType(gridParams)) {
+            // This proven logic remains unchanged.
+            int subdivisions = 120;
+            int verticesPerRow = (subdivisions * 3) + 1;
+            final double TILE_SIZE = 512.0;
+            for (int row = 0; row <= subdivisions; row++) {
+                for (int col = 0; col <= subdivisions * 3; col++) {
+                    float v_interp = (float) row / subdivisions;
+                    float u_interp = (float) col / subdivisions;
+                    double lon = -540.0 + u_interp * 1080.0;
+                    double lat = -90.0 + v_interp * 180.0;
+                    double mercX_normalized = (lon + 180.0) / 360.0;
+                    double clampedLat = Math.max(-85.05112878, Math.min(85.05112878, lat));
+                    double sinLatitude = Math.sin(Math.toRadians(clampedLat));
+                    double mercY_normalized = 0.5 - Math.log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * Math.PI);
+                    double mercX = mercX_normalized * TILE_SIZE;
+                    double mercY = mercY_normalized * TILE_SIZE;
+                    vertices.add((float) mercX);
+                    vertices.add((float) mercY);
+                    float tex_u = (float) ((lon + 180.0) / 360.0);
+                    float tex_v = 1.0f - v_interp;
+                    vertices.add(tex_u);
+                    vertices.add(tex_v);
+                }
             }
-        }
-        for (short row = 0; row < subdivisions; row++) {
-            for (short col = 0; col < subdivisions * 3; col++) {
-                short tl = (short) (row * verticesPerRow + col);
-                short tr = (short) (tl + 1);
-                short bl = (short) ((row + 1) * verticesPerRow + col);
-                short br = (short) (bl + 1);
-                indices.add(tl); indices.add(bl); indices.add(tr);
-                indices.add(tr); indices.add(bl); indices.add(br);
+            for (short row = 0; row < subdivisions; row++) {
+                for (short col = 0; col < subdivisions * 3; col++) {
+                    short tl = (short) (row * verticesPerRow + col);
+                    short tr = (short) (tl + 1);
+                    short bl = (short) ((row + 1) * verticesPerRow + col);
+                    short br = (short) (bl + 1);
+                    indices.add(tl); indices.add(bl); indices.add(tr);
+                    indices.add(tr); indices.add(bl); indices.add(br);
+                }
             }
+            return;
         }
-        return;
-    }
 
-    // --- Path 2: LCC Grid Logic ---
-    if (isLCCType(gridDefMap)) {
-        generateLCCGeometry(gridDefMap, vertices, indices);
-        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);
-    double lat_first = getDouble(gridParams, "lat_first", 90.0);
-    double dx = getDouble(gridParams, "dx_degrees", 0.0);
-    double dy = getDouble(gridParams, "dy_degrees", 0.0);
-    double lon_last = getDouble(gridParams, "lon_last", lon_first + (nx - 1) * dx);
-    double lat_last = getDouble(gridParams, "lat_last", lat_first + (ny - 1) * dy);
-    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;
-    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_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
-    for (int world_copy = -1; world_copy <= 1; world_copy++) {
-        short vertexStartIndex = (short) (vertices.size() / 4); // 4 floats per vertex (x,y,u,v)
-        double lon_offset = world_copy * 360.0;
-
-        // Generate vertices for this specific 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
-                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
-                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));
-                double mercY_normalized = 0.5 - Math.log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * Math.PI);
-                double mercX = mercX_normalized * TILE_SIZE;
-                double mercY = mercY_normalized * TILE_SIZE;
+        // --- Path 2: LCC Grid Logic ---
+        if (isLCCType(gridDefMap)) {
+            generateLCCGeometry(gridDefMap, vertices, indices);
+            return;
+        }
 
-                vertices.add((float) mercX);
-                vertices.add((float) mercY);
+        // Step 1: Extract grid parameters
+        int nx = gridParams.getInt("nx");
+        int ny = gridParams.getInt("ny");
+        double lon_first = getDouble(gridParams, "lon_first", 0.0);
+        double lat_first = getDouble(gridParams, "lat_first", 90.0);
+        double dx = getDouble(gridParams, "dx_degrees", 0.0);
+        double dy = getDouble(gridParams, "dy_degrees", 0.0);
+        double lon_last = getDouble(gridParams, "lon_last", lon_first + (nx - 1) * dx);
+        double lat_last = getDouble(gridParams, "lat_last", lat_first + (ny - 1) * dy);
+        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;
+        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_y = 60;
+        int verticesPerMesh = (subdivisions_y + 1) * (subdivisions_x + 1);
+        int verticesPerRow = subdivisions_x + 1;
+        final double TILE_SIZE = 512.0;
 
-                // Texture coordinates are always a clean 0.0 to 1.0 for each mesh instance
-                float tex_u = u_interp;
-                float tex_v = isSouthToNorth ? (1.0f - v_interp) : v_interp;
-                
-                vertices.add(tex_u);
-                vertices.add(tex_v);
+        // Step 4: Generate three separate, non-connected meshes to prevent seam artifacts
+        for (int world_copy = -1; world_copy <= 1; world_copy++) {
+            short vertexStartIndex = (short) (vertices.size() / 4); // 4 floats per vertex (x,y,u,v)
+            double lon_offset = world_copy * 360.0;
+
+            // Generate vertices for this specific 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
+                    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
+                    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));
+                    double mercY_normalized = 0.5 - Math.log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * Math.PI);
+                    double mercX = mercX_normalized * TILE_SIZE;
+                    double mercY = mercY_normalized * TILE_SIZE;
+
+                    vertices.add((float) mercX);
+                    vertices.add((float) mercY);
+
+                    // Texture coordinates are always a clean 0.0 to 1.0 for each mesh instance
+                    float tex_u = u_interp;
+                    float tex_v = isSouthToNorth ? (1.0f - v_interp) : v_interp;
+                    
+                    vertices.add(tex_u);
+                    vertices.add(tex_v);
+                }
             }
-        }
-
-        // Generate indices for this specific world copy, offsetting by the starting index
-        for (short row = 0; row < subdivisions_y; row++) {
-            for (short col = 0; col < subdivisions_x; col++) {
-                short tl = (short) (vertexStartIndex + row * verticesPerRow + col);
-                short tr = (short) (tl + 1);
-                short bl = (short) (vertexStartIndex + (row + 1) * verticesPerRow + col);
-                short br = (short) (bl + 1);
 
-                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)
-                    indices.add(tl); indices.add(tr); indices.add(bl);
-                    indices.add(bl); indices.add(tr); indices.add(br);
+            // Generate indices for this specific world copy, offsetting by the starting index
+            for (short row = 0; row < subdivisions_y; row++) {
+                for (short col = 0; col < subdivisions_x; col++) {
+                    short tl = (short) (vertexStartIndex + row * verticesPerRow + col);
+                    short tr = (short) (tl + 1);
+                    short bl = (short) (vertexStartIndex + (row + 1) * verticesPerRow + col);
+                    short br = (short) (bl + 1);
+
+                    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)
+                        indices.add(tl); indices.add(tr); indices.add(bl);
+                        indices.add(bl); indices.add(tr); indices.add(br);
+                    }
                 }
             }
         }
     }
-}
-
 }

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

@@ -241,7 +241,6 @@ public class GridRenderLayerView extends FrameLayout {
         colormapBuffer.put(bytes);
         colormapBuffer.position(0);
         gridLayerImplementation.updateColormapTexture(colormapBuffer);
-        triggerRepaint();
     }
 
     public void updateGeometry(ReadableMap corners, ReadableMap gridDef) {
@@ -289,6 +288,9 @@ public class GridRenderLayerView extends FrameLayout {
         lastDataScale = scale;
         lastDataOffset = offset;
         lastDataMissing = missing;
+        
+        // CRITICAL FIX: Also update the GridRenderLayer implementation
+        gridLayerImplementation.updateDataParameters(scale, offset, missing);
     }
 
     public void clearData() {

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

@@ -32,6 +32,7 @@ public class InspectorModule extends ReactContextBaseJavaModule {
             float scale = GridRenderLayerView.getLastDataScale();
             float offset = GridRenderLayerView.getLastDataOffset();
             float missing = GridRenderLayerView.getLastDataMissing();
+            String scaleType = GridRenderLayerView.getLastDataScaleType();  // ADD THIS
             
             // Calculate index
             int index = j * nx + i;
@@ -45,18 +46,25 @@ public class InspectorModule extends ReactContextBaseJavaModule {
             // Read byte value
             int byteValue = data[index] & 0xFF; // Convert to unsigned
             int signedQuantizedValue = byteValue - 128;
-            int missingQuantized = Math.round(missing - 128);
+            int missingQuantized = Math.round(missing);  // CHANGED: removed -128 since missing is already adjusted
             
             // Check for missing value
-            if (signedQuantizedValue == missingQuantized) {
+            if (Math.abs(signedQuantizedValue - missingQuantized) < 0.5) {  // CHANGED: use tolerance
                 promise.resolve(null);
                 return;
             }
             
-            // Calculate actual value
-            double value = signedQuantizedValue * scale + offset;
+            // Step 1: Linear dequantization
+            double intermediateValue = signedQuantizedValue * scale + offset;
+            double finalValue = intermediateValue;
             
-            promise.resolve(value);
+            // Step 2: Apply sqrt inverse transformation if needed (matching the shader)
+            if ("sqrt".equals(scaleType)) {
+                // Square the intermediate value while preserving sign
+                finalValue = intermediateValue * Math.abs(intermediateValue);
+            }
+            
+            promise.resolve(finalValue);
         } catch (Exception e) {
             promise.reject("ERROR", e.getMessage());
         }

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

@@ -1,12 +1,10 @@
-// packages/com/aguacerowx/reactnative/WeatherFrameProcessorModule.java
-
 package com.aguacerowx.reactnative;
 
 import androidx.annotation.NonNull;
 import android.util.Base64;
 
 import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.Promise;  // CHANGED: Import Promise instead of Callback
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
@@ -61,7 +59,7 @@ public class WeatherFrameProcessorModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void processFrame(ReadableMap options, Callback callback) {
+    public void processFrame(ReadableMap options, Promise promise) {  // CHANGED: Use Promise instead of Callback
         final int taskToken = this.currentRunToken;
         executorService.execute(() -> {
             FileOutputStream fos = null;
@@ -70,17 +68,12 @@ public class WeatherFrameProcessorModule extends ReactContextBaseJavaModule {
                     return; // Task was cancelled
                 }
 
-                // --- START OF REPLACEMENT ---
-
-                // 1. Get the shared OkHttpClient instance from React Native
                 OkHttpClient client = OkHttpClientProvider.getOkHttpClient();
 
-                // 2. Get request details from options
                 String urlString = options.getString("url");
                 String apiKey = options.getString("apiKey");
                 String bundleId = options.getString("bundleId");
 
-                // 3. Build the OkHttp Request
                 Request.Builder requestBuilder = new Request.Builder()
                         .url(urlString)
                         .header("x-api-key", apiKey);
@@ -92,7 +85,6 @@ public class WeatherFrameProcessorModule extends ReactContextBaseJavaModule {
                 Request request = requestBuilder.build();
 
                 String responseString;
-                // 4. Execute the request and handle the response
                 try (Response response = client.newCall(request).execute()) {
                     if (!response.isSuccessful()) {
                         throw new IOException("HTTP Error: " + response.code());
@@ -105,21 +97,15 @@ public class WeatherFrameProcessorModule extends ReactContextBaseJavaModule {
                     responseString = body.string();
                 }
 
-                // --- END OF REPLACEMENT ---
-
-                // The rest of your logic remains the same
                 JSONObject jsonResponse = new JSONObject(responseString);
                 if (!jsonResponse.has("data") || !jsonResponse.has("encoding")) {
-                    // If the core keys are missing, the response is invalid. Log it and fail.
                     throw new IOException("Invalid API response. 'data' or 'encoding' key is missing. Response: " + responseString);
                 }
 
                 String b64CompressedData = jsonResponse.getString("data");
                 JSONObject encoding = jsonResponse.getJSONObject("encoding");
 
-
                 if (!encoding.has("scale") || !encoding.has("offset") || !encoding.has("missing_quantized")) {
-                    // If the encoding object is missing required values, fail with a clear error.
                     throw new IOException("Invalid 'encoding' object in API response. Required keys are missing. Response: " + responseString);
                 }
 
@@ -145,12 +131,12 @@ public class WeatherFrameProcessorModule extends ReactContextBaseJavaModule {
                 }
                 responseMap.putString("dataAsBase64", b64CompressedData);
 
-                callback.invoke(null, responseMap);
+                promise.resolve(responseMap);  // CHANGED: Use promise.resolve() instead of callback
 
             } catch (Exception e) {
                 if (taskToken == this.currentRunToken) {
                     android.util.Log.e("AguaceroWX", "Error processing frame", e);
-                    callback.invoke(e.getMessage(), null);
+                    promise.reject("PROCESSING_ERROR", e.getMessage(), e);  // CHANGED: Use promise.reject() instead of callback
                 }
             } finally {
                 if (fos != null) {

package/ios/AguaceroPackage.m

@@ -0,0 +1,19 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+// This file acts as a central manifest for all your native code.
+// The autolinker will find this and use it to register your modules.
+
+// --- Make sure these module names match your Swift/Objective-C class names ---
+
+// Exposing the Swift module to Objective-C
+@interface RCT_EXTERN_MODULE(WeatherFrameProcessorModule, NSObject)
+@end
+
+// Exposing the Swift module to Objective-C
+@interface RCT_EXTERN_MODULE(InspectorModule, NSObject)
+@end
+
+// Exposing the ViewManager to Objective-C
+@interface RCT_EXTERN_MODULE(GridRenderLayerManager, RCTViewManager)
+@end

package/ios/FragmentUniforms.swift

@@ -0,0 +1,14 @@
+import Foundation
+import simd
+
+// Must match the fragment shader's uniform structure
+struct FragmentUniforms {
+    var opacity: Float
+    var dataRange: SIMD2<Float>
+    var scale: Float
+    var offset: Float
+    var missingQuantized: Float
+    var textureSize: SIMD2<Float>
+    var smoothing: Int32
+    var scaleType: Int32
+}