Merge branch 'master' of github.com:Motorola-Mobility/ninja-internal into Snapping

Conflicts:
	js/panels/presets/animations-presets.reel/animations-presets.js
	js/panels/presets/style-presets.reel/style-presets.js
	js/panels/presets/transitions-presets.reel/transitions-presets.js

1 files changed, 50 insertions, 249 deletions

diff --git a/js/lib/drawing/world.js b/js/lib/drawing/world.js
index 5a054224..657c849f 100755
--- a/js/lib/drawing/world.js
+++ b/js/lib/drawing/world.js
@@ -144,45 +144,45 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
     
     // post-load processing of the scene
     this.init = function() {
-                var ctx1 = g_Engine.ctxMan.handleToObject(this._canvas.rdgeCtxHandle),
-                        ctx2 = g_Engine.getContext();
+                var ctx1 = RDGE.globals.engine.ctxMan.handleToObject(this._canvas.rdgeCtxHandle),
+                        ctx2 = RDGE.globals.engine.getContext();
                 if (ctx1 != ctx2)  console.log( "***** different contexts *****" );
                 this.renderer = ctx1.renderer;
                 this.renderer._world = this;
       
                 // create a camera, set its perspective, and then point it at the origin
-                var cam = new camera();
+                var cam = new RDGE.camera();
                 this._camera = cam;
                 cam.setPerspective(this.getFOV(), this.getAspect(), this.getZNear(), this.getZFar());
-                cam.setLookAt([0, 0, this.getViewDistance()], [0, 0, 0], vec3.up());
+                cam.setLookAt([0, 0, this.getViewDistance()], [0, 0, 0], RDGE.vec3.up());
         
                 // make this camera the active camera
                 this.renderer.cameraManager().setActiveCamera(cam);
 
                 // change clear color
-                //this.renderer.setClearFlags(g_Engine.getContext().DEPTH_BUFFER_BIT);
+                //this.renderer.setClearFlags(RDGE.globals.engine.getContext().DEPTH_BUFFER_BIT);
                 this.renderer.setClearColor([0.0, 0.0, 0.0, 0.0]);
                 //this.renderer.NinjaWorld = this;
         
                 // create an empty scene graph
-                this.myScene = new SceneGraph();
+                this.myScene = new RDGE.SceneGraph();
         
                 // create some lights
                 // light 1
-                this.light = createLightNode("myLight");
+                this.light = RDGE.createLightNode("myLight");
                 this.light.setPosition([0,0,1.2]);
                 this.light.setDiffuseColor([0.75,0.9,1.0,1.0]);
         
                 // light 2
-                this.light2 = createLightNode("myLight2");
+                this.light2 = RDGE.createLightNode("myLight2");
                 this.light2.setPosition([-0.5,0,1.2]);
                 this.light2.setDiffuseColor([1.0,0.9,0.75,1.0]);
         
                 // create a light transform
-                var lightTr = createTransformNode("lightTr");
+                var lightTr = RDGE.createTransformNode("lightTr");
         
                 // create and attach a material - materials hold the light data
-                lightTr.attachMaterial(createMaterialNode("lights"));
+                lightTr.attachMaterial(RDGE.createMaterialNode("lights"));
         
                 // enable light channels 1, 2 - channel 0 is used by the default shader
                 lightTr.materialNode.enableLightChannel(1, this.light);
@@ -195,9 +195,9 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
                 this.myScene.addNode(lightTr);
         
                 // Add the scene to the engine - necessary if you want the engine to draw for you
-                //g_Engine.AddScene("myScene" + this._canvas.id, this.myScene);
+                //RDGE.globals.engine.AddScene("myScene" + this._canvas.id, this.myScene);
                 var name = this._canvas.getAttribute( "data-RDGE-id" ); 
-                g_Engine.AddScene("myScene" + name, this.myScene);
+                RDGE.globals.engine.AddScene("myScene" + name, this.myScene);
         };
     
         // main code for handling user interaction and updating the scene   
@@ -209,7 +209,7 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
         
                 if (this._useWebGL) {
                         // changed the global position uniform of light 0, another way to change behavior of a light
-                        rdgeGlobalParameters.u_light0Pos.set( [5*Math.cos(this.elapsed), 5*Math.sin(this.elapsed), 20]);
+                    RDGE.rdgeGlobalParameters.u_light0Pos.set([5 * Math.cos(this.elapsed), 5 * Math.sin(this.elapsed), 20]);
         
                         // orbit the light nodes around the boxes
                         this.light.setPosition([1.2*Math.cos(this.elapsed*2.0), 1.2*Math.sin(this.elapsed*2.0), 1.2*Math.cos(this.elapsed*2.0)]);
@@ -226,8 +226,8 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
     // defining the draw function to control how the scene is rendered      
         this.draw = function() {
                 if (this._useWebGL) {
-                        g_Engine.setContext( this._canvas.rdgeid );
-                        var ctx = g_Engine.getContext();
+                        RDGE.globals.engine.setContext( this._canvas.rdgeid );
+                        var ctx = RDGE.globals.engine.getContext();
                         var renderer = ctx.renderer;
                         if (renderer.unloadedTextureCount <= 0) {
                                 renderer.disableCulling();
@@ -365,9 +365,9 @@ var World = function GLWorld( canvas, use3D, preserveDrawingBuffer ) {
         if (this._useWebGL) {
                 rdgeStarted = true;
                 this._canvas.rdgeid = this._canvas.getAttribute( "data-RDGE-id" );
-                g_Engine.unregisterCanvas( this._canvas )
-                g_Engine.registerCanvas(this._canvas, this);
-                RDGEStart( this._canvas );
+                RDGE.globals.engine.unregisterCanvas( this._canvas );
+                RDGE.globals.engine.registerCanvas(this._canvas, this);
+                RDGE.RDGEStart( this._canvas );
                 this._canvas.task.stop()
         }
 };
@@ -396,13 +396,13 @@ World.prototype.updateObject = function (obj) {
     if (nPrims > 0) {
         ctrTrNode = obj.getTransformNode();
                 if (ctrTrNode == null) {
-                        ctrTrNode = createTransformNode("objRootNode_" + this._nodeCounter++);
+                        ctrTrNode = RDGE.createTransformNode("objRootNode_" + this._nodeCounter++);
                         this._rootNode.insertAsChild( ctrTrNode );
                         obj.setTransformNode( ctrTrNode );
                 }
 
                 ctrTrNode.meshes.forEach(function(thisMesh) {
-                        g_meshMan.deleteMesh(thisMesh.mesh.name);
+                    RDGE.globals.meshMan.deleteMesh(thisMesh.mesh.name);
                 });
                 ctrTrNode.meshes = [];
 
@@ -421,11 +421,11 @@ World.prototype.updateObject = function (obj) {
                         childTrNode = children[i-1].transformNode;
 
                         childTrNode.meshes.forEach(function(thisMesh) {
-                                g_meshMan.deleteMesh(thisMesh.mesh.name);
+                            RDGE.globals.meshMan.deleteMesh(thisMesh.mesh.name);
                         });
                         childTrNode.meshes = [];
                 } else {
-                        childTrNode = createTransformNode("objNode_" + this._nodeCounter++);
+                        childTrNode = RDGE.createTransformNode("objNode_" + this._nodeCounter++);
                         ctrTrNode.insertAsChild(childTrNode);
                 }
 
@@ -466,7 +466,7 @@ World.prototype.addObject = function( obj ) {
     catch(e) {
         alert( "Exception in GLWorld.addObject " + e );
     }
-}
+};
 
 World.prototype.restartRenderLoop = function() {
         //console.log( "restartRenderLoop" );
@@ -527,7 +527,7 @@ World.prototype.clearTree = function() {
         if (this._useWebGL) {
                 var root = this._rootNode;
                 root.children = new Array();
-                g_Engine.unregisterCanvas( this._canvas.rdgeid )
+                RDGE.globals.engine.unregisterCanvas( this._canvas.rdgeid );
 
                 this.update( 0 );
                 this.draw();
@@ -540,9 +540,10 @@ World.prototype.updateMaterials = function( obj, time ) {
         var matArray = obj.getMaterialArray();
         if (matArray) {
                 var n = matArray.length;
-                for (var i=0;  i<n;  i++)
+                for (var i=0;  i<n;  i++) {
                         matArray[i].update( time );
         }
+        }
 
         this.updateMaterials( obj.getNext(),  time );
         this.updateMaterials( obj.getChild(), time );
@@ -553,9 +554,8 @@ World.prototype.getNDCOrigin = function() {
   var pt = MathUtils.transformPoint( [0,0,0], this.getCameraMatInverse() );
   var projMat = Matrix.makePerspective( this.getFOV(), this.getAspect(), this.getZNear(), this.getZFar());
   var ndcPt = MathUtils.transformHomogeneousPoint( pt, projMat );
-  var ndcOrigin = MathUtils.applyHomogeneousCoordinate( ndcPt );
 
-  return ndcOrigin;
+  return  MathUtils.applyHomogeneousCoordinate( ndcPt );
 };
 
 World.prototype.worldToScreen = function(v) {
@@ -570,9 +570,8 @@ World.prototype.worldToScreen = function(v) {
         var x = v2[0],  y = v2[1],  z = v2[2];
 
         var h = this.getGLContext().viewportHeight/2.0, w = this.getGLContext().viewportWidth/2.0;
-        var x2 = w*(1 + x),  y2 = h*( 1 - y ),  z2 = z;
+    var x2 = w * (1 + x), y2 = h * ( 1 - y );