x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/ParticleSystems/X3DParticleEmitterNode.js

@@ -57,7 +57,7 @@ define ([
 	"standard/Math/Algorithm",
 	"standard/Math/Algorithms/QuickSort",
 ],
-function (X3DNode, 
+function (X3DNode,
           X3DConstants,
           Vector3,
           Rotation4,
@@ -141,7 +141,7 @@ function (X3DNode,
 				v   = particleLifetime * lifetimeVariation,
 				min = Math .max (0, particleLifetime - v),
 				max = particleLifetime + v;
-		
+
 			return Math .random () * (max - min) + min;
 		},
 		getRandomSpeed: function ()
@@ -151,7 +151,7 @@ function (X3DNode,
 				v     = speed * this .variation,
 				min   = Math .max (0, speed - v),
 				max   = speed + v;
-		
+
 			return Math .random () * (max - min) + min;
 		},
 		getSphericalRandomVelocity: function (velocity)
@@ -169,7 +169,7 @@ function (X3DNode,
 				cphi  = this .getRandomValue (-1, 1),
 				phi   = Math .acos (cphi),
 				r     = Math .sin (phi);
-		
+
 			return normal .set (Math .sin (theta) * r,
 			                    Math .cos (theta) * r,
 			                    cphi);
@@ -181,7 +181,7 @@ function (X3DNode,
 				cphi  = this .getRandomValue (Math .cos (angle), 1),
 				phi   = Math .acos (cphi),
 				r     = Math .sin (phi);
-		
+
 			return normal .set (Math .sin (theta) * r,
 			                    Math .cos (theta) * r,
 			                    cphi);
@@ -199,7 +199,7 @@ function (X3DNode,
 				cphi  = Math .pow (Math .random (), 1/3),
 				phi   = Math .acos (cphi),
 				r     = Math .sin (phi);
-		
+
 			return normal .set (Math .sin (theta) * r,
 			                    Math .cos (theta) * r,
 			                    cphi);
@@ -231,7 +231,7 @@ function (X3DNode,
 				var
 					particle    = particles [i],
 					elapsedTime = particle .elapsedTime + deltaTime;
-		
+
 				if (elapsedTime > particle .lifetime)
 				{
 					// Create new particle or hide particle.
@@ -270,7 +270,7 @@ function (X3DNode,
 						position .x += velocity .x * deltaTime;
 						position .y += velocity .y * deltaTime;
 						position .z += velocity .z * deltaTime;
-			
+
 						this .bounce (boundedVolume, fromPosition, position, velocity);
 					}
 					else
@@ -279,14 +279,14 @@ function (X3DNode,
 						position .y += velocity .y * deltaTime;
 						position .z += velocity .z * deltaTime;
 					}
-				
+
 					particle .elapsedTime = elapsedTime;
 				}
 			}
 
 			// Animate color if needed.
 
-			if (particleSystem .colorMaterial)
+			if (particleSystem .geometryContext .colorMaterial)
 				this .getColors (particles, particleSystem .colorKeys, particleSystem .colorRamp, numParticles);
 		},
 		bounce: function (boundedVolume, fromPosition, toPosition, velocity)
@@ -294,7 +294,7 @@ function (X3DNode,
 			normal .assign (velocity) .normalize ();
 
 			line .set (fromPosition, normal);
-		
+
 			var
 				intersections       = this .intersections,
 				intersectionNormals = this .intersectionNormals,
@@ -306,11 +306,11 @@ function (X3DNode,
 					intersections [i] .index = i;
 
 				plane .set (fromPosition, normal);
-		
+
 				this .sorter .sort (0, numIntersections);
 
 				var index = Algorithm .upperBound (intersections, 0, numIntersections, 0, PlaneCompareValue);
-				
+
 				if (index < numIntersections)
 				{
 					var
@@ -318,7 +318,7 @@ function (X3DNode,
 						intersectionNormal = intersectionNormals [intersection .index];
 
 					plane .set (intersection, intersectionNormal);
-		
+
 					if (plane .getDistanceToPoint (fromPosition) * plane .getDistanceToPoint (toPosition) < 0)
 					{
 						var dot2 = 2 * intersectionNormal .dot (velocity);
@@ -345,7 +345,7 @@ function (X3DNode,
 				index0 = 0,
 				index1 = 0,
 				weight = 0;
-		
+
 			for (var i = 0; i < numParticles; ++ i)
 			{
 				// Determine index0, index1 and weight.
@@ -370,16 +370,16 @@ function (X3DNode,
 				else
 				{
 					var index = Algorithm .upperBound (colorKeys, 0, length, fraction, Algorithm .less);
-	
+
 					if (index < length)
 					{
 						index1 = index;
 						index0 = index - 1;
-				
+
 						var
 							key0 = colorKeys [index0],
 							key1 = colorKeys [index1];
-				
+
 						weight = Algorithm .clamp ((fraction - key0) / (key1 - key0), 0, 1);
 					}
 					else
@@ -389,13 +389,13 @@ function (X3DNode,
 						weight = 0;
 					}
 				}
-	
+
 				// Interpolate and set color.
 
 				var
 					color0 = colorRamp [index0],
 					color1 = colorRamp [index1];
-	
+
 				// Algorithm .lerp (color0, color1, weight);
 				color .x = color0 .x + weight * (color1 .x - color0 .x);
 				color .y = color0 .y + weight * (color1 .y - color0 .y);
@@ -407,5 +407,3 @@ function (X3DNode,
 
 	return X3DParticleEmitterNode;
 });
-
-

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

@@ -53,12 +53,22 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Picking/X3DPickSensorNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Browser/Picking/IntersectionType",
+	"standard/Math/Numbers/Vector3",
+	"standard/Math/Numbers/Matrix4",
+	"standard/Math/Geometry/Box3",
+	"standard/Math/Geometry/Line3",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DPickSensorNode, 
-          X3DConstants)
+          X3DConstants,
+          IntersectionType,
+          Vector3,
+          Matrix4,
+          Box3,
+          Line3)
 {
 "use strict";
 
@@ -67,6 +77,8 @@ function (Fields,
 		X3DPickSensorNode .call (this, executionContext);
 
 		this .addType (X3DConstants .LinePickSensor);
+
+		this .pickingGeometryNode = null;
 	}
 
 	LinePickSensor .prototype = Object .assign (Object .create (X3DPickSensorNode .prototype),
@@ -75,16 +87,17 @@ 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,     "pickedTextureCoordinate", new Fields .MFVec3f ()),
 			new X3DFieldDefinition (X3DConstants .outputOnly,     "pickedNormal",            new Fields .MFVec3f ()),
 			new X3DFieldDefinition (X3DConstants .outputOnly,     "pickedPoint",             new Fields .MFVec3f ()),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "pickedTextureCoordinate", 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 ()
 		{
@@ -98,6 +111,238 @@ 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 .IndexedLineSet:
+						case X3DConstants .LineSet:
+						{
+							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),
+				matrix                  = new Matrix4 (),
+				point1                  = new Vector3 (0, 0, 0),
+				point2                  = new Vector3 (0, 0, 0),
+				line                    = new Line3 (Vector3 .Zero, Vector3 .zAxis),
+				a                       = new Vector3 (0, 0, 0),
+				b                       = new Vector3 (0, 0, 0),
+				clipPlanes              = [ ],
+				intersections           = [ ],
+				texCoord                = new Vector3 (0, 0, 0),
+				pickedTextureCoordinate = new Fields .MFVec3f (),
+				pickedNormal            = new Fields .MFVec3f (),
+				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.
+		
+							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)
+								{
+									try
+									{
+										var
+											target       = targets [t],
+											geometryNode = target .geometryNode,
+											vertices     = this .pickingGeometryNode .getVertices ();
+
+										targetBBox .assign (geometryNode .getBBox ()) .multRight (target .modelMatrix);
+										matrix .assign (target .modelMatrix) .inverse () .multLeft (modelMatrix);
+	
+										for (var v = 0, vLength = vertices .length; v < vLength; v += 8)
+										{
+											matrix .multVecMatrix (point1 .set (vertices [v + 0], vertices [v + 1], vertices [v + 2]));
+											matrix .multVecMatrix (point2 .set (vertices [v + 4], vertices [v + 5], vertices [v + 6]));
+											line .setPoints (point1, point2);
+	
+											intersections .length = 0;
+	
+											if (geometryNode .intersectsLine (line, clipPlanes, target .modelMatrix, intersections))
+											{
+												for (var i = 0, iLength = intersections .length; i < iLength; ++ i)
+												{
+													// Test if intersection.point is between point1 and point2.
+	
+													var intersection = intersections [i];
+	
+													a .assign (intersection .point) .subtract (point1);
+													b .assign (intersection .point) .subtract (point2);
+	
+													var
+														c = a .add (b) .abs (),
+														s = point1 .distance (point2);
+	
+													if (c <= s)
+														target .intersections .push (intersection);
+												}
+											}
+										}
+	
+										if (target .intersections .length)
+										{
+											pickingCenter .assign (pickingBBox .center);
+											targetCenter  .assign (targetBBox .center);
+	
+											target .intersected = true;
+											target .distance    = pickingCenter .distance (targetCenter);
+										}
+									}
+									catch (error)
+									{
+										// Catch inverse.
+										console .log (error);
+									}
+								}
+							}
+		
+							// 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 ();
+
+							pickedTextureCoordinate .length = 0;
+							pickedNormal            .length = 0;
+							pickedPoint             .length = 0;
+
+							for (var t = 0, tLength = pickedTargets .length; t < tLength; ++ t)
+							{
+								var pickedIntersections = pickedTargets [t] .intersections;
+
+								for (var i = 0, iLength = pickedIntersections .length; i < iLength; ++ i)
+								{
+									var
+										intersection = pickedIntersections [i],
+										t            = intersection .texCoord;
+	
+									texCoord .set (t .x, t .y, t .z);
+	
+									pickedTextureCoordinate .push (texCoord);
+									pickedNormal            .push (intersection .normal);
+									pickedPoint             .push (intersection .point);
+								}
+							}
+
+							if (! this .pickedTextureCoordinate_ .equals (pickedTextureCoordinate))
+								this .pickedTextureCoordinate_ = pickedTextureCoordinate;
+
+							if (! this .pickedNormal_ .equals (pickedNormal))
+								this .pickedNormal_ = pickedNormal;
+
+							if (! this .pickedPoint_ .equals (pickedPoint))
+								this .pickedPoint_ = pickedPoint;
+
+							break;
+						}
+					}
+				}
+
+				X3DPickSensorNode .prototype .process .call (this);
+			};
+		})(),
 	});
 
 	return LinePickSensor;

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

@@ -53,32 +53,39 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Grouping/X3DGroupingNode",
 	"x_ite/Components/Picking/X3DPickableObject",
+	"x_ite/Browser/Picking/MatchCriterion",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/TraverseType",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DGroupingNode, 
-          X3DPickableObject, 
-          X3DConstants)
+          X3DGroupingNode,
+          X3DPickableObject,
+          MatchCriterion,
+          X3DConstants,
+          TraverseType)
 {
 "use strict";
 
 	function PickableGroup (executionContext)
 	{
-		X3DGroupingNode .call (this, executionContext);
+		X3DGroupingNode   .call (this, executionContext);
 		X3DPickableObject .call (this, executionContext);
 
 		this .addType (X3DConstants .PickableGroup);
 	}
 
-	PickableGroup .prototype = Object .assign (Object .create (X3DGroupingNode .prototype),new X3DPickableObject (),
+	PickableGroup .prototype = Object .assign (Object .create (X3DGroupingNode .prototype),
+		X3DPickableObject .prototype,
 	{
 		constructor: PickableGroup,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",       new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "pickable",       new Fields .SFBool (true)),
 			new X3DFieldDefinition (X3DConstants .inputOutput,    "objectType",     new Fields .MFString ("ALL")),
+			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 .inputOnly,      "addChildren",    new Fields .MFNode ()),
@@ -97,9 +104,115 @@ function (Fields,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DGroupingNode   .prototype .initialize .call (this);
+			X3DPickableObject .prototype .initialize .call (this);
+
+			this .pickable_ .addInterest ("set_pickable__", this);
+
+			this .set_pickable__ ();
+		},
+		set_pickableObjects__: function ()
+		{
+			this .set_pickable__ ();
+		},
+		set_pickable__: function ()
+		{
+			this .setPickableObject (Boolean (this .pickable_ .getValue () || this .getTransformSensors () .size));
+		},
+		traverse: (function ()
+		{
+			const pickSensorNodes = new Set ();
+
+			return function (type, renderObject)
+			{
+				if (type === TraverseType .PICKING)
+				{
+					if (this .pickable_ .getValue ())
+					{
+						if (this .getObjectType () .has ("NONE"))
+							return;
+
+						const
+							browser       = renderObject .getBrowser (),
+							pickableStack = browser .getPickable ();
+
+						if (this .getObjectType () .has ("ALL"))
+						{
+							pickableStack .push (true);
+							X3DGroupingNode .prototype .traverse .call (this, type, renderObject);
+							pickableStack .pop ();
+						}
+						else
+						{
+							// Filter pick sensors.
+
+							const pickSensorStack = browser .getPickSensors ();
+
+							for (const pickSensorNode of pickSensorStack .at (-1))
+							{
+								if (! pickSensorNode .getObjectType () .has ("ALL"))
+								{
+									let intersection = 0;
+
+									for (const objectType of this .getObjectType ())
+									{
+										if (pickSensorNode .getObjectType () .has (objectType))
+										{
+											++ intersection;
+											break;
+										}
+									}
+
+									switch (pickSensorNode .getMatchCriterion ())
+									{
+										case MatchCriterion .MATCH_ANY:
+										{
+											if (intersection === 0)
+												continue;
+
+											break;
+										}
+										case MatchCriterion .MATCH_EVERY:
+										{
+											if (intersection !== pickSensor .getObjectType () .size)
+												continue;
+
+											break;
+										}
+										case MatchCriterion .MATCH_ONLY_ONE:
+										{
+											if (intersection !== 1)
+												continue;
+
+											break;
+										}
+									}
+								}
+
+								pickSensorNodes .add (pickSensorNode);
+							}
+
+							pickableStack   .push (true);
+							pickSensorStack .push (pickSensorNodes);
+
+							X3DGroupingNode .prototype .traverse .call (this, type, renderObject);
+
+							pickSensorStack .pop ();
+							pickableStack   .pop ();
+
+							pickSensorNodes .clear ();
+						}
+					}
+				}
+				else
+				{
+					X3DGroupingNode .prototype .traverse .call (this, type, renderObject);
+				}
+			};
+		})(),
 	});
 
 	return PickableGroup;
 });
-
-