diff --git a/Source/Editor/CustomEditors/CustomEditorsUtil.cs b/Source/Editor/CustomEditors/CustomEditorsUtil.cs index 476219960..2323333e2 100644 --- a/Source/Editor/CustomEditors/CustomEditorsUtil.cs +++ b/Source/Editor/CustomEditors/CustomEditorsUtil.cs @@ -58,11 +58,13 @@ namespace FlaxEditor.CustomEditors if (targetType.Type == typeof(object) && values.Count > 0 && values[0] != null && !values.HasDifferentTypes) return CreateEditor(TypeUtils.GetObjectType(values[0]), canUseRefPicker); - // Special case if property is interface but the value is implemented as Scripting Object that should use reference picker - if (targetType.IsInterface && canUseRefPicker && values.Count > 0 && values[0] is FlaxEngine.Object) - return new DummyEditor(); - // Use editor for the property type + if (canUseRefPicker && + targetType.IsInterface && + values.GetAttributes().Any(x => x is ScriptingObjectInterfaceReferenceAttribute || x is SoftObjectInterfaceReferenceAttribute)) + { + return new FlaxObjectRefEditor(); + } return CreateEditor(targetType, canUseRefPicker); } diff --git a/Source/Editor/CustomEditors/Editors/DictionaryEditor.cs b/Source/Editor/CustomEditors/Editors/DictionaryEditor.cs index 1fe849f09..7dfce6055 100644 --- a/Source/Editor/CustomEditors/Editors/DictionaryEditor.cs +++ b/Source/Editor/CustomEditors/Editors/DictionaryEditor.cs @@ -260,7 +260,7 @@ namespace FlaxEditor.CustomEditors.Editors var overrideEditor = overrideEditorType != null ? (CustomEditor)Activator.CreateInstance(overrideEditorType) : null; var property = panel.AddPropertyItem(new DictionaryItemLabel(this, key)); var itemLayout = useSharedLayout ? (LayoutElementsContainer)property : property.VerticalPanel(); - itemLayout.Object(new DictionaryValueContainer(valuesType, key, Values), overrideEditor); + itemLayout.Object(new DictionaryValueContainer(valuesType, key, Values, attributes), overrideEditor); if (_readOnly && itemLayout.Children.Count > 0) GenericEditor.OnReadOnlyProperty(itemLayout); } diff --git a/Source/Editor/CustomEditors/Editors/FlaxObjectRefEditor.cs b/Source/Editor/CustomEditors/Editors/FlaxObjectRefEditor.cs index a6a02ae1f..7ce707a77 100644 --- a/Source/Editor/CustomEditors/Editors/FlaxObjectRefEditor.cs +++ b/Source/Editor/CustomEditors/Editors/FlaxObjectRefEditor.cs @@ -48,7 +48,7 @@ namespace FlaxEditor.CustomEditors.Editors public IPresenterOwner PresenterContext; /// - /// Gets or sets the allowed objects type (given type and all subclasses). Must be type of any subclass. + /// Gets or sets the allowed objects type (given type and all subclasses). Must be type of any subclass or a scripting interface. /// public ScriptType Type { @@ -57,11 +57,12 @@ namespace FlaxEditor.CustomEditors.Editors { if (_type == value) return; - if (value == ScriptType.Null || (value.Type != typeof(Object) && !value.IsSubclassOf(ScriptType.Object))) + if (value == ScriptType.Null || (!value.IsInterface && value.Type != typeof(Object) && !value.IsSubclassOf(ScriptType.Object))) throw new ArgumentException(string.Format("Invalid type for FlaxObjectRefEditor. Input type: {0}", value != ScriptType.Null ? value.TypeName : "null")); _type = value; - _supportsPickDropDown = new ScriptType(typeof(Actor)).IsAssignableFrom(value) || + _supportsPickDropDown = value.IsInterface || + new ScriptType(typeof(Actor)).IsAssignableFrom(value) || new ScriptType(typeof(Script)).IsAssignableFrom(value); // Deselect value if it's not valid now @@ -149,13 +150,22 @@ namespace FlaxEditor.CustomEditors.Editors protected virtual bool IsValid(Object obj) { var type = TypeUtils.GetObjectType(obj); - return obj == null || _type.IsAssignableFrom(type) && (CheckValid == null || CheckValid(obj, type)); + return obj == null || (!_type.IsInterface || obj is SceneObject) && _type.IsAssignableFrom(type) && (CheckValid == null || CheckValid(obj, type)); } private void ShowDropDownMenu() { Focus(); - if (new ScriptType(typeof(Actor)).IsAssignableFrom(_type)) + if (_type.IsInterface) + { + SceneObjectSearchPopup.Show(this, new Float2(0, Height), IsValid, obj => + { + Value = obj; + RootWindow.Focus(); + Focus(); + }, PresenterContext); + } + else if (new ScriptType(typeof(Actor)).IsAssignableFrom(_type)) { ActorSearchPopup.Show(this, new Float2(0, Height), IsValid, actor => { diff --git a/Source/Editor/CustomEditors/Values/DictionaryValueContainer.cs b/Source/Editor/CustomEditors/Values/DictionaryValueContainer.cs index b143b44b1..435e5a515 100644 --- a/Source/Editor/CustomEditors/Values/DictionaryValueContainer.cs +++ b/Source/Editor/CustomEditors/Values/DictionaryValueContainer.cs @@ -14,6 +14,8 @@ namespace FlaxEditor.CustomEditors [HideInEditor] public class DictionaryValueContainer : ValueContainer { + private readonly object[] _attributes; + /// /// The key in the collection. /// @@ -36,9 +38,12 @@ namespace FlaxEditor.CustomEditors /// Type of the collection elements. /// The key. /// The collection values. - public DictionaryValueContainer(ScriptType elementType, object key, ValueContainer values) + /// The dictionary property attributes to inherit. + public DictionaryValueContainer(ScriptType elementType, object key, ValueContainer values, object[] attributes = null) : this(elementType, key) { + _attributes = attributes; + Capacity = values.Count; for (int i = 0; i < values.Count; i++) { @@ -123,5 +128,11 @@ namespace FlaxEditor.CustomEditors _hasReferenceValue = true; } } + + /// + public override object[] GetAttributes() + { + return _attributes ?? base.GetAttributes(); + } } } diff --git a/Source/Editor/GUI/Popups/SceneObjectSearchPopup.cs b/Source/Editor/GUI/Popups/SceneObjectSearchPopup.cs new file mode 100644 index 000000000..4868dd049 --- /dev/null +++ b/Source/Editor/GUI/Popups/SceneObjectSearchPopup.cs @@ -0,0 +1,146 @@ +// Copyright (c) Wojciech Figat. All rights reserved. + +using System; +using FlaxEditor.Windows; +using FlaxEditor.Windows.Assets; +using FlaxEngine; +using FlaxEngine.GUI; +using FlaxEngine.Utilities; + +namespace FlaxEditor.GUI +{ + /// + /// Popup that shows the list of scene objects to pick. Supports searching and basic type filtering. + /// + /// + public class SceneObjectSearchPopup : ItemsListContextMenu + { + /// + /// The scene object item. + /// + /// + public class SceneObjectItemView : Item + { + private SceneObject _object; + + /// + /// Gets the scene object. + /// + public SceneObject Object => _object; + + /// + /// Initializes a new instance of the class. + /// + /// The object. + public SceneObjectItemView(SceneObject obj) + { + _object = obj; + Category = obj is Actor ? "Actors" : "Scripts"; + if (obj is Script script) + { + var type = TypeUtils.GetObjectType(script); + Name = script.Actor ? $"{type.Name} ({script.Actor.Name})" : type.Name; + } + else if (obj is Actor actor) + { + Name = actor.Name; + } + else + { + Name = obj.ToString(); + } + TooltipText = Utilities.Utils.GetTooltip(obj); + } + + /// + public override void OnDestroy() + { + _object = null; + base.OnDestroy(); + } + } + + /// + /// Validates if the given scene object item can be used to pick it. + /// + /// The scene object. + /// True if is valid. + public delegate bool IsValidDelegate(SceneObject obj); + + private IsValidDelegate _isValid; + private Action _selected; + + private SceneObjectSearchPopup(IsValidDelegate isValid, Action selected, CustomEditors.IPresenterOwner context) + { + _isValid = isValid; + _selected = selected; + + ItemClicked += OnItemClicked; + + if (context is PropertiesWindow || context == null) + { + // TODO: use async thread to search scenes + for (int i = 0; i < Level.ScenesCount; i++) + { + Find(Level.GetScene(i)); + } + } + else if (context is PrefabWindow prefabWindow) + { + Find(prefabWindow.Graph.MainActor); + } + + SortItems(); + } + + private void OnItemClicked(Item item) + { + _selected(((SceneObjectItemView)item).Object); + } + + private void Find(Actor actor) + { + if (!actor) + return; + + if (_isValid(actor)) + AddItem(new SceneObjectItemView(actor)); + + for (int i = 0; i < actor.ScriptsCount; i++) + { + var script = actor.GetScript(i); + if (_isValid(script)) + AddItem(new SceneObjectItemView(script)); + } + + for (int i = 0; i < actor.ChildrenCount; i++) + { + Find(actor.GetChild(i)); + } + } + + /// + /// Shows the popup. + /// + /// The show target. + /// The show target location. + /// Event called to check if a given scene object item is valid to be used. + /// Event called on scene object item pick. + /// The presenter owner context (i.e. PrefabWindow, PropertiesWindow). + /// The dialog. + public static SceneObjectSearchPopup Show(Control showTarget, Float2 showTargetLocation, IsValidDelegate isValid, Action selected, CustomEditors.IPresenterOwner context) + { + var popup = new SceneObjectSearchPopup(isValid, selected, context); + popup.Show(showTarget, showTargetLocation); + return popup; + } + + /// + public override void OnDestroy() + { + _isValid = null; + _selected = null; + base.OnDestroy(); + } + } +} diff --git a/Source/Engine/Scripting/Attributes/Editor/ScriptingObjectInterfaceReferenceAttribute.cs b/Source/Engine/Scripting/Attributes/Editor/ScriptingObjectInterfaceReferenceAttribute.cs new file mode 100644 index 000000000..720497b2c --- /dev/null +++ b/Source/Engine/Scripting/Attributes/Editor/ScriptingObjectInterfaceReferenceAttribute.cs @@ -0,0 +1,14 @@ +// Copyright (c) Wojciech Figat. All rights reserved. + +using System; + +namespace FlaxEngine +{ + /// + /// Marks a generated interface property as a native scripting object interface reference. + /// + [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)] + public sealed class ScriptingObjectInterfaceReferenceAttribute : Attribute + { + } +} diff --git a/Source/Engine/Scripting/Attributes/Editor/SoftObjectInterfaceReferenceAttribute.cs b/Source/Engine/Scripting/Attributes/Editor/SoftObjectInterfaceReferenceAttribute.cs new file mode 100644 index 000000000..ec106412f --- /dev/null +++ b/Source/Engine/Scripting/Attributes/Editor/SoftObjectInterfaceReferenceAttribute.cs @@ -0,0 +1,14 @@ +// Copyright (c) Wojciech Figat. All rights reserved. + +using System; + +namespace FlaxEngine +{ + /// + /// Marks a generated interface property as a native soft object interface reference. + /// + [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)] + public sealed class SoftObjectInterfaceReferenceAttribute : Attribute + { + } +} diff --git a/Source/Engine/Scripting/Internal/InternalCalls.h b/Source/Engine/Scripting/Internal/InternalCalls.h index 4535952ea..d179fd8fd 100644 --- a/Source/Engine/Scripting/Internal/InternalCalls.h +++ b/Source/Engine/Scripting/Internal/InternalCalls.h @@ -37,7 +37,7 @@ struct FLAXENGINE_API VTableFunctionInjector #if USE_NETCORE #define ADD_INTERNAL_CALL(fullName, method) -#define DEFINE_INTERNAL_CALL(returnType) extern "C" DLLEXPORT returnType +#define DEFINE_INTERNAL_CALL(returnType) extern "C" DLLEXPORT USED returnType #else extern "C" FLAXENGINE_API void mono_add_internal_call(const char* name, const void* method); #define ADD_INTERNAL_CALL(fullName, method) mono_add_internal_call(fullName, (const void*)method) diff --git a/Source/Engine/Scripting/ManagedCLR/MUtils.h b/Source/Engine/Scripting/ManagedCLR/MUtils.h index 5598dbee0..aed0c48c5 100644 --- a/Source/Engine/Scripting/ManagedCLR/MUtils.h +++ b/Source/Engine/Scripting/ManagedCLR/MUtils.h @@ -278,6 +278,10 @@ struct MConverter::Val // Converter for ScriptingObject References. template class ScriptingObjectReference; +template +class ScriptingObjectInterfaceReference; +template +class SoftObjectInterfaceReference; template struct MConverter> @@ -311,6 +315,50 @@ struct MConverter> } }; +template +struct MInterfaceReferenceConverter +{ + MObject* Box(const TReference& data, const MClass* klass) + { + return data.GetManagedInstance(); + } + + void Unbox(TReference& result, MObject* data) + { + result = ScriptingObject::ToInterface(ScriptingObject::ToNative(data)); + } + + void ToManagedArray(MArray* result, const Span& data) + { + if (data.Length() == 0) + return; + MObject** objects = (MObject**)Allocator::Allocate(data.Length() * sizeof(MObject*)); + for (int32 i = 0; i < data.Length(); i++) + objects[i] = data[i].GetManagedInstance(); + MCore::GC::WriteArrayRef(result, Span(objects, data.Length())); + Allocator::Free(objects); + } + + void ToNativeArray(Span& result, const MArray* data) + { + MObject** dataPtr = MCore::Array::GetAddress(data); + for (int32 i = 0; i < result.Length(); i++) + result.Get()[i] = ScriptingObject::ToInterface(ScriptingObject::ToNative(dataPtr[i])); + } +}; + +// Converter for Scripting Interface References. +template +struct MConverter> : MInterfaceReferenceConverter, T> +{ +}; + +// Converter for Soft Object Interface References. +template +struct MConverter> : MInterfaceReferenceConverter, T> +{ +}; + // Converter for Asset References. template class AssetReference; diff --git a/Source/Engine/Scripting/ScriptingObject.cpp b/Source/Engine/Scripting/ScriptingObject.cpp index dee97a849..dd530c50f 100644 --- a/Source/Engine/Scripting/ScriptingObject.cpp +++ b/Source/Engine/Scripting/ScriptingObject.cpp @@ -717,6 +717,12 @@ DEFINE_INTERNAL_CALL(MString*) ObjectInternal_GetTypeName(ScriptingObject* obj) return MUtils::ToString(obj->GetType().Fullname); } +FORCE_INLINE bool ObjectInternal_MatchesType(ScriptingObject* obj, MClass* klass) +{ + return !klass || + (klass->IsInterface() ? obj->GetClass()->HasInterface(klass) : obj->Is(klass)); +} + DEFINE_INTERNAL_CALL(MObject*) ObjectInternal_FindObject(Guid* id, MTypeObject* type, bool skipLog = false) { if (!id->IsValid()) @@ -732,7 +738,7 @@ DEFINE_INTERNAL_CALL(MObject*) ObjectInternal_FindObject(Guid* id, MTypeObject* } if (obj) { - if (klass && !obj->Is(klass)) + if (!ObjectInternal_MatchesType(obj, klass)) { if (!skipLog) { @@ -762,7 +768,7 @@ DEFINE_INTERNAL_CALL(MObject*) ObjectInternal_FindObject(Guid* id, MTypeObject* DEFINE_INTERNAL_CALL(MObject*) ObjectInternal_TryFindObject(Guid* id, MTypeObject* type) { ScriptingObject* obj = Scripting::TryFindObject(*id); - if (obj && !obj->Is(MUtils::GetClass(type))) + if (obj && !ObjectInternal_MatchesType(obj, MUtils::GetClass(type))) obj = nullptr; return obj ? obj->GetOrCreateManagedInstance() : nullptr; } diff --git a/Source/Engine/Scripting/ScriptingObjectInterfaceReference.h b/Source/Engine/Scripting/ScriptingObjectInterfaceReference.h new file mode 100644 index 000000000..65c479075 --- /dev/null +++ b/Source/Engine/Scripting/ScriptingObjectInterfaceReference.h @@ -0,0 +1,195 @@ +// Copyright (c) Wojciech Figat. All rights reserved. + +#pragma once + +#include "Engine/Scripting/ScriptingObjectInterfaceReferenceUtils.h" + +/// +/// The scene object interface reference. +/// +/// The type of the scripting interface. +template +API_CLASS(InBuild) class ScriptingObjectInterfaceReference : public ScriptingObjectReferenceBase +{ + typedef ScriptingObjectInterfaceReferenceHelper Helper; + +public: + typedef ScriptingObjectInterfaceReference Type; + +public: + /// + /// Initializes a new instance of the class. + /// + ScriptingObjectInterfaceReference() + { + } + + /// + /// Initializes a new instance of the class. + /// + /// The object to link. + ScriptingObjectInterfaceReference(SceneObject* obj) + : ScriptingObjectReferenceBase(Helper::IsValidObject(obj) ? obj : nullptr) + { + } + + /// + /// Initializes a new instance of the class. + /// + /// The interface object to link. + ScriptingObjectInterfaceReference(T* interfaceObj) + : ScriptingObjectReferenceBase(Helper::GetSceneObject(interfaceObj)) + { + } + + /// + /// Initializes a new instance of the class. + /// + /// The other property. + ScriptingObjectInterfaceReference(const ScriptingObjectInterfaceReference& other) + : ScriptingObjectReferenceBase(other._object) + { + } + + ScriptingObjectInterfaceReference(ScriptingObjectInterfaceReference&& other) noexcept + : ScriptingObjectReferenceBase(MoveTemp(other)) + { + } + + /// + /// Finalizes an instance of the class. + /// + ~ScriptingObjectInterfaceReference() + { + } + +public: + FORCE_INLINE bool operator==(SceneObject* other) const + { + return _object == other; + } + + FORCE_INLINE bool operator!=(SceneObject* other) const + { + return _object != other; + } + + FORCE_INLINE bool operator==(T* other) const + { + return Get() == other; + } + + FORCE_INLINE bool operator!=(T* other) const + { + return Get() != other; + } + + FORCE_INLINE bool operator==(const ScriptingObjectInterfaceReference& other) const + { + return _object == other._object; + } + + FORCE_INLINE bool operator!=(const ScriptingObjectInterfaceReference& other) const + { + return _object != other._object; + } + + FORCE_INLINE ScriptingObjectInterfaceReference& operator=(SceneObject* other) + { + OnSet(Helper::IsValidObject(other) ? other : nullptr); + return *this; + } + + FORCE_INLINE ScriptingObjectInterfaceReference& operator=(T* other) + { + OnSet(Helper::GetSceneObject(other)); + return *this; + } + + ScriptingObjectInterfaceReference& operator=(const ScriptingObjectInterfaceReference& other) + { + OnSet(other._object); + return *this; + } + + ScriptingObjectInterfaceReference& operator=(ScriptingObjectInterfaceReference&& other) noexcept + { + ScriptingObjectReferenceBase::operator=(MoveTemp(other)); + return *this; + } + + FORCE_INLINE ScriptingObjectInterfaceReference& operator=(const Guid& id) + { + OnSet(Helper::FindSceneObject(id)); + return *this; + } + + /// + /// Implicit conversion to the interface. + /// + FORCE_INLINE operator T*() const + { + return Get(); + } + + /// + /// Implicit conversion to boolean value. + /// + FORCE_INLINE operator bool() const + { + return _object != nullptr; + } + + /// + /// Interface accessor. + /// + FORCE_INLINE T* operator->() const + { + return Get(); + } + + /// + /// Gets the interface pointer. + /// + FORCE_INLINE T* Get() const + { + return ScriptingObject::ToInterface(_object); + } + + /// + /// Gets the referenced object. + /// + FORCE_INLINE SceneObject* GetObject() const + { + return static_cast(_object); + } + + /// + /// Copies the object ID into the raw storage. + /// + FORCE_INLINE void CopyID(uint32 id[4]) const + { + memset(id, 0, sizeof(uint32) * 4); + if (_object) + { + const Guid value = GetID(); + memcpy(id, &value, sizeof(uint32) * 4); + } + } + + /// + /// Gets the object as a given type (static cast). + /// + template + FORCE_INLINE U* As() const + { + return static_cast(_object); + } + +}; + +template +uint32 GetHash(const ScriptingObjectInterfaceReference& key) +{ + return GetHash(key.GetID()); +} diff --git a/Source/Engine/Scripting/ScriptingObjectInterfaceReferenceUtils.h b/Source/Engine/Scripting/ScriptingObjectInterfaceReferenceUtils.h new file mode 100644 index 000000000..d18df3d80 --- /dev/null +++ b/Source/Engine/Scripting/ScriptingObjectInterfaceReferenceUtils.h @@ -0,0 +1,30 @@ +// Copyright (c) Wojciech Figat. All rights reserved. + +#pragma once + +#include "Engine/Scripting/ScriptingObjectReference.h" +#include "Engine/Level/SceneObject.h" + +/// +/// Utility methods for scene object interface references. +/// +/// The type of the scripting interface. +template +struct ScriptingObjectInterfaceReferenceHelper +{ + FORCE_INLINE static bool IsValidObject(const SceneObject* obj) + { + return !obj || obj->GetType().GetInterface(T::TypeInitializer) != nullptr; + } + + FORCE_INLINE static SceneObject* GetSceneObject(T* interfaceObj) + { + return ScriptingObject::Cast(ScriptingObject::FromInterface(interfaceObj)); + } + + FORCE_INLINE static SceneObject* FindSceneObject(const Guid& id) + { + SceneObject* obj = static_cast(FindObject(id, SceneObject::GetStaticClass())); + return IsValidObject(obj) ? obj : nullptr; + } +}; diff --git a/Source/Engine/Scripting/SoftObjectInterfaceReference.h b/Source/Engine/Scripting/SoftObjectInterfaceReference.h new file mode 100644 index 000000000..0814f4927 --- /dev/null +++ b/Source/Engine/Scripting/SoftObjectInterfaceReference.h @@ -0,0 +1,258 @@ +// Copyright (c) Wojciech Figat. All rights reserved. + +#pragma once + +#include "Engine/Scripting/SoftObjectReference.h" +#include "Engine/Scripting/ScriptingObjectInterfaceReferenceUtils.h" + +/// +/// The scene object soft interface reference. Objects gets referenced on use (ID reference is resolving it). +/// +/// The type of the scripting interface. +template +API_CLASS(InBuild) class SoftObjectInterfaceReference : public SoftObjectReferenceBase +{ + typedef ScriptingObjectInterfaceReferenceHelper Helper; + +public: + typedef SoftObjectInterfaceReference Type; + +public: + /// + /// Initializes a new instance of the class. + /// + SoftObjectInterfaceReference() + { + } + + /// + /// Initializes a new instance of the class. + /// + /// The object to link. + SoftObjectInterfaceReference(SceneObject* obj) + { + OnSet(Helper::IsValidObject(obj) ? obj : nullptr); + } + + /// + /// Initializes a new instance of the class. + /// + /// The interface object to link. + SoftObjectInterfaceReference(T* interfaceObj) + { + OnSet(Helper::GetSceneObject(interfaceObj)); + } + + /// + /// Initializes a new instance of the class. + /// + /// The other property. + SoftObjectInterfaceReference(const SoftObjectInterfaceReference& other) + { + OnSet(other.GetID()); + } + + /// + /// Initializes a new instance of the class. + /// + /// The other property. + SoftObjectInterfaceReference(SoftObjectInterfaceReference&& other) + { + OnSet(other.GetID()); + other.OnSet(nullptr); + } + + /// + /// Finalizes an instance of the class. + /// + ~SoftObjectInterfaceReference() + { + } + +public: + FORCE_INLINE bool operator==(SceneObject* other) + { + return GetObject() == other; + } + + FORCE_INLINE bool operator!=(SceneObject* other) + { + return GetObject() != other; + } + + FORCE_INLINE bool operator==(T* other) + { + return Get() == other; + } + + FORCE_INLINE bool operator!=(T* other) + { + return Get() != other; + } + + FORCE_INLINE bool operator==(const SoftObjectInterfaceReference& other) + { + return GetID() == other.GetID(); + } + + FORCE_INLINE bool operator!=(const SoftObjectInterfaceReference& other) + { + return GetID() != other.GetID(); + } + + SoftObjectInterfaceReference& operator=(const SoftObjectInterfaceReference& other) + { + if (this != &other) + OnSet(other.GetID()); + return *this; + } + + SoftObjectInterfaceReference& operator=(SoftObjectInterfaceReference&& other) + { + if (this != &other) + { + OnSet(other.GetID()); + other.OnSet(nullptr); + } + return *this; + } + + FORCE_INLINE SoftObjectInterfaceReference& operator=(SceneObject* other) + { + OnSet(Helper::IsValidObject(other) ? other : nullptr); + return *this; + } + + FORCE_INLINE SoftObjectInterfaceReference& operator=(T* other) + { + OnSet(Helper::GetSceneObject(other)); + return *this; + } + + FORCE_INLINE SoftObjectInterfaceReference& operator=(const Guid& id) + { + OnSet(id); + return *this; + } + + /// + /// Implicit conversion to the interface. + /// + FORCE_INLINE operator T*() const + { + return Get(); + } + + /// + /// Implicit conversion to boolean value. + /// + FORCE_INLINE operator bool() const + { + return Get() != nullptr; + } + + /// + /// Interface accessor. + /// + FORCE_INLINE T* operator->() const + { + return Get(); + } + + /// + /// Gets the object as a given type (static cast). + /// + template + FORCE_INLINE U* As() const + { + return static_cast(GetObject()); + } + +public: + /// + /// Gets the interface pointer. + /// + FORCE_INLINE T* Get() const + { + return ScriptingObject::ToInterface(GetObject()); + } + + /// + /// Gets the referenced object. + /// + SceneObject* GetObject() const + { + if (!_object) + const_cast(this)->OnResolve(SceneObject::GetStaticClass()); + return Helper::IsValidObject(static_cast(_object)) ? static_cast(_object) : nullptr; + } + + /// + /// Gets managed instance object (or null if no object linked). + /// + MObject* GetManagedInstance() const + { + auto object = GetObject(); + return object ? object->GetOrCreateManagedInstance() : nullptr; + } + + /// + /// Determines whether object is assigned and managed instance of the object is alive. + /// + bool HasManagedInstance() const + { + auto object = GetObject(); + return object && object->HasManagedInstance(); + } + + /// + /// Gets the managed instance object or creates it if missing or null if not assigned. + /// + MObject* GetOrCreateManagedInstance() const + { + auto object = GetObject(); + return object ? object->GetOrCreateManagedInstance() : nullptr; + } + + /// + /// Copies the object ID into the raw storage. + /// + FORCE_INLINE void CopyID(uint32 id[4]) const + { + const Guid value = GetID(); + memcpy(id, &value, sizeof(uint32) * 4); + } + + /// + /// Sets the object. + /// + /// The object ID. Uses Scripting to find the registered object of the given ID. + FORCE_INLINE void Set(const Guid& id) + { + OnSet(id); + } + + /// + /// Sets the object. + /// + /// The object. + FORCE_INLINE void Set(SceneObject* object) + { + OnSet(Helper::IsValidObject(object) ? object : nullptr); + } + + /// + /// Sets the object. + /// + /// The interface object. + FORCE_INLINE void Set(T* interfaceObj) + { + OnSet(Helper::GetSceneObject(interfaceObj)); + } +}; + +template +uint32 GetHash(const SoftObjectInterfaceReference& key) +{ + return GetHash(key.GetID()); +} diff --git a/Source/Engine/Serialization/JsonCustomSerializers/ExtendedDefaultContractResolver.cs b/Source/Engine/Serialization/JsonCustomSerializers/ExtendedDefaultContractResolver.cs index 4f2690863..84b4729fd 100644 --- a/Source/Engine/Serialization/JsonCustomSerializers/ExtendedDefaultContractResolver.cs +++ b/Source/Engine/Serialization/JsonCustomSerializers/ExtendedDefaultContractResolver.cs @@ -13,6 +13,7 @@ namespace FlaxEngine.Json.JsonCustomSerializers internal class ExtendedDefaultContractResolver : DefaultContractResolver { private readonly Type _flaxType = typeof(Object); + private static readonly JsonConverter InterfaceObjectReferenceConverterInstance = new InterfaceObjectReferenceConverter(); private readonly Type[] AttributesIgnoreList = { @@ -34,6 +35,88 @@ namespace FlaxEngine.Json.JsonCustomSerializers _attributesIgnoreList = isManagedOnly ? AttributesIgnoreListManaged : AttributesIgnoreList; } + private static bool HasObjectInterfaceReferenceAttribute(IEnumerable attributes) + { + return attributes.Any(x => x is ScriptingObjectInterfaceReferenceAttribute || x is SoftObjectInterfaceReferenceAttribute); + } + + private static Type GetCollectionItemType(Type type) + { + if (type.IsArray) + return type.GetElementType(); + if (!type.IsGenericType || type == typeof(string)) + return null; + + var types = type.GetInterfaces().Concat(new[] { type }); + var dictionaryType = types.FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IDictionary<,>)); + if (dictionaryType != null) + return dictionaryType.GetGenericArguments()[1]; + var enumerableType = types.FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IEnumerable<>)); + return enumerableType?.GetGenericArguments()[0]; + } + + private static void SetupInterfaceObjectReferenceItems(JsonContainerContract contract, Type itemType) + { + if (itemType?.IsInterface == true) + { + contract.ItemReferenceLoopHandling = ReferenceLoopHandling.Serialize; + contract.ItemConverter = InterfaceObjectReferenceConverterInstance; + } + } + + private void SetupObjectReferenceProperty(JsonProperty jsonProperty, Type type, IEnumerable attributes) + { + var hasObjectInterfaceReferenceAttribute = HasObjectInterfaceReferenceAttribute(attributes); + if (_flaxType.IsAssignableFrom(type) || (type.IsInterface && hasObjectInterfaceReferenceAttribute)) + { + jsonProperty.ReferenceLoopHandling = ReferenceLoopHandling.Serialize; + jsonProperty.Converter = JsonSerializer.ObjectConverter; + } + if (hasObjectInterfaceReferenceAttribute && GetCollectionItemType(type)?.IsInterface == true) + { + jsonProperty.ItemReferenceLoopHandling = ReferenceLoopHandling.Serialize; + jsonProperty.ItemConverter = JsonSerializer.ObjectConverter; + } + } + + private sealed class InterfaceObjectReferenceConverter : JsonConverter + { + public override unsafe void WriteJson(JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer) + { + if (value is Object obj) + { + var id = obj.ID; + writer.WriteValue(JsonSerializer.GetStringID(&id)); + } + else if (value == null) + { + writer.WriteNull(); + } + else + { + serializer.Serialize(writer, value, value.GetType()); + } + } + + public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer) + { + if (reader.TokenType == JsonToken.String && JsonSerializer.TryParseID((string)reader.Value, out var id)) + { + return Object.Find(ref id, objectType, true); + } + if (reader.TokenType == JsonToken.Null) + return null; + // objectType is the same interface item type that selected this converter. Passing it back to + // Newtonsoft can cause this converter to be chosen again and recurse until the stack overflows. + return Newtonsoft.Json.Linq.JToken.Load(reader).ToObject(serializer); + } + + public override bool CanConvert(Type objectType) + { + return objectType.IsInterface; + } + } + /// protected override JsonContract CreateContract(Type objectType) { @@ -55,11 +138,23 @@ namespace FlaxEngine.Json.JsonCustomSerializers return contract; } + /// + protected override JsonArrayContract CreateArrayContract(Type objectType) + { + var contract = base.CreateArrayContract(objectType); + + SetupInterfaceObjectReferenceItems(contract, contract.CollectionItemType); + + return contract; + } + /// protected override JsonDictionaryContract CreateDictionaryContract(Type objectType) { var contract = base.CreateDictionaryContract(objectType); + SetupInterfaceObjectReferenceItems(contract, contract.DictionaryValueType); + // Override contract to save enums keys as integer var keyType = contract.DictionaryKeyType; if ((keyType?.IsEnum ?? false) && keyType.GetCustomAttribute() == null) @@ -116,11 +211,7 @@ namespace FlaxEngine.Json.JsonCustomSerializers jsonProperty.Writable = true; jsonProperty.Readable = true; - if (_flaxType.IsAssignableFrom(f.FieldType)) - { - jsonProperty.ReferenceLoopHandling = ReferenceLoopHandling.Serialize; - jsonProperty.Converter = JsonSerializer.ObjectConverter; - } + SetupObjectReferenceProperty(jsonProperty, f.FieldType, attributes); result.Add(jsonProperty); } @@ -159,11 +250,7 @@ namespace FlaxEngine.Json.JsonCustomSerializers jsonProperty.Writable = true; jsonProperty.Readable = !isObsolete; - if (_flaxType.IsAssignableFrom(p.PropertyType)) - { - jsonProperty.ReferenceLoopHandling = ReferenceLoopHandling.Serialize; - jsonProperty.Converter = JsonSerializer.ObjectConverter; - } + SetupObjectReferenceProperty(jsonProperty, p.PropertyType, attributes); result.Add(jsonProperty); } diff --git a/Source/Engine/Serialization/JsonSerializer.cs b/Source/Engine/Serialization/JsonSerializer.cs index c8d00567a..758ebf1ff 100644 --- a/Source/Engine/Serialization/JsonSerializer.cs +++ b/Source/Engine/Serialization/JsonSerializer.cs @@ -618,6 +618,31 @@ namespace FlaxEngine.Json return id; } + /// + /// Tries to parse the given object identifier represented in the internal serialization format. + /// + /// The ID string. + /// The identifier. + /// True if parsing succeeded, otherwise false. + public static unsafe bool TryParseID(string str, out Guid id) + { + id = Guid.Empty; + if (str == null || str.Length != 32) + return false; + + GuidInterop g; + if (!TryParseHex(str, 0, 8, out g.A) || + !TryParseHex(str, 8, 8, out g.B) || + !TryParseHex(str, 16, 8, out g.C) || + !TryParseHex(str, 24, 8, out g.D)) + { + return false; + } + + id = *(Guid*)&g; + return true; + } + /// /// Parses the given object identifier represented in the internal serialization format. /// @@ -625,76 +650,40 @@ namespace FlaxEngine.Json /// The identifier. public static unsafe void ParseID(string str, out Guid id) { - GuidInterop g; - - // Broken after VS 15.5 - /*fixed (char* a = str) - { - char* b = a + 8; - char* c = b + 8; - char* d = c + 8; - - ParseHex(a, 8, out g.A); - ParseHex(b, 8, out g.B); - ParseHex(c, 8, out g.C); - ParseHex(d, 8, out g.D); - }*/ - - // Temporary fix (not using raw char* pointer) - ParseHex(str, 0, 8, out g.A); - ParseHex(str, 8, 8, out g.B); - ParseHex(str, 16, 8, out g.C); - ParseHex(str, 24, 8, out g.D); - - id = *(Guid*)&g; + TryParseID(str, out id); } [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static unsafe void ParseHex(char* str, int length, out uint result) { - uint sum = 0; - char* p = str; - char* end = str + length; - - if (*p == '0' && *(p + 1) == 'x') - p += 2; - - while (p < end && *p != 0) - { - int c = *p - '0'; - - if (c < 0 || c > 9) - { - c = char.ToLower(*p) - 'a' + 10; - if (c < 10 || c > 15) - { - result = 0; - return; - } - } - - sum = 16 * sum + (uint)c; - - p++; - } - - result = sum; + TryParseHex(new ReadOnlySpan(str, length), out result); } [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static void ParseHex(string str, int start, int length, out uint result) { - uint sum = 0; - int p = start; - int end = start + length; + TryParseHex(str, start, length, out result); + } - if (str.Length < end) + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static bool TryParseHex(string str, int start, int length, out uint result) + { + if (str.Length < start + length) { result = 0; - return; + return false; } + return TryParseHex(str.AsSpan(start, length), out result); + } - if (str[p] == '0' && str[p + 1] == 'x') + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static bool TryParseHex(ReadOnlySpan str, out uint result) + { + uint sum = 0; + int p = 0; + int end = str.Length; + + if (p + 1 < end && str[p] == '0' && str[p + 1] == 'x') p += 2; while (p < end && str[p] != 0) @@ -707,7 +696,7 @@ namespace FlaxEngine.Json if (c < 10 || c > 15) { result = 0; - return; + return false; } } @@ -717,6 +706,7 @@ namespace FlaxEngine.Json } result = sum; + return p == end; } } } diff --git a/Source/Engine/Serialization/ReadStream.h b/Source/Engine/Serialization/ReadStream.h index cc2b7e73b..d8868c67e 100644 --- a/Source/Engine/Serialization/ReadStream.h +++ b/Source/Engine/Serialization/ReadStream.h @@ -133,6 +133,14 @@ public: v = ptr; } + template + FORCE_INLINE void Read(ScriptingObjectInterfaceReference& v) + { + uint32 id[4]; + ReadBytes(id, sizeof(id)); + v = *(Guid*)id; + } + template FORCE_INLINE void Read(SoftObjectReference& v) { @@ -141,6 +149,14 @@ public: v.Set(*(Guid*)id); } + template + FORCE_INLINE void Read(SoftObjectInterfaceReference& v) + { + uint32 id[4]; + ReadBytes(id, sizeof(id)); + v.Set(*(Guid*)id); + } + template FORCE_INLINE void Read(AssetReference& v) { diff --git a/Source/Engine/Serialization/Serialization.h b/Source/Engine/Serialization/Serialization.h index 41ae4898a..cc27d1726 100644 --- a/Source/Engine/Serialization/Serialization.h +++ b/Source/Engine/Serialization/Serialization.h @@ -14,8 +14,12 @@ struct VariantType; template class ScriptingObjectReference; template +class ScriptingObjectInterfaceReference; +template class SoftObjectReference; template +class SoftObjectInterfaceReference; +template class AssetReference; template class WeakAssetReference; @@ -458,7 +462,6 @@ namespace Serialization } FLAXENGINE_API bool ShouldSerializeRef(const SceneObject* v, const SceneObject* other); - template inline typename TEnableIf, TNot>>::Value, bool>::Type ShouldSerialize(const T* v, const void* otherObj) { @@ -474,7 +477,7 @@ namespace Serialization { Guid id; Deserialize(stream, id, modifier); - modifier->IdsMapping.TryGet(id, id); + modifier->IdsMapping.TryGet(id, id); v = (T*)::FindObject(id, T::GetStaticClass()); } @@ -501,7 +504,28 @@ namespace Serialization { Guid id; Deserialize(stream, id, modifier); - modifier->IdsMapping.TryGet(id, id); + modifier->IdsMapping.TryGet(id, id); + v = id; + } + + // Scripting Interface Reference + + template + inline bool ShouldSerialize(const ScriptingObjectInterfaceReference& v, const void* otherObj) + { + return !otherObj || ShouldSerializeRef(v.GetObject(), ((ScriptingObjectInterfaceReference*)otherObj)->GetObject()); + } + template + inline void Serialize(ISerializable::SerializeStream& stream, const ScriptingObjectInterfaceReference& v, const void* otherObj) + { + stream.Guid(v.GetID()); + } + template + inline void Deserialize(ISerializable::DeserializeStream& stream, ScriptingObjectInterfaceReference& v, ISerializeModifier* modifier) + { + Guid id; + Deserialize(stream, id, modifier); + modifier->IdsMapping.TryGet(id, id); v = id; } @@ -522,7 +546,28 @@ namespace Serialization { Guid id; Deserialize(stream, id, modifier); - modifier->IdsMapping.TryGet(id, id); + modifier->IdsMapping.TryGet(id, id); + v = id; + } + + // Soft Object Interface Reference + + template + inline bool ShouldSerialize(const SoftObjectInterfaceReference& v, const void* otherObj) + { + return !otherObj || ShouldSerializeRef(v.GetObject(), ((SoftObjectInterfaceReference*)otherObj)->GetObject()); + } + template + inline void Serialize(ISerializable::SerializeStream& stream, const SoftObjectInterfaceReference& v, const void* otherObj) + { + stream.Guid(v.GetID()); + } + template + inline void Deserialize(ISerializable::DeserializeStream& stream, SoftObjectInterfaceReference& v, ISerializeModifier* modifier) + { + Guid id; + Deserialize(stream, id, modifier); + modifier->IdsMapping.TryGet(id, id); v = id; } diff --git a/Source/Engine/Serialization/Stream.h b/Source/Engine/Serialization/Stream.h index 7e82467f5..e6dd3a42b 100644 --- a/Source/Engine/Serialization/Stream.h +++ b/Source/Engine/Serialization/Stream.h @@ -17,8 +17,12 @@ class ScriptingObject; template class ScriptingObjectReference; template +class ScriptingObjectInterfaceReference; +template class SoftObjectReference; template +class SoftObjectInterfaceReference; +template class AssetReference; template class WeakAssetReference; diff --git a/Source/Engine/Serialization/WriteStream.h b/Source/Engine/Serialization/WriteStream.h index f027deabb..6c610b66f 100644 --- a/Source/Engine/Serialization/WriteStream.h +++ b/Source/Engine/Serialization/WriteStream.h @@ -156,11 +156,29 @@ public: { Write(v.Get()); } + + template + FORCE_INLINE void Write(const ScriptingObjectInterfaceReference& v) + { + uint32 id[4]; + v.CopyID(id); + WriteBytes(id, sizeof(id)); + } + template FORCE_INLINE void Write(const SoftObjectReference& v) { Write(v.Get()); } + + template + FORCE_INLINE void Write(const SoftObjectInterfaceReference& v) + { + uint32 id[4]; + v.CopyID(id); + WriteBytes(id, sizeof(id)); + } + template FORCE_INLINE void Write(const AssetReference& v) { diff --git a/Source/Engine/Tests/TestScripting.h b/Source/Engine/Tests/TestScripting.h index ca13ac307..0a764c89f 100644 --- a/Source/Engine/Tests/TestScripting.h +++ b/Source/Engine/Tests/TestScripting.h @@ -6,6 +6,8 @@ #include "Engine/Core/Math/Vector3.h" #include "Engine/Core/Collections/Array.h" #include "Engine/Scripting/ScriptingObject.h" +#include "Engine/Scripting/ScriptingObjectInterfaceReference.h" +#include "Engine/Scripting/SoftObjectInterfaceReference.h" #include "Engine/Scripting/SerializableScriptingObject.h" #include "Engine/Scripting/SoftTypeReference.h" #include "Engine/Content/SceneReference.h" @@ -177,6 +179,10 @@ public: // Test struct API_FIELD() TestStruct SimpleStruct; + // Test interface reference + API_FIELD() ScriptingObjectInterfaceReference InterfaceRef; + // Test soft interface reference + API_FIELD() SoftObjectInterfaceReference SoftInterfaceRef; // Test event API_EVENT() Delegate&, Array&> SimpleEvent; diff --git a/Source/Tools/Flax.Build/Bindings/BindingsGenerator.CSharp.cs b/Source/Tools/Flax.Build/Bindings/BindingsGenerator.CSharp.cs index 174c6de2c..81fb9d873 100644 --- a/Source/Tools/Flax.Build/Bindings/BindingsGenerator.CSharp.cs +++ b/Source/Tools/Flax.Build/Bindings/BindingsGenerator.CSharp.cs @@ -108,7 +108,7 @@ namespace Flax.Build.Bindings if (attribute && valueType != null && !valueType.IsArray) { //if (valueType.Type == "") - //ScriptingObjectReference + //ScriptingObjectReference, ScriptingObjectInterfaceReference, SoftObjectInterfaceReference apiType = FindApiTypeInfo(buildData, valueType, caller); // Object reference @@ -315,6 +315,83 @@ namespace Flax.Build.Bindings return value; } + private static bool IsInterfaceRefArrayLike(TypeInfo typeInfo) + { + return typeInfo != null && + (typeInfo.Type == "Array" || typeInfo.Type == "Span" || typeInfo.Type == "DataContainer") && + typeInfo.GenericArgs != null && + typeInfo.GenericArgs.Count != 0 && + typeInfo.GenericArgs[0].IsInterfaceRef; + } + + private static bool IsInterfaceRefDictionary(TypeInfo typeInfo) + { + return typeInfo != null && + typeInfo.Type == "Dictionary" && + typeInfo.GenericArgs != null && + typeInfo.GenericArgs.Count == 2 && + (typeInfo.GenericArgs[0].IsInterfaceRef || typeInfo.GenericArgs[1].IsInterfaceRef); + } + + private static bool IsInterfaceRefContainer(TypeInfo typeInfo) + { + return IsInterfaceRefArrayLike(typeInfo) || IsInterfaceRefDictionary(typeInfo); + } + + private static TypeInfo GetInterfaceRefElementType(TypeInfo typeInfo) + { + if (typeInfo == null) + return null; + if (typeInfo.IsInterfaceRef) + return typeInfo; + if (IsInterfaceRefArrayLike(typeInfo)) + return typeInfo.GenericArgs[0]; + if (IsInterfaceRefDictionary(typeInfo)) + return typeInfo.GenericArgs[1].IsInterfaceRef ? typeInfo.GenericArgs[1] : typeInfo.GenericArgs[0]; + return null; + } + + private static string GenerateInterfaceRefToNative(BuildData buildData, TypeInfo interfaceRefType, ApiTypeInfo caller, string value) + { + return $"FlaxEngine.Object.GetUnmanagedInterface({value}, typeof({GenerateCSharpNativeToManaged(buildData, interfaceRefType.GenericArgs[0], caller)}))"; + } + + private static string GenerateInterfaceRefToManaged(BuildData buildData, TypeInfo interfaceRefType, ApiTypeInfo caller, string value, bool fromHandle) + { + var managedType = GenerateCSharpNativeToManaged(buildData, interfaceRefType.GenericArgs[0], caller); + return fromHandle + ? $"{value} != IntPtr.Zero ? Unsafe.As<{managedType}>(ManagedHandle.FromIntPtr({value}).Target) : null" + : $"{value} != null ? Unsafe.As<{managedType}>({value}) : null"; + } + + private static string GenerateInterfaceRefContainerToNative(TypeInfo typeInfo) + { + if (IsInterfaceRefArrayLike(typeInfo)) + return "{0} != null ? FlaxEngine.Interop.NativeInterop.ManagedArrayToGCHandleArray({0}) : null"; + if (IsInterfaceRefDictionary(typeInfo)) + { + var keyConverter = typeInfo.GenericArgs[0].IsInterfaceRef ? "(object)x.Key" : "x.Key"; + var valueConverter = typeInfo.GenericArgs[1].IsInterfaceRef ? "(object)x.Value" : "x.Value"; + return $"{{0}} != null ? System.Linq.Enumerable.ToDictionary({{0}}, x => {keyConverter}, x => {valueConverter}) : null"; + } + return string.Empty; + } + + private static string GenerateInterfaceRefContainerToManaged(BuildData buildData, TypeInfo typeInfo, ApiTypeInfo caller, string value) + { + if (IsInterfaceRefArrayLike(typeInfo)) + return $"{value}?.ConvertArray(x => {GenerateInterfaceRefToManaged(buildData, typeInfo.GenericArgs[0], caller, "x", true)})"; + if (IsInterfaceRefDictionary(typeInfo)) + { + var keyTypeInfo = typeInfo.GenericArgs[0]; + var valueTypeInfo = typeInfo.GenericArgs[1]; + var keyConverter = keyTypeInfo.IsInterfaceRef ? GenerateInterfaceRefToManaged(buildData, keyTypeInfo, caller, "x.Key", false) : "x.Key"; + var valueConverter = valueTypeInfo.IsInterfaceRef ? GenerateInterfaceRefToManaged(buildData, valueTypeInfo, caller, "x.Value", false) : "x.Value"; + return $"{value} != null ? System.Linq.Enumerable.ToDictionary({value}, x => {keyConverter}, x => {valueConverter}) : null"; + } + return value; + } + private static string GenerateCSharpNativeToManaged(BuildData buildData, TypeInfo typeInfo, ApiTypeInfo caller, bool marshalling = false) { string result; @@ -350,6 +427,10 @@ namespace Flax.Build.Bindings if (CSharpNativeToManagedDefault.TryGetValue(typeInfo.Type, out result)) return result; + // Interface reference property + if (typeInfo.IsInterfaceRef) + return marshalling ? "IntPtr" : GenerateCSharpNativeToManaged(buildData, typeInfo.GenericArgs[0], caller, marshalling); + // Object reference property if (typeInfo.IsObjectRef) return GenerateCSharpNativeToManaged(buildData, typeInfo.GenericArgs[0], caller, marshalling); @@ -371,12 +452,16 @@ namespace Flax.Build.Bindings if (arrayApiType != null && arrayApiType.MarshalAs != null) arrayTypeInfo = arrayApiType.MarshalAs; } - return GenerateCSharpNativeToManaged(buildData, arrayTypeInfo, caller) + "[]"; + return GenerateCSharpNativeToManaged(buildData, arrayTypeInfo, caller, marshalling) + "[]"; } // Dictionary if (typeInfo.Type == "Dictionary" && typeInfo.GenericArgs != null) - return string.Format("System.Collections.Generic.Dictionary<{0}, {1}>", GenerateCSharpNativeToManaged(buildData, typeInfo.GenericArgs[0], caller, marshalling), GenerateCSharpNativeToManaged(buildData, typeInfo.GenericArgs[1], caller, marshalling)); + { + var keyType = marshalling && typeInfo.GenericArgs[0].IsInterfaceRef ? "object" : GenerateCSharpNativeToManaged(buildData, typeInfo.GenericArgs[0], caller, marshalling); + var valueType = marshalling && typeInfo.GenericArgs[1].IsInterfaceRef ? "object" : GenerateCSharpNativeToManaged(buildData, typeInfo.GenericArgs[1], caller, marshalling); + return string.Format("System.Collections.Generic.Dictionary<{0}, {1}>", keyType, valueType); + } // HashSet if (typeInfo.Type == "HashSet" && typeInfo.GenericArgs != null) @@ -546,6 +631,8 @@ namespace Flax.Build.Bindings case "Array": case "Span": case "DataContainer": + if (IsInterfaceRefArrayLike(typeInfo)) + return GenerateInterfaceRefContainerToNative(typeInfo); if (typeInfo.GenericArgs != null) { // Convert array that uses different type for marshalling @@ -555,7 +642,15 @@ namespace Flax.Build.Bindings return $"{{0}}.ConvertArray(x => ({GenerateCSharpNativeToManaged(buildData, arrayApiType.MarshalAs, caller)})x)"; } return string.Empty; + case "Dictionary": + if (IsInterfaceRefDictionary(typeInfo)) + return GenerateInterfaceRefContainerToNative(typeInfo); + return string.Empty; default: + // Interface reference property + if (typeInfo.IsInterfaceRef) + return GenerateInterfaceRefToNative(buildData, typeInfo, caller, "{0}"); + var apiType = FindApiTypeInfo(buildData, typeInfo, caller); if (apiType != null) { @@ -778,9 +873,23 @@ namespace Flax.Build.Bindings } } #endif + const string interfaceResultName = "__interfaceResult"; + const string interfaceContainerResultName = "__interfaceContainerResult"; + + var returnInterfaceRef = !functionInfo.Glue.UseReferenceForResult && functionInfo.ReturnType.IsInterfaceRef; + var returnInterfaceRefContainer = !functionInfo.Glue.UseReferenceForResult && IsInterfaceRefContainer(functionInfo.ReturnType); + if (functionInfo.Glue.UseReferenceForResult) { } + else if (returnInterfaceRef) + { + contents.Append("var ").Append(interfaceResultName).Append(" = "); + } + else if (returnInterfaceRefContainer) + { + contents.Append("var ").Append(interfaceContainerResultName).Append(" = "); + } else if (!functionInfo.ReturnType.IsVoid) { contents.Append("return "); @@ -851,7 +960,15 @@ namespace Flax.Build.Bindings } contents.Append(')'); - if ((functionInfo.ReturnType.Type == "Array" || functionInfo.ReturnType.Type == "Span" || functionInfo.ReturnType.Type == "DataContainer") && functionInfo.ReturnType.GenericArgs != null) + if (returnInterfaceRef) + { + contents.Append("; return ").Append(GenerateInterfaceRefToManaged(buildData, functionInfo.ReturnType, caller, interfaceResultName, true)); + } + else if (returnInterfaceRefContainer) + { + contents.Append("; return ").Append(GenerateInterfaceRefContainerToManaged(buildData, functionInfo.ReturnType, caller, interfaceContainerResultName)); + } + else if ((functionInfo.ReturnType.Type == "Array" || functionInfo.ReturnType.Type == "Span" || functionInfo.ReturnType.Type == "DataContainer") && functionInfo.ReturnType.GenericArgs != null) { // Convert array that uses different type for marshalling var arrayTypeInfo = functionInfo.ReturnType.GenericArgs[0]; @@ -987,6 +1104,13 @@ namespace Flax.Build.Bindings private static void GenerateCSharpAttributes(BuildData buildData, StringBuilder contents, string indent, ApiTypeInfo apiTypeInfo, MemberInfo memberInfo, bool useUnmanaged, string defaultValue = null, TypeInfo defaultValueType = null) { GenerateCSharpAttributes(buildData, contents, indent, apiTypeInfo, memberInfo.Attributes, memberInfo.Comment, true, useUnmanaged, defaultValue, memberInfo.DeprecatedMessage, defaultValueType); + var memberType = (memberInfo as FieldInfo)?.Type ?? (memberInfo as PropertyInfo)?.Type; + var interfaceRefType = GetInterfaceRefElementType(memberType); + if (interfaceRefType != null) + { + var attribute = interfaceRefType.Type == "SoftObjectInterfaceReference" ? "SoftObjectInterfaceReference" : "ScriptingObjectInterfaceReference"; + contents.Append(indent).Append("[FlaxEngine.").Append(attribute).AppendLine("]"); + } } private static bool GenerateCSharpStructureUseDefaultInitialize(BuildData buildData, StructureInfo structureInfo) diff --git a/Source/Tools/Flax.Build/Bindings/BindingsGenerator.Cpp.cs b/Source/Tools/Flax.Build/Bindings/BindingsGenerator.Cpp.cs index c8d73c559..56d8d9b27 100644 --- a/Source/Tools/Flax.Build/Bindings/BindingsGenerator.Cpp.cs +++ b/Source/Tools/Flax.Build/Bindings/BindingsGenerator.Cpp.cs @@ -167,6 +167,8 @@ namespace Flax.Build.Bindings return $"Variant(StringView({value}))"; if (typeInfo.Type == "StringAnsi") return $"Variant(StringAnsiView({value}))"; + if (typeInfo.IsInterfaceRef) + return $"Variant({value}.GetObject())"; if (typeInfo.IsObjectRef) return $"Variant({value}.Get())"; if (typeInfo.Type == "SoftTypeReference") @@ -307,6 +309,8 @@ namespace Flax.Build.Bindings return $"((StringView){value}).GetText()"; // (StringView)Variant, if not empty, is guaranteed to point to a null-terminated buffer. if (typeInfo.Type == "ScriptingObjectReference" || typeInfo.Type == "SoftObjectReference") return $"ScriptingObject::Cast<{typeInfo.GenericArgs[0].Type}>((ScriptingObject*){value})"; + if (typeInfo.IsInterfaceRef) + return $"ScriptingObject::ToInterface<{typeInfo.GenericArgs[0].Type}>((ScriptingObject*){value})"; if (typeInfo.IsObjectRef) return $"ScriptingObject::Cast<{typeInfo.GenericArgs[0].Type}>((Asset*){value})"; if (typeInfo.Type == "SoftTypeReference") @@ -652,8 +656,8 @@ namespace Flax.Build.Bindings { CppIncludeFiles.Add("Engine/Scripting/Internal/ManagedDictionary.h"); type = "MObject*"; - var keyClass = GenerateCppGetNativeType(buildData, typeInfo.GenericArgs[0], caller, functionInfo); - var valueClass = GenerateCppGetNativeType(buildData, typeInfo.GenericArgs[1], caller, functionInfo); + var keyClass = typeInfo.GenericArgs[0].IsInterfaceRef ? "MCore::TypeCache::Object->GetType()" : GenerateCppGetNativeType(buildData, typeInfo.GenericArgs[0], caller, functionInfo); + var valueClass = typeInfo.GenericArgs[1].IsInterfaceRef ? "MCore::TypeCache::Object->GetType()" : GenerateCppGetNativeType(buildData, typeInfo.GenericArgs[1], caller, functionInfo); return "ManagedDictionary::ToManaged({0}, " + keyClass + ", " + valueClass + ")"; } @@ -797,6 +801,19 @@ namespace Flax.Build.Bindings type = "MObject*"; return "MUtils::ToNative({0})"; default: + // Interface reference property + if (typeInfo.IsInterfaceRef) + { + if (CppNonPodTypesConvertingGeneration) + { + type = "MObject*"; + return "ScriptingObject::ToInterface<" + typeInfo.GenericArgs[0].Type + ">(ScriptingObject::ToNative({0}))"; + } + + type = typeInfo.GenericArgs[0].Type + '*'; + return string.Empty; + } + // Object reference property if (typeInfo.IsObjectRef) { @@ -1006,8 +1023,8 @@ namespace Flax.Build.Bindings if (typeInfo.Type == "Dictionary" && typeInfo.GenericArgs != null) { CppIncludeFiles.Add("Engine/Scripting/Internal/ManagedDictionary.h"); - var keyClass = GenerateCppGetNativeType(buildData, typeInfo.GenericArgs[0], caller); - var valueClass = GenerateCppGetNativeType(buildData, typeInfo.GenericArgs[1], caller); + var keyClass = typeInfo.GenericArgs[0].IsInterfaceRef ? "MCore::TypeCache::Object->GetType()" : GenerateCppGetNativeType(buildData, typeInfo.GenericArgs[0], caller); + var valueClass = typeInfo.GenericArgs[1].IsInterfaceRef ? "MCore::TypeCache::Object->GetType()" : GenerateCppGetNativeType(buildData, typeInfo.GenericArgs[1], caller); return $"ManagedDictionary::ToManaged({value}, {keyClass}, {valueClass})"; } diff --git a/Source/Tools/Flax.Build/Bindings/ClassInfo.cs b/Source/Tools/Flax.Build/Bindings/ClassInfo.cs index f2d82cc6e..46097a218 100644 --- a/Source/Tools/Flax.Build/Bindings/ClassInfo.cs +++ b/Source/Tools/Flax.Build/Bindings/ClassInfo.cs @@ -18,6 +18,8 @@ namespace Flax.Build.Bindings "ManagedScriptingObject", "PersistentScriptingObject", "ScriptingObjectReference", + "ScriptingObjectInterfaceReference", + "SoftObjectInterfaceReference", "AssetReference", "BinaryAsset", "SceneObject", diff --git a/Source/Tools/Flax.Build/Bindings/TypeInfo.cs b/Source/Tools/Flax.Build/Bindings/TypeInfo.cs index 04836c636..79ade2bfa 100644 --- a/Source/Tools/Flax.Build/Bindings/TypeInfo.cs +++ b/Source/Tools/Flax.Build/Bindings/TypeInfo.cs @@ -38,10 +38,18 @@ namespace Flax.Build.Bindings /// Gets a value indicating whether this type is a reference to another object. /// public bool IsObjectRef => (Type == "ScriptingObjectReference" || + Type == "ScriptingObjectInterfaceReference" || Type == "AssetReference" || Type == "WeakAssetReference" || Type == "SoftAssetReference" || - Type == "SoftObjectReference") && GenericArgs != null; + Type == "SoftObjectReference" || + Type == "SoftObjectInterfaceReference") && GenericArgs != null; + + /// + /// Gets a value indicating whether this type is a reference to another object filtered by interface. + /// + public bool IsInterfaceRef => (Type == "ScriptingObjectInterfaceReference" || + Type == "SoftObjectInterfaceReference") && GenericArgs != null; public TypeInfo() {