First commit of Ninja to ninja-internal

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

1 files changed, 1342 insertions, 0 deletions

diff --git a/js/helper-classes/3D/view-utils.js b/js/helper-classes/3D/view-utils.js
new file mode 100644
index 00000000..c8e20def
--- /dev/null
+++ b/js/helper-classes/3D/view-utils.js
@@ -0,0 +1,1342 @@
+/* <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> */
+
+var vecUtils = require("js/helper-classes/3D/vec-utils").VecUtils,
+    snapManagerModule = require("js/helper-classes/3D/snap-manager"),
+    Rectangle = require("js/helper-classes/3D/rectangle").Rectangle,
+    ElementsMediator = require("js/mediators/element-mediator").ElementMediator;
+///////////////////////////////////////////////////////////////////////
+// Class ViewUtils
+//      Viewing Utility functions
+///////////////////////////////////////////////////////////////////////
+var ViewUtils = exports.ViewUtils = Object.create(Object.prototype,
+{
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+
+    m_viewportObj : { value: null, writable: true},
+    _perspectiveDist: { value: null, writable: true},
+
+    // keep a stack of viewport objects
+    _viewportObjStack: { value: [], writable: true },
+
+    _currentDocument: { value: null , writable: true},
+    _userContentLeft: { value: null , writable: true},
+    _userContentTop: { value: null , writable: true},
+
+    _rootElement: { value: null, writable: true},
+    _stageElement: { value: null, writable: true},
+
+    ///////////////////////////////////////////////////////////////////////
+    // Property accessors
+    ///////////////////////////////////////////////////////////////////////
+    setViewportObj: {
+        value: function( vp ) {
+            this.m_viewportObj = vp;
+            this._perspectiveDist = 1400;
+
+            var dist = this.getPerspectiveDistFromElement( vp );
+            var mode = this.getPerspectiveModeFromElement( vp );
+        }
+    },
+    getViewportObj: { value: function()                 {  return this.m_viewportObj;   } },
+
+    setRootElement: { value: function( elt )            { this._rootElement = elt; } },
+    getRootElement: { value: function ()                { return this._rootElement;        } },
+
+    setStageElement: { value: function( elt )    {  this._stageElement = elt;    } },
+    getStageElement: { value: function () { return this._stageElement; } },
+
+    setCurrentDocument: { value: function(value) { this._currentDocument = value; }},
+
+    setUserContentLeft: { value: function(value) { this._userContentLeft = value; }},
+    setUserContentTop: { value: function(value) { this._userContentTop = value; }},
+
+
+    getPerspectiveDistance: { value: function () { return this._perspectiveDist; } },
+
+    ///////////////////////////////////////////////////////////////////////
+    // Camera and View Methods
+    ///////////////////////////////////////////////////////////////////////
+    getMatrixFromElement: {
+        value: function( elt ) {
+            var mat = ElementsMediator.getMatrix(elt);
+            if(mat)
+            {
+                return mat;
+            }
+            else
+            {
+                return Matrix.I(4);
+            }
+        }
+    },
+
+    setMatrixForElement: {
+        value: function( elt, mat, isChanging ) {
+            ElementsMediator.setMatrix(elt, mat, isChanging);
+        }
+    },
+
+
+    elementHas3D: {
+        value: function( elt ) {
+            return ElementsMediator.has3D(elt);
+        }
+    },
+
+    getElementPlane: {
+        value: function( elt ) {
+            var bounds = this.getElementViewBounds3D( elt );
+            var xArr = new Array(),  yArr = new Array(),  zArr = new Array();
+            for (var j=0;  j<4;  j++)
+            {
+                var pt = this.localToGlobal( bounds[j],  elt );
+                xArr.push(pt[0]);  yArr.push(pt[1]);  zArr.push(pt[2]);
+            }
+            var normal = MathUtils.getPolygonNormal( 4, xArr, yArr, zArr );
+            //var d = -MathUtils.dot3( bounds[0], normal );
+            var d = -MathUtils.dot3( [xArr[0],yArr[0],zArr[0]], normal );
+            normal[3] = d;
+
+            return normal;
+        }
+    },
+
+    getUnprojectedElementPlane: {
+        value: function( elt ) {
+            var mat = this.getMatrixFromElement(elt);
+            var plane = [mat[8],  mat[9],  mat[10],  mat[11]];
+
+            // The translation value is a point on the plane
+            this.pushViewportObj( elt );
+            var ptOnPlane = this.getCenterOfProjection();
+            this.popViewportObj();
+
+            ptOnPlane[2] = 0;
+
+            ptOnPlane = this.localToStageWorld(ptOnPlane, elt);
+            plane[3] = -vecUtils.vecDot(3, plane, ptOnPlane );
+
+            return plane;
+        }
+    },
+
+    getNormalToUnprojectedElementPlane: {
+        value: function( elt ) {
+            var mat = this.getMatrixFromElement(elt);
+
+            var xVec = [mat[0],  mat[1],  mat[2],  mat[3]];
+            var yVec = [mat[4],  mat[5],  mat[6],  mat[7]];
+
+            var stage = snapManagerModule.SnapManager.getStage();
+            var stageMat = this.getMatrixFromElement(stage);
+            var stagePlane = [stageMat[8],  stageMat[9],  stageMat[10],  stageMat[11]];
+
+            var xDot = Math.abs(vecUtils.vecDot(3, xVec, stagePlane));
+            var yDot = Math.abs(vecUtils.vecDot(3, yVec, stagePlane));
+
+            var plane;
+            if(xDot > yDot)
+            {
+                plane = xVec;
+            }
+            else
+            {
+                plane = yVec;
+            }
+
+            // The translation value is a point on the plane
+            this.pushViewportObj( elt );
+            var ptOnPlane = this.getCenterOfProjection();
+            this.popViewportObj();
+
+            ptOnPlane[2] = 0;
+
+            ptOnPlane = this.localToStageWorld(ptOnPlane, elt);
+            plane[3] = -vecUtils.vecDot(3, plane, ptOnPlane );
+
+            return plane;
+        }
+    },
+
+    getPerspectiveModeFromElement: {
+        value: function( elt ) {
+            return ElementsMediator.getPerspectiveMode(elt);
+        }
+    },
+
+    getPerspectiveDistFromElement: {
+        value: function( elt ) {
+            return ElementsMediator.getPerspectiveDist(elt);
+        }
+    },
+
+    getEyePoint: {
+        value:function() {
+            // this function should use the center of projection - it is currently hard wired to (0,0).
+            var eye = [0, 0, this._perspectiveDist];
+
+            return eye;
+        }
+    },
+
+    getCameraMatrix: {
+        value: function() {
+            return this.getMatrixFromElement( this.m_viewportObj );
+        }
+    },
+
+    getElementViewBounds3D: {
+        value: function( elt ) {
+            var bounds = this.getElementBounds( elt, true );
+            var ptArray = new Array();
+            for (var i=0;  i<4;  i++)
+            {
+                var pt = bounds.getPoint( i );
+                pt[2] = 0; // z == 0
+                ptArray.push( pt );
+            }
+
+            return ptArray;
+        }
+    },
+
+    getCenterOfProjection: {
+        value: function() {
+            var cop;
+            var vp = this.getViewportObj();
+            if (vp)
+            {
+                var bounds = this.getViewportBounds();
+                cop = bounds.getCenter();
+                //cop = Vector.create( [bounds.getRight(), bounds.getBottom()] );
+            }
+
+            return cop;
+        }
+    },
+
+    preToPostScreen: {
+        value: function( pt, elt ) {
+            this.pushViewportObj( elt );
+            var viewPt = this.screenToView( pt[0], pt[1], pt[2] );
+            var mat = this.getMatrixFromElement( elt );
+            var worldPt = MathUtils.transformPoint( viewPt, mat );
+            var screenPt = this.viewToScreen( worldPt );
+            this.popViewportObj