@aguacerowx/react-native 0.0.46 → 0.0.49

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

@@ -1,906 +0,0 @@
-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;
-        }
-    }
-}