x_ite 4.2.17 → 4.7.7

package/src/{x_ite/Browser/Shaders/Include/Shadow.h → assets/shaders/webgl1/include/Shadow.glsl}

@@ -1,6 +1,5 @@
-/* -*- Mode: C++; coding: utf-8; tab-width: 3; indent-tabs-mode: tab; c-basic-offset: 3 -*-*/
 
-#pragma X3D include "Pack.h"
+#pragma X3D include "Pack.glsl"
 
 #ifdef X3D_SHADOWS
 
@@ -55,7 +54,9 @@ getShadowDepth (const in int index, const in vec2 shadowCoord)
 float
 texture2DCompare (const in int index, const in vec2 texCoord, const in float compare)
 {
-	return step (getShadowDepth (index, texCoord), compare);
+	float shadowDepth = getShadowDepth (index, texCoord);
+
+	return (1.0 - step (1.0, shadowDepth)) * step (shadowDepth, compare);
 }
 
 float
@@ -119,25 +120,25 @@ cubeToUVCompact (in vec3 v, const float texelSizeY)
 	{
 		// zZ
 
-		if (v.z > 0.0)
-			planar .x = 4.0 - v.x;
+		if (v .z > 0.0)
+			planar .x = 4.0 - v .x;
 	}
 	else if (absV .x >= almostOne)
 	{
 		// xX
 
-		float signX = sign (v.x);
+		float signX = sign (v .x);
 
-		planar .x = v.z * signX + 2.0 * signX;
+		planar .x = v .z * signX + 2.0 * signX;
 	}
 	else if (absV .y >= almostOne)
 	{
 		// yY
 
-		float signY = sign (v.y);
+		float signY = sign (v .y);
 
-		planar .x = (v.x + 0.5 + signY) * 2.0;
-		planar .y = v.z * signY - 2.0;
+		planar .x = (v .x + 0.5 + signY) * 2.0;
+		planar .y = v .z * signY - 2.0;
 	}
 
 	// Transform to UV space
@@ -148,7 +149,7 @@ cubeToUVCompact (in vec3 v, const float texelSizeY)
 }
 
 mat4
-getPointLightRotation (const in vec3 vector)
+getPointLightRotations (const in vec3 vector)
 {
 	mat4 rotations [6];
 	rotations [0] = mat4 ( 0, 0 , 1, 0,   0, 1,  0, 0,  -1,  0,  0, 0,   0, 0, 0, 1);  // left
@@ -191,17 +192,16 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
 			                           0.0, 0.0, 0.5, 0.0,
 			                           0.5, 0.5, 0.5, 1.0);
 
-		// 90° fov, as used in PointLight shadow calculations.
 		const mat4 projectionMatrix = mat4 (1.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.0, -1.000025000312504, -1.0, 0, 0.0, -0.25000312503906297, 0.0);
 
 		vec2 texelSize = vec2 (1.0) / (float (light .shadowMapSize) * vec2 (4.0, 2.0));
 
 		// for point lights, the uniform @vShadowCoord is re-purposed to hold
 		// the vector from the light to the world-space position of the fragment.
-		vec4 shadowCoord     = light .shadowMatrix * vec4 (v, 1.0);
+		vec4 shadowCoord     = light .shadowMatrix * vec4 (vertex, 1.0);
 		vec3 lightToPosition = shadowCoord .xyz;
 
-		shadowCoord       = biasMatrix * (projectionMatrix * (getPointLightRotation (lightToPosition) * shadowCoord));
+		shadowCoord       = biasMatrix * (projectionMatrix * (getPointLightRotations (lightToPosition) * shadowCoord));
 		shadowCoord .z   -= light .shadowBias;
 		shadowCoord .xyz /= shadowCoord .w;
 
@@ -209,9 +209,9 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
 		//tex = texture2D (x3d_ShadowMap [0], cubeToUVCompact (lightToPosition, texelSize .y));
 
 		#if defined (X3D_PCF_FILTERING) || defined (X3D_PCF_SOFT_FILTERING)
-	
+
 			vec2 offset = vec2 (-1, 1) * (texelSize .y * 42.0);
-	
+
 			float value = (
 				texture2DCompare (index, cubeToUVCompact (lightToPosition + offset .xyy, texelSize .y), shadowCoord .z) +
 				texture2DCompare (index, cubeToUVCompact (lightToPosition + offset .yyy, texelSize .y), shadowCoord .z) +
@@ -223,7 +223,7 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
 				texture2DCompare (index, cubeToUVCompact (lightToPosition + offset .xxx, texelSize .y), shadowCoord .z) +
 				texture2DCompare (index, cubeToUVCompact (lightToPosition + offset .yxx, texelSize .y), shadowCoord .z)
 			) * (1.0 / 9.0);
-	
+
 			return light .shadowIntensity * value;
 
 		#else // no percentage-closer filtering
@@ -231,7 +231,7 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
 			float value = texture2DCompare (index, cubeToUVCompact (lightToPosition, texelSize .y), shadowCoord .z);
 
 			return light .shadowIntensity * value;
-	
+
 		#endif
 	}
 	else
@@ -239,16 +239,16 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
 		#if defined (X3D_PCF_FILTERING)
 
 			vec2 texelSize   = vec2 (1.0) / vec2 (light .shadowMapSize);
-			vec4 shadowCoord = light .shadowMatrix * vec4 (v, 1.0);
-	
+			vec4 shadowCoord = light .shadowMatrix * vec4 (vertex, 1.0);
+
 			shadowCoord .z   -= light .shadowBias;
 			shadowCoord .xyz /= shadowCoord .w;
-	
+
 			float dx0 = - texelSize .x;
 			float dy0 = - texelSize .y;
 			float dx1 = + texelSize .x;
 			float dy1 = + texelSize .y;
-	
+
 			float value = (
 				texture2DCompare (index, shadowCoord .xy + vec2 (dx0, dy0), shadowCoord .z) +
 				texture2DCompare (index, shadowCoord .xy + vec2 (0.0, dy0), shadowCoord .z) +
@@ -260,22 +260,22 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
 				texture2DCompare (index, shadowCoord .xy + vec2 (0.0, dy1), shadowCoord .z) +
 				texture2DCompare (index, shadowCoord .xy + vec2 (dx1, dy1), shadowCoord .z)
 			) * (1.0 / 9.0);
-	
+
 			return light .shadowIntensity * value;
 
 		#elif defined (X3D_PCF_SOFT_FILTERING)
 
 			vec2 texelSize   = vec2 (1.0) / vec2 (light .shadowMapSize);
-			vec4 shadowCoord = light .shadowMatrix * vec4 (v, 1.0);
-	
+			vec4 shadowCoord = light .shadowMatrix * vec4 (vertex, 1.0);
+
 			shadowCoord .z   -= light .shadowBias;
 			shadowCoord .xyz /= shadowCoord .w;
-	
+
 			float dx0 = - texelSize.x;
 			float dy0 = - texelSize.y;
 			float dx1 = + texelSize.x;
 			float dy1 = + texelSize.y;
-			
+
 			float value = (
 				texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx0, dy0), shadowCoord .z) +
 				texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (0.0, dy0), shadowCoord .z) +
@@ -287,18 +287,18 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
 				texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (0.0, dy1), shadowCoord .z) +
 				texture2DShadowLerp (index, texelSize, float (shadowMapSize), shadowCoord .xy + vec2 (dx1, dy1), shadowCoord .z)
 			) * ( 1.0 / 9.0 );
-	
+
 			return light .shadowIntensity * value;
 
 		#else // no percentage-closer filtering
 
-			vec4 shadowCoord = shadowMatrix * vec4 (v, 1.0);
-	
+			vec4 shadowCoord = shadowMatrix * vec4 (vertex, 1.0);
+
 			shadowCoord .z   -= shadowBias;
 			shadowCoord .xyz /= shadowCoord .w;
-	
+
 			float value = texture2DCompare (index, shadowCoord .xy, shadowCoord .z);
-	
+
 			return light .shadowIntensity * value;
 
 		#endif
@@ -307,4 +307,4 @@ getShadowIntensity (const in int index, const in x3d_LightSourceParameters light
 	return 0.0;
 }
 
-#endif
+#endif

package/src/assets/shaders/webgl1/include/Texture.glsl

@@ -0,0 +1,488 @@
+
+uniform int         x3d_NumTextures;
+uniform int         x3d_TextureType [x3d_MaxTextures]; // x3d_None, x3d_TextureType2D or x3d_TextureTypeCubeMapTexture
+uniform sampler2D   x3d_Texture2D [x3d_MaxTextures];
+uniform samplerCube x3d_CubeMapTexture [x3d_MaxTextures];
+
+#ifdef X3D_MULTI_TEXTURING
+
+#pragma X3D include "Perlin.glsl"
+
+#ifdef X3D_PROJECTIVE_TEXTURE_MAPPING
+uniform int       x3d_NumProjectiveTextures;
+uniform sampler2D x3d_ProjectiveTexture [x3d_MaxTextures];
+uniform mat4      x3d_ProjectiveTextureMatrix [x3d_MaxTextures];
+uniform vec3      x3d_ProjectiveTextureLocation [x3d_MaxTextures];
+#endif
+
+uniform vec4 x3d_MultiTextureColor;
+uniform x3d_MultiTextureParameters x3d_MultiTexture [x3d_MaxTextures];
+
+uniform x3d_TextureCoordinateGeneratorParameters x3d_TextureCoordinateGenerator [x3d_MaxTextures];
+
+vec4
+getTexCoord (const in int i)
+{
+	vec4 texCoord = vec4 (0.0);
+
+	#if x3d_MaxTextures > 0
+	if (i == 0)
+		texCoord = texCoord0;
+	#endif
+
+	#if x3d_MaxTextures > 1
+	else if (i == 1)
+		texCoord = texCoord1;
+	#endif
+
+	return texCoord;
+}
+
+vec4
+getTextureCoordinate (const in x3d_TextureCoordinateGeneratorParameters textureCoordinateGenerator, const in int i)
+{
+	int mode = textureCoordinateGenerator .mode;
+
+	if (mode == x3d_None)
+	{
+		return getTexCoord (i);
+	}
+	else if (mode == x3d_Sphere)
+	{
+		vec2 N = normalize (gl_FrontFacing ? normal : -normal) .xy;
+
+		return vec4 (N / 2.0 + 0.5, 0.0, 1.0);
+	}
+	else if (mode == x3d_CameraSpaceNormal)
+	{
+		vec3 N = normalize (gl_FrontFacing ? normal : -normal);
+
+		return vec4 (N, 1.0);
+	}
+	else if (mode == x3d_CameraSpacePosition)
+	{
+		return vec4 (vertex, 1.0);
+	}
+	else if (mode == x3d_CameraSpaceReflectionVector)
+	{
+		vec3 N = normalize (gl_FrontFacing ? normal : -normal);
+
+		return vec4 (reflect (normalize (vertex), -N), 1.0);
+	}
+	else if (mode == x3d_SphereLocal)
+	{
+		vec2 N = normalize (gl_FrontFacing ? localNormal : -localNormal) .xy;
+
+		return vec4 (N / 2.0 + 0.5, 0.0, 1.0);
+	}
+	else if (mode == x3d_Coord)
+	{
+		return vec4 (localVertex, 1.0);
+	}
+	else if (mode == x3d_CoordEye)
+	{
+		return vec4 (vertex, 1.0);
+	}
+	else if (mode == x3d_Noise)
+	{
+		vec3 scale       = vec3 (textureCoordinateGenerator .parameter [0], textureCoordinateGenerator .parameter [1], textureCoordinateGenerator .parameter [2]);
+		vec3 translation = vec3 (textureCoordinateGenerator .parameter [3], textureCoordinateGenerator .parameter [4], textureCoordinateGenerator .parameter [5]);
+
+		return vec4 (perlin (localVertex * scale + translation), 1.0);
+	}
+	else if (mode == x3d_NoiseEye)
+	{
+		vec3 scale       = vec3 (textureCoordinateGenerator .parameter [0], textureCoordinateGenerator .parameter [1], textureCoordinateGenerator .parameter [2]);
+		vec3 translation = vec3 (textureCoordinateGenerator .parameter [3], textureCoordinateGenerator .parameter [4], textureCoordinateGenerator .parameter [5]);
+
+		return vec4 (perlin (vertex * scale + translation), 1.0);
+	}
+	else if (mode == x3d_SphereReflect)
+	{
+		vec3  N   = normalize (gl_FrontFacing ? normal : -normal);
+		float eta = textureCoordinateGenerator .parameter [0];
+
+		return vec4 (refract (normalize (vertex), -N, eta), 1.0);
+	}
+	else if (mode == x3d_SphereReflectLocal)
+	{
+		vec3  N   = normalize (gl_FrontFacing ? localNormal : -localNormal);
+		float eta = textureCoordinateGenerator .parameter [0];
+		vec3  eye = vec3 (textureCoordinateGenerator .parameter [1], textureCoordinateGenerator .parameter [2], textureCoordinateGenerator .parameter [3]);
+
+		return vec4 (refract (normalize (localVertex - eye), -N, eta), 1.0);
+	}
+
+	return getTexCoord (i);
+}
+
+vec4
+getTexture2D (const in int i, const in vec2 texCoord)
+{
+	vec4 color = vec4 (0.0);
+
+	#if x3d_MaxTextures > 0
+	if (i == 0)
+		color = texture2D (x3d_Texture2D [0], texCoord);
+	#endif
+
+	#if x3d_MaxTextures > 1
+	else if (i == 1)
+		color = texture2D (x3d_Texture2D [1], texCoord);
+	#endif
+
+	return color;
+}
+
+vec4
+getTextureCube (const in int i, const in vec3 texCoord)
+{
+	vec4 color = vec4 (0.0);
+
+	#if x3d_MaxTextures > 0
+	if (i == 0)
+		color = textureCube (x3d_CubeMapTexture [0], texCoord);
+	#endif
+
+	#if x3d_MaxTextures > 1
+	else if (i == 1)
+		color = textureCube (x3d_CubeMapTexture [1], texCoord);
+	#endif
+
+	return color;
+}
+
+vec4
+getTextureColor (const in vec4 diffuseColor, const in vec4 specularColor)
+{
+	vec4 currentColor = diffuseColor;
+
+	for (int i = 0; i < x3d_MaxTextures; ++ i)
+	{
+		if (i == x3d_NumTextures)
+			break;
+
+		// Get texture color.
+
+		vec4 texCoord     = getTextureCoordinate (x3d_TextureCoordinateGenerator [i], i);
+		vec4 textureColor = vec4 (1.0);
+
+		texCoord .stp /= texCoord .q;
+
+		if ((x3d_GeometryType == x3d_Geometry2D) && (gl_FrontFacing == false))
+			texCoord .s = 1.0 - texCoord .s;
+
+		if (x3d_TextureType [i] == x3d_TextureType2D)
+		{
+			textureColor = getTexture2D (i, texCoord .st);
+		}
+	 	else if (x3d_TextureType [i] == x3d_TextureTypeCubeMapTexture)
+		{
+			textureColor = getTextureCube (i, texCoord .stp);
+		}
+
+		// Multi texturing
+
+		x3d_MultiTextureParameters multiTexture = x3d_MultiTexture [i];
+
+		vec4 arg1 = textureColor;
+		vec4 arg2 = currentColor;
+
+		// Source
+
+		int source = multiTexture .source;
+
+		if (source == x3d_Diffuse)
+		{
+			arg1 = diffuseColor;
+		}
+		else if (source == x3d_Specular)
+		{
+			arg1 = specularColor;
+		}
+		else if (source == x3d_Factor)
+		{
+			arg1 = x3d_MultiTextureColor;
+		}
+
+		// Function
+
+		int function = multiTexture .function;
+
+		if (function == x3d_Complement)
+		{
+			arg1 = 1.0 - arg1;
+		}
+		else if (function == x3d_AlphaReplicate)
+		{
+			arg1 .a = arg2 .a;
+		}
+
+		// Mode
+
+		int mode      = multiTexture .mode;
+		int alphaMode = multiTexture .alphaMode;
+
+		// RGB
+
+		if (mode == x3d_Replace)
+		{
+			currentColor .rgb = arg1 .rgb;
+		}
+		else if (mode == x3d_Modulate)
+		{
+			currentColor .rgb = arg1 .rgb * arg2 .rgb;
+		}
+		else if (mode == x3d_Modulate2X)
+		{
+			currentColor .rgb = (arg1 .rgb * arg2 .rgb) * 2.0;
+		}
+		else if (mode == x3d_Modulate4X)
+		{
+			currentColor .rgb = (arg1 .rgb * arg2 .rgb) * 4.0;
+		}
+		else if (mode == x3d_Add)
+		{
+			currentColor .rgb = arg1 .rgb + arg2 .rgb;
+		}
+		else if (mode == x3d_AddSigned)
+		{
+			currentColor .rgb = arg1 .rgb + arg2 .rgb - 0.5;
+		}
+		else if (mode == x3d_AddSigned2X)
+		{
+			currentColor .rgb = (arg1 .rgb + arg2 .rgb - 0.5) * 2.0;
+		}
+		else if (mode == x3d_AddSmooth)
+		{
+			currentColor .rgb = arg1 .rgb + (1.0 - arg1 .rgb) * arg2 .rgb;
+		}
+		else if (mode == x3d_Subtract)
+		{
+			currentColor .rgb = arg1 .rgb - arg2 .rgb;
+		}
+		else if (mode == x3d_BlendDiffuseAlpha)
+		{
+			currentColor .rgb = arg1 .rgb * diffuseColor .a + arg2 .rgb * (1.0 - diffuseColor .a);
+		}
+		else if (mode == x3d_BlendTextureAlpha)
+		{
+			currentColor .rgb = arg1 .rgb * arg1 .a + arg2 .rgb * (1.0 - arg1 .a);
+		}
+		else if (mode == x3d_BlendFactorAlpha)
+		{
+			currentColor .rgb = arg1 .rgb * x3d_MultiTextureColor .a + arg2 .rgb * (1.0 - x3d_MultiTextureColor .a);
+		}
+		else if (mode == x3d_BlendCurrentAlpha)
+		{
+			currentColor .rgb = arg1 .rgb * arg2 .a + arg2 .rgb * (1.0 - arg2 .a);
+		}
+		else if (mode == x3d_ModulateAlphaAddColor)
+		{
+			currentColor .rgb = arg1 .rgb + arg1 .a * arg2 .rgb;
+		}
+		else if (mode == x3d_ModulateInvAlphaAddColor)
+		{
+			currentColor .rgb = (1.0 - arg1 .a) * arg2 .rgb + arg1 .rgb;
+		}
+		else if (mode == x3d_ModulateInvColorAddAlpha)
+		{
+			currentColor .rgb = (1.0 - arg1 .rgb) * arg2 .rgb + arg1 .a;
+		}
+		else if (mode == x3d_DotProduct3)
+		{
+			currentColor .rgb = vec3 (dot (arg1 .rgb * 2.0 - 1.0, arg2 .rgb * 2.0 - 1.0));
+		}
+		else if (mode == x3d_SelectArg1)
+		{
+			currentColor .rgb = arg1 .rgb;
+		}
+		else if (mode == x3d_SelectArg2)
+		{
+			currentColor .rgb = arg2 .rgb;
+		}
+		else if (mode == x3d_Off)
+			;
+
+		// Alpha
+
+		if (alphaMode == x3d_Replace)
+		{
+			currentColor .a = arg1 .a;
+		}
+		else if (alphaMode == x3d_Modulate)
+		{
+			currentColor .a = arg1 .a * arg2 .a;
+		}
+		else if (alphaMode == x3d_Modulate2X)
+		{
+			currentColor .a = (arg1 .a * arg2 .a) * 2.0;
+		}
+		else if (alphaMode == x3d_Modulate4X)
+		{
+			currentColor .a = (arg1 .a * arg2 .a) * 4.0;
+		}
+		else if (alphaMode == x3d_Add)
+		{
+			currentColor .a = arg1 .a + arg2 .a;
+		}
+		else if (alphaMode == x3d_AddSigned)
+		{
+			currentColor .a = arg1 .a + arg2 .a - 0.5;
+		}
+		else if (alphaMode == x3d_AddSigned2X)
+		{
+			currentColor .a = (arg1 .a + arg2 .a - 0.5) * 2.0;
+		}
+		else if (alphaMode == x3d_AddSmooth)
+		{
+			currentColor .a = arg1 .a + (1.0 - arg1 .a) * arg2 .a;
+		}
+		else if (alphaMode == x3d_Subtract)
+		{
+			currentColor .a = arg1 .a - arg2 .a;
+		}
+		else if (alphaMode == x3d_BlendDiffuseAlpha)
+		{
+			currentColor .a = arg1 .a * diffuseColor .a + arg2 .a * (1.0 - diffuseColor .a);
+		}
+		else if (alphaMode == x3d_BlendTextureAlpha)
+		{
+			currentColor .a = arg1 .a * arg1 .a + arg2 .a * (1.0 - arg1 .a);
+		}
+		else if (alphaMode == x3d_BlendFactorAlpha)
+		{
+			currentColor .a = arg1 .a * x3d_MultiTextureColor .a + arg2 .a * (1.0 - x3d_MultiTextureColor .a);
+		}
+		else if (alphaMode == x3d_BlendCurrentAlpha)
+		{
+			currentColor .a = arg1 .a * arg2 .a + arg2 .a * (1.0 - arg2 .a);
+		}
+		else if (alphaMode == x3d_ModulateAlphaAddColor)
+		{
+			currentColor .a = arg1 .a + arg1 .a * arg2 .a;
+		}
+		else if (alphaMode == x3d_ModulateInvAlphaAddColor)
+		{
+			currentColor .a = (1.0 - arg1 .a) * arg2 .a + arg1 .a;
+		}
+		else if (alphaMode == x3d_ModulateInvColorAddAlpha)
+		{
+			currentColor .a = (1.0 - arg1 .a) * arg2 .a + arg1 .a;
+		}
+		else if (alphaMode == x3d_DotProduct3)
+		{
+			currentColor .a = dot (arg1 .rgb * 2.0 - 1.0, arg2 .rgb * 2.0 - 1.0);
+		}
+		else if (alphaMode == x3d_SelectArg1)
+		{
+			currentColor .a = arg1 .a;
+		}
+		else if (alphaMode == x3d_SelectArg2)
+		{
+			currentColor .a = arg2 .a;
+		}
+		else if (alphaMode == x3d_Off)
+			;
+	}
+
+	return currentColor;
+}
+
+#ifdef X3D_PROJECTIVE_TEXTURE_MAPPING
+vec4
+getProjectiveTexture (const in int i, const in vec2 texCoord)
+{
+	vec4 color = vec4 (0.0);
+
+	#if x3d_MaxTextures > 0
+	if (i == 0)
+		color = texture2D (x3d_ProjectiveTexture [0], texCoord);
+	#endif
+
+	#if x3d_MaxTextures > 1
+	else if (i == 1)
+		color = texture2D (x3d_ProjectiveTexture [1], texCoord);
+	#endif
+
+	return color;
+}
+
+vec4
+getProjectiveTextureColor (in vec4 currentColor)
+{
+	if (x3d_NumProjectiveTextures > 0)
+	{
+		vec3 N = gl_FrontFacing ? normal : -normal;
+
+		for (int i = 0; i < x3d_MaxTextures; ++ i)
+		{
+			if (i == x3d_NumProjectiveTextures)
+				break;
+
+			vec4 texCoord = x3d_ProjectiveTextureMatrix [i] * vec4 (vertex, 1.0);
+
+			texCoord .stp /= texCoord .q;
+
+			if (texCoord .s < 0.0 || texCoord .s > 1.0)
+				continue;
+
+			if (texCoord .t < 0.0 || texCoord .t > 1.0)
+				continue;
+
+			if (texCoord .p < 0.0 || texCoord .p > 1.0)
+				continue;
+
+			// We do not need to normalze p, as we only need the sign of the dot product.
+			vec3 p = x3d_ProjectiveTextureLocation [i] - vertex;
+
+			if (dot (N, p) < 0.0)
+				continue;
+
+			currentColor *= getProjectiveTexture (i, texCoord .st);
+		}
+	}
+
+	return currentColor;
+}
+#else
+vec4
+getProjectiveTextureColor (in vec4 currentColor)
+{
+	return currentColor;
+}
+#endif
+
+#else
+
+vec4
+getTextureColor (const in vec4 diffuseColor, const in vec4 specularColor)
+{
+	// Get texture color.
+
+	vec4 texCoord     = texCoord0;
+	vec4 textureColor = vec4 (1.0);
+
+	texCoord .stp /= texCoord .q;
+
+	if ((x3d_GeometryType == x3d_Geometry2D) && (gl_FrontFacing ? false : true))
+		texCoord .s = 1.0 - texCoord .s;
+
+	if (x3d_TextureType [0] == x3d_TextureType2D)
+	{
+		textureColor = texture2D (x3d_Texture2D [0], texCoord .st);
+	}
+ 	else if (x3d_TextureType [0] == x3d_TextureTypeCubeMapTexture)
+	{
+		textureColor = textureCube (x3d_CubeMapTexture [0], texCoord .stp);
+	}
+
+	return diffuseColor * textureColor;
+}
+
+vec4
+getProjectiveTextureColor (in vec4 currentColor)
+{
+	return currentColor;
+}
+#endif

package/src/assets/shaders/webgl2/Background.fs

@@ -0,0 +1,19 @@
+#version 300 es
+
+precision highp float;
+precision highp int;
+
+in vec4 color;  // color
+in vec3 vertex; // point on geometry
+
+out vec4 x3d_FragColor;
+
+#pragma X3D include "include/ClipPlanes.glsl"
+
+void
+main ()
+{
+	clip ();
+
+	x3d_FragColor = color;
+}

package/src/assets/shaders/webgl2/Background.vs

@@ -0,0 +1,23 @@
+#version 300 es
+
+precision highp float;
+precision highp int;
+
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+
+in vec4 x3d_Color;
+in vec4 x3d_Vertex;
+
+out vec4 color;  // color
+out vec3 vertex; // point on geometry
+
+void
+main ()
+{
+	vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+
+	color       = x3d_Color;
+	vertex      = position .xyz;
+	gl_Position = x3d_ProjectionMatrix * position;
+}