First commit of Ninja to ninja-internal

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

1 files changed, 1671 insertions, 0 deletions

diff --git a/js/helper-classes/RDGE/GLSubpath.js b/js/helper-classes/RDGE/GLSubpath.js
new file mode 100644
index 00000000..25b12093
--- /dev/null
+++ b/js/helper-classes/RDGE/GLSubpath.js
@@ -0,0 +1,1671 @@
+/* <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;
+
+
+function SubpathOffsetPoint(pos, mapPos) {
+    this.Pos = Vector.create([pos[0],pos[1],pos[2]]);
+    this.CurveMapPos = Vector.create([mapPos[0], mapPos[1], mapPos[2]]);
+}
+
+function SubpathOffsetTriangle(v0, v1, v2) {
+    this.v0 = v0;
+    this.v1 = v1;
+    this.v2 = v2;
+    this.n = Vector.create([0,0,1]); //replace with the actual cross product later
+}
+
+function sortNumberAscending(a,b){
+    return a-b;
+}
+function sortNumberDescending(a,b){
+    return b-a;
+}
+function SegmentIntersections(){
+    this.paramArray = [];
+}
+
+///////////////////////////////////////////////////////////////////////
+// Class GLSubpath
+//      representation a sequence of cubic bezier curves.
+//      Derived from class GLGeomObj
+///////////////////////////////////////////////////////////////////////
+function GLSubpath() {
+    ///////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////
+    this._Anchors = [];
+    this._BBoxMin = [0, 0, 0];
+    this._BBoxMax = [0, 0, 0];
+    this._isClosed = false;
+
+    this._samples = [];                 //polyline representation of this curve
+    this._sampleParam = [];            //parametric distance of samples, within [0, N], where N is # of Bezier curves (=# of anchor points if closed, =#anchor pts -1 if open)
+    this._anchorSampleIndex = [];       //index within _samples corresponding to anchor points
+    
+    this._UnprojectedAnchors = [];
+
+    //offset path samples and the points on the input path they map to
+    this._offsetPointsLeft = [];
+    this._offsetPointsRight = [];
+
+    //triangles determined by the offset points
+    this._offsetTrianglesLeft = [];
+    this._offsetTrianglesRight = [];
+
+    //initially set the _dirty bit so we will construct samples
+    this._dirty = true;
+
+    //whether or not to use the canvas drawing to stroke/fill
+    this._useCanvasDrawing = true;
+
+    //the X and Y location of this subpath's canvas in stage world space of Ninja
+    this._canvasX = 0;
+    this._canvasY = 0;
+
+    //stroke information
+    this._strokeWidth = 0.0;
+    this._strokeColor = [0.4, 0.4, 0.4, 1.0];
+    this._strokeMaterial;
+    this._strokeStyle = "Solid";
+    this._materialAmbient = [0.2, 0.2, 0.2, 1.0];
+    this._materialDiffuse = [0.4, 0.4, 0.4, 1.0];
+    this._materialSpecular = [0.4, 0.4, 0.4, 1.0];
+    this._fillColor = [0.4, 0.4, 0.4, 1.0];
+    this._fillMaterial;
+    this._DISPLAY_ANCHOR_RADIUS = 5;
+    //drawing context
+    this._world = null;
+
+    //tool that owns this subpath
+    this._drawingTool = null;
+    this._planeMat = null;
+    this._planeMatInv = null;
+    this._planeCenter = null;
+
+    // initialize the inherited members
+    this.inheritedFrom = GLGeomObj;
+    this.inheritedFrom();
+
+    //used to query what the user selected, OR-able for future extensions
+    this.SEL_NONE = 0;          //nothing was selected
+    this.SEL_ANCHOR = 1;        //anchor point was selected
+    this.SEL_PREV = 2;          //previous handle of anchor point was selected
+    this.SEL_NEXT = 4;          //next handle of anchor point was selected
+    this.SEL_PATH = 8;          //the path itself was selected
+    this._selectMode = this.SEL_NONE;
+    this._selectedAnchorIndex = -1;
+
+    this._SAMPLING_EPSILON = 0.5; //epsilon used for sampling the curve
+    this._DEFAULT_STROKE_WIDTH = 20; //use only if stroke width not specified
+    this._MAX_OFFSET_ANGLE = 10; //max angle (in degrees) between consecutive vectors from curve to offset path
+
+    /////////////////////////////////////////////////////////
+    // Property Accessors/Setters
+    /////////////////////////////////////////////////////////
+    this.setWorld = function (world) { this._world = world; }
+    this.getWorld = function () { return this._world; }
+    this.makeDirty = function () {this._dirty = true;}
+    this.geomType = function () { return this.GEOM_TYPE_CUBIC_BEZIER; }
+    this.setDrawingTool = function (tool) {this._drawingTool = tool;}
+    this.getDrawingTool = function () {return this._drawingTool;}
+    this.setPlaneMatrix = function(planeMat){this._planeMat = planeMat;}
+    this.setPlaneMatrixInverse = function(planeMatInv){this._planeMatInv = planeMatInv;}
+    this.setPlaneCenter = function(pc){this._planeCenter = pc;}
+
+    this.getCanvasX = function(){return this._canvasX;}
+    this.getCanvasY = function(){return this._canvasY;}
+    this.setCanvasX = function(cx){this._canvasX=cx;}
+    this.setCanvasY = function(cy){this._canvasY=cy;}
+        
+    this.getIsClosed = function () {return this._isClosed;}
+    this.setIsClosed = function (isClosed) { 
+        if (this._isClosed !== isClosed) {
+            this._isClosed = isClosed;  
+            this._dirty = true;
+        }
+    }
+    this.getNumAnchors = function () { return this._Anchors.length; }
+    this.getAnchor = function (index) { return this._Anchors[index]; } 
+    this.addAnchor = function (anchorPt) { 
+        this._Anchors.push(anchorPt);
+        this._selectedAnchorIndex = this._Anchors.length-1;
+        this._dirty = true;
+    }
+
+    this.insertAnchor = function(anchorPt, index){
+        this._Anchors.splice(index, 0, anchorPt);
+    }
+
+    //remove and return anchor at specified index, return null on error
+    this.removeAnchor = function (index) { 
+        var retAnchor = null;
+        if (index < this._Anchors.length) {
+            retAnchor = this._Anchors.splice(index, 1);
+            this._dirty = true;
+        }
+        //deselect the removed anchor if necessary
+        if (this._selectedAnchorIndex === index){
+            this._selectedAnchorIndex = -1;
+        }
+        return retAnchor;
+    }
+
+    //remove all the anchor points
+    this.clearAllAnchors = function () {
+        this._Anchors = [];
+        this._isClosed = false; 
+        this._dirty = true;
+    }
+
+    this.insertAnchorAtParameter = function(index, param) {
+        if (index+1 >= this._Anchors.length && !this._isClosed) {
+            return;
+        }
+        //insert an anchor after the specified index using the parameter, using De Casteljau subdivision
+        var nextIndex = (index+1)%this._Anchors.length;
+
+        //build the De Casteljau points
+        var P0P1 = VecUtils.vecInterpolate(3, this._Anchors[index].getPos(), this._Anchors[index].getNext(), param);
+        var P1P2 = VecUtils.vecInterpolate(3, this._Anchors[index].getNext(), this._Anchors[nextIndex].getPrev(), param);
+        var P2P3 = VecUtils.vecInterpolate(3, this._Anchors[nextIndex].getPrev(), this._Anchors[nextIndex].getPos(), param);
+
+        var P0P1P2 = VecUtils.vecInterpolate(3, P0P1, P1P2, param);
+        var P1P2P3 = VecUtils.vecInterpolate(3, P1P2, P2P3, param);
+        var anchorPos = VecUtils.vecInterpolate(3, P0P1P2, P1P2P3, param);
+
+
+        //update the next of the anchor at index and prev of anchor at nextIndex
+        var isPrevCoincident = false;
+        var isNextCoincident = false;
+        if (VecUtils.vecDist( 3, P0P1, this._Anchors[index].getNext()) < this._SAMPLING_EPSILON) {
+            //no change to the next point
+            isPrevCoincident = true;
+        } else {
+            this._Anchors[index].setNextPos(P0P1[0], P0P1[1], P0P1[2]);
+        }
+
+        if (VecUtils.vecDist( 3, P2P3, this._Anchors[nextIndex].getPrev()) < this._SAMPLING_EPSILON) {
+            //no change to the prev point
+            isNextCoincident = true;
+        } else {
+            this._Anchors[nextIndex].setPrevPos(P2P3[0], P2P3[1], P2P3[2]);
+        }
+
+        //create a new anchor point
+        var newAnchor = new GLAnchorPoint();
+
+        if (isPrevCoincident && isNextCoincident){
+            anchorPos[0]=P1P2[0];anchorPos[1]=P1P2[1];anchorPos[2]=P1P2[2];
+            newAnchor.setPos(anchorPos[0],anchorPos[1],anchorPos[2]);
+            newAnchor.setPrevPos(anchorPos[0],anchorPos[1],anchorPos[2]);
+            newAnchor.setNextPos(anchorPos[0],anchorPos[1],anchorPos[2]);
+        } else {
+            newAnchor.setPrevPos(P0P1P2[0], P0P1P2[1], P0P1P2[2]);
+            newAnchor.setNextPos(P1P2P3[0], P1P2P3[1], P1P2P3[2]);
+            newAnchor.setPos(anchorPos[0], anchorPos[1], anchorPos[2]);
+        }
+
+        //insert the new anchor point at the correct index and set it as the selected anchor
+        this._Anchors.splice(nextIndex, 0, newAnchor);
+        this._selectedAnchorIndex = nextIndex;
+        this._dirty = true;
+    }
+
+    this._checkIntersectionWithSamples = function(startIndex, endIndex, point, radius){
+        //check whether the point is within the radius distance from the curve represented as a polyline in _samples
+        //return the parametric distance along the curve if there is an intersection, else return null
+        //will assume that the BBox test is performed outside this function
+
+        for (var i=startIndex; i<endIndex; i++){