1 files changed, 200 insertions, 30 deletions

diff --git a/js/helper-classes/RDGE/GLWorld.js b/js/helper-classes/RDGE/GLWorld.js
index cc44da50..819f89db 100644
--- a/js/helper-classes/RDGE/GLWorld.js
+++ b/js/helper-classes/RDGE/GLWorld.js
@@ -65,6 +65,11 @@ function GLWorld( canvas, use3D )
 
         this._camera;
 
+        // keep a flag indicating whether a render has been completed.
+        // this allows us to turn off automatic updating if there are
+        // no animated materials
+        this._firstRender = true;
+
     ///////////////////////////////////////////////////////////////////////
     // Property accessors
     ///////////////////////////////////////////////////////////////////////
@@ -103,6 +108,8 @@ function GLWorld( canvas, use3D )
 
         this.isWebGL                            = function()            {  return this._useWebGL;                       }
 
+        this.getRenderer                        = function()            {  return this.renderer;                        }
+
   ////////////////////////////////////////////////////////////////////////////////////
   // RDGE
   // local variables
@@ -114,6 +121,10 @@ function GLWorld( canvas, use3D )
     this.strokeShader = null;
     this.renderer = null;
 
+        // keep an array of texture maps that need to be loaded
+        this._texMapsToLoad = [];
+        this._allMapsLoaded = true;
+
         // this is the node to which objects get hung
         this._rootNode;
 
@@ -214,18 +225,159 @@ function GLWorld( canvas, use3D )
     {
                 if (this._useWebGL)
                 {
-                        var ctx = g_Engine.getContext();
-                        //console.log( "RDGE state: " + ctx.ctxStateManager.currentState().name);
-
-                        var renderer = ctx.renderer;
-                        renderer.disableCulling();
-                        this.myScene.render();
+                        if (this._allMapsLoaded)
+                        {
+                                var ctx = g_Engine.getContext();
+                                //console.log( "RDGE state: " + ctx.ctxStateManager.currentState().name);
+
+                                /////////////////////////////
+                                var ctx1 = g_Engine.ctxMan.handleToObject(this._canvas.rdgeCtxHandle);
+                                if (ctx1 != ctx)  console.log( "***** different contexts (2) *****" );
+                                var aRenderer = ctx1.renderer;
+                                //////////////////////////////////////////
+
+                                var renderer = ctx.renderer;
+                                if (renderer != aRenderer)  console.log( "***** DIFFERENT RENDERERS *****" );
+                                renderer.disableCulling();
+                                this.myScene.render();
+                                //console.log( "render" );
+
+                                if (this._firstRender)
+                                {
+                                        this._firstRender = false;
+
+                                        if (!this.hasAnimatedMaterials())
+                                        {
+                                                //this.myScene.render();
+                                                //this._canvas.task.stop();
+                                                this._renderCount = 10;
+                                        }
+                                }
+                                else if (this._renderCount >= 0)
+                                {
+                                        this._renderCount--;
+                                        if (this._renderCount <= 0)
+                                                this._canvas.task.stop();
+                                }
+
+                        }
                 }
                 else
                 {
                         this.render();
                 }
     }
+        
+    this.onRunState = function()
+        {
+                console.log( "GLWorld.onRunState" );
+                this.restartRenderLoop();
+        }
+        
+    this.onLoadState = function()
+        {
+                console.log( "GLWorld.onLoadState" );
+        }
+
+        this.textureToLoad = function( texture )
+        {
+                if (!texture.previouslyReferenced)
+                {
+                        var name = texture.lookUpName;
+                        texture._world = this;
+                        texture.callback = this.textureMapLoaded;
+                        this._texMapsToLoad[name] = true;
+                        this._allMapsLoaded = false;
+
+                        // stop the draw loop until all textures have been loaded
+                        this._canvas.task.stop();
+                }
+        }
+
+        this.textureMapLoaded = function( texture )
+        {
+                var world = texture._world;
+                if (!world)
+                {
+                        console.log( "**** loaded texture does not have world defined ****" );
+                        return;
+                }
+
+                var name = texture.lookUpName;
+                if (!world._texMapsToLoad[name])
+                {
+                        console.log( "loaded an unregistered texture map: " + name );
+                }
+                else
+                {
+                        //console.log( "loaded a registered texture map: " + name );
+                        world._texMapsToLoad[name] = undefined;
+                }
+
+                // check if all the texture maps are loaded.  if so, resume the render loop
+                world._allMapsLoaded = world.allTextureMapsLoaded();
+                if (world._allMapsLoaded)
+                        world._canvas.task.start();
+        }
+
+        this.allTextureMapsLoaded = function()
+        {
+                for (var name in this._texMapsToLoad)
+                {
+                        var needsLoad = this._texMapsToLoad[name];
+                        if (needsLoad)  return false;
+                }
+
+                return true;
+        }
+
+        this.textureLoadedCallback = function( name )
+        {
+                console.log( "*** material texture loaded: " + name );
+
+                var world = this._world;
+                if (!world)
+                        console.log( "**** world not defined for loaded texture map: " + name );
+                else
+                        world.textureMapLoaded( name );
+        }
+        
+        this.hasAnimatedMaterials = function()
+        {
+                var root = this.getGeomRoot();
+                var rtnVal = false;
+                if (root)
+                        rtnVal = this.hHasAnimatedMaterials( root );
+
+                return rtnVal;
+        }
+
+        this.hHasAnimatedMaterials = function( obj )
+        {
+                if (obj)
+                {
+                        if (obj.getFillMaterial())
+                        {
+                                if (obj.getFillMaterial().isAnimated())  return true;
+                        }
+
+                        if (obj.getStrokeMaterial())
+                        {
+                                if (obj.getStrokeMaterial().isAnimated())  return true;
+                        }
+
+
+                        // do the sibling
+                        var hasAnim = false;
+                        if  (obj.getNext())  hasAnim = this.hHasAnimatedMaterials( obj.getNext() );
+                        if (hasAnim)  return true;
+                        if  (obj.getChild())  hasAnim = this.hHasAnimatedMaterials( obj.getChild() );
+                        if (hasAnim)  return true;
+                }
+
+                return false;
+        }
+
 
         // END RDGE
         ////////////////////////////////////////////////////////////////////////////////////
@@ -233,23 +385,17 @@ function GLWorld( canvas, use3D )
     
     // start RDGE passing your runtime object, and false to indicate we don't need a an initialization state
     // in the case of a procedurally built scene an init state is not needed for loading data
-        //if (this._useWebGL)
+        if (this._useWebGL)
         {
-                if (this._useWebGL)
-                {
-                        rdgeStarted = true;
-
-            // TODO - temporary fix for RDGE id's
-            this._canvas.id = this._canvas.uuid;
+                rdgeStarted = true;
 
-                        g_Engine.registerCanvas(this._canvas, this);
-                        RDGEStart( this._canvas );
+        this._canvas.rdgeid = this._canvas.uuid;
+                g_Engine.registerCanvas(this._canvas, this);
+                RDGEStart( this._canvas );