Merge branch 'timeline-local' into timeline-multiselect

Conflicts:
	js/panels/Timeline/TimelinePanel.reel/TimelinePanel.js
	resolved using theirs. (selectLayers)

1 files changed, 1536 insertions, 1462 deletions

diff --git a/assets/canvas-runtime.js b/assets/canvas-runtime.js
index ce2a15de..eeafaab6 100644
--- a/assets/canvas-runtime.js
+++ b/assets/canvas-runtime.js
@@ -17,7 +17,7 @@ NinjaCvsRt.initWebGl = function (rootElement, directory) {
                 }
         }
         //Creating data manager
-        cvsDataMngr = new NinjaCvsRt.CanvasDataManager();
+        cvsDataMngr = Object.create(NinjaCvsRt.CanvasDataManager, {});
         //Loading data to canvas(es)
         cvsDataMngr.loadGLData(rootElement, ninjaWebGlData.data, directory);
 };
@@ -26,1024 +26,870 @@ NinjaCvsRt.initWebGl = function (rootElement, directory) {
 // Class ShapeRuntime
 //      Manages runtime shape display
 ///////////////////////////////////////////////////////////////////////
-NinjaCvsRt.CanvasDataManager = function () 
-{
-        this.loadGLData = function(root,  valueArray,  assetPath )
-        {
-                if (assetPath)
-                        this._assetPath = assetPath.slice();
-
-                var value = valueArray;
-                var nWorlds = value.length;
-                for (var i=0;  i<nWorlds;  i++)
-                {
-                        var importStr = value[i];
-
-                        // there should be some version information in
-                        // the form of 'v0.0;'  Pull that off.  (the trailing ';' should
-                        // be in the first 24 characters).
-                        var index = importStr.indexOf( ';' );
-                        if ((importStr[0] === 'v') && (index < 24))
-                        {
-                                // JSON format.  pull off the version info
-                                importStr = importStr.substr( index+1 );
-
-                                var jObj = JSON.parse( importStr );
-                                var id = jObj.id;
-                                if (id)
-                                {
-                                        var canvas = this.findCanvasWithID( id, root );
-                                        if (canvas)
-                                        {
-                                                new NinjaCvsRt.GLRuntime( canvas, jObj,  assetPath );
-                                        }
-                                }
-                        }
-                }
-        };
-
-        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;
-                        }
-                }
-        };
-};
+NinjaCvsRt.CanvasDataManager = Object.create(Object.prototype, {
+
+    loadGLData: {
+        value: function(root, valueArray, assetPath) {
+            if (assetPath)
+                this._assetPath = assetPath.slice();
+
+            var value = valueArray;
+            var nWorlds = value.length;
+            for (var i=0;  i<nWorlds;  i++)
+            {
+                var importStr = value[i];
+
+                // there should be some version information in
+                // the form of 'v0.0;'  Pull that off.  (the trailing ';' should
+                // be in the first 24 characters).
+                var index = importStr.indexOf( ';' );
+                if ((importStr[0] === 'v') && (index < 24))
+                {
+                    // JSON format.  pull off the version info
+                    importStr = importStr.substr( index+1 );
+
+                    var jObj = JSON.parse( importStr );
+                    var id = jObj.id;
+                    if (id)
+                    {
+                        var canvas = this.findCanvasWithID( id, root );
+                        if (canvas)
+                        {
+//                            new NinjaCvsRt.GLRuntime( canvas, jObj,  assetPath );
+                            var glRt = Object.create(NinjaCvsRt.GLRuntime, {});
+                            glRt.renderWorld(canvas, jObj, this._assetPath);
+                        }
+                    }
+                }
+            }
+            }
+    },
+
+    findCanvasWithID: {
+        value: 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;
+                }
+            }
+        }
+    }
+});
 
 ///////////////////////////////////////////////////////////////////////
 // Class GLRuntime
 //      Manages runtime fora WebGL canvas
 ///////////////////////////////////////////////////////////////////////
-NinjaCvsRt.GLRuntime = function ( canvas, jObj,  assetPath )
-{
+NinjaCvsRt.GLRuntime = Object.create(Object.prototype, {
     ///////////////////////////////////////////////////////////////////////
     // Instance variables
     ///////////////////////////////////////////////////////////////////////
-        this._canvas            = canvas;
-        this._context           = null;
+    _canvas: { value: null, writable: true },
+    _context : { value: null, writable: true },
         //this._importStr               = importStr;
-        this._jObj                      = jObj;
+    _jObj: { value: null, writable: true },
 
-        this.renderer           = null;
-        this.myScene            = null;
-        this.light                      = null;
-        this.light2                     = null;
-        this._rootNode          = null;
+    _renderer: { value: null, writable: true },
+    myScene: { value: null, writable: true },
+    light: { value: null, writable: true },
+    light2: { value: null, writable: true },
+    _rootNode: { value: null, writable: true },
 
-        this._firstRender       = true;
-        this._initialized       = false;
+    _firstRender: { value: true, writable: true },
+    _renderCount: { value: -1, writable: true },
+    _initialized: { value: false, writable: true },
 
-        this._useWebGL          = false;
-        this._assetPath     = undefined;
+    _useWebGL: { value: false, writable: true },
+    _assetPath: { value: undefined, writable: true },
 
-        // view parameters
-        this._fov = 45.0;
-        this._zNear = 0.1;
-        this._zFar = 100.0;
-        this._viewDist = 5.0;
+    // view parameters
+    _fov: { value: 45.0, writable: true },
+    _zNear: { value: 0.1, writable: true },
+    _zFar: { value: 100.0, writable: true },
+    _viewDist: { value: 5.0, writable: true },
 
-        this.elapsed = 0;
+    elapsed: { value: 0, writable: true },
 
-        this._aspect = canvas.width/canvas.height;
+    _aspect: { value: 1, writable: true },
 
-        this._geomRoot = null;
+        //this._geomRoot = null;
+    _rootChildren: { value: [], writable: true },
 
         // all "live" materials
-        this._materials = [];
+    _materials: { value: [], writable: true },
+
+    renderWorld: {
+        value: function(canvas, jObj, assetPath) {
+            this._materials = [];
+            this._rootChildren = [];
+            this._canvas = canvas;
+            this._aspect = this._canvas.width/this._canvas.height;
+
+            this._jObj= jObj;
+
+            // provide the mapping for the asset directory
+            if (assetPath) {
+                this._assetPath = assetPath.slice();
+                if (this._assetPath[this._assetPath.length - 1] != '/')
+                    this._assetPath += '/';
+            }
 
-    // provide the mapping for the asset directory
-    if (assetPath) {
-        this._assetPath = assetPath.slice();
-        if (this._assetPath[this._assetPath.length - 1] != '/')
-            this._assetPath += '/';
-    }
+            if(this._assetPath !== undefined) {
+                RDGE.globals.engine.setAssetPath(this._assetPath);
+            }
 
-        if(this._assetPath !== undefined) {
-                RDGE.globals.engine.setAssetPath(this._assetPath);
-        }
+            // start RDGE or load Canvas 2D objects
+            if (jObj.scenedata)  this._useWebGL = true;
+            if (this._useWebGL)
+            {
+                var id = this._canvas.getAttribute( "data-RDGE-id" );
+                this._canvas.rdgeid = id;
+                RDGE.globals.engine.registerCanvas(this._canvas, this);
+                RDGE.RDGEStart( this._canvas );
+            }
+            else
+            {
+                this.loadScene();
+            }
+        }
+    },
 
     ///////////////////////////////////////////////////////////////////////
         // accessors
     ///////////////////////////////////////////////////////////////////////
-        this.getZNear                   = function()            {  return this._zNear;                  };
-        this.getZFar                    = function()            {  return this._zFar;                   };
-        this.getFOV                             = function()            {  return this._fov;                    };
+    getZNear: { value: function() { return this._zNear; }},
+    getZFar: { value: function() { return this._zFar; }},
+    getFOV: { va