Managed components can now receive OnTransformChanged events

MBansheeEngine/Component.cs

@@ -47,8 +47,8 @@ namespace BansheeEngine
         /// </summary>
         protected TransformChangedFlags NotifyFlags
         {
-            set { /* TODO */}
-            get { return TransformChangedFlags.None; /* TODO */ }
+            set { Internal_SetNotifyFlags(mCachedPtr, value); }
+            get { return Internal_GetNotifyFlags(mCachedPtr); }
         }
 
         /// <summary>
@@ -96,6 +96,12 @@ namespace BansheeEngine
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal static extern SceneObject Internal_GetSceneObject(IntPtr nativeInstance);
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern TransformChangedFlags Internal_GetNotifyFlags(IntPtr nativeInstance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void Internal_SetNotifyFlags(IntPtr nativeInstance, TransformChangedFlags flags);
+
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_Destroy(IntPtr nativeInstance, bool immediate);
     }

MBansheeEngine/GameObject.cs

@@ -26,7 +26,7 @@ namespace BansheeEngine
     /// Flags used for notifying child scene object and components when a transform has been changed.
     /// </summary>
     [Flags]
-    public enum TransformChangedFlags
+    public enum TransformChangedFlags // Note: Must match C++ enum TransformChangedFlags
     {
         /// <summary>
         /// Component will not be notified about any events relating to the transform.

MBansheeEngine/Physics/CharacterController.cs

@@ -1,6 +1,5 @@
 //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-
 using System;
 using System.Runtime.InteropServices;
 
@@ -479,7 +478,9 @@ namespace BansheeEngine
         public int triangleIndex;
     };
 
-    /** Contains data about a collision between two character controllers. */
+    /// <summary>
+    /// Contains data about a collision between two character controllers.
+    /// </summary>
     public class ControllerControllerCollision : ControllerCollision
     {
         /// <summary>

SBansheeEngine/Include/BsManagedComponent.h

@@ -11,83 +11,64 @@ namespace BansheeEngine
 	struct ComponentBackupData;
 
 	/**
-	 * @brief	Component that internally wraps a managed component object
-	 *			that can be of user-defined type. Acts as interop interop layer
-	 *			between native Component and a managed user defined component type
-	 *			since managed types cannot simply derive from Component
-	 *			to implement its functionality.
+	 * Component that internally wraps a managed component object that can be of user-defined type. Acts as interop interop
+	 * layer between native Component and a managed user defined component type since managed types cannot simply derive
+	 * from Component to implement its functionality.
 	 */
 	class BS_SCR_BE_EXPORT ManagedComponent : public Component
 	{
 	public:
 		~ManagedComponent();
 
-		/**
-		 * @brief	Returns managed component object instance.
-		 */
+		/**	Returns managed component object instance. */
 		MonoObject* getManagedInstance() const { return mManagedInstance; }
 
-		/**
-		 * @brief	Returns managed type of the component.
-		 */
+		/**	Returns managed type of the component. */
 		MonoReflectionType* getRuntimeType() const { return mRuntimeType; }
 
-		/**
-		 * @brief	Returns namespace of the managed component.
-		 */
+		/**	Returns namespace of the managed component. */
 		const String& getManagedNamespace() const { return mNamespace; }
 
-		/**
-		 * @brief	Returns type name of the managed component.
-		 */
+		/**	Returns type name of the managed component. */
 		const String& getManagedTypeName() const { return mTypeName; }
 
-		/**
-		 * @brief	Returns namespace and type name of the component in format "namespace.typename".
-		 */
+		/**	Returns namespace and type name of the component in format "namespace.typename". */
 		const String& getManagedFullTypeName() const { return mFullTypeName; }
 
 		/**
-		 * @brief	Serializes the internal managed component.
+		 * Serializes the internal managed component.
 		 *
-		 * @param	clearExisting	Should the managed component handle be released. (Will trigger a finalizer
-		 *							if this is the last reference to it)
-		 * 
-		 * @return	An object containing the serialized component. You can provide this to ::restore
-		 *			method to re-create the original component.
+		 * @param[in]	clearExisting	Should the managed component handle be released. (Will trigger a finalizer if this
+		 *								is the last reference to it)
+		 * @return						An object containing the serialized component. You can provide this to restore()
+		 *								method to re-create the original component.
 		 */
 		ComponentBackupData backup(bool clearExisting = true);
 
 		/**
-		 * @brief	Restores a component from previously serialized data.
+		 * Restores a component from previously serialized data.
 		 *
-		 * @param	instance	New instance of the managed component. Must be of the valid component type
-		 *						or of BansheeEngine.MissingComponent type if the original type is missing.
-		 * @param	data		Serialized managed component data that will be used for initializing
-		 *						the new managed instance.
-		 * @param	missingType	Is the component's type missing (can happen after assembly reload).
-		 *						If true then the serialized data will be stored internally until later
-		 *						date when user perhaps restores the type with another refresh.
-		 *						\p instance must be null if this is true.
+		 * @param[in]	instance	New instance of the managed component. Must be of the valid component type or of 
+		 *							BansheeEngine.MissingComponent type if the original type is missing.
+		 * @param[in]	data		Serialized managed component data that will be used for initializing the new managed
+		 *							instance.
+		 * @param[in]	missingType	Is the component's type missing (can happen after assembly reload). If true then the
+		 *							serialized data will be stored internally until later date when user perhaps restores
+		 *							the type with another refresh. @p instance must be null if this is true.
 		 */
 		void restore(MonoObject* instance, const ComponentBackupData& data, bool missingType);
 
-		/**
-		 * @brief	Triggers the managed OnInitialize callback.
-		 */
+		/**	Triggers the managed OnInitialize callback. */
 		void triggerOnInitialize();
 
-		/**
-		 * @brief	Triggers the managed OnReset callback.
-		 */
+		/**	Triggers the managed OnReset callback. */
 		void triggerOnReset();
 
 	private:
 		/**
-		 * @brief	Finalizes construction of the object. Must be called before use or when
-		 *			the managed component instance changes.
+		 * Finalizes construction of the object. Must be called before use or when the managed component instance changes.
 		 *
-		 * @param	object	Managed component instance.
+		 * @param[in]	object	Managed component instance.
 		 */
 		void initialize(MonoObject* object);
 
@@ -97,6 +78,7 @@ namespace BansheeEngine
 		typedef void(__stdcall *OnResetThunkDef) (MonoObject*, MonoException**);
 		typedef void(__stdcall *OnEnabledThunkDef) (MonoObject*, MonoException**);
 		typedef void(__stdcall *OnDisabledThunkDef) (MonoObject*, MonoException**);
+		typedef void(__stdcall *OnTransformChangedThunkDef) (MonoObject*, TransformChangedFlags, MonoException**);
 
 		MonoObject* mManagedInstance;
 		MonoReflectionType* mRuntimeType;
@@ -118,6 +100,7 @@ namespace BansheeEngine
 		OnDestroyedThunkDef mOnDestroyThunk;
 		OnDestroyedThunkDef mOnDisabledThunk;
 		OnDestroyedThunkDef mOnEnabledThunk;
+		OnTransformChangedThunkDef mOnTransformChangedThunk;
 		MonoMethod* mCalculateBoundsMethod;
 
 		/************************************************************************/
@@ -130,45 +113,32 @@ namespace BansheeEngine
 
 		ManagedComponent(const HSceneObject& parent, MonoReflectionType* runtimeType);
 
-		/**
-		 * @copydoc	Component::instantiate
-		 */
+		/** @copydoc Component::instantiate */
 		void instantiate() override;
 
-		/**
-		 * @copydoc	Component::onInitialized
-		 */
+		/** @copydoc Component::onInitialized */
 		void onInitialized() override;
 
-		/**
-		 * @copydoc	Component::onDestroyed
-		 */
+		/** @copydoc Component::onDestroyed */
 		void onDestroyed() override;
 
-		/**
-		 * @copydoc	Component::onEnabled 
-		 */
+		/** @copydoc Component::onEnabled  */
 		void onEnabled() override;
 
-		/**
-		 * @copydoc	Component::onDisabled 
-		 */
+		/** @copydoc Component::onDisabled  */
 		void onDisabled() override;
 
+		/** @copydoc Component::onTransformChanged  */
+		void onTransformChanged(TransformChangedFlags flags) override;
+
 	public:
-		/**
-		 * @copydoc	Component::update
-		 */
+		/** @copydoc Component::update */
 		void update() override;
 
-		/**
-		 * @copydoc	Component::typeEquals
-		 */
+		/** @copydoc Component::typeEquals */
 		bool typeEquals(const Component& other) override;
 
-		/**
-		 * @copydoc	Component::calculateBounds
-		 */
+		/** @copydoc Component::calculateBounds */
 		bool calculateBounds(Bounds& bounds) override;
 
 		/************************************************************************/
@@ -183,9 +153,7 @@ namespace BansheeEngine
 		ManagedComponent(); // Serialization only
 	};
 
-	/**
-	 * @brief	Contains serialized component data buffer.
-	 */
+	/**	Contains serialized component data buffer. */
 	struct ComponentBackupData
 	{
 		UINT8* data;

SBansheeEngine/Include/BsScriptComponent.h

@@ -9,22 +9,16 @@
 
 namespace BansheeEngine
 {
-	/**
-	 * @brief	Interop class between C++ & CLR for ManagedComponent.
-	 */
+	/**	Interop class between C++ & CLR for ManagedComponent. */
 	class BS_SCR_BE_EXPORT ScriptComponent : public ScriptObject<ScriptComponent, ScriptGameObjectBase>
 	{
 	public:
 		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "Component")
 
-		/**
-		 * @copydoc	ScriptGameObjectBase::getNativeHandle
-		 */
+		/** @copydoc ScriptGameObjectBase::getNativeHandle */
 		virtual HGameObject getNativeHandle() const override { return mManagedComponent; }
 
-		/**
-		 * @copydoc	ScriptGameObjectBase::setNativeHandle
-		 */
+		/** @copydoc ScriptGameObjectBase::setNativeHandle */
 		virtual void setNativeHandle(const HGameObject& gameObject) override;
 
 	private:
@@ -32,30 +26,19 @@ namespace BansheeEngine
 
 		ScriptComponent(MonoObject* instance);
 		
-		/**
-		 * @copydoc	ScriptObjectBase::beginRefresh
-		 */
+		/** @copydoc ScriptObjectBase::beginRefresh */
 		virtual ScriptObjectBackup beginRefresh() override;
 
-		/**
-		 * @copydoc	ScriptObjectBase::endRefresh
-		 */
+		/** @copydoc ScriptObjectBase::endRefresh */
 		virtual void endRefresh(const ScriptObjectBackup& backupData) override;
 
-		/**
-		 * @copydoc	ScriptObjectBase::_createManagedInstance
-		 */
+		/** @copydoc ScriptObjectBase::_createManagedInstance */
 		virtual MonoObject* _createManagedInstance(bool construct) override;
 
-		/**
-		 * @copydoc	ScriptObjectBase::_onManagedInstanceDeleted
-		 */
+		/** @copydoc ScriptObjectBase::_onManagedInstanceDeleted */
 		void _onManagedInstanceDeleted() override;
 
-		/**
-		 * @brief	Checks if the provided game object is destroyed and logs
-		 *			a warning if it is.
-		 */
+		/** Checks if the provided game object is destroyed and logs a warning if it is. */
 		static bool checkIfDestroyed(const GameObjectHandleBase& handle);
 
 		GameObjectHandle<ManagedComponent> mManagedComponent;
@@ -72,6 +55,8 @@ namespace BansheeEngine
 		static MonoArray* internal_getComponentsPerType(MonoObject* parentSceneObject, MonoReflectionType* type);
 		static void internal_removeComponent(MonoObject* parentSceneObject, MonoReflectionType* type);
 		static MonoObject* internal_getSceneObject(ScriptComponent* nativeInstance);
+		static TransformChangedFlags internal_getNotifyFlags(ScriptComponent* nativeInstance);
+		static void internal_setNotifyFlags(ScriptComponent* nativeInstance, TransformChangedFlags flags);
 		static void internal_destroy(ScriptComponent* nativeInstance, bool immediate);
 	};
 }

SBansheeEngine/Source/BsManagedComponent.cpp

@@ -19,14 +19,14 @@ namespace BansheeEngine
 	ManagedComponent::ManagedComponent()
 		:mManagedInstance(nullptr), mOnUpdateThunk(nullptr), mOnDestroyThunk(nullptr), mOnInitializedThunk(nullptr), 
 		mOnResetThunk(nullptr), mMissingType(false), mRequiresReset(true), mOnEnabledThunk(nullptr), mOnDisabledThunk(nullptr),
-		mCalculateBoundsMethod(nullptr), mRunInEditor(false)
+		mOnTransformChangedThunk(nullptr), mCalculateBoundsMethod(nullptr), mRunInEditor(false)
 	{ }
 
 	ManagedComponent::ManagedComponent(const HSceneObject& parent, MonoReflectionType* runtimeType)
 		: Component(parent), mManagedInstance(nullptr), mRuntimeType(runtimeType), mOnUpdateThunk(nullptr), 
 		mOnDestroyThunk(nullptr), mOnInitializedThunk(nullptr), mOnResetThunk(nullptr), mMissingType(false), 
 		mRequiresReset(true), mOnEnabledThunk(nullptr), mOnDisabledThunk(nullptr), mCalculateBoundsMethod(nullptr),
-		mRunInEditor(false)
+		mOnTransformChangedThunk(nullptr), mRunInEditor(false)
 	{
 		MonoType* monoType = mono_reflection_type_get_type(mRuntimeType);
 		::MonoClass* monoClass = mono_type_get_class(monoType);
@@ -93,6 +93,7 @@ namespace BansheeEngine
 			mOnDestroyThunk = nullptr;
 			mOnEnabledThunk = nullptr;
 			mOnDisabledThunk = nullptr;
+			mOnTransformChangedThunk = nullptr;
 			mCalculateBoundsMethod = nullptr;
 		}
 
@@ -172,6 +173,10 @@ namespace BansheeEngine
 			if (onEnableMethod != nullptr)
 				mOnEnabledThunk = (OnInitializedThunkDef)onEnableMethod->getThunk();
 
+			MonoMethod* onTransformChangedMethod = managedClass->getMethod("OnTransformChanged", 1);
+			if (onTransformChangedMethod != nullptr)
+				mOnTransformChangedThunk = (OnTransformChangedThunkDef)onTransformChangedMethod->getThunk();
+
 			mCalculateBoundsMethod = managedClass->getMethod("CalculateBounds", 2);
 
 			MonoAssembly* bansheeEngineAssembly = MonoManager::instance().getAssembly(ENGINE_ASSEMBLY);
@@ -364,6 +369,19 @@ namespace BansheeEngine
 		}
 	}
 
+	void ManagedComponent::onTransformChanged(TransformChangedFlags flags)
+	{
+		if (PlayInEditorManager::instance().getState() == PlayInEditorState::Stopped && !mRunInEditor)
+			return;
+
+		if(mOnTransformChangedThunk != nullptr)
+		{
+			// Note: Not calling virtual methods. Can be easily done if needed but for now doing this
+			// for some extra speed.
+			MonoUtil::invokeThunk(mOnTransformChangedThunk, mManagedInstance, flags);
+		}
+	}
+
 	RTTITypeBase* ManagedComponent::getRTTIStatic()
 	{
 		return ManagedComponentRTTI::instance();

SBansheeEngine/Source/BsScriptComponent.cpp

@@ -33,6 +33,8 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_GetComponentsPerType", &ScriptComponent::internal_getComponentsPerType);
 		metaData.scriptClass->addInternalCall("Internal_RemoveComponent", &ScriptComponent::internal_removeComponent);
 		metaData.scriptClass->addInternalCall("Internal_GetSceneObject", &ScriptComponent::internal_getSceneObject);
+		metaData.scriptClass->addInternalCall("Internal_GetNotifyFlags", &ScriptComponent::internal_getNotifyFlags);
+		metaData.scriptClass->addInternalCall("Internal_SetNotifyFlags", &ScriptComponent::internal_setNotifyFlags);
 		metaData.scriptClass->addInternalCall("Internal_Destroy", &ScriptComponent::internal_destroy);
 	}
 
@@ -200,6 +202,20 @@ namespace BansheeEngine
 		return scriptSO->getManagedInstance();
 	}
 
+	TransformChangedFlags ScriptComponent::internal_getNotifyFlags(ScriptComponent* nativeInstance)
+	{
+		if (!checkIfDestroyed(nativeInstance->mManagedComponent))
+			return nativeInstance->mManagedComponent->mNotifyFlags;
+
+		return TCF_None;
+	}
+
+	void ScriptComponent::internal_setNotifyFlags(ScriptComponent* nativeInstance, TransformChangedFlags flags)
+	{
+		if (!checkIfDestroyed(nativeInstance->mManagedComponent))
+			nativeInstance->mManagedComponent->mNotifyFlags = flags;
+	}
+
 	void ScriptComponent::internal_destroy(ScriptComponent* nativeInstance, bool immediate)
 	{
 		if (!checkIfDestroyed(nativeInstance->mManagedComponent))