From fb0a659c9ca3479fd6799325498b11f074689936 Mon Sep 17 00:00:00 2001
From: John Mayhew
Date: Mon, 2 Apr 2012 14:57:31 -0700
Subject: -Namespaced all RDGE javascript.

-Removed the following unused files from the build script
	/core/script/fx/blur.js
	/core/script/fx/ssao.js
	/core/script/animation.js
- Fully removed the following from the build and from source control as they are unused or no longer needed
	/core/script/util/dbgpanel.js
	/core/script/util/fpsTracker.js
	/core/script/util/statTracker.js
	/core/script/input.js
	/core/script/TextureManager.js
	/core/script/ubershader.js
---
 js/helper-classes/RDGE/src/core/script/engine.js | 513 ++++++++++-------------
 1 file changed, 223 insertions(+), 290 deletions(-)

(limited to 'js/helper-classes/RDGE/src/core/script/engine.js')

diff --git a/js/helper-classes/RDGE/src/core/script/engine.js b/js/helper-classes/RDGE/src/core/script/engine.js
index 5bc9305c..0975fcef 100755
--- a/js/helper-classes/RDGE/src/core/script/engine.js
+++ b/js/helper-classes/RDGE/src/core/script/engine.js
@@ -4,91 +4,79 @@ No rights, expressed or implied, whatsoever to this software are provided by Mot
 (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
 </copyright> */
 
+var RDGE = RDGE || {};
 
 /*
  *	Manage state instances
  */
-stateManager = function()
-{
-	// a stack of states
-	this.stateStack = [];
-	
-	// number of states on the stack
-    this.stateTop       = undefined;
-    
+RDGE.stateManager = function () {
+    // a stack of states
+    this.stateStack = [];
+
+    // number of states on the stack
+    this.stateTop = undefined;
+
     // the states of the context
-    this.RDGEInitState	= null;
-    this.RDGERunState	= null;
-    
-    this.currentState = function()
-    {
-		if(this.stateTop != undefined)
-			return this.stateStack[this.stateTop];
-			
-		return null;
-    }
-	
-	/*
-	 *  Push new IRuntime state - engine executes the new state
-	 */
-	this.PushState = function(state, flags) 
-	{
-		if(state!=null && typeof state.Init == 'function')
-		{
-			if(this.stateTop != undefined)
-				this.stateStack[this.stateTop].LeaveState();
-			
-			if(flags == undefined || flags != "noInit")
-				state.Init();
-				
-			this.stateTop = this.stateStack.push(state) - 1;
-		}
-	}
-
-	/*
-	 *  Remove IRuntime state from stack, engine executes previous state
-	 */
-	this.PopState = function()
-	{
-		state = this.stateStack.pop();
-		if(state!=null)
-		{
-			state.Shutdown();
-		}
-		
-		this.stateTop = this.stateTop > 0 ? this.stateTop - 1 : 0;
-	    
-		if(this.stateStack[this.stateTop])
-		{
-			this.stateStack[this.stateTop].ReInit();
-		}
-	}
-
-	/*
-	 *  Remove all states from the stack
-	 */
-	this.PopAll = function()
-	{
-		while(this.stateStack[this.stateTop] != null)
-		{
-			this.PopState();
-		}
-	}
-	
-	this.tick = function(dt)
-	{
-		if(this.stateStack[this.stateTop]!=null) 
-		{
-			this.stateStack[this.stateTop].Update(dt);
-			this.stateStack[this.stateTop].Resize();
-			this.stateStack[this.stateTop].Draw();
-		}
-	}
-}
-
-g_enableBenchmarks = true;
-function Engine()
-{
+    this.RDGEInitState = null;
+    this.RDGERunState = null;
+
+    this.currentState = function () {
+        if (this.stateTop != undefined)
+            return this.stateStack[this.stateTop];
+
+        return null;
+    };
+
+    /*
+    *  Push new IRuntime state - engine executes the new state
+    */
+    this.PushState = function (state, flags) {
+        if (state != null && typeof state.Init == 'function') {
+            if (this.stateTop != undefined)
+                this.stateStack[this.stateTop].LeaveState();
+
+            if (flags == undefined || flags != "noInit")
+                state.Init();
+
+            this.stateTop = this.stateStack.push(state) - 1;
+        }
+    };
+
+    /*
+    *  Remove IRuntime state from stack, engine executes previous state
+    */
+    this.PopState = function () {
+        state = this.stateStack.pop();
+        if (state != null) {
+            state.Shutdown();
+        }
+
+        this.stateTop = this.stateTop > 0 ? this.stateTop - 1 : 0;
+
+        if (this.stateStack[this.stateTop]) {
+            this.stateStack[this.stateTop].ReInit();
+        }
+    };
+
+    /*
+    *  Remove all states from the stack
+    */
+    this.PopAll = function () {
+        while (this.stateStack[this.stateTop] != null) {
+            this.PopState();
+        }
+    };
+
+    this.tick = function (dt) {
+        if (this.stateStack[this.stateTop] != null) {
+            this.stateStack[this.stateTop].Update(dt);
+            this.stateStack[this.stateTop].Resize();
+            this.stateStack[this.stateTop].Draw();
+        }
+    };
+};
+
+RDGE.Engine = function() {
     // map of scene graphs to names
     this.sceneMap = [];
     
@@ -105,8 +93,6 @@ function Engine()
     
     clearColor = [0.0, 0.0, 0.0, 0.0];
     
-    panelObjectManager	= new objectManager();
-    
     this.initializeComplete = false;
     
     this.RDGECanvas = null;
@@ -130,43 +116,39 @@ function Engine()
      *	regex object to verify runtime object is not some sort of exploit
      */
     invalidObj = new RegExp("([()]|function)");
-    
-    isValidObj = function( name )
-    {
-		// do a quick test make sure user isn't trying to execute a function
-		if(invalidObj.test(name))
-		{
-			window.console.error("invalid object name passed to RDGE, " + name + " - looks like a function");
-			return false;
-		}
-		
-		return true;
-    }
+
+    isValidObj = function (name) {
+        // do a quick test make sure user isn't trying to execute a function
+        if (invalidObj.test(name)) {
+            window.console.error("invalid object name passed to RDGE, " + name + " - looks like a function");
+            return false;
+        }
+
+        return true;
+    };
     
     /*
      *	The context definition - every context shares these parameters
      */
-    contextDef = function()
-    {
-        this.id = null;	
+    contextDef = function () {
+        this.id = null;
         this.renderer = null;
         this.ctxStateManager = null;
         this.startUpState = null;
         this.sceneGraphMap = [];
         this.currentScene = null;
-        this.getScene = function()
-        {
-			return this.sceneGraphMap[this.currentScene];
+        this.getScene = function () {
+            return this.sceneGraphMap[this.currentScene];
         }
-        this.debug = 
+        this.debug =
         {
-			'frameCounter' : 0,
-			'mat4CallCount': 0
+            'frameCounter': 0,
+            'mat4CallCount': 0
         }
-	}
+    };
     
     // maintains the contexts
-    contextManager = new objectManager();
+    contextManager = new RDGE.objectManager();
     this.ctxMan = contextManager;
     
     // the context currently being updated
@@ -174,219 +156,174 @@ function Engine()
        
     contextManager._addObject = contextManager.addObject;
     contextManager.contextMap = {};
-    
-    contextManager.addObject = function( context )
-    {
-		this.contextMap[context.id] = context;
-		return this._addObject(context);
-    }
-    
-    contextManager.start = function()
-    {
-		var len = this.objects.length;
-		for(var i = 0; i < len; ++i)
-		{
-		    // set the current context
-		    contextManager.currentCtx = this.objects[i];
-		    this.objects[i].ctxStateManager.PushState(this.objects[i].startUpState);
-		}
-    }
-    
-    contextManager.forEach = function(cb)
-    {
-		var len = this.objects.length;
-		for(var i = 0; i < len; ++i)
-		{
-			cb(this.objects[i]);
-		}
-    }
-    
-    this.getContext = function( optCanvasID )
-    {
-		if(!optCanvasID)
-		{
-			return contextManager.currentCtx;
-		}
-		else
-		{
-			return contextManager.contextMap[optCanvasID];
-		}
-    }
+
+    contextManager.addObject = function (context) {
+        this.contextMap[context.id] = context;
+        return this._addObject(context);
+    };
+
+    contextManager.start = function () {
+        var len = this.objects.length;
+        for (var i = 0; i < len; ++i) {
+            // set the current context
+            contextManager.currentCtx = this.objects[i];
+            this.objects[i].ctxStateManager.PushState(this.objects[i].startUpState);
+        }
+    };
+
+    contextManager.forEach = function (cb) {
+        var len = this.objects.length;
+        for (var i = 0; i < len; ++i) {
+            cb(this.objects[i]);
+        }
+    };
+
+    this.getContext = function (optCanvasID) {
+        if (!optCanvasID) {
+            return contextManager.currentCtx;
+        }
+        else {
+            return contextManager.contextMap[optCanvasID];
+        }
+    };
     
     /*
      *	give the contextID (canvas id) of the context to set
      */
-    this.setContext = function( contextID )
-    {
+    this.setContext = function (contextID) {
         contextManager.currentCtx = contextManager.contextMap[contextID];
-    }
-	
-	this.tickContext = function(contextID) {
-	    var savedCtx = contextManager.currentCtx;
-	    contextManager.currentCtx = contextManager.contextMap[contextID];
-	    this.objects[i].ctxStateManager.tick(dt);
-	    contextManager.currentCtx = savedCtx;
-
-	}
-    
-}
+    };
+
+    this.tickContext = function (contextID) {
+        var savedCtx = contextManager.currentCtx;
+        contextManager.currentCtx = contextManager.contextMap[contextID];
+        this.objects[i].ctxStateManager.tick(dt);
+        contextManager.currentCtx = savedCtx;
+
+    };
+};
 
 /*
  *   Initialize the RDGE web engine
  */
-Engine.prototype.init = function(userInitState, userRunState, canvasObject)
-{
+RDGE.Engine.prototype.init = function (userInitState, userRunState, canvasObject) {
     this.GlInit(canvasObject);
 
-    globalParamFuncSet =  function(param)
-    {
-		this.data = param.data;
-		this.type =param.type;
-		
-    	this.set  = function(v)
-    	{
-			var len = this.data ? this.data.length : 0;
-			for(var i=0;i<len;++i)
-				this.data[i]=v[i];
-    	}
-    	this.get = function()
-    	{
-    		if( this.data.length == undefined ) 
-    		{
-    			return this.data;
-    		}
-    		else 
-    		{    		
-    			return this.data.slice();
-    		}
-    	}
-    }
-    
+    globalParamFuncSet = function (param) {
+        this.data = param.data;
+        this.type = param.type;
+
+        this.set = function (v) {
+            var len = this.data ? this.data.length : 0;
+            for (var i = 0; i < len; ++i)
+                this.data[i] = v[i];
+        }
+        this.get = function () {
+            if (this.data.length == undefined) {
+                return this.data;
+            }
+            else {
+                return this.data.slice();
+            }
+        }
+    };
+
     // light manager init before global parameters structure is reconfigured
-    this.lightManager = new LightManager(rdgeGlobalParameters.rdge_lights);
-    	
+    this.lightManager = new RDGE.LightManager(RDGE.rdgeGlobalParameters.rdge_lights);
+
     // added getter and setter to global uniforms
-    for(var p in rdgeGlobalParameters)
-    {
-		if(p != "rdge_lights")
-		{
-			rdgeGlobalParameters[p] = new globalParamFuncSet(rdgeGlobalParameters[p]);
-		}
-		else
-		{
-			var lights = rdgeGlobalParameters[p];
-			for(var l in lights)
-			{
-				rdgeGlobalParameters[l] = new globalParamFuncSet(lights[l]);
-			}
-		}
+    for (var p in RDGE.rdgeGlobalParameters) {
+        if (p != "rdge_lights") {
+            RDGE.rdgeGlobalParameters[p] = new globalParamFuncSet(RDGE.rdgeGlobalParameters[p]);
+        }
+        else {
+            var lights = RDGE.rdgeGlobalParameters[p];
+            for (var l in lights) {
+                RDGE.rdgeGlobalParameters[l] = new globalParamFuncSet(lights[l]);
+            }
+        }
     }
-    
+
     // initial window
     this.lastWindowWidth = window.innerWidth;
     this.lastWindowHeight = window.innerHeight;
 
     // setup default render context
-    this.defaultContext = new RenderContext();
+    this.defaultContext = new RDGE.RenderContext();
 
     this.defaultContext.uniforms = [
-        { 'name': "u_matAmbient", 'value': [0.02,0.02,0.02, 1.0] },
+        { 'name': "u_matAmbient", 'value': [0.02, 0.02, 0.02, 1.0] },
         { 'name': "u_matDiffuse", 'value': [1.0, 1.0, 1.0, 1.0] },
         { 'name': "u_matSpecular", 'value': [1.0, 1.0, 1.0, 1.0] },
         { 'name': "u_matShininess", 'value': [128.0] },
         { 'name': "u_matEmission", 'value': [0.0, 0.0, 0.0, 1.0] }
     ];
-    
-	// startup the contexts
+
+    // startup the contexts
     contextManager.start();
-		
+
     this.initializeComplete = true;
-}
+};
 
 // shutdown the engine clears all states
-Engine.prototype.Shutdown = function()
-{
+RDGE.Engine.prototype.Shutdown = function () {
     this.PopAll();
-}
+};
 
 // initialize WebGL
-Engine.prototype.GlInit = function( canvasObject)
-{
+RDGE.Engine.prototype.GlInit = function (canvasObject) {
     // Initialize
     var canvases = document.getElementsByTagName("canvas");
-    
+
     // transverse the canvases and create the contexts
     var numCv = canvases.length;
-    for( var cvIdx = 0; cvIdx < numCv; ++cvIdx)
-    {
-	    var canvas;
-		
-		// if this canvas has a rdge attribute initialize the render context
-		var rdgeAttr = canvases[cvIdx].getAttribute("rdge");
-		if(rdgeAttr == "true")
-		{
-			// hack ~ while implementing multi-context
-			canvas = canvases[cvIdx];
-			this.registerCanvas(canvas);
-		}
+    for (var cvIdx = 0; cvIdx < numCv; ++cvIdx) {
+        var canvas;
+
+        // if this canvas has a rdge attribute initialize the render context
+        var rdgeAttr = canvases[cvIdx].getAttribute("rdge");
+        if (rdgeAttr == "true") {
+            // hack ~ while implementing multi-context
+            canvas = canvases[cvIdx];
+            this.registerCanvas(canvas);
+        }
 
     }
-/*
+    /*
     canvas.addEventListener("webglcontextlost", contextLostHandler, false);
     canvas.addEventListener("webglcontextrestored", contextRestoredHandler, false);
-*/
-   
-}
-
-Engine.prototype.loadScene = function(name)
-{
-	var url = "assets_web/mesh/" + name + ".json"
-	
-	// if we are not in the load state than push it on again
-	if(contextManager.currentCtx.stateMan.currentState().name == "RunState")
-	{
-		contextManager.currentCtx.stateMan.PushState(contextManager.currentCtx.stateMan.RDGEInitState);
-		contextManager.currentCtx.loadScene(url, name);
-	}
-	
-}
-
-Engine.prototype.getScene = function(name)
-{
-	return contextManager.currentCtx.sceneGraphMap[name];
-}
-
-Engine.prototype.AddScene = function(name, sceneGraph)
-{	
-	contextManager.currentCtx.sceneGraphMap[name] = sceneGraph;
-	contextManager.currentCtx.currentScene = name;
-}
-
-
-Engine.prototype.createRDGEPanel=function() 
-{
-	var panel = new utilDbgPanel('tools','WebGL Viewer Settings');
-	panel.appendLabel("", "");
-	var panelID=panelObjectManager.addObject(panel)	// adding to object manager will fill out the object async
-
-	return panelID;
-}
-
-Engine.prototype.getRDGEPanel=function(panelID) 
-{
-	return panelObjectManager.handleToObject(panelID);
-}
-
-Engine.prototype.registerCanvas = function(canvas, runState) {
+    */
+};
+
+RDGE.Engine.prototype.loadScene = function (name) {
+    var url = "assets_web/mesh/" + name + ".json"
+
+    // if we are not in the load state than push it on again
+    if (contextManager.currentCtx.stateMan.currentState().name == "RunState") {
+        contextManager.currentCtx.stateMan.PushState(contextManager.currentCtx.stateMan.RDGEInitState);
+        contextManager.currentCtx.loadScene(url, name);
+    }
+};
+
+RDGE.Engine.prototype.getScene = function (name) {
+    return contextManager.currentCtx.sceneGraphMap[name];
+};
+
+RDGE.Engine.prototype.AddScene = function (name, sceneGraph) {
+    contextManager.currentCtx.sceneGraphMap[name] = sceneGraph;
+    contextManager.currentCtx.currentScene = name;
+};
+
+RDGE.Engine.prototype.registerCanvas = function (canvas, runState) {
     if (canvas && this.getContext(canvas.rdgeid))
-	    return;
- 
-    canvas.renderer = new _renderer(canvas); 	// create the renderer for the context
+        return;
+
+    canvas.renderer = new RDGE._renderer(canvas); 	// create the renderer for the context
     this.canvasToRendererMap[canvas.rdgeid] = canvas; // store the canvas in the context map
     canvas.renderer.id = canvas.rdgeid;
 
     // configure the state manager for this context
-    var stateMan = new stateManager();
+    var stateMan = new RDGE.stateManager();
 
     // add this context to the contextManager and attach the handle to DOM canvas for user retrieval
     var context = new contextDef();
@@ -395,12 +332,11 @@ Engine.prototype.registerCanvas = function(canvas, runState) {
     context.renderer = canvas.renderer;
     context.ctxStateManager = stateMan;
     context.startUpState;
-    context.fpsTracker = new fpsTracker(canvas.rdgeid);
 
-    context.renderer.mvMatrix = mat4.identity();
-    context.renderer.invMvMatrix = mat4.identity();
-    context.renderer.projectionMatrix = mat4.identity();
-    context.renderer.normalMatrix = mat4.identity();
+    context.renderer.mvMatrix = RDGE.mat4.identity();
+    context.renderer.invMvMatrix = RDGE.mat4.identity();
+    context.renderer.projectionMatrix = RDGE.mat4.identity();
+    context.renderer.normalMatrix = RDGE.mat4.identity();
 
     canvas.rdgeCtxHandle = contextManager.addObject(context);
 
@@ -432,7 +368,7 @@ Engine.prototype.registerCanvas = function(canvas, runState) {
         }
         else {
             _runState = {};
-            validateUserState(_runState);
+            RDGE.utilities.validateUserState(_runState);
         }
     }
 
@@ -440,11 +376,11 @@ Engine.prototype.registerCanvas = function(canvas, runState) {
     var sceneName = canvas.getAttribute("rdgescene");
 
     // setup the RDGE states passing the user state or undefined
-    stateMan.RDGEInitState = new LoadState(_runState, context);
-    stateMan.RDGERunState = new RunState(_runState, context);
+    stateMan.RDGEInitState = new RDGE.LoadState(_runState, context);
+    stateMan.RDGERunState = new RDGE.RunState(_runState, context);
 
     // fill out any user state missing methods with dummy methods
-    validateUserState(_runState);
+    RDGE.utilities.validateUserState(_runState);
 
     if (sceneName) {
         stateMan.RDGEInitState.sceneName = sceneName;
@@ -468,15 +404,12 @@ Engine.prototype.registerCanvas = function(canvas, runState) {
     //	{
     //		contextManager.currentCtx = oldCtx;
     //	}
-}
+};
 
-Engine.prototype.unregisterCanvas = function(canvas) {
-    stat.closePage(canvas.rdgeid + "_fps");
+RDGE.Engine.prototype.unregisterCanvas = function (canvas) {
     contextManager.removeObject(canvas.rdgeCtxHandle);
+};
 
-}
-
-Engine.prototype.getCanvas = function( id )
-{
-	return this.canvasToRendererMap[id];
-}
+RDGE.Engine.prototype.getCanvas = function (id) {
+    return this.canvasToRendererMap[id];
+};
-- 
cgit v1.2.3