Merge branch 'refs/heads/Ninja-Internal' into FileIO

1 files changed, 488 insertions, 0 deletions

diff --git a/js/lib/geom/line.js b/js/lib/geom/line.js
new file mode 100755
index 00000000..da63b21c
--- /dev/null
+++ b/js/lib/geom/line.js
@@ -0,0 +1,488 @@
+/* <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 GLLine
+//      GL representation of a line.
+//      Derived from class GeomObj
+///////////////////////////////////////////////////////////////////////
+var Line = function GLLine( world, xOffset, yOffset, width, height, slope, strokeSize, strokeColor, strokeMaterial, strokeStyle, xAdj, yAdj) {
+        ///////////////////////////////////////////////////////////////////////
+        // Instance variables
+        ///////////////////////////////////////////////////////////////////////
+        this._width = 2.0;
+        this._height = 2.0;
+        this._xOffset = 0;
+        this._yOffset = 0;
+
+        // If line doesn't fit in canvas world, we had to grow the canvas by this much on either side
+        this._xAdj = 0;
+        this._yAdj = 0;
+        
+        this._slope = 0;
+
+        this._strokeWidth = 0.25;
+
+        this._strokeStyle = "Solid";
+        this._scaleX = 1.0;
+        this._scaleY = 1.0;
+
+        if (arguments.length > 0) {
+                this._width = width;
+                this._height = height;
+                this._xOffset = xOffset;
+                this._yOffset = yOffset;
+
+                this._xAdj = xAdj;
+                this._yAdj = yAdj;
+
+                this._slope = slope;
+                this._strokeWidth = strokeSize;
+                if (strokeColor)  this._strokeColor = strokeColor.slice();
+
+                this._strokeStyle = strokeStyle;
+                this._scaleX = (world.getViewportWidth())/(world.getViewportHeight());
+        }
+
+        this._strokeVerticesLen = 0;
+
+        this.m_world = world;
+
+        this._materialAmbient  = [0.2, 0.2, 0.2,  1.0];
+        this._materialDiffuse  = [0.4, 0.4, 0.4,  1.0];
+        this._materialSpecular = [0.4, 0.4, 0.4,  1.0];
+
+        if(strokeMaterial) {
+                this._strokeMaterial = strokeMaterial;
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+        // 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.getStrokeColor             = function()            {  return this._strokeColor;    }
+        //this.setStrokeColor   = function(c)           {  this._strokeColor = c;               }
+
+        this.getStrokeStyle             = function()            {  return this._strokeStyle;    }
+        this.setStrokeStyle             = function(s)           {  this._strokeStyle = s;               }
+
+        this.getFillMaterial    = function()            {  return null;         }
+        
+        this.setStrokeMaterial  = function(m)            {  this._strokeMaterial = m;            }
+        this.getStrokeMaterial  = function()            {  return this._strokeMaterial;         }
+
+        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.getXAdj                    = function()            {  return this._xAdj;                   }
+        this.setXAdj            = function(x)           {  this._xAdj = x;                              }
+
+        this.getYAdj                    = function()            {  return this._yAdj;                   }
+        this.setYAdj            = function(y)           {  this._yAdj = y;                              }
+
+        this.getSlope                   = function()            {  return this._slope;                  }
+        this.setSlope            = function(m)          {  this._slope = m;                             }
+
+        this.geomType   = function()                            {  return this.GEOM_TYPE_LINE;  }
+
+                ///////////////////////////////////////////////////////////////////////
+        // Methods
+        ///////////////////////////////////////////////////////////////////////
+        this.export = function() {
+                var rtnStr = "type: " + this.geomType() + "\n";
+
+                rtnStr += "xoff: "                      + this._xOffset         + "\n";
+                rtnStr += "yoff: "                      + this._yOffset         + "\n";
+                rtnStr += "width: "                     + this._width           + "\n";
+                rtnStr += "height: "            + this._height          + "\n";
+                rtnStr += "xAdj: "                  + this._xAdj                + "\n";
+                rtnStr += "yAdj: "                  + this._yAdj                + "\n";
+                rtnStr += "strokeWidth: "       + this._strokeWidth     + "\n";
+                rtnStr += "strokeColor: "       + String(this._strokeColor)  + "\n";
+                rtnStr += "strokeStyle: "       + this._strokeStyle     + "\n";
+                rtnStr += "slope: "             + String(this._slope)   + "\n";
+
+                rtnStr += "strokeMat: ";
+                if (this._strokeMaterial) {
+                        rtnStr += this._strokeMaterial.getName();
+        } else {
+                        rtnStr += "flatMaterial";
+        }
+
+                rtnStr += "\n";
+                return rtnStr;
+        };
+
+        this.import = function( importStr ) {
+                this._xOffset                   = Number( this.getPropertyFromString( "xoff: ",                 importStr )  );
+                this._yOffset                   = Number( this.getPropertyFromString( "yoff: ",                 importStr )  );
+                this._width                             = Number( this.getPropertyFromString( "width: ",                importStr )  );
+                this._height                    = Number( this.getPropertyFromString( "height: ",               importStr )  );
+                this._xAdj                          = Number( this.getPropertyFromString( "xAdj: ",                     importStr )  );
+                this._yAdj                          = Number( this.getPropertyFromString( "yAdj: ",                     importStr )  );
+                this._strokeWidth               = Number( this.getPropertyFromString( "strokeWidth: ",  importStr )  );
+                var slope                       = this.getPropertyFromString( "slope: ",        importStr );
+
+                if(isNaN(Number(slope))) {
+                        this._slope                 = slope;
+        } else {
+                        this._slope         = Number(slope);
+        }
+
+                var strokeMaterialName  = this.getPropertyFromString( "strokeMat: ",    importStr );
+                this._strokeStyle               = this.getPropertyFromString( "strokeStyle: ",  importStr );
+                this._strokeColor               = eval( "[" + this.getPropertyFromString( "strokeColor: ",      importStr ) + "]" );
+
+                var strokeMat = MaterialsModel.getMaterial( strokeMaterialName );
+                if (!strokeMat) {
+                        console.log( "object material not found in library: " + strokeMaterialName );
+                        strokeMat = MaterialsModel.exportFlatMaterial();
+                }
+
+                this._strokeMaterial = strokeMat;
+
+        };
+
+        ///////////////////////////////////////////////////////////////////////
+        // Methods
+        ///////////////////////////////////////////////////////////////////////
+        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();
+
+                this._strokeVerticesLen = 0;
+
+                var strokeVertices = [];
+                var strokeTextures = [];
+                var strokeNormals = [];
+                var strokeColors = [];
+
+//        var scaleMat = Matrix.I(3);
+//        scaleMat.elements[0][0] = this._scaleX;
+//        scaleMat.elements[1][1] = this._scaleY;
+
+
+        // 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,
+                        xFillNDC = this._width/vpw,  yFillNDC = this._height/vph,
+                        xAdjNDC = this._xAdj/vpw,  yAdjNDC = this._yAdj/vph,
+                        xStrokeNDC = this._strokeWidth/vpw,  yStrokeNDC = this._strokeWidth/vph;
+
+                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 fill
+                var xFill = -z*(r-l)/(2.0*zn)*xFillNDC,
+                        yFill = -z*(t-b)/(2.0*zn)*yFillNDC;
+
+                // 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 x & y adjustments size
+                var xAdj = -z*(r-l)/(2.0*zn)*xAdjNDC*2,
+                        yAdj = -z*(t-b)/(2.0*zn)*yAdjNDC*2;
+
+
+                this._primArray = [];
+                this._materialArray = [];
+                this._materialTypeArray = [];
+                this._materialNodeArray = [];
+                
+                this._scaleX = (world._viewportWidth)/(world._viewportHeight);
+                
+                var innerX = xFill-xStroke;
+                var innerY = yFill-yStroke;