1 files changed, 178 insertions, 229 deletions

diff --git a/js/lib/drawing/world.js b/js/lib/drawing/world.js
index 4ca738f4..eb06e59d 100755
--- a/js/lib/drawing/world.js
+++ b/js/lib/drawing/world.js
@@ -29,14 +29,20 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
     }
 
     this._canvas = canvas;
-        if (this._useWebGL) {
+        if (this._useWebGL)
+        {
         preserveDrawingBuffer = true;
-        if(preserveDrawingBuffer) {
+        if(preserveDrawingBuffer)
+                {
             this._glContext = canvas.getContext("experimental-webgl", {preserveDrawingBuffer: true});
-        } else {
+        }
+                else
+                {
                     this._glContext = canvas.getContext("experimental-webgl");
         }
-    } else {
+    }
+        else
+        {
                 this._2DContext = canvas.getContext( "2d" );
     }
     
@@ -124,6 +130,7 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
 
     // Flag to play/pause animation at authortime
     this._previewAnimation = true;
+  
   ////////////////////////////////////////////////////////////////////////////////////
   // RDGE
   // local variables
@@ -148,46 +155,47 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
         this.setCameraMat( camMat );
     
     // post-load processing of the scene
-    this.init = function() {
-                var ctx1 = g_Engine.ctxMan.handleToObject(this._canvas.rdgeCtxHandle),
-                        ctx2 = g_Engine.getContext();
+    this.init = function()
+        {
+                var ctx1 = RDGE.globals.engine.ctxMan.handleToObject(this._canvas.rdgeCtxHandle),
+                        ctx2 = RDGE.globals.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();
+                var cam = new RDGE.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());
+                cam.setLookAt([0, 0, this.getViewDistance()], [0, 0, 0], RDGE.vec3.up());
         
                 // make this camera the active camera
                 this.renderer.cameraManager().setActiveCamera(cam);
 
                 // change clear color
-                //this.renderer.setClearFlags(g_Engine.getContext().DEPTH_BUFFER_BIT);
+                //this.renderer.setClearFlags(RDGE.globals.engine.getContext().DEPTH_BUFFER_BIT);
                 this.renderer.setClearColor([0.0, 0.0, 0.0, 0.0]);
                 //this.renderer.NinjaWorld = this;
         
                 // create an empty scene graph
-                this.myScene = new SceneGraph();
+                this.myScene = new RDGE.SceneGraph();
         
                 // create some lights
                 // light 1
-                this.light = createLightNode("myLight");
+                this.light = RDGE.createLightNode("myLight");
                 this.light.setPosition([0,0,1.2]);
                 this.light.setDiffuseColor([0.75,0.9,1.0,1.0]);
         
                 // light 2
-                this.light2 = createLightNode("myLight2");
+                this.light2 = RDGE.createLightNode("myLight2");
                 this.light2.setPosition([-0.5,0,1.2]);
                 this.light2.setDiffuseColor([1.0,0.9,0.75,1.0]);
         
                 // create a light transform
-                var lightTr = createTransformNode("lightTr");
+                var lightTr = RDGE.createTransformNode("lightTr");
         
                 // create and attach a material - materials hold the light data
-                lightTr.attachMaterial(createMaterialNode("lights"));
+                lightTr.attachMaterial(RDGE.createMaterialNode("lights"));
         
                 // enable light channels 1, 2 - channel 0 is used by the default shader
                 lightTr.materialNode.enableLightChannel(1, this.light);
@@ -200,21 +208,23 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
                 this.myScene.addNode(lightTr);
         
                 // Add the scene to the engine - necessary if you want the engine to draw for you
-                //g_Engine.AddScene("myScene" + this._canvas.id, this.myScene);
+                //RDGE.globals.engine.AddScene("myScene" + this._canvas.id, this.myScene);
                 var name = this._canvas.getAttribute( "data-RDGE-id" ); 
-                g_Engine.AddScene("myScene" + name, this.myScene);
+                RDGE.globals.engine.AddScene("myScene" + name, this.myScene);
         };
     
         // main code for handling user interaction and updating the scene   
-        this.update = function(dt) {
+        this.update = function(dt)
+        {
                 if (!dt)  dt = 0.2;
         
                 dt = 0.01;      // use our own internal throttle
                 this.elapsed += dt;
         
-                if (this._useWebGL) {
+                if (this._useWebGL)
+                {
                         // 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]);
+                    RDGE.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)]);
@@ -229,36 +239,48 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
     };
 
     // defining the draw function to control how the scene is rendered      
-        this.draw = function() {
-                if (this._useWebGL) {
-                        g_Engine.setContext( this._canvas.rdgeid );
-                        var ctx = g_Engine.getContext();
+        this.draw = function()
+        {
+                if (this._useWebGL)
+                {
+                        RDGE.globals.engine.setContext( this._canvas.rdgeid );
+                        var ctx = RDGE.globals.engine.getContext();
                         var renderer = ctx.renderer;
-                        if (renderer.unloadedTextureCount <= 0) {
+                        if (renderer.unloadedTextureCount <= 0)
+                        {
                                 renderer.disableCulling();
                                 renderer._clear();
                                 this.myScene.render();
 
-                                if (this._firstRender) {
+                                if (this._firstRender)
+                                {
                                         this._notifier.sendNotification( this._notifier.FIRST_RENDER );
-                                        if (this._canvas.task) {
+                                        if (this._canvas.task)
+                                        {
                                                 this._firstRender = false;
 
-                                                if (!this.hasAnimatedMaterials() || !this._previewAnimation) {
+                                                if (!this.hasAnimatedMaterials() || !this._previewAnimation)
+                                                {
                                                         this._canvas.task.stop();
                                                         //this._renderCount = 10;
                                                 }
                                         }
-                                } else if (this._renderCount >= 0) {
-                                        if (this._canvas.task) {
+                                }
+                                else if (this._renderCount >= 0)
+                                {
+                                        if (this._canvas.task)
+                                        {
                                                 this._renderCount--;
-                                                if (this._renderCount <= 0) {
+                                                if (this._renderCount <= 0)
+                                                {
                                                         this._canvas.task.stop();
                         }
                                         }
                                 }
                         }
-                } else {
+                }
+                else
+                {
                         this.render();
                 }
     };
@@ -272,8 +294,10 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
 //              console.log( "GLWorld.onLoadState" );
         };
 
-        this.textureToLoad = function( texture ) {
-                if (!texture.previouslyReferenced) {
+        this.textureToLoad = function( texture )
+        {
+                if (!texture.previouslyReferenced)
+                {
                         var name = texture.lookUpName;
                         texture._world = this;
                         texture.callback = this.textureMapLoaded;
@@ -285,7 +309,