4 files changed, 284 insertions, 491 deletions

diff --git a/OpenSim/Region/Physics/UbitMeshing/Mesh.cs b/OpenSim/Region/Physics/UbitMeshing/Mesh.cs
index c715642..98c0f0b 100644
--- a/OpenSim/Region/Physics/UbitMeshing/Mesh.cs
+++ b/OpenSim/Region/Physics/UbitMeshing/Mesh.cs
@@ -37,6 +37,7 @@ namespace OpenSim.Region.Physics.Meshing
 {
     public class Mesh : IMesh
     {
+
         private Dictionary<Vertex, int> m_vertices;
         private List<Triangle> m_triangles;
         GCHandle m_pinnedVertexes;
@@ -46,8 +47,9 @@ namespace OpenSim.Region.Physics.Meshing
         IntPtr m_indicesPtr = IntPtr.Zero;
         int m_indexCount = 0;
         public float[] m_normals;
-        Vector3 _centroid;
-        int _centroidDiv;
+        Vector3 m_centroid;
+        int m_centroidDiv;
+
 
         private class vertexcomp : IEqualityComparer<Vertex>
         {
@@ -65,7 +67,6 @@ namespace OpenSim.Region.Physics.Meshing
                 int c = v.Z.GetHashCode();
                 return (a << 16) ^ (b << 8) ^ c;
             }
-
         }
 
         public Mesh()
@@ -74,8 +75,18 @@ namespace OpenSim.Region.Physics.Meshing
 
             m_vertices = new Dictionary<Vertex, int>(vcomp);
             m_triangles = new List<Triangle>();
-            _centroid = Vector3.Zero;
-            _centroidDiv = 0;
+            m_centroid = Vector3.Zero;
+            m_centroidDiv = 0;
+        }
+
+        public int RefCount { get; set; }
+
+        public AMeshKey Key { get; set; }
+
+        public void Scale(Vector3 scale)
+        {
+
+
         }
 
         public Mesh Clone()
@@ -86,8 +97,8 @@ namespace OpenSim.Region.Physics.Meshing
             {
                 result.Add(new Triangle(t.v1.Clone(), t.v2.Clone(), t.v3.Clone()));
             }
-            result._centroid = _centroid;
-            result._centroidDiv = _centroidDiv;
+            result.m_centroid = m_centroid;
+            result.m_centroidDiv = m_centroidDiv;
             return result;
         }
 
@@ -109,41 +120,41 @@ namespace OpenSim.Region.Physics.Meshing
 
             if (m_vertices.Count == 0)
             {
-                _centroidDiv = 0;
-                _centroid = Vector3.Zero;
+                m_centroidDiv = 0;
+                m_centroid = Vector3.Zero;
             }
 
             if (!m_vertices.ContainsKey(triangle.v1))
             {
                 m_vertices[triangle.v1] = m_vertices.Count;
-                _centroid.X += triangle.v1.X;
-                _centroid.Y += triangle.v1.Y;
-                _centroid.Z += triangle.v1.Z;
-                _centroidDiv++;
+                m_centroid.X += triangle.v1.X;
+                m_centroid.Y += triangle.v1.Y;
+                m_centroid.Z += triangle.v1.Z;
+                m_centroidDiv++;
             }
             if (!m_vertices.ContainsKey(triangle.v2))
             {
                 m_vertices[triangle.v2] = m_vertices.Count;
-                _centroid.X += triangle.v2.X;
-                _centroid.Y += triangle.v2.Y;
-                _centroid.Z += triangle.v2.Z;
-                _centroidDiv++;
+                m_centroid.X += triangle.v2.X;
+                m_centroid.Y += triangle.v2.Y;
+                m_centroid.Z += triangle.v2.Z;
+                m_centroidDiv++;
             }
             if (!m_vertices.ContainsKey(triangle.v3))
             {
                 m_vertices[triangle.v3] = m_vertices.Count;
-                _centroid.X += triangle.v3.X;
-                _centroid.Y += triangle.v3.Y;
-                _centroid.Z += triangle.v3.Z;
-                _centroidDiv++;
+                m_centroid.X += triangle.v3.X;
+                m_centroid.Y += triangle.v3.Y;
+                m_centroid.Z += triangle.v3.Z;
+                m_centroidDiv++;
             }
             m_triangles.Add(triangle);
         }
 
         public Vector3 GetCentroid()
         {
-            if (_centroidDiv > 0)
-                return new Vector3(_centroid.X / _centroidDiv, _centroid.Y / _centroidDiv, _centroid.Z / _centroidDiv);
+            if (m_centroidDiv > 0)
+                return new Vector3(m_centroid.X / m_centroidDiv, m_centroid.Y / m_centroidDiv, m_centroid.Z / m_centroidDiv);
             else
                 return Vector3.Zero;
         }
diff --git a/OpenSim/Region/Physics/UbitMeshing/Meshmerizer.cs b/OpenSim/Region/Physics/UbitMeshing/Meshmerizer.cs
index f002bba..4c40175 100644
--- a/OpenSim/Region/Physics/UbitMeshing/Meshmerizer.cs
+++ b/OpenSim/Region/Physics/UbitMeshing/Meshmerizer.cs
@@ -82,7 +82,10 @@ namespace OpenSim.Region.Physics.Meshing
 
         private float minSizeForComplexMesh = 0.2f; // prims with all dimensions smaller than this will have a bounding box mesh
 
-        private Dictionary<ulong, Mesh> m_uniqueMeshes = new Dictionary<ulong, Mesh>();
+//        private Dictionary<ulong, Mesh> m_uniqueMeshes = new Dictionary<ulong, Mesh>();
+//        private Dictionary<ulong, Mesh> m_uniqueReleasedMeshes = new Dictionary<ulong, Mesh>();
+        private Dictionary<AMeshKey, Mesh> m_uniqueMeshes = new Dictionary<AMeshKey, Mesh>();
+        private Dictionary<AMeshKey, Mesh> m_uniqueReleasedMeshes = new Dictionary<AMeshKey, Mesh>();
 
         public Meshmerizer(IConfigSource config)
         {
@@ -314,6 +317,9 @@ namespace OpenSim.Region.Physics.Meshing
                                         coords[f.v3].X, coords[f.v3].Y, coords[f.v3].Z));
             }
 
+            coords.Clear();
+            faces.Clear();
+
             return mesh;
         }
 
@@ -780,7 +786,9 @@ namespace OpenSim.Region.Physics.Meshing
             }
 
             PrimMesher.SculptMesh.SculptType sculptType;
-            switch ((OpenMetaverse.SculptType)primShape.SculptType)
+            // remove mirror and invert bits
+            OpenMetaverse.SculptType pbsSculptType = ((OpenMetaverse.SculptType)(primShape.SculptType & 0x3f));
+            switch (pbsSculptType)
             {
                 case OpenMetaverse.SculptType.Cylinder:
                     sculptType = PrimMesher.SculptMesh.SculptType.cylinder;
@@ -802,7 +810,7 @@ namespace OpenSim.Region.Physics.Meshing
             bool mirror = ((primShape.SculptType & 128) != 0);
             bool invert = ((primShape.SculptType & 64) != 0);
 
-            sculptMesh = new PrimMesher.SculptMesh((Bitmap)idata, sculptType, (int)lod, false, mirror, invert);
+            sculptMesh = new PrimMesher.SculptMesh((Bitmap)idata, sculptType, (int)lod, mirror, invert);
 
             idata.Dispose();
 
@@ -971,6 +979,76 @@ namespace OpenSim.Region.Physics.Meshing
             return true;
         }
 
+        public AMeshKey GetMeshUniqueKey(PrimitiveBaseShape primShape, Vector3 size, byte lod, bool convex)
+        {
+            AMeshKey key = new AMeshKey();
+            Byte[] someBytes;
+
+            key.hashB = 5181;
+            ulong hash = 5381;
+
+            if (primShape.SculptEntry)
+            {
+                key.uuid = primShape.SculptTexture;
+                key.hashB = mdjb2(key.hashB, primShape.SculptType);
+            }
+            else
+            {
+                hash = mdjb2(hash, primShape.PathCurve);
+                hash = mdjb2(hash, (byte)primShape.HollowShape);
+                hash = mdjb2(hash, (byte)primShape.ProfileShape);
+                hash = mdjb2(hash, primShape.PathBegin);
+                hash = mdjb2(hash, primShape.PathEnd);
+                hash = mdjb2(hash, primShape.PathScaleX);
+                hash = mdjb2(hash, primShape.PathScaleY);
+                hash = mdjb2(hash, primShape.PathShearX);
+                hash = mdjb2(hash, primShape.PathShearY);
+                hash = mdjb2(hash, (byte)primShape.PathTwist);
+                hash = mdjb2(hash, (byte)primShape.PathTwistBegin);
+                hash = mdjb2(hash, (byte)primShape.PathRadiusOffset);
+                hash = mdjb2(hash, (byte)primShape.PathTaperX);
+                hash = mdjb2(hash, (byte)primShape.PathTaperY);
+                hash = mdjb2(hash, primShape.PathRevolutions);
+                hash = mdjb2(hash, (byte)primShape.PathSkew);
+                hash = mdjb2(hash, primShape.ProfileBegin);
+                hash = mdjb2(hash, primShape.ProfileEnd);
+                hash = mdjb2(hash, primShape.ProfileHollow);
+                key.hashA = hash;
+            }
+
+            hash = key.hashB;
+
+            someBytes = size.GetBytes();
+            for (int i = 0; i < someBytes.Length; i++)
+                hash = mdjb2(hash, someBytes[i]);
+
+            hash = mdjb2(hash, lod);
+            
+            hash &= 0x3fffffffffffffff; 
+
+            if (convex)
+                hash |= 0x4000000000000000;
+
+            if (primShape.SculptEntry)
+                hash |= 0x8000000000000000;
+
+            key.hashB = hash;
+
+            return key;
+        }
+
+        private ulong mdjb2(ulong hash, byte c)
+        {
+            return ((hash << 5) + hash) + (ulong)c;
+        }
+
+        private ulong mdjb2(ulong hash, ushort c)
+        {
+            hash = ((hash << 5) + hash) + (ulong)((byte)c);
+            return ((hash << 5) + hash) + (ulong)(c >> 8);
+        }
+
+
         public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod)
         {
             return CreateMesh(primName, primShape, size, lod, false,false);
@@ -981,6 +1059,8 @@ namespace OpenSim.Region.Physics.Meshing
             return CreateMesh(primName, primShape, size, lod, false,false);
         }
 
+        private static Vector3 m_MeshUnitSize = new Vector3(0.5f, 0.5f, 0.5f);
+
         public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool convex)
         {
 #if SPAM
@@ -988,18 +1068,42 @@ namespace OpenSim.Region.Physics.Meshing
 #endif
 
             Mesh mesh = null;
-            ulong key = 0;
-
-            // If this mesh has been created already, return it instead of creating another copy
-            // For large regions with 100k+ prims and hundreds of copies of each, this can save a GB or more of memory
-            key = primShape.GetMeshKey(size, lod, convex);
-            if (m_uniqueMeshes.TryGetValue(key, out mesh))
-                return mesh;
+//            ulong key = 0;
+            
 
             if (size.X < 0.01f) size.X = 0.01f;
             if (size.Y < 0.01f) size.Y = 0.01f;
             if (size.Z < 0.01f) size.Z = 0.01f;
 
+            // try to find a identical mesh on meshs in use
+//            key = primShape.GetMeshKey(size, lod, convex);
+            AMeshKey key = GetMeshUniqueKey(primShape,size,(byte)lod, convex);
+
+            lock (m_uniqueMeshes)
+            {
+                m_uniqueMeshes.TryGetValue(key, out mesh);
+
+                if (mesh != null)
+                {
+                    mesh.RefCount++;
+                    return mesh;
+                }
+            }
+
+            // try to find a identical mesh on meshs recently released
+            lock (m_uniqueReleasedMeshes)
+            {
+                m_uniqueReleasedMeshes.TryGetValue(key, out mesh);
+                if (mesh != null)
+                {
+                    m_uniqueReleasedMeshes.Remove(key);
+                    lock (m_uniqueMeshes)
+                        m_uniqueMeshes.Add(key, mesh);
+                    mesh.RefCount = 1;
+                    return mesh;
+                }
+            }
+
             mesh = CreateMeshFromPrimMesher(primName, primShape, size, lod,convex);
 
             if (mesh != null)
@@ -1016,11 +1120,68 @@ namespace OpenSim.Region.Physics.Meshing
 
                 // trim the vertex and triangle lists to free up memory
                 mesh.TrimExcess();
+                mesh.Key = key;
+                mesh.RefCount = 1;
 
-                m_uniqueMeshes.Add(key, mesh);
+                lock(m_uniqueMeshes)
+                    m_uniqueMeshes.Add(key, mesh);
             }
 
             return mesh;
         }
+
+        public void ReleaseMesh(IMesh imesh)
+        {
+            if (imesh == null)
+                return;
+
+            Mesh mesh = (Mesh)imesh;
+
+            int curRefCount = mesh.RefCount;
+            curRefCount--;
+
+            if (curRefCount > 0)
+            {
+                mesh.RefCount = curRefCount;
+                return;
+            }
+
+            lock (m_uniqueMeshes)
+            {
+                mesh.RefCount = 0;
+                m_uniqueMeshes.Remove(mesh.Key);
+                lock (m_uniqueReleasedMeshes)
+                    m_uniqueReleasedMeshes.Add(mesh.Key, mesh);
+            }
+        }
+
+        public void ExpireReleaseMeshs()
+        {
+            if (m_uniqueReleasedMeshes.Count == 0)
+                return;
+
+            List<Mesh> meshstodelete = new List<Mesh>();
+            int refcntr;
+
+            lock (m_uniqueReleasedMeshes)
+            {
+                foreach (Mesh m in m_uniqueReleasedMeshes.Values)
+                {
+                    refcntr = m.RefCount;
+                    refcntr--;
+                    if (refcntr > -6)
+                        m.RefCount = refcntr;
+                    else
+                        meshstodelete.Add(m);
+                }
+
+                foreach (Mesh m in meshstodelete)
+                {
+                    m_uniqueReleasedMeshes.Remove(m.Key);
+                    m.releaseSourceMeshData();
+                    m.releasePinned();
+                }
+            }
+        }
     }
 }
diff --git a/OpenSim/Region/Physics/UbitMeshing/SculptMap.cs b/OpenSim/Region/Physics/UbitMeshing/SculptMap.cs
index b3d9cb6..1c75db6 100644
--- a/OpenSim/Region/Physics/UbitMeshing/SculptMap.cs
+++ b/OpenSim/Region/Physics/UbitMeshing/SculptMap.cs
@@ -25,14 +25,10 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-// to build without references to System.Drawing, comment this out
-#define SYSTEM_DRAWING
-
 using System;
 using System.Collections.Generic;
 using System.Text;
 
-#if SYSTEM_DRAWING
 using System.Drawing;
 using System.Drawing.Imaging;
 
@@ -60,11 +56,12 @@ namespace PrimMesher
 
             int numLodPixels = lod * lod;  // (32 * 2)^2  = 64^2 pixels for default sculpt map image
 
-            bool smallMap = bmW * bmH <= numLodPixels;
             bool needsScaling = false;
+            bool smallMap = false;
 
             width = bmW;
             height = bmH;
+
             while (width * height > numLodPixels * 4)
             {
                 width >>= 1;
@@ -85,9 +82,12 @@ namespace PrimMesher
 
             if (width * height > numLodPixels)
             {
+                smallMap = false;
                 width >>= 1;
                 height >>= 1;
             }
+            else
+                smallMap = true;
 
             int numBytes = (width + 1) * (height + 1);
             redBytes = new byte[numBytes];
@@ -95,21 +95,18 @@ namespace PrimMesher
             blueBytes = new byte[numBytes];
 
             int byteNdx = 0;
+            Color c;
 
             try
             {
                 for (int y = 0; y <= height; y++)
                 {
-                    for (int x = 0; x <= width; x++)
+                    for (int x = 0; x < width; x++)
                     {
-                        Color c;
-
                         if (smallMap)
-                            c = bm.GetPixel(x < width ? x : x - 1,
-                                            y < height ? y : y - 1);
+                            c = bm.GetPixel(x,  y < height ? y : y - 1);
                         else
-                            c = bm.GetPixel(x < width ? x * 2 : x * 2 - 1,
-                                            y < height ? y * 2 : y * 2 - 1);
+                            c = bm.GetPixel(x * 2, y < height ? y * 2 : y * 2 - 1);
 
                         redBytes[byteNdx] = c.R;
                         greenBytes[byteNdx] = c.G;
@@ -117,6 +114,17 @@ namespace PrimMesher
 
                         ++byteNdx;
                     }
+
+                    if (smallMap)
+                        c = bm.GetPixel(width - 1, y < height ? y : y - 1);
+                    else
+                        c = bm.GetPixel(width * 2 - 1, y < height ? y * 2 : y * 2 - 1);
+
+                    redBytes[byteNdx] = c.R;
+                    greenBytes[byteNdx] = c.G;
+                    blueBytes[byteNdx] = c.B;
+
+                    ++byteNdx;
                 }
             }
             catch (Exception e)
@@ -140,7 +148,6 @@ namespace PrimMesher
             int rowNdx, colNdx;
             int smNdx = 0;
 
-
             for (rowNdx = 0; rowNdx < numRows; rowNdx++)
             {
                 List<Coord> row = new List<Coord>(numCols);
@@ -163,16 +170,27 @@ namespace PrimMesher
         {
 
             Bitmap scaledImage = new Bitmap(destWidth, destHeight, PixelFormat.Format24bppRgb);
-            
+
             Color c;
-            float xscale = srcImage.Width / destWidth;
-            float yscale = srcImage.Height / destHeight;
             
+
+            // will let last step to be eventually diferent, as seems to be in sl
+
+            float xscale = (float)srcImage.Width / (float)destWidth;
+            float yscale = (float)srcImage.Height / (float)destHeight;
+
+            int lastsx = srcImage.Width - 1;
+            int lastsy = srcImage.Height - 1;
+            int lastdx = destWidth - 1;
+            int lastdy = destHeight - 1;
+
             float sy = 0.5f;
-            for (int y = 0; y < destHeight; y++)
+            float sx;
+
+            for (int y = 0; y < lastdy; y++)
             {
-                float sx = 0.5f;
-                for (int x = 0; x < destWidth; x++)
+                sx = 0.5f;
+                for (int x = 0; x < lastdx; x++)
                 {
                     try
                     {
@@ -182,16 +200,45 @@ namespace PrimMesher
                     catch (IndexOutOfRangeException)
                     {
                     }
-
                     sx += xscale;
                 }
+                try
+                {
+                    c = srcImage.GetPixel(lastsx, (int)(sy));
+                    scaledImage.SetPixel(lastdx, y, Color.FromArgb(c.R, c.G, c.B));
+                }
+                catch (IndexOutOfRangeException)
+                {
+                }
+
                 sy += yscale;
             }
+
+            sx = 0.5f;
+            for (int x = 0; x < lastdx; x++)
+            {
+                try
+                {
+                    c = srcImage.GetPixel((int)(sx), lastsy);
+                    scaledImage.SetPixel(x, lastdy, Color.FromArgb(c.R, c.G, c.B));
+                }
+                catch (IndexOutOfRangeException)
+                {
+                }
+
+                sx += xscale;
+            }
+            try
+            {
+                c = srcImage.GetPixel(lastsx, lastsy);
+                scaledImage.SetPixel(lastdx, lastdy, Color.FromArgb(c.R, c.G, c.B));
+            }
+            catch (IndexOutOfRangeException)
+            {
+            }
+
             srcImage.Dispose();
             return scaledImage;
         }
-
-    }        
-    
     }
-#endif
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Physics/UbitMeshing/SculptMesh.cs b/OpenSim/Region/Physics/UbitMeshing/SculptMesh.cs
index 4a7f3ad..bc1375b 100644
--- a/OpenSim/Region/Physics/UbitMeshing/SculptMesh.cs
+++ b/OpenSim/Region/Physics/UbitMeshing/SculptMesh.cs
@@ -25,18 +25,13 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-// to build without references to System.Drawing, comment this out
-#define SYSTEM_DRAWING
-
 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.IO;
 
-#if SYSTEM_DRAWING
 using System.Drawing;
 using System.Drawing.Imaging;
-#endif
 
 namespace PrimMesher
 {
@@ -46,274 +41,28 @@ namespace PrimMesher
         public List<Coord> coords;
         public List<Face> faces;
 
-        public List<ViewerFace> viewerFaces;
-        public List<Coord> normals;
-        public List<UVCoord> uvs;
-
         public enum SculptType { sphere = 1, torus = 2, plane = 3, cylinder = 4 };
 
-#if SYSTEM_DRAWING
-
-        public SculptMesh SculptMeshFromFile(string fileName, SculptType sculptType, int lod, bool viewerMode)
-        {
-            Bitmap bitmap = (Bitmap)Bitmap.FromFile(fileName);
-            SculptMesh sculptMesh = new SculptMesh(bitmap, sculptType, lod, viewerMode);
-            bitmap.Dispose();
-            return sculptMesh;
-        }
-
-
-        public SculptMesh(string fileName, int sculptType, int lod, int viewerMode, int mirror, int invert)
-        {
-            Bitmap bitmap = (Bitmap)Bitmap.FromFile(fileName);
-            _SculptMesh(bitmap, (SculptType)sculptType, lod, viewerMode != 0, mirror != 0, invert != 0);
-            bitmap.Dispose();
-        }
-#endif
-
-        /// <summary>
-        /// ** Experimental ** May disappear from future versions ** not recommeneded for use in applications
-        /// Construct a sculpt mesh from a 2D array of floats
-        /// </summary>
-        /// <param name="zMap"></param>
-        /// <param name="xBegin"></param>
-        /// <param name="xEnd"></param>
-        /// <param name="yBegin"></param>
-        /// <param name="yEnd"></param>
-        /// <param name="viewerMode"></param>
-        public SculptMesh(float[,] zMap, float xBegin, float xEnd, float yBegin, float yEnd, bool viewerMode)
-        {
-            float xStep, yStep;
-            float uStep, vStep;
-
-            int numYElements = zMap.GetLength(0);
-            int numXElements = zMap.GetLength(1);
-
-            try
-            {
-                xStep = (xEnd - xBegin) / (float)(numXElements - 1);
-                yStep = (yEnd - yBegin) / (float)(numYElements - 1);
-
-                uStep = 1.0f / (numXElements - 1);
-                vStep = 1.0f / (numYElements - 1);
-            }
-            catch (DivideByZeroException)
-            {
-                return;
-            }
-
-            coords = new List<Coord>();
-            faces = new List<Face>();
-            normals = new List<Coord>();
-            uvs = new List<UVCoord>();
-
-            viewerFaces = new List<ViewerFace>();
-
-            int p1, p2, p3, p4;
-
-            int x, y;
-            int xStart = 0, yStart = 0;
-
-            for (y = yStart; y < numYElements; y++)
-            {
-                int rowOffset = y * numXElements;
-
-                for (x = xStart; x < numXElements; x++)
-                {
-                    /*
-                    *   p1-----p2
-                    *   | \ f2 |
-                    *   |   \  |
-                    *   | f1  \|
-                    *   p3-----p4
-                    */
-
-                    p4 = rowOffset + x;
-                    p3 = p4 - 1;
-
-                    p2 = p4 - numXElements;
-                    p1 = p3 - numXElements;
-
-                    Coord c = new Coord(xBegin + x * xStep, yBegin + y * yStep, zMap[y, x]);
-                    this.coords.Add(c);
-                    if (viewerMode)
-                    {
-                        this.normals.Add(new Coord());
-                        this.uvs.Add(new UVCoord(uStep * x, 1.0f - vStep * y));
-                    }
-
-                    if (y > 0 && x > 0)
-                    {
-                        Face f1, f2;
-
-                        if (viewerMode)
-                        {
-                            f1 = new Face(p1, p4, p3, p1, p4, p3);
-                            f1.uv1 = p1;
-                            f1.uv2 = p4;
-                            f1.uv3 = p3;
-
-                            f2 = new Face(p1, p2, p4, p1, p2, p4);
-                            f2.uv1 = p1;
-                            f2.uv2 = p2;
-                            f2.uv3 = p4;
-                        }
-                        else
-                        {
-                            f1 = new Face(p1, p4, p3);
-                            f2 = new Face(p1, p2, p4);
-                        }
-
-                        this.faces.Add(f1);
-                        this.faces.Add(f2);
-                    }
-                }
-            }
-
-            if (viewerMode)
-                calcVertexNormals(SculptType.plane, numXElements, numYElements);
-        }
-
-#if SYSTEM_DRAWING
-        public SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool viewerMode)
-        {
-            _SculptMesh(sculptBitmap, sculptType, lod, viewerMode, false, false);
-        }
 
-        public SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool viewerMode, bool mirror, bool invert)
+        public SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool mirror, bool invert)
         {
-            _SculptMesh(sculptBitmap, sculptType, lod, viewerMode, mirror, invert);
-        }
-#endif
-
-        public SculptMesh(List<List<Coord>> rows, SculptType sculptType, bool viewerMode, bool mirror, bool invert)
-        {
-            _SculptMesh(rows, sculptType, viewerMode, mirror, invert);
-        }
-
-#if SYSTEM_DRAWING
-        /// <summary>
-        /// converts a bitmap to a list of lists of coords, while scaling the image.
-        /// the scaling is done in floating point so as to allow for reduced vertex position
-        /// quantization as the position will be averaged between pixel values. this routine will
-        /// likely fail if the bitmap width and height are not powers of 2.
-        /// </summary>
-        /// <param name="bitmap"></param>
-        /// <param name="scale"></param>
-        /// <param name="mirror"></param>
-        /// <returns></returns>
-        private List<List<Coord>> bitmap2Coords(Bitmap bitmap, int scale, bool mirror)
-        {
-            int numRows = bitmap.Height / scale;
-            int numCols = bitmap.Width / scale;
-            List<List<Coord>> rows = new List<List<Coord>>(numRows);
-
-            float pixScale = 1.0f / (scale * scale);
-            pixScale /= 255;
-
-            int imageX, imageY = 0;
-
-            int rowNdx, colNdx;
-
-            for (rowNdx = 0; rowNdx < numRows; rowNdx++)
-            {
-                List<Coord> row = new List<Coord>(numCols);
-                for (colNdx = 0; colNdx < numCols; colNdx++)
-                {
-                    imageX = colNdx * scale;
-                    int imageYStart = rowNdx * scale;
-                    int imageYEnd = imageYStart + scale;
-                    int imageXEnd = imageX + scale;
-                    float rSum = 0.0f;
-                    float gSum = 0.0f;
-                    float bSum = 0.0f;
-                    for (; imageX < imageXEnd; imageX++)
-                    {
-                        for (imageY = imageYStart; imageY < imageYEnd; imageY++)
-                        {
-                            Color c = bitmap.GetPixel(imageX, imageY);
-                            if (c.A != 255)
-                            {
-                                bitmap.SetPixel(imageX, imageY, Color.FromArgb(255, c.R, c.G, c.B));
-                                c = bitmap.GetPixel(imageX, imageY);
-                            }
-                            rSum += c.R;
-                            gSum += c.G;
-                            bSum += c.B;
-                        }
-                    }
-                    if (mirror)
-                        row.Add(new Coord(-(rSum * pixScale - 0.5f), gSum * pixScale - 0.5f, bSum * pixScale - 0.5f));
-                    else
-                        row.Add(new Coord(rSum * pixScale - 0.5f, gSum * pixScale - 0.5f, bSum * pixScale - 0.5f));
-
-                }
-                rows.Add(row);
-            }
-            return rows;
-        }
-
-        private List<List<Coord>> bitmap2CoordsSampled(Bitmap bitmap, int scale, bool mirror)
-        {
-            int numRows = bitmap.Height / scale;
-            int numCols = bitmap.Width / scale;
-            List<List<Coord>> rows = new List<List<Coord>>(numRows);
-
-            float pixScale = 1.0f / 256.0f;
-
-            int imageX, imageY = 0;
-
-            int rowNdx, colNdx;
-
-            for (rowNdx = 0; rowNdx <= numRows; rowNdx++)
-            {
-                List<Coord> row = new List<Coord>(numCols);
-                imageY = rowNdx * scale;
-                if (rowNdx == numRows) imageY--;
-                for (colNdx = 0; colNdx <= numCols; colNdx++)
-                {
-                    imageX = colNdx * scale;
-                    if (colNdx == numCols) imageX--;
-
-                    Color c = bitmap.GetPixel(imageX, imageY);
-                    if (c.A != 255)
-                    {
-                        bitmap.SetPixel(imageX, imageY, Color.FromArgb(255, c.R, c.G, c.B));
-                        c = bitmap.GetPixel(imageX, imageY);
-                    }
-
-                    if (mirror)
-                        row.Add(new Coord(-(c.R * pixScale - 0.5f), c.G * pixScale - 0.5f, c.B * pixScale - 0.5f));
-                    else
-                        row.Add(new Coord(c.R * pixScale - 0.5f, c.G * pixScale - 0.5f, c.B * pixScale - 0.5f));
+            if (mirror)
+                invert = !invert;
 
-                }
-                rows.Add(row);
-            }
-            return rows;
-        }
+            SculptMap smap = new SculptMap(sculptBitmap, lod);
 
+            List<List<Coord>> rows = smap.ToRows(mirror);
 
-        void _SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool viewerMode, bool mirror, bool invert)
-        {
-            _SculptMesh(new SculptMap(sculptBitmap, lod).ToRows(mirror), sculptType, viewerMode, mirror, invert);
+            _SculptMesh(rows, sculptType, invert);
         }
-#endif
 
-        void _SculptMesh(List<List<Coord>> rows, SculptType sculptType, bool viewerMode, bool mirror, bool invert)
+        private void _SculptMesh(List<List<Coord>> rows, SculptType sculptType, bool invert)
         {
             coords = new List<Coord>();
             faces = new List<Face>();
-            normals = new List<Coord>();
-            uvs = new List<UVCoord>();
 
             sculptType = (SculptType)(((int)sculptType) & 0x07);
 
-            if (mirror)
-                invert = !invert;
-
-            viewerFaces = new List<ViewerFace>();
-
             int width = rows[0].Count;
 
             int p1, p2, p3, p4;
@@ -375,7 +124,6 @@ namespace PrimMesher
 
             int coordsDown = rows.Count;
             int coordsAcross = rows[0].Count;
-//            int lastColumn = coordsAcross - 1;
 
             float widthUnit = 1.0f / (coordsAcross - 1);
             float heightUnit = 1.0f / (coordsDown - 1);
@@ -401,45 +149,11 @@ namespace PrimMesher
                     p1 = p3 - coordsAcross;
 
                     this.coords.Add(rows[imageY][imageX]);
-                    if (viewerMode)
-                    {
-                        this.normals.Add(new Coord());
-                        this.uvs.Add(new UVCoord(widthUnit * imageX, heightUnit * imageY));
-                    }
 
                     if (imageY > 0 && imageX > 0)
                     {
                         Face f1, f2;
 
-                        if (viewerMode)
-                        {
-                            if (invert)
-                            {
-                                f1 = new Face(p1, p4, p3, p1, p4, p3);
-                                f1.uv1 = p1;
-                                f1.uv2 = p4;
-                                f1.uv3 = p3;
-
-                                f2 = new Face(p1, p2, p4, p1, p2, p4);
-                                f2.uv1 = p1;
-                                f2.uv2 = p2;
-                                f2.uv3 = p4;
-                            }
-                            else
-                            {
-                                f1 = new Face(p1, p3, p4, p1, p3, p4);
-                                f1.uv1 = p1;
-                                f1.uv2 = p3;
-                                f1.uv3 = p4;
-
-                                f2 = new Face(p1, p4, p2, p1, p4, p2);
-                                f2.uv1 = p1;
-                                f2.uv2 = p4;
-                                f2.uv3 = p2;
-                            }
-                        }
-                        else
-                        {
                             if (invert)
                             {
                                 f1 = new Face(p1, p4, p3);
@@ -450,16 +164,12 @@ namespace PrimMesher
                                 f1 = new Face(p1, p3, p4);
                                 f2 = new Face(p1, p4, p2);
                             }
-                        }
 
                         this.faces.Add(f1);
                         this.faces.Add(f2);
                     }
                 }
             }
-
-            if (viewerMode)
-                calcVertexNormals(sculptType, coordsAcross, coordsDown);
         }
 
         /// <summary>
@@ -475,129 +185,6 @@ namespace PrimMesher
         {
             coords = new List<Coord>(sm.coords);
             faces = new List<Face>(sm.faces);
-            viewerFaces = new List<ViewerFace>(sm.viewerFaces);
-            normals = new List<Coord>(sm.normals);
-            uvs = new List<UVCoord>(sm.uvs);
-        }
-
-        private void calcVertexNormals(SculptType sculptType, int xSize, int ySize)
-        {  // compute vertex normals by summing all the surface normals of all the triangles sharing
-            // each vertex and then normalizing
-            int numFaces = this.faces.Count;
-            for (int i = 0; i < numFaces; i++)
-            {
-                Face face = this.faces[i];
-                Coord surfaceNormal = face.SurfaceNormal(this.coords);
-                this.normals[face.n1] += surfaceNormal;
-                this.normals[face.n2] += surfaceNormal;
-                this.normals[face.n3] += surfaceNormal;
-            }
-
-            int numNormals = this.normals.Count;
-            for (int i = 0; i < numNormals; i++)
-                this.normals[i] = this.normals[i].Normalize();
-
-            if (sculptType != SculptType.plane)
-            { // blend the vertex normals at the cylinder seam
-                for (int y = 0; y < ySize; y++)
-                {
-                    int rowOffset = y * xSize;
-
-                    this.normals[rowOffset] = this.normals[rowOffset + xSize - 1] = (this.normals[rowOffset] + this.normals[rowOffset + xSize - 1]).Normalize();
-                }
-            }
-
-            foreach (Face face in this.faces)
-            {
-                ViewerFace vf = new ViewerFace(0);
-                vf.v1 = this.coords[face.v1];
-                vf.v2 = this.coords[face.v2];
-                vf.v3 = this.coords[face.v3];
-
-                vf.coordIndex1 = face.v1;
-                vf.coordIndex2 = face.v2;
-                vf.coordIndex3 = face.v3;
-
-                vf.n1 = this.normals[face.n1];
-                vf.n2 = this.normals[face.n2];
-                vf.n3 = this.normals[face.n3];
-
-                vf.uv1 = this.uvs[face.uv1];
-                vf.uv2 = this.uvs[face.uv2];
-                vf.uv3 = this.uvs[face.uv3];
-
-                this.viewerFaces.Add(vf);
-            }
-        }
-
-        /// <summary>
-        /// Adds a value to each XYZ vertex coordinate in the mesh
-        /// </summary>
-        /// <param name="x"></param>
-        /// <param name="y"></param>
-        /// <param name="z"></param>
-        public void AddPos(float x, float y, float z)
-        {
-            int i;
-            int numVerts = this.coords.Count;
-            Coord vert;
-
-            for (i = 0; i < numVerts; i++)
-            {
-                vert = this.coords[i];
-                vert.X += x;
-                vert.Y += y;
-                vert.Z += z;
-                this.coords[i] = vert;
-            }
-
-            if (this.viewerFaces != null)
-            {
-                int numViewerFaces = this.viewerFaces.Count;
-
-                for (i = 0; i < numViewerFaces; i++)
-                {
-                    ViewerFace v = this.viewerFaces[i];
-                    v.AddPos(x, y, z);
-                    this.viewerFaces[i] = v;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Rotates the mesh
-        /// </summary>
-        /// <param name="q"></param>
-        public void AddRot(Quat q)
-        {
-            int i;
-            int numVerts = this.coords.Count;
-
-            for (i = 0; i < numVerts; i++)
-                this.coords[i] *= q;
-
-            int numNormals = this.normals.Count;
-            for (i = 0; i < numNormals; i++)
-                this.normals[i] *= q;
-
-            if (this.viewerFaces != null)
-            {
-                int numViewerFaces = this.viewerFaces.Count;
-
-                for (i = 0; i < numViewerFaces; i++)
-                {
-                    ViewerFace v = this.viewerFaces[i];
-                    v.v1 *= q;
-                    v.v2 *= q;
-                    v.v3 *= q;
-
-                    v.n1 *= q;
-                    v.n2 *= q;
-                    v.n3 *= q;
-
-                    this.viewerFaces[i] = v;
-                }
-            }
         }
 
         public void Scale(float x, float y, float z)
@@ -608,19 +195,6 @@ namespace PrimMesher
             Coord m = new Coord(x, y, z);
             for (i = 0; i < numVerts; i++)
                 this.coords[i] *= m;
-
-            if (this.viewerFaces != null)
-            {
-                int numViewerFaces = this.viewerFaces.Count;
-                for (i = 0; i < numViewerFaces; i++)
-                {
-                    ViewerFace v = this.viewerFaces[i];
-                    v.v1 *= m;
-                    v.v2 *= m;
-                    v.v3 *= m;
-                    this.viewerFaces[i] = v;
-                }
-            }
         }
 
         public void DumpRaw(String path, String name, String title)