1 files changed, 107 insertions, 10 deletions

diff --git a/js/helper-classes/RDGE/GLRectangle.js b/js/helper-classes/RDGE/GLRectangle.js
index 5b6ff94f..4216fe53 100755
--- a/js/helper-classes/RDGE/GLRectangle.js
+++ b/js/helper-classes/RDGE/GLRectangle.js
@@ -404,18 +404,12 @@ function GLRectangle()
                 ctx.beginPath();
                 ctx.fillStyle   = "#990000";
                 if (this._fillColor)
-                {
-                        var c = "rgba(" + 255*this._fillColor[0] + "," + 255*this._fillColor[1] + "," + 255*this._fillColor[2] + "," + this._fillColor[3] + ")";  
-                        ctx.fillStyle = c;
-                }
+                        ctx.fillStyle = MathUtils.colorToHex( this._fillColor );
 
                 // set the stroke
                 ctx.strokeStyle = "#0000ff";
                 if (this._strokeColor)
-                {
-                        var c = "rgba(" + 255*this._strokeColor[0] + "," + 255*this._strokeColor[1] + "," + 255*this._strokeColor[2] + "," + this._strokeColor[3] + ")";  
-                        ctx.strokeStyle = c;
-                }
+                        ctx.strokeStyle = MathUtils.colorToHex( this._strokeColor );
 
                 ctx.lineWidth   = lw;
                 var inset = Math.ceil( 0.5*lw ) + 0.5;
@@ -1057,12 +1051,13 @@ 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 );
+                        nVertices = ShapePrimitive.refineMesh( this.vertices, this.normals, this.uvs, this.indices, nVertices,  paramRange,  tolerance );
                 }
         }
 
         // create the RDGE primitive
         var prim = ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, g_Engine.getContext().renderer.TRIANGLES, nVertices);
+        //var prim = ShapePrimitive.create(this.vertices, this.normals, this.uvs, this.indices, g_Engine.getContext().renderer.LINES, nVertices);
         return prim;
 }
 
@@ -1150,7 +1145,7 @@ RectangleGeometry.create = function( ctr,  width, height, material )
                 {
                         var paramRange = material.getVertexDeformationRange();
                         var tolerance = material.getVertexDeformationTolerance();
-                        //nVertices = ShapePrimitive.refineMesh( this.vertices, this.normals, this.uvs, this.indices, nVertices,  paramRange,  tolerance );
+                        nVertices = ShapePrimitive.refineMesh( this.vertices, this.normals, this.uvs, this.indices, nVertices,  paramRange,  tolerance );
                 }
         }
 
@@ -1228,6 +1223,108 @@ ShapePrimitive.create = function(coords,  normals,  uvs,  indices, primType, ver
 }
 
 
+ShapePrimitive.refineMesh = function( verts, norms, uvs, indices, nVertices,  paramRange,  tolerance )
+{
+        // get the param range
+        var pUMin = paramRange[0],  pVMin = paramRange[1],
+                pUMax = paramRange[2],  pVMax = paramRange[3];
+        var iTriangle = 0;
+        var nTriangles = indices.length/3;
+        var index = 0;
+        while (iTriangle < nTriangles)
+        {
+                // get the indices of the 3 vertices
+                var i0 = indices[index],
+                        i1 = indices[index+1],
+                        i2 = indices[index+2];
+
+                // get the uv values
+                //var vrtIndex = 3*iTriangle;
+                var iuv0 = 2 * i0,
+                        iuv1 = 2 * i1,
+                        iuv2 = 2 * i2;
+                var u0 = uvs[iuv0],  v0 = uvs[iuv0+1],
+                        u1 = uvs[iuv1],  v1 = uvs[iuv1+1],
+                        u2 = uvs[iuv2],  v2 = uvs[iuv2+1];
+
+                // find the u and v range
+                var uMin = u0,  vMin = v0;
+                if (u1 < uMin)  uMin = u1;  if (v1 < vMin)  vMin = v1;
+                if (u2 < uMin)  uMin = u2;  if (v2 < vMin)  vMin = v2;
+                var uMax = u0,  vMax = v0;
+                if (u1 > uMax)  uMax = u1;  if (v1 > vMax)  vMax = v1;
+                if (u2 > uMax)  uMax = u2;  if (v2 > vMax)  vMax = v2;
+
+                // if the parameter range of the triangle is outside the
+                // desired parameter range, advance to the next polygon and continue
+                if ((uMin > pUMax) || (uMax < pUMin) || (vMin > pVMax) || (vMax < pVMin))
+                {
+                        // go to the next triangle
+                        iTriangle++;
+                        index += 3;
+                }
+                else
+                {
+                        // check thesize of the triangle in uv space.  If small enough, advance
+                        // to the next triangle.  If not small enough, split the triangle into 3;
+                        var du = uMax - uMin,  dv = vMax - vMin;
+                        if ((du < tolerance) && (dv < tolerance))
+                        {
+                                iTriangle++;
+                                index += 3;
+                        }
+                        else    // split the triangle into 4 parts
+                        {
+                                //calculate the position of the new vertex
+                                var iPt0 = 3 * i0,
+                                        iPt1 = 3 * i1,
+                                        iPt2 = 3 * i2;
+                                var x0 = verts[iPt0],  y0 = verts[iPt0+1],  z0 = verts[iPt0+2],
+                                        x1 = verts[iPt1],  y1 = verts[iPt1+1],  z1 = verts[iPt1+2],
+                                        x2 = verts[iPt2],  y2 = verts[iPt2+1],  z2 = verts[iPt2+2];
+                                
+                                // calculate the midpoints of the edges
+                                var xA = (x0 + x1)/2.0,  yA = (y0 + y1)/2.0,  zA = (z0 + z1)/2.0,
+                                        xB = (x1 + x2)/2.0,  yB = (y1 + y2)/2.0,  zB = (z1 + z2)/2.0,
+                                        xC = (x2 + x0)/2.0,  yC = (y2 + y0)/2.0,  zC = (z2 + z0)/2.0;
+
+                                // calculate the uv values of the new coordinates
+                                var uA = (u0 + u1)/2.0,  vA = (v0 + v1)/2.0,
+                                        uB = (u1 + u2)/2.0,  vB = (v1 + v2)/2.0,
+                                        uC = (u2 + u0)/2.0,  vC = (v2 + v0)/2.0;
+
+                                // calculate the normals for the new points
+                                var nx0 = norms[iPt0],  ny0 = norms[iPt0+1],  nz0 = norms[iPt0+2],
+                                        nx1 = norms[iPt1],  ny1 = norms[iPt1+1],  nz1 = norms[iPt1+2],
+                                        nx2 = norms[iPt2],  ny2 = norms[iPt2+1],  nz2 = norms[iPt2+2];
+                                var nxA = (nx0 + nx1),  nyA = (ny0 + ny1),  nzA = (nz0 + nz1);  var nrmA = VecUtils.vecNormalize(3, [nxA, nyA, nzA], 1.0 ),
+                                        nxB = (nx1 + nx2),  nyB = (ny1 + ny2),  nzB = (nz1 + nz2);  var nrmB = VecUtils.vecNormalize(3, [nxB, nyB, nzB], 1.0 ),
+                                        nxC = (nx2 + nx0),  nyC = (ny2 + ny0),  nzC = (nz2 + nz0);  var nrmC = VecUtils.vecNormalize(3, [nxC, nyC, nzC], 1.0 );
+
+                                // push everything
+                                verts.push(xA);  verts.push(yA);  verts.push(zA);
+                                verts.push(xB);  verts.push(yB);  verts.push(zB);
+                                verts.push(xC);  verts.push(yC);  verts.push(zC);
+                                uvs.push(uA),  uvs.push(vA);
+                                uvs.push(uB),  uvs.push(vB);
+                                uvs.push(uC),  uvs.push(vC);
+                                norms.push(nrmA[0]);  norms.push(nrmA[1]);  norms.push(nrmA[2]);
+                                norms.push(nrmB[0]);  norms.push(nrmB[1]);  norms.push(nrmB[2]);
+                                norms.push(nrmC[0]);  norms.push(nrmC[1]);  norms.push(nrmC[2]);
+
+                                // split the current triangle into 4
+                                indices[index+1] = nVertices;  indices[index+2] = nVertices+2;
+                                indices.push(nVertices);    indices.push(i1);           indices.push(nVertices+1);  nTriangles++;
+                                indices.push(nVertices+1);  indices.push(i2);           indices.push(nVertices+2);  nTriangles++;
+                                indices.push(nVertices);    indices.push(nVertices+1);  indices.push(nVertices+2);  nTriangles++;
+                                nVertices += 3;
+
+                                // by not advancing 'index', we examine the first of the 3 triangles generated above
+                        }
+                }
+        }
+        return nVertices;
+}