1 files changed, 109 insertions, 22 deletions

diff --git a/js/lib/geom/rectangle.js b/js/lib/geom/rectangle.js
index ec3e25b2..cfa6aae5 100755
--- a/js/lib/geom/rectangle.js
+++ b/js/lib/geom/rectangle.js
@@ -101,15 +101,28 @@ exports.Rectangle = 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);
+        }
+            }
         }
     },
 
@@ -407,11 +420,15 @@ exports.Rectangle = Object.create(GeomObj, {
             brRadius = -z*(r-l)/(2.0*zn)*brRadiusNDC;
 
             // stroke
+                        var i;
             var strokeMaterial = this.makeStrokeMaterial();
-            var strokePrim = this.createStroke([x,y],  2*xFill,  2*yFill,  strokeSize,  tlRadius, blRadius, brRadius, trRadius, strokeMaterial);
-        strokeMaterial.fitToPrimitive( strokePrim );
-            this._primArray.push( strokePrim );
+                        var strokePrimArray = this.createStroke([x,y],  2*xFill,  2*yFill,  strokeSize,  tlRadius, blRadius, brRadius, trRadius, strokeMaterial);
+                        strokeMaterial.fitToPrimitiveArray( strokePrimArray );
+                        for (i=0;  i<strokePrimArray.length;  i++)
+                        {
+                                this._primArray.push( strokePrimArray[i] );
             this._materialNodeArray.push( strokeMaterial.getMaterialNode() );
+                        }
 
             // fill
             tlRadius -= strokeSize;  if (tlRadius < 0)  tlRadius = 0.0;
@@ -422,10 +439,13 @@ exports.Rectangle = Object.create(GeomObj, {
             yFill -= strokeSize;
             var fillMaterial = this.makeFillMaterial();
             //console.log( "fillMaterial: " + fillMaterial.getName() );
-            var fillPrim = this.createFill([x,y],  2*xFill,  2*yFill,  tlRadius, blRadius, brRadius, trRadius, fillMaterial);
-        fillMaterial.fitToPrimitive( fillPrim );
-            this._primArray.push( fillPrim );
+                        var fillPrimArray = this.createFill([x,y],  2*xFill,  2*yFill,  tlRadius, blRadius, brRadius, trRadius, fillMaterial);
+                        fillMaterial.fitToPrimitiveArray( fillPrimArray );
+                        for (i=0;  i<fillPrimArray.length;  i++)
+                        {
+                                this._primArray.push( fillPrimArray[i] );
             this._materialNodeArray.push( fillMaterial.getMaterialNode() );
+                        }
 
             world.updateObject(this);
         }
@@ -645,15 +665,17 @@ exports.Rectangle = Object.create(GeomObj, {
         value: function(ctr,  width,  height,  tlRad, blRad, brRad, trRad, material) {
             // create the geometry
             // special the (common) case of no rounded corners
-            var prim;
+            var primArray;
 
             if ((tlRad <= 0) && (blRad <= 0) && (brRad <= 0) && (trRad <= 0)) {
-                prim = RectangleGeometry.create( ctr, width, height, material );
+                primArray = RectangleGeometry.create( ctr, width, height, material );
             } else {
-                prim = RectangleFill.create( ctr,  width, height,  tlRad, blRad,  brRad, trRad, material);
+                primArray = RectangleFill.create( ctr,  width, height,  tlRad, blRad,  brRad, trRad, material);
             }
 
-            return prim;
+                        console.log( "rectangle produced " + primArray.length + " fill primitives" );
+
+            return primArray;
         }
     },
 
@@ -976,16 +998,43 @@ RectangleFill.create = function( rectCtr,  width, height, tlRad, blRad,  brRad,
     }
 
     //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();
             nVertices = ShapePrimitive.refineMesh( this.vertices, this.normals, this.uvs, this.indices, nVertices,  paramRange,  tolerance );
+
+                        var subdividedParts = ShapePrimitive.subdivideOversizedMesh( this.vertices, this.normals, this.uvs, this.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
+                                rtnArray = [ ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, nVertices) ];
+
+//                      var vertsOut = [],  normsOut = [], uvsOut = [],  indicesOut = [];
+//                      ShapePrimitive.convertTrianglesToLines( this.vertices, this.normals, this.uvs, this.indices,   vertsOut, normsOut,  uvsOut, indicesOut );
+//                      nVertices = vertsOut.length;
+//                      return ShapePrimitive.create(vertsOut, normsOut, uvsOut, indicesOut, RDGE.globals.engine.getContext().renderer.LINES, nVertices);
 
+                }
+                else
+                {
     // create the RDGE primitive
-    return ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, nVertices);
+                        rtnArray = [ ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, nVertices) ];
+                }
+        }
+
+        return rtnArray;
 };
 
 RectangleFill.pushVertex = function( x, y, z ) {
@@ -1018,7 +1067,7 @@ RectangleFill.getVertex = function( index ) {
 
 RectangleFill.getUV = function( x, y, xMin, w, yMin, h) {
     var u = (x - xMin)/w,
-        v = (y - yMin)/h;
+                v = 1.0 - (y - yMin)/h;
 
     var uv = [ u, v ];
     return uv;
@@ -1208,6 +1257,7 @@ RectangleStroke.create = function( rectCtr,  width, height, strokeWidth,  tlRad,
     }
 
     //refine the mesh for vertex deformations
+        var rtnArray;
     if (material)
     {
         if (material.hasVertexDeformation())
@@ -1215,11 +1265,29 @@ RectangleStroke.create = function( rectCtr,  width, height, strokeWidth,  tlRad,
             var paramRange = material.getVertexDeformationRange();
             var tolerance = material.getVertexDeformationTolerance();
             nVertices = ShapePrimitive.refineMesh( this.vertices, this.normals, this.uvs, this.indices, nVertices,  paramRange,  tolerance );
+
+                        var subdividedParts = ShapePrimitive.subdivideOversizedMesh( this.vertices, this.normals, this.uvs, this.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) );
         }
     }
-
-    // create the RDGE primitive
-    return ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, nVertices);
+                        else
+                                rtnArray = [ ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, nVertices) ];
+                }
+                else
+                {
+                        // create the RDGE primitive
+                        rtnArray = [ ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, RDGE.globals.engine.getContext().renderer.TRIANGLES, nVertices) ];
+                }
+        }
+
+        return rtnArray;
 };
 
 RectangleStroke.getRoundedCorner = function( ctr, insidePt, outsidePt ) {
@@ -1294,6 +1362,7 @@ RectangleGeometry.create = function( ctr,  width, height, material ) {
     RectangleGeometry.pushIndices( 0, 3, 2 );
 
     //refine the mesh for vertex deformations
+        var rtnArray;
     if (material)
     {
         if (material.hasVertexDeformation())
@@ -1301,11 +1370,29 @@ RectangleGeometry.create = function( ctr,  width, height, material ) {
             var paramRange = material.getVertexDeformationRange();
             var tolerance = material.getVertexDeformationTolerance();