1 files changed, 354 insertions, 212 deletions

diff --git a/js/helper-classes/3D/StageLine.js b/js/helper-classes/3D/StageLine.js
index 787a4568..f9abc5ce 100755
--- a/js/helper-classes/3D/StageLine.js
+++ b/js/helper-classes/3D/StageLine.js
@@ -1,24 +1,25 @@
 /* <copyright>
-Copyright (c) 2012, Motorola Mobility, Inc
+Copyright (c) 2012, Motorola Mobility LLC.
 All Rights Reserved.
-BSD License.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
-  - Redistributions of source code must retain the above copyright notice,
-    this list of conditions and the following disclaimer.
-  - Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-  - Neither the name of Motorola Mobility nor the names of its contributors
-    may be used to endorse or promote products derived from this software
-    without specific prior written permission.
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of Motorola Mobility LLC nor the names of its
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
@@ -33,6 +34,7 @@ POSSIBILITY OF SUCH DAMAGE.
 //      The line class represents a line intersected with all planes on the scene
 ///////////////////////////////////////////////////////////////////////
 var vecUtils = require("js/helper-classes/3D/vec-utils").VecUtils;
+var viewUtils = require( "js/helper-classes/3D/view-utils").ViewUtils;
 var LinePlaneIntersectRec = require("js/helper-classes/3D/LinePlaneIntersectRec").LinePlaneIntersectRec;
 
 var StageLine = exports.StageLine = Object.create(Object.prototype, {
@@ -95,7 +97,7 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, {
             if (minPt[2] > plane.getZMax())           return;
 
             // get the boundary points for the plane
-            var boundaryPts = plane.getBoundaryPoints();
+            var boundaryPts = plane.getBoundaryPoints().slice();
 
             // get the points and direction vector for the current line
             var pt0 = this.getPoint0(),  pt1 = this.getPoint1();
@@ -114,13 +116,14 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, {
 
                     // see if the intersection point is contained in the bounds
                     //var contains = this.boundaryContainsPoint( boundaryPts, plane.isBackFacing(), pt );
-                    var contains = MathUtils.boundaryContainsPoint( boundaryPts, pt, plane.isBackFacing() );
+                    var onEdge = [];
+                    var contains = MathUtils.boundaryContainsPoint( boundaryPts, pt, plane.isBackFacing(), onEdge );
                     if (contains == MathUtils.INSIDE)
                     {
                         // 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 );
@@ -129,23 +132,40 @@ var StageLine = exports.StageLine = Object.create(Object.prototype, {
                     {
                         if (MathUtils.fpCmp(t,1.0) < 0)
                         {
-                            // take the dot product between the line and the normal to the plane
-                            // to determine the change in visibility
-                            var vec = vecUtils.vecSubtract( 3, pt1, pt0 );
-                            var dot = vecUtils.vecDot( 3, vec, plane.getPlaneEq() );
-                            var sign = MathUtils.fpSign( dot );
-                            if (sign == 0)
-                                throw new Error( "coplanar intersection being treated as not coplanar" );
-                            if (!plane.isBackFacing())
+                            // determine if the intersection is on a front side (no intersection) of the polygons
+                            //var ctr = [ 0.5*(boundaryPts[0][0] + boundaryPts[2][0]),  0.5*(boundaryPts[0][1] + boundaryPts[2][1]),  0.5*(boundaryPts[0][2] + boundaryPts[2][2]) ];
+                            //var vec = vecUtils.vecSubtract(3, pt, ctr );
+                            if (this.edgeGoesBehindPlane( plane, boundaryPts, onEdge[0], onEdge[1],  pt0, pt1  ))
                             {
-                                if (sign < 0)
-                                    this.addIntersection( plane, t, 1 );
+                                this.addIntersection( plane, t, 1 );
                             }
-                            else
+                            else if (this.edgeGoesBehindPlane( plane, boundaryPts, onEdge[0], onEdge[1],  pt1, pt0  ))
                             {
-                                if (sign > 0)
-                                    this.addIntersection( plane, t, -1 );
+                                this.addIntersection( plane, t, -1 );
+                            }
+
+                            /*
+                            if ( !this.edgeIsFrontFacing(boundaryPts, planeEq, plane.isBackFacing(), onEdge[0], onEdge[1]) )
+                            {
+                                // take the dot product between the line and the normal to the plane
+                                // to determine the change in visibility
+                                var vec = vecUtils.vecSubtract( 3, pt1, pt0 );
+                                var dot = vecUtils.vecDot( 3, vec, planeEq );
+                                var sign = MathUtils.fpSign( dot );
+                                if (sign == 0)
+                                    throw new Error( "coplanar intersection being treated as not coplanar" );
+                                if (!plane.isBackFacing())
+                                {
+                                    if (sign < 0)
+                                        this.addIntersection( plane, t, 1 );
+                                }
+                                else
+                                {
+                                    if (sign > 0)
+                                        this.addIntersection( plane, t, -1 );
+                                }
                             }
+                            */
                         }
                     }
                 }
@@ -175,14 +195,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 +227,306 @@ 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];
+    edgeGoesBehindPlane:
+    {
+        value: function( plane, boundaryPts, iEdge, t,  lPt0, lPt1 )
+        {
+            var rtnVal = false;
+
+            if ( MathUtils.fpCmp(t,1.0) == 0 )
+            {
+                iEdge = (iEdge + 1) % 4;
+                t = 0.0;
+            }
+
+            // boundary points (line points: lPt0, lPt1)
+            var bPt0, bPt1, bPt2, bVec, bVec0, bVec1, lVec, d;
+
+            var planeEq = plane.getPlaneEq();
+            if (MathUtils.fpSign(t) == 0)
+            {
+                // get the 3 relevant points.  The line goes through pt1.
+                bPt0  = boundaryPts[(iEdge+3)%4].slice();
+                bPt1  = boundaryPts[iEdge].slice();
+                bPt2  = boundaryPts[(iEdge+1)%4].slice();
+                bVec0 = vecUtils.vecSubtract(2, bPt0, bPt1);
+                bVec1 = vecUtils.vecSubtract(2, bPt2, bPt1);
+                lVec  = vecUtils.vecSubtract(2, lPt1, bPt1);
+
+                var c0 = vecUtils.vecCross(2, bVec1, lVec),
+                    c1 = vecUtils.vecCross(2, lVec, bVec0);
+//                if ((MathUtils.fpSign(c0) < 0) && (MathUtils.fpSign(c1) < 0))
+//                    rtnVal = true;
+                                if (!plane.isBackFacing() && (MathUtils.fpSign(c0) < 0) && (MathUtils.fpSign(c1) < 0))
+                                        rtnVal = true;