Merge branch 'refs/heads/integration-candidate'

8 files changed, 378 insertions, 164 deletions

diff --git a/js/helper-classes/RDGE/GLAnchorPoint.js b/js/helper-classes/RDGE/GLAnchorPoint.js
index 716f59d4..c3e95b34 100755
--- a/js/helper-classes/RDGE/GLAnchorPoint.js
+++ b/js/helper-classes/RDGE/GLAnchorPoint.js
@@ -133,6 +133,13 @@ GLAnchorPoint.prototype.translateAll = function (x, y, z) {
 }
 
 
+GLAnchorPoint.prototype.scaleAll = function(sx,sy,sz){
+    this._x *= sx;this._prevX *= sx;this._nextX *= sx;
+    this._y *= sy;this._prevY *= sy;this._nextY *= sy;
+    this._z *= sz;this._prevZ *= sz;this._nextZ *= sz;
+}
+
+
 // ********* getters **********
 GLAnchorPoint.prototype.getPosX = function () { return this._x; }
 GLAnchorPoint.prototype.getPosY = function () { return this._y; }
diff --git a/js/helper-classes/RDGE/GLBrushStroke.js b/js/helper-classes/RDGE/GLBrushStroke.js
index fdf1595c..5d773c2d 100755
--- a/js/helper-classes/RDGE/GLBrushStroke.js
+++ b/js/helper-classes/RDGE/GLBrushStroke.js
@@ -34,6 +34,13 @@ function GLBrushStroke() {
     this._strokeMaterial;
     this._strokeStyle = "Solid";
 
+    //the wetness of the brush (currently this is multiplied to the square of the stroke width, but todo should be changed to not depend on stroke width entirely
+    //smaller value means more samples for the path
+    this._WETNESS_FACTOR = 0.25;
+
+    //prevent extremely long paths that can take a long time to render
+    this._MAX_ALLOWED_SAMPLES = 500;
+
     //drawing context
     this._world = null;
 
@@ -67,7 +74,25 @@ function GLBrushStroke() {
 
     this.getNumPoints = function () { return this._Points.length; }
     this.getPoint = function (index) { return this._Points[index]; }
-    this.addPoint = function (anchorPt) { this._Points.push(anchorPt); this._dirty=true; }
+    this.addPoint = function (pt)
+    {
+        //add the point only if it is some epsilon away from the previous point
+        var numPoints = this._Points.length;
+        if (numPoints>0) {
+            var threshold = this._WETNESS_FACTOR*this._strokeWidth;
+            var prevPt = this._Points[numPoints-1];
+            var diffPt = [prevPt[0]-pt[0], prevPt[1]-pt[1]];
+            var diffPtMag = Math.sqrt(diffPt[0]*diffPt[0] + diffPt[1]*diffPt[1]);
+            if (diffPtMag>threshold){
+                this._Points.push(pt);
+                this._dirty=true;
+            }
+        }else{
+            this._Points.push(pt);
+            this._dirty=true;
+        }
+    }
+    
     this.insertPoint = function(pt, index){ this._Points.splice(index, 0, pt); this._dirty=true;}
     this.isDirty = function(){return this._dirty;}
     this.makeDirty = function(){this._dirty=true;}
@@ -111,10 +136,45 @@ function GLBrushStroke() {
 
     this.computeMetaGeometry = function(){
         if (this._dirty){
+            var numPoints = this._Points.length;
+
+            //**** add samples to the path if needed...linear interpolation for now
+            if (numPoints>1) {
+                var threshold = this._WETNESS_FACTOR*this._strokeWidth;
+                var prevPt = this._Points[0];
+                var prevIndex = 0;
+                for (var i=1;i<numPoints;i++){
+                    var pt = this._Points[i];
+                    var diff = [pt[0]-prevPt[0], pt[1]-prevPt[1]];
+                    var distance = Math.sqrt(diff[0]*diff[0]+diff[1]*diff[1]);
+                    if (distance>threshold){
+                        //insert points along the prev. to current point
+                        var numNewPoints = Math.floor(distance/threshold);
+                        for (var j=0;j<numNewPoints;j++){
+                            var param = (j+1)/(numNewPoints+1);
+                            var newpt = [prevPt[0]+ diff[0]*param, prevPt[1]+ diff[1]*param];
+                            //insert new point before point i
+                            this._Points.splice(i, 0, [newpt[0], newpt[1], 0]);
+                            i++;
+                        }
+                        this._dirty=true;
+                    }
+                    prevPt=pt;
+                    //update numPoints to match the new length
+                    numPoints = this._Points.length;
+
+                    //end this function if the numPoints has gone above the max. size specified
+                    if (numPoints> this._MAX_ALLOWED_SAMPLES){
+                        console.log("leaving the resampling because numPoints is greater than limit:"+this._MAX_ALLOWED_SAMPLES);
+                        break;
+                    }
+                }
+            }
+
             // *** compute the bounding box *********
             this._BBoxMin = [Infinity, Infinity, Infinity];
             this._BBoxMax = [-Infinity, -Infinity, -Infinity];
-            var numPoints = this._Points.length;
+            numPoints = this._Points.length;
             if (numPoints === 0) {
                 this._BBoxMin = [0, 0, 0];
                 this._BBoxMax = [0, 0, 0];
@@ -167,7 +227,8 @@ function GLBrushStroke() {
         var bboxWidth = bboxMax[0] - bboxMin[0];
         var bboxHeight = bboxMax[1] - bboxMin[1];
         ctx.clearRect(0, 0, bboxWidth, bboxHeight);
-/*
+
+        /*
         ctx.lineWidth = this._strokeWidth;
         ctx.strokeStyle = "black";
         if (this._strokeColor)
@@ -185,30 +246,120 @@ function GLBrushStroke() {
             ctx.lineTo(pt[0]-bboxMin[0], pt[1]-bboxMin[1]);
         }
         ctx.stroke();
- */
+        */
+
+        /*
+        var isDebug = false;
+        var prevPt = this._Points[0];
+        var prevX = prevPt[0]-bboxMin[0];
+        var prevY = prevPt[1]-bboxMin[1];
+        prevPt = [prevX,prevY];
+        for (var i = 1; i < numPoints; i++) {
+            var pt = this._Points[i];
+            ctx.globalCompositeOperation = 'source-over';
+            var x = pt[0]-bboxMin[0];
+            var y = pt[1]-bboxMin[1];
+            pt = [x,y];
+
+            //vector from prev to current pt
+            var seg = VecUtils.vecSubtract(2, pt, prevPt);
+            var segDir = VecUtils.vecNormalize(2, seg, 1.0);
+
+            var segMidPt = VecUtils.vecInterpolate(2, pt, prevPt, 0.5);
+            var w2 = this._strokeWidth*0.5;
+            var segDirOrtho = [w2*segDir[1], -w2*segDir[0]];
+            
+            //add half the strokewidth to the segMidPt
+            var lgStart = VecUtils.vecAdd(2, segMidPt, segDirOrtho);
+            var lgEnd = VecUtils.vecSubtract(2, segMidPt, segDirOrtho);
+
+            ctx.save();
+            ctx.beginPath();
+
+            if (isDebug) {
+                ctx.strokeStyle="black";
+                ctx.lineWidth = 1;
+
+                ctx.moveTo(lgStart[0], lgStart[1]);
+                ctx.lineTo(lgEnd[0], lgEnd[1]);
+                ctx.stroke();
+            }
+
+            var lg = ctx.createLinearGradient(lgStart[0], lgStart[1], lgEnd[0], lgEnd[1]);
+            lg.addColorStop(1, 'rgba(0,0,0,0.0)');
+            lg.addColorStop(0.5,'rgba(255,0,0,1.0)');
+            lg.addColorStop(0, 'rgba(0,0,0,0.0)');
+            ctx.fillStyle = lg;
+
+            if (isDebug){
+                ctx.strokeStyle="blue";
+                ctx.lineWidth=0.5;
+            }
+            ctx.moveTo(prevX-w2, prevY);
+            ctx.lineTo(prevX+w2, prevY);
+            ctx.lineTo(x+w2, y);
+            ctx.lineTo(x-w2, y);
+            ctx.lineTo(prevX-w2, prevY);
+            ctx.fill();
+            ctx.closePath();
+
+            ctx.restore();
+
+            prevPt = pt;
+            prevX = x;
+            prevY = y;
+        }
+        
+
+        if (isDebug)
+            ctx.stroke();
+
+        if (isDebug){
+            //draw the skeleton of this stroke
+            ctx.lineWidth = 1;
+            ctx.strokeStyle = "black";
+            var pt = this._Points[0];