react-native-cesium 1.0.6 → 1.2.0

package/nitrogen/generated/android/c++/JHybridCesiumViewSpec.cpp

@@ -17,9 +17,9 @@ namespace margelo::nitro::reactnativecesium { struct Quaternion; }
 #include <string>
 #include "CameraState.hpp"
 #include "JCameraState.hpp"
+#include <optional>
 #include "CesiumMetrics.hpp"
 #include <functional>
-#include <optional>
 #include "JFunc_void_CesiumMetrics.hpp"
 #include <NitroModules/JNICallable.hpp>
 #include "JCesiumMetrics.hpp"
@@ -139,6 +139,114 @@ namespace margelo::nitro::reactnativecesium {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* ionImageryAssetId */)>("setIonImageryAssetId");
     method(_javaPart, ionImageryAssetId);
   }
+  std::optional<double> JHybridCesiumViewSpec::getMaximumCachedMiB() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getMaximumCachedMiB");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setMaximumCachedMiB(std::optional<double> maximumCachedMiB) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* maximumCachedMiB */)>("setMaximumCachedMiB");
+    method(_javaPart, maximumCachedMiB.has_value() ? jni::JDouble::valueOf(maximumCachedMiB.value()) : nullptr);
+  }
+  std::optional<bool> JHybridCesiumViewSpec::getPreloadAncestors() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getPreloadAncestors");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setPreloadAncestors(std::optional<bool> preloadAncestors) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* preloadAncestors */)>("setPreloadAncestors");
+    method(_javaPart, preloadAncestors.has_value() ? jni::JBoolean::valueOf(preloadAncestors.value()) : nullptr);
+  }
+  std::optional<bool> JHybridCesiumViewSpec::getPreloadSiblings() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getPreloadSiblings");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setPreloadSiblings(std::optional<bool> preloadSiblings) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* preloadSiblings */)>("setPreloadSiblings");
+    method(_javaPart, preloadSiblings.has_value() ? jni::JBoolean::valueOf(preloadSiblings.value()) : nullptr);
+  }
+  std::optional<bool> JHybridCesiumViewSpec::getForbidHoles() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getForbidHoles");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setForbidHoles(std::optional<bool> forbidHoles) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* forbidHoles */)>("setForbidHoles");
+    method(_javaPart, forbidHoles.has_value() ? jni::JBoolean::valueOf(forbidHoles.value()) : nullptr);
+  }
+  std::optional<bool> JHybridCesiumViewSpec::getEnableWaterMask() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getEnableWaterMask");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setEnableWaterMask(std::optional<bool> enableWaterMask) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* enableWaterMask */)>("setEnableWaterMask");
+    method(_javaPart, enableWaterMask.has_value() ? jni::JBoolean::valueOf(enableWaterMask.value()) : nullptr);
+  }
+  std::optional<bool> JHybridCesiumViewSpec::getEnableFogCulling() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getEnableFogCulling");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setEnableFogCulling(std::optional<bool> enableFogCulling) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* enableFogCulling */)>("setEnableFogCulling");
+    method(_javaPart, enableFogCulling.has_value() ? jni::JBoolean::valueOf(enableFogCulling.value()) : nullptr);
+  }
+  std::optional<bool> JHybridCesiumViewSpec::getEnforceCulledScreenSpaceError() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getEnforceCulledScreenSpaceError");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setEnforceCulledScreenSpaceError(std::optional<bool> enforceCulledScreenSpaceError) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* enforceCulledScreenSpaceError */)>("setEnforceCulledScreenSpaceError");
+    method(_javaPart, enforceCulledScreenSpaceError.has_value() ? jni::JBoolean::valueOf(enforceCulledScreenSpaceError.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getCulledScreenSpaceError() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getCulledScreenSpaceError");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setCulledScreenSpaceError(std::optional<double> culledScreenSpaceError) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* culledScreenSpaceError */)>("setCulledScreenSpaceError");
+    method(_javaPart, culledScreenSpaceError.has_value() ? jni::JDouble::valueOf(culledScreenSpaceError.value()) : nullptr);
+  }
+  std::optional<bool> JHybridCesiumViewSpec::getEnableLodTransitionPeriod() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getEnableLodTransitionPeriod");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setEnableLodTransitionPeriod(std::optional<bool> enableLodTransitionPeriod) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* enableLodTransitionPeriod */)>("setEnableLodTransitionPeriod");
+    method(_javaPart, enableLodTransitionPeriod.has_value() ? jni::JBoolean::valueOf(enableLodTransitionPeriod.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getLodTransitionLength() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getLodTransitionLength");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setLodTransitionLength(std::optional<double> lodTransitionLength) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* lodTransitionLength */)>("setLodTransitionLength");
+    method(_javaPart, lodTransitionLength.has_value() ? jni::JDouble::valueOf(lodTransitionLength.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getSqliteCacheMaxRows() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getSqliteCacheMaxRows");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setSqliteCacheMaxRows(std::optional<double> sqliteCacheMaxRows) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* sqliteCacheMaxRows */)>("setSqliteCacheMaxRows");
+    method(_javaPart, sqliteCacheMaxRows.has_value() ? jni::JDouble::valueOf(sqliteCacheMaxRows.value()) : nullptr);
+  }
+  std::optional<double> JHybridCesiumViewSpec::getTaskProcessorThreads() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getTaskProcessorThreads");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridCesiumViewSpec::setTaskProcessorThreads(std::optional<double> taskProcessorThreads) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* taskProcessorThreads */)>("setTaskProcessorThreads");
+    method(_javaPart, taskProcessorThreads.has_value() ? jni::JDouble::valueOf(taskProcessorThreads.value()) : nullptr);
+  }
   std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> JHybridCesiumViewSpec::getOnMetrics() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_CesiumMetrics::javaobject>()>("getOnMetrics_cxx");
     auto __result = method(_javaPart);

package/nitrogen/generated/android/c++/JHybridCesiumViewSpec.hpp

@@ -68,6 +68,30 @@ namespace margelo::nitro::reactnativecesium {
     void setMsaaSampleCount(double msaaSampleCount) override;
     double getIonImageryAssetId() override;
     void setIonImageryAssetId(double ionImageryAssetId) override;
+    std::optional<double> getMaximumCachedMiB() override;
+    void setMaximumCachedMiB(std::optional<double> maximumCachedMiB) override;
+    std::optional<bool> getPreloadAncestors() override;
+    void setPreloadAncestors(std::optional<bool> preloadAncestors) override;
+    std::optional<bool> getPreloadSiblings() override;
+    void setPreloadSiblings(std::optional<bool> preloadSiblings) override;
+    std::optional<bool> getForbidHoles() override;
+    void setForbidHoles(std::optional<bool> forbidHoles) override;
+    std::optional<bool> getEnableWaterMask() override;
+    void setEnableWaterMask(std::optional<bool> enableWaterMask) override;
+    std::optional<bool> getEnableFogCulling() override;
+    void setEnableFogCulling(std::optional<bool> enableFogCulling) override;
+    std::optional<bool> getEnforceCulledScreenSpaceError() override;
+    void setEnforceCulledScreenSpaceError(std::optional<bool> enforceCulledScreenSpaceError) override;
+    std::optional<double> getCulledScreenSpaceError() override;
+    void setCulledScreenSpaceError(std::optional<double> culledScreenSpaceError) override;
+    std::optional<bool> getEnableLodTransitionPeriod() override;
+    void setEnableLodTransitionPeriod(std::optional<bool> enableLodTransitionPeriod) override;
+    std::optional<double> getLodTransitionLength() override;
+    void setLodTransitionLength(std::optional<double> lodTransitionLength) override;
+    std::optional<double> getSqliteCacheMaxRows() override;
+    void setSqliteCacheMaxRows(std::optional<double> sqliteCacheMaxRows) override;
+    std::optional<double> getTaskProcessorThreads() override;
+    void setTaskProcessorThreads(std::optional<double> taskProcessorThreads) override;
     std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> getOnMetrics() override;
     void setOnMetrics(const std::optional<std::function<void(const CesiumMetrics& /* metrics */)>>& onMetrics) override;
 

package/nitrogen/generated/android/c++/views/JHybridCesiumViewStateUpdater.cpp

@@ -73,6 +73,54 @@ void JHybridCesiumViewStateUpdater::updateViewProps(jni::alias_ref<jni::JClass>
     hybridView->setIonImageryAssetId(props->ionImageryAssetId.value);
     props->ionImageryAssetId.isDirty = false;
   }
+  if (props->maximumCachedMiB.isDirty) {
+    hybridView->setMaximumCachedMiB(props->maximumCachedMiB.value);
+    props->maximumCachedMiB.isDirty = false;
+  }
+  if (props->preloadAncestors.isDirty) {
+    hybridView->setPreloadAncestors(props->preloadAncestors.value);
+    props->preloadAncestors.isDirty = false;
+  }
+  if (props->preloadSiblings.isDirty) {
+    hybridView->setPreloadSiblings(props->preloadSiblings.value);
+    props->preloadSiblings.isDirty = false;
+  }
+  if (props->forbidHoles.isDirty) {
+    hybridView->setForbidHoles(props->forbidHoles.value);
+    props->forbidHoles.isDirty = false;
+  }
+  if (props->enableWaterMask.isDirty) {
+    hybridView->setEnableWaterMask(props->enableWaterMask.value);
+    props->enableWaterMask.isDirty = false;
+  }
+  if (props->enableFogCulling.isDirty) {
+    hybridView->setEnableFogCulling(props->enableFogCulling.value);
+    props->enableFogCulling.isDirty = false;
+  }
+  if (props->enforceCulledScreenSpaceError.isDirty) {
+    hybridView->setEnforceCulledScreenSpaceError(props->enforceCulledScreenSpaceError.value);
+    props->enforceCulledScreenSpaceError.isDirty = false;
+  }
+  if (props->culledScreenSpaceError.isDirty) {
+    hybridView->setCulledScreenSpaceError(props->culledScreenSpaceError.value);
+    props->culledScreenSpaceError.isDirty = false;
+  }
+  if (props->enableLodTransitionPeriod.isDirty) {
+    hybridView->setEnableLodTransitionPeriod(props->enableLodTransitionPeriod.value);
+    props->enableLodTransitionPeriod.isDirty = false;
+  }
+  if (props->lodTransitionLength.isDirty) {
+    hybridView->setLodTransitionLength(props->lodTransitionLength.value);
+    props->lodTransitionLength.isDirty = false;
+  }
+  if (props->sqliteCacheMaxRows.isDirty) {
+    hybridView->setSqliteCacheMaxRows(props->sqliteCacheMaxRows.value);
+    props->sqliteCacheMaxRows.isDirty = false;
+  }
+  if (props->taskProcessorThreads.isDirty) {
+    hybridView->setTaskProcessorThreads(props->taskProcessorThreads.value);
+    props->taskProcessorThreads.isDirty = false;
+  }
   if (props->onMetrics.isDirty) {
     hybridView->setOnMetrics(props->onMetrics.value);
     props->onMetrics.isDirty = false;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativecesium/CameraState.kt

@@ -9,6 +9,7 @@ package com.margelo.nitro.reactnativecesium
 
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
 
 
 /**
@@ -41,6 +42,30 @@ data class CameraState(
 ) {
   /* primary constructor */
 
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is CameraState) return false
+    return Objects.deepEquals(this.latitude, other.latitude)
+      && Objects.deepEquals(this.longitude, other.longitude)
+      && Objects.deepEquals(this.altitude, other.altitude)
+      && Objects.deepEquals(this.heading, other.heading)
+      && Objects.deepEquals(this.pitch, other.pitch)
+      && Objects.deepEquals(this.roll, other.roll)
+      && Objects.deepEquals(this.verticalFovDeg, other.verticalFovDeg)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf(
+      latitude,
+      longitude,
+      altitude,
+      heading,
+      pitch,
+      roll,
+      verticalFovDeg
+    ).contentDeepHashCode()
+  }
+
   companion object {
     /**
      * Constructor called from C++

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativecesium/CesiumMetrics.kt

@@ -9,6 +9,7 @@ package com.margelo.nitro.reactnativecesium
 
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
 
 
 /**
@@ -34,6 +35,9 @@ data class CesiumMetrics(
   val ionTokenConfigured: Boolean,
   @DoNotStrip
   @Keep
+  val tlsConfigured: Boolean,
+  @DoNotStrip
+  @Keep
   val tilesetReady: Boolean,
   @DoNotStrip
   @Keep
@@ -41,6 +45,32 @@ data class CesiumMetrics(
 ) {
   /* primary constructor */
 
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is CesiumMetrics) return false
+    return Objects.deepEquals(this.fps, other.fps)
+      && Objects.deepEquals(this.tilesRendered, other.tilesRendered)
+      && Objects.deepEquals(this.tilesLoading, other.tilesLoading)
+      && Objects.deepEquals(this.tilesVisited, other.tilesVisited)
+      && Objects.deepEquals(this.ionTokenConfigured, other.ionTokenConfigured)
+      && Objects.deepEquals(this.tlsConfigured, other.tlsConfigured)
+      && Objects.deepEquals(this.tilesetReady, other.tilesetReady)
+      && Objects.deepEquals(this.creditsPlainText, other.creditsPlainText)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf(
+      fps,
+      tilesRendered,
+      tilesLoading,
+      tilesVisited,
+      ionTokenConfigured,
+      tlsConfigured,
+      tilesetReady,
+      creditsPlainText
+    ).contentDeepHashCode()
+  }
+
   companion object {
     /**
      * Constructor called from C++
@@ -49,8 +79,8 @@ data class CesiumMetrics(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(fps: Double, tilesRendered: Double, tilesLoading: Double, tilesVisited: Double, ionTokenConfigured: Boolean, tilesetReady: Boolean, creditsPlainText: String): CesiumMetrics {
-      return CesiumMetrics(fps, tilesRendered, tilesLoading, tilesVisited, ionTokenConfigured, tilesetReady, creditsPlainText)
+    private fun fromCpp(fps: Double, tilesRendered: Double, tilesLoading: Double, tilesVisited: Double, ionTokenConfigured: Boolean, tlsConfigured: Boolean, tilesetReady: Boolean, creditsPlainText: String): CesiumMetrics {
+      return CesiumMetrics(fps, tilesRendered, tilesLoading, tilesVisited, ionTokenConfigured, tlsConfigured, tilesetReady, creditsPlainText)
     }
   }
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativecesium/HybridCesiumViewSpec.kt

@@ -81,6 +81,78 @@ abstract class HybridCesiumViewSpec: HybridView() {
   @set:Keep
   abstract var ionImageryAssetId: Double
   
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maximumCachedMiB: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var preloadAncestors: Boolean?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var preloadSiblings: Boolean?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var forbidHoles: Boolean?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var enableWaterMask: Boolean?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var enableFogCulling: Boolean?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var enforceCulledScreenSpaceError: Boolean?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var culledScreenSpaceError: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var enableLodTransitionPeriod: Boolean?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var lodTransitionLength: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var sqliteCacheMaxRows: Double?
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var taskProcessorThreads: Double?
+  
   abstract var onMetrics: ((metrics: CesiumMetrics) -> Unit)?
   
   private var onMetrics_cxx: Func_void_CesiumMetrics?

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativecesium/Quaternion.kt

@@ -9,6 +9,7 @@ package com.margelo.nitro.reactnativecesium
 
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
 
 
 /**
@@ -32,6 +33,24 @@ data class Quaternion(
 ) {
   /* primary constructor */
 
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is Quaternion) return false
+    return Objects.deepEquals(this.w, other.w)
+      && Objects.deepEquals(this.x, other.x)
+      && Objects.deepEquals(this.y, other.y)
+      && Objects.deepEquals(this.z, other.z)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf(
+      w,
+      x,
+      y,
+      z
+    ).contentDeepHashCode()
+  }
+
   companion object {
     /**
      * Constructor called from C++

package/nitrogen/generated/ios/ReactNativeCesium-Swift-Cxx-Bridge.hpp

@@ -41,6 +41,36 @@ namespace ReactNativeCesium { class HybridCesiumViewSpec_cxx; }
  */
 namespace margelo::nitro::reactnativecesium::bridge::swift {
 
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::function<void(const CesiumMetrics& /* metrics */)>
   /**
    * Specialized version of `std::function<void(const CesiumMetrics&)>`.

package/nitrogen/generated/ios/c++/HybridCesiumViewSpecSwift.hpp

@@ -21,9 +21,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"
 
@@ -128,6 +128,90 @@ namespace margelo::nitro::reactnativecesium {
     inline void setIonImageryAssetId(double ionImageryAssetId) noexcept override {
       _swiftPart.setIonImageryAssetId(std::forward<decltype(ionImageryAssetId)>(ionImageryAssetId));
     }
+    inline std::optional<double> getMaximumCachedMiB() noexcept override {
+      auto __result = _swiftPart.getMaximumCachedMiB();
+      return __result;
+    }
+    inline void setMaximumCachedMiB(std::optional<double> maximumCachedMiB) noexcept override {
+      _swiftPart.setMaximumCachedMiB(maximumCachedMiB);
+    }
+    inline std::optional<bool> getPreloadAncestors() noexcept override {
+      auto __result = _swiftPart.getPreloadAncestors();
+      return __result;
+    }
+    inline void setPreloadAncestors(std::optional<bool> preloadAncestors) noexcept override {
+      _swiftPart.setPreloadAncestors(preloadAncestors);
+    }
+    inline std::optional<bool> getPreloadSiblings() noexcept override {
+      auto __result = _swiftPart.getPreloadSiblings();
+      return __result;
+    }
+    inline void setPreloadSiblings(std::optional<bool> preloadSiblings) noexcept override {
+      _swiftPart.setPreloadSiblings(preloadSiblings);
+    }
+    inline std::optional<bool> getForbidHoles() noexcept override {
+      auto __result = _swiftPart.getForbidHoles();
+      return __result;
+    }
+    inline void setForbidHoles(std::optional<bool> forbidHoles) noexcept override {
+      _swiftPart.setForbidHoles(forbidHoles);
+    }
+    inline std::optional<bool> getEnableWaterMask() noexcept override {
+      auto __result = _swiftPart.getEnableWaterMask();
+      return __result;
+    }
+    inline void setEnableWaterMask(std::optional<bool> enableWaterMask) noexcept override {
+      _swiftPart.setEnableWaterMask(enableWaterMask);
+    }
+    inline std::optional<bool> getEnableFogCulling() noexcept override {
+      auto __result = _swiftPart.getEnableFogCulling();
+      return __result;
+    }
+    inline void setEnableFogCulling(std::optional<bool> enableFogCulling) noexcept override {
+      _swiftPart.setEnableFogCulling(enableFogCulling);
+    }
+    inline std::optional<bool> getEnforceCulledScreenSpaceError() noexcept override {
+      auto __result = _swiftPart.getEnforceCulledScreenSpaceError();
+      return __result;
+    }
+    inline void setEnforceCulledScreenSpaceError(std::optional<bool> enforceCulledScreenSpaceError) noexcept override {
+      _swiftPart.setEnforceCulledScreenSpaceError(enforceCulledScreenSpaceError);
+    }
+    inline std::optional<double> getCulledScreenSpaceError() noexcept override {
+      auto __result = _swiftPart.getCulledScreenSpaceError();
+      return __result;
+    }
+    inline void setCulledScreenSpaceError(std::optional<double> culledScreenSpaceError) noexcept override {
+      _swiftPart.setCulledScreenSpaceError(culledScreenSpaceError);
+    }
+    inline std::optional<bool> getEnableLodTransitionPeriod() noexcept override {
+      auto __result = _swiftPart.getEnableLodTransitionPeriod();
+      return __result;
+    }
+    inline void setEnableLodTransitionPeriod(std::optional<bool> enableLodTransitionPeriod) noexcept override {
+      _swiftPart.setEnableLodTransitionPeriod(enableLodTransitionPeriod);
+    }
+    inline std::optional<double> getLodTransitionLength() noexcept override {
+      auto __result = _swiftPart.getLodTransitionLength();
+      return __result;
+    }
+    inline void setLodTransitionLength(std::optional<double> lodTransitionLength) noexcept override {
+      _swiftPart.setLodTransitionLength(lodTransitionLength);
+    }
+    inline std::optional<double> getSqliteCacheMaxRows() noexcept override {
+      auto __result = _swiftPart.getSqliteCacheMaxRows();
+      return __result;
+    }
+    inline void setSqliteCacheMaxRows(std::optional<double> sqliteCacheMaxRows) noexcept override {
+      _swiftPart.setSqliteCacheMaxRows(sqliteCacheMaxRows);
+    }
+    inline std::optional<double> getTaskProcessorThreads() noexcept override {
+      auto __result = _swiftPart.getTaskProcessorThreads();
+      return __result;
+    }
+    inline void setTaskProcessorThreads(std::optional<double> taskProcessorThreads) noexcept override {
+      _swiftPart.setTaskProcessorThreads(taskProcessorThreads);
+    }
     inline std::optional<std::function<void(const CesiumMetrics& /* metrics */)>> getOnMetrics() noexcept override {
       auto __result = _swiftPart.getOnMetrics();
       return __result;

package/nitrogen/generated/ios/c++/views/HybridCesiumViewComponent.mm

@@ -124,6 +124,66 @@ using namespace margelo::nitro::reactnativecesium::views;
     swiftPart.setIonImageryAssetId(newViewProps.ionImageryAssetId.value);
     newViewProps.ionImageryAssetId.isDirty = false;
   }
+  // maximumCachedMiB: optional
+  if (newViewProps.maximumCachedMiB.isDirty) {
+    swiftPart.setMaximumCachedMiB(newViewProps.maximumCachedMiB.value);
+    newViewProps.maximumCachedMiB.isDirty = false;
+  }
+  // preloadAncestors: optional
+  if (newViewProps.preloadAncestors.isDirty) {
+    swiftPart.setPreloadAncestors(newViewProps.preloadAncestors.value);
+    newViewProps.preloadAncestors.isDirty = false;
+  }
+  // preloadSiblings: optional
+  if (newViewProps.preloadSiblings.isDirty) {
+    swiftPart.setPreloadSiblings(newViewProps.preloadSiblings.value);
+    newViewProps.preloadSiblings.isDirty = false;
+  }
+  // forbidHoles: optional
+  if (newViewProps.forbidHoles.isDirty) {
+    swiftPart.setForbidHoles(newViewProps.forbidHoles.value);
+    newViewProps.forbidHoles.isDirty = false;
+  }
+  // enableWaterMask: optional
+  if (newViewProps.enableWaterMask.isDirty) {
+    swiftPart.setEnableWaterMask(newViewProps.enableWaterMask.value);
+    newViewProps.enableWaterMask.isDirty = false;
+  }
+  // enableFogCulling: optional
+  if (newViewProps.enableFogCulling.isDirty) {
+    swiftPart.setEnableFogCulling(newViewProps.enableFogCulling.value);
+    newViewProps.enableFogCulling.isDirty = false;
+  }
+  // enforceCulledScreenSpaceError: optional
+  if (newViewProps.enforceCulledScreenSpaceError.isDirty) {
+    swiftPart.setEnforceCulledScreenSpaceError(newViewProps.enforceCulledScreenSpaceError.value);
+    newViewProps.enforceCulledScreenSpaceError.isDirty = false;
+  }
+  // culledScreenSpaceError: optional
+  if (newViewProps.culledScreenSpaceError.isDirty) {
+    swiftPart.setCulledScreenSpaceError(newViewProps.culledScreenSpaceError.value);
+    newViewProps.culledScreenSpaceError.isDirty = false;
+  }
+  // enableLodTransitionPeriod: optional
+  if (newViewProps.enableLodTransitionPeriod.isDirty) {
+    swiftPart.setEnableLodTransitionPeriod(newViewProps.enableLodTransitionPeriod.value);
+    newViewProps.enableLodTransitionPeriod.isDirty = false;
+  }
+  // lodTransitionLength: optional
+  if (newViewProps.lodTransitionLength.isDirty) {
+    swiftPart.setLodTransitionLength(newViewProps.lodTransitionLength.value);
+    newViewProps.lodTransitionLength.isDirty = false;
+  }
+  // sqliteCacheMaxRows: optional
+  if (newViewProps.sqliteCacheMaxRows.isDirty) {
+    swiftPart.setSqliteCacheMaxRows(newViewProps.sqliteCacheMaxRows.value);
+    newViewProps.sqliteCacheMaxRows.isDirty = false;
+  }
+  // taskProcessorThreads: optional
+  if (newViewProps.taskProcessorThreads.isDirty) {
+    swiftPart.setTaskProcessorThreads(newViewProps.taskProcessorThreads.value);
+    newViewProps.taskProcessorThreads.isDirty = false;
+  }
   // onMetrics: optional
   if (newViewProps.onMetrics.isDirty) {
     swiftPart.setOnMetrics(newViewProps.onMetrics.value);

package/nitrogen/generated/ios/swift/CesiumMetrics.swift

@@ -18,8 +18,8 @@ public extension CesiumMetrics {
   /**
    * Create a new instance of `CesiumMetrics`.
    */
-  init(fps: Double, tilesRendered: Double, tilesLoading: Double, tilesVisited: Double, ionTokenConfigured: Bool, tilesetReady: Bool, creditsPlainText: String) {
-    self.init(fps, tilesRendered, tilesLoading, tilesVisited, ionTokenConfigured, tilesetReady, std.string(creditsPlainText))
+  init(fps: Double, tilesRendered: Double, tilesLoading: Double, tilesVisited: Double, ionTokenConfigured: Bool, tlsConfigured: Bool, tilesetReady: Bool, creditsPlainText: String) {
+    self.init(fps, tilesRendered, tilesLoading, tilesVisited, ionTokenConfigured, tlsConfigured, tilesetReady, std.string(creditsPlainText))
   }
 
   @inline(__always)
@@ -47,6 +47,11 @@ public extension CesiumMetrics {
     return self.__ionTokenConfigured
   }
   
+  @inline(__always)
+  var tlsConfigured: Bool {
+    return self.__tlsConfigured
+  }
+  
   @inline(__always)
   var tilesetReady: Bool {
     return self.__tilesetReady