SuperTuxKart 1.5 upstream source (from official release tarball)

data/shaders/irrlicht/COGLES2FixedPipeline.fsh

@@ -0,0 +1,223 @@
+precision mediump float;
+
+/* Definitions */
+
+#define Solid 0
+#define Solid2Layer 1
+#define LightMap 2
+#define DetailMap 3
+#define SphereMap 4
+#define Reflection2Layer 5
+#define TransparentAlphaChannel 6
+#define TransparentAlphaChannelRef 7
+#define TransparentVertexAlpha 8
+#define TransparentReflection2Layer 9
+#define StkGrass 10
+#define StkBlend 11
+
+/* Uniforms */
+
+uniform int uMaterialType;
+
+uniform float uHueChange;
+uniform vec4 uVertexColor;
+
+uniform bool uTextureUsage0;
+//uniform bool uTextureUsage1;
+
+uniform sampler2D uTextureUnit0;
+//uniform sampler2D uTextureUnit1;
+
+/* Varyings */
+
+varying vec2 varTexCoord0;
+//varying vec2 varTexCoord1;
+varying vec4 varVertexColor;
+varying float varEyeDist;
+
+vec3 rgbToHsv(vec3 c)
+{
+	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+	vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+	vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+
+	float d = q.x - min(q.w, q.y);
+	float e = 1.0e-10;
+	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+vec3 hsvToRgb(vec3 c)
+{
+	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+vec4 renderSolid()
+{
+	vec4 Color = vec4(1.0, 1.0, 1.0, 1.0);
+	if(uTextureUsage0)
+	{
+		Color *= texture2D(uTextureUnit0, varTexCoord0);
+		if (uHueChange > 0.0)
+		{
+			float f_hue_change = 0.66;
+			float mask = Color.a;
+			vec3 old_hsv = rgbToHsv(Color.rgb);
+			float mask_step = step(mask, 0.5);
+			float saturation = mask * 1.825;
+			vec2 new_xy = mix(vec2(old_hsv.x, old_hsv.y), vec2(uHueChange,
+				max(old_hsv.y, saturation)), vec2(mask_step, mask_step));
+			Color.rgb = hsvToRgb(vec3(new_xy.x, new_xy.y, old_hsv.z));
+		}
+		vec3 mixed_color = varVertexColor.rgb * uVertexColor.rgb;
+		Color.rgb *= mixed_color;
+		Color.a = 1.0;
+	}
+	else
+	{
+		Color = varVertexColor * uVertexColor;
+		Color.a = 1.0;
+	}
+	return Color;
+}
+
+vec4 render2LayerSolid()
+{
+	float BlendFactor = varVertexColor.a;
+	
+	vec4 Texel0 = texture2D(uTextureUnit0, varTexCoord0);
+	//vec4 Texel1 = texture2D(uTextureUnit1, varTexCoord1);
+	
+	vec4 Color = Texel0 * BlendFactor;
+	//vec4 Color += Texel1 * (1.0 - BlendFactor);
+	
+	return Color;
+}
+
+vec4 renderLightMap()
+{
+	vec4 Texel0 = texture2D(uTextureUnit0, varTexCoord0);
+	//vec4 Texel1 = texture2D(uTextureUnit1, varTexCoord1);
+	
+	vec4 Color = Texel0 * 4.0;
+	//Color *= Texel1;
+	Color.a = Texel0.a * Texel0.a;
+	
+	return Color;
+}
+
+vec4 renderDetailMap()
+{
+	vec4 Texel0 = texture2D(uTextureUnit0, varTexCoord0);
+	//vec4 Texel1 = texture2D(uTextureUnit1, varTexCoord1);
+	
+	vec4 Color = Texel0;
+	//Color += Texel1 - 0.5;
+	
+	return Color;
+}
+
+vec4 renderReflection2Layer()
+{
+	vec4 Color = varVertexColor;
+	
+	vec4 Texel0 = texture2D(uTextureUnit0, varTexCoord0);
+	//vec4 Texel1 = texture2D(uTextureUnit1, varTexCoord1);
+	
+	Color *= Texel0;
+	//Color *= Texel1;
+	
+	return Color;
+}
+
+vec4 renderTransparent()
+{
+	vec4 Color = vec4(1.0, 1.0, 1.0, 1.0);
+
+	if(uTextureUsage0)
+	{
+		Color *= texture2D(uTextureUnit0, varTexCoord0);
+		if (uHueChange > 0.0)
+		{
+			vec3 old_hsv = rgbToHsv(Color.rgb);
+			vec2 new_xy = vec2(uHueChange, old_hsv.y);
+			vec3 new_color = hsvToRgb(vec3(new_xy.x, new_xy.y, old_hsv.z));
+			Color.rgb = vec3(new_color.r, new_color.g, new_color.b);
+		}
+	}
+
+	return Color;
+}
+
+vec4 renderTransparentVertexColor()
+{
+	vec4 Color = vec4(1.0, 1.0, 1.0, 1.0);
+	if(uTextureUsage0)
+	{
+		Color *= texture2D(uTextureUnit0, varTexCoord0);
+		if (uHueChange > 0.0)
+		{
+			vec3 old_hsv = rgbToHsv(Color.rgb);
+			vec2 new_xy = vec2(uHueChange, old_hsv.y);
+			vec3 new_color = hsvToRgb(vec3(new_xy.x, new_xy.y, old_hsv.z));
+			Color.rgb = vec3(new_color.r, new_color.g, new_color.b);
+		}
+		vec4 mixed_color = varVertexColor * uVertexColor;
+		Color *= mixed_color;
+	}
+
+	return Color;
+}
+
+void main ()
+{
+    if (uMaterialType == Solid)
+		gl_FragColor = renderSolid();
+	else if(uMaterialType == Solid2Layer)
+		gl_FragColor = render2LayerSolid();
+	else if(uMaterialType == LightMap)
+		gl_FragColor = renderSolid();
+	else if(uMaterialType == DetailMap)
+		gl_FragColor = renderDetailMap();
+	else if(uMaterialType == SphereMap)
+		gl_FragColor = renderSolid();
+	else if(uMaterialType == Reflection2Layer)
+		gl_FragColor = renderReflection2Layer();
+	else if(uMaterialType == TransparentAlphaChannel)
+		gl_FragColor = renderTransparent();
+	else if(uMaterialType == TransparentAlphaChannelRef)
+	{
+		vec4 Color = renderTransparentVertexColor();
+		if (Color.a < 0.5)
+			discard;
+		gl_FragColor = Color;
+	}
+	else if(uMaterialType == StkGrass)
+	{
+		vec4 Color = renderTransparent();
+		if (Color.a < 0.5)
+			discard;
+		gl_FragColor = Color;
+	}
+	else if(uMaterialType == StkBlend)
+	{
+		gl_FragColor = renderTransparentVertexColor();
+	}
+	else if(uMaterialType == TransparentVertexAlpha)
+	{
+		vec4 Color = renderTransparent();
+		Color.a = varVertexColor.a;
+		
+		gl_FragColor = Color * uVertexColor;
+	}
+	else if(uMaterialType == TransparentReflection2Layer)
+	{
+		vec4 Color = renderReflection2Layer();
+		Color.a = varVertexColor.a;
+		
+		gl_FragColor = Color;
+	}
+	else
+		gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
+}

data/shaders/irrlicht/COGLES2FixedPipeline.vsh

@@ -0,0 +1,33 @@
+/* Attributes */
+
+attribute vec3 inVertexPosition;
+attribute vec3 inVertexNormal;
+attribute vec4 inVertexColor;
+attribute vec2 inTexCoord0;
+//attribute vec2 inTexCoord1;
+
+/* Uniforms */
+
+uniform mat4 uMvpMatrix;
+
+uniform vec2 uTextureTrans0;
+//uniform mat4 uTextureMatrix1;
+
+/* Varyings */
+
+varying vec2 varTexCoord0;
+//varying vec2 varTexCoord1;
+varying vec4 varVertexColor;
+varying float varEyeDist;
+
+void main(void)
+{
+	gl_Position = uMvpMatrix * vec4(inVertexPosition,1.0);
+
+	varTexCoord0 = inTexCoord0 + uTextureTrans0;
+
+	//vec4 TexCoord1 = vec4(inTexCoord1.x, inTexCoord1.y, 0.0, 0.0);
+	//varTexCoord1 = vec4(uTextureMatrix1 * TexCoord1).xy;
+
+	varVertexColor = inVertexColor.zyxw;
+}

data/shaders/irrlicht/COGLES2NormalMap.fsh

@@ -0,0 +1,36 @@
+// Copyright (C) 2009-2010 Amundis
+// Heavily based on the OpenGL driver implemented by Nikolaus Gebhardt
+// and OpenGL ES driver implemented by Christian Stehno
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+#define MAX_LIGHTS 2
+
+precision mediump float;
+
+uniform sampler2D texture0;
+uniform sampler2D texture1;
+
+varying vec4 varTexCoord;
+varying vec3 varLightVector[MAX_LIGHTS];
+varying vec4 varLightColor[MAX_LIGHTS];
+
+varying vec4 debug;
+
+void main(void)
+{
+	// fetch color and normal map
+	vec4 normalMap = texture2D(texture1, varTexCoord.xy) *  2.0 - 1.0;
+	vec4 colorMap  = texture2D(texture0, varTexCoord.xy);
+	
+	// calculate color of light 0
+	vec4 color = clamp(varLightColor[0], 0.0, 1.0) * dot(normalMap.xyz, normalize(varLightVector[0].xyz));
+	
+	// calculate color of light 1
+	color += clamp(varLightColor[1], 0.0, 1.0) * dot(normalMap.xyz, normalize(varLightVector[1].xyz));
+
+	//luminance * base color
+	color *= colorMap;
+	color.a = varLightColor[0].a;
+	
+	gl_FragColor = color;
+}

data/shaders/irrlicht/COGLES2NormalMap.vsh

@@ -0,0 +1,69 @@
+// Copyright (C) 2009-2010 Amundis
+// Heavily based on the OpenGL driver implemented by Nikolaus Gebhardt
+// and OpenGL ES driver implemented by Christian Stehno
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+#define MAX_LIGHTS 2
+
+attribute vec4 inVertexPosition;
+attribute vec4 inVertexColor;
+attribute vec4 inTexCoord0;
+attribute vec3 inVertexNormal;
+attribute vec3 inVertexTangent;
+attribute vec3 inVertexBinormal;
+
+uniform mat4 uMvpMatrix;
+uniform vec4 uLightPos[MAX_LIGHTS];
+uniform vec4 uLightColor[MAX_LIGHTS];
+
+varying vec4 varTexCoord;
+varying vec3 varLightVector[MAX_LIGHTS];
+varying vec4 varLightColor[MAX_LIGHTS];
+
+varying vec4 debug;
+
+void main(void)
+{
+	debug = vec4(inVertexNormal, 1.0);
+	// transform position to clip space
+	gl_Position = uMvpMatrix * inVertexPosition;
+	
+	// vertex - lightpositions
+	vec4 tempLightVector0 = uLightPos[0] - inVertexPosition;
+	vec4 tempLightVector1 = uLightPos[1] - inVertexPosition;
+	
+	// transform the light vector 1 with U, V, W
+	varLightVector[0].x = dot(inVertexTangent,  tempLightVector0.xyz);
+	varLightVector[0].y = dot(inVertexBinormal, tempLightVector0.xyz);
+	varLightVector[0].z = dot(inVertexNormal,   tempLightVector0.xyz);
+
+	
+	// transform the light vector 2 with U, V, W
+	varLightVector[1].x = dot(inVertexTangent,  tempLightVector1.xyz);
+	varLightVector[1].y = dot(inVertexBinormal, tempLightVector1.xyz);
+	varLightVector[1].z = dot(inVertexNormal,   tempLightVector1.xyz);
+
+	// calculate attenuation of light 0
+	varLightColor[0].w = 0.0;
+	varLightColor[0].x = dot(tempLightVector0, tempLightVector0);
+	varLightColor[0].x *= uLightColor[0].w;
+	varLightColor[0] = vec4(inversesqrt(varLightColor[0].x));
+	varLightColor[0] *= uLightColor[0];
+	
+	// normalize light vector 0
+	varLightVector[0] = normalize(varLightVector[0]);
+	
+	// calculate attenuation of light 1
+	varLightColor[1].w = 0.0;
+	varLightColor[1].x = dot(tempLightVector1, tempLightVector1);
+	varLightColor[1].x *= uLightColor[1].w;
+	varLightColor[1] = vec4(inversesqrt(varLightColor[1].x));
+	varLightColor[1] *= uLightColor[1];
+	
+	// normalize light vector 1
+	varLightVector[1] = normalize(varLightVector[1]);
+	
+	// move out texture coordinates and original alpha value
+	varTexCoord = inTexCoord0;
+	varLightColor[0].a = inVertexColor.a;
+}

data/shaders/irrlicht/COGLES2ParallaxMap.fsh

@@ -0,0 +1,49 @@
+// Copyright (C) 2009-2010 Amundis
+// Heavily based on the OpenGL driver implemented by Nikolaus Gebhardt
+// and OpenGL ES driver implemented by Christian Stehno
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+#define MAX_LIGHTS 2
+
+precision mediump float;
+
+uniform sampler2D texture0;
+uniform sampler2D texture1;
+
+//uniform vec4 uLightDiffuse[MAX_LIGHTS];
+uniform float uHeightScale;
+
+varying vec4 varTexCoord;
+varying vec3 varLightVector[MAX_LIGHTS];
+varying vec4 varLightColor[MAX_LIGHTS];
+varying vec3 varEyeVector;
+
+varying vec4 debug;
+
+void main(void)
+{
+	// fetch color and normal map
+	vec4 normalMap = texture2D(texture1, varTexCoord.xy) *  2.0 - 1.0;
+
+	// height = height * scale
+	normalMap *= uHeightScale;
+	
+	// calculate new texture coord: height * eye + oldTexCoord
+	vec2 offset = varEyeVector.xy * normalMap.w + varTexCoord.xy;
+
+	// fetch new textures
+	vec4 colorMap  = texture2D(texture0, offset);
+	normalMap = normalize(texture2D(texture1, offset) * 2.0 - 1.0); 
+	
+	// calculate color of light 0
+	vec4 color = clamp(varLightColor[0], 0.0, 1.0) * dot(normalMap.xyz, normalize(varLightVector[0].xyz));
+	
+	// calculate color of light 1
+	color += clamp(varLightColor[1], 0.0, 1.0) * dot(normalMap.xyz, normalize(varLightVector[1].xyz));
+
+	//luminance * base color
+	color *= colorMap;
+	color.a = varLightColor[0].a;
+	
+	gl_FragColor = color;
+}

data/shaders/irrlicht/COGLES2ParallaxMap.vsh

@@ -0,0 +1,81 @@
+// Copyright (C) 2009-2010 Amundis
+// Heavily based on the OpenGL driver implemented by Nikolaus Gebhardt
+// and OpenGL ES driver implemented by Christian Stehno
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+#define MAX_LIGHTS 2
+
+attribute vec4 inVertexPosition;
+attribute vec4 inVertexColor;
+attribute vec4 inTexCoord0;
+attribute vec3 inVertexNormal;
+attribute vec3 inVertexTangent;
+attribute vec3 inVertexBinormal;
+
+uniform mat4 uMvpMatrix;
+uniform vec4 uLightPos[MAX_LIGHTS];
+uniform vec4 uLightColor[MAX_LIGHTS];
+uniform vec3 uEyePos;
+
+varying vec4 varTexCoord;
+varying vec3 varLightVector[MAX_LIGHTS];
+varying vec4 varLightColor[MAX_LIGHTS];
+varying vec3 varEyeVector;
+
+varying vec4 debug;
+
+void main(void)
+{
+	debug = vec4(inVertexNormal, 1.0);
+	// transform position to clip space
+	gl_Position = uMvpMatrix * inVertexPosition;
+	
+	// vertex - lightpositions
+	vec4 tempLightVector0 = uLightPos[0] - inVertexPosition;
+	vec4 tempLightVector1 = uLightPos[1] - inVertexPosition;
+	
+	// eye vector
+	vec4 Temp = vec4(uEyePos, 1.0) - inVertexPosition;
+	
+	// transform the light vector 1 with U, V, W
+	varLightVector[0].x = dot(inVertexTangent,  tempLightVector0.xyz);
+	varLightVector[0].y = dot(inVertexBinormal, tempLightVector0.xyz);
+	varLightVector[0].z = dot(inVertexNormal,   tempLightVector0.xyz);
+
+	
+	// transform the light vector 2 with U, V, W
+	varLightVector[1].x = dot(inVertexTangent,  tempLightVector1.xyz);
+	varLightVector[1].y = dot(inVertexBinormal, tempLightVector1.xyz);
+	varLightVector[1].z = dot(inVertexNormal,   tempLightVector1.xyz);
+	
+	// transform the eye vector with U, V, W 
+	varEyeVector.x = dot(inVertexTangent,  Temp.xyz);
+	varEyeVector.y = dot(inVertexBinormal, Temp.xyz);
+	varEyeVector.z = dot(inVertexNormal,   Temp.xyz);
+	varEyeVector *= vec3(1.0,-1.0, -1.0);
+	varEyeVector = normalize(varEyeVector);
+
+	// calculate attenuation of light 0
+	varLightColor[0].w = 0.0;
+	varLightColor[0].x = dot(tempLightVector0, tempLightVector0);
+	varLightColor[0].x *= uLightColor[0].w;
+	varLightColor[0] = vec4(inversesqrt(varLightColor[0].x));
+	varLightColor[0] *= uLightColor[0];
+	
+	// normalize light vector 0
+	varLightVector[0] = normalize(varLightVector[0]);
+	
+	// calculate attenuation of light 1
+	varLightColor[1].w = 0.0;
+	varLightColor[1].x = dot(tempLightVector1, tempLightVector1);
+	varLightColor[1].x *= uLightColor[1].w;
+	varLightColor[1] = vec4(inversesqrt(varLightColor[1].x));
+	varLightColor[1] *= uLightColor[1];
+	
+	// normalize light vector 1
+	varLightVector[1] = normalize(varLightVector[1]);
+	
+	// move out texture coordinates and original alpha value
+	varTexCoord = inTexCoord0;
+	varLightColor[0].a = inVertexColor.a;
+}

data/shaders/irrlicht/COGLES2Renderer2D.fsh

@@ -0,0 +1,23 @@
+// Copyright (C) 2009-2010 Amundis
+// Heavily based on the OpenGL driver implemented by Nikolaus Gebhardt
+// and OpenGL ES driver implemented by Christian Stehno
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+precision mediump float;
+
+uniform bool uUseTexture;
+uniform sampler2D uTextureUnit;
+
+varying vec4 vVertexColor;
+varying vec2 vTexCoord;
+
+void main(void)
+{
+	vec4 Color = vVertexColor;
+
+	if(uUseTexture)
+		Color *= texture2D(uTextureUnit, vTexCoord);
+	
+	gl_FragColor = Color;
+}

data/shaders/irrlicht/COGLES2Renderer2D.vsh

@@ -0,0 +1,21 @@
+// Copyright (C) 2009-2010 Amundis
+// Heavily based on the OpenGL driver implemented by Nikolaus Gebhardt
+// and OpenGL ES driver implemented by Christian Stehno
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+attribute vec4 inVertexPosition;
+attribute vec4 inVertexColor;
+attribute vec2 inTexCoord0;
+
+uniform mat4 uOrthoMatrix;
+
+varying vec4 vVertexColor;
+varying vec2 vTexCoord;
+
+void main(void)
+{
+	gl_Position = uOrthoMatrix * inVertexPosition;
+	vVertexColor = inVertexColor.bgra;
+	vTexCoord = inTexCoord0;
+}