7 files changed, 619 insertions, 191 deletions

diff --git a/js/lib/drawing/world.js b/js/lib/drawing/world.js
index 9e502c3e..4b117242 100755
--- a/js/lib/drawing/world.js
+++ b/js/lib/drawing/world.js
@@ -17,7 +17,7 @@ var worldCounter = 0;
 // Class GLWorld
 //      Manages display in a canvas
 ///////////////////////////////////////////////////////////////////////
-var World = function GLWorld( canvas, use3D ) {
+var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
     ///////////////////////////////////////////////////////////////////////
     // Instance variables
     ///////////////////////////////////////////////////////////////////////
@@ -30,7 +30,11 @@ var World = function GLWorld( canvas, use3D ) {
 
     this._canvas = canvas;
         if (this._useWebGL) {
-                this._glContext = canvas.getContext("experimental-webgl");
+        if(preserveDrawingBuffer) {
+            this._glContext = canvas.getContext("experimental-webgl", {preserveDrawingBuffer: true});
+        } else {
+                    this._glContext = canvas.getContext("experimental-webgl");
+        }
     } else {
                 this._2DContext = canvas.getContext( "2d" );
     }
@@ -347,20 +351,18 @@ var World = function GLWorld( canvas, use3D ) {
                 return false;
         };
 
-        this.generateUniqueNodeID = function()
-        {
+        this.generateUniqueNodeID = function() {
                 var str = "" + this._nodeCounter;
                 this._nodeCounter++;
                 return str;
-        }
+        };
 
     
     // start RDGE passing your runtime object, and false to indicate we don't need a an initialization state
     // in the case of a procedurally built scene an init state is not needed for loading data
         if (this._useWebGL) {
                 rdgeStarted = true;
-                var id = this._canvas.getAttribute( "data-RDGE-id" ); 
-                this._canvas.rdgeid = id;
+                this._canvas.rdgeid = this._canvas.getAttribute( "data-RDGE-id" );
                 g_Engine.registerCanvas(this._canvas, this);
                 RDGEStart( this._canvas );
                 this._canvas.task.stop()
@@ -680,7 +682,7 @@ World.prototype.render = function() {
                 var root = this.getGeomRoot();
                 this.hRender( root );
         } else {
-                g_Engine.setContext( this._canvas.rdgeId );
+                g_Engine.setContext( this._canvas.rdgeid );
                 //this.draw();
                 this.restartRenderLoop();
         }
diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index 9a934928..4c42539a 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -32,13 +32,24 @@ var BrushStroke = function GLBrushStroke() {
     //stroke information
     this._strokeWidth = 0.0;
     this._strokeColor = [0.4, 0.4, 0.4, 1.0];
+    this._secondStrokeColor = [1, 0.4, 0.4, 1.0];
+    this._strokeHardness = 100;
     this._strokeMaterial = null;
     this._strokeStyle = "Solid";
+    this._strokeDoSmoothing = false;
+    this._strokeUseCalligraphic = false;
+    this._strokeAngle = 0;
 
     //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;
 
+    //threshold that tells us whether two samples are too far apart
+    this._MAX_SAMPLE_DISTANCE_THRESHOLD = 5;
+
+    //threshold that tells us whether two samples are too close
+    this._MIN_SAMPLE_DISTANCE_THRESHOLD = 2;
+
     //prevent extremely long paths that can take a long time to render
     this._MAX_ALLOWED_SAMPLES = 500;
 
@@ -114,7 +125,7 @@ var BrushStroke = function GLBrushStroke() {
         //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 threshold = this._MIN_SAMPLE_DISTANCE_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]);
@@ -173,6 +184,26 @@ var BrushStroke = function GLBrushStroke() {
         this._strokeColor = c;
     };
 
+    this.setSecondStrokeColor = function(c){
+        this._secondStrokeColor=c;
+    }
+
+    this.setStrokeHardness = function(h){
+        this._strokeHardness=h;
+    }
+
+    this.setDoSmoothing = function(s){
+        this._strokeDoSmoothing = s;
+    }
+
+    this.setStrokeUseCalligraphic = function(c){
+        this._strokeUseCalligraphic = c;
+    }
+
+    this.setStrokeAngle = function(a){
+        this._strokeAngle = a;
+    }
+
     this.getStrokeStyle = function () {
         return this._strokeStyle;
     };
@@ -219,7 +250,8 @@ var BrushStroke = function GLBrushStroke() {
             var numPoints = this._Points.length;
 
             //**** add samples to the path if needed...linear interpolation for now
-            if (numPoints>1) {
+            //if (numPoints>1) {
+            if (0){
                 var threshold = this._WETNESS_FACTOR*this._strokeWidth;
                 var prevPt = this._Points[0];
                 var prevIndex = 0;
@@ -251,6 +283,66 @@ var BrushStroke = function GLBrushStroke() {
                 }
             }
 
+            //todo 4-point subdivision iterations over continuous regions of 'long' segments
+            // look at http://www.gvu.gatech.edu/~jarek/Split&Tweak/ for formula
+            //**** add samples to the long sections of the path --- Catmull-Rom spline interpolation
+            if (this._strokeDoSmoothing && numPoints>1) {
+                var numInsertedPoints = 0;
+                var newPoints = [];
+                var threshold = this._MAX_SAMPLE_DISTANCE_THRESHOLD;//this determines whether a segment between two sample is long enough to warrant checking for angle
+                var prevPt = this._Points[0];
+                newPoints.push(this._Points[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){
+                        //build the control polygon for the Catmull-Rom spline (prev. 2 points and next 2 points)
+                        var prev = (i===1) ? i-1 : i-2;
+                        var next = (i===numPoints-1) ? i : i+1;
+                        var ctrlPts = [this._Points[prev], this._Points[i-1], this._Points[i], this._Points[next]];
+                        //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 = this._CatmullRomSplineInterpolate(ctrlPts, param);
+                            //insert new point before point i
+                            //this._Points.splice(i, 0, newpt);
+                            //i++;
+                            newPoints.push(newpt);
+                            numInsertedPoints++;
+                        }
+                        this._dirty=true;
+                    }
+                    newPoints.push(pt);
+                    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;
+                    }
+                }
+                this._Points = newPoints;
+                numPoints = this._Points.length;
+                console.log("Inserted "+numInsertedPoints+" additional CatmullRom points");
+
+                //now do 3-4 iterations of Laplacian smoothing (setting the points to the average of their neighbors)
+                var numLaplacianIterations = 3; //todo figure out the proper number of Laplacian iterations (perhaps as a function of stroke width)
+                for (var n=0;n<numLaplacianIterations;n++){
+                    newPoints = this._Points;
+                    for (var i=1;i<numPoints-1;i++){
+                        var avgPos = [  0.5*(this._Points[i-1][0] + this._Points[i+1][0]),
+                                        0.5*(this._Points[i-1][1] + this._Points[i+1][1]),
+                                        0.5*(this._Points[i-1][2] + this._Points[i+1][2])] ;
+                        newPoints[i] = avgPos;
+                    }
+                    this._Points = newPoints;
+                }
+            }
+
             // *** compute the bounding box *********
             this._BBoxMin = [Infinity, Infinity, Infinity];
             this._BBoxMax = [-Infinity, -Infinity, -Infinity];
@@ -271,11 +363,20 @@ var BrushStroke = function GLBrushStroke() {