1 files changed, 882 insertions, 1430 deletions

diff --git a/js/helper-classes/RDGE/GLSubpath.js b/js/helper-classes/RDGE/GLSubpath.js
index 25b12093..fd2f3560 100644
--- a/js/helper-classes/RDGE/GLSubpath.js
+++ b/js/helper-classes/RDGE/GLSubpath.js
@@ -34,6 +34,7 @@ function SegmentIntersections(){
 //      representation a sequence of cubic bezier curves.
 //      Derived from class GLGeomObj
 ///////////////////////////////////////////////////////////////////////
+
 function GLSubpath() {
     ///////////////////////////////////////////////////
     // Instance variables
@@ -49,14 +50,6 @@ function GLSubpath() {
     
     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;
 
@@ -87,7 +80,6 @@ function GLSubpath() {
     this._planeMatInv = null;
     this._planeCenter = null;
 
-    // initialize the inherited members
     this.inheritedFrom = GLGeomObj;
     this.inheritedFrom();
 
@@ -104,681 +96,540 @@ function GLSubpath() {
     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;
-    }
+    // (current GLGeomObj complains if buildBuffers/render is added to GLSubpath prototype)
+    //buildBuffers
+    //  Build the stroke vertices, normals, textures and colors
+    //  Add that array data to the GPU using OpenGL data binding
+    this.buildBuffers = function () {
+        return; //no need to do anything for now
+    }//buildBuffers()
 
-    this.insertAnchor = function(anchorPt, index){
-        this._Anchors.splice(index, 0, anchorPt);
-    }
+    //render
+    //  specify how to render the subpath in Canvas2D
+    this.render = function () {
+        // get the world
+        var world = this.getWorld();
+        if (!world)  throw( "null world in subpath render" );
 
-    //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;
-    }
+         // get the context
+        var ctx = world.get2DContext();
+        if (!ctx)  throw ("null context in subpath render")
 
-    //remove all the anchor points
-    this.clearAllAnchors = function () {
-        this._Anchors = [];
-        this._isClosed = false; 
-        this._dirty = true;
-    }
+        var numAnchors = this.getNumAnchors();
+        if (numAnchors === 0)
+            return; //nothing to do for empty paths
 
-    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;
+        ctx.save();
 
-        //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);
+        this.createSamples(); //dirty bit checked in this function...will generate a polyline representation
+        var bboxMin = this.getBBoxMin();
+        var bboxMax = this.getBBoxMax();
+        var bboxWidth = bboxMax[0] - bboxMin[0];
+        var bboxHeight = bboxMax[1] - bboxMin[1];
+        var bboxMid = Vector.create([0.5 * (bboxMax[0] + bboxMin[0]), 0.5 * (bboxMax[1] + bboxMin[1]), 0.5 * (bboxMax[2] + bboxMin[2])]);
 
-        var P0P1P2 = VecUtils.vecInterpolate(3, P0P1, P1P2, param);
-        var P1P2P3 = VecUtils.vecInterpolate(3, P1P2, P2P3, param);
-        var anchorPos = VecUtils.vecInterpolate(3, P0P1P2, P1P2P3, param);
+        ctx.clearRect(0, 0, bboxWidth, bboxHeight);
 
 
-        //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]);
+        ctx.lineWidth = this._strokeWidth;
+        ctx.strokeStyle = "black";
+        if (this._strokeColor)
+            ctx.strokeStyle = MathUtils.colorToHex( this._strokeColor );
+        ctx.fillStyle = "white";
+        if (this._fillColor)
+            ctx.fillStyle = MathUtils.colorToHex( this._fillColor );
+        var lineCap = ['butt','round','square'];
+        ctx.lineCap = lineCap[1];
+        ctx.beginPath();
+
+        var prevAnchor = this.getAnchor(0);
+        ctx.moveTo(prevAnchor.getPosX()-bboxMin[0],prevAnchor.getPosY()-bboxMin[1]);
+        for (var i = 1; i < numAnchors; i++) {
+            var currAnchor = this.getAnchor(i);
+            ctx.bezierCurveTo(prevAnchor.getNextX()-bboxMin[0],prevAnchor.getNextY()-bboxMin[1], currAnchor.getPrevX()-bboxMin[0], currAnchor.getPrevY()-bboxMin[1], currAnchor.getPosX()-bboxMin[0], currAnchor.getPosY()-bboxMin[1]);
+            prevAnchor = currAnchor;
+        }
+        if (this._isClosed === true) {
+            var currAnchor = this.getAnchor(0);
+            ctx.bezierCurveTo(prevAnchor.getNextX()-bboxMin[0],prevAnchor.getNextY()-bboxMin[1], currAnchor.getPrevX()-bboxMin[0], currAnchor.getPrevY()-bboxMin[1], currAnchor.getPosX()-bboxMin[0], currAnchor.getPosY()-bboxMin[1]);
+            prevAnchor = currAnchor;
+        }
+        if (this._isClosed){
+            ctx.fill();
         }
 
-        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]);
+        /*
+        var numPoints = this._samples.length/3;
+        ctx.moveTo(this._samples[0],this._samples[1]);
+        for (var i=0;i<numPoints;i++){
+            ctx.lineTo(this._samples[3*i]-bboxMin[0],this._samples[3*i + 1]-bboxMin[1]);
         }
+        */
+        ctx.stroke();
+        ctx.restore();
+    } //render()
+
+    this.geomType = function () { return this.GEOM_TYPE_CUBIC_BEZIER; }
+} //function GLSubpath ...class definition
+
+
 
-        //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;
+
+    /////////////////////////////////////////////////////////
+    // Property Accessors/Setters
+    /////////////////////////////////////////////////////////
+GLSubpath.prototype.setWorld = function (world) { this._world = world; }
+GLSubpath.prototype.getWorld = function () { return this._world; }
+GLSubpath.prototype.makeDirty = function () {this._dirty = true;}
+GLSubpath.prototype.setDrawingTool = function