5 files changed, 249 insertions, 216 deletions

diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs
index 42fc11b..f72ad28 100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs
@@ -141,14 +141,30 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
     }
 
     // The passed position is relative to the base of the region.
+    // There are many assumptions herein that the heightmap increment is 1.
     public override float GetTerrainHeightAtXYZ(Vector3 pos)
     {
         float ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;
 
-        int mapIndex = (int)pos.Y * (int)m_mapInfo.sizeY + (int)pos.X;
-        try
-        {
-            ret = m_mapInfo.heightMap[mapIndex];
+        try {
+            int baseX = (int)pos.X;
+            int baseY = (int)pos.Y;
+            int maxX = (int)m_mapInfo.sizeX;
+            int maxY = (int)m_mapInfo.sizeY;
+            float diffX = pos.X - (float)baseX;
+            float diffY = pos.Y - (float)baseY;
+
+            float mapHeight1 = m_mapInfo.heightMap[baseY * maxY + baseX];
+            float mapHeight2 = m_mapInfo.heightMap[Math.Min(baseY + 1, maxY - 1) * maxY + baseX];
+            float mapHeight3 = m_mapInfo.heightMap[baseY * maxY + Math.Min(baseX + 1, maxX  - 1)];
+            float mapHeight4 = m_mapInfo.heightMap[Math.Min(baseY + 1, maxY - 1) * maxY +  Math.Min(baseX + 1, maxX  - 1)];
+
+            float Xrise = (mapHeight4 - mapHeight3) * diffX;
+            float Yrise = (mapHeight2 - mapHeight1) * diffY;
+
+            ret = mapHeight1 + ((Xrise + Yrise) / 2f);
+            // m_physicsScene.DetailLog("{0},BSTerrainHeightMap,GetTerrainHeightAtXYZ,pos={1},{2}/{3}/{4}/{5},ret={6}",
+            //         BSScene.DetailLogZero, pos, mapHeight1, mapHeight2, mapHeight3, mapHeight4, ret);
         }
         catch
         {
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs
index 4f95554..0d4b6b9 100644
--- a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs
@@ -66,7 +66,7 @@ namespace OpenSim.Region.PhysicsModule.Meshing
 
         private bool cacheSculptMaps = true;
         private string decodedSculptMapPath = null;
-        private bool useMeshiesPhysicsMesh = false;
+        private bool useMeshiesPhysicsMesh = true;
 
         private float minSizeForComplexMesh = 0.2f; // prims with all dimensions smaller than this will have a bounding box mesh
 
diff --git a/OpenSim/Region/PhysicsModules/ubOde/ODEMeshWorker.cs b/OpenSim/Region/PhysicsModules/ubOde/ODEMeshWorker.cs
index dc87a78..5465035 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODEMeshWorker.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODEMeshWorker.cs
@@ -62,6 +62,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         public byte shapetype;
         public bool hasOBB;
         public bool hasMeshVolume;
+        public bool isTooSmall;
         public MeshState meshState;
         public UUID? assetID;
         public meshWorkerCmnds comand;
@@ -69,16 +70,14 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
     public class ODEMeshWorker
     {
-
         private ILog m_log;
         private ODEScene m_scene;
         private IMesher m_mesher;
 
         public bool meshSculptedPrim = true;
-        public bool forceSimplePrimMeshing = false;
         public float meshSculptLOD = 32;
         public float MeshSculptphysicalLOD = 32;
-
+        public float MinSizeToMeshmerize = 0.1f;
 
         private OpenSim.Framework.BlockingQueue<ODEPhysRepData> workQueue = new OpenSim.Framework.BlockingQueue<ODEPhysRepData>();
         private bool m_running;
@@ -93,9 +92,9 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
             if (pConfig != null)
             {
-                forceSimplePrimMeshing = pConfig.GetBoolean("force_simple_prim_meshing", forceSimplePrimMeshing);
                 meshSculptedPrim = pConfig.GetBoolean("mesh_sculpted_prim", meshSculptedPrim);
                 meshSculptLOD = pConfig.GetFloat("mesh_lod", meshSculptLOD);
+                MinSizeToMeshmerize =  pConfig.GetFloat("mesh_min_size", MinSizeToMeshmerize);
                 MeshSculptphysicalLOD = pConfig.GetFloat("mesh_physical_lod", MeshSculptphysicalLOD);
             }
             m_running = true;
@@ -288,6 +287,16 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         {
             PrimitiveBaseShape pbs = repData.pbs;
             // check sculpts or meshs
+
+            Vector3 scale = pbs.Scale;
+            if(scale.X <= MinSizeToMeshmerize &&
+               scale.Y <= MinSizeToMeshmerize &&
+               scale.Z <= MinSizeToMeshmerize)
+            {
+                repData.isTooSmall = true;
+                return false;
+            }
+
             if (pbs.SculptEntry)
             {
                 if (meshSculptedPrim)
@@ -299,9 +308,6 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 return false;
             }
 
-            if (forceSimplePrimMeshing)
-                return true;
-
             // convex shapes have no holes
             ushort profilehollow = pbs.ProfileHollow;
             if(repData.shapetype == 2)
@@ -425,17 +431,8 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             Vector3 size = repData.size;
 
             int clod = (int)LevelOfDetail.High;
-            bool convex;
             byte shapetype = repData.shapetype;
-            if (shapetype == 0)
-                convex = false;
-            else
-            {
-                convex = true;
-                // sculpts pseudo convex
-                if (pbs.SculptEntry && pbs.SculptType != (byte)SculptType.Mesh)
-                    clod = (int)LevelOfDetail.Low;
-            }
+            bool convex = shapetype == 2;
 
             mesh = m_mesher.GetMesh(actor.Name, pbs, size, clod, true, convex);
 
@@ -563,10 +560,16 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
         private void CalculateBasicPrimVolume(ODEPhysRepData repData)
         {
-            PrimitiveBaseShape _pbs = repData.pbs;
             Vector3 _size = repData.size;
 
             float volume = _size.X * _size.Y * _size.Z; // default
+            if(repData.isTooSmall)
+            {
+                repData.volume = volume;
+                return;
+            }
+
+            PrimitiveBaseShape _pbs = repData.pbs;
             float tmp;
 
             float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f;
diff --git a/OpenSim/Region/PhysicsModules/ubOde/ODEPrim.cs b/OpenSim/Region/PhysicsModules/ubOde/ODEPrim.cs
index 76ef88b..aa208e2 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODEPrim.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODEPrim.cs
@@ -1733,7 +1733,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             return true;
         }
 
-        private void CreateGeom()
+        private void CreateGeom(bool OverrideToBox)
         {
             bool hasMesh = false;
 
@@ -1742,7 +1742,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             if ((m_meshState & MeshState.MeshNoColide) != 0)
                 m_NoColide = true;
 
-            else if(m_mesh != null)
+            else if(!OverrideToBox && m_mesh != null)
             {
                 if (GetMeshGeom())
                     hasMesh = true;
@@ -3180,7 +3180,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
             primVolume = repData.volume;
 
-            CreateGeom();
+            CreateGeom(repData.isTooSmall);
 
             if (prim_geom != IntPtr.Zero)
             {
@@ -3256,7 +3256,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
             primVolume = repData.volume;
 
-            CreateGeom();
+            CreateGeom(repData.isTooSmall);
 
             if (prim_geom != IntPtr.Zero)
             {
diff --git a/OpenSim/Region/PhysicsModules/ubOdeMeshing/Meshmerizer.cs b/OpenSim/Region/PhysicsModules/ubOdeMeshing/Meshmerizer.cs
index 0117800..a2a3f79 100644
--- a/OpenSim/Region/PhysicsModules/ubOdeMeshing/Meshmerizer.cs
+++ b/OpenSim/Region/PhysicsModules/ubOdeMeshing/Meshmerizer.cs
@@ -36,15 +36,13 @@ using OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet;
 using OpenMetaverse;
 using OpenMetaverse.StructuredData;
 using System.Drawing;
-using System.Drawing.Imaging;
+using System.Threading;
 using System.IO.Compression;
 using PrimMesher;
 using log4net;
 using Nini.Config;
 using System.Reflection;
 using System.IO;
-using System.Runtime.Serialization;
-using System.Runtime.Serialization.Formatters.Binary;
 
 using Mono.Addins;
 
@@ -58,22 +56,22 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
         // Setting baseDir to a path will enable the dumping of raw files
         // raw files can be imported by blender so a visual inspection of the results can be done
 
+        private static string cacheControlFilename = "cntr";
         private bool m_Enabled = false;
 
         public static object diskLock = new object();
 
         public bool doMeshFileCache = true;
-
+        public bool doCacheExpire = true;
         public string cachePath = "MeshCache";
         public TimeSpan CacheExpire;
-        public bool doCacheExpire = true;
 
 //        const string baseDir = "rawFiles";
         private const string baseDir = null; //"rawFiles";
 
-        private bool useMeshiesPhysicsMesh = false;
-
-        private float minSizeForComplexMesh = 0.2f; // prims with all dimensions smaller than this will have a bounding box mesh
+        private bool useMeshiesPhysicsMesh = true;
+        private bool doConvexPrims = true;
+        private bool doConvexSculpts = true;
 
         private Dictionary<AMeshKey, Mesh> m_uniqueMeshes = new Dictionary<AMeshKey, Mesh>();
         private Dictionary<AMeshKey, Mesh> m_uniqueReleasedMeshes = new Dictionary<AMeshKey, Mesh>();
@@ -103,40 +101,31 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                 if (mesh_config != null)
                 {
                     useMeshiesPhysicsMesh = mesh_config.GetBoolean("UseMeshiesPhysicsMesh", useMeshiesPhysicsMesh);
-                    if (useMeshiesPhysicsMesh)
-                    {
-                        doMeshFileCache = mesh_config.GetBoolean("MeshFileCache", doMeshFileCache);
-                        cachePath = mesh_config.GetString("MeshFileCachePath", cachePath);
-                        fcache = mesh_config.GetFloat("MeshFileCacheExpireHours", fcache);
-                        doCacheExpire = mesh_config.GetBoolean("MeshFileCacheDoExpire", doCacheExpire);
-                    }
-                    else
-                    {
-                        doMeshFileCache = false;
-                        doCacheExpire = false;
-                    }
+                    doConvexPrims = mesh_config.GetBoolean("ConvexPrims",doConvexPrims);
+                    doConvexSculpts = mesh_config.GetBoolean("ConvexSculpts",doConvexPrims);
+                    doMeshFileCache = mesh_config.GetBoolean("MeshFileCache", doMeshFileCache);
+                    cachePath = mesh_config.GetString("MeshFileCachePath", cachePath);
+                    fcache = mesh_config.GetFloat("MeshFileCacheExpireHours", fcache);
+                    doCacheExpire = mesh_config.GetBoolean("MeshFileCacheDoExpire", doCacheExpire);
 
                     m_Enabled = true;
                 }
 
                 CacheExpire = TimeSpan.FromHours(fcache);
 
-                lock (diskLock)
+                if(String.IsNullOrEmpty(cachePath))
+                    doMeshFileCache = false;
+
+                if(doMeshFileCache)
                 {
-                    if(doMeshFileCache && cachePath != "")
+                    if(!checkCache())
                     {
-                        try
-                        {
-                            if (!Directory.Exists(cachePath))
-                                Directory.CreateDirectory(cachePath);
-                        }
-                        catch
-                        {
-                            doMeshFileCache = false;
-                            doCacheExpire = false;
-                        }
+                        doMeshFileCache = false;
+                        doCacheExpire = false;
                     }
                 }
+                else
+                    doCacheExpire = false;
             }
         }
 
@@ -168,87 +157,6 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
 
         #endregion
 
-        /// <summary>
-        /// creates a simple box mesh of the specified size. This mesh is of very low vertex count and may
-        /// be useful as a backup proxy when level of detail is not needed or when more complex meshes fail
-        /// for some reason
-        /// </summary>
-        /// <param name="minX"></param>
-        /// <param name="maxX"></param>
-        /// <param name="minY"></param>
-        /// <param name="maxY"></param>
-        /// <param name="minZ"></param>
-        /// <param name="maxZ"></param>
-        /// <returns></returns>
-        private static Mesh CreateSimpleBoxMesh(float minX, float maxX, float minY, float maxY, float minZ, float maxZ)
-        {
-            Mesh box = new Mesh(true);
-            List<Vertex> vertices = new List<Vertex>();
-            // bottom
-
-            vertices.Add(new Vertex(minX, maxY, minZ));
-            vertices.Add(new Vertex(maxX, maxY, minZ));
-            vertices.Add(new Vertex(maxX, minY, minZ));
-            vertices.Add(new Vertex(minX, minY, minZ));
-
-            box.Add(new Triangle(vertices[0], vertices[1], vertices[2]));
-            box.Add(new Triangle(vertices[0], vertices[2], vertices[3]));
-
-            // top
-
-            vertices.Add(new Vertex(maxX, maxY, maxZ));
-            vertices.Add(new Vertex(minX, maxY, maxZ));
-            vertices.Add(new Vertex(minX, minY, maxZ));
-            vertices.Add(new Vertex(maxX, minY, maxZ));
-
-            box.Add(new Triangle(vertices[4], vertices[5], vertices[6]));
-            box.Add(new Triangle(vertices[4], vertices[6], vertices[7]));
-
-            // sides
-
-            box.Add(new Triangle(vertices[5], vertices[0], vertices[3]));
-            box.Add(new Triangle(vertices[5], vertices[3], vertices[6]));
-
-            box.Add(new Triangle(vertices[1], vertices[0], vertices[5]));
-            box.Add(new Triangle(vertices[1], vertices[5], vertices[4]));
-
-            box.Add(new Triangle(vertices[7], vertices[1], vertices[4]));
-            box.Add(new Triangle(vertices[7], vertices[2], vertices[1]));
-
-            box.Add(new Triangle(vertices[3], vertices[2], vertices[7]));
-            box.Add(new Triangle(vertices[3], vertices[7], vertices[6]));
-
-            return box;
-        }
-
-        /// <summary>
-        /// Creates a simple bounding box mesh for a complex input mesh
-        /// </summary>
-        /// <param name="meshIn"></param>
-        /// <returns></returns>
-        private static Mesh CreateBoundingBoxMesh(Mesh meshIn)
-        {
-            float minX = float.MaxValue;
-            float maxX = float.MinValue;
-            float minY = float.MaxValue;
-            float maxY = float.MinValue;
-            float minZ = float.MaxValue;
-            float maxZ = float.MinValue;
-
-            foreach (Vector3 v in meshIn.getVertexList())
-            {
-                if (v.X < minX) minX = v.X;
-                if (v.Y < minY) minY = v.Y;
-                if (v.Z < minZ) minZ = v.Z;
-
-                if (v.X > maxX) maxX = v.X;
-                if (v.Y > maxY) maxY = v.Y;
-                if (v.Z > maxZ) maxZ = v.Z;
-            }
-
-            return CreateSimpleBoxMesh(minX, maxX, minY, maxY, minZ, maxZ);
-        }
-
         private void ReportPrimError(string message, string primName, PrimMesh primMesh)
         {
             m_log.Error(message);
@@ -265,7 +173,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
         /// <param name="faces"></param>
         private void AddSubMesh(OSDMap subMeshData, List<Coord> coords, List<Face> faces)
         {
-    //                                    Console.WriteLine("subMeshMap for {0} - {1}", primName, Util.GetFormattedXml((OSD)subMeshMap));
+            // Console.WriteLine("subMeshMap for {0} - {1}", primName, Util.GetFormattedXml((OSD)subMeshMap));
 
             // As per http://wiki.secondlife.com/wiki/Mesh/Mesh_Asset_Format, some Mesh Level
             // of Detail Blocks (maps) contain just a NoGeometry key to signal there is no
@@ -330,6 +238,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
 
             List<Coord> coords;
             List<Face> faces;
+            bool needsConvexProcessing = convex;
 
             if (primShape.SculptEntry)
             {
@@ -340,23 +249,49 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
 
                     if (!GenerateCoordsAndFacesFromPrimMeshData(primName, primShape, out coords, out faces, convex))
                         return null;
+                    needsConvexProcessing = false;
                 }
                 else
                 {
                     if (!GenerateCoordsAndFacesFromPrimSculptData(primName, primShape, lod, out coords, out faces))
                         return null;
+                    needsConvexProcessing &= doConvexSculpts;
                 }
             }
             else
             {
                 if (!GenerateCoordsAndFacesFromPrimShapeData(primName, primShape, lod, convex, out coords, out faces))
                     return null;
+                 needsConvexProcessing &= doConvexPrims;
             }
 
-
             int numCoords = coords.Count;
             int numFaces = faces.Count;
 
+            if(numCoords < 3 || (!needsConvexProcessing && numFaces < 1))
+            {
+                m_log.ErrorFormat("[MESH]: invalid degenerated mesh for prim {0} ignored", primName);
+                return null;
+            }
+
+            if(needsConvexProcessing)
+            {
+                List<Coord> convexcoords;
+                List<Face> convexfaces;
+                if(CreateBoundingHull(coords, out convexcoords, out convexfaces) && convexcoords != null && convexfaces != null)
+                {
+                    coords.Clear();
+                    coords = convexcoords;
+                    numCoords = coords.Count;
+
+                    faces.Clear();
+                    faces = convexfaces;
+                    numFaces = faces.Count;
+                }
+                else
+                     m_log.ErrorFormat("[ubMESH]: failed to create convex for {0} using normal mesh", primName);
+            }
+
             Mesh mesh = new Mesh(true);
             // Add the corresponding triangles to the mesh
             for (int i = 0; i < numFaces; i++)
@@ -371,10 +306,10 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
             faces.Clear();
 
             if(mesh.numberVertices() < 3 || mesh.numberTriangles() < 1)
-                {
-                m_log.ErrorFormat("[MESH]: invalid degenerated mesh for prim " + primName + " ignored");
+            {
+                m_log.ErrorFormat("[MESH]: invalid degenerated mesh for prim {0} ignored", primName);
                 return null;
-                }
+            }
 
             primShape.SculptData = Utils.EmptyBytes;
 
@@ -625,45 +560,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                                         vs.Clear();
                                         continue;
                                     }
-    /*
-                                    if (!HullUtils.ComputeHull(vs, ref hullr, 0, 0.0f))
-                                    {
-                                        vs.Clear();
-                                        continue;
-                                    }
 
-                                    nverts = hullr.Vertices.Count;
-                                    nindexs = hullr.Indices.Count;
-
-                                    if (nindexs % 3 != 0)
-                                    {
-                                        vs.Clear();
-                                        continue;
-                                    }
-
-                                    for (i = 0; i < nverts; i++)
-                                    {
-                                        c.X = hullr.Vertices[i].x;
-                                        c.Y = hullr.Vertices[i].y;
-                                        c.Z = hullr.Vertices[i].z;
-                                        coords.Add(c);
-                                    }
-
-                                    for (i = 0; i < nindexs; i += 3)
-                                    {
-                                        t1 = hullr.Indices[i];
-                                        if (t1 > nverts)
-                                            break;
-                                        t2 = hullr.Indices[i + 1];
-                                        if (t2 > nverts)
-                                            break;
-                                        t3 = hullr.Indices[i + 2];
-                                        if (t3 > nverts)
-                                            break;
-                                        f = new Face(vertsoffset + t1, vertsoffset + t2, vertsoffset + t3);
-                                        faces.Add(f);
-                                    }
-    */
                                     List<int> indices;
                                     if (!HullUtils.ComputeHull(vs, out indices))
                                     {
@@ -769,38 +666,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                             vs.Clear();
                             return true;
                         }
-/*
-                        if (!HullUtils.ComputeHull(vs, ref hullr, 0, 0.0f))
-                            return false;
-
-                        nverts = hullr.Vertices.Count;
-                        nindexs = hullr.Indices.Count;
-
-                        if (nindexs % 3 != 0)
-                            return false;
 
-                        for (i = 0; i < nverts; i++)
-                        {
-                            c.X = hullr.Vertices[i].x;
-                            c.Y = hullr.Vertices[i].y;
-                            c.Z = hullr.Vertices[i].z;
-                            coords.Add(c);
-                        }
-                        for (i = 0; i < nindexs; i += 3)
-                        {
-                            t1 = hullr.Indices[i];
-                            if (t1 > nverts)
-                                break;
-                            t2 = hullr.Indices[i + 1];
-                            if (t2 > nverts)
-                                break;
-                            t3 = hullr.Indices[i + 2];
-                            if (t3 > nverts)
-                                break;
-                            f = new Face(t1, t2, t3);
-                            faces.Add(f);
-                        }
-*/
                         List<int> indices;
                         if (!HullUtils.ComputeHull(vs, out indices))
                             return false;
@@ -1413,7 +1279,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
             }
         }
 
-        public void FileNames(AMeshKey key, out string dir,out string fullFileName)
+        public void FileNames(AMeshKey key, out string dir, out string fullFileName)
         {
             string id = key.ToString();
             string init = id.Substring(0, 1);
@@ -1530,7 +1396,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
             if (!doCacheExpire)
                 return;
 
-            string controlfile = System.IO.Path.Combine(cachePath, "cntr");
+            string controlfile = System.IO.Path.Combine(cachePath, cacheControlFilename);
 
             lock (diskLock)
             {
@@ -1583,5 +1449,153 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                 catch { }
             }
         }
+
+        public bool checkCache()
+        {
+            string controlfile = System.IO.Path.Combine(cachePath, cacheControlFilename);
+            lock (diskLock)
+            {
+                try
+                {
+                    if (!Directory.Exists(cachePath))
+                    {
+                        Directory.CreateDirectory(cachePath);
+                        Thread.Sleep(100);
+                        FileStream fs = File.Create(controlfile, 4096, FileOptions.WriteThrough);
+                        fs.Close();
+                        return true;
+                    }
+                }
+                catch
+                {
+                    doMeshFileCache = false;
+                    doCacheExpire = false;
+                    return false;
+                }
+                finally {}
+
+                if (File.Exists(controlfile))
+                    return true;
+
+                try
+                {
+                    Directory.Delete(cachePath, true);
+                    while(Directory.Exists(cachePath))
+                        Thread.Sleep(100);
+                }
+                catch(Exception e)
+                {
+                    m_log.Error("[MESH CACHE]: failed to delete old version of the cache: " + e.Message);
+                    doMeshFileCache = false;
+                    doCacheExpire = false;
+                    return false;
+                } 
+                finally {}
+                try
+                {
+                    Directory.CreateDirectory(cachePath);
+                    while(!Directory.Exists(cachePath))
+                        Thread.Sleep(100);
+                }
+                catch(Exception e)
+                {
+                    m_log.Error("[MESH CACHE]: failed to create new cache folder: " + e.Message);
+                    doMeshFileCache = false;
+                    doCacheExpire = false;
+                    return false;
+                } 
+                finally {}
+
+                try
+                {
+                    FileStream fs = File.Create(controlfile, 4096, FileOptions.WriteThrough);
+                    fs.Close();
+                }
+                catch(Exception e)
+                {
+                    m_log.Error("[MESH CACHE]: failed to create new control file: " + e.Message);
+                    doMeshFileCache = false;
+                    doCacheExpire = false;
+                    return false;
+                } 
+                finally {}
+            
+                return true;
+            }
+        }
+
+        public bool CreateBoundingHull(List<Coord> inputVertices, out List<Coord> convexcoords, out List<Face> newfaces)
+        {
+            convexcoords = null;
+            newfaces = null;
+            HullDesc desc = new HullDesc();
+            HullResult result = new HullResult();
+
+            int nInputVerts = inputVertices.Count;
+            int i;
+
+            List<float3> vs = new List<float3>(nInputVerts);
+            float3 f3;
+
+            //useless copy
+            for(i = 0 ; i < nInputVerts; i++)
+            {
+                f3 = new float3(inputVertices[i].X, inputVertices[i].Y, inputVertices[i].Z);
+                vs.Add(f3);
+            }
+
+            desc.Vertices = vs;
+            desc.Flags = HullFlag.QF_TRIANGLES;
+            desc.MaxVertices = 256;
+
+            try
+            {
+                HullError ret = HullUtils.CreateConvexHull(desc, ref result);
+                if (ret != HullError.QE_OK)
+                    return false;
+                int nverts = result.OutputVertices.Count;
+                int nindx = result.Indices.Count;
+                if(nverts < 3 || nindx< 3)
+                    return false;
+                if(nindx % 3 != 0)
+                    return false;
+
+                convexcoords = new List<Coord>(nverts);
+                Coord c;
+                vs = result.OutputVertices;
+
+                for(i = 0 ; i < nverts; i++)
+                {
+                    c = new Coord(vs[i].x, vs[i].y, vs[i].z);
+                    convexcoords.Add(c);
+                }
+
+                newfaces = new List<Face>(nindx / 3);
+                List<int> indxs = result.Indices;
+                int k, l, m;
+                Face f;
+                for(i = 0 ; i < nindx;)
+                {
+                    k = indxs[i++];
+                    l = indxs[i++];
+                    m = indxs[i++];
+                    if(k > nInputVerts)
+                        continue;
+                    if(l > nInputVerts)
+                        continue;
+                    if(m > nInputVerts)
+                        continue;
+                    f = new Face(k,l,m);
+                    newfaces.Add(f);
+                }
+                return true;
+            }
+            catch
+            {
+
+                return false;
+            }
+            return false;
+        }
     }
 }