From e065244ac75d1d0f25fd5c75cb58e714a13fe16b Mon Sep 17 00:00:00 2001
From: Jonathan Duran
Date: Wed, 14 Mar 2012 08:59:17 -0700
Subject: Squashed commit of the following:

merge master into timeline

Signed-off-by: Jonathan Duran <jduran@motorola.com>
---
 js/helper-classes/backup-delete/GLBrushStroke.js   | 174 ++++++++++++++++++++-
 js/helper-classes/backup-delete/GLCircle.js        |   3 +-
 js/helper-classes/backup-delete/GLGeomObj.js       |  46 ++++++
 js/helper-classes/backup-delete/GLRectangle.js     |   2 +
 js/helper-classes/backup-delete/GLSubpath.js       | 147 ++++++++++++++---
 js/helper-classes/backup-delete/GLWorld.js         |  71 +++++----
 .../backup-delete/Materials/BumpMetalMaterial.js   |  39 +++--
 .../backup-delete/Materials/DeformMaterial.js      |   2 +-
 .../backup-delete/Materials/FlatMaterial.js        |  34 ++--
 .../backup-delete/Materials/FlyMaterial.js         |   2 +-
 .../backup-delete/Materials/JuliaMaterial.js       |   2 +-
 .../Materials/KeleidoscopeMaterial.js              |   2 +-
 .../Materials/LinearGradientMaterial.js            |   2 +-
 .../backup-delete/Materials/MandelMaterial.js      |   2 +-
 .../backup-delete/Materials/PlasmaMaterial.js      |   2 +-
 .../backup-delete/Materials/PulseMaterial.js       |   5 +-
 .../backup-delete/Materials/RadialBlurMaterial.js  |   2 +-
 .../Materials/RadialGradientMaterial.js            |   6 +-
 .../Materials/ReliefTunnelMaterial.js              |   2 +-
 .../Materials/SquareTunnelMaterial.js              |   2 +-
 .../backup-delete/Materials/StarMaterial.js        |   2 +-
 .../backup-delete/Materials/TaperMaterial.js       |   4 +-
 .../backup-delete/Materials/TunnelMaterial.js      |   2 +-
 .../backup-delete/Materials/TwistMaterial.js       |   2 +-
 .../backup-delete/Materials/TwistVertMaterial.js   |   2 +-
 .../backup-delete/Materials/UberMaterial.js        |  73 ++++++++-
 .../backup-delete/Materials/WaterMaterial.js       |   4 +-
 .../backup-delete/Materials/ZInvertMaterial.js     |   2 +-
 28 files changed, 526 insertions(+), 112 deletions(-)

(limited to 'js/helper-classes/backup-delete')

diff --git a/js/helper-classes/backup-delete/GLBrushStroke.js b/js/helper-classes/backup-delete/GLBrushStroke.js
index 5d773c2d..26c922a3 100755
--- a/js/helper-classes/backup-delete/GLBrushStroke.js
+++ b/js/helper-classes/backup-delete/GLBrushStroke.js
@@ -31,6 +31,8 @@ function GLBrushStroke() {
     //stroke information
     this._strokeWidth = 0.0;
     this._strokeColor = [0.4, 0.4, 0.4, 1.0];
+    this._secondStrokeColor = this._strokeColor;
+    this._strokeHardness = 100;
     this._strokeMaterial;
     this._strokeStyle = "Solid";
 
@@ -39,7 +41,7 @@ function GLBrushStroke() {
     this._WETNESS_FACTOR = 0.25;
 
     //prevent extremely long paths that can take a long time to render
-    this._MAX_ALLOWED_SAMPLES = 500;
+    this._MAX_ALLOWED_SAMPLES = 5000;
 
     //drawing context
     this._world = null;
@@ -79,7 +81,7 @@ 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 = 1;//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]);
@@ -106,6 +108,8 @@ function GLBrushStroke() {
     this.setStrokeMaterial = function (m) { this._strokeMaterial = m; }
     this.getStrokeColor = function () { return this._strokeColor; }
     this.setStrokeColor = function (c) { this._strokeColor = c; }
+    this.setSecondStrokeColor = function(c){this._secondStrokeColor=c;}
+    this.setStrokeHardness = function(h){this._strokeHardness=h;}
     this.getStrokeStyle = function () { return this._strokeStyle; }
     this.setStrokeStyle = function (s) { this._strokeStyle = s; }
 
@@ -133,13 +137,14 @@ function GLBrushStroke() {
             this._Points[i][2]+=tz;
         }
     }
-
+    
     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) {
+            //if (numPoints>1) {
+            if (0){
                 var threshold = this._WETNESS_FACTOR*this._strokeWidth;
                 var prevPt = this._Points[0];
                 var prevIndex = 0;
@@ -171,6 +176,44 @@ function GLBrushStroke() {
                 }
             }
 
+            //**** add samples to the long sections of the path --- Catmull-Rom spline interpolation
+            if (numPoints>1) {
+                var numInsertedPoints = 0;
+                var threshold = 5;//0.25*this._strokeWidth; //this determines whether a segment between two sample is too long
+                var prevPt = 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++;
+                            numInsertedPoints++;
+                        }
+                        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;
+                    }
+                }
+                console.log("Inserted "+numInsertedPoints+" additional CatmullRom points");
+            }
             // *** compute the bounding box *********
             this._BBoxMin = [Infinity, Infinity, Infinity];
             this._BBoxMax = [-Infinity, -Infinity, -Infinity];
@@ -331,7 +374,109 @@ function GLBrushStroke() {
         }
         */
 
+        /*
+        //build the stamp for the brush stroke
+        //todo get this directly from the UI
+        var t=0;
+        var numTraces = this._strokeWidth;
+        var halfNumTraces = numTraces/2;
+        var startPos = [-this._strokeWidth/2,0];
+        var brushStamp = [];
+
+        //build an angled (calligraphic) brush stamp
+        var deltaDisplacement = [1,1];//[this._strokeWidth/numTraces, 0]; //a horizontal line brush
+        for (t=0;t<numTraces;t++){
+            var brushPt = [startPos[0]+t*deltaDisplacement[0], startPos[1]+t*deltaDisplacement[1]];
+            brushStamp.push(brushPt);
+        }
+
+
+        //make a circular brush stamp
+        brushStamp=[];
+        numTraces = this._strokeWidth*Math.PI; //figure out how to
+        var radius = this._strokeWidth/2;
+        for (t=0;t<numTraces;t++)
+        {
+            var angle = Math.PI*(360*t/numTraces)/180;
+            var brushPt = [radius*Math.cos(angle), radius*Math.sin(angle)];
+            brushStamp.push(brushPt);
+        }
+        
+//        //make a square brush stamp
+//        STOPPED HERE
+//        brushStamp = [];
+//        numTraces = 4*strokeWidth;
+//        for (t=0;t<numTraces;t++){
+//            if (t<numTraces*0.25){
+//                var brushPt = [startPos[0]+t*deltaDisplacement[0], startPos[1]+t*deltaDisplacement[1]];
+//            } else if (t<numTraces*0.5){
+//
+//            } else if (t<numTraces*0.75){
+//
+//            } else {
+//
+//            }
+//            brushStamp.push(brushPt);
+//        }
+
+        for (t=0;t<numTraces;t++){
+            var disp = [brushStamp[t][0], brushStamp[t][1]];
+            //ctx.globalCompositeOperation = 'source-over';
+            var distFromMiddle = Math.abs(halfNumTraces-t);
+            var alphaVal = 1.0 - (100-this._strokeHardness)*(distFromMiddle/halfNumTraces)/100;
+            alphaVal = 0.2;
+            ctx.save();
+            ctx.lineWidth=this._strokeWidth/10;//todo figure out the correct formula for the line width
+            if (ctx.lineWidth<2)
+                ctx.lineWidth=2;
+            if (t===numTraces-1){
+                ctx.lineWidth = 1; 
+            }
+            ctx.lineJoin="bevel";
+            ctx.lineCap="butt";
+            //if (t<numTraces/2)
+                ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
+            //else
+            //    ctx.strokeStyle="rgba("+parseInt(255*this._secondStrokeColor[0])+","+parseInt(255*this._secondStrokeColor[1])+","+parseInt(255*this._secondStrokeColor[2])+","+alphaVal+")";
+            ctx.translate(disp[0],disp[1]);
+            ctx.beginPath();
+            ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
+            for (var i=0;i<numPoints;i++){
+                ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
+            }
+            ctx.stroke();
+            ctx.restore();
+        }
+        */
+
+        /*
+        //debugging path
+        ctx.beginPath();
+        ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
+        for (var i=1;i<numPoints;i++){
+            ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
+        }
+        ctx.lineWidth=1.0;
+        ctx.strokeStyle = "black";
+        ctx.stroke();
+        */
 
+        var numlayers = this._strokeWidth/2;
+        var alphaVal = 1.0/(numlayers-1);
+        for (var l=0;l<numlayers;l++){
+            ctx.beginPath();
+            ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
+            for (var i=1;i<numPoints;i++){
+                ctx.lineTo(this._Points[i][0]-bboxMin[0], this._Points[i][1]-bboxMin[1]);
+            }
+            ctx.lineCap = "round";
+            ctx.lineJoin="round";
+            ctx.lineWidth=l+1;
+            ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
+            ctx.stroke();
+        }
+
+        /*
         var R2 = this._strokeWidth;
         var R = R2*0.5;
         var hardness = 0; //for a pencil, this is always 1 //TODO get hardness parameter from user interface
@@ -356,9 +501,12 @@ function GLBrushStroke() {
             ctx.arc(0, 0, R, 0, 2 * Math.PI, false);
             ctx.fill();
             ctx.restore();
+            break;
             //ctx.globalCompositeOperation = 'source-in';
             //ctx.rect(x-R, y-R, R2, R2);
         }
+        */
+
 
         ctx.restore();
     } //render()
@@ -394,4 +542,20 @@ function GLBrushStroke() {
         return true;
     }
 
-} //function GLSubpath ...class definition
\ No newline at end of file
+} //function GLBrushStroke ...class definition
+
+GLBrushStroke.prototype._CatmullRomSplineInterpolate = function(ctrlPts, t)
+{
+    //perform CatmullRom interpolation on the spline...assume t is in [0,1]
+    var t2 = t*t;
+    var t3 = t2*t;
+    var retPoint = [0,0,0];
+    for (var i=0;i<3;i++){
+        retPoint[i] = 0.5 *(
+            (2*ctrlPts[1][i]) +
+            (-ctrlPts[0][i] + ctrlPts[2][i]) * t +
+            (2*ctrlPts[0][i] - 5*ctrlPts[1][i] + 4*ctrlPts[2][i] - ctrlPts[3][i]) * t2 +
+            (-ctrlPts[0][i] + 3*ctrlPts[1][i]- 3*ctrlPts[2][i] + ctrlPts[3][i]) * t3);
+    }
+    return retPoint;
+}
\ No newline at end of file
diff --git a/js/helper-classes/backup-delete/GLCircle.js b/js/helper-classes/backup-delete/GLCircle.js
index 15ed6b6d..59d0bdaf 100755
--- a/js/helper-classes/backup-delete/GLCircle.js
+++ b/js/helper-classes/backup-delete/GLCircle.js
@@ -381,7 +381,6 @@ function GLCircle()
 		// translate
 		var xCtr = 0.5*world.getViewportWidth() + this._xOffset,
 			yCtr = 0.5*world.getViewportHeight() + this._yOffset;
-		//ctx.setTransform( xScale, 0.0,  0.0, yScale, xCtr, yCtr );
 		var mat = Matrix.create( [
 							[ xScale,     0.0,  0.0,  xCtr],
 							[    0.0,  yScale,  0.0,  yCtr],
@@ -538,6 +537,8 @@ function GLCircle()
 			rtnStr += "flatMaterial";
 		rtnStr += "\n";
 
+		rtnStr += this.exportMaterials();
+
 		return rtnStr;
 	}
 
diff --git a/js/helper-classes/backup-delete/GLGeomObj.js b/js/helper-classes/backup-delete/GLGeomObj.js
index 8946470d..54933590 100755
--- a/js/helper-classes/backup-delete/GLGeomObj.js
+++ b/js/helper-classes/backup-delete/GLGeomObj.js
@@ -158,6 +158,52 @@ function GLGeomObj()
         return fillMaterial;
     }
 
+	this.exportMaterials = function()
+	{
+		var rtnStr = "";
+		if (this._materialArray && this._materialNodeArray)
+		{
+			var nMats = this._materialArray.length;
+			rtnStr += "nMaterials: " + nMats + "\n";
+			for (var i=0;  i<nMats;  i++)
+			{
+				var matNode  = this._materialNodeArray[i];
+				rtnStr += "materialNodeName: " + matNode.name + "\n";
+
+				var material = this._materialArray[i];
+				rtnStr += material.export();
+			}
+		}
+		else
+			rtnStr += "nMaterials: 0\n" ;
+
+		return rtnStr;
+	}
+
+	this.importMaterials = function(importStr)
+	{
+		var nMaterials = Number( this.getPropertyFromString( "nMaterials: ", importStr )  );
+		for (var i=0;  i<nMaterials;  i++)
+		{
+			var mat;
+			var materialType = this.getPropertyFromString( "material: ",	importStr );
+			switch (materialType)
+			{
+				case "flat":		mat = new FlatMaterial();		break;
+
+				default:
+					console.log( "material type: " + materialType + " is not supported" );
+					break;
+			}
+
+			if (mat)
+				mat.import( importStr );
+
+			var endIndex = importStr.indexOf( "endMaterial\n" );
+			if (endIndex < 0)  break;
+			importStr = importStr.substr( endIndex );
+		}
+	}
 
     this.translate   = function(v)
     {
diff --git a/js/helper-classes/backup-delete/GLRectangle.js b/js/helper-classes/backup-delete/GLRectangle.js
index a801d3c4..2caa7080 100755
--- a/js/helper-classes/backup-delete/GLRectangle.js
+++ b/js/helper-classes/backup-delete/GLRectangle.js
@@ -166,6 +166,8 @@ function GLRectangle()
 			rtnStr += "flatMaterial";
 		rtnStr += "\n";
 
+		rtnStr += this.exportMaterials();
+
 		return rtnStr;
 	}
 
diff --git a/js/helper-classes/backup-delete/GLSubpath.js b/js/helper-classes/backup-delete/GLSubpath.js
index f3d8ad36..2fb91d33 100755
--- a/js/helper-classes/backup-delete/GLSubpath.js
+++ b/js/helper-classes/backup-delete/GLSubpath.js
@@ -505,7 +505,6 @@ GLSubpath.prototype._isWithinBoundingBox = function(point, ctrlPts, radius) {
 GLSubpath.prototype.pickAnchor = function (pickX, pickY, pickZ, radius) {
     var numAnchors = this._Anchors.length;
     var selAnchorIndex = -1;
-    var retCode = this.SEL_NONE;
     var radSq = radius * radius;
     var minDistance = Infinity;
     //check if the clicked location is close to the currently selected anchor position
@@ -515,9 +514,23 @@ GLSubpath.prototype.pickAnchor = function (pickX, pickY, pickZ, radius) {
         if (distSq < minDistance && distSq < radSq) {
             selAnchorIndex = this._selectedAnchorIndex;
             minDistance = distSq;
-            retCode = retCode | this.SEL_ANCHOR;
+        } else {
+            //check the prev and next of the selected anchor if the above did not register a hit
+            distSq = this._Anchors[this._selectedAnchorIndex].getPrevDistanceSq(pickX, pickY, pickZ);
+            if (distSq < minDistance && distSq < radSq){
+                selAnchorIndex = this._selectedAnchorIndex;
+                minDistance = distSq;
+            } else {
+                //check the next for this anchor point
+                distSq = this._Anchors[this._selectedAnchorIndex].getNextDistanceSq(pickX, pickY, pickZ);
+                if (distSq<minDistance && distSq<radSq){
+                    selAnchorIndex = this._selectedAnchorIndex;
+                    minDistance = distSq;
+                }
+            }
         }
     }
+    
     //now check if the click location is close to any anchor position
     if (selAnchorIndex===-1) {
         for (var i = 0; i < numAnchors; i++) {
@@ -532,12 +545,97 @@ GLSubpath.prototype.pickAnchor = function (pickX, pickY, pickZ, radius) {
     return selAnchorIndex;
 }
 
+GLSubpath.prototype.isWithinBBox =function(x,y,z){
+    if (this._BBoxMin[0]>x || this._BBoxMin[1]>y || this._BBoxMin[2]>z){
+        return false;
+    }
+    if (this._BBoxMax[0]<x || this._BBoxMax[1]<y || this._BBoxMax[2]<z){
+        return false;
+    }
+    return true;
+}
+
+//pick the path point closest to the specified location, return null if some anchor point (or its handles) is within radius, else return the parameter distance
+GLSubpath.prototype.pathHitTest = function (pickX, pickY, pickZ, radius) {
+    var numAnchors = this._Anchors.length;
+    var selAnchorIndex = -1;
+    var retParam = null;
+    var radSq = radius * radius;
+    var minDistance = Infinity;
+    
+    //check if the location is close to the currently selected anchor position
+    if (this._selectedAnchorIndex>=0 && this._selectedAnchorIndex<this._Anchors.length){
+        var distSq = this._Anchors[this._selectedAnchorIndex].getDistanceSq(pickX, pickY, pickZ);
+        //check the anchor point
+        if (distSq < minDistance && distSq < radSq) {
+            selAnchorIndex = this._selectedAnchorIndex;
+            minDistance = distSq;
+        }
+    }
+    //check the prev and next of the selected anchor if the above did not register a hit
+    if (this._selectedAnchorIndex>=0 && selAnchorIndex === -1) {
+        var distSq = this._Anchors[this._selectedAnchorIndex].getPrevDistanceSq(pickX, pickY, pickZ);
+        if (distSq < minDistance && distSq < radSq){
+            selAnchorIndex = this._selectedAnchorIndex;
+            minDistance = distSq;
+        } else {
+            //check the next for this anchor point
+            distSq = this._Anchors[this._selectedAnchorIndex].getNextDistanceSq(pickX, pickY, pickZ);
+            if (distSq<minDistance && distSq<radSq){
+                selAnchorIndex = this._selectedAnchorIndex;
+                minDistance = distSq;
+            }
+        }
+    }
+
+    //now check if the location is close to any anchor position
+    if (selAnchorIndex===-1) {
+        for (var i = 0; i < numAnchors; i++) {
+            var distSq = this._Anchors[i].getDistanceSq(pickX, pickY, pickZ);
+            //check the anchor point
+            if (distSq < minDistance && distSq < radSq) {
+                selAnchorIndex = i;
+                minDistance = distSq;
+            }
+        }//for every anchor i
+    }
+
+    //finally check if the location is close to the curve itself
+    if (selAnchorIndex===-1) {
+        //first check if the input location is within the bounding box
+        if (this.isWithinBBox(pickX,pickY,pickZ)){
+            var numSegments = this._isClosed ? numAnchors : numAnchors-1;
+            for (var i = 0; i < numSegments; i++) {
+                var nextIndex = (i+1)%numAnchors;
+                //check if the point is close to the bezier segment between anchor i and anchor nextIndex
+                var controlPoints = Vector.create([Vector.create([this._Anchors[i].getPosX(),this._Anchors[i].getPosY(),this._Anchors[i].getPosZ()]),
+                    Vector.create([this._Anchors[i].getNextX(),this._Anchors[i].getNextY(),this._Anchors[i].getNextZ()]),
+                    Vector.create([this._Anchors[nextIndex].getPrevX(),this._Anchors[nextIndex].getPrevY(),this._Anchors[nextIndex].getPrevZ()]),
+                    Vector.create([this._Anchors[nextIndex].getPosX(),this._Anchors[nextIndex].getPosY(),this._Anchors[nextIndex].getPosZ()])]);
+                var point = Vector.create([pickX, pickY, pickZ]);
+                if (this._isWithinBoundingBox(point, controlPoints, radius)) {
+                    //var intersectParam = this._checkIntersection(controlPoints, 0.0, 1.0, point, radius);
+                    var intersectParam = this._checkIntersectionWithSamples(this._anchorSampleIndex[i], this._anchorSampleIndex[nextIndex], point, radius);
+                    console.log("intersectParam:"+intersectParam);
+                    if (intersectParam){
+                        selAnchorIndex=i;
+                        retParam = intersectParam-i; //make the retParam go from 0 to 1
+                        break;
+                    }
+                }
+            }//for every anchor i
+        }//if is within bbox
+    }
+    return [selAnchorIndex,retParam];
+}     //GLSubpath.pathHitTest function
+
 
 //pick the path point closest to the specified location, return null if some anchor point (or its handles) is within radius, else return the parameter distance
 GLSubpath.prototype.pickPath = function (pickX, pickY, pickZ, radius) {
     var numAnchors = this._Anchors.length;
     var selAnchorIndex = -1;
     var retCode = this.SEL_NONE;
+    var retParam = null;
     var radSq = radius * radius;
     var minDistance = Infinity;
     //check if the clicked location is close to the currently selected anchor position
@@ -580,33 +678,36 @@ GLSubpath.prototype.pickPath = function (pickX, pickY, pickZ, radius) {
             }
         }
     }
-    var retParam = null;
+
     if (retCode !== this.SEL_NONE) {
         retCode = retCode | this.SEL_PATH; //ensure that path is also selected if anything else is selected
         this._selectedAnchorIndex = selAnchorIndex;
     } else {
         this._selectedAnchorIndex = -1;
-        var numSegments = this._isClosed ? numAnchors : numAnchors-1;
-        for (var i = 0; i < numSegments; i++) {
-            var nextIndex = (i+1)%numAnchors;
-            //check if the point is close to the bezier segment between anchor i and anchor nextIndex
-            var controlPoints = Vector.create([Vector.create([this._Anchors[i].getPosX(),this._Anchors[i].getPosY(),this._Anchors[i].getPosZ()]),
-                Vector.create([this._Anchors[i].getNextX(),this._Anchors[i].getNextY(),this._Anchors[i].getNextZ()]),
-                Vector.create([this._Anchors[nextIndex].getPrevX(),this._Anchors[nextIndex].getPrevY(),this._Anchors[nextIndex].getPrevZ()]),
-                Vector.create([this._Anchors[nextIndex].getPosX(),this._Anchors[nextIndex].getPosY(),this._Anchors[nextIndex].getPosZ()])]);
-            var point = Vector.create([pickX, pickY, pickZ]);
-            if (this._isWithinBoundingBox(point, controlPoints, radius)) {
-                //var intersectParam = this._checkIntersection(controlPoints, 0.0, 1.0, point, radius);
-                var intersectParam = this._checkIntersectionWithSamples(this._anchorSampleIndex[i], this._anchorSampleIndex[nextIndex], point, radius);
-                console.log("intersectParam:"+intersectParam);
-                if (intersectParam){
-                    retCode = retCode | this.SEL_PATH;
-                    retParam = intersectParam-i; //make the retParam go from 0 to 1
-                    this._selectedAnchorIndex = i;
-                    break;
+        //first check if the input location is within the bounding box
+        if (this.isWithinBBox(pickX,pickY,pickZ)){
+            var numSegments = this._isClosed ? numAnchors : numAnchors-1;
+            for (var i = 0; i < numSegments; i++) {
+                var nextIndex = (i+1)%numAnchors;
+                //check if the point is close to the bezier segment between anchor i and anchor nextIndex
+                var controlPoints = Vector.create([Vector.create([this._Anchors[i].getPosX(),this._Anchors[i].getPosY(),this._Anchors[i].getPosZ()]),
+                    Vector.create([this._Anchors[i].getNextX(),this._Anchors[i].getNextY(),this._Anchors[i].getNextZ()]),
+                    Vector.create([this._Anchors[nextIndex].getPrevX(),this._Anchors[nextIndex].getPrevY(),this._Anchors[nextIndex].getPrevZ()]),
+                    Vector.create([this._Anchors[nextIndex].getPosX(),this._Anchors[nextIndex].getPosY(),this._Anchors[nextIndex].getPosZ()])]);
+                var point = Vector.create([pickX, pickY, pickZ]);
+                if (this._isWithinBoundingBox(point, controlPoints, radius)) {
+                    //var intersectParam = this._checkIntersection(controlPoints, 0.0, 1.0, point, radius);
+                    var intersectParam = this._checkIntersectionWithSamples(this._anchorSampleIndex[i], this._anchorSampleIndex[nextIndex], point, radius);
+                    console.log("intersectParam:"+intersectParam);
+                    if (intersectParam){
+                        retCode = retCode | this.SEL_PATH;
+                        retParam = intersectParam-i; //make the retParam go from 0 to 1
+                        this._selectedAnchorIndex = i;
+                        break;
+                    }
                 }
-            }
-        }//for every anchor i
+            }//for every anchor i
+        }//is within bounding box
     }
     this._selectMode = retCode;
     return retParam;
diff --git a/js/helper-classes/backup-delete/GLWorld.js b/js/helper-classes/backup-delete/GLWorld.js
index 8017207f..c8bc4c1c 100755
--- a/js/helper-classes/backup-delete/GLWorld.js
+++ b/js/helper-classes/backup-delete/GLWorld.js
@@ -13,7 +13,6 @@ var fragmentShaderSource = "";
 
 var rdgeStarted = false;
 
-var nodeCounter = 0;
 var worldCounter = 0;
 
 
@@ -74,6 +73,10 @@ function GLWorld( canvas, use3D )
 	this._worldCount = worldCounter;
 	worldCounter++;
 
+	// keep a counter for generating node names
+	this._nodeCounter = 0;
+
+
     ///////////////////////////////////////////////////////////////////////
     // Property accessors
     ///////////////////////////////////////////////////////////////////////
@@ -376,10 +379,12 @@ function GLWorld( canvas, use3D )
 		return false;
 	}
 
-
-	// END RDGE
-	////////////////////////////////////////////////////////////////////////////////////
-
+	this.generateUniqueNodeID = function()
+	{
+		var str = String( 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
@@ -418,7 +423,7 @@ GLWorld.prototype.updateObject = function (obj)
         ctrTrNode = obj.getTransformNode();
 		if (ctrTrNode == null)
 		{
-			ctrTrNode = createTransformNode("objRootNode_" + nodeCounter++);
+			ctrTrNode = createTransformNode("objRootNode_" + this._nodeCounter++);
 			this._rootNode.insertAsChild( ctrTrNode );
 			obj.setTransformNode( ctrTrNode );
 		}
@@ -428,7 +433,7 @@ GLWorld.prototype.updateObject = function (obj)
 		});
 		ctrTrNode.meshes = [];
 
-        ctrTrNode.attachMeshNode(this.renderer.id + "_prim_" + nodeCounter++, prims[0]);
+        ctrTrNode.attachMeshNode(this.renderer.id + "_prim_" + this._nodeCounter++, prims[0]);
         ctrTrNode.attachMaterial(materialNodes[0]);
     }
 	
@@ -451,12 +456,12 @@ GLWorld.prototype.updateObject = function (obj)
 		}
 		else
 		{
-			childTrNode = createTransformNode("objNode_" + nodeCounter++);
+			childTrNode = createTransformNode("objNode_" + this._nodeCounter++);
 			ctrTrNode.insertAsChild(childTrNode);
 		}
 
         // attach the instanced box goe
-        childTrNode.attachMeshNode(this.renderer.id + "_prim_" + nodeCounter++, prim);
+        childTrNode.attachMeshNode(this.renderer.id + "_prim_" + this._nodeCounter++, prim);
         childTrNode.attachMaterial(materialNodes[i]);
     }
 }
@@ -811,7 +816,7 @@ GLWorld.prototype.getShapeFromPoint = function( offsetX, offsetY )
 	}
 }
 
-GLWorld.prototype.export = function()
+GLWorld.prototype.export = function( exportForPublish )
 {
 	var exportStr = "GLWorld 1.0\n";
 	var id = this.getCanvas().getAttribute( "data-RDGE-id" );
@@ -821,20 +826,28 @@ GLWorld.prototype.export = function()
 	exportStr += "zNear: " + this._zNear + "\n";
 	exportStr += "zFar: " + this._zFar + "\n";
 	exportStr += "viewDist: " + this._viewDist + "\n";
+	if (this._useWebGL)
+		exportStr += "webGL: true\n";
 
 	// we need 2 export modes:  One for save/restore, one for publish.
 	// hardcoding for now
-	var exportForPublish = false;
+	//var exportForPublish = false;
+	if (!exportForPublish)  exportForPublish = false;
 	exportStr += "publish: " + exportForPublish + "\n";
 
-	if (exportForPublish)
+	if (exportForPublish && this._useWebGL)
 	{
 		exportStr += "scenedata: " + this.myScene.exportJSON() + "endscene\n";
+
+		// write out all of the objects
+		exportStr += "tree\n";
+		exportStr += this.exportObjects( this._geomRoot );
+		exportStr += "endtree\n";
 	}
 	else
 	{
 		// output the material library
-		exportStr += MaterialsLibrary.export();
+		//exportStr += MaterialsLibrary.export();	// THIS NEEDS TO BE DONE AT THE DOC LEVEL
 
 		// write out all of the objects
 		exportStr += "tree\n";
@@ -892,24 +905,26 @@ GLWorld.prototype.import = function( importStr )
 
 	// determine if the data was written for export (no Ninja objects)
 	// or for save/restore
-	var index = importStr.indexOf( "scenedata: " );
-	if (index >= 0)
+	//var index = importStr.indexOf( "scenedata: " );
+	var index = importStr.indexOf( "webGL: " );
+	this._useWebGL = (index >= 0)
+	if (this._useWebGL)
 	{
-		var rdgeStr = importStr.substr( index+11 );
-		var endIndex = rdgeStr.indexOf( "endscene\n" );
-		if (endIndex < 0)  throw new Error( "ill-formed WebGL data" );
-		var len = endIndex - index + 11;
-		rdgeStr = rdgeStr.substr( 0, endIndex );
-
-		this.myScene.importJSON( rdgeStr );
+		// start RDGE
+		rdgeStarted = true;
+		var id = this._canvas.getAttribute( "data-RDGE-id" ); 
+		this._canvas.rdgeid = id;
+		g_Engine.registerCanvas(this._canvas, this);
+		RDGEStart( this._canvas );
+		this._canvas.task.stop()
 	}
-	else
-	{
-		// load the material library
-		importStr = MaterialsLibrary.import( importStr );
 
-		// import the objects
-		this.importObjects( importStr, this._rootNode );
+	this.importObjects( importStr, this._rootNode );
+
+	if (!this._useWebGL)
+	{
+		// render using canvas 2D
+		this.render();
 	}
 }
 
diff --git a/js/helper-classes/backup-delete/Materials/BumpMetalMaterial.js b/js/helper-classes/backup-delete/Materials/BumpMetalMaterial.js
index a7a3724e..52332ab8 100755
--- a/js/helper-classes/backup-delete/Materials/BumpMetalMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/BumpMetalMaterial.js
@@ -65,7 +65,7 @@ function BumpMetalMaterial()
     this.setProperty = function( prop, value )
 	{
 		// every material should do something with the "color" property
-		if (prop === "color")  prop = "lightDiff";
+		if (prop === "color")  return;	//prop = "lightDiff";
 
 		// make sure we have legitimate imput
 		var ok = this.validateProperty( prop, value );
@@ -97,22 +97,27 @@ function BumpMetalMaterial()
 	this.init = function( world )
 	{
 		// save the world
-		if (world)  this.setWorld( world );
-
-		// set up the shader
-		this._shader = new jshader();
-		this._shader.def = bumpMetalMaterialDef;
-		this._shader.init();
-		this._shader.default.u_light0Diff.set( this.getLightDiff() );
-
-		// set up the material node
-		this._materialNode = createMaterialNode( this.getShaderName() );
-		this._materialNode.setShader(this._shader);
-
-		// set some image maps
-		this.updateTexture(1);
-        this.updateTexture(2);
-        this.updateTexture(3);
+		if (world)  
+		{
+			this.setWorld( world );
+
+			// set up the shader
+			this._shader = new jshader();
+			this._shader.def = bumpMetalMaterialDef;
+			this._shader.init();
+			this._shader.default.u_light0Diff.set( this.getLightDiff() );
+
+			// set up the material node
+			this._materialNode = createMaterialNode( this.getShaderName() + "_" + world.generateUniqueNodeID() );
+			this._materialNode.setShader(this._shader);
+
+			// set some image maps
+			this.updateTexture(1);
+			this.updateTexture(2);
+			this.updateTexture(3);
+		}
+		else
+			throw new Error( "GLWorld not supplied to material initialization" );
 	};
 
 	this.updateTexture = function( index )
diff --git a/js/helper-classes/backup-delete/Materials/DeformMaterial.js b/js/helper-classes/backup-delete/Materials/DeformMaterial.js
index ddc97383..b7101227 100644
--- a/js/helper-classes/backup-delete/Materials/DeformMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/DeformMaterial.js
@@ -71,7 +71,7 @@ function DeformMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("deformMaterial");
+		this._materialNode = createMaterialNode("deformMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/FlatMaterial.js b/js/helper-classes/backup-delete/Materials/FlatMaterial.js
index 570e7f9e..eb8970b8 100755
--- a/js/helper-classes/backup-delete/Materials/FlatMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/FlatMaterial.js
@@ -40,19 +40,27 @@ function FlatMaterial()
 	// duplcate method requirde
 	this.dup = function()	{  return new FlatMaterial();	} ;
 
-	this.init = function()
+	this.init = function( world )
 	{
-		// set up the shader
-		this._shader = new jshader();
-		this._shader.def = flatShaderDef;
-		this._shader.init();
+		// save the world
+		if (world)
+		{
+			this.setWorld( world );
+
+			// set up the shader
+			this._shader = new jshader();
+			this._shader.def = flatShaderDef;
+			this._shader.init();
 
-        // set the defaults
-		this._shader.colorMe.color.set( this.getColor() );
+			// set the defaults
+			this._shader.colorMe.color.set( this.getColor() );
 
-		// set up the material node
-		this._materialNode = createMaterialNode("flatMaterial");
-		this._materialNode.setShader(this._shader);
+			// set up the material node
+			this._materialNode = createMaterialNode("flatMaterial_" + world.generateUniqueNodeID() );
+			this._materialNode.setShader(this._shader);
+		}
+		else
+			throw new Error( "GLWorld not supplied to material initialization" );
 	};
 
 
@@ -83,11 +91,7 @@ function FlatMaterial()
 		// this function should be overridden by subclasses
 		var exportStr = "material: " + this.getShaderName() + "\n";
 		exportStr += "name: " + this.getName() + "\n";
-		
-		if (this._shader)
-			exportStr += "color: " + String(this._shader.colorMe.color) + "\n";
-		else
-			exportStr += "color: " + this.getColor() + "\n";
+		exportStr += "color: " + String(this._propValues["color"]) + "\n";
 		exportStr += "endMaterial\n";
 
 		return exportStr;
diff --git a/js/helper-classes/backup-delete/Materials/FlyMaterial.js b/js/helper-classes/backup-delete/Materials/FlyMaterial.js
index 4a44e2e5..a70b53e8 100644
--- a/js/helper-classes/backup-delete/Materials/FlyMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/FlyMaterial.js
@@ -71,7 +71,7 @@ function FlyMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("flyMaterial");
+		this._materialNode = createMaterialNode("flyMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/JuliaMaterial.js b/js/helper-classes/backup-delete/Materials/JuliaMaterial.js
index f95263f4..9b5d588c 100644
--- a/js/helper-classes/backup-delete/Materials/JuliaMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/JuliaMaterial.js
@@ -73,7 +73,7 @@ function JuliaMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("juliaMaterial");
+		this._materialNode = createMaterialNode("juliaMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/KeleidoscopeMaterial.js b/js/helper-classes/backup-delete/Materials/KeleidoscopeMaterial.js
index 1547aca9..af7ce97c 100644
--- a/js/helper-classes/backup-delete/Materials/KeleidoscopeMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/KeleidoscopeMaterial.js
@@ -71,7 +71,7 @@ function KeleidoscopeMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("keleidoscopeMaterial");
+		this._materialNode = createMaterialNode("keleidoscopeMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/LinearGradientMaterial.js b/js/helper-classes/backup-delete/Materials/LinearGradientMaterial.js
index 7fe2be0c..2f900894 100755
--- a/js/helper-classes/backup-delete/Materials/LinearGradientMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/LinearGradientMaterial.js
@@ -159,7 +159,7 @@ function LinearGradientMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode( this.getShaderName() );
+		this._materialNode = createMaterialNode( this.getShaderName() + world.generateUniqueNodeID() );
 		this._materialNode.setShader(this._shader);
 
 		// send the current values to the shader
diff --git a/js/helper-classes/backup-delete/Materials/MandelMaterial.js b/js/helper-classes/backup-delete/Materials/MandelMaterial.js
index 25b08404..df732ed2 100644
--- a/js/helper-classes/backup-delete/Materials/MandelMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/MandelMaterial.js
@@ -74,7 +74,7 @@ function MandelMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("mandelMaterial");
+		this._materialNode = createMaterialNode("mandelMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/PlasmaMaterial.js b/js/helper-classes/backup-delete/Materials/PlasmaMaterial.js
index a65f3a33..4e60df9f 100644
--- a/js/helper-classes/backup-delete/Materials/PlasmaMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/PlasmaMaterial.js
@@ -74,7 +74,7 @@ function PlasmaMaterial()
 		this.setProperty( "color", [this._time, 0, 0,  1] );
 
 		// set up the material node
-		this._materialNode = createMaterialNode("plasmaMaterial");
+		this._materialNode = createMaterialNode("plasmaMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 	}
 
diff --git a/js/helper-classes/backup-delete/Materials/PulseMaterial.js b/js/helper-classes/backup-delete/Materials/PulseMaterial.js
index d76b9966..e55798b7 100644
--- a/js/helper-classes/backup-delete/Materials/PulseMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/PulseMaterial.js
@@ -105,7 +105,7 @@ function PulseMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("pulseMaterial");
+		this._materialNode = createMaterialNode("pulseMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
@@ -185,6 +185,9 @@ function PulseMaterial()
 		// every material needs the base type and instance name
 		var exportStr = "material: " + this.getShaderName() + "\n";
 		exportStr += "name: " + this.getName() + "\n";
+
+		var texMapName = this._propValues[this._propNames[0]];
+		exportStr += "texture: " + texMapName + "\n";
 		
 		// every material needs to terminate like this
 		exportStr += "endMaterial\n";
diff --git a/js/helper-classes/backup-delete/Materials/RadialBlurMaterial.js b/js/helper-classes/backup-delete/Materials/RadialBlurMaterial.js
index a5fb134c..471ff3c3 100644
--- a/js/helper-classes/backup-delete/Materials/RadialBlurMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/RadialBlurMaterial.js
@@ -103,7 +103,7 @@ function RadialBlurMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("radialBlurMaterial");
+		this._materialNode = createMaterialNode("radialBlurMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/RadialGradientMaterial.js b/js/helper-classes/backup-delete/Materials/RadialGradientMaterial.js
index 12842798..45b260ef 100755
--- a/js/helper-classes/backup-delete/Materials/RadialGradientMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/RadialGradientMaterial.js
@@ -146,15 +146,17 @@ function RadialGradientMaterial()
 	// duplcate method requirde
 	this.dup = function()	{  return new RadialGradientMaterial();	} 
 
-	this.init = function()
+	this.init = function( world )
 	{
+		this.setWorld( world );
+
 		// set up the shader
 		this._shader = new jshader();
 		this._shader.def = radialGradientMaterialDef;
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("radialGradientMaterial");
+		this._materialNode = createMaterialNode("radialGradientMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		// set the shader values in the shader
diff --git a/js/helper-classes/backup-delete/Materials/ReliefTunnelMaterial.js b/js/helper-classes/backup-delete/Materials/ReliefTunnelMaterial.js
index 6540c3e9..ba938806 100644
--- a/js/helper-classes/backup-delete/Materials/ReliefTunnelMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/ReliefTunnelMaterial.js
@@ -71,7 +71,7 @@ function ReliefTunnelMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("reliefTunnelMaterial");
+		this._materialNode = createMaterialNode("reliefTunnelMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/SquareTunnelMaterial.js b/js/helper-classes/backup-delete/Materials/SquareTunnelMaterial.js
index 8238b651..3a8afd18 100644
--- a/js/helper-classes/backup-delete/Materials/SquareTunnelMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/SquareTunnelMaterial.js
@@ -71,7 +71,7 @@ function SquareTunnelMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("squareTunnelMaterial");
+		this._materialNode = createMaterialNode("squareTunnelMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/StarMaterial.js b/js/helper-classes/backup-delete/Materials/StarMaterial.js
index a5f188a1..ea8e4edb 100644
--- a/js/helper-classes/backup-delete/Materials/StarMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/StarMaterial.js
@@ -71,7 +71,7 @@ function StarMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("starMaterial");
+		this._materialNode = createMaterialNode("starMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/TaperMaterial.js b/js/helper-classes/backup-delete/Materials/TaperMaterial.js
index e8cc7a49..eea3f699 100644
--- a/js/helper-classes/backup-delete/Materials/TaperMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/TaperMaterial.js
@@ -42,7 +42,7 @@ function TaperMaterial()
 	// duplcate method requirde
 	this.dup = function()	{  return new TaperMaterial();	} 
 
-	this.init = function()
+	this.init = function( world )
 	{
 		// set up the shader
 		this._shader = new jshader();
@@ -53,7 +53,7 @@ function TaperMaterial()
 		this._shader.colorMe.color.set( this.getColor() );
 
 		// set up the material node
-		this._materialNode = createMaterialNode("taperMaterial");
+		this._materialNode = createMaterialNode("taperMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		// initialize the taper properties
diff --git a/js/helper-classes/backup-delete/Materials/TunnelMaterial.js b/js/helper-classes/backup-delete/Materials/TunnelMaterial.js
index 853a6a8d..ab69fec0 100644
--- a/js/helper-classes/backup-delete/Materials/TunnelMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/TunnelMaterial.js
@@ -71,7 +71,7 @@ function TunnelMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("tunnelMaterial");
+		this._materialNode = createMaterialNode("tunnelMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/TwistMaterial.js b/js/helper-classes/backup-delete/Materials/TwistMaterial.js
index b113965b..a52440e9 100644
--- a/js/helper-classes/backup-delete/Materials/TwistMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/TwistMaterial.js
@@ -71,7 +71,7 @@ function TwistMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("twistMaterial");
+		this._materialNode = createMaterialNode("twistMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/TwistVertMaterial.js b/js/helper-classes/backup-delete/Materials/TwistVertMaterial.js
index 853e895c..dd49555c 100644
--- a/js/helper-classes/backup-delete/Materials/TwistVertMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/TwistVertMaterial.js
@@ -57,7 +57,7 @@ function TwistVertMaterial()
 		this._shader.twistMe.color.set( this.getColor() );
 
 		// set up the material node
-		this._materialNode = createMaterialNode("twistVertMaterial");
+		this._materialNode = createMaterialNode("twistVertMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		// initialize the twist vert properties
diff --git a/js/helper-classes/backup-delete/Materials/UberMaterial.js b/js/helper-classes/backup-delete/Materials/UberMaterial.js
index c7855c95..1652b4c9 100755
--- a/js/helper-classes/backup-delete/Materials/UberMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/UberMaterial.js
@@ -30,6 +30,8 @@ function UberMaterial()
 	this._specularPower = 32.0;
 	this._environmentAmount = 0.2;		// 0 .. 1
 
+	this._MAX_LIGHTS = 4;
+
 	// set the default maps
 	this._diffuseMapOb = { 'texture' : 'assets/images/rocky-diffuse.jpg', 'wrap' : 'REPEAT' };
 	this._normalMapOb = { 'texture' : 'assets/images/rocky-normal.jpg', 'wrap' : 'REPEAT' };
@@ -424,10 +426,79 @@ function UberMaterial()
 		this._shader = this.buildUberShader( this._ubershaderCaps );
 
 		// set up the material node
-		this._materialNode = createMaterialNode("uberMaterial");
+		this._materialNode = createMaterialNode("uberMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 	};
 
+	this.import = function( importStr )
+	{
+		// limit the key searches to this material
+        var endKey = "endMaterial\n";
+        var index = importStr.indexOf( endKey );
+        index += endKey.length;
+        importStr = importStr.substr( index );
+	}
+
+	this.export = function()
+	{
+		// every material needs the base type and instance name
+		var exportStr = "material: " + this.getShaderName() + "\n";
+		exportStr += "name: " + this.getName() + "\n";
+
+		var caps = this._ubershaderCaps;
+		
+		// export the material properties
+		if (typeof caps.material != 'undefined')
+		{
+			exportStr += "material: true\n";
+			exportStr += "ambientColor: " + caps.material.ambientColor + "\n";
+			exportStr += "diffuseColor: " + caps.material.diffuseColor + "\n";
+			exportStr += "specularColor: " + caps.material.specularColor + "\n";
+			exportStr += "specularPower: " + caps.material.specularPower + "\n";
+		}
+
+		if (typeof caps.lighting != 'undefined')
+		{
+			var light = caps.lighting['light' + i];
+			var t;
+			for (var i=0;  i<this._MAX_LIGHTS;  i++)
+			{
+				var light = caps.lighting["light" + i];
+				if( typeof light != "undefined")
+				{
+					exportStr += "light" + i + ': ' + light.type + "\n";
+
+					if (light.type === 'directional')
+					{
+						exportStr += 'light' + i + 'Dir: ' + light['direction'] + '\n';
+					}
+					else if (light.type === 'spot')
+					{
+						exportStr += 'light' + i + 'Pos: ' + light['position'] + '\n';
+
+						var deg2Rad = Math.PI / 180;
+						exportStr += 'light' + i + 'Spot: ' + [ Math.cos( ( light['spotInnerCutoff'] || 45.0 )  * deg2Rad ), 
+																Math.cos( ( light['spotOuterCutoff'] || 90.0 ) * deg2Rad )] + '\n';
+					}
+					else		// light.type === 'point'
+					{
+						technique['u_light'+i+'Pos'].set(light['position'] || [ 0, 0, 0 ]);                        
+						technique['u_light'+i+'Atten'].set(light['attenuation'] || [ 1,0,0 ]);                
+					}
+					exportStr += 'light' + i + 'Color: ' + light['diffuseColor'] || [ 1,1,1,1 ] + '\n';
+					exportStr += 'light' + i + 'SpecularColor: ' + light['specularColor'] || [ 1, 1, 1, 1 ] + '\n'; 
+					
+					exportStr += "endlight\n";          
+				}
+			}
+		}
+		
+		// every material needs to terminate like this
+		exportStr += "endMaterial\n";
+
+		return exportStr;
+	}
+
 	this.buildUberShader = function(caps)
 	{
 		var preproc = "";
diff --git a/js/helper-classes/backup-delete/Materials/WaterMaterial.js b/js/helper-classes/backup-delete/Materials/WaterMaterial.js
index 101a8c0c..49761c58 100644
--- a/js/helper-classes/backup-delete/Materials/WaterMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/WaterMaterial.js
@@ -22,7 +22,7 @@ function WaterMaterial()
 	this._name = "WaterMaterial";
 	this._shaderName = "water";
 
-	this._texMap = 'assets/images/rocky-normal.jpg';
+	this._texMap = 'assets/images/rocky-normal.jpg\n';
 
 	this._time = 0.0;
 	this._dTime = 0.01;
@@ -71,7 +71,7 @@ function WaterMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("waterMaterial");
+		this._materialNode = createMaterialNode("waterMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
diff --git a/js/helper-classes/backup-delete/Materials/ZInvertMaterial.js b/js/helper-classes/backup-delete/Materials/ZInvertMaterial.js
index 2ac8920f..c25290e3 100644
--- a/js/helper-classes/backup-delete/Materials/ZInvertMaterial.js
+++ b/js/helper-classes/backup-delete/Materials/ZInvertMaterial.js
@@ -71,7 +71,7 @@ function ZInvertMaterial()
 		this._shader.init();
 
 		// set up the material node
-		this._materialNode = createMaterialNode("zInvertMaterial");
+		this._materialNode = createMaterialNode("zInvertMaterial_" + world.generateUniqueNodeID());
 		this._materialNode.setShader(this._shader);
 
 		this._time = 0;
-- 
cgit v1.2.3