Conversion to JSON based file IO for canvas2D and WebGL rendering

16 files changed, 923 insertions, 51 deletions

diff --git a/js/document/html-document.js b/js/document/html-document.js
index d4db6e2f..bf03e38b 100755
--- a/js/document/html-document.js
+++ b/js/document/html-document.js
@@ -194,11 +194,7 @@ exports.HTMLDocument = Montage.create(TextDocument, {
                         //
                         if (elt) {
                                 this._glData = [];
-                                //if (path) {
-                                        //this.collectGLData(elt, this._glData, path);
-                                //} else {
-                                        this.collectGLData(elt, this._glData );
-                                //}
+                                this.collectGLData(elt, this._glData );
                         } else {
                                 this._glData = null
                         }
@@ -220,25 +216,26 @@ exports.HTMLDocument = Montage.create(TextDocument, {
 
                                         // /*
                                         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 );
-                                                        if (id) {
-                                                                var canvas = this.findCanvasWithID( id, elt );
-                                                                if (canvas) {
-                                                                        if (!canvas.elementModel) {
-                                                                                NJUtils.makeElementModel(canvas, "Canvas", "shape", true);
+                                        var jObj = JSON.parse( importStr );
+                                        if (jObj)
+                                        {
+                                                var id = jObj.id;
+                                                if (id)
+                                                {
+                                                        var canvas = this.findCanvasWithID( id, elt );
+                                                        if (canvas) {
+                                                                if (!canvas.elementModel) {
+                                                                        NJUtils.makeElementModel(canvas, "Canvas", "shape", true);
+                                                                }
+                                                                if (canvas.elementModel) {
+                                                                        if (canvas.elementModel.shapeModel.GLWorld) {
+                                                                                canvas.elementModel.shapeModel.GLWorld.clearTree();
                                                                         }
-                                                                        if (canvas.elementModel) {
-                                                                                if (canvas.elementModel.shapeModel.GLWorld) {
-                                                                                        canvas.elementModel.shapeModel.GLWorld.clearTree();
-                                                                                }
-                                                                                var index = importStr.indexOf( "webGL: " );
-                                                                                var useWebGL = (index >= 0)
+                                                                        if (jObj)
+                                                                        {
+                                                                                var useWebGL = jObj.webGL;
                                                                                 var world = new GLWorld( canvas, useWebGL );
-                                                                                world.import( importStr );
+                                                                                world.importJSON( jObj );
                                                                                 this.buildShapeModel( canvas.elementModel, world );
                                                                         }
                                                                 }
@@ -382,7 +379,7 @@ exports.HTMLDocument = Montage.create(TextDocument, {
                 {
                         if (elt.elementModel && elt.elementModel.shapeModel && elt.elementModel.shapeModel.GLWorld)
                         {
-                                var data = elt.elementModel.shapeModel.GLWorld.export();
+                                var data = elt.elementModel.shapeModel.GLWorld.exportJSON();
                                 dataArray.push( data );
                         }
 
diff --git a/js/lib/drawing/world.js b/js/lib/drawing/world.js
index 44c9e37d..9e502c3e 100755
--- a/js/lib/drawing/world.js
+++ b/js/lib/drawing/world.js
@@ -727,6 +727,57 @@ World.prototype.getShapeFromPoint = function( offsetX, offsetY ) {
         }
 };
 
+World.prototype.exportJSON = function()
+{
+        // world properties
+        var worldObj = 
+        {
+                'version'       : 1.1,
+                'id'            : this.getCanvas().getAttribute( "data-RDGE-id" ),
+                'fov'           : this._fov,
+                'zNear'         : this._zNear,
+                'zFar'          : this._zFar,
+                'viewDist'      : this._viewDist,
+                'webGL'         : this._useWebGL
+        };
+
+        // RDGE scenegraph
+        if (this._useWebGL)
+                worldObj.scenedata = this.myScene.exportJSON();
+
+        // object data
+        var strArray = [];
+        this.exportObjectsJSON( this._geomRoot, worldObj );
+
+        // convert the object to a string
+        var jStr = JSON.stringify( worldObj );
+
+        // the RDGE export function corrupts the data.
+        // rebuild the tree
+        var root = this._rootNode;
+        root.children = new Array();
+        if (worldObj.children && (worldObj.children.length === 1))
+                this.importObjectsJSON( worldObj.children[0] );
+        
+        return jStr;
+}
+
+World.prototype.exportObjectsJSON = function( obj,  parentObj )
+{
+        if (!obj)  return;
+
+        var jObj = obj.exportJSON();
+        if (!parentObj.children)  parentObj.children = [];
+        parentObj.children.push( jObj );
+
+        if (obj.getChild()) {
+                 this.exportObjects( obj.getChild (), jObj  );
+    }
+
+        if (obj.getNext())
+                this.exportObjects( obj.getNext(), parentObj );
+}
+
 World.prototype.export = function()
 {
         var exportStr = "GLWorld 1.0\n";
@@ -808,6 +859,83 @@ World.prototype.findTransformNodeByMaterial = function( materialNode,  trNode )
         return rtnNode;
 };
 
+World.prototype.importJSON = function( jObj )
+{
+        if (jObj.webGL)
+        {
+                // 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()
+        }
+
+        // import the objects
+        // there should be exactly one child of the parent object
+        if (jObj.children && (jObj.children.length === 1))
+                this.importObjectsJSON( jObj.children[0] );
+        else
+                throw new Error ("unrecoverable canvas import error - inconsistent root object: " + jObj.children );
+
+        if (!this._useWebGL)
+        {
+                // render using canvas 2D
+                this.render();
+        }
+}
+
+World.prototype.importObjectsJSON = function( jObj,  parentGeomObj )
+{
+        // read the next object
+        var gObj = this.importObjectJSON( jObj,  parentGeomObj );
+
+        // determine if we have children
+        if (jObj.children)
+        {
+                var nKids = ojObjbj.chilodren.length;
+                for (var i=0;  i<nKids;  i++)
+                {
+                        var child = jObj.children[i];
+                        this.importObjectsJSON( child, gObj );
+                }
+        }
+}
+
+World.prototype.importObjectJSON = function( jObj, parentGeomObj )
+{
+        var type = jObj.type;
+
+        var obj;
+        switch (type)
+        {
+                case 1:
+                        obj = new Rectangle();
+                        obj.importJSON( jObj );
+                        break;
+
+                case 2:         // circle
+                        obj = new Circle();
+                        obj.importJSON( jObj );
+                        break;
+
+                case 3:         // line
+            obj = new Line();
+            obj.importJSON( jObj );
+            break;
+
+                default:
+                        throw new Error( "Unrecognized object type: " + type );
+                        break;