x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/Grouping/X3DGroupingNode.js

@@ -48,19 +48,17 @@
 
 
 define ([
-	"x_ite/Fields",
 	"x_ite/Components/Core/X3DChildNode",
 	"x_ite/Components/Grouping/X3DBoundedObject",
 	"x_ite/Bits/TraverseType",
 	"x_ite/Bits/X3DConstants",
-	"standard/Math/Numbers/Matrix4",
+	"x_ite/Bits/X3DCast",
 ],
-function (Fields,
-          X3DChildNode, 
-          X3DBoundedObject, 
+function (X3DChildNode,
+          X3DBoundedObject,
           TraverseType,
           X3DConstants,
-          Matrix4)
+          X3DCast)
 {
 "use strict";
 
@@ -68,9 +66,9 @@ function (Fields,
 
 	function remove (array, first, last, range, rfirst, rlast)
 	{
-		var set = { };
+		const set = { };
 
-		for (var i = rfirst; i < rlast; ++ i)
+		for (let i = rfirst; i < rlast; ++ i)
 			set [getId (range [i])] = true;
 
 		function compare (value) { return set [getId (value)]; }
@@ -78,25 +76,29 @@ function (Fields,
 		return array .remove (first, last, compare);
 	}
 
-	var visible = new Fields .MFBool ();
-
 	function X3DGroupingNode (executionContext)
 	{
 		X3DChildNode     .call (this, executionContext);
 		X3DBoundedObject .call (this, executionContext);
 
 		this .addType (X3DConstants .X3DGroupingNode);
-	               
-		this .hidden                = false;
-		this .allowedTypes          = new Set ();
-		this .pointingDeviceSensors = [ ];
-		this .maybeCameraObjects    = [ ];
-		this .cameraObjects         = [ ];
-		this .clipPlanes            = [ ];
-		this .localFogs             = [ ];
-		this .lights                = [ ];
-		this .displayNodes          = [ ];
-		this .childNodes            = [ ];
+
+		this .hidden                    = false;
+		this .allowedTypes              = new Set ();
+		this .clipPlaneNodes            = [ ];
+		this .localFogNodes             = [ ];
+		this .lightNodes                = [ ];
+		this .textureProjectorNodes     = [ ];
+		this .pointingDeviceSensorNodes = [ ];
+		this .maybeCameraObjects        = [ ];
+		this .cameraObjects             = [ ];
+		this .maybePickableSensorNodes  = [ ];
+		this .pickableSensorNodes       = [ ];
+		this .pickableObjects           = [ ];
+		this .childNodes                = [ ];
+		this .displayNodes              = [ ];
+		this .visibleNodes              = [ ];
+		this .boundedObjects            = [ ];
 	}
 
 	X3DGroupingNode .prototype = Object .assign (Object .create (X3DChildNode .prototype),
@@ -108,23 +110,21 @@ function (Fields,
 			X3DChildNode     .prototype .initialize .call (this);
 			X3DBoundedObject .prototype .initialize .call (this);
 
+			this .transformSensors_changed_ .addInterest ("set_transformSensors__", this);
+
 			this .addChildren_    .addInterest ("set_addChildren__",    this);
 			this .removeChildren_ .addInterest ("set_removeChildren__", this);
 			this .children_       .addInterest ("set_children__",       this);
 
 			this .set_children__ ();
 		},
-		getBBox: function (bbox)
+		getBBox: function (bbox, shadow)
 		{
-			if (this .bboxSize_ .getValue () .equals (this .defaultBBoxSize))
-				return X3DBoundedObject .prototype .getBBox .call (this, this .children_ .getValue (), bbox);
+			if (this .bboxSize_ .getValue () .equals (this .getDefaultBBoxSize ()))
+				return X3DBoundedObject .prototype .getBBox .call (this, this .visibleNodes, bbox, shadow);
 
 			return bbox .set (this .bboxSize_ .getValue (), this .bboxCenter_ .getValue ());
 		},
-		getMatrix: function ()
-		{
-			return Matrix4 .Identity;
-		},
 		setHidden: function (value)
 		{
 			if (value !== this .hidden)
@@ -134,37 +134,14 @@ function (Fields,
 				this .set_children__ ();
 			}
 		},
-		getVisible: function ()
+		setAllowedTypes: function (/* type, ... */)
 		{
-			return visible;
-		},
-		setAllowedTypes: function (type)
-		{
-			var allowedTypes = this .allowedTypes;
+			const allowedTypes = this .allowedTypes;
 
 			allowedTypes .clear ();
 
-			for (var i = 0, length = arguments .length; i < length; ++ i)
-				allowedTypes .add (arguments [i]);
-		},
-		getChild: function (index)
-		{
-			// Used in LOD and Switch.
-			
-			try
-			{
-				if (index >= 0 && index < this .children_ .length)
-				{
-					var child = this .children_ [index];
-
-					if (child)
-						return child .getValue () .getInnerNode ();
-				}
-			}
-			catch (error)
-			{ }
-
-			return null;
+			for (const type of arguments)
+				allowedTypes .add (type);
 		},
 		set_addChildren__: function ()
 		{
@@ -182,10 +159,8 @@ function (Fields,
 				this .children_ .addInterest ("connectChildren", this);
 			}
 
-			var first = this .children_ .length;
-
 			this .children_ .insert (this .children_ .length, this .addChildren_, 0, this .addChildren_ .length);
-			this .add (first, this .addChildren_);
+			this .add (this .addChildren_);
 
 			this .addChildren_ .set ([ ]);
 			this .addChildren_ .setTainted (false);
@@ -195,55 +170,75 @@ function (Fields,
 			if (this .removeChildren_ .length === 0)
 				return;
 
-			if (this .children_ .length === 0)
-				return;
-
-			if (! this .children_ .getTainted ())
+			if (this .children_ .length > 0)
 			{
-				this .children_ .removeInterest ("set_children__", this);
-				this .children_ .addInterest ("connectChildren", this);
-			}
+				if (! this .children_ .getTainted ())
+				{
+					this .children_ .removeInterest ("set_children__", this);
+					this .children_ .addInterest ("connectChildren", this);
+				}
 
-			this .children_ .erase (remove (this .children_,       0, this .children_ .length,
-			                                this .removeChildren_, 0, this .removeChildren_ .length),
-			                        this .children_ .length);
+				this .children_ .erase (remove (this .children_,       0, this .children_ .length,
+														  this .removeChildren_, 0, this .removeChildren_ .length),
+												this .children_ .length);
 
-			this .remove (this .removeChildren_);
+				this .remove (this .removeChildren_);
+			}
 
 			this .removeChildren_ .set ([ ]);
 		},
 		set_children__: function ()
 		{
 			this .clear ();
-			this .add (0, this .children_);
+			this .add (this .children_);
 		},
 		connectChildren: function ()
 		{
 			this .children_ .removeInterest ("connectChildren", this);
 			this .children_ .addInterest ("set_children__", this);
 		},
-		add: function (first, children)
+		clear: function ()
+		{
+			for (const maybePickableSensorNode of this .maybePickableSensorNodes)
+				maybePickableSensorNode .isPickableObject_ .removeInterest ("set_pickableObjects__", this);
+
+			for (const childNode of this .childNodes)
+			{
+				childNode .isCameraObject_   .removeInterest ("set_cameraObjects__",   this);
+				childNode .isPickableObject_ .removeInterest ("set_pickableObjects__", this);
+
+				if (X3DCast (X3DConstants .X3DBoundedObject, childNode))
+				{
+					childNode .visible_     .removeInterest ("set_visibles__",      this);
+					childNode .bboxDisplay_ .removeInterest ("set_bboxDisplays__",  this);
+				}
+			}
+
+			this .clipPlaneNodes            .length = 0;
+			this .localFogNodes             .length = 0;
+			this .lightNodes                .length = 0;
+			this .textureProjectorNodes     .length = 0;
+			this .pointingDeviceSensorNodes .length = 0;
+			this .maybeCameraObjects        .length = 0;
+			this .maybePickableSensorNodes  .length = 0;
+			this .childNodes                .length = 0;
+		},
+		add: function (children)
 		{
 			if (this .hidden)
 				return;
 
-			var
-				visible    = this .getVisible (),
-				numVisible = visible .length;
-
-			for (var i = 0, v = first, length = children .length; i < length; ++ i, ++ v)
+			for (const child of children)
 			{
-				var child = children [i];
-
-				if (child && (v >= numVisible || visible [v]))
+				if (child)
 				{
 					try
 					{
-						var
+						const
 							innerNode = child .getValue () .getInnerNode (),
 							type      = innerNode .getType ();
 
-						for (var t = type .length - 1; t >= 0; -- t)
+						for (let t = type .length - 1; t >= 0; -- t)
 						{
 //							if (this .allowedTypes .size)
 //							{
@@ -255,33 +250,53 @@ function (Fields,
 							{
 								case X3DConstants .X3DPointingDeviceSensorNode:
 								{
-									this .pointingDeviceSensors .push (innerNode);
+									this .pointingDeviceSensorNodes .push (innerNode);
 									break;
 								}
 								case X3DConstants .ClipPlane:
 								{
-									this .clipPlanes .push (innerNode);
+									this .clipPlaneNodes .push (innerNode);
 									break;
 								}
 								case X3DConstants .LocalFog:
 								{
-									this .localFogs .push (innerNode);
+									this .localFogNodes .push (innerNode);
+									break;
+								}
+								case X3DConstants .X3DTextureProjectorNode:
+								{
+									this .textureProjectorNodes .push (innerNode);
 									break;
 								}
 								case X3DConstants .X3DLightNode:
 								{
-									this .lights .push (innerNode);
+									this .lightNodes .push (innerNode);
 									break;
 								}
 								case X3DConstants .X3DBindableNode:
 								{
 									this .maybeCameraObjects .push (innerNode);
-									break;				
+									break;
+								}
+								case X3DConstants .TransformSensor:
+								case X3DConstants .X3DPickSensorNode:
+								{
+									innerNode .isPickableObject_ .addInterest ("set_pickableObjects__", this);
+
+									this .maybePickableSensorNodes .push (innerNode);
+									break;
 								}
 								case X3DConstants .X3DBackgroundNode:
 								case X3DConstants .X3DChildNode:
 								{
-									innerNode .isCameraObject_ .addInterest ("set_cameraObjects__", this);
+									innerNode .isCameraObject_   .addInterest ("set_cameraObjects__",   this);
+									innerNode .isPickableObject_ .addInterest ("set_pickableObjects__", this);
+
+									if (X3DCast (X3DConstants .X3DBoundedObject, innerNode))
+									{
+										innerNode .visible_     .addInterest ("set_visibles__",     this);
+										innerNode .bboxDisplay_ .addInterest ("set_bboxDisplays__", this);
+									}
 
 									this .maybeCameraObjects .push (innerNode);
 									this .childNodes .push (innerNode);
@@ -296,6 +311,7 @@ function (Fields,
 								case X3DConstants .X3DFollowerNode:
 								case X3DConstants .X3DInfoNode:
 								case X3DConstants .X3DInterpolatorNode:
+								case X3DConstants .X3DKeyDeviceSensorNode:
 								case X3DConstants .X3DLayoutNode:
 								case X3DConstants .X3DScriptNode:
 								case X3DConstants .X3DSequencerNode:
@@ -313,76 +329,104 @@ function (Fields,
 				}
 			}
 
-			this .set_cameraObjects__ ();
-			this .set_display_nodes ();
+			this .set_pickableObjects__ ()
+			this .set_displayNodes__ ()
+			this .set_visibles__ ()
+			this .set_bboxDisplays__ ();
 		},
 		remove: function (children)
 		{
-			for (var i = 0, length = children .length; i < length; ++ i)
+			for (const child of children)
 			{
-				var child = children [i];
-
 				if (child)
 				{
 					try
 					{
-						var
+						const
 							innerNode = child .getValue () .getInnerNode (),
 							type      = innerNode .getType ();
 
-						for (var t = type .length - 1; t >= 0; -- t)
+						for (let t = type .length - 1; t >= 0; -- t)
 						{
 							switch (type [t])
 							{
 								case X3DConstants .X3DPointingDeviceSensorNode:
 								{
-									var index = this .pointingDeviceSensors .indexOf (innerNode);
+									const index = this .pointingDeviceSensorNodes .indexOf (innerNode);
 
 									if (index >= 0)
-										this .pointingDeviceSensors .splice (index, 1);
+										this .pointingDeviceSensorNodes .splice (index, 1);
 
 									break;
 								}
 								case X3DConstants .ClipPlane:
 								{
-									var index = this .clipPlanes .indexOf (innerNode);
+									const index = this .clipPlaneNodes .indexOf (innerNode);
 
 									if (index >= 0)
-										this .clipPlanes .splice (index, 1);
+										this .clipPlaneNodes .splice (index, 1);
 
 									break;
 								}
 								case X3DConstants .LocalFog:
 								{
-									var index = this .localFogs .indexOf (innerNode);
+									const index = this .localFogNodes .indexOf (innerNode);
+
+									if (index >= 0)
+										this .localFogNodes .splice (index, 1);
+
+									break;
+								}
+								case X3DConstants .X3DTextureProjectorNode:
+								{
+									const index = this .textureProjectorNodes .indexOf (innerNode);
 
 									if (index >= 0)
-										this .localFogs .splice (index, 1);
+										this .textureProjectorNodes .splice (index, 1);
 
 									break;
 								}
 								case X3DConstants .X3DLightNode:
 								{
-									var index = this .lights .indexOf (innerNode);
+									const index = this .lightNodes .indexOf (innerNode);
 
 									if (index >= 0)
-										this .lights .splice (index, 1);
+										this .lightNodes .splice (index, 1);
 
 									break;
 								}
 								case X3DConstants .X3DBindableNode:
 								{
-									var index = this .maybeCameraObjects .indexOf (innerNode);
+									const index = this .maybeCameraObjects .indexOf (innerNode);
 
 									if (index >= 0)
 										this .maybeCameraObjects .splice (index, 1);
 
-									break;				
+									break;
+								}
+								case X3DConstants .TransformSensor:
+								case X3DConstants .X3DPickSensorNode:
+								{
+									innerNode .isPickableObject_ .removeInterest ("set_pickableObjects__", this);
+
+									const index = this .maybePickableSensorNodes .indexOf (innerNode);
+
+									if (index >= 0)
+										this .maybePickableSensorNodes .splice (index, 1);
+
+									break;
 								}
 								case X3DConstants .X3DBackgroundNode:
 								case X3DConstants .X3DChildNode:
 								{
-									innerNode .isCameraObject_ .removeInterest ("set_cameraObjects__", this);
+									innerNode .isCameraObject_   .removeInterest ("set_cameraObjects__",   this);
+									innerNode .isPickableObject_ .removeInterest ("set_pickableObjects__", this);
+
+									if (X3DCast (X3DConstants .X3DBoundedObject, innerNode))
+									{
+										innerNode .visible_     .removeInterest ("set_visibles__",     this);
+										innerNode .bboxDisplay_ .removeInterest ("set_bboxDisplays__", this);
+									}
 
 									var index = this .maybeCameraObjects .indexOf (innerNode);
 
@@ -405,6 +449,7 @@ function (Fields,
 								case X3DConstants .X3DFollowerNode:
 								case X3DConstants .X3DInfoNode:
 								case X3DConstants .X3DInterpolatorNode:
+								case X3DConstants .X3DKeyDeviceSensorNode:
 								case X3DConstants .X3DLayoutNode:
 								case X3DConstants .X3DScriptNode:
 								case X3DConstants .X3DSequencerNode:
@@ -422,54 +467,123 @@ function (Fields,
 				}
 			}
 
-			this .set_cameraObjects__ ();
-			this .set_display_nodes ();
+			this .set_pickableObjects__ ();
+			this .set_displayNodes__ ();
+			this .set_visibles__ ();
+			this .set_bboxDisplays__ ();
 		},
-		clear: function ()
+		set_cameraObjects__: function ()
 		{
-			for (var i = 0, length = this .childNodes .length; i < length; ++ i)
-				this .childNodes [i] .isCameraObject_ .removeInterest ("set_cameraObjects__", this);
-			
-			this .pointingDeviceSensors .length = 0;
-			this .maybeCameraObjects    .length = 0;
-			this .cameraObjects         .length = 0;
-			this .clipPlanes            .length = 0;
-			this .localFogs             .length = 0;
-			this .lights                .length = 0;
-			this .childNodes            .length = 0;
+			const cameraObjects = this .cameraObjects;
+
+			cameraObjects .length = 0;
+
+			for (const childNode of this .maybeCameraObjects)
+			{
+				if (childNode .getCameraObject ())
+				{
+					if (X3DCast (X3DConstants .X3DBoundedObject, childNode))
+					{
+						if (childNode .visible_ .getValue ())
+						{
+							cameraObjects .push (childNode);
+						}
+					}
+					else
+					{
+						cameraObjects .push (childNode);
+					}
+				}
+			}
+
+			this .setCameraObject (Boolean (cameraObjects .length));
 		},
-		set_cameraObjects__: function ()
+		set_pickableObjects__: function ()
 		{
-			this .cameraObjects .length = 0;
+			const
+				pickableSensorNodes = this .pickableSensorNodes,
+				pickableObjects     = this .pickableObjects;
+
+			pickableSensorNodes .length = 0;
+			pickableObjects     .length = 0;
 
-			for (var i = 0, length = this .maybeCameraObjects .length; i < length; ++ i)
+			for (const sensorNode of this .maybePickableSensorNodes)
 			{
-				var childNode = this .maybeCameraObjects [i];
+				if (sensorNode .getPickableObject ())
+					pickableSensorNodes .push (sensorNode);
+			}
 
-				if (childNode .getCameraObject ())
-					this .cameraObjects .push (childNode);
+			for (const childNode of this .childNodes)
+			{
+				if (childNode .getPickableObject ())
+					pickableObjects .push (childNode);
 			}
 
-			this .setCameraObject (this .cameraObjects .length);
+			this .set_transformSensors__ ()
+		},
+		set_transformSensors__: function ()
+		{
+			this .setPickableObject (Boolean (this .getTransformSensors () .size || this .pickableSensorNodes .length || this .pickableObjects .length));
 		},
-		set_display_nodes: function ()
+		set_displayNodes__: function ()
 		{
-			var
-				clipPlanes   = this .clipPlanes,
-				localFogs    = this .localFogs,
-				lights       = this .lights,
-				displayNodes = this .displayNodes;
+			const displayNodes = this .displayNodes;
 
 			displayNodes .length = 0;
 
-			for (var i = 0, length = clipPlanes .length; i < length; ++ i)
-				displayNodes .push (clipPlanes [i]);
+			for (const node of this .clipPlaneNodes)
+				displayNodes .push (node);
+
+			for (const node of this .localFogNodes)
+				displayNodes .push (node);
+
+			for (const node of this .lightNodes)
+				displayNodes .push (node);
+
+			for (const node of this .textureProjectorNodes)
+				displayNodes .push (node);
+		},
+		set_visibles__: function ()
+		{
+			const
+				childNodes   = this .childNodes,
+				visibleNodes = this .visibleNodes;
+
+			visibleNodes .length = 0;
+
+			for (const childNode of childNodes)
+			{
+				if (X3DCast (X3DConstants .X3DBoundedObject, childNode))
+				{
+					if (childNode .visible_ .getValue ())
+					{
+						visibleNodes .push (childNode);
+					}
+				}
+				else
+				{
+					visibleNodes .push (childNode);
+				}
+			}
+
+			this .set_cameraObjects__ ();
+		},
+		set_bboxDisplays__: function ()
+		{
+			const boundedObjects = this .boundedObjects;
 
-			for (var i = 0, length = localFogs .length; i < length; ++ i)
-				displayNodes .push (localFogs [i]);
+			boundedObjects .length = 0;
 
-			for (var i = 0, length = lights .length; i < length; ++ i)
-				displayNodes .push (lights [i]);
+			for (const childNode of this .childNodes)
+			{
+				if (X3DCast (X3DConstants .X3DBoundedObject, childNode))
+				{
+					if (childNode .bboxDisplay_ .getValue ())
+					{
+						boundedObjects .push (childNode);
+					}
+				}
+			}
 		},
 		traverse: function (type, renderObject)
 		{
@@ -477,76 +591,121 @@ function (Fields,
 			{
 				case TraverseType .POINTER:
 				{
-					var
-						pointingDeviceSensors = this .pointingDeviceSensors,
-						clipPlanes            = this .clipPlanes,
-						childNodes            = this .childNodes;
+					const
+						pointingDeviceSensorNodes = this .pointingDeviceSensorNodes,
+						clipPlaneNodes            = this .clipPlaneNodes;
 
-					if (pointingDeviceSensors .length)
+					if (pointingDeviceSensorNodes .length)
 					{
-						var sensors = { };
-						
+						const sensors = { };
+
 						renderObject .getBrowser () .getSensors () .push (sensors);
-					
-						for (var i = 0, length = pointingDeviceSensors .length; i < length; ++ i)
-							pointingDeviceSensors [i] .push (renderObject, sensors);
+
+						for (const pointingDeviceSensorNode of pointingDeviceSensorNodes)
+							pointingDeviceSensorNode .push (renderObject, sensors);
 					}
 
-					for (var i = 0, length = clipPlanes .length; i < length; ++ i)
-						clipPlanes [i] .push (renderObject);
+					for (const clipPlaneNode of clipPlaneNodes)
+						clipPlaneNode .push (renderObject);
 
-					for (var i = 0, length = childNodes .length; i < length; ++ i)
-						childNodes [i] .traverse (type, renderObject);
+					for (const childNode of this .childNodes)
+						childNode .traverse (type, renderObject);
 
-					for (var i = clipPlanes .length - 1; i >= 0; -- i)
-						clipPlanes [i] .pop (renderObject);
+					for (const clipPlaneNode of clipPlaneNodes)
+						clipPlaneNode .pop (renderObject);
 
-					if (pointingDeviceSensors .length)
+					if (pointingDeviceSensorNodes .length)
 						renderObject .getBrowser () .getSensors () .pop ();
 
 					return;
 				}
 				case TraverseType .CAMERA:
 				{
-					var cameraObjects = this .cameraObjects;
+					for (const cameraObject of this .cameraObjects)
+						cameraObject .traverse (type, renderObject);
+
+					return;
+				}
+				case TraverseType .PICKING:
+				{
+					if (this .getTransformSensors () .size)
+					{
+						const modelMatrix = renderObject .getModelViewMatrix () .get ();
+
+						for (const transformSensorNode of this .getTransformSensors ())
+							transformSensorNode .collect (modelMatrix);
+					}
+
+					for (const pickableSensorNode of this .pickableSensorNodes)
+						pickableSensorNode .traverse (type, renderObject);
+
+					const
+						browser          = renderObject .getBrowser (),
+						pickingHierarchy = browser .getPickingHierarchy ();
+
+					pickingHierarchy .push (this);
 
-					for (var i = 0, length = cameraObjects .length; i < length; ++ i)
-						cameraObjects [i] .traverse (type, renderObject);
+					if (browser .getPickable () .at (-1))
+					{
+						for (const childNode of this .childNodes)
+							childNode .traverse (type, renderObject);
+					}
+					else
+					{
+						for (const pickableObject of this .pickableObjects)
+							pickableObject .traverse (type, renderObject);
+					}
 
+					pickingHierarchy .pop ();
 					return;
 				}
 				case TraverseType .COLLISION:
-				case TraverseType .DEPTH:
-				{					
-					var
-						clipPlanes = this .clipPlanes,
-						childNodes = this .childNodes;
+				{
+					const clipPlaneNodes = this .clipPlaneNodes;
+
+					for (const clipPlaneNode of clipPlaneNodes)
+						clipPlaneNode .push (renderObject);
+
+					for (const childNode of this .childNodes)
+						childNode .traverse (type, renderObject);
+
+					for (const clipPlaneNode of clipPlaneNodes)
+						clipPlaneNode .pop (renderObject);
+
+					return;
+				}
+				case TraverseType .SHADOW:
+				{
+					// Nodes that are not visible do not cast shadows.
+
+					const clipPlaneNodes = this .clipPlaneNodes;
+
+					for (const clipPlaneNode of clipPlaneNodes)
+						clipPlaneNode .push (renderObject);
 
-					for (var i = 0, length = clipPlanes .length; i < length; ++ i)
-						clipPlanes [i] .push (renderObject);
+					for (const visibleNode of this .visibleNodes)
+						visibleNode .traverse (type, renderObject);
 
-					for (var i = 0, length = childNodes .length; i < length; ++ i)
-						childNodes [i] .traverse (type, renderObject);
+					for (const clipPlaneNode of clipPlaneNodes)
+						clipPlaneNode .push (renderObject);
 
-					for (var i = clipPlanes .length - 1; i >= 0; -- i)
-						clipPlanes [i] .pop (renderObject);
-					
 					return;
 				}
 				case TraverseType .DISPLAY:
 				{
-					var
-						displayNodes = this .displayNodes,
-						childNodes   = this .childNodes;
+					const displayNodes = this .displayNodes;
 
-					for (var i = 0, length = displayNodes .length; i < length; ++ i)
-						displayNodes [i] .push (renderObject, this);
+					for (const displayNode of displayNodes)
+						displayNode .push (renderObject, this);
 
-					for (var i = 0, length = childNodes .length; i < length; ++ i)
-						childNodes [i] .traverse (type, renderObject);
+					for (const visibleNode of this .visibleNodes)
+						visibleNode .traverse (type, renderObject);
 
-					for (var i = displayNodes .length - 1; i >= 0; -- i)
-						displayNodes [i] .pop (renderObject);
+					for (const boundedObject of this .boundedObjects)
+						boundedObject .displayBBox (type, renderObject);
+
+					for (const displayNode of displayNodes)
+						displayNode .pop (renderObject);
 
 					return;
 				}
@@ -554,7 +713,7 @@ function (Fields,
 		},
 	});
 
+	X3DGroupingNode .prototype .getSubBBox = X3DGroupingNode .prototype .getBBox;
+
 	return X3DGroupingNode;
 });
-
-