5 files changed, 440 insertions, 82 deletions

diff --git a/js/lib/geom/circle.js b/js/lib/geom/circle.js
index e691f458..53847631 100755
--- a/js/lib/geom/circle.js
+++ b/js/lib/geom/circle.js
@@ -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);
+        }
+            }
         }
     },
 
@@ -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 = [];
@@ -322,42 +337,48 @@ exports.Circle = Object.create(GeomObj, {
                 var numStrokes = 1;
                 if(this._innerRadius !== 0) {
                     strokeMaterial0 = this.makeStrokeMaterial();
-                    strokePrim0 = this.generateOvalRing(x, y, reverseRotMat, innerStrokeScaleMat, innerRadiusScaleMat, nTriangles,  strokeMaterial0);
+                                        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);
         }
@@ -419,15 +440,37 @@ exports.Circle = Object.create(GeomObj, {
             this.recalcTexMapCoords( vrts, uvs );
 
             //refine the mesh for vertex deformations
-            if (material) {
-                if (material.hasVertexDeformation()) {
+                        var rtnArray;
+                        if (material)
+                        {
+                                if (material.hasVertexDeformation())
+                                {
                     var paramRange = material.getVertexDeformationRange();
                     var tolerance = material.getVertexDeformationTolerance();
-                    ShapePrimitive.refineMesh( vrts, nrms, uvs, indices, vrts.length/3,  paramRange,  tolerance );
+                                        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) );
                 }
             }
-
-            return ShapePrimitive.create(vrts, nrms, uvs, indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, index);
+                                        else
+                                                rtnArray = [ ShapePrimitive.create(vrts, nrms, uvs, indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, nVertices) ];
+                                }
+                                else
+                                {
+                                        // create the RDGE primitive
+                                        rtnArray = [ ShapePrimitive.create(vrts, nrms, uvs, indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, nVertices) ];
+                                }
+                        }
+
+                        return rtnArray;
         }
     },
 
@@ -486,18 +529,39 @@ exports.Circle = Object.create(GeomObj, {
 
             this.recalcTexMapCoords( vrts, uvs );
 
-            /*
             //refine the mesh for vertex deformations
-            if (material) {
-                if (material.hasVertexDeformation()) {
+                        var rtnArray;
+                        if (material)
+                        {
+                                if (material.hasVertexDeformation())
+                                {
                     var paramRange = material.getVertexDeformationRange();
                     var tolerance = material.getVertexDeformationTolerance();
-                    ShapePrimitive.refineMesh( vrts, nrms, uvs, indices, indices.length,  paramRange,  tolerance );
+                                        var nVertices = indices.length;
+                                        indices = ShapePrimitive.convertTriangleStripToTriangles( indices );
+                                        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) );
                 }
             }
-            */
-
-            return ShapePrimitive.create(vrts, nrms, uvs, indices, RDGE.globals.engine.getContext().renderer.TRIANGLE_STRIP, indices.length);
+                                        else
+                                                rtnArray = [ ShapePrimitive.create(vrts, nrms, uvs, indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, nVertices) ];
+                                }
+                                else
+                                {
+                                        // create the RDGE primitive
+                                        rtnArray = [ ShapePrimitive.create(vrts, nrms, uvs, indices, RDGE.globals.engine.getContext().renderer.TRIANGLE_STRIP, indices.length) ];
+                                }
+                        }
+
+                        return rtnArray;
         }
     },
 
@@ -883,7 +947,7 @@ exports.Circle = Object.create(GeomObj, {
                 if (uvs[iuv] > uMax)  uMax = uvs[iuv];
 
                 iuv++;  ivrt++;
-                uvs[iuv] = (vrts[ivrt]-yMin)/ovalHeight;
+                                uvs[iuv] = 1.0 - (vrts[ivrt]-yMin)/ovalHeight;