First commit of Ninja to ninja-internal

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

1 files changed, 1104 insertions, 0 deletions

diff --git a/js/helper-classes/3D/math-utils.js b/js/helper-classes/3D/math-utils.js
new file mode 100644
index 00000000..49c77c41
--- /dev/null
+++ b/js/helper-classes/3D/math-utils.js
@@ -0,0 +1,1104 @@
+/* <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 Utils
+//      Math Utility functions
+///////////////////////////////////////////////////////////////////////
+var VecUtils = require("js/helper-classes/3D/vec-utils").VecUtils;
+
+var MathUtilsClass = exports.MathUtilsClass = Object.create(Object.prototype, {
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+//    VecUtils: { value: null, writable: true },
+    
+    EPSILON: { value: 1.e-5, writable: true },
+
+    // these are used in containment tests
+    INSIDE: { value: -1, writable: true },
+    ON: { value: 0, writable: true },
+    OUTSIDE: { value: 1, writable: true },
+
+    PI2: { value: 2*Math.PI, writable: true },
+    RAD_TO_DEG: { value: 180/Math.PI, writable: true },
+    DEG_TO_RAD: { value: Math.PI/180, writable: true },
+
+    ///////////////////////////////////////////////////////////////////////
+    // Property accessors
+    ///////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////
+    // Vector Methods
+    ///////////////////////////////////////////////////////////////////////
+
+        vecIntersectPlaneForParam: {
+        value: function( pt0, vec, plane )
+        {
+            // declare the variable to return - undefined when there is no solution
+            var param;
+
+            var     a = plane[0],  b = plane[1], c = plane[2], d = plane[3];
+            var     dx = vec[0],  dy = vec[1],  dz = vec[2];
+            var     x0 = pt0[0],  y0 = pt0[1],  z0 = pt0[2];
+
+            var numerator = -(a*x0 + b*y0 + c*z0 + d);
+            var denominator = a*dx + b*dy + c*dz;
+
+            var rtnPt;
+            if (this.fpSign(denominator) != 0)
+                param = numerator / denominator;
+
+            return param;
+        }
+    },
+
+        vecMag3: {
+        value: function( vec )
+        {
+            if (vec.length < 3)  return;
+            var mag = vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2];
+            mag = Math.sqrt( mag );
+            return mag;
+        }
+    },
+
+        vecMag: {
+        value: function( dimen, vec )
+        {
+            var sum = 0.0;
+            for (var i=0;  i<dimen;  i++)
+                sum += vec[i]*vec[i];
+            return Math.sqrt( sum );
+        }
+    },
+
+        vecSubtract: {
+        value: function( a, b )
+        {
+            var rtnVec;
+            var n = a.length;
+            if (b.length < n)  n = b.length;
+            if (n > 0)
+            {
+                rtnVec = Vector.create([0]);
+                for (var i=0;  i<n;  i++)
+                    rtnVec[i] = a[i] - b[i];
+            }
+
+            return rtnVec;
+        }
+    },
+
+        vecAdd: {
+        value: function( a, b )
+        {
+            var rtnVec;
+            var n = a.length;
+            if (b.length < n)  n = b.length;
+            if (n > 0)
+            {
+                rtnVec = Vector.create([0]);
+                for (var i=0;  i<n;  i++)
+                    rtnVec[i] = a[i] + b[i];
+            }
+
+            return rtnVec;
+        }
+    },
+
+        vecDist: {
+        value: function( a, b )
+        {
+            var sum;
+            var n = a.length;
+            if (b.length < n)  n = b.length;
+            if (n > 0)
+            {
+                var sum = 0.0;
+                for (var i=0;  i<n;  i++)
+                {
+                    var d = a[i] - b[i];
+                    sum += d*d;
+                }
+
+                sum = Math.sqrt( sum );
+            }
+
+            return sum;
+        }
+    },
+
+    vecIntersectPlane: {
+        value: function( pt0, vec, plane )
+        {
+            // declare the return point.  May be undefined in ill-conditioned cases.
+            var rtnPt;
+
+            var t = this.vecIntersectPlaneForParam( pt0, vec, plane );
+            if (t != undefined)
+            {
+                var     x0 = pt0[0],  y0 = pt0[1],  z0 = pt0[2];
+                var     dx = vec[0],  dy = vec[1],  dz = vec[2];
+                rtnPt = Vector.create( [x0 + t*dx,
+                    y0 + t*dy,
+                    z0 + t*dz] );
+            }
+
+            return rtnPt;
+        }
+    },
+
+        getPointOnPlane: {
+        value: function( plane )
+        {
+            // abreviate the plane equation
+            var a = plane[0],  b = plane[1],  c = plane[2],  d = plane[3];
+
+            var x = 0.0,  y = 0.0,  z = 0.0;
+            if ( Math.abs(plane[0]) > Math.abs(plane[1]) )
+            {
+                if ( Math.abs(plane[0]) > Math.abs(plane[2]) )
+                    x = -d/a;
+                else
+                    z = -d/c;
+            }
+            else
+            {
+                if (Math.abs(plane[1]) > Math.abs(plane[2]) )
+                    y = -d/b;
+                else
+                    z = -d/c;
+            }
+
+            // get the point on the plane
+            return [x, y, z];
+        }
+    },
+
+        transformPlane: {
+        value: function( plane,  mat )
+        {
+            // we will project a point down one of the coordinate axes to find a point on the plane
+            // that point and the normal to the plane will be transformed by the matrix, and the 'd'
+            // component of the plane equation will be reset using the new normal and point.
+
+            // find a point on the plane
+            var ptOnPlane = this.getPointOnPlane(plane);
+
+            ptOnPlane[3] = 1.0; // 4 dimen so we can transform it
+
+            // transform the point
+            //ptOnPlane = mat.multiply( ptOnPlane );
+            ptOnPlane = glmat4.multiplyVec3(mat, ptOnPlane, []);
+            plane = this.transformVector( plane, mat );
+            plane[3] = -this.dot3(plane, ptOnPlane );
+
+            return plane;
+        }
+    },
+
+        transformHomogeneousPoint: {
+        value: function( srcPt, mat )
+        {
+            var pt = srcPt.slice(0);
+            this.makeDimension4( pt );
+            var x = VecUtils.vecDot(4,  pt, [mat[0], mat[4], mat[ 8], mat[12]] ),
+                    y = VecUtils.vecDot(4,  pt, [mat[1], mat[5], mat[ 9], mat[13]] ),
+                    z = VecUtils.vecDot(4,  pt, [mat[2], mat[6], mat[10], mat[14]] ),
+                    w = VecUtils.vecDot(4,  pt, [mat[3], mat[7], mat[11], mat[15]] );
+
+            return [x, y, z, w];
+        }
+    },
+
+        applyHomogeneousCoordinate: {
+        value: function( hPt )
+        {
+            var w = hPt[3];
+            hPt[0] /= w;
+            hPt[1] /= w;
+            hPt[2] /= w;
+            hPt[3]  = 1;
+
+            return hPt;
+        }
+    },
+
+        transformAndDivideHomogeneousPoint: {
+        value: function( pt, mat )
+        {
+            return this.applyHomogeneousCoordinate( this.transformHomogeneousPoint(pt, mat) );