x_ite 4.2.17 → 4.7.7

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

@@ -53,12 +53,16 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Core/X3DSensorNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
+	"standard/Math/Numbers/Vector3",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DSensorNode, 
-          X3DConstants)
+          X3DSensorNode,
+          X3DConstants,
+          X3DCast,
+          Vector3)
 {
 "use strict";
 
@@ -67,6 +71,9 @@ function (Fields,
 		X3DSensorNode .call (this, executionContext);
 
 		this .addType (X3DConstants .CollisionSensor);
+
+		this .colliderNode = null;
+		this .contactCache = [ ];
 	}
 
 	CollisionSensor .prototype = Object .assign (Object .create (X3DSensorNode .prototype),
@@ -92,9 +99,187 @@ function (Fields,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DSensorNode .prototype .initialize .call (this);
+
+			this .isLive () .addInterest ("set_live__", this);
+
+			this .collider_ .addInterest ("set_collider__", this);
+
+			this .set_collider__ ();
+		},
+		set_live__: function ()
+		{
+			if (this .isLive () .getValue () && this .enabled_ .getValue () && this .colliderNode)
+			{
+				this .getBrowser () .sensorEvents () .addInterest ("update", this);
+			}
+			else
+			{
+				this .getBrowser () .sensorEvents () .removeInterest ("update", this);
+			}
+		},
+		set_collider__: function ()
+		{
+			this .colliderNode = X3DCast (X3DConstants .CollisionCollection, this .collider_);
+
+			this .set_live__ ();
+		},
+		update: (function ()
+		{
+			var
+				collidableNodesIndex = new Map (),
+				collisionWorlds      = new Set (),
+				intersectionNodes    = new Set (),
+				contactNodes         = [ ],
+				position             = new Vector3 (0, 0, 0),
+				contactNormal        = new Vector3 (0, 0, 0);
+
+			return function ()
+			{
+				var
+					colliderNode    = this .colliderNode,
+					collidableNodes = colliderNode .getCollidables ();
+
+				collidableNodesIndex .clear ();
+				collisionWorlds      .clear ();
+
+				for (var i = 0, length = collidableNodes .length; i < length; ++ i)
+				{
+					var
+						collidableNode = collidableNodes [i],
+						bodyNode       = collidableNodes [i] .getBody ();
+
+					if (bodyNode)
+					{
+						collidableNodesIndex .set (bodyNode .getRigidBody () .ptr, collidableNode);
+
+						var collection = bodyNode .getCollection ();
+
+						if (collection)
+							collisionWorlds .add (collection .getDynamicsWorld ());
+					}
+				}
+
+				intersectionNodes .clear ();
+				contactNodes .length = 0;
+
+				collisionWorlds .forEach (function (collisionWorld)
+				{
+					//collisionWorld .performDiscreteCollisionDetection ();
+
+					var
+						dispatcher   = collisionWorld .getDispatcher (),
+						numManifolds = dispatcher .getNumManifolds ();
+
+					for (var i = 0; i < numManifolds; ++ i)
+					{
+						var
+							contactManifold = dispatcher .getManifoldByIndexInternal (i),
+							numContacts     = contactManifold .getNumContacts ();
+
+						for (var j = 0; j < numContacts; ++ j)
+						{
+							var pt = contactManifold .getContactPoint (j);
+
+							if (pt .getDistance () <= 0)
+							{
+								var
+									collidableNode1 = collidableNodesIndex .get (contactManifold .getBody0 () .ptr),
+									collidableNode2 = collidableNodesIndex .get (contactManifold .getBody1 () .ptr);
+
+								if (! collidableNode1 && ! collidableNode2)
+									continue;
+
+								var contactNode = this .getContact (contactNodes .length);
+
+								var
+									btPosition      = pt .getPositionWorldOnA (),
+									btContactNormal = pt .get_m_normalWorldOnB ();
+
+								contactNode .position_                 = position .set (btPosition .x (), btPosition .y (), btPosition .z ());
+								contactNode .contactNormal_            = contactNormal .set (btContactNormal .x (), btContactNormal .y (), btContactNormal .z ());
+								contactNode .depth_                    = -pt .getDistance ();
+//								contactNode .frictionDirection_        = context .frictionDirection;
+								contactNode .appliedParameters_        = colliderNode .appliedParameters_;
+								contactNode .bounce_                   = colliderNode .bounce_;
+								contactNode .minBounceSpeed_           = colliderNode .minBounceSpeed_;
+								contactNode .frictionCoefficients_     = colliderNode .frictionCoefficients_;
+								contactNode .surfaceSpeed_             = colliderNode .surfaceSpeed_;
+								contactNode .slipCoefficients_         = colliderNode .slipFactors_;
+								contactNode .softnessConstantForceMix_ = colliderNode .softnessConstantForceMix_;
+								contactNode .softnessErrorCorrection_  = colliderNode .softnessErrorCorrection_;
+
+								if (collidableNode1)
+								{
+									intersectionNodes .add (collidableNode1);
+
+									contactNode .geometry1_ = collidableNode1;
+									contactNode .body1_     = collidableNode1 .getBody ();
+								}
+
+								if (collidableNode2)
+								{
+									intersectionNodes .add (collidableNode2);
+
+									contactNode .geometry2_ = collidableNode2;
+									contactNode .body2_     = collidableNode2 .getBody ();
+								}
+
+								contactNodes .push (contactNode);
+							}
+						}
+					}
+				},
+				this);
+
+				var active = Boolean (contactNodes .length);
+
+				if (this .isActive_ .getValue () !== active)
+					this .isActive_ = active;
+
+				if (intersectionNodes .size)
+				{
+					var i = 0;
+
+					intersectionNodes .forEach (function (intersectionNode)
+					{
+						this .intersections_ [i ++] = intersectionNode;
+					},
+					this);
+
+					this .intersections_ .length = i;
+				}
+
+				if (contactNodes .length)
+				{
+					var i = 0;
+
+					contactNodes .forEach (function (contactNode)
+					{
+						this .contacts_ [i ++] = contactNode;
+					},
+					this);
+
+					this .contacts_ .length = i;
+				}
+			};
+		})(),
+		getContact: function (index)
+		{
+			var contactNode = this .contactCache [index];
+
+			if (contactNode)
+				return contactNode;
+
+			contactNode = this .contactCache [index] = this .getExecutionContext () .createNode ("Contact", false);
+
+			contactNode .setup ();
+
+			return contactNode;
+		},
 	});
 
 	return CollisionSensor;
 });
-
-

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

@@ -53,12 +53,14 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/RigidBodyPhysics/X3DNBodyCollisionSpaceNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DNBodyCollisionSpaceNode, 
-          X3DConstants)
+          X3DNBodyCollisionSpaceNode,
+          X3DConstants,
+          X3DCast)
 {
 "use strict";
 
@@ -67,6 +69,9 @@ function (Fields,
 		X3DNBodyCollisionSpaceNode .call (this, executionContext);
 
 		this .addType (X3DConstants .CollisionSpace);
+
+		this .collidableNodes     = [ ];
+		this .collisionSpaceNodes = [ ];
 	}
 
 	CollisionSpace .prototype = Object .assign (Object .create (X3DNBodyCollisionSpaceNode .prototype),
@@ -76,6 +81,8 @@ function (Fields,
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",    new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "enabled",     new Fields .SFBool (true)),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "useGeometry", new Fields .SFBool ()),
+			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 .inputOutput,    "collidables", new Fields .MFNode ()),
@@ -92,9 +99,80 @@ function (Fields,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DNBodyCollisionSpaceNode .prototype .initialize .call (this);
+
+			this .collidables_ .addInterest ("set_collidables__", this);
+
+			this .set_collidables__ ();
+		},
+		getBBox: function (bbox, shadow)
+		{
+			// TODO: add space node.
+			if (this .bboxSize_ .getValue () .equals (this .getDefaultBBoxSize ()))
+				return X3DBoundedObject .getBBox (this .collidableNodes, bbox, shadow);
+
+			return bbox;
+		},
+		getCollidables: function ()
+		{
+			return this .collidableNodes;
+		},
+		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;
+				}
+			}
+
+			this .addNodeEvent ();
+		},
 	});
 
 	return CollisionSpace;
 });
-
-

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

@@ -88,7 +88,7 @@ function (Fields,
 			new X3DFieldDefinition (X3DConstants .inputOutput, "frictionDirection",        new Fields .SFVec3f (0, 1, 0)),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "appliedParameters",        new Fields .MFString ("BOUNCE")),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "bounce",                   new Fields .SFFloat ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "minbounceSpeed",           new Fields .SFFloat ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "minBounceSpeed",           new Fields .SFFloat ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "frictionCoefficients",     new Fields .SFVec2f ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceSpeed",             new Fields .SFVec2f ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "slipCoefficients",         new Fields .SFVec2f ()),

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

@@ -57,13 +57,13 @@ define ([
 	"standard/Math/Numbers/Vector3",
 	"standard/Math/Numbers/Rotation4",
 	"standard/Math/Numbers/Matrix4",
-	"lib/ammojs/ammo",
+	"lib/ammojs/AmmoJS",
 ],
 function ($,
           Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DRigidJointNode, 
+          X3DRigidJointNode,
           X3DConstants,
           Vector3,
           Rotation4,
@@ -140,7 +140,7 @@ function ($,
 		initialize: function ()
 		{
 			X3DRigidJointNode .prototype .initialize .call (this);
-		
+
 			this .anchorPoint_ .addInterest ("set_joint__", this);
 			this .axis1_       .addInterest ("set_joint__", this);
 			this .axis2_       .addInterest ("set_joint__", this);
@@ -157,16 +157,16 @@ function ($,
 			{
 				if (! this .getCollection ())
 					return;
-	
+
 				if (! this .getBody1 ())
 					return;
-		
+
 				if (! this .getBody2 ())
 					return;
-			
+
 			   if (this .getBody1 () .getCollection () !== this .getCollection ())
 					return;
-			
+
 			   if (this .getBody2 () .getCollection () !== this .getCollection ())
 					return;
 
@@ -240,23 +240,30 @@ function ($,
 
 			return function ()
 			{
-				if (this .outputs .body1AnchorPoint)
-					this .body1AnchorPoint_ = this .getBody1 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix1 () .multVecMatrix (localAnchorPoint1 .assign (this .localAnchorPoint1)));
-
-				if (this .outputs .body1Axis)
-					this .body1Axis_ = this .getInitialInverseMatrix1 () .multDirMatrix (this .getBody1 () .getMatrix () .multDirMatrix (localAxis1 .assign (this .localAxis1))) .normalize ();
-	
-				if (this .outputs .hinge1Angle)
+				try
 				{
-					var lastAngle  = this .hinge1Angle_ .getValue ();
+					if (this .outputs .body1AnchorPoint)
+						this .body1AnchorPoint_ = this .getBody1 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix1 () .multVecMatrix (localAnchorPoint1 .assign (this .localAnchorPoint1)));
+
+					if (this .outputs .body1Axis)
+						this .body1Axis_ = this .getInitialInverseMatrix1 () .multDirMatrix (this .getBody1 () .getMatrix () .multDirMatrix (localAxis1 .assign (this .localAxis1))) .normalize ();
+
+					if (this .outputs .hinge1Angle)
+					{
+						var lastAngle  = this .hinge1Angle_ .getValue ();
 
-					difference .assign (this .getInitialInverseMatrix1 ()) .multRight (this .getBody1 () .getMatrix ());
-					difference .get (null, rotation);
-			
-					this .hinge1Angle_ = rotation .angle;
+						difference .assign (this .getInitialInverseMatrix1 ()) .multRight (this .getBody1 () .getMatrix ());
+						difference .get (null, rotation);
 
-					if (this .outputs .angleRate)
-						this .hinge1AngleRate_ = (this .hinge1Angle_ .getValue () - lastAngle) * this .getBrowser () .getCurrentFrameRate ();
+						this .hinge1Angle_ = rotation .angle;
+
+						if (this .outputs .angleRate)
+							this .hinge1AngleRate_ = (this .hinge1Angle_ .getValue () - lastAngle) * this .getBrowser () .getCurrentFrameRate ();
+					}
+				}
+				catch (error)
+				{
+					// matrix .get
 				}
 			};
 		})(),
@@ -270,23 +277,30 @@ function ($,
 
 			return function ()
 			{
-				if (this .outputs .body2AnchorPoint)
-					this .body2AnchorPoint_ = this .getBody2 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix2 () .multVecMatrix (localAnchorPoint2 .assign (this .localAnchorPoint2)));
-
-				if (this .outputs .body2Axis)
-					this .body2Axis_ = this .getInitialInverseMatrix2 () .multDirMatrix (this .getBody2 () .getMatrix () .multDirMatrix (localAxis2 .assign (this .localAxis2))) .normalize ();
-	
-				if (this .outputs .hinge2Angle)
+				try
 				{
-					var lastAngle  = this .hinge2Angle_ .getValue ();
+					if (this .outputs .body2AnchorPoint)
+						this .body2AnchorPoint_ = this .getBody2 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix2 () .multVecMatrix (localAnchorPoint2 .assign (this .localAnchorPoint2)));
+
+					if (this .outputs .body2Axis)
+						this .body2Axis_ = this .getInitialInverseMatrix2 () .multDirMatrix (this .getBody2 () .getMatrix () .multDirMatrix (localAxis2 .assign (this .localAxis2))) .normalize ();
+
+					if (this .outputs .hinge2Angle)
+					{
+						var lastAngle  = this .hinge2Angle_ .getValue ();
+
+						difference .assign (this .getInitialInverseMatrix2 ()) .multRight (this .getBody2 () .getMatrix ());
+						difference .get (null, rotation);
 
-					difference .assign (this .getInitialInverseMatrix2 ()) .multRight (this .getBody2 () .getMatrix ());
-					difference .get (null, rotation);
-			
-					this .hinge2Angle_ = rotation .angle;
+						this .hinge2Angle_ = rotation .angle;
 
-					if (this .outputs .angleRate)
-						this .hinge2AngleRate_ = (this .hinge2Angle_ .getValue () - lastAngle) * this .getBrowser () .getCurrentFrameRate ();
+						if (this .outputs .angleRate)
+							this .hinge2AngleRate_ = (this .hinge2Angle_ .getValue () - lastAngle) * this .getBrowser () .getCurrentFrameRate ();
+					}
+				}
+				catch (error)
+				{
+					// matrix .get
 				}
 			};
 		})(),
@@ -294,5 +308,3 @@ function ($,
 
 	return DoubleAxisHingeJoint;
 });
-
-