WIP C# DragDropManager

BansheeEngine/Source/BsDragAndDropManager.cpp

@@ -25,6 +25,9 @@ namespace BansheeEngine
 
 	void DragAndDropManager::startDrag(UINT32 typeId, void* data, std::function<void(bool)> dropCallback, bool needsValidDropTarget)
 	{
+		if (mIsDragInProgress)
+			endDrag(false);
+
 		mDragTypeId = typeId;
 		mData = data;
 		mNeedsValidDropTarget = needsValidDropTarget;

BansheeEngine/Source/BsProfilerOverlay.cpp

@@ -657,7 +657,7 @@ namespace BansheeEngine
 
 	void ProfilerOverlay::updateGPUSampleContents(const GPUProfilerReport& gpuReport)
 	{
-		mGPUFrameNumStr.setParameter(0, toWString((UINT64)gTime().getCurrentFrameNumber()));
+		mGPUFrameNumStr.setParameter(0, toWString((UINT64)gTime().getFrameNumber()));
 		mGPUTimeStr.setParameter(0, toWString(gpuReport.frameSample.timeMs));
 		mGPUDrawCallsStr.setParameter(0, toWString(gpuReport.frameSample.numDrawCalls));
 		mGPURenTargetChangesStr.setParameter(0, toWString(gpuReport.frameSample.numRenderTargetChanges));

BansheeOISInput/Source/BsInputHandlerOIS.cpp

@@ -255,7 +255,7 @@ namespace BansheeEngine
 
 		// Update sample times used for determining sampling rate. But only if something was
 		// actually sampled, and only if this isn't the first non-zero sample.
-		if (mLastMouseUpdateFrame != gTime().getCurrentFrameNumber())
+		if (mLastMouseUpdateFrame != gTime().getFrameNumber())
 		{
 			if (arg.state.X.rel != 0 && !Math::approxEquals(mMouseSmoothedAxis[0], 0.0f))
 				mTotalMouseSamplingTime[0] += gTime().getFrameDelta();
@@ -263,7 +263,7 @@ namespace BansheeEngine
 			if (arg.state.Y.rel != 0 && !Math::approxEquals(mMouseSmoothedAxis[1], 0.0f))
 				mTotalMouseSamplingTime[1] += gTime().getFrameDelta();
 
-			mLastMouseUpdateFrame = gTime().getCurrentFrameNumber();
+			mLastMouseUpdateFrame = gTime().getFrameNumber();
 		}
 
 		RawAxisState zState;

BansheeUtility/Include/BsTime.h

@@ -45,7 +45,7 @@ namespace BansheeEngine
 		 *
 		 * @return	The current frame.
 		 */
-		unsigned long getCurrentFrameNumber() const { return mCurrentFrame; }
+		unsigned long getFrameNumber() const { return mCurrentFrame; }
 
 		/**
 		 * @brief	Returns the precise time since application start, in microseconds.

MBansheeEditor/DragDrop.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Runtime.CompilerServices;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+    public static class DragDrop
+    {
+        public static bool DragInProgress { get { return Internal_IsDragInProgress(); } }
+        public static bool DropInProgress { get { return Internal_IsDropInProgress(); } }
+        public static DragDropData Data { get { return Internal_GetData(); } }
+
+        public static DragDropType Type
+        {
+            get
+            {
+                if (Data != null)
+                    return Data.Type;
+
+                return DragDropType.None;
+            }
+        }
+
+        public static void StartDrag(DragDropData data)
+        {
+            if (data is SceneObjectDragDropData)
+                Internal_StartSceneObjectDrag(data.GetCachedPtr());
+            else if (data is ResourceDragDropData)
+                Internal_StartResourceDrag(data.GetCachedPtr());
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_IsDragInProgress();
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool Internal_IsDropInProgress();
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern DragDropData Internal_GetData();
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_StartSceneObjectDrag(IntPtr instance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_StartResourceDrag(IntPtr instance);
+    }
+
+    public class DragDropData : ScriptObject
+    {
+        internal DragDropType type;
+
+        public DragDropType Type { get { return type; } }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(DragDropData instance);
+    }
+
+    public class SceneObjectDragDropData : DragDropData
+    {
+        public SceneObject[] Objects { get { return Internal_GetObjects(mCachedPtr); } }
+
+        public SceneObjectDragDropData(SceneObject[] objects)
+        {
+            this.type = DragDropType.SceneObject;
+
+            Internal_CreateInstance(this, objects);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(SceneObjectDragDropData instance, SceneObject[] objects);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern SceneObject[] Internal_GetObjects(IntPtr thisPtr);
+    }
+
+    public class ResourceDragDropData : DragDropData
+    {
+        public string[] Paths { get { return Internal_GetPaths(mCachedPtr); } }
+
+        public ResourceDragDropData(string[] paths)
+        {
+            this.type = DragDropType.Resource;
+
+            Internal_CreateInstance(this, paths);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_CreateInstance(ResourceDragDropData instance, string[] paths);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern string[] Internal_GetPaths(IntPtr thisPtr);
+    }
+
+    public enum DragDropType
+    {
+        Resource,
+        SceneObject,
+        None
+    }
+}

MBansheeEditor/MBansheeEditor.csproj

@@ -51,6 +51,7 @@
     <Compile Include="Debug_Component1.cs" />
     <Compile Include="Debug_Component2.cs" />
     <Compile Include="DialogBox.cs" />
+    <Compile Include="DragDrop.cs" />
     <Compile Include="EditorApplication.cs" />
     <Compile Include="EditorSettings.cs" />
     <Compile Include="EditorStyles.cs" />

SBansheeEditor/Include/BsScriptDragDropManager.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include "BsScriptEditorPrerequisites.h"
+#include "BsScriptObject.h"
+#include "BsDragAndDropManager.h"
+
+namespace BansheeEngine
+{
+	class ScriptSceneObjectDragDropData;
+	class ScriptResourceDragDropData;
+
+	class BS_SCR_BED_EXPORT ScriptDragDrop : public ScriptObject<ScriptDragDrop>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "DragDrop");
+
+	private:
+		ScriptDragDrop(MonoObject* instance);
+
+		static bool internal_IsDragInProgress();
+		static bool internal_IsDropInProgress();
+		static MonoObject* internal_GetData();
+		static void internal_StartSceneObjectDrag(ScriptSceneObjectDragDropData* dragData);
+		static void internal_StartResourceDrag(ScriptResourceDragDropData* dragData);
+	};
+
+	class BS_SCR_BED_EXPORT ScriptSceneObjectDragDropData : public ScriptObject<ScriptSceneObjectDragDropData>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "SceneObjectDragDropData");
+
+		static MonoObject* create(const Vector<HSceneObject>& sceneObjects);
+
+		const Vector<HSceneObject>& getSceneObjects() const { return mSceneObjects; }
+
+	private:
+		ScriptSceneObjectDragDropData(MonoObject* instance, const Vector<HSceneObject>& sceneObjects);
+
+		static void internal_CreateInstance(MonoObject* instance, MonoArray* objects);
+		static MonoArray* internal_GetObjects(ScriptSceneObjectDragDropData* instance);
+
+		Vector<HSceneObject> mSceneObjects;
+	};
+
+	class BS_SCR_BED_EXPORT ScriptResourceDragDropData : public ScriptObject < ScriptResourceDragDropData >
+	{
+	public:
+		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "ResourceDragDropData");
+
+		static MonoObject* create(const Vector<Path>& paths);
+
+		const Vector<Path>& getPaths() const { return mPaths; }
+
+	private:
+		ScriptResourceDragDropData(MonoObject* instance, const Vector<Path>& paths);
+
+		static void internal_CreateInstance(MonoObject* instance, MonoArray* paths);
+		static MonoArray* internal_GetPaths(ScriptResourceDragDropData* instance);
+
+		Vector<Path> mPaths;
+	};
+
+	// Note: Must be equal to C# DragDropType enum
+	enum class ScriptDragDropType
+	{
+		Resource,
+		SceneObject,
+		None
+	};
+
+	class BS_SCR_BED_EXPORT ScriptDragDropManager : public Module<ScriptDragDropManager>
+	{
+	public:
+		ScriptDragDropManager();
+		~ScriptDragDropManager();
+
+		void update();
+
+		bool isDropInProgress() const { return mIsDropInProgress; }
+		MonoObject* getDropData() const;
+
+	private:
+		void onMouseDragEnded(const PointerEvent& evt, DragCallbackInfo& callbackInfo);
+
+		HEvent mDragEndedConn;
+
+		bool mIsDropInProgress;
+		UINT64 mDroppedFrameIdx;
+		ScriptDragDropType mDropType;
+		Vector<Path> mDroppedPaths;
+		Vector<HSceneObject> mDroppedSceneObjects;
+	};
+}

SBansheeEditor/SBansheeEditor.vcxproj

@@ -237,6 +237,7 @@
     <ClInclude Include="Include\BsGUIPanelContainer.h" />
     <ClInclude Include="Include\BsGUIResourceField.h" />
     <ClInclude Include="Include\BsScriptBrowseDialog.h" />
+    <ClInclude Include="Include\BsScriptDragDropManager.h" />
     <ClInclude Include="Include\BsScriptEditorPrerequisites.h" />
     <ClInclude Include="Include\BsScriptEditorSettings.h" />
     <ClInclude Include="Include\BsScriptEditorUtility.h" />
@@ -269,6 +270,7 @@
     <ClInclude Include="Include\BsScriptSelection.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="Source\BsScriptDragDropManager.cpp" />
     <ClCompile Include="Source\BsEditorScriptManager.cpp" />
     <ClCompile Include="Source\BsGUIGameObjectField.cpp" />
     <ClCompile Include="Source\BsGUIPanelContainer.cpp" />

SBansheeEditor/SBansheeEditor.vcxproj.filters

@@ -120,6 +120,9 @@
     <ClInclude Include="Include\BsScriptBrowseDialog.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsScriptDragDropManager.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsScriptEditorPlugin.cpp">
@@ -227,5 +230,8 @@
     <ClCompile Include="Source\BsScriptBrowseDialog.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Source\BsScriptDragDropManager.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

SBansheeEditor/Source/BsEditorScriptManager.cpp

@@ -8,6 +8,7 @@
 #include "BsScriptGizmoManager.h"
 #include "BsScriptHandleManager.h"
 #include "BsScriptHandleSliderManager.h"
+#include "BsScriptDragDropManager.h"
 #include "BsTime.h"
 #include "BsMath.h"
 
@@ -25,6 +26,7 @@ namespace BansheeEngine
 		ScriptHandleSliderManager::startUp();
 		ScriptGizmoManager::startUp(ScriptAssemblyManager::instance());
 		HandleManager::startUp<ScriptHandleManager>(ScriptAssemblyManager::instance());
+		ScriptDragDropManager::startUp();
 
 		mOnDomainLoadConn = ScriptObjectManager::instance().onRefreshDomainLoaded.connect(std::bind(&EditorScriptManager::loadMonoTypes, this));
 		mOnAssemblyRefreshDoneConn = ScriptObjectManager::instance().onRefreshComplete.connect(std::bind(&EditorScriptManager::onAssemblyRefreshDone, this));
@@ -40,6 +42,7 @@ namespace BansheeEngine
 		mOnDomainLoadConn.disconnect();
 		mOnAssemblyRefreshDoneConn.disconnect();
 
+		ScriptDragDropManager::shutDown();
 		ScriptHandleSliderManager::shutDown();
 		HandleManager::shutDown();
 		ScriptGizmoManager::shutDown();
@@ -65,6 +68,7 @@ namespace BansheeEngine
 		}
 
 		ScriptGizmoManager::instance().update();
+		ScriptDragDropManager::instance().update();
 	}
 
 	void EditorScriptManager::debug_refreshAssembly()

SBansheeEditor/Source/BsScriptDragDropManager.cpp

@@ -0,0 +1,248 @@
+#include "BsScriptDragDropManager.h"
+#include "BsMonoManager.h"
+#include "BsMonoClass.h"
+#include "BsMonoMethod.h"
+#include "BsMonoUtil.h"
+#include "BsScriptSceneObject.h"
+#include "BsScriptGameObjectManager.h"
+#include "BsGUISceneTreeView.h"
+#include "BsGUIResourceTreeView.h"
+#include "BsTime.h"
+
+using namespace std::placeholders;
+
+namespace BansheeEngine
+{
+	ScriptDragDrop::ScriptDragDrop(MonoObject* instance)
+		:ScriptObject(instance)
+	{ }
+
+	void ScriptDragDrop::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_IsDragInProgress", &ScriptDragDrop::internal_IsDragInProgress);
+		metaData.scriptClass->addInternalCall("Internal_IsDropInProgress", &ScriptDragDrop::internal_IsDropInProgress);
+		metaData.scriptClass->addInternalCall("Internal_GetData", &ScriptDragDrop::internal_GetData);
+		metaData.scriptClass->addInternalCall("Internal_StartSceneObjectDrag", &ScriptDragDrop::internal_StartSceneObjectDrag);
+		metaData.scriptClass->addInternalCall("Internal_StartResourceDrag", &ScriptDragDrop::internal_StartResourceDrag);
+	}
+
+	bool ScriptDragDrop::internal_IsDragInProgress()
+	{
+		return DragAndDropManager::instance().isDragInProgress();
+	}
+
+	bool ScriptDragDrop::internal_IsDropInProgress()
+	{
+		return ScriptDragDropManager::instance().isDropInProgress();
+	}
+
+	MonoObject* ScriptDragDrop::internal_GetData()
+	{
+		return ScriptDragDropManager::instance().getDropData();
+	}
+
+	void ScriptDragDrop::internal_StartSceneObjectDrag(ScriptSceneObjectDragDropData* value)
+	{
+		const Vector<HSceneObject>& sceneObjects = value->getSceneObjects();
+		DraggedSceneObjects* draggedSceneObjects = bs_new<DraggedSceneObjects>((UINT32)sceneObjects.size());
+
+		UINT32 idx = 0;
+		for (auto& so : sceneObjects)
+		{
+			draggedSceneObjects->objects[idx] = so;
+			idx++;
+		}
+
+		DragAndDropManager::instance().startDrag((UINT32)DragAndDropType::SceneObject, draggedSceneObjects, nullptr, false);
+	}
+
+	void ScriptDragDrop::internal_StartResourceDrag(ScriptResourceDragDropData* value)
+	{
+		// TODO
+
+	}
+
+	ScriptSceneObjectDragDropData::ScriptSceneObjectDragDropData(MonoObject* instance, const Vector<HSceneObject>& sceneObjects)
+		:ScriptObject(instance), mSceneObjects(sceneObjects)
+	{ }
+
+	void ScriptSceneObjectDragDropData::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptSceneObjectDragDropData::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetObjects", &ScriptSceneObjectDragDropData::internal_GetObjects);
+	}
+
+	MonoObject* ScriptSceneObjectDragDropData::create(const Vector<HSceneObject>& sceneObjects)
+	{
+		ScriptArray arrSceneObjects = ScriptArray::create<ScriptSceneObject>((UINT32)sceneObjects.size());
+
+		UINT32 idx = 0;
+		for (auto& so : sceneObjects)
+		{
+			ScriptSceneObject* scriptSceneObject = ScriptGameObjectManager::instance().getOrCreateScriptSceneObject(so);
+
+			arrSceneObjects.set(idx, scriptSceneObject);
+			idx++;
+		}
+
+		void* params[1] = { arrSceneObjects.getInternal() };
+		MonoObject* instance = metaData.scriptClass->createInstance(params, 1);
+
+		return instance;
+	}
+
+	void ScriptSceneObjectDragDropData::internal_CreateInstance(MonoObject* managedInstance, MonoArray* objects)
+	{
+		ScriptArray objectsArray = ScriptArray(objects);
+
+		Vector<HSceneObject> sceneObjects(objectsArray.size());
+		for (UINT32 i = 0; i < objectsArray.size(); i++)
+		{
+			ScriptSceneObject* scriptSO = ScriptSceneObject::toNative(objectsArray.get<MonoObject*>(i));
+			if (scriptSO != nullptr)
+				sceneObjects[i] = scriptSO->getNativeSceneObject();
+		}
+
+		ScriptSceneObjectDragDropData* nativeInstance = new (bs_alloc<ScriptSceneObjectDragDropData>()) ScriptSceneObjectDragDropData(managedInstance, sceneObjects);
+	}
+
+	MonoArray* ScriptSceneObjectDragDropData::internal_GetObjects(ScriptSceneObjectDragDropData* instance)
+	{
+		ScriptArray objectsArray = ScriptArray::create<ScriptSceneObject>((UINT32)instance->mSceneObjects.size());
+		for (UINT32 i = 0; i < (UINT32)instance->mSceneObjects.size(); i++)
+		{
+			ScriptSceneObject* scriptSO = ScriptGameObjectManager::instance().getOrCreateScriptSceneObject(instance->mSceneObjects[i]);
+
+			if (scriptSO != nullptr)
+				objectsArray.set(i, scriptSO->getManagedInstance());
+		}
+
+		return objectsArray.getInternal();
+	}
+
+	ScriptResourceDragDropData::ScriptResourceDragDropData(MonoObject* instance, const Vector<Path>& paths)
+		:ScriptObject(instance), mPaths(paths)
+	{ }
+
+	void ScriptResourceDragDropData::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptResourceDragDropData::internal_CreateInstance);
+		metaData.scriptClass->addInternalCall("Internal_GetPaths", &ScriptResourceDragDropData::internal_GetPaths);
+	}
+
+	MonoObject* ScriptResourceDragDropData::create(const Vector<Path>& paths)
+	{
+		MonoArray* rawArray = mono_array_new(MonoManager::instance().getDomain(), mono_get_string_class(), (UINT32)paths.size());
+		ScriptArray arrStrings(rawArray);
+
+		UINT32 idx = 0;
+		for (auto& path : paths)
+		{
+			MonoString* managedPath = MonoUtil::wstringToMono(MonoManager::instance().getDomain(), path.toWString());
+
+			arrStrings.set(idx, managedPath);
+			idx++;
+		}
+
+		void* params[1] = { arrStrings.getInternal() };
+		MonoObject* instance = metaData.scriptClass->createInstance(params, 1);
+
+		return instance;
+	}
+
+	void ScriptResourceDragDropData::internal_CreateInstance(MonoObject* managedInstance, MonoArray* monoPaths)
+	{
+		ScriptArray pathsArray = ScriptArray(monoPaths);
+
+		Vector<Path> paths(pathsArray.size());
+		for (UINT32 i = 0; i < pathsArray.size(); i++)
+		{
+			MonoString* monoPath = pathsArray.get<MonoString*>(i);
+			paths[i] = MonoUtil::monoToWString(monoPath);
+		}
+
+		ScriptResourceDragDropData* nativeInstance = new (bs_alloc<ScriptResourceDragDropData>()) ScriptResourceDragDropData(managedInstance, paths);
+	}
+
+	MonoArray* ScriptResourceDragDropData::internal_GetPaths(ScriptResourceDragDropData* instance)
+	{
+		MonoArray* rawArray = mono_array_new(MonoManager::instance().getDomain(),
+			mono_get_string_class(), (UINT32)instance->mPaths.size());
+
+		ScriptArray arrStrings(rawArray);
+
+		UINT32 idx = 0;
+		for (auto& path : instance->mPaths)
+		{
+			MonoString* managedPath = MonoUtil::wstringToMono(MonoManager::instance().getDomain(), path.toWString());
+
+			arrStrings.set(idx, managedPath);
+			idx++;
+		}
+
+		return arrStrings.getInternal();
+	}
+
+	ScriptDragDropManager::ScriptDragDropManager()
+		:mDroppedFrameIdx(0), mIsDropInProgress(false), mDropType(ScriptDragDropType::None)
+	{
+		mDragEndedConn = DragAndDropManager::instance().onDragEnded.connect(std::bind(&ScriptDragDropManager::onMouseDragEnded, this, _1, _2));
+	}
+
+	ScriptDragDropManager::~ScriptDragDropManager()
+	{
+		mDragEndedConn.disconnect();
+	}
+
+	void ScriptDragDropManager::update()
+	{
+		// This only stays active for a single frame
+		if (mIsDropInProgress && mDroppedFrameIdx < Time::instance().getFrameNumber())
+			mIsDropInProgress = false;
+	}
+
+	MonoObject* ScriptDragDropManager::getDropData() const
+	{
+		if (mDropType == ScriptDragDropType::SceneObject)
+			return ScriptSceneObjectDragDropData::create(mDroppedSceneObjects);
+		else if (mDropType == ScriptDragDropType::Resource)
+			return ScriptResourceDragDropData::create(mDroppedPaths);
+
+		return nullptr;
+	}
+
+	void ScriptDragDropManager::onMouseDragEnded(const PointerEvent& evt, DragCallbackInfo& callbackInfo)
+	{
+		if (!DragAndDropManager::instance().isDragInProgress())
+			return;
+
+		mDroppedPaths.clear();
+		mDroppedSceneObjects.clear();
+		mIsDropInProgress = false;
+		mDropType = ScriptDragDropType::None;
+		
+		UINT32 nativeType = DragAndDropManager::instance().getDragTypeId();
+
+		if (nativeType == (UINT32)DragAndDropType::SceneObject)
+		{
+			DraggedSceneObjects* draggedSceneObjects = reinterpret_cast<DraggedSceneObjects*>(DragAndDropManager::instance().getDragData());
+
+			for (UINT32 i = 0; i < draggedSceneObjects->numObjects; i++)
+				mDroppedSceneObjects.push_back(draggedSceneObjects->objects[i]);
+
+			mIsDropInProgress = true;
+			mDropType = ScriptDragDropType::SceneObject;
+			mDroppedFrameIdx = Time::instance().getFrameNumber();
+		}
+		else if (nativeType == (UINT32)DragAndDropType::Resources)
+		{
+			DraggedResources* draggedResources = reinterpret_cast<DraggedResources*>(DragAndDropManager::instance().getDragData());
+
+			// TODO - When dragging resources I also need to support dragging of resource folders, which isn't supported by this system
+
+			mIsDropInProgress = true;
+			mDropType = ScriptDragDropType::Resource;
+			mDroppedFrameIdx = Time::instance().getFrameNumber();
+		}
+	}
+}

SBansheeEngine/Include/BsScriptGameObjectManager.h

@@ -21,6 +21,7 @@ namespace BansheeEngine
 		ScriptGameObjectManager();
 		~ScriptGameObjectManager();
 
+		ScriptSceneObject* getOrCreateScriptSceneObject(const HSceneObject& sceneObject);
 		ScriptSceneObject* createScriptSceneObject(const HSceneObject& sceneObject);
 		ScriptSceneObject* createScriptSceneObject(MonoObject* existingInstance, const HSceneObject& sceneObject);
 		ScriptComponent* createScriptComponent(MonoObject* existingInstance, const GameObjectHandle<ManagedComponent>& component);

SBansheeEngine/Source/BsScriptGameObjectManager.cpp

@@ -34,6 +34,15 @@ namespace BansheeEngine
 		mOnAssemblyReloadDoneConn.disconnect();
 	}
 
+	ScriptSceneObject* ScriptGameObjectManager::getOrCreateScriptSceneObject(const HSceneObject& sceneObject)
+	{
+		auto findIter = mScriptGameObjects.find(sceneObject.getInstanceId());
+		if (findIter != mScriptGameObjects.end())
+			return static_cast<ScriptSceneObject*>(findIter->second.instance);
+
+		return createScriptSceneObject(sceneObject);
+	}
+
 	ScriptSceneObject* ScriptGameObjectManager::createScriptSceneObject(const HSceneObject& sceneObject)
 	{
 		MonoClass* sceneObjectClass = ScriptAssemblyManager::instance().getSceneObjectClass();

SBansheeEngine/Source/BsScriptTime.cpp

@@ -30,6 +30,6 @@ namespace BansheeEngine
 
 	UINT32 ScriptTime::internal_getFrameNumber()
 	{
-		return gTime().getCurrentFrameNumber();
+		return gTime().getFrameNumber();
 	}
 }

TODO.txt

@@ -11,7 +11,6 @@ C#:
 Dialog.Show(title, text, btn1 text, btn1 callback, btn2 text, btn2 callback, btn3 text, btn3 callback)
 
 ColorPicker
- - Set up proper sizes for elements as it looks pretty shit at the moment
  - Sliders don't show up
 
 Got a crash on shutdown that was caused by locking a mutex in an Event destructor. Event was Platform::onMouseCaptureChanged.