Implement land, terrain, environment, and sound managers (#70)

crates/libremetaverse/src/client_core.rs

@@ -119,6 +119,10 @@ struct ClientRuntime {
     network_manager: Mutex<std::sync::Weak<crate::network_manager::NetworkManagerInner>>,
     agent_manager: Mutex<std::sync::Weak<crate::agent_manager::AgentManagerInner>>,
     object_manager: Mutex<Option<Arc<crate::object_manager::ObjectManagerInner>>>,
+    environment_manager: Mutex<Option<Arc<crate::environment_manager::EnvironmentManagerInner>>>,
+    terrain_manager: Mutex<Option<Arc<crate::terrain_manager::TerrainManagerInner>>>,
+    sound_manager: Mutex<Option<Arc<crate::sound_manager::SoundManagerInner>>>,
+    parcel_manager: Mutex<Option<Arc<crate::parcel_manager::ParcelManagerInner>>>,
     appearance_manager: Mutex<Option<Arc<crate::appearance_manager::AppearanceManagerInner>>>,
     avatar_manager: Mutex<Option<Arc<crate::avatar_manager::AvatarManagerInner>>>,
     animesh_manager: Mutex<Option<Arc<crate::animesh_runtime::AnimeshManagerInner>>>,
@@ -154,6 +158,10 @@ impl ClientRuntime {
             network_manager: Mutex::new(std::sync::Weak::new()),
             agent_manager: Mutex::new(std::sync::Weak::new()),
             object_manager: Mutex::new(None),
+            environment_manager: Mutex::new(None),
+            terrain_manager: Mutex::new(None),
+            sound_manager: Mutex::new(None),
+            parcel_manager: Mutex::new(None),
             appearance_manager: Mutex::new(None),
             avatar_manager: Mutex::new(None),
             animesh_manager: Mutex::new(None),
@@ -684,6 +692,159 @@ impl GridClient {
         self.cache_object_manager_inner(&value.inner);
     }
 
+    pub(crate) fn install_environment_manager_inner(
+        &self,
+        candidate: Arc<crate::environment_manager::EnvironmentManagerInner>,
+    ) -> Arc<crate::environment_manager::EnvironmentManagerInner> {
+        let mut cached = self
+            .runtime
+            .environment_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        if let Some(inner) = cached.as_ref() {
+            return Arc::clone(inner);
+        }
+        *cached = Some(Arc::clone(&candidate));
+        candidate
+    }
+
+    pub(crate) fn native_environment(&self) -> Result<crate::EnvironmentManager, crate::Error> {
+        if let Some(inner) = self
+            .runtime
+            .environment_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .clone()
+        {
+            return Ok(crate::EnvironmentManager { inner });
+        }
+        crate::environment_manager::EnvironmentManager::native_new(Arc::new(self.clone()))
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    pub(crate) fn native_set_environment(&self, value: crate::EnvironmentManager) {
+        *self
+            .runtime
+            .environment_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(value.inner);
+    }
+
+    pub(crate) fn cached_terrain_manager_inner(
+        &self,
+    ) -> Option<Arc<crate::terrain_manager::TerrainManagerInner>> {
+        self.runtime
+            .terrain_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .clone()
+    }
+    pub(crate) fn install_terrain_manager_inner(
+        &self,
+        candidate: Arc<crate::terrain_manager::TerrainManagerInner>,
+    ) -> Arc<crate::terrain_manager::TerrainManagerInner> {
+        let mut cached = self
+            .runtime
+            .terrain_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        if let Some(inner) = cached.as_ref() {
+            return Arc::clone(inner);
+        }
+        *cached = Some(Arc::clone(&candidate));
+        candidate
+    }
+    pub(crate) fn native_terrain(&self) -> Result<crate::TerrainManager, crate::Error> {
+        if let Some(inner) = self.cached_terrain_manager_inner() {
+            Ok(crate::TerrainManager { inner })
+        } else {
+            crate::terrain_manager::TerrainManager::native_new(Arc::new(self.clone()))
+        }
+    }
+    pub(crate) fn native_set_terrain(&self, value: crate::TerrainManager) {
+        *self
+            .runtime
+            .terrain_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(value.inner);
+    }
+    pub(crate) fn cached_sound_manager_inner(
+        &self,
+    ) -> Option<Arc<crate::sound_manager::SoundManagerInner>> {
+        self.runtime
+            .sound_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .clone()
+    }
+    pub(crate) fn install_sound_manager_inner(
+        &self,
+        candidate: Arc<crate::sound_manager::SoundManagerInner>,
+    ) -> Arc<crate::sound_manager::SoundManagerInner> {
+        let mut cached = self
+            .runtime
+            .sound_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        if let Some(inner) = cached.as_ref() {
+            return Arc::clone(inner);
+        }
+        *cached = Some(Arc::clone(&candidate));
+        candidate
+    }
+    pub(crate) fn native_sound(&self) -> Result<crate::SoundManager, crate::Error> {
+        if let Some(inner) = self.cached_sound_manager_inner() {
+            Ok(crate::SoundManager { inner })
+        } else {
+            crate::sound_manager::SoundManager::native_new(Arc::new(self.clone()))
+        }
+    }
+    pub(crate) fn native_set_sound(&self, value: crate::SoundManager) {
+        *self
+            .runtime
+            .sound_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(value.inner);
+    }
+    pub(crate) fn cached_parcel_manager_inner(
+        &self,
+    ) -> Option<Arc<crate::parcel_manager::ParcelManagerInner>> {
+        self.runtime
+            .parcel_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+            .clone()
+    }
+    pub(crate) fn install_parcel_manager_inner(
+        &self,
+        candidate: Arc<crate::parcel_manager::ParcelManagerInner>,
+    ) -> Arc<crate::parcel_manager::ParcelManagerInner> {
+        let mut cached = self
+            .runtime
+            .parcel_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner);
+        if let Some(inner) = cached.as_ref() {
+            return Arc::clone(inner);
+        }
+        *cached = Some(Arc::clone(&candidate));
+        candidate
+    }
+    pub(crate) fn native_parcels(&self) -> Result<crate::ParcelManager, crate::Error> {
+        if let Some(inner) = self.cached_parcel_manager_inner() {
+            Ok(crate::ParcelManager { inner })
+        } else {
+            crate::parcel_manager::ParcelManager::native_new(Arc::new(self.clone()))
+        }
+    }
+    pub(crate) fn native_set_parcels(&self, value: crate::ParcelManager) {
+        *self
+            .runtime
+            .parcel_manager
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(value.inner);
+    }
+
     pub(crate) fn native_set_caps_rate_limiter(
         &mut self,
         value: crate::caps_http::CapsRateLimiter,