1 files changed, 219 insertions, 29 deletions

diff --git a/js/helper-classes/RDGE/GLWorld.js b/js/helper-classes/RDGE/GLWorld.js
index 59f0bda0..c8327064 100644
--- a/js/helper-classes/RDGE/GLWorld.js
+++ b/js/helper-classes/RDGE/GLWorld.js
@@ -14,6 +14,7 @@ var fragmentShaderSource = "";
 var rdgeStarted = false;
 
 var nodeCounter = 0;
+var worldCounter = 0;
 
 
 ///////////////////////////////////////////////////////////////////////
@@ -65,6 +66,14 @@ 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;
+
+        this._worldCount = worldCounter;
+        worldCounter++;
+
     ///////////////////////////////////////////////////////////////////////
     // Property accessors
     ///////////////////////////////////////////////////////////////////////
@@ -103,6 +112,8 @@ function GLWorld( canvas, use3D )
 
         this.isWebGL                            = function()            {  return this._useWebGL;                       }
 
+        this.getRenderer                        = function()            {  return this.renderer;                        }
+
   ////////////////////////////////////////////////////////////////////////////////////
   // RDGE
   // local variables
@@ -114,6 +125,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;
 
@@ -136,6 +151,7 @@ function GLWorld( canvas, use3D )
                         ctx2 = g_Engine.getContext();
                 if (ctx1 != ctx2)  console.log( "***** different contexts *****" );
                 this.renderer = ctx1.renderer;
+                this.renderer._world = this;
       
                 // create a camera, set its perspective, and then point it at the origin
                 var cam = new camera();
@@ -214,18 +230,160 @@ function GLWorld( canvas, use3D )
     {
                 if (this._useWebGL)
                 {
+                        g_Engine.setContext( this._canvas.uuid );
                         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;
-                        renderer.disableCulling();
-                        this.myScene.render();
+                        if (renderer != aRenderer)
+                        {
+                                console.log( "***** DIFFERENT RENDERERS *****" );
+                                renderer = aRenderer;
+                        }
+                                
+                        if (renderer.unloadedTextureCount <= 0)
+                        {
+                                renderer.disableCulling();
+                                //console.log( "GLWorld.draw " + renderer._world._worldCount );
+                                this.myScene.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
         ////////////////////////////////////////////////////////////////////////////////////