@aguacerowx/react-native 0.0.8 → 0.0.9

package/ios/Shaders.metal

@@ -0,0 +1,131 @@
+#include <metal_stdlib>
+using namespace metal;
+
+// Struct to match the vertex buffer layout in Swift
+struct Vertex {
+    float2 position [[attribute(0)]];
+    float2 texCoord [[attribute(1)]];
+};
+
+// Struct for passing data from vertex to fragment shader
+struct RasterizerData {
+    float4 position [[position]];
+    float2 texCoord;
+};
+
+// Uniforms passed from the CPU to the fragment shader
+struct FragmentUniforms {
+    float opacity;
+    float2 dataRange;
+    float scale;
+    float offset;
+    float missingQuantized;
+    float2 textureSize;
+    int smoothing;
+    int scaleType; // 0 for linear, 1 for sqrt
+};
+
+// --- Vertex Shader (Unchanged) ---
+vertex RasterizerData vertex_main(const Vertex in [[stage_in]],
+                                  constant float4x4 &mvp [[buffer(1)]]) {
+    RasterizerData out;
+    out.position = mvp * float4(in.position, 0.0, 1.0);
+    out.texCoord = in.texCoord;
+    return out;
+}
+
+float sampleDataTextureSmooth(
+    texture2d<float, access::sample> dataTexture,
+    sampler dataSampler,
+    float2 uv,
+    constant FragmentUniforms &uniforms)
+{
+    float missing_value = uniforms.missingQuantized + 128.0;
+
+    // Calculate the fractional part for interpolation and the size of one texel.
+    float2 texel_size = 1.0 / uniforms.textureSize;
+    float2 pixel_coord = uv * uniforms.textureSize;
+    float2 pixel_floor = floor(pixel_coord - 0.5);
+    float2 f = fract(pixel_coord - 0.5);
+
+    // Calculate the precise UV coordinates for the CENTER of the four surrounding texels.
+    float2 uv00 = (pixel_floor + float2(0.5, 0.5)) * texel_size;
+    float2 uv10 = (pixel_floor + float2(1.5, 0.5)) * texel_size;
+    float2 uv01 = (pixel_floor + float2(0.5, 1.5)) * texel_size;
+    float2 uv11 = (pixel_floor + float2(1.5, 1.5)) * texel_size;
+
+    // Sample the four corner texels.
+    float s00 = dataTexture.sample(dataSampler, uv00).r * 255.0;
+    float s10 = dataTexture.sample(dataSampler, uv10).r * 255.0;
+    float s01 = dataTexture.sample(dataSampler, uv01).r * 255.0;
+    float s11 = dataTexture.sample(dataSampler, uv11).r * 255.0;
+
+    // THE CRITICAL CHECK: If any surrounding pixel is a "missing" value,
+    // treat this entire fragment as missing to prevent interpolation.
+    if (abs(s00 - missing_value) < 0.5 ||
+        abs(s10 - missing_value) < 0.5 ||
+        abs(s01 - missing_value) < 0.5 ||
+        abs(s11 - missing_value) < 0.5)
+    {
+        return missing_value;
+    }
+
+    // All neighbors are valid data, so we can safely perform manual bilinear interpolation.
+    float s0 = mix(s00, s10, f.x); // Interpolate the top row
+    float s1 = mix(s01, s11, f.x); // Interpolate the bottom row
+    
+    // --- THE FIX IS HERE ---
+    // Remove the incorrect "1.0 - f.y" inversion. The vertical mix should use f.y directly.
+    return mix(s0, s1, f.y);
+}
+
+// --- Fragment Shader (NEW & IMPROVED) ---
+fragment float4 fragment_main(RasterizerData in [[stage_in]],
+                                constant FragmentUniforms &uniforms [[buffer(0)]],
+                                texture2d<float, access::sample> dataTexture [[texture(0)]],
+                                texture2d<float, access::sample> colormapTexture [[texture(1)]],
+                                sampler dataSampler [[sampler(0)]],
+                                sampler colormapSampler [[sampler(1)]])
+{
+    // Choose the sampling method based on the smoothing uniform.
+    float value_in_texture;
+    if (uniforms.smoothing == 1) {
+        // Use our custom function that prevents edge artifacts.
+        value_in_texture = sampleDataTextureSmooth(dataTexture, dataSampler, in.texCoord, uniforms);
+    } else {
+        // Smoothing is off. The sampler is already set to 'nearest' by the Swift code,
+        // so a standard sample call produces the correct pixelated result.
+        value_in_texture = dataTexture.sample(dataSampler, in.texCoord).r * 255.0;
+    }
+
+    float missing_value = uniforms.missingQuantized + 128.0;
+
+    // Discard if the pixel is a predefined missing value (either originally or from our function).
+    if (abs(value_in_texture - missing_value) < 0.5) {
+        discard_fragment();
+    }
+
+    // Dequantize the value to its real-world representation.
+    float quantized_value = value_in_texture - 128.0;
+    float intermediate_value = quantized_value * uniforms.scale + uniforms.offset;
+    float raw_value = intermediate_value;
+    
+    // Apply non-linear inverse scaling if specified.
+    if (uniforms.scaleType == 1) { // 'sqrt'
+        raw_value = intermediate_value * abs(intermediate_value);
+    }
+    
+    // Discard if the data is below the specified visible range.
+    if (raw_value < uniforms.dataRange.x) {
+        discard_fragment();
+    }
+    
+    // Normalize the value to a 0-1 coordinate for colormap lookup.
+    float colormap_coord = (raw_value - uniforms.dataRange.x) / (uniforms.dataRange.y - uniforms.dataRange.x);
+    colormap_coord = clamp(colormap_coord, 0.0, 1.0);
+    
+    // Sample the colormap and apply final opacity.
+    float4 color = colormapTexture.sample(colormapSampler, float2(colormap_coord, 0.5));
+    
+    return float4(color.rgb, color.a * uniforms.opacity);
+}

package/ios/WeatherFrameProcessorModule.m

@@ -0,0 +1,16 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(WeatherFrameProcessorModule, NSObject)
+
+RCT_EXTERN_METHOD(processFrame:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(cancelAllFrames)
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+@end

package/ios/WeatherFrameProcessorModule.swift

@@ -0,0 +1,104 @@
+import Foundation
+import React
+
+@objc(WeatherFrameProcessorModule)
+class WeatherFrameProcessorModule: NSObject {
+
+    private var currentRunToken = 0
+    private let session = URLSession(configuration: .default)
+
+    @objc(cancelAllFrames)
+    func cancelAllFrames() {
+        // Incrementing the token effectively cancels any in-flight tasks
+        // as they will check their token against the new value upon completion.
+        currentRunToken += 1
+    }
+
+    @objc(processFrame:resolver:rejecter:)
+    func processFrame(options: [String: Any], resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        let taskToken = self.currentRunToken
+
+        guard let urlString = options["url"] as? String, let url = URL(string: urlString) else {
+            reject("INVALID_URL", "The provided URL is not valid.", nil)
+            return
+        }
+
+        let apiKey = options["apiKey"] as? String ?? ""
+        let bundleId = options["bundleId"] as? String
+
+        var request = URLRequest(url: url)
+        request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
+        if let bundleId = bundleId {
+            request.setValue(bundleId, forHTTPHeaderField: "x-app-identifier")
+        }
+
+        let task = session.dataTask(with: request) { data, response, error in
+            if self.currentRunToken != taskToken {
+                // Task was cancelled
+                return
+            }
+
+            if let error = error {
+                reject("NETWORK_ERROR", "Failed to fetch frame data: \(error.localizedDescription)", error)
+                return
+            }
+
+            guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
+                let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
+                reject("HTTP_ERROR", "HTTP request failed with status code: \(statusCode)", nil)
+                return
+            }
+
+            guard let data = data else {
+                reject("NO_DATA", "The server returned no data.", nil)
+                return
+            }
+
+            do {
+                guard let jsonResponse = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any],
+                      let b64CompressedData = jsonResponse["data"] as? String,
+                      let encoding = jsonResponse["encoding"] as? [String: Any],
+                      let scale = encoding["scale"] as? NSNumber,
+                      let offset = encoding["offset"] as? NSNumber,
+                      let missing = encoding["missing_quantized"] as? NSNumber else {
+                    reject("INVALID_RESPONSE", "The API response format was invalid.", nil)
+                    return
+                }
+                
+                guard let compressedData = Data(base64Encoded: b64CompressedData) else {
+                    reject("DECODING_ERROR", "Failed to decode base64 data string.", nil)
+                    return
+                }
+
+                let cacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first!
+                let fileName = "frame_\(urlString.hashValue).zst"
+                let dataFile = cacheDir.appendingPathComponent(fileName)
+                
+                try compressedData.write(to: dataFile)
+
+                var responseMap: [String: Any] = [
+                    "filePath": dataFile.path,
+                    "scale": scale,
+                    "offset": offset,
+                    "missing": missing,
+                    "dataAsBase64": b64CompressedData // Pass this through for the initial load case
+                ]
+                
+                if let scaleType = encoding["scale_type"] as? String {
+                    responseMap["scaleType"] = scaleType
+                }
+
+                resolve(responseMap)
+
+            } catch {
+                reject("PROCESSING_ERROR", "Failed to process the frame data: \(error.localizedDescription)", error)
+            }
+        }
+        task.resume()
+    }
+    
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+}

package/ios/aguacerowx-react-native.podspec

@@ -5,25 +5,32 @@ Pod::Spec.new do |s|
   s.name         = "aguacerowx-react-native"
   s.version      = package["version"]
   s.summary      = package["description"]
-  s.homepage     = package["homepage"] || "https://github.com/AguaceroWx/aguacero-sdks"
+  s.homepage     = "https://www.npmjs.com/package/@aguacerowx/react-native"
   s.license      = package["license"]
   s.authors      = { package["author"] => "support@aguacerowx.com" }
   s.platforms    = { :ios => "13.4" }
-  s.source       = { :git => "https://github.com/AguaceroWx/aguacero-sdks", :tag => "v#{s.version}" }
-
-  # --- CONFIGURATION FOR SWIFT AND OBJECTIVE-C INTEROP ---
-  s.swift_version = "5.0" # Explicitly set the Swift version
-
-  # This tells Xcode how to build your specific pod target.
-  # It explicitly defines the name of the generated header file, making it discoverable.
+  s.source       = { :git => "https://github.com/AguaceroWx/aguacero-sdks.git", :tag => "v#{s.version}" }
+  
+  s.swift_version = "5.0"
+  
   s.pod_target_xcconfig = {
     'DEFINES_MODULE' => 'YES',
-    'SWIFT_OBJC_INTERFACE_HEADER_NAME' => 'aguacerowx_react_native-Swift.h'
+    'CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule',
+    'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) ZSTD_DISABLE_ASM=1' 
   }
-  # --------------------------------------------------------
-
-  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  
+  s.user_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES'
+  }
+  
+  s.resource_bundles = {
+    'AguaceroMetalShaders' => ['**/*.metal']
+  }
+  
+  s.source_files = "**/*.{h,m,mm,swift}"
+  
   s.dependency "React-Core"
-
-  # No need for s.static_framework = true, React Native handles this now.
+  s.dependency "MapboxMaps", "~> 11.0"
+  s.dependency "libzstd", "~> 1.5.5"
 end

package/lib/commonjs/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/lib/commonjs/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() {