react-native-cesium 1.0.6 → 1.2.0

package/nitrogen/generated/ios/swift/HybridCesiumViewSpec.swift

@@ -19,6 +19,18 @@ public protocol HybridCesiumViewSpec_protocol: HybridObject, HybridView {
   var loadingDescendantLimit: Double { get set }
   var msaaSampleCount: Double { get set }
   var ionImageryAssetId: Double { get set }
+  var maximumCachedMiB: Double? { get set }
+  var preloadAncestors: Bool? { get set }
+  var preloadSiblings: Bool? { get set }
+  var forbidHoles: Bool? { get set }
+  var enableWaterMask: Bool? { get set }
+  var enableFogCulling: Bool? { get set }
+  var enforceCulledScreenSpaceError: Bool? { get set }
+  var culledScreenSpaceError: Double? { get set }
+  var enableLodTransitionPeriod: Bool? { get set }
+  var lodTransitionLength: Double? { get set }
+  var sqliteCacheMaxRows: Double? { get set }
+  var taskProcessorThreads: Double? { get set }
   var onMetrics: ((_ metrics: CesiumMetrics) -> Void)? { get set }
 
   // Methods

package/nitrogen/generated/ios/swift/HybridCesiumViewSpec_cxx.swift

@@ -220,6 +220,294 @@ open class HybridCesiumViewSpec_cxx {
     }
   }
   
+  public final var maximumCachedMiB: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.maximumCachedMiB {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.maximumCachedMiB = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var preloadAncestors: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.preloadAncestors {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.preloadAncestors = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var preloadSiblings: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.preloadSiblings {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.preloadSiblings = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var forbidHoles: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.forbidHoles {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.forbidHoles = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var enableWaterMask: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.enableWaterMask {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.enableWaterMask = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var enableFogCulling: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.enableFogCulling {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.enableFogCulling = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var enforceCulledScreenSpaceError: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.enforceCulledScreenSpaceError {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.enforceCulledScreenSpaceError = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var culledScreenSpaceError: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.culledScreenSpaceError {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.culledScreenSpaceError = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var enableLodTransitionPeriod: bridge.std__optional_bool_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = self.__implementation.enableLodTransitionPeriod {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.enableLodTransitionPeriod = { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(newValue) {
+          let __unwrapped = bridge.get_std__optional_bool_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var lodTransitionLength: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.lodTransitionLength {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.lodTransitionLength = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var sqliteCacheMaxRows: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.sqliteCacheMaxRows {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.sqliteCacheMaxRows = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
+  public final var taskProcessorThreads: bridge.std__optional_double_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = self.__implementation.taskProcessorThreads {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.taskProcessorThreads = { () -> Double? in
+        if bridge.has_value_std__optional_double_(newValue) {
+          let __unwrapped = bridge.get_std__optional_double_(newValue)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var onMetrics: bridge.std__optional_std__function_void_const_CesiumMetrics_____metrics______ {
     @inline(__always)
     get {

package/nitrogen/generated/shared/c++/CesiumMetrics.hpp

@@ -44,12 +44,13 @@ namespace margelo::nitro::reactnativecesium {
     double tilesLoading     SWIFT_PRIVATE;
     double tilesVisited     SWIFT_PRIVATE;
     bool ionTokenConfigured     SWIFT_PRIVATE;
+    bool tlsConfigured     SWIFT_PRIVATE;
     bool tilesetReady     SWIFT_PRIVATE;
     std::string creditsPlainText     SWIFT_PRIVATE;
 
   public:
     CesiumMetrics() = default;
-    explicit CesiumMetrics(double fps, double tilesRendered, double tilesLoading, double tilesVisited, bool ionTokenConfigured, bool tilesetReady, std::string creditsPlainText): fps(fps), tilesRendered(tilesRendered), tilesLoading(tilesLoading), tilesVisited(tilesVisited), ionTokenConfigured(ionTokenConfigured), tilesetReady(tilesetReady), creditsPlainText(creditsPlainText) {}
+    explicit CesiumMetrics(double fps, double tilesRendered, double tilesLoading, double tilesVisited, bool ionTokenConfigured, bool tlsConfigured, bool tilesetReady, std::string creditsPlainText): fps(fps), tilesRendered(tilesRendered), tilesLoading(tilesLoading), tilesVisited(tilesVisited), ionTokenConfigured(ionTokenConfigured), tlsConfigured(tlsConfigured), tilesetReady(tilesetReady), creditsPlainText(creditsPlainText) {}
 
   public:
     friend bool operator==(const CesiumMetrics& lhs, const CesiumMetrics& rhs) = default;
@@ -70,6 +71,7 @@ namespace margelo::nitro {
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tilesLoading"))),
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tilesVisited"))),
         JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ionTokenConfigured"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tlsConfigured"))),
         JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tilesetReady"))),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "creditsPlainText")))
       );
@@ -81,6 +83,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "tilesLoading"), JSIConverter<double>::toJSI(runtime, arg.tilesLoading));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "tilesVisited"), JSIConverter<double>::toJSI(runtime, arg.tilesVisited));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "ionTokenConfigured"), JSIConverter<bool>::toJSI(runtime, arg.ionTokenConfigured));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "tlsConfigured"), JSIConverter<bool>::toJSI(runtime, arg.tlsConfigured));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "tilesetReady"), JSIConverter<bool>::toJSI(runtime, arg.tilesetReady));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "creditsPlainText"), JSIConverter<std::string>::toJSI(runtime, arg.creditsPlainText));
       return obj;
@@ -98,6 +101,7 @@ namespace margelo::nitro {
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tilesLoading")))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tilesVisited")))) return false;
       if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "ionTokenConfigured")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tlsConfigured")))) return false;
       if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "tilesetReady")))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "creditsPlainText")))) return false;
       return true;

package/nitrogen/generated/shared/c++/HybridCesiumViewSpec.cpp

@@ -32,6 +32,30 @@ namespace margelo::nitro::reactnativecesium {
       prototype.registerHybridSetter("msaaSampleCount", &HybridCesiumViewSpec::setMsaaSampleCount);
       prototype.registerHybridGetter("ionImageryAssetId", &HybridCesiumViewSpec::getIonImageryAssetId);
       prototype.registerHybridSetter("ionImageryAssetId", &HybridCesiumViewSpec::setIonImageryAssetId);
+      prototype.registerHybridGetter("maximumCachedMiB", &HybridCesiumViewSpec::getMaximumCachedMiB);
+      prototype.registerHybridSetter("maximumCachedMiB", &HybridCesiumViewSpec::setMaximumCachedMiB);
+      prototype.registerHybridGetter("preloadAncestors", &HybridCesiumViewSpec::getPreloadAncestors);
+      prototype.registerHybridSetter("preloadAncestors", &HybridCesiumViewSpec::setPreloadAncestors);
+      prototype.registerHybridGetter("preloadSiblings", &HybridCesiumViewSpec::getPreloadSiblings);
+      prototype.registerHybridSetter("preloadSiblings", &HybridCesiumViewSpec::setPreloadSiblings);
+      prototype.registerHybridGetter("forbidHoles", &HybridCesiumViewSpec::getForbidHoles);
+      prototype.registerHybridSetter("forbidHoles", &HybridCesiumViewSpec::setForbidHoles);
+      prototype.registerHybridGetter("enableWaterMask", &HybridCesiumViewSpec::getEnableWaterMask);
+      prototype.registerHybridSetter("enableWaterMask", &HybridCesiumViewSpec::setEnableWaterMask);
+      prototype.registerHybridGetter("enableFogCulling", &HybridCesiumViewSpec::getEnableFogCulling);
+      prototype.registerHybridSetter("enableFogCulling", &HybridCesiumViewSpec::setEnableFogCulling);
+      prototype.registerHybridGetter("enforceCulledScreenSpaceError", &HybridCesiumViewSpec::getEnforceCulledScreenSpaceError);
+      prototype.registerHybridSetter("enforceCulledScreenSpaceError", &HybridCesiumViewSpec::setEnforceCulledScreenSpaceError);
+      prototype.registerHybridGetter("culledScreenSpaceError", &HybridCesiumViewSpec::getCulledScreenSpaceError);
+      prototype.registerHybridSetter("culledScreenSpaceError", &HybridCesiumViewSpec::setCulledScreenSpaceError);
+      prototype.registerHybridGetter("enableLodTransitionPeriod", &HybridCesiumViewSpec::getEnableLodTransitionPeriod);
+      prototype.registerHybridSetter("enableLodTransitionPeriod", &HybridCesiumViewSpec::setEnableLodTransitionPeriod);
+      prototype.registerHybridGetter("lodTransitionLength", &HybridCesiumViewSpec::getLodTransitionLength);
+      prototype.registerHybridSetter("lodTransitionLength", &HybridCesiumViewSpec::setLodTransitionLength);
+      prototype.registerHybridGetter("sqliteCacheMaxRows", &HybridCesiumViewSpec::getSqliteCacheMaxRows);
+      prototype.registerHybridSetter("sqliteCacheMaxRows", &HybridCesiumViewSpec::setSqliteCacheMaxRows);
+      prototype.registerHybridGetter("taskProcessorThreads", &HybridCesiumViewSpec::getTaskProcessorThreads);
+      prototype.registerHybridSetter("taskProcessorThreads", &HybridCesiumViewSpec::setTaskProcessorThreads);
       prototype.registerHybridGetter("onMetrics", &HybridCesiumViewSpec::getOnMetrics);
       prototype.registerHybridSetter("onMetrics", &HybridCesiumViewSpec::setOnMetrics);
       prototype.registerHybridMethod("getCameraState", &HybridCesiumViewSpec::getCameraState);

package/nitrogen/generated/shared/c++/HybridCesiumViewSpec.hpp

@@ -22,9 +22,9 @@ namespace margelo::nitro::reactnativecesium { struct Quaternion; }
 
 #include <string>
 #include "CameraState.hpp"
+#include <optional>
 #include "CesiumMetrics.hpp"
 #include <functional>
-#include <optional>
 #include <NitroModules/Promise.hpp>
 #include "Quaternion.hpp"
 
@@ -73,6 +73,30 @@ namespace margelo::nitro::reactnativecesium {
       virtual void setMsaaSampleCount(double msaaSampleCount) = 0;
       virtual double getIonImageryAssetId() = 0;
       virtual void setIonImageryAssetId(double ionImageryAssetId) = 0;
+      virtual std::optional<double> getMaximumCachedMiB() = 0;
+      virtual void setMaximumCachedMiB(std::optional<double> maximumCachedMiB) = 0;
+      virtual std::optional<bool> getPreloadAncestors() = 0;
+      virtual void setPreloadAncestors(std::optional<bool> preloadAncestors) = 0;
+      virtual std::optional<bool> getPreloadSiblings() = 0;
+      virtual void setPreloadSiblings(std::optional<bool> preloadSiblings) = 0;
+      virtual std::optional<bool> getForbidHoles() = 0;
+      virtual void setForbidHoles(std::optional<bool> forbidHoles) = 0;
+      virtual std::optional<bool> getEnableWaterMask() = 0;
+      virtual void setEnableWaterMask(std::optional<bool> enableWaterMask) = 0;
+      virtual std::optional<bool> getEnableFogCulling() = 0;
+      virtual void setEnableFogCulling(std::optional<bool> enableFogCulling) = 0;
+      virtual std::optional<bool> getEnforceCulledScreenSpaceError() = 0;
+      virtual void setEnforceCulledScreenSpaceError(std::optional<bool> enforceCulledScreenSpaceError) = 0;
+      virtual std::optional<double> getCulledScreenSpaceError() = 0;
+      virtual void setCulledScreenSpaceError(std::optional<double> culledScreenSpaceError) = 0;
+      virtual std::optional<bool> getEnableLodTransitionPeriod() = 0;
+      virtual void setEnableLodTransitionPeriod(std::optional<bool> enableLodTransitionPeriod) = 0;
+      virtual std::optional<double> getLodTransitionLength() = 0;
+      virtual void setLodTransitionLength(std::optional<double> lodTransitionLength) = 0;
+      virtual std::optional<double> getSqliteCacheMaxRows() = 0;
+      virtual void setSqliteCacheMaxRows(std::optional<double> sqliteCacheMaxRows) = 0;
+      virtual std::optional<double> getTaskProcessorThreads() = 0;
+      virtual void setTaskProcessorThreads(std::optional<double> taskProcessorThreads) = 0;
       virtual std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> getOnMetrics() = 0;
       virtual void setOnMetrics(const std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>& onMetrics) = 0;
 

package/nitrogen/generated/shared/c++/views/HybridCesiumViewComponent.cpp

@@ -116,6 +116,126 @@ namespace margelo::nitro::reactnativecesium::views {
         throw std::runtime_error(std::string("CesiumView.ionImageryAssetId: ") + exc.what());
       }
     }()),
+    maximumCachedMiB([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("maximumCachedMiB", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.maximumCachedMiB;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.maximumCachedMiB);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.maximumCachedMiB: ") + exc.what());
+      }
+    }()),
+    preloadAncestors([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("preloadAncestors", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.preloadAncestors;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.preloadAncestors);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.preloadAncestors: ") + exc.what());
+      }
+    }()),
+    preloadSiblings([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("preloadSiblings", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.preloadSiblings;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.preloadSiblings);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.preloadSiblings: ") + exc.what());
+      }
+    }()),
+    forbidHoles([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("forbidHoles", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.forbidHoles;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.forbidHoles);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.forbidHoles: ") + exc.what());
+      }
+    }()),
+    enableWaterMask([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("enableWaterMask", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.enableWaterMask;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.enableWaterMask);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.enableWaterMask: ") + exc.what());
+      }
+    }()),
+    enableFogCulling([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("enableFogCulling", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.enableFogCulling;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.enableFogCulling);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.enableFogCulling: ") + exc.what());
+      }
+    }()),
+    enforceCulledScreenSpaceError([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("enforceCulledScreenSpaceError", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.enforceCulledScreenSpaceError;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.enforceCulledScreenSpaceError);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.enforceCulledScreenSpaceError: ") + exc.what());
+      }
+    }()),
+    culledScreenSpaceError([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("culledScreenSpaceError", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.culledScreenSpaceError;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.culledScreenSpaceError);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.culledScreenSpaceError: ") + exc.what());
+      }
+    }()),
+    enableLodTransitionPeriod([&]() -> CachedProp<std::optional<bool>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("enableLodTransitionPeriod", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.enableLodTransitionPeriod;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<bool>>::fromRawValue(*runtime, value, sourceProps.enableLodTransitionPeriod);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.enableLodTransitionPeriod: ") + exc.what());
+      }
+    }()),
+    lodTransitionLength([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("lodTransitionLength", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.lodTransitionLength;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.lodTransitionLength);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.lodTransitionLength: ") + exc.what());
+      }
+    }()),
+    sqliteCacheMaxRows([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("sqliteCacheMaxRows", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.sqliteCacheMaxRows;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.sqliteCacheMaxRows);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.sqliteCacheMaxRows: ") + exc.what());
+      }
+    }()),
+    taskProcessorThreads([&]() -> CachedProp<std::optional<double>> {
+      try {
+        const react::RawValue* rawValue = rawProps.at("taskProcessorThreads", nullptr, nullptr);
+        if (rawValue == nullptr) return sourceProps.taskProcessorThreads;
+        const auto& [runtime, value] = (std::pair<jsi::Runtime*, jsi::Value>)*rawValue;
+        return CachedProp<std::optional<double>>::fromRawValue(*runtime, value, sourceProps.taskProcessorThreads);
+      } catch (const std::exception& exc) {
+        throw std::runtime_error(std::string("CesiumView.taskProcessorThreads: ") + exc.what());
+      }
+    }()),
     onMetrics([&]() -> CachedProp<std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>> {
       try {
         const react::RawValue* rawValue = rawProps.at("onMetrics", nullptr, nullptr);
@@ -148,6 +268,18 @@ namespace margelo::nitro::reactnativecesium::views {
       case hashString("loadingDescendantLimit"): return true;
       case hashString("msaaSampleCount"): return true;
       case hashString("ionImageryAssetId"): return true;
+      case hashString("maximumCachedMiB"): return true;
+      case hashString("preloadAncestors"): return true;
+      case hashString("preloadSiblings"): return true;
+      case hashString("forbidHoles"): return true;
+      case hashString("enableWaterMask"): return true;
+      case hashString("enableFogCulling"): return true;
+      case hashString("enforceCulledScreenSpaceError"): return true;
+      case hashString("culledScreenSpaceError"): return true;
+      case hashString("enableLodTransitionPeriod"): return true;
+      case hashString("lodTransitionLength"): return true;
+      case hashString("sqliteCacheMaxRows"): return true;
+      case hashString("taskProcessorThreads"): return true;
       case hashString("onMetrics"): return true;
       case hashString("hybridRef"): return true;
       default: return false;

package/nitrogen/generated/shared/c++/views/HybridCesiumViewComponent.hpp

@@ -18,9 +18,9 @@
 
 #include <string>
 #include "CameraState.hpp"
+#include <optional>
 #include "CesiumMetrics.hpp"
 #include <functional>
-#include <optional>
 #include <memory>
 #include "HybridCesiumViewSpec.hpp"
 
@@ -53,6 +53,18 @@ namespace margelo::nitro::reactnativecesium::views {
     CachedProp<double> loadingDescendantLimit;
     CachedProp<double> msaaSampleCount;
     CachedProp<double> ionImageryAssetId;
+    CachedProp<std::optional<double>> maximumCachedMiB;
+    CachedProp<std::optional<bool>> preloadAncestors;
+    CachedProp<std::optional<bool>> preloadSiblings;
+    CachedProp<std::optional<bool>> forbidHoles;
+    CachedProp<std::optional<bool>> enableWaterMask;
+    CachedProp<std::optional<bool>> enableFogCulling;
+    CachedProp<std::optional<bool>> enforceCulledScreenSpaceError;
+    CachedProp<std::optional<double>> culledScreenSpaceError;
+    CachedProp<std::optional<bool>> enableLodTransitionPeriod;
+    CachedProp<std::optional<double>> lodTransitionLength;
+    CachedProp<std::optional<double>> sqliteCacheMaxRows;
+    CachedProp<std::optional<double>> taskProcessorThreads;
     CachedProp<std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>> onMetrics;
     CachedProp<std::optional<std::function<void(const std::shared_ptr<HybridCesiumViewSpec>& /* ref */)>>> hybridRef;
 

package/nitrogen/generated/shared/json/CesiumViewConfig.json

@@ -13,6 +13,18 @@
     "loadingDescendantLimit": true,
     "msaaSampleCount": true,
     "ionImageryAssetId": true,
+    "maximumCachedMiB": true,
+    "preloadAncestors": true,
+    "preloadSiblings": true,
+    "forbidHoles": true,
+    "enableWaterMask": true,
+    "enableFogCulling": true,
+    "enforceCulledScreenSpaceError": true,
+    "culledScreenSpaceError": true,
+    "enableLodTransitionPeriod": true,
+    "lodTransitionLength": true,
+    "sqliteCacheMaxRows": true,
+    "taskProcessorThreads": true,
     "onMetrics": true,
     "hybridRef": true
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-cesium",
-  "version": "1.0.6",
+  "version": "1.2.0",
   "description": "Experimental Cesium rendering for React Native via Nitro (iOS/Metal today; Android planned)",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
@@ -64,7 +64,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "react-native-nitro-modules": "^0.35.4"
+    "react-native-nitro-modules": "^0.35.6"
   },
   "publishConfig": {
     "access": "public",
@@ -77,9 +77,9 @@
     "@types/jest": "^29.5.14",
     "@types/react": "19.2.14",
     "conventional-changelog-conventionalcommits": "^9.3.1",
-    "nitrogen": "0.35.4",
+    "nitrogen": "0.35.6",
     "react": "19.2.3",
-    "react-native": "0.85.1",
+    "react-native": "0.85.2",
     "react-native-builder-bob": "^0.41.0",
     "semantic-release": "^25.0.3",
     "typescript": "^5.9.3"

package/scripts/cesium/clone.mjs

@@ -12,7 +12,7 @@ const root = join(__dirname, '..', '..')
 const vendor = join(root, 'vendor')
 const dest = join(vendor, 'cesium-native')
 const repo = 'https://github.com/CesiumGS/cesium-native.git'
-const ref = 'v0.59.0'
+const ref = 'v0.60.0'
 
 function run(cmd, args, opts = {}) {
   execFileSync(cmd, args, { stdio: 'inherit', ...opts })