x_ite 5.0.2 → 6.0.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 .intersectsLine (line, clipPlanes, target .modelMatrix, 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) .abs (),
+                                       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

@@ -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)) .abs ();
 
-               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

@@ -151,82 +151,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)

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

@@ -141,97 +141,80 @@ 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 ();
-
-               var
-                  hitPoint = this .invModelViewMatrix .multVecMatrix (hit .intersection .point .copy ()),
-                  center   = new Vector3 (0, 0, 0);
-
-               this .zPlane = new Plane3 (center, this .invModelViewMatrix .multDirMatrix (new Vector3 (0, 0, 1)) .normalize ()); // Screen aligned Z-plane
-               this .sphere = new Sphere3 (hitPoint .abs (), center);
-               this .behind = this .zPlane .getDistanceToPoint (hitPoint) < 0;
-
-               this .fromVector  .assign (hitPoint);
-               this .startPoint  .assign (hitPoint);
-               this .startOffset .assign (this ._offset .getValue ());
-
-               this ._trackPoint_changed = hitPoint;
-               this ._rotation_changed   = this ._offset .getValue ();
-            }
-            else
-            {
-               if (this ._autoOffset .getValue ())
-                  this ._offset = this ._rotation_changed;
-            }
+            this .modelViewMatrix    .assign (modelViewMatrix);
+            this .invModelViewMatrix .assign (modelViewMatrix) .inverse ();
+
+            var
+               hitPoint = this .invModelViewMatrix .multVecMatrix (hit .intersection .point .copy ()),
+               center   = new Vector3 (0, 0, 0);
+
+            this .zPlane = new Plane3 (center, this .invModelViewMatrix .multDirMatrix (new Vector3 (0, 0, 1)) .normalize ()); // Screen aligned Z-plane
+            this .sphere = new Sphere3 (hitPoint .abs (), center);
+            this .behind = this .zPlane .getDistanceToPoint (hitPoint) < 0;
+
+            this .fromVector  .assign (hitPoint);
+            this .startPoint  .assign (hitPoint);
+            this .startOffset .assign (this ._offset .getValue ());
+
+            this ._trackPoint_changed = hitPoint;
+            this ._rotation_changed   = this ._offset .getValue ();
          }
-         catch (error)
+         else
          {
-            //console .error (error);
+            if (this ._autoOffset .getValue ())
+               this ._offset = this ._rotation_changed;
          }
       },
       set_motion__: function (hit)
       {
-         try
-         {
-            var
-               hitRay     = hit .hitRay .copy () .multLineMatrix (this .invModelViewMatrix),
-               trackPoint = new Vector3 (0, 0, 0);
+         var
+            hitRay     = hit .hitRay .copy () .multLineMatrix (this .invModelViewMatrix),
+            trackPoint = new Vector3 (0, 0, 0);
 
-            if (this .getTrackPoint (hitRay, trackPoint, this .behind))
-            {
-               var zAxis = this .invModelViewMatrix .multDirMatrix (new Vector3 (0, 0, 1)) .normalize (); // Camera direction
-               this .zPlane = new Plane3 (trackPoint, zAxis);                                             // Screen aligned Z-plane
-            }
-            else
-            {
-               // Find trackPoint on the plane with sphere
-
-               var tangentPoint = new Vector3 (0, 0, 0);
-               this .zPlane .intersectsLine (hitRay, tangentPoint);
+         if (this .getTrackPoint (hitRay, trackPoint, this .behind))
+         {
+            var zAxis = this .invModelViewMatrix .multDirMatrix (new Vector3 (0, 0, 1)) .normalize (); // Camera direction
+            this .zPlane = new Plane3 (trackPoint, zAxis);                                             // Screen aligned Z-plane
+         }
+         else
+         {
+            // Find trackPoint on the plane with sphere
 
-               hitRay = new Line3 (tangentPoint, Vector3 .subtract (this .sphere .center, tangentPoint) .normalize ());
+            var tangentPoint = new Vector3 (0, 0, 0);
+            this .zPlane .intersectsLine (hitRay, tangentPoint);
 
-               //console .log (hitRay .toString ());
+            hitRay = new Line3 (tangentPoint, Vector3 .subtract (this .sphere .center, tangentPoint) .normalize ());
 
-               this .getTrackPoint (hitRay, trackPoint, false);
+            //console .log (hitRay .toString ());
 
-               // Find trackPoint behind sphere
+            this .getTrackPoint (hitRay, trackPoint, false);
 
-               var
-                  triNormal     = Triangle3 .normal (this .sphere .center, trackPoint, this .startPoint, new Vector3 (0, 0, 0)),
-                  dirFromCenter = Vector3 .subtract (trackPoint, this .sphere .center) .normalize (),
-                  normal        = Vector3 .cross (triNormal, dirFromCenter) .normalize ();
+            // Find trackPoint behind sphere
 
-               var point1 = Vector3 .subtract (trackPoint, normal .multiply (Vector3 .subtract (tangentPoint, trackPoint) .abs ()));
+            var
+               triNormal     = Triangle3 .normal (this .sphere .center, trackPoint, this .startPoint, new Vector3 (0, 0, 0)),
+               dirFromCenter = Vector3 .subtract (trackPoint, this .sphere .center) .normalize (),
+               normal        = Vector3 .cross (triNormal, dirFromCenter) .normalize ();
 
-               hitRay = new Line3 (point1, Vector3 .subtract (this .sphere .center, point1) .normalize ());
+            var point1 = Vector3 .subtract (trackPoint, normal .multiply (Vector3 .subtract (tangentPoint, trackPoint) .abs ()));
 
-               this .getTrackPoint (hitRay, trackPoint, false);
-            }
+            hitRay = new Line3 (point1, Vector3 .subtract (this .sphere .center, point1) .normalize ());
 
-            this ._trackPoint_changed = trackPoint;
+            this .getTrackPoint (hitRay, trackPoint, false);
+         }
 
-            var
-               toVector = Vector3 .subtract (trackPoint, this .sphere .center),
-               rotation = new Rotation4 (this .fromVector, toVector);
+         this ._trackPoint_changed = trackPoint;
 
-            if (this .behind)
-               rotation .inverse ();
+         var
+            toVector = Vector3 .subtract (trackPoint, this .sphere .center),
+            rotation = new Rotation4 (this .fromVector, toVector);
 
-            this ._rotation_changed = Rotation4 .multRight (this .startOffset, rotation);
-         }
-         catch (error)
-         {
-            //console .error (error);
+         if (this .behind)
+            rotation .inverse ();
 
-            this ._trackPoint_changed .addEvent ();
-            this ._rotation_changed   .addEvent ();
-         }
+         this ._rotation_changed = Rotation4 .multRight (this .startOffset, rotation);
       },
    });
 

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

@@ -103,24 +103,17 @@ function (Fields,
       },
       set_over__: function (over, hit, modelViewMatrix, projectionMatrix, viewport)
       {
-         try
-         {
-            X3DTouchSensorNode .prototype .set_over__ .call (this, over, hit, modelViewMatrix, projectionMatrix, viewport);
+         X3DTouchSensorNode .prototype .set_over__ .call (this, over, hit, modelViewMatrix, projectionMatrix, viewport);
 
-            if (this ._isOver .getValue ())
-            {
-               var intersection = hit .intersection;
+         if (this ._isOver .getValue ())
+         {
+            var intersection = hit .intersection;
 
-               invModelViewMatrix .assign (modelViewMatrix) .inverse ();
+            invModelViewMatrix .assign (modelViewMatrix) .inverse ();
 
-               this ._hitTexCoord_changed = intersection .texCoord;
-               this ._hitNormal_changed   = modelViewMatrix .multMatrixDir (intersection .normal .copy ()) .normalize ();
-               this ._hitPoint_changed    = invModelViewMatrix .multVecMatrix (intersection .point .copy ());
-            }
-         }
-         catch (error)
-         {
-            console .error (error);
+            this ._hitTexCoord_changed = intersection .texCoord;
+            this ._hitNormal_changed   = modelViewMatrix .multMatrixDir (intersection .normal .copy ()) .normalize ();
+            this ._hitPoint_changed    = invModelViewMatrix .multVecMatrix (intersection .point .copy ());
          }
       },
    });