x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/Picking/PointPickSensor.js

@@ -52,21 +52,41 @@ define ([
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Picking/X3DPickSensorNode",
+	"x_ite/Bits/X3DCast",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Browser/Picking/IntersectionType",
+	"x_ite/Browser/Picking/VolumePicker",
+	"standard/Math/Numbers/Vector3",
+	"standard/Math/Numbers/Rotation4",
+	"standard/Math/Geometry/Box3",
+	require .getComponentUrl ("rigid-body-physics"),
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DPickSensorNode, 
-          X3DConstants)
+          X3DPickSensorNode,
+          X3DCast,
+          X3DConstants,
+          IntersectionType,
+          VolumePicker,
+          Vector3,
+          Rotation4,
+          Box3,
+          RigidBodyPhysics)
 {
 "use strict";
 
+	var Ammo = RigidBodyPhysics .Ammo;
+
 	function PointPickSensor (executionContext)
 	{
 		X3DPickSensorNode .call (this, executionContext);
 
 		this .addType (X3DConstants .PointPickSensor);
+
+		this .pickingGeometryNode = null;
+		this .picker              = new VolumePicker ();
+		this .compoundShapes      = [ ];
 	}
 
 	PointPickSensor .prototype = Object .assign (Object .create (X3DPickSensorNode .prototype),
@@ -75,14 +95,15 @@ function (Fields,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",         new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "enabled",          new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "isActive",         new Fields .SFBool ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "objectType",       new Fields .MFString ("ALL")),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "pickingGeometry",  new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "pickTarget",       new Fields .MFNode ()),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "pickedGeometry",   new Fields .MFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "matchCriterion",   new Fields .SFString ("MATCH_ANY")),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "intersectionType", new Fields .SFString ("BOUNDS")),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "sortOrder",        new Fields .SFString ("CLOSEST")),
+			new X3DFieldDefinition (X3DConstants .outputOnly,     "isActive",         new Fields .SFBool ()),
 			new X3DFieldDefinition (X3DConstants .outputOnly,     "pickedPoint",      new Fields .MFVec3f ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "pickingGeometry",  new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "pickTarget",       new Fields .MFNode ()),
+			new X3DFieldDefinition (X3DConstants .outputOnly,     "pickedGeometry",   new Fields .MFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -96,9 +117,240 @@ function (Fields,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DPickSensorNode .prototype .initialize .call (this);
+
+			this .pickingGeometry_ .addInterest ("set_pickingGeometry__", this);
+
+			this .set_pickingGeometry__ ();
+		},
+		set_pickingGeometry__: function ()
+		{
+			if (this .pickingGeometryNode)
+				this .pickingGeometryNode .rebuild_ .removeInterest ("set_geometry__", this);
+
+			this .pickingGeometryNode = X3DCast (X3DConstants .PointSet, this .pickingGeometry_);
+
+			if (this .pickingGeometryNode)
+				this .pickingGeometryNode .rebuild_ .addInterest ("set_geometry__", this);
+
+			this .set_geometry__ ();
+		},
+		set_geometry__: (function ()
+		{
+			var
+				defaultScale = new Ammo .btVector3 (1, 1, 1),
+				o            = new Ammo .btVector3 (),
+				t            = new Ammo .btTransform ();
+
+			return function ()
+			{
+				var compoundShapes = this .compoundShapes;
+
+				if (this .pickingGeometryNode)
+				{
+					var coord = this .pickingGeometryNode .getCoord ();
+
+					if (coord)
+					{
+						for (var i = 0, length = coord .getSize (); i < length; ++ i)
+						{
+							if (i < compoundShapes .length)
+							{
+								var
+									compoundShape = compoundShapes [i],
+									point         = coord .get1Point (i, compoundShape .point);
+
+								o .setValue (point .x, point .y, point .z);
+								t .setOrigin (o);
+
+								compoundShape .setLocalScaling (defaultScale);
+								compoundShape .updateChildTransform (0, t);
+							}
+							else
+							{
+								var
+									compoundShape = new Ammo .btCompoundShape (),
+									sphereShape   = new Ammo .btSphereShape (0),
+									point         = coord .get1Point (i, new Vector3 (0, 0, 0));
+
+								compoundShape .point = point;
+
+								o .setValue (point .x, point .y, point .z);
+								t .setOrigin (o);
+
+								compoundShape .addChildShape (t, sphereShape);
+								compoundShapes .push (compoundShape);
+							}
+						}
+
+						compoundShapes .length = length;
+					}
+					else
+					{
+						compoundShapes .length = 0;
+					}
+				}
+				else
+				{
+					compoundShapes .length = 0;
+				}
+			};
+		})(),
+		process: (function ()
+		{
+			var
+				pickingBBox   = new Box3 (),
+				targetBBox    = new Box3 (),
+				pickingCenter = new Vector3 (0, 0, 0),
+				targetCenter  = new Vector3 (0, 0, 0),
+				transform     = new Ammo .btTransform (),
+				localScaling  = new Ammo .btVector3 (),
+				translation   = new Vector3 (0, 0, 0),
+				rotation      = new Rotation4 (0, 0, 1, 0),
+				scale         = new Vector3 (1, 1, 1),
+				pickedPoint   = new Fields .MFVec3f ();
+
+			return function ()
+			{
+				if (this .pickingGeometryNode)
+				{
+					var
+						modelMatrices = this .getModelMatrices (),
+						targets       = this .getTargets ();
+
+					switch (this .getIntersectionType ())
+					{
+						case IntersectionType .BOUNDS:
+						{
+							// Intersect bboxes.
+
+							for (var m = 0, mLength = modelMatrices .length; m < mLength; ++ m)
+							{
+								var modelMatrix = modelMatrices [m];
+
+								pickingBBox .assign (this .pickingGeometryNode .getBBox ()) .multRight (modelMatrix);
+
+								for (var t = 0, tLength = targets .size; t < tLength; ++ t)
+								{
+									var target = targets [t];
+
+									targetBBox .assign (target .geometryNode .getBBox ()) .multRight (target .modelMatrix);
+
+									if (pickingBBox .intersectsBox (targetBBox))
+									{
+										pickingCenter .assign (pickingBBox .center);
+										targetCenter  .assign (targetBBox .center);
+
+										target .intersected = true;
+										target .distance    = pickingCenter .distance (targetCenter);
+									}
+								}
+							}
+
+							// Send events.
+
+							var
+								pickedGeometries = this .getPickedGeometries (),
+								active           = Boolean (pickedGeometries .length);
+
+							pickedGeometries .remove (0, pickedGeometries .length, null);
+
+							if (active !== this .isActive_ .getValue ())
+								this .isActive_ = active;
+
+							if (! this .pickedGeometry_ .equals (pickedGeometries))
+								this .pickedGeometry_ = pickedGeometries;
+
+							break;
+						}
+						case IntersectionType .GEOMETRY:
+						{
+							// Intersect geometry.
+
+							var
+								picker         = this .picker,
+								compoundShapes = this .compoundShapes;
+
+							for (var m = 0, mLength = modelMatrices .length; m < mLength; ++ m)
+							{
+								var modelMatrix = modelMatrices [m];
+
+								pickingBBox .assign (this .pickingGeometryNode .getBBox ()) .multRight (modelMatrix);
+
+								modelMatrix .get (translation, rotation, scale);
+
+								picker .getTransform (translation, rotation, transform);
+								localScaling .setValue (scale .x, scale .y, scale .z);
+
+								for (var c = 0, cLength = compoundShapes .length; c < cLength; ++ c)
+								{
+									var compoundShape = compoundShapes [c];
+
+									picker .setChildShape1Components (transform, localScaling, compoundShape);
+
+									for (var t = 0, tLength = targets .size; t < tLength; ++ t)
+									{
+										var
+											target      = targets [t],
+											targetShape = this .getPickShape (target .geometryNode);
+
+										targetBBox .assign (target .geometryNode .getBBox ()) .multRight (target .modelMatrix);
+
+										picker .setChildShape2 (target .modelMatrix, targetShape .getCompoundShape ());
+
+										if (picker .contactTest ())
+										{
+											pickingCenter .assign (pickingBBox .center);
+											targetCenter  .assign (targetBBox .center);
+
+											target .intersected = true;
+											target .distance    = pickingCenter .distance (targetCenter);
+											target .pickedPoint .push (compoundShape .point);
+										}
+									}
+								}
+							}
+
+							// Send events.
+
+							var
+								pickedGeometries = this .getPickedGeometries (),
+								active           = Boolean (pickedGeometries .length);
+
+							pickedGeometries .remove (0, pickedGeometries .length, null);
+
+							if (active !== this .isActive_ .getValue ())
+								this .isActive_ = active;
+
+							if (! this .pickedGeometry_ .equals (pickedGeometries))
+								this .pickedGeometry_ = pickedGeometries;
+
+							var pickedTargets = this .getPickedTargets ();
+
+							pickedPoint .length = 0;
+
+							for (var t = 0, tLength = pickedTargets .length; t < tLength; ++ t)
+							{
+								var pp = pickedTargets [t] .pickedPoint;
+
+								for (var p = 0, pLength = pp .length; p < pLength; ++ p)
+									pickedPoint .push (pp [p]);
+							}
+
+							if (! this .pickedPoint_ .equals (pickedPoint))
+								this .pickedPoint_ = pickedPoint;
+
+							break;
+						}
+					}
+				}
+
+				X3DPickSensorNode .prototype .process .call (this);
+			};
+		})(),
 	});
 
 	return PointPickSensor;
 });
-
-

package/src/x_ite/Components/Picking/PrimitivePickSensor.js

@@ -53,12 +53,20 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Picking/X3DPickSensorNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Browser/Picking/IntersectionType",
+	"x_ite/Browser/Picking/VolumePicker",
+	"standard/Math/Numbers/Vector3",
+	"standard/Math/Geometry/Box3",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DPickSensorNode, 
-          X3DConstants)
+          X3DConstants,
+          IntersectionType,
+          VolumePicker,
+          Vector3,
+          Box3)
 {
 "use strict";
 
@@ -67,6 +75,9 @@ function (Fields,
 		X3DPickSensorNode .call (this, executionContext);
 
 		this .addType (X3DConstants .PrimitivePickSensor);
+
+		this .pickingGeometryNode = null;
+		this .picker              = new VolumePicker ();
 	}
 
 	PrimitivePickSensor .prototype = Object .assign (Object .create (X3DPickSensorNode .prototype),
@@ -75,13 +86,14 @@ function (Fields,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",         new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "enabled",          new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "isActive",         new Fields .SFBool ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "objectType",       new Fields .MFString ("ALL")),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "matchCriterion",   new Fields .SFString ("MATCH_ANY")),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "intersectionType", new Fields .SFString ("BOUNDS")),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "sortOrder",        new Fields .SFString ("CLOSEST")),
+			new X3DFieldDefinition (X3DConstants .outputOnly,     "isActive",         new Fields .SFBool ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "pickingGeometry",  new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "pickTarget",       new Fields .MFNode ()),
 			new X3DFieldDefinition (X3DConstants .outputOnly,     "pickedGeometry",   new Fields .MFNode ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "intersectionType", new Fields .SFString ("BOUNDS")),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "sortOrder",        new Fields .SFString ("CLOSEST")),
 		]),
 		getTypeName: function ()
 		{
@@ -95,6 +107,164 @@ function (Fields,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DPickSensorNode .prototype .initialize .call (this);
+			
+			this .pickingGeometry_ .addInterest ("set_pickingGeometry__", this);
+
+			this .set_pickingGeometry__ ();
+		},
+		set_pickingGeometry__: function ()
+		{
+			this .pickingGeometryNode = null;
+
+			try
+			{
+				var
+					node = this .pickingGeometry_ .getValue () .getInnerNode (),
+					type = node .getType ();
+
+				for (var t = type .length - 1; t >= 0; -- t)
+				{
+					switch (type [t])
+					{
+						case X3DConstants .Box:
+						case X3DConstants .Cone:
+						case X3DConstants .Cylinder:
+						case X3DConstants .Sphere:
+						{
+							this .pickingGeometryNode = node;
+							break;
+						}
+						default:
+							continue;
+					}
+				}
+			}
+			catch (error)
+			{ }
+		},
+		process: (function ()
+		{
+			var
+				pickingBBox   = new Box3 (),
+				targetBBox    = new Box3 (),
+				pickingCenter = new Vector3 (0, 0, 0),
+				targetCenter  = new Vector3 (0, 0, 0);
+
+			return function ()
+			{
+				if (this .pickingGeometryNode)
+				{
+					var
+						modelMatrices = this .getModelMatrices (),
+						targets       = this .getTargets ();
+		
+					switch (this .getIntersectionType ())
+					{
+						case IntersectionType .BOUNDS:
+						{
+							// Intersect bboxes.
+	
+							for (var m = 0, mLength = modelMatrices .length; m < mLength; ++ m)
+							{
+								var modelMatrix = modelMatrices [m];
+
+								pickingBBox .assign (this .pickingGeometryNode .getBBox ()) .multRight (modelMatrix);
+				
+								for (var t = 0, tLength = targets .size; t < tLength; ++ t)
+								{
+									var target = targets [t];
+
+									targetBBox .assign (target .geometryNode .getBBox ()) .multRight (target .modelMatrix);
+	
+									if (pickingBBox .intersectsBox (targetBBox))
+									{
+										pickingCenter .assign (pickingBBox .center);
+										targetCenter  .assign (targetBBox .center);
+
+										target .intersected = true;
+										target .distance    = pickingCenter .distance (targetCenter);
+									}
+								}
+							}
+		
+							// Send events.
+	
+							var
+								pickedGeometries = this .getPickedGeometries (),
+								active           = Boolean (pickedGeometries .length);
+
+							pickedGeometries .remove (0, pickedGeometries .length, null);
+
+							if (active !== this .isActive_ .getValue ())
+								this .isActive_ = active;
+	
+							if (! this .pickedGeometry_ .equals (pickedGeometries))
+								this .pickedGeometry_ = pickedGeometries;
+	
+							break;
+						}
+						case IntersectionType .GEOMETRY:
+						{
+							// Intersect geometry.
+	
+							var picker = this .picker;
+
+							for (var m = 0, mLength = modelMatrices .length; m < mLength; ++ m)
+							{
+								var
+									modelMatrix  = modelMatrices [m],
+									pickingShape = this .getPickShape (this .pickingGeometryNode);
+
+								pickingBBox .assign (this .pickingGeometryNode .getBBox ()) .multRight (modelMatrix);
+
+								picker .setChildShape1 (modelMatrix, pickingShape .getCompoundShape ());
+
+								for (var t = 0, tLength = targets .size; t < tLength; ++ t)
+								{
+									var
+										target      = targets [t],
+										targetShape = this .getPickShape (target .geometryNode);
+
+									targetBBox .assign (target .geometryNode .getBBox ()) .multRight (target .modelMatrix);
+
+									picker .setChildShape2 (target .modelMatrix, targetShape .getCompoundShape ());
+	
+									if (picker .contactTest ())
+									{
+										pickingCenter .assign (pickingBBox .center);
+										targetCenter  .assign (targetBBox .center);
+
+										target .intersected = true;
+										target .distance    = pickingCenter .distance (targetCenter);
+									}
+								}
+							}
+		
+							// Send events.
+	
+							var
+								pickedGeometries = this .getPickedGeometries (),
+								active           = Boolean (pickedGeometries .length);
+
+							pickedGeometries .remove (0, pickedGeometries .length, null);
+
+							if (active !== this .isActive_ .getValue ())
+								this .isActive_ = active;
+	
+							if (! this .pickedGeometry_ .equals (pickedGeometries))
+								this .pickedGeometry_ = pickedGeometries;
+	
+							break;
+						}
+					}
+				}
+
+				X3DPickSensorNode .prototype .process .call (this);
+			};
+		})(),
 	});
 
 	return PrimitivePickSensor;

package/src/x_ite/Components/Picking/VolumePickSensor.js

@@ -52,13 +52,23 @@ define ([
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Picking/X3DPickSensorNode",
+	"x_ite/Bits/X3DCast",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Browser/Picking/IntersectionType",
+	"x_ite/Browser/Picking/VolumePicker",
+	"standard/Math/Numbers/Vector3",
+	"standard/Math/Geometry/Box3",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DPickSensorNode, 
-          X3DConstants)
+          X3DCast,
+          X3DConstants,
+          IntersectionType,
+          VolumePicker,
+          Vector3,
+          Box3)
 {
 "use strict";
 
@@ -67,6 +77,9 @@ function (Fields,
 		X3DPickSensorNode .call (this, executionContext);
 
 		this .addType (X3DConstants .VolumePickSensor);
+
+		this .pickingGeometryNode = null;
+		this .picker              = new VolumePicker ();
 	}
 
 	VolumePickSensor .prototype = Object .assign (Object .create (X3DPickSensorNode .prototype),
@@ -75,13 +88,14 @@ function (Fields,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",         new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "enabled",          new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "isActive",         new Fields .SFBool ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "objectType",       new Fields .MFString ("ALL")),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "matchCriterion",   new Fields .SFString ("MATCH_ANY")),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "intersectionType", new Fields .SFString ("BOUNDS")),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "sortOrder",        new Fields .SFString ("CLOSEST")),
+			new X3DFieldDefinition (X3DConstants .outputOnly,     "isActive",         new Fields .SFBool ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "pickingGeometry",  new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "pickTarget",       new Fields .MFNode ()),
 			new X3DFieldDefinition (X3DConstants .outputOnly,     "pickedGeometry",   new Fields .MFNode ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "intersectionType", new Fields .SFString ("BOUNDS")),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "sortOrder",        new Fields .SFString ("CLOSEST")),
 		]),
 		getTypeName: function ()
 		{
@@ -95,6 +109,138 @@ function (Fields,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DPickSensorNode .prototype .initialize .call (this);
+			
+			this .pickingGeometry_ .addInterest ("set_pickingGeometry__", this);
+
+			this .set_pickingGeometry__ ();
+		},
+		set_pickingGeometry__: function ()
+		{
+			this .pickingGeometryNode = X3DCast (X3DConstants .X3DGeometryNode, this .pickingGeometry_);
+		},
+		process: (function ()
+		{
+			var
+				pickingBBox   = new Box3 (),
+				targetBBox    = new Box3 (),
+				pickingCenter = new Vector3 (0, 0, 0),
+				targetCenter  = new Vector3 (0, 0, 0);
+
+			return function ()
+			{
+				if (this .pickingGeometryNode)
+				{
+					var
+						modelMatrices = this .getModelMatrices (),
+						targets       = this .getTargets ();
+		
+					switch (this .getIntersectionType ())
+					{
+						case IntersectionType .BOUNDS:
+						{
+							// Intersect bboxes.
+	
+							for (var m = 0, mLength = modelMatrices .length; m < mLength; ++ m)
+							{
+								var modelMatrix = modelMatrices [m];
+
+								pickingBBox .assign (this .pickingGeometryNode .getBBox ()) .multRight (modelMatrix);
+				
+								for (var t = 0, tLength = targets .size; t < tLength; ++ t)
+								{
+									var target = targets [t];
+
+									targetBBox .assign (target .geometryNode .getBBox ()) .multRight (target .modelMatrix);
+	
+									if (pickingBBox .intersectsBox (targetBBox))
+									{
+										pickingCenter .assign (pickingBBox .center);
+										targetCenter  .assign (targetBBox .center);
+
+										target .intersected = true;
+										target .distance    = pickingCenter .distance (targetCenter);
+									}
+								}
+							}
+		
+							// Send events.
+	
+							var
+								pickedGeometries = this .getPickedGeometries (),
+								active           = Boolean (pickedGeometries .length);
+
+							pickedGeometries .remove (0, pickedGeometries .length, null);
+
+							if (active !== this .isActive_ .getValue ())
+								this .isActive_ = active;
+	
+							if (! this .pickedGeometry_ .equals (pickedGeometries))
+								this .pickedGeometry_ = pickedGeometries;
+	
+							break;
+						}
+						case IntersectionType .GEOMETRY:
+						{
+							// Intersect geometry.
+	
+							var picker = this .picker;
+
+							for (var m = 0, mLength = modelMatrices .length; m < mLength; ++ m)
+							{
+								var
+									modelMatrix  = modelMatrices [m],
+									pickingShape = this .getPickShape (this .pickingGeometryNode);
+
+								pickingBBox .assign (this .pickingGeometryNode .getBBox ()) .multRight (modelMatrix);
+
+								picker .setChildShape1 (modelMatrix, pickingShape .getCompoundShape ());
+
+								for (var t = 0, tLength = targets .size; t < tLength; ++ t)
+								{
+									var
+										target      = targets [t],
+										targetShape = this .getPickShape (target .geometryNode);
+
+									targetBBox .assign (target .geometryNode .getBBox ()) .multRight (target .modelMatrix);
+
+									picker .setChildShape2 (target .modelMatrix, targetShape .getCompoundShape ());
+	
+									if (picker .contactTest ())
+									{
+										pickingCenter .assign (pickingBBox .center);
+										targetCenter  .assign (targetBBox .center);
+
+										target .intersected = true;
+										target .distance    = pickingCenter .distance (targetCenter);
+									}
+								}
+							}
+		
+							// Send events.
+	
+							var
+								pickedGeometries = this .getPickedGeometries (),
+								active           = Boolean (pickedGeometries .length);
+
+							pickedGeometries .remove (0, pickedGeometries .length, null);
+
+							if (active !== this .isActive_ .getValue ())
+								this .isActive_ = active;
+	
+							if (! this .pickedGeometry_ .equals (pickedGeometries))
+								this .pickedGeometry_ = pickedGeometries;
+	
+							break;
+						}
+					}
+				}
+
+				X3DPickSensorNode .prototype .process .call (this);
+			};
+		})(),
 	});
 
 	return VolumePickSensor;