react-native-cesium 1.2.18 → 1.2.20

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

@@ -20,6 +20,14 @@ import com.margelo.nitro.reactnativecesium.*
  * Represents the React Native `ViewManager` for the "CesiumView" Nitro HybridView.
  */
 public class HybridCesiumViewManager: SimpleViewManager<View>() {
+  /**
+   * Represents the View and its last state snapshot (mutable)
+   */
+  private class HybridViewHolder(
+    val hybridView: HybridCesiumView,
+    var lastState: StateWrapper? = null,
+  )
+
   init {
     if (RecyclableView::class.java.isAssignableFrom(HybridCesiumView::class.java)) {
       // Enable view recycling
@@ -34,33 +42,41 @@ public class HybridCesiumViewManager: SimpleViewManager<View>() {
   override fun createViewInstance(reactContext: ThemedReactContext): View {
     val hybridView = HybridCesiumView(reactContext)
     val view = hybridView.view
-    view.setTag(associated_hybrid_view_tag, hybridView)
+    view.setTag(associated_hybrid_view_tag, HybridViewHolder(hybridView))
     return view
   }
 
   override fun updateState(view: View, props: ReactStylesDiffMap, stateWrapper: StateWrapper): Any? {
-    val hybridView = getHybridView(view)
+    val holder = getHybridViewHolder(view)
       ?: throw Error("Couldn't find view $view in local views table!")
+    val hybridView = holder.hybridView
+    val oldState = holder.lastState
+    val newState = stateWrapper
 
     // 1. Update each prop individually
     hybridView.beforeUpdate()
-    HybridCesiumViewStateUpdater.updateViewProps(hybridView, stateWrapper)
+    HybridCesiumViewStateUpdater.updateViewProps(hybridView, newState, oldState)
     hybridView.afterUpdate()
+    holder.lastState = newState
 
     // 2. Continue in base View props
-    return super.updateState(view, props, stateWrapper)
+    return super.updateState(view, props, newState)
   }
 
   override fun onDropViewInstance(view: View) {
-    val hybridView = getHybridView(view)
-    hybridView?.onDropView()
+    val holder = getHybridViewHolder(view)
+    holder?.lastState = null
+    holder?.hybridView?.onDropView()
     return super.onDropViewInstance(view)
   }
 
   protected override fun prepareToRecycleView(reactContext: ThemedReactContext, view: View): View? {
-    super.prepareToRecycleView(reactContext, view)
-    val hybridView = getHybridView(view)
+    val preparedView = super.prepareToRecycleView(reactContext, view)
+      ?: return null
+    val holder = getHybridViewHolder(preparedView)
       ?: return null
+    val hybridView = holder.hybridView
+    holder.lastState = null
 
     @Suppress("USELESS_IS_CHECK")
     if (hybridView is RecyclableView) {
@@ -74,7 +90,7 @@ public class HybridCesiumViewManager: SimpleViewManager<View>() {
     }
   }
 
-  private fun getHybridView(view: View): HybridCesiumView? {
-    return view.getTag(associated_hybrid_view_tag) as? HybridCesiumView
+  private fun getHybridViewHolder(view: View): HybridViewHolder? {
+    return view.getTag(associated_hybrid_view_tag) as? HybridViewHolder
   }
 }

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

@@ -14,10 +14,10 @@ internal class HybridCesiumViewStateUpdater {
   companion object {
     /**
      * Updates the props for [view] through C++.
-     * The [state] prop is expected to contain [view]'s props as wrapped Fabric state.
+     * The [newState] prop is expected to contain [view]'s props as wrapped Fabric state.
      */
     @Suppress("KotlinJniMissingFunction")
     @JvmStatic
-    external fun updateViewProps(view: HybridCesiumViewSpec, state: StateWrapper)
+    external fun updateViewProps(view: HybridCesiumViewSpec, newState: StateWrapper, oldState: StateWrapper?)
   }
 }

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

@@ -41,6 +41,21 @@ namespace ReactNativeCesium { class HybridCesiumViewSpec_cxx; }
  */
 namespace margelo::nitro::reactnativecesium::bridge::swift {
 
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.value();
+  }
+  
   // pragma MARK: std::optional<double>
   /**
    * Specialized version of `std::optional<double>`.

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

@@ -128,6 +128,13 @@ namespace margelo::nitro::reactnativecesium {
     inline void setIonImageryAssetId(double ionImageryAssetId) noexcept override {
       _swiftPart.setIonImageryAssetId(std::forward<decltype(ionImageryAssetId)>(ionImageryAssetId));
     }
+    inline std::optional<std::string> getAltitudeDatum() noexcept override {
+      auto __result = _swiftPart.getAltitudeDatum();
+      return __result;
+    }
+    inline void setAltitudeDatum(const std::optional<std::string>& altitudeDatum) noexcept override {
+      _swiftPart.setAltitudeDatum(altitudeDatum);
+    }
     inline std::optional<double> getMaximumCachedMiB() noexcept override {
       auto __result = _swiftPart.getMaximumCachedMiB();
       return __result;

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

@@ -37,6 +37,7 @@ using namespace margelo::nitro::reactnativecesium::views;
 
 @implementation HybridCesiumViewComponent {
   std::shared_ptr<HybridCesiumViewSpecSwift> _hybridView;
+  BOOL _didDropView;
 }
 
 + (void) load {
@@ -50,6 +51,7 @@ using namespace margelo::nitro::reactnativecesium::views;
 
 - (instancetype) init {
   if (self = [super init]) {
+    _props = HybridCesiumViewShadowNode::defaultSharedProps();
     std::shared_ptr<HybridCesiumViewSpec> hybridView = ReactNativeCesium::ReactNativeCesiumAutolinking::createCesiumView();
     _hybridView = std::dynamic_pointer_cast<HybridCesiumViewSpecSwift>(hybridView);
     [self updateView];
@@ -69,175 +71,229 @@ using namespace margelo::nitro::reactnativecesium::views;
   [self setContentView:view];
 }
 
+- (void) notifyOnDropView {
+  // A recycled component can later be invalidated. Notify only once per mount.
+  if (_didDropView) {
+    return;
+  }
+  ReactNativeCesium::HybridCesiumViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
+  swiftPart.onDropView();
+  _didDropView = YES;
+}
+
 - (void) updateProps:(const std::shared_ptr<const react::Props>&)props
             oldProps:(const std::shared_ptr<const react::Props>&)oldProps {
+  // A props update marks a newly mounted or still-active component.
+  _didDropView = NO;
+
   // 1. Downcast props
-  const auto& newViewPropsConst = *std::static_pointer_cast<HybridCesiumViewProps const>(props);
-  auto& newViewProps = const_cast<HybridCesiumViewProps&>(newViewPropsConst);
+  const auto& newViewProps = *std::static_pointer_cast<const HybridCesiumViewProps>(props);
+  const auto* oldViewProps = static_cast<const HybridCesiumViewProps*>(oldProps.get());
   ReactNativeCesium::HybridCesiumViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
 
-  // 2. Update each prop individually
-  swiftPart.beforeUpdate();
+  // 2. Update only props that differ from the previous Props snapshot.
+  const bool hasTransactionPropChanges = oldViewProps == nullptr
+      ? newViewProps.hasAnyProvidedProps()
+      : !newViewProps.hasSameProps(*oldViewProps);
+  if (hasTransactionPropChanges) {
+    swiftPart.beforeUpdate();
 
-  // ionAccessToken: string
-  if (newViewProps.ionAccessToken.isDirty) {
-    swiftPart.setIonAccessToken(newViewProps.ionAccessToken.value);
-    newViewProps.ionAccessToken.isDirty = false;
-  }
-  // ionAssetId: number
-  if (newViewProps.ionAssetId.isDirty) {
-    swiftPart.setIonAssetId(newViewProps.ionAssetId.value);
-    newViewProps.ionAssetId.isDirty = false;
-  }
-  // initialCamera: struct
-  if (newViewProps.initialCamera.isDirty) {
-    swiftPart.setInitialCamera(newViewProps.initialCamera.value);
-    newViewProps.initialCamera.isDirty = false;
-  }
-  // pauseRendering: boolean
-  if (newViewProps.pauseRendering.isDirty) {
-    swiftPart.setPauseRendering(newViewProps.pauseRendering.value);
-    newViewProps.pauseRendering.isDirty = false;
-  }
-  // maximumScreenSpaceError: number
-  if (newViewProps.maximumScreenSpaceError.isDirty) {
-    swiftPart.setMaximumScreenSpaceError(newViewProps.maximumScreenSpaceError.value);
-    newViewProps.maximumScreenSpaceError.isDirty = false;
-  }
-  // maximumSimultaneousTileLoads: number
-  if (newViewProps.maximumSimultaneousTileLoads.isDirty) {
-    swiftPart.setMaximumSimultaneousTileLoads(newViewProps.maximumSimultaneousTileLoads.value);
-    newViewProps.maximumSimultaneousTileLoads.isDirty = false;
-  }
-  // loadingDescendantLimit: number
-  if (newViewProps.loadingDescendantLimit.isDirty) {
-    swiftPart.setLoadingDescendantLimit(newViewProps.loadingDescendantLimit.value);
-    newViewProps.loadingDescendantLimit.isDirty = false;
-  }
-  // msaaSampleCount: number
-  if (newViewProps.msaaSampleCount.isDirty) {
-    swiftPart.setMsaaSampleCount(newViewProps.msaaSampleCount.value);
-    newViewProps.msaaSampleCount.isDirty = false;
-  }
-  // ionImageryAssetId: number
-  if (newViewProps.ionImageryAssetId.isDirty) {
-    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;
-  }
-  // minAltitudeAboveTerrain: optional
-  if (newViewProps.minAltitudeAboveTerrain.isDirty) {
-    swiftPart.setMinAltitudeAboveTerrain(newViewProps.minAltitudeAboveTerrain.value);
-    newViewProps.minAltitudeAboveTerrain.isDirty = false;
-  }
-  // maxYawRateDegSec: optional
-  if (newViewProps.maxYawRateDegSec.isDirty) {
-    swiftPart.setMaxYawRateDegSec(newViewProps.maxYawRateDegSec.value);
-    newViewProps.maxYawRateDegSec.isDirty = false;
-  }
-  // maxPitchRateDegSec: optional
-  if (newViewProps.maxPitchRateDegSec.isDirty) {
-    swiftPart.setMaxPitchRateDegSec(newViewProps.maxPitchRateDegSec.value);
-    newViewProps.maxPitchRateDegSec.isDirty = false;
-  }
-  // maxRollRateDegSec: optional
-  if (newViewProps.maxRollRateDegSec.isDirty) {
-    swiftPart.setMaxRollRateDegSec(newViewProps.maxRollRateDegSec.value);
-    newViewProps.maxRollRateDegSec.isDirty = false;
-  }
-  // maxClimbRateMps: optional
-  if (newViewProps.maxClimbRateMps.isDirty) {
-    swiftPart.setMaxClimbRateMps(newViewProps.maxClimbRateMps.value);
-    newViewProps.maxClimbRateMps.isDirty = false;
-  }
-  // maxGroundSpeedMps: optional
-  if (newViewProps.maxGroundSpeedMps.isDirty) {
-    swiftPart.setMaxGroundSpeedMps(newViewProps.maxGroundSpeedMps.value);
-    newViewProps.maxGroundSpeedMps.isDirty = false;
-  }
-  // onMetrics: optional
-  if (newViewProps.onMetrics.isDirty) {
-    swiftPart.setOnMetrics(newViewProps.onMetrics.value);
-    newViewProps.onMetrics.isDirty = false;
-  }
-  // onActualCamera: optional
-  if (newViewProps.onActualCamera.isDirty) {
-    swiftPart.setOnActualCamera(newViewProps.onActualCamera.value);
-    newViewProps.onActualCamera.isDirty = false;
-  }
-
-  swiftPart.afterUpdate();
+    // ionAccessToken: string
+    if (oldViewProps == nullptr
+          ? newViewProps.ionAccessToken.isProvided()
+          : !newViewProps.ionAccessToken.hasSameValue(oldViewProps->ionAccessToken)) {
+      swiftPart.setIonAccessToken(newViewProps.ionAccessToken.get());
+    }
+    // ionAssetId: number
+    if (oldViewProps == nullptr
+          ? newViewProps.ionAssetId.isProvided()
+          : !newViewProps.ionAssetId.hasSameValue(oldViewProps->ionAssetId)) {
+      swiftPart.setIonAssetId(newViewProps.ionAssetId.get());
+    }
+    // initialCamera: struct
+    if (oldViewProps == nullptr
+          ? newViewProps.initialCamera.isProvided()
+          : !newViewProps.initialCamera.hasSameValue(oldViewProps->initialCamera)) {
+      swiftPart.setInitialCamera(newViewProps.initialCamera.get());
+    }
+    // pauseRendering: boolean
+    if (oldViewProps == nullptr
+          ? newViewProps.pauseRendering.isProvided()
+          : !newViewProps.pauseRendering.hasSameValue(oldViewProps->pauseRendering)) {
+      swiftPart.setPauseRendering(newViewProps.pauseRendering.get());
+    }
+    // maximumScreenSpaceError: number
+    if (oldViewProps == nullptr
+          ? newViewProps.maximumScreenSpaceError.isProvided()
+          : !newViewProps.maximumScreenSpaceError.hasSameValue(oldViewProps->maximumScreenSpaceError)) {
+      swiftPart.setMaximumScreenSpaceError(newViewProps.maximumScreenSpaceError.get());
+    }
+    // maximumSimultaneousTileLoads: number
+    if (oldViewProps == nullptr
+          ? newViewProps.maximumSimultaneousTileLoads.isProvided()
+          : !newViewProps.maximumSimultaneousTileLoads.hasSameValue(oldViewProps->maximumSimultaneousTileLoads)) {
+      swiftPart.setMaximumSimultaneousTileLoads(newViewProps.maximumSimultaneousTileLoads.get());
+    }
+    // loadingDescendantLimit: number
+    if (oldViewProps == nullptr
+          ? newViewProps.loadingDescendantLimit.isProvided()
+          : !newViewProps.loadingDescendantLimit.hasSameValue(oldViewProps->loadingDescendantLimit)) {
+      swiftPart.setLoadingDescendantLimit(newViewProps.loadingDescendantLimit.get());
+    }
+    // msaaSampleCount: number
+    if (oldViewProps == nullptr
+          ? newViewProps.msaaSampleCount.isProvided()
+          : !newViewProps.msaaSampleCount.hasSameValue(oldViewProps->msaaSampleCount)) {
+      swiftPart.setMsaaSampleCount(newViewProps.msaaSampleCount.get());
+    }
+    // ionImageryAssetId: number
+    if (oldViewProps == nullptr
+          ? newViewProps.ionImageryAssetId.isProvided()
+          : !newViewProps.ionImageryAssetId.hasSameValue(oldViewProps->ionImageryAssetId)) {
+      swiftPart.setIonImageryAssetId(newViewProps.ionImageryAssetId.get());
+    }
+    // altitudeDatum: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.altitudeDatum.isProvided()
+          : !newViewProps.altitudeDatum.hasSameValue(oldViewProps->altitudeDatum)) {
+      swiftPart.setAltitudeDatum(newViewProps.altitudeDatum.get());
+    }
+    // maximumCachedMiB: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.maximumCachedMiB.isProvided()
+          : !newViewProps.maximumCachedMiB.hasSameValue(oldViewProps->maximumCachedMiB)) {
+      swiftPart.setMaximumCachedMiB(newViewProps.maximumCachedMiB.get());
+    }
+    // preloadAncestors: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.preloadAncestors.isProvided()
+          : !newViewProps.preloadAncestors.hasSameValue(oldViewProps->preloadAncestors)) {
+      swiftPart.setPreloadAncestors(newViewProps.preloadAncestors.get());
+    }
+    // preloadSiblings: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.preloadSiblings.isProvided()
+          : !newViewProps.preloadSiblings.hasSameValue(oldViewProps->preloadSiblings)) {
+      swiftPart.setPreloadSiblings(newViewProps.preloadSiblings.get());
+    }
+    // forbidHoles: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.forbidHoles.isProvided()
+          : !newViewProps.forbidHoles.hasSameValue(oldViewProps->forbidHoles)) {
+      swiftPart.setForbidHoles(newViewProps.forbidHoles.get());
+    }
+    // enableWaterMask: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.enableWaterMask.isProvided()
+          : !newViewProps.enableWaterMask.hasSameValue(oldViewProps->enableWaterMask)) {
+      swiftPart.setEnableWaterMask(newViewProps.enableWaterMask.get());
+    }
+    // enableFogCulling: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.enableFogCulling.isProvided()
+          : !newViewProps.enableFogCulling.hasSameValue(oldViewProps->enableFogCulling)) {
+      swiftPart.setEnableFogCulling(newViewProps.enableFogCulling.get());
+    }
+    // enforceCulledScreenSpaceError: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.enforceCulledScreenSpaceError.isProvided()
+          : !newViewProps.enforceCulledScreenSpaceError.hasSameValue(oldViewProps->enforceCulledScreenSpaceError)) {
+      swiftPart.setEnforceCulledScreenSpaceError(newViewProps.enforceCulledScreenSpaceError.get());
+    }
+    // culledScreenSpaceError: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.culledScreenSpaceError.isProvided()
+          : !newViewProps.culledScreenSpaceError.hasSameValue(oldViewProps->culledScreenSpaceError)) {
+      swiftPart.setCulledScreenSpaceError(newViewProps.culledScreenSpaceError.get());
+    }
+    // enableLodTransitionPeriod: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.enableLodTransitionPeriod.isProvided()
+          : !newViewProps.enableLodTransitionPeriod.hasSameValue(oldViewProps->enableLodTransitionPeriod)) {
+      swiftPart.setEnableLodTransitionPeriod(newViewProps.enableLodTransitionPeriod.get());
+    }
+    // lodTransitionLength: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.lodTransitionLength.isProvided()
+          : !newViewProps.lodTransitionLength.hasSameValue(oldViewProps->lodTransitionLength)) {
+      swiftPart.setLodTransitionLength(newViewProps.lodTransitionLength.get());
+    }
+    // sqliteCacheMaxRows: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.sqliteCacheMaxRows.isProvided()
+          : !newViewProps.sqliteCacheMaxRows.hasSameValue(oldViewProps->sqliteCacheMaxRows)) {
+      swiftPart.setSqliteCacheMaxRows(newViewProps.sqliteCacheMaxRows.get());
+    }
+    // taskProcessorThreads: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.taskProcessorThreads.isProvided()
+          : !newViewProps.taskProcessorThreads.hasSameValue(oldViewProps->taskProcessorThreads)) {
+      swiftPart.setTaskProcessorThreads(newViewProps.taskProcessorThreads.get());
+    }
+    // minAltitudeAboveTerrain: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.minAltitudeAboveTerrain.isProvided()
+          : !newViewProps.minAltitudeAboveTerrain.hasSameValue(oldViewProps->minAltitudeAboveTerrain)) {
+      swiftPart.setMinAltitudeAboveTerrain(newViewProps.minAltitudeAboveTerrain.get());
+    }
+    // maxYawRateDegSec: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.maxYawRateDegSec.isProvided()
+          : !newViewProps.maxYawRateDegSec.hasSameValue(oldViewProps->maxYawRateDegSec)) {
+      swiftPart.setMaxYawRateDegSec(newViewProps.maxYawRateDegSec.get());
+    }
+    // maxPitchRateDegSec: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.maxPitchRateDegSec.isProvided()
+          : !newViewProps.maxPitchRateDegSec.hasSameValue(oldViewProps->maxPitchRateDegSec)) {
+      swiftPart.setMaxPitchRateDegSec(newViewProps.maxPitchRateDegSec.get());
+    }
+    // maxRollRateDegSec: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.maxRollRateDegSec.isProvided()
+          : !newViewProps.maxRollRateDegSec.hasSameValue(oldViewProps->maxRollRateDegSec)) {
+      swiftPart.setMaxRollRateDegSec(newViewProps.maxRollRateDegSec.get());
+    }
+    // maxClimbRateMps: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.maxClimbRateMps.isProvided()
+          : !newViewProps.maxClimbRateMps.hasSameValue(oldViewProps->maxClimbRateMps)) {
+      swiftPart.setMaxClimbRateMps(newViewProps.maxClimbRateMps.get());
+    }
+    // maxGroundSpeedMps: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.maxGroundSpeedMps.isProvided()
+          : !newViewProps.maxGroundSpeedMps.hasSameValue(oldViewProps->maxGroundSpeedMps)) {
+      swiftPart.setMaxGroundSpeedMps(newViewProps.maxGroundSpeedMps.get());
+    }
+    // onMetrics: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.onMetrics.isProvided()
+          : !newViewProps.onMetrics.hasSameValue(oldViewProps->onMetrics)) {
+      swiftPart.setOnMetrics(newViewProps.onMetrics.get());
+    }
+    // onActualCamera: optional
+    if (oldViewProps == nullptr
+          ? newViewProps.onActualCamera.isProvided()
+          : !newViewProps.onActualCamera.hasSameValue(oldViewProps->onActualCamera)) {
+      swiftPart.setOnActualCamera(newViewProps.onActualCamera.get());
+    }
 
-  // 3. Update hybridRef if it changed
-  if (newViewProps.hybridRef.isDirty) {
-    // hybridRef changed - call it with new this
-    const auto& maybeFunc = newViewProps.hybridRef.value;
-    if (maybeFunc.has_value()) {
-      maybeFunc.value()(_hybridView);
+    // Update hybridRef if it changed
+    if (oldViewProps == nullptr
+          ? newViewProps.hybridRef.isProvided()
+          : !newViewProps.hybridRef.hasSameValue(oldViewProps->hybridRef)) {
+      // hybridRef changed - call it with new this
+      const auto& maybeFunc = newViewProps.hybridRef.get();
+      if (maybeFunc.has_value()) {
+        maybeFunc.value()(_hybridView);
+      }
     }
-    newViewProps.hybridRef.isDirty = false;
+
+    swiftPart.afterUpdate();
   }
 
-  // 4. Continue in base class
+  // 3. Continue in base class
   [super updateProps:props oldProps:oldProps];
 }
 
@@ -246,6 +302,7 @@ using namespace margelo::nitro::reactnativecesium::views;
 }
 
 - (void)prepareForRecycle {
+  [self notifyOnDropView];
   [super prepareForRecycle];
   ReactNativeCesium::HybridCesiumViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
   swiftPart.maybePrepareForRecycle();
@@ -253,8 +310,7 @@ using namespace margelo::nitro::reactnativecesium::views;
 
 #ifdef ENABLE_RCT_COMPONENT_VIEW_INVALIDATE
 - (void)invalidate {
-  ReactNativeCesium::HybridCesiumViewSpec_cxx& swiftPart = _hybridView->getSwiftPart();
-  swiftPart.onDropView();
+  [self notifyOnDropView];
   [super invalidate];
 }
 #endif

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

@@ -19,6 +19,7 @@ public protocol HybridCesiumViewSpec_protocol: HybridObject, HybridView {
   var loadingDescendantLimit: Double { get set }
   var msaaSampleCount: Double { get set }
   var ionImageryAssetId: Double { get set }
+  var altitudeDatum: String? { get set }
   var maximumCachedMiB: Double? { get set }
   var preloadAncestors: Bool? { get set }
   var preloadSiblings: Bool? { get set }

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

@@ -220,6 +220,30 @@ open class HybridCesiumViewSpec_cxx {
     }
   }
   
+  public final var altitudeDatum: bridge.std__optional_std__string_ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = self.__implementation.altitudeDatum {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.altitudeDatum = { () -> String? in
+        if bridge.has_value_std__optional_std__string_(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__string_(newValue)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
+  
   public final var maximumCachedMiB: bridge.std__optional_double_ {
     @inline(__always)
     get {

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

@@ -32,6 +32,8 @@ namespace margelo::nitro::reactnativecesium {
       prototype.registerHybridSetter("msaaSampleCount", &HybridCesiumViewSpec::setMsaaSampleCount);
       prototype.registerHybridGetter("ionImageryAssetId", &HybridCesiumViewSpec::getIonImageryAssetId);
       prototype.registerHybridSetter("ionImageryAssetId", &HybridCesiumViewSpec::setIonImageryAssetId);
+      prototype.registerHybridGetter("altitudeDatum", &HybridCesiumViewSpec::getAltitudeDatum);
+      prototype.registerHybridSetter("altitudeDatum", &HybridCesiumViewSpec::setAltitudeDatum);
       prototype.registerHybridGetter("maximumCachedMiB", &HybridCesiumViewSpec::getMaximumCachedMiB);
       prototype.registerHybridSetter("maximumCachedMiB", &HybridCesiumViewSpec::setMaximumCachedMiB);
       prototype.registerHybridGetter("preloadAncestors", &HybridCesiumViewSpec::getPreloadAncestors);

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

@@ -73,6 +73,8 @@ namespace margelo::nitro::reactnativecesium {
       virtual void setMsaaSampleCount(double msaaSampleCount) = 0;
       virtual double getIonImageryAssetId() = 0;
       virtual void setIonImageryAssetId(double ionImageryAssetId) = 0;
+      virtual std::optional<std::string> getAltitudeDatum() = 0;
+      virtual void setAltitudeDatum(const std::optional<std::string>& altitudeDatum) = 0;
       virtual std::optional<double> getMaximumCachedMiB() = 0;
       virtual void setMaximumCachedMiB(std::optional<double> maximumCachedMiB) = 0;
       virtual std::optional<bool> getPreloadAncestors() = 0;