x_ite 5.0.3 → 6.1.0

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

@@ -232,58 +232,50 @@ function (Fields,
 
                         for (var t = 0, tLength = targets .size; t < tLength; ++ t)
                         {
-                           try
-                           {
-                              var
-                                 target       = targets [t],
-                                 geometryNode = target .geometryNode,
-                                 vertices     = this .pickingGeometryNode .getVertices ();
+                           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);
+                           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);
+                           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;
+                              intersections .length = 0;
 
-                                 if (geometryNode .intersectsLine (line, clipPlanes, target .modelMatrix, intersections))
+                              if (geometryNode .intersectsLineWithGeometry (line, target .modelMatrix, clipPlanes, intersections))
+                              {
+                                 for (var i = 0, iLength = intersections .length; i < iLength; ++ i)
                                  {
-                                    for (var i = 0, iLength = intersections .length; i < iLength; ++ i)
-                                    {
-                                       // Test if intersection.point is between point1 and point2.
+                                    // Test if intersection.point is between point1 and point2.
 
-                                       var intersection = intersections [i];
+                                    var intersection = intersections [i];
 
-                                       a .assign (intersection .point) .subtract (point1);
-                                       b .assign (intersection .point) .subtract (point2);
+                                    a .assign (intersection .point) .subtract (point1);
+                                    b .assign (intersection .point) .subtract (point2);
 
-                                       var
-                                          c = a .add (b) .abs (),
-                                          s = point1 .distance (point2);
+                                    var
+                                       c = a .add (b) .magnitude (),
+                                       s = point1 .distance (point2);
 
-                                       if (c <= s)
-                                          target .intersections .push (intersection);
-                                    }
+                                    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)
+
+                           if (target .intersections .length)
                            {
-                              // Catch inverse.
-                              console .error (error);
+                              pickingCenter .assign (pickingBBox .center);
+                              targetCenter  .assign (targetBBox .center);
+
+                              target .intersected = true;
+                              target .distance    = pickingCenter .distance (targetCenter);
                            }
                         }
                      }

package/src/x_ite/Components/PointingDeviceSensor/CylinderSensor.js

@@ -143,7 +143,7 @@ function (Fields,
 
          this .cylinder .intersectsLine (hitRay, enter, exit);
 
-         return Vector3 .subtract (hitPoint, enter) .abs () > Vector3 .subtract (hitPoint, exit) .abs ();
+         return Vector3 .subtract (hitPoint, enter) .magnitude () > Vector3 .subtract (hitPoint, exit) .magnitude ();
       },
       getTrackPoint: function (hitRay, trackPoint)
       {
@@ -179,143 +179,126 @@ function (Fields,
       {
          X3DDragSensorNode .prototype .set_active__ .call (this, active, hit, modelViewMatrix, projectionMatrix, viewport);
 
-         try
+         if (this ._isActive .getValue ())
          {
-            if (this ._isActive .getValue ())
-            {
-               this .modelViewMatrix    .assign (modelViewMatrix);
-               this .invModelViewMatrix .assign (modelViewMatrix) .inverse ();
+            this .modelViewMatrix    .assign (modelViewMatrix);
+            this .invModelViewMatrix .assign (modelViewMatrix) .inverse ();
 
-               const
-                  hitRay   = hit .hitRay .copy () .multLineMatrix (this .invModelViewMatrix),
-                  hitPoint = this .invModelViewMatrix .multVecMatrix (hit .intersection .point .copy ());
+            const
+               hitRay   = hit .hitRay .copy () .multLineMatrix (this .invModelViewMatrix),
+               hitPoint = this .invModelViewMatrix .multVecMatrix (hit .intersection .point .copy ());
 
-               const
-                  yAxis      = this ._axisRotation .getValue () .multVecRot (new Vector3 (0, 1, 0)),
-                  cameraBack = this .invModelViewMatrix .multDirMatrix (new Vector3 (0, 0, 1)) .normalize ();
+            const
+               yAxis      = this ._axisRotation .getValue () .multVecRot (new Vector3 (0, 1, 0)),
+               cameraBack = this .invModelViewMatrix .multDirMatrix (new Vector3 (0, 0, 1)) .normalize ();
 
-               const
-                  axis   = new Line3 (new Vector3 (0, 0, 0), yAxis),
-                  radius = axis .getPerpendicularVectorToPoint (hitPoint, new Vector3 (0, 0, 0)) .abs ();
+            const
+               axis   = new Line3 (new Vector3 (0, 0, 0), yAxis),
+               radius = axis .getPerpendicularVectorToPoint (hitPoint, new Vector3 (0, 0, 0)) .magnitude ();
 
-               this .cylinder = new Cylinder3 (axis, radius);
-               this .disk     = Math .abs (Vector3 .dot (cameraBack, yAxis)) > Math .cos (this ._diskAngle .getValue ());
-               this .behind   = this .isBehind (hitRay, hitPoint);
-               this .yPlane   = new Plane3 (hitPoint, yAxis);             // Sensor aligned y-plane
-               this .zPlane   = new Plane3 (hitPoint, cameraBack);        // Screen aligned z-plane
+            this .cylinder = new Cylinder3 (axis, radius);
+            this .disk     = Math .abs (Vector3 .dot (cameraBack, yAxis)) > Math .cos (this ._diskAngle .getValue ());
+            this .behind   = this .isBehind (hitRay, hitPoint);
+            this .yPlane   = new Plane3 (hitPoint, yAxis);             // Sensor aligned y-plane
+            this .zPlane   = new Plane3 (hitPoint, cameraBack);        // Screen aligned z-plane
 
-               // Compute normal like in Billboard with yAxis as axis of rotation.
-               const
-                  billboardToViewer = this .invModelViewMatrix .origin,
-                  sxNormal          = Vector3 .cross (yAxis, billboardToViewer) .normalize ();
+            // Compute normal like in Billboard with yAxis as axis of rotation.
+            const
+               billboardToViewer = this .invModelViewMatrix .origin,
+               sxNormal          = Vector3 .cross (yAxis, billboardToViewer) .normalize ();
 
-               this .sxPlane  = new Plane3 (new Vector3 (0, 0, 0), sxNormal);   // Billboarded special x-plane made parallel to sensors axis.
-               this .szNormal = Vector3 .cross (sxNormal, yAxis) .normalize (); // Billboarded special z-normal made parallel to sensors axis.
+            this .sxPlane  = new Plane3 (new Vector3 (0, 0, 0), sxNormal);   // Billboarded special x-plane made parallel to sensors axis.
+            this .szNormal = Vector3 .cross (sxNormal, yAxis) .normalize (); // Billboarded special z-normal made parallel to sensors axis.
 
-               const trackPoint = new Vector3 (0, 0, 0);
+            const trackPoint = new Vector3 (0, 0, 0);
 
-               if (this .disk)
-                  this .yPlane .intersectsLine (hitRay, trackPoint);
-               else
-                  this .getTrackPoint (hitRay, trackPoint);
+            if (this .disk)
+               this .yPlane .intersectsLine (hitRay, trackPoint);
+            else
+               this .getTrackPoint (hitRay, trackPoint);
 
-               this .fromVector  = this .cylinder .axis .getPerpendicularVectorToPoint (trackPoint, new Vector3 (0, 0, 0)) .negate ();
-               this .startOffset = new Rotation4 (yAxis, this ._offset .getValue ());
+            this .fromVector  = this .cylinder .axis .getPerpendicularVectorToPoint (trackPoint, new Vector3 (0, 0, 0)) .negate ();
+            this .startOffset = new Rotation4 (yAxis, this ._offset .getValue ());
 
-               this ._trackPoint_changed = trackPoint;
-               this ._rotation_changed   = this .startOffset;
+            this ._trackPoint_changed = trackPoint;
+            this ._rotation_changed   = this .startOffset;
 
-               // For min/max angle.
+            // For min/max angle.
 
-               this .angle       = this ._offset .getValue ();
-               this .startVector = this ._rotation_changed .getValue () .multVecRot (this ._axisRotation .getValue () .multVecRot (new Vector3 (0, 0, 1)));
-            }
-            else
-            {
-               if (this ._autoOffset .getValue ())
-                  this ._offset = this .getAngle (this ._rotation_changed .getValue ());
-            }
+            this .angle       = this ._offset .getValue ();
+            this .startVector = this ._rotation_changed .getValue () .multVecRot (this ._axisRotation .getValue () .multVecRot (new Vector3 (0, 0, 1)));
          }
-         catch (error)
+         else
          {
-            console .error (error);
+            if (this ._autoOffset .getValue ())
+               this ._offset = this .getAngle (this ._rotation_changed .getValue ());
          }
       },
       set_motion__: function (hit)
       {
-         try
-         {
-            const
-               hitRay     = hit .hitRay .copy () .multLineMatrix (this .invModelViewMatrix),
-               trackPoint = new Vector3 (0, 0, 0);
+         const
+            hitRay     = hit .hitRay .copy () .multLineMatrix (this .invModelViewMatrix),
+            trackPoint = new Vector3 (0, 0, 0);
 
-            if (this .disk)
-               this .yPlane .intersectsLine (hitRay, trackPoint);
-            else
-               this .getTrackPoint (hitRay, trackPoint);
+         if (this .disk)
+            this .yPlane .intersectsLine (hitRay, trackPoint);
+         else
+            this .getTrackPoint (hitRay, trackPoint);
 
-            this ._trackPoint_changed = trackPoint;
+         this ._trackPoint_changed = trackPoint;
 
-            const
-               toVector = this .cylinder .axis .getPerpendicularVectorToPoint (trackPoint, new Vector3 (0, 0, 0)) .negate (),
-               rotation = new Rotation4 (this .fromVector, toVector);
+         const
+            toVector = this .cylinder .axis .getPerpendicularVectorToPoint (trackPoint, new Vector3 (0, 0, 0)) .negate (),
+            rotation = new Rotation4 (this .fromVector, toVector);
 
-            if (this .disk)
-            {
-               // The trackpoint can swap behind the viewpoint if viewpoint is a Viewpoint node
-               // as the viewing volume is not a cube where the picking ray goes straight up.
-               // This phenomenon is very clear on the viewport corners.
+         if (this .disk)
+         {
+            // The trackpoint can swap behind the viewpoint if viewpoint is a Viewpoint node
+            // as the viewing volume is not a cube where the picking ray goes straight up.
+            // This phenomenon is very clear on the viewport corners.
 
-               const trackPoint_ = this .modelViewMatrix .multVecMatrix (trackPoint .copy ());
+            const trackPoint_ = this .modelViewMatrix .multVecMatrix (trackPoint .copy ());
 
-               if (trackPoint_ .z > 0)
-                  rotation .multRight (new Rotation4 (this .yPlane .normal, Math .PI));
-            }
-            else
-            {
-               if (this .behind)
-                  rotation .inverse ();
-            }
+            if (trackPoint_ .z > 0)
+               rotation .multRight (new Rotation4 (this .yPlane .normal, Math .PI));
+         }
+         else
+         {
+            if (this .behind)
+               rotation .inverse ();
+         }
 
-            rotation .multLeft (this .startOffset);
+         rotation .multLeft (this .startOffset);
 
-            if (this ._minAngle .getValue () > this ._maxAngle .getValue ())
-            {
-               this ._rotation_changed = rotation;
-            }
-            else
-            {
-               const
-                  endVector     = rotation .multVecRot (this ._axisRotation .getValue () .multVecRot (new Vector3 (0, 0, 1))),
-                  deltaRotation = new Rotation4 (this .startVector, endVector),
-                  axis          = this ._axisRotation .getValue () .multVecRot (new Vector3 (0, 1, 0)),
-                  sign          = axis .dot (deltaRotation .getAxis ()) > 0 ? 1 : -1,
-                  min           = this ._minAngle .getValue (),
-                  max           = this ._maxAngle .getValue ();
-
-               this .angle += sign * deltaRotation .angle;
-
-               this .startVector .assign (endVector);
-
-               //console .log (this .angle, min, max);
-
-               if (this .angle < min)
-                  rotation .setAxisAngle (this .cylinder .axis .direction, min);
-               else if (this .angle > max)
-                  rotation .setAxisAngle (this .cylinder .axis .direction, max);
-               else
-                  rotation .setAxisAngle (this .cylinder .axis .direction, this .angle);
-
-               if (! this ._rotation_changed .getValue () .equals (rotation))
-                  this ._rotation_changed = rotation;
-            }
+         if (this ._minAngle .getValue () > this ._maxAngle .getValue ())
+         {
+            this ._rotation_changed = rotation;
          }
-         catch (error)
+         else
          {
-            console .error (error);
+            const
+               endVector     = rotation .multVecRot (this ._axisRotation .getValue () .multVecRot (new Vector3 (0, 0, 1))),
+               deltaRotation = new Rotation4 (this .startVector, endVector),
+               axis          = this ._axisRotation .getValue () .multVecRot (new Vector3 (0, 1, 0)),
+               sign          = axis .dot (deltaRotation .getAxis ()) > 0 ? 1 : -1,
+               min           = this ._minAngle .getValue (),
+               max           = this ._maxAngle .getValue ();
+
+            this .angle += sign * deltaRotation .angle;
 
-            this ._trackPoint_changed .addEvent ();
-            this ._rotation_changed   .addEvent ();
+            this .startVector .assign (endVector);
+
+            //console .log (this .angle, min, max);
+
+            if (this .angle < min)
+               rotation .setAxisAngle (this .cylinder .axis .direction, min);
+            else if (this .angle > max)
+               rotation .setAxisAngle (this .cylinder .axis .direction, max);
+            else
+               rotation .setAxisAngle (this .cylinder .axis .direction, this .angle);
+
+            if (! this ._rotation_changed .getValue () .equals (rotation))
+               this ._rotation_changed = rotation;
          }
       },
    });

package/src/x_ite/Components/PointingDeviceSensor/PlaneSensor.js

@@ -54,9 +54,11 @@ define ([
    "x_ite/Components/PointingDeviceSensor/X3DDragSensorNode",
    "x_ite/Base/X3DConstants",
    "standard/Math/Numbers/Rotation4",
+   "standard/Math/Numbers/Vector2",
    "standard/Math/Numbers/Vector3",
    "standard/Math/Numbers/Vector4",
    "standard/Math/Numbers/Matrix4",
+   "standard/Math/Geometry/Line2",
    "standard/Math/Geometry/Line3",
    "standard/Math/Geometry/Plane3",
    "standard/Math/Geometry/ViewVolume",
@@ -68,9 +70,11 @@ function (Fields,
           X3DDragSensorNode,
           X3DConstants,
           Rotation4,
+          Vector2,
           Vector3,
           Vector4,
           Matrix4,
+          Line2,
           Line3,
           Plane3,
           ViewVolume,
@@ -78,9 +82,9 @@ function (Fields,
 {
 "use strict";
 
-   var
-      screenLine     = new Line3 (Vector3 .Zero, Vector3 .Zero),
-      trackPoint1    = new Vector3 (0, 0, 0),
+   const
+      screenLine     = new Line2 (Vector2 .Zero, Vector2 .Zero),
+      trackPoint1    = new Vector2 (0, 0, 0),
       trackPointLine = new Line3 (Vector3 .Zero, Vector3 .Zero);
 
    function PlaneSensor (executionContext)
@@ -142,7 +146,7 @@ function (Fields,
       getLineTrackPoint: function (hit, line, trackPoint)
       {
          ViewVolume .projectLine (line, this .modelViewMatrix, this .projectionMatrix, this .viewport, screenLine);
-         screenLine .getClosestPointToPoint (new Vector3 (hit .pointer .x, hit .pointer .y, 0), trackPoint1);
+         screenLine .getClosestPointToPoint (hit .pointer, trackPoint1);
          ViewVolume .unProjectRay (trackPoint1 .x, trackPoint1 .y, this .modelViewMatrix, this .projectionMatrix, this .viewport, trackPointLine);
 
          return line .getClosestPointToLine (trackPointLine, trackPoint);
@@ -151,82 +155,75 @@ function (Fields,
       {
          X3DDragSensorNode .prototype .set_active__ .call (this, active, hit, modelViewMatrix, projectionMatrix, viewport);
 
-         try
+         if (this ._isActive .getValue ())
          {
-            if (this ._isActive .getValue ())
-            {
-               this .modelViewMatrix    .assign (modelViewMatrix);
-               this .projectionMatrix   .assign (projectionMatrix);
-               this .viewport           .assign (viewport);
-               this .invModelViewMatrix .assign (modelViewMatrix) .inverse ();
+            this .modelViewMatrix    .assign (modelViewMatrix);
+            this .projectionMatrix   .assign (projectionMatrix);
+            this .viewport           .assign (viewport);
+            this .invModelViewMatrix .assign (modelViewMatrix) .inverse ();
 
-               var
-                  hitRay   = hit .hitRay .copy () .multLineMatrix (this .invModelViewMatrix),
-                  hitPoint = this .invModelViewMatrix .multVecMatrix (hit .intersection .point .copy ());
+            var
+               hitRay   = hit .hitRay .copy () .multLineMatrix (this .invModelViewMatrix),
+               hitPoint = this .invModelViewMatrix .multVecMatrix (hit .intersection .point .copy ());
 
-               var axisRotation = this ._axisRotation .getValue ();
+            var axisRotation = this ._axisRotation .getValue ();
 
-               if (this ._minPosition .x === this ._maxPosition .x)
-               {
-                  this .planeSensor = false;
+            if (this ._minPosition .x === this ._maxPosition .x)
+            {
+               this .planeSensor = false;
 
-                  var direction = axisRotation .multVecRot (new Vector3 (0, Math .abs (this ._maxPosition .y - this ._minPosition .y), 0));
+               var direction = axisRotation .multVecRot (new Vector3 (0, Math .abs (this ._maxPosition .y - this ._minPosition .y), 0));
 
-                  this .line = new Line3 (hitPoint, direction .normalize ());
-               }
-               else if (this ._minPosition .y === this ._maxPosition .y)
-               {
-                  this .planeSensor = false;
+               this .line = new Line3 (hitPoint, direction .normalize ());
+            }
+            else if (this ._minPosition .y === this ._maxPosition .y)
+            {
+               this .planeSensor = false;
 
-                  var direction = axisRotation .multVecRot (new Vector3 (Math .abs (this ._maxPosition .x - this ._minPosition .x), 0, 0));
+               var direction = axisRotation .multVecRot (new Vector3 (Math .abs (this ._maxPosition .x - this ._minPosition .x), 0, 0));
 
-                  this .line = new Line3 (hitPoint, direction .normalize ());
-               }
-               else
+               this .line = new Line3 (hitPoint, direction .normalize ());
+            }
+            else
+            {
+               this .planeSensor = true;
+               this .plane       = new Plane3 (hitPoint, axisRotation .multVecRot (new Vector3 (0, 0, 1)));
+            }
+
+            if (this .planeSensor)
+            {
+               if (this .plane .intersectsLine (hitRay, this .startPoint))
                {
-                  this .planeSensor = true;
-                  this .plane       = new Plane3 (hitPoint, axisRotation .multVecRot (new Vector3 (0, 0, 1)));
+                  this .trackStart (this .startPoint);
                }
 
-               if (this .planeSensor)
+//						new Plane3 (new Vector3 (0, 0, 0), this .plane .normal) .intersectsLine (hitRay, trackPoint);
+            }
+            else
+            {
+               if (this .getLineTrackPoint (hit, this .line, this .startPoint))
                {
-                  if (this .plane .intersectsLine (hitRay, this .startPoint))
+                  var trackPoint = new Vector3 (0, 0, 0);
+
+                  try
                   {
-                     this .trackStart (this .startPoint);
+                     this .getLineTrackPoint (hit, new Line3 (this .line .direction, this .line .direction), trackPoint);
                   }
-
-//						new Plane3 (new Vector3 (0, 0, 0), this .plane .normal) .intersectsLine (hitRay, trackPoint);
-               }
-               else
-               {
-                  if (this .getLineTrackPoint (hit, this .line, this .startPoint))
+                  catch (error)
                   {
-                     var trackPoint = new Vector3 (0, 0, 0);
-
-                     try
-                     {
-                        this .getLineTrackPoint (hit, new Line3 (this .line .direction, this .line .direction), trackPoint);
-                     }
-                     catch (error)
-                     {
-                        //console .error (error);
+                     //console .error (error);
 
-                        trackPoint = this .startPoint;
-                     }
-
-                     this .trackStart (trackPoint);
+                     trackPoint = this .startPoint;
                   }
+
+                  this .trackStart (trackPoint);
                }
             }
-            else
-            {
-               if (this ._autoOffset .getValue ())
-                  this ._offset = this ._translation_changed;
-            }
          }
-         catch (error)
+         else
          {
-            console .error (error);
+            if (this ._autoOffset .getValue ())
+               this ._offset = this ._translation_changed;
          }
       },
       trackStart: function (trackPoint)