From cf61d1545bffb25a807706fb56b2fe7f291adc2c Mon Sep 17 00:00:00 2001
From: Nivesh Rajbhandari
Date: Tue, 6 Mar 2012 09:45:23 -0800
Subject: Create element models based on nodeName.

Signed-off-by: Nivesh Rajbhandari <mqg734@motorola.com>
---
 js/lib/NJUtils.js | 34 +++++++++++++++++++++++++++++++++-
 1 file changed, 33 insertions(+), 1 deletion(-)

(limited to 'js/lib')

diff --git a/js/lib/NJUtils.js b/js/lib/NJUtils.js
index e16715a4..4f1082f9 100755
--- a/js/lib/NJUtils.js
+++ b/js/lib/NJUtils.js
@@ -116,7 +116,39 @@ exports.NJUtils = Object.create(Object.prototype, {
     ///// TODO: Selection and model should be based on the element type
     makeModelFromElement: {
         value: function(el) {
-            this.makeElementModel(el, "Div", "block", false);
+            var selection = "div",
+                controller = "block",
+                isShape = false;
+            switch(el.nodeName.toLowerCase())
+            {
+                case "div":
+                    break;
+                case "img":
+                    selection = "image";
+                    controller = "image";
+                    break;
+                case "video":
+                    selection = "video";
+                    controller = "video";
+                    break;
+                case "canvas":
+                    isShape = el.getAttribute("data-RDGE-id");
+                    if(isShape)
+                    {
+                        // TODO - Need more info about the shape
+                        selection = "canvas";
+                        controller = "shape";
+                    }
+                    else
+                    {
+                        selection = "canvas";
+                        controller = "canvas";
+                    }
+                    break;
+                case "shape":
+                    break;
+            }
+            this.makeElementModel(el, selection, controller, isShape);
         }
     },
 
-- 
cgit v1.2.3


From 40f3fc5feae866c99af818a886e8bf9d8cf2b8dd Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Tue, 6 Mar 2012 17:23:58 -0800
Subject: merge Valerio's architecture changes into pen tool

---
 js/lib/geom/sub-path.js | 84 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)

(limited to 'js/lib')

diff --git a/js/lib/geom/sub-path.js b/js/lib/geom/sub-path.js
index ab54d1e9..0a65511b 100755
--- a/js/lib/geom/sub-path.js
+++ b/js/lib/geom/sub-path.js
@@ -584,6 +584,90 @@ 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 = [[this._Anchors[i].getPosX(),this._Anchors[i].getPosY(),this._Anchors[i].getPosZ()],
+                    [this._Anchors[i].getNextX(),this._Anchors[i].getNextY(),this._Anchors[i].getNextZ()],
+                    [this._Anchors[nextIndex].getPrevX(),this._Anchors[nextIndex].getPrevY(),this._Anchors[nextIndex].getPrevZ()],
+                    [this._Anchors[nextIndex].getPosX(),this._Anchors[nextIndex].getPosY(),this._Anchors[nextIndex].getPosZ()]];
+                var point = [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;
-- 
cgit v1.2.3


From 353bfa04a6153b0146a0c73b6e6bb0e5f4b23194 Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Tue, 6 Mar 2012 17:40:22 -0800
Subject: merge Valerio's architecture changes

---
 js/lib/geom/brush-stroke.js | 177 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 172 insertions(+), 5 deletions(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index 9a934928..39af5c5c 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -32,6 +32,8 @@ var BrushStroke = 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 = null;
     this._strokeStyle = "Solid";
 
@@ -114,7 +116,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 = 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]);
@@ -173,6 +175,14 @@ var BrushStroke = function GLBrushStroke() {
         this._strokeColor = c;
     };
 
+    this.setSecondStrokeColor = function(c){
+        this._secondStrokeColor=c;
+    }
+
+    this.setStrokeHardness = function(h){
+        this._strokeHardness=h;
+    }
+
     this.getStrokeStyle = function () {
         return this._strokeStyle;
     };
@@ -219,7 +229,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;
@@ -250,6 +261,44 @@ var BrushStroke = 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];
@@ -412,7 +461,7 @@ var BrushStroke = function GLBrushStroke() {
         }
         */
 
-
+        /*
         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
@@ -440,6 +489,109 @@ var BrushStroke = function GLBrushStroke() {
             //ctx.globalCompositeOperation = 'source-in';
             //ctx.rect(x-R, y-R, R2, R2);
         }
+        */
+
+        /*
+        //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();
+        }
 
         ctx.restore();
     }; //render()
@@ -473,10 +625,25 @@ var BrushStroke = function GLBrushStroke() {
         return true;
     };
 
-}; //function GLSubpath ...class definition
+}; //function BrushStroke ...class definition
 
 BrushStroke.prototype = new GeomObj();
 
+BrushStroke.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;
+}
 if (typeof exports === "object") {
     exports.BrushStroke = BrushStroke;
-}
\ No newline at end of file
+}
-- 
cgit v1.2.3


From 703fb3d06e88257ac73c1d1a0ec6ca33a64f4371 Mon Sep 17 00:00:00 2001
From: Pushkar Joshi
Date: Wed, 7 Mar 2012 14:33:21 -0800
Subject: implement stroke hardness such that it is percentage of the stroke
 width that's fully the color of the brush

AND
add a smoothing flag for the brush options
---
 js/lib/geom/brush-stroke.js | 66 +++++++++++++--------------------------------
 1 file changed, 19 insertions(+), 47 deletions(-)

(limited to 'js/lib')

diff --git a/js/lib/geom/brush-stroke.js b/js/lib/geom/brush-stroke.js
index 39af5c5c..3e64e730 100755
--- a/js/lib/geom/brush-stroke.js
+++ b/js/lib/geom/brush-stroke.js
@@ -36,6 +36,7 @@ var BrushStroke = function GLBrushStroke() {
     this._strokeHardness = 100;
     this._strokeMaterial = null;
     this._strokeStyle = "Solid";
+    this._strokeDoSmoothing = false;
 
     //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
@@ -183,6 +184,10 @@ var BrushStroke = function GLBrushStroke() {
         this._strokeHardness=h;
     }
 
+    this.setDoSmoothing = function(s){
+        this._strokeDoSmoothing = s;
+    }
+
     this.getStrokeStyle = function () {
         return this._strokeStyle;
     };
@@ -262,7 +267,7 @@ var BrushStroke = function GLBrushStroke() {
                 }
             }
             //**** add samples to the long sections of the path --- Catmull-Rom spline interpolation
-            if (numPoints>1) {
+            if (this._strokeDoSmoothing && 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];
@@ -507,35 +512,6 @@ var BrushStroke = function GLBrushStroke() {
             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';
@@ -566,30 +542,26 @@ var BrushStroke = function GLBrushStroke() {
         }
         */
 
-        /*
-        //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);
+        var minStrokeWidth = (this._strokeHardness*this._strokeWidth)/100; //the hardness is the percentage of the stroke width that's fully opaque
+        var numlayers = 1 + (this._strokeWidth-minStrokeWidth)/2;
+        var alphaVal = 1.0/(numlayers);
+        ctx.lineCap = "round";
+        ctx.lineJoin="round";
+        ctx.strokeStyle="rgba("+parseInt(255*this._strokeColor[0])+","+parseInt(255*this._strokeColor[1])+","+parseInt(255*this._strokeColor[2])+","+alphaVal+")";
+        ctx.globalCompositeOperation = 'lighter'; //we wish to add up the colors
+        ctx.globalAlpha = this._strokeColor[3];
         for (var l=0;l<numlayers;l++){
             ctx.beginPath();
             ctx.moveTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]);
+            if (numPoints===1){
+               ctx.lineTo(this._Points[0][0]-bboxMin[0], this._Points[0][1]-bboxMin[1]+0.01);
+            }
             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.lineWidth=2*l+minStrokeWidth;
             ctx.stroke();
         }
 
-- 
cgit v1.2.3


From 818582d389f504c915be0c9052fafa33e3e76c92 Mon Sep 17 00:00:00 2001
From: hwc487
Date: Wed, 7 Mar 2012 16:48:48 -0800
Subject: File IO

---
 js/lib/drawing/world.js                           |  90 ++--
 js/lib/geom/circle.js                             |   3 +-
 js/lib/geom/geom-obj.js                           |  47 ++
 js/lib/geom/rectangle.js                          |   4 +-
 js/lib/rdge/materials/bump-metal-material.js      |   4 +-
 js/lib/rdge/materials/deform-material.js          |   2 +-
 js/lib/rdge/materials/flat-material.js            |  41 +-
 js/lib/rdge/materials/fly-material.js             |   2 +-
 js/lib/rdge/materials/julia-material.js           |   2 +-
 js/lib/rdge/materials/keleidoscope-material.js    |   2 +-
 js/lib/rdge/materials/linear-gradient-material.js |   2 +-
 js/lib/rdge/materials/mandel-material.js          |   2 +-
 js/lib/rdge/materials/plasma-material.js          |   7 +-
 js/lib/rdge/materials/pulse-material.js           |   7 +-
 js/lib/rdge/materials/radial-blur-material.js     |   2 +-
 js/lib/rdge/materials/radial-gradient-material.js |   7 +-
 js/lib/rdge/materials/relief-tunnel-material.js   |   2 +-
 js/lib/rdge/materials/square-tunnel-material.js   |   2 +-
 js/lib/rdge/materials/star-material.js            |   2 +-
 js/lib/rdge/materials/taper-material.js           |   6 +-
 js/lib/rdge/materials/tunnel-material.js          |   2 +-
 js/lib/rdge/materials/twist-material.js           |   2 +-
 js/lib/rdge/materials/twist-vert-material.js      |   6 +-
 js/lib/rdge/materials/uber-material.js            |  71 ++-
 js/lib/rdge/materials/water-material.js           |   2 +-
 js/lib/rdge/materials/z-invert-material.js        |   2 +-
 js/lib/rdge/runtime/CanvasDataManager.js          |  83 +++
 js/lib/rdge/runtime/GLRuntime.js                  | 357 ++++++++++++
 js/lib/rdge/runtime/RuntimeGeomObj.js             | 630 ++++++++++++++++++++++
 js/lib/rdge/runtime/RuntimeMaterial.js            | 317 +++++++++++
 30 files changed, 1624 insertions(+), 84 deletions(-)
 create mode 100644 js/lib/rdge/runtime/CanvasDataManager.js
 create mode 100644 js/lib/rdge/runtime/GLRuntime.js
 create mode 100644 js/lib/rdge/runtime/RuntimeGeomObj.js
 create mode 100644 js/lib/rdge/runtime/RuntimeMaterial.js

(limited to 'js/lib')

diff --git a/js/lib/drawing/world.js b/js/lib/drawing/world.js
index 3d6c6fc4..b8bceda6 100755
--- a/js/lib/drawing/world.js
+++ b/js/lib/drawing/world.js
@@ -4,17 +4,6 @@ No rights, expressed or implied, whatsoever to this software are provided by Mot
 (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
 </copyright> */
 
-// Useless Global variables.
-// TODO: Remove this as soon as QE test pass
-/*
-var shaderProgramArray = new Array;
-var glContextArray = new Array;
-var vertexShaderSource = "";
-var fragmentShaderSource = "";
-var rdgeStarted = false;
-*/
-
-var nodeCounter = 0;
 
 var GeomObj = require("js/lib/geom/geom-obj").GeomObj;
 var Line = require("js/lib/geom/line").Line;
@@ -22,6 +11,8 @@ var Rectangle = require("js/lib/geom/rectangle").Rectangle;
 var Circle = require("js/lib/geom/circle").Circle;
 var MaterialsModel = require("js/models/materials-model").MaterialsModel;
 
+var worldCounter = 0;
+
 ///////////////////////////////////////////////////////////////////////
 // Class GLWorld
 //      Manages display in a canvas
@@ -76,6 +67,12 @@ var World = function GLWorld( canvas, use3D ) {
 	// no animated materials
 	this._firstRender = true;
 
+	this._worldCount = worldCounter;
+	worldCounter++;
+
+	// keep a counter for generating node names
+	this._nodeCounter = 0;
+
     ///////////////////////////////////////////////////////////////////////
     // Property accessors
     ///////////////////////////////////////////////////////////////////////
@@ -350,9 +347,12 @@ var World = 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
@@ -391,7 +391,7 @@ World.prototype.updateObject = function (obj) {
     if (nPrims > 0) {
         ctrTrNode = obj.getTransformNode();
 		if (ctrTrNode == null) {
-			ctrTrNode = createTransformNode("objRootNode_" + nodeCounter++);
+			ctrTrNode = createTransformNode("objRootNode_" + this._nodeCounter++);
 			this._rootNode.insertAsChild( ctrTrNode );
 			obj.setTransformNode( ctrTrNode );
 		}
@@ -401,7 +401,7 @@ World.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]);
     }
 	
@@ -420,12 +420,12 @@ World.prototype.updateObject = function (obj) {
 			});
 			childTrNode.meshes = [];
 		} 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]);
     }
 };
@@ -727,7 +727,7 @@ World.prototype.getShapeFromPoint = function( offsetX, offsetY ) {
 	}
 };
 
-World.prototype.export = function() {
+World.prototype.export = function( exportForPublish ) {
 	var exportStr = "GLWorld 1.0\n";
 	var id = this.getCanvas().getAttribute( "data-RDGE-id" );
 	exportStr += "id: " + id + "\n";
@@ -736,17 +736,28 @@ World.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";
-	} else {
+
+		// write out all of the objects
+		exportStr += "tree\n";
+		exportStr += this.exportObjects( this._geomRoot );
+		exportStr += "endtree\n";
+	}
+	else
+	{
 		// output the material library
-		exportStr += MaterialsModel.exportMaterials();
+		//exportStr += MaterialsLibrary.export();	// THIS NEEDS TO BE DONE AT THE DOC LEVEL
 
 		// write out all of the objects
 		exportStr += "tree\n";
@@ -800,21 +811,26 @@ World.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 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 );
-	} else {
-		// load the material library
-		importStr = MaterialsModel.importMaterials( importStr );
+	//var index = importStr.indexOf( "scenedata: " );
+	var index = importStr.indexOf( "webGL: " );
+	this._useWebGL = (index >= 0)
+	if (this._useWebGL)
+	{
+		// 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()
+	}
+
+	this.importObjects( importStr, this._rootNode );
 
-		// import the objects
-		this.importObjects( importStr, this._rootNode );
+	if (!this._useWebGL)
+	{
+		// render using canvas 2D
+		this.render();
 	}
 };
 
diff --git a/js/lib/geom/circle.js b/js/lib/geom/circle.js
index dd82a4cc..ad77383b 100755
--- a/js/lib/geom/circle.js
+++ b/js/lib/geom/circle.js
@@ -577,9 +577,10 @@ var Circle = function GLCircle() {
         } else {
 			rtnStr += "flatMaterial";
         }
-
 		rtnStr += "\n";
 
+		rtnStr += this.exportMaterials();
+
 		return rtnStr;
 	};
 
diff --git a/js/lib/geom/geom-obj.js b/js/lib/geom/geom-obj.js
index c5880843..852aab89 100755
--- a/js/lib/geom/geom-obj.js
+++ b/js/lib/geom/geom-obj.js
@@ -204,6 +204,53 @@ var GeomObj = 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) {
         var mat = Matrix.Translation( v );
         //var mat2 = mat.multiply( this._matrix );
diff --git a/js/lib/geom/rectangle.js b/js/lib/geom/rectangle.js
index 81b385b3..f91e830c 100755
--- a/js/lib/geom/rectangle.js
+++ b/js/lib/geom/rectangle.js
@@ -218,7 +218,6 @@ var Rectangle = function GLRectangle() {
         } else {
 			rtnStr += "flatMaterial";
         }
-
 		rtnStr += "\n";
 
 		rtnStr += "fillMat: ";
@@ -227,9 +226,10 @@ var Rectangle = function GLRectangle() {
         } else {
 			rtnStr += "flatMaterial";
         }
-
 		rtnStr += "\n";
 
+		rtnStr += this.exportMaterials();
+
 		return rtnStr;
 	};
 
diff --git a/js/lib/rdge/materials/bump-metal-material.js b/js/lib/rdge/materials/bump-metal-material.js
index 61126952..67b16371 100755
--- a/js/lib/rdge/materials/bump-metal-material.js
+++ b/js/lib/rdge/materials/bump-metal-material.js
@@ -75,7 +75,7 @@ var BumpMetalMaterial = 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;
 
 		// make sure we have legitimate imput
 		var ok = this.validateProperty( prop, value );
@@ -116,7 +116,7 @@ var BumpMetalMaterial = function BumpMetalMaterial() {
 		this._shader['default'].u_light0Diff.set( this.getLightDiff() );
 
 		// set up the material node
-		this._materialNode = createMaterialNode( this.getShaderName() );
+		this._materialNode = createMaterialNode( this.getShaderName() + "_" + world.generateUniqueNodeID() );
 		this._materialNode.setShader(this._shader);
 
 		// set some image maps
diff --git a/js/lib/rdge/materials/deform-material.js b/js/lib/rdge/materials/deform-material.js
index 1e6af6ac..dfd89d12 100644
--- a/js/lib/rdge/materials/deform-material.js
+++ b/js/lib/rdge/materials/deform-material.js
@@ -60,7 +60,7 @@ var DeformMaterial = 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/lib/rdge/materials/flat-material.js b/js/lib/rdge/materials/flat-material.js
index be8bf2b8..97e4f646 100755
--- a/js/lib/rdge/materials/flat-material.js
+++ b/js/lib/rdge/materials/flat-material.js
@@ -36,19 +36,27 @@ var FlatMaterial = 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();
-
-        // set the defaults
-		this._shader.colorMe.color.set( this.getColor() );
-
-		// set up the material node
-		this._materialNode = createMaterialNode("flatMaterial");
-		this._materialNode.setShader(this._shader);
+		// 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 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" );
 	};
 
 
@@ -73,15 +81,12 @@ var FlatMaterial = function FlatMaterial() {
 	};
     ///////////////////////////////////////////////////////////////////////
 
-	this.export = function() {
+	this.export = function()
+	{
 		// 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/lib/rdge/materials/fly-material.js b/js/lib/rdge/materials/fly-material.js
index 8eadb3ab..bd92ecd8 100644
--- a/js/lib/rdge/materials/fly-material.js
+++ b/js/lib/rdge/materials/fly-material.js
@@ -53,7 +53,7 @@ var FlyMaterial = 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/lib/rdge/materials/julia-material.js b/js/lib/rdge/materials/julia-material.js
index 07536f33..976dfad3 100644
--- a/js/lib/rdge/materials/julia-material.js
+++ b/js/lib/rdge/materials/julia-material.js
@@ -55,7 +55,7 @@ var JuliaMaterial = 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/lib/rdge/materials/keleidoscope-material.js b/js/lib/rdge/materials/keleidoscope-material.js
index 3ef5d613..16d1ccfa 100644
--- a/js/lib/rdge/materials/keleidoscope-material.js
+++ b/js/lib/rdge/materials/keleidoscope-material.js
@@ -60,7 +60,7 @@ var KeleidoscopeMaterial = 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/lib/rdge/materials/linear-gradient-material.js b/js/lib/rdge/materials/linear-gradient-material.js
index 2c52c67d..8e05e23d 100755
--- a/js/lib/rdge/materials/linear-gradient-material.js
+++ b/js/lib/rdge/materials/linear-gradient-material.js
@@ -212,7 +212,7 @@ var LinearGradientMaterial = 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/lib/rdge/materials/mandel-material.js b/js/lib/rdge/materials/mandel-material.js
index 07e009a2..d9f00383 100644
--- a/js/lib/rdge/materials/mandel-material.js
+++ b/js/lib/rdge/materials/mandel-material.js
@@ -66,7 +66,7 @@ var MandelMaterial = 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/lib/rdge/materials/plasma-material.js b/js/lib/rdge/materials/plasma-material.js
index 9ecc2b48..62d0db70 100644
--- a/js/lib/rdge/materials/plasma-material.js
+++ b/js/lib/rdge/materials/plasma-material.js
@@ -54,7 +54,10 @@ var PlasmaMaterial = function PlasmaMaterial() {
         return new PlasmaMaterial();
     };
 
-	this.init = function() {
+	this.init = function( world)
+	{
+		this.setWorld( world );
+
 		// set up the shader
 		this._shader = new jshader();
 		this._shader.def = plasmaShaderDef;
@@ -66,7 +69,7 @@ var PlasmaMaterial = 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/lib/rdge/materials/pulse-material.js b/js/lib/rdge/materials/pulse-material.js
index 63cab2f4..1e3137eb 100644
--- a/js/lib/rdge/materials/pulse-material.js
+++ b/js/lib/rdge/materials/pulse-material.js
@@ -101,7 +101,7 @@ var PulseMaterial = 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;
@@ -178,6 +178,9 @@ var PulseMaterial = 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";
@@ -193,6 +196,8 @@ var PulseMaterial = function PulseMaterial() {
 
 		var rtnStr;
         try {
+			this._propValues[this._propNames[0]] = pu.nextValue( "texture: " );
+
             var endKey = "endMaterial\n";
             var index = importStr.indexOf( endKey );
             index += endKey.length;
diff --git a/js/lib/rdge/materials/radial-blur-material.js b/js/lib/rdge/materials/radial-blur-material.js
index 41e68182..89116af4 100644
--- a/js/lib/rdge/materials/radial-blur-material.js
+++ b/js/lib/rdge/materials/radial-blur-material.js
@@ -94,7 +94,7 @@ var RadialBlurMaterial = 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/lib/rdge/materials/radial-gradient-material.js b/js/lib/rdge/materials/radial-gradient-material.js
index 13be50f5..d19b44b7 100755
--- a/js/lib/rdge/materials/radial-gradient-material.js
+++ b/js/lib/rdge/materials/radial-gradient-material.js
@@ -193,14 +193,17 @@ var RadialGradientMaterial = function RadialGradientMaterial() {
         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/lib/rdge/materials/relief-tunnel-material.js b/js/lib/rdge/materials/relief-tunnel-material.js
index 20290895..52c40543 100644
--- a/js/lib/rdge/materials/relief-tunnel-material.js
+++ b/js/lib/rdge/materials/relief-tunnel-material.js
@@ -54,7 +54,7 @@ var ReliefTunnelMaterial = 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/lib/rdge/materials/square-tunnel-material.js b/js/lib/rdge/materials/square-tunnel-material.js
index b5cbff30..9264872f 100644
--- a/js/lib/rdge/materials/square-tunnel-material.js
+++ b/js/lib/rdge/materials/square-tunnel-material.js
@@ -55,7 +55,7 @@ var SquareTunnelMaterial = 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/lib/rdge/materials/star-material.js b/js/lib/rdge/materials/star-material.js
index 9c0f3172..d7d797e4 100644
--- a/js/lib/rdge/materials/star-material.js
+++ b/js/lib/rdge/materials/star-material.js
@@ -55,7 +55,7 @@ var StarMaterial = 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/lib/rdge/materials/taper-material.js b/js/lib/rdge/materials/taper-material.js
index eeb08aec..bd89f08f 100644
--- a/js/lib/rdge/materials/taper-material.js
+++ b/js/lib/rdge/materials/taper-material.js
@@ -42,8 +42,10 @@ function TaperMaterial()
 	// duplcate method requirde
 	this.dup = function()	{  return new TaperMaterial();	} 
 
-	this.init = function()
+	this.init = function( world )
 	{
+		this.setWorld( world );
+
 		// set up the shader
 		this._shader = new jshader();
 		this._shader.def = taperShaderDef;
@@ -53,7 +55,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/lib/rdge/materials/tunnel-material.js b/js/lib/rdge/materials/tunnel-material.js
index fe787d16..fe0fbd51 100644
--- a/js/lib/rdge/materials/tunnel-material.js
+++ b/js/lib/rdge/materials/tunnel-material.js
@@ -56,7 +56,7 @@ var TunnelMaterial = 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/lib/rdge/materials/twist-material.js b/js/lib/rdge/materials/twist-material.js
index eb562e99..163c8a77 100644
--- a/js/lib/rdge/materials/twist-material.js
+++ b/js/lib/rdge/materials/twist-material.js
@@ -56,7 +56,7 @@ var TwistMaterial = 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/lib/rdge/materials/twist-vert-material.js b/js/lib/rdge/materials/twist-vert-material.js
index c2573071..05172a1b 100644
--- a/js/lib/rdge/materials/twist-vert-material.js
+++ b/js/lib/rdge/materials/twist-vert-material.js
@@ -46,8 +46,10 @@ function TwistVertMaterial()
 	// duplcate method requirde
 	this.dup = function()	{  return new TwistVertMaterial();	} 
 
-	this.init = function()
+	this.init = function( world )
 	{
+		this.setWorld( world );
+
 		// set up the shader
 		this._shader = new jshader();
 		this._shader.def = twistVertShaderDef;
@@ -57,7 +59,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/lib/rdge/materials/uber-material.js b/js/lib/rdge/materials/uber-material.js
index 6bc35d51..0964c9c4 100755
--- a/js/lib/rdge/materials/uber-material.js
+++ b/js/lib/rdge/materials/uber-material.js
@@ -363,10 +363,79 @@ var UberMaterial = 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/lib/rdge/materials/water-material.js b/js/lib/rdge/materials/water-material.js
index 92b96b18..cac5a249 100644
--- a/js/lib/rdge/materials/water-material.js
+++ b/js/lib/rdge/materials/water-material.js
@@ -57,7 +57,7 @@ var WaterMaterial = 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/lib/rdge/materials/z-invert-material.js b/js/lib/rdge/materials/z-invert-material.js
index 051b724f..a0d20de5 100644
--- a/js/lib/rdge/materials/z-invert-material.js
+++ b/js/lib/rdge/materials/z-invert-material.js
@@ -55,7 +55,7 @@ var ZInvertMaterial = 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;
diff --git a/js/lib/rdge/runtime/CanvasDataManager.js b/js/lib/rdge/runtime/CanvasDataManager.js
new file mode 100644
index 00000000..265fee13
--- /dev/null
+++ b/js/lib/rdge/runtime/CanvasDataManager.js
@@ -0,0 +1,83 @@
+/* <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 GeomObj			= require("js/lib/geom/geom-obj").GeomObj;
+var ShapePrimitive	= require("js/lib/geom/shape-primitive").ShapePrimitive;
+var MaterialsModel	= require("js/models/materials-model").MaterialsModel;
+var GLRuntime		= require("js/lib/rdge/runtime/GLRuntime").GLRuntime;
+
+///////////////////////////////////////////////////////////////////////
+// Class ShapeRuntime
+//      Manages runtime shape display
+///////////////////////////////////////////////////////////////////////
+var CanvasDataManager = function CanvasDataManager()
+{
+	this.loadGLData = function(root,  valueArray,  NinjaUtils)
+	{
+		var value = valueArray;
+		var nWorlds = value.length;
+		for (var i=0;  i<nWorlds;  i++)
+		{
+			var importStr = value[i];
+			var startIndex = importStr.indexOf( "id: " );
+			if (startIndex >= 0)
+			{
+				var endIndex = importStr.indexOf( "\n", startIndex );
+				if (endIndex > 0)
+				{
+					var id = importStr.substring( startIndex+4, endIndex );
+					var canvas = this.findCanvasWithID( id, root );
+					if (canvas)
+					{
+						var rt = new GLRuntime( canvas, importStr );
+					}
+				}
+			}
+		}
+	}
+
+	this.collectGLData = function( elt,  dataArray )
+	{
+		if (elt.elementModel && elt.elementModel.shapeModel && elt.elementModel.shapeModel.GLWorld)
+		{
+			var data = elt.elementModel.shapeModel.GLWorld.export( true );
+			dataArray.push( data );
+		}
+
+		if (elt.children)
+		{
+			var nKids = elt.children.length;
+			for (var i=0;  i<nKids;  i++)
+			{
+				var child = elt.children[i];
+				this.collectGLData( child, dataArray );
+			}
+		}
+	}
+
+	this.findCanvasWithID = function( id,  elt )
+	{
+		var cid = elt.getAttribute( "data-RDGE-id" );
+		if (cid == id)  return elt;
+
+		if (elt.children)
+		{
+			var nKids = elt.children.length;
+			for (var i=0;  i<nKids;  i++)
+			{
+				var child = elt.children[i];
+				var foundElt = this.findCanvasWithID( id, child );
+				if (foundElt)  return foundElt;
+			}
+		}
+	}
+}
+
+
+if (typeof exports === "object") {
+    exports.CanvasDataManager = CanvasDataManager;
+}
diff --git a/js/lib/rdge/runtime/GLRuntime.js b/js/lib/rdge/runtime/GLRuntime.js
new file mode 100644
index 00000000..a4da8549
--- /dev/null
+++ b/js/lib/rdge/runtime/GLRuntime.js
@@ -0,0 +1,357 @@
+/* <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	GeomObj					= require("js/lib/geom/geom-obj").GeomObj,
+	RuntimeGeomObj			= require("js/lib/rdge/runtime/RuntimeGeomObj"),
+	RuntimeRectangle		= RuntimeGeomObj.RuntimeRectangle,
+	RuntimeOval				= RuntimeGeomObj.RuntimeOval,
+	getPropertyFromString	= require("js/lib/rdge/runtime/RuntimeGeomObj").getPropertyFromString;
+
+///////////////////////////////////////////////////////////////////////
+// Class GLRuntime
+//      Manages runtime fora WebGL canvas
+///////////////////////////////////////////////////////////////////////
+var GLRuntime = function GLRuntime( canvas, importStr )
+{
+    ///////////////////////////////////////////////////////////////////////
+    // Instance variables
+    ///////////////////////////////////////////////////////////////////////
+	this._canvas		= canvas;
+	this._context		= null;
+	this._importStr		= importStr;
+
+	this.renderer		= null;
+	this.myScene		= null;
+	this.light			= null;
+	this.light2			= null;
+	this._rootNode		= null;
+
+	this._firstRender	= true;
+	this._initialized	= false;
+
+	this._useWebGL		= false;
+
+	// view parameters
+	this._fov = 45.0;
+	this._zNear = 0.1;
+	this._zFar = 100.0;
+	this._viewDist = 5.0;
+
+	this._aspect = canvas.width/canvas.height;
+
+	this._geomRoot;
+
+	// all "live" materials
+	this._materials = [];
+
+    ///////////////////////////////////////////////////////////////////////
+	// accessors
+    ///////////////////////////////////////////////////////////////////////
+	this.getZNear			= function()		{  return this._zNear;			}
+	this.getZFar			= function()		{  return this._zFar;			}
+	this.getFOV				= function()		{  return this._fov;			}
+	this.getAspect			= function()		{  return this._aspect;			}
+	this.getViewDistance	= function()		{  return this._viewDist;		}
+
+	this.get2DContext		= function()		{  return this._context;		}
+
+	this.getViewportWidth	= function()		{  return this._canvas.width;	}
+	this.getViewportHeight	= function()		{  return this._canvas.height;	}
+
+    ///////////////////////////////////////////////////////////////////////
+	// accessors
+    ///////////////////////////////////////////////////////////////////////
+	this.loadScene = function()
+	{
+		// parse the data
+		// the GL runtime must start with a "sceneData: "
+		var index = importStr.indexOf( "scenedata: " );
+		if (index >= 0)
+		{
+			this._useWebGL = true;
+
+			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 );
+			this.importObjects( importStr );
+			this.linkMaterials( this._geomRoot );
+			this.initMaterials();
+		}
+		else
+		{
+			this._context = this._canvas.getContext( "2d" );
+			this.importObjects( importStr );
+			this.render();
+		}
+	}
+
+	this.init = function()
+    { 
+		var ctx1 = g_Engine.ctxMan.handleToObject(this._canvas.rdgeCtxHandle),
+			ctx2 = g_Engine.getContext();
+		if (ctx1 != ctx2)  console.log( "***** different contexts *****" );
+		this.renderer = ctx1.renderer;
+      
+		// create a camera, set its perspective, and then point it at the origin
+		var cam = new camera();
+		this._camera = cam;
+		cam.setPerspective(this.getFOV(), this.getAspect(), this.getZNear(), this.getZFar());
+		cam.setLookAt([0, 0, this.getViewDistance()], [0, 0, 0], vec3.up());
+        
+		// make this camera the active camera
+		this.renderer.cameraManager().setActiveCamera(cam);
+
+		// change clear color
+		this.renderer.setClearColor([1.0, 1.0, 1.0, 0.0]);
+        
+		// create an empty scene graph
+		this.myScene = new SceneGraph();
+
+		// load the scene graph data
+		this.loadScene();
+        
+		// Add the scene to the engine - necessary if you want the engine to draw for you
+		var name = "myScene" + this._canvas.getAttribute( "data-RDGE-id" ); 
+		g_Engine.AddScene(name, this.myScene);
+
+		this._initialized = true;
+	}
+    
+	// main code for handling user interaction and updating the scene   
+	this.update = function(dt)
+    {
+		if (this._initialized)
+		{
+			if (!dt)  dt = 0.2;
+        
+			dt = 0.01;	// use our own internal throttle
+			this.elapsed += dt;
+        
+			// changed the global position uniform of light 0, another way to change behavior of a light
+			rdgeGlobalParameters.u_light0Pos.set( [5*Math.cos(this.elapsed), 5*Math.sin(this.elapsed), 20]);
+        
+			// orbit the light nodes around the boxes
+			//this.light.setPosition([1.2*Math.cos(this.elapsed*2.0), 1.2*Math.sin(this.elapsed*2.0), 1.2*Math.cos(this.elapsed*2.0)]);
+			//this.light2.setPosition([-1.2*Math.cos(this.elapsed*2.0), 1.2*Math.sin(this.elapsed*2.0), -1.2*Math.cos(this.elapsed)]);
+
+			this.updateMaterials();
+
+			// now update all the nodes in the scene
+			this.myScene.update(dt);
+		}
+    }
+
+	this.updateMaterials = function()
+	{
+		var nMats = this._materials.length;
+		for (var i=0;  i<nMats;  i++)
+		{
+			var mat = this._materials[i];
+			mat.update();
+		}
+	}
+
+    // defining the draw function to control how the scene is rendered      
+	this.draw = function()
+    {
+		if (this._initialized)
+		{
+			g_Engine.setContext( this._canvas.rdgeid );
+
+			var ctx = g_Engine.getContext();
+			var renderer = ctx.renderer;
+			if (renderer.unloadedTextureCount <= 0)
+			{
+				renderer.disableCulling();
+				renderer._clear();
+				this.myScene.render();
+
+				if (this._firstRender)
+				{
+					if (this._canvas.task)
+					{
+						this._firstRender = false;
+						//this._canvas.task.stop();
+					}
+				}
+			}
+		}
+    }
+
+	this.importObjects = function( importStr,  parent )
+	{
+		var index = importStr.indexOf( "OBJECT\n", 0 );
+		while (index >= 0)
+		{
+			// update the string to the current object
+			importStr = importStr.substr( index+7 );
+
+			// read the next object
+			var obj = this.importObject( importStr, parent );
+
+			// determine if we have children
+			var endIndex = importStr.indexOf( "ENDOBJECT\n" ),
+				childIndex = importStr.indexOf( "OBJECT\n" );
+			if (endIndex < 0)  throw new Error( "ill-formed object data" );
+			if ((childIndex >= 0) && (childIndex < endIndex))
+			{
+				importStr = importStr.substr( childIndex + 7 );
+				importStr = this.importObjects( importStr, obj );
+				endIndex = importStr.indexOf( "ENDOBJECT\n" )
+			}
+
+			// remove the string for the object(s) just created
+			importStr = importStr.substr( endIndex );
+
+			// get the location of the next object
+			index = importStr.indexOf( "OBJECT\n", endIndex );
+		}
+
+		return importStr;
+	}
+
+	this.importObject = function( objStr,  parent )
+	{
+		var type = Number( getPropertyFromString( "type: ", objStr ) );
+
+		var obj;
+		switch (type)
+		{
+			case 1:
+				obj = new RuntimeRectangle();
+				obj.import( objStr, parent );
+				break;
+
+			case 2:		// circle
+				obj = new RuntimeOval();
+				obj.import( objStr, parent );
+				break;
+
+			case 3:		// line
+				obj = new RuntimeLine();
+				obj.import( objStr, parent );
+				break;
+
+			default:
+				throw new Error( "Attempting to load unrecognized object type: " + type );
+				break;
+		}
+
+		if (obj)
+			this.addObject( obj );
+
+		return obj;
+	}
+
+	this.addObject = function( obj, parent )
+	{
+		if (!obj)  return;
+		obj.setWorld( this );
+
+		if (parent == null)
+			this._geomRoot = obj;
+		else
+			parent.addChild( obj );
+	}
+
+	this.linkMaterials = function( obj )
+	{
+		if (!obj)  return;
+
+		// get the array of materials from the object
+		var matArray = obj._materials;
+		var nMats = matArray.length;
+		for (var i=0;  i<nMats;  i++)
+		{
+			var mat = matArray[i];
+			var nodeName = mat._materialNodeName;
+			var matNode = this.findMaterialNode( nodeName, this.myScene.scene );
+			if (matNode)
+			{
+				mat._materialNode = matNode;
+				mat._shader = matNode.shaderProgram;
+				this._materials.push( mat );
+			}
+		}
+	}
+
+	this.initMaterials = function()
+	{
+		var nMats = this._materials.length;
+		for (var i=0;  i<nMats;  i++)
+		{
+			var mat = this._materials[i];
+			mat.init();
+		}
+	}
+
+	this.findMaterialNode = function( nodeName,  node )
+	{
+		if (node.transformNode)
+			node = node.transformNode;
+
+		if (node.materialNode)
+		{
+			if (nodeName === node.materialNode.name)  return node.materialNode;
+		}
+
+		if (node.children)
+		{
+			var nKids = node.children.length;
+			for (var i=0;  i<nKids;  i++)
+			{
+				var child = node.children[i];
+				var rtnNode = this.findMaterialNode( nodeName, child );
+				if (rtnNode)  return rtnNode;
+			}
+		}
+	}
+
+	this.render = function( obj )
+	{
+		if (!obj)  obj = this._geomRoot;
+		obj.render();
+
+		if (obj.children)
+		{
+			var nKids = obj.children.length;
+			for (var i=0;  i<nKids;  i++)
+			{
+				var child = obj.children[i];
+				if (child)
+					this.render( child );
+			}
+		}
+	}
+
+	// start RDGE or load Canvas 2D objects
+	var index = importStr.indexOf( "scenedata: " );
+	this._useWebGL = (index >= 0);
+	if (this._useWebGL)
+	{
+		var id = canvas.getAttribute( "data-RDGE-id" ); 
+		canvas.rdgeid = id;
+		g_Engine.registerCanvas(canvas, this);
+		RDGEStart( canvas );
+	}
+	else
+	{
+		this.loadScene();
+	}
+}
+
+
+if (typeof exports === "object") {
+    exports.GLRuntime = GLRuntime;
+}
+
+
+
diff --git a/js/lib/rdge/runtime/RuntimeGeomObj.js b/js/lib/rdge/runtime/RuntimeGeomObj.js
new file mode 100644
index 00000000..5b212dce
--- /dev/null
+++ b/js/lib/rdge/runtime/RuntimeGeomObj.js
@@ -0,0 +1,630 @@
+
+/* <copyright>
+This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+No rights, expressed or implied, whatsoever t