x_ite 4.0.5 → 4.7.5

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

@@ -48,62 +48,78 @@
 
 
 define ([
-	"jquery",
-	"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 (),
-		NULL    = new Fields .SFNode ();
-
 	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_ShadowIntensity       = [ ];
-		this .x3d_ShadowDiffusion       = [ ];
-		this .x3d_ShadowColor           = [ ];
-		this .x3d_ShadowMatrix          = [ ];
-		this .x3d_ShadowMap             = [ ];
+		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 =
 	{
 		constructor: X3DProgrammableShaderObject,
-		x3d_NoneClipPlane: new Float32Array ([ 88, 51, 68, 33 ]), // X3D!
-		numGlobalLights: 0,
-		normalMatrixArray: new Float32Array (9),
 		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 ();
-
-			this .textureTypeArray = new Int32Array (this .x3d_MaxTextures);
 		},
 		hasUserDefinedFields: function ()
 		{
@@ -111,94 +127,152 @@ function ($,
 		},
 		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_GeometryType = gl .getUniformLocation (program, "x3d_GeometryType");
+			this .x3d_LogarithmicFarFactor1_2 = gl .getUniformLocation (program, "x3d_LogarithmicFarFactor1_2");
+
+			this .x3d_GeometryType  = gl .getUniformLocation (program, "x3d_GeometryType");
+			this .x3d_NumClipPlanes = gl .getUniformLocation (program, "x3d_NumClipPlanes");
+
+			this .x3d_ClipPlanes = gl .getUniformLocation (program, "x3d_ClipPlane");
+
+			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");
 
-			for (var i = 0; i < this .x3d_MaxClipPlanes; ++ i)
-				this .x3d_ClipPlane [i]  = gl .getUniformLocation (program, "x3d_ClipPlane[" + i + "]");
+			this .x3d_AlphaCutoff = gl .getUniformLocation (program, "x3d_AlphaCutoff");
 
-			this .x3d_FogType            = gl .getUniformLocation (program, "x3d_FogType");
-			this .x3d_FogColor           = gl .getUniformLocation (program, "x3d_FogColor");
-			this .x3d_FogVisibilityRange = gl .getUniformLocation (program, "x3d_FogVisibilityRange");
+			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_LinewidthScaleFactor = gl .getUniformLocation (program, "x3d_LinewidthScaleFactor");
+			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]             = gl .getUniformLocation (program, "x3d_LightType[" + i + "]");
-				this .x3d_LightColor [i]            = gl .getUniformLocation (program, "x3d_LightColor[" + i + "]");
-				this .x3d_LightAmbientIntensity [i] = gl .getUniformLocation (program, "x3d_LightAmbientIntensity[" + i + "]");
-				this .x3d_LightIntensity [i]        = gl .getUniformLocation (program, "x3d_LightIntensity[" + i + "]");
-				this .x3d_LightAttenuation [i]      = gl .getUniformLocation (program, "x3d_LightAttenuation[" + i + "]");
-				this .x3d_LightLocation [i]         = gl .getUniformLocation (program, "x3d_LightLocation[" + i + "]");
-				this .x3d_LightDirection [i]        = gl .getUniformLocation (program, "x3d_LightDirection[" + i + "]");
-				this .x3d_LightBeamWidth [i]        = gl .getUniformLocation (program, "x3d_LightBeamWidth[" + i + "]");
-				this .x3d_LightCutOffAngle [i]      = gl .getUniformLocation (program, "x3d_LightCutOffAngle[" + i + "]");
-				this .x3d_LightRadius [i]           = gl .getUniformLocation (program, "x3d_LightRadius[" + i + "]");
-
-				this .x3d_ShadowIntensity [i] = gl .getUniformLocation (program, "x3d_ShadowIntensity[" + i + "]");
-				this .x3d_ShadowDiffusion [i] = gl .getUniformLocation (program, "x3d_ShadowDiffusion[" + i + "]");
-				this .x3d_ShadowColor [i]     = gl .getUniformLocation (program, "x3d_ShadowColor[" + i + "]");
-				this .x3d_ShadowMatrix [i]    = gl .getUniformLocation (program, "x3d_ShadowMatrix[" + 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 + "]");
+				this .x3d_LightAmbientIntensity [i] = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].ambientIntensity", "x3d_LightAmbientIntensity[" + i + "]");
+				this .x3d_LightIntensity [i]        = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].intensity",        "x3d_LightIntensity[" + i + "]");
+				this .x3d_LightAttenuation [i]      = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].attenuation",      "x3d_LightAttenuation[" + i + "]");
+				this .x3d_LightLocation [i]         = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].location",         "x3d_LightLocation[" + i + "]");
+				this .x3d_LightDirection [i]        = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].direction",        "x3d_LightDirection[" + i + "]");
+				this .x3d_LightBeamWidth [i]        = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].beamWidth",        "x3d_LightBeamWidth[" + i + "]");
+				this .x3d_LightCutOffAngle [i]      = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].cutOffAngle",      "x3d_LightCutOffAngle[" + i + "]");
+				this .x3d_LightRadius [i]           = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].radius",           "x3d_LightRadius[" + i + "]");
+				this .x3d_LightMatrix [i]           = this .getUniformLocation (gl, program, "x3d_LightSource[" + i + "].matrix",           "x3d_LightMatrix[" + i + "]");
+
+				this .x3d_ShadowIntensity [i] = gl .getUniformLocation (program, "x3d_LightSource[" + i + "].shadowIntensity");
+				this .x3d_ShadowColor [i]     = gl .getUniformLocation (program, "x3d_LightSource[" + i + "].shadowColor");
+				this .x3d_ShadowBias [i]      = gl .getUniformLocation (program, "x3d_LightSource[" + i + "].shadowBias");
+				this .x3d_ShadowMatrix [i]    = gl .getUniformLocation (program, "x3d_LightSource[" + i + "].shadowMatrix");
+				this .x3d_ShadowMapSize [i]   = gl .getUniformLocation (program, "x3d_LightSource[" + i + "].shadowMapSize");
 				this .x3d_ShadowMap [i]       = gl .getUniformLocation (program, "x3d_ShadowMap[" + i + "]");
 			}
 
-			this .x3d_SeparateBackColor = gl .getUniformLocation (program, "x3d_SeparateBackColor");
-
-			this .x3d_AmbientIntensity = gl .getUniformLocation (program, "x3d_AmbientIntensity");
-			this .x3d_DiffuseColor     = gl .getUniformLocation (program, "x3d_DiffuseColor");
-			this .x3d_SpecularColor    = gl .getUniformLocation (program, "x3d_SpecularColor");
-			this .x3d_EmissiveColor    = gl .getUniformLocation (program, "x3d_EmissiveColor");
-			this .x3d_Shininess        = gl .getUniformLocation (program, "x3d_Shininess");
-			this .x3d_Transparency     = gl .getUniformLocation (program, "x3d_Transparency");
-
-			this .x3d_BackAmbientIntensity = gl .getUniformLocation (program, "x3d_BackAmbientIntensity");
-			this .x3d_BackDiffuseColor     = gl .getUniformLocation (program, "x3d_BackDiffuseColor");
-			this .x3d_BackSpecularColor    = gl .getUniformLocation (program, "x3d_BackSpecularColor");
-			this .x3d_BackEmissiveColor    = gl .getUniformLocation (program, "x3d_BackEmissiveColor");
-			this .x3d_BackShininess        = gl .getUniformLocation (program, "x3d_BackShininess");
-			this .x3d_BackTransparency     = gl .getUniformLocation (program, "x3d_BackTransparency");
-
-			this .x3d_TextureType    = gl .getUniformLocation (program, "x3d_TextureType");
-			this .x3d_Texture2D      = gl .getUniformLocation (program, "x3d_Texture2D");
-			this .x3d_CubeMapTexture = gl .getUniformLocation (program, "x3d_CubeMapTexture");
-
-			this .x3d_Texture = gl .getUniformLocation (program, "x3d_Texture"); // depreciated
-
-			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_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_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_TextureCoordinateGeneratorMode [i]      = gl .getUniformLocation (program, "x3d_TextureCoordinateGenerator[" + i + "].mode");
+				this .x3d_TextureCoordinateGeneratorParameter [i] = gl .getUniformLocation (program, "x3d_TextureCoordinateGenerator[" + i + "].parameter");
+
+				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_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");
+			this .x3d_ParticleElapsedTime = gl .getUniformLocation (program, "x3d_Particle.elapsedTime");
+
+			// 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_Texture,              new Int32Array ([2])); // depreciated
-			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 .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;
@@ -210,15 +284,15 @@ function ($,
 				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)
@@ -233,22 +307,79 @@ function ($,
 			}
 
 			if (this .x3d_Vertex < 0)
+			{
+				if (gl .getVersion () >= 2)
+					console .warn ("Missing »in vec4 x3d_Vertex;«.");
+				else
+					console .warn ("Missing »attribute vec4 x3d_Vertex;«.");
+
 				return false;
+			}
 
 			return true;
 		},
+		getUniformLocation: function (gl, program, name, depreciated)
+		{
+			// Legacy function to get uniform location.
+
+			let location = gl .getUniformLocation (program, name);
+
+			if (location)
+				return location;
+
+			// Look for depreciated location.
+
+			if (depreciated)
+			{
+				location = gl .getUniformLocation (program, depreciated);
+
+				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 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 ();
 
-			for (var name in userDefinedFields)
+			this .textures .clear ();
+
+			userDefinedFields .forEach (function (field)
 			{
-				var
-					field    = userDefinedFields [name],
-					location = gl .getUniformLocation (program, name);
+				const location = gl .getUniformLocation (program, field .getName ());
 
 				if (location)
 				{
@@ -276,6 +407,10 @@ function ($,
 							location .array = new Float32Array (16);
 							break;
 						}
+						case X3DConstants .SFNode:
+						{
+							break;
+						}
 						case X3DConstants .MFBool:
 						case X3DConstants .MFInt32:
 						{
@@ -309,16 +444,16 @@ function ($,
 						}
 						case X3DConstants .MFNode:
 						{
-							var array = field ._uniformLocation = [ ];
+							const locations = location .locations = [ ];
 
-							for (var i = 0; ; ++ i)
+							for (let i = 0;; ++ i)
 							{
-								var location = gl .getUniformLocation (program, name + "[" + i + "]");
+								const l = gl .getUniformLocation (program, field .getName () + "[" + i + "]");
 
-								if (location)
-									array [i] = location;
-								else
+								if (! l)
 									break;
+
+								locations .push (l);
 							}
 
 							break;
@@ -347,523 +482,452 @@ function ($,
 
 					this .set_field__ (field);
 				}
-			}
+			},
+			this);
 		},
 		removeShaderFields: function ()
 		{
-			var
-				gl                = this .getBrowser () .getContext (),
-				program           = this .getProgram (),
-				userDefinedFields = this .getUserDefinedFields ();
+			const userDefinedFields = this .getUserDefinedFields ();
 
-			for (var name in userDefinedFields)
+			userDefinedFields .forEach (function (field)
 			{
-				var field = userDefinedFields [name];
-
 				field .removeInterest ("set_field__", this);
+			},
+			this);
+		},
+		set_field__: (function ()
+		{
+			const matrix3 = new Matrix3 ();
 
-				switch (field .getType ())
+			return function (field)
+			{
+				const
+					gl       = this .getBrowser () .getContext (),
+					location = field ._uniformLocation;
+
+				if (location)
 				{
-					case X3DConstants .SFNode:
-					{
-						this .removeNode (gl, program, field ._uniformLocation);
-						break;
-					}
-					case X3DConstants .MFNode:
+					switch (field .getType ())
 					{
-						var name = field .getName ();
+						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:
+						{
+							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;
+
+							const
+								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 (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:
+						{
+							location .array .set (field .getValue ());
 
-						for (var i = 0; ; ++ i)
+							gl .uniformMatrix3fv (location, false, location .array);
+							return;
+						}
+						case X3DConstants .SFMatrix4d:
+						case X3DConstants .SFMatrix4f:
 						{
-							var location = gl .getUniformLocation (program, name + "[" + i + "]");
+							location .array .set (field .getValue ());
 
-							if (location)
-								this .removeNode (gl, program, location);
-							else
-								break;
+							gl .uniformMatrix4fv (location, false, location .array);
+							return;
 						}
+						case X3DConstants .SFNode:
+						{
+							const texture = X3DCast (X3DConstants .X3DTextureNode, field);
 
-						break;
-					}
-					default:
-						continue;
-				}
+							if (texture)
+							{
+								this .textures .set (location, { name: field .getName (), texture: texture, textureUnit: undefined } );
+								return;
+							}
 
-				break;
-			}
-		},
-		set_field__: function (field)
-		{
-			var
-				gl       = this .getBrowser () .getContext (),
-				program  = this .getProgram (),
-				location = field ._uniformLocation;
+							this .textures .delete (location);
+							return;
+						}
+						case X3DConstants .SFRotation:
+						{
+							field .getValue () .getMatrix (location .array);
 
-			if (location)
-			{
-				this .useProgram (gl); // TODO: only in ComposedShader possible.
+							gl .uniformMatrix3fv (location, false, location .array);
+							return;
+						}
+						case X3DConstants .SFString:
+						{
+							return;
+						}
+						case X3DConstants .SFVec2d:
+						case X3DConstants .SFVec2f:
+						{
+							const value = field .getValue ();
+							gl .uniform2f (location, value .x, value .y);
+							return;
+						}
+						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;
 
-				switch (field .getType ())
-				{
-					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 .getValue (),
-							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)
-							array [a ++] = pixels [p] .getValue ();
-	
-						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:
-					{
-						this .setNode (gl, program, location, field);
-						return;
-					}
-					case X3DConstants .SFRotation:
-					{
-						field .getValue () .getMatrix (location .array);
+							for (var i = 0, length = field .length; i < length; ++ i)
+								array [i] = field [i];
 
-						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
-							value = field .getValue (),
-							array = location .array;
-	
-						for (var i = 0, length = value .length; i < length; ++ i)
-							array [i] = value [i] .getValue ();
-	
-						for (var length = array .length; i < length; ++ i)
-							array [i] = 0;
-	
-						gl .uniform1iv (location, array);
-						return;
-					}
-					case X3DConstants .MFColor:
-					{
-						var
-							value = field .getValue (),
-							array = location .array;
-	
-						for (var i = 0, k = 0, length = value .length; i < length; ++ i)
+							for (let length = array .length; i < length; ++ i)
+								array [i] = 0;
+
+							gl .uniform1iv (location, array);
+							return;
+						}
+						case X3DConstants .MFColor:
 						{
-							var color = value [i] .getValue ();
-	
-							array [k++] = color .r;
-							array [k++] = color .g;
-							array [k++] = color .b;
+							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;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniform3fv (location, array);
-						return;
-					}
-					case X3DConstants .MFColorRGBA:
-					{
-						var
-							value = field .getValue (),
-							array = location .array;
-	
-						for (var i = 0, k = 0, length = value .length; i < length; ++ i)
+						case X3DConstants .MFColorRGBA:
 						{
-							var color = value [i] .getValue ();
-	
-							array [k++] = color .r;
-							array [k++] = color .g;
-							array [k++] = color .b;
-							array [k++] = color .a;
+							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;
+								array [k++] = color .a;
+							}
+
+							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;
-					}
-					case X3DConstants .MFDouble:
-					case X3DConstants .MFFloat:
-					case X3DConstants .MFTime:
-					{
-						var
-							value = field .getValue (),
-							array = location .array;
-	
-						for (var i = 0, length = value .length; i < length; ++ i)
-							array [i] = value [i] .getValue ();
-	
-						for (var length = array .length; i < length; ++ i)
-							array [i] = 0;
-	
-						gl .uniform1fv (location, array);
-						return;
-					}
-					case X3DConstants .MFImage:
-					{
-						var
-							images = field .getValue (),
-							array  = location .array,
-							length = this .getImagesLength (field);
-	
-						if (length !== array .length)
-							array = location .array = new Int32Array (length);
-	
-						for (var i = 0, a = 0, length = images .length; i < length; ++ i)
+						case X3DConstants .MFDouble:
+						case X3DConstants .MFFloat:
+						case X3DConstants .MFTime:
 						{
-							var
-								value  = images [i],
-								pixels = value .array .getValue ();
-	
-							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] .getValue ();
+							const array = location .array;
+
+							for (var i = 0, length = field .length; i < length; ++ i)
+								array [i] = field [i];
+
+							for (let length = array .length; i < length; ++ i)
+								array [i] = 0;
+
+							gl .uniform1fv (location, array);
+							return;
 						}
-	
-						gl .uniform1iv (location, array);
-						return;
-					}
-					case X3DConstants .MFMatrix3d:
-					case X3DConstants .MFMatrix3f:
-					{
-						var
-							value = field .getValue (),
-							array = location .array;
-	
-						for (var i = 0, k = 0, length = value .length; i < length; ++ i)
+						case X3DConstants .MFImage:
 						{
-							var matrix = value [i] .getValue ();
-	
-							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];
+							let array = location .array;
+
+							const numImages = this .getImagesLength (field);
+
+							if (numImages !== array .length)
+								array = location .array = new Int32Array (numImages);
+
+							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 .MFMatrix4d:
-					case X3DConstants .MFMatrix4f:
-					{
-						var
-							value = field .getValue (),
-							array = location .array;
-	
-						for (var i = 0, k = 0, length = value .length; i < length; ++ i)
+						case X3DConstants .MFMatrix3d:
+						case X3DConstants .MFMatrix3f:
 						{
-							var matrix = value [i] .getValue ();
-	
-							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];
-							array [k++] = matrix [ 9];
-							array [k++] = matrix [10];
-							array [k++] = matrix [11];
-							array [k++] = matrix [12];
-							array [k++] = matrix [13];
-							array [k++] = matrix [14];
-							array [k++] = matrix [15];
+							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;
-	
-						gl .uniformMatrix4fv (location, false, array);
-						return;
-					}
-					case X3DConstants .MFNode:
-					{
-						var value = field .getValue ();
-	
-						for (var i = 0, length = value .length; i < length; ++ i)
-							this .setNode (gl, program, location [i], value [i]);
-	
-						for (var length = location .length; i < length; ++ i)
-							this .setNode (gl, program, location [i], NULL);
-	
-						return;
-					}
-					case X3DConstants .MFRotation:
-					{
-						var
-							value = field .getValue (),
-							array = location .array;
+						case X3DConstants .MFMatrix4d:
+						case X3DConstants .MFMatrix4f:
+						{
+							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 < 16; ++ m)
+									array [k++] = matrix [m];
+							}
 
-						for (var i = 0, k = 0, length = value .length; i < length; ++ i)
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
+
+							gl .uniformMatrix4fv (location, false, array);
+							return;
+						}
+						case X3DConstants .MFNode:
 						{
-							var matrix = value [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 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 .uniformMatrix3fv (location, false, array);
-						return;
-					}
-					case X3DConstants .MFString:
-					{
-						return;
-					}
-					case X3DConstants .MFVec2d:
-					case X3DConstants .MFVec2f:
-					{
-						var
-							value = field .getValue (),
-							array = location .array;
-	
-						for (var i = 0, k = 0, length = value .length; i < length; ++ i)
+						case X3DConstants .MFRotation:
 						{
-							var vector = value [i] .getValue ();
-	
-							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] .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;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniform2fv (location, array);
-						return;
-					}
-					case X3DConstants .MFVec3d:
-					case X3DConstants .MFVec3f:
-					{
-						var
-							value = field .getValue (),
-							array = location .array;
-	
-						for (var i = 0, k = 0, length = value .length; i < length; ++ i)
+						case X3DConstants .MFString:
 						{
-							var vector = value [i] .getValue ();
-	
-							array [k++] = vector .x;
-							array [k++] = vector .y;
-							array [k++] = vector .z;
+							return;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniform3fv (location, array);
-						return;
-					}
-					case X3DConstants .MFVec4d:
-					case X3DConstants .MFVec4f:
-					{
-						var
-							value = field .getValue (),
-							array = location .array;
-	
-						for (var i = 0, k = 0, length = value .length; i < length; ++ i)
+						case X3DConstants .MFVec2d:
+						case X3DConstants .MFVec2f:
 						{
-							var vector = value [i] .getValue ();
-	
-							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;
+							}
+
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
+
+							gl .uniform2fv (location, array);
+							return;
 						}
-	
-						for (var length = array .length; k < length; ++ k)
-							array [k] = 0;
-	
-						gl .uniform4fv (location, array);
-						return;
-					}
-				}
-			}
-		},
-		setNode: function (gl, program, location, field)
-		{
-			if (location)
-			{
-				var textureUnit = gl .getUniform (program, location);
+						case X3DConstants .MFVec3d:
+						case X3DConstants .MFVec3f:
+						{
+							const array = location .array;
 
-				if (! textureUnit)
-				{
-					if (this .getBrowser () .getCombinedTextureUnits () .length)
-					{
-						textureUnit = this .getBrowser () .getCombinedTextureUnits () .pop ();
-						gl .uniform1i (location, textureUnit);
-					}
-					else
-					{
-						console .warn ("Not enough combined texture units for uniform variable '", field .getName (), "' available.");
-						return;
-					}
-				}
+							for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							{
+								const vector = field [i];
 
-				gl .activeTexture (gl .TEXTURE0 + textureUnit);
+								array [k++] = vector .x;
+								array [k++] = vector .y;
+								array [k++] = vector .z;
+							}
 
-				var texture = X3DCast (X3DConstants .X3DTextureNode, field);
+							for (let length = array .length; k < length; ++ k)
+								array [k] = 0;
 
-				if (texture)
-					gl .bindTexture (texture .getTarget (), texture .getTexture ());
+							gl .uniform3fv (location, array);
+							return;
+						}
+						case X3DConstants .MFVec4d:
+						case X3DConstants .MFVec4f:
+						{
+							const array = location .array;
 
-				gl .activeTexture (gl .TEXTURE0);
-			}
-		},
-		removeNode: function (gl, program, location)
-		{
-			if (location)
-			{
-				var textureUnit = gl .getUniform (program, location);
-	
-				if (textureUnit)
-					this .getBrowser () .getCombinedTextureUnits () .push (textureUnit);
+							for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+							{
+								const vector = field [i];
 
-				gl .uniform1i (location, 0);
-			}
-		},
+								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;
+						}
+					}
+				}
+			};
+		})(),
 		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)
+			for (let i = 0, l = images .length; i < l; ++ i)
 				length += images [i] .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;
 		},
-		setClipPlanes: function (gl, clipPlanes)
+		hasLight: function (i, lightNode)
 		{
-			if (clipPlanes .length)
-			{
-				for (var i = 0, numClipPlanes = Math .min (this .x3d_MaxClipPlanes, clipPlanes .length); i < numClipPlanes; ++ i)
-					clipPlanes [i] .setShaderUniforms (gl, this, i);
-	
-				if (i < this .x3d_MaxClipPlanes)
-					gl .uniform4fv (this .x3d_ClipPlane [i], this .x3d_NoneClipPlane);
-			}
-			else
-				gl .uniform4fv (this .x3d_ClipPlane [0], this .x3d_NoneClipPlane);
+			if (this .lightNodes [i] === lightNode)
+				return true;
+
+			this .lightNodes [i] = lightNode;
+
+			return false;
+		},
+		hasTextureProjector: function (i, textureProjectorNode)
+		{
+			if (this .projectiveTextureNodes [i] === textureProjectorNode)
+				return true;
+
+			this .projectiveTextureNodes [i] = textureProjectorNode;
+
+			return false;
 		},
-		setGlobalUniforms: function (renderObject, gl, projectionMatrixArray, viewportArray)
+		setLocalObjects: function (gl, localObjects)
 		{
-			var globalLights = renderObject .getGlobalLights ();
+			// Clip planes and local lights
+
+			this .numClipPlanes                  = 0;
+			this .numLights                      = 0;
+			this .numProjectiveTextures          = 0;
+			this .lightNodes .length             = 0;
+			this .projectiveTextureNodes .length = 0;
+
+			for (const localObject of localObjects)
+				localObject .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));
+			gl .uniform1i (this .x3d_NumProjectiveTextures, Math .min (this .numProjectiveTextures, this .x3d_MaxTextures));
+		},
+		setGlobalUniforms: function (gl, renderObject, cameraSpaceMatrixArray, projectionMatrixArray, viewportArray)
+		{
+			const globalObjects = renderObject .getGlobalObjects ();
 
 			// Set viewport
 
@@ -871,160 +935,197 @@ function ($,
 
 			// Set projection matrix
 
-			gl .uniformMatrix4fv (this .x3d_ProjectionMatrix, false, projectionMatrixArray);
+			gl .uniformMatrix4fv (this .x3d_ProjectionMatrix,  false, projectionMatrixArray);
+			gl .uniformMatrix4fv (this .x3d_CameraSpaceMatrix, false, cameraSpaceMatrixArray);
+
+			// Fog
+
+			this .fogNode = null;
 
-			// Set global lights
+			// Set global lights and global texture projectors
 
-			this .numGlobalLights = Math .min (this .x3d_MaxLights, globalLights .length);
+			this .numLights                      = 0;
+			this .numProjectiveTextures          = 0;
+			this .lightNodes .length             = 0;
+			this .projectiveTextureNodes .length = 0;
 
-			for (var i = 0, length = this .numGlobalLights; i < length; ++ i)
-				globalLights [i] .setShaderUniforms (gl, this, i);
+			for (const globalObject of globalObjects)
+				globalObject .setShaderUniforms (gl, this);
+
+			this .numGlobalLights             = this .numLights;
+			this .numGlobalProjectiveTextures = this .numProjectiveTextures;
+
+			// Logarithmic depth buffer support.
+
+			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));
 		},
-		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,
-				clipPlaneNodes       = context .clipPlanes;
+			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
+			// Clip planes and local lights
 
-			if (clipPlaneNodes .length)
-			{
-				for (var i = 0, numClipPlanes = Math .min (this .x3d_MaxClipPlanes, clipPlaneNodes .length); i < numClipPlanes; ++ i)
-					clipPlaneNodes [i] .setShaderUniforms (gl, this, i);
-	
-				if (i < this .x3d_MaxClipPlanes)
-					gl .uniform4fv (this .x3d_ClipPlane [i], this .x3d_NoneClipPlane);
-			}
-			else
-			{
-				gl .uniform4fv (this .x3d_ClipPlane [0], this .x3d_NoneClipPlane);
-			}
+			this .numClipPlanes         = 0;
+			this .numLights             = this .numGlobalLights;
+			this .numProjectiveTextures = this .numGlobalProjectiveTextures;
 
-			// Fog, there is always one
+			for (const localObject of localObjects)
+				localObject .setShaderUniforms (gl, this);
 
-			context .fogNode .setShaderUniforms (gl, this, context .renderer);
+			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));
 
-			// LineProperties
+			// Fog, there is always one
 
-			if (linePropertiesNode && linePropertiesNode .applied_ .getValue ())
-			{
-				var linewidthScaleFactor = linePropertiesNode .getLinewidthScaleFactor ();
+			context .fogNode .setShaderUniforms (gl, this);
+			gl .uniform1i (this .x3d_FogCoord, geometryNode .fogCoords);
 
-				gl .lineWidth (linewidthScaleFactor);
-				gl .uniform1f (this .x3d_LinewidthScaleFactor, linewidthScaleFactor);
-			}
-			else
-			{
-				gl .lineWidth (1);
-				gl .uniform1f (this .x3d_LinewidthScaleFactor, 1);
-			}
-	
-			// Material
+			// Alpha
 
-			gl .uniform1i (this .x3d_ColorMaterial, context .colorMaterial);
+			gl .uniform1f (this .x3d_AlphaCutoff, appearanceNode .alphaCutoff);
 
-			if (materialNode)
-			{
-				// Lights
+			// Style
 
-				gl .uniform1i  (this .x3d_Lighting, true);
+			stylePropertiesNode .setShaderUniforms (gl, this);
 
-				var
-					localLights = context .localLights,
-					numLights   = Math .min (this .x3d_MaxLights, this .numGlobalLights + localLights .length);
+			// Material
 
-				for (var i = this .numGlobalLights, l = 0; i < numLights; ++ i, ++ l)
-					localLights [l] .setShaderUniforms (gl, this, i);
+			gl .uniform1i (this .x3d_ColorMaterial, geometryNode .colorMaterial);
+			materialNode .setShaderUniforms (gl, this, front);
 
-				if (numLights < this .x3d_MaxLights)
-					gl .uniform1i (this .x3d_LightType [numLights], 0);
+			// Normal matrix
 
-				// Material
+			gl .uniformMatrix3fv (this .x3d_NormalMatrix, false, this .getNormalMatrix (modelViewMatrix));
 
-				materialNode .setShaderUniforms (gl, this);
+			// Texture
 
-				// Normal matrix
+			if (textureNode)
+			{
+				textureNode           .setShaderUniforms (gl, this, context .renderer);
+				textureTransformNode  .setShaderUniforms (gl, this);
+				textureCoordinateNode .setShaderUniforms (gl, this);
+			}
+			else
+			{
+				gl .uniform1i (this .x3d_NumTextures, 0);
 
+				if (this .getCustom ())
+				{
+					textureTransformNode  .setShaderUniforms (gl, this);
+					textureCoordinateNode .setShaderUniforms (gl, this);
+				}
+			}
+		},
+		getNormalMatrix: (function ()
+		{
+			const normalMatrix = new Float32Array (9);
+
+			return function (modelViewMatrix)
+			{
 				try
 				{
-					// Set normal matrix.
-					var normalMatrix = this .normalMatrixArray;
-					normalMatrix [0] = modelViewMatrix [0]; normalMatrix [1] = modelViewMatrix [4]; normalMatrix [2] = modelViewMatrix [ 8];
-					normalMatrix [3] = modelViewMatrix [1]; normalMatrix [4] = modelViewMatrix [5]; normalMatrix [5] = modelViewMatrix [ 9];
-					normalMatrix [6] = modelViewMatrix [2]; normalMatrix [7] = modelViewMatrix [6]; normalMatrix [8] = modelViewMatrix [10];
+					normalMatrix [0] = modelViewMatrix [0], normalMatrix [3] = modelViewMatrix [1], normalMatrix [6] = modelViewMatrix [ 2],
+					normalMatrix [1] = modelViewMatrix [4], normalMatrix [4] = modelViewMatrix [5], normalMatrix [7] = modelViewMatrix [ 6],
+					normalMatrix [2] = modelViewMatrix [8], normalMatrix [5] = modelViewMatrix [9], normalMatrix [8] = modelViewMatrix [10];
+
 					Matrix3 .prototype .inverse .call (normalMatrix);
-					gl .uniformMatrix3fv (this .x3d_NormalMatrix, false, normalMatrix);
+
+					return normalMatrix;
 				}
 				catch (error)
 				{
-					gl .uniformMatrix3fv (this .x3d_NormalMatrix, false, new Float32Array (Matrix3 .Identity));
+					normalMatrix .set (Matrix3 .Identity);
+
+					return normalMatrix;
 				}
-			}
-			else
+			};
+		})(),
+		enable: function (gl)
+		{
+			const browser = this .getBrowser ();
+
+			//console .log (this .getName ());
+			//console .log (browser .getCombinedTextureUnits () .length);
+
+			this .textures .forEach (function (object, location)
 			{
-				gl .uniform1i (this .x3d_Lighting, false);
+				const
+					name    = object .name,
+					texture = object .texture;
 
-				if (this .getCustom ())
+				if (! browser .getCombinedTextureUnits () .length)
 				{
-					try
-					{
-						// Set normal matrix.
-						var normalMatrix = this .normalMatrixArray;
-						normalMatrix [0] = modelViewMatrix [0]; normalMatrix [1] = modelViewMatrix [4]; normalMatrix [2] = modelViewMatrix [ 8];
-						normalMatrix [3] = modelViewMatrix [1]; normalMatrix [4] = modelViewMatrix [5]; normalMatrix [5] = modelViewMatrix [ 9];
-						normalMatrix [6] = modelViewMatrix [2]; normalMatrix [7] = modelViewMatrix [6]; normalMatrix [8] = modelViewMatrix [10];
-						Matrix3 .prototype .inverse .call (normalMatrix);
-						gl .uniformMatrix3fv (this .x3d_NormalMatrix, false, normalMatrix);
-					}
-					catch (error)
-					{
-						gl .uniformMatrix3fv (this .x3d_NormalMatrix, false, new Float32Array (Matrix3 .Identity));
-					}
+					console .warn ("Not enough combined texture units for uniform variable '" + name + "' available.");
+					return;
 				}
-			}
 
-			if (textureNode)
-			{
-				textureNode .setShaderUniforms (gl, this, 0);
-				textureTransformNode .setShaderUniforms (gl, this);
-			}
-			else
+				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)
+		{
+			const browser = this .getBrowser ();
+
+			this .textures .forEach (function (object)
 			{
-				this .textureTypeArray [0] = 0;
-				gl .uniform1iv (this .x3d_TextureType, this .textureTypeArray);
+				const textureUnit = object .textureUnit;
 
-				if (this .getCustom ())
-				{
-					textureTransformNode .setShaderUniforms (gl, this);
-				}
-			}
+				if (textureUnit !== undefined)
+					browser .getCombinedTextureUnits () .push (textureUnit);
 
-			gl .uniformMatrix4fv (this .x3d_ModelViewMatrix, false, modelViewMatrix);
+				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;
@@ -1033,63 +1134,73 @@ function ($,
 		},
 		enableMatrix3Attrib: function (gl, name, buffer)
 		{
-			var location = gl .getAttribLocation (this .getProgram (), name);
+			const location = gl .getAttribLocation (this .getProgram (), name);
 
 			if (location === -1)
 				return;
 
-			gl .enableVertexAttribArray (location + 0);
+			gl .enableVertexAttribArray (location);
 			gl .enableVertexAttribArray (location + 1);
 			gl .enableVertexAttribArray (location + 2);
 
 			gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
 
-			gl .vertexAttribPointer (location + 0, 3, gl .FLOAT, false, 9 * 4, 3 * 4 * 0);
+			gl .vertexAttribPointer (location,     3, gl .FLOAT, false, 9 * 4, 3 * 4 * 0);
 			gl .vertexAttribPointer (location + 1, 3, gl .FLOAT, false, 9 * 4, 3 * 4 * 1);
 			gl .vertexAttribPointer (location + 2, 3, gl .FLOAT, false, 9 * 4, 3 * 4 * 2);
 		},
 		disableMatrix3Attrib: function (gl, name)
 		{
-			var location = gl .getAttribLocation (this .getProgram (), name);
+			const location = gl .getAttribLocation (this .getProgram (), name);
 
 			if (location === -1)
 				return;
 
-			gl .disableVertexAttribArray (location + 0);
+			gl .disableVertexAttribArray (location);
 			gl .disableVertexAttribArray (location + 1);
 			gl .disableVertexAttribArray (location + 2);
 		},
 		enableMatrix4Attrib: function (gl, name, buffer)
 		{
-			var location = gl .getAttribLocation (this .getProgram (), name);
+			const location = gl .getAttribLocation (this .getProgram (), name);
 
 			if (location === -1)
 				return;
 
-			gl .enableVertexAttribArray (location + 0);
+			gl .enableVertexAttribArray (location);
 			gl .enableVertexAttribArray (location + 1);
 			gl .enableVertexAttribArray (location + 2);
 			gl .enableVertexAttribArray (location + 3);
 
 			gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
 
-			gl .vertexAttribPointer (location + 0, 4, gl .FLOAT, false, 16 * 4, 4 * 4 * 0);
+			gl .vertexAttribPointer (location,     4, gl .FLOAT, false, 16 * 4, 4 * 4 * 0);
 			gl .vertexAttribPointer (location + 1, 4, gl .FLOAT, false, 16 * 4, 4 * 4 * 1);
 			gl .vertexAttribPointer (location + 2, 4, gl .FLOAT, false, 16 * 4, 4 * 4 * 2);
 			gl .vertexAttribPointer (location + 3, 4, gl .FLOAT, false, 16 * 4, 4 * 4 * 3);
 		},
 		disableMatrix4Attrib: function (gl, name)
 		{
-			var location = gl .getAttribLocation (this .getProgram (), name);
+			const location = gl .getAttribLocation (this .getProgram (), name);
 
 			if (location === -1)
 				return;
 
-			gl .disableVertexAttribArray (location + 0);
+			gl .disableVertexAttribArray (location);
 			gl .disableVertexAttribArray (location + 1);
 			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);
@@ -1100,15 +1211,33 @@ function ($,
 		{
 			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)
 		{
@@ -1130,13 +1259,23 @@ function ($,
 		{
 			gl .disableVertexAttribArray (this .x3d_Vertex);
 		},
+		setParticle: function (gl, particle, modelViewMatrix)
+		{
+			gl .uniformMatrix4fv (this .x3d_ModelViewMatrix, false, modelViewMatrix);
+
+			gl .uniform1i (this .x3d_ParticleId,          particle .id);
+			gl .uniform1i (this .x3d_ParticleLife,        particle .life);
+			gl .uniform1f (this .x3d_ParticleElapsedTime, particle .elapsedTime / particle .lifetime);
+		},
 		getProgramInfo: function ()
 		{
-			var
+			function cmp (lhs, rhs) { return lhs < rhs ? -1 : lhs > rhs ? 1 : 0; }
+
+			const
 				gl      = this .getBrowser () .getContext (),
 				program = this .getProgram ();
 
-			var
+			const
 				result = {
 					attributes: [ ],
 					uniforms: [ ],
@@ -1148,7 +1287,7 @@ function ($,
 
 			// 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',
@@ -1174,31 +1313,31 @@ function ($,
 			};
 
 			// 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 ($.extend ({ }, uniform));
+				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 ($.extend ({ }, attribute));
+				result .attributes .push (Object .assign ({ }, attribute));
 				result .attributeCount += attribute .size;
 			}
 
-			result .uniforms   .sort (function (a, b) { return a .name < b .name ? -1 : a .name > b .name ? 1 : 0 });
-			result .attributes .sort (function (a, b) { return a .name < b .name ? -1 : a .name > b .name ? 1 : 0 });
+			result .uniforms   .sort (function (a, b) { return cmp (a .name, b .name); });
+			result .attributes .sort (function (a, b) { return cmp (a .name, b .name); });
 
 			return result;
 		},
 		printProgramInfo: function ()
 		{
-			var programInfo = this .getProgramInfo ();
+			const programInfo = this .getProgramInfo ();
 
 			console .log (this .getName ());
 			console .table (programInfo .attributes);
@@ -1211,5 +1350,3 @@ function ($,
 
 	return X3DProgrammableShaderObject;
 });
-
-