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

Conflicts:
	js/preloader/Preloader.js

1 files changed, 751 insertions, 0 deletions

diff --git a/js/lib/geom/circle.js b/js/lib/geom/circle.js
new file mode 100755
index 00000000..dd82a4cc
--- /dev/null
+++ b/js/lib/geom/circle.js
@@ -0,0 +1,751 @@
+/* <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> */
+
+var GeomObj =           require("js/lib/geom/geom-obj").GeomObj;
+var ShapePrimitive =    require("js/lib/geom/shape-primitive").ShapePrimitive;
+var MaterialsModel = require("js/models/materials-model").MaterialsModel;
+///////////////////////////////////////////////////////////////////////
+// Class GLCircle
+//      GL representation of a circle.
+//      Derived from class GLGeomObj
+//              The position and dimensions of the stroke, fill, and inner Radius should be in pixels
+///////////////////////////////////////////////////////////////////////
+var Circle = function GLCircle() {
+
+        this.init = function( world, xOffset, yOffset, width, height, strokeSize, strokeColor, fillColor, innerRadius, strokeMaterial, fillMaterial, strokeStyle) {
+                ///////////////////////////////////////////////////////////////////////
+                // Instance variables
+                ///////////////////////////////////////////////////////////////////////
+                this._width = 2.0;
+                this._height = 2.0;
+                this._xOffset = 0;
+                this._yOffset = 0;
+
+                this._radius = 2.0;
+                this._strokeWidth = 0.25;
+                this._innerRadius = 0;
+
+                this._ovalHeight = this._ovalHeight = 2.0 * this._radius;
+
+                this._strokeStyle = "Solid";
+
+                this._aspectRatio = 1.0;
+
+                if (arguments.length > 0) {
+                        this._width = width;
+                        this._height = height;
+                        this._xOffset = xOffset;
+                        this._yOffset = yOffset;
+        
+                        this._strokeWidth = strokeSize;
+                        this._innerRadius = innerRadius;
+                        if (strokeColor)  this._strokeColor = strokeColor;
+                        if (fillColor)  this._fillColor = fillColor;
+
+                        this._strokeStyle = strokeStyle;
+                }
+
+                this.m_world = world;
+
+                if(strokeMaterial){
+                        this._strokeMaterial = strokeMaterial;
+        } else {
+                        this._strokeMaterial = MaterialsModel.exportFlatMaterial();
+        }
+
+                if(fillMaterial) {
+                        this._fillMaterial = fillMaterial;
+        } else {
+                        this._fillMaterial = MaterialsModel.exportFlatMaterial();
+        }
+        };
+
+    ///////////////////////////////////////////////////////////////////////
+    // Property Accessors
+    ///////////////////////////////////////////////////////////////////////
+        this.getStrokeWidth = function() {
+        return this._strokeWidth;
+    };
+
+        this.setStrokeWidth = function(w) {
+        this._strokeWidth = w;
+    };
+
+        this.getStrokeMaterial = function() {
+        return this._strokeMaterial;
+    };
+
+        this.setStrokeMaterial = function(m) {
+        this._strokeMaterial = m;
+    };
+
+        this.getFillMaterial = function() {
+        return this._fillMaterial;
+    };
+
+        this.setFillMaterial = function(m) {
+        this._fillMaterial = m;
+    };
+
+        this.getRadius = function() {
+        return this._radius;
+    };
+
+        this.setRadius = function(r) {
+        this._radius = r;
+    };
+
+        this.getWorld = function() {
+        return this._world;
+    };
+
+        this.setWorld = function(w) {
+        this._world = w;
+    };
+
+    this.getInnerRadius = function() {
+        return this._innerRadius;
+    };
+
+        this.setInnerRadius = function(r) {
+        this._innerRadius = r;
+    };
+
+    this.getStrokeStyle = function() {
+        return this._strokeStyle;
+    };
+        this.setStrokeStyle     = function(s) {
+        this._strokeStyle = s;
+    };
+
+        this.getWidth = function() {
+        return this._width;
+    };
+
+        this.setWidth = function(w) {
+        this._width = w;
+    };
+
+        this.getHeight = function() {
+        return this._height;
+    };
+
+        this.setHeight = function(h) {
+        this._height = h;
+    };
+
+        this.geomType = function() {
+        return this.GEOM_TYPE_CIRCLE;
+    };
+
+    ///////////////////////////////////////////////////////////////////////
+    // Methods
+    ///////////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////////
+        // update the "color of the material
+    this.getFillColor = function()
+        {
+                return this._fillColor;
+        }
+        
+//      this.setFillColor = function(c)
+//      {
+//              this._fillColor = c;
+//      }
+
+    this.getStrokeColor = function()
+        {
+                return this._strokeColor;
+        }
+        
+//      this.setStrokeColor     = function(c)
+//      {
+//              this._strokeColor = c;
+//      }
+    ///////////////////////////////////////////////////////////////////////
+
+        this.buildBuffers = function() {
+        // get the world
+        var world = this.getWorld();
+        if (!world)  throw( "null world in buildBuffers" );
+
+                if (!world._useWebGL)  return;
+                
+                // make sure RDGE has the correct context
+                g_Engine.setContext( world.getCanvas().rdgeid );
+
+         // create the gl buffer
+        var gl = world.getGLContext();
+
+        // determine the number of triangles to generate
+        var nTriangles = 60;        // yes, we will do better than this
+
+                // get the normalized device coordinates (NDC) for
+                // all position and dimensions.
+                var     vpw = world.getViewportWidth(),  vph = world.getViewportHeight();
+                var     xNDC = 2*this._xOffset/vpw,  yNDC = 2*this._yOffset/vph,
+                        xRadNDC = this._width/vpw,  yRadNDC = this._height/vph,
+                        xStrokeNDC = 2*this._strokeWidth/vpw,  yStrokeNDC = 2*this._strokeWidth/vph,
+                        xInnRadNDC = this._innerRadius*xRadNDC,  yInnRadNDC = this._innerRadius*yRadNDC;
+
+                var aspect = world.getAspect();
+                var zn = world.getZNear(),  zf = world.getZFar();
+                var     t = zn * Math.tan(world.getFOV() * Math.PI / 360.0),
+                        b = -t,
+                        r = aspect*t,
+                        l = -r;
+
+                // calculate the object coordinates from their NDC coordinates
+                var z = -world.getViewDistance();
+
+                // get the position of the origin
+                var x = -z*(r-l)/(2.0*zn)*xNDC,
+                        y = -z*(t-b)/(2.0*zn)*yNDC;
+
+                // get the x and y radii
+                var xRad = -z*(r-l)/(2.0*zn)*xRadNDC,
+                        yRad = -z*(t-b)/(2.0*zn)*yRadNDC;
+
+                // save the overall dimensions to be used in the uv calculations
+                this._ovalWidth = xRad;  this._ovalHeight = yRad;
+
+                // get the x & y stroke size
+                var xStroke = -z*(r-l)/(2.0*zn)*xStrokeNDC,
+                        yStroke = -z*(t-b)/(2.0*zn)*yStrokeNDC;
+
+                // get the inner radius
+                var xInnRad = -z*(r-l)/(2.0*zn)*xInnRadNDC,
+                        yInnRad = -z*(t-b)/(2.0*zn)*yInnRadNDC;
+        
+                // get a matrix to rotate a point around the circle
+        var angle = 2.0 * Math.PI/Number(nTriangles);
+        var mat = Matrix.RotationZ( angle );
+                var reverseRotMat = Matrix.RotationZ( -angle );
+
+                // calculate matrices to scale the circle and stroke to fit the bounds of the ellipse
+                var strokeScaleMat = Matrix.I(4);
+                strokeScaleMat[0] = xRad;
+                strokeScaleMat[5] = yRad;
+
+                var fillScaleMat = Matrix.I(4);
+                fillScaleMat[0] = xRad - xStroke;
+                fillScaleMat[5] = yRad - yStroke;
+
+                var innerRadiusScaleMat = Matrix.I(4);
+                innerRadiusScaleMat[0] = xInnRad;
+                innerRadiusScaleMat[5] = yInnRad;
+
+                var innerStrokeScaleM