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

Conflicts:
	js/helper-classes/3D/StageLine.js

1 files changed, 167 insertions, 79 deletions

diff --git a/js/lib/rdge/materials/radial-gradient-material.js b/js/lib/rdge/materials/radial-gradient-material.js
index 6a5a9e9a..f1094771 100755
--- a/js/lib/rdge/materials/radial-gradient-material.js
+++ b/js/lib/rdge/materials/radial-gradient-material.js
@@ -47,17 +47,17 @@ var RadialGradientMaterial = function RadialGradientMaterial() {
     this._defaultColorStop2 = 0.3;
     this._defaultColorStop3 = 0.6;
     this._defaultColorStop4 = 1.0;
-    //  this._defaultColorCount = 4;
+    //  this._defaultColorCount = 4;
 
-        this._textureTransform = [1,0,0, 0,1,0, 0,0,1];
+    this._textureTransform = [1,0,0, 0,1,0, 0,0,1];
 
     ///////////////////////////////////////////////////////////////////////
     // Property Accessors
     ///////////////////////////////////////////////////////////////////////
-    
 
-    this.isAnimated             = function ()   {  return false;                                                };
-        this.getShaderDef       = function()    {  return radialGradientMaterialDef;    };
+
+    this.isAnimated     = function ()   {  return false;                        };
+    this.getShaderDef   = function()    {  return radialGradientMaterialDef;    };
 
     ///////////////////////////////////////////////////////////////////////
     // Material Property Accessors
@@ -95,49 +95,137 @@ var RadialGradientMaterial = function RadialGradientMaterial() {
         this._materialNode.setShader(this._shader);
 
         // set the shader values in the shader
-                this._shader['default'].u_texTransform.set( this._textureTransform );
+        this._shader['default'].u_texTransform.set( this._textureTransform );
         this.setShaderValues();
     };
 
-        this.fitToPrimitive = function( prim )
+        this.resetToDefault = function()
+    {
+                this._propValues[this._propNames[0]] = this._defaultColor1.slice(0);
+                this._propValues[this._propNames[1]] = this._defaultColor2.slice(0);
+                this._propValues[this._propNames[2]] = this._defaultColor3.slice(0);
+                this._propValues[this._propNames[3]] = this._defaultColor4.slice(0);
+
+                this._propValues[this._propNames[4]] = this._defaultColorStop1;
+                this._propValues[this._propNames[5]] = this._defaultColorStop2;
+                this._propValues[this._propNames[6]] = this._defaultColorStop3;
+                this._propValues[this._propNames[7]] = this._defaultColorStop4;
+        
+                var nProps = this._propNames.length;
+                for (var i=0; i<nProps;  i++) {
+                        this.setProperty( this._propNames[i],  this._propValues[this._propNames[i]]  );
+        }
+        };
+
+        this.fitToBounds = function( bounds )
         {
-                var bounds = ShapePrimitive.getBounds( prim );
-                if (bounds)
+        if (bounds)
+        {
+            var dx = Math.abs( bounds[3] - bounds[0] ),
+                dy = Math.abs( bounds[4] - bounds[1] );
+            if (dy == 0)  dy = 1.0;
+            if (dx == 0)  dx = 1.0;
+            var xScale = 2.0, yScale = 2.0;
+            if (dx > dy)
+                yScale *= dy/dx;
+            else
+                xScale *= dx/dy;
+
+            // build the matrix - the translation to the origin, the scale,
+            // and the translation back to the center (hard coded at (0.5, 0.5) for now).
+            // the matrix is build directly instead of with matrix multiplications
+            // for efficiency, not to mention that the multiplication function does
+            // not exist for mat3's.
+            // the matrix as laid out below looks transposed - order is columnwise.
+            var xCtr = 0.5,  yCtr = 0.5;
+            this._textureTransform = [
+                                                     xScale,                0.0,  0.0,
+                                                        0.0,             yScale,  0.0,
+                                            xCtr*(1-xScale),  yCtr*(1 - yScale),  1.0
+                                    ];
+
+            if (this._shader && this._shader['default'])
+                this._shader['default'].u_texTransform.set( this._textureTransform );
+
+        }
+    };
+
+        this.fitToPrimitiveArray = function( primArray )
+        {
+                if (!primArray)  return;
+                var nPrims = primArray.length;
+                if (nPrims == 0)  return;
+                var bounds = ShapePrimitive.getBounds( primArray[0] );
+                for (var i=1;  i<nPrims;  i++)
                 {
-                        var dx = Math.abs( bounds[3] - bounds[0] ),
-                                dy = Math.abs( bounds[4] - bounds[1] );
-                        if (dy == 0)  dy = 1.0;
-                        if (dx == 0)  dx = 1.0;
-                        var xScale = 2.0, yScale = 2.0;
-                        if (dx > dy)
-                                yScale *= dy/dx;
-                        else
-                                xScale *= dx/dy;
-
-                        // build the matrix - the translation to the origin, the scale,
-                        // and the translation back to the center (hard coded at (0.5, 0.5) for now).
-                        // the matrix is build directly instead of with matrix multiplications
-                        // for efficiency, not to mention that the multiplication function does
-                        // not exist for mat3's.
-                        // the matrix as laid out below looks transposed - order is columnwise.
-                        var xCtr = 0.5,  yCtr = 0.5;
-                        this._textureTransform = [
-                                                                                                         xScale,                0.0,  0.0,
-                                                                                                                0.0,             yScale,  0.0,
-                                                                                        xCtr*(1-xScale),  yCtr*(1 - yScale),  1.0
-                                                                        ];
-                        
-                        if (this._shader && this._shader['default'])
-                                this._shader['default'].u_texTransform.set( this._textureTransform );   
+                        var prim = primArray[i];
+                        var b2 = ShapePrimitive.getBounds( prim );
+
+                        // [xMin, yMin, zMin,  xMax, yMax, zMax]
+                        if (b2[0] < bounds[0])  bounds[0] = b2[0];
+                        if (b2[1] < bounds[1])  bounds[1] = b2[1];
+                        if (b2[2] < bounds[2])  bounds[2] = b2[2];
 
+                        if (b2[3] > bounds[3])  bounds[3] = b2[3];
+                        if (b2[4] > bounds[4])  bounds[4] = b2[4];
+                        if (b2[5] > bounds[5])  bounds[5] = b2[5];
                 }
+
+                this.fitToBounds( bounds );
         };
 
-        this.customExport = function( jObj )
+        this.fitToPrimitive = function( prim )
         {
-                jObj.u_texTransform = this._textureTransform.slice();
-                return jObj;
-        }
+                var bounds = ShapePrimitive.getBounds( prim );
+                this.fitToBounds( bounds );
+        };
+
+    this.customExport = function( jObj )
+    {
+        jObj.u_texTransform = this._textureTransform.slice();
+        return jObj;
+        };
+
+    // Only Linear Gradient and Radial Gradient have gradient data.
+    this.gradientType = "radial";
+
+    this.getGradientData = function() {
+        var angle = Math.round(this._angle*180/Math.PI),
+            color,
+            colorStr,
+            css = "-webkit-gradient(linear, " + angle + "deg";
+
+        // TODO - Angle is not supported in -webkit-gradient syntax, so just default to across:
+        css = '-webkit-radial-gradient(50% 50%, ellipse cover';
+
+        // TODO - Also, Color Model requires from and to in the gradient string
+        for (var i=1; i < 5; i++) {
+            color = this.getProperty('u_color'+i);
+            colorStr = Math.round(color[0] * 255) + ', ' + Math.round(color[1] * 255) + ', ' + Math.round(color[2] * 255) + ', ' + Math.round(color[3] * 100);
+            css += ', rgba(' + colorStr + ') ' + Math.round(this.getProperty('u_colorStop'+i)*100) + '%';
+    }
+
+        css += ')';
+
+        return css;
+};
+
+    this.setGradientData = function(colors) {
+        var len = colors.length;
+        // TODO - Current shaders only support 4 color stops
+        if (len > 4) {
+            len = 4;
+        }
+
+        for (var n = 0; n < len; n++) {
+            var position = colors[n].position/100;
+            var cs = colors[n].value;
+            var stop = [cs.r/255, cs.g/255, cs.b/255, cs.a];
+
+            this.setProperty("u_color" + (n + 1), stop.slice(0));
+            this.setProperty("u_colorStop" + (n + 1), position);
+        }
+    };
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////
@@ -146,48 +234,48 @@ var RadialGradientMaterial = function RadialGradientMaterial() {