First commit of Ninja to ninja-internal

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

1 files changed, 637 insertions, 0 deletions

diff --git a/js/tools/Rotate3DToolBase.js b/js/tools/Rotate3DToolBase.js
new file mode 100644
index 00000000..6e17864b
--- /dev/null
+++ b/js/tools/Rotate3DToolBase.js
@@ -0,0 +1,637 @@
+/* <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> */
+
+/* Base class for the 3D rotation tools
+Subclass RotateObject3DTool will rotate the object that was clicked.
+Subclass RotateStage3DTool will rotate the stage.
+ */
+var Montage = require("montage/core/core").Montage,
+    ModifierToolBase = require("js/tools/modifier-tool-base").ModifierToolBase,
+    snapManager = require("js/helper-classes/3D/snap-manager").SnapManager,
+    viewUtils = require("js/helper-classes/3D/view-utils").ViewUtils,
+    vecUtils = require("js/helper-classes/3D/vec-utils").VecUtils,
+    drawUtils = require("js/helper-classes/3D/draw-utils").DrawUtils,
+    ElementsMediator = require("js/mediators/element-mediator").ElementMediator;
+
+exports.Rotate3DToolBase = Montage.create(ModifierToolBase, {
+        _canSnap: { value: false },
+
+    _inLocalMode: { value: true, enumerable: true },
+
+    drawWithoutSnapping:
+    {
+        value: function(event)
+        {
+            if(this._handleMode !== null)
+            {
+                this._matL = this._handles[this._handleMode]._matL.slice(0);
+                this._planeEq = this._handles[this._handleMode]._planeEq.slice(0);
+                this._dirVecL = this._handles[this._handleMode]._dirVecL.slice(0);
+                this._startPoint = MathUtils.getLocalPoint(this.downPoint.x,
+                                                            this.downPoint.y,
+                                                            this._planeEq,
+                                                            this._matL);
+                if(!this._startPoint)
+                {
+                    this._startPoint = [this.downPoint.x, this.downPoint.y];
+                }
+            }
+        }
+    },
+
+    modifyElements: {
+        value: function(data, event) {
+            var mat,
+                angle,
+                pt0 = data.pt0,
+                pt1 = data.pt1;
+
+            if(this._handleMode !== null)
+            {
+                if(this._activateOriginHandle)
+                {
+                    // move the transform origin handle
+                    var dx = pt1.x - pt0.x;
+                    var dy = pt1.y - pt0.y;
+                    this._origin[0] += dx;
+                    this._origin[1] += dy;
+
+                    var len = this._targets.length;
+                    if(len === 1)
+                    {
+                        this._startOriginArray[0][0] += dx;
+                        this._startOriginArray[0][1] += dy;
+                    }
+                    this.downPoint.x = pt1.x;
+                    this.downPoint.y = pt1.y;
+                    this.DrawHandles();
+                    return;
+                }
+
+                angle = this._getAngleToRotate(pt1.x, pt1.y);
+                if(event.shiftKey)
+                {
+                    var f = Math.floor(angle/(Math.PI/4));
+                    angle = f*Math.PI/4;
+                }
+                this._delta = angle;
+                switch(this._handleMode)
+                {
+                    case 0:
+                        // Rotate X;
+                        mat = Matrix.RotationX(angle);
+                        break;
+                    case 1:
+                        // Rotate Y
+                        mat = Matrix.RotationY(angle);
+                        break;
+                    case 2:
+                        // Rotate Z
+                        mat = Matrix.RotationZ(angle);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            else
+            {
+                if (event.ctrlKey || event.metaKey)
+                {
+                    var zAngle = this._mouseSpeed * (pt1.y - this.downPoint.y) * Math.PI / 180.0;
+                    if (zAngle === 0)
+                    {
+                        zAngle = 0.01 * Math.PI / 180.0;
+                    }
+                    if(event.shiftKey)
+                    {
+                        var f = Math.floor(zAngle/(Math.PI/4));
+                        zAngle = f*Math.PI/4;
+                    }
+                    mat = Matrix.RotationZ(zAngle);
+                }
+                else
+                {
+                    var yAngle = this._mouseSpeed * (pt1.x - this.downPoint.x) * Math.PI / 180.0;
+                    var xAngle = -this._mouseSpeed * (pt1.y - this.downPoint.y) * Math.PI / 180.0;
+                    if(event.shiftKey)
+                    {
+                        var f = Math.floor(yAngle/(Math.PI/4));
+                        yAngle = f*Math.PI/4;
+                        f = Math.floor(xAngle/(Math.PI/4));
+                        xAngle = f*Math.PI/4;
+                    }
+
+                    // check the orientation of the X axis
+                    //if (drawUtils.drawYZ)  xAngle = -xAngle;
+                    var yMat  = Matrix.RotationY( yAngle ),
+                        xMat  = Matrix.RotationX( xAngle );
+
+                    mat = glmat4.multiply(yMat, xMat, []);
+                }
+            }
+
+            if(this._inLocalMode && (this._targets.length === 1) )
+            {
+                this._rotateLocally(mat);
+            }
+            else
+            {
+                this._rotateGlobally(mat);
+            }
+
+//            this.UpdateSelection();
+            NJevent("elementChanging", {type : "Changing", redraw: false});
+        }
+    },
+
+    _rotateLocally: {
+        value: function (rotMat) {
+            var len = this._targets.length;
+            for(var i = 0; i < len; i++)
+            {
+                var item = this._targets[i];
+                var elt = item.elt;
+                var curMat = item.mat;
+
+                // pre-translate by the transformation center
+                var tMat = Matrix.I(4);
+
+                var transformCtr = this._startOriginArray[i];
+
+                tMat[12] = transformCtr[0];
+                tMat[13] = transformCtr[1];
+                tMat[14] = transformCtr[2];
+
+                var mat = glmat4.multiply(curMat, tMat, []);
+
+                // translate back
+                tMat[12] = -transformCtr[0];
+                tMat[13] = -transformCtr[1];
+                tMat[14] = -transformCtr[2];
+
+                glmat4.multiply(mat, rotMat, mat);
+
+
+                glmat4.multiply(mat, tMat, mat);
+
+                // while moving, set inline style to improve performance
+                viewUtils.setMatrixForElement( elt, mat, true );
+            }
+        }
+    },
+
+    _rotateGlobally: {
+        value: function (rotMat) {
+            var len = this._targets.length;
+            for(var i = 0; i < len; i++)
+            {
+                var item = this._targets[i];
+                var elt = item.elt;
+                var curMat = item.mat;
+
+                // pre-translate by the transformation center
+                var tMat = Matrix.I(4);
+
+                var transformCtr = this._startOriginArray[i].slice(0);
+                transformCtr = MathUtils.transformPoint(transformCtr, curMat);
+
+                tMat[12] = transformCtr[0];
+                tMat[13] = transformCtr[1];
+                tMat[14] = transformCtr[2];
+
+                var mat = glmat4.multiply(tMat, rotMat, []);
+
+                // translate back
+                tMat[12] = -transformCtr[0];
+                tMat[13] = -transformCtr[1];
+                tMat[14] = -transformCtr[2];
+
+                glmat4.multiply(mat, tMat, mat);
+
+                glmat4.multiply(mat, curMat, mat);
+
+                viewUtils.setMatrixForElement( elt, mat, true );
+            }
+        }
+    },
+
+    _getAngleToRotate: {
+        value: function (x, y) {
+            var angle;
+            var pt = MathUtils.getLocalPoint(x, y, this._planeEq, this._matL);
+            if(!pt)
+            {
+                //TODO - should this be _startPoint.x/y instead of downPoint.x/y?
+                var st = [this.downPoint.x, this.downPoint.y];
+                pt = [x, y];
+                var sub = vecUtils.vecSubtract(2, pt, st);
+                var dot = vecUtils.vecDot(2, sub, this._dirVecL);
+
+                angle = vecUtils.vecDist(2, pt, st) * 0.1;
+
+                if (dot < 0)
+                {
+                    an