x_ite 4.0.5 → 4.7.5

package/src/x_ite/Rendering/X3DRenderObject.js

@@ -49,7 +49,7 @@
 
 define ([
 	"jquery",
-	"x_ite/Rendering/DepthBuffer",
+	"x_ite/Rendering/TextureBuffer",
 	"x_ite/Bits/TraverseType",
 	"standard/Math/Algorithm",
 	"standard/Math/Algorithms/MergeSort",
@@ -63,7 +63,7 @@ define ([
 	"standard/Math/Utility/MatrixStack",
 ],
 function ($,
-          DepthBuffer,
+          TextureBuffer,
 	       TraverseType,
           Algorithm,
           MergeSort,
@@ -78,43 +78,28 @@ function ($,
 {
 "use strict";
 
-	var
-		DEPTH_BUFFER_WIDTH          = 16,
-		DEPTH_BUFFER_HEIGHT         = DEPTH_BUFFER_WIDTH,
-		viewportArray               = new Int32Array (4),
-		projectionMatrix            = new Matrix4 (),
-		projectionMatrixArray       = new Float32Array (16),
-		modelViewMatrix             = new Matrix4 (),
-		cameraSpaceProjectionMatrix = new Matrix4 (),
-		localOrientation            = new Rotation4 (0, 0, 1, 0),
-		yAxis                       = new Vector3 (0, 1, 0),
-		zAxis                       = new Vector3 (0, 0, 1),
-		vector                      = new Vector3 (0, 0, 0),
-		rotation                    = new Rotation4 (0, 0, 1, 0),
-		depthBufferViewport         = new Vector4 (0, 0, DEPTH_BUFFER_WIDTH, DEPTH_BUFFER_HEIGHT),
-		depthBufferViewVolume       = new ViewVolume (),
-		collisionBox                = new Box3 (Vector3 .Zero, Vector3 .Zero),
-		collisionSize               = new Vector3 (0, 0, 0);
-
-	depthBufferViewVolume .set (Matrix4 .Identity, depthBufferViewport, depthBufferViewport);
+	const
+		DEPTH_BUFFER_WIDTH  = 16,
+		DEPTH_BUFFER_HEIGHT = DEPTH_BUFFER_WIDTH;
 
 	function compareDistance (lhs, rhs) { return lhs .distance < rhs .distance; }
 
 	function X3DRenderObject (executionContext)
 	{
 		this .cameraSpaceMatrix        = new MatrixStack (Matrix4);
-		this .inverseCameraSpaceMatrix = new MatrixStack (Matrix4);
+		this .viewMatrix               = new MatrixStack (Matrix4);
 		this .projectionMatrix         = new MatrixStack (Matrix4);
 		this .modelViewMatrix          = new MatrixStack (Matrix4);
 		this .viewVolumes              = [ ];
-		this .clipPlanes               = [ ];
-		this .globalLights             = [ ];
-		this .localLights              = [ ];
+		this .globalObjects            = [ ];
+		this .localObjects             = [ ];
 		this .lights                   = [ ];
+		this .shadow                   = [ false ];
 		this .localFogs                = [ ];
 		this .layouts                  = [ ];
+		this .textureProjectors        = [ ];
 		this .generatedCubeMapTextures = [ ];
-		this .shaders                  = [ ];
+		this .shaders                  = new Set ();
 		this .collisions               = [ ];
 		this .numOpaqueShapes          = 0;
 		this .numTransparentShapes     = 0;
@@ -126,12 +111,11 @@ function ($,
 		this .collisionShapes          = [ ];
 		this .activeCollisions         = { };
 		this .depthShapes              = [ ];
-		this .invModelViewMatrix       = new Matrix4 ();
 		this .speed                    = 0;
 
 		try
 		{
-			this .depthBuffer = new DepthBuffer (executionContext .getBrowser (), DEPTH_BUFFER_WIDTH, DEPTH_BUFFER_HEIGHT);
+			this .depthBuffer = new TextureBuffer (executionContext .getBrowser (), DEPTH_BUFFER_WIDTH, DEPTH_BUFFER_HEIGHT);
 		}
 		catch (error)
 		{
@@ -144,9 +128,6 @@ function ($,
 	X3DRenderObject .prototype =
 	{
 		constructor: X3DRenderObject,
-		bboxSize: new Vector3 (0, 0, 0),
-		bboxCenter: new Vector3 (0, 0, 0),
-		translation: new Vector3 (0, 0, 0),
 		initialize: function ()
 		{ },
 		isIndependent: function ()
@@ -157,9 +138,9 @@ function ($,
 		{
 			return this .cameraSpaceMatrix;
 		},
-		getInverseCameraSpaceMatrix: function ()
+		getViewMatrix: function ()
 		{
-			return this .inverseCameraSpaceMatrix;
+			return this .viewMatrix;
 		},
 		getProjectionMatrix: function ()
 		{
@@ -175,39 +156,55 @@ function ($,
 		},
 		getViewVolume: function ()
 		{
-			return this .viewVolumes [this .viewVolumes .length - 1];
+			return this .viewVolumes .at (-1);
 		},
-		getClipPlanes: function ()
+		getGlobalObjects: function ()
 		{
-			return this .clipPlanes;
+			return this .globalObjects;
 		},
-		getGlobalLights: function ()
+		getLocalObjects: function ()
 		{
-			return this .globalLights;
-		},
-		getLocalLights: function ()
-		{
-			return this .localLights;
+			return this .localObjects;
 		},
 		getLights: function ()
 		{
 			return this .lights;
 		},
-		setGlobalFog: function (fog)
+		pushShadow: function (value)
+		{
+			this .shadow .push (value || this .shadow .at (-1));
+		},
+		popShadow: function ()
 		{
-			this .localFog = this .localFogs [0] = fog;
+			this .shadow .pop ();
 		},
-		pushLocalFog: function (fog)
+		setGlobalFog: (function ()
 		{
-			this .localFogs .push (fog);
+			const modelViewMatrix = new Matrix4 ();
+
+			return function (fog)
+			{
+				const fogContainer = this .localFogs [0] || fog .getFogs () .pop ();
+
+				modelViewMatrix .assign (fog .getModelMatrix ()) .multRight (this .getViewMatrix () .get ());
+				fogContainer .set (fog, modelViewMatrix);
 
-			this .localFog = fog;
+				this .localFog = this .localFogs [0] = fogContainer;
+			};
+		})(),
+		pushLocalFog: function (localFog)
+		{
+			this .localFogs .push (localFog);
+
+			this .localFog = localFog;
 		},
 		popLocalFog: function ()
 		{
-			this .localFogs .pop ();
+			const localFog = this .localFogs .pop ();
 
-			this .localFog = this .localFogs [this .localFogs .length - 1];
+			this .localFog = this .localFogs .at (-1);
+
+			return localFog;
 		},
 		getLayouts: function ()
 		{
@@ -215,7 +212,11 @@ function ($,
 		},
 		getParentLayout: function ()
 		{
-			return this .layouts .length ? this .layouts [this .layouts .length - 1] : null;
+			return this .layouts .at (-1);
+		},
+		getTextureProjectors: function ()
+		{
+			return this .textureProjectors;
 		},
 		getGeneratedCubeMapTextures: function ()
 		{
@@ -229,28 +230,74 @@ function ($,
 		{
 			return this .collisions;
 		},
+		setNumCollisionShapes: function (value)
+		{
+			this .numCollisionShapes = value;
+		},
+		getNumCollisionShapes: function ()
+		{
+			return this .numCollisionShapes;
+		},
+		getCollisionShapes: function ()
+		{
+			return this .collisionShapes;
+		},
+		setNumDepthShapes: function (value)
+		{
+			this .numDepthShapes = value;
+		},
+		getNumDepthShapes: function ()
+		{
+			return this .numDepthShapes;
+		},
+		getDepthShapes: function ()
+		{
+			return this .depthShapes;
+		},
+		setNumOpaqueShapes: function (value)
+		{
+			this .numOpaqueShapes = value;
+		},
+		getNumOpaqueShapes: function ()
+		{
+			return this .numOpaqueShapes;
+		},
+		getOpaqueShapes: function ()
+		{
+			return this .opaqueShapes;
+		},
+		setNumTransparentShapes: function (value)
+		{
+			this .numTransparentShapes = value;
+		},
+		getNumTransparentShapes: function ()
+		{
+			return this .numTransparentShapes;
+		},
+		getTransparentShapes: function ()
+		{
+			return this .transparentShapes;
+		},
 		constrainTranslation: function (translation, stepBack)
 		{
 			///  Contrains @a translation to a possible value the avatar can move.  If the avatar reaches and intersects with an
 			///  and obstacle and @a stepBack is true a translation in the opposite directiion is returned.  Future implementation will
 			///  will then return a value where the avatar slides along the wall.  Modifies translation in place.
 
-			var distance = this .getDistance (translation);
-
 			// Constrain translation when the viewer collides with an obstacle.
 
-			distance -= this .getNavigationInfo () .getCollisionRadius ();
+			const distance = this .getDistance (translation) - this .getNavigationInfo () .getCollisionRadius ();
 
 			if (distance > 0)
 			{
 				// Move.
-				
-				var length = translation .abs ();
+
+				const length = translation .abs ();
 
 				if (length > distance)
 				{
 					// Collision, the avatar would intersect with the obstacle.
-					
+
 					return translation .normalize () .multiply (distance);
 				}
 
@@ -266,79 +313,98 @@ function ($,
 
 			return translation .assign (Vector3 .Zero);
 		},
-		getDistance: function (direction)
+		getDistance: (function ()
 		{
-			///  Returns the distance to the closest object in @a direction.  The maximum determinable value is avatarHeight * 2.
-
-			try
+			const
+				projectionMatrix            = new Matrix4 (),
+				cameraSpaceProjectionMatrix = new Matrix4 (),
+				localOrientation            = new Rotation4 (0, 0, 1, 0),
+				vector                      = new Vector3 (0, 0, 0),
+				rotation                    = new Rotation4 (0, 0, 1, 0);
+
+			return function (direction)
 			{
-			   var t0 = performance .now ();
+				///  Returns the distance to the closest object in @a direction.  The maximum determinable value is avatarHeight * 2.
+
+				try
+				{
+				   const t0 = performance .now ();
 
-				var
-					viewpoint       = this .getViewpoint (),
-					navigationInfo  = this .getNavigationInfo (),
-					collisionRadius = navigationInfo .getCollisionRadius (),
-					bottom          = navigationInfo .getStepHeight () - navigationInfo .getAvatarHeight (),
-					nearValue       = navigationInfo .getNearValue (),
-					avatarHeight    = navigationInfo .getAvatarHeight ();
+					const
+						viewpoint       = this .getViewpoint (),
+						navigationInfo  = this .getNavigationInfo (),
+						collisionRadius = navigationInfo .getCollisionRadius (),
+						bottom          = navigationInfo .getStepHeight () - navigationInfo .getAvatarHeight (),
+						nearValue       = navigationInfo .getNearValue (),
+						avatarHeight    = navigationInfo .getAvatarHeight ();
 
-				// Determine width and height of camera
+					// Determine width and height of camera
 
-				// Reshape camera
+					// Reshape camera
 
-				Camera .ortho (-collisionRadius,
-				               collisionRadius,
-				               Math .min (bottom, -collisionRadius), /// TODO: bottom could be a positive value if stepHeight > avatarHeight.
-				               collisionRadius,
-				               nearValue,
-				               Math .max (collisionRadius * 2, avatarHeight * 2),
-				               projectionMatrix);
+					Camera .ortho (-collisionRadius,
+					               collisionRadius,
+					               Math .min (bottom, -collisionRadius), /// TODO: bottom could be a positive value if stepHeight > avatarHeight.
+					               collisionRadius,
+					               nearValue,
+					               Math .max (collisionRadius * 2, avatarHeight * 2),
+					               projectionMatrix);
 
-				// Translate camera to user position and to look in the direction of the direction.
+					// Translate camera to user position and to look in the direction of the direction.
 
-				localOrientation .assign (viewpoint .orientation_ .getValue ()) .inverse () .multRight (viewpoint .getOrientation ());
-				rotation .setFromToVec (zAxis, vector .assign (direction) .negate ()) .multRight (localOrientation);
-				viewpoint .straightenHorizon (rotation);
+					localOrientation .assign (viewpoint .orientation_ .getValue ()) .inverse () .multRight (viewpoint .getOrientation ());
+					rotation .setFromToVec (Vector3 .zAxis, vector .assign (direction) .negate ()) .multRight (localOrientation);
+					viewpoint .straightenHorizon (rotation);
 
-				cameraSpaceProjectionMatrix .assign (viewpoint .getTransformationMatrix ());
-				cameraSpaceProjectionMatrix .translate (viewpoint .getUserPosition ());
-				cameraSpaceProjectionMatrix .rotate (rotation);
-				cameraSpaceProjectionMatrix .inverse ();
+					cameraSpaceProjectionMatrix .assign (viewpoint .getModelMatrix ());
+					cameraSpaceProjectionMatrix .translate (viewpoint .getUserPosition ());
+					cameraSpaceProjectionMatrix .rotate (rotation);
+					cameraSpaceProjectionMatrix .inverse ();
 
-				cameraSpaceProjectionMatrix .multRight (projectionMatrix);
-				cameraSpaceProjectionMatrix .multLeft (viewpoint .getCameraSpaceMatrix ());
+					cameraSpaceProjectionMatrix .multRight (projectionMatrix);
+					cameraSpaceProjectionMatrix .multLeft (viewpoint .getCameraSpaceMatrix ());
 
-				this .getProjectionMatrix () .pushMatrix (cameraSpaceProjectionMatrix);
+					this .getProjectionMatrix () .pushMatrix (cameraSpaceProjectionMatrix);
 
-				var depth = this .getDepth (projectionMatrix);
+					const depth = this .getDepth (projectionMatrix);
 
-				this .getProjectionMatrix () .pop ();
+					this .getProjectionMatrix () .pop ();
 
-				this .collisionTime += performance .now () - t0;
-				return -depth;
-			}
-			catch (error)
-			{
-				console .log (error);
-			}
-		},
-		getDepth: function (projectionMatrix)
+					this .collisionTime += performance .now () - t0;
+					return -depth;
+				}
+				catch (error)
+				{
+					console .log (error);
+				}
+			};
+		})(),
+		getDepth: (function ()
 		{
-			///  Returns the depth value to the closest object.  The maximum determinable value is avatarHeight * 2.
+			const
+				depthBufferViewport   = new Vector4 (0, 0, DEPTH_BUFFER_WIDTH, DEPTH_BUFFER_HEIGHT),
+				depthBufferViewVolume = new ViewVolume ();
+
+			depthBufferViewVolume .set (Matrix4 .Identity, depthBufferViewport, depthBufferViewport);
 
-			this .depthBuffer .bind ();
+			return function (projectionMatrix)
+			{
+				///  Returns the depth value to the closest object.  The maximum determinable value is avatarHeight * 2.
 
-			this .viewVolumes .push (depthBufferViewVolume);
-			this .depth (this .collisionShapes, this .numCollisionShapes);
-			this .viewVolumes .pop ();	
+				this .depthBuffer .bind ();
 
-			var depth = this .depthBuffer .getDepth (projectionMatrix, depthBufferViewport);
+				this .viewVolumes .push (depthBufferViewVolume);
+				this .depth (this .collisionShapes, this .numCollisionShapes);
+				this .viewVolumes .pop ();
 
-			this .depthBuffer .unbind ();
+				const depth = this .depthBuffer .getDepth (projectionMatrix, depthBufferViewport);
 
-			return depth;
-		},
-		render: function (type, group)
+				this .depthBuffer .unbind ();
+
+				return depth;
+			};
+		})(),
+		render: function (type, callback, group)
 		{
 			switch (type)
 			{
@@ -347,16 +413,16 @@ function ($,
 					// Collect for collide and gravite
 					this .numCollisionShapes = 0;
 
-					group .traverse (type, this);
+					callback .call (group, type, this);
 					this .collide ();
 					this .gravite ();
 					break;
 				}
-				case TraverseType .DEPTH:
+				case TraverseType .SHADOW:
 				{
 					this .numDepthShapes = 0;
 
-					group .traverse (type, this);
+					callback .call (group, type, this);
 					this .depth (this .depthShapes, this .numDepthShapes);
 					break;
 				}
@@ -368,568 +434,611 @@ function ($,
 
 					this .setGlobalFog (this .getFog ());
 
-					group .traverse (type, this);
-					this .draw (group);
+					callback .call (group, type, this);
+					this .draw ();
 					break;
 				}
 			}
 		},
-		addCollisionShape: function (shapeNode)
+		addCollisionShape: (function ()
 		{
-			var
-				modelViewMatrix = this .getModelViewMatrix () .get (),
-				bboxSize        = modelViewMatrix .multDirMatrix (this .bboxSize   .assign (shapeNode .getBBoxSize ())),
-				bboxCenter      = modelViewMatrix .multVecMatrix (this .bboxCenter .assign (shapeNode .getBBoxCenter ())),
-				radius          = bboxSize .abs () / 2,
-				viewVolume      = this .viewVolumes [this .viewVolumes .length - 1];
+			const
+				bboxSize   = new Vector3 (0, 0, 0),
+				bboxCenter = new Vector3 (0, 0, 0);
 
-			if (viewVolume .intersectsSphere (radius, bboxCenter))
+			return function (shapeNode)
 			{
-				if (this .numCollisionShapes === this .collisionShapes .length)
-					this .collisionShapes .push ({ renderer: this, modelViewMatrix: new Float32Array (16), collisions: [ ], clipPlanes: [ ] });
-	
-				var context = this .collisionShapes [this .numCollisionShapes];
-	
-				++ this .numCollisionShapes;
-	
-				context .modelViewMatrix .set (modelViewMatrix);
-				context .shapeNode = shapeNode;
-				context .scissor   = viewVolume .getScissor ();
-	
-				// Collisions
-	
-				var
-					sourceCollisions = this .getCollisions (),
-					destCollisions   = context .collisions;
-	
-				for (var i = 0, length = sourceCollisions .length; i < length; ++ i)
-				   destCollisions [i] = sourceCollisions [i];
-				
-				destCollisions .length = sourceCollisions .length;
-	
-				// Clip planes
-	
-				var
-					sourcePlanes = this .getClipPlanes (),
-					destPlanes   = context .clipPlanes;
-	
-				for (var i = 0, length = sourcePlanes .length; i < length; ++ i)
-					destPlanes [i] = sourcePlanes [i];
-				
-				destPlanes .length = sourcePlanes .length;
-	
-				return true;
-			}
+				const modelViewMatrix = this .getModelViewMatrix () .get ();
 
-			return false;
-		},
-		addDepthShape: function (shapeNode)
-		{
-			var
-				modelViewMatrix = this .getModelViewMatrix () .get (),
-				bboxSize        = modelViewMatrix .multDirMatrix (this .bboxSize   .assign (shapeNode .getBBoxSize ())),
-				bboxCenter      = modelViewMatrix .multVecMatrix (this .bboxCenter .assign (shapeNode .getBBoxCenter ())),
-				radius          = bboxSize .abs () / 2,
-				viewVolume      = this .viewVolumes [this .viewVolumes .length - 1];
+				modelViewMatrix .multDirMatrix (bboxSize   .assign (shapeNode .getBBoxSize ()));
+				modelViewMatrix .multVecMatrix (bboxCenter .assign (shapeNode .getBBoxCenter ()));
 
-			if (viewVolume .intersectsSphere (radius, bboxCenter))
-			{
-				if (this .numDepthShapes === this .depthShapes .length)
-					this .depthShapes .push ({ renderer: this, modelViewMatrix: new Float32Array (16), clipPlanes: [ ] });
-	
-				var context = this .depthShapes [this .numDepthShapes];
-	
-				++ this .numDepthShapes;
-	
-				context .modelViewMatrix .set (modelViewMatrix);
-				context .shapeNode = shapeNode;
-				context .scissor   = viewVolume .getScissor ();
-	
-				// Clip planes
-	
-				var
-					sourcePlanes = this .getClipPlanes (),
-					destPlanes   = context .clipPlanes;
-	
-				for (var i = 0, length = sourcePlanes .length; i < length; ++ i)
-					destPlanes [i] = sourcePlanes [i];
-				
-				destPlanes .length = sourcePlanes .length;
-	
-				return true;
-			}
+				const
+					radius     = bboxSize .abs () / 2,
+					viewVolume = this .viewVolumes .at (-1);
 
-			return false;
-		},
-		addDisplayShape: function (shapeNode)
+				if (viewVolume .intersectsSphere (radius, bboxCenter))
+				{
+					const num = this .numCollisionShapes ++;
+
+					if (num === this .collisionShapes .length)
+					{
+						this .collisionShapes .push ({ renderer: this, browser: this .getBrowser (), modelViewMatrix: new Float32Array (16), collisions: [ ], clipPlanes: [ ] });
+					}
+
+					const context = this .collisionShapes [num];
+
+					context .modelViewMatrix .set (modelViewMatrix);
+					context .shapeNode = shapeNode;
+					context .scissor   = viewVolume .getScissor ();
+
+					// Collisions
+
+					assign (context .collisions, this .collisions);
+
+					// Clip planes
+
+					assign (context .clipPlanes, this .localObjects);
+
+					return true;
+				}
+
+				return false;
+			};
+		})(),
+		addDepthShape: (function ()
 		{
-			var
-				modelViewMatrix = this .getModelViewMatrix () .get (),
-				bboxSize        = modelViewMatrix .multDirMatrix (this .bboxSize   .assign (shapeNode .getBBoxSize ())),
-				bboxCenter      = modelViewMatrix .multVecMatrix (this .bboxCenter .assign (shapeNode .getBBoxCenter ())),
-				radius          = bboxSize .abs () / 2,
-				distance        = bboxCenter .z,
-				viewVolume      = this .viewVolumes [this .viewVolumes .length - 1];
+			const
+				bboxSize   = new Vector3 (0, 0, 0),
+				bboxCenter = new Vector3 (0, 0, 0);
 
-			if (viewVolume .intersectsSphere (radius, bboxCenter))
+			return function (shapeNode)
 			{
-				if (shapeNode .isTransparent ())
-				{
-					var num = this .numTransparentShapes;
+				const modelViewMatrix = this .getModelViewMatrix () .get ();
 
-					if (num === this .transparentShapes .length)
-						this .transparentShapes .push (this .createShapeContext (true));
+				modelViewMatrix .multDirMatrix (bboxSize   .assign (shapeNode .getBBoxSize ()));
+				modelViewMatrix .multVecMatrix (bboxCenter .assign (shapeNode .getBBoxCenter ()));
 
-					var context = this .transparentShapes [num];
+				const
+					radius     = bboxSize .abs () / 2,
+					viewVolume = this .viewVolumes .at (-1);
 
-					++ this .numTransparentShapes;
-				}
-				else
+				if (viewVolume .intersectsSphere (radius, bboxCenter))
 				{
-					var num = this .numOpaqueShapes;
+					const num = this .numDepthShapes ++;
+
+					if (num === this .depthShapes .length)
+					{
+						this .depthShapes .push ({ renderer: this, browser: this .getBrowser (), modelViewMatrix: new Float32Array (16), clipPlanes: [ ] });
+					}
+
+					const context = this .depthShapes [num];
 
-					if (num === this .opaqueShapes .length)
-						this .opaqueShapes .push (this .createShapeContext (false));
+					context .modelViewMatrix .set (modelViewMatrix);
+					context .shapeNode = shapeNode;
+					context .scissor   = viewVolume .getScissor ();
 
-					var context = this .opaqueShapes [num];
+					// Clip planes
 
-					++ this .numOpaqueShapes;
+					assign (context .clipPlanes, this .localObjects);
+
+					return true;
 				}
 
-				context .modelViewMatrix .set (modelViewMatrix);
-				context .scissor .assign (viewVolume .getScissor ());
-				context .shapeNode = shapeNode;
-				context .distance  = distance - radius;
-				context .fogNode   = this .localFog;
+				return false;
+			};
+		})(),
+		addDisplayShape: (function ()
+		{
+			const
+				bboxSize   = new Vector3 (0, 0, 0),
+				bboxCenter = new Vector3 (0, 0, 0);
+
+			return function (shapeNode)
+			{
+				const modelViewMatrix = this .getModelViewMatrix () .get ();
 
-				// Clip planes
+				modelViewMatrix .multDirMatrix (bboxSize   .assign (shapeNode .getBBoxSize ()));
+				modelViewMatrix .multVecMatrix (bboxCenter .assign (shapeNode .getBBoxCenter ()));
 
-				var
-					sourcePlanes = this .getClipPlanes (),
-					destPlanes   = context .clipPlanes;
+				const
+					radius     = bboxSize .abs () / 2,
+					viewVolume = this .viewVolumes .at (-1);
 
-				for (var i = 0, length = sourcePlanes .length; i < length; ++ i)
-					destPlanes [i] = sourcePlanes [i];
-				
-				destPlanes .length = sourcePlanes .length;
+				if (viewVolume .intersectsSphere (radius, bboxCenter))
+				{
+					if (shapeNode .getTransparent ())
+					{
+						const num = this .numTransparentShapes ++;
 
-				// Local lights
+						if (num === this .transparentShapes .length)
+							this .transparentShapes .push (this .createShapeContext (true));
 
-				var
-					sourceLights = this .getLocalLights (),
-					destLights   = context .localLights;
+						var context = this .transparentShapes [num];
+					}
+					else
+					{
+						const num = this .numOpaqueShapes ++;
 
-				for (var i = 0, length = sourceLights .length; i < length; ++ i)
-					destLights [i] = sourceLights [i];
-				
-				destLights .length = sourceLights .length;
+						if (num === this .opaqueShapes .length)
+							this .opaqueShapes .push (this .createShapeContext (false));
 
-				return true;
-			}
+						var context = this .opaqueShapes [num];
+					}
 
-			return false;
-		},
+					context .modelViewMatrix .set (modelViewMatrix);
+					context .scissor .assign (viewVolume .getScissor ());
+					context .shapeNode   = shapeNode;
+					context .textureNode = null;
+					context .distance    = bboxCenter .z;
+					context .fogNode     = this .localFog;
+					context .shadow      = this .shadow .at (-1);
+
+					// Clip planes and local lights
+
+					assign (context .localObjects, this .localObjects);
+
+					return true;
+				}
+
+				return false;
+			};
+		})(),
 		createShapeContext: function (transparent)
 		{
 			return {
 				renderer: this,
-				transparent: true,
-				geometryType: 3,
-				colorMaterial: false,
+				browser: this .getBrowser (),
+				transparent: transparent,
 				modelViewMatrix: new Float32Array (16),
 				scissor: new Vector4 (0, 0, 0, 0),
-				clipPlanes: [ ],
-				localLights: [ ],
-				linePropertiesNode: null,
-				materialNode: null,
-				textureNode: null,
-				textureTransformNode: null,
-				shaderNode: null,
+				localObjects: [ ],
 			};
 		},
-		collide: function ()
+		collide: (function ()
 		{
-			// Collision nodes are handled here.
+			const
+				invModelViewMatrix = new Matrix4 (),
+				modelViewMatrix    = new Matrix4 (),
+				collisionBox       = new Box3 (Vector3 .Zero, Vector3 .Zero),
+				collisionSize      = new Vector3 (0, 0, 0);
 
-			var
-				activeCollisions = { }, // current active Collision nodes
-				collisionRadius2 = 2.2 * this .getNavigationInfo () .getCollisionRadius (); // Make the radius a little bit larger.
+			return function ()
+			{
+				// Collision nodes are handled here.
 
-			collisionSize .set (collisionRadius2, collisionRadius2, collisionRadius2);
+				const
+					activeCollisions = { }, // current active Collision nodes
+					collisionRadius2 = 2.2 * this .getNavigationInfo () .getCollisionRadius (); // Make the radius a little bit larger.
 
-			for (var i = 0, length = this .numCollisionShapes; i < length; ++ i)
-			{
-				try
-				{
-					var
-						context    = this .collisionShapes [i],
-						collisions = context .collisions;
+				collisionSize .set (collisionRadius2, collisionRadius2, collisionRadius2);
 
-					if (collisions .length)
+				for (let i = 0, length = this .numCollisionShapes; i < length; ++ i)
+				{
+					try
 					{
-					   collisionBox .set (collisionSize, Vector3 .Zero);
-						collisionBox .multRight (this .invModelViewMatrix .assign (context .modelViewMatrix) .inverse ());
+						const
+							context    = this .collisionShapes [i],
+							collisions = context .collisions;
 
-						if (context .shapeNode .intersectsBox (collisionBox, context .clipPlanes, modelViewMatrix .assign (context .modelViewMatrix)))
+						if (collisions .length)
 						{
-						   for (var c = 0; c < collisions .length; ++ c)
-								activeCollisions [collisions [c] .getId ()] = collisions [c];
+						   collisionBox .set (collisionSize, Vector3 .Zero);
+							collisionBox .multRight (invModelViewMatrix .assign (context .modelViewMatrix) .inverse ());
+
+							if (context .shapeNode .intersectsBox (collisionBox, context .clipPlanes, modelViewMatrix .assign (context .modelViewMatrix)))
+							{
+							   for (const collision of collisions)
+									activeCollisions [collision .getId ()] = collision;
+							}
 						}
 					}
+					catch (error)
+					{
+						console .log (error);
+					}
 				}
-				catch (error)
-				{
-					console .log (error);
-				}
-			}
 
-			// Set isActive to FALSE for affected nodes.
+				// Set isActive to FALSE for affected nodes.
 
-			if (! $.isEmptyObject (this .activeCollisions))
-			{
-				var inActiveCollisions = $.isEmptyObject (activeCollisions)
-				                         ? this .activeCollisions
-				                         : Algorithm .set_difference (this .activeCollisions, activeCollisions, { });
-		
-				for (var key in inActiveCollisions)
-					inActiveCollisions [key] .set_active (false);
-			}
+				if (! $.isEmptyObject (this .activeCollisions))
+				{
+					const inActiveCollisions = $.isEmptyObject (activeCollisions)
+					                           ? this .activeCollisions
+					                           : Algorithm .set_difference (this .activeCollisions, activeCollisions, { });
 
-			// Set isActive to TRUE for affected nodes.
+					for (const key in inActiveCollisions)
+						inActiveCollisions [key] .set_active (false);
+				}
 
-			this .activeCollisions = activeCollisions;
+				// Set isActive to TRUE for affected nodes.
 
-			for (var key in activeCollisions)
-				activeCollisions [key] .set_active (true);
-		},
-		gravite: function ()
+				this .activeCollisions = activeCollisions;
+
+				for (const key in activeCollisions)
+					activeCollisions [key] .set_active (true);
+			};
+		})(),
+		gravite: (function ()
 		{
-		   try
-		   {
-				// Terrain following and gravitation
+			const
+				projectionMatrix            = new Matrix4 (),
+				cameraSpaceProjectionMatrix = new Matrix4 (),
+				translation                 = new Vector3 (0, 0, 0),
+				rotation                    = new Rotation4 (0, 0, 1, 0);
 
-				if (this .getBrowser () .getActiveLayer () .getNavigationInfo () === this .getNavigationInfo ())
-				{
-					if (this .getBrowser () .getCurrentViewer () !== "WALK")
-						return;
-				}
-				else if (this .getNavigationInfo () .getViewer () !== "WALK")
-					return;
+			return function ()
+			{
+			   try
+			   {
+					const
+						browser    = this .getBrowser (),
+						shaderNode = browser .getDepthShader ();
 
-				// Get NavigationInfo values
+					if (shaderNode .getValid ())
+					{
+						// Terrain following and gravitation
 
-				var
-					navigationInfo  = this .getNavigationInfo (),
-					viewpoint       = this .getViewpoint (),
-					collisionRadius = navigationInfo .getCollisionRadius (),
-					nearValue       = navigationInfo .getNearValue (),
-					avatarHeight    = navigationInfo .getAvatarHeight (),
-					stepHeight      = navigationInfo .getStepHeight ();
+						if (browser .getActiveLayer () === this)
+						{
+							if (browser .getCurrentViewer () !== "WALK")
+								return;
+						}
+						else if (this .getNavigationInfo () .getViewer () !== "WALK")
+							return;
 
-				// Reshape viewpoint for gravite.
+						// Get NavigationInfo values
 
-				Camera .ortho (-collisionRadius,
-				               collisionRadius,
-				               -collisionRadius,
-				               collisionRadius,
-				               nearValue,
-				               Math .max (collisionRadius * 2, avatarHeight * 2),
-				               projectionMatrix)
+						const
+							navigationInfo  = this .getNavigationInfo (),
+							viewpoint       = this .getViewpoint (),
+							collisionRadius = navigationInfo .getCollisionRadius (),
+							nearValue       = navigationInfo .getNearValue (),
+							avatarHeight    = navigationInfo .getAvatarHeight (),
+							stepHeight      = navigationInfo .getStepHeight ();
 
-				// Transform viewpoint to look down the up vector
+						// Reshape viewpoint for gravite.
 
-				var
-					upVector = viewpoint .getUpVector (),
-					down     = rotation .setFromToVec (zAxis, upVector);
+						Camera .ortho (-collisionRadius,
+						               collisionRadius,
+						               -collisionRadius,
+						               collisionRadius,
+						               nearValue,
+						               Math .max (collisionRadius * 2, avatarHeight * 2),
+						               projectionMatrix);
 
-				cameraSpaceProjectionMatrix .assign (viewpoint .getTransformationMatrix ());
-				cameraSpaceProjectionMatrix .translate (viewpoint .getUserPosition ());
-				cameraSpaceProjectionMatrix .rotate (down);
-				cameraSpaceProjectionMatrix .inverse ();
+						// Transform viewpoint to look down the up vector
 
-				cameraSpaceProjectionMatrix .multRight (projectionMatrix);
-				cameraSpaceProjectionMatrix .multLeft (viewpoint .getCameraSpaceMatrix ());
+						const
+							upVector = viewpoint .getUpVector (),
+							down     = rotation .setFromToVec (Vector3 .zAxis, upVector);
 
-				this .getProjectionMatrix () .pushMatrix (cameraSpaceProjectionMatrix);
+						cameraSpaceProjectionMatrix .assign (viewpoint .getModelMatrix ());
+						cameraSpaceProjectionMatrix .translate (viewpoint .getUserPosition ());
+						cameraSpaceProjectionMatrix .rotate (down);
+						cameraSpaceProjectionMatrix .inverse ();
 
-				var distance = -this .getDepth (projectionMatrix);
+						cameraSpaceProjectionMatrix .multRight (projectionMatrix);
+						cameraSpaceProjectionMatrix .multLeft (viewpoint .getCameraSpaceMatrix ());
 
-				this .getProjectionMatrix () .pop ();
+						this .getProjectionMatrix () .pushMatrix (cameraSpaceProjectionMatrix);
 
-				// Gravite or step up
+						let distance = -this .getDepth (projectionMatrix);
 
-				distance -= avatarHeight;
+						this .getProjectionMatrix () .pop ();
 
-				var up = rotation .setFromToVec (yAxis, upVector);
+						// Gravite or step up
 
-				if (distance > 0)
-				{
-					// Gravite and fall down the to the floor
+						distance -= avatarHeight;
 
-					var currentFrameRate = this .speed ? this .getBrowser () .getCurrentFrameRate () : 1000000;
+						const up = rotation .setFromToVec (Vector3 .yAxis, upVector);
 
-					this .speed -= this .getBrowser () .getBrowserOptions () .Gravity_ .getValue () / currentFrameRate;
+						if (distance > 0)
+						{
+							// Gravite and fall down the to the floor
 
-					var translation = this .speed / currentFrameRate;
+							const currentFrameRate = this .speed ? browser .getCurrentFrameRate () : 1000000;
 
-					if (translation < -distance)
-					{
-						// The ground is reached.
-						translation = -distance;
-						this .speed = 0;
-					}
+							this .speed -= browser .getBrowserOptions () .Gravity_ .getValue () / currentFrameRate;
 
-					viewpoint .positionOffset_ = viewpoint .positionOffset_ .getValue () .add (up .multVecRot (vector .set (0, translation, 0)));
-				}
-				else
-				{
-					this .speed = 0;
+							let y = this .speed / currentFrameRate;
 
-					distance = -distance;
+							if (y < -distance)
+							{
+								// The ground is reached.
+								y = -distance;
+								this .speed = 0;
+							}
 
-					if (distance > 0.01 && distance < stepHeight)
-					{
-						// Step up
-						var translation = this .constrainTranslation (up .multVecRot (this .translation .set (0, distance, 0)), false);
-
-						//if (getBrowser () -> getBrowserOptions () -> animateStairWalks ())
-						//{
-						//	float step = getBrowser () -> getCurrentSpeed () / getBrowser () -> getCurrentFrameRate ();
-						//	step = abs (getInverseCameraSpaceMatrix () .mult_matrix_dir (Vector3f (0, step, 0) * up));
-						//
-						//	Vector3f offset = Vector3f (0, step, 0) * up;
-						//
-						//	if (math::abs (offset) > math::abs (translation) or getBrowser () -> getCurrentSpeed () == 0)
-						//		offset = translation;
-						//
-						//	getViewpoint () -> positionOffset () += offset;
-						//}
-						//else
-							viewpoint .positionOffset_ = translation .add (viewpoint .positionOffset_ .getValue ());
+							viewpoint .positionOffset_ = viewpoint .positionOffset_ .getValue () .add (up .multVecRot (translation .set (0, y, 0)));
+						}
+						else
+						{
+							this .speed = 0;
+
+							distance = -distance;
+
+							if (distance > 0.01 && distance < stepHeight)
+							{
+								// Step up
+								this .constrainTranslation (up .multVecRot (translation .set (0, distance, 0)), false);
+
+								//if (getBrowser () -> getBrowserOptions () -> animateStairWalks ())
+								//{
+								//	float step = getBrowser () -> getCurrentSpeed () / getBrowser () -> getCurrentFrameRate ();
+								//	step = abs (getViewMatrix () .mult_matrix_dir (Vector3f (0, step, 0) * up));
+								//
+								//	Vector3f offset = Vector3f (0, step, 0) * up;
+								//
+								//	if (math::abs (offset) > math::abs (translation) or getBrowser () -> getCurrentSpeed () == 0)
+								//		offset = translation;
+								//
+								//	getViewpoint () -> positionOffset () += offset;
+								//}
+								//else
+									viewpoint .positionOffset_ = translation .add (viewpoint .positionOffset_ .getValue ());
+							}
+						}
 					}
 				}
-			}
-			catch (error)
-			{
-			   console .log (error);
-			}
-		},
-		depth: function (shapes, numShapes)
+				catch (error)
+				{
+				   console .log (error);
+				}
+			};
+		})(),
+		depth: (function ()
 		{
-			var
-				browser    = this .getBrowser (),
-				gl         = browser .getContext (),
-				viewport   = this .getViewVolume () .getViewport (),
-				shaderNode = browser .getDepthShader ();
+			const projectionMatrixArray = new Float32Array (16);
 
-			// Configure depth shader.
+			return function (shapes, numShapes)
+			{
+				const
+					browser    = this .getBrowser (),
+					gl         = browser .getContext (),
+					viewport   = this .getViewVolume () .getViewport (),
+					shaderNode = browser .getDepthShader ();
 
-			shaderNode .useProgram (gl);
+				// Configure depth shader.
 
-			projectionMatrixArray .set (this .getProjectionMatrix () .get ());
+				if (shaderNode .getValid ())
+				{
+					shaderNode .enable (gl);
 
-			gl .uniformMatrix4fv (shaderNode .x3d_ProjectionMatrix, false, projectionMatrixArray);
+					projectionMatrixArray .set (this .getProjectionMatrix () .get ());
 
-			// Configure viewport and background
+					gl .uniformMatrix4fv (shaderNode .x3d_ProjectionMatrix, false, projectionMatrixArray);
 
-			gl .viewport (viewport [0],
-			              viewport [1],
-			              viewport [2],
-			              viewport [3]);
+					// Configure viewport and background
 
-			gl .scissor (viewport [0],
-			             viewport [1],
-			             viewport [2],
-			             viewport [3]);
+					gl .viewport (viewport [0],
+					              viewport [1],
+					              viewport [2],
+					              viewport [3]);
 
-			gl .clearColor (1, 0, 0, 0);
-			gl .clear (gl .COLOR_BUFFER_BIT | gl .DEPTH_BUFFER_BIT);
+					gl .scissor (viewport [0],
+					             viewport [1],
+					             viewport [2],
+					             viewport [3]);
 
-			// Render all objects
+					gl .clearColor (1, 0, 0, 0); // Must be '1, 0, 0, 0'.
+					gl .clear (gl .COLOR_BUFFER_BIT | gl .DEPTH_BUFFER_BIT);
 
-			gl .enable (gl .DEPTH_TEST);
-			gl .depthMask (true);
-			gl .disable (gl .BLEND);
-			gl .disable (gl .CULL_FACE);
+					// Render all objects
 
-			for (var s = 0; s < numShapes; ++ s)
-			{
-				var
-					context = shapes [s],
-					scissor = context .scissor;
+					gl .enable (gl .DEPTH_TEST);
+					gl .depthMask (true);
+					gl .disable (gl .BLEND);
+					gl .disable (gl .CULL_FACE);
 
-				// TODO: viewport must not be the browser or layer viewport.
-				gl .scissor (scissor .x,
-				             scissor .y,
-				             scissor .z,
-				             scissor .w);
+					for (let s = 0; s < numShapes; ++ s)
+					{
+						const
+							context = shapes [s],
+							scissor = context .scissor;
 
-				// Clip planes
+						// TODO: viewport must not be the browser or layer viewport.
+						gl .scissor (scissor .x,
+						             scissor .y,
+						             scissor .z,
+						             scissor .w);
 
-				shaderNode .setClipPlanes (gl, context .clipPlanes);
+						// Clip planes
 
-				// modelViewMatrix
-	
-				gl .uniformMatrix4fv (shaderNode .x3d_ModelViewMatrix, false, context .modelViewMatrix);
+						shaderNode .setLocalObjects (gl, context .clipPlanes);
 
-				// Draw
-	
-				context .shapeNode .depth (context, shaderNode);
-			}
-		},
-		draw: function (group)
-		{
-			var
-				browser                  = this .getBrowser (),
-				gl                       = browser .getContext (),
-				viewport                 = this .getViewVolume () .getViewport (),
-				shaders                  = this .shaders,
-				lights                   = this .lights,
-				generatedCubeMapTextures = this .generatedCubeMapTextures;
+						// modelViewMatrix
+
+						gl .uniformMatrix4fv (shaderNode .x3d_ModelViewMatrix, false, context .modelViewMatrix);
 
+						// Draw
 
-			// PREPARATIONS
+						context .shapeNode .depth (gl, context, shaderNode);
+					}
 
+					shaderNode .disable (gl);
+				}
+			};
+		})(),
+		draw: (function ()
+		{
+			const
+				viewportArray          = new Int32Array (4),
+				projectionMatrixArray  = new Float32Array (16),
+				cameraSpaceMatrixArray = new Float32Array (16);
 
-			if (this .isIndependent ())
+			return function ()
 			{
-				// Render shadow maps.
-
-				for (var i = 0, length = lights .length; i < length; ++ i)
-					lights [i] .renderShadowMap (this);
-	
-				// Render GeneratedCubeMapTextures.
-			
-				for (var i = 0, length = generatedCubeMapTextures .length; i < length; ++ i)
-					generatedCubeMapTextures [i] .renderTexture (this, group);
-			}
+				const
+					browser                  = this .getBrowser (),
+					gl                       = browser .getContext (),
+					viewport                 = this .getViewVolume () .getViewport (),
+					shaders                  = this .shaders,
+					lights                   = this .lights,
+					textureProjectors        = this .textureProjectors,
+					generatedCubeMapTextures = this .generatedCubeMapTextures;
 
 
-			// DRAW
+				// PREPARATIONS
 
 
-			// Set shadow matrix for all lights.
+				if (this .isIndependent ())
+				{
+					// Render shadow maps.
 
-			browser .getHeadlight () .setGlobalVariables (this);
+					for (const light of lights)
+						light .renderShadowMap (this);
 
-			for (var i = 0, length = lights .length; i < length; ++ i)
-				lights [i] .setGlobalVariables (this);
+					// Render GeneratedCubeMapTextures.
 
-			// Configure viewport and background
+					for (const generatedCubeMapTexture of generatedCubeMapTextures)
+						generatedCubeMapTexture .renderTexture (this);
+				}
 
-			gl .viewport (viewport [0],
-			              viewport [1],
-			              viewport [2],
-			              viewport [3]);
 
-			gl .scissor (viewport [0],
-			             viewport [1],
-			             viewport [2],
-			             viewport [3]);
+				// DRAW
 
-			gl .clear (gl .DEPTH_BUFFER_BIT);
 
-			this .getBackground () .display (this, viewport);
+				// Set up shadow matrix for all lights, and matrix for all projective textures.
 
-			// Sorted blend
+				browser .getHeadlight () .setGlobalVariables (this);
 
-			viewportArray         .set (viewport);
-			projectionMatrixArray .set (this .getProjectionMatrix () .get ());
+				for (const light of lights)
+					light .setGlobalVariables (this);
 
-			browser .getPointShader   () .setGlobalUniforms (this, gl, projectionMatrixArray, viewportArray);
-			browser .getLineShader    () .setGlobalUniforms (this, gl, projectionMatrixArray, viewportArray);
-			browser .getDefaultShader () .setGlobalUniforms (this, gl, projectionMatrixArray, viewportArray);
+				for (const textureProjector of textureProjectors)
+					textureProjector .setGlobalVariables (this);
 
-			for (var id in shaders)
-				shaders [id] .setGlobalUniforms (this, gl, projectionMatrixArray, viewportArray);
+				// Configure viewport and background
 
-			// Render opaque objects first
+				gl .viewport (viewport [0],
+				              viewport [1],
+				              viewport [2],
+				              viewport [3]);
 
-			gl .enable (gl .DEPTH_TEST);
-			gl .depthMask (true);
-			gl .disable (gl .BLEND);
+				gl .scissor (viewport [0],
+				             viewport [1],
+				             viewport [2],
+								 viewport [3]);
 
-			for (var i = 0; i < this .numOpaqueShapes; ++ i)
-			{
-				var
-					context = this .opaqueShapes [i],
-					scissor = context .scissor;
+				// Draw background.
 
-				gl .scissor (scissor .x,
-				             scissor .y,
-				             scissor .z,
-				             scissor .w);
+				gl .clear (gl .DEPTH_BUFFER_BIT);
 
-				context .shapeNode .display (context);
-			}
+				this .getBackground () .display (gl, this, viewport);
 
-			// Render transparent objects
+				// Set global uniforms.
 
-			gl .depthMask (false);
-			gl .enable (gl .BLEND);
+				viewportArray          .set (viewport);
+				cameraSpaceMatrixArray .set (this .getCameraSpaceMatrix () .get ());
+				projectionMatrixArray  .set (this .getProjectionMatrix () .get ());
 
-			this .transparencySorter .sort (0, this .numTransparentShapes);
+				if (browser .hasPointShader ())  shaders .add (browser .getPointShader ());
+				if (browser .hasLineShader ())   shaders .add (browser .getLineShader ());
+				if (browser .hasUnlitShader ())  shaders .add (browser .getUnlitShader ());
+				if (browser .hasShadowShader ()) shaders .add (browser .getShadowShader ());
+				shaders .add (browser .getDefaultShader ());
 
-			for (var i = 0; i < this .numTransparentShapes; ++ i)
-			{
-				var
-					context = this .transparentShapes [i],
-					scissor = context .scissor;
+				shaders .forEach (function (shader)
+				{
+					shader .setGlobalUniforms (gl, this, cameraSpaceMatrixArray, projectionMatrixArray, viewportArray);
+				},
+				this);
 
-				gl .scissor (scissor .x,
-				             scissor .y,
-				             scissor .z,
-				             scissor .w);
+				// Sorted blend
 
-				context .shapeNode .display (context);
-			}
+				// Render opaque objects first
+
+				gl .enable (gl .DEPTH_TEST);
+				gl .depthMask (true);
+				gl .disable (gl .BLEND);
+
+				const opaqueShapes = this .opaqueShapes;
+
+				for (let i = 0, length = this .numOpaqueShapes; i < length; ++ i)
+				{
+					const
+						context = opaqueShapes [i],
+						scissor = context .scissor;
 
-			gl .depthMask (true);
-			gl .disable (gl .BLEND);
+					gl .scissor (scissor .x,
+					             scissor .y,
+					             scissor .z,
+					             scissor .w);
 
+					context .shapeNode .display (gl, context);
+				}
 
-			// POST DRAW
+				// Render transparent objects
 
+				gl .depthMask (false);
+				gl .enable (gl .BLEND);
 
-			gl .activeTexture (gl .TEXTURE0);
+				const transparentShapes = this .transparentShapes;
 
-			// Recycle clip planes.
+				this .transparencySorter .sort (0, this .numTransparentShapes);
 
-			var clipPlanes = this .getBrowser () .getClipPlanes ();
+				for (let i = 0, length = this .numTransparentShapes; i < length; ++ i)
+				{
+					const
+						context = transparentShapes [i],
+						scissor = context .scissor;
 
-			for (var i = 0, length = clipPlanes .length; i < length; ++ i)
-			   clipPlanes [i] .dispose ();
+					gl .scissor (scissor .x,
+					             scissor .y,
+					             scissor .z,
+					             scissor .w);
 
-			clipPlanes .length = 0;
+					context .shapeNode .display (gl, context);
+				}
 
-			// Reset GeneratedCubeMapTextures.
+				gl .depthMask (true);
+				gl .disable (gl .BLEND);
 
-			generatedCubeMapTextures .length = 0;
 
+				// POST DRAW
 
-			if (this .isIndependent ())
-			{
-				// Recycle global lights.
-	
-				var lights = this .globalLights;
-	
-				for (var i = 0, length = lights .length; i < length; ++ i)
-				   lights [i] .dispose ();
-	
-				// Recycle local lights.
-	
-				var lights = this .getBrowser () .getLocalLights ();
-	
-				for (var i = 0, length = lights .length; i < length; ++ i)
-				   lights [i] .dispose ();
-	
-				lights .length = 0;
-			}
 
-			this .globalLights .length = 0;
-			this .lights       .length = 0;
-		},
+				gl .activeTexture (gl .TEXTURE0);
+
+				const globalObjects = this .globalObjects;
+
+				if (this .isIndependent ())
+				{
+					// Recycle clip planes, local fogs, local lights, and local projective textures.
+
+					const localObjects = browser .getLocalObjects ();
+
+					for (const localObject of localObjects)
+						localObject .dispose ();
+
+					localObjects .length = 0;
+
+					// Recycle global lights and global projective textures.
+
+					for (const globalObject of globalObjects)
+						globalObject .dispose ();
+				}
+
+				// Reset containers.
+
+				shaders .clear ();
+
+				globalObjects            .length = 0;
+				lights                   .length = 0;
+				textureProjectors        .length = 0;
+				generatedCubeMapTextures .length = 0;
+			};
+		})(),
 	};
 
+	function assign (lhs, rhs)
+	{
+		for (var i = 0, length = rhs .length; i < length; ++ i)
+			lhs [i] = rhs [i];
+
+		lhs .length = length;
+	}
+
 	return X3DRenderObject;
 });