@aguacerowx/react-native 0.0.4 → 0.0.6

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

@@ -0,0 +1,597 @@
+// 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;  
+    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 textureParametersDirty = 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");
+        aPosition = GLES20.glGetAttribLocation(program, "a_position");
+        aTexCoord = GLES20.glGetAttribLocation(program, "a_texCoord");
+    }
+
+    @Override
+    public void render(CustomLayerRenderParameters renderParameters) {
+        if (program == 0) 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.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;
+        }
+    }
+
+    // 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;
+        }
+    }
+    
+    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;
+    }
+
+// 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;
+    }
+
+    // --- 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);
+                }
+            }
+        }
+    }
+}
+
+}