x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/Shaders/X3DProgrammableShaderObject.js

@@ -48,51 +48,66 @@
 
 
 define ([
-	"x_ite/Fields",
 	"x_ite/Bits/X3DCast",
 	"x_ite/Bits/X3DConstants",
 	"x_ite/Components/Navigation/OrthoViewpoint",
 	"standard/Math/Numbers/Matrix3",
 ],
-function (Fields,
-          X3DCast,
+function (X3DCast,
           X3DConstants,
           OrthoViewpoint,
           Matrix3)
 {
 "use strict";
 
-	var matrix3 = new Matrix3 ();
-
 	function X3DProgrammableShaderObject (executionContext)
 	{
 		this .addType (X3DConstants .X3DProgrammableShaderObject);
 
-		this .x3d_ClipPlane             = [ ];
-		this .x3d_LightType             = [ ];
-		this .x3d_LightOn               = [ ];
-		this .x3d_LightColor            = [ ];
-		this .x3d_LightIntensity        = [ ];
-		this .x3d_LightAmbientIntensity = [ ];
-		this .x3d_LightAttenuation      = [ ];
-		this .x3d_LightLocation         = [ ];
-		this .x3d_LightDirection        = [ ];
-		this .x3d_LightBeamWidth        = [ ];
-		this .x3d_LightCutOffAngle      = [ ];
-		this .x3d_LightRadius           = [ ];
-		this .x3d_LightMatrix           = [ ];
-		this .x3d_ShadowIntensity       = [ ];
-		this .x3d_ShadowColor           = [ ];
-		this .x3d_ShadowBias            = [ ];
-		this .x3d_ShadowMatrix          = [ ];
-		this .x3d_ShadowMapSize         = [ ];
-		this .x3d_ShadowMap             = [ ];
-
-		this .numClipPlanes   = 0;
-		this .numGlobalLights = 0;
-		this .numLights       = 0;
-
-		this .textures = new Map ();
+		this .x3d_ClipPlane                           = [ ];
+		this .x3d_LightType                           = [ ];
+		this .x3d_LightOn                             = [ ];
+		this .x3d_LightColor                          = [ ];
+		this .x3d_LightIntensity                      = [ ];
+		this .x3d_LightAmbientIntensity               = [ ];
+		this .x3d_LightAttenuation                    = [ ];
+		this .x3d_LightLocation                       = [ ];
+		this .x3d_LightDirection                      = [ ];
+		this .x3d_LightBeamWidth                      = [ ];
+		this .x3d_LightCutOffAngle                    = [ ];
+		this .x3d_LightRadius                         = [ ];
+		this .x3d_LightMatrix                         = [ ];
+		this .x3d_ShadowIntensity                     = [ ];
+		this .x3d_ShadowColor                         = [ ];
+		this .x3d_ShadowBias                          = [ ];
+		this .x3d_ShadowMatrix                        = [ ];
+		this .x3d_ShadowMapSize                       = [ ];
+		this .x3d_ShadowMap                           = [ ];
+		this .x3d_TextureType                         = [ ];
+		this .x3d_Texture2D                           = [ ];
+		this .x3d_Texture3D                           = [ ];
+		this .x3d_CubeMapTexture                      = [ ];
+		this .x3d_MultiTextureMode                    = [ ];
+		this .x3d_MultiTextureAlphaMode               = [ ];
+		this .x3d_MultiTextureSource                  = [ ];
+		this .x3d_MultiTextureFunction                = [ ];
+		this .x3d_TextureCoordinateGeneratorMode      = [ ];
+		this .x3d_TextureCoordinateGeneratorParameter = [ ];
+		this .x3d_ProjectiveTexture                   = [ ];
+		this .x3d_ProjectiveTextureMatrix             = [ ];
+		this .x3d_ProjectiveTextureLocation           = [ ];
+		this .x3d_TexCoord                            = [ ];
+		this .x3d_TextureMatrix                       = [ ];
+
+		this .numClipPlanes               = 0;
+		this .fogNode                     = null;
+		this .numLights                   = 0;
+		this .numGlobalLights             = 0;
+		this .lightNodes                  = [ ];
+		this .numProjectiveTextures       = 0;
+		this .numGlobalProjectiveTextures = 0;
+		this .projectiveTextureNodes      = [ ];
+		this .textures                    = new Map ();
 	}
 
 	X3DProgrammableShaderObject .prototype =
@@ -100,19 +115,11 @@ function (Fields,
 		constructor: X3DProgrammableShaderObject,
 		initialize: function ()
 		{
-			var browser = this .getBrowser ();
+			const browser = this .getBrowser ();
 
 			this .x3d_MaxClipPlanes = browser .getMaxClipPlanes ();
 			this .x3d_MaxLights     = browser .getMaxLights ();
 			this .x3d_MaxTextures   = browser .getMaxTextures ();
-
-			var defaultClipPlanes = [ ];
-
-			for (var i = 0, length = this .x3d_MaxClipPlanes; i < length; ++ i)
-				defaultClipPlanes .push (0, 0, -1, 0);
-
-			this .defaultClipPlanesArray = new Float32Array (defaultClipPlanes);
-			this .textureTypeArray       = new Int32Array (this .x3d_MaxTextures);
 		},
 		hasUserDefinedFields: function ()
 		{
@@ -120,17 +127,15 @@ function (Fields,
 		},
 		bindAttributeLocations: function (gl, program)
 		{
-			gl .bindAttribLocation (program, 3, "x3d_Color");
-			gl .bindAttribLocation (program, 2, "x3d_TexCoord");
-			gl .bindAttribLocation (program, 1, "x3d_Normal");
 			gl .bindAttribLocation (program, 0, "x3d_Vertex");
 		},
 		getDefaultUniforms: function ()
 		{
 			// Get uniforms and attributes.
 
-			var
-				gl      = this .getBrowser () .getContext (),
+			const
+				browser = this .getBrowser (),
+				gl      = browser .getContext (),
 				program = this .getProgram ();
 
 			this .x3d_LogarithmicFarFactor1_2 = gl .getUniformLocation (program, "x3d_LogarithmicFarFactor1_2");
@@ -140,21 +145,36 @@ function (Fields,
 
 			this .x3d_ClipPlanes = gl .getUniformLocation (program, "x3d_ClipPlane");
 
-			for (var i = 0; i < this .x3d_MaxClipPlanes; ++ i)
-				this .x3d_ClipPlane [i]  = gl .getUniformLocation (program, "x3d_ClipPlane[" + i + "]");
+			for (let i = 0; i < this .x3d_MaxClipPlanes; ++ i)
+				this .x3d_ClipPlane [i] = gl .getUniformLocation (program, "x3d_ClipPlane[" + i + "]");
 
 			this .x3d_FogType            = this .getUniformLocation (gl, program, "x3d_Fog.type",            "x3d_FogType");
 			this .x3d_FogColor           = this .getUniformLocation (gl, program, "x3d_Fog.color",           "x3d_FogColor");
 			this .x3d_FogVisibilityRange = this .getUniformLocation (gl, program, "x3d_Fog.visibilityRange", "x3d_FogVisibilityRange");
 			this .x3d_FogMatrix          = this .getUniformLocation (gl, program, "x3d_Fog.matrix",          "x3d_FogMatrix");
+			this .x3d_FogCoord           = this .getUniformLocation (gl, program, "x3d_Fog.fogCoord",        "x3d_FogCoord");
+
+			this .x3d_AlphaCutoff = gl .getUniformLocation (program, "x3d_AlphaCutoff");
 
-			this .x3d_LinewidthScaleFactor = gl .getUniformLocation (program, "x3d_LinewidthScaleFactor");
+			this .x3d_PointPropertiesPointSizeScaleFactor = gl .getUniformLocation (program, "x3d_PointProperties.pointSizeScaleFactor");
+			this .x3d_PointPropertiesPointSizeMinValue    = gl .getUniformLocation (program, "x3d_PointProperties.pointSizeMinValue");
+			this .x3d_PointPropertiesPointSizeMaxValue    = gl .getUniformLocation (program, "x3d_PointProperties.pointSizeMaxValue");
+			this .x3d_PointPropertiesPointSizeAttenuation = gl .getUniformLocation (program, "x3d_PointProperties.pointSizeAttenuation");
+			this .x3d_PointPropertiesColorMode            = gl .getUniformLocation (program, "x3d_PointProperties.colorMode");
+
+			this .x3d_LinePropertiesApplied              = gl .getUniformLocation (program, "x3d_LineProperties.applied");
+			this .x3d_LinePropertiesLinewidthScaleFactor = this .getUniformLocation (gl, program, "x3d_LineProperties.linewidthScaleFactor", "x3d_LinewidthScaleFactor");
+			this .x3d_LinePropertiesLinetype             = gl .getUniformLocation (program, "x3d_LineProperties.linetype");
+
+			this .x3d_FillPropertiesFilled     = gl .getUniformLocation (program, "x3d_FillProperties.filled");
+			this .x3d_FillPropertiesHatched    = gl .getUniformLocation (program, "x3d_FillProperties.hatched");
+			this .x3d_FillPropertiesHatchColor = gl .getUniformLocation (program, "x3d_FillProperties.hatchColor");
+			this .x3d_FillPropertiesHatchStyle = gl .getUniformLocation (program, "x3d_FillProperties.hatchStyle");
 
-			this .x3d_Lighting      = gl .getUniformLocation (program, "x3d_Lighting");
 			this .x3d_ColorMaterial = gl .getUniformLocation (program, "x3d_ColorMaterial");
 			this .x3d_NumLights     = gl .getUniformLocation (program, "x3d_NumLights");
 
-			for (var i = 0; i < this .x3d_MaxLights; ++ i)
+			for (let i = 0; i < this .x3d_MaxLights; ++ i)
 			{
 				this .x3d_LightType [i]             = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].type",             "x3d_LightType[" + i + "]");
 				this .x3d_LightColor [i]            = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].color",            "x3d_LightColor[" + i + "]");
@@ -176,38 +196,50 @@ function (Fields,
 				this .x3d_ShadowMap [i]       = gl .getUniformLocation (program, "x3d_ShadowMap[" + i + "]");
 			}
 
-			this .x3d_SeparateBackColor = gl .getUniformLocation (program, "x3d_SeparateBackColor");
+			this .x3d_AmbientIntensity = this .getUniformLocation (gl, program, "x3d_Material.ambientIntensity", "x3d_FrontMaterial.ambientIntensity");
+			this .x3d_DiffuseColor     = this .getUniformLocation (gl, program, "x3d_Material.diffuseColor",     "x3d_FrontMaterial.diffuseColor");
+			this .x3d_SpecularColor    = this .getUniformLocation (gl, program, "x3d_Material.specularColor",    "x3d_FrontMaterial.specularColor");
+			this .x3d_EmissiveColor    = this .getUniformLocation (gl, program, "x3d_Material.emissiveColor",    "x3d_FrontMaterial.emissiveColor");
+			this .x3d_Shininess        = this .getUniformLocation (gl, program, "x3d_Material.shininess",        "x3d_FrontMaterial.shininess");
+			this .x3d_Transparency     = this .getUniformLocation (gl, program, "x3d_Material.transparency",     "x3d_FrontMaterial.transparency");
+
+			this .x3d_NumTextures           = gl .getUniformLocation (program, "x3d_NumTextures");
+			this .x3d_NumProjectiveTextures = gl .getUniformLocation (program, "x3d_NumProjectiveTextures");
+			this .x3d_MultiTextureColor     = gl .getUniformLocation (program, "x3d_MultiTextureColor");
+
+			for (let i = 0; i < this .x3d_MaxTextures; ++ i)
+			{
+				this .x3d_TextureType [i]    = gl .getUniformLocation (program, "x3d_TextureType[" + i + "]");
+				this .x3d_Texture2D [i]      = gl .getUniformLocation (program, "x3d_Texture2D[" + i + "]");
+				this .x3d_Texture3D [i]      = gl .getUniformLocation (program, "x3d_Texture3D[" + i + "]");
+				this .x3d_CubeMapTexture [i] = gl .getUniformLocation (program, "x3d_CubeMapTexture[" + i + "]");
 
-			this .x3d_AmbientIntensity = this .getUniformLocation (gl, program, "x3d_FrontMaterial.ambientIntensity", "x3d_AmbientIntensity");
-			this .x3d_DiffuseColor     = this .getUniformLocation (gl, program, "x3d_FrontMaterial.diffuseColor",     "x3d_DiffuseColor");
-			this .x3d_SpecularColor    = this .getUniformLocation (gl, program, "x3d_FrontMaterial.specularColor",    "x3d_SpecularColor");
-			this .x3d_EmissiveColor    = this .getUniformLocation (gl, program, "x3d_FrontMaterial.emissiveColor",    "x3d_EmissiveColor");
-			this .x3d_Shininess        = this .getUniformLocation (gl, program, "x3d_FrontMaterial.shininess",        "x3d_Shininess");
-			this .x3d_Transparency     = this .getUniformLocation (gl, program, "x3d_FrontMaterial.transparency",     "x3d_Transparency");
+				this .x3d_MultiTextureMode [i]      = gl .getUniformLocation (program, "x3d_MultiTexture[" + i + "].mode");
+				this .x3d_MultiTextureAlphaMode [i] = gl .getUniformLocation (program, "x3d_MultiTexture[" + i + "].alphaMode");
+				this .x3d_MultiTextureSource [i]    = gl .getUniformLocation (program, "x3d_MultiTexture[" + i + "].source");
+				this .x3d_MultiTextureFunction [i]  = gl .getUniformLocation (program, "x3d_MultiTexture[" + i + "].function");
 
-			this .x3d_BackAmbientIntensity = this .getUniformLocation (gl, program, "x3d_BackMaterial.ambientIntensity", "x3d_BackAmbientIntensity");
-			this .x3d_BackDiffuseColor     = this .getUniformLocation (gl, program, "x3d_BackMaterial.diffuseColor",     "x3d_BackDiffuseColor");
-			this .x3d_BackSpecularColor    = this .getUniformLocation (gl, program, "x3d_BackMaterial.specularColor",    "x3d_BackSpecularColor");
-			this .x3d_BackEmissiveColor    = this .getUniformLocation (gl, program, "x3d_BackMaterial.emissiveColor",    "x3d_BackEmissiveColor");
-			this .x3d_BackShininess        = this .getUniformLocation (gl, program, "x3d_BackMaterial.shininess",        "x3d_BackShininess");
-			this .x3d_BackTransparency     = this .getUniformLocation (gl, program, "x3d_BackMaterial.transparency",     "x3d_BackTransparency");
+				this .x3d_TextureCoordinateGeneratorMode [i]      = gl .getUniformLocation (program, "x3d_TextureCoordinateGenerator[" + i + "].mode");
+				this .x3d_TextureCoordinateGeneratorParameter [i] = gl .getUniformLocation (program, "x3d_TextureCoordinateGenerator[" + i + "].parameter");
 
-			this .x3d_NumTextures    = gl .getUniformLocation (program, "x3d_NumTextures");
-			this .x3d_TextureType    = gl .getUniformLocation (program, "x3d_TextureType");
-			this .x3d_Texture2D      = this .getUniformLocation (gl, program, "x3d_Texture2D", "x3d_Texture");
-			this .x3d_CubeMapTexture = gl .getUniformLocation (program, "x3d_CubeMapTexture");
+				this .x3d_ProjectiveTexture [i]         = gl .getUniformLocation (program, "x3d_ProjectiveTexture[" + i + "]");
+				this .x3d_ProjectiveTextureMatrix [i]   = gl .getUniformLocation (program, "x3d_ProjectiveTextureMatrix[" + i + "]");
+				this .x3d_ProjectiveTextureLocation [i] = gl .getUniformLocation (program, "x3d_ProjectiveTextureLocation[" + i + "]");
+
+				this .x3d_TextureMatrix [i] = gl .getUniformLocation (program, "x3d_TextureMatrix[" + i + "]");
+				this .x3d_TexCoord [i]      = this .getAttribLocation (gl, program, "x3d_TexCoord" + i, i ? "" : "x3d_TexCoord");
+			}
 
 			this .x3d_Viewport          = gl .getUniformLocation (program, "x3d_Viewport");
 			this .x3d_ProjectionMatrix  = gl .getUniformLocation (program, "x3d_ProjectionMatrix");
 			this .x3d_ModelViewMatrix   = gl .getUniformLocation (program, "x3d_ModelViewMatrix");
 			this .x3d_NormalMatrix      = gl .getUniformLocation (program, "x3d_NormalMatrix");
-			this .x3d_TextureMatrix     = gl .getUniformLocation (program, "x3d_TextureMatrix");
 			this .x3d_CameraSpaceMatrix = gl .getUniformLocation (program, "x3d_CameraSpaceMatrix");
-		
+
+			this .x3d_FogDepth = gl .getAttribLocation (program, "x3d_FogDepth");
 			this .x3d_Color    = gl .getAttribLocation (program, "x3d_Color");
-			this .x3d_TexCoord = gl .getAttribLocation (program, "x3d_TexCoord");
 			this .x3d_Normal   = gl .getAttribLocation (program, "x3d_Normal");
-			this .x3d_Vertex   = gl .getAttribLocation (program, "x3d_Vertex");	
+			this .x3d_Vertex   = gl .getAttribLocation (program, "x3d_Vertex");
 
 			this .x3d_ParticleId          = gl .getUniformLocation (program, "x3d_Particle.id");
 			this .x3d_ParticleLife        = gl .getUniformLocation (program, "x3d_Particle.life");
@@ -215,16 +247,32 @@ function (Fields,
 
 			// Fill special uniforms with default values, textures for units are created in X3DTexturingContext.
 
-			gl .uniform1f  (this .x3d_LinewidthScaleFactor, 1);
-			gl .uniform1iv (this .x3d_TextureType,          new Int32Array ([0]));
-			gl .uniform1iv (this .x3d_Texture2D,            new Int32Array ([2])); // Set texture to active texture unit 2.
-			gl .uniform1iv (this .x3d_CubeMapTexture,       new Int32Array ([4])); // Set cube map texture to active texture unit 3.
-			gl .uniform1iv (gl .getUniformLocation (program, "x3d_ShadowMap"), new Int32Array (this .x3d_MaxLights) .fill (5)); // Set cube map texture to active texture unit 5, the whole uniform must be set at once.
-			
-			gl .uniform1i (this .x3d_NumTextures, 1);
+			gl .uniform1i  (this .x3d_LinePropertiesLinetype,   browser .getLinetypeUnit ());
+			gl .uniform1i  (this .x3d_FillPropertiesHatchStyle, browser .getHatchStyleUnit ());
+			gl .uniform1i  (this .x3d_NumTextures,              0);
+			gl .uniform1iv (this .x3d_Texture2D [0],            browser .getTexture2DUnits ());
+			gl .uniform1iv (this .x3d_CubeMapTexture [0],       browser .getCubeMapTextureUnits ());
+			gl .uniform1iv (this .x3d_ShadowMap [0],            new Int32Array (this .x3d_MaxLights) .fill (browser .getShadowTextureUnit ()));
+
+			if (browser .getProjectiveTextureMapping ())
+				gl .uniform1iv (this .x3d_ProjectiveTexture [0], browser .getProjectiveTextureUnits ());
+
+			if (gl .getVersion () >= 2)
+				gl .uniform1iv (this .x3d_Texture3D [0], browser .getTexture3DUnits ());
 
 			// Return true if valid, otherwise false.
 
+			if (this .x3d_FogDepth < 0)
+			{
+				this .enableFogDepthAttribute  = Function .prototype;
+				this .disableFogDepthAttribute = Function .prototype;
+			}
+			else
+			{
+				delete this .enableFogDepthAttribute;
+				delete this .disableFogDepthAttribute;
+			}
+
 			if (this .x3d_Color < 0)
 			{
 				this .enableColorAttribute  = Function .prototype;
@@ -236,15 +284,15 @@ function (Fields,
 				delete this .disableColorAttribute;
 			}
 
-			if (this .x3d_TexCoord < 0)
+			if (this .x3d_TexCoord .some (function (location) { return location >= 0; }))
 			{
-				this .enableTexCoordAttribute  = Function .prototype;
-				this .disableTexCoordAttribute = Function .prototype;
+				delete this .enableTexCoordAttribute;
+				delete this .disableTexCoordAttribute;
 			}
 			else
 			{
-				delete this .enableTexCoordAttribute;
-				delete this .disableTexCoordAttribute;
+				this .enableTexCoordAttribute  = Function .prototype;
+				this .disableTexCoordAttribute = Function .prototype;
 			}
 
 			if (this .x3d_Normal < 0)
@@ -260,7 +308,11 @@ function (Fields,
 
 			if (this .x3d_Vertex < 0)
 			{
-				console .warn ("Missing »attribute vec4 x3d_Vertex;«.");
+				if (gl .getVersion () >= 2)
+					console .warn ("Missing »in vec4 x3d_Vertex;«.");
+				else
+					console .warn ("Missing »attribute vec4 x3d_Vertex;«.");
+
 				return false;
 			}
 
@@ -270,39 +322,67 @@ function (Fields,
 		{
 			// Legacy function to get uniform location.
 
-			var location = gl .getUniformLocation (program, name);
+			let location = gl .getUniformLocation (program, name);
 
 			if (location)
 				return location;
 
 			// Look for depreciated location.
 
-			location = gl .getUniformLocation (program, depreciated);
+			if (depreciated)
+			{
+				location = gl .getUniformLocation (program, depreciated);
 
-			if (location)
-				console .error (this .getTypeName (), this .getName (), "Using uniform location name »" + depreciated + "« is depreciated. See http://create3000.de/x_ite/custom-shaders/.");
+				if (location)
+				{
+					console .warn (this .getTypeName (), this .getName (), "Using uniform location name »" + depreciated + "« is depreciated, use »" + name + "«. See https://create3000.github.io/x_ite/Custom-Shaders.html.");
+				}
+
+				return location;
+			}
 
-			return location;
+			return 0;
+		},
+		getAttribLocation: function (gl, program, name, depreciated)
+		{
+			// Legacy function to get uniform location.
+
+			let location = gl .getAttribLocation (program, name);
+
+			if (location >= 0)
+				return location;
+
+			// Look for depreciated location.
+
+			if (depreciated)
+			{
+				location = gl .getAttribLocation (program, depreciated);
+
+				if (location >= 0)
+				{
+					console .warn (this .getTypeName (), this .getName (), "Using attribute location name »" + depreciated + "« is depreciated, use »" + name + "«. See https://create3000.github.io/x_ite/Custom-Shaders.html.");
+				}
+
+				return location;
+			}
+
+			return -1;
 		},
 		addShaderFields: function ()
 		{
-			var
+			const
 				gl                = this .getBrowser () .getContext (),
 				program           = this .getProgram (),
 				userDefinedFields = this .getUserDefinedFields ();
 
 			this .textures .clear ();
 
-			for (var field of userDefinedFields .values ())
+			userDefinedFields .forEach (function (field)
 			{
-				var location = gl .getUniformLocation (program, field .getName ());
+				const location = gl .getUniformLocation (program, field .getName ());
 
 				if (location)
 				{
-					field ._uniformLocation = location;
-
-					field .addInterest ("set_field__", this);
-
 					switch (field .getType ())
 					{
 						case X3DConstants .SFImage:
@@ -360,11 +440,11 @@ function (Fields,
 						}
 						case X3DConstants .MFNode:
 						{
-							var locations = location .locations = [ ];
+							const locations = location .locations = [ ];
 
-							for (var i = 0;; ++ i)
+							for (let i = 0;; ++ i)
 							{
-								var l = gl .getUniformLocation (program, field .getName () + "[" + i + "]");
+								const l = gl .getUniformLocation (program, field .getName () + "[" + i + "]");
 
 								if (! l)
 									break;
@@ -396,424 +476,456 @@ function (Fields,
 						}
 					}
 
+					if (location .array)
+						field ._uniformLocation = location .array .length ? location : null;
+					else
+						field ._uniformLocation = location;
+
+					field .addInterest ("set_field__", this);
+
 					this .set_field__ (field);
 				}
-			}
+			},
+			this);
 		},
 		removeShaderFields: function ()
 		{
-			var userDefinedFields = this .getUserDefinedFields ();
+			const userDefinedFields = this .getUserDefinedFields ();
 
-			for (var field of userDefinedFields .values ())
+			userDefinedFields .forEach (function (field)
 			{
 				field .removeInterest ("set_field__", this);
-			}
+			},
+			this);
 		},
-		set_field__: function (field)
+		set_field__: (function ()
 		{
-			var
-				gl       = this .getBrowser () .getContext (),
-				location = field ._uniformLocation;
+			const matrix3 = new Matrix3 ();
 
-			if (location)
+			return function (field)
 			{
-				switch (field .getType ())
+				const
+					gl       = this .getBrowser () .getContext (),
+					location = field ._uniformLocation;
+
+				if (location)
 				{
-					case X3DConstants .SFBool:
-					case X3DConstants .SFInt32:
-					{
-						gl .uniform1i (location, field .getValue ());
-						return;
-					}
-					case X3DConstants .SFColor:
-					{
-						var value = field .getValue ();
-						gl .uniform3f (location, value .r, value .g, value .b);
-						return;
-					}
-					case X3DConstants .SFColorRGBA:
-					{
-						var value = field .getValue ();
-						gl .uniform4f (location, value .r, value .g, value .b, value .a);
-						return;
-					}
-					case X3DConstants .SFDouble:
-					case X3DConstants .SFFloat:
-					case X3DConstants .SFTime:
-					{
-						gl .uniform1f (location, field .getValue ());
-						return;
-					}
-					case X3DConstants .SFImage:
-					{
-						var
-							array  = location .array,
-							pixels = field .array,
-							length = 3 + pixels .length;
-	
-						if (length !== array .length)
-							array = location .array = new Int32Array (length);
-	
-						array [0] = field .width;
-						array [1] = field .height;
-						array [2] = field .comp;
-	
-						for (var a = 3, p = 0, length = pixels .length; p < length; ++ p, ++ a)
-							array [a] = pixels [p];
-	
-						gl .uniform1iv (location, array);
-						return;
-					}
-					case X3DConstants .SFMatrix3d:
-					case X3DConstants .SFMatrix3f:
-					{
-						location .array .set (field .getValue ());
-	
-						gl .uniformMatrix3fv (location, false, location .array);
-						return;
-					}
-					case X3DConstants .SFMatrix4d:
-					case X3DConstants .SFMatrix4f:
-					{
-						location .array .set (field .getValue ());
-	
-						gl .uniformMatrix4fv (location, false, location .array);
-						return;
-					}
-					case X3DConstants .SFNode:
+					switch (field .getType ())
 					{
-						var texture = X3DCast (X3DConstants .X3DTextureNode, field);
-		
-						if (texture)
+						case X3DConstants .SFBool:
+						case X3DConstants .SFInt32:
+						{
+							gl .uniform1i (location, field .getValue ());
+							return;
+						}
+						case X3DConstants .SFColor:
+						{
+							const value = field .getValue ();
+							gl .uniform3f (location, value .r, value .g, value .b);
+							return;
+						}
+						case X3DConstants .SFColorRGBA:
 						{
-							this .textures .set (location, { name: field .getName (), texture: texture, textureUnit: undefined } );
+							const value = field .getValue ();
+							gl .uniform4f (location, value .r, value .g, value .b, value .a);
 							return;
 						}
+						case X3DConstants .SFDouble:
+						case X3DConstants .SFFloat:
+						case X3DConstants .SFTime:
+						{
+							gl .uniform1f (location, field .getValue ());
+							return;
+						}
+						case X3DConstants .SFImage:
+						{
+							let array = location .array;
 
-						this .textures .delete (location);
-						return;
-					}
-					case X3DConstants .SFRotation:
-					{
-						field .getValue () .getMatrix (location .array);
+							const
+								pixels = field .array,
+								length = 3 + pixels .length;
 
-						gl .uniformMatrix3fv (location, false, location .array);
-						return;
-					}
-					case X3DConstants .SFString:
-					{
-						return;
-					}
-					case X3DConstants .SFVec2d:
-					case X3DConstants .SFVec2f:
-					{
-						var value = field .getValue ();
-						gl .uniform2f (location, value .x, value .y);
-						return;
-					}
-					case X3DConstants .SFVec3d:
-					case X3DConstants .SFVec3f:
-					{
-						var value = field .getValue ();
-						gl .uniform3f (location, value .x, value .y, value .z);
-						return;
-					}
-					case X3DConstants .SFVec4d:
-					case X3DConstants .SFVec4f:
-					{
-						var value = field .getValue ();
-						gl .uniform4f (location, value .x, value .y, value .z, value .w);
-						return;
-					}
-					case X3DConstants .MFBool:
-					case X3DConstants .MFInt32:
-					{
-						var array = location .array;
-
-						for (var i = 0, length = field .length; i < length; ++ i)
-							array [i] = field [i];
-	
-						for (var length = array .length; i < length; ++ i)
-							array [i] = 0;
-	
-						gl .uniform1iv (location, array);
-						return;
-					}
-					case X3DConstants .MFColor:
-					{
-						var array = location .array;
-	
-						for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							if (length !== array .length)
+								array = location .array = new Int32Array (length);
+
+							array [0] = field .width;
+							array [1] = field .height;
+							array [2] = field .comp;
+
+							for (let a = 3, p = 0, pl = pixels .length; p < pl; ++ p, ++ a)
+								array [a] = pixels [p];
+
+							gl .uniform1iv (location, array);
+							return;
+						}
+						case X3DConstants .SFMatrix3d:
+						case X3DConstants .SFMatrix3f:
 						{
-							var color = field [i];
-	
-							array [k++] = color .r;
-							array [k++] = color .g;
-							array [k++] = color .b;
+							location .array .set (field .getValue ());
+
+							gl .uniformMatrix3fv (location, false, location .array);
+							return;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniform3fv (location, array);
-						return;
-					}
-					case X3DConstants .MFColorRGBA:
-					{
-						var array = location .array;
-	
-						for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+						case X3DConstants .SFMatrix4d:
+						case X3DConstants .SFMatrix4f:
 						{
-							var color = field [i];
-	
-							array [k++] = color .r;
-							array [k++] = color .g;
-							array [k++] = color .b;
-							array [k++] = color .a;
+							location .array .set (field .getValue ());
+
+							gl .uniformMatrix4fv (location, false, location .array);
+							return;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniform4fv (location, array);
-						return;
-					}
-					case X3DConstants .MFDouble:
-					case X3DConstants .MFFloat:
-					case X3DConstants .MFTime:
-					{
-						var array = location .array;
+						case X3DConstants .SFNode:
+						{
+							const texture = X3DCast (X3DConstants .X3DTextureNode, field);
 
-						for (var i = 0, length = field .length; i < length; ++ i)
-							array [i] = field [i];
-	
-						for (var length = array .length; i < length; ++ i)
-							array [i] = 0;
+							if (texture)
+							{
+								this .textures .set (location, { name: field .getName (), texture: texture, textureUnit: undefined } );
+								return;
+							}
 
-						gl .uniform1fv (location, array);
-						return;
-					}
-					case X3DConstants .MFImage:
-					{
-						var
-							array  = location .array,
-							length = this .getImagesLength (field);
-	
-						if (length !== array .length)
-							array = location .array = new Int32Array (length);
-	
-						for (var i = 0, a = 0, length = field .length; i < length; ++ i)
+							this .textures .delete (location);
+							return;
+						}
+						case X3DConstants .SFRotation:
 						{
-							var
-								value  = field [i],
-								pixels = value .array;
-	
-							array [a ++] = value .width;
-							array [a ++] = value .height;
-							array [a ++] = value .comp;
-	
-							for (var p = 0, plength = pixels .length; p < plength; ++ p)
-								array [a ++] = pixels [p];
+							field .getValue () .getMatrix (location .array);
+
+							gl .uniformMatrix3fv (location, false, location .array);
+							return;
 						}
-	
-						gl .uniform1iv (location, array);
-						return;
-					}
-					case X3DConstants .MFMatrix3d:
-					case X3DConstants .MFMatrix3f:
-					{
-						var array = location .array;
-	
-						for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+						case X3DConstants .SFString:
 						{
-							var matrix = field [i];
-	
-							for (var m = 0; m < 9; ++ m)
-								array [k++] = matrix [m];
+							return;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniformMatrix3fv (location, false, array);
-						return;
-					}
-					case X3DConstants .MFMatrix4d:
-					case X3DConstants .MFMatrix4f:
-					{
-						var array = location .array;
-	
-						for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+						case X3DConstants .SFVec2d:
+						case X3DConstants .SFVec2f:
 						{
-							var matrix = field [i];
-	
-							for (var m = 0; m < 16; ++ m)
-								array [k++] = matrix [m];
+							const value = field .getValue ();
+							gl .uniform2f (location, value .x, value .y);
+							return;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniformMatrix4fv (location, false, array);
-						return;
-					}
-					case X3DConstants .MFNode:
-					{
-						var locations = location .locations;
+						case X3DConstants .SFVec3d:
+						case X3DConstants .SFVec3f:
+						{
+							const value = field .getValue ();
+							gl .uniform3f (location, value .x, value .y, value .z);
+							return;
+						}
+						case X3DConstants .SFVec4d:
+						case X3DConstants .SFVec4f:
+						{
+							const value = field .getValue ();
+							gl .uniform4f (location, value .x, value .y, value .z, value .w);
+							return;
+						}
+						case X3DConstants .MFBool:
+						case X3DConstants .MFInt32:
+						{
+							const array = location .array;
+
+							for (var i = 0, length = field .length; i < length; ++ i)
+								array [i] = field [i];
 
-						for (var i = 0, length = field .length; i < length; ++ i)
+							for (let length = array .length; i < length; ++ i)
+								array [i] = 0;
+
+							gl .uniform1iv (location, array);
+							return;
+						}
+						case X3DConstants .MFColor:
 						{
-							var texture = X3DCast (X3DConstants .X3DTextureNode, field [i]);
-			
-							if (texture)
+							const array = location .array;
+
+							for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							{
+								const color = field [i];
+
+								array [k++] = color .r;
+								array [k++] = color .g;
+								array [k++] = color .b;
+							}
+
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
+
+							gl .uniform3fv (location, array);
+							return;
+						}
+						case X3DConstants .MFColorRGBA:
+						{
+							const array = location .array;
+
+							for (var i = 0, k = 0, length = field .length; i < length; ++ i)
 							{
-								this .textures .set (locations [i], { name: field [i] .getName (), texture: texture, textureUnit: undefined } );
-								continue;
+								const color = field [i];
+
+								array [k++] = color .r;
+								array [k++] = color .g;
+								array [k++] = color .b;
+								array [k++] = color .a;
 							}
+
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
+
+							gl .uniform4fv (location, array);
+							return;
 						}
+						case X3DConstants .MFDouble:
+						case X3DConstants .MFFloat:
+						case X3DConstants .MFTime:
+						{
+							const array = location .array;
 
-						return;
-					}
-					case X3DConstants .MFRotation:
-					{
-						var array = location .array;
+							for (var i = 0, length = field .length; i < length; ++ i)
+								array [i] = field [i];
 
-						for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							for (let length = array .length; i < length; ++ i)
+								array [i] = 0;
+
+							gl .uniform1fv (location, array);
+							return;
+						}
+						case X3DConstants .MFImage:
 						{
-							var matrix = field [i] .getValue () .getMatrix (matrix3);
-	
-							array [k++] = matrix [0];
-							array [k++] = matrix [1];
-							array [k++] = matrix [2];
-							array [k++] = matrix [3];
-							array [k++] = matrix [4];
-							array [k++] = matrix [5];
-							array [k++] = matrix [6];
-							array [k++] = matrix [7];
-							array [k++] = matrix [8];
+							const array = location .array;
+
+							for (let i = 0, a = 0, length = field .length; i < length; ++ i)
+							{
+								const
+									value  = field [i],
+									pixels = value .array;
+
+								array [a ++] = value .width;
+								array [a ++] = value .height;
+								array [a ++] = value .comp;
+
+								for (let p = 0, pl = pixels .length; p < pl; ++ p)
+									array [a ++] = pixels [p];
+							}
+
+							gl .uniform1iv (location, array);
+							return;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniformMatrix3fv (location, false, array);
-						return;
-					}
-					case X3DConstants .MFString:
-					{
-						return;
-					}
-					case X3DConstants .MFVec2d:
-					case X3DConstants .MFVec2f:
-					{
-						var array = location .array;
-	
-						for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+						case X3DConstants .MFMatrix3d:
+						case X3DConstants .MFMatrix3f:
 						{
-							var vector = field [i];
-	
-							array [k++] = vector .x;
-							array [k++] = vector .y;
+							const array = location .array;
+
+							for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							{
+								const matrix = field [i];
+
+								for (let m = 0; m < 9; ++ m)
+									array [k++] = matrix [m];
+							}
+
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
+
+							gl .uniformMatrix3fv (location, false, array);
+							return;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
+						case X3DConstants .MFMatrix4d:
+						case X3DConstants .MFMatrix4f:
+						{
+							const array = location .array;
 
-						gl .uniform2fv (location, array);
-						return;
-					}
-					case X3DConstants .MFVec3d:
-					case X3DConstants .MFVec3f:
-					{
-						var array = location .array;
-	
-						for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							{
+								const matrix = field [i];
+
+								for (let m = 0; m < 16; ++ m)
+									array [k++] = matrix [m];
+							}
+
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
+
+							gl .uniformMatrix4fv (location, false, array);
+							return;
+						}
+						case X3DConstants .MFNode:
 						{
-							var vector = field [i];
-	
-							array [k++] = vector .x;
-							array [k++] = vector .y;
-							array [k++] = vector .z;
+							const locations = location .locations;
+
+							for (let i = 0, length = field .length; i < length; ++ i)
+							{
+								const texture = X3DCast (X3DConstants .X3DTextureNode, field [i]);
+
+								if (texture)
+								{
+									this .textures .set (locations [i], { name: field [i] .getName (), texture: texture, textureUnit: undefined } );
+									continue;
+								}
+							}
+
+							return;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniform3fv (location, array);
-						return;
-					}
-					case X3DConstants .MFVec4d:
-					case X3DConstants .MFVec4f:
-					{
-						var array = location .array;
-	
-						for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+						case X3DConstants .MFRotation:
+						{
+							const array = location .array;
+
+							for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							{
+								const matrix = field [i] .getValue () .getMatrix (matrix3);
+
+								array [k++] = matrix [0];
+								array [k++] = matrix [1];
+								array [k++] = matrix [2];
+								array [k++] = matrix [3];
+								array [k++] = matrix [4];
+								array [k++] = matrix [5];
+								array [k++] = matrix [6];
+								array [k++] = matrix [7];
+								array [k++] = matrix [8];
+							}
+
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
+
+							gl .uniformMatrix3fv (location, false, array);
+							return;
+						}
+						case X3DConstants .MFString:
+						{
+							return;
+						}
+						case X3DConstants .MFVec2d:
+						case X3DConstants .MFVec2f:
+						{
+							const array = location .array;
+
+							for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							{
+								const vector = field [i];
+
+								array [k++] = vector .x;
+								array [k++] = vector .y;
+							}
+
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
+
+							gl .uniform2fv (location, array);
+							return;
+						}
+						case X3DConstants .MFVec3d:
+						case X3DConstants .MFVec3f:
 						{
-							var vector = field [i];
-	
-							array [k++] = vector .x;
-							array [k++] = vector .y;
-							array [k++] = vector .z;
-							array [k++] = vector .w;
+							const array = location .array;
+
+							for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							{
+								const vector = field [i];
+
+								array [k++] = vector .x;
+								array [k++] = vector .y;
+								array [k++] = vector .z;
+							}
+
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
+
+							gl .uniform3fv (location, array);
+							return;
+						}
+						case X3DConstants .MFVec4d:
+						case X3DConstants .MFVec4f:
+						{
+							const array = location .array;
+
+							for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							{
+								const vector = field [i];
+
+								array [k++] = vector .x;
+								array [k++] = vector .y;
+								array [k++] = vector .z;
+								array [k++] = vector .w;
+							}
+
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
+
+							gl .uniform4fv (location, array);
+							return;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniform4fv (location, array);
-						return;
 					}
 				}
-			}
-		},
+			};
+		})(),
 		getImagesLength: function (field)
 		{
-			var
-				images = field .getValue (),
-				length = 3 * images .length;
+			const images = field .getValue ();
+
+			let length = 3 * images .length;
 
-			for (var i = 0, l = images .length; i < l; ++ i)
-				length += images [i] .array .length;
+			for (const image of images)
+				length += image .array .length;
 
 			return length;
 		},
 		getLocationLength: function (gl, program, field)
 		{
-			var name = field .getName ();
+			const name = field .getName ();
 
-			for (var i = 0; ; ++ i)
+			for (let i = 0; ; ++ i)
 			{
-				var location = gl .getUniformLocation (program, name + "[" + i + "]");
+				const location = gl .getUniformLocation (program, name + "[" + i + "]");
 
 				if (! location)
-					break;
+					return i;
 			}
+		},
+		hasFog: function (fogNode)
+		{
+			if (this .fogNode === fogNode)
+				return true;
+
+			this .fogNode = fogNode;
 
-			return i;
+			return false;
 		},
-		setShaderObjects: function (gl, shaderObjects)
+		hasLight: function (i, lightNode)
 		{
-			// Clip planes and local lights
+			if (this .lightNodes [i] === lightNode)
+				return true;
 
-			this .numClipPlanes = 0;
-			this .numLights     = 0;
+			this .lightNodes [i] = lightNode;
 
-			gl .uniform4fv (this .x3d_ClipPlanes, this .defaultClipPlanesArray);
+			return false;
+		},
+		hasTextureProjector: function (i, textureProjectorNode)
+		{
+			if (this .projectiveTextureNodes [i] === textureProjectorNode)
+				return true;
 
-			for (var i = 0, length = shaderObjects .length; i < length; ++ i)
-				shaderObjects [i] .setShaderUniforms (gl, this);
+			this .projectiveTextureNodes [i] = textureProjectorNode;
 
-			gl .uniform1i (this .x3d_NumClipPlanes, Math .min (this .numClipPlanes, this .x3d_MaxClipPlanes));
-			gl .uniform1i (this .x3d_NumLights,     Math .min (this .numLights,     this .x3d_MaxLights));
+			return false;
+		},
+		setLocalObjects: function (gl, localObjects)
+		{
+			// Clip planes and local lights
+
+			this .numClipPlanes                  = 0;
+			this .numLights                      = 0;
+			this .numProjectiveTextures          = 0;
+			this .lightNodes .length             = 0;
+			this .projectiveTextureNodes .length = 0;
 
-			// Legacy before 4.1.4
+			for (const localObject of localObjects)
+				localObject .setShaderUniforms (gl, this);
 
-			if (this .numLights < this .x3d_MaxLights)
-				gl .uniform1i (this .x3d_LightType [this .numLights], 0);
+			gl .uniform1i (this .x3d_NumClipPlanes,         Math .min (this .numClipPlanes,         this .x3d_MaxClipPlanes));
+			gl .uniform1i (this .x3d_NumLights,             Math .min (this .numLights,             this .x3d_MaxLights));
+			gl .uniform1i (this .x3d_NumProjectiveTextures, Math .min (this .numProjectiveTextures, this .x3d_MaxTextures));
 		},
 		setGlobalUniforms: function (gl, renderObject, cameraSpaceMatrixArray, projectionMatrixArray, viewportArray)
 		{
-			var globalLights = renderObject .getGlobalLights ();
+			const globalObjects = renderObject .getGlobalObjects ();
 
 			// Set viewport
 
@@ -824,122 +936,114 @@ function (Fields,
 			gl .uniformMatrix4fv (this .x3d_ProjectionMatrix,  false, projectionMatrixArray);
 			gl .uniformMatrix4fv (this .x3d_CameraSpaceMatrix, false, cameraSpaceMatrixArray);
 
-			// Set global lights
+			// Fog
+
+			this .fogNode = null;
+
+			// Set global lights and global texture projectors
+
+			this .numLights                      = 0;
+			this .numProjectiveTextures          = 0;
+			this .lightNodes .length             = 0;
+			this .projectiveTextureNodes .length = 0;
 
-			this .numGlobalLights = globalLights .length;
-			this .numLights       = 0;
+			for (const globalObject of globalObjects)
+				globalObject .setShaderUniforms (gl, this);
 
-			for (var i = 0, length = globalLights .length; i < length; ++ i)
-				globalLights [i] .setShaderUniforms (gl, this);
+			this .numGlobalLights             = this .numLights;
+			this .numGlobalProjectiveTextures = this .numProjectiveTextures;
 
 			// Logarithmic depth buffer support.
 
-			var viewpoint      = renderObject .getViewpoint ();
-			var navigationInfo = renderObject .getNavigationInfo ();
+			const
+				viewpoint      = renderObject .getViewpoint (),
+				navigationInfo = renderObject .getNavigationInfo ();
 
 			if (viewpoint instanceof OrthoViewpoint)
 				gl .uniform1f (this .x3d_LogarithmicFarFactor1_2, -1);
 			else
-				gl .uniform1f (this .x3d_LogarithmicFarFactor1_2, 1 / Math .log2 (navigationInfo .getFarValue (viewpoint) + 1));		
+				gl .uniform1f (this .x3d_LogarithmicFarFactor1_2, 1 / Math .log2 (navigationInfo .getFarValue (viewpoint) + 1));
 		},
-		setLocalUniforms: function (gl, context)
+		setLocalUniforms: function (gl, context, front = true)
 		{
-			var
-				linePropertiesNode   = context .linePropertiesNode,
-				materialNode         = context .materialNode,
-				textureNode          = context .textureNode,
-				textureTransformNode = context .textureTransformNode,
-				modelViewMatrix      = context .modelViewMatrix,
-				shaderObjects        = context .shaderObjects;
+			const
+				shapeNode             = context .shapeNode,
+				geometryNode          = context .geometryContext || shapeNode .getGeometry (),
+				geometryType          = geometryNode .geometryType,
+				textureCoordinateNode = geometryNode .textureCoordinateNode,
+				appearanceNode        = shapeNode .getAppearance (),
+				stylePropertiesNode   = appearanceNode .stylePropertiesNode [geometryType],
+				materialNode          = front ? appearanceNode .materialNode : appearanceNode .backMaterialNode,
+				textureNode           = context .textureNode || appearanceNode .textureNode,
+				textureTransformNode  = appearanceNode .textureTransformNode,
+				modelViewMatrix       = context .modelViewMatrix,
+				localObjects          = context .localObjects;
+
+			// Model view matrix
+
+			gl .uniformMatrix4fv (this .x3d_ModelViewMatrix, false, modelViewMatrix);
 
 			// Geometry type
 
-			gl .uniform1i (this .x3d_GeometryType, context .geometryType);
+			gl .uniform1i (this .x3d_GeometryType, geometryType);
 
 			// Clip planes and local lights
 
-			this .numClipPlanes = 0;
-			this .numLights     = this .numGlobalLights;
-
-			gl .uniform4fv (this .x3d_ClipPlanes, this .defaultClipPlanesArray);
-
-			for (var i = 0, length = shaderObjects .length; i < length; ++ i)
-				shaderObjects [i] .setShaderUniforms (gl, this);
-
-			gl .uniform1i (this .x3d_NumClipPlanes, Math .min (this .numClipPlanes, this .x3d_MaxClipPlanes));
-			gl .uniform1i (this .x3d_NumLights,     Math .min (this .numLights,     this .x3d_MaxLights));
+			this .numClipPlanes         = 0;
+			this .numLights             = this .numGlobalLights;
+			this .numProjectiveTextures = this .numGlobalProjectiveTextures;
 
-			// Legacy before 4.1.4
+			for (const localObject of localObjects)
+				localObject .setShaderUniforms (gl, this);
 
-			if (this .numLights < this .x3d_MaxLights)
-				gl .uniform1i (this .x3d_LightType [this .numLights], 0);
+			gl .uniform1i (this .x3d_NumClipPlanes,         Math .min (this .numClipPlanes,         this .x3d_MaxClipPlanes));
+			gl .uniform1i (this .x3d_NumLights,             Math .min (this .numLights,             this .x3d_MaxLights));
+			gl .uniform1i (this .x3d_NumProjectiveTextures, Math .min (this .numProjectiveTextures, this .x3d_MaxTextures));
 
 			// Fog, there is always one
 
 			context .fogNode .setShaderUniforms (gl, this);
+			gl .uniform1i (this .x3d_FogCoord, geometryNode .fogCoords);
 
-			// LineProperties
+			// Alpha
 
-			if (linePropertiesNode && linePropertiesNode .applied_ .getValue ())
-			{
-				var linewidthScaleFactor = linePropertiesNode .getLinewidthScaleFactor ();
+			gl .uniform1f (this .x3d_AlphaCutoff, appearanceNode .alphaCutoff);
 
-				gl .lineWidth (linewidthScaleFactor);
-				gl .uniform1f (this .x3d_LinewidthScaleFactor, linewidthScaleFactor);
-			}
-			else
-			{
-				gl .lineWidth (1);
-				gl .uniform1f (this .x3d_LinewidthScaleFactor, 1);
-			}
-	
-			// Material
+			// Style
 
-			gl .uniform1i (this .x3d_ColorMaterial, context .colorMaterial);
+			stylePropertiesNode .setShaderUniforms (gl, this);
 
-			if (materialNode)
-			{
-				// Lights
+			// Material
 
-				gl .uniform1i  (this .x3d_Lighting, true);
+			gl .uniform1i (this .x3d_ColorMaterial, geometryNode .colorMaterial);
+			materialNode .setShaderUniforms (gl, this, front);
 
-				// Material
+			// Normal matrix
 
-				materialNode .setShaderUniforms (gl, this);
+			gl .uniformMatrix3fv (this .x3d_NormalMatrix, false, this .getNormalMatrix (modelViewMatrix));
 
-				// Normal matrix
-
-				gl .uniformMatrix3fv (this .x3d_NormalMatrix, false, this .getNormalMatrix (modelViewMatrix));
-			}
-			else
-			{
-				gl .uniform1i (this .x3d_Lighting, false);
-
-				if (this .getCustom ())
-					gl .uniformMatrix3fv (this .x3d_NormalMatrix, false, this .getNormalMatrix (modelViewMatrix));
-			}
+			// Texture
 
 			if (textureNode)
 			{
-				textureNode .setShaderUniforms (gl, this, 0);
-				textureTransformNode .setShaderUniforms (gl, this);
+				textureNode           .setShaderUniforms (gl, this, context .renderer);
+				textureTransformNode  .setShaderUniforms (gl, this);
+				textureCoordinateNode .setShaderUniforms (gl, this);
 			}
 			else
 			{
-				this .textureTypeArray [0] = 0;
-				gl .uniform1iv (this .x3d_TextureType, this .textureTypeArray);
+				gl .uniform1i (this .x3d_NumTextures, 0);
 
 				if (this .getCustom ())
 				{
-					textureTransformNode .setShaderUniforms (gl, this);
+					textureTransformNode  .setShaderUniforms (gl, this);
+					textureCoordinateNode .setShaderUniforms (gl, this);
 				}
 			}
-
-			gl .uniformMatrix4fv (this .x3d_ModelViewMatrix, false, modelViewMatrix);
 		},
 		getNormalMatrix: (function ()
 		{
-			var normalMatrix = new Float32Array (9);
+			const normalMatrix = new Float32Array (9);
 
 			return function (modelViewMatrix)
 			{
@@ -963,67 +1067,63 @@ function (Fields,
 		})(),
 		enable: function (gl)
 		{
-			var browser = this .getBrowser ();
+			const browser = this .getBrowser ();
 
 			//console .log (this .getName ());
 			//console .log (browser .getCombinedTextureUnits () .length);
 
-			for (let item of this .textures)
+			this .textures .forEach (function (object, location)
 			{
-				var
-					location = item [0],
-					object   = item [1],
-					name     = object .name,
-					texture  = object .texture;
+				const
+					name    = object .name,
+					texture = object .texture;
 
 				if (! browser .getCombinedTextureUnits () .length)
 				{
 					console .warn ("Not enough combined texture units for uniform variable '" + name + "' available.");
-					continue;
+					return;
 				}
 
-				var textureUnit = object .textureUnit = browser .getCombinedTextureUnits () .pop ();
-	
+				const textureUnit = object .textureUnit = browser .getCombinedTextureUnits () .pop ();
+
 				gl .uniform1i (location, textureUnit);
 				gl .activeTexture (gl .TEXTURE0 + textureUnit);
 				gl .bindTexture (texture .getTarget (), texture .getTexture ());
-			}
+			});
 
 			gl .activeTexture (gl .TEXTURE0);
 		},
 		disable: function (gl)
 		{
-			var browser = this .getBrowser ();
+			const browser = this .getBrowser ();
 
-			for (let item of this .textures)
+			this .textures .forEach (function (object)
 			{
-				var
-					object      = item [1],
-					textureUnit = object .textureUnit;
+				const textureUnit = object .textureUnit;
 
 				if (textureUnit !== undefined)
 					browser .getCombinedTextureUnits () .push (textureUnit);
 
 				object .textureUnit = undefined;
-			}		
+			});
 
 			//console .log (browser .getCombinedTextureUnits () .length);
 		},
 		enableFloatAttrib: function (gl, name, buffer, components)
 		{
-			var location = gl. getAttribLocation (this .getProgram (), name);
-		
+			const location = gl. getAttribLocation (this .getProgram (), name);
+
 			if (location === -1)
 				return;
-		
+
 			gl .enableVertexAttribArray (location);
-		
+
 			gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
 			gl .vertexAttribPointer (location, components, gl .FLOAT, false, 0, 0);
 		},
 		disableFloatAttrib: function (gl, name)
 		{
-			var location = gl .getAttribLocation (this .getProgram (), name);
+			const location = gl .getAttribLocation (this .getProgram (), name);
 
 			if (location === -1)
 				return;
@@ -1032,7 +1132,7 @@ function (Fields,
 		},
 		enableMatrix3Attrib: function (gl, name, buffer)
 		{
-			var location = gl .getAttribLocation (this .getProgram (), name);
+			const location = gl .getAttribLocation (this .getProgram (), name);
 
 			if (location === -1)
 				return;
@@ -1049,7 +1149,7 @@ function (Fields,
 		},
 		disableMatrix3Attrib: function (gl, name)
 		{
-			var location = gl .getAttribLocation (this .getProgram (), name);
+			const location = gl .getAttribLocation (this .getProgram (), name);
 
 			if (location === -1)
 				return;
@@ -1060,7 +1160,7 @@ function (Fields,
 		},
 		enableMatrix4Attrib: function (gl, name, buffer)
 		{
-			var location = gl .getAttribLocation (this .getProgram (), name);
+			const location = gl .getAttribLocation (this .getProgram (), name);
 
 			if (location === -1)
 				return;
@@ -1079,7 +1179,7 @@ function (Fields,
 		},
 		disableMatrix4Attrib: function (gl, name)
 		{
-			var location = gl .getAttribLocation (this .getProgram (), name);
+			const location = gl .getAttribLocation (this .getProgram (), name);
 
 			if (location === -1)
 				return;
@@ -1089,6 +1189,16 @@ function (Fields,
 			gl .disableVertexAttribArray (location + 2);
 			gl .disableVertexAttribArray (location + 3);
 		},
+		enableFogDepthAttribute: function (gl, fogDepthBuffer)
+		{
+			gl .enableVertexAttribArray (this .x3d_FogDepth);
+			gl .bindBuffer (gl .ARRAY_BUFFER, fogDepthBuffer);
+			gl .vertexAttribPointer (this .x3d_FogDepth, 1, gl .FLOAT, false, 0, 0);
+		},
+		disableFogDepthAttribute: function (gl)
+		{
+			gl .disableVertexAttribArray (this .x3d_FogDepth);
+		},
 		enableColorAttribute: function (gl, colorBuffer)
 		{
 			gl .enableVertexAttribArray (this .x3d_Color);
@@ -1099,15 +1209,33 @@ function (Fields,
 		{
 			gl .disableVertexAttribArray (this .x3d_Color);
 		},
-		enableTexCoordAttribute: function (gl, texCoordBuffers)
+		enableTexCoordAttribute: function (gl, texCoordBuffers, d)
 		{
-			gl .enableVertexAttribArray (this .x3d_TexCoord);
-			gl .bindBuffer (gl .ARRAY_BUFFER, texCoordBuffers [0]);
-			gl .vertexAttribPointer (this .x3d_TexCoord, 4, gl .FLOAT, false, 0, 0);
+			const length = Math .min (this .x3d_MaxTextures, texCoordBuffers .length);
+
+			for (let i = 0; i < length; ++ i)
+			{
+				const x3d_TexCoord = this .x3d_TexCoord [i];
+
+				if (x3d_TexCoord === -1)
+					continue;
+
+				gl .enableVertexAttribArray (x3d_TexCoord);
+				gl .bindBuffer (gl .ARRAY_BUFFER, texCoordBuffers [i]);
+				gl .vertexAttribPointer (x3d_TexCoord, 4, gl .FLOAT, false, 0, 0);
+			}
 		},
 		disableTexCoordAttribute: function (gl)
 		{
-			gl .disableVertexAttribArray (this .x3d_TexCoord);
+			for (let i = 0, length = this .x3d_MaxTextures; i < length; ++ i)
+			{
+				const x3d_TexCoord = this .x3d_TexCoord [i];
+
+				if (x3d_TexCoord === -1)
+					continue;
+
+				gl .disableVertexAttribArray (x3d_TexCoord);
+			}
 		},
 		enableNormalAttribute: function (gl, normalBuffer)
 		{
@@ -1129,14 +1257,11 @@ function (Fields,
 		{
 			gl .disableVertexAttribArray (this .x3d_Vertex);
 		},
-		setParticle: function (gl, id, particle, modelViewMatrix, normalMatrix)
+		setParticle: function (gl, particle, modelViewMatrix)
 		{
-			if (normalMatrix)
-				gl .uniformMatrix3fv (this .x3d_NormalMatrix, false, this .getNormalMatrix (modelViewMatrix));
-
 			gl .uniformMatrix4fv (this .x3d_ModelViewMatrix, false, modelViewMatrix);
 
-			gl .uniform1i (this .x3d_ParticleId,          id);
+			gl .uniform1i (this .x3d_ParticleId,          particle .id);
 			gl .uniform1i (this .x3d_ParticleLife,        particle .life);
 			gl .uniform1f (this .x3d_ParticleElapsedTime, particle .elapsedTime / particle .lifetime);
 		},
@@ -1144,11 +1269,11 @@ function (Fields,
 		{
 			function cmp (lhs, rhs) { return lhs < rhs ? -1 : lhs > rhs ? 1 : 0; }
 
-			var
+			const
 				gl      = this .getBrowser () .getContext (),
 				program = this .getProgram ();
 
-			var
+			const
 				result = {
 					attributes: [ ],
 					uniforms: [ ],
@@ -1160,7 +1285,7 @@ function (Fields,
 
 			// Taken from the WebGl spec:
 			// http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14
-			var enums = {
+			const enums = {
 				0x8B50: 'vec2',
 				0x8B51: 'vec3',
 				0x8B52: 'vec4',
@@ -1186,18 +1311,18 @@ function (Fields,
 			};
 
 			// Loop through active uniforms
-			for (var i = 0; i < activeUniforms; ++ i)
+			for (let i = 0; i < activeUniforms; ++ i)
 			{
-				var uniform = gl .getActiveUniform (program, i);
+				const uniform = gl .getActiveUniform (program, i);
 				uniform .typeName = enums [uniform.type];
 				result .uniforms .push (Object .assign ({ }, uniform));
 				result .uniformCount += uniform .size;
 			}
 
 			// Loop through active attributes
-			for (var i = 0; i < activeAttributes; ++ i)
+			for (let i = 0; i < activeAttributes; ++ i)
 			{
-				var attribute = gl .getActiveAttrib (program, i);
+				const attribute = gl .getActiveAttrib (program, i);
 				attribute .typeName = enums [attribute .type];
 				result .attributes .push (Object .assign ({ }, attribute));
 				result .attributeCount += attribute .size;
@@ -1210,7 +1335,7 @@ function (Fields,
 		},
 		printProgramInfo: function ()
 		{
-			var programInfo = this .getProgramInfo ();
+			const programInfo = this .getProgramInfo ();
 
 			console .log (this .getName ());
 			console .table (programInfo .attributes);
@@ -1223,5 +1348,3 @@ function (Fields,
 
 	return X3DProgrammableShaderObject;
 });
-
-