react-native-cesium 1.2.7 → 1.2.9

package/android/src/main/cpp/vulkan/shaders/terrain.frag

@@ -27,7 +27,7 @@ layout(push_constant) uniform PC {
   float translationY;       // byte  112
   float scaleX;             // byte  116
   float scaleY;             // byte  120
-  float _pad;               // byte  124
+  float lodFade;            // byte  124
 } pc;
 
 layout(set = 1, binding = 0) uniform sampler2D overlayTex;
@@ -56,6 +56,20 @@ vec3 hypsometricColor(float alt, float steep) {
 }
 
 void main() {
+#ifdef TERRAIN_DITHER
+  // ── LOD transition dither (IGN / Jorge Jimenez) ─────────────────────────────
+  // Compiled only into the dither pipeline so the solid pipeline keeps the GPU's
+  // early-Z optimisation enabled at full speed.  Interleaved Gradient Noise
+  // produces a per-pixel threshold approximating blue noise without a texture
+  // lookup; the pattern is far less perceptible than Bayer 4×4.
+  // lodFade=1 → all pass; lodFade=0 → all discard.
+  {
+    float ign = fract(52.9829189 *
+        fract(0.06711056 * gl_FragCoord.x + 0.00583715 * gl_FragCoord.y));
+    if (pc.lodFade <= ign) { discard; }
+  }
+#endif
+
   // ── World position (RTC reconstruction) ────────────────────────────────────
   // wp = tile-local pos + RTC centre (both float32 at ~6.4 Mm scale).
   // ~0.75 m ULP — far better than eyeRelPos + cameraEcef at altitude.
@@ -86,10 +100,16 @@ void main() {
     vec2 texUV = fragUV * vec2(pc.scaleX, pc.scaleY)
                + vec2(pc.translationX, pc.translationY);
     texUV.y = 1.0 - texUV.y;
+    // Return the overlay RGBA directly — preserves any transparency at tile
+    // edges and avoids incorrectly stamping the coastline outline on top of
+    // satellite imagery.  The dither discard above fires before this return,
+    // so LOD fading still works correctly on overlay tiles.
     outColor = texture(overlayTex, texUV);
     return;
   }
 
+  vec3 lit;
+  {
   // ── Hypsometric path ──────────────────────────────────────────────────────
   vec3  dpdx_v = dFdx(localPos), dpdy_v = dFdy(localPos);
   vec3  rawN   = cross(dpdx_v, dpdy_v);
@@ -115,24 +135,32 @@ void main() {
   vec3  oceanBlue = vec3(0.04, 0.26, 0.52);
   float landAlt   = (pc.hasWaterMask != 0u) ? max(rawAlt, 0.0) : rawAlt;
   vec3  landLit   = hypsometricColor(landAlt, steep) * (amb + diff * 0.72 + rim);
-  vec3  lit       = mix(landLit, oceanBlue, waterVal);
+  lit             = mix(landLit, oceanBlue, waterVal);
 
   // 1 km lat/lon grid — fades when sub-pixel to suppress Moiré.
   const float gridLat = 1000.0 / 6371000.0;
-  float cosLat  = max(cos(lat), 0.001);
+  // cosLat from pxy (already computed above for the Bowring iteration) —
+  // avoids a second cos() transcendental.  pxy/a_e is the geocentric cosine;
+  // the ~0.2 % geodetic difference is imperceptible at grid-line scale.
+  float cosLat  = max(pxy / 6378137.0, 0.001);
   float gridLon = gridLat / cosLat;
   float wLat    = fwidth(lat) * 1.5, wLon = fwidth(lon) * 1.5;
   float gridVis = clamp(min(gridLat / max(wLat, 1e-9),
                             gridLon / max(wLon, 1e-9)), 0.0, 1.0);
-  float latCell = lat - gridLat * floor(lat / gridLat);
-  float lonCell = lon - gridLon * floor(lon / gridLon);
+  // GLSL mod() is floor-based (always non-negative) — equivalent to the
+  // original floor dance but one instruction cleaner.
+  float latCell = mod(lat, gridLat);
+  float lonCell = mod(lon, gridLon);
   float dLat    = min(latCell, gridLat - latCell);
   float dLon    = min(lonCell, gridLon - lonCell);
-  float gridA   = max(1.0 - smoothstep(0.0, wLat, dLat),
-                      1.0 - smoothstep(0.0, wLon, dLon)) * gridVis;
+  // Linear ramp instead of smoothstep cubic — visually identical for a
+  // 1.5 px anti-aliased line, saves two multiplies per component.
+  float gridA   = max(clamp(1.0 - dLat / max(wLat, 1e-9), 0.0, 1.0),
+                      clamp(1.0 - dLon / max(wLon, 1e-9), 0.0, 1.0)) * gridVis;
   lit = mix(lit, vec3(0.15, 0.15, 0.15), gridA * 0.6);
+  } // end hypsometric block
 
-  // Coastline outline from water mask.
+  // Coastline outline from water mask (hypsometric path only — overlay returns above).
   if (pc.isEllipsoidFallback == 0u) {
     float dWater  = fwidth(waterVal);
     float coastPx = abs(waterVal - 0.5) / max(dWater * 0.5, 0.01);

package/android/src/main/java/com/margelo/nitro/reactnativecesium/CesiumBridgeJNI.kt

@@ -9,8 +9,9 @@ import android.view.Surface
 class CesiumBridgeJNI {
   private var nativePtr: Long = nativeCreate()
 
-  fun init(surface: Surface, width: Int, height: Int, cacheDir: String, cacertPath: String) {
-    nativeInit(nativePtr, surface, width, height, cacheDir, cacertPath)
+  fun init(surface: Surface, width: Int, height: Int, cacheDir: String, cacertPath: String,
+           ionAccessToken: String = "", ionAssetId: Long = 1L) {
+    nativeInit(nativePtr, surface, width, height, cacheDir, cacertPath, ionAccessToken, ionAssetId)
   }
 
   fun shutdown() = nativeShutdown(nativePtr)
@@ -98,7 +99,7 @@ class CesiumBridgeJNI {
   fun setMinAltitudeAboveTerrain(v: Float) = nativeSetMinAltitudeAboveTerrain(nativePtr, v)
 
   private external fun nativeCreate(): Long
-  private external fun nativeInit(ptr: Long, surface: Surface, w: Int, h: Int, cacheDir: String, cacertPath: String)
+  private external fun nativeInit(ptr: Long, surface: Surface, w: Int, h: Int, cacheDir: String, cacertPath: String, ionAccessToken: String, ionAssetId: Long)
   private external fun nativeShutdown(ptr: Long)
   private external fun nativeDestroy(ptr: Long)
   private external fun nativeResize(ptr: Long, w: Int, h: Int)

package/android/src/main/java/com/margelo/nitro/reactnativecesium/HybridCesiumView.kt

@@ -29,6 +29,10 @@ class HybridCesiumView(private val appContext: Context) : HybridCesiumViewSpec()
   private var idleProbeAccumulator = 0.0
   private var renderLoopActive = false
   private val renderInFlight = AtomicBoolean(false)
+  // Last System.nanoTime() when tilesLoading was > 0. Used to keep the render
+  // loop at full speed for a grace period after loading finishes — prevents the
+  // cascade of idle gaps between LOD refinement phases. 0 = not yet seen.
+  private var lastLoadingTimeNs: Long = 0L
 
   /// Set in `surfaceDestroyed` before any teardown work begins. Render-thread
   /// callbacks and choreographer frame ticks check this flag and bail out so
@@ -199,11 +203,20 @@ class HybridCesiumView(private val appContext: Context) : HybridCesiumViewSpec()
       return
     }
 
-    val shouldRender = b.shouldRenderNextFrame()
+    // Post-loading grace period: keep the loop at full speed for 2 seconds
+    // after the last non-zero loading frame so LOD transitions complete quickly
+    // and the next refinement level is discovered without a multi-second idle gap.
+    val nowNs = System.nanoTime()
+    val inGracePeriod = lastLoadingTimeNs > 0L &&
+        (nowNs - lastLoadingTimeNs) < 2_000_000_000L
+
+    val shouldRender = b.shouldRenderNextFrame() || inGracePeriod
     val nextImmediate: Boolean
     if (shouldRender) {
       idleProbeAccumulator = 0.0
       b.renderFrame(nowSeconds)
+      // Stamp after renderFrame so the freshly-updated tile counts are used.
+      if (b.getMetricsTilesLoading() > 0) lastLoadingTimeNs = nowNs
       nextImmediate = true
     } else {
       // Approximate dt for the idle probe; not used for motion.
@@ -273,7 +286,12 @@ class HybridCesiumView(private val appContext: Context) : HybridCesiumViewSpec()
       val cacertPath = extractCacert()
       rh.post {
         val b = CesiumBridgeJNI()
-        b.init(surface, w, h, cacheDir, cacertPath)
+        // sqliteCacheMaxRows and taskProcessorThreads are consumed once inside
+        // CesiumEngine::initialize() (SqliteCache + TaskProcessor sizing).
+        // They must be seeded into config_ before init() calls buildEngine().
+        sqliteCacheMaxRows?.let { b.setSqliteCacheMaxRows(it.toInt()) }
+        taskProcessorThreads?.let { b.setTaskProcessorThreads(it.toInt()) }
+        b.init(surface, w, h, cacheDir, cacertPath, ionAccessToken, ionAssetId.toLong())
         bridge = b
         syncBridgePropsOnRenderThread(b)
 
@@ -300,12 +318,13 @@ class HybridCesiumView(private val appContext: Context) : HybridCesiumViewSpec()
           b.setViewCorrection(q.w, q.x, q.y, q.z); pendingViewCorrection = null
         }
 
+        // Ion credentials were seeded at init() time for parallel tileset
+        // fetch; call updateIonAccessToken here only as a hot-reload safety
+        // net in case the token changed between bridge teardown and rebuild.
         if (ionAccessToken.isNotEmpty()) {
           b.updateIonAccessToken(ionAccessToken, ionAssetId.toLong())
         }
-        if (ionImageryAssetId != 1.0) {
-          b.updateImageryAssetId(ionImageryAssetId.toLong())
-        }
+        b.updateImageryAssetId(ionImageryAssetId.toLong())
         b.setMsaa(msaaSampleCount.toInt())
 
         pushRateCaps()
@@ -497,8 +516,8 @@ class HybridCesiumView(private val appContext: Context) : HybridCesiumViewSpec()
     culledScreenSpaceError?.let { b.setCulledScreenSpaceError(it) }
     enableLodTransitionPeriod?.let { b.setEnableLodTransitionPeriod(it) }
     lodTransitionLength?.let { b.setLodTransitionLength(it) }
-    sqliteCacheMaxRows?.let { b.setSqliteCacheMaxRows(it.toInt()) }
-    taskProcessorThreads?.let { b.setTaskProcessorThreads(it.toInt()) }
+    // sqliteCacheMaxRows and taskProcessorThreads are applied before init() in
+    // surfaceCreated; calling them here (after buildEngine) has no effect.
     minAltitudeAboveTerrain?.let { b.setMinAltitudeAboveTerrain(it.toFloat()) }
   }