Merge branch 'refs/heads/master' into dom-architecture

Conflicts:
	js/io/system/ninjalibrary.json

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

2 files changed, 86 insertions, 73 deletions

diff --git a/js/helper-classes/3D/snap-manager.js b/js/helper-classes/3D/snap-manager.js
index e22ac3ad..0f456e1e 100755
--- a/js/helper-classes/3D/snap-manager.js
+++ b/js/helper-classes/3D/snap-manager.js
@@ -223,64 +223,22 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
                                 else
                                         parentPt = [xScreen, yScreen, 0.0];
 
-                var eyePt = [];
-                                var vec = viewUtils.parentToChildVec(parentPt, stage, eyePt);
-                                if (vec)
-                                {
-                                        // activate the drag working plane
-                                        if (!snap3D && this.hasDragPlane())
-                                                this.activateDragPlane();
-
-                                        // project to the working plane
-                                        var currentWorkingPlane = workingPlane.slice(0);
-                                        var wp = currentWorkingPlane.slice(0);
-                                        var mat = viewUtils.getMatrixFromElement(stage);
-                                        wp = MathUtils.transformPlane(wp, mat);
-                                        var projPt = MathUtils.vecIntersectPlane(eyePt, vec, wp);
-                                        if (projPt)
-                                        {
-                                                // the local point gets stored in the coordinate space of the plane
-                                                var wpMat = drawUtils.getPlaneToWorldMatrix(currentWorkingPlane, MathUtils.getPointOnPlane(currentWorkingPlane));
-                                                projPt[3] = 1.0;
-                                                //var planeToViewMat = mat.multiply(wpMat);
-                                                var planeToViewMat = glmat4.multiply(mat, wpMat, []);
-                                                //var viewToPlaneMat = planeToViewMat.inverse();
-                                                var viewToPlaneMat = glmat4.inverse( planeToViewMat, [] );
-                                                var planePt = projPt.slice(0);
-                                                planePt[3] = 1.0;
-                                                //planePt = viewToPlaneMat.multiply(planePt);
-                                                planePt = glmat4.multiplyVec3( viewToPlaneMat, planePt );
-
-                                                // get the screen position of the projected point
-                                                viewUtils.setViewportObj(stage);
-                                                var offset = viewUtils.getElementOffset(stage);
-                                                offset[2] = 0;
-                                                var scrPt = viewUtils.viewToScreen(projPt);
-                                                //scrPt = scrPt.add(offset);
-                                                scrPt = vecUtils.vecAdd(3, scrPt, offset);
-
-                                                // create the hit record
-                                                var hitRec = Object.create(HitRecord);//new HitRecord();
-                                                hitRec.setLocalPoint(planePt);
-                                                hitRec.setPlaneMatrix( wpMat );
-                                                hitRec.setScreenPoint(scrPt);
-                                                hitRec.setPlane(currentWorkingPlane);
-                                                hitRec.setType( hitRec.SNAP_TYPE_STAGE );
-                                                hitRec.setElt( stage );
-                                                if (quadPt)  hitRec.setUseQuadPoint( true );
-
-                                                // try snapping to the 3D grid, or to the stage boundaries if the grid is not displayed
-                                                if (this.gridSnapEnabled())
-                                                        this.snapToGrid( hitRec );
-
-                                                // save the hit record
-                                                hitRecArray.push( hitRec );
-
-                                                // restore the original working plane
-                                                if (!snap3D && this.hasDragPlane())
-                                                        this.deactivateDragPlane();
-                                        }
-                                }
+                                if (!snap3D && this._hasDragPlane)
+                                        this.activateDragPlane();
+
+                                var hitRec = this.snapToStage( parentPt,  quadPt );
+
+                                // try snapping to the 3D grid, or to the stage boundaries if the grid is not displayed
+                                if (this.gridSnapEnabled())
+                                        this.snapToGrid( hitRec );
+
+                                // save the hit record
+                                hitRecArray.push( hitRec );
+
+                                // restore the original working plane
+                                if (!snap3D && this.hasDragPlane())
+                                        this.deactivateDragPlane();
+
                         }       //if (hitRecArray.length == 0)
 
                         var rtnHit;
@@ -305,6 +263,62 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
                 }
         },
 
+        snapToStage:
+        {
+                value: function( scrPt,  quadPt )
+                {
+                        var stage = this.getStage();
+                        var l2g = viewUtils.getLocalToGlobalMatrix( stage );
+                        var g2l = glmat4.inverse( l2g, [] );
+
+                        var pt0 = scrPt.slice(),  pt1 = scrPt.slice();
+                        pt0[2] = 0.0;   pt1[2] = 10;
+
+                        var localPt0 = MathUtils.transformAndDivideHomogeneousPoint( pt0, g2l ),
+                                localPt1 = MathUtils.transformAndDivideHomogeneousPoint( pt1, g2l );
+
+                        var stageWorldPt0 = viewUtils.localToStageWorld( localPt0, stage ),
+                                stageWorldPt1 = viewUtils.localToStageWorld( localPt1, stage );
+                        var vec = vecUtils.vecSubtract( 3,  stageWorldPt1, stageWorldPt0 );
+                        
+                        var ptOnWorkingPlane = MathUtils.vecIntersectPlane(stageWorldPt0, vec, workingPlane);
+
+                        var wpMat = drawUtils.getPlaneToWorldMatrix(workingPlane, MathUtils.getPointOnPlane(workingPlane)),
+                                wpMatInv = glmat4.inverse( wpMat, [] );
+                        var localPt = MathUtils.transformPoint( ptOnWorkingPlane, wpMatInv );
+
+                        // create the hit record
+                        var hitRec = Object.create(HitRecord);
+                        hitRec.setLocalPoint( localPt );
+                        hitRec.setPlaneMatrix( wpMat );
+                        hitRec.setScreenPoint(scrPt);
+                        hitRec.setPlane(workingPlane);
+                        hitRec.setType( hitRec.SNAP_TYPE_STAGE );
+                        hitRec.setElt( stage );
+                        if (quadPt)  hitRec.setUseQuadPoint( true );
+
+                        // DEBUG CODE
+                        // check that the point is on the working plane
+                        var tmpStageWorldPt = hitRec.calculateStageWorldPoint();
+                        var err = vecUtils.vecDot(3, tmpStageWorldPt, workingPlane) + workingPlane[3];
+                        if (MathUtils.fpSign(err) !== 0)
+                                console.log( "snapToStage (function) not on working plane: " + err );
+                        //////////////////////////////////////////////////////////////////////
+
+                        var calculatedScreenPt = hitRec.calculateScreenPoint();
+                        hitRec.setScreenPoint(calculatedScreenPt);
+
+                        // DEBUG CODE
+                        // check that the point is on the working plane
+                        var err2 = vecUtils.vecDist(2,  calculatedScreenPt, scrPt );
+                        if (MathUtils.fpSign(err2) !== 0)
+                                console.log( "snapToStage (function) error in screen point: " + err2 );
+                        //////////////////////////////////////////////////////////////////////
+
+                        return hitRec;
+                }
+        },
+
         snapToGrid : {
                 value: function( hitRec )
                 {
@@ -1791,8 +1805,8 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
                                                 hSnap.setScreenPoint( scrPt );
                                                 hSnap.setType( hSnap.SNAP_TYPE_ALIGN_MERGED );
                                                 hSnap.setElement( stage );
-                                                hSnap.setPlane( [0,0,1,0] );
-                                                hSnap.setPlaneMatrix( Matrix.I(4) );
+                                                //hSnap.setPlane( [0,0,1,0] );
+                                                //hSnap.setPlaneMatrix( Matrix.I(4) );
                                                 if (vSnap.hasAssociatedScreenPoint() )
                                                         hSnap.setAssociatedScreenPoint( vSnap.getAssociatedScreenPoint() );
                                                 if (vSnap.hasAssociatedScreenPoint2() )
@@ -1840,8 +1854,8 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
                                                 hSnap.setScreenPoint( scrPt );
                                                 hSnap.setType( hSnap.SNAP_TYPE_ALIGN_MERGED );
                                                 hSnap.setElement( stage );
-                                                hSnap.setPlane( [0,0,1,0] );
-                                                hSnap.setPlaneMatrix( Matrix.I(4) );
+                                                //hSnap.setPlane( [0,0,1,0] );
+                                                //hSnap.setPlaneMatrix( Matrix.I(4) );
                                                 if (vSnap.hasAssociatedScreenPoint() )
                                                         hSnap.setAssociatedScreenPoint( vSnap.getAssociatedScreenPoint() );
                                                 if (vSnap.hasAssociatedScreenPoint2() )
@@ -1895,8 +1909,8 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
                                                         hSnap.setScreenPoint( scrPt );
                                                         hSnap.setType( hSnap.SNAP_TYPE_ALIGN_MERGED );
                                                         hSnap.setElement( stage );
-                                                        hSnap.setPlane( [0,0,1,0] );
-                                                        hSnap.setPlaneMatrix( Matrix.I(4) );
+                                                        //hSnap.setPlane( [0,0,1,0] );
+                                                        //hSnap.setPlaneMatrix( Matrix.I(4) );
                                                         if (vSnap.hasAssociatedScreenPoint() )
                                                                 hSnap.setAssociatedScreenPoint( vSnap.getAssociatedScreenPoint() );
                                                         if (vSnap.hasAssociatedScreenPoint2() )
@@ -1937,6 +1951,8 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
                         //this._globalToStageWorldMat = this._stageWorldToGlobalMat.inverse();
                         this._globalToStageWorldMat = glmat4.inverse( this._stageWorldToGlobalMat, [] );
 
+                        //console.log( "setupDragPlane: " + this._dragPlane );
+
                         // load the 2D elements
                         this.load2DCache( this._dragPlane );
                 }
@@ -2028,7 +2044,7 @@ var SnapManager = exports.SnapManager = Montage.create(Component, {
                                         var z = s0[2];