Move default shader into a separate file

Added a different default shader for meshes with no normals

BansheeEditor/Include/BsEditorApplication.h

@@ -5,19 +5,28 @@
 
 namespace BansheeEngine
 {
+	/**
+	 * @brief	Types of render APIs supported by the editor.
+	 */
+	enum class EditorRenderAPI
+	{
+		DX11,
+		OpenGL
+	};
+
 	/**
 	 * @brief	Primary editor class containing the editor entry point.
 	 */
 	class BS_ED_EXPORT EditorApplication : public Application
 	{
 	public:
-		EditorApplication(RenderAPIPlugin renderAPI);
+		EditorApplication(EditorRenderAPI renderAPI);
 		virtual ~EditorApplication();
 
 		/**
 		 * @brief	Starts the editor with the specified render system.
 		 */
-		static void startUp(RenderAPIPlugin renderAPI);
+		static void startUp(EditorRenderAPI renderAPI);
 
 		/**
 		 * @brief	Checks whether the editor currently has a project loaded.
@@ -159,6 +168,12 @@ namespace BansheeEngine
 		 */
 		virtual ShaderIncludeHandlerPtr getShaderIncludeHandler() const override;
 
+		/**
+		 * @brief	Converts a render API type supported by the editor into a type recognized by the lower
+		 * 			layers of the engine.
+		 */
+		static RenderAPIPlugin toEngineRenderAPI(EditorRenderAPI renderAPI);
+
 	private:
 		static const Path WIDGET_LAYOUT_PATH;
 		static const Path BUILD_DATA_PATH;

BansheeEditor/Source/BsEditorApplication.cpp

@@ -48,9 +48,9 @@ namespace BansheeEngine
 		return renderWindowDesc;
 	}
 
-	EditorApplication::EditorApplication(RenderAPIPlugin renderAPIPlugin)
-		:Application(createRenderWindowDesc(), renderAPIPlugin, RendererPlugin::Default),
-		mActiveRAPIPlugin(renderAPIPlugin), mSBansheeEditorPlugin(nullptr), mIsProjectLoaded(false)
+	EditorApplication::EditorApplication(EditorRenderAPI renderAPIPlugin)
+		:Application(createRenderWindowDesc(), toEngineRenderAPI(renderAPIPlugin), RendererPlugin::Default),
+		mActiveRAPIPlugin(toEngineRenderAPI(renderAPIPlugin)), mSBansheeEditorPlugin(nullptr), mIsProjectLoaded(false)
 	{
 
 	}
@@ -136,7 +136,7 @@ namespace BansheeEngine
 		loadPlugin("SBansheeEditor", &mSBansheeEditorPlugin);
 	}
 
-	void EditorApplication::startUp(RenderAPIPlugin renderAPI)
+	void EditorApplication::startUp(EditorRenderAPI renderAPI)
 	{
 		CoreApplication::startUp<EditorApplication>(renderAPI);
 	}
@@ -362,6 +362,16 @@ namespace BansheeEngine
 		return bs_shared_ptr_new<EditorShaderIncludeHandler>();
 	}
 
+	RenderAPIPlugin EditorApplication::toEngineRenderAPI(EditorRenderAPI renderAPI)
+	{
+		if (renderAPI == EditorRenderAPI::DX11)
+			return RenderAPIPlugin::DX11;
+		else if (renderAPI == EditorRenderAPI::OpenGL)
+			return RenderAPIPlugin::OpenGL;
+
+		BS_EXCEPT(InvalidStateException, "Unsupported render API.");
+	}
+
 	EditorApplication& gEditorApplication()
 	{
 		return static_cast<EditorApplication&>(EditorApplication::instance());

BansheeEditorExec/BsEditorExec.cpp

@@ -72,7 +72,7 @@ int CALLBACK WinMain(
 
 	__try
 	{
-		EditorApplication::startUp(RenderAPIPlugin::DX9);
+		EditorApplication::startUp(EditorRenderAPI::DX11);
 		EditorApplication::instance().runMainLoop();
 		EditorApplication::shutDown();
 	}

BansheeEngine/Include/BsBuiltinResources.h

@@ -91,11 +91,6 @@ namespace BansheeEngine
 		 */
 		HShader getDiffuseShader() const { return mShaderDiffuse; }
 
-		/**
-		 * @brief	Returns a shader used as a replacement when no other is usable.
-		 */
-		HShader getDummyShader() const { return mShaderDummy; }
-
 		/**
 		 * @brief	Creates material used for textual sprite rendering (e.g. text in GUI).
 		 */
@@ -111,11 +106,6 @@ namespace BansheeEngine
 		*/
 		GUIMaterialInfo createSpriteNonAlphaImageMaterial() const;
 
-		/**
-		 * @brief	Creates a material used as a replacement when no other material is usable.
-		 */
-		HMaterial createDummyMaterial() const;
-
 		/**
 		 * @brief	Retrieves one of the builtin meshes.
 		 */
@@ -188,7 +178,6 @@ namespace BansheeEngine
 		HShader mShaderSpriteImage;
 		HShader mShaderSpriteNonAlphaImage;
 		HShader mShaderDiffuse;
-		HShader mShaderDummy;
 
 		ResourceManifestPtr mResourceManifest;
 
@@ -304,7 +293,6 @@ namespace BansheeEngine
 		static const WString ShaderSpriteImageAlphaFile;
 		static const WString ShaderSpriteImageNoAlphaFile;
 		static const WString ShaderDiffuseFile;
-		static const WString ShaderDummyFile;
 
 		static const WString MeshSphereFile;
 		static const WString MeshBoxFile;

BansheeEngine/Include/BsRendererMaterial.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "BsPrerequisites.h"
+#include "BsRendererMaterialManager.h"
 
 #define RMAT_DEF(path) virtual Path getShaderPath() const override { return path; }
 
@@ -60,22 +61,29 @@ namespace BansheeEngine
 		public:
 			InitOnStart()
 			{
-				instance = new T();
-
-				RendererMaterialManager::_registerMaterial(instance);
+				RendererMaterialManager::_registerMaterial(&instance);
 			}
+
+			void makeSureIAmInstantiated() { }
 		};
 
 	public:
+		RendererMaterial()
+		{
+			mInit.makeSureIAmInstantiated();
+		}
 		virtual ~RendererMaterial() { }
 
-		static T* instance;
+		static T instance;
 	private:
 		friend class RendererMaterialManager;
 
-		volatile InitOnStart mInit;
+		static InitOnStart mInit;
 	};
 
 	template<class T>
-	T* RendererMaterial<T>::instance = nullptr;
+	T RendererMaterial<T>::instance;
+
+	template<class T>
+	typename RendererMaterial<T>::InitOnStart RendererMaterial<T>::mInit;
 }

BansheeEngine/Include/BsRendererMaterialManager.h

@@ -6,6 +6,8 @@
 
 namespace BansheeEngine
 {
+	class RendererMaterialBase;
+
 	/**
 	 * @brief	Initializes and handles all renderer materials.
 	 */

BansheeEngine/Source/BsBuiltinResources.cpp

@@ -169,7 +169,6 @@ namespace BansheeEngine
 	const WString BuiltinResources::ShaderSpriteImageAlphaFile = L"SpriteImageAlpha.bsl";
 	const WString BuiltinResources::ShaderSpriteImageNoAlphaFile = L"SpriteImageNoAlpha.bsl";
 	const WString BuiltinResources::ShaderDiffuseFile = L"Diffuse.bsl";
-	const WString BuiltinResources::ShaderDummyFile = L"Dummy.bsl";
 
 	/************************************************************************/
 	/* 								MESHES							  		*/
@@ -225,7 +224,6 @@ namespace BansheeEngine
 		mShaderSpriteImage = getShader(ShaderSpriteImageAlphaFile);
 		mShaderSpriteNonAlphaImage = getShader(ShaderSpriteImageNoAlphaFile);
 		mShaderDiffuse = getShader(ShaderDiffuseFile);
-		mShaderDummy = getShader(ShaderDummyFile);
 
 		mWhiteSpriteTexture = getSkinTexture(WhiteTex);
 
@@ -962,11 +960,6 @@ namespace BansheeEngine
 		return info;
 	}
 
-	HMaterial BuiltinResources::createDummyMaterial() const
-	{
-		return Material::create(mShaderDummy);
-	}
-
 	void BuiltinResourcesHelper::importAssets(const Path& inputFolder, const Path& outputFolder, const ResourceManifestPtr& manifest)
 	{
 		if (!FileSystem::exists(inputFolder))

RenderBeast/Include/BsRenderBeast.h

@@ -222,11 +222,6 @@ namespace BansheeEngine
 		 */
 		void destroyCore();
 
-		/**
-		 * @brief	Creates a dummy shader to be used when no other is available.
-		 */
-		SPtr<ShaderCore> createDefaultShader();
-
 		/**
 		 * @brief	Checks all sampler overrides in case material sampler states changed,
 		 *			and updates them.
@@ -270,8 +265,6 @@ namespace BansheeEngine
 		UnorderedMap<const CameraCore*, CameraData> mCameraData; // Core thread
 		UnorderedMap<SPtr<MaterialCore>, MaterialSamplerOverrides*> mSamplerOverrides; // Core thread
 
-		SPtr<MaterialCore> mDummyMaterial; // Core thread
-
 		Vector<RenderableData> mRenderables; // Core thread
 		Vector<RenderableShaderData> mRenderableShaderData; // Core thread
 		Vector<Bounds> mWorldBounds; // Core thread

RenderBeast/Source/BsRenderBeast.cpp

@@ -39,6 +39,12 @@ using namespace std::placeholders;
 
 namespace BansheeEngine
 {
+	/** Basic shader that is used when no other is available. */
+	class DefaultMaterial : public RendererMaterial<DefaultMaterial> { RMAT_DEF("Default.bsl"); };
+
+	/** Basic shader that is used when no other is available, and the rendered mesh has no normal information. */
+	class DefaultMaterialNoNormal : public RendererMaterial<DefaultMaterialNoNormal> { RMAT_DEF("DefaultNoNormal.bsl"); };
+
 	RenderBeast::RenderBeast()
 		:mOptions(bs_shared_ptr_new<RenderBeastOptions>()), mOptionsDirty(true), mStaticHandler(nullptr)
 	{
@@ -72,9 +78,6 @@ namespace BansheeEngine
 		mStaticHandler = bs_new<StaticRenderableHandler>();
 
 		RenderTexturePool::startUp();
-
-		SPtr<ShaderCore> shader = createDefaultShader();
-		mDummyMaterial = MaterialCore::create(shader);
 	}
 
 	void RenderBeast::destroyCore()
@@ -89,8 +92,6 @@ namespace BansheeEngine
 		RenderTexturePool::shutDown();
 
 		assert(mSamplerOverrides.empty());
-
-		mDummyMaterial = nullptr;
 	}
 
 	void RenderBeast::_notifyRenderableAdded(RenderableCore* renderable)
@@ -136,7 +137,15 @@ namespace BansheeEngine
 					renElement.material = renderable->getMaterial(0);
 
 				if (renElement.material == nullptr)
-					renElement.material = mDummyMaterial;
+				{
+					SPtr<VertexData> vertexData = mesh->getVertexData();
+					const VertexDeclarationProperties& vertexProps = vertexData->vertexDeclaration->getProperties();
+
+					if (vertexProps.findElementBySemantic(VES_NORMAL))
+						renElement.material = DefaultMaterial::instance.getMaterial();
+					else
+						renElement.material = DefaultMaterialNoNormal::instance.getMaterial();
+				}
 
 				auto iterFind = mSamplerOverrides.find(renElement.material);
 				if (iterFind != mSamplerOverrides.end())
@@ -579,7 +588,7 @@ namespace BansheeEngine
 		// Render lights and resolve gbuffer if there is one
 		if (hasGBuffer)
 		{
-			SPtr<MaterialCore> dirMaterial = DirectionalLightMat::instance->getMaterial();
+			SPtr<MaterialCore> dirMaterial = DirectionalLightMat::instance.getMaterial();
 			SPtr<PassCore> dirPass = dirMaterial->getPass(0);
 
 			setPass(dirPass);
@@ -589,7 +598,7 @@ namespace BansheeEngine
 				if (!light.internal->getIsActive())
 					continue;
 
-				DirectionalLightMat::instance->setParameters(light.internal);
+				DirectionalLightMat::instance.setParameters(light.internal);
 
 				SPtr<MeshCore> mesh = nullptr; // TODO - Get full screen quad
 				draw(mesh, mesh->getProperties().getSubMesh(0));
@@ -601,7 +610,7 @@ namespace BansheeEngine
 				if (!light.internal->getIsActive())
 					continue;
 
-				PointLightMat::instance->setParameters(light.internal);
+				PointLightMat::instance.setParameters(light.internal);
 
 				SPtr<MeshCore> mesh = light.internal->getMesh();
 				draw(mesh, mesh->getProperties().getSubMesh(0));
@@ -1001,168 +1010,4 @@ namespace BansheeEngine
 			rs.setConstantBuffers(stage.type, params);
 		}
 	}
-
-	SPtr<ShaderCore> RenderBeast::createDefaultShader()
-	{
-		StringID rsName = RenderAPICore::instance().getName();
-
-		SPtr<GpuProgramCore> vsProgram;
-		SPtr<GpuProgramCore> psProgram;
-
-		if (rsName == RenderAPIDX11)
-		{
-			String vsCode = R"(
-				cbuffer PerObject
-				{
-					float4x4 gMatWorldViewProj;
-					float4x4 gMatWorld;
-					float4x4 gMatInvWorld;
-					float4x4 gMatWorldNoScale;
-					float4x4 gMatInvWorldNoScale;
-					float gWorldDeterminantSign;
-				}
-
-				void vs_main(
-					in float3 inPos : POSITION,
-					in float3 inNormal : NORMAL,
-					out float4 oPosition : SV_Position,
-					out float3 oNormal : NORMAL)
-				{
-					oPosition = mul(gMatWorldViewProj, float4(inPos.xyz, 1));
-					oNormal = inNormal;
-				})";
-
-			String psCode = R"(
-				cbuffer PerCamera
-				{
-					float3 gViewDir;
-					float4x4 gMatViewProj;
-					float4x4 gMatView;
-					float4x4 gMatProj;
-				}
-
-				float4 ps_main(
-					in float4 inPos : SV_Position,
-					in float3 normal : NORMAL) : SV_Target
-				{
-					float4 outColor = float4(0.3f, 0.3f, 0.3f, 1.0f) * clamp(dot(normalize(normal), -gViewDir), 0.5f, 1.0);
-					outColor.a = 1.0f;
-				
-					return outColor;
-				})";
-
-			vsProgram = GpuProgramCore::create(vsCode, "vs_main", "hlsl", GPT_VERTEX_PROGRAM, GPP_VS_4_0);
-			psProgram = GpuProgramCore::create(psCode, "ps_main", "hlsl", GPT_FRAGMENT_PROGRAM, GPP_FS_4_0);
-		}
-		else if (rsName == RenderAPIDX9)
-		{
-			String vsCode = R"(
-				BS_PARAM_BLOCK PerObject { gMatWorldViewProj, gMatWorld, gMatInvWorld, gMatWorldNoScale, gMatInvWorldNoScale, gMatWorldDeterminantSign }
-
-				float4x4 gMatWorldViewProj;
-				float4x4 gMatWorld;
-				float4x4 gMatInvWorld;
-				float4x4 gMatWorldNoScale;
-				float4x4 gMatInvWorldNoScale;
-				float gWorldDeterminantSign;
-
-				 void vs_main(
-					in float3 inPos : POSITION,
-					in float3 inNormal : NORMAL,
-					out float4 oPosition : POSITION,
-					out float3 oNormal : TEXCOORD0)
-				 {
-					 oPosition = mul(gMatWorldViewProj, float4(inPos.xyz, 1));
-					 oNormal = inNormal;
-				 })";
-
-			String psCode = R"(
-				 BS_PARAM_BLOCK PerCamera { gViewDir, gMatViewProj, gMatView, gMatProj }
-				 float3 gViewDir;
-				 float4x4 gMatViewProj;
-				 float4x4 gMatView;
-				 float4x4 gMatProj;
-
-				float4 ps_main(
-					in float3 inPos : POSITION,
-					in float3 inNormal : TEXCOORD0) : COLOR0
-				{
-					float4 outColor = float4(0.3f, 0.3f, 0.3f, 1.0f) * clamp(dot(normalize(inNormal), -gViewDir), 0.5f, 1.0);
-					outColor.a = 1.0f;
-				
-					return outColor;
-				})";
-
-			vsProgram = GpuProgramCore::create(vsCode, "vs_main", "hlsl9", GPT_VERTEX_PROGRAM, GPP_VS_2_0);
-			psProgram = GpuProgramCore::create(psCode, "ps_main", "hlsl9", GPT_FRAGMENT_PROGRAM, GPP_FS_2_0);
-		}
-		else if (rsName == RenderAPIOpenGL)
-		{
-			String vsCode = R"(
-				uniform PerObject
-				{
-					mat4 gMatWorldViewProj;
-					mat4 gMatWorld;
-					mat4 gMatInvWorld;
-					mat4 gMatWorldNoScale;
-					mat4 gMatInvWorldNoScale;
-					float gWorldDeterminantSign;
-				};
-
-				in vec3 bs_position;
-				in vec3 bs_normal;
-				out vec3 normal;
-
-				out gl_PerVertex
-				{
-					vec4 gl_Position;
-				};
-
-				void main()
-				{
-					gl_Position = gMatWorldViewProj * vec4(bs_position.xyz, 1);
-					normal = bs_normal;
-				})";
-
-			String psCode = R"(
-				uniform PerCamera
-				{
-					vec3 gViewDir;
-					mat4 gMatViewProj;
-					mat4 gMatView;
-					mat4 gMatProj;
-				};
-
-				in vec3 normal;
-				out vec4 fragColor;
-
-				void main()
-				{
-					vec4 outColor = vec4(0.3f, 0.3f, 0.3f, 1.0f) * clamp(dot(normalize(normal), -gViewDir), 0.5f, 1.0);
-					outColor.a = 1.0f;
-				
-					fragColor = outColor;
-				})";
-
-			vsProgram = GpuProgramCore::create(vsCode, "main", "glsl", GPT_VERTEX_PROGRAM, GPP_VS_4_0);
-			psProgram = GpuProgramCore::create(psCode, "main", "glsl", GPT_FRAGMENT_PROGRAM, GPP_FS_4_0);
-		}
-
-		PASS_DESC_CORE passDesc;
-		passDesc.vertexProgram = vsProgram;
-		passDesc.fragmentProgram = psProgram;
-
-		SPtr<PassCore> newPass = PassCore::create(passDesc);
-		SPtr<TechniqueCore> newTechnique = TechniqueCore::create(rsName, RendererDefault, { newPass });
-
-		SHADER_DESC_CORE shaderDesc;
-		shaderDesc.setParamBlockAttribs("PerObject", true, GPBU_DYNAMIC, RBS_PerObject);
-		shaderDesc.setParamBlockAttribs("PerCamera", true, GPBU_DYNAMIC, RBS_PerCamera);
-		shaderDesc.addParameter("gMatWorldViewProj", "gMatWorldViewProj", GPDT_MATRIX_4X4, RPS_WorldViewProjTfrm);
-		shaderDesc.addParameter("gViewDir", "gViewDir", GPDT_FLOAT3, RPS_ViewDir);
-
-		SPtr<ShaderCore> defaultShader = ShaderCore::create("DummyShader", shaderDesc, { newTechnique });
-
-		return defaultShader;
-	}
 }

SBansheeEngine/Source/BsScriptMaterial.cpp

@@ -57,7 +57,7 @@ namespace BansheeEngine
 			nativeShader = shader->getHandle();
 
 		if (nativeShader == nullptr)
-			nativeShader = BuiltinResources::instance().getDummyShader();
+			nativeShader = BuiltinResources::instance().getDiffuseShader();
 
 		HMaterial material = Material::create(nativeShader);
 
@@ -95,7 +95,7 @@ namespace BansheeEngine
 			nativeShader = shader->getHandle();
 
 		if (nativeShader == nullptr)
-			nativeShader = BuiltinResources::instance().getDummyShader();
+			nativeShader = BuiltinResources::instance().getDiffuseShader();
 
 		nativeInstance->getHandle()->setShader(nativeShader);
 	}