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
---
 .../RDGE/src/core/script/MeshManager.js            |  255 +--
 .../RDGE/src/core/script/RenderInitProcs.js        |  476 ++--
 .../RDGE/src/core/script/RenderProcs.js            |  787 ++++---
 .../RDGE/src/core/script/ScreenQuad.js             |   32 +-
 .../RDGE/src/core/script/ShaderManager.js          |  124 +-
 .../RDGE/src/core/script/TextureManager.js         |    6 -
 .../RDGE/src/core/script/animation.js              |  191 +-
 js/helper-classes/RDGE/src/core/script/box.js      |  181 +-
 js/helper-classes/RDGE/src/core/script/camera.js   |  468 ++--
 js/helper-classes/RDGE/src/core/script/engine.js   |  513 ++---
 js/helper-classes/RDGE/src/core/script/fx/blur.js  |  283 ++-
 js/helper-classes/RDGE/src/core/script/fx/ssao.js  |  211 +-
 .../RDGE/src/core/script/init_state.js             |  553 +++--
 js/helper-classes/RDGE/src/core/script/input.js    |  117 -
 js/helper-classes/RDGE/src/core/script/jpass.js    |  771 +++----
 js/helper-classes/RDGE/src/core/script/jshader.js  |  260 ++-
 .../RDGE/src/core/script/lightmanager.js           |  148 +-
 .../RDGE/src/core/script/math/mat4.js              | 1055 +++++----
 .../RDGE/src/core/script/math/quat.js              |  237 +-
 .../RDGE/src/core/script/math/vec2.js              |  229 +-
 .../RDGE/src/core/script/math/vec3.js              |  423 ++--
 .../RDGE/src/core/script/math/vec4.js              |  315 +--
 .../RDGE/src/core/script/objectManager.js          |    8 +-
 js/helper-classes/RDGE/src/core/script/particle.js | 1591 +++++++-------
 .../RDGE/src/core/script/precompiled.js            |  123 +-
 .../RDGE/src/core/script/renderUtils.js            |  644 +++---
 .../RDGE/src/core/script/rendercontext.js          |  454 ++--
 js/helper-classes/RDGE/src/core/script/renderer.js | 2299 ++++++++++----------
 .../RDGE/src/core/script/run_state.js              |  711 +++---
 js/helper-classes/RDGE/src/core/script/runtime.js  |  280 +--
 .../RDGE/src/core/script/scenegraph.js             | 1754 +++++++--------
 .../RDGE/src/core/script/scenegraphNodes.js        | 1016 ++++-----
 .../RDGE/src/core/script/shadowLight.js            |   90 +-
 js/helper-classes/RDGE/src/core/script/sockets.js  |  243 +--
 .../RDGE/src/core/script/ubershader.js             |  159 --
 .../RDGE/src/core/script/util/dbgpanel.js          |  237 --
 .../RDGE/src/core/script/util/fpsTracker.js        |   51 -
 .../RDGE/src/core/script/util/statTracker.js       |  338 ---
 .../RDGE/src/core/script/utilities.js              |  282 ++-
 39 files changed, 8075 insertions(+), 9840 deletions(-)
 delete mode 100755 js/helper-classes/RDGE/src/core/script/TextureManager.js
 delete mode 100755 js/helper-classes/RDGE/src/core/script/input.js
 delete mode 100755 js/helper-classes/RDGE/src/core/script/ubershader.js
 delete mode 100755 js/helper-classes/RDGE/src/core/script/util/dbgpanel.js
 delete mode 100755 js/helper-classes/RDGE/src/core/script/util/fpsTracker.js
 delete mode 100755 js/helper-classes/RDGE/src/core/script/util/statTracker.js

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

diff --git a/js/helper-classes/RDGE/src/core/script/MeshManager.js b/js/helper-classes/RDGE/src/core/script/MeshManager.js
index 43813078..2c31781e 100755
--- a/js/helper-classes/RDGE/src/core/script/MeshManager.js
+++ b/js/helper-classes/RDGE/src/core/script/MeshManager.js
@@ -4,86 +4,80 @@ No rights, expressed or implied, whatsoever to this software are provided by Mot
 (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
 </copyright> */
 
-function Model(name, mesh) 
-{
+// RDGE namespaces
+var RDGE = RDGE || {};
+
+RDGE.Model = function (name, mesh) {
     this.name = name;
     this.mesh = mesh;
     this.camera = null;
-}
+};
 
 /*
- *	Maintains a list of meshes to allow instancing of data
- */
-function MeshManager() {
-    this.contentUrl					= "assets_web/mesh/";
-    this.modelMap					= {};
-    this.readyList					= [];		// meshes that have data ready
-    this.meshesLoading				= true;		// indicates that no meshes have loaded or that they are still loading
-    this.postMeshLoadCallbackList	= [];
-    this.tempSphere					= null;
-    this.requestCounter				= 0;
-}
+*	Maintains a list of meshes to allow instancing of data
+*/
+RDGE.MeshManager = function () {
+    this.contentUrl = "assets_web/mesh/";
+    this.modelMap = {};
+    this.readyList = []; 	// meshes that have data ready
+    this.meshesLoading = true; 	// indicates that no meshes have loaded or that they are still loading
+    this.postMeshLoadCallbackList = [];
+    this.tempSphere = null;
+    this.requestCounter = 0;
+};
 
 /*
- * Pass the scene meshNode stump, loads temp object while real mesh is downloading
- */
-MeshManager.prototype.loadMesh = function (meshStump, tempMesh) 
-{
+* Pass the scene meshNode stump, loads temp object while real mesh is downloading
+*/
+RDGE.MeshManager.prototype.loadMesh = function (meshStump, tempMesh) {
     // if it exists already, return the mesh requested
-    if ( this.modelMap[meshStump.name] !== undefined )
+    if (this.modelMap[meshStump.name] !== undefined)
         return this.modelMap[meshStump.name];
 
     meshStump.ready = false;
     meshStump.addr = this.contentUrl + meshStump.name + "_mesh.json";
-    meshStump.ctxID = g_Engine.getContext().renderer.id;
-
-	// sets a temp mesh up in place of the final mesh to load
-    if (!tempMesh) 
-    {
-        if (this.tempSphere == null) 
-        {
-            this.tempSphere = makeSphere(g_Engine.getContext().renderer.ctx, 25, 5, 5);
+    meshStump.ctxID = RDGE.globals.engine.getContext().renderer.id;
+
+    // sets a temp mesh up in place of the final mesh to load
+    if (!tempMesh) {
+        if (this.tempSphere == null) {
+            this.tempSphere = RDGE.renderUtils.makeSphere(RDGE.globals.engine.getContext().renderer.ctx, 25, 5, 5);
         }
 
         tempMesh = this.tempSphere;
     }
 
-	// add the temp mesh to the map of loaded meshes
+    // add the temp mesh to the map of loaded meshes
     this.modelMap[meshStump.name] = tempMesh;
-    
+
     // update the request counter - we now have one more mesh to load
     this.requestCounter++;
 
-    requestMesh(meshStump);
+    RDGE.requestMesh(meshStump);
 
     return null;
 };
 
 /*
- * Deletes the passed mesh from the manager as well as all renderers
- */
-MeshManager.prototype.deleteMesh = function (name) 
-{
-	var model = this.modelMap[name];
-	
-	if (model)
-	{
-		g_Engine.ctxMan.forEach(function(context)
-		{
-			context.renderer.deletePrimitive(model.primitive);
-		});
-
-		delete this.modelMap[name];
-	}
+* Deletes the passed mesh from the manager as well as all renderers
+*/
+RDGE.MeshManager.prototype.deleteMesh = function (name) {
+    var model = this.modelMap[name];
+
+    if (model) {
+        RDGE.globals.engine.ctxMan.forEach(function (context) {
+            context.renderer.deletePrimitive(model.primitive);
+        });
+
+        delete this.modelMap[name];
+    }
 };
 
-MeshManager.prototype.getModelByName = function (name) 
-{
+RDGE.MeshManager.prototype.getModelByName = function (name) {
     return this.modelMap[name];
 };
 
-MeshManager.prototype.getModelNames = function () 
-{
+RDGE.MeshManager.prototype.getModelNames = function () {
     var names = [];
     for (var index in this.modelMap) {
         names.push(this.modelList[index].name);
@@ -93,134 +87,121 @@ MeshManager.prototype.getModelNames = function ()
 };
 
 
-MeshManager.prototype.processMeshData = function () {
-	var renderer = g_Engine.getContext().renderer;
-	
+RDGE.MeshManager.prototype.processMeshData = function () {
+    var renderer = RDGE.globals.engine.getContext().renderer;
+
     // loop through meshes and load ready data
     for (var index in this.readyList) {
         // if item is ready load it
         if (this.readyList[index] && this.readyList[index].ready && renderer.id === this.readyList[index].ctxID) {
-        
+
 
             // pop the item
             var model = this.readyList[index];
             this.readyList.splice(index, 1);
-            
-            var primset = new rdgePrimitiveDefinition();
-            
-            primset.vertexDefinition = 
+
+            var primset = new RDGE.rdgePrimitiveDefinition();
+
+            primset.vertexDefinition =
             {
-				// this shows two ways to map this data to an attribute
-				"vert":{'type':rdgeConstants.VS_ELEMENT_POS, 'bufferIndex':0, 'bufferUsage': rdgeConstants.BUFFER_STATIC},
-				"a_pos":{'type':rdgeConstants.VS_ELEMENT_POS, 'bufferIndex':0, 'bufferUsage': rdgeConstants.BUFFER_STATIC},
-				"normal":{'type':rdgeConstants.VS_ELEMENT_FLOAT3, 'bufferIndex':1, 'bufferUsage': rdgeConstants.BUFFER_STATIC},
-				"a_norm":{'type':rdgeConstants.VS_ELEMENT_FLOAT3, 'bufferIndex':1, 'bufferUsage': rdgeConstants.BUFFER_STATIC},
-				"a_normal":{'type':rdgeConstants.VS_ELEMENT_FLOAT3, 'bufferIndex':1, 'bufferUsage': rdgeConstants.BUFFER_STATIC},
-				"texcoord":{'type':rdgeConstants.VS_ELEMENT_FLOAT2, 'bufferIndex':2, 'bufferUsage': rdgeConstants.BUFFER_STATIC},
-				"a_texcoord":{'type':rdgeConstants.VS_ELEMENT_FLOAT2, 'bufferIndex':2, 'bufferUsage': rdgeConstants.BUFFER_STATIC},
-				"a_texcoords":{'type':rdgeConstants.VS_ELEMENT_FLOAT2, 'bufferIndex':2, 'bufferUsage': rdgeConstants.BUFFER_STATIC},
-				"a_uv":{'type':rdgeConstants.VS_ELEMENT_FLOAT2, 'bufferIndex':2, 'bufferUsage': rdgeConstants.BUFFER_STATIC}
+                // this shows two ways to map this data to an attribute
+                "vert": { 'type': RDGE.rdgeConstants.VS_ELEMENT_POS, 'bufferIndex': 0, 'bufferUsage': RDGE.rdgeConstants.BUFFER_STATIC },
+                "a_pos": { 'type': RDGE.rdgeConstants.VS_ELEMENT_POS, 'bufferIndex': 0, 'bufferUsage': RDGE.rdgeConstants.BUFFER_STATIC },
+                "normal": { 'type': RDGE.rdgeConstants.VS_ELEMENT_FLOAT3, 'bufferIndex': 1, 'bufferUsage': RDGE.rdgeConstants.BUFFER_STATIC },
+                "a_norm": { 'type': RDGE.rdgeConstants.VS_ELEMENT_FLOAT3, 'bufferIndex': 1, 'bufferUsage': RDGE.rdgeConstants.BUFFER_STATIC },
+                "a_normal": { 'type': RDGE.rdgeConstants.VS_ELEMENT_FLOAT3, 'bufferIndex': 1, 'bufferUsage': RDGE.rdgeConstants.BUFFER_STATIC },
+                "texcoord": { 'type': RDGE.rdgeConstants.VS_ELEMENT_FLOAT2, 'bufferIndex': 2, 'bufferUsage': RDGE.rdgeConstants.BUFFER_STATIC },
+                "a_texcoord": { 'type': RDGE.rdgeConstants.VS_ELEMENT_FLOAT2, 'bufferIndex': 2, 'bufferUsage': RDGE.rdgeConstants.BUFFER_STATIC },
+                "a_texcoords": { 'type': RDGE.rdgeConstants.VS_ELEMENT_FLOAT2, 'bufferIndex': 2, 'bufferUsage': RDGE.rdgeConstants.BUFFER_STATIC },
+                "a_uv": { 'type': RDGE.rdgeConstants.VS_ELEMENT_FLOAT2, 'bufferIndex': 2, 'bufferUsage': RDGE.rdgeConstants.BUFFER_STATIC }
             };
-            
-            primset.bufferStreams = 
+
+            primset.bufferStreams =
             [
 				model.root.data.coords,
 				model.root.data.normals,
 				model.root.data.uvs
             ];
-            
-            primset.streamUsage = 
+
+            primset.streamUsage =
             [
-				rdgeConstants.BUFFER_STATIC,
-				rdgeConstants.BUFFER_STATIC,
-				rdgeConstants.BUFFER_STATIC
+				RDGE.rdgeConstants.BUFFER_STATIC,
+				RDGE.rdgeConstants.BUFFER_STATIC,
+				RDGE.rdgeConstants.BUFFER_STATIC
             ];
-            
-            primset.indexUsage  = rdgeConstants.BUFFER_STREAM;
-            
+
+            primset.indexUsage = RDGE.rdgeConstants.BUFFER_STREAM;
+
             primset.indexBuffer = model.root.data.indices;
 
-			renderer.createPrimitive( primset );
-			
-			model.root.primitive = primset;
+            renderer.createPrimitive(primset);
+
+            model.root.primitive = primset;
 
             // generate a bounding box for this mesh
-            model.root.bbox = new box();
+            model.root.bbox = new RDGE.box();
 
             var numCoords = model.root.data.coords.length; var idx = 0;
-            while (idx < numCoords - 2)
-            {
-              var thisCoord = [model.root.data.coords[idx+0], model.root.data.coords[idx+1], model.root.data.coords[idx+2]];
-              model.root.bbox.addVec3(thisCoord);
-              idx += 3;
+            while (idx < numCoords - 2) {
+                var thisCoord = [model.root.data.coords[idx + 0], model.root.data.coords[idx + 1], model.root.data.coords[idx + 2]];
+                model.root.bbox.addVec3(thisCoord);
+                idx += 3;
             }
 
             this.modelMap[model.root.attribs.name] = model.root;
-            
+
             // now that the model is load reduce the request count
             this.requestCounter--;
-            
+
             this.onLoaded(model.root.attribs.name);
             //break;
         }
 
     }
-}
+};
 
-MeshManager.prototype.isReady = function() 
-{ 
-	return this.readyList.length == 0; 
-}
+RDGE.MeshManager.prototype.isReady = function () {
+    return this.readyList.length == 0;
+};
 
-MeshManager.prototype.addOnLoadedCallback = function (callback) 
-{
+RDGE.MeshManager.prototype.addOnLoadedCallback = function (callback) {
     this.postMeshLoadCallbackList.push(callback)
-}
+};
 
-MeshManager.prototype.onLoaded = function ( meshName ) 
-{
-    for (var index = 0 in this.postMeshLoadCallbackList) 
-    {
+RDGE.MeshManager.prototype.onLoaded = function (meshName) {
+    for (var index = 0 in this.postMeshLoadCallbackList) {
         // call the functions
         this.postMeshLoadCallbackList[index].onMeshLoaded(meshName);
     }
-}
-
-MeshManager.prototype.exportJSON = function () 
-{	
-	for(var m in this.modelMap)
-	{
-		this.modelMap[m].primitive.built = false;
-	}
-	
-	return JSON.stringify(this.modelMap);
-}
-
-MeshManager.prototype.importJSON = function ( jsonMeshExport ) 
-{
-	try
-	{
-		var tempModelMap = JSON.parse(jsonMeshExport);
-		
-		for(var m in tempModelMap)
-		{
-			if(!this.modelMap[m])
-			{
-				this.modelMap[m] = tempModelMap[m];
-			}
-		}
-		window.console.log("meshes imported");
-	}catch( e )
-	{
-		window.console.error("error importing meshes: " + e.description );		
-	}
-}
+};
+
+RDGE.MeshManager.prototype.exportJSON = function () {
+    for (var m in this.modelMap) {
+        this.modelMap[m].primitive.built = false;
+    }
+
+    return JSON.stringify(this.modelMap);
+};
+
+RDGE.MeshManager.prototype.importJSON = function (jsonMeshExport) {
+    try {
+        var tempModelMap = JSON.parse(jsonMeshExport);
+
+        for (var m in tempModelMap) {
+            if (!this.modelMap[m]) {
+                this.modelMap[m] = tempModelMap[m];
+            }
+        }
+        window.console.log("meshes imported");
+    } catch (e) {
+        window.console.error("error importing meshes: " + e.description);
+    }
+};
 
 /*
- *	global function for the mesh manager to make mesh file requests
- */ 
-function requestMesh(mesh) 
-{
+*	global function for the mesh manager to make mesh file requests
+*/
+RDGE.requestMesh = function (mesh) {
     var request = new XMLHttpRequest();
     request.mesh = mesh;
     request.onreadystatechange = function () {
@@ -229,7 +210,7 @@ function requestMesh(mesh)
                 var mesh = eval("(" + request.responseText + ")"); //retrieve result as an JavaScript object
                 mesh.ready = true;
                 mesh.ctxID = request.mesh.ctxID;
-                g_meshMan.readyList.push(mesh);
+                RDGE.globals.meshMan.readyList.push(mesh);
             }
             else {
                 alert("An error has occured making the request");
@@ -239,4 +220,4 @@ function requestMesh(mesh)
 
     request.open("GET", mesh.addr, true);
     request.send(null);
-}
+};
diff --git a/js/helper-classes/RDGE/src/core/script/RenderInitProcs.js b/js/helper-classes/RDGE/src/core/script/RenderInitProcs.js
index 9d4e0d63..4e80183e 100755
--- a/js/helper-classes/RDGE/src/core/script/RenderInitProcs.js
+++ b/js/helper-classes/RDGE/src/core/script/RenderInitProcs.js
@@ -4,260 +4,232 @@ No rights, expressed or implied, whatsoever to this software are provided by Mot
 (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
 </copyright> */
 
-renderInitProcDefault   = __renderInitProcDefault;
-renderInitScreenQuad    = __renderInitScreenQuad;
-renderInitProcDepthMap  = __renderInitProcDepthMap;
-renderInitShadowReceiver= __renderInitShadowReceiver;
-renderInitShadowProjection = __renderInitShadowProjection;
-
-function __renderInitProcDefault(primSet, vertexData)
-{
-        var material = primSet.material;
-        
-        //push envMap tex
-        material.tex.env.push(arrayPeek(material.shader).envMap);
-        material.tex.envDiff.push(arrayPeek(material.shader).envDiff);
-        
-        gl.useProgram(arrayPeek(material.shader).shaderHandle);
-        
-        arrayPeek(material.renderObj).addTexture("layerMap1", 0, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("layerMap2", 1, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("colorMeMap1", 2, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("colorMeMap2", 3, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("envMap", 4, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("envDiff", 5, UNIFORMTYPE.TEXTURE2D);
-
-        arrayPeek(material.renderObj).addTexture("normalMap1", 15, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("normalMap2", 6, UNIFORMTYPE.TEXTURE2D);
-
-        arrayPeek(material.renderObj).addTexture("stickerMap0", 7, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("stickerMap1", 8, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("stickerMap2", 9, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("stickerMap3", 10, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("stickerMap4", 11, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("stickerMap5", 12, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("stickerMap6", 13, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addTexture("stickerMap7", 14, UNIFORMTYPE.TEXTURE2D);
-
-        arrayPeek(material.renderObj).addUniform("u_normalMatrix", gl.normalMatrix, UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_mvMatrix", gl.mvMatrix, UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_invMvMatrix", gl.invMvMatrix, UNIFORMTYPE.MATRIX4);
-        
-        arrayPeek(material.renderObj).addUniform("u_stickerMatrix0", primSet.parentMesh.stickers[0], UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_stickerMatrix1", primSet.parentMesh.stickers[1], UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_stickerMatrix2", primSet.parentMesh.stickers[2], UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_stickerMatrix3", primSet.parentMesh.stickers[3], UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_stickerMatrix4", primSet.parentMesh.stickers[4], UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_stickerMatrix5", primSet.parentMesh.stickers[5], UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_stickerMatrix6", primSet.parentMesh.stickers[6], UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_stickerMatrix7", primSet.parentMesh.stickers[7], UNIFORMTYPE.MATRIX4);
-
-        arrayPeek(material.renderObj).addUniform("u_stickerPos0", primSet.parentMesh.stickersPos[0], UNIFORMTYPE.FLOAT3);
-        arrayPeek(material.renderObj).addUniform("u_stickerPos1", primSet.parentMesh.stickersPos[1], UNIFORMTYPE.FLOAT3);
-        arrayPeek(material.renderObj).addUniform("u_stickerPos2", primSet.parentMesh.stickersPos[2], UNIFORMTYPE.FLOAT3);
-        arrayPeek(material.renderObj).addUniform("u_stickerPos3", primSet.parentMesh.stickersPos[3], UNIFORMTYPE.FLOAT3);
-        arrayPeek(material.renderObj).addUniform("u_stickerPos4", primSet.parentMesh.stickersPos[4], UNIFORMTYPE.FLOAT3);
-        arrayPeek(material.renderObj).addUniform("u_stickerPos5", primSet.parentMesh.stickersPos[5], UNIFORMTYPE.FLOAT3);
-        arrayPeek(material.renderObj).addUniform("u_stickerPos6", primSet.parentMesh.stickersPos[6], UNIFORMTYPE.FLOAT3);
-        arrayPeek(material.renderObj).addUniform("u_stickerPos7", primSet.parentMesh.stickersPos[7], UNIFORMTYPE.FLOAT3);
-        
-
-        arrayPeek(material.renderObj).addUniform("u_projMatrix", gl.perspectiveMatrix, UNIFORMTYPE.MATRIX4);
-        
-        arrayPeek(material.renderObj).addUniform("u_fillColor1",  material.fillColor[0], UNIFORMTYPE.FLOAT4);
-        arrayPeek(material.renderObj).addUniform("u_fillColor2",  material.fillColor[1], UNIFORMTYPE.FLOAT4);
-        arrayPeek(material.renderObj).addUniform("u_skinColor",   material.fillColor[2], UNIFORMTYPE.FLOAT4);
-        
-
-        // debug---
-        vertexData.vertexObject.name   = "vertexObject";
-        vertexData.normalObject.name   = "normalObject";
-        vertexData.texCoordObject.name = "texCoordObject";
-        vertexData.indexObject.name    = "indexObject";
-        //----------
-        
-        arrayPeek(material.renderObj).addBuffers(vertexData.vertexObject,     gl.ARRAY_BUFFER, 3, 0, gl.FLOAT);
-        arrayPeek(material.renderObj).addBuffers(vertexData.normalObject,     gl.ARRAY_BUFFER, 3, 1, gl.FLOAT);
-        arrayPeek(material.renderObj).addBuffers(vertexData.texCoordObject,   gl.ARRAY_BUFFER, 2, 2, gl.FLOAT);
-        arrayPeek(material.renderObj).addBuffers(vertexData.indexObject,      gl.ELEMENT_ARRAY_BUFFER);
-
-       
-     //}
-
-     gl.useProgram(null);
-//     gl.console.log("Mesh Init done!");
-
-}
-
-function __renderInitScreenQuad(quad, shader)
-{
-    if(shader == undefined)
-    {
-      quad.shader = createShader(gl, 'screenQuad_vShader', 'screenQuad_fShader', [ "vert", "texcoord"]);
-  }
-  else
-  {
-      quad.shader = shader;
-  }
-  
-  quad.renderObj = new RenderObject(quad.shader);
-  
-  quadBuf = getScreenAlignedQuad();
-  
-  quad.vertBuffer = quadBuf.vertexObject;
-  quad.uvBuffer = quadBuf.texCoordObject;
-  
-  
-  quad.renderObj.addTexture("basemap", 0, UNIFORMTYPE.TEXTURE2D);
-  
-  var invWidth = (g_width == 0.0) ? 0.0 : 1.0/g_width, invHeight = (g_height == 0.0) ? 0.0 : 1.0/g_height;
-  quad.renderObj.addUniform("u_inv_viewport_width", invWidth, UNIFORMTYPE.FLOAT);
-  quad.renderObj.addUniform("u_inv_viewport_height", invHeight, UNIFORMTYPE.FLOAT);
-  
-  quad.renderObj.addBuffers(quad.vertBuffer,  gl.ARRAY_BUFFER,  3, 0, gl.FLOAT);
-  quad.renderObj.addBuffers(quad.uvBuffer,  gl.ARRAY_BUFFER,  2, 2, gl.FLOAT);
-}
-
-function __renderInitProcDepthMap(renderObj)
-{
-    renderObj.shader = g_depthShader.shaderHandle;//createShader(gl, depthMapVShader, depthMapFShader, [ "vert", "normal", "texcoord"]);
-    
+// RDGE namespaces
+var RDGE = RDGE || {};
+
+RDGE.renderInitProcDefault = function (primSet, vertexData) {
+    var material = primSet.material;
+
+    //push envMap tex
+    material.tex.env.push(arrayPeek(material.shader).envMap);
+    material.tex.envDiff.push(arrayPeek(material.shader).envDiff);
+
+    gl.useProgram(arrayPeek(material.shader).shaderHandle);
+
+    arrayPeek(material.renderObj).addTexture("layerMap1", 0, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("layerMap2", 1, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("colorMeMap1", 2, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("colorMeMap2", 3, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("envMap", 4, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("envDiff", 5, RDGE.UNIFORMTYPE.TEXTURE2D);
+
+    arrayPeek(material.renderObj).addTexture("normalMap1", 15, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("normalMap2", 6, RDGE.UNIFORMTYPE.TEXTURE2D);
+
+    arrayPeek(material.renderObj).addTexture("stickerMap0", 7, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("stickerMap1", 8, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("stickerMap2", 9, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("stickerMap3", 10, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("stickerMap4", 11, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("stickerMap5", 12, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("stickerMap6", 13, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addTexture("stickerMap7", 14, RDGE.UNIFORMTYPE.TEXTURE2D);
+
+    arrayPeek(material.renderObj).addUniform("u_normalMatrix", gl.normalMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_mvMatrix", gl.mvMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_invMvMatrix", gl.invMvMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+
+    arrayPeek(material.renderObj).addUniform("u_stickerMatrix0", primSet.parentMesh.stickers[0], RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_stickerMatrix1", primSet.parentMesh.stickers[1], RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_stickerMatrix2", primSet.parentMesh.stickers[2], RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_stickerMatrix3", primSet.parentMesh.stickers[3], RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_stickerMatrix4", primSet.parentMesh.stickers[4], RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_stickerMatrix5", primSet.parentMesh.stickers[5], RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_stickerMatrix6", primSet.parentMesh.stickers[6], RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_stickerMatrix7", primSet.parentMesh.stickers[7], RDGE.UNIFORMTYPE.MATRIX4);
+
+    arrayPeek(material.renderObj).addUniform("u_stickerPos0", primSet.parentMesh.stickersPos[0], RDGE.UNIFORMTYPE.FLOAT3);
+    arrayPeek(material.renderObj).addUniform("u_stickerPos1", primSet.parentMesh.stickersPos[1], RDGE.UNIFORMTYPE.FLOAT3);
+    arrayPeek(material.renderObj).addUniform("u_stickerPos2", primSet.parentMesh.stickersPos[2], RDGE.UNIFORMTYPE.FLOAT3);
+    arrayPeek(material.renderObj).addUniform("u_stickerPos3", primSet.parentMesh.stickersPos[3], RDGE.UNIFORMTYPE.FLOAT3);
+    arrayPeek(material.renderObj).addUniform("u_stickerPos4", primSet.parentMesh.stickersPos[4], RDGE.UNIFORMTYPE.FLOAT3);
+    arrayPeek(material.renderObj).addUniform("u_stickerPos5", primSet.parentMesh.stickersPos[5], RDGE.UNIFORMTYPE.FLOAT3);
+    arrayPeek(material.renderObj).addUniform("u_stickerPos6", primSet.parentMesh.stickersPos[6], RDGE.UNIFORMTYPE.FLOAT3);
+    arrayPeek(material.renderObj).addUniform("u_stickerPos7", primSet.parentMesh.stickersPos[7], RDGE.UNIFORMTYPE.FLOAT3);
+
+    arrayPeek(material.renderObj).addUniform("u_projMatrix", gl.perspectiveMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+
+    arrayPeek(material.renderObj).addUniform("u_fillColor1", material.fillColor[0], RDGE.UNIFORMTYPE.FLOAT4);
+    arrayPeek(material.renderObj).addUniform("u_fillColor2", material.fillColor[1], RDGE.UNIFORMTYPE.FLOAT4);
+    arrayPeek(material.renderObj).addUniform("u_skinColor", material.fillColor[2], RDGE.UNIFORMTYPE.FLOAT4);
+
+    // debug---
+    vertexData.vertexObject.name = "vertexObject";
+    vertexData.normalObject.name = "normalObject";
+    vertexData.texCoordObject.name = "texCoordObject";
+    vertexData.indexObject.name = "indexObject";
+    //----------
+
+    arrayPeek(material.renderObj).addBuffers(vertexData.vertexObject, gl.ARRAY_BUFFER, 3, 0, gl.FLOAT);
+    arrayPeek(material.renderObj).addBuffers(vertexData.normalObject, gl.ARRAY_BUFFER, 3, 1, gl.FLOAT);
+    arrayPeek(material.renderObj).addBuffers(vertexData.texCoordObject, gl.ARRAY_BUFFER, 2, 2, gl.FLOAT);
+    arrayPeek(material.renderObj).addBuffers(vertexData.indexObject, gl.ELEMENT_ARRAY_BUFFER);
+
+    gl.useProgram(null);
+    //     gl.console.log("Mesh Init done!");
+};
+
+RDGE.renderInitScreenQuad = function (quad, shader) {
+    if (shader == undefined) {
+        quad.shader = RDGE.createShader(gl, 'screenQuad_vShader', 'screenQuad_fShader', ["vert", "texcoord"]);
+    }
+    else {
+        quad.shader = shader;
+    }
+
+    quad.renderObj = new RDGE.RenderObject(quad.shader);
+
+    quadBuf = getScreenAlignedQuad();
+
+    quad.vertBuffer = quadBuf.vertexObject;
+    quad.uvBuffer = quadBuf.texCoordObject;
+
+
+    quad.renderObj.addTexture("basemap", 0, RDGE.UNIFORMTYPE.TEXTURE2D);
+
+    var invWidth = (RDGE.globals.width == 0.0) ? 0.0 : 1.0 / RDGE.globals.width, invHeight = (RDGE.globals.height == 0.0) ? 0.0 : 1.0 / RDGE.globals.height;
+    quad.renderObj.addUniform("u_inv_viewport_width", invWidth, RDGE.UNIFORMTYPE.FLOAT);
+    quad.renderObj.addUniform("u_inv_viewport_height", invHeight, RDGE.UNIFORMTYPE.FLOAT);
+
+    quad.renderObj.addBuffers(quad.vertBuffer, gl.ARRAY_BUFFER, 3, 0, gl.FLOAT);
+    quad.renderObj.addBuffers(quad.uvBuffer, gl.ARRAY_BUFFER, 2, 2, gl.FLOAT);
+};
+
+RDGE.renderInitProcDepthMap = function (renderObj) {
+    renderObj.shader = g_depthShader.shaderHandle; //RDGE.createShader(gl, depthMapVShader, depthMapFShader, [ "vert", "normal", "texcoord"]);
+
     gl.useProgram(renderObj.shader);
 
-    renderObj.addUniform("u_mvpLightMatrix",  g_mainLight.mvpMatrix, UNIFORMTYPE.MATRIX4);
-    //renderObj.addUniform("u_mvpLightMatrixWTF",  g_mainLight.mvpMatrix, UNIFORMTYPE.MATRIX4);
-   // var uni = gl.getUniformLocation(renderObj.shader, "u_mvpLightMatrixWTF");
-//    renderObj.addUniform("u_WTF1",  g_lightMat[0], UNIFORMTYPE.FLOAT4);
-//    renderObj.addUniform("u_WTF2",  g_lightMat[1], UNIFORMTYPE.FLOAT4);
-//    renderObj.addUniform("u_WTF3",  g_lightMat[2], UNIFORMTYPE.FLOAT4);
-//    renderObj.addUniform("u_WTF4",  g_lightMat[3], UNIFORMTYPE.FLOAT4);
-//    
+    renderObj.addUniform("u_mvpLightMatrix", g_mainLight.mvpMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+    //renderObj.addUniform("u_mvpLightMatrixWTF",  g_mainLight.mvpMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+    // var uni = gl.getUniformLocation(renderObj.shader, "u_mvpLightMatrixWTF");
+    //    renderObj.addUniform("u_WTF1",  g_lightMat[0], RDGE.UNIFORMTYPE.FLOAT4);
+    //    renderObj.addUniform("u_WTF2",  g_lightMat[1], RDGE.UNIFORMTYPE.FLOAT4);
+    //    renderObj.addUniform("u_WTF3",  g_lightMat[2], RDGE.UNIFORMTYPE.FLOAT4);
+    //    renderObj.addUniform("u_WTF4",  g_lightMat[3], RDGE.UNIFORMTYPE.FLOAT4);
+    //    
     // since the uniform data references should not change we can just bind one time
     renderObj.bindUniforms();
-    
+
+    gl.useProgram(null);
+};
+
+RDGE.renderInitShadowReceiver = function (primSet, vertexData) {
+    // setup passes
+    primSet.shadowTarget = g_texMan.loadRenderTarget("shadowTarget", 256, 256);
+    primSet.shadowTargetFinal = g_texMan.loadRenderTarget("shadowTargetFinal", 256, 256);
+    primSet.screenQuad = new RDGE.ScreenQuad(primSet.shadowTargetFinal);
+    primSet.screenQuad.initialize(RDGE.renderInitRadialBlur);
+
+    // set the target as the shadow to get projcetd
+    primSet.parentMesh.shadowToProject = primSet.shadowTarget;
+
+    //mainSceneQuad   = new RDGE.ScreenQuad(primSet.shadowTarget);
+    //mainSceneQuad.initialize(renderInitScreenQuad);
+
+    var material = primSet.material;
+
+    //push envMap tex
+    material.tex.env.push(arrayPeek(material.shader).envMap);
+    material.tex.envDiff.push(arrayPeek(material.shader).envDiff);
+
+    gl.useProgram(arrayPeek(material.shader).shaderHandle);
+
+    arrayPeek(material.renderObj).addTexture("shadowMap", 0, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addUniform("u_mvMatrix", gl.mvMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+
+    arrayPeek(material.renderObj).addUniform("u_projMatrix", gl.perspectiveMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+
+    arrayPeek(material.renderObj).addUniform("u_shadowBiasMatrix", g_mainLight.shadowMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_vShadowLight", g_mainLight.view, RDGE.UNIFORMTYPE.MATRIX4);
+
+
+    // debug---
+    vertexData.vertexObject.name = "vertexObject";
+    vertexData.normalObject.name = "normalObject";
+    vertexData.texCoordObject.name = "texCoordObject";
+    vertexData.indexObject.name = "indexObject";
+    //----------
+
+    arrayPeek(material.renderObj).addBuffers(vertexData.vertexObject, gl.ARRAY_BUFFER, 3, 0, gl.FLOAT);
+    arrayPeek(material.renderObj).addBuffers(vertexData.normalObject, gl.ARRAY_BUFFER, 3, 1, gl.FLOAT);
+    arrayPeek(material.renderObj).addBuffers(vertexData.texCoordObject, gl.ARRAY_BUFFER, 2, 2, gl.FLOAT);
+    arrayPeek(material.renderObj).addBuffers(vertexData.indexObject, gl.ELEMENT_ARRAY_BUFFER);
+
     gl.useProgram(null);
-}
-
-function __renderInitShadowReceiver(primSet, vertexData)
-{
-        // setup passes
-        primSet.shadowTarget = g_texMan.loadRenderTarget("shadowTarget", 256, 256);
-        primSet.shadowTargetFinal = g_texMan.loadRenderTarget("shadowTargetFinal", 256, 256);
-        primSet.screenQuad = new ScreenQuad(primSet.shadowTargetFinal);
-        primSet.screenQuad.initialize(__renderInitRadialBlur);
-        
-        // set the target as the shadow to get projcetd
-        primSet.parentMesh.shadowToProject = primSet.shadowTarget;
-        
-        //mainSceneQuad   = new ScreenQuad(primSet.shadowTarget);
-        //mainSceneQuad.initialize(renderInitScreenQuad);
-
-        var material = primSet.material;
-        
-        //push envMap tex
-        material.tex.env.push(arrayPeek(material.shader).envMap);
-        material.tex.envDiff.push(arrayPeek(material.shader).envDiff);
-        
-        gl.useProgram(arrayPeek(material.shader).shaderHandle);
-        
-        arrayPeek(material.renderObj).addTexture("shadowMap", 0, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addUniform("u_mvMatrix", gl.mvMatrix, UNIFORMTYPE.MATRIX4);
-        
-        arrayPeek(material.renderObj).addUniform("u_projMatrix", gl.perspectiveMatrix, UNIFORMTYPE.MATRIX4);
-        
-        arrayPeek(material.renderObj).addUniform("u_shadowBiasMatrix",  g_mainLight.shadowMatrix, UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_vShadowLight",  g_mainLight.view, UNIFORMTYPE.MATRIX4);
-        
-
-        // debug---
-        vertexData.vertexObject.name   = "vertexObject";
-        vertexData.normalObject.name   = "normalObject";
-        vertexData.texCoordObject.name = "texCoordObject";
-        vertexData.indexObject.name    = "indexObject";
-        //----------
-        
-        arrayPeek(material.renderObj).addBuffers(vertexData.vertexObject,     gl.ARRAY_BUFFER, 3, 0, gl.FLOAT);
-        arrayPeek(material.renderObj).addBuffers(vertexData.normalObject,     gl.ARRAY_BUFFER, 3, 1, gl.FLOAT);
-        arrayPeek(material.renderObj).addBuffers(vertexData.texCoordObject,   gl.ARRAY_BUFFER, 2, 2, gl.FLOAT);
-        arrayPeek(material.renderObj).addBuffers(vertexData.indexObject,      gl.ELEMENT_ARRAY_BUFFER);
-
-       
-     //}
-
-     gl.useProgram(null);
-//     gl.console.log("Mesh Init done!");
-    
-    //__renderInitShadowProjection(primSet, vertexData);
-
-}
-
-
-function __renderInitShadowProjection(primSet, vertexData)
-{
-        var material = primSet.material;
-        
-        //push envMap tex
-        //material.tex.env.push(arrayPeek(material.shader).envMap);
-        //material.tex.envDiff.push(arrayPeek(material.shader).envDiff);
-        
-        gl.useProgram(arrayPeek(material.shader).shaderHandle);
-        
-        arrayPeek(material.renderObj).addTexture("shadowMap", 0, UNIFORMTYPE.TEXTURE2D);
-        arrayPeek(material.renderObj).addUniform("u_mvMatrix", gl.mvMatrix, UNIFORMTYPE.MATRIX4);
-        
-        arrayPeek(material.renderObj).addUniform("u_projMatrix", gl.perspectiveMatrix, UNIFORMTYPE.MATRIX4);
-        
-        arrayPeek(material.renderObj).addUniform("u_shadowBiasMatrix",  g_mainLight.shadowMatrix, UNIFORMTYPE.MATRIX4);
-        arrayPeek(material.renderObj).addUniform("u_vShadowLight",  g_mainLight.view, UNIFORMTYPE.MATRIX4);
-        
-
-        // debug---
-        vertexData.vertexObject.name   = "vertexObject";
-        vertexData.normalObject.name   = "normalObject";
-        vertexData.texCoordObject.name = "texCoordObject";
-        vertexData.indexObject.name    = "indexObject";
-        //----------
-        
-        arrayPeek(material.renderObj).addBuffers(vertexData.vertexObject,     gl.ARRAY_BUFFER, 3, 0, gl.FLOAT);
-        arrayPeek(material.renderObj).addBuffers(vertexData.normalObject,     gl.ARRAY_BUFFER, 3, 1, gl.FLOAT);
-        arrayPeek(material.renderObj).addBuffers(vertexData.texCoordObject,   gl.ARRAY_BUFFER, 2, 2, gl.FLOAT);
-        arrayPeek(material.renderObj).addBuffers(vertexData.indexObject,      gl.ELEMENT_ARRAY_BUFFER);
-
-       
-     //}
-
-     gl.useProgram(null);
-//     gl.console.log("Mesh Init done!");
-
-}
-
-function __renderInitRadialBlur(quad, shader)
-{
-     if(shader == undefined)
-    {
-      quad.shader = createShader(gl, 'radialBlur_vshader', 'radialBlur_fshader', [ "vert", "texcoord"]);
-  }
-  else
-  {
-      quad.shader = shader;
-  }
-  
-  quad.renderObj = new RenderObject(quad.shader);
-  
-  quadBuf = getScreenAlignedQuad();
-  
-  quad.vertBuffer = quadBuf.vertexObject;
-  quad.uvBuffer = quadBuf.texCoordObject;
-  
-  
-  quad.renderObj.addTexture("basemap", 0, UNIFORMTYPE.TEXTURE2D);
-  
-  quad.renderObj.addUniform("u_inv_viewport_width", 1.0/g_width, UNIFORMTYPE.FLOAT);
-  quad.renderObj.addUniform("u_inv_viewport_height", 1.0/g_height, UNIFORMTYPE.FLOAT);
-  quad.renderObj.addUniform("u_sampRadius", 5.0, UNIFORMTYPE.FLOAT);
-  quad.renderObj.addUniform("u_numSamples", 16, UNIFORMTYPE.INT);
-  quad.renderObj.addUniform("u_mapSize", 256.0, UNIFORMTYPE.FLOAT);
-  
-  quad.renderObj.addBuffers(quad.vertBuffer,  gl.ARRAY_BUFFER,  3, 0, gl.FLOAT);
-  quad.renderObj.addBuffers(quad.uvBuffer,  gl.ARRAY_BUFFER,  2, 2, gl.FLOAT);
-}
+
+    //RDGE.renderInitShadowProjection(primSet, vertexData);
+};
+
+
+RDGE.renderInitShadowProjection = function (primSet, vertexData) {
+    var material = primSet.material;
+
+    //push envMap tex
+    //material.tex.env.push(arrayPeek(material.shader).envMap);
+    //material.tex.envDiff.push(arrayPeek(material.shader).envDiff);
+
+    gl.useProgram(arrayPeek(material.shader).shaderHandle);
+
+    arrayPeek(material.renderObj).addTexture("shadowMap", 0, RDGE.UNIFORMTYPE.TEXTURE2D);
+    arrayPeek(material.renderObj).addUniform("u_mvMatrix", gl.mvMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+
+    arrayPeek(material.renderObj).addUniform("u_projMatrix", gl.perspectiveMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+
+    arrayPeek(material.renderObj).addUniform("u_shadowBiasMatrix", g_mainLight.shadowMatrix, RDGE.UNIFORMTYPE.MATRIX4);
+    arrayPeek(material.renderObj).addUniform("u_vShadowLight", g_mainLight.view, RDGE.UNIFORMTYPE.MATRIX4);
+
+
+    // debug---
+    vertexData.vertexObject.name = "vertexObject";
+    vertexData.normalObject.name = "normalObject";
+    vertexData.texCoordObject.name = "texCoordObject";
+    vertexData.indexObject.name = "indexObject";
+    //----------
+
+    arrayPeek(material.renderObj).addBuffers(vertexData.vertexObject, gl.ARRAY_BUFFER, 3, 0, gl.FLOAT);
+    arrayPeek(material.renderObj).addBuffers(vertexData.normalObject, gl.ARRAY_BUFFER, 3, 1, gl.FLOAT);
+    arrayPeek(material.renderObj).addBuffers(vertexData.texCoordObject, gl.ARRAY_BUFFER, 2, 2, gl.FLOAT);
+    arrayPeek(material.renderObj).addBuffers(vertexData.indexObject, gl.ELEMENT_ARRAY_BUFFER);
+
+
+    gl.useProgram(null);    
+};
+
+RDGE.renderInitRadialBlur = function(quad, shader) {
+    if (shader == undefined) {
+        quad.shader = RDGE.createShader(gl, 'radialBlur_vshader', 'radialBlur_fshader', ["vert", "texcoord"]);
+    }
+    else {
+        quad.shader = shader;
+    }
+
+    quad.renderObj = new RDGE.RenderObject(quad.shader);
+
+    quadBuf = getScreenAlignedQuad();
+
+    quad.vertBuffer = quadBuf.vertexObject;
+    quad.uvBuffer = quadBuf.texCoordObject;
+
+
+    quad.renderObj.addTexture("basemap", 0, RDGE.UNIFORMTYPE.TEXTURE2D);
+
+    quad.renderObj.addUniform("u_inv_viewport_width", 1.0 / RDGE.globals.width, RDGE.UNIFORMTYPE.FLOAT);
+    quad.renderObj.addUniform("u_inv_viewport_height", 1.0 / RDGE.globals.height, RDGE.UNIFORMTYPE.FLOAT);
+    quad.renderObj.addUniform("u_sampRadius", 5.0, RDGE.UNIFORMTYPE.FLOAT);
+    quad.renderObj.addUniform("u_numSamples", 16, RDGE.UNIFORMTYPE.INT);
+    quad.renderObj.addUniform("u_mapSize", 256.0, RDGE.UNIFORMTYPE.FLOAT);
+
+    quad.renderObj.addBuffers(quad.vertBuffer, gl.ARRAY_BUFFER, 3, 0, gl.FLOAT);
+    quad.renderObj.addBuffers(quad.uvBuffer, gl.ARRAY_BUFFER, 2, 2, gl.FLOAT);
+};
diff --git a/js/helper-classes/RDGE/src/core/script/RenderProcs.js b/js/helper-classes/RDGE/src/core/script/RenderProcs.js
index 6d3b02df..4d7c055c 100755
--- a/js/helper-classes/RDGE/src/core/script/RenderProcs.js
+++ b/js/helper-classes/RDGE/src/core/script/RenderProcs.js
@@ -4,533 +4,484 @@ No rights, expressed or implied, whatsoever to this software are provided by Mot
 (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
 </copyright> */
 
+// RDGE namespaces
+var RDGE = RDGE || {};
+
 /**
- *  supported uniform types
- */
-function __UNIFORMTYPE()
-{
-  this.INT          = 0x3F0;
-  this.FLOAT      = 0x3E8;
-  this.FLOAT2     = 0x3E9;
-  this.FLOAT3     = 0x3EA;
-  this.FLOAT4     = 0x3EB;
-  this.MATRIX3    = 0x3EC;
-  this.MATRIX4    = 0x3ED;
-  this.TEXTURE2D    = 0x3EE;
-  this.TEXTURECUBE  = 0x3EF;
-}
-UNIFORMTYPE = new __UNIFORMTYPE();
+*  supported uniform types
+*/
+RDGE.UNIFORMTYPE = function () {
+    this.INT = 0x3F0;
+    this.FLOAT = 0x3E8;
+    this.FLOAT2 = 0x3E9;
+    this.FLOAT3 = 0x3EA;
+    this.FLOAT4 = 0x3EB;
+    this.MATRIX3 = 0x3EC;
+    this.MATRIX4 = 0x3ED;
+    this.TEXTURE2D = 0x3EE;
+    this.TEXTURECUBE = 0x3EF;
+};
 
 /**
- * RenderObject - contains references to all the data need to render, including vertex buffers, uniform handles, and matrices
- * @param shaderHandle
- */
-function RenderObject(shaderHandle)
-{
-  this.shader         = shaderHandle;
-  this.world        = null;
-  this.bindings       = new ShaderData();
-  this.initRenderProc = null;
-  this.renderProc     = null;
-  this.postRenderProc = null;
-}
+* RDGE.RenderObject - contains references to all the data need to render, including vertex buffers, uniform handles, and matrices
+* @param shaderHandle
+*/
+RDGE.RenderObject = function (shaderHandle) {
+    this.shader = shaderHandle;
+    this.world = null;
+    this.bindings = new RDGE.ShaderData();
+    this.initRenderProc = null;
+    this.renderProc = null;
+    this.postRenderProc = null;
+};
 
 /**
- * Adds a uniform to the render object to bound during render
- * @param name - name of the uniform
- * @param value - reference to value that will get bound (will be referenced from now on, don't delete the ref)
- * @param type  - type of uniform, use UNIFORMTYPE
- */
-RenderObject.prototype.addUniform = function(name, value, type)
-{
-  var  uniform = gl.getUniformLocation(this.shader, name);
-  if(uniform)
-  {
-    uniform.debugName = name;
-    this.bindings.uniforms.push( new UniformPair(uniform, value, type));
-  }
-/*
-  else
-  {
-    gl.console.log("ERROR: uniform - " + name + " not found!");
-  }
+* Adds a uniform to the render object to bound during render
+* @param name - name of the uniform
+* @param value - reference to value that will get bound (will be referenced from now on, don't delete the ref)
+* @param type  - type of uniform, use RDGE.UNIFORMTYPE
 */
+RDGE.RenderObject.prototype.addUniform = function (name, value, type) {
+    var uniform = RDGE.globals.gl.getUniformLocation(this.shader, name);
+    if (uniform) {
+        uniform.debugName = name;
+        this.bindings.uniforms.push(new RDGE.UniformPair(uniform, value, type));
+    }
+    /*
+    else
+    {
+    gl.console.log("ERROR: uniform - " + name + " not found!");
+    }
+    */
 };
 
 /**
 * Adds a uniform to the render object to bound during render
 * @param name - name of the uniform
 * @param value - reference to value that will get bound (will be referenced from now on, don't delete the ref)
-* @param type - type of uniform, use UNIFORMTYPE
+* @param type - type of uniform, use RDGE.UNIFORMTYPE
 */
-RenderObject.prototype.addUniformArray = function(name, value, type, size)
-{
-  var  uniform = gl.getUniformLocation(this.shader, name);
-  if (uniform)
-  {
-        for (var index=0; index<size; index)
-        {
-        uniform.debugName = name+index;
-        this.bindings.uniforms.push( new UniformPair(uniform, value[index], type));
-        uniform+=value[index].length;
-        value++;
-      }
+RDGE.RenderObject.prototype.addUniformArray = function (name, value, type, size) {
+    var uniform = RDGE.globals.gl.getUniformLocation(this.shader, name);
+    if (uniform) {
+        for (var index = 0; index < size; index) {
+            uniform.debugName = name + index;
+            this.bindings.uniforms.push(new RDGE.UniformPair(uniform, value[index], type));
+            uniform += value[index].length;
+            value++;
+        }
     }
-/*
-  else
-  {
+    /*
+    else
+    {
     gl.console.log("ERROR: uniform - " + name + " not found!");
-  }*/
+    }*/
 };
+
 /**
- * Add texture to uniform
- * @param name - handle to the texture
- * @param unit - texture slot to use
- * @param type - UNIFORMTYPE.TEXTURE2D or TEXTURE2D.TEXTURECUBE
- */
-RenderObject.prototype.addTexture = function(name, unit, type)
-{
-  var  uniform = gl.getUniformLocation(this.shader, name);
-  if(uniform)
-  {
-    this.bindings.textures.push( new TexUniform(uniform, unit, type));
-  }
-/*
-  else
-  {
-    gl.console.log("ERROR: texture uniform - " + name + " not found!");
-  }
+* Add texture to uniform
+* @param name - handle to the texture
+* @param unit - texture slot to use
+* @param type - RDGE.UNIFORMTYPE.TEXTURE2D or TEXTURE2D.TEXTURECUBE
 */
+RDGE.RenderObject.prototype.addTexture = function (name, unit, type) {
+    var uniform = RDGE.globals.gl.getUniformLocation(this.shader, name);
+    if (uniform) {
+        this.bindings.textures.push(new RDGE.TexUniform(uniform, unit, type));
+    }
+    /*
+    else
+    {
+    gl.console.log("ERROR: texture uniform - " + name + " not found!");
+    }
+    */
 };
 
 /**
- * Adds a vertex buffer to the render object
- * @param buffer    - buffer to use
- * @param glBufferType  - type of buffer i.e. gl.ARRAY_BUFFER
- * @param attribSize  - if using attrib the size of an element (3 for vec3)
- * @param attribIndex - the index slot the attrib goes in
- * @param glAttribType  - type of the attrib i.e. gl.FLOAT
- */
-RenderObject.prototype.addBuffers = function(buffer, glBufferType, attribSize, attribIndex, glAttribType)
-{
-  //gl.useProgram(this.shader);
-  if( attribSize == undefined || attribIndex == undefined || glAttribType == undefined ||
-    attribSize == null    || attribIndex == null    || glAttribType == null )
-  {
-    this.bindings.buffers.push( new BufferAttrib(buffer, glBufferType, null, null, null));
-  }
-  else
-  {
-    this.bindings.buffers.push( new BufferAttrib(buffer, glBufferType, attribSize, attribIndex, glAttribType));
-  }
-  //gl.useProgram(null);
+* Adds a vertex buffer to the render object
+* @param buffer    - buffer to use
+* @param glBufferType  - type of buffer i.e. gl.ARRAY_BUFFER
+* @param attribSize  - if using attrib the size of an element (3 for vec3)
+* @param attribIndex - the index slot the attrib goes in
+* @param glAttribType  - type of the attrib i.e. gl.FLOAT
+*/
+RDGE.RenderObject.prototype.addBuffers = function (buffer, glBufferType, attribSize, attribIndex, glAttribType) {
+    //gl.useProgram(this.shader);
+    if (attribSize == undefined || attribIndex == undefined || glAttribType == undefined ||
+    attribSize == null || attribIndex == null || glAttribType == null) {
+        this.bindings.buffers.push(new RDGE.BufferAttrib(buffer, glBufferType, null, null, null));
+    }
+    else {
+        this.bindings.buffers.push(new RDGE.BufferAttrib(buffer, glBufferType, attribSize, attribIndex, glAttribType));
+    }
+    //gl.useProgram(null);
 };
 
 /**
- * bind the matrices, vertices and floats to shader uniforms
- */
-RenderObject.prototype.bindUniforms = function()
-{
-  for(var uniIndex = 0; uniIndex < this.bindings.uniforms.length; uniIndex++)
-  {
-    var bind = this.bindings.uniforms[uniIndex];
-    switch(bind.type)
-    {
-        case UNIFORMTYPE.INT:
-        gl.uniform1i(bind.uniform, bind.value);
-        break;
-      case UNIFORMTYPE.FLOAT:
-        gl.uniform1f(bind.uniform, bind.value);
-        break;
-      case UNIFORMTYPE.FLOAT2:  
-        gl.uniform2fv(bind.uniform, bind.value);
-        break;
-      case UNIFORMTYPE.FLOAT3:  
-        gl.uniform3fv(bind.uniform, bind.value);
-        break;
-      case UNIFORMTYPE.FLOAT4:  
-        gl.uniform4fv(bind.uniform, bind.value);
-        break;
-      case UNIFORMTYPE.MATRIX3: 
-        gl.uniformMatrix3fv(bind.uniform, false, bind.value);
-        break;
-      case UNIFORMTYPE.MATRIX4: 
-        gl.uniformMatrix4fv(bind.uniform, false, bind.value);
-        break;
-      default:
-//          gl.console.log("RenderObject: trying to bind unknown texture type");
-          break;
+* bind the matrices, vertices and floats to shader uniforms
+*/
+RDGE.RenderObject.prototype.bindUniforms = function () {
+    for (var uniIndex = 0; uniIndex < this.bindings.uniforms.length; uniIndex++) {
+        var bind = this.bindings.uniforms[uniIndex];
+        switch (bind.type) {
+            case RDGE.UNIFORMTYPE.INT:
+                RDGE.globals.gl.uniform1i(bind.uniform, bind.value);
+                break;
+            case RDGE.UNIFORMTYPE.FLOAT:
+                RDGE.globals.gl.uniform1f(bind.uniform, bind.value);
+                break;
+            case RDGE.UNIFORMTYPE.FLOAT2:
+                RDGE.globals.gl.uniform2fv(bind.uniform, bind.value);
+                break;
+            case RDGE.UNIFORMTYPE.FLOAT3:
+                RDGE.globals.gl.uniform3fv(bind.uniform, bind.value);
+                break;
+            case RDGE.UNIFORMTYPE.FLOAT4:
+                RDGE.globals.gl.uniform4fv(bind.uniform, bind.value);
+                break;
+            case RDGE.UNIFORMTYPE.MATRIX3:
+                RDGE.globals.gl.uniformMatrix3fv(bind.uniform, false, bind.value);
+                break;
+            case RDGE.UNIFORMTYPE.MATRIX4:
+                RDGE.globals.gl.uniformMatrix4fv(bind.uniform, false, bind.value);
+                break;
+            default:
+                //          gl.console.log("RDGE.RenderObject: trying to bind unknown texture type");
+                break;
+        }
     }
-  }
 };
 
 /**
- * binds the texture uniform to texture slots
- */
-RenderObject.prototype.bindTextures = function()
-{
-  for(var uniIndex = 0; uniIndex < this.bindings.textures.length; uniIndex++)
-  {
-    var bind = this.bindings.textures[uniIndex];
-    var error = 0;
-    switch(bind.type)
-    {
-      case UNIFORMTYPE.TEXTURE2D:
-        gl.activeTexture(gl.TEXTURE0 + bind.unit);
-                gl.uniform1i(bind.uniform, bind.unit);
-        break;
-      case UNIFORMTYPE.TEXTURECUBE:
-        gl.activeTexture(gl.TEXTURE0 + bind.unit);
-        gl.uniform1i(bind.uniform, bind.unit);
-        break;
-      default:
-//        gl.console.log("RenderObject: trying to bind unknown texture type");
-          break;
+* binds the texture uniform to texture slots
+*/
+RDGE.RenderObject.prototype.bindTextures = function () {
+    for (var uniIndex = 0; uniIndex < this.bindings.textures.length; uniIndex++) {
+        var bind = this.bindings.textures[uniIndex];
+        var error = 0;
+        switch (bind.type) {
+            case RDGE.UNIFORMTYPE.TEXTURE2D:
+                RDGE.globals.gl.activeTexture(RDGE.globals.gl.TEXTURE0 + bind.unit);
+                RDGE.globals.gl.uniform1i(bind.uniform, bind.unit);
+                break;
+            case RDGE.UNIFORMTYPE.TEXTURECUBE:
+                RDGE.globals.gl.activeTexture(RDGE.globals.gl.TEXTURE0 + bind.unit);
+                RDGE.globals.gl.uniform1i(bind.uniform, bind.unit);
+                break;
+            default:
+                //        gl.console.log("RDGE.RenderObject: trying to bind unknown texture type");
+                break;
+        }
     }
-  }
 };
+
 /**
- * Binds all buffers and enables any vertexAttribs
- */
-RenderObject.prototype.bindBuffers = function() {
-    for (var bufIndex = 0; bufIndex < this.bindings.buffers.length; bufIndex++) 
-    {
+* Binds all buffers and enables any vertexAttribs
+*/
+RDGE.RenderObject.prototype.bindBuffers = function () {
+    for (var bufIndex = 0; bufIndex < this.bindings.buffers.length; bufIndex++) {
         var bind = this.bindings.buffers[bufIndex];
-        gl.bindBuffer(bind.glBufferType, bind.buffer);
+        RDGE.globals.gl.bindBuffer(bind.glBufferType, bind.buffer);
 
         if (bind.glAttribType != null) {
             // enable the attribute and point buffer to it
-            gl.enableVertexAttribArray(bind.attribIndex);
+            RDGE.globals.gl.enableVertexAttribArray(bind.attribIndex);
 
-            gl.vertexAttribPointer(bind.attribIndex, bind.attribSize, bind.glAttribType, false, 0, 0);
+            RDGE.globals.gl.vertexAttribPointer(bind.attribIndex, bind.attribSize, bind.glAttribType, false, 0, 0);
         }
     }
 };
 
-RenderObject.prototype.unBindBuffers=function() 
-{
-    for(var bufIndex=0;bufIndex<this.bindings.buffers.length;bufIndex++) 
-    {
-        var bind=this.bindings.buffers[bufIndex];
-        
-        if(bind.glAttribType!=null) 
-        {
+RDGE.RenderObject.prototype.unBindBuffers = function () {
+    for (var bufIndex = 0; bufIndex < this.bindings.buffers.length; bufIndex++) {
+        var bind = this.bindings.buffers[bufIndex];
+
+        if (bind.glAttribType != null) {
             // enable the attribute and point buffer to it
-            gl.disableVertexAttribArray(bind.attribIndex);
+            RDGE.globals.gl.disableVertexAttribArray(bind.attribIndex);
         }
 
-        gl.bindBuffer(bind.glBufferType, null);
-
-
+        RDGE.globals.gl.bindBuffer(bind.glBufferType, null);
     }
 };
 
-RenderObject.prototype.initialize = function(initRenderProc)
-{
-  initRenderProc(this);
+RDGE.RenderObject.prototype.initialize = function (initRenderProc) {
+    initRenderProc(this);
 };
 
-RenderObject.prototype.clear = function()
-{
-  this.world   = mat4.identity();
-  this.bindings = new ShaderData();
+RDGE.RenderObject.prototype.clear = function () {
+    this.world = RDGE.mat4.identity();
+    this.bindings = new RDGE.ShaderData();
 };
 
-
 /***
- * Shader data proto
- */
-function ShaderData()
-{
-  this.uniforms     = [];
-  this.textures     = [];
-  this.buffers		= [];
-}
+* Shader data proto
+*/
+RDGE.ShaderData = function () {
+    this.uniforms = [];
+    this.textures = [];
+    this.buffers = [];
+};
 
 /***
- * Structure to contain reference data for binding to during render
- */
-function UniformPair(uniform, value, type)
-{
-  this.uniform = uniform;
-  this.value = value;
-  this.type = type;
-}
-
-function TexUniform(uniform, unit, type)
-{
-  this.uniform = uniform;
-  this.unit = unit;
-  this.type = type;
-}
-
-function BufferAttrib(buffer, glBufferType, attribSize, attribIndex, glAttribType)
-{
-  // buffer data
-  this.buffer     = buffer;
-  this.glBufferType = glBufferType;
-  
-  // attribute data (can be null)
-  this.attribSize   = attribSize;
-  this.glAttribType   = glAttribType;
-  this.attribIndex  = attribIndex;
-}
-
-
-
-/*-------------------------------------------------------------RENDER PROC HANDLES----------------------------------------------------------------------*/
-renderProcDefault       = __renderProcDefault;
-postRenderProcDefault   = __postRenderProcDefault;
-renderProcLines         = __renderProcLines;
-renderProcScreenQuad    = __renderProcScreenQuad;
-renderProcDepthMap      = __renderProcDepthMap;
-renderProcShadowReceiver= __renderProcShadowReceiver;
-renderProcShadowProjection = __renderProcShadowProjection;
-
-/*----------------------------------------------------------------RENDER PROCS--------------------------------------------------------------------------*/
-function __setActiveTexture(id, texture) 
-{
-    gl.activeTexture(id);
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-}
-
-function __renderProcDefault(primSet)
-{   
+* Structure to contain reference data for binding to during render
+*/
+RDGE.UniformPair = function (uniform, value, type) {
+    this.uniform = uniform;
+    this.value = value;
+    this.type = type;
+};
+
+RDGE.TexUniform = function (uniform, unit, type) {
+    this.uniform = uniform;
+    this.unit = unit;
+    this.type = type;
+};
+
+RDGE.BufferAttrib = function (buffer, glBufferType, attribSize, attribIndex, glAttribType) {
+    // buffer data
+    this.buffer = buffer;
+    this.glBufferType = glBufferType;
+
+    // attribute data (can be null)
+    this.attribSize = attribSize;
+    this.glAttribType = glAttribType;
+    this.attribIndex = attribIndex;
+};
+
+RDGE.setActiveTexture = function (id, texture) {
+    RDGE.globals.gl.activeTexture(id);
+    RDGE.globals.gl.bindTexture(RDGE.globals.gl.TEXTURE_2D, texture);
+};
+
+RDGE.renderProcDefault = function (primSet) {
     //gl.disable(gl.DEPTH_TEST);
     //gl.disable(gl.CULL_FACE);
-    var activeCam = g_cameraManager.getActiveCamera();
-    gl.mvMatrix = activeCam.view;
-    gl.mvMatrix = mat4.mul(gl.mvMatrix, primSet.parentMesh.world);
-    gl.invMvMatrix = mat4.inverse(gl.mvMatrix);
-    gl.normalMatrix = mat4.transpose( gl.invMvMatrix );
+    var activeCam = RDGE.globals.cameraManager.getActiveCamera();
+    RDGE.globals.gl.mvMatrix = activeCam.view;
+    RDGE.globals.gl.mvMatrix = RDGE.mat4.mul(RDGE.globals.gl.mvMatrix, primSet.parentMesh.world);
+    RDGE.globals.gl.invMvMatrix = RDGE.mat4.inverse(RDGE.globals.gl.mvMatrix);
+    RDGE.globals.gl.normalMatrix = RDGE.mat4.transpose(RDGE.globals.gl.invMvMatrix);
 
     // update shadow light MV matrix
-    gl.useProgram(arrayPeek(primSet.material.shader).shaderHandle);
+    RDGE.globals.gl.useProgram(arrayPeek(primSet.material.shader).shaderHandle);
     // Bind the texture
 
-    gl.activeTexture(gl.TEXTURE0);
-    gl.bindTexture(gl.TEXTURE_2D, arrayPeek(primSet.material.tex.set1).diff );
-    
-    gl.activeTexture(gl.TEXTURE1);
-    gl.bindTexture(gl.TEXTURE_2D, arrayPeek(primSet.material.tex.set2).diff );
-    
-     gl.activeTexture(gl.TEXTURE2);
-    gl.bindTexture(gl.TEXTURE_2D, arrayPeek(primSet.material.tex.set1).spec );
-    
-     gl.activeTexture(gl.TEXTURE3);
-    gl.bindTexture(gl.TEXTURE_2D, arrayPeek(primSet.material.tex.set2).spec );
-    
-    gl.activeTexture(gl.TEXTURE4);
-    gl.bindTexture(gl.TEXTURE_2D, arrayPeek(primSet.material.tex.env) );
-
-    gl.activeTexture(gl.TEXTURE5);
-    gl.bindTexture(gl.TEXTURE_2D, arrayPeek(primSet.material.tex.envDiff) );
-    
+    RDGE.globals.gl.activeTexture(RDGE.globals.gl.TEXTURE0);
+    RDGE.globals.gl.bindTexture(RDGE.globals.gl.TEXTURE_2D, arrayPeek(primSet.material.tex.set1).diff);
+
+    RDGE.globals.gl.activeTexture(RDGE.globals.gl.TEXTURE1);
+    RDGE.globals.gl.bindTexture(RDGE.globals.gl.TEXTURE_2D, arrayPeek(primSet.material.tex.set2).diff);
+
+    RDGE.globals.gl.activeTexture(RDGE.globals.gl.TEXTURE2);
+    RDGE.globals.gl.bindTexture(RDGE.globals.gl.TEXTURE_2D, arrayPeek(primSet.material.tex.set1).spec);
+
+    RDGE.globals.gl.activeTexture(RDGE.globals.gl.TEXTURE3);
+    RDGE.globals.gl.bindTexture(RDGE.globals.gl.TEXTURE_2D, arrayPeek(primSet.material.tex.set2).spec);
+
+    RDGE.globals.gl.activeTexture(RDGE.globals.gl.TEXTURE4);
+    RDGE.globals.gl.bindTexture(RDGE.globals.gl.TEXTURE_2D, arrayPeek(primSet.material.tex.env));
+
+    RDGE.globals.gl.activeTexture(RDGE.globals.gl.TEXTURE5);
+    RDGE.globals.gl.bindTexture(RDGE.globals.gl.TEXTURE_2D, arrayPeek(primSet.material.tex.envDiff));
+
     // stickers
-    __setActiveTexture(gl.TEXTURE7, g_cam.stickerTexture[0]);
-    __setActiveTexture(gl.TEXTURE8, g_cam.stickerTexture[1]);
-    __setActiveTexture(gl.TEXTURE9, g_cam.stickerTexture[2]);
-    __setActiveTexture(gl.TEXTURE10, g_cam.stickerTexture[3]);
-    __setActiveTexture(gl.TEXTURE11, g_cam.stickerTexture[4]);
-    __setActiveTexture(gl.TEXTURE12, g_cam.stickerTexture[5]);
-    __setActiveTexture(gl.TEXTURE13, g_cam.stickerTexture[6]);
-    __setActiveTexture(gl.TEXTURE14, g_cam.stickerTexture[7]);
+    RDGE.setActiveTexture(RDGE.globals.gl.TEXTURE7, RDGE.globals.cam.stickerTexture[0]);
+    RDGE.setActiveTexture(RDGE.globals.gl.TEXTURE8, RDGE.globals.cam.stickerTexture[1]);
+    RDGE.setActiveTexture(RDGE.globals.gl.TEXTURE9, RDGE.globals.cam.stickerTexture[2]);
+    RDGE.setActiveTexture(RDGE.globals.gl.TEXTURE10, RDGE.globals.cam.stickerTexture[3]);
+    RDGE.setActiveTexture(RDGE.globals.gl.TEXTURE11, RDGE.globals.cam.stickerTexture[4]);
+    RDGE.setActiveTexture(RDGE.globals.gl.TEXTURE12, RDGE.globals.cam.stickerTexture[5]);
+    RDGE.setActiveTexture(RDGE.globals.gl.TEXTURE13, RDGE.globals.cam.stickerTexture[6]);
+    RDGE.setActiveTexture(RDGE.globals.gl.TEXTURE14, RDGE.globals.cam.stickerTexture[7]);
 
     // copy current cams matrix
-    for (var i = 0; i < 8; i++) 
-    {
-        primSet.parentMesh.stickers[i].load(g_cam.stickers[i]);
-        primSet.parentMesh.stickersPos[i].setvec(g_cam.stickersPos[i]);
+    for (var i = 0; i < 8; i++) {
+        primSet.parentMesh.stickers[i].load(RDGE.globals.cam.stickers[i]);
+        primSet.parentMesh.stickersPos[i].setvec(RDGE.globals.cam.stickersPos[i]);
     }
-    __setActiveTexture(gl.TEXTURE15, arrayPeek(primSet.material.tex.set1).norm);
-    __setActiveTexture(gl.TEXTURE6, arrayPeek(primSet.material.tex.set2).norm);
+    RDGE.setActiveTexture(RDGE.globals.gl.TEXTURE15, arrayPeek(primSet.material.tex.set1).norm);
+    RDGE.setActiveTexture(RDGE.globals.gl.TEXTURE6, arrayPeek(primSet.material.tex.set2).norm);
 
     //bind buffers and attribs
     arrayPeek(primSet.material.renderObj).bindBuffers();
 
     // bind shader uniforms
     arrayPeek(primSet.material.renderObj).bindTextures();
-    
+
     arrayPeek(primSet.material.renderObj).bindUniforms();
-    
-    gl.drawElements(gl.TRIANGLES, primSet.size, gl.UNSIGNED_SHORT, primSet.indexInBuffer*2);
-}
-
-function __renderProcLines(renderObj, r, g, b, a)
-{
-  gl.useProgram(renderObj.shader);
-  
-  renderObj.lineColor[0] = r;
-  renderObj.lineColor[1] = g;
-  renderObj.lineColor[2] = b;
-  renderObj.lineColor[3] = a;
-  
-  //bind buffers and attribs
-  renderObj.bindBuffers();
-