x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/RigidBodyPhysics/CollidableShape.js

@@ -54,16 +54,16 @@ define ([
 	"x_ite/Components/RigidBodyPhysics/X3DNBodyCollidableNode",
 	"x_ite/Bits/X3DConstants",
 	"x_ite/Bits/X3DCast",
-	"standard/Math/Numbers/Vector3",
-	"lib/ammojs/ammo",
+	"x_ite/Bits/TraverseType",
+	"lib/ammojs/AmmoJS",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DNBodyCollidableNode, 
+          X3DNBodyCollidableNode,
           X3DConstants,
           X3DCast,
-          Vector3,
+          TraverseType,
           Ammo)
 {
 "use strict";
@@ -74,7 +74,10 @@ function (Fields,
 
 		this .addType (X3DConstants .CollidableShape);
 
+		this .convex         = false;
 		this .shapeNode      = null;
+		this .visibleNode    = null;
+		this .boundedObject  = null;
 		this .geometryNode   = null;
 		this .collisionShape = null;
 		this .triangleMesh   = null;
@@ -88,6 +91,8 @@ function (Fields,
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "enabled",     new Fields .SFBool (true)),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "translation", new Fields .SFVec3f ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "rotation",    new Fields .SFRotation ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "visible",     new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "bboxDisplay", new Fields .SFBool ()),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxSize",    new Fields .SFVec3f (-1, -1, -1)),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxCenter",  new Fields .SFVec3f ()),
 			new X3DFieldDefinition (X3DConstants .initializeOnly, "shape",       new Fields .SFNode ()),
@@ -113,43 +118,90 @@ function (Fields,
 
 			this .set_shape__ ();
 		},
-		getBBox: function (bbox)
+		getBBox: function (bbox, shadow)
 		{
-			if (this .bboxSize_ .getValue () .equals (this .defaultBBoxSize))
+			if (this .bboxSize_ .getValue () .equals (this .getDefaultBBoxSize ()))
 			{
-				var boundedObject = X3DCast (X3DConstants .X3DBoundedObject, this .shape_);
-		
+				const boundedObject = this .visibleNode;
+
 				if (boundedObject)
-					return boundedObject .getBBox (bbox);
-		
+					return boundedObject .getBBox (bbox, shadow);
+
 				return bbox .set ();
 			}
-		
+
 			return bbox .set (this .bboxSize_ .getValue (), this .bboxCenter_ .getValue ());
 		},
-		createConcaveGeometry: function ()
+		setConvex: function (value)
+		{
+			this .convex = value;
+		},
+		getConvex: function ()
+		{
+			return this .convex;
+		},
+		createConvexGeometry: (function ()
 		{
-			var vertices = this .geometryNode .getVertices () .getValue ();
+			var p = new Ammo .btVector3 ();
+
+			return function ()
+			{
+				var vertices = this .geometryNode .getVertices () .getValue ();
+
+				if (vertices .length === 0)
+					return null;
+
+				var convexHull = new Ammo .btConvexHullShape ();
+
+				for (var i = 0, length = vertices .length; i < length; i += 4)
+				{
+					p .setValue (vertices [i], vertices [i + 1], vertices [i + 2]);
+					convexHull .addPoint (p, false);
+				}
 
-			if (vertices .length === 0)
-				return null;
+				convexHull .recalcLocalAabb ();
 
-			this .triangleMesh = new Ammo .btTriangleMesh ();
+				return convexHull;
+			};
+		})(),
+		createConcaveGeometry: (function ()
+		{
+			var
+				p1 = new Ammo .btVector3 (),
+				p2 = new Ammo .btVector3 (),
+				p3 = new Ammo .btVector3 ();
 
-			for (var i = 0, length = vertices .length; i < length; i += 12)
+			return function ()
 			{
-				this .triangleMesh .addTriangle (new Ammo .btVector3 (vertices [i],     vertices [i + 1], vertices [i + 2]),
-				                                 new Ammo .btVector3 (vertices [i + 4], vertices [i + 5], vertices [i + 6]),
-				                                 new Ammo .btVector3 (vertices [i + 8], vertices [i + 9], vertices [i + 10]));	
-			}
+				var vertices = this .geometryNode .getVertices () .getValue ();
 
-			return new Ammo .btBvhTriangleMeshShape (this .triangleMesh, false);
-		},
+				if (vertices .length === 0)
+					return null;
+
+				this .triangleMesh = new Ammo .btTriangleMesh ();
+
+				for (var i = 0, length = vertices .length; i < length; i += 12)
+				{
+					p1 .setValue (vertices [i],     vertices [i + 1], vertices [i + 2]);
+					p2 .setValue (vertices [i + 4], vertices [i + 5], vertices [i + 6]);
+					p3 .setValue (vertices [i + 8], vertices [i + 9], vertices [i + 10]);
+
+					this .triangleMesh .addTriangle (p1, p2, p3);
+				}
+
+				return new Ammo .btBvhTriangleMeshShape (this .triangleMesh, false);
+			};
+		})(),
 		set_shape__: function ()
 		{
 			if (this .shapeNode)
 			{
-				this .shapeNode .isCameraObject_ .removeFieldInterest (this .isCameraObject_);
+				this .shapeNode .isCameraObject_   .removeFieldInterest (this .isCameraObject_);
+				this .shapeNode .isPickableObject_ .removeFieldInterest (this .isPickableObject_);
+
+				this .shapeNode .visible_     .removeInterest ("set_visible__",     this);
+				this .shapeNode .bboxDisplay_ .removeInterest ("set_bboxDisplay__", this);
+
 				this .shapeNode .geometry_ .removeInterest ("set_geometry__", this);
 			}
 
@@ -157,22 +209,66 @@ function (Fields,
 
 			if (this .shapeNode)
 			{
-				this .shapeNode .isCameraObject_ .addFieldInterest (this .isCameraObject_);
+				this .shapeNode .isCameraObject_   .addFieldInterest (this .isCameraObject_);
+				this .shapeNode .isPickableObject_ .addFieldInterest (this .isPickableObject_);
+
+				this .shapeNode .visible_     .addInterest ("set_visible__",     this);
+				this .shapeNode .bboxDisplay_ .addInterest ("set_bboxDisplay__", this);
+
 				this .shapeNode .geometry_ .addInterest ("set_geometry__", this);
 
-				this .setCameraObject (this .shapeNode .getCameraObject ());
+				this .setCameraObject   (this .shapeNode .getCameraObject ());
+				this .setPickableObject (this .shapeNode .getPickableObject ());
 
 				delete this .traverse;
 			}
 			else
 			{
-				this .setCameraObject (false);
+				this .setCameraObject   (false);
+				this .setPickableObject (false);
 
 				this .traverse = Function .prototype;
 			}
 
+			this .set_visible__ ();
+			this .set_bboxDisplay__ ();
 			this .set_geometry__ ();
 		},
+		set_cameraObject__: function ()
+		{
+			if (this .shapeNode && this .shapeNode .getCameraObject ())
+			{
+				this .setCameraObject (this .shapeNode .visible_ .getValue ());
+			}
+			else
+			{
+				this .setCameraObject (false);
+			}
+		},
+		set_visible__: function ()
+		{
+			if (this .shapeNode)
+			{
+				this .visibleNode = this .shapeNode .visible_ .getValue () ? this .shapeNode : null;
+			}
+			else
+			{
+				this .visibleNode = this .shapeNode;
+			}
+
+			this .set_cameraObject__ ();
+		},
+		set_bboxDisplay__: function ()
+		{
+			if (this .shapeNode)
+			{
+				this .boundedObject = this .shapeNode .bboxDisplay_ .getValue () ? this .shapeNode : null;
+			}
+			else
+			{
+				this .boundedObject = null;
+			}
+		},
 		set_geometry__: function ()
 		{
 			if (this .geometryNode)
@@ -188,123 +284,152 @@ function (Fields,
 
 			this .set_collidableGeometry__ ();
 		},
-		set_collidableGeometry__: function ()
+		set_collidableGeometry__: (function ()
 		{
-			this .removeCollidableGeometry ();
-			this .setOffset (0, 0, 0);
+			var
+				localScaling   = new Ammo .btVector3 (),
+				defaultScaling = new Ammo .btVector3 (1, 1, 1);
 
-			if (this .geometryNode && this .enabled_ .getValue ())
+			return function ()
 			{
-				switch (this .geometryNode .getType () [this .geometryNode .getType () .length - 1])
-				{
-					case X3DConstants .Box:
-					{
-						var
-							box  = this .geometryNode,
-							size = box .size_ .getValue ();
+				var ls = this .getCompoundShape () .getLocalScaling ();
+				localScaling .setValue (ls .x (), ls .y (), ls .z ());
 
-						this .collisionShape = new Ammo .btBoxShape (new Ammo .btVector3 (size .x / 2, size .y / 2, size .z / 2));
-						break;
-					}
-					case X3DConstants .Cone:
-					{
-						var cone = this .geometryNode;
-		
-						if (cone .side_ .getValue () && cone .bottom_ .getValue ())
-							this .collisionShape = new Ammo .btConeShape (cone .bottomRadius_ .getValue (), cone .height_ .getValue ());
-						else
-							this .collisionShape = this .createConcaveGeometry ();
+				this .removeCollidableGeometry ();
+				this .setOffset (0, 0, 0);
+				this .getCompoundShape () .setLocalScaling (defaultScaling);
 
-						break;
-					}
-					case X3DConstants .Cylinder:
-					{
-						var
-							cylinder  = this .geometryNode,
-							radius    = cylinder .radius_ .getValue (),
-							height1_2 = cylinder .height_ .getValue () * 0.5;
-		
-						if (cylinder .side_ .getValue () && cylinder .top_ .getValue () && cylinder .bottom_ .getValue ())
-							this .collisionShape = new Ammo .btCylinderShape (new Ammo .btVector3 (radius, height1_2, radius));
-						else
-							this .collisionShape = this .createConcaveGeometry ();
+				if (this .enabled_ .getValue () && this .geometryNode && this .geometryNode .getGeometryType () > 1)
+				{
+					var type = this .geometryNode .getType ();
 
-						break;
-					}
-					case X3DConstants .ElevationGrid:
+					for (var t = type .length - 1; t >= 0; -- t)
 					{
-						var elevationGrid = this .geometryNode;
-		
-						if (elevationGrid .xDimension_ .getValue () > 1 && elevationGrid .zDimension_ .getValue () > 1)
+						switch (type [t])
 						{
-							var
-								min         = Number .POSITIVE_INFINITY,
-								max         = Number .NEGATIVE_INFINITY,
-								heightField = this .heightField = Ammo ._malloc (4 * elevationGrid .xDimension_ .getValue () * elevationGrid .zDimension_ .getValue ()),
-								i4          = 0;
+							case X3DConstants .Box:
+							{
+								var
+									box  = this .geometryNode,
+									size = box .size_ .getValue ();
+
+								this .collisionShape = new Ammo .btBoxShape (new Ammo .btVector3 (size .x / 2, size .y / 2, size .z / 2));
+								break;
+							}
+							case X3DConstants .Cone:
+							{
+								var cone = this .geometryNode;
+
+								if (cone .side_ .getValue () && cone .bottom_ .getValue ())
+									this .collisionShape = new Ammo .btConeShape (cone .bottomRadius_ .getValue (), cone .height_ .getValue ());
+								else
+									this .collisionShape = this .createConcaveGeometry ();
 
-							for (var i = 0, length = elevationGrid .height_ .length; i < length; ++ i)
+								break;
+							}
+							case X3DConstants .Cylinder:
 							{
-								var value = elevationGrid .height_ [i];
+								var
+									cylinder  = this .geometryNode,
+									radius    = cylinder .radius_ .getValue (),
+									height1_2 = cylinder .height_ .getValue () * 0.5;
 
-								min = Math .min (min, value);
-								max = Math .max (max, value);
+								if (cylinder .side_ .getValue () && cylinder .top_ .getValue () && cylinder .bottom_ .getValue ())
+									this .collisionShape = new Ammo .btCylinderShape (new Ammo .btVector3 (radius, height1_2, radius));
+								else
+									this .collisionShape = this .createConcaveGeometry ();
 
-								Ammo .HEAPF32 [heightField + i4 >> 2] = elevationGrid .height_ [i];
+								break;
+							}
+							case X3DConstants .ElevationGrid:
+							{
+								var elevationGrid = this .geometryNode;
+
+								if (elevationGrid .xDimension_ .getValue () > 1 && elevationGrid .zDimension_ .getValue () > 1)
+								{
+									var
+										min         = Number .POSITIVE_INFINITY,
+										max         = Number .NEGATIVE_INFINITY,
+										heightField = this .heightField = Ammo ._malloc (4 * elevationGrid .xDimension_ .getValue () * elevationGrid .zDimension_ .getValue ()),
+										i4          = 0;
+
+									for (var i = 0, length = elevationGrid .height_ .length; i < length; ++ i)
+									{
+										var value = elevationGrid .height_ [i];
+
+										min = Math .min (min, value);
+										max = Math .max (max, value);
+
+										Ammo .HEAPF32 [heightField + i4 >> 2] = elevationGrid .height_ [i];
+
+										i4 += 4;
+									}
+
+									this .collisionShape = new Ammo .btHeightfieldTerrainShape (elevationGrid .xDimension_ .getValue (),
+									                                                            elevationGrid .zDimension_ .getValue (),
+									                                                            heightField,
+									                                                            1,
+									                                                            min,
+									                                                            max,
+									                                                            1,
+									                                                            "PHY_FLOAT",
+									                                                            true);
+
+									this .collisionShape .setLocalScaling (new Ammo .btVector3 (elevationGrid .xSpacing_ .getValue (), 1, elevationGrid .zSpacing_ .getValue ()));
+
+									this .setOffset (elevationGrid .xSpacing_ .getValue () * (elevationGrid .xDimension_ .getValue () - 1) * 0.5,
+									                 (min + max) * 0.5,
+									                 elevationGrid .zSpacing_ .getValue () * (elevationGrid .zDimension_ .getValue () - 1) * 0.5);
+								}
+
+								break;
+							}
+							case X3DConstants .Sphere:
+							{
+								var sphere = this .geometryNode;
 
-								i4 += 4;
+								this .collisionShape = new Ammo .btSphereShape (sphere .radius_ .getValue ());
+								break;
 							}
+							case X3DConstants .X3DGeometryNode:
+							{
+								if (this .convex)
+									this .collisionShape = this .createConvexGeometry ();
+								else
+									this .collisionShape = this .createConcaveGeometry ();
 
-							this .collisionShape = new Ammo .btHeightfieldTerrainShape (elevationGrid .xDimension_ .getValue (),
-							                                                            elevationGrid .zDimension_ .getValue (),
-							                                                            heightField,
-							                                                            1,
-							                                                            min,
-							                                                            max,
-							                                                            1,
-							                                                            "PHY_FLOAT",
-							                                                            true);
-			
-							this .collisionShape .setLocalScaling (new Ammo .btVector3 (elevationGrid .xSpacing_ .getValue (), 1, elevationGrid .zSpacing_ .getValue ()));
-
-							this .setOffset (elevationGrid .xSpacing_ .getValue () * (elevationGrid .xDimension_ .getValue () - 1) * 0.5,
-							                 (min + max) * 0.5,
-							                 elevationGrid .zSpacing_ .getValue () * (elevationGrid .zDimension_ .getValue () - 1) * 0.5);
+								break;
+							}
+							default:
+							{
+								continue;
+							}
 						}
-		
-						break;
-					}
-					case X3DConstants .Sphere:
-					{
-						var sphere = this .geometryNode;
-		
-						this .collisionShape = new Ammo .btSphereShape (sphere .radius_ .getValue ());
-						break;
-					}
-					default:
-					{
-						this .collisionShape = this .createConcaveGeometry ();
+
 						break;
 					}
 				}
-			}
-			else
-			{
-				this .collisionShape = null;
-			}
+				else
+				{
+					this .collisionShape = null;
+				}
 
-			if (this .collisionShape)
-				this .getCompoundShape () .addChildShape (this .getLocalTransform (), this .collisionShape);
-		
-			this .addNodeEvent ();
-		},
+				if (this .collisionShape)
+					this .getCompoundShape () .addChildShape (this .getLocalTransform (), this .collisionShape);
+
+				this .getCompoundShape () .setLocalScaling (localScaling);
+
+				this .addNodeEvent ();
+				this .compoundShape_changed_ = this .getBrowser () .getCurrentTime ();
+			};
+		})(),
 		removeCollidableGeometry: function ()
 		{
 			if (this .collisionShape)
 			{
 				this .getCompoundShape () .removeChildShapeByIndex (0);
 				Ammo .destroy (this .collisionShape);
-				this .collisionShape = null;;	
+				this .collisionShape = null;;
 			}
 
 			if (this .heightField)
@@ -321,14 +446,75 @@ function (Fields,
 		},
 		traverse: function (type, renderObject)
 		{
-			var modelViewMatrix = renderObject .getModelViewMatrix ();
-
-			modelViewMatrix .push ();
-			modelViewMatrix .multLeft (this .getMatrix ());
-	
-			this .shapeNode .traverse (type, renderObject);
-		
-			modelViewMatrix .pop ();
+			switch (type)
+			{
+				case TraverseType .POINTER:
+				case TraverseType .CAMERA:
+				case TraverseType .SHADOW:
+				{
+					const modelViewMatrix = renderObject .getModelViewMatrix ();
+
+					modelViewMatrix .push ();
+					modelViewMatrix .multLeft (this .getMatrix ());
+
+					const visibleNode = this .visibleNode;
+
+					if (visibleNode)
+						visibleNode .traverse (type, renderObject);
+
+					modelViewMatrix .pop ();
+					return;
+				}
+				case TraverseType .PICKING:
+				{
+					const
+						browser          = renderObject .getBrowser (),
+						pickingHierarchy = browser .getPickingHierarchy (),
+						modelViewMatrix  = renderObject .getModelViewMatrix ();
+
+					pickingHierarchy .push (this);
+					modelViewMatrix .push ();
+					modelViewMatrix .multLeft (this .getMatrix ());
+
+					this .shapeNode .traverse (type, renderObject);
+
+					modelViewMatrix .pop ();
+					pickingHierarchy .pop ();
+					return;
+				}
+				case TraverseType .COLLISION:
+				{
+					const modelViewMatrix = renderObject .getModelViewMatrix ();
+
+					modelViewMatrix .push ();
+					modelViewMatrix .multLeft (this .getMatrix ());
+
+					this .shapeNode .traverse (type, renderObject);
+
+					modelViewMatrix .pop ();
+					return;
+				}
+				case TraverseType .DISPLAY:
+				{
+					const modelViewMatrix = renderObject .getModelViewMatrix ();
+
+					modelViewMatrix .push ();
+					modelViewMatrix .multLeft (this .getMatrix ());
+
+					const visibleNode = this .visibleNode;
+
+					if (visibleNode)
+						visibleNode .traverse (type, renderObject);
+
+					const boundedObject = this .boundedObject;
+
+					if (boundedObject)
+						boundedObject .displayBBox (type, renderObject);
+
+					modelViewMatrix .pop ();
+					return;
+				}
+			}
 		},
 		dispose: function ()
 		{
@@ -340,5 +526,3 @@ function (Fields,
 
 	return CollidableShape;
 });
-
-

package/src/x_ite/Components/RigidBodyPhysics/CollisionCollection.js

@@ -53,12 +53,16 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Core/X3DChildNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
+	"x_ite/Browser/RigidBodyPhysics/AppliedParametersType",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DChildNode, 
-          X3DConstants)
+          X3DConstants,
+          X3DCast,
+          AppliedParametersType)
 {
 "use strict";
 
@@ -72,7 +76,9 @@ function (Fields,
 		this .surfaceSpeed_             .setUnit ("speed");
 		this .softnessConstantForceMix_ .setUnit ("force");
 
-		this .appliedParameters = { };
+		this .appliedParameters   = new Set ();
+		this .collidableNodes     = [ ];
+		this .collisionSpaceNodes = [ ];
 	}
 
 	CollisionCollection .prototype = Object .assign (Object .create (X3DChildNode .prototype),
@@ -108,20 +114,98 @@ function (Fields,
 			X3DChildNode .prototype .initialize .call (this);
 
 			this .appliedParameters_ .addInterest ("set_appliedParameters__", this);
+			this .collidables_       .addInterest ("set_collidables__",       this);
 
 			this .set_appliedParameters__ ();
+			this .set_collidables__ ();
 		},
 		getAppliedParameters: function ()
 		{
 			return this .appliedParameters;
 		},
-		set_appliedParameters__: function ()
+		getCollidables: function ()
 		{
-			for (var key in this .appliedParameters)
-				delete this .appliedParameters [key];
+			return this .collidableNodes;
+		},
+		set_appliedParameters__: (function ()
+		{
+			var appliedParametersIndex = new Map ([
+				["BOUNCE",                 AppliedParametersType .BOUNCE],
+				["USER_FRICTION",          AppliedParametersType .USER_FRICTION],
+				["FRICTION_COEFFICIENT-2", AppliedParametersType .FRICTION_COEFFICIENT_2],
+				["ERROR_REDUCTION",        AppliedParametersType .ERROR_REDUCTION],
+				["CONSTANT_FORCE",         AppliedParametersType .CONSTANT_FORCE],
+				["SPEED-1",                AppliedParametersType .SPEED_1],
+				["SPEED-2",                AppliedParametersType .SPEED_2],
+				["SLIP-1",                 AppliedParametersType .SLIP_1],
+				["SLIP-2",                 AppliedParametersType .SLIP_2],
+			]);
+
+			return function ()
+			{
+				this .appliedParameters .clear ();
+	
+				for (var i = 0, length = this .appliedParameters_ .length; i < length; ++ i)
+				{
+					var appliedParameter = appliedParametersIndex .get (this .appliedParameters_ [i]);
+
+					if (appliedParameter !== undefined)
+						this .appliedParameters .add (appliedParameter);
+				}
+			};
+		})(),
+		set_collidables__: function ()
+		{
+			var collisionSpaceNodes = this .collisionSpaceNodes;
+
+			for (var i = 0, length = collisionSpaceNodes .length; i < length; ++ i)
+				collisionSpaceNodes [i] .removeInterest ("collect", this);
+
+			collisionSpaceNodes .length = 0;
+
+			for (var i = 0, length = this .collidables_ .length; i < length; ++ i)
+			{
+				var collisionSpaceNode = X3DCast (X3DConstants .X3DNBodyCollisionSpaceNode, this .collidables_ [i]);
+
+				if (collisionSpaceNode)
+				{
+					collisionSpaceNode .addInterest ("collect", this);
+
+					collisionSpaceNodes .push (collisionSpaceNode);
+				}
+			}
+
+			this .collect ();
+		},
+		collect: function ()
+		{
+			var
+				collidableNodes     = this .collidableNodes,
+				collisionSpaceNodes = this .collisionSpaceNodes;
+
+			collidableNodes     .length = 0;
+			collisionSpaceNodes .length = 0;
+
+			for (var i = 0, length = this .collidables_ .length; i < length; ++ i)
+			{
+				var collidableNode = X3DCast (X3DConstants .X3DNBodyCollidableNode, this .collidables_ [i]);
+
+				if (collidableNode)
+				{
+					collidableNodes .push (collidableNode);
+					continue;
+				}
+
+				var collisionSpaceNode = X3DCast (X3DConstants .X3DNBodyCollisionSpaceNode, this .collidables_ [i]);
+
+				if (collisionSpaceNode)
+				{
+					Array .prototype .push .apply (collidableNodes, collisionSpaceNode .getCollidables ());
+					continue;
+				}
+			}
 
-			for (var i = 0, length = this .appliedParameters_ .length; i < length; ++ i)
-				this .appliedParameters [this .appliedParameters_ [i]] = true;
+			this .addNodeEvent ();
 		},
 	});