Merge branch 'refs/heads/master' into panels

1 files changed, 710 insertions, 0 deletions

diff --git a/js/helper-classes/backup-delete/GLCircle.js b/js/helper-classes/backup-delete/GLCircle.js
new file mode 100755
index 00000000..15ed6b6d
--- /dev/null
+++ b/js/helper-classes/backup-delete/GLCircle.js
@@ -0,0 +1,710 @@
+/* <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> */
+
+///////////////////////////////////////////////////////////////////////
+// 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
+///////////////////////////////////////////////////////////////////////
+function GLCircle()
+{
+
+        // initialize the inherited members
+        this.inheritedFrom = GLGeomObj;
+        this.inheritedFrom();
+
+        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 = new FlatMaterial();
+
+                if(fillMaterial)
+                        this._fillMaterial = fillMaterial;
+                else 
+                        this._fillMaterial = new FlatMaterial();
+        }
+
+    ///////////////////////////////////////////////////////////////////////
+    // 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 innerStrokeScaleMat = Matrix.I(4);
+                innerStrokeScaleMat[0] = xInnRad - xStroke;
+                innerStrokeScaleMat[5] = yInnRad - yStroke;
+
+                var fillPrim,  strokePrim0,  strokePrim1;
+                var fillMaterial,  strokeMaterial0,  strokeMaterial2;
+
+        this._primArray = [];
+        this._materialArray = [];
+                this._materialTypeArray = [];
+            this._materialNodeArray = [];
+
+        //////////////////////////