Updated material inspector so it shows builtin shaders

Source/BansheeEngine/Include/BsBuiltinResources.h

@@ -14,18 +14,24 @@ namespace BansheeEngine
 	 *  @{
 	 */
 
-	/**	Types of builtin meshes that are always available in the engine. */
+	/**	Types of builtin meshes that are always available. */
 	enum class BuiltinMesh
 	{
 		Box, Sphere, Cone, Quad, Disc
 	};
 
-	/**	Types of builtin textures that are always available in the engine. */
+	/**	Types of builtin textures that are always available. */
 	enum class BuiltinTexture
 	{
 		White, Black, Normal
 	};
 
+	/** Types of builtin shaders that are always available. */
+	enum class BuiltinShader
+	{
+		Standard, Custom
+	};
+
 	/**	Holds references to built-in resources used by the core engine. */
 	class BS_EXPORT BuiltinResources : public BansheeEngine::Module<BuiltinResources>
 	{
@@ -82,7 +88,7 @@ namespace BansheeEngine
 		const PixelData& getBansheeIcon();
 
 		/**	Returns a shader used for rendering only a diffuse texture. */
-		HShader getDiffuseShader() const { return mShaderDiffuse; }
+		HShader getBuiltinShader(BuiltinShader type) const;
 
 		/**	Creates a material used for textual sprite rendering (for example text in GUI). */
 		HMaterial createSpriteTextMaterial() const;

Source/BansheeEngine/Source/BsBuiltinResources.cpp

@@ -1103,6 +1103,17 @@ namespace BansheeEngine
 		return gResources().load<Mesh>(meshPath);
 	}
 
+	HShader BuiltinResources::getBuiltinShader(BuiltinShader type) const
+	{
+		switch(type)
+		{
+		case BuiltinShader::Standard:
+				return mShaderDiffuse;
+		}
+
+		return HShader();
+	}
+
 	HTexture BuiltinResources::getTexture(BuiltinTexture type)
 	{
 		Path texturePath = Paths::getEngineDataPath();

Source/MBansheeEditor/Inspectors/MaterialInspector.cs

@@ -17,6 +17,7 @@ namespace BansheeEditor
     {
         private MaterialParamGUI[] guiParams;
         private GUIResourceField shaderField;
+        private GUIEnumField builtinShaderField;
 
         /// <inheritdoc/>
         protected internal override void Initialize()
@@ -25,7 +26,25 @@ namespace BansheeEditor
             if (material == null)
                 return;
 
-            shaderField = new GUIResourceField(typeof(Shader), new LocEdString("Shader"));
+            Shader activeShader = material.Shader;
+            BuiltinShader builtinType = ShaderToBuiltin(activeShader);
+
+            builtinShaderField = new GUIEnumField(typeof(BuiltinShader), new LocEdString("Shader"));
+            builtinShaderField.Value = (ulong) builtinType;
+            builtinShaderField.OnSelectionChanged += x =>
+            {
+                BuiltinShader newBuiltinType = (BuiltinShader) x;
+
+                material.Shader = Builtin.GetShader(newBuiltinType);
+                EditorApplication.SetDirty(material);
+                RebuildParamGUI(material);
+
+                bool newIsCustom = newBuiltinType == BuiltinShader.Custom;
+                builtinShaderField.Active = !newIsCustom;
+                shaderField.Active = newIsCustom;
+            };
+
+            shaderField = new GUIResourceField(typeof(Shader), new LocEdString("Shader file"));
             shaderField.Value = material.Shader;
             shaderField.OnChanged += (x) =>
             {
@@ -36,6 +55,11 @@ namespace BansheeEditor
                 RebuildParamGUI(material);
             };
 
+            bool isCustom = builtinType == BuiltinShader.Custom;
+            builtinShaderField.Active = !isCustom;
+            shaderField.Active = isCustom;
+
+            Layout.AddElement(builtinShaderField);
             Layout.AddElement(shaderField);
 
             RebuildParamGUI(material);
@@ -81,6 +105,20 @@ namespace BansheeEditor
                 guiParams = CreateMaterialGUI(material, Layout);
         }
 
+        /// <summary>
+        /// Converts a shader resource into a builtin shader.
+        /// </summary>
+        /// <param name="shader">Shader resource to convert.</param>
+        /// <returns>Type of builtin shader, if any.</returns>
+        private BuiltinShader ShaderToBuiltin(Shader shader)
+        {
+            // Note: Need a better way to detect the builtin shader perhaps (store it in Material?)
+            Shader standardShader = Builtin.GetShader(BuiltinShader.Standard);
+            if(standardShader == shader)
+                return BuiltinShader.Standard;
+            
+            return BuiltinShader.Custom;
+        }
 
         /// <summary>
         /// Creates a set of objects in which each object represents a GUI for a material parameter.

Source/MBansheeEditor/Windows/Library/LibraryUtility.cs

@@ -36,7 +36,7 @@ namespace BansheeEditor
             string path = Path.Combine(folder, "New Material.asset");
             path = GetUniquePath(path);
 
-            Material material = new Material(Builtin.DiffuseShader);
+            Material material = new Material(Builtin.GetShader(BuiltinShader.Standard));
             ProjectLibrary.Create(material, path);
         }
 

Source/MBansheeEngine/Utility/Builtin.cs

@@ -8,6 +8,16 @@ namespace BansheeEngine
      *  @{
      */
 
+
+    /// <summary>
+    /// Available builtin shader types.
+    /// </summary>
+    public enum BuiltinShader // Note: Must match C++ BuiltinShader enum
+    {
+        Standard,
+        Custom
+    }
+
     /// <summary>
     /// Contains various builtin resources that are always available.
     /// </summary>
@@ -30,11 +40,14 @@ namespace BansheeEngine
         }
 
         /// <summary>
-        /// Returns the default shader to be used with renderables.
+        /// Returns one of the builtin shaders
         /// </summary>
-        public static Shader DiffuseShader
+        public static Shader GetShader(BuiltinShader shader)
         {
-            get { return Internal_GetDiffuseShader(); }
+            if (shader == BuiltinShader.Custom)
+                return null;
+
+            return Internal_GetBuiltinShader((int)shader);
         }
 
         /// <summary>
@@ -89,7 +102,7 @@ namespace BansheeEngine
         private static extern SpriteTexture Internal_GetWhiteTexture();
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Shader Internal_GetDiffuseShader();
+        private static extern Shader Internal_GetBuiltinShader(int shaderType);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern Mesh Internal_GetMesh(BuiltinMesh mesh);

Source/SBansheeEngine/Include/BsScriptBuiltin.h

@@ -25,7 +25,7 @@ namespace BansheeEngine
 		/* 								CLR HOOKS						   		*/
 		/************************************************************************/
 		static MonoObject* internal_GetWhiteTexture();
-		static MonoObject* internal_GetDiffuseShader();
+		static MonoObject* internal_GetBuiltinShader(BuiltinShader type);
 		static MonoObject* internal_GetMesh(BuiltinMesh meshType);
 		static MonoObject* internal_GetDefaultFont();
 	};

Source/SBansheeEngine/Source/BsScriptBuiltin.cpp

@@ -21,7 +21,7 @@ namespace BansheeEngine
 	void ScriptBuiltin::initRuntimeData()
 	{
 		metaData.scriptClass->addInternalCall("Internal_GetWhiteTexture", &ScriptBuiltin::internal_GetWhiteTexture);
-		metaData.scriptClass->addInternalCall("Internal_GetDiffuseShader", &ScriptBuiltin::internal_GetDiffuseShader);
+		metaData.scriptClass->addInternalCall("Internal_GetBuiltinShader", &ScriptBuiltin::internal_GetBuiltinShader);
 		metaData.scriptClass->addInternalCall("Internal_GetMesh", &ScriptBuiltin::internal_GetMesh);
 		metaData.scriptClass->addInternalCall("Internal_GetDefaultFont", &ScriptBuiltin::internal_GetDefaultFont);
 	}
@@ -36,9 +36,9 @@ namespace BansheeEngine
 		return scriptSpriteTex->getManagedInstance();
 	}
 
-	MonoObject* ScriptBuiltin::internal_GetDiffuseShader()
+	MonoObject* ScriptBuiltin::internal_GetBuiltinShader(BuiltinShader type)
 	{
-		HShader diffuseShader = BuiltinResources::instance().getDiffuseShader();
+		HShader diffuseShader = BuiltinResources::instance().getBuiltinShader(type);
 
 		ScriptShader* scriptShader;
 		ScriptResourceManager::instance().getScriptResource(diffuseShader, &scriptShader, true);

Source/SBansheeEngine/Source/BsScriptMaterial.cpp

@@ -59,7 +59,7 @@ namespace BansheeEngine
 			nativeShader = shader->getHandle();
 
 		if (nativeShader == nullptr)
-			nativeShader = BuiltinResources::instance().getDiffuseShader();
+			nativeShader = BuiltinResources::instance().getBuiltinShader(BuiltinShader::Standard);
 
 		HMaterial material = Material::create(nativeShader);
 
@@ -97,7 +97,7 @@ namespace BansheeEngine
 			nativeShader = shader->getHandle();
 
 		if (nativeShader == nullptr)
-			nativeShader = BuiltinResources::instance().getDiffuseShader();
+			nativeShader = BuiltinResources::instance().getBuiltinShader(BuiltinShader::Standard);
 
 		nativeInstance->getHandle()->setShader(nativeShader);
 	}