Finding resource dependencies will now properly consider resource handles that aren't loaded yet

When reimporting native resources in project library avoid loading its dependencies because their UUIDs can be changed in case the project library manifest is missing or obsolete
Camera & Renderable now properly restore their serialized data on load
Resolving resource handles to managed object instances now works even if the resource handle hasn't been loaded yet
"New scene" menu item

BansheeCore/Source/BsUtility.cpp

@@ -43,7 +43,7 @@ namespace BansheeEngine
 						for (UINT32 j = 0; j < numElements; j++)
 						{
 							HResource resource = (HResource&)reflectableField->getArrayValue(&obj, j);
-							if (resource != nullptr)
+							if (!resource.getUUID().empty())
 							{
 								ResourceDependency& dependency = dependencies[resource.getUUID()];
 								dependency.resource = resource;
@@ -54,7 +54,7 @@ namespace BansheeEngine
 					else
 					{
 						HResource resource = (HResource&)reflectableField->getValue(&obj);
-						if (resource != nullptr)
+						if (!resource.getUUID().empty())
 						{
 							ResourceDependency& dependency = dependencies[resource.getUUID()];
 							dependency.resource = resource;

BansheeEditor/Source/BsProjectLibrary.cpp

@@ -397,10 +397,12 @@ namespace BansheeEngine
 			{
 				// If meta exists make sure it is registered in the manifest before load, otherwise it will get assigned a new UUID.
 				// This can happen if library isn't properly saved before exiting the application.
-				if (resource->meta != nullptr && !mResourceManifest->uuidExists(resource->meta->getUUID()))
+				if (resource->meta != nullptr)
 					mResourceManifest->registerResource(resource->meta->getUUID(), resource->path);
 
-				importedResource = gResources().load(resource->path);
+				// Don't load dependencies because we don't need them, but also because they might not be in the manifest
+				// which would screw up their UUIDs.
+				importedResource = gResources().load(resource->path, false);
 			}
 
 			if(resource->meta == nullptr)
@@ -444,7 +446,6 @@ namespace BansheeEngine
 					FileSystem::createDir(internalResourcesPath);
 
 				internalResourcesPath.setFilename(toWString(importedResource.getUUID()) + L".asset");
-
 				gResources().save(importedResource, internalResourcesPath, true);
 
 				if (!isNativeResource)
@@ -1233,7 +1234,10 @@ namespace BansheeEngine
 		{
 			String uuid = file.getFilename(false);
 			if (mUUIDToPath.find(uuid) == mUUIDToPath.end())
+			{
+				mResourceManifest->unregisterResource(uuid);
 				toDelete.push_back(file);
+			}
 
 			return true;
 		};

MBansheeEditor/EditorApplication.cs

@@ -187,11 +187,20 @@ namespace BansheeEditor
             codeManager.Update();
         }
 
+        /// <summary>
+        /// Creates a new empty scene.
+        /// </summary>
+        [MenuItem("File/New Scene", 10051, true)]
+        private static void NewScene()
+        {
+            LoadScene(null);
+        }
+
         /// <summary>
         /// Opens a dialog that allows the user to select a new prefab to load as the current scene. If current scene
         /// is modified the user is offered a chance to save it.
         /// </summary>
-        [MenuItem("File/Open Scene", ButtonModifier.Ctrl, ButtonCode.L, 10050, true)]
+        [MenuItem("File/Open Scene", ButtonModifier.Ctrl, ButtonCode.L, 10050)]
         private static void LoadScene()
         {
             string[] scenePaths;
@@ -248,13 +257,18 @@ namespace BansheeEditor
         /// Loads a prefab as the current scene at the specified path. If current scene is modified the user is offered a 
         /// chance to save it.
         /// </summary>
-        /// <param name="path">Path to a valid prefab relative to the resource folder.</param>
+        /// <param name="path">Path to a valid prefab relative to the resource folder. If path is empty a brand new
+        ///                    scene will be loaded.</param>
         public static void LoadScene(string path)
         {
             Action<string> continueLoad =
                 (scenePath) =>
                 {
-                    Scene.Load(path);
+                    if (string.IsNullOrEmpty(path))
+                        Scene.Clear();
+                    else
+                        Scene.Load(path);
+
                     SetSceneDirty(false);
 
                     ProjectSettings.LastOpenScene = scenePath;

MBansheeEngine/Camera.cs

@@ -340,20 +340,6 @@ namespace BansheeEngine
         /// <returns>3D point in view space.</returns>
         public Vector3 UnprojectPoint(Vector3 value) { return native.UnprojectPoint(value); }
 
-        private void OnInitialize()
-        {
-            serializableData.aspectRatio = 1.333f;
-            serializableData.nearClipPlane = 1.0f;
-            serializableData.farClipPlane = 1000.0f;
-            serializableData.fieldOfView = new Degree(60);
-            serializableData.viewportRect = new Rect2(0, 0, 1, 1);
-            serializableData.projectionType = ProjectionType.Perspective;
-            serializableData.layers = 0xFFFFFFFFFFFFFFFF;
-            serializableData.clearColor = new Color(143.0f / 255.0f, 111.0f / 255.0f, 0);
-            serializableData.clearDepth = 1.0f;
-            serializableData.clearFlags = ClearFlags.Color | ClearFlags.Depth | ClearFlags.Stencil;
-        }
-
         private void OnReset()
         {
             if (native != null)
@@ -393,21 +379,21 @@ namespace BansheeEngine
         /// Holds all data the camera component needs to persist through serialization.
         /// </summary>
         [SerializeObject]
-        internal struct SerializableData
+        internal class SerializableData
         {
-            public float aspectRatio;
-            public float nearClipPlane;
-            public float farClipPlane;
-            public Degree fieldOfView;
-            public Rect2 viewportRect;
-            public ProjectionType projectionType;
+            public float aspectRatio = 1.333f;
+            public float nearClipPlane = 1.0f;
+            public float farClipPlane = 1000.0f;
+            public Degree fieldOfView = new Degree(60);
+            public Rect2 viewportRect = new Rect2(0, 0, 1, 1);
+            public ProjectionType projectionType = ProjectionType.Perspective;
             public float orthoHeight;
-            public Color clearColor;
-            public float clearDepth;
+            public Color clearColor = new Color(143.0f / 255.0f, 111.0f / 255.0f, 0);
+            public float clearDepth = 1.0f;
             public UInt16 clearStencil;
-            public ClearFlags clearFlags;
+            public ClearFlags clearFlags = ClearFlags.Color | ClearFlags.Depth | ClearFlags.Stencil;
             public int priority;
-            public UInt64 layers;
+            public UInt64 layers = 0xFFFFFFFFFFFFFFFF;
         }
     }
 }

MBansheeEngine/Renderable.cs

@@ -108,12 +108,6 @@ namespace BansheeEngine
             get { return _native.GetBounds(SceneObject); }
         }
 
-        private void OnInitialize()
-        {
-            serializableData.materials = new Material[0];
-            serializableData.layers = 1;
-        }
-
         private void OnReset()
         {
             if (_native != null)
@@ -147,11 +141,11 @@ namespace BansheeEngine
         /// Holds all data the renderable component needs to persist through serialization.
         /// </summary>
         [SerializeObject]
-        private struct SerializableData
+        private class SerializableData
         {
             public Mesh mesh;
-            public Material[] materials;
-            public UInt64 layers;
+            public Material[] materials = new Material[0];
+            public UInt64 layers = 1;
         }
     }
 }

SBansheeEngine/Include/BsManagedSerializableFieldRTTI.h

@@ -23,18 +23,18 @@ namespace BansheeEngine
 			addPlainField("mFieldId", 1, &ManagedSerializableFieldKeyRTTI::getFieldId, &ManagedSerializableFieldKeyRTTI::setFieldId);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldKey";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldKey;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldKey>();
 		}
@@ -50,18 +50,18 @@ namespace BansheeEngine
 
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldData";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldData;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			BS_EXCEPT(InvalidStateException, "Cannot instantiate an abstract class.");
 		}
@@ -83,18 +83,18 @@ namespace BansheeEngine
 			addReflectablePtrField("mValue", 1, &ManagedSerializableFieldDataEntryRTTI::getValue, &ManagedSerializableFieldDataEntryRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataEntry";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataEntry;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataEntry>();
 		}
@@ -112,18 +112,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataBoolRTTI::getValue, &ManagedSerializableFieldDataBoolRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataBool";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataBool;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataBool>();
 		}
@@ -141,18 +141,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataCharRTTI::getValue, &ManagedSerializableFieldDataCharRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataChar";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataChar;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataBool>();
 		}
@@ -170,18 +170,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataI8RTTI::getValue, &ManagedSerializableFieldDataI8RTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataI8";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataI8;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataI8>();
 		}
@@ -199,18 +199,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataU8RTTI::getValue, &ManagedSerializableFieldDataU8RTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataU8";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataU8;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataU8>();
 		}
@@ -228,18 +228,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataI16RTTI::getValue, &ManagedSerializableFieldDataI16RTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataI16";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataI16;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataI16>();
 		}
@@ -257,18 +257,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataU16RTTI::getValue, &ManagedSerializableFieldDataU16RTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataU16";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataU16;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataU16>();
 		}
@@ -286,18 +286,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataI32RTTI::getValue, &ManagedSerializableFieldDataI32RTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataI32";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataI32;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataI32>();
 		}
@@ -315,18 +315,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataU32RTTI::getValue, &ManagedSerializableFieldDataU32RTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataU32";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataU32;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataU32>();
 		}
@@ -344,18 +344,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataI64RTTI::getValue, &ManagedSerializableFieldDataI64RTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataI64";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataI64;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataI64>();
 		}
@@ -373,18 +373,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataU64RTTI::getValue, &ManagedSerializableFieldDataU64RTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataU64";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataU64;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataU64>();
 		}
@@ -402,18 +402,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataFloatRTTI::getValue, &ManagedSerializableFieldDataFloatRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataFloat";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataFloat;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataFloat>();
 		}
@@ -431,18 +431,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataDoubleRTTI::getValue, &ManagedSerializableFieldDataDoubleRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataDouble";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataDouble;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataDouble>();
 		}
@@ -460,18 +460,18 @@ namespace BansheeEngine
 			addPlainField("mValue", 0, &ManagedSerializableFieldDataStringRTTI::getValue, &ManagedSerializableFieldDataStringRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataString";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataString;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataString>();
 		}
@@ -481,7 +481,7 @@ namespace BansheeEngine
 	{
 	private:
 		HResource& getValue(ManagedSerializableFieldDataResourceRef* obj) { return obj->value; }
-		void setValue(ManagedSerializableFieldDataResourceRef* obj, HResource& val) { obj->value = val; }
+		void setValue(ManagedSerializableFieldDataResourceRef* obj, HResource& val) { obj->value = HResource(val); }
 
 	public:
 		ManagedSerializableFieldDataResourceRefRTTI()
@@ -489,18 +489,18 @@ namespace BansheeEngine
 			addReflectableField("mValue", 0, &ManagedSerializableFieldDataResourceRefRTTI::getValue, &ManagedSerializableFieldDataResourceRefRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataResourceRef";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataResourceRef;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataResourceRef>();
 		}
@@ -518,18 +518,18 @@ namespace BansheeEngine
 			addReflectableField("mValue", 0, &ManagedSerializableFieldDataGameObjectRefRTTI::getValue, &ManagedSerializableFieldDataGameObjectRefRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataGameObjectRef";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataGameObjectRef;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataGameObjectRef>();
 		}
@@ -547,18 +547,18 @@ namespace BansheeEngine
 			addReflectablePtrField("mValue", 0, &ManagedSerializableFieldDataObjectRTTI::getValue, &ManagedSerializableFieldDataObjectRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataObject";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataObject;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataObject>();
 		}
@@ -576,18 +576,18 @@ namespace BansheeEngine
 			addReflectablePtrField("mValue", 0, &ManagedSerializableFieldDataArrayRTTI::getValue, &ManagedSerializableFieldDataArrayRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataArray";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataArray;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataArray>();
 		}
@@ -605,18 +605,18 @@ namespace BansheeEngine
 			addReflectablePtrField("mValue", 0, &ManagedSerializableFieldDataListRTTI::getValue, &ManagedSerializableFieldDataListRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataList";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataList;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataList>();
 		}
@@ -634,18 +634,18 @@ namespace BansheeEngine
 			addReflectablePtrField("mValue", 0, &ManagedSerializableFieldDataDictionaryRTTI::getValue, &ManagedSerializableFieldDataDictionaryRTTI::setValue);
 		}
 
-		virtual const String& getRTTIName()
+		virtual const String& getRTTIName() override
 		{
 			static String name = "SerializableFieldDataDictionary";
 			return name;
 		}
 
-		virtual UINT32 getRTTIId()
+		virtual UINT32 getRTTIId() override
 		{
 			return TID_SerializableFieldDataDictionary;
 		}
 
-		virtual std::shared_ptr<IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject() override
 		{
 			return bs_shared_ptr_new<ManagedSerializableFieldDataDictionary>();
 		}

SBansheeEngine/Source/BsManagedSerializableField.cpp

@@ -617,7 +617,7 @@ namespace BansheeEngine
 
 			if(primitiveTypeInfo->mType == ScriptPrimitiveType::Texture2DRef)
 			{
-				if(value)
+				if(!value.getUUID().empty())
 				{
 					HTexture texture = static_resource_cast<Texture>(value);
 
@@ -631,7 +631,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::Texture3DRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HTexture texture = static_resource_cast<Texture>(value);
 
@@ -645,7 +645,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::TextureCubeRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HTexture texture = static_resource_cast<Texture>(value);
 
@@ -659,7 +659,7 @@ namespace BansheeEngine
 			}
 			else if(primitiveTypeInfo->mType == ScriptPrimitiveType::SpriteTextureRef)
 			{
-				if(value)
+				if (!value.getUUID().empty())
 				{
 					HSpriteTexture spriteTexture = static_resource_cast<SpriteTexture>(value);
 
@@ -674,7 +674,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::ShaderRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HShader shader = static_resource_cast<Shader>(value);
 
@@ -689,7 +689,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::ShaderIncludeRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HShaderInclude shader = static_resource_cast<ShaderInclude>(value);
 
@@ -704,7 +704,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::MaterialRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HMaterial material = static_resource_cast<Material>(value);
 
@@ -719,7 +719,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::MeshRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HMesh mesh = static_resource_cast<Mesh>(value);
 
@@ -734,7 +734,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::PlainTextRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HPlainText plainText = static_resource_cast<PlainText>(value);
 
@@ -749,7 +749,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::ScriptCodeRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HScriptCode scriptCode = static_resource_cast<ScriptCode>(value);
 
@@ -764,7 +764,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::PrefabRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HPrefab prefab = static_resource_cast<Prefab>(value);
 
@@ -779,7 +779,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::FontRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HFont font = static_resource_cast<Font>(value);
 
@@ -794,7 +794,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::StringTableRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HStringTable stringTable = static_resource_cast<StringTable>(value);
 
@@ -809,7 +809,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::GUISkinRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HGUISkin guiSkin = static_resource_cast<GUISkin>(value);
 
@@ -824,7 +824,7 @@ namespace BansheeEngine
 			}
 			else if (primitiveTypeInfo->mType == ScriptPrimitiveType::ManagedResourceRef)
 			{
-				if (value)
+				if (!value.getUUID().empty())
 				{
 					HManagedResource managedResource = static_resource_cast<ManagedResource>(value);
 

TODO.txt

@@ -31,16 +31,12 @@ Other polish:
    - Custom inspectors can get rid of manual "isExpanded" bools and use the dictionary instead
 
 Stage 2 polish:
- - Prefabs
  - Game window
  - Game play/pause/step (+ save/restore objects on play/pause switch)
  - Resource hotswap
- - C# script compiling in editor
- - VS integration
  - When managed exception happens log an error and continue execution
   - Doing a pass over all methods referencing Internal_ methods ensuring they do proper checking on C# side would be good
  - Game publishing (Build window, collect resources, output exe, default viewport) (described below)
- - Settings/Preferences window (+ menu entry)
  - Console window
 
 Optional: