editor support for dyn types

Author: mrDIMAS

editor/src/plugins/inspector/editors/dyntype.rs

@@ -18,6 +18,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
+use crate::plugins::inspector::editors::dyntype::DynTypePropertyEditorDefinition;
 use crate::plugins::inspector::editors::shader::field::ShaderSourceCodeEditorDefinition;
 use crate::{
     fyrox::{
@@ -185,6 +186,7 @@ use crate::{
 use fyrox::resource::texture::TextureKind;
 
 pub mod animation;
+pub mod dyntype;
 pub mod font;
 pub mod handle;
 pub mod resource;
@@ -632,6 +634,8 @@ pub fn make_property_editors_container(
 
     container.insert(EnumPropertyEditorDefinition::<TextureKind>::new());
 
+    container.insert(DynTypePropertyEditorDefinition {});
+
     reg_node_handle_editors!(
         container,
         sender,

editor/src/plugins/inspector/editors/mod.rs

@@ -56,6 +56,7 @@ use crate::{
     utils::window_content,
     Editor, Message, WidgetMessage, WrapMode,
 };
+use fyrox::core::dyntype::DynTypeConstructorContainer;
 use fyrox::gui::style::resource::StyleResource;
 use fyrox::{
     core::type_traits::prelude::*,
@@ -81,6 +82,7 @@ pub struct AnimationDefinition {
 pub struct EditorEnvironment {
     pub resource_manager: ResourceManager,
     pub serialization_context: Arc<SerializationContext>,
+    pub dyn_type_constructors: Arc<DynTypeConstructorContainer>,
     /// List of animations definitions (name + handle). It is filled only if current selection
     /// is `AnimationBlendingStateMachine`. The list is filled using ABSM's animation player.
     pub available_animations: Vec<AnimationDefinition>,
@@ -325,6 +327,7 @@ impl InspectorPlugin {
         ui: &mut UserInterface,
         resource_manager: ResourceManager,
         serialization_context: Arc<SerializationContext>,
+        dyn_type_constructors: Arc<DynTypeConstructorContainer>,
         available_animations: &[AnimationDefinition],
         sender: &MessageSender,
         icon_request_sender: Sender<IconRequest>,
@@ -338,6 +341,7 @@ impl InspectorPlugin {
             sender: sender.clone(),
             icon_request_sender,
             style,
+            dyn_type_constructors,
         });
 
         let context = InspectorContext::from_object(InspectorContextArgs {
@@ -406,6 +410,7 @@ impl EditorPlugin for InspectorPlugin {
                             ui,
                             editor.engine.resource_manager.clone(),
                             editor.engine.serialization_context.clone(),
+                            editor.engine.dyn_type_constructors.clone(),
                             &available_animations,
                             &editor.message_sender,
                             editor.asset_browser.preview_sender.clone(),

editor/src/plugins/inspector/mod.rs

@@ -151,6 +151,7 @@ impl SceneSettingsWindow {
         let environment = Arc::new(EditorEnvironment {
             resource_manager: engine.resource_manager.clone(),
             serialization_context: engine.serialization_context.clone(),
+            dyn_type_constructors: engine.dyn_type_constructors.clone(),
             available_animations: Default::default(),
             sender,
             icon_request_sender,

editor/src/scene/settings/mod.rs

@@ -20,7 +20,7 @@
 
 use crate::{reflect::prelude::*, type_traits::prelude::*, visitor::prelude::*, SafeLock};
 use fxhash::FxHashMap;
-use parking_lot::Mutex;
+use parking_lot::{Mutex, MutexGuard};
 use std::{
     any::{type_name, Any, TypeId},
     fmt::{Debug, Display, Formatter},
@@ -87,7 +87,7 @@ where
 
 #[derive(Debug, TypeUuidProvider)]
 #[type_uuid(id = "87d9ef74-09a9-4228-a2d1-df270b50fddb")]
-pub struct DynTypeWrapper(Box<dyn DynType>);
+pub struct DynTypeWrapper(pub Box<dyn DynType>);
 
 impl Clone for DynTypeWrapper {
     fn clone(&self) -> Self {
@@ -197,7 +197,7 @@ impl Reflect for DynTypeWrapper {
 }
 
 #[derive(Default, Reflect, Clone, Debug)]
-pub struct DynTypeContainer(Option<DynTypeWrapper>);
+pub struct DynTypeContainer(pub Option<DynTypeWrapper>);
 
 impl DynTypeContainer {
     pub fn value_ref(&self) -> Option<&dyn DynType> {
@@ -245,24 +245,36 @@ impl Visit for DynTypeContainer {
     }
 }
 
-pub type DynTypeConstructor = Box<dyn Fn() -> Box<dyn DynType>>;
+pub type DynTypeConstructor = Box<dyn Fn() -> Box<dyn DynType> + Send + 'static>;
 
+pub struct DynTypeConstructorDefinition {
+    pub name: String,
+    pub constructor: DynTypeConstructor,
+}
+
+#[derive(Default)]
 pub struct DynTypeConstructorContainer {
-    map: Mutex<FxHashMap<Uuid, DynTypeConstructor>>,
+    map: Mutex<FxHashMap<Uuid, DynTypeConstructorDefinition>>,
 }
 
 impl DynTypeConstructorContainer {
     pub fn try_create(&self, type_uuid: &Uuid) -> Option<Box<dyn DynType>> {
-        self.map.safe_lock().get(type_uuid).map(|c| (*c)())
+        self.map
+            .safe_lock()
+            .get(type_uuid)
+            .map(|c| (*c.constructor)())
     }
 
-    pub fn add<T>(&self) -> &Self
+    pub fn add<T>(&self, name: &str) -> &Self
     where
         T: TypeUuidProvider + Default + DynType,
     {
         let old = self.map.safe_lock().insert(
             <T as TypeUuidProvider>::type_uuid(),
-            Box::new(|| Box::new(T::default())),
+            DynTypeConstructorDefinition {
+                name: name.to_string(),
+                constructor: Box::new(|| Box::new(T::default())),
+            },
         );
 
         assert!(old.is_none());
@@ -273,7 +285,7 @@ impl DynTypeConstructorContainer {
     pub fn add_custom(
         &self,
         type_uuid: Uuid,
-        constructor: DynTypeConstructor,
+        constructor: DynTypeConstructorDefinition,
     ) -> Result<(), String> {
         let mut map = self.map.safe_lock();
         let old = map.insert(type_uuid, constructor);
@@ -282,4 +294,8 @@ impl DynTypeConstructorContainer {
 
         Ok(())
     }
+
+    pub fn inner(&self) -> MutexGuard<FxHashMap<Uuid, DynTypeConstructorDefinition>> {
+        self.map.safe_lock()
+    }
 }

fyrox-core/src/dyntype.rs

@@ -112,6 +112,7 @@ use crate::{
 };
 use fxhash::{FxHashMap, FxHashSet};
 use fyrox_animation::AnimationTracksData;
+use fyrox_core::dyntype::DynTypeConstructorContainer;
 use fyrox_graphics::server::SharedGraphicsServer;
 use fyrox_graphics_gl::server::GlGraphicsServer;
 use fyrox_sound::{
@@ -516,6 +517,10 @@ pub struct Engine {
     /// A container with widget constructors.
     pub widget_constructors: Arc<WidgetConstructorContainer>,
 
+    /// A container with constructors for dynamic types. See [`DynTypeConstructorContainer`] for more
+    /// info.
+    pub dyn_type_constructors: Arc<DynTypeConstructorContainer>,
+
     /// Script processor is used to run script methods in a strict order.
     pub script_processor: ScriptProcessor,
 }
@@ -1546,6 +1551,7 @@ impl Engine {
             plugins: Default::default(),
             serialization_context,
             widget_constructors,
+            dyn_type_constructors: Default::default(),
             script_processor: Default::default(),
             plugins_enabled: false,
             elapsed_time: 0.0,
@@ -2620,6 +2626,7 @@ impl Engine {
     fn register_plugin_internal(
         serialization_context: &Arc<SerializationContext>,
         widget_constructors: &Arc<WidgetConstructorContainer>,
+        dyn_type_constructors: &Arc<DynTypeConstructorContainer>,
         resource_manager: &ResourceManager,
         plugin: &dyn Plugin,
     ) {
@@ -2628,6 +2635,7 @@ impl Engine {
             plugin.register(PluginRegistrationContext {
                 serialization_context,
                 widget_constructors,
+                dyn_type_constructors,
                 resource_manager,
             }),
         );
@@ -2637,6 +2645,7 @@ impl Engine {
         Self::register_plugin_internal(
             &self.serialization_context,
             &self.widget_constructors,
+            &self.dyn_type_constructors,
             &self.resource_manager,
             plugin,
         )
@@ -2862,6 +2871,7 @@ impl Engine {
             Self::register_plugin_internal(
                 &self.serialization_context,
                 &self.widget_constructors,
+                &self.dyn_type_constructors,
                 &self.resource_manager,
                 plugin,
             );

fyrox-impl/src/engine/mod.rs

@@ -44,6 +44,7 @@ use crate::{
     plugin::error::GameResult,
     scene::{Scene, SceneContainer},
 };
+use fyrox_core::dyntype::DynTypeConstructorContainer;
 use std::{
     ops::{Deref, DerefMut},
     path::Path,
@@ -120,6 +121,9 @@ pub struct PluginRegistrationContext<'a> {
     /// A reference to serialization context of the engine. See [`WidgetConstructorContainer`] for more
     /// info.
     pub widget_constructors: &'a Arc<WidgetConstructorContainer>,
+    /// A container with constructors for dynamic types. See [`DynTypeConstructorContainer`] for more
+    /// info.
+    pub dyn_type_constructors: &'a Arc<DynTypeConstructorContainer>,
     /// A reference to the resource manager instance of the engine. Could be used to register resource loaders.
     pub resource_manager: &'a ResourceManager,
 }

fyrox-impl/src/plugin/mod.rs

@@ -29,7 +29,7 @@ use crate::{
     button::Button,
     canvas::Canvas,
     core::{
-        algebra::{UnitQuaternion, Vector2, Vector3, Vector4},
+        algebra::{Matrix2, Matrix3, Matrix4, SMatrix, UnitQuaternion, Vector2, Vector3, Vector4},
         color::Color,
         color_gradient::ColorGradient,
         math::{curve::Curve, Rect, SmoothAngle},
@@ -112,7 +112,6 @@ use crate::{
 };
 use fxhash::FxHashMap;
 use fyrox_animation::machine::Parameter;
-use fyrox_core::algebra::{Matrix2, Matrix3, Matrix4, SMatrix};
 use fyrox_texture::TextureResource;
 use std::{
     any::{Any, TypeId},