react-native-cesium 1.2.16 → 1.2.17

package/android/build.gradle

@@ -80,7 +80,9 @@ android {
 
         buildTypes {
           debug {
-            cppFlags "-O1 -g"
+            // -O2 (was -O1) so debug builds — the default dev/emulator workflow —
+            // aren't unfairly slow when profiling the renderer. -g keeps symbols.
+            cppFlags "-O2 -g"
           }
           release {
             cppFlags "-O2"

package/android/src/main/cpp/vulkan/VulkanBackend.cpp

@@ -10,7 +10,9 @@
 //     catastrophic cancellation in the shader.
 //   - Single merged vertex + index buffer uploaded each frame.
 //   - Reversed-Z infinite projection: depth clear = 0, compare = GREATER.
-//   - Sky drawn first (no depth write), terrain drawn after.
+//   - Terrain drawn first (writes depth); sky drawn after with a depth test
+//     (no write) so the full-screen atmospheric shader only runs on pixels not
+//     covered by terrain.
 //   - Water mask: UV computed from geographic lat/lon + tile bounds (not fragUV).
 //   - Push constants: bytes 0-63 vertex (MVP), bytes 64-127 fragment.
 //   - Triple-buffered persistent VkBuffers guarded by VkFence.
@@ -447,6 +449,29 @@ void VulkanBackend::pickPhysicalDevice() {
   supportsAnisotropy_ = feats.samplerAnisotropy == VK_TRUE;
   maxAnisotropy_      = props.limits.maxSamplerAnisotropy;
 
+  // One-time log of the selected GPU so we can tell a real hardware device from
+  // a software rasterizer (e.g. the Android Emulator's SwiftShader / a slow
+  // gfxstream translation layer), which is the dominant factor in emulator FPS.
+  const char* typeStr = "OTHER";
+  switch (props.deviceType) {
+    case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:   typeStr = "DISCRETE_GPU";   break;
+    case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: typeStr = "INTEGRATED_GPU"; break;
+    case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:    typeStr = "VIRTUAL_GPU";    break;
+    case VK_PHYSICAL_DEVICE_TYPE_CPU:            typeStr = "CPU (software)";  break;
+    default:                                     typeStr = "OTHER";          break;
+  }
+  LOGI("Vulkan GPU: \"%s\" type=%s apiVersion=%u.%u.%u driverVersion=0x%x",
+       props.deviceName, typeStr,
+       VK_VERSION_MAJOR(props.apiVersion),
+       VK_VERSION_MINOR(props.apiVersion),
+       VK_VERSION_PATCH(props.apiVersion),
+       props.driverVersion);
+  if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) {
+    LOGW("Selected a CPU/software Vulkan device — expect very low FPS. "
+         "This is typical on the Android Emulator without host-GPU acceleration; "
+         "measure on a physical device for representative performance.");
+  }
+
   const VkSampleCountFlags counts = props.limits.framebufferColorSampleCounts &
                                     props.limits.framebufferDepthSampleCounts;
   if      (counts & VK_SAMPLE_COUNT_8_BIT) supportedMsaaMask_ = VK_SAMPLE_COUNT_8_BIT;
@@ -1065,6 +1090,7 @@ struct PipelineBuildSpec {
   const VkVertexInputAttributeDescription* attributes;
   bool depthTest;
   bool depthWrite;
+  VkCompareOp depthCompare;
   VkCullModeFlags cull;
   VkSampleCountFlagBits samples;
 };
@@ -1115,7 +1141,7 @@ VkPipeline buildPipeline(VkDevice                 device,
   depthStencil.sType            = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
   depthStencil.depthTestEnable  = spec.depthTest  ? VK_TRUE : VK_FALSE;
   depthStencil.depthWriteEnable = spec.depthWrite ? VK_TRUE : VK_FALSE;
-  depthStencil.depthCompareOp   = VK_COMPARE_OP_GREATER; // Reversed-Z
+  depthStencil.depthCompareOp   = spec.depthCompare; // Reversed-Z (GREATER family)
 
   VkPipelineColorBlendAttachmentState colorBlendAttach{};
   colorBlendAttach.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
@@ -1166,8 +1192,15 @@ void VulkanBackend::createSkyPipeline() {
   spec.bindings       = nullptr;
   spec.attributeCount = 0;
   spec.attributes     = nullptr;
-  spec.depthTest      = false;
+  // Depth-test the sky against the terrain (which is drawn first and writes
+  // depth) so the expensive atmospheric raymarch only runs on pixels that
+  // aren't covered by geometry. sky.vert emits z=0 (the reversed-Z far plane)
+  // and the depth buffer is cleared to 0, so GREATER_OR_EQUAL passes only where
+  // no terrain wrote a closer (>0) depth. No depth write — the sky never
+  // occludes anything.
+  spec.depthTest      = true;
   spec.depthWrite     = false;
+  spec.depthCompare   = VK_COMPARE_OP_GREATER_OR_EQUAL;
   spec.cull           = VK_CULL_MODE_NONE;
   spec.samples        = sampleCount_;
   skyPipeline_ = buildPipeline(device_, skyPipelineLayout_, renderPass_,
@@ -1207,6 +1240,7 @@ void VulkanBackend::createTerrainPipeline() {
     spec.attributes     = attrs;
     spec.depthTest      = true;
     spec.depthWrite     = true;
+    spec.depthCompare   = VK_COMPARE_OP_GREATER; // Reversed-Z
     spec.cull           = VK_CULL_MODE_BACK_BIT;
     spec.samples        = sampleCount_;
     return buildPipeline(device_, terrainPipelineLayout_, renderPass_,
@@ -2100,31 +2134,11 @@ void VulkanBackend::drawScene(const FrameResult& frame) {
 
   VkCommandBuffer cmd = commandBuffers_[frameIndex_];
 
-  // ── Sky pass ──────────────────────────────────────────────────────────────
-  if (skyPipeline_ && skyDescSet_) {
-    SkyUBO skyU{};
-    const float* iv = glm::value_ptr(frame.invVP);
-    for (int i = 0; i < 16; ++i) skyU.invVP[i] = iv[i];
-    skyU.cameraEcef[0] = frame.cameraEcef.x;
-    skyU.cameraEcef[1] = frame.cameraEcef.y;
-    skyU.cameraEcef[2] = frame.cameraEcef.z;
-    float cl = sqrtf(frame.cameraEcef.x * frame.cameraEcef.x +
-                     frame.cameraEcef.y * frame.cameraEcef.y +
-                     frame.cameraEcef.z * frame.cameraEcef.z);
-    if (cl > 0.0f) {
-      skyU.lightDir[0] = frame.cameraEcef.x / cl;
-      skyU.lightDir[1] = frame.cameraEcef.y / cl;
-      skyU.lightDir[2] = frame.cameraEcef.z / cl;
-    }
-
-    memcpy(skyUboMapped_, &skyU, sizeof(SkyUBO));
-
-    vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, skyPipeline_);
-    vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, skyPipelineLayout_,
-                            0, 1, &skyDescSet_, 0, nullptr);
-    vkCmdDraw(cmd, 3, 1, 0, 0);
-  }
-
+  // ── Terrain pass (opaque, writes depth) ─────────────────────────────────────
+  // Drawn FIRST so the sky pass below can depth-test against the terrain and
+  // skip the expensive full-screen atmospheric raymarch on every covered pixel.
+  // Wrapped in a lambda so its early-outs still fall through to the sky pass.
+  auto drawTerrain = [&]() {
   if (frame.draws.empty() || !terrainSolidPipeline_ || !terrainDitherPipeline_) {
     return;
   }
@@ -2277,6 +2291,36 @@ void VulkanBackend::drawScene(const FrameResult& frame) {
     uint32_t firstIndex = draw.indexByteOffset / sizeof(uint32_t);
     vkCmdDrawIndexed(cmd, draw.indexCount, 1, firstIndex, 0, 0);
   }
+  }; // drawTerrain
+  drawTerrain();
+
+  // ── Sky pass ────────────────────────────────────────────────────────────────
+  // Drawn LAST and depth-tested (no write): the raymarch only executes on pixels
+  // where no terrain was rendered (depth still at the cleared reversed-Z far
+  // plane). This avoids shading the full screen and then overdrawing it.
+  if (skyPipeline_ && skyDescSet_) {
+    SkyUBO skyU{};
+    const float* iv = glm::value_ptr(frame.invVP);
+    for (int i = 0; i < 16; ++i) skyU.invVP[i] = iv[i];
+    skyU.cameraEcef[0] = frame.cameraEcef.x;
+    skyU.cameraEcef[1] = frame.cameraEcef.y;
+    skyU.cameraEcef[2] = frame.cameraEcef.z;
+    float cl = sqrtf(frame.cameraEcef.x * frame.cameraEcef.x +
+                     frame.cameraEcef.y * frame.cameraEcef.y +
+                     frame.cameraEcef.z * frame.cameraEcef.z);
+    if (cl > 0.0f) {
+      skyU.lightDir[0] = frame.cameraEcef.x / cl;
+      skyU.lightDir[1] = frame.cameraEcef.y / cl;
+      skyU.lightDir[2] = frame.cameraEcef.z / cl;
+    }
+
+    memcpy(skyUboMapped_, &skyU, sizeof(SkyUBO));
+
+    vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, skyPipeline_);
+    vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, skyPipelineLayout_,
+                            0, 1, &skyDescSet_, 0, nullptr);
+    vkCmdDraw(cmd, 3, 1, 0, 0);
+  }
 }
 
 void VulkanBackend::endFrame() {

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

@@ -38,11 +38,11 @@ void main() {
   float tmin = max(at.x, 0.0);
   if (tmin >= tmax) { outColor = vec4(0, 0, 0, 1); return; }
 
-  // Sample counts halved from 16/4 to 8/2 — visually negligible at typical
+  // Sample counts reduced 16/4 -> 8/2 -> 6/2 — visually negligible at typical
   // phone DPI / viewport sizes (a 24-bit screen can't resolve the difference
-  // in atmospheric scattering past ~6 primary samples), saves ~half the
-  // expensive `exp` calls per pixel.
-  const int S = 8, L = 2;
+  // in atmospheric scattering past ~6 primary samples), and cuts the expensive
+  // per-pixel `exp` calls further (helps weak/software GPUs most).
+  const int S = 6, L = 2;
   float ss = (tmax - tmin) / float(S);
   vec3 rayl = vec3(0), miel = vec3(0);
   float oR = 0.0, oM = 0.0;

package/ios/metal/MetalBackend.mm

@@ -16,7 +16,9 @@
 //     ellipsoidHeightMeters(wp) in the old shader.
 //   • Single merged vertex + index buffer uploaded each frame.
 //   • Reversed-Z infinite projection: depth clear = 0, compare = GREATER.
-//   • Sky drawn first (no depth write), terrain drawn after.
+//   • Terrain drawn first (writes depth); sky drawn after with a depth test
+//     (no write) so the full-screen atmospheric shader only runs on pixels not
+//     covered by terrain.
 //   • Triple-buffered persistent MTLBuffers: one slot per in-flight frame.
 
 #import <Foundation/Foundation.h>
@@ -335,9 +337,10 @@ fragment float4 skyFragment(SkyVOut in [[stage_in]],
   // underground sample heights to zero (ground-level density).
   float tmax=at.y;
   float tmin=max(at.x,0.f);if(tmin>=tmax)return float4(0,0,0,1);
-  // Halved from 16/4 to 8/2 — visually negligible at typical phone DPI
-  // (atmospheric scattering banding is sub-pixel at this sample count).
-  const int S=8,L=2;
+  // Reduced 16/4 -> 8/2 -> 6/2 — visually negligible at typical phone DPI
+  // (atmospheric scattering banding is sub-pixel at this sample count) and
+  // cuts per-pixel `exp` calls further. Kept in sync with the Vulkan sky.frag.
+  const int S=6,L=2;
   float ss=(tmax-tmin)/float(S);
   float3 rayl=0,miel=0;float oR=0,oM=0;
   for(int i=0;i<S;++i){
@@ -542,7 +545,11 @@ void MetalBackend::buildRenderPipelines() {
   }
   if (!skyDepthState_) {
     MTLDepthStencilDescriptor* sd = [MTLDepthStencilDescriptor new];
-    sd.depthCompareFunction = MTLCompareFunctionAlways;
+    // Sky is drawn after terrain with a depth test (no write). skyVertex emits
+    // z=0 (the reversed-Z far plane) and the depth buffer clears to 0, so
+    // GreaterEqual passes only where no terrain wrote a closer (>0) depth —
+    // i.e. the raymarch only runs on uncovered pixels.
+    sd.depthCompareFunction = MTLCompareFunctionGreaterEqual;
     sd.depthWriteEnabled    = NO;
     skyDepthState_ = (__bridge_retained void*)
         [dev newDepthStencilStateWithDescriptor:sd];
@@ -550,6 +557,8 @@ void MetalBackend::buildRenderPipelines() {
 }
 
 void MetalBackend::setMsaaSampleCount(int sc) {
+  if (!device_) return;
+
   int n = sc;
   if (n != 2 && n != 4) n = 1;
   id<MTLDevice> dev = (__bridge id<MTLDevice>)device_;
@@ -594,24 +603,26 @@ void MetalBackend::resize(int width, int height) {
 }
 
 void MetalBackend::shutdown() {
-  // Drain in-flight frames: wait until all GPU completion handlers have fired
-  // before releasing the semaphore and the persistent buffers they reference.
-  // Bounded wait — if a slot doesn't release in 1 s we are almost certainly
-  // looking at a hung GPU command. Forcing release lets the app exit/teardown
-  // cleanly rather than ANRing on backgrounding.
+  // Idempotent — CesiumBridge calls shutdown() explicitly and the unique_ptr
+  // dtor calls it again; during Fast Refresh teardown may also overlap with
+  // in-flight Metal completion handlers that captured the frame semaphore.
+  if (!device_) return;
+
+  // Drain in-flight frame slots: each beginFrame wait consumes a token and
+  // endFrame's GPU completion handler signals it back. Blocking here until
+  // every committed command buffer has finished ensures no handler signals
+  // the semaphore after we CFRelease it (Fast Refresh / unmount crash).
   if (frameSemaphore_) {
     dispatch_semaphore_t sem = (__bridge dispatch_semaphore_t)frameSemaphore_;
     for (int i = 0; i < kMaxFramesInFlight; ++i) {
-      dispatch_time_t deadline = dispatch_time(DISPATCH_TIME_NOW,
-                                               (int64_t)NSEC_PER_SEC);
-      if (dispatch_semaphore_wait(sem, deadline) != 0) {
-        NSLog(@"[CesiumMetal] shutdown semaphore wait timed out at slot %d; "
-              @"force-releasing and continuing teardown", i);
-        break;
-      }
+      dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+    }
+    for (int i = 0; i < kMaxFramesInFlight; ++i) {
+      dispatch_semaphore_signal(sem);
     }
-    CFRelease(frameSemaphore_);
+    void* semToRelease = frameSemaphore_;
     frameSemaphore_ = nullptr;
+    CFRelease(semToRelease);
   }
 
   for (int i = 0; i < kMaxFramesInFlight; ++i) {
@@ -733,6 +744,8 @@ void* MetalBackend::createRasterTexture(const uint8_t* pixels,
 // ── Per-frame ─────────────────────────────────────────────────────────────────
 
 void MetalBackend::beginFrame(const FrameParams& /*params*/) {
+  if (!device_ || !frameSemaphore_) return;
+
   // Acquire a frame slot.  Blocks if kMaxFramesInFlight frames are already
   // queued on the GPU.  The completion handler in endFrame() signals the
   // semaphore to release the slot.
@@ -797,32 +810,11 @@ void MetalBackend::drawScene(const FrameResult& frame) {
   id<MTLRenderCommandEncoder> enc = (__bridge id<MTLRenderCommandEncoder>)currentEncoder_;
   id<MTLDevice> dev = (__bridge id<MTLDevice>)device_;
 
-  // ── Sky pass ──────────────────────────────────────────────────────────────
-  if (skyPipeline_ && skyDepthState_) {
-    SkyUniforms skyU{};
-    const float* iv = glm::value_ptr(frame.invVP);
-    for (int i = 0; i < 16; ++i) skyU.invVP[i] = iv[i];
-    skyU.cameraEcef[0] = frame.cameraEcef.x;
-    skyU.cameraEcef[1] = frame.cameraEcef.y;
-    skyU.cameraEcef[2] = frame.cameraEcef.z;
-    float cl = sqrtf(frame.cameraEcef.x * frame.cameraEcef.x +
-                     frame.cameraEcef.y * frame.cameraEcef.y +
-                     frame.cameraEcef.z * frame.cameraEcef.z);
-    if (cl > 0.0f) {
-      skyU.lightDir[0] = frame.cameraEcef.x / cl;
-      skyU.lightDir[1] = frame.cameraEcef.y / cl;
-      skyU.lightDir[2] = frame.cameraEcef.z / cl;
-    }
-
-    [enc setRenderPipelineState:(__bridge id<MTLRenderPipelineState>)skyPipeline_];
-    [enc setDepthStencilState:(__bridge id<MTLDepthStencilState>)skyDepthState_];
-    [enc setCullMode:MTLCullModeNone];
-    [enc setVertexBytes:&skyU length:sizeof(skyU) atIndex:0];
-    [enc setFragmentBytes:&skyU length:sizeof(skyU) atIndex:0];
-    [enc drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:3];
-  }
-
   // ── Terrain pass ──────────────────────────────────────────────────────────
+  // Drawn FIRST (writes depth) so the sky pass below can depth-test against the
+  // terrain and skip the expensive full-screen atmospheric raymarch on every
+  // covered pixel. Wrapped in a lambda so its early-outs fall through to sky.
+  auto drawTerrain = [&]() {
   if (frame.draws.empty() ||
       !terrainSolidPipeline_ || !terrainDitherPipeline_ || !terrainDepthState_) {
     return;
@@ -1013,6 +1005,35 @@ void MetalBackend::drawScene(const FrameResult& frame) {
                    indexBuffer:idxBuf
              indexBufferOffset:draw.indexByteOffset];
   }
+  }; // drawTerrain
+  drawTerrain();
+
+  // ── Sky pass ──────────────────────────────────────────────────────────────
+  // Drawn LAST, depth-tested (no write): only shades pixels not covered by
+  // terrain (depth still at the cleared reversed-Z far plane).
+  if (skyPipeline_ && skyDepthState_) {
+    SkyUniforms skyU{};
+    const float* iv = glm::value_ptr(frame.invVP);
+    for (int i = 0; i < 16; ++i) skyU.invVP[i] = iv[i];
+    skyU.cameraEcef[0] = frame.cameraEcef.x;
+    skyU.cameraEcef[1] = frame.cameraEcef.y;
+    skyU.cameraEcef[2] = frame.cameraEcef.z;
+    float cl = sqrtf(frame.cameraEcef.x * frame.cameraEcef.x +
+                     frame.cameraEcef.y * frame.cameraEcef.y +
+                     frame.cameraEcef.z * frame.cameraEcef.z);
+    if (cl > 0.0f) {
+      skyU.lightDir[0] = frame.cameraEcef.x / cl;
+      skyU.lightDir[1] = frame.cameraEcef.y / cl;
+      skyU.lightDir[2] = frame.cameraEcef.z / cl;
+    }
+
+    [enc setRenderPipelineState:(__bridge id<MTLRenderPipelineState>)skyPipeline_];
+    [enc setDepthStencilState:(__bridge id<MTLDepthStencilState>)skyDepthState_];
+    [enc setCullMode:MTLCullModeNone];
+    [enc setVertexBytes:&skyU length:sizeof(skyU) atIndex:0];
+    [enc setFragmentBytes:&skyU length:sizeof(skyU) atIndex:0];
+    [enc drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:3];
+  }
 }
 
 void MetalBackend::endFrame() {
@@ -1031,7 +1052,9 @@ void MetalBackend::endFrame() {
   // Signal the frame semaphore when the GPU is done with this frame's buffers.
   void* semPtr = frameSemaphore_;
   [cb addCompletedHandler:^(id<MTLCommandBuffer> __unused) {
-    dispatch_semaphore_signal((__bridge dispatch_semaphore_t)semPtr);
+    if (semPtr) {
+      dispatch_semaphore_signal((__bridge dispatch_semaphore_t)semPtr);
+    }
   }];
 
   [cb presentDrawable:drawable];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-cesium",
-  "version": "1.2.16",
+  "version": "1.2.17",
   "description": "Experimental Cesium rendering for React Native via Nitro",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
@@ -76,13 +76,13 @@
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@types/jest": "^29.5.14",
-    "@types/react": "19.2.14",
+    "@types/react": "19.2.17",
     "conventional-changelog-conventionalcommits": "^9.3.1",
     "nitrogen": "0.35.9",
     "react": "19.2.3",
-    "react-native": "0.85.3",
-    "react-native-builder-bob": "^0.41.0",
-    "semantic-release": "^25.0.3",
+    "react-native": "0.86.0",
+    "react-native-builder-bob": "^0.43.0",
+    "semantic-release": "^25.0.5",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {