1 files changed, 181 insertions, 117 deletions

diff --git a/js/lib/geom/circle.js b/js/lib/geom/circle.js
index 39cde514..53847631 100755
--- a/js/lib/geom/circle.js
+++ b/js/lib/geom/circle.js
@@ -31,14 +31,14 @@ POSSIBILITY OF SUCH DAMAGE.
 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;
-var drawUtils           = require("js/helper-classes/3D/draw-utils").DrawUtils;
-var vecUtils            = require("js/helper-classes/3D/vec-utils").VecUtils;
+var drawUtils       = require("js/helper-classes/3D/draw-utils").DrawUtils;
+var vecUtils        = require("js/helper-classes/3D/vec-utils").VecUtils;
 
 ///////////////////////////////////////////////////////////////////////
 // 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
+//      The position and dimensions of the stroke, fill, and inner Radius should be in pixels
 ///////////////////////////////////////////////////////////////////////
 exports.Circle = Object.create(GeomObj, {
 
@@ -57,7 +57,7 @@ exports.Circle = Object.create(GeomObj, {
     _strokeStyle: { value : "Solid", writable: true },
     _aspectRatio: { value : 1.0, writable: true },
 
-        init: {
+    init: {
         value: function(world, xOffset, yOffset, width, height, strokeSize, strokeColor, fillColor, innerRadius, strokeMaterial, fillMaterial, strokeStyle) {
             if(arguments.length > 0) {
                 this._width = width;
@@ -85,14 +85,28 @@ exports.Circle = Object.create(GeomObj, {
             } else {
                 this._strokeMaterial = MaterialsModel.getMaterial( MaterialsModel.getDefaultMaterialName() ).dup();
             }
-                        if (strokeColor && this._strokeMaterial.hasProperty( "color" ))  this._strokeMaterial.setProperty( "color",  this._strokeColor );
+
+            if(strokeColor) {
+                if(this._strokeMaterial.hasProperty("color")) {
+                    this._strokeMaterial.setProperty( "color",  this._strokeColor );
+                } else if (this._strokeMaterial && (this._strokeMaterial.gradientType === this._strokeColor.gradientMode)) {
+                    this._strokeMaterial.setGradientData(this._strokeColor.color);
+                }
+            }
 
             if(fillMaterial) {
                 this._fillMaterial = fillMaterial.dup();
             } else {
                 this._fillMaterial = MaterialsModel.getMaterial(  MaterialsModel.getDefaultMaterialName() ).dup();
             }
-                        if (fillColor && this._fillMaterial.hasProperty( "color" ))  this._fillMaterial.setProperty( "color",  this._fillColor );
+
+            if(fillColor) {
+                if(this._fillMaterial.hasProperty("color")) {
+                    this._fillMaterial.setProperty( "color",  this._fillColor );
+                } else if (this._fillMaterial && (this._fillMaterial.gradientType === this._fillColor.gradientMode)) {
+                    this._fillMaterial.setGradientData(this._fillColor.color);
+        }
+            }
         }
     },
 
@@ -203,7 +217,7 @@ exports.Circle = Object.create(GeomObj, {
     },
 
     ///////////////////////////////////////////////////////////////////////
-        // update the "color of the material
+    // update the "color of the material
     getFillColor: {
         value: function() {
             return this._fillColor;
@@ -251,15 +265,15 @@ exports.Circle = Object.create(GeomObj, {
 
             // 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,
+            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),
+            var t = zn * Math.tan(world.getFOV() * Math.PI / 360.0),
                 b = -t,
                 r = aspect*t,
                 l = -r;
@@ -308,7 +322,8 @@ exports.Circle = Object.create(GeomObj, {
             innerStrokeScaleMat[0] = xInnRad - xStroke;
             innerStrokeScaleMat[5] = yInnRad - yStroke;
 
-            var fillPrim,  strokePrim0,  strokePrim1;
+                        var i;
+                        var fillPrimArray,  strokePrim0Array,  strokePrim1Array;
             var fillMaterial,  strokeMaterial0,  strokeMaterial2;
 
             this._primArray = [];
@@ -321,43 +336,49 @@ exports.Circle = Object.create(GeomObj, {
             if(this._strokeWidth > 0) {
                 var numStrokes = 1;
                 if(this._innerRadius !== 0) {
-                                        strokeMaterial0 = this.makeStrokeMaterial();
-                    strokePrim0 = this.generateOvalRing(x, y, reverseRotMat, innerStrokeScaleMat, innerRadiusScaleMat, nTriangles,  strokeMaterial0);
+                    strokeMaterial0 = this.makeStrokeMaterial();
+                                        strokePrim0Array = this.generateOvalRing(x, y, reverseRotMat, innerStrokeScaleMat, innerRadiusScaleMat, nTriangles,  strokeMaterial0);
                 }
 
                 strokeMaterial2 = this.makeStrokeMaterial();
-                strokePrim1 = this.generateOvalRing(x, y, reverseRotMat, fillScaleMat, strokeScaleMat, nTriangles,  strokeMaterial2);
+                                strokePrim1Array = this.generateOvalRing(x, y, reverseRotMat, fillScaleMat, strokeScaleMat, nTriangles,  strokeMaterial2);
             }
 
-            if (strokePrim0) {
-                                strokeMaterial0.fitToPrimitive( strokePrim0 );
-
-                this._primArray.push( strokePrim0 );
+                        if (strokePrim0Array) {
+                                strokeMaterial0.fitToPrimitiveArray( strokePrim0Array );
+                                for (i=0;  i<strokePrim0Array.length;  i++)
+                                {
+                                        this._primArray.push( strokePrim0Array[i] );
                 this._materialNodeArray.push( strokeMaterial0.getMaterialNode() );
             }
+                        }
 
-            if (strokePrim1) {
-                                strokeMaterial2.fitToPrimitive( strokePrim1 );
-
-                this._primArray.push( strokePrim1 );
+                        if (strokePrim1Array) {
+                                strokeMaterial2.fitToPrimitiveArray( strokePrim1Array );
+                                for (i=0;  i<strokePrim1Array.length;  i++)
+                                {
+                                        this._primArray.push( strokePrim1Array[i] );
                 this._materialNodeArray.push( strokeMaterial2.getMaterialNode() );
             }
+                        }
 
             /////////////////////////////////////////////////////////////
             //  Fill
             fillMaterial = this.makeFillMaterial();
             if(this._innerRadius === 0) {
-                fillPrim = this.generateOval(x, y, mat, fillScaleMat, nTriangles,  fillMaterial);
+                                fillPrimArray = this.generateOval(x, y, mat, fillScaleMat, nTriangles,  fillMaterial);
             } else {
-                fillPrim = this.generateOvalRing(x, y, reverseRotMat, innerRadiusScaleMat, fillScaleMat, nTriangles,  fillMaterial);
+                                fillPrimArray = this.generateOvalRing(x, y, reverseRotMat, innerRadiusScaleMat, fillScaleMat, nTriangles,  fillMaterial);
             }
 
-            if (fillPrim) {
-                                fillMaterial.fitToPrimitive( fillPrim );
-
-                this._primArray.push( fillPrim );
+                        if (fillPrimArray) {
+                                fillMaterial.fitToPrimitiveArray( fillPrimArray );
+                                for (i=0;  i<fillPrimArray.length;  i++)
+                                {
+                                        this._primArray.push( fillPrimArray[i] );
                 this._materialNodeArray.push( fillMaterial.getMaterialNode() );
             }
+                        }
 
             world.updateObject(this);
         }
@@ -371,7 +392,7 @@ exports.Circle = Object.create(GeomObj, {
             var x = pts[0],  y = pts[1], z = 0;
             var xs = scaleMat[0], ys = scaleMat[4];
 
-            var vrts = [], nrms = [], uvs = [], indices = [];
+            var vrts = [], nrms = [], uvs = [], indices = [];
             var index = 0;
             for (var i=0;  i<nTriangles;  i++) {
                 //pt = rotationMat.multiply( pt );
@@ -418,16 +439,38 @@ exports.Circle = Object.create(GeomObj, {
 
             this.recalcTexMapCoords( vrts, uvs );
 
-                        //refine the mesh for vertex deformations
-                        if (material) {
-                                if (material.hasVertexDeformation()) {
-                                        var paramRange = material.getVertexDeformationRange();
-                                        var tolerance = material.getVertexDeformationTolerance();
-                                        ShapePrimitive.refineMesh( vrts, nrms, uvs, indices, vrts.length/3,  paramRange,  tolerance );
+            //refine the mesh for vertex deformations
+                        var rtnArray;
+                        if (material)
+                        {
+                                if (material.hasVertexDeformation())
+                                {
+                    var paramRange = material.getVertexDeformationRange();
+                    var tolerance = material.getVertexDeformationTolerance();
+                                        var nVertices = vrts.length/3
+                                        nVertices = ShapePrimitive.refineMesh( vrts, nrms, uvs, indices, nVertices,  paramRange,  tolerance );
+                                        var subdividedParts = ShapePrimitive.subdivideOversizedMesh( vrts, nrms, uvs, indices );
+
+                                        rtnArray = [];
+                                        if (subdividedParts)
+                                        {
+                                                for (var i=0;  i<subdividedParts.length;  i++)
+                                                {
+                                                        var obj = subdividedParts[i];
+                                                        rtnArray.push( ShapePrimitive.create(obj.vertices, obj.normals, obj.uvs, obj.indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, obj.vertices.length/3) );
+                }
+            }
+                                        else