@aguacerowx/react-native 0.0.20 → 0.0.21

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

@@ -1,628 +1,658 @@
-// packages/react-native/android/src/main/java/com/aguacerowx/reactnative/GridRenderLayer.java
-
-package com.aguacerowx.reactnative;
-
-import android.content.Context;
-import android.opengl.GLES20;
-import android.util.Log;
-
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.ReadableMap;
-import com.mapbox.maps.CustomLayerHost;
-import com.mapbox.maps.CustomLayerRenderParameters;
-
-import java.io.InputStream;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.FloatBuffer;
-import java.nio.ShortBuffer;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Scanner;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import com.github.luben.zstd.Zstd;
-
-public class GridRenderLayer implements CustomLayerHost {
-    private final Context context;
-    private final String TAG = "AguaceroWX";
-    private int program;
-
-    // Uniform and Attribute locations
-    private int uMatrix, uDataTexture, uColormapTexture, uOpacity, uDataRange, 
-                uScale, uOffset, uMissingQuantized, uTextureSize, uConversionType, uSmoothing,
-                uScaleType, uIsPtype;
-    private int aPosition, aTexCoord;
-
-    // GPU-side resource IDs
-    private int dataTextureId = 0;
-    private int colormapTextureId = 0;
-    private int vboId = 0;
-    private int iboId = 0;
-    private int indexCount = 0;
-
-    // Layer properties
-    private float opacity = 1.0f;
-    private float[] dataRange = new float[]{0.0f, 1.0f};
-    private float scale = 1.0f;
-    private float offset = 0.0f;
-    private float missingQuantized = 127.0f;
-    private int textureWidth = 0;
-    private int textureHeight = 0;
-    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;
-
-    // Pending data buffers for thread-safe uploads
-    private final Object dataLock = new Object();
-    private ByteBuffer pendingDataBuffer = null;
-    private int pendingNx = 0, pendingNy = 0;
-    private float pendingScale = 1.0f, pendingOffset = 0.0f, pendingMissing = 127.0f;
-    private int pendingScaleType = 0;
-    private ByteBuffer pendingColormapBuffer = null;
-    private FloatBuffer pendingVertexBuffer = null;
-    private ShortBuffer pendingIndexBuffer = null;
-
-
-    public GridRenderLayer(Context context) {
-        this.context = context;
-    }
-
-    private double getDouble(ReadableMap map, String key, double defaultValue) {
-        return map.hasKey(key) ? map.getDouble(key) : defaultValue;
-    }
-
-    private String loadShaderSource(int resourceId) {
-        InputStream inputStream = context.getResources().openRawResource(resourceId);
-        return new Scanner(inputStream).useDelimiter("\\A").next();
-    }
-
-    private int createShader(int type, String source) {
-        int shader = GLES20.glCreateShader(type);
-        if (shader == 0) return 0;
-        GLES20.glShaderSource(shader, source);
-        GLES20.glCompileShader(shader);
-        final int[] compileStatus = new int[1];
-        GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compileStatus, 0);
-        if (compileStatus[0] == 0) {
-            Log.e(TAG, "Error compiling shader: " + GLES20.glGetShaderInfoLog(shader));
-            GLES20.glDeleteShader(shader);
-            return 0;
-        }
-        return shader;
-    }
-
-    @Override
-    public void initialize() {
-        String vertexSource = loadShaderSource(R.raw.vertex_shader);
-        String fragmentSource = loadShaderSource(R.raw.fragment_shader);
-        int vertexShader = createShader(GLES20.GL_VERTEX_SHADER, vertexSource);
-        int fragmentShader = createShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
-
-        program = GLES20.glCreateProgram();
-        GLES20.glAttachShader(program, vertexShader);
-        GLES20.glAttachShader(program, fragmentShader);
-        GLES20.glLinkProgram(program);
-
-        uMatrix = GLES20.glGetUniformLocation(program, "u_matrix");
-        uDataTexture = GLES20.glGetUniformLocation(program, "u_data_texture");
-        uColormapTexture = GLES20.glGetUniformLocation(program, "u_colormap_texture");
-        uOpacity = GLES20.glGetUniformLocation(program, "u_opacity");
-        uDataRange = GLES20.glGetUniformLocation(program, "u_data_range");
-        uScale = GLES20.glGetUniformLocation(program, "u_scale");
-        uOffset = GLES20.glGetUniformLocation(program, "u_offset");
-        uMissingQuantized = GLES20.glGetUniformLocation(program, "u_missing_quantized");
-        uTextureSize = GLES20.glGetUniformLocation(program, "u_texture_size");
-        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;
-        // Also clear any pending data to prevent a stale frame from rendering
-        synchronized (dataLock) {
-            pendingDataBuffer = null;
-        }
-    }
-
-    @Override
-    public void render(CustomLayerRenderParameters renderParameters) {
-        if (program == 0 || !isVisible) return;
-
-        synchronized (dataLock) {
-            if (pendingVertexBuffer != null && pendingIndexBuffer != null) {
-                this.indexCount = pendingIndexBuffer.capacity();
-                if (vboId == 0) {
-                    int[] bufs = new int[2];
-                    GLES20.glGenBuffers(2, bufs, 0);
-                    vboId = bufs[0];
-                    iboId = bufs[1];
-                }
-                GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboId);
-                GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, pendingVertexBuffer.capacity() * 4, pendingVertexBuffer, GLES20.GL_STATIC_DRAW);
-                GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, iboId);
-                GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, pendingIndexBuffer.capacity() * 2, pendingIndexBuffer, GLES20.GL_STATIC_DRAW);
-                pendingVertexBuffer = null;
-                pendingIndexBuffer = null;
-            }
-
-            if (pendingDataBuffer != null) {
-                // --- FIX 2: LOGICAL FIX FOR TEXTURE RESIZING ---
-                boolean dimensionsChanged = (pendingNx != this.textureWidth || pendingNy != this.textureHeight);
-
-                this.textureWidth = pendingNx;
-                this.textureHeight = pendingNy;
-                this.scale = pendingScale;
-                this.offset = pendingOffset;
-                this.missingQuantized = pendingMissing;
-                this.scaleType = pendingScaleType;
-                
-                if (dataTextureId == 0) {
-                    int[] t = new int[1];
-                    GLES20.glGenTextures(1, t, 0);
-                    dataTextureId = t[0];
-                }
-                
-                GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, dataTextureId);
-
-                if (dimensionsChanged || dataTextureId == 0) {
-                    int filter = smoothingEnabled ? GLES20.GL_LINEAR : GLES20.GL_NEAREST;
-                    GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, filter);
-                    GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, filter);
-                    
-                    GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
-
-                    GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
-                    GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
-                    
-                    pendingDataBuffer.position(0);
-                    GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_ALPHA, pendingNx, pendingNy, 0, GLES20.GL_ALPHA, GLES20.GL_UNSIGNED_BYTE, pendingDataBuffer);
-                }  else {
-                    // Texture dimensions are the same, so just update its contents efficiently
-                    pendingDataBuffer.position(0);
-                    GLES20.glTexSubImage2D(GLES20.GL_TEXTURE_2D, 0, 0, 0, pendingNx, pendingNy, GLES20.GL_ALPHA, GLES20.GL_UNSIGNED_BYTE, pendingDataBuffer);
-                }
-                pendingDataBuffer = null;
-            }
-
-            if (pendingColormapBuffer != null) {
-                if (colormapTextureId == 0) {
-                    int[] t = new int[1];
-                    GLES20.glGenTextures(1, t, 0);
-                    colormapTextureId = t[0];
-                }
-                GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, colormapTextureId);
-                GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
-                GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_NEAREST);
-                GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
-                pendingColormapBuffer.position(0);
-                GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, 256, 1, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, pendingColormapBuffer);
-                pendingColormapBuffer = null;
-            }
-        }
-
-        double zoom = renderParameters.getZoom();
-
-        if (vboId == 0 || iboId == 0 || indexCount == 0 || dataTextureId == 0 || colormapTextureId == 0) return;
-
-        if (textureParametersDirty) {
-            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, dataTextureId);
-            int filter = smoothingEnabled ? GLES20.GL_LINEAR : GLES20.GL_NEAREST;
-            GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, filter);
-            GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, filter);
-            textureParametersDirty = false;
-        }
-
-        GLES20.glUseProgram(program);
-        
-        double scale = Math.pow(2.0, zoom);
-        
-        List<Double> matrix = renderParameters.getProjectionMatrix();
-        float[] floatMatrix = new float[16];
-        for (int i = 0; i < 16; i++) { 
-            floatMatrix[i] = matrix.get(i).floatValue(); 
-        }
-        
-        floatMatrix[0] *= scale;
-        floatMatrix[5] *= scale;
-
-        GLES20.glUniformMatrix4fv(uMatrix, 1, false, floatMatrix, 0);
-        GLES20.glUniform1f(uOpacity, opacity);
-        GLES20.glUniform2fv(uDataRange, 1, dataRange, 0);
-        GLES20.glUniform1f(uScale, this.scale);
-        GLES20.glUniform1f(uOffset, offset);
-        GLES20.glUniform1f(uMissingQuantized, missingQuantized);
-        GLES20.glUniform2f(uTextureSize, (float) textureWidth, (float) textureHeight);
-        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);
-        GLES20.glUniform1i(uDataTexture, 0);
-        
-        GLES20.glActiveTexture(GLES20.GL_TEXTURE1);
-        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, colormapTextureId);
-        GLES20.glUniform1i(uColormapTexture, 1);
-
-        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboId);
-        GLES20.glEnableVertexAttribArray(aPosition);
-        GLES20.glVertexAttribPointer(aPosition, 2, GLES20.GL_FLOAT, false, 16, 0);
-        GLES20.glEnableVertexAttribArray(aTexCoord);
-        GLES20.glVertexAttribPointer(aTexCoord, 2, GLES20.GL_FLOAT, false, 16, 8);
-        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, iboId);
-
-        GLES20.glEnable(GLES20.GL_BLEND);
-        GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);
-        GLES20.glDisable(GLES20.GL_DEPTH_TEST);
-        
-        GLES20.glDrawElements(GLES20.GL_TRIANGLES, indexCount, GLES20.GL_UNSIGNED_SHORT, 0);
-
-        GLES20.glDisableVertexAttribArray(aPosition);
-        GLES20.glDisableVertexAttribArray(aTexCoord);
-        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
-        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, 0);
-    }
-
-    @Override
-    public void deinitialize() {
-        if (program != 0) { GLES20.glDeleteProgram(program); program = 0; }
-        int[] texturesToDelete = {dataTextureId, colormapTextureId};
-        GLES20.glDeleteTextures(2, texturesToDelete, 0);
-        dataTextureId = 0; colormapTextureId = 0;
-        int[] buffersToDelete = {vboId, iboId};
-        GLES20.glDeleteBuffers(2, buffersToDelete, 0);
-        vboId = 0; iboId = 0;
-    }
-
-    @Override
-    public void contextLost() {
-        program = 0; dataTextureId = 0; colormapTextureId = 0; vboId = 0; iboId = 0;
-    }
-
-    public void setOpacity(float opacity) { this.opacity = opacity; }
-    public void setDataRange(float[] dataRange) { this.dataRange = dataRange; }
-    public void setConversionType(int type) { this.conversionType = type; }
-    public void setSmoothing(boolean enabled) {
-        if (this.smoothingEnabled != enabled) {
-            this.smoothingEnabled = enabled;
-            this.textureParametersDirty = true;
-        }
-    }
-
-    // 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);
-        dataBuffer.put(bytes);
-        dataBuffer.position(0);
-        synchronized (dataLock) {
-            this.pendingDataBuffer = dataBuffer;
-            this.pendingNx = nx;
-            this.pendingNy = ny;
-            this.pendingScale = scale;
-            this.pendingOffset = offset;
-            this.pendingMissing = missing;
-            this.pendingScaleType = "sqrt".equals(scaleType) ? 1 : 0;
-        }
-        // When new data is provided, ensure the layer is visible
-        this.isVisible = true; 
-    }
-    
-    public void updateColormapTexture(ByteBuffer data) {
-        synchronized (dataLock) { this.pendingColormapBuffer = data; }
-    }
-
-    private void generateLCCGeometry(ReadableMap gridDefMap, ArrayList<Float> vertices, ArrayList<Short> indices) {
-        ReadableMap gridParams = gridDefMap.getMap("grid_params");
-        ReadableMap projParams = gridDefMap.getMap("proj_params");
-        
-        if (gridParams == null || projParams == null) {
-            Log.e(TAG, "Missing grid or projection parameters for LCC");
-            return;
-        }
-        
-        int nx = gridParams.getInt("nx");
-        int ny = gridParams.getInt("ny");
-        double dx = getDouble(gridParams, "dx", 0);
-        double dy = getDouble(gridParams, "dy", 0);
-        double x_origin = getDouble(gridParams, "x_origin", 0);
-        double y_origin = getDouble(gridParams, "y_origin", 0);
-        
-        int subdivisions = 60;
-        final double TILE_SIZE = 512.0;
-        
-        double x_min = x_origin;
-        double y_max = y_origin;
-        double x_max = x_origin + (nx - 1) * dx;
-        double y_min = y_origin + (ny - 1) * dy;
-        
-        Object[][] vertexGrid = new Object[subdivisions + 1][subdivisions + 1];
-        int validVertexCount = 0;
-        
-        for (int row = 0; row <= subdivisions; row++) {
-            for (int col = 0; col <= subdivisions; col++) {
-                double t_x = (double) col / subdivisions;
-                double t_y = (double) row / subdivisions;
-                
-                double proj_x = x_min + t_x * (x_max - x_min);
-                double proj_y = y_max + t_y * (y_min - y_max);
-                
-                double[] latLon = projectLCCToLatLon(proj_x, proj_y, projParams);
-                
-                if (latLon == null) {
-                    vertexGrid[row][col] = null;
-                    continue;
-                }
-                
-                double lon = latLon[0];
-                double lat = latLon[1];
-                
-                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;
-                
-                if (!Double.isFinite(mercX) || !Double.isFinite(mercY)) {
-                    vertexGrid[row][col] = null;
-                    continue;
-                }
-                
-                float tex_u = (float) t_x;
-                float tex_v = (float) t_y;
-                
-                VertexInfo vInfo = new VertexInfo();
-                vInfo.mercX = (float) mercX;
-                vInfo.mercY = (float) mercY;
-                vInfo.texU = tex_u;
-                vInfo.texV = tex_v;
-                vInfo.index = (short) validVertexCount;
-                
-                vertexGrid[row][col] = vInfo;
-                
-                vertices.add((float) mercX);
-                vertices.add((float) mercY);
-                vertices.add(tex_u);
-                vertices.add(tex_v);
-                
-                validVertexCount++;
-            }
-        }
-        
-        if (vertices.isEmpty()) {
-            Log.e(TAG, "No valid vertices generated for LCC grid");
-            return;
-        }
-        
-        for (int row = 0; row < subdivisions; row++) {
-            for (int col = 0; col < subdivisions; col++) {
-                VertexInfo topLeft = (VertexInfo) vertexGrid[row][col];
-                VertexInfo topRight = (VertexInfo) vertexGrid[row][col + 1];
-                VertexInfo bottomLeft = (VertexInfo) vertexGrid[row + 1][col];
-                VertexInfo bottomRight = (VertexInfo) vertexGrid[row + 1][col + 1];
-                
-                if (topLeft != null && topRight != null && bottomLeft != null && bottomRight != null) {
-                    indices.add(topLeft.index);
-                    indices.add(bottomLeft.index);
-                    indices.add(topRight.index);
-                    
-                    indices.add(topRight.index);
-                    indices.add(bottomLeft.index);
-                    indices.add(bottomRight.index);
-                }
-            }
-        }
-    }
-
-    private static class VertexInfo {
-        float mercX, mercY, texU, texV;
-        short index;
-    }
-
-    private double[] projectLCCToLatLon(double x, double y, ReadableMap projParams) {
-        // TODO: Implement using proj4j library
-        Log.w(TAG, "LCC projection conversion not yet implemented - add proj4j library");
-        return null;
-    }
-
-    private boolean isLCCType(ReadableMap gridDefMap) {
-        if (gridDefMap == null) return false;
-        ReadableMap projParams = gridDefMap.getMap("proj_params");
-        if (projParams == null) return false;
-        return projParams.hasKey("proj") && "lcc".equals(projParams.getString("proj"));
-    }
-
-    public void updateGeometry(ReadableMap cornersMap, ReadableMap gridDefMap) {
-        if (gridDefMap == null) return;
-        ArrayList<Float> vertices = new ArrayList<>();
-        ArrayList<Short> indices = new ArrayList<>();
-        generateGeometryData(gridDefMap, vertices, indices);
-        if (vertices.isEmpty() || indices.isEmpty()) {
-            Log.e(TAG, "Generated geometry is empty, aborting GPU buffer update.");
-            return;
-        }
-        FloatBuffer vb = ByteBuffer.allocateDirect(vertices.size() * 4).order(ByteOrder.nativeOrder()).asFloatBuffer();
-        float[] vertexArray = new float[vertices.size()];
-        for (int i = 0; i < vertices.size(); i++) vertexArray[i] = vertices.get(i);
-        vb.put(vertexArray).position(0);
-        ShortBuffer ib = ByteBuffer.allocateDirect(indices.size() * 2).order(ByteOrder.nativeOrder()).asShortBuffer();
-        short[] indexArray = new short[indices.size()];
-        for (int i = 0; i < indices.size(); i++) indexArray[i] = indices.get(i);
-        ib.put(indexArray).position(0);
-        synchronized (dataLock) {
-            pendingVertexBuffer = vb;
-            pendingIndexBuffer = ib;
-        }
-    }
-    
-    private boolean isGFSType(ReadableMap gridParams) {
-        if (gridParams == null) return false;
-        return getDouble(gridParams, "lon_first", -1) == 0.0 &&
-            Math.abs(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) {
-            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);
-                }
-            }
-            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;
-        }
-
-        // --- 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;
-
-                    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);
-                    }
-                }
-            }
-        }
-    }
+// packages/react-native/android/src/main/java/com/aguacerowx/reactnative/GridRenderLayer.java
+
+package com.aguacerowx.reactnative;
+
+import android.content.Context;
+import android.opengl.GLES20;
+import android.util.Log;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.mapbox.maps.CustomLayerHost;
+import com.mapbox.maps.CustomLayerRenderParameters;
+
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.ShortBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import com.github.luben.zstd.Zstd;
+
+public class GridRenderLayer implements CustomLayerHost {
+    private final Context context;
+    private final String TAG = "AguaceroWX";
+    private int program;
+
+    // Uniform and Attribute locations
+    private int uMatrix, uDataTexture, uColormapTexture, uOpacity, uDataRange, 
+                uScale, uOffset, uMissingQuantized, uTextureSize, uConversionType, uSmoothing,
+                uScaleType, uIsPtype;
+    private int aPosition, aTexCoord;
+
+    // GPU-side resource IDs
+    private int dataTextureId = 0;
+    private int colormapTextureId = 0;
+    private int vboId = 0;
+    private int iboId = 0;
+    private int indexCount = 0;
+
+    // Layer properties
+    private float opacity = 1.0f;
+    private float[] dataRange = new float[]{0.0f, 1.0f};
+    private float scale = 1.0f;
+    private float offset = 0.0f;
+    private float missingQuantized = 127.0f;
+    private int textureWidth = 0;
+    private int textureHeight = 0;
+    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;
+
+    // Pending data buffers for thread-safe uploads
+    private final Object dataLock = new Object();
+    private ByteBuffer pendingDataBuffer = null;
+    private int pendingNx = 0, pendingNy = 0;
+    private float pendingScale = 1.0f, pendingOffset = 0.0f, pendingMissing = 127.0f;
+    private int pendingScaleType = 0;
+    private ByteBuffer pendingColormapBuffer = null;
+    private FloatBuffer pendingVertexBuffer = null;
+    private ShortBuffer pendingIndexBuffer = null;
+
+
+    public GridRenderLayer(Context context) {
+        this.context = context;
+    }
+
+    private double getDouble(ReadableMap map, String key, double defaultValue) {
+        return map.hasKey(key) ? map.getDouble(key) : defaultValue;
+    }
+
+    private String loadShaderSource(int resourceId) {
+        InputStream inputStream = context.getResources().openRawResource(resourceId);
+        return new Scanner(inputStream).useDelimiter("\\A").next();
+    }
+
+    private int createShader(int type, String source) {
+        int shader = GLES20.glCreateShader(type);
+        if (shader == 0) return 0;
+        GLES20.glShaderSource(shader, source);
+        GLES20.glCompileShader(shader);
+        final int[] compileStatus = new int[1];
+        GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compileStatus, 0);
+        if (compileStatus[0] == 0) {
+            Log.e(TAG, "Error compiling shader: " + GLES20.glGetShaderInfoLog(shader));
+            GLES20.glDeleteShader(shader);
+            return 0;
+        }
+        return shader;
+    }
+
+    @Override
+    public void initialize() {
+        String vertexSource = loadShaderSource(R.raw.vertex_shader);
+        String fragmentSource = loadShaderSource(R.raw.fragment_shader);
+        int vertexShader = createShader(GLES20.GL_VERTEX_SHADER, vertexSource);
+        int fragmentShader = createShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
+
+        program = GLES20.glCreateProgram();
+        GLES20.glAttachShader(program, vertexShader);
+        GLES20.glAttachShader(program, fragmentShader);
+        GLES20.glLinkProgram(program);
+
+        uMatrix = GLES20.glGetUniformLocation(program, "u_matrix");
+        uDataTexture = GLES20.glGetUniformLocation(program, "u_data_texture");
+        uColormapTexture = GLES20.glGetUniformLocation(program, "u_colormap_texture");
+        uOpacity = GLES20.glGetUniformLocation(program, "u_opacity");
+        uDataRange = GLES20.glGetUniformLocation(program, "u_data_range");
+        uScale = GLES20.glGetUniformLocation(program, "u_scale");
+        uOffset = GLES20.glGetUniformLocation(program, "u_offset");
+        uMissingQuantized = GLES20.glGetUniformLocation(program, "u_missing_quantized");
+        uTextureSize = GLES20.glGetUniformLocation(program, "u_texture_size");
+        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;
+        // Also clear any pending data to prevent a stale frame from rendering
+        synchronized (dataLock) {
+            pendingDataBuffer = null;
+        }
+    }
+
+    @Override
+    public void render(CustomLayerRenderParameters renderParameters) {
+        if (program == 0 || !isVisible) return;
+
+        synchronized (dataLock) {
+            if (pendingVertexBuffer != null && pendingIndexBuffer != null) {
+                this.indexCount = pendingIndexBuffer.capacity();
+                if (vboId == 0) {
+                    int[] bufs = new int[2];
+                    GLES20.glGenBuffers(2, bufs, 0);
+                    vboId = bufs[0];
+                    iboId = bufs[1];
+                }
+                GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboId);
+                GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, pendingVertexBuffer.capacity() * 4, pendingVertexBuffer, GLES20.GL_STATIC_DRAW);
+                GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, iboId);
+                GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER, pendingIndexBuffer.capacity() * 2, pendingIndexBuffer, GLES20.GL_STATIC_DRAW);
+                pendingVertexBuffer = null;
+                pendingIndexBuffer = null;
+            }
+
+            if (pendingDataBuffer != null) {
+                // --- FIX 2: LOGICAL FIX FOR TEXTURE RESIZING ---
+                boolean dimensionsChanged = (pendingNx != this.textureWidth || pendingNy != this.textureHeight);
+
+                this.textureWidth = pendingNx;
+                this.textureHeight = pendingNy;
+                this.scale = pendingScale;
+                this.offset = pendingOffset;
+                this.missingQuantized = pendingMissing;
+                this.scaleType = pendingScaleType;
+                
+                if (dataTextureId == 0) {
+                    int[] t = new int[1];
+                    GLES20.glGenTextures(1, t, 0);
+                    dataTextureId = t[0];
+                }
+                
+                GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, dataTextureId);
+
+                if (dimensionsChanged || dataTextureId == 0) {
+                    int filter = smoothingEnabled ? GLES20.GL_LINEAR : GLES20.GL_NEAREST;
+                    GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, filter);
+                    GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, filter);
+                    
+                    GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
+
+                    GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
+                    GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
+                    
+                    pendingDataBuffer.position(0);
+                    GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_ALPHA, pendingNx, pendingNy, 0, GLES20.GL_ALPHA, GLES20.GL_UNSIGNED_BYTE, pendingDataBuffer);
+                }  else {
+                    // Texture dimensions are the same, so just update its contents efficiently
+                    pendingDataBuffer.position(0);
+                    GLES20.glTexSubImage2D(GLES20.GL_TEXTURE_2D, 0, 0, 0, pendingNx, pendingNy, GLES20.GL_ALPHA, GLES20.GL_UNSIGNED_BYTE, pendingDataBuffer);
+                }
+                pendingDataBuffer = null;
+            }
+
+            if (pendingColormapBuffer != null) {
+                if (colormapTextureId == 0) {
+                    int[] t = new int[1];
+                    GLES20.glGenTextures(1, t, 0);
+                    colormapTextureId = t[0];
+                }
+                GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, colormapTextureId);
+                GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
+                GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_NEAREST);
+                GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
+                pendingColormapBuffer.position(0);
+                GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, 256, 1, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, pendingColormapBuffer);
+                pendingColormapBuffer = null;
+            }
+        }
+
+        double zoom = renderParameters.getZoom();
+
+        if (vboId == 0 || iboId == 0 || indexCount == 0 || dataTextureId == 0 || colormapTextureId == 0) return;
+
+        if (textureParametersDirty) {
+            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, dataTextureId);
+            int filter = smoothingEnabled ? GLES20.GL_LINEAR : GLES20.GL_NEAREST;
+            GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, filter);
+            GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, filter);
+            textureParametersDirty = false;
+        }
+
+        GLES20.glUseProgram(program);
+        
+        double scale = Math.pow(2.0, zoom);
+        
+        List<Double> matrix = renderParameters.getProjectionMatrix();
+        float[] floatMatrix = new float[16];
+        for (int i = 0; i < 16; i++) { 
+            floatMatrix[i] = matrix.get(i).floatValue(); 
+        }
+        
+        floatMatrix[0] *= scale; 
+        floatMatrix[1] *= scale;  
+        floatMatrix[4] *= scale;    
+        floatMatrix[5] *= scale;
+
+        GLES20.glUniformMatrix4fv(uMatrix, 1, false, floatMatrix, 0);
+        GLES20.glUniform1f(uOpacity, opacity);
+        GLES20.glUniform2fv(uDataRange, 1, dataRange, 0);
+        GLES20.glUniform1f(uScale, this.scale);
+        GLES20.glUniform1f(uOffset, offset);
+        GLES20.glUniform1f(uMissingQuantized, missingQuantized);
+        GLES20.glUniform2f(uTextureSize, (float) textureWidth, (float) textureHeight);
+        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);
+        GLES20.glUniform1i(uDataTexture, 0);
+        
+        GLES20.glActiveTexture(GLES20.GL_TEXTURE1);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, colormapTextureId);
+        GLES20.glUniform1i(uColormapTexture, 1);
+
+        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, vboId);
+        GLES20.glEnableVertexAttribArray(aPosition);
+        GLES20.glVertexAttribPointer(aPosition, 2, GLES20.GL_FLOAT, false, 16, 0);
+        GLES20.glEnableVertexAttribArray(aTexCoord);
+        GLES20.glVertexAttribPointer(aTexCoord, 2, GLES20.GL_FLOAT, false, 16, 8);
+        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, iboId);
+
+        GLES20.glEnable(GLES20.GL_BLEND);
+        GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);
+        GLES20.glDisable(GLES20.GL_DEPTH_TEST);
+        
+        GLES20.glDrawElements(GLES20.GL_TRIANGLES, indexCount, GLES20.GL_UNSIGNED_SHORT, 0);
+
+        GLES20.glDisableVertexAttribArray(aPosition);
+        GLES20.glDisableVertexAttribArray(aTexCoord);
+        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
+        GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, 0);
+    }
+
+    @Override
+    public void deinitialize() {
+        if (program != 0) { GLES20.glDeleteProgram(program); program = 0; }
+        int[] texturesToDelete = {dataTextureId, colormapTextureId};
+        GLES20.glDeleteTextures(2, texturesToDelete, 0);
+        dataTextureId = 0; colormapTextureId = 0;
+        int[] buffersToDelete = {vboId, iboId};
+        GLES20.glDeleteBuffers(2, buffersToDelete, 0);
+        vboId = 0; iboId = 0;
+    }
+
+    @Override
+    public void contextLost() {
+        program = 0; dataTextureId = 0; colormapTextureId = 0; vboId = 0; iboId = 0;
+    }
+
+    public void setOpacity(float opacity) { this.opacity = opacity; }
+    public void setDataRange(float[] dataRange) { this.dataRange = dataRange; }
+    public void setConversionType(int type) { this.conversionType = type; }
+    public void setSmoothing(boolean enabled) {
+        if (this.smoothingEnabled != enabled) {
+            this.smoothingEnabled = enabled;
+            this.textureParametersDirty = true;
+        }
+    }
+
+    // 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);
+        dataBuffer.put(bytes);
+        dataBuffer.position(0);
+        synchronized (dataLock) {
+            this.pendingDataBuffer = dataBuffer;
+            this.pendingNx = nx;
+            this.pendingNy = ny;
+            this.pendingScale = scale;
+            this.pendingOffset = offset;
+            this.pendingMissing = missing;
+            this.pendingScaleType = "sqrt".equals(scaleType) ? 1 : 0;
+        }
+        // When new data is provided, ensure the layer is visible
+        this.isVisible = true; 
+    }
+    
+    public void updateColormapTexture(ByteBuffer data) {
+        synchronized (dataLock) { this.pendingColormapBuffer = data; }
+    }
+
+    private void generateLCCGeometry(ReadableMap gridDefMap, ArrayList<Float> vertices, ArrayList<Short> indices) {
+        ReadableMap gridParams = gridDefMap.getMap("grid_params");
+        ReadableMap projParams = gridDefMap.getMap("proj_params");
+        
+        if (gridParams == null || projParams == null) {
+            Log.e(TAG, "Missing grid or projection parameters for LCC");
+            return;
+        }
+        
+        int nx = gridParams.getInt("nx");
+        int ny = gridParams.getInt("ny");
+        double dx = getDouble(gridParams, "dx", 0);
+        double dy = getDouble(gridParams, "dy", 0);
+        double x_origin = getDouble(gridParams, "x_origin", 0);
+        double y_origin = getDouble(gridParams, "y_origin", 0);
+        
+        int subdivisions = 60;
+        final double TILE_SIZE = 512.0;
+        
+        double x_min = x_origin;
+        double y_max = y_origin;
+        double x_max = x_origin + (nx - 1) * dx;
+        double y_min = y_origin + (ny - 1) * dy;
+        
+        Object[][] vertexGrid = new Object[subdivisions + 1][subdivisions + 1];
+        int validVertexCount = 0;
+        
+        for (int row = 0; row <= subdivisions; row++) {
+            for (int col = 0; col <= subdivisions; col++) {
+                double t_x = (double) col / subdivisions;
+                double t_y = (double) row / subdivisions;
+                
+                double proj_x = x_min + t_x * (x_max - x_min);
+                double proj_y = y_max + t_y * (y_min - y_max);
+                
+                double[] latLon = projectLCCToLatLon(proj_x, proj_y, projParams);
+                
+                if (latLon == null) {
+                    vertexGrid[row][col] = null;
+                    continue;
+                }
+                
+                double lon = latLon[0];
+                double lat = latLon[1];
+                
+                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;
+                
+                if (!Double.isFinite(mercX) || !Double.isFinite(mercY)) {
+                    vertexGrid[row][col] = null;
+                    continue;
+                }
+                
+                float tex_u = (float) t_x;
+                float tex_v = (float) t_y;
+                
+                VertexInfo vInfo = new VertexInfo();
+                vInfo.mercX = (float) mercX;
+                vInfo.mercY = (float) mercY;
+                vInfo.texU = tex_u;
+                vInfo.texV = tex_v;
+                vInfo.index = (short) validVertexCount;
+                
+                vertexGrid[row][col] = vInfo;
+                
+                vertices.add((float) mercX);
+                vertices.add((float) mercY);
+                vertices.add(tex_u);
+                vertices.add(tex_v);
+                
+                validVertexCount++;
+            }
+        }
+        
+        if (vertices.isEmpty()) {
+            Log.e(TAG, "No valid vertices generated for LCC grid");
+            return;
+        }
+        
+        for (int row = 0; row < subdivisions; row++) {
+            for (int col = 0; col < subdivisions; col++) {
+                VertexInfo topLeft = (VertexInfo) vertexGrid[row][col];
+                VertexInfo topRight = (VertexInfo) vertexGrid[row][col + 1];
+                VertexInfo bottomLeft = (VertexInfo) vertexGrid[row + 1][col];
+                VertexInfo bottomRight = (VertexInfo) vertexGrid[row + 1][col + 1];
+                
+                if (topLeft != null && topRight != null && bottomLeft != null && bottomRight != null) {
+                    indices.add(topLeft.index);
+                    indices.add(bottomLeft.index);
+                    indices.add(topRight.index);
+                    
+                    indices.add(topRight.index);
+                    indices.add(bottomLeft.index);
+                    indices.add(bottomRight.index);
+                }
+            }
+        }
+    }
+
+    private static class VertexInfo {
+        float mercX, mercY, texU, texV;
+        short index;
+    }
+
+    private double[] projectLCCToLatLon(double x, double y, ReadableMap projParams) {
+        try {
+            StringBuilder projString = new StringBuilder("+proj=lcc");
+            
+            if (projParams.hasKey("lat_1")) projString.append(" +lat_1=").append(projParams.getDouble("lat_1"));
+            if (projParams.hasKey("lat_2")) projString.append(" +lat_2=").append(projParams.getDouble("lat_2"));
+            if (projParams.hasKey("lat_0")) projString.append(" +lat_0=").append(projParams.getDouble("lat_0"));
+            if (projParams.hasKey("lon_0")) projString.append(" +lon_0=").append(projParams.getDouble("lon_0"));
+            if (projParams.hasKey("x_0")) projString.append(" +x_0=").append(projParams.getDouble("x_0"));
+            if (projParams.hasKey("y_0")) projString.append(" +y_0=").append(projParams.getDouble("y_0"));
+            if (projParams.hasKey("ellps")) projString.append(" +ellps=").append(projParams.getString("ellps"));
+            if (projParams.hasKey("a")) projString.append(" +a=").append(projParams.getDouble("a"));
+            if (projParams.hasKey("b")) projString.append(" +b=").append(projParams.getDouble("b"));
+            projString.append(" +units=m +no_defs");
+            
+            org.locationtech.proj4j.CRSFactory crsFactory = new org.locationtech.proj4j.CRSFactory();
+            org.locationtech.proj4j.CoordinateReferenceSystem srcCRS = crsFactory.createFromParameters("LCC", projString.toString());
+            org.locationtech.proj4j.CoordinateReferenceSystem dstCRS = crsFactory.createFromParameters("WGS84", "+proj=longlat +datum=WGS84 +no_defs");
+            
+            org.locationtech.proj4j.CoordinateTransformFactory ctFactory = new org.locationtech.proj4j.CoordinateTransformFactory();
+            org.locationtech.proj4j.CoordinateTransform transform = ctFactory.createTransform(srcCRS, dstCRS);
+            
+            org.locationtech.proj4j.ProjCoordinate srcCoord = new org.locationtech.proj4j.ProjCoordinate(x, y);
+            org.locationtech.proj4j.ProjCoordinate dstCoord = new org.locationtech.proj4j.ProjCoordinate();
+            transform.transform(srcCoord, dstCoord);
+            
+            return new double[]{dstCoord.x, dstCoord.y};
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error in LCC projection: " + e.getMessage());
+            return null;
+        }
+    }
+
+    private boolean isLCCType(ReadableMap gridDefMap) {
+        if (gridDefMap == null) return false;
+        ReadableMap projParams = gridDefMap.getMap("proj_params");
+        if (projParams == null) return false;
+        return projParams.hasKey("proj") && "lcc".equals(projParams.getString("proj"));
+    }
+
+    public void updateGeometry(ReadableMap cornersMap, ReadableMap gridDefMap) {
+        if (gridDefMap == null) return;
+        ArrayList<Float> vertices = new ArrayList<>();
+        ArrayList<Short> indices = new ArrayList<>();
+        generateGeometryData(gridDefMap, vertices, indices);
+        if (vertices.isEmpty() || indices.isEmpty()) {
+            Log.e(TAG, "Generated geometry is empty, aborting GPU buffer update.");
+            return;
+        }
+        FloatBuffer vb = ByteBuffer.allocateDirect(vertices.size() * 4).order(ByteOrder.nativeOrder()).asFloatBuffer();
+        float[] vertexArray = new float[vertices.size()];
+        for (int i = 0; i < vertices.size(); i++) vertexArray[i] = vertices.get(i);
+        vb.put(vertexArray).position(0);
+        ShortBuffer ib = ByteBuffer.allocateDirect(indices.size() * 2).order(ByteOrder.nativeOrder()).asShortBuffer();
+        short[] indexArray = new short[indices.size()];
+        for (int i = 0; i < indices.size(); i++) indexArray[i] = indices.get(i);
+        ib.put(indexArray).position(0);
+        synchronized (dataLock) {
+            pendingVertexBuffer = vb;
+            pendingIndexBuffer = ib;
+        }
+    }
+    
+    private boolean isGFSType(ReadableMap gridParams) {
+        if (gridParams == null) return false;
+        return getDouble(gridParams, "lon_first", -1) == 0.0 &&
+            Math.abs(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) {
+            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);
+                }
+            }
+            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;
+        }
+
+        // --- 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;
+
+                    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);
+                    }
+                }
+            }
+        }
+    }
 }