@aguacerowx/react-native 0.0.51 → 0.0.53

package/android/src/main/cpp/satellite_ktx_jni.cpp

@@ -8,6 +8,7 @@
 
 #define LOG_TAG "AguaceroSatKtx"
 #define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
+#define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
 
 namespace {
 
@@ -104,10 +105,13 @@ Java_com_aguacerowx_reactnative_SatelliteKtxDecoder_nativeTranscodeKtx2(
     std::vector<uint8_t> out_pixels;
     basist::transcoder_texture_format used_fmt = basist::transcoder_texture_format::cTFTotalTextureFormats;
 
+    // Android: prefer ETC2 (GLES 3.0 baseline), then uncompressed RGBA32, then ASTC last.
+    // CPU-side ASTC transcode can succeed while Mapbox's GL context cannot sample it → black tiles.
+    // Web (satelliteKtxWorker.js) probes WebGL extensions before picking ASTC; match that intent here.
     static const basist::transcoder_texture_format k_try_order[] = {
-            basist::transcoder_texture_format::cTFASTC_LDR_4x4_RGBA,
             basist::transcoder_texture_format::cTFETC2_RGBA,
             basist::transcoder_texture_format::cTFRGBA32,
+            basist::transcoder_texture_format::cTFASTC_LDR_4x4_RGBA,
     };
 
     bool ok = false;
@@ -131,6 +135,7 @@ Java_com_aguacerowx_reactnative_SatelliteKtxDecoder_nativeTranscodeKtx2(
     }
 
     const int32_t fmt_ordinal = static_cast<int32_t>(used_fmt);
+    ALOGI("KTX2 transcoded %ux%u to format ordinal %d", width, height, fmt_ordinal);
 
     const uint32_t header_size = 20;
     const uint32_t payload_size = static_cast<uint32_t>(out_pixels.size());

package/android/src/main/java/com/aguacerowx/reactnative/SatelliteLayer.java

@@ -26,11 +26,46 @@ import java.util.Map;
 public class SatelliteLayer implements CustomLayerHost {
 
     private static final String TAG = "AguaceroSatellite";
+    /** Matches Metro filter {@code [AguaceroRN][satellite]} when debug is on. */
+    private static final String DIAG_TAG = "AguaceroRN";
     private static final int MAX_GPU_CACHED_FRAMES = 64;
 
+    private static volatile boolean debugLogging = false;
+    private int debugRenderTick = 0;
+
     private static final int GL_COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0;
     private static final int GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278;
 
+    public static void setDebugLogging(boolean enabled) {
+        debugLogging = enabled;
+    }
+
+    private static void diag(String msg) {
+        if (debugLogging) {
+            android.util.Log.w(DIAG_TAG, "[satellite.native] " + msg);
+        }
+    }
+
+    private static String basisFormatName(int fmt) {
+        if (fmt == SatelliteKtxDecoder.TF_ETC2_RGBA) return "ETC2_RGBA";
+        if (fmt == SatelliteKtxDecoder.TF_ASTC_LDR_4x4_RGBA) return "ASTC_LDR_4x4";
+        if (fmt == SatelliteKtxDecoder.TF_RGBA32) return "RGBA32";
+        return "ordinal_" + fmt;
+    }
+
+    /** Snapshot for debug events (thread-safe). */
+    public void fillDebugSnapshot(@NonNull java.util.Map<String, Object> out) {
+        synchronized (lock) {
+            out.put("cachedFrameCount", cache.size());
+            out.put("pendingGpuUploads", pendingGpuQueue.size());
+            out.put("activeUnix", activeUnix);
+            out.put("targetUnix", targetUnix);
+            out.put("visible", visible);
+            out.put("opacity", opacity);
+            out.put("programReady", program != 0);
+        }
+    }
+
     private final Object lock = new Object();
 
     private int program;
@@ -197,6 +232,17 @@ public class SatelliteLayer implements CustomLayerHost {
         defaultIrColormapTex = uploadColormapTexture(ir);
         defaultWvColormapTex = uploadColormapTexture(wv);
         userColormapTex = 0;
+
+        if (debugLogging) {
+            String ext = GLES20.glGetString(GLES20.GL_EXTENSIONS);
+            if (ext == null) ext = "";
+            diag(
+                    "gl.extensions hasASTC="
+                            + ext.contains("ASTC")
+                            + " hasETC2="
+                            + (ext.contains("ETC2") || ext.contains("EAC"))
+                            + " (black geocolor tiles often mean ASTC upload on unsupported GPU)");
+        }
     }
 
     private int uploadColormapTexture(byte[] rgba) {
@@ -401,6 +447,51 @@ public class SatelliteLayer implements CustomLayerHost {
             return null;
         }
 
+        int glErr = GLES20.glGetError();
+        if (glErr != GLES20.GL_NO_ERROR) {
+            Log.w(
+                    TAG,
+                    "GPU texture upload failed (GL 0x"
+                            + Integer.toHexString(glErr)
+                            + ") fmt="
+                            + fmt
+                            + " "
+                            + w
+                            + "x"
+                            + h
+                            + " — device may not support this compressed format; rebuild SDK with latest KTX transcode order");
+            diag(
+                    "gpu.upload.fail unix="
+                            + p.unix
+                            + " gl=0x"
+                            + Integer.toHexString(glErr)
+                            + " fmt="
+                            + basisFormatName(fmt)
+                            + " "
+                            + w
+                            + "x"
+                            + h
+                            + " trueColor="
+                            + p.trueColor);
+            GLES20.glDeleteTextures(1, texArr, 0);
+            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+            return null;
+        }
+
+        diag(
+                "gpu.upload.ok unix="
+                        + p.unix
+                        + " fmt="
+                        + basisFormatName(fmt)
+                        + " "
+                        + w
+                        + "x"
+                        + h
+                        + " trueColor="
+                        + p.trueColor
+                        + " useColormap="
+                        + p.useColormap);
+
         GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
 
         FloatBuffer vb = p.mesh.vertexBuffer;
@@ -459,7 +550,36 @@ public class SatelliteLayer implements CustomLayerHost {
         synchronized (lock) {
             draw = activeUnix != null ? cache.get(activeUnix) : null;
         }
-        if (draw == null || draw.indexCount <= 0) return;
+        if (draw == null || draw.indexCount <= 0) {
+            if (debugLogging && ++debugRenderTick % 90 == 0) {
+                synchronized (lock) {
+                    diag(
+                            "render.noDraw targetUnix="
+                                    + targetUnix
+                                    + " activeUnix="
+                                    + activeUnix
+                                    + " cached="
+                                    + cache.size()
+                                    + " pendingUploads="
+                                    + pendingGpuQueue.size()
+                                    + " visible="
+                                    + visible
+                                    + " opacity="
+                                    + opacity);
+                }
+            }
+            return;
+        }
+
+        if (debugLogging && debugRenderTick % 180 == 0) {
+            diag(
+                    "render.drawing unix="
+                            + draw.unix
+                            + " trueColor="
+                            + draw.trueColor
+                            + " indexCount="
+                            + draw.indexCount);
+        }
 
         GLES20.glUseProgram(program);