x_ite 4.0.5 → 4.7.5

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

@@ -48,19 +48,23 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/RigidBodyPhysics/X3DNBodyCollidableNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
+	"x_ite/Bits/TraverseType",
+	"lib/ammojs/AmmoJS",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DNBodyCollidableNode, 
-          X3DConstants)
+          X3DNBodyCollidableNode,
+          X3DConstants,
+          X3DCast,
+          TraverseType,
+          Ammo)
 {
 "use strict";
 
@@ -69,18 +73,28 @@ function ($,
 		X3DNBodyCollidableNode .call (this, executionContext);
 
 		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;
 	}
 
-	CollidableShape .prototype = $.extend (Object .create (X3DNBodyCollidableNode .prototype),
+	CollidableShape .prototype = Object .assign (Object .create (X3DNBodyCollidableNode .prototype),
 	{
 		constructor: CollidableShape,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",    new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxSize",    new Fields .SFVec3f (-1, -1, -1)),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxCenter",  new Fields .SFVec3f ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "enabled",     new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "rotation",    new Fields .SFRotation ()),
 			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 ()),
 		]),
 		getTypeName: function ()
@@ -95,9 +109,420 @@ function ($,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DNBodyCollidableNode .prototype .initialize .call (this);
+
+			this .enabled_ .addInterest ("set_collidableGeometry__", this);
+			this .shape_   .addInterest ("set_shape__",              this);
+
+			this .set_shape__ ();
+		},
+		getBBox: function (bbox, shadow)
+		{
+			if (this .bboxSize_ .getValue () .equals (this .getDefaultBBoxSize ()))
+			{
+				const boundedObject = this .visibleNode;
+
+				if (boundedObject)
+					return boundedObject .getBBox (bbox, shadow);
+
+				return bbox .set ();
+			}
+
+			return bbox .set (this .bboxSize_ .getValue (), this .bboxCenter_ .getValue ());
+		},
+		setConvex: function (value)
+		{
+			this .convex = value;
+		},
+		getConvex: function ()
+		{
+			return this .convex;
+		},
+		createConvexGeometry: (function ()
+		{
+			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);
+				}
+
+				convexHull .recalcLocalAabb ();
+
+				return convexHull;
+			};
+		})(),
+		createConcaveGeometry: (function ()
+		{
+			var
+				p1 = new Ammo .btVector3 (),
+				p2 = new Ammo .btVector3 (),
+				p3 = new Ammo .btVector3 ();
+
+			return function ()
+			{
+				var vertices = this .geometryNode .getVertices () .getValue ();
+
+				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 .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);
+			}
+
+			this .shapeNode = X3DCast (X3DConstants .Shape, this .shape_);
+
+			if (this .shapeNode)
+			{
+				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 .setPickableObject (this .shapeNode .getPickableObject ());
+
+				delete this .traverse;
+			}
+			else
+			{
+				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)
+				this .geometryNode .rebuild_ .removeInterest ("set_collidableGeometry__", this);
+
+			if (this .shapeNode)
+				this .geometryNode = this .shapeNode .getGeometry ();
+			else
+				this .geometryNode = null;
+
+			if (this .geometryNode)
+				this .geometryNode .rebuild_ .addInterest ("set_collidableGeometry__", this);
+
+			this .set_collidableGeometry__ ();
+		},
+		set_collidableGeometry__: (function ()
+		{
+			var
+				localScaling   = new Ammo .btVector3 (),
+				defaultScaling = new Ammo .btVector3 (1, 1, 1);
+
+			return function ()
+			{
+				var ls = this .getCompoundShape () .getLocalScaling ();
+				localScaling .setValue (ls .x (), ls .y (), ls .z ());
+
+				this .removeCollidableGeometry ();
+				this .setOffset (0, 0, 0);
+				this .getCompoundShape () .setLocalScaling (defaultScaling);
+
+				if (this .enabled_ .getValue () && this .geometryNode && this .geometryNode .getGeometryType () > 1)
+				{
+					var type = this .geometryNode .getType ();
+
+					for (var t = type .length - 1; t >= 0; -- t)
+					{
+						switch (type [t])
+						{
+							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 ();
+
+								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 ();
+
+								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;
+
+								this .collisionShape = new Ammo .btSphereShape (sphere .radius_ .getValue ());
+								break;
+							}
+							case X3DConstants .X3DGeometryNode:
+							{
+								if (this .convex)
+									this .collisionShape = this .createConvexGeometry ();
+								else
+									this .collisionShape = this .createConcaveGeometry ();
+
+								break;
+							}
+							default:
+							{
+								continue;
+							}
+						}
+
+						break;
+					}
+				}
+				else
+				{
+					this .collisionShape = null;
+				}
+
+				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;;
+			}
+
+			if (this .heightField)
+			{
+				Ammo ._free (this .heightField);
+				this .heightField = null;
+			}
+
+			if (this .triangleMesh)
+			{
+				Ammo .destroy (this .triangleMesh);
+				this .triangleMesh = null;
+			}
+		},
+		traverse: function (type, renderObject)
+		{
+			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 ()
+		{
+			this .removeCollidableGeometry ();
+
+			X3DNBodyCollidableNode .prototype .dispose .call (this);
+		},
 	});
 
 	return CollidableShape;
 });
-
-

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

@@ -48,19 +48,21 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Core/X3DChildNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
+	"x_ite/Browser/RigidBodyPhysics/AppliedParametersType",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DChildNode, 
-          X3DConstants)
+          X3DConstants,
+          X3DCast,
+          AppliedParametersType)
 {
 "use strict";
 
@@ -69,23 +71,31 @@ function ($,
 		X3DChildNode .call (this, executionContext);
 
 		this .addType (X3DConstants .CollisionCollection);
+
+		this .minBounceSpeed_           .setUnit ("speed");
+		this .surfaceSpeed_             .setUnit ("speed");
+		this .softnessConstantForceMix_ .setUnit ("force");
+
+		this .appliedParameters   = new Set ();
+		this .collidableNodes     = [ ];
+		this .collisionSpaceNodes = [ ];
 	}
 
-	CollisionCollection .prototype = $.extend (Object .create (X3DChildNode .prototype),
+	CollisionCollection .prototype = Object .assign (Object .create (X3DChildNode .prototype),
 	{
 		constructor: CollisionCollection,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",                 new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "enabled",                  new Fields .SFBool (true)),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "appliedParameters",        new Fields .MFString ("BOUNCE")),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "bounce",                   new Fields .SFFloat ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "collidables",              new Fields .MFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "enabled",                  new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "frictionCoefficients",     new Fields .SFVec2f ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "minBounceSpeed",           new Fields .SFFloat (0.1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "frictionCoefficients",     new Fields .SFVec2f ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceSpeed",             new Fields .SFVec2f ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "slipFactors",              new Fields .SFVec2f ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "softnessConstantForceMix", new Fields .SFFloat (0.0001)),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "softnessErrorCorrection",  new Fields .SFFloat (0.8)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceSpeed",             new Fields .SFVec2f ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "collidables",              new Fields .MFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -97,7 +107,105 @@ function ($,
 		},
 		getContainerField: function ()
 		{
-			return "collidables";
+			return "collider";
+		},
+		initialize: function ()
+		{
+			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;
+		},
+		getCollidables: function ()
+		{
+			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;
+				}
+			}
+
+			this .addNodeEvent ();
 		},
 	});