Dirty project resources now persist assembly refresh

Assembly refresh no longer causes the active scene link to resource to be lost
Don't mark the scene as dirty when just dragging a mesh/prefab over it (without dropping it)

MBansheeEditor/EditorApplication.cs

@@ -219,18 +219,28 @@ namespace BansheeEditor
         private static EditorApplication instance;
         private static FolderMonitor monitor;
         private static ScriptCodeManager codeManager;
-        private static HashSet<string> dirtyResources = new HashSet<string>();
         private static bool sceneDirty;
         private static bool unitTestsExecuted;
+        private static EditorPersistentData persistentData;
 
         /// <summary>
-        /// Constructs a new editor application. Called at editor start-up by the runtime.
+        /// Constructs a new editor application. Called at editor start-up by the runtime, and any time assembly refresh
+        /// occurrs.
         /// </summary>
         internal EditorApplication()
         {
             instance = this;
             codeManager = new ScriptCodeManager();
 
+            const string soName = "EditorPersistentData";
+            SceneObject so = Scene.Root.FindChild(soName);
+            if (so == null)
+                so = new SceneObject(soName, true);
+
+            persistentData = so.GetComponent<EditorPersistentData>();
+            if (persistentData == null)
+                persistentData = so.AddComponent<EditorPersistentData>();
+
             // Register controls
             InputConfiguration inputConfig = VirtualInput.KeyConfig;
 
@@ -481,8 +491,9 @@ namespace BansheeEditor
         [ToolbarItem("Save Project", ToolbarIcon.SaveProject, "Save project", 1999)]
         public static void SaveProject()
         {
-            foreach (var resourceUUID in dirtyResources)
+            foreach (var KVP in persistentData.dirtyResources)
             {
+                string resourceUUID = KVP.Key;
                 string path = ProjectLibrary.GetPath(resourceUUID);
                 if (!IsNative(path))
                     continue; // Native resources can't be changed
@@ -492,8 +503,8 @@ namespace BansheeEditor
                 if(resource != null)
                     ProjectLibrary.Save(resource);
             }
-                
-            dirtyResources.Clear();
+
+            persistentData.dirtyResources.Clear();
             SetStatusProject(false);
 
             Internal_SaveProject();
@@ -558,7 +569,7 @@ namespace BansheeEditor
                 return;
 
             SetStatusProject(true);
-            dirtyResources.Add(resource.UUID);
+            persistentData.dirtyResources[resource.UUID] = true;
         }
 
         /// <summary>
@@ -579,7 +590,7 @@ namespace BansheeEditor
             SetStatusScene(Scene.ActiveSceneName, dirty);
 
             if (!dirty)
-                dirtyResources.Remove(Scene.ActiveSceneUUID);
+                persistentData.dirtyResources.Remove(Scene.ActiveSceneUUID);
         }
 
         /// <summary>
@@ -589,7 +600,7 @@ namespace BansheeEditor
         /// <returns>True if the resource requires saving, false otherwise.</returns>
         public static bool IsDirty(Resource resource)
         {
-            return dirtyResources.Contains(resource.UUID);
+            return persistentData.dirtyResources.ContainsKey(resource.UUID);
         }
 
         /// <summary>

MBansheeEditor/EditorPersistentData.cs

@@ -0,0 +1,16 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+using BansheeEngine;
+using System.Collections.Generic;
+
+namespace BansheeEditor
+{
+    /// <summary>
+    /// Contains editor data that should persist assembly refresh.
+    /// </summary>
+    internal class EditorPersistentData : Component
+    {
+        [SerializeField]
+        internal Dictionary<string, bool> dirtyResources = new Dictionary<string, bool>();
+    }
+}

MBansheeEditor/Inspectors/MaterialInspector.cs

@@ -1,608 +1,609 @@
 //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-using System.Collections.Generic;
-using BansheeEngine;
-
-namespace BansheeEditor
-{
-    /// <summary>
-    /// Renders an inspector for the <see cref="Material"/> resource.
-    /// </summary>
-    [CustomInspector(typeof (Material))]
-    internal class MaterialInspector : Inspector
-    {
-        private MaterialParamGUI[] guiParams;
-        private GUIResourceField shaderField;
-
-        /// <inheritdoc/>
-        protected internal override void Initialize()
-        {
-            Material material = InspectedObject as Material;
-            if (material == null)
-                return;
-
-            shaderField = new GUIResourceField(typeof(Shader), new LocEdString("Shader"));
-            shaderField.Value = material.Shader;
-            shaderField.OnChanged += (x) =>
-            {
-                Shader shader = Resources.Load<Shader>(x);
-
-                material.Shader = shader;
-                RebuildParamGUI(material);
-            };
-
-            Layout.AddElement(shaderField);
-
-            RebuildParamGUI(material);
-        }
-
-        /// <inheritdoc/>
-        protected internal override InspectableState Refresh()
-        {
-            Material material = InspectedObject as Material;
-            if (material == null)
-                return InspectableState.NotModified;
-
-            if (material.Shader != shaderField.Value)
-            {
-                shaderField.Value = material.Shader;
-                RebuildParamGUI(material);
-            }
-
-            if (guiParams != null)
-            {
-                foreach (var param in guiParams)
-                    param.Refresh(material);
-            }
-
-            return InspectableState.NotModified;
-        }
-
-        /// <summary>
-        /// Recreates GUI elements for all material parameters.
-        /// </summary>
-        /// <param name="material">Material to create parameters for</param>
-        private void RebuildParamGUI(Material material)
-        {
-            if (guiParams != null)
-            {
-                foreach (var param in guiParams)
-                    param.Destroy();
-
-                guiParams = null;
-            }
-
-            if (material != null && material.Shader != null)
-                guiParams = CreateMaterialGUI(material, Layout);
-        }
-
-
-        /// <summary>
-        /// Creates a set of objects in which each object represents a GUI for a material parameter.
-        /// </summary>
-        /// <param name="mat">Material for whose parameters to create GUI for.</param>
-        /// <param name="layout">Layout to add the parameter GUI elements to.</param>
-        /// <returns>A material parameter GUI object for each supported material parameter.</returns>
-        static internal MaterialParamGUI[] CreateMaterialGUI(Material mat, GUILayout layout)
-        {
-            Shader shader = mat.Shader;
-            if (shader == null)
-                return new MaterialParamGUI[0];
-
-            List<MaterialParamGUI> guiParams = new List<MaterialParamGUI>();
-            ShaderParameter[] shaderParams = shader.Parameters;
-
-            foreach (var param in shaderParams)
-            {
-                if (param.Internal)
-                    continue;
-
-                switch (param.Type)
-                {
-                    case ShaderParameterType.Float:
-                        layout.AddSpace(5);
-                        guiParams.Add(new MaterialParamFloatGUI(param, mat, layout));
-                        break;
-                    case ShaderParameterType.Vector2:
-                        layout.AddSpace(5);
-                        guiParams.Add(new MaterialParamVec2GUI(param, mat, layout));
-                        break;
-                    case ShaderParameterType.Vector3:
-                        layout.AddSpace(5);
-                        guiParams.Add(new MaterialParamVec3GUI(param, mat, layout));
-                        break;
-                    case ShaderParameterType.Vector4:
-                        layout.AddSpace(5);
-                        guiParams.Add(new MaterialParamVec4GUI(param, mat, layout));
-                        break;
-                    case ShaderParameterType.Matrix3:
-                        layout.AddSpace(5);
-                        guiParams.Add(new MaterialParamMat3GUI(param, mat, layout));
-                        break;
-                    case ShaderParameterType.Matrix4:
-                        layout.AddSpace(5);
-                        guiParams.Add(new MaterialParamMat4GUI(param, mat, layout));
-                        break;
-                    case ShaderParameterType.Color:
-                        layout.AddSpace(5);
-                        guiParams.Add(new MaterialParamColorGUI(param, mat, layout));
-                        break;
-                    case ShaderParameterType.Texture2D:
-                    case ShaderParameterType.Texture3D:
-                    case ShaderParameterType.TextureCube:
-                        layout.AddSpace(5);
-                        guiParams.Add(new MaterialParamTextureGUI(param, mat, layout));
-                        break;
-                }
-            }
-
-            return guiParams.ToArray();
-        }
-    }
-
-    /// <summary>
-    /// Contains GUI element(s) for a single parameter in a <see cref="Material"/>.
-    /// </summary>
-    internal abstract class MaterialParamGUI
-    {
-        protected ShaderParameter shaderParam;
-
-        /// <summary>
-        /// Creates a new material parameter GUI.
-        /// </summary>
-        /// <param name="shaderParam">Shader parameter to create the GUI for.</param>
-        protected MaterialParamGUI(ShaderParameter shaderParam)
-        {
-            this.shaderParam = shaderParam;
-        }
-
-        /// <summary>
-        /// Checks if the data stored in GUI and in the material matches, and updates the GUI if it doesn't.
-        /// </summary>
-        /// <param name="material">Material whose data to check.</param>
-        internal abstract void Refresh(Material material);
-
-        /// <summary> 
-        /// Destroys the internal GUI elements.
-        /// </summary>
-        internal abstract void Destroy();
-    }
-
-    /// <summary>
-    /// Contains GUI element(s) for a single floating point parameter in a <see cref="Material"/>.
-    /// </summary>
-    internal class MaterialParamFloatGUI : MaterialParamGUI
-    {
-        private GUIFloatField guiElem;
-
-        /// <summary>
-        /// Creates a new material parameter GUI.
-        /// </summary>
-        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of floating point type.</param>
-        /// <param name="material">Material the parameter is a part of.</param>
-        /// <param name="layout">Layout to append the GUI elements to.</param>
-        internal MaterialParamFloatGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
-            : base(shaderParam)
-        {
-            LocString title = new LocEdString(shaderParam.Name);
-            guiElem = new GUIFloatField(title);
-            guiElem.OnChanged += (x) =>
-            {
-                material.SetFloat(shaderParam.Name, x);
-                EditorApplication.SetDirty(material);
-            };
-
-            layout.AddElement(guiElem);
-        }
-
-        /// <inheritdoc/>
-        internal override void Refresh(Material material)
-        {
-            guiElem.Value = material.GetFloat(shaderParam.Name);
-        }
-
-        /// <inheritdoc/>
-        internal override void Destroy()
-        {
-            guiElem.Destroy();
-        }
-    }
-
-    /// <summary>
-    /// Contains GUI element(s) for a single 2D vector parameter in a <see cref="Material"/>.
-    /// </summary>
-    internal class MaterialParamVec2GUI : MaterialParamGUI
-    {
-        private GUIVector2Field guiElem;
-
-        /// <summary>
-        /// Creates a new material parameter GUI.
-        /// </summary>
-        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 2D vector type.</param>
-        /// <param name="material">Material the parameter is a part of.</param>
-        /// <param name="layout">Layout to append the GUI elements to.</param>
-        internal MaterialParamVec2GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
-            : base(shaderParam)
-        {
-            LocString title = new LocEdString(shaderParam.Name);
-            guiElem = new GUIVector2Field(title);
-            guiElem.OnChanged += (x) =>
-            {
-                material.SetVector2(shaderParam.Name, x);
-                EditorApplication.SetDirty(material);
-            };
-
-            layout.AddElement(guiElem);
-        }
-
-        /// <inheritdoc/>
-        internal override void Refresh(Material material)
-        {
-            guiElem.Value = material.GetVector2(shaderParam.Name);
-        }
-
-        /// <inheritdoc/>
-        internal override void Destroy()
-        {
-            guiElem.Destroy();
-        }
-    }
-
-    /// <summary>
-    /// Contains GUI element(s) for a single 3D vector parameter in a <see cref="Material"/>.
-    /// </summary>
-    internal class MaterialParamVec3GUI : MaterialParamGUI
-    {
-        private GUIVector3Field guiElem;
-
-        /// <summary>
-        /// Creates a new material parameter GUI.
-        /// </summary>
-        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 3D vector type.</param>
-        /// <param name="material">Material the parameter is a part of.</param>
-        /// <param name="layout">Layout to append the GUI elements to.</param>
-        internal MaterialParamVec3GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
-            : base(shaderParam)
-        {
-            LocString title = new LocEdString(shaderParam.Name);
-            guiElem = new GUIVector3Field(title);
-            guiElem.OnChanged += (x) =>
-            {
-                material.SetVector3(shaderParam.Name, x);
-                EditorApplication.SetDirty(material);
-            };
-
-            layout.AddElement(guiElem);
-        }
-
-        /// <inheritdoc/>
-        internal override void Refresh(Material material)
-        {
-            guiElem.Value = material.GetVector3(shaderParam.Name);
-        }
-
-        /// <inheritdoc/>
-        internal override void Destroy()
-        {
-            guiElem.Destroy();
-        }
-    }
-
-    /// <summary>
-    /// Contains GUI element(s) for a single 4D vector parameter in a <see cref="Material"/>.
-    /// </summary>
-    internal class MaterialParamVec4GUI : MaterialParamGUI
-    {
-        private GUIVector4Field guiElem;
-
-        /// <summary>
-        /// Creates a new material parameter GUI.
-        /// </summary>
-        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 4D vector type.</param>
-        /// <param name="material">Material the parameter is a part of.</param>
-        /// <param name="layout">Layout to append the GUI elements to.</param>
-        internal MaterialParamVec4GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
-            : base(shaderParam)
-        {
-            LocString title = new LocEdString(shaderParam.Name);
-            guiElem = new GUIVector4Field(title);
-            guiElem.OnChanged += (x) =>
-            {
-                material.SetVector4(shaderParam.Name, x);
-                EditorApplication.SetDirty(material);
-            };
-
-            layout.AddElement(guiElem);
-        }
-
-        /// <inheritdoc/>
-        internal override void Refresh(Material material)
-        {
-            guiElem.Value = material.GetVector4(shaderParam.Name);
-        }
-
-        /// <inheritdoc/>
-        internal override void Destroy()
-        {
-            guiElem.Destroy();
-        }
-    }
-
-    /// <summary>
-    /// Contains GUI element(s) for a single 3x3 matrix parameter in a <see cref="Material"/>.
-    /// </summary>
-    internal class MaterialParamMat3GUI : MaterialParamGUI
-    {
-        private const int MAT_SIZE = 3;
-
-        private GUILayout mainLayout;
-        private GUIFloatField[] guiMatFields = new GUIFloatField[MAT_SIZE * MAT_SIZE];
-
-        /// <summary>
-        /// Creates a new material parameter GUI.
-        /// </summary>
-        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 3x3 matrix type.</param>
-        /// <param name="material">Material the parameter is a part of.</param>
-        /// <param name="layout">Layout to append the GUI elements to.</param>
-        internal MaterialParamMat3GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
-            : base(shaderParam)
-        {
-            LocString title = new LocEdString(shaderParam.Name);
-            GUILabel guiTitle = new GUILabel(title, GUIOption.FixedWidth(100));
-
-            mainLayout = layout.AddLayoutY();
-            GUILayoutX titleLayout = mainLayout.AddLayoutX();
-            titleLayout.AddElement(guiTitle);
-            titleLayout.AddFlexibleSpace();
-
-            GUILayoutY contentLayout = mainLayout.AddLayoutY();
-
-            GUILayoutX[] rows = new GUILayoutX[MAT_SIZE];
-            for (int i = 0; i < rows.Length; i++)
-                rows[i] = contentLayout.AddLayoutX();
-
-            for (int row = 0; row < MAT_SIZE; row++)
-            {
-                for (int col = 0; col < MAT_SIZE; col++)
-                {
-                    int index = row * MAT_SIZE + col;
-                    guiMatFields[index] = new GUIFloatField(row + "," + col, 20, "", GUIOption.FixedWidth(80));
-
-                    GUIFloatField field = guiMatFields[index];
-                    rows[row].AddElement(field);
-                    rows[row].AddSpace(5);
-
-                    int hoistedRow = row;
-                    int hoistedCol = col;
-                    field.OnChanged += (x) =>
-                    {
-                        Matrix3 value = material.GetMatrix3(shaderParam.Name);
-                        value[hoistedRow, hoistedCol] = x;
-                        material.SetMatrix3(shaderParam.Name, value);
-                        EditorApplication.SetDirty(material);
-                    };
-                }
-            }
-        }
-
-        /// <inheritdoc/>
-        internal override void Refresh(Material material)
-        {
-            Matrix3 value = material.GetMatrix3(shaderParam.Name);
-
-            for (int row = 0; row < MAT_SIZE; row++)
-            {
-                for (int col = 0; col < MAT_SIZE; col++)
-                {
-                    int index = row * MAT_SIZE + col;
-                    guiMatFields[index].Value = value[row, col];
-                }
-            }
-        }
-
-        /// <inheritdoc/>
-        internal override void Destroy()
-        {
-            mainLayout.Destroy();
-        }
-    }
-
-    /// <summary>
-    /// Contains GUI element(s) for a single 4x4 matrix parameter in a <see cref="Material"/>.
-    /// </summary>
-    internal class MaterialParamMat4GUI : MaterialParamGUI
-    {
-        private const int MAT_SIZE = 4;
-
-        private GUILayout mainLayout;
-        private GUIFloatField[] guiMatFields = new GUIFloatField[MAT_SIZE * MAT_SIZE];
-
-        /// <summary>
-        /// Creates a new material parameter GUI.
-        /// </summary>
-        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 4x4 matrix type.</param>
-        /// <param name="material">Material the parameter is a part of.</param>
-        /// <param name="layout">Layout to append the GUI elements to.</param>
-        internal MaterialParamMat4GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
-            : base(shaderParam)
-        {
-            LocString title = new LocEdString(shaderParam.Name);
-            GUILabel guiTitle = new GUILabel(title, GUIOption.FixedWidth(100));
-
-            mainLayout = layout.AddLayoutY();
-            GUILayoutX titleLayout = mainLayout.AddLayoutX();
-            titleLayout.AddElement(guiTitle);
-            titleLayout.AddFlexibleSpace();
-
-            GUILayoutY contentLayout = mainLayout.AddLayoutY();
-
-            GUILayoutX[] rows = new GUILayoutX[MAT_SIZE];
-            for (int i = 0; i < rows.Length; i++)
-                rows[i] = contentLayout.AddLayoutX();
-
-            for (int row = 0; row < MAT_SIZE; row++)
-            {
-                for (int col = 0; col < MAT_SIZE; col++)
-                {
-                    int index = row * MAT_SIZE + col;
-                    guiMatFields[index] = new GUIFloatField(row + "," + col, 20, "", GUIOption.FixedWidth(80));
-
-                    GUIFloatField field = guiMatFields[index];
-                    rows[row].AddElement(field);
-                    rows[row].AddSpace(5);
-
-                    int hoistedRow = row;
-                    int hoistedCol = col;
-                    field.OnChanged += (x) =>
-                    {
-                        Matrix4 value = material.GetMatrix4(shaderParam.Name);
-                        value[hoistedRow, hoistedCol] = x;
-                        material.SetMatrix4(shaderParam.Name, value);
-                        EditorApplication.SetDirty(material);
-                    };
-                }
-            }
-        }
-
-        /// <inheritdoc/>
-        internal override void Refresh(Material material)
-        {
-            Matrix4 value = material.GetMatrix4(shaderParam.Name);
-
-            for (int row = 0; row < MAT_SIZE; row++)
-            {
-                for (int col = 0; col < MAT_SIZE; col++)
-                {
-                    int index = row * MAT_SIZE + col;
-                    guiMatFields[index].Value = value[row, col];
-                }
-            }
-        }
-
-        /// <inheritdoc/>
-        internal override void Destroy()
-        {
-            mainLayout.Destroy();
-        }
-    }
-
-    /// <summary>
-    /// Contains GUI element(s) for a single color parameter in a <see cref="Material"/>.
-    /// </summary>
-    internal class MaterialParamColorGUI : MaterialParamGUI
-    {
-        private GUIColorField guiElem;
-
-        /// <summary>
-        /// Creates a new material parameter GUI.
-        /// </summary>
-        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of color type.</param>
-        /// <param name="material">Material the parameter is a part of.</param>
-        /// <param name="layout">Layout to append the GUI elements to.</param>
-        internal MaterialParamColorGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
-            : base(shaderParam)
-        {
-            LocString title = new LocEdString(shaderParam.Name);
-            guiElem = new GUIColorField(title);
-            guiElem.OnChanged += (x) =>
-            {
-                material.SetColor(shaderParam.Name, x);
-                EditorApplication.SetDirty(material);
-            };
-
-            layout.AddElement(guiElem);
-        }
-
-        /// <inheritdoc/>
-        internal override void Refresh(Material material)
-        {
-            guiElem.Value = material.GetColor(shaderParam.Name);
-        }
-
-        /// <inheritdoc/>
-        internal override void Destroy()
-        {
-            guiElem.Destroy();
-        }
-    }
-
-    /// <summary>
-    /// Contains GUI element(s) for a single texture parameter in a <see cref="Material"/>.
-    /// </summary>
-    internal class MaterialParamTextureGUI : MaterialParamGUI
-    {
-        private GUITextureField guiElem;
-
-        /// <summary>
-        /// Creates a new material parameter GUI.
-        /// </summary>
-        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of texture type.</param>
-        /// <param name="material">Material the parameter is a part of.</param>
-        /// <param name="layout">Layout to append the GUI elements to.</param>
-        internal MaterialParamTextureGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
-            : base(shaderParam)
-        {
-            LocString title = new LocEdString(shaderParam.Name);
-            guiElem = new GUITextureField(title);
-
-            switch (shaderParam.Type)
-            {
-                case ShaderParameterType.Texture2D:
-                    guiElem.OnChanged += (x) =>
-                    {
-                        Texture2D texture = Resources.Load<Texture2D>(x);
-
-                        material.SetTexture2D(shaderParam.Name, texture);
-                        EditorApplication.SetDirty(material);
-                    };
-                    break;
-                case ShaderParameterType.Texture3D:
-                    guiElem.OnChanged += (x) =>
-                    {
-                        Texture3D texture = Resources.Load<Texture3D>(x);
-
-                        material.SetTexture3D(shaderParam.Name, texture);
-                        EditorApplication.SetDirty(material);
-                    };
-                    break;
-                case ShaderParameterType.TextureCube:
-                    guiElem.OnChanged += (x) =>
-                    {
-                        TextureCube texture = Resources.Load<TextureCube>(x);
-
-                        material.SetTextureCube(shaderParam.Name, texture);
-                        EditorApplication.SetDirty(material);
-                    };
-                    break;
-            }
-
-            layout.AddElement(guiElem);
-        }
-
-        /// <inheritdoc/>
-        internal override void Refresh(Material material)
-        {
-            Texture value = null;
-            switch (shaderParam.Type)
-            {
-                case ShaderParameterType.Texture2D:
-                    value = material.GetTexture2D(shaderParam.Name);
-                    break;
-                case ShaderParameterType.Texture3D:
-                    value = material.GetTexture3D(shaderParam.Name);
-                    break;
-                case ShaderParameterType.TextureCube:
-                    value = material.GetTextureCube(shaderParam.Name);
-                    break;
-            }
-
-            guiElem.Value = value;
-        }
-
-        /// <inheritdoc/>
-        internal override void Destroy()
-        {
-            guiElem.Destroy();
-        }
-    }
-}
+using System.Collections.Generic;
+using BansheeEngine;
+
+namespace BansheeEditor
+{
+    /// <summary>
+    /// Renders an inspector for the <see cref="Material"/> resource.
+    /// </summary>
+    [CustomInspector(typeof (Material))]
+    internal class MaterialInspector : Inspector
+    {
+        private MaterialParamGUI[] guiParams;
+        private GUIResourceField shaderField;
+
+        /// <inheritdoc/>
+        protected internal override void Initialize()
+        {
+            Material material = InspectedObject as Material;
+            if (material == null)
+                return;
+
+            shaderField = new GUIResourceField(typeof(Shader), new LocEdString("Shader"));
+            shaderField.Value = material.Shader;
+            shaderField.OnChanged += (x) =>
+            {
+                Shader shader = Resources.Load<Shader>(x);
+
+                material.Shader = shader;
+                EditorApplication.SetDirty(material);
+                RebuildParamGUI(material);
+            };
+
+            Layout.AddElement(shaderField);
+
+            RebuildParamGUI(material);
+        }
+
+        /// <inheritdoc/>
+        protected internal override InspectableState Refresh()
+        {
+            Material material = InspectedObject as Material;
+            if (material == null)
+                return InspectableState.NotModified;
+
+            if (material.Shader != shaderField.Value)
+            {
+                shaderField.Value = material.Shader;
+                RebuildParamGUI(material);
+            }
+
+            if (guiParams != null)
+            {
+                foreach (var param in guiParams)
+                    param.Refresh(material);
+            }
+
+            return InspectableState.NotModified;
+        }
+
+        /// <summary>
+        /// Recreates GUI elements for all material parameters.
+        /// </summary>
+        /// <param name="material">Material to create parameters for</param>
+        private void RebuildParamGUI(Material material)
+        {
+            if (guiParams != null)
+            {
+                foreach (var param in guiParams)
+                    param.Destroy();
+
+                guiParams = null;
+            }
+
+            if (material != null && material.Shader != null)
+                guiParams = CreateMaterialGUI(material, Layout);
+        }
+
+
+        /// <summary>
+        /// Creates a set of objects in which each object represents a GUI for a material parameter.
+        /// </summary>
+        /// <param name="mat">Material for whose parameters to create GUI for.</param>
+        /// <param name="layout">Layout to add the parameter GUI elements to.</param>
+        /// <returns>A material parameter GUI object for each supported material parameter.</returns>
+        static internal MaterialParamGUI[] CreateMaterialGUI(Material mat, GUILayout layout)
+        {
+            Shader shader = mat.Shader;
+            if (shader == null)
+                return new MaterialParamGUI[0];
+
+            List<MaterialParamGUI> guiParams = new List<MaterialParamGUI>();
+            ShaderParameter[] shaderParams = shader.Parameters;
+
+            foreach (var param in shaderParams)
+            {
+                if (param.Internal)
+                    continue;
+
+                switch (param.Type)
+                {
+                    case ShaderParameterType.Float:
+                        layout.AddSpace(5);
+                        guiParams.Add(new MaterialParamFloatGUI(param, mat, layout));
+                        break;
+                    case ShaderParameterType.Vector2:
+                        layout.AddSpace(5);
+                        guiParams.Add(new MaterialParamVec2GUI(param, mat, layout));
+                        break;
+                    case ShaderParameterType.Vector3:
+                        layout.AddSpace(5);
+                        guiParams.Add(new MaterialParamVec3GUI(param, mat, layout));
+                        break;
+                    case ShaderParameterType.Vector4:
+                        layout.AddSpace(5);
+                        guiParams.Add(new MaterialParamVec4GUI(param, mat, layout));
+                        break;
+                    case ShaderParameterType.Matrix3:
+                        layout.AddSpace(5);
+                        guiParams.Add(new MaterialParamMat3GUI(param, mat, layout));
+                        break;
+                    case ShaderParameterType.Matrix4:
+                        layout.AddSpace(5);
+                        guiParams.Add(new MaterialParamMat4GUI(param, mat, layout));
+                        break;
+                    case ShaderParameterType.Color:
+                        layout.AddSpace(5);
+                        guiParams.Add(new MaterialParamColorGUI(param, mat, layout));
+                        break;
+                    case ShaderParameterType.Texture2D:
+                    case ShaderParameterType.Texture3D:
+                    case ShaderParameterType.TextureCube:
+                        layout.AddSpace(5);
+                        guiParams.Add(new MaterialParamTextureGUI(param, mat, layout));
+                        break;
+                }
+            }
+
+            return guiParams.ToArray();
+        }
+    }
+
+    /// <summary>
+    /// Contains GUI element(s) for a single parameter in a <see cref="Material"/>.
+    /// </summary>
+    internal abstract class MaterialParamGUI
+    {
+        protected ShaderParameter shaderParam;
+
+        /// <summary>
+        /// Creates a new material parameter GUI.
+        /// </summary>
+        /// <param name="shaderParam">Shader parameter to create the GUI for.</param>
+        protected MaterialParamGUI(ShaderParameter shaderParam)
+        {
+            this.shaderParam = shaderParam;
+        }
+
+        /// <summary>
+        /// Checks if the data stored in GUI and in the material matches, and updates the GUI if it doesn't.
+        /// </summary>
+        /// <param name="material">Material whose data to check.</param>
+        internal abstract void Refresh(Material material);
+
+        /// <summary> 
+        /// Destroys the internal GUI elements.
+        /// </summary>
+        internal abstract void Destroy();
+    }
+
+    /// <summary>
+    /// Contains GUI element(s) for a single floating point parameter in a <see cref="Material"/>.
+    /// </summary>
+    internal class MaterialParamFloatGUI : MaterialParamGUI
+    {
+        private GUIFloatField guiElem;
+
+        /// <summary>
+        /// Creates a new material parameter GUI.
+        /// </summary>
+        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of floating point type.</param>
+        /// <param name="material">Material the parameter is a part of.</param>
+        /// <param name="layout">Layout to append the GUI elements to.</param>
+        internal MaterialParamFloatGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
+            : base(shaderParam)
+        {
+            LocString title = new LocEdString(shaderParam.Name);
+            guiElem = new GUIFloatField(title);
+            guiElem.OnChanged += (x) =>
+            {
+                material.SetFloat(shaderParam.Name, x);
+                EditorApplication.SetDirty(material);
+            };
+
+            layout.AddElement(guiElem);
+        }
+
+        /// <inheritdoc/>
+        internal override void Refresh(Material material)
+        {
+            guiElem.Value = material.GetFloat(shaderParam.Name);
+        }
+
+        /// <inheritdoc/>
+        internal override void Destroy()
+        {
+            guiElem.Destroy();
+        }
+    }
+
+    /// <summary>
+    /// Contains GUI element(s) for a single 2D vector parameter in a <see cref="Material"/>.
+    /// </summary>
+    internal class MaterialParamVec2GUI : MaterialParamGUI
+    {
+        private GUIVector2Field guiElem;
+
+        /// <summary>
+        /// Creates a new material parameter GUI.
+        /// </summary>
+        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 2D vector type.</param>
+        /// <param name="material">Material the parameter is a part of.</param>
+        /// <param name="layout">Layout to append the GUI elements to.</param>
+        internal MaterialParamVec2GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
+            : base(shaderParam)
+        {
+            LocString title = new LocEdString(shaderParam.Name);
+            guiElem = new GUIVector2Field(title);
+            guiElem.OnChanged += (x) =>
+            {
+                material.SetVector2(shaderParam.Name, x);
+                EditorApplication.SetDirty(material);
+            };
+
+            layout.AddElement(guiElem);
+        }
+
+        /// <inheritdoc/>
+        internal override void Refresh(Material material)
+        {
+            guiElem.Value = material.GetVector2(shaderParam.Name);
+        }
+
+        /// <inheritdoc/>
+        internal override void Destroy()
+        {
+            guiElem.Destroy();
+        }
+    }
+
+    /// <summary>
+    /// Contains GUI element(s) for a single 3D vector parameter in a <see cref="Material"/>.
+    /// </summary>
+    internal class MaterialParamVec3GUI : MaterialParamGUI
+    {
+        private GUIVector3Field guiElem;
+
+        /// <summary>
+        /// Creates a new material parameter GUI.
+        /// </summary>
+        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 3D vector type.</param>
+        /// <param name="material">Material the parameter is a part of.</param>
+        /// <param name="layout">Layout to append the GUI elements to.</param>
+        internal MaterialParamVec3GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
+            : base(shaderParam)
+        {
+            LocString title = new LocEdString(shaderParam.Name);
+            guiElem = new GUIVector3Field(title);
+            guiElem.OnChanged += (x) =>
+            {
+                material.SetVector3(shaderParam.Name, x);
+                EditorApplication.SetDirty(material);
+            };
+
+            layout.AddElement(guiElem);
+        }
+
+        /// <inheritdoc/>
+        internal override void Refresh(Material material)
+        {
+            guiElem.Value = material.GetVector3(shaderParam.Name);
+        }
+
+        /// <inheritdoc/>
+        internal override void Destroy()
+        {
+            guiElem.Destroy();
+        }
+    }
+
+    /// <summary>
+    /// Contains GUI element(s) for a single 4D vector parameter in a <see cref="Material"/>.
+    /// </summary>
+    internal class MaterialParamVec4GUI : MaterialParamGUI
+    {
+        private GUIVector4Field guiElem;
+
+        /// <summary>
+        /// Creates a new material parameter GUI.
+        /// </summary>
+        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 4D vector type.</param>
+        /// <param name="material">Material the parameter is a part of.</param>
+        /// <param name="layout">Layout to append the GUI elements to.</param>
+        internal MaterialParamVec4GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
+            : base(shaderParam)
+        {
+            LocString title = new LocEdString(shaderParam.Name);
+            guiElem = new GUIVector4Field(title);
+            guiElem.OnChanged += (x) =>
+            {
+                material.SetVector4(shaderParam.Name, x);
+                EditorApplication.SetDirty(material);
+            };
+
+            layout.AddElement(guiElem);
+        }
+
+        /// <inheritdoc/>
+        internal override void Refresh(Material material)
+        {
+            guiElem.Value = material.GetVector4(shaderParam.Name);
+        }
+
+        /// <inheritdoc/>
+        internal override void Destroy()
+        {
+            guiElem.Destroy();
+        }
+    }
+
+    /// <summary>
+    /// Contains GUI element(s) for a single 3x3 matrix parameter in a <see cref="Material"/>.
+    /// </summary>
+    internal class MaterialParamMat3GUI : MaterialParamGUI
+    {
+        private const int MAT_SIZE = 3;
+
+        private GUILayout mainLayout;
+        private GUIFloatField[] guiMatFields = new GUIFloatField[MAT_SIZE * MAT_SIZE];
+
+        /// <summary>
+        /// Creates a new material parameter GUI.
+        /// </summary>
+        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 3x3 matrix type.</param>
+        /// <param name="material">Material the parameter is a part of.</param>
+        /// <param name="layout">Layout to append the GUI elements to.</param>
+        internal MaterialParamMat3GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
+            : base(shaderParam)
+        {
+            LocString title = new LocEdString(shaderParam.Name);
+            GUILabel guiTitle = new GUILabel(title, GUIOption.FixedWidth(100));
+
+            mainLayout = layout.AddLayoutY();
+            GUILayoutX titleLayout = mainLayout.AddLayoutX();
+            titleLayout.AddElement(guiTitle);
+            titleLayout.AddFlexibleSpace();
+
+            GUILayoutY contentLayout = mainLayout.AddLayoutY();
+
+            GUILayoutX[] rows = new GUILayoutX[MAT_SIZE];
+            for (int i = 0; i < rows.Length; i++)
+                rows[i] = contentLayout.AddLayoutX();
+
+            for (int row = 0; row < MAT_SIZE; row++)
+            {
+                for (int col = 0; col < MAT_SIZE; col++)
+                {
+                    int index = row * MAT_SIZE + col;
+                    guiMatFields[index] = new GUIFloatField(row + "," + col, 20, "", GUIOption.FixedWidth(80));
+
+                    GUIFloatField field = guiMatFields[index];
+                    rows[row].AddElement(field);
+                    rows[row].AddSpace(5);
+
+                    int hoistedRow = row;
+                    int hoistedCol = col;
+                    field.OnChanged += (x) =>
+                    {
+                        Matrix3 value = material.GetMatrix3(shaderParam.Name);
+                        value[hoistedRow, hoistedCol] = x;
+                        material.SetMatrix3(shaderParam.Name, value);
+                        EditorApplication.SetDirty(material);
+                    };
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        internal override void Refresh(Material material)
+        {
+            Matrix3 value = material.GetMatrix3(shaderParam.Name);
+
+            for (int row = 0; row < MAT_SIZE; row++)
+            {
+                for (int col = 0; col < MAT_SIZE; col++)
+                {
+                    int index = row * MAT_SIZE + col;
+                    guiMatFields[index].Value = value[row, col];
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        internal override void Destroy()
+        {
+            mainLayout.Destroy();
+        }
+    }
+
+    /// <summary>
+    /// Contains GUI element(s) for a single 4x4 matrix parameter in a <see cref="Material"/>.
+    /// </summary>
+    internal class MaterialParamMat4GUI : MaterialParamGUI
+    {
+        private const int MAT_SIZE = 4;
+
+        private GUILayout mainLayout;
+        private GUIFloatField[] guiMatFields = new GUIFloatField[MAT_SIZE * MAT_SIZE];
+
+        /// <summary>
+        /// Creates a new material parameter GUI.
+        /// </summary>
+        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of 4x4 matrix type.</param>
+        /// <param name="material">Material the parameter is a part of.</param>
+        /// <param name="layout">Layout to append the GUI elements to.</param>
+        internal MaterialParamMat4GUI(ShaderParameter shaderParam, Material material, GUILayout layout)
+            : base(shaderParam)
+        {
+            LocString title = new LocEdString(shaderParam.Name);
+            GUILabel guiTitle = new GUILabel(title, GUIOption.FixedWidth(100));
+
+            mainLayout = layout.AddLayoutY();
+            GUILayoutX titleLayout = mainLayout.AddLayoutX();
+            titleLayout.AddElement(guiTitle);
+            titleLayout.AddFlexibleSpace();
+
+            GUILayoutY contentLayout = mainLayout.AddLayoutY();
+
+            GUILayoutX[] rows = new GUILayoutX[MAT_SIZE];
+            for (int i = 0; i < rows.Length; i++)
+                rows[i] = contentLayout.AddLayoutX();
+
+            for (int row = 0; row < MAT_SIZE; row++)
+            {
+                for (int col = 0; col < MAT_SIZE; col++)
+                {
+                    int index = row * MAT_SIZE + col;
+                    guiMatFields[index] = new GUIFloatField(row + "," + col, 20, "", GUIOption.FixedWidth(80));
+
+                    GUIFloatField field = guiMatFields[index];
+                    rows[row].AddElement(field);
+                    rows[row].AddSpace(5);
+
+                    int hoistedRow = row;
+                    int hoistedCol = col;
+                    field.OnChanged += (x) =>
+                    {
+                        Matrix4 value = material.GetMatrix4(shaderParam.Name);
+                        value[hoistedRow, hoistedCol] = x;
+                        material.SetMatrix4(shaderParam.Name, value);
+                        EditorApplication.SetDirty(material);
+                    };
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        internal override void Refresh(Material material)
+        {
+            Matrix4 value = material.GetMatrix4(shaderParam.Name);
+
+            for (int row = 0; row < MAT_SIZE; row++)
+            {
+                for (int col = 0; col < MAT_SIZE; col++)
+                {
+                    int index = row * MAT_SIZE + col;
+                    guiMatFields[index].Value = value[row, col];
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        internal override void Destroy()
+        {
+            mainLayout.Destroy();
+        }
+    }
+
+    /// <summary>
+    /// Contains GUI element(s) for a single color parameter in a <see cref="Material"/>.
+    /// </summary>
+    internal class MaterialParamColorGUI : MaterialParamGUI
+    {
+        private GUIColorField guiElem;
+
+        /// <summary>
+        /// Creates a new material parameter GUI.
+        /// </summary>
+        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of color type.</param>
+        /// <param name="material">Material the parameter is a part of.</param>
+        /// <param name="layout">Layout to append the GUI elements to.</param>
+        internal MaterialParamColorGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
+            : base(shaderParam)
+        {
+            LocString title = new LocEdString(shaderParam.Name);
+            guiElem = new GUIColorField(title);
+            guiElem.OnChanged += (x) =>
+            {
+                material.SetColor(shaderParam.Name, x);
+                EditorApplication.SetDirty(material);
+            };
+
+            layout.AddElement(guiElem);
+        }
+
+        /// <inheritdoc/>
+        internal override void Refresh(Material material)
+        {
+            guiElem.Value = material.GetColor(shaderParam.Name);
+        }
+
+        /// <inheritdoc/>
+        internal override void Destroy()
+        {
+            guiElem.Destroy();
+        }
+    }
+
+    /// <summary>
+    /// Contains GUI element(s) for a single texture parameter in a <see cref="Material"/>.
+    /// </summary>
+    internal class MaterialParamTextureGUI : MaterialParamGUI
+    {
+        private GUITextureField guiElem;
+
+        /// <summary>
+        /// Creates a new material parameter GUI.
+        /// </summary>
+        /// <param name="shaderParam">Shader parameter to create the GUI for. Must be of texture type.</param>
+        /// <param name="material">Material the parameter is a part of.</param>
+        /// <param name="layout">Layout to append the GUI elements to.</param>
+        internal MaterialParamTextureGUI(ShaderParameter shaderParam, Material material, GUILayout layout)
+            : base(shaderParam)
+        {
+            LocString title = new LocEdString(shaderParam.Name);
+            guiElem = new GUITextureField(title);
+
+            switch (shaderParam.Type)
+            {
+                case ShaderParameterType.Texture2D:
+                    guiElem.OnChanged += (x) =>
+                    {
+                        Texture2D texture = Resources.Load<Texture2D>(x);
+
+                        material.SetTexture2D(shaderParam.Name, texture);
+                        EditorApplication.SetDirty(material);
+                    };
+                    break;
+                case ShaderParameterType.Texture3D:
+                    guiElem.OnChanged += (x) =>
+                    {
+                        Texture3D texture = Resources.Load<Texture3D>(x);
+
+                        material.SetTexture3D(shaderParam.Name, texture);
+                        EditorApplication.SetDirty(material);
+                    };
+                    break;
+                case ShaderParameterType.TextureCube:
+                    guiElem.OnChanged += (x) =>
+                    {
+                        TextureCube texture = Resources.Load<TextureCube>(x);
+
+                        material.SetTextureCube(shaderParam.Name, texture);
+                        EditorApplication.SetDirty(material);
+                    };
+                    break;
+            }
+
+            layout.AddElement(guiElem);
+        }
+
+        /// <inheritdoc/>
+        internal override void Refresh(Material material)
+        {
+            Texture value = null;
+            switch (shaderParam.Type)
+            {
+                case ShaderParameterType.Texture2D:
+                    value = material.GetTexture2D(shaderParam.Name);
+                    break;
+                case ShaderParameterType.Texture3D:
+                    value = material.GetTexture3D(shaderParam.Name);
+                    break;
+                case ShaderParameterType.TextureCube:
+                    value = material.GetTextureCube(shaderParam.Name);
+                    break;
+            }
+
+            guiElem.Value = value;
+        }
+
+        /// <inheritdoc/>
+        internal override void Destroy()
+        {
+            guiElem.Destroy();
+        }
+    }
+}

MBansheeEditor/MBansheeEditor.csproj

@@ -46,6 +46,7 @@
     <Compile Include="BuildWindow.cs" />
     <Compile Include="CodeEditor.cs" />
     <Compile Include="ColorPicker.cs" />
+    <Compile Include="EditorPersistentData.cs" />
     <Compile Include="Inspectors\GUIWidgetInspector.cs" />
     <Compile Include="LogWindow.cs" />
     <Compile Include="DefaultSize.cs" />

MBansheeEditor/Scene/SceneWindow.cs

@@ -456,7 +456,10 @@ namespace BansheeEditor
                     dragActive = false;
 
                     if (draggedSO != null)
+                    {
                         Selection.SceneObject = draggedSO;
+                        EditorApplication.SetSceneDirty();
+                    }
 
                     draggedSO = null;
                 }
@@ -486,8 +489,6 @@ namespace BansheeEditor
 
                                         Renderable renderable = draggedSO.AddComponent<Renderable>();
                                         renderable.Mesh = mesh;
-
-                                        EditorApplication.SetSceneDirty();
                                     }
 
                                     break;
@@ -498,8 +499,6 @@ namespace BansheeEditor
                                     {
                                         Prefab prefab = ProjectLibrary.Load<Prefab>(draggedPaths[i]);
                                         draggedSO = UndoRedo.Instantiate(prefab, "Instantiating " + prefab.Name);
-
-                                        EditorApplication.SetSceneDirty();
                                     }
 
                                     break;

MBansheeEngine/Scene.cs

@@ -82,6 +82,42 @@ namespace BansheeEngine
             }
         }
 
+        /// <summary>
+        /// Wrapper around scene name static field because Mono has problems accessing static fields directly.
+        /// </summary>
+        /// <returns>Name of the currently active scene.</returns>
+        private static string GetSceneName()
+        {
+            return activeSceneName;
+        }
+
+        /// <summary>
+        /// Wrapper around scene name static field because Mono has problems accessing static fields directly.
+        /// </summary>
+        /// <param name="name">Name of the currently active scene.</param>
+        private static void SetSceneName(string name)
+        {
+            activeSceneName = name;
+        }
+
+        /// <summary>
+        /// Wrapper around scene UUID static field because Mono has problems accessing static fields directly.
+        /// </summary>
+        /// <returns>UUID of the currently active scene.</returns>
+        private static string GetSceneUUID()
+        {
+            return activeSceneUUID;
+        }
+
+        /// <summary>
+        /// Wrapper around scene UUID static field because Mono has problems accessing static fields directly.
+        /// </summary>
+        /// <param name="uuid">UUID of the currently active scene.</param>
+        private static void SetSceneUUID(string uuid)
+        {
+            activeSceneUUID = uuid;
+        }
+
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern Prefab Internal_LoadScene(string path);
 

SBansheeEngine/Include/BsScriptScene.h

@@ -28,9 +28,6 @@ namespace BansheeEngine
 		/** Triggered when assembly domain is loaded during assembly refresh. */
 		static void onRefreshDomainLoaded();
 
-		static const char* ActiveSceneNameFieldName;
-		static const char* ActiveSceneUUIDFieldName;
-
 		static HEvent OnRefreshDomainLoadedConn;
 		static HEvent OnRefreshStartedConn;
 

SBansheeEngine/Source/BsEngineScriptLibrary.cpp

@@ -17,6 +17,7 @@
 #include "BsScriptDebug.h"
 #include "BsScriptGUI.h"
 #include "BsPlayInEditorManager.h"
+#include "BsScriptScene.h"
 
 namespace BansheeEngine
 {
@@ -40,6 +41,7 @@ namespace BansheeEngine
 		ScriptAssemblyManager::startUp();
 		ScriptResourceManager::startUp();
 		ScriptGameObjectManager::startUp();
+		ScriptScene::startUp();
 		ScriptInput::startUp();
 		ScriptVirtualInput::startUp();
 		ScriptGUI::startUp();
@@ -105,6 +107,7 @@ namespace BansheeEngine
 		ScriptGUI::shutDown();
 		ScriptVirtualInput::shutDown();
 		ScriptInput::shutDown();
+		ScriptScene::shutDown();
 		ManagedResourceManager::shutDown();
 		MonoManager::shutDown();
 		ScriptGameObjectManager::shutDown();

SBansheeEngine/Source/BsScriptScene.cpp

@@ -3,7 +3,7 @@
 #include "BsScriptScene.h"
 #include "BsMonoManager.h"
 #include "BsMonoClass.h"
-#include "BsMonoField.h"
+#include "BsMonoMethod.h"
 #include "BsMonoUtil.h"
 #include "BsSceneManager.h"
 #include "BsResources.h"
@@ -19,9 +19,6 @@
 
 namespace BansheeEngine
 {
-	const char* ScriptScene::ActiveSceneNameFieldName = "activeSceneName";
-	const char* ScriptScene::ActiveSceneUUIDFieldName = "activeSceneUUID";
-
 	HEvent ScriptScene::OnRefreshDomainLoadedConn;
 	HEvent ScriptScene::OnRefreshStartedConn;
 
@@ -76,24 +73,34 @@ namespace BansheeEngine
 
 	void ScriptScene::onRefreshStarted()
 	{
-		MonoField* uuidField = metaData.scriptClass->getField(ActiveSceneUUIDFieldName);
-		if (uuidField != nullptr)
-			ActiveSceneUUID = MonoUtil::monoToString((MonoString*)uuidField->getValueBoxed(nullptr));
+		MonoMethod* uuidMethod = metaData.scriptClass->getMethod("GetSceneUUID");
+		if (uuidMethod != nullptr)
+			ActiveSceneUUID = MonoUtil::monoToString((MonoString*)uuidMethod->invoke(nullptr, nullptr));
 
-		MonoField* nameField = metaData.scriptClass->getField(ActiveSceneNameFieldName);
-		if (nameField != nullptr)
-			ActiveSceneName = MonoUtil::monoToWString((MonoString*)nameField->getValueBoxed(nullptr));
+		MonoMethod* nameMethod = metaData.scriptClass->getMethod("GetSceneName");
+		if (nameMethod != nullptr)
+			ActiveSceneName = MonoUtil::monoToWString((MonoString*)nameMethod->invoke(nullptr, nullptr));
 	}
 
 	void ScriptScene::onRefreshDomainLoaded()
 	{
-		MonoField* uuidField = metaData.scriptClass->getField(ActiveSceneUUIDFieldName);
-		if (uuidField != nullptr)
-			uuidField->setValue(nullptr, MonoUtil::stringToMono(ActiveSceneUUID));
+		MonoMethod* uuidMethod = metaData.scriptClass->getMethod("SetSceneUUID", 1);
+		if (uuidMethod != nullptr)
+		{
+			void* params[1];
+			params[0] = MonoUtil::stringToMono(ActiveSceneUUID);
+
+			uuidMethod->invoke(nullptr, params);
+		}
+			
+		MonoMethod* nameMethod = metaData.scriptClass->getMethod("SetSceneName", 1);
+		if (nameMethod != nullptr)
+		{
+			void* params[1];
+			params[0] = MonoUtil::wstringToMono(ActiveSceneName);
 
-		MonoField* nameField = metaData.scriptClass->getField(ActiveSceneNameFieldName);
-		if (nameField != nullptr)
-			nameField->setValue(nullptr, MonoUtil::wstringToMono(ActiveSceneName));
+			nameMethod->invoke(nullptr, params);
+		}
 	}
 
 	MonoObject* ScriptScene::internal_GetRoot()