react-native-cesium 1.0.6 → 1.2.0

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "engine/EngineTunables.hpp"
 #include "renderer/IGPUBackend.hpp"
 
 #define VK_USE_PLATFORM_ANDROID_KHR
@@ -9,6 +10,7 @@
 #include <cstdint>
 #include <deque>
 #include <mutex>
+#include <string>
 #include <vector>
 
 namespace reactnativecesium {
@@ -19,6 +21,13 @@ struct VulkanTexture {
   VkImageView     imageView     = VK_NULL_HANDLE;
   VkSampler       sampler       = VK_NULL_HANDLE;
   VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
+  uint32_t        width         = 0;
+  uint32_t        height        = 0;
+  uint32_t        mipLevels     = 1;
+  // True until the deferred upload command for this texture has been submitted.
+  // Bound textures with `pendingUpload == true` are skipped (the fallback is
+  // used instead) — prevents reading from a still-uninitialised image.
+  bool            pendingUpload = false;
 };
 
 class VulkanBackend : public IGPUBackend {
@@ -34,6 +43,11 @@ public:
   void drawScene(const FrameResult& frame) override;
   void endFrame() override;
 
+  // Cache directory used to persist the VkPipelineCache between sessions and
+  // (in future) any other on-disk Vulkan artefacts. Must be called before
+  // `initialize` to take effect on cold start.
+  void setCacheDir(const std::string& cacheDir) { cacheDir_ = cacheDir; }
+
   void* createRasterTexture(const uint8_t* pixels, int32_t width, int32_t height);
   void  freeRasterTexture(void* tex);
 
@@ -45,12 +59,14 @@ public:
   void setMsaaSampleCount(int sampleCount);
 
 private:
+  // ── Init helpers ─────────────────────────────────────────────────────────
   void createInstance();
   void pickPhysicalDevice();
   void createDevice();
   void createSwapchain();
   void createRenderPass();
   void createDepthResources();
+  void createMsaaResources();
   void createFramebuffers();
   void createCommandPool();
   void createCommandBuffers();
@@ -59,6 +75,10 @@ private:
   void createPipelineLayout();
   void createSkyPipeline();
   void createTerrainPipeline();
+  void createGraphicsPipelinesAll();
+  void destroyGraphicsPipelinesAll();
+  void createPipelineCache();
+  void persistPipelineCache();
   void createFallbackTexture();
   void createDescriptorPool();
   void createWaterMaskPool();
@@ -67,22 +87,72 @@ private:
   void cleanupSwapchain();
   void recreateSwapchain();
 
+  // Pick the best supported MSAA count <= `requested` (1, 2, 4, or 8).
+  // `requested` of 0 or 1 disables MSAA.
+  VkSampleCountFlagBits resolveMsaaSamples(int requested) const;
+
   VkFormat pickDepthFormat() const;
 
-  uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags props);
-  void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage,
+  // Picks a present mode: prefer MAILBOX (if `wantLowLatency`), then FIFO_RELAXED,
+  // then the default FIFO (always available per spec).
+  VkPresentModeKHR pickPresentMode() const;
+
+  uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags props,
+                          bool* outFound = nullptr);
+
+  // Creates a HOST_VISIBLE | HOST_COHERENT or DEVICE_LOCAL buffer.
+  bool createBuffer(VkDeviceSize size, VkBufferUsageFlags usage,
                     VkMemoryPropertyFlags props, VkBuffer& buffer,
                     VkDeviceMemory& memory);
   void ensureBuffer(VkBuffer& buffer, VkDeviceMemory& memory, size_t& capacity,
                     size_t needed, const void* data, VkBufferUsageFlags usage);
-  VkCommandBuffer beginSingleTimeCommands();
-  void endSingleTimeCommands(VkCommandBuffer commandBuffer);
 
-  // Upload pixel data from a staging buffer into image, transitioning layout
-  // UNDEFINED → TRANSFER_DST → SHADER_READ_ONLY in a single command buffer.
-  void uploadToImage(VkBuffer staging, VkImage image, uint32_t width, uint32_t height);
+  // ── Deferred upload pipeline ─────────────────────────────────────────────
+  // Each call to createRasterTexture / createWaterMaskTexture allocates a slice
+  // of the persistent staging ring, copies the pixels in, and queues a
+  // PendingUpload entry. The next beginFrame() submits all pending uploads in
+  // one command buffer with a single batched pipeline barrier, no
+  // vkQueueWaitIdle, no per-tile staging buffer churn.
+  struct PendingUpload {
+    VulkanTexture* tex;
+    VkDeviceSize   stagingOffset;
+    uint32_t       width;
+    uint32_t       height;
+    uint64_t       enqueueFrame;
+  };
+  void initStagingRing(VkDeviceSize bytes);
+  // Reserve `size` bytes from the staging ring; returns the offset and updates
+  // the head. Returns SIZE_MAX if the ring is full this frame (the call site
+  // falls back to an unbatched synchronous upload for that one tile).
+  VkDeviceSize allocateStagingSlice(VkDeviceSize size);
+  // Submit all queued uploads on the graphics queue (no wait). The submit's
+  // signal fence is one of `uploadFences_`; in N frames' time we know the GPU
+  // is done with the staging slices and can free their offsets.
+  void flushPendingUploads();
+
+  // Synchronous fallback used during init (fallback texture) and as the
+  // last-resort path when the staging ring is exhausted for a frame.
+  VkCommandBuffer beginSingleTimeCommands();
+  bool            endSingleTimeCommands(VkCommandBuffer commandBuffer);
+
+  // Generic image creator (replaces createRasterTexture / createWaterMaskTexture
+  // duplication). Allocates the image, image view, sampler, descriptor set, and
+  // either enqueues a deferred upload (preferred) or runs the synchronous path.
+  VulkanTexture* createImageFromPixels(const uint8_t* pixels,
+                                       int32_t width, int32_t height,
+                                       VkDescriptorPool pool,
+                                       VkSampleCountFlagBits samples,
+                                       bool wantMipmaps);
+
+  // Generates mipmap chain via blit (assumes the image has TRANSFER_SRC bit
+  // and was allocated with mipLevels > 1). Records into `cmd`, leaves the
+  // image in SHADER_READ_ONLY_OPTIMAL.
+  void recordGenerateMipmaps(VkCommandBuffer cmd, VkImage image,
+                             uint32_t width, uint32_t height,
+                             uint32_t mipLevels);
 
   void* window_ = nullptr; // ANativeWindow*
+  std::string cacheDir_;
 
   VkInstance               instance_       = VK_NULL_HANDLE;
   VkPhysicalDevice         physicalDevice_ = VK_NULL_HANDLE;
@@ -98,15 +168,30 @@ private:
   std::vector<VkImage>     swapchainImages_;
   std::vector<VkImageView> swapchainImageViews_;
 
+  // Anisotropy / MSAA support cached at device-pick time.
+  bool                  supportsAnisotropy_ = false;
+  float                 maxAnisotropy_      = 1.0f;
+  VkSampleCountFlagBits supportedMsaaMask_  = VK_SAMPLE_COUNT_1_BIT;
+  VkSampleCountFlagBits sampleCount_        = VK_SAMPLE_COUNT_1_BIT;
+
   VkRenderPass             renderPass_     = VK_NULL_HANDLE;
   std::vector<VkFramebuffer> framebuffers_;
 
+  // Single-sample depth (always present).
   VkImage        depthImage_      = VK_NULL_HANDLE;
   VkDeviceMemory depthMemory_     = VK_NULL_HANDLE;
   VkImageView    depthImageView_  = VK_NULL_HANDLE;
 
-  VkCommandPool              commandPool_ = VK_NULL_HANDLE;
+  // Multi-sample colour resolve target (present iff sampleCount_ > 1).
+  VkImage        msaaColorImage_  = VK_NULL_HANDLE;
+  VkDeviceMemory msaaColorMemory_ = VK_NULL_HANDLE;
+  VkImageView    msaaColorView_   = VK_NULL_HANDLE;
+
+  VkCommandPool                commandPool_ = VK_NULL_HANDLE;
   std::vector<VkCommandBuffer> commandBuffers_;
+  std::vector<VkCommandBuffer> uploadCommandBuffers_; // one per frame-in-flight
+
+  VkPipelineCache  pipelineCache_  = VK_NULL_HANDLE;
 
   VkDescriptorSetLayout terrainDescSetLayout_ = VK_NULL_HANDLE; // set 0: UBO
   VkDescriptorSetLayout terrainTexLayout_     = VK_NULL_HANDLE; // set 1: texture
@@ -120,8 +205,10 @@ private:
   VkDescriptorPool waterMaskPool_      = VK_NULL_HANDLE;
 
   VulkanTexture   fallbackTexture_;
+  VulkanTexture*  fallbackTexturePtr_     = nullptr;  // Heap pointer kept alive for pending upload
   VkDescriptorSet fallbackTexDescSet_     = VK_NULL_HANDLE;
   VulkanTexture   fallbackWaterMaskTex_;
+  VulkanTexture*  fallbackWaterMaskTexPtr_ = nullptr;  // Heap pointer kept alive for pending upload
   VkDescriptorSet fallbackWaterMaskDescSet_ = VK_NULL_HANDLE;
 
   // Sky UBO — persistently mapped
@@ -130,12 +217,17 @@ private:
   void*           skyUboMapped_  = nullptr;
   VkDescriptorSet skyDescSet_    = VK_NULL_HANDLE;
 
-  static constexpr int kMaxFramesInFlight = 3;
-  // Upper bound on simultaneously live raster overlay textures.
-  // Cesium can cache many hundreds of tiles at high zoom; 2048 gives headroom.
-  static constexpr int kMaxRasterTextures = 2048;
+  static constexpr int kMaxFramesInFlight = tunables::kMaxFramesInFlight;
+  static constexpr int kMaxRasterTextures = tunables::kMaxRasterTextures;
 
+  // Per-frame-in-flight semaphores: signalled by acquire and waited on by the
+  // frame's command-buffer submit. Sized by kMaxFramesInFlight.
   std::vector<VkSemaphore> imageAvailableSemaphores_;
+  // Per-swapchain-image semaphores: signalled by the frame's submit and waited
+  // on by present. Sized by swapchainImages_.size() — keyed on imageIndex_,
+  // not frameIndex_. This avoids the well-known 3-image swapchain race where
+  // the same per-frame semaphore can be signalled twice for two in-flight
+  // images (Khronos sample VulkanGuide chapter 1).
   std::vector<VkSemaphore> renderFinishedSemaphores_;
   std::vector<VkFence>     inFlightFences_;
   int      frameIndex_  = 0;
@@ -169,6 +261,23 @@ private:
   int  viewportWidth_  = 0;
   int  viewportHeight_ = 0;
   bool needsSwapchainRecreate_ = false;
+  int  pendingMsaaRequest_     = 0; // applied between frames
+
+  // ── Persistent staging ring (P0-vk-uploads) ──────────────────────────────
+  // Single host-visible buffer, persistently mapped. Each upload allocates a
+  // 256-byte aligned slice; the head wraps every kStagingSize bytes. Slices
+  // are kept alive for kMaxFramesInFlight frames after submit (free in
+  // beginFrame when the matching upload fence is signalled).
+  static constexpr VkDeviceSize kStagingSize = 64ULL * 1024ULL * 1024ULL;
+  static constexpr VkDeviceSize kStagingAlignment = 256;
+  VkBuffer       stagingBuffer_ = VK_NULL_HANDLE;
+  VkDeviceMemory stagingMemory_ = VK_NULL_HANDLE;
+  uint8_t*       stagingMapped_ = nullptr;
+  VkDeviceSize   stagingHead_   = 0;
+  VkFence        uploadFences_[kMaxFramesInFlight] = {};
+  std::vector<PendingUpload> pendingUploadsCurrent_;     // queued, not yet submitted
+  std::vector<PendingUpload> uploadsInFlight_[kMaxFramesInFlight]; // submitted
+  std::mutex                 stagingMutex_;
 
   // Deferred texture deletion — freeRasterTexture enqueues here so no GPU stall
   // on eviction; beginFrame flushes entries old enough to be safe.

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

@@ -29,13 +29,20 @@ void main() {
   vec2 at = rsi(org, rd, AR);
   if (at.y < 0.0) { outColor = vec4(0, 0, 0, 1); return; }
 
-  vec2 er = rsi(org, rd, ER);
+  // No earth-surface tmax clamp — that creates a visible band discontinuity
+  // at the geometric horizon (rays below horizon get short atmospheric path,
+  // showing as lighter sky between the orange horizon glow and terrain).
+  // Instead integrate full atmospheric path and clamp underground sample
+  // heights to zero so they contribute ground-level density.
   float tmax = at.y;
-  if (er.x > 0.0) tmax = min(tmax, er.x);
   float tmin = max(at.x, 0.0);
   if (tmin >= tmax) { outColor = vec4(0, 0, 0, 1); return; }
 
-  const int S = 16, L = 4;
+  // Sample counts halved from 16/4 to 8/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;
   float ss = (tmax - tmin) / float(S);
   vec3 rayl = vec3(0), miel = vec3(0);
   float oR = 0.0, oM = 0.0;
@@ -43,7 +50,7 @@ void main() {
   for (int i = 0; i < S; ++i) {
     float t = tmin + (float(i) + 0.5) * ss;
     vec3 sp = org + rd * t;
-    float h = length(sp) - ER;
+    float h = max(0.0, length(sp) - ER);
     float hr = exp(-h / 10000.0) * ss, hm = exp(-h / 3200.0) * ss;
     oR += hr; oM += hm;
 
@@ -74,13 +81,16 @@ void main() {
   float mPh = 1.5 * ((1.0 - g2) / (2.0 + g2)) * (1.0 + cos2) / pow(1.0 + g2 - 2.0 * MG * cosT, 1.5);
   vec3 col = LINT * (rayl * RAY * rPh + miel * MIE3 * mPh);
   col = 1.0 - exp(-col * 1.1);
-  col *= vec3(0.18, 0.45, 1.0);
+  col *= vec3(0.30, 0.55, 1.0);
 
-  vec3 nu = normalize(org);
-  float up = clamp(dot(rd, nu), 0.0, 1.0);
-  float camH = max(0.0, length(org) - ER);
-  float hStr = clamp(1.0 - camH / 35000.0, 0.0, 1.0);
-  col = mix(col, vec3(0.40, 0.62, 0.96), (1.0 - smoothstep(0.05, 0.45, up)) * 0.40 * hStr);
+  // Single-scatter atmosphere produces sunset-like yellow at horizons with
+  // long path lengths (because blue out-scatters faster). Real daytime sky
+  // appears whitish-blue at horizon thanks to multiple scattering, which we
+  // approximate here by blending toward a natural blue based on the
+  // total atmospheric path length traversed by the view ray.
+  float pathLen = tmax - tmin;
+  float hazeFactor = smoothstep(100000.0, 600000.0, pathLen);
+  col = mix(col, vec3(0.35, 0.58, 0.90), hazeFactor * 0.65);
 
   outColor = vec4(col, 1.0);
 }

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

@@ -67,8 +67,22 @@ class CesiumBridgeJNI {
   fun getMetricsTilesVisited(): Int = nativeGetMetricsTilesVisited(nativePtr)
   fun getMetricsIonTokenConfigured(): Boolean = nativeGetMetricsIonTokenConfigured(nativePtr)
   fun getMetricsTilesetReady(): Boolean = nativeGetMetricsTilesetReady(nativePtr)
+  fun getMetricsTlsConfigured(): Boolean = nativeGetMetricsTlsConfigured(nativePtr)
   fun getMetricsCreditsPlainText(): String = nativeGetMetricsCreditsPlainText(nativePtr)
 
+  fun setMaximumCachedMiB(v: Int) = nativeSetMaximumCachedMiB(nativePtr, v)
+  fun setPreloadAncestors(v: Boolean) = nativeSetPreloadAncestors(nativePtr, v)
+  fun setPreloadSiblings(v: Boolean) = nativeSetPreloadSiblings(nativePtr, v)
+  fun setForbidHoles(v: Boolean) = nativeSetForbidHoles(nativePtr, v)
+  fun setEnableWaterMask(v: Boolean) = nativeSetEnableWaterMask(nativePtr, v)
+  fun setEnableFogCulling(v: Boolean) = nativeSetEnableFogCulling(nativePtr, v)
+  fun setEnforceCulledScreenSpaceError(v: Boolean) = nativeSetEnforceCulledScreenSpaceError(nativePtr, v)
+  fun setCulledScreenSpaceError(v: Double) = nativeSetCulledScreenSpaceError(nativePtr, v)
+  fun setEnableLodTransitionPeriod(v: Boolean) = nativeSetEnableLodTransitionPeriod(nativePtr, v)
+  fun setLodTransitionLength(v: Double) = nativeSetLodTransitionLength(nativePtr, v)
+  fun setSqliteCacheMaxRows(v: Int) = nativeSetSqliteCacheMaxRows(nativePtr, v)
+  fun setTaskProcessorThreads(v: Int) = nativeSetTaskProcessorThreads(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 nativeShutdown(ptr: Long)
@@ -115,5 +129,19 @@ class CesiumBridgeJNI {
   private external fun nativeGetMetricsTilesVisited(ptr: Long): Int
   private external fun nativeGetMetricsIonTokenConfigured(ptr: Long): Boolean
   private external fun nativeGetMetricsTilesetReady(ptr: Long): Boolean
+  private external fun nativeGetMetricsTlsConfigured(ptr: Long): Boolean
   private external fun nativeGetMetricsCreditsPlainText(ptr: Long): String
+
+  private external fun nativeSetMaximumCachedMiB(ptr: Long, v: Int)
+  private external fun nativeSetPreloadAncestors(ptr: Long, v: Boolean)
+  private external fun nativeSetPreloadSiblings(ptr: Long, v: Boolean)
+  private external fun nativeSetForbidHoles(ptr: Long, v: Boolean)
+  private external fun nativeSetEnableWaterMask(ptr: Long, v: Boolean)
+  private external fun nativeSetEnableFogCulling(ptr: Long, v: Boolean)
+  private external fun nativeSetEnforceCulledScreenSpaceError(ptr: Long, v: Boolean)
+  private external fun nativeSetCulledScreenSpaceError(ptr: Long, v: Double)
+  private external fun nativeSetEnableLodTransitionPeriod(ptr: Long, v: Boolean)
+  private external fun nativeSetLodTransitionLength(ptr: Long, v: Double)
+  private external fun nativeSetSqliteCacheMaxRows(ptr: Long, v: Int)
+  private external fun nativeSetTaskProcessorThreads(ptr: Long, v: Int)
 }