First commit of Ninja to ninja-internal

Signed-off-by: Valerio Virgillito <rmwh84@motorola.com>

1 files changed, 461 insertions, 0 deletions

diff --git a/js/helper-classes/3D/StageLine.js b/js/helper-classes/3D/StageLine.js
new file mode 100644
index 00000000..e0e7a8e3
--- /dev/null
+++ b/js/helper-classes/3D/StageLine.js
@@ -0,0 +1,461 @@
+/* <copyright>
+This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+(c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+</copyright> */
+
+///////////////////////////////////////////////////////////////////////
+// Class StageLine
+//      The line class represents a line intersected with all planes on the scene
+///////////////////////////////////////////////////////////////////////
+var vecUtils = require("js/helper-classes/3D/vec-utils").VecUtils;
+var LinePlaneIntersectRec = require("js/helper-classes/3D/LinePlaneIntersectRec").LinePlaneIntersectRec;
+
+var StageLine = exports.StageLine = Object.create(Object.prototype, {
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+
+    // the 2 points of the line
+    _pt0: { value: null, writable: true },
+    _pt1: { value: null, writable: true },
+
+    // cache the 3D min and max points for the line
+    _minPt: { value: null, writable: true },
+    _maxPt: { value: null, writable: true },
+
+    // the visibility at the start point (this._pt0).
+    _vis: { value: null, writable: true },
+
+    // each line/plane intersection records 2 values:  the parameter along
+    // the line from pt0 to pt1, and the change in visibility (+1 or -1).  we
+    // keep a doubly-linked list of intersection records
+    _intersectionList: { value: null, writable: true },
+    _intersectionCount: { value: 0, writable: true },
+
+    ///////////////////////////////////////////////////////////////////////
+    // Property accessors
+    ///////////////////////////////////////////////////////////////////////
+    getMinPoint: { value: function()    {  return this._minPt.slice(0);     } },
+    getMaxPoint: { value: function()    {  return this._maxPt.slice(0);        } },
+
+    getPoint0: { value: function()    {  return this._pt0.slice(0);          } },
+    getPoint1: { value: function()    {  return this._pt1.slice(0);          } },
+
+    getIntersectionCount: { value: function()    {  return this._intersectionCount;  } },
+    getIntersectionList: { value: function()    {  return this._intersectionList;   } },
+
+    getVisibility: { value: function()    { return this._vis;                 } },
+    setVisibility: { value: function(v)   {  this._vis = v;                   } },
+
+    ///////////////////////////////////////////////////////////////////////
+    // Methods
+    ///////////////////////////////////////////////////////////////////////
+
+    intersectWithPlane: {
+        value: function( plane )
+        {
+            // if the plane is edge-on, ignore it
+            if ( MathUtils.fpSign( plane.getPlaneEq()[2] ) == 0 )  return;
+
+            // do some quick box tests.
+            var minPt = this.getMinPoint(),
+                    maxPt = this.getMaxPoint();
+
+            if (maxPt[0] < plane._rect.getLeft())     return;
+            if (minPt[0] > plane._rect.getRight())    return;
+
+            if (maxPt[1] < plane._rect.getTop())      return;
+            if (minPt[1] > plane._rect.getBottom())   return;
+
+            if (minPt[2] > plane.getZMax())           return;
+
+            // get the boundary points for the plane
+            var boundaryPts = plane.getBoundaryPoints();
+
+            // get the points and direction vector for the current line
+            var pt0 = this.getPoint0(),  pt1 = this.getPoint1();
+            //var lineDir = pt1.subtract( pt0 );
+            var lineDir = vecUtils.vecSubtract(3, pt1, pt0);
+
+            // intersect with the front plane
+            var planeEq = plane.getPlaneEq();
+            var t = MathUtils.vecIntersectPlaneForParam( pt0, lineDir, planeEq );
+            if (t != undefined)
+            {
+                if ((MathUtils.fpSign(t) >= 0) && (MathUtils.fpCmp(t,1.0) <= 0))
+                {
+                    // get the intersection point
+                    var pt = MathUtils.interpolateLine3D( pt0, pt1, t );
+
+                    // 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() );
+                    if (contains == MathUtils.INSIDE)
+                    {
+                        // add the intersection
+                        var dot = MathUtils.dot3( pt0, planeEq ) + planeEq[3];
+                        var deltaVis = (dot > 0) ? 1 : -1;
+//                                      if (plane.isBackFacing())
+//                        deltaVis = (dot < 0) ? 1 : -1;
+
+                        this.addIntersection( plane, t, deltaVis );
+                    }
+                    else if (contains == MathUtils.ON)
+                    {
+                        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())
+                            {
+                                if (sign < 0)
+                                    this.addIntersection( plane, t, 1 );
+                            }
+                            else
+                            {
+                                if (sign > 0)
+                                    this.addIntersection( plane, t, -1 );
+                            }
+                        }
+                    }
+                }
+            }
+            else
+            {
+                // the line must be parallel to the plane.  If the line is in the plane,
+                // we need to do some special processing
+                var d0 = vecUtils.vecDot(3, planeEq, pt0) + planeEq[3],
+                        d1 = vecUtils.vecDot(3, planeEq, pt1) + planeEq[3];
+                if ((MathUtils.fpSign(d0) == 0) && (MathUtils.fpSign(d1) == 0))
+                    this.doCoplanarIntersection( plane );
+            }
+
+            // intersect with the 4 planes formed by the edges of the plane, going back in Z
+            var bPt1 = boundaryPts[3];
+            for (var i=0;  i<4;  i++)
+            {
+                // get the 2 points that define the front edge of the plane
+                var bPt0 = bPt1;
+                var bPt1 = boundaryPts[i];
+
+                // calculate the plane equation.  The normal should point towards the OUTSIDE of the boundary
+                //var vec = bPt1.subtract( bPt0 );
+                var vec = vecUtils.vecSubtract(3, bPt1, bPt0);
+                if (plane.isBackFacing())
+                    MathUtils.negate( vec );
+                planeEq = Vector.create( [-vec[1], vec[0], 0] );
+                var normal = Vector.create( [planeEq[0], planeEq[1], planeEq[2]] );
+//                      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!
+                    {
+                        // get the intersection point
+                        var pt = MathUtils.interpolateLine3D( pt0, pt1, t );
+
+                        // we need to get the parameter on the edge of the projection
+                        // of the intersection point onto the line.
+                        var index = (Math.abs(vec[0]) > Math.abs(vec[1])) ? 0 : 1;
+                        var tEdge = (pt[index] - bPt0[index])/(bPt1[index] - bPt0[index]);
+                        if ((MathUtils.fpSign(tEdge) > 0) && (MathUtils.fpCmp(tEdge,1.0) <= 0))
+                        {
+                            var edgePt = MathUtils.interpolateLine3D( bPt0, bPt1, tEdge );
+                            if (MathUtils.fpCmp(pt[2],edgePt[2]) < 0)
+                            {
+                                // add the intersection
+                                var deltaVis = MathUtils.dot(lineDir,normal) > 0 ? -1 : 1;
+                                this.addIntersection( plane, t, deltaVis );
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+
+        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);
+