From b89a7ee8b956c96a1dcee995ea840feddc5d4b27 Mon Sep 17 00:00:00 2001
From: Pierre Frisch
Date: Thu, 22 Dec 2011 07:25:50 -0800
Subject: First commit of Ninja to ninja-internal

Signed-off-by: Valerio Virgillito <rmwh84@motorola.com>
---
 js/helper-classes/RDGE/src/core/script/engine.js | 482 +++++++++++++++++++++++
 1 file changed, 482 insertions(+)
 create mode 100644 js/helper-classes/RDGE/src/core/script/engine.js

(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
new file mode 100644
index 00000000..6fe964c7
--- /dev/null
+++ b/js/helper-classes/RDGE/src/core/script/engine.js
@@ -0,0 +1,482 @@
+/* <copyright>
+This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+(c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+</copyright> */
+
+
+/*
+ *	Manage state instances
+ */
+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()
+{
+    // map of scene graphs to names
+    this.sceneMap = [];
+    
+    // number of states on the stack
+    this.stateTop       = undefined;
+    
+    // size of the browser window
+    this.lastWindowWidth	= window.innerWidth;
+    this.lastWindowHeight	= window.innerHeight;
+       
+    this.defaultContext = null;
+    
+    this.lightManager = null;
+    
+    clearColor = [0.0, 0.0, 0.0, 0.0];
+    
+    panelObjectManager	= new objectManager();
+    
+    this.initializeComplete = false;
+    
+    this.RDGECanvas = null;
+    
+    /*
+     *	a map of canvas names to renderer
+     */
+    this.canvasToRendererMap = {};
+    
+    /*
+     *	states to canvas map - maps a state stack to the canvas context it belongs to
+     */
+    this.canvasNameToStateStack = {};
+    
+    /*
+     *	the list of context's that are active
+     */
+    this.canvasCtxList = [];
+    
+    /*
+     *	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;
+    }
+    
+    /*
+     *	The context definition - every context shares these parameters
+     */
+    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.debug = 
+        {
+			'frameCounter' : 0,
+			'mat4CallCount': 0
+        }
+	}
+    
+    // maintains the contexts
+    contextManager = new objectManager();
+    this.ctxMan = contextManager;
+    
+    // the context currently being updated
+    contextManager.currentCtx = null;
+       
+    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];
+		}
+    }
+    
+    /*
+     *	give the contextID (canvas id) of the context to set
+     */
+    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;
+
+	}
+    
+}
+
+/*
+ *   Initialize the RDGE web engine
+ */
+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();
+    		}
+    	}
+    }
+    
+    // light manager init before global parameters structure is reconfigured
+    this.lightManager = new LightManager(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]);
+			}
+		}
+    }
+    
+    // initial window
+    this.lastWindowWidth = window.innerWidth;
+    this.lastWindowHeight = window.innerHeight;
+
+    // setup default render context
+    this.defaultContext = new RenderContext();
+
+    this.defaultContext.uniforms = [
+        { '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
+    contextManager.start();
+		
+    this.initializeComplete = true;
+}
+
+// shutdown the engine clears all states
+Engine.prototype.Shutdown = function()
+{
+    this.PopAll();
+}
+
+// initialize WebGL
+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);
+		}
+
+    }
+/*
+    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) {
+    if (canvas && this.getContext(canvas.id))
+	    return;
+ 
+    canvas.renderer = new _renderer(canvas); 	// create the renderer for the context
+    this.canvasToRendererMap[canvas.id] = canvas; // store the canvas in the context map
+    canvas.renderer.id = canvas.id;
+
+    // configure the state manager for this context
+    var stateMan = new stateManager();
+
+    // add this context to the contextManager and attach the handle to DOM canvas for user retrieval
+    var context = new contextDef();
+
+    context.id = canvas.id;
+    context.renderer = canvas.renderer;
+    context.ctxStateManager = stateMan;
+    context.startUpState;
+    context.fpsTracker = new fpsTracker(canvas.id);
+
+    context.renderer.mvMatrix = mat4.identity();
+    context.renderer.invMvMatrix = mat4.identity();
+    context.renderer.projectionMatrix = mat4.identity();
+    context.renderer.normalMatrix = mat4.identity();
+
+    canvas.rdgeCtxHandle = contextManager.addObject(context);
+
+    // set new context as the current context so that when the runtime object is instantiated
+    // it can use the context during construction
+    var oldCtx = contextManager.currentCtx;
+    contextManager.currentCtx = context;
+
+    var _runState;
+
+    // check for runtime handlers
+    if (runState) {
+        _runState = runState;
+    }
+    else {
+        var runAttr = canvas.getAttribute("rdgerun");
+
+        if (runAttr) {
+            // make sure attribute is valid
+            if (!isValidObj(runAttr))
+                return;
+            try {
+                var state = eval(runAttr);
+                _runState = new state();
+            }
+            catch (err) {
+                window.console.error("The provided RDGE state object \"" + runAttr + "\" is not defined");
+            }
+        }
+        else {
+            _runState = {};
+            validateUserState(_runState);
+        }
+    }
+
+    // check for a scene
+    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);
+
+    // fill out any user state missing methods with dummy methods
+    validateUserState(_runState);
+
+    if (sceneName) {
+        stateMan.RDGEInitState.sceneName = sceneName;
+
+        // run is now always the bottom state, loading can happen at any time
+        stateMan.PushState(stateMan.RDGERunState, "noInit");
+
+        context.startUpState = stateMan.RDGEInitState;
+    }
+    else {
+        context.startUpState = stateMan.RDGERunState;
+    }
+
+    if (this.initializeComplete) {
+        context.ctxStateManager.PushState(context.startUpState);
+    }
+
+    // restore previous context
+    // NOTE: Ninja requires this to be commented out!
+    //	if (oldCtx)
+    //	{
+    //		contextManager.currentCtx = oldCtx;
+    //	}
+}
+
+Engine.prototype.unregisterCanvas = function(canvas) {
+    stat.closePage(canvas.id + "_fps");
+    contextManager.removeObject(canvas.rdgeCtxHandle);
+
+}
+
+Engine.prototype.getCanvas = function( id )
+{
+	return this.canvasToRendererMap[id];
+}
-- 
cgit v1.2.3