Expand tabs

1 files changed, 186 insertions, 186 deletions

diff --git a/js/helper-classes/3D/StageLine.js b/js/helper-classes/3D/StageLine.js
index 787a4568..d6eea478 100755
--- a/js/helper-classes/3D/StageLine.js
+++ b/js/helper-classes/3D/StageLine.js
@@ -120,7 +120,7 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, {
                         // add the intersection
                         var dot = MathUtils.dot3( pt0, planeEq ) + planeEq[3];
                         var deltaVis = (dot > 0) ? 1 : -1;
-//                                      if (plane.isBackFacing())
+//                  if (plane.isBackFacing())
 //                        deltaVis = (dot < 0) ? 1 : -1;
 
                         this.addIntersection( plane, t, deltaVis );
@@ -175,14 +175,14 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, {
                     MathUtils.negate( vec );
                 planeEq = [-vec[1], vec[0], 0];
                 var normal = [planeEq[0], planeEq[1], planeEq[2]];
-//                      var d = -planeEq.dot(bPt0);
+//          var d = -planeEq.dot(bPt0);
                 var d = -vecUtils.vecDot(3, planeEq, bPt0);
                 planeEq[3] = d;
 
                 t = MathUtils.vecIntersectPlaneForParam( pt0, lineDir, planeEq );
                 if (t)
                 {
-                    if ((MathUtils.fpSign(t) > 0) && (MathUtils.fpCmp(t,1.0) <= 0))     // the strict vs not-strict inequality comparisons are IMPORTANT!
+                    if ((MathUtils.fpSign(t) > 0) && (MathUtils.fpCmp(t,1.0) <= 0)) // the strict vs not-strict inequality comparisons are IMPORTANT!
                     {
                         // get the intersection point
                         var pt = MathUtils.interpolateLine3D( pt0, pt1, t );
@@ -207,184 +207,184 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, {
         }
     },
 
-        doCoplanarIntersection: {
-                value: function( plane )
-                {
-                        // get the boundary points for the plane
-                        var boundaryPts = plane.getBoundaryPoints();
-                        var planeEq = plane.getPlaneEq();
-
-                        if (plane.isBackFacing())
-                        {
-                                var tmp;
-                                tmp = boundaryPts[0];  boundaryPts[0] = boundaryPts[3];  boundaryPts[3] = tmp;
-                                tmp = boundaryPts[1];  boundaryPts[1] = boundaryPts[2];  boundaryPts[2] = tmp;
-                        }
-
-                        var pt0 = this.getPoint0(),
-                                pt1 = this.getPoint1();
-
-                        // keep a couple flags to prevent counting crossings twice in edge cases
-                        var gotEnter = false,
-                                        gotExit = false;
-
-                        var bp1 = boundaryPts[3];
-                        for (var i=0;  i<4;  i++)
-                        {
-                                var bp0 = bp1;
-                                bp1 = boundaryPts[i];
-                                var vec = vecUtils.vecSubtract(3, bp1, bp0);
-                                var nrm = vecUtils.vecCross(3, vec, planeEq);
-                                nrm[3] = -vecUtils.vecDot(3, bp0, nrm);
-
-                                var d0 = vecUtils.vecDot(3, nrm, pt0) + nrm[3],
-                                                d1 = vecUtils.vecDot(3, nrm, pt1) + nrm[3];
-
-                                var s0 = MathUtils.fpSign(d0),
-                                                s1 = MathUtils.fpSign(d1);
-
-                                if (s0 != s1)
-                                {
-                                        var t = Math.abs(d0)/( Math.abs(d0) + Math.abs(d1) );
-                                        if (t == 0)
-                                        {
-                                                if (s1 > 0)     // entering the material from the beginning of the line that is to be drawn
-                                                {
-                                                        // see if the start point of the line is at a corner of the bounded plane
-                                                        var lineDir = vecUtils.vecSubtract(3, pt1, pt0);
-                                                        vecUtils.vecNormalize(3, lineDir);
-                                                        var dist = vecUtils.vecDist( 3, pt0, bp1 );
-                                                        var bp2, bv0, bv1, cross1, cross2, cross3;
-                                                        if ( MathUtils.fpSign(dist) == 0)
-                                                        {
-                                                                bp2 = boundaryPts[(i+1) % 4];
-                                                                bv0 = vecUtils.vecSubtract(3, bp2, bp1);
-                                                                bv1 = vecUtils.vecSubtract(3, bp0, bp1);
-                                                                cross1 = vecUtils.vecCross(3, bv0, lineDir);
-                                                                cross2 = vecUtils.vecCross(3, lineDir, bv1);
-                                                                cross3 = vecUtils.vecCross(3, bv0, bv1);
-                                                                if ( (MathUtils.fpSign(vecUtils.vecDot(3, cross1, cross3)) == 0) && (MathUtils.fpSign(vecUtils.vecDot(3, cross2, cross3)) == 0))
-                                                                {
-                                                                        gotEnter = true;
-                                                                        this.addIntersection( plane, t, 1 );
-                                                                }
-                                                        }
-                                                        else if (MathUtils.fpSign( vecUtils.vecDist(3, pt0, bp0)) === 0)
-                                                        {
-                                                                bp2 = boundaryPts[(i+2) % 4];
-                                                                bv0 = vecUtils.vecSubtract(3, bp2, bp0);
-                                                                bv1 = vecUtils.vecSubtract(3, bp1, bp0);
-                                                                cross1 = vecUtils.vecCross(3, bv0, lineDir);
-                                                                cross2 = vecUtils.vecCross(3, lineDir, bv1);
-                                                                cross3 = vecUtils.vecCross(3, bv0, bv1);
-                                                                if ( (MathUtils.fpSign(vecUtils.vecDot(3, cross1, cross3)) == 0) && (MathUtils.fpSign(vecUtils.vecDot(3, cross2, cross3)) == 0))
-                                                                {
-                                                                        gotEnter = true;
-                                                                        this.addIntersection( plane, t, 1 );
-                                                                }
-                                                        }
-                                                        else
-                                                        {
-                                                                // check if the line is on the edge of the boundary or goes to the interior
-                                                                gotEnter = true;
-                                                                this.addIntersection( plane, t, 1 );
-                                                        }
-                                                }
-                                        }
-                                        else if ( (MathUtils.fpSign(t) > 0) && (MathUtils.fpCmp(t,1.0) <= 0))
-                                        {
-                                                // get the point where the line crosses the edge of the element plane
-                                                var pt = MathUtils.interpolateLine3D(pt0, pt1, t );
-
-                                                // we know that the line crosses the infinite extension of the edge.  Determine
-                                                // if that crossing is within the bounds of the edge
-                                                var dot0 = vecUtils.vecDot(3, vecUtils.vecSubtract(3,pt, bp0),  vec),
-                                                                dot1 = vecUtils.vecDot(3, vecUtils.vecSubtract(3,pt, bp1),  vec);
-                                                if ((MathUtils.fpSign(dot0) > 0) && (MathUtils.fpSign(dot1) < 0))
-                                                {
-                                                        // determine if the line is entering or exiting
-                                                        if (s0 <= 0)            // entering
-                                                        {
-                                                                if (!gotEnter)
+    doCoplanarIntersection: {
+        value: function( plane )
+        {
+            // get the boundary points for the plane
+            var boundaryPts = plane.getBoundaryPoints();
+            var planeEq = plane.getPlaneEq();
+
+            if (plane.isBackFacing())
+            {
+                var tmp;
+                tmp = boundaryPts[0];  boundaryPts[0] = boundaryPts[3];  boundaryPts[3] = tmp;
+                tmp = boundaryPts[1];  boundaryPts[1] = boundaryPts[2];  boundaryPts[2] = tmp;
+            }
+
+            var pt0 = this.getPoint0(),
+                pt1 = this.getPoint1();
+
+            // keep a couple flags to prevent counting crossings twice in edge cases
+            var gotEnter = false,
+                    gotExit = false;
+
+            var bp1 = boundaryPts[3];
+            for (var i=0;  i<4;  i++)
+            {
+                var bp0 = bp1;
+                bp1 = boundaryPts[i];
+                var vec = vecUtils.vecSubtract(3, bp1, bp0);
+                var nrm = vecUtils.vecCross(3, vec, planeEq);
+                nrm[3] = -vecUtils.vecDot(3, bp0, nrm);
+
+                var d0 = vecUtils.vecDot(3, nrm, pt0) + nrm[3],
+                        d1 = vecUtils.vecDot(3, nrm, pt1) + nrm[3];
+
+                var s0 = MathUtils.fpSign(d0),
+                        s1 = MathUtils.fpSign(d1);
+
+                if (s0 != s1)
+                {
+                    var t = Math.abs(d0)/( Math.abs(d0) + Math.abs(d1) );
+                    if (t == 0)
+                    {
+                        if (s1 > 0) // entering the material from the beginning of the line that is to be drawn
+                        {
+                            // see if the start point of the line is at a corner of the bounded plane
+                            var lineDir = vecUtils.vecSubtract(3, pt1, pt0);
+                            vecUtils.vecNormalize(3, lineDir);
+                            var dist = vecUtils.vecDist( 3, pt0, bp1 );
+                            var bp2, bv0, bv1, cross1, cross2, cross3;
+                            if ( MathUtils.fpSign(dist) == 0)
+                            {
+                                bp2 = boundaryPts[(i+1) % 4];
+                                bv0 = vecUtils.vecSubtract(3, bp2, bp1);
+                                bv1 = vecUtils.vecSubtract(3, bp0, bp1);
+                                cross1 = vecUtils.vecCross(3, bv0, lineDir);
+                                cross2 = vecUtils.vecCross(3, lineDir, bv1);
+                                cross3 = vecUtils.vecCross(3, bv0, bv1);
+                                if ( (MathUtils.fpSign(vecUtils.vecDot(3, cross1, cross3)) == 0) && (MathUtils.fpSign(vecUtils.vecDot(3, cross2, cross3)) == 0))
+                                {
+                                    gotEnter = true;
+                                    this.addIntersection( plane, t, 1 );
+                                }
+                            }
+                            else if (MathUtils.fpSign( vecUtils.vecDist(3, pt0, bp0)) === 0)
+                            {
+                                bp2 = boundaryPts[(i+2) % 4];
+                                bv0 = vecUtils.vecSubtract(3, bp2, bp0);
+                                bv1 = vecUtils.vecSubtract(3, bp1, bp0);
+                                cross1 = vecUtils.vecCross(3, bv0, lineDir);
+                                cross2 = vecUtils.vecCross(3, lineDir, bv1);
+                                cross3 = vecUtils.vecCross(3, bv0, bv1);
+                                if ( (MathUtils.fpSign(vecUtils.vecDot(3, cross1, cross3)) == 0) && (MathUtils.fpSign(vecUtils.vecDot(3, cross2, cross3)) == 0))
+                                {
+                                    gotEnter = true;
+                                    this.addIntersection( plane, t, 1 );
+                                }
+                            }
+                            else
+                            {
+                                // check if the line is on the edge of the boundary or goes to the interior
+                                gotEnter = true;
+                                this.addIntersection( plane, t, 1 );
+                            }
+                        }
+                    }
+                    else if ( (MathUtils.fpSign(t) > 0) && (MathUtils.fpCmp(t,1.0) <= 0))
+                    {
+                        // get the point where the line crosses the edge of the element plane
+                        var pt = MathUtils.interpolateLine3D(pt0, pt1, t );
+
+                        // we know that the line crosses the infinite extension of the edge.  Determine
+                        // if that crossing is within the bounds of the edge
+                        var dot0 = vecUtils.vecDot(3, vecUtils.vecSubtract(3,pt, bp0),  vec),
+                                dot1 = vecUtils.vecDot(3, vecUtils.vecSubtract(3,pt, bp1),  vec);
+                        if ((MathUtils.fpSign(dot0) > 0) && (MathUtils.fpSign(dot1) < 0))
+                        {
+                            // determine if the line is entering or exiting
+                            if (s0 <= 0)        // entering
+                            {
+                                if (!gotEnter)