@aguacerowx/react-native 0.0.42 → 0.0.44

package/lib/commonjs/android/src/main/java/com/aguacerowx/reactnative/NexradRadarLayer.java

@@ -0,0 +1,906 @@
+package com.aguacerowx.reactnative;
+
+import android.content.Context;
+import android.opengl.GLES20;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+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.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Scanner;
+
+/**
+ * Mapbox Android custom layer port of mapsgl {@code MapboxRadarLayer} (NEXRAD gate texture + LUT).
+ * GPU uploads run in {@link #render} (GL thread), mirroring {@link GridRenderLayer}.
+ */
+public class NexradRadarLayer implements CustomLayerHost {
+
+    private static final String TAG = "AguaceroNexrad";
+    private static final int LUT_SIZE = 256;
+    /** Max decoded gate textures retained for instant scrub-back (matches JS controller). */
+    private static final int MAX_GPU_CACHED_FRAMES = 16;
+
+    /** Called on UI thread after a frame is registered in {@link #gpuFrameSlots} (GL thread). */
+    public interface GpuFrameRegisteredListener {
+        void onGpuFrameRegistered(@NonNull String nativeGpuCacheKey);
+    }
+
+    /** Per-frame GPU cache entry (gate texture + draw uniforms + geometry fingerprint). */
+    private static final class GpuFrameSlot {
+        final int gateTexId;
+        final int nGates;
+        final int nRays;
+        final float valueScale;
+        final float valueOffset;
+        final float discrete;
+        @NonNull final String geomKey;
+
+        GpuFrameSlot(
+                int gateTexId,
+                int nGates,
+                int nRays,
+                float valueScale,
+                float valueOffset,
+                float discrete,
+                @NonNull String geomKey) {
+            this.gateTexId = gateTexId;
+            this.nGates = nGates;
+            this.nRays = nRays;
+            this.valueScale = valueScale;
+            this.valueOffset = valueOffset;
+            this.discrete = discrete;
+            this.geomKey = geomKey;
+        }
+    }
+
+    private final Context context;
+    private final @Nullable GpuFrameRegisteredListener gpuFrameRegisteredListener;
+    private int program;
+    private int uMatrix;
+    private int uGateTexture;
+    private int uLutTexture;
+    private int uTextureSize;
+    private int uValueScaleOffset;
+    private int uLutValueRange;
+    private int uDiscreteIntegerLut;
+    private int uOpacity;
+    private int uGateSmoothPolar;
+    private int aPos;
+    private int aUv;
+
+    private int gateTextureId;
+    private int lutTextureId;
+    private int geometryBufferId;
+    /** Gate texture bound for sampling on draw (may differ from {@link #gateTextureId} when using cache). */
+    private int activeDrawGateTexId;
+
+    private volatile int activeVertCount;
+    private volatile float anchorMercatorX;
+    private volatile float anchorMercatorY;
+
+    private final Object lock = new Object();
+    private volatile boolean hasFrame;
+    private volatile boolean visible = true;
+
+    private byte[] pendingGateBytes;
+    private int pendingNGates;
+    private int pendingNRays;
+    private double pendingStationLat;
+    private double pendingStationLon;
+    private float pendingFirstGateKm;
+    private float pendingGateWidthKm;
+    private float[] pendingRayBoundaries;
+    private byte[] pendingLutRgba;
+    private float pendingValueScale = 1f;
+    private float pendingValueOffset = 0f;
+    private float pendingLutMin = 0f;
+    private float pendingLutMax = 80f;
+    private float pendingDiscrete = 0f;
+    private float pendingOpacity = 1f;
+    private float pendingGateSmooth = 1f;
+    private int pendingInterpolateLut = 1;
+    /** NONE = 0, FULL = 1, STYLE = 2, ACTIVATE_CACHED = 4 */
+    private volatile int pendingUploadKind;
+    @Nullable private String pendingNativeGpuCacheKey;
+    @Nullable private String pendingActivateCacheKey;
+    private volatile boolean pendingGpuSlotsClear;
+    /** Style-only request arrived while an activate (kind 4) was pending — run LUT upload right after activate on GL thread. */
+    private volatile boolean pendingStyleAfterActivate;
+
+    /** LRU (access-ordered): native cache key → slot. Only touched on GL thread. */
+    private final LinkedHashMap<String, GpuFrameSlot> gpuFrameSlots =
+            new LinkedHashMap<String, GpuFrameSlot>(32, 0.75f, true) {
+                private static final long serialVersionUID = 1L;
+            };
+
+    /** Logcat spam control */
+    private int renderCallCount;
+    private int glUploadSeq;
+    private boolean loggedFirstDraw;
+    private boolean loggedProgramZero;
+
+    /**
+     * When scrubbing timestamps, gate data changes but radar mesh often matches mapsgl
+     * {@code MapboxRadarLayer} geometry LRU — skip ray mesh rebuild and only re-upload textures.
+     */
+    private String committedGeometryKey;
+
+    public NexradRadarLayer(Context context, @Nullable GpuFrameRegisteredListener gpuFrameRegisteredListener) {
+        this.context = context.getApplicationContext();
+        this.gpuFrameRegisteredListener = gpuFrameRegisteredListener;
+    }
+
+    private static void drainGlErrors(@NonNull String where) {
+        int err;
+        int n = 0;
+        while ((err = GLES20.glGetError()) != GLES20.GL_NO_ERROR && n++ < 12) {
+            Log.e(TAG, "[NEXRAD] GL error after " + where + ": 0x" + Integer.toHexString(err));
+        }
+    }
+    private String loadRaw(int resId) {
+        InputStream is = context.getResources().openRawResource(resId);
+        return new Scanner(is).useDelimiter("\\A").next();
+    }
+
+    private int compileShader(int type, String src) {
+        int s = GLES20.glCreateShader(type);
+        GLES20.glShaderSource(s, src);
+        GLES20.glCompileShader(s);
+        int[] ok = new int[1];
+        GLES20.glGetShaderiv(s, GLES20.GL_COMPILE_STATUS, ok, 0);
+        if (ok[0] == 0) {
+            Log.e(TAG, GLES20.glGetShaderInfoLog(s));
+            GLES20.glDeleteShader(s);
+            return 0;
+        }
+        return s;
+    }
+
+    @Override
+    public void initialize() {
+        String vs = loadRaw(R.raw.nexrad_vertex);
+        String fs = loadRaw(R.raw.nexrad_fragment);
+        int vShader = compileShader(GLES20.GL_VERTEX_SHADER, vs);
+        int fShader = compileShader(GLES20.GL_FRAGMENT_SHADER, fs);
+        program = GLES20.glCreateProgram();
+        GLES20.glAttachShader(program, vShader);
+        GLES20.glAttachShader(program, fShader);
+        GLES20.glLinkProgram(program);
+        int[] linked = new int[1];
+        GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linked, 0);
+        if (linked[0] == 0) {
+            Log.e(TAG, GLES20.glGetProgramInfoLog(program));
+        }
+        GLES20.glDeleteShader(vShader);
+        GLES20.glDeleteShader(fShader);
+
+        uMatrix = GLES20.glGetUniformLocation(program, "u_matrix");
+        uGateTexture = GLES20.glGetUniformLocation(program, "u_gate_texture");
+        uLutTexture = GLES20.glGetUniformLocation(program, "u_lut_texture");
+        uTextureSize = GLES20.glGetUniformLocation(program, "u_texture_size");
+        uValueScaleOffset = GLES20.glGetUniformLocation(program, "u_value_scale_offset");
+        uLutValueRange = GLES20.glGetUniformLocation(program, "u_lut_value_range");
+        uDiscreteIntegerLut = GLES20.glGetUniformLocation(program, "u_discrete_integer_lut");
+        uOpacity = GLES20.glGetUniformLocation(program, "u_opacity");
+        uGateSmoothPolar = GLES20.glGetUniformLocation(program, "u_gate_smooth_polar");
+        aPos = GLES20.glGetAttribLocation(program, "a_pos");
+        aUv = GLES20.glGetAttribLocation(program, "a_uv");
+
+        int[] tex = new int[2];
+        GLES20.glGenTextures(2, tex, 0);
+        gateTextureId = tex[0];
+        lutTextureId = tex[1];
+
+        int[] buf = new int[1];
+        GLES20.glGenBuffers(1, buf, 0);
+        geometryBufferId = buf[0];
+        activeDrawGateTexId = gateTextureId;
+    }
+
+    private RadarRayGeometryBuilder.Result pendingGeomResult;
+
+    public void requestFullFrameUpload(
+            byte[] gateBytes,
+            int nGates,
+            int nRays,
+            double stationLat,
+            double stationLon,
+            float firstGateKm,
+            float gateWidthKm,
+            float[] rayBoundariesDeg,
+            byte[] lutRgba256,
+            float valueScale,
+            float valueOffset,
+            float lutMin,
+            float lutMax,
+            float discreteIntegerLut,
+            float opacity,
+            float gateSmoothPolar,
+            int interpolateLut,
+            @Nullable String nativeGpuCacheKey,
+            @Nullable RadarRayGeometryBuilder.Result geomResult) {
+        synchronized (lock) {
+            pendingGateBytes = gateBytes;
+            pendingNGates = nGates;
+            pendingNRays = nRays;
+            pendingStationLat = stationLat;
+            pendingStationLon = stationLon;
+            pendingFirstGateKm = firstGateKm;
+            pendingGateWidthKm = gateWidthKm;
+            pendingRayBoundaries = rayBoundariesDeg;
+            pendingLutRgba = lutRgba256;
+            pendingValueScale = valueScale;
+            pendingValueOffset = valueOffset;
+            pendingLutMin = lutMin;
+            pendingLutMax = lutMax;
+            pendingDiscrete = discreteIntegerLut;
+            pendingOpacity = opacity;
+            pendingGateSmooth = gateSmoothPolar;
+            pendingInterpolateLut = interpolateLut;
+            pendingNativeGpuCacheKey = nativeGpuCacheKey;
+            pendingGeomResult = geomResult;
+            pendingUploadKind = 1;
+            visible = true;
+        }
+    }
+
+    /**
+     * Instant scrub to a frame whose gate texture was previously registered (see {@link #gpuFrameSlots}).
+     * Style (LUT/opacity) must be applied separately if needed.
+     */
+    public void requestActivateCachedFrame(@NonNull String nativeGpuCacheKey) {
+        synchronized (lock) {
+            pendingActivateCacheKey = nativeGpuCacheKey;
+            pendingUploadKind = 4;
+        }
+    }
+
+    public void requestStyleOnlyUpload(
+            byte[] lutRgba256,
+            float valueScale,
+            float valueOffset,
+            float lutMin,
+            float lutMax,
+            float discreteIntegerLut,
+            float opacity,
+            float gateSmoothPolar,
+            int interpolateLut
+    ) {
+        synchronized (lock) {
+            pendingLutRgba = lutRgba256;
+            pendingValueScale = valueScale;
+            pendingValueOffset = valueOffset;
+            pendingLutMin = lutMin;
+            pendingLutMax = lutMax;
+            pendingDiscrete = discreteIntegerLut;
+            pendingOpacity = opacity;
+            pendingGateSmooth = gateSmoothPolar;
+            pendingInterpolateLut = interpolateLut;
+            if (pendingUploadKind == 4) {
+                pendingStyleAfterActivate = true;
+            } else {
+                pendingUploadKind = 2;
+            }
+        }
+    }
+
+    public void clearFrame() {
+        synchronized (lock) {
+            hasFrame = false;
+            activeVertCount = 0;
+            pendingUploadKind = 0;
+            committedGeometryKey = null;
+            pendingGpuSlotsClear = true;
+            pendingStyleAfterActivate = false;
+        }
+    }
+
+    /** GL thread: delete cached gate textures (except primary {@link #gateTextureId}). */
+    private void clearGpuFrameSlotsOnGlThread() {
+        for (GpuFrameSlot s : new ArrayList<>(gpuFrameSlots.values())) {
+            if (s.gateTexId != 0 && s.gateTexId != gateTextureId) {
+                GLES20.glDeleteTextures(1, new int[] {s.gateTexId}, 0);
+            }
+        }
+        gpuFrameSlots.clear();
+        activeDrawGateTexId = gateTextureId;
+    }
+
+    /**
+     * Resolve gate GL texture for an upload. LRU-evicts oldest slots when at capacity (GL thread only).
+     */
+    private int obtainGateTextureForCacheKey(@Nullable String cacheKey) {
+        if (cacheKey == null || cacheKey.isEmpty()) {
+            return gateTextureId;
+        }
+        GpuFrameSlot ex = gpuFrameSlots.get(cacheKey);
+        if (ex != null) {
+            gpuFrameSlots.remove(cacheKey);
+            gpuFrameSlots.put(cacheKey, ex);
+            return ex.gateTexId;
+        }
+        while (gpuFrameSlots.size() >= MAX_GPU_CACHED_FRAMES) {
+            Iterator<Map.Entry<String, GpuFrameSlot>> it = gpuFrameSlots.entrySet().iterator();
+            if (!it.hasNext()) break;
+            Map.Entry<String, GpuFrameSlot> e = it.next();
+            it.remove();
+            int tid = e.getValue().gateTexId;
+            if (tid != 0 && tid != gateTextureId) {
+                GLES20.glDeleteTextures(1, new int[] {tid}, 0);
+            }
+        }
+        int[] tid = new int[1];
+        GLES20.glGenTextures(1, tid, 0);
+        return tid[0];
+    }
+
+    private void registerGpuFrameSlot(
+            @Nullable String cacheKey,
+            int gateTexId,
+            int nGates,
+            int nRays,
+            float vs,
+            float vo,
+            float discrete,
+            @NonNull String geomKey) {
+        if (cacheKey == null || cacheKey.isEmpty()) {
+            return;
+        }
+        GpuFrameSlot old = gpuFrameSlots.remove(cacheKey);
+        if (old != null && old.gateTexId != gateTexId && old.gateTexId != gateTextureId) {
+            GLES20.glDeleteTextures(1, new int[] {old.gateTexId}, 0);
+        }
+        GpuFrameSlot slot = new GpuFrameSlot(gateTexId, nGates, nRays, vs, vo, discrete, geomKey);
+        while (gpuFrameSlots.size() >= MAX_GPU_CACHED_FRAMES) {
+            Iterator<Map.Entry<String, GpuFrameSlot>> it = gpuFrameSlots.entrySet().iterator();
+            if (!it.hasNext()) break;
+            Map.Entry<String, GpuFrameSlot> e = it.next();
+            if (e.getKey().equals(cacheKey)) break;
+            it.remove();
+            int tid = e.getValue().gateTexId;
+            if (tid != 0 && tid != gateTextureId) {
+                GLES20.glDeleteTextures(1, new int[] {tid}, 0);
+            }
+        }
+        gpuFrameSlots.put(cacheKey, slot);
+    }
+
+    private void notifyGpuFrameRegistered(@Nullable String cacheKey) {
+        if (cacheKey == null || cacheKey.isEmpty()) {
+            return;
+        }
+        final GpuFrameRegisteredListener listener = gpuFrameRegisteredListener;
+        if (listener != null) {
+            listener.onGpuFrameRegistered(cacheKey);
+        }
+    }
+
+    /** FNV-1a fingerprint of ray boundaries — aligned with mapsgl {@code fingerprintRayBoundariesDegQuantized}. */
+    private static String fingerprintRayBoundariesDeg(float[] b, int unitsPerDeg) {
+        if (b == null || b.length == 0) return "0";
+        int h = (int) 2166136261L;
+        int n = b.length;
+        for (int i = 0; i < n; i++) {
+            int v = Math.round(b[i] * (float) unitsPerDeg);
+            h ^= v;
+            h *= 16777619;
+        }
+        h ^= n * 73856093;
+        long uh = h & 0xFFFFFFFFL;
+        return Long.toString(uh, 36);
+    }
+
+    public static String buildGeometryCacheKey(
+            int nRays,
+            int nGates,
+            double stationLat,
+            double stationLon,
+            float firstGateKm,
+            float gateWidthKm,
+            float[] rayBoundariesDeg) {
+        String base =
+                stationLat
+                        + ","
+                        + stationLon
+                        + ","
+                        + firstGateKm
+                        + ","
+                        + gateWidthKm
+                        + ","
+                        + nRays
+                        + ","
+                        + nGates;
+        String rb = fingerprintRayBoundariesDeg(rayBoundariesDeg, 1000);
+        return base + ",rb:" + rb;
+    }
+
+    public boolean isGeometryCommitted(String geomKey) {
+        synchronized (lock) {
+            return committedGeometryKey != null && committedGeometryKey.equals(geomKey);
+        }
+    }
+
+    public void setVisible(boolean v) {
+        this.visible = v;
+    }
+
+    private void applyLutUploadGL() {
+        byte[] lut = pendingLutRgba;
+        if (lut == null || lut.length < LUT_SIZE * 4) return;
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, lutTextureId);
+        int lutFilter = pendingInterpolateLut != 0 ? GLES20.GL_LINEAR : GLES20.GL_NEAREST;
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, lutFilter);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, lutFilter);
+        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);
+        ByteBuffer lutBuf = ByteBuffer.allocateDirect(lut.length).order(ByteOrder.nativeOrder());
+        lutBuf.put(lut);
+        lutBuf.position(0);
+        GLES20.glTexImage2D(
+                GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, LUT_SIZE, 1, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, lutBuf);
+    }
+
+    @Override
+    public void render(CustomLayerRenderParameters params) {
+        renderCallCount++;
+        final int tick = renderCallCount;
+
+        if (program == 0) {
+            if (!loggedProgramZero) {
+                loggedProgramZero = true;
+                Log.w(TAG, "[NEXRAD] render: program=0 (GL not initialized or context lost)");
+            }
+            return;
+        }
+
+        synchronized (lock) {
+            if (pendingGpuSlotsClear) {
+                pendingGpuSlotsClear = false;
+                clearGpuFrameSlotsOnGlThread();
+                if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE) {
+                    Log.i(TAG, "[NEXRAD][PERF] glUpload gpuSlotCacheCleared tick=" + tick);
+                }
+            }
+
+            int kind = pendingUploadKind;
+            if (kind != 0) {
+                final long tPendingStart = System.nanoTime();
+                if (kind == 4) {
+                    final String actKey = pendingActivateCacheKey;
+                    pendingUploadKind = 0;
+                    pendingActivateCacheKey = null;
+                    GpuFrameSlot slot = actKey != null ? gpuFrameSlots.get(actKey) : null;
+                    if (slot == null) {
+                        if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE) {
+                            Log.w(
+                                    TAG,
+                                    String.format(
+                                            Locale.US,
+                                            "[NEXRAD][PERF] glUpload activateCached MISS tick=%d keyTail=%s cacheSize=%d",
+                                            tick,
+                                            actKey != null && actKey.length() > 80 ? actKey.substring(actKey.length() - 80) : actKey,
+                                            gpuFrameSlots.size()));
+                        }
+                    } else if (activeVertCount <= 0) {
+                        if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE) {
+                            Log.w(TAG, "[NEXRAD][PERF] glUpload activateCached SKIP noMesh tick=" + tick);
+                        }
+                    } else if (committedGeometryKey != null && !committedGeometryKey.equals(slot.geomKey)) {
+                        if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE) {
+                            Log.w(
+                                    TAG,
+                                    String.format(
+                                            Locale.US,
+                                            "[NEXRAD][PERF] glUpload activateCached SKIP geomMismatch tick=%d committed=%s slot=%s",
+                                            tick,
+                                            committedGeometryKey.length() > 48
+                                                    ? committedGeometryKey.substring(0, 48)
+                                                    : committedGeometryKey,
+                                            slot.geomKey.length() > 48 ? slot.geomKey.substring(0, 48) : slot.geomKey));
+                        }
+                    } else {
+                        activeDrawGateTexId = slot.gateTexId;
+                        pendingNGates = slot.nGates;
+                        pendingNRays = slot.nRays;
+                        pendingValueScale = slot.valueScale;
+                        pendingValueOffset = slot.valueOffset;
+                        pendingDiscrete = slot.discrete;
+                        hasFrame = activeVertCount > 0;
+                        if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE) {
+                            Log.i(
+                                    TAG,
+                                    String.format(
+                                            Locale.US,
+                                            "[NEXRAD][PERF] glUpload activateCached OK tick=%d gateTex=%d nGates=%d nRays=%d vs=%.6f vo=%.6f totalMs=%.3f",
+                                            tick,
+                                            slot.gateTexId,
+                                            slot.nGates,
+                                            slot.nRays,
+                                            slot.valueScale,
+                                            slot.valueOffset,
+                                            (System.nanoTime() - tPendingStart) / 1_000_000.0));
+                        }
+                    }
+                }
+                if (pendingStyleAfterActivate && hasFrame) {
+                    pendingStyleAfterActivate = false;
+                    long mark = System.nanoTime();
+                    applyLutUploadGL();
+                    double lutAfterActMs = (System.nanoTime() - mark) / 1_000_000.0;
+                    drainGlErrors("style-after-activate lut");
+                    if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE) {
+                        Log.i(
+                                TAG,
+                                String.format(
+                                        Locale.US,
+                                        "[NEXRAD][PERF] glUpload styleAfterActivate tick=%d lutMs=%.3f seq=%d",
+                                        tick,
+                                        lutAfterActMs,
+                                        glUploadSeq));
+                    }
+                }
+                if (kind == 2 && hasFrame) {
+                    long mark = System.nanoTime();
+                    applyLutUploadGL();
+                    double lutOnlyMs = (System.nanoTime() - mark) / 1_000_000.0;
+                    drainGlErrors("style-only lut");
+                    pendingUploadKind = 0;
+                    if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE) {
+                        Log.i(
+                                TAG,
+                                String.format(
+                                        Locale.US,
+                                        "[NEXRAD][PERF] glUpload styleOnly tick=%d lutMs=%.3f pendingTotalMs=%.3f seq=%d",
+                                        tick,
+                                        lutOnlyMs,
+                                        (System.nanoTime() - tPendingStart) / 1_000_000.0,
+                                        glUploadSeq));
+                    }
+                } else if (kind == 1 && pendingGateBytes != null && pendingRayBoundaries != null) {
+                    int expectedGateBytes = pendingNGates * pendingNRays * 2;
+                    String geomKey =
+                            buildGeometryCacheKey(
+                                    pendingNRays,
+                                    pendingNGates,
+                                    pendingStationLat,
+                                    pendingStationLon,
+                                    pendingFirstGateKm,
+                                    pendingGateWidthKm,
+                                    pendingRayBoundaries);
+                    boolean reuseMesh =
+                            hasFrame
+                                    && activeVertCount > 0
+                                    && committedGeometryKey != null
+                                    && committedGeometryKey.equals(geomKey)
+                                    && pendingGateBytes.length == expectedGateBytes
+                                    && pendingRayBoundaries.length == pendingNRays + 1;
+
+                    double geomBuildMs = 0;
+                    double bufferDataMs = 0;
+                    if (!reuseMesh) {
+                        RadarRayGeometryBuilder.Result geom = pendingGeomResult;
+                        if (geom != null) {
+                            activeVertCount = geom.vertexCount;
+                            anchorMercatorX = geom.anchorMercatorX;
+                            anchorMercatorY = geom.anchorMercatorY;
+
+                            FloatBuffer vb = geom.vertexBuffer;
+                            GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, geometryBufferId);
+                            int bytes = vb.capacity() * 4;
+                            vb.position(0);
+                            long mark = System.nanoTime();
+                            GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, bytes, vb, GLES20.GL_STATIC_DRAW);
+                            bufferDataMs = (System.nanoTime() - mark) / 1_000_000.0;
+                            GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
+                            committedGeometryKey = geomKey;
+                        }
+                    }
+                    pendingGeomResult = null;
+
+                    final String cacheKeySnapshot = pendingNativeGpuCacheKey;
+                    pendingNativeGpuCacheKey = null;
+                    int texTarget = obtainGateTextureForCacheKey(cacheKeySnapshot);
+
+                    long mark = System.nanoTime();
+                    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texTarget);
+                    GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
+                    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);
+                    GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
+                    ByteBuffer gateBuf = ByteBuffer.wrap(pendingGateBytes);
+                    GLES20.glTexImage2D(
+                            GLES20.GL_TEXTURE_2D,
+                            0,
+                            GLES20.GL_LUMINANCE_ALPHA,
+                            pendingNGates,
+                            pendingNRays,
+                            0,
+                            GLES20.GL_LUMINANCE_ALPHA,
+                            GLES20.GL_UNSIGNED_BYTE,
+                            gateBuf);
+                    double gateTexMs = (System.nanoTime() - mark) / 1_000_000.0;
+                    drainGlErrors("glTexImage2D gate LA " + pendingNGates + "x" + pendingNRays);
+
+                    mark = System.nanoTime();
+                    applyLutUploadGL();
+                    double lutMs = (System.nanoTime() - mark) / 1_000_000.0;
+                    drainGlErrors("applyLutUploadGL");
+
+                    activeDrawGateTexId = texTarget;
+                    hasFrame = activeVertCount > 0;
+                    pendingUploadKind = 0;
+                    glUploadSeq++;
+                    double pendingTotalMs = (System.nanoTime() - tPendingStart) / 1_000_000.0;
+
+                    registerGpuFrameSlot(
+                            cacheKeySnapshot,
+                            texTarget,
+                            pendingNGates,
+                            pendingNRays,
+                            pendingValueScale,
+                            pendingValueOffset,
+                            pendingDiscrete,
+                            geomKey);
+                    notifyGpuFrameRegistered(cacheKeySnapshot);
+
+                    if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE) {
+                        Log.i(
+                                TAG,
+                                String.format(
+                                        Locale.US,
+                                        "[NEXRAD][PERF] glUpload full tick=%d reuseMesh=%s verts=%d gate=%dx%d "
+                                                + "geomBuildMs=%.3f bufferDataMs=%.3f gateTexMs=%.3f lutMs=%.3f pendingTotalMs=%.3f seq=%d "
+                                                + "cacheKey=%s texTarget=%d cacheSlots=%d",
+                                        tick,
+                                        Boolean.toString(reuseMesh),
+                                        activeVertCount,
+                                        pendingNGates,
+                                        pendingNRays,
+                                        geomBuildMs,
+                                        bufferDataMs,
+                                        gateTexMs,
+                                        lutMs,
+                                        pendingTotalMs,
+                                        glUploadSeq,
+                                        cacheKeySnapshot != null && !cacheKeySnapshot.isEmpty() ? "yes" : "no",
+                                        texTarget,
+                                        gpuFrameSlots.size()));
+                        Log.i(
+                                TAG,
+                                (reuseMesh ? "[NEXRAD] GL gate+LUT only (mesh reused) verts=" : "[NEXRAD] GL frame buffers uploaded verts=")
+                                        + activeVertCount
+                                        + " gateTex="
+                                        + pendingNGates
+                                        + "x"
+                                        + pendingNRays
+                                        + " anchorMerc=("
+                                        + anchorMercatorX
+                                        + ","
+                                        + anchorMercatorY
+                                        + ") seq="
+                                        + glUploadSeq
+                                        + " vs="
+                                        + pendingValueScale
+                                        + " vo="
+                                        + pendingValueOffset
+                                        + " lut=("
+                                        + pendingLutMin
+                                        + ","
+                                        + pendingLutMax
+                                        + ") tile512");
+                    }
+                } else if (kind == 1) {
+                    if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE) {
+                        Log.w(
+                                TAG,
+                                "[NEXRAD] full upload pending but incomplete: gateBytes="
+                                        + (pendingGateBytes != null ? pendingGateBytes.length : -1)
+                                        + " rays="
+                                        + (pendingRayBoundaries != null ? pendingRayBoundaries.length : -1));
+                    }
+                }
+            }
+        }
+
+        if (!visible) {
+            if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE && (tick <= 3 || tick % 180 == 0)) {
+                Log.i(TAG, "[NEXRAD] render skip: visible=false tick=" + tick);
+            }
+            return;
+        }
+
+        int vc;
+        float ax, ay;
+        float vs, vo, lmin, lmax, disc, op, gsm;
+        int tw, th;
+        synchronized (lock) {
+            if (!hasFrame || activeVertCount <= 0) {
+                if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE && (tick <= 5 || tick % 180 == 0)) {
+                    Log.i(TAG, "[NEXRAD] render skip: no drawable mesh hasFrame=" + hasFrame + " verts=" + activeVertCount);
+                }
+                return;
+            }
+            vc = activeVertCount;
+            ax = anchorMercatorX;
+            ay = anchorMercatorY;
+            vs = pendingValueScale;
+            vo = pendingValueOffset;
+            lmin = pendingLutMin;
+            lmax = pendingLutMax;
+            disc = pendingDiscrete;
+            op = pendingOpacity;
+            gsm = pendingGateSmooth;
+            tw = pendingNGates;
+            th = pendingNRays;
+        }
+
+        List<Double> matrixList = params.getProjectionMatrix();
+        float[] matrix = new float[16];
+        double[] md = new double[16];
+        for (int i = 0; i < 16; i++) {
+            double d = matrixList.get(i);
+            md[i] = d;
+            matrix[i] = (float) d;
+        }
+
+        // Same as {@link GridRenderLayer}: Android Mapbox custom-layer projection matrices use a
+        // coordinate convention where the linear 3x4 block (column-major indices 0-11) is scaled by
+        // 2^zoom. {@link RadarRayGeometryBuilder} emits vertex x/y and anchor in mercator*512 space
+        // to match the grid; Web GL JS uses raw normalized mercator with a different matrix.
+        double zoom = params.getZoom();
+        double mercatorScale = Math.pow(2.0, zoom);
+        for (int i = 0; i < 12; i++) {
+            md[i] *= mercatorScale;
+            matrix[i] *= mercatorScale;
+        }
+
+        float shifted12 = (float) (md[0] * ax + md[4] * ay + md[12]);
+        float shifted13 = (float) (md[1] * ax + md[5] * ay + md[13]);
+        float shifted14 = (float) (md[2] * ax + md[6] * ay + md[14]);
+        float shifted15 = (float) (md[3] * ax + md[7] * ay + md[15]);
+        matrix[12] = shifted12;
+        matrix[13] = shifted13;
+        matrix[14] = shifted14;
+        matrix[15] = shifted15;
+
+        if (AguaceroDebugLog.NEXRAD_NATIVE_VERBOSE && (!loggedFirstDraw || tick % 120 == 0)) {
+            Log.i(
+                    TAG,
+                    "[NEXRAD] draw tick="
+                            + tick
+                            + " verts="
+                            + vc
+                            + " tex="
+                            + tw
+                            + "x"
+                            + th
+                            + " anchor=("
+                            + ax
+                            + ","
+                            + ay
+                            + ") zoom="
+                            + String.format(java.util.Locale.US, "%.3f", zoom)
+                            + " mercS="
+                            + String.format(java.util.Locale.US, "%.3f", mercatorScale)
+                            + " m0-3=("
+                            + matrix[0]
+                            + ","
+                            + matrix[1]
+                            + ","
+                            + matrix[2]
+                            + ","
+                            + matrix[3]
+                            + ") m12-15=("
+                            + matrix[12]
+                            + ","
+                            + matrix[13]
+                            + ","
+                            + matrix[14]
+                            + ","
+                            + matrix[15]
+                            + ") lut=("
+                            + lmin
+                            + ","
+                            + lmax
+                            + ") vs="
+                            + vs
+                            + " vo="
+                            + vo
+                            + " op="
+                            + op
+                            + " gsm="
+                            + gsm);
+            loggedFirstDraw = true;
+        }
+
+        GLES20.glUseProgram(program);
+        GLES20.glUniformMatrix4fv(uMatrix, 1, false, matrix, 0);
+
+        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, activeDrawGateTexId);
+        GLES20.glUniform1i(uGateTexture, 0);
+
+        GLES20.glActiveTexture(GLES20.GL_TEXTURE1);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, lutTextureId);
+        GLES20.glUniform1i(uLutTexture, 1);
+
+        GLES20.glUniform2f(uTextureSize, tw, th);
+        GLES20.glUniform2f(uValueScaleOffset, vs, vo);
+        GLES20.glUniform2f(uLutValueRange, lmin, lmax);
+        GLES20.glUniform1f(uDiscreteIntegerLut, disc);
+        GLES20.glUniform1f(uOpacity, op);
+        GLES20.glUniform1f(uGateSmoothPolar, gsm);
+
+        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, geometryBufferId);
+        GLES20.glEnableVertexAttribArray(aPos);
+        GLES20.glVertexAttribPointer(aPos, 2, GLES20.GL_FLOAT, false, 16, 0);
+        GLES20.glEnableVertexAttribArray(aUv);
+        GLES20.glVertexAttribPointer(aUv, 2, GLES20.GL_FLOAT, false, 16, 8);
+
+        GLES20.glEnable(GLES20.GL_BLEND);
+        GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);
+        GLES20.glDisable(GLES20.GL_DEPTH_TEST);
+
+        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, vc);
+        drainGlErrors("glDrawArrays tri=" + vc);
+
+        GLES20.glDisableVertexAttribArray(aPos);
+        GLES20.glDisableVertexAttribArray(aUv);
+        GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+    }
+    @Override
+    public void deinitialize() {
+        for (GpuFrameSlot s : new ArrayList<>(gpuFrameSlots.values())) {
+            if (s.gateTexId != 0) {
+                GLES20.glDeleteTextures(1, new int[] {s.gateTexId}, 0);
+            }
+        }
+        gpuFrameSlots.clear();
+        if (program != 0) {
+            GLES20.glDeleteProgram(program);
+            program = 0;
+        }
+        if (gateTextureId != 0 || lutTextureId != 0) {
+            int[] tex = {gateTextureId, lutTextureId};
+            GLES20.glDeleteTextures(2, tex, 0);
+            gateTextureId = 0;
+            lutTextureId = 0;
+        }
+        activeDrawGateTexId = 0;
+        if (geometryBufferId != 0) {
+            GLES20.glDeleteBuffers(1, new int[] {geometryBufferId}, 0);
+            geometryBufferId = 0;
+        }
+    }
+
+    @Override
+    public void contextLost() {
+        program = 0;
+        gateTextureId = 0;
+        lutTextureId = 0;
+        geometryBufferId = 0;
+        activeDrawGateTexId = 0;
+        loggedProgramZero = false;
+        synchronized (lock) {
+            gpuFrameSlots.clear();
+            committedGeometryKey = null;
+            hasFrame = false;
+            activeVertCount = 0;
+        }
+    }
+}