Implement a global shader parameter passing system and useful shaders

client/shaders/test_shader_1/base.txt

@@ -0,0 +1 @@
+trans_alphach_ref

client/shaders/test_shader_1/opengl_fragment.glsl

@@ -0,0 +1,25 @@
+
+uniform sampler2D myTexture;
+uniform vec4 skyBgColor;
+uniform float fogDistance;
+
+varying vec3 vPosition;
+
+void main (void)
+{
+    //vec4 col = vec4(1.0, 0.0, 0.0, 1.0);
+    vec4 col = texture2D(myTexture, vec2(gl_TexCoord[0]));
+	float a = col.a;
+    col *= gl_Color;
+	col = col * col; // SRGB -> Linear
+	col *= 1.8;
+	col.r = 1.0 - exp(1.0 - col.r) / exp(1.0);
+	col.g = 1.0 - exp(1.0 - col.g) / exp(1.0);
+	col.b = 1.0 - exp(1.0 - col.b) / exp(1.0);
+	col = sqrt(col); // Linear -> SRGB
+	if(fogDistance != 0.0){
+		float d = max(0.0, min(vPosition.z / fogDistance * 1.5 - 0.6, 1.0));
+		col = mix(col, skyBgColor, d);
+	}
+    gl_FragColor = vec4(col.r, col.g, col.b, a);
+}

client/shaders/test_shader_1/opengl_vertex.glsl

@@ -0,0 +1,25 @@
+
+uniform mat4 mWorldViewProj;
+uniform mat4 mInvWorld;
+uniform mat4 mTransWorld;
+
+varying vec3 vPosition;
+
+void main(void)
+{
+	gl_Position = mWorldViewProj * gl_Vertex;
+
+	vPosition = (mWorldViewProj * gl_Vertex).xyz;
+
+	if(gl_Normal.y > 0.5)
+		gl_FrontColor = gl_BackColor = gl_Color;
+	else
+		gl_FrontColor = gl_BackColor = gl_Color * 0.7;
+
+	/*if(gl_Normal.y > 0.5)
+		gl_FrontColor = gl_BackColor = vec4(1.0, 1.0, 1.0, 1.0);
+	else
+		gl_FrontColor = gl_BackColor = vec4(1.0, 1.0, 1.0, 1.0) * 0.7;*/
+
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+}

client/shaders/test_shader_2/base.txt

@@ -0,0 +1 @@
+trans_alphach

client/shaders/test_shader_2/opengl_fragment.glsl

@@ -0,0 +1,23 @@
+
+uniform sampler2D myTexture;
+uniform float fogDistance;
+
+varying vec3 vPosition;
+
+void main (void)
+{
+    vec4 col = texture2D(myTexture, vec2(gl_TexCoord[0]));
+    col *= gl_Color;
+	float a = gl_Color.a;
+	col = col * col; // SRGB -> Linear
+	col *= 1.8;
+	col.r = 1.0 - exp(1.0 - col.r) / exp(1.0);
+	col.g = 1.0 - exp(1.0 - col.g) / exp(1.0);
+	col.b = 1.0 - exp(1.0 - col.b) / exp(1.0);
+	col = sqrt(col); // Linear -> SRGB
+	if(fogDistance != 0.0){
+		float d = max(0.0, min(vPosition.z / fogDistance * 1.5 - 0.6, 1.0));
+		a = mix(a, 0.0, d);
+	}
+	gl_FragColor = vec4(col.r, col.g, col.b, a);
+}

client/shaders/test_shader_2/opengl_vertex.glsl

@@ -0,0 +1,20 @@
+
+uniform mat4 mWorldViewProj;
+uniform mat4 mInvWorld;
+uniform mat4 mTransWorld;
+
+varying vec3 vPosition;
+
+void main(void)
+{
+	vec4 pos = gl_Vertex;
+	pos.y -= 2.0;
+	gl_Position = mWorldViewProj * pos;
+
+	vPosition = (mWorldViewProj * gl_Vertex).xyz;
+
+	gl_FrontColor = gl_BackColor = gl_Color;
+	//gl_FrontColor = gl_BackColor = vec4(1.0, 1.0, 1.0, 1.0);
+
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+}

client/shaders/the_darkness_of_light/opengl_fragment.asm

@@ -1,17 +0,0 @@
-!!ARBfp1.0
-
-#Input
-ATTRIB inTexCoord = fragment.texcoord;      # texture coordinates
-ATTRIB inColor = fragment.color.primary; # interpolated diffuse color
-
-#Output
-OUTPUT outColor = result.color;
-
-TEMP texelColor;
-TXP texelColor, inTexCoord, texture, 2D; 
-MUL texelColor, texelColor, inColor;  # multiply with color   
-SUB outColor, {1.0,1.0,1.0,1.0}, texelColor;
-MOV outColor.w, 1.0;
-
-END
-

client/shaders/the_darkness_of_light/opengl_fragment.glsl

@@ -1,9 +0,0 @@
-
-uniform sampler2D myTexture;
-
-void main (void)
-{
-    vec4 col = texture2D(myTexture, vec2(gl_TexCoord[0]));
-    col *= gl_Color;
-    gl_FragColor = vec4(1.0-col.r, 1.0-col.g, 1.0-col.b, 1.0);
-}

client/shaders/the_darkness_of_light/opengl_vertex.asm

@@ -1,38 +0,0 @@
-!!ARBvp1.0
-
-#input
-ATTRIB InPos = vertex.position;
-ATTRIB InColor = vertex.color;
-ATTRIB InNormal = vertex.normal;
-ATTRIB InTexCoord = vertex.texcoord;
-
-#output
-OUTPUT OutPos = result.position;
-OUTPUT OutColor = result.color;
-OUTPUT OutTexCoord = result.texcoord;
-
-PARAM MVP[4] = { state.matrix.mvp }; # modelViewProjection matrix.
-TEMP Temp;
-TEMP TempColor;
-TEMP TempCompare;
-
-#transform position to clip space 
-DP4 Temp.x, MVP[0], InPos;
-DP4 Temp.y, MVP[1], InPos;
-DP4 Temp.z, MVP[2], InPos;
-DP4 Temp.w, MVP[3], InPos;
-
-# check if normal.y > 0.5
-SLT TempCompare, InNormal, {0.5,0.5,0.5,0.5};
-MUL TempCompare.z, TempCompare.y, 0.5;
-SUB TempCompare.x, 1.0, TempCompare.z;
-MOV TempCompare.y, TempCompare.x;
-MOV TempCompare.z, TempCompare.x;
-
-# calculate light color
-MUL OutColor, InColor, TempCompare;
-MOV OutColor.w, 1.0;          # we want alpha to be always 1
-MOV OutTexCoord, InTexCoord; # store texture coordinate
-MOV OutPos, Temp;
-
-END

client/shaders/the_darkness_of_light/opengl_vertex.glsl

@@ -1,16 +0,0 @@
-
-uniform mat4 mWorldViewProj;
-uniform mat4 mInvWorld;
-uniform mat4 mTransWorld;
-
-void main(void)
-{
-	gl_Position = mWorldViewProj * gl_Vertex;
-	
-	if(gl_Normal.y > 0.5)
-		gl_FrontColor = gl_BackColor = gl_Color;
-	else
-		gl_FrontColor = gl_BackColor = gl_Color * 0.5;
-
-	gl_TexCoord[0] = gl_MultiTexCoord0;
-}

src/game.cpp

@@ -24,6 +24,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <IGUIButton.h>
 #include <IGUIStaticText.h>
 #include <IGUIFont.h>
+#include <IMaterialRendererServices.h>
 #include "client.h"
 #include "server.h"
 #include "guiPauseMenu.h"
@@ -835,6 +836,49 @@ public:
 	}
 };
 
+class GameGlobalShaderConstantSetter : public IShaderConstantSetter
+{
+	Sky *m_sky;
+	bool *m_force_fog_off;
+	f32 *m_fog_range;
+
+public:
+	GameGlobalShaderConstantSetter(Sky *sky, bool *force_fog_off,
+			f32 *fog_range):
+		m_sky(sky),
+		m_force_fog_off(force_fog_off),
+		m_fog_range(fog_range)
+	{}
+	~GameGlobalShaderConstantSetter() {}
+
+	virtual void onSetConstants(video::IMaterialRendererServices *services,
+			bool is_highlevel)
+	{
+		if(!is_highlevel)
+			return;
+
+		// Background color
+		video::SColor bgcolor = m_sky->getBgColor();
+		video::SColorf bgcolorf(bgcolor);
+		float bgcolorfa[4] = {
+			bgcolorf.r,
+			bgcolorf.g,
+			bgcolorf.b,
+			bgcolorf.a,
+		};
+		services->setPixelShaderConstant("skyBgColor", bgcolorfa, 4);
+
+		// Fog distance
+		float fog_distance = *m_fog_range;
+		if(*m_force_fog_off)
+			fog_distance = 10000*BS;
+		services->setPixelShaderConstant("fogDistance", &fog_distance, 1);
+	}
+
+private:
+	IrrlichtDevice *m_device;
+};
+
 void the_game(
 	bool &kill,
 	bool random_input,
@@ -1250,6 +1294,7 @@ void the_game(
 	bool show_hud = true;
 	bool show_chat = true;
 	bool force_fog_off = false;
+	f32 fog_range = 100*BS;
 	bool disable_camera_update = false;
 	bool show_debug = g_settings->getBool("show_debug");
 	bool show_profiler_graph = false;
@@ -1259,6 +1304,12 @@ void the_game(
 	float time_of_day = 0;
 	float time_of_day_smooth = 0;
 
+	/*
+		Shader constants
+	*/
+	shsrc->addGlobalConstantSetter(
+			new GameGlobalShaderConstantSetter(sky, &force_fog_off, &fog_range));
+
 	/*
 		Main loop
 	*/
@@ -2434,7 +2485,6 @@ void the_game(
 			Fog range
 		*/
 	
-		f32 fog_range;
 		if(farmesh)
 		{
 			fog_range = BS*farmesh_range;

src/mapblock_mesh.cpp

@@ -1012,8 +1012,11 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data):
 		Convert MeshCollector to SMesh
 		Also store animation info
 	*/
-	video::E_MATERIAL_TYPE shadermat = m_gamedef->getShaderSource()->
+	bool enable_shaders = (g_settings->getS32("enable_shaders") > 0);
-			getShader("the_darkness_of_light").material;
+	video::E_MATERIAL_TYPE shadermat1 = m_gamedef->getShaderSource()->
+			getShader("test_shader_1").material;
+	video::E_MATERIAL_TYPE shadermat2 = m_gamedef->getShaderSource()->
+			getShader("test_shader_2").material;
 	for(u32 i = 0; i < collector.prebuffers.size(); i++)
 	{
 		PreMeshBuffer &p = collector.prebuffers[i];
@@ -1080,8 +1083,12 @@ MapBlockMesh::MapBlockMesh(MeshMakeData *data):
 		material.setTexture(0, p.tile.texture.atlas);
 		p.tile.applyMaterialOptions(material);
 
-		//if(material.MaterialType == video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF)
+		if(enable_shaders){
-			material.MaterialType = shadermat;
+			if(material.MaterialType == video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF)
+				material.MaterialType = shadermat1;
+			if(material.MaterialType == video::EMT_TRANSPARENT_VERTEX_ALPHA)
+				material.MaterialType = shadermat2;
+		}
 
 		// Create meshbuffer
 

src/shader.cpp

@@ -35,6 +35,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "EShaderTypes.h"
 #include "log.h"
 #include "gamedef.h"
+#include "strfnd.h" // trim()
 
 /*
 	A cache from shader name to shader path
@@ -171,10 +172,24 @@ private:
 	ShaderCallback: Sets constants that can be used in shaders
 */
 
-class ShaderCallback : public video::IShaderConstantSetCallBack
+class IShaderConstantSetterRegistry
 {
 public:
-	ShaderCallback(IrrlichtDevice *device): m_device(device) {}
+	virtual ~IShaderConstantSetterRegistry(){};
+	virtual void onSetConstants(video::IMaterialRendererServices *services,
+			bool is_highlevel, const std::string &name) = 0;
+};
+
+class ShaderCallback : public video::IShaderConstantSetCallBack
+{
+	IShaderConstantSetterRegistry *m_scsr;
+	std::string m_name;
+
+public:
+	ShaderCallback(IShaderConstantSetterRegistry *scsr, const std::string &name):
+		m_scsr(scsr),
+		m_name(name)
+	{}
 	~ShaderCallback() {}
 
 	virtual void OnSetConstants(video::IMaterialRendererServices *services, s32 userData)
@@ -184,6 +199,28 @@ public:
 
 		bool is_highlevel = userData;
 
+		m_scsr->onSetConstants(services, is_highlevel, m_name);
+	}
+};
+
+/*
+	MainShaderConstantSetter: Set basic constants required for almost everything
+*/
+
+class MainShaderConstantSetter : public IShaderConstantSetter
+{
+public:
+	MainShaderConstantSetter(IrrlichtDevice *device):
+		m_device(device)
+	{}
+	~MainShaderConstantSetter() {}
+
+	virtual void onSetConstants(video::IMaterialRendererServices *services,
+			bool is_highlevel)
+	{
+		video::IVideoDriver *driver = services->getVideoDriver();
+		assert(driver);
+
 		// set inverted world matrix
 		core::matrix4 invWorld = driver->getTransform(video::ETS_WORLD);
 		invWorld.makeInverse();
@@ -219,7 +256,7 @@ private:
 	ShaderSource
 */
 
-class ShaderSource : public IWritableShaderSource
+class ShaderSource : public IWritableShaderSource, public IShaderConstantSetterRegistry
 {
 public:
 	ShaderSource(IrrlichtDevice *device);
@@ -272,6 +309,14 @@ public:
 	// Shall be called from the main thread.
 	void rebuildShaders();
 
+	void addGlobalConstantSetter(IShaderConstantSetter *setter)
+	{
+		m_global_setters.push_back(setter);
+	}
+
+	void onSetConstants(video::IMaterialRendererServices *services,
+			bool is_highlevel, const std::string &name);
+
 private:
 
 	// The id of the thread that is allowed to use irrlicht directly
@@ -295,6 +340,10 @@ private:
 
 	// Queued shader fetches (to be processed by the main thread)
 	RequestQueue<std::string, u32, u8, u8> m_get_shader_queue;
+
+	// Global constant setters
+	// TODO: Delete these in the destructor
+	core::array<IShaderConstantSetter*> m_global_setters;
 };
 
 IWritableShaderSource* createShaderSource(IrrlichtDevice *device)
@@ -322,7 +371,7 @@ ShaderSource::ShaderSource(IrrlichtDevice *device):
 {
 	assert(m_device);
 
-	m_shader_callback = new ShaderCallback(device);
+	m_shader_callback = new ShaderCallback(this, "default");
 
 	m_shaderinfo_cache_mutex.Init();
 
@@ -331,6 +380,9 @@ ShaderSource::ShaderSource(IrrlichtDevice *device):
 	// Add a dummy ShaderInfo as the first index, named ""
 	m_shaderinfo_cache.push_back(ShaderInfo());
 	m_name_to_id[""] = 0;
+
+	// Add main global constant setter
+	addGlobalConstantSetter(new MainShaderConstantSetter(device));
 }
 
 ShaderSource::~ShaderSource()
@@ -532,6 +584,15 @@ void ShaderSource::rebuildShaders()
 	}
 }
 
+void ShaderSource::onSetConstants(video::IMaterialRendererServices *services,
+		bool is_highlevel, const std::string &name)
+{
+	for(u32 i=0; i<m_global_setters.size(); i++){
+		IShaderConstantSetter *setter = m_global_setters[i];
+		setter->onSetConstants(services, is_highlevel);
+	}
+}
+ 
 ShaderInfo generate_shader(std::string name, IrrlichtDevice *device,
 		video::IShaderConstantSetCallBack *callback,
 		SourceShaderCache *sourcecache)
@@ -546,7 +607,8 @@ ShaderInfo generate_shader(std::string name, IrrlichtDevice *device,
 	/*
 		Get the base material
 	*/
-	std::string base_material_name = sourcecache->getOrLoad(name, "base.txt");
+	std::string base_material_name =
+		trim(sourcecache->getOrLoad(name, "base.txt"));
 	for(s32 i = 0; video::sBuiltInMaterialTypeNames[i] != 0; i++){
 		if(video::sBuiltInMaterialTypeNames[i] == base_material_name){
 			shaderinfo.material = (video::E_MATERIAL_TYPE) i;

src/shader.h

@@ -51,6 +51,22 @@ struct ShaderInfo
 	ShaderInfo(): name(""), material(video::EMT_SOLID) {}
 };
 
+/*
+	Setter of constants for shaders
+*/
+
+namespace irr { namespace video {
+	class IMaterialRendererServices;
+} }
+
+class IShaderConstantSetter
+{
+public:
+	virtual ~IShaderConstantSetter(){};
+	virtual void onSetConstants(video::IMaterialRendererServices *services,
+			bool is_highlevel) = 0;
+};
+
 /*
 	ShaderSource creates and caches shaders.
 */
@@ -82,6 +98,7 @@ public:
 	virtual void insertSourceShader(const std::string &name_of_shader,
 		const std::string &filename, const std::string &program)=0;
 	virtual void rebuildShaders()=0;
+	virtual void addGlobalConstantSetter(IShaderConstantSetter *setter)=0;
 };
 
 IWritableShaderSource* createShaderSource(IrrlichtDevice *device);