5 files changed, 1442 insertions, 820 deletions

diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs
index c363310..f5bf05d 100644
--- a/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs
@@ -172,7 +172,6 @@ namespace OpenSim.Region.Physics.OdePlugin
             // force lower density for testing
             m_density = 3.0f;
 
-
             mu = parent_scene.AvatarFriction;
 
             walkDivisor = walk_divisor;
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODEMeshWorker.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODEMeshWorker.cs
new file mode 100644
index 0000000..73dd2fd
--- /dev/null
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODEMeshWorker.cs
@@ -0,0 +1,931 @@
+/*
+ * AJLDuarte 2012
+ */
+
+using System;
+using System.Threading;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using OpenSim.Framework;
+using OpenSim.Region.Physics.Manager;
+using OdeAPI;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+
+namespace OpenSim.Region.Physics.OdePlugin
+{
+    public enum MeshState : byte
+    {
+        noNeed = 0,
+
+        loadingAsset = 1,
+
+        AssetOK = 0x0f,     // 00001111
+
+        NeedMask = 0x30,    // 00110000
+        needMesh = 0x10,    // 00010000 
+        needAsset = 0x20,   // 00100000
+
+        FailMask = 0xC0,    // 11000000
+        AssetFailed = 0x40, // 01000000
+        MeshFailed = 0x80,   // 10000000
+
+        MeshNoColide = FailMask | needAsset
+    }
+
+    public enum meshWorkerCmnds : byte
+    {
+        nop = 0,
+        addnew,
+        changefull,
+        changesize,
+        changeshapetype,
+        getmesh,
+    }
+
+    public class ODEPhysRepData
+    {
+        public PhysicsActor actor;
+        public PrimitiveBaseShape pbs;
+        public IMesh mesh;
+
+        public Vector3 size;
+        public Vector3 OBB;
+        public Vector3 OBBOffset;
+
+        public float volume;
+
+        public byte shapetype;
+        public bool hasOBB;
+        public bool hasMeshVolume;
+        public MeshState meshState;
+        public UUID? assetID;
+        public meshWorkerCmnds comand;
+    }
+
+    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;
+
+
+        private OpenSim.Framework.BlockingQueue<ODEPhysRepData> createqueue = new OpenSim.Framework.BlockingQueue<ODEPhysRepData>();
+        private bool m_running;
+
+        private Thread m_thread;
+
+        public ODEMeshWorker(OdeScene pScene, ILog pLog, IMesher pMesher, IConfig pConfig)
+        {
+            m_scene = pScene;
+            m_log = pLog;
+            m_mesher = pMesher;
+
+            if (pConfig != null)
+            {
+                forceSimplePrimMeshing = pConfig.GetBoolean("force_simple_prim_meshing", forceSimplePrimMeshing);
+                meshSculptedPrim = pConfig.GetBoolean("mesh_sculpted_prim", meshSculptedPrim);
+                meshSculptLOD = pConfig.GetFloat("mesh_lod", meshSculptLOD);
+                MeshSculptphysicalLOD = pConfig.GetFloat("mesh_physical_lod", MeshSculptphysicalLOD);
+            }
+            m_running = true;
+            m_thread = new Thread(DoWork);
+            m_thread.Start();
+        }
+
+        private void DoWork()
+        {
+            m_mesher.ExpireFileCache();
+
+            while(m_running)
+            {
+                 ODEPhysRepData nextRep = createqueue.Dequeue();
+                if(!m_running)
+                    return;
+                if (nextRep == null)
+                    continue;
+                if (m_scene.haveActor(nextRep.actor))
+                {
+                    switch (nextRep.comand)
+                    {
+                        case meshWorkerCmnds.changefull:
+                        case meshWorkerCmnds.changeshapetype:
+                        case meshWorkerCmnds.changesize:
+                            GetMesh(nextRep);
+                            if (CreateActorPhysRep(nextRep) && m_scene.haveActor(nextRep.actor))
+                                m_scene.AddChange(nextRep.actor, changes.PhysRepData, nextRep);
+                            break;
+                        case meshWorkerCmnds.getmesh:
+                            DoRepDataGetMesh(nextRep);
+                            break;
+                    }
+                }
+            }
+        }
+
+        public void Stop()
+        {
+            try
+            {
+                m_thread.Abort();
+                createqueue.Clear();
+            }
+            catch
+            {
+            }
+        }
+
+        public void ChangeActorPhysRep(PhysicsActor actor, PrimitiveBaseShape pbs,
+                                        Vector3 size, byte shapetype)
+        {
+            ODEPhysRepData repData = new ODEPhysRepData();
+            repData.actor = actor;
+            repData.pbs = pbs;
+            repData.size = size;
+            repData.shapetype = shapetype;
+
+            CheckMesh(repData);
+            CalcVolumeData(repData);
+            m_scene.AddChange(actor, changes.PhysRepData, repData);
+            return;
+        }
+
+        public ODEPhysRepData NewActorPhysRep(PhysicsActor actor, PrimitiveBaseShape pbs,
+                                        Vector3 size, byte shapetype)
+        {
+            ODEPhysRepData repData = new ODEPhysRepData();
+            repData.actor = actor;
+            repData.pbs = pbs;
+            repData.size = size;
+            repData.shapetype = shapetype;
+
+            CheckMesh(repData);
+            CalcVolumeData(repData);
+            m_scene.AddChange(actor, changes.AddPhysRep, repData);
+            return repData;
+        }
+
+        public void RequestMesh(ODEPhysRepData repData)
+        {
+            repData.mesh = null;
+
+            if (repData.meshState == MeshState.needAsset)
+            {
+                PrimitiveBaseShape pbs = repData.pbs;
+
+                // check if we got outdated
+
+                if (!pbs.SculptEntry || pbs.SculptTexture == UUID.Zero)
+                {
+                    repData.meshState = MeshState.noNeed;
+                    return;
+                }
+
+                repData.assetID = pbs.SculptTexture;
+                repData.meshState = MeshState.loadingAsset;
+
+                repData.comand = meshWorkerCmnds.getmesh;
+                createqueue.Enqueue(repData);
+            }
+        }
+
+        // creates and prepares a mesh to use and calls parameters estimation
+        public bool CreateActorPhysRep(ODEPhysRepData repData)
+        {
+            IMesh mesh = repData.mesh;
+
+            if (mesh != null)
+            {
+                IntPtr vertices, indices;
+                int vertexCount, indexCount;
+                int vertexStride, triStride;
+
+                mesh.getVertexListAsPtrToFloatArray(out vertices, out vertexStride, out vertexCount);
+                mesh.getIndexListAsPtrToIntArray(out indices, out triStride, out indexCount);
+
+                if (vertexCount == 0 || indexCount == 0)
+                {
+                    m_log.WarnFormat("[PHYSICS]: Invalid mesh data on prim {0} mesh UUID {1}",
+                        repData.actor.Name, repData.pbs.SculptTexture.ToString());
+                    repData.meshState = MeshState.MeshFailed;
+                    repData.hasOBB = false;
+                    repData.mesh = null;
+                    m_scene.mesher.ReleaseMesh(mesh);
+                }
+                else
+                {
+                    repData.OBBOffset = mesh.GetCentroid();
+                    repData.OBB = mesh.GetOBB();
+                    repData.hasOBB = true;
+                    mesh.releaseSourceMeshData();
+                }
+            }
+            CalcVolumeData(repData);
+            return true;
+        }
+
+        public void AssetLoaded(ODEPhysRepData repData)
+        {
+            if (m_scene.haveActor(repData.actor))
+            {
+                if (needsMeshing(repData.pbs)) // no need for pbs now?
+                {
+                    repData.comand = meshWorkerCmnds.changefull;
+                    createqueue.Enqueue(repData);
+                }
+            }
+            else
+                repData.pbs.SculptData = Utils.EmptyBytes;
+        }
+
+        public void DoRepDataGetMesh(ODEPhysRepData repData)
+        {
+            if (!repData.pbs.SculptEntry)
+                return;
+
+            if (repData.meshState != MeshState.loadingAsset)
+                return;
+
+            if (repData.assetID == null || repData.assetID == UUID.Zero)
+                return;
+
+            if (repData.assetID != repData.pbs.SculptTexture)
+                return;
+
+            // check if it is in cache
+            GetMesh(repData);
+            if (repData.meshState != MeshState.needAsset)
+            {
+                CreateActorPhysRep(repData);
+                m_scene.AddChange(repData.actor, changes.PhysRepData, repData);
+                return;
+            }
+
+            RequestAssetDelegate assetProvider = m_scene.RequestAssetMethod;
+            if (assetProvider == null)
+                return;
+            ODEAssetRequest asr = new ODEAssetRequest(this, assetProvider, repData, m_log);
+        }
+
+
+        /// <summary>
+        /// Routine to figure out if we need to mesh this prim with our mesher
+        /// </summary>
+        /// <param name="pbs"></param>
+        /// <returns></returns>
+        public bool needsMeshing(PrimitiveBaseShape pbs)
+        {
+            // check sculpts or meshs 
+            if (pbs.SculptEntry)
+            {
+                if (meshSculptedPrim)
+                    return true;
+
+                if (pbs.SculptType == (byte)SculptType.Mesh) // always do meshs
+                    return true;
+
+                return false;
+            }
+
+            if (forceSimplePrimMeshing)
+                return true;
+
+            // if it's a standard box or sphere with no cuts, hollows, twist or top shear, return false since ODE can use an internal representation for the prim
+
+            if ((pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight)
+                    || (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1
+                    && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z))
+            {
+
+                if (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0
+                    && pbs.ProfileHollow == 0
+                    && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0
+                    && pbs.PathBegin == 0 && pbs.PathEnd == 0
+                    && pbs.PathTaperX == 0 && pbs.PathTaperY == 0
+                    && pbs.PathScaleX == 100 && pbs.PathScaleY == 100
+                    && pbs.PathShearX == 0 && pbs.PathShearY == 0)
+                {
+                    return false;
+                }
+            }
+
+            //  following code doesn't give meshs to boxes and spheres ever
+            // and it's odd..  so for now just return true if asked to force meshs
+            // hopefully mesher will fail if doesn't suport so things still get basic boxes
+
+            int iPropertiesNotSupportedDefault = 0;
+
+            if (pbs.ProfileHollow != 0)
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathBegin != 0) || pbs.PathEnd != 0)
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0))
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0)
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathScaleX != 100) || (pbs.PathScaleY != 100))
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathShearX != 0) || (pbs.PathShearY != 0))
+                iPropertiesNotSupportedDefault++;
+
+            if (pbs.ProfileShape == ProfileShape.Circle && pbs.PathCurve == (byte)Extrusion.Straight)
+                iPropertiesNotSupportedDefault++;
+
+            if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1 && (pbs.Scale.X != pbs.Scale.Y || pbs.Scale.Y != pbs.Scale.Z || pbs.Scale.Z != pbs.Scale.X))
+                iPropertiesNotSupportedDefault++;
+
+            if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1)
+                iPropertiesNotSupportedDefault++;
+
+            // test for torus
+            if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Square)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Curve1)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Straight)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+
+                // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits
+                else if (pbs.PathCurve == (byte)Extrusion.Curve1)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Straight)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+                else if (pbs.PathCurve == (byte)Extrusion.Curve1)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+
+            if (iPropertiesNotSupportedDefault == 0)
+            {
+                return false;
+            }
+            return true;
+        }
+
+        // see if we need a mesh and if so if we have a cached one
+        // called with a new repData
+        public void CheckMesh(ODEPhysRepData repData)
+        {
+            PhysicsActor actor = repData.actor;
+            PrimitiveBaseShape pbs = repData.pbs;
+
+            if (!needsMeshing(pbs))
+            {
+                repData.meshState = MeshState.noNeed;
+                return;
+            }
+
+            IMesh mesh = null;
+
+            Vector3 size = repData.size;
+            byte shapetype = repData.shapetype;
+
+            bool convex;
+
+            int clod = (int)LevelOfDetail.High;
+            if (shapetype == 0)
+                convex = false;
+            else
+            {
+                convex = true;
+                if (pbs.SculptType != (byte)SculptType.Mesh)
+                    clod = (int)LevelOfDetail.Low;
+            }
+
+            mesh = m_mesher.GetMesh(actor.Name, pbs, size, clod, true, convex);
+
+            if (mesh == null)
+            {
+                if (pbs.SculptEntry)
+                {
+                    if (pbs.SculptTexture != null && pbs.SculptTexture != UUID.Zero)
+                    {
+                        repData.assetID = pbs.SculptTexture;
+                        repData.meshState = MeshState.needAsset;
+                    }
+                    else
+                        repData.meshState = MeshState.MeshFailed;
+
+                    return;
+                }
+                else
+                {
+                    repData.meshState = MeshState.needMesh;
+                    mesh = m_mesher.CreateMesh(actor.Name, pbs, size, clod, true, convex, true);
+                    if (mesh == null)
+                    {
+                        repData.meshState = MeshState.MeshFailed;
+                        return;
+                    }
+                }               
+            }
+
+            repData.meshState = MeshState.AssetOK;
+            repData.mesh = mesh;
+
+            if (pbs.SculptEntry)
+            {
+                repData.assetID = pbs.SculptTexture;
+            }
+
+            pbs.SculptData = Utils.EmptyBytes;
+            return ;
+        }
+
+        public void GetMesh(ODEPhysRepData repData)
+        {
+            PhysicsActor actor = repData.actor;
+
+            PrimitiveBaseShape pbs = repData.pbs;
+
+            repData.mesh = null;
+            repData.hasOBB = false;
+
+            if (!needsMeshing(pbs))
+            {
+                repData.meshState = MeshState.noNeed;
+                return;
+            }
+
+            if (repData.meshState == MeshState.MeshFailed)
+                return;
+
+            if (pbs.SculptEntry)
+            {
+                if (repData.meshState == MeshState.AssetFailed)
+                {
+                    if (pbs.SculptTexture == repData.assetID)
+                        return;
+                }
+            }
+
+            repData.meshState = MeshState.noNeed;
+
+            IMesh mesh = null;
+            Vector3 size = repData.size;
+            byte shapetype = repData.shapetype;
+
+            bool convex;
+            int clod = (int)LevelOfDetail.High;
+            if (shapetype == 0)
+                convex = false;
+            else
+            {
+                convex = true;
+                if (pbs.SculptType != (byte)SculptType.Mesh)
+                    clod = (int)LevelOfDetail.Low;
+            }
+
+            mesh = m_mesher.CreateMesh(actor.Name, pbs, size, clod, true, convex, true);
+   
+            if (mesh == null)
+            {
+                if (pbs.SculptEntry)
+                {
+                    if (pbs.SculptTexture == UUID.Zero)
+                        return;
+
+                    repData.assetID = pbs.SculptTexture;
+
+                    if (pbs.SculptData == null || pbs.SculptData.Length == 0)
+                    {
+                        repData.meshState = MeshState.needAsset;
+                        return;
+                    }
+                }
+            }
+
+            repData.mesh = mesh;
+            repData.pbs.SculptData = Utils.EmptyBytes;
+
+            if (mesh == null)
+            {
+                if (pbs.SculptEntry)
+                    repData.meshState = MeshState.AssetFailed;
+                else
+                    repData.meshState = MeshState.MeshFailed;
+
+                return;
+            }
+
+            repData.meshState = MeshState.AssetOK;
+
+            return;
+        }
+
+        private void CalculateBasicPrimVolume(ODEPhysRepData repData)
+        {
+            PrimitiveBaseShape _pbs = repData.pbs;
+            Vector3 _size = repData.size;
+
+            float volume = _size.X * _size.Y * _size.Z; // default
+            float tmp;
+
+            float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f;
+            float hollowVolume = hollowAmount * hollowAmount;
+
+            switch (_pbs.ProfileShape)
+            {
+                case ProfileShape.Square:
+                    // default box
+
+                    if (_pbs.PathCurve == (byte)Extrusion.Straight)
+                    {
+                        if (hollowAmount > 0.0)
+                        {
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Square:
+                                case HollowShape.Same:
+                                    break;
+
+                                case HollowShape.Circle:
+
+                                    hollowVolume *= 0.78539816339f;
+                                    break;
+
+                                case HollowShape.Triangle:
+
+                                    hollowVolume *= (0.5f * .5f);
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+
+                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                        //a tube 
+
+                        volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX);
+                        tmp = 1.0f - 2.0e-2f * (float)(200 - _pbs.PathScaleY);
+                        volume -= volume * tmp * tmp;
+
+                        if (hollowAmount > 0.0)
+                        {
+                            hollowVolume *= hollowAmount;
+
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Square:
+                                case HollowShape.Same:
+                                    break;
+
+                                case HollowShape.Circle:
+                                    hollowVolume *= 0.78539816339f;
+                                    break;
+
+                                case HollowShape.Triangle:
+                                    hollowVolume *= 0.5f * 0.5f;
+                                    break;
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+
+                    break;
+
+                case ProfileShape.Circle:
+
+                    if (_pbs.PathCurve == (byte)Extrusion.Straight)
+                    {
+                        volume *= 0.78539816339f; // elipse base
+
+                        if (hollowAmount > 0.0)
+                        {
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Same:
+                                case HollowShape.Circle:
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.5f * 2.5984480504799f;
+                                    break;
+
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .5f * 1.27323954473516f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+
+                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                        volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - _pbs.PathScaleX);
+                        tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
+                        volume *= (1.0f - tmp * tmp);
+
+                        if (hollowAmount > 0.0)
+                        {
+
+                            // calculate the hollow volume by it's shape compared to the prim shape
+                            hollowVolume *= hollowAmount;
+
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Same:
+                                case HollowShape.Circle:
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.5f * 2.5984480504799f;
+                                    break;
+
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .5f * 1.27323954473516f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+                    break;
+
+                case ProfileShape.HalfCircle:
+                    if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                        volume *= 0.5236f;
+
+                        if (hollowAmount > 0.0)
+                        {
+                            hollowVolume *= hollowAmount;
+
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Circle:
+                                case HollowShape.Triangle:  // diference in sl is minor and odd
+                                case HollowShape.Same:
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.909f;
+                                    break;
+
+                                //                                case HollowShape.Triangle:
+                                //                                    hollowVolume *= .827f;
+                                //                                    break;
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+
+                    }
+                    break;
+
+                case ProfileShape.EquilateralTriangle:
+
+                    if (_pbs.PathCurve == (byte)Extrusion.Straight)
+                    {
+                        volume *= 0.32475953f;
+
+                        if (hollowAmount > 0.0)
+                        {
+
+                            // calculate the hollow volume by it's shape compared to the prim shape
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Same:
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .25f;
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.499849f * 3.07920140172638f;
+                                    break;
+
+                                case HollowShape.Circle:
+                                    // Hollow shape is a perfect cyllinder in respect to the cube's scale
+                                    // Cyllinder hollow volume calculation
+
+                                    hollowVolume *= 0.1963495f * 3.07920140172638f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                        volume *= 0.32475953f;
+                        volume *= 0.01f * (float)(200 - _pbs.PathScaleX);
+                        tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
+                        volume *= (1.0f - tmp * tmp);
+
+                        if (hollowAmount > 0.0)
+                        {
+
+                            hollowVolume *= hollowAmount;
+
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Same:
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .25f;
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.499849f * 3.07920140172638f;
+                                    break;
+
+                                case HollowShape.Circle:
+
+                                    hollowVolume *= 0.1963495f * 3.07920140172638f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+
+            float taperX1;
+            float taperY1;
+            float taperX;
+            float taperY;
+            float pathBegin;
+            float pathEnd;
+            float profileBegin;
+            float profileEnd;
+
+            if (_pbs.PathCurve == (byte)Extrusion.Straight || _pbs.PathCurve == (byte)Extrusion.Flexible)
+            {
+                taperX1 = _pbs.PathScaleX * 0.01f;
+                if (taperX1 > 1.0f)
+                    taperX1 = 2.0f - taperX1;
+                taperX = 1.0f - taperX1;
+
+                taperY1 = _pbs.PathScaleY * 0.01f;
+                if (taperY1 > 1.0f)
+                    taperY1 = 2.0f - taperY1;
+                taperY = 1.0f - taperY1;
+            }
+            else
+            {
+                taperX = _pbs.PathTaperX * 0.01f;
+                if (taperX < 0.0f)
+                    taperX = -taperX;
+                taperX1 = 1.0f - taperX;
+
+                taperY = _pbs.PathTaperY * 0.01f;
+                if (taperY < 0.0f)
+                    taperY = -taperY;
+                taperY1 = 1.0f - taperY;
+            }
+
+            volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY);
+
+            pathBegin = (float)_pbs.PathBegin * 2.0e-5f;
+            pathEnd = 1.0f - (float)_pbs.PathEnd * 2.0e-5f;
+            volume *= (pathEnd - pathBegin);
+
+            // this is crude aproximation
+            profileBegin = (float)_pbs.ProfileBegin * 2.0e-5f;
+            profileEnd = 1.0f - (float)_pbs.ProfileEnd * 2.0e-5f;
+            volume *= (profileEnd - profileBegin);           
+
+            repData.volume = volume;
+        }
+
+        private void CalcVolumeData(ODEPhysRepData repData)
+        {
+            if (repData.hasOBB)
+            {
+                Vector3 OBB = repData.OBB;
+            }
+            else
+            {
+                Vector3 OBB = repData.size;
+                OBB.X *= 0.5f;
+                OBB.Y *= 0.5f;
+                OBB.Z *= 0.5f;
+
+                repData.OBB = OBB;
+                repData.OBBOffset = Vector3.Zero;
+            }
+
+            CalculateBasicPrimVolume(repData);
+        }
+    }
+
+    public class ODEAssetRequest
+    {
+        ODEMeshWorker m_worker;
+        private ILog m_log;
+        ODEPhysRepData repData;
+
+        public ODEAssetRequest(ODEMeshWorker pWorker, RequestAssetDelegate provider,
+            ODEPhysRepData pRepData, ILog plog)
+        {
+            m_worker = pWorker;
+            m_log = plog;
+            repData = pRepData;
+
+            repData.meshState = MeshState.AssetFailed;
+            if (provider == null)
+                return;
+
+            if (repData.assetID == null)
+                return;
+
+            UUID assetID = (UUID) repData.assetID;
+            if (assetID == UUID.Zero)
+                return;
+
+            repData.meshState = MeshState.loadingAsset;
+            provider(assetID, ODEassetReceived);
+        }
+
+        void ODEassetReceived(AssetBase asset)
+        {
+            repData.meshState = MeshState.AssetFailed;
+            if (asset != null)
+            {
+                if (asset.Data != null && asset.Data.Length > 0)
+                {
+                    repData.meshState = MeshState.noNeed;
+
+                    if (!repData.pbs.SculptEntry)
+                        return;
+                    if (repData.pbs.SculptTexture != repData.assetID)
+                        return;
+
+                    repData.pbs.SculptData = new byte[asset.Data.Length];
+                    asset.Data.CopyTo(repData.pbs.SculptData,0);
+                    repData.meshState = MeshState.AssetOK;
+                    m_worker.AssetLoaded(repData);
+                }
+                else
+                    m_log.WarnFormat("[PHYSICS]: asset provider returned invalid mesh data for prim {0} asset UUID {1}.",
+                        repData.actor.Name, asset.ID.ToString());
+            }
+            else
+                m_log.WarnFormat("[PHYSICS]: asset provider returned null asset fo mesh of prim {0}.",
+                    repData.actor.Name);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs
index f2f4725..ce67cc4 100644
--- a/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs
@@ -79,7 +79,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         private bool m_lastdoneSelected;

         internal bool m_outbounds;

 

-        private Quaternion m_lastorientation = new Quaternion();

+        private Quaternion m_lastorientation;

         private Quaternion _orientation;

 

         private Vector3 _position;

@@ -91,33 +91,30 @@ namespace OpenSim.Region.Physics.OdePlugin
         private Vector3 _size;

         private Vector3 _acceleration;

         private Vector3 m_angularlock = Vector3.One;

-        private IntPtr Amotor = IntPtr.Zero;

+        private IntPtr Amotor;

 

         private Vector3 m_force;

         private Vector3 m_forceacc;

         private Vector3 m_angularForceacc;

 

-        private float m_invTimeStep = 50.0f;

-        private float m_timeStep = .02f;

+        private float m_invTimeStep;

+        private float m_timeStep;

 

         private Vector3 m_PIDTarget;

         private float m_PIDTau;

         private bool m_usePID;

 

-        // KF: These next 7 params apply to llSetHoverHeight(float height, integer water, float tau),

-        // and are for non-VEHICLES only.

-

         private float m_PIDHoverHeight;

         private float m_PIDHoverTau;

         private bool m_useHoverPID;

-        private PIDHoverType m_PIDHoverType = PIDHoverType.Ground;

+        private PIDHoverType m_PIDHoverType;

         private float m_targetHoverHeight;

         private float m_groundHeight;

         private float m_waterHeight;

         private float m_buoyancy;                //KF: m_buoyancy should be set by llSetBuoyancy() for non-vehicle. 

 

-        private int body_autodisable_frames = 5;

-        public int bodydisablecontrol = 0;

+        private int body_autodisable_frames;

+        public int bodydisablecontrol;

 

 

         // Default we're a Geometry

@@ -147,12 +144,16 @@ namespace OpenSim.Region.Physics.OdePlugin
         private IMesh m_mesh;

         private object m_meshlock = new object();

         private PrimitiveBaseShape _pbs;

+

+        private UUID? m_assetID;

+        private MeshState m_meshState;

+        

         public OdeScene _parent_scene;

 

         /// <summary>

         /// The physics space which contains prim geometry

         /// </summary>

-        public IntPtr m_targetSpace = IntPtr.Zero;

+        public IntPtr m_targetSpace;

 

         public IntPtr prim_geom;

         public IntPtr _triMeshData;

@@ -166,27 +167,32 @@ namespace OpenSim.Region.Physics.OdePlugin
 

         public IntPtr collide_geom; // for objects: geom if single prim space it linkset

 

-        private float m_density = 10.000006836f; // Aluminum g/cm3;

+        private float m_density;

         private byte m_shapetype;

         public bool _zeroFlag;

         private bool m_lastUpdateSent;

 

-        public IntPtr Body = IntPtr.Zero;

+        public IntPtr Body;

 

         private Vector3 _target_velocity;

 

-        public Vector3 primOOBsize; // prim real dimensions from mesh 

-        public Vector3 primOOBoffset; // its centroid out of mesh or rest aabb

+        public Vector3 m_OBBOffset;

+        public Vector3 m_OBB;

         public float primOOBradiusSQ;

+

+        private bool m_hasOBB = true;

+

+        private float m_physCost;

+        private float m_streamCost;

+

         public d.Mass primdMass; // prim inertia information on it's own referencial

         float primMass; // prim own mass

         float primVolume; // prim own volume;

         float _mass; // object mass acording to case

-        private bool hasOOBoffsetFromMesh = false; // if true we did compute it form mesh centroid, else from aabb

 

-        public int givefakepos = 0;

+        public int givefakepos;

         private Vector3 fakepos;

-        public int givefakeori = 0;

+        public int givefakeori;

         private Quaternion fakeori;

 

         private int m_eventsubscription;

@@ -271,7 +277,23 @@ namespace OpenSim.Region.Physics.OdePlugin
                     cdata.mu *= veh.FrictionFactor;

 //                    cdata.mu *= 0;

             }

-        }    

+        }

+

+        public override float PhysicsCost

+        {

+            get

+            {

+                return m_physCost;

+            }

+        }

+

+        public override float StreamCost

+        {

+            get

+            {

+                return m_streamCost;

+            }

+        }

 

         public override int PhysicsActorType

         {

@@ -394,7 +416,7 @@ namespace OpenSim.Region.Physics.OdePlugin
             {

                 if (value.IsFinite())

                 {

-                    AddChange(changes.Size, value);

+                     _parent_scene.m_meshWorker.ChangeActorPhysRep(this, _pbs, value, m_shapetype);

                 }

                 else

                 {

@@ -464,7 +486,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                         q.Z = dq.Z;

                         q.W = dq.W;

 

-                        Vector3 Ptot = primOOBoffset * q;

+                        Vector3 Ptot = m_OBBOffset * q;

                         dtmp = d.GeomGetPosition(prim_geom);

                         Ptot.X += dtmp.X;

                         Ptot.Y += dtmp.Y;

@@ -504,7 +526,7 @@ namespace OpenSim.Region.Physics.OdePlugin
             {

             get

                 {

-                return primOOBsize;

+                return m_OBB;

                 }

             }

 

@@ -512,7 +534,7 @@ namespace OpenSim.Region.Physics.OdePlugin
             {

             get

                 {

-                return primOOBoffset;

+                return m_OBBOffset;

                 }

             }

 

@@ -528,7 +550,8 @@ namespace OpenSim.Region.Physics.OdePlugin
         {

             set

             {

-                AddChange(changes.Shape, value);

+//                AddChange(changes.Shape, value);

+                _parent_scene.m_meshWorker.ChangeActorPhysRep(this, value, _size, m_shapetype);

             }

         }

 

@@ -541,11 +564,10 @@ namespace OpenSim.Region.Physics.OdePlugin
             set

             {

                 m_shapetype = value;

-                AddChange(changes.Shape, null);

+               _parent_scene.m_meshWorker.ChangeActorPhysRep(this, _pbs, _size, value);

             }

         }

 

-

         public override Vector3 Velocity

         {

             get

@@ -619,6 +641,9 @@ namespace OpenSim.Region.Physics.OdePlugin
                 {

                     fakeori = value;

                     givefakeori++;

+

+                    value.Normalize();

+

                     AddChange(changes.Orientation, value);

                 }

                 else

@@ -1012,7 +1037,6 @@ namespace OpenSim.Region.Physics.OdePlugin
             m_invTimeStep = 1f / m_timeStep;

 

             m_density = parent_scene.geomDefaultDensity;

-            // m_tensor = parent_scene.bodyMotorJointMaxforceTensor;

             body_autodisable_frames = parent_scene.bodyFramesAutoDisable;

 

             prim_geom = IntPtr.Zero;

@@ -1064,7 +1088,6 @@ namespace OpenSim.Region.Physics.OdePlugin
             m_colliderfilter = 0;

             m_NoColide = false;

 

-            hasOOBoffsetFromMesh = false;

             _triMeshData = IntPtr.Zero;

 

             m_shapetype = _shapeType;

@@ -1079,27 +1102,14 @@ namespace OpenSim.Region.Physics.OdePlugin
             mu = parent_scene.m_materialContactsData[(int)Material.Wood].mu;

             bounce = parent_scene.m_materialContactsData[(int)Material.Wood].bounce;

 

-            CalcPrimBodyData();

+            m_building = true; // control must set this to false when done

 

-            m_mesh = null;

-            if (_parent_scene.needsMeshing(pbs) && (pbs.SculptData.Length > 0))

-            {

-                bool convex;

-                int clod = (int)LevelOfDetail.High;

-                if (m_shapetype == 0)

-                    convex = false;

-                else

-                {

-                    convex = true;

-                    if (_pbs.SculptType != (byte)SculptType.Mesh)

-                        clod = (int)LevelOfDetail.Low;

-                }

-                m_mesh = _parent_scene.mesher.CreateMesh(Name, _pbs, _size, clod, true, convex);

-            }

+            // get basic mass parameters

+            ODEPhysRepData repData = _parent_scene.m_meshWorker.NewActorPhysRep(this, _pbs, _size, m_shapetype);

 

-            m_building = true; // control must set this to false when done

+            primVolume = repData.volume;

 

-            AddChange(changes.Add, null);

+            UpdatePrimBodyData();

         }

 

         private void resetCollisionAccounting()

@@ -1323,76 +1333,88 @@ namespace OpenSim.Region.Physics.OdePlugin
             }

         }

 

-        private bool setMesh(OdeScene parent_scene)

-        {

-            IntPtr vertices, indices;

-            int vertexCount, indexCount;

-            int vertexStride, triStride;

 

-            if (Body != IntPtr.Zero)

+        private void SetGeom(IntPtr geom)

+        {

+            prim_geom = geom;

+            //Console.WriteLine("SetGeom to " + prim_geom + " for " + Name);

+            if (prim_geom != IntPtr.Zero)

             {

-                if (childPrim)

+

+                if (m_NoColide)

                 {

-                    if (_parent != null)

+                    d.GeomSetCategoryBits(prim_geom, 0);

+                    if (m_isphysical)

                     {

-                        OdePrim parent = (OdePrim)_parent;

-                        parent.ChildDelink(this, false);

+                        d.GeomSetCollideBits(prim_geom, (uint)CollisionCategories.Land);

+                    }

+                    else

+                    {

+                        d.GeomSetCollideBits(prim_geom, 0);

+                        d.GeomDisable(prim_geom);

                     }

                 }

                 else

                 {

-                    DestroyBody();

+                    d.GeomSetCategoryBits(prim_geom, (uint)m_collisionCategories);

+                    d.GeomSetCollideBits(prim_geom, (uint)m_collisionFlags);

                 }

-            }

 

-            IMesh mesh = null;

+                UpdatePrimBodyData();

+                _parent_scene.actor_name_map[prim_geom] = this;

 

-            lock (m_meshlock)

-            {

-                if (m_mesh == null)

-                {

-                    bool convex;

-                    int clod = (int)LevelOfDetail.High;

+/*

+// debug

+                d.AABB aabb;

+                d.GeomGetAABB(prim_geom, out aabb);

+                float x = aabb.MaxX - aabb.MinX;

+                float y = aabb.MaxY - aabb.MinY;

+                float z = aabb.MaxZ - aabb.MinZ;

+                if( x > 60.0f || y > 60.0f || z > 60.0f)

+                    m_log.WarnFormat("[PHYSICS]: large prim geo {0},size {1}, AABBsize <{2},{3},{4}, mesh {5} at {6}",

+                        Name, _size.ToString(), x, y, z, _pbs.SculptEntry ? _pbs.SculptTexture.ToString() : "primMesh", _position.ToString());

+                else if (x < 0.001f || y < 0.001f || z < 0.001f)

+                    m_log.WarnFormat("[PHYSICS]: small prim geo {0},size {1}, AABBsize <{2},{3},{4}, mesh {5} at {6}",

+                        Name, _size.ToString(), x, y, z, _pbs.SculptEntry ? _pbs.SculptTexture.ToString() : "primMesh", _position.ToString());

+

+//

+*/

 

-                    if (m_shapetype == 0)

-                        convex = false;

-                    else

-                    {

-                        convex = true;

-                        if (_pbs.SculptType != (byte)SculptType.Mesh)

-                            clod = (int)LevelOfDetail.Low;

-                    }

+            }

+            else

+                m_log.Warn("Setting bad Geom");

+        }

 

-                    mesh = _parent_scene.mesher.CreateMesh(Name, _pbs, _size, clod, true, convex);

-                }

-                else

-                {

-                    mesh = m_mesh;

-                }

+        private bool GetMeshGeom()

+        {

+            IntPtr vertices, indices;

+            int vertexCount, indexCount;

+            int vertexStride, triStride;

+            

+            IMesh mesh = m_mesh;

 

-                if (mesh == null)

-                {                  

-                    m_log.WarnFormat("[PHYSICS]: CreateMesh Failed on prim {0} at <{1},{2},{3}>.", Name, _position.X, _position.Y, _position.Z);

-                    return false;

-                }

+            if (mesh == null)

+                return false;

 

+            mesh.getVertexListAsPtrToFloatArray(out vertices, out vertexStride, out vertexCount);

+            mesh.getIndexListAsPtrToIntArray(out indices, out triStride, out indexCount);

 

-                mesh.getVertexListAsPtrToFloatArray(out vertices, out vertexStride, out vertexCount); // Note, that vertices are fixed in unmanaged heap

-                mesh.getIndexListAsPtrToIntArray(out indices, out triStride, out indexCount); // Also fixed, needs release after usage

+            if (vertexCount == 0 || indexCount == 0)

+            {

+                m_log.WarnFormat("[PHYSICS]: Invalid mesh data on OdePrim {0}, mesh {1}",

+                    Name, _pbs.SculptEntry ? _pbs.SculptTexture.ToString() : "primMesh");

 

-                if (vertexCount == 0 || indexCount == 0)

-                {

-                    m_log.WarnFormat("[PHYSICS]: Got invalid mesh on prim {0} at <{1},{2},{3}>. mesh UUID {4}",

-                        Name, _position.X, _position.Y, _position.Z, _pbs.SculptTexture.ToString());

-                    mesh.releaseSourceMeshData();

-                    return false;

-                }

+                m_hasOBB = false;

+                m_OBBOffset = Vector3.Zero;

+                m_OBB = _size * 0.5f;

 

-                primOOBoffset = mesh.GetCentroid();

-                hasOOBoffsetFromMesh = true;

+                m_physCost = 0.1f;

+                m_streamCost = 1.0f;

 

-                mesh.releaseSourceMeshData();

-                m_mesh = mesh;

+                _parent_scene.mesher.ReleaseMesh(mesh);

+                m_meshState = MeshState.MeshFailed;

+                m_mesh = null;

+                return false;

             }

 

             IntPtr geo = IntPtr.Zero;

@@ -1404,7 +1426,6 @@ namespace OpenSim.Region.Physics.OdePlugin
                 d.GeomTriMeshDataBuildSimple(_triMeshData, vertices, vertexStride, vertexCount, indices, indexCount, triStride);

                 d.GeomTriMeshDataPreprocess(_triMeshData);

 

-                _parent_scene.waitForSpaceUnlock(m_targetSpace);

                 geo = d.CreateTriMesh(m_targetSpace, _triMeshData, null, null, null);

             }

 

@@ -1413,85 +1434,65 @@ namespace OpenSim.Region.Physics.OdePlugin
                 m_log.ErrorFormat("[PHYSICS]: SetGeom Mesh failed for {0} exception: {1}", Name, e);

                 if (_triMeshData != IntPtr.Zero)

                 {

-                    d.GeomTriMeshDataDestroy(_triMeshData);

-                    _triMeshData = IntPtr.Zero;

-                }

-                return false;

-            }

-

-            SetGeom(geo);

-            return true;

-        }

-

-        private void SetGeom(IntPtr geom)

-        {

-            prim_geom = geom;

-            //Console.WriteLine("SetGeom to " + prim_geom + " for " + Name);

-            if (prim_geom != IntPtr.Zero)

-            {

-

-                if (m_NoColide)

-                {

-                    d.GeomSetCategoryBits(prim_geom, 0);

-                    if (m_isphysical)

+                    try

                     {

-                        d.GeomSetCollideBits(prim_geom, (uint)CollisionCategories.Land);

+                        d.GeomTriMeshDataDestroy(_triMeshData);

                     }

-                    else

+                    catch

                     {

-                        d.GeomSetCollideBits(prim_geom, 0);

-                        d.GeomDisable(prim_geom);

                     }

                 }

-                else

-                {

-                    d.GeomSetCategoryBits(prim_geom, (uint)m_collisionCategories);

-                    d.GeomSetCollideBits(prim_geom, (uint)m_collisionFlags);

-                }

+                _triMeshData = IntPtr.Zero;

 

-                CalcPrimBodyData();

+                m_hasOBB = false;

+                m_OBBOffset = Vector3.Zero;

+                m_OBB = _size * 0.5f;

+                m_physCost = 0.1f;

+                m_streamCost = 1.0f;

+              

+                _parent_scene.mesher.ReleaseMesh(mesh);

+                m_meshState = MeshState.MeshFailed;

+                m_mesh = null;

+                return false;

+            }

 

-                _parent_scene.actor_name_map[prim_geom] = this;

+            m_physCost = 0.0013f * (float)indexCount;

+            // todo

+            m_streamCost = 1.0f;

 

-            }

-            else

-                m_log.Warn("Setting bad Geom");

-        }

+            SetGeom(geo);

 

+            return true;

+        }

 

-        /// <summary>

-        /// Create a geometry for the given mesh in the given target space.

-        /// </summary>

-        /// <param name="m_targetSpace"></param>

-        /// <param name="mesh">If null, then a mesh is used that is based on the profile shape data.</param>

         private void CreateGeom()

         {

-            if (_triMeshData != IntPtr.Zero)

-            {

-                d.GeomTriMeshDataDestroy(_triMeshData);

-                _triMeshData = IntPtr.Zero;

-            }

+            bool hasMesh = false;

 

-            bool haveMesh = false;

-            hasOOBoffsetFromMesh = false;

             m_NoColide = false;

 

-            if (_parent_scene.needsMeshing(_pbs))

+            if ((m_meshState & MeshState.MeshNoColide) != 0)

+                m_NoColide = true;

+

+            else if(m_mesh != null)

             {

-                haveMesh = setMesh(_parent_scene); // this will give a mesh to non trivial known prims

-                if (!haveMesh)

+                if (GetMeshGeom())

+                    hasMesh = true;

+                else

                     m_NoColide = true;

             }

 

-            if (!haveMesh)

+

+            if (!hasMesh)

             {

+                IntPtr geo = IntPtr.Zero;

+

                 if (_pbs.ProfileShape == ProfileShape.HalfCircle && _pbs.PathCurve == (byte)Extrusion.Curve1

                     && _size.X == _size.Y && _size.Y == _size.Z)

                 { // it's a sphere

-                    _parent_scene.waitForSpaceUnlock(m_targetSpace);

                     try

                     {

-                        SetGeom(d.CreateSphere(m_targetSpace, _size.X * 0.5f));

+                        geo = d.CreateSphere(m_targetSpace, _size.X * 0.5f);

                     }

                     catch (Exception e)

                     {

@@ -1501,11 +1502,9 @@ namespace OpenSim.Region.Physics.OdePlugin
                 }

                 else

                 {// do it as a box

-                    _parent_scene.waitForSpaceUnlock(m_targetSpace);

                     try

                     {

-                        //Console.WriteLine("  CreateGeom 4");

-                        SetGeom(d.CreateBox(m_targetSpace, _size.X, _size.Y, _size.Z));

+                        geo = d.CreateBox(m_targetSpace, _size.X, _size.Y, _size.Z);

                     }

                     catch (Exception e)

                     {

@@ -1513,19 +1512,18 @@ namespace OpenSim.Region.Physics.OdePlugin
                         return;

                     }

                 }

+                m_physCost = 0.1f;

+                m_streamCost = 1.0f;

+                SetGeom(geo);

             }

         }

 

-        /// <summary>

-        /// Set a new geometry for this prim.

-        /// </summary>

-        /// <param name="geom"></param>

         private void RemoveGeom()

         {

             if (prim_geom != IntPtr.Zero)

             {

-//                _parent_scene.geom_name_map.Remove(prim_geom);

                 _parent_scene.actor_name_map.Remove(prim_geom);

+

                 try

                 {

                     d.GeomDestroy(prim_geom);

@@ -1534,11 +1532,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                         d.GeomTriMeshDataDestroy(_triMeshData);

                         _triMeshData = IntPtr.Zero;

                     }

-

                 }

-

-

-                //                catch (System.AccessViolationException)

                 catch (Exception e)

                 {

                     m_log.ErrorFormat("[PHYSICS]: PrimGeom destruction failed for {0} exception {1}", Name, e);

@@ -1546,29 +1540,26 @@ namespace OpenSim.Region.Physics.OdePlugin
 

                 prim_geom = IntPtr.Zero;

                 collide_geom = IntPtr.Zero;

+                m_targetSpace = IntPtr.Zero;

             }

             else

             {

                 m_log.ErrorFormat("[PHYSICS]: PrimGeom destruction BAD {0}", Name);

             }

 

-            if (m_mesh != null)

+            lock (m_meshlock)

             {

-                _parent_scene.mesher.ReleaseMesh(m_mesh);

-                m_mesh = null;

+                if (m_mesh != null)

+                {

+                    _parent_scene.mesher.ReleaseMesh(m_mesh);

+                    m_mesh = null;

+                }

             }

 

             Body = IntPtr.Zero;

-            hasOOBoffsetFromMesh = false;

+            m_hasOBB = false;

         }

-/*

-        private void ChildSetGeom(OdePrim odePrim)

-        {

-            // well.. 

-            DestroyBody();

-            MakeBody();

-        }

-*/

+

         //sets non physical prim m_targetSpace to right space in spaces grid for static prims

         // should only be called for non physical prims unless they are becoming non physical

         private void SetInStaticSpace(OdePrim prim)

@@ -1631,9 +1622,6 @@ namespace OpenSim.Region.Physics.OdePlugin
 

             if (Body != IntPtr.Zero)

             {

-//                d.BodyDestroy(Body);

-//                Body = IntPtr.Zero;

-                // do a more complet destruction

                 DestroyBody();

                 m_log.Warn("[PHYSICS]: MakeBody called having a body");

             }

@@ -2143,339 +2131,9 @@ namespace OpenSim.Region.Physics.OdePlugin
 

         #region Mass Calculation

 

-        private float CalculatePrimVolume()

+        private void UpdatePrimBodyData()

         {

-            float volume = _size.X * _size.Y * _size.Z; // default

-            float tmp;

-

-            float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f;

-            float hollowVolume = hollowAmount * hollowAmount;

-

-            switch (_pbs.ProfileShape)

-            {

-                case ProfileShape.Square:

-                    // default box

-

-                    if (_pbs.PathCurve == (byte)Extrusion.Straight)

-                    {

-                        if (hollowAmount > 0.0)

-                        {

-                            switch (_pbs.HollowShape)

-                            {

-                                case HollowShape.Square:

-                                case HollowShape.Same:

-                                    break;

-

-                                case HollowShape.Circle:

-

-                                    hollowVolume *= 0.78539816339f;

-                                    break;

-

-                                case HollowShape.Triangle:

-

-                                    hollowVolume *= (0.5f * .5f);

-                                    break;

-

-                                default:

-                                    hollowVolume = 0;

-                                    break;

-                            }

-                            volume *= (1.0f - hollowVolume);

-                        }

-                    }

-

-                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)

-                    {

-                        //a tube 

-

-                        volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX);

-                        tmp = 1.0f - 2.0e-2f * (float)(200 - _pbs.PathScaleY);

-                        volume -= volume * tmp * tmp;

-

-                        if (hollowAmount > 0.0)

-                        {

-                            hollowVolume *= hollowAmount;

-

-                            switch (_pbs.HollowShape)

-                            {

-                                case HollowShape.Square:

-                                case HollowShape.Same:

-                                    break;

-

-                                case HollowShape.Circle:

-                                    hollowVolume *= 0.78539816339f;

-                                    break;

-

-                                case HollowShape.Triangle:

-                                    hollowVolume *= 0.5f * 0.5f;

-                                    break;

-                                default:

-                                    hollowVolume = 0;

-                                    break;

-                            }

-                            volume *= (1.0f - hollowVolume);

-                        }

-                    }

-

-                    break;

-

-                case ProfileShape.Circle:

-

-                    if (_pbs.PathCurve == (byte)Extrusion.Straight)

-                    {

-                        volume *= 0.78539816339f; // elipse base

-

-                        if (hollowAmount > 0.0)

-                        {

-                            switch (_pbs.HollowShape)

-                            {

-                                case HollowShape.Same:

-                                case HollowShape.Circle:

-                                    break;

-

-                                case HollowShape.Square:

-                                    hollowVolume *= 0.5f * 2.5984480504799f;

-                                    break;

-

-                                case HollowShape.Triangle:

-                                    hollowVolume *= .5f * 1.27323954473516f;

-                                    break;

-

-                                default:

-                                    hollowVolume = 0;

-                                    break;

-                            }

-                            volume *= (1.0f - hollowVolume);

-                        }

-                    }

-

-                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)

-                    {

-                        volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - _pbs.PathScaleX);

-                        tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);

-                        volume *= (1.0f - tmp * tmp);

-

-                        if (hollowAmount > 0.0)

-                        {

-

-                            // calculate the hollow volume by it's shape compared to the prim shape

-                            hollowVolume *= hollowAmount;

-

-                            switch (_pbs.HollowShape)

-                            {

-                                case HollowShape.Same:

-                                case HollowShape.Circle:

-                                    break;

-

-                                case HollowShape.Square:

-                                    hollowVolume *= 0.5f * 2.5984480504799f;

-                                    break;

-

-                                case HollowShape.Triangle:

-                                    hollowVolume *= .5f * 1.27323954473516f;

-                                    break;

-

-                                default:

-                                    hollowVolume = 0;

-                                    break;

-                            }

-                            volume *= (1.0f - hollowVolume);

-                        }

-                    }

-                    break;

-

-                case ProfileShape.HalfCircle:

-                    if (_pbs.PathCurve == (byte)Extrusion.Curve1)

-                    {

-                        volume *= 0.5236f;

-

-                        if (hollowAmount > 0.0)

-                        {

-                            hollowVolume *= hollowAmount;

-

-                            switch (_pbs.HollowShape)

-                            {

-                                case HollowShape.Circle:

-                                case HollowShape.Triangle:  // diference in sl is minor and odd

-                                case HollowShape.Same:

-                                    break;

-

-                                case HollowShape.Square:

-                                    hollowVolume *= 0.909f;

-                                    break;

-

-                                //                                case HollowShape.Triangle:

-                                //                                    hollowVolume *= .827f;

-                                //                                    break;

-                                default:

-                                    hollowVolume = 0;

-                                    break;

-                            }

-                            volume *= (1.0f - hollowVolume);

-                        }

-

-                    }

-                    break;

-

-                case ProfileShape.EquilateralTriangle:

-

-                    if (_pbs.PathCurve == (byte)Extrusion.Straight)

-                    {

-                        volume *= 0.32475953f;

-

-                        if (hollowAmount > 0.0)

-                        {

-

-                            // calculate the hollow volume by it's shape compared to the prim shape

-                            switch (_pbs.HollowShape)

-                            {

-                                case HollowShape.Same:

-                                case HollowShape.Triangle:

-                                    hollowVolume *= .25f;

-                                    break;

-

-                                case HollowShape.Square:

-                                    hollowVolume *= 0.499849f * 3.07920140172638f;

-                                    break;

-

-                                case HollowShape.Circle:

-                                    // Hollow shape is a perfect cyllinder in respect to the cube's scale

-                                    // Cyllinder hollow volume calculation

-

-                                    hollowVolume *= 0.1963495f * 3.07920140172638f;

-                                    break;

-

-                                default:

-                                    hollowVolume = 0;

-                                    break;

-                            }

-                            volume *= (1.0f - hollowVolume);

-                        }

-                    }

-                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)

-                    {

-                        volume *= 0.32475953f;

-                        volume *= 0.01f * (float)(200 - _pbs.PathScaleX);

-                        tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);

-                        volume *= (1.0f - tmp * tmp);

-

-                        if (hollowAmount > 0.0)

-                        {

-

-                            hollowVolume *= hollowAmount;

-

-                            switch (_pbs.HollowShape)

-                            {

-                                case HollowShape.Same:

-                                case HollowShape.Triangle:

-                                    hollowVolume *= .25f;

-                                    break;

-

-                                case HollowShape.Square:

-                                    hollowVolume *= 0.499849f * 3.07920140172638f;

-                                    break;

-

-                                case HollowShape.Circle:

-

-                                    hollowVolume *= 0.1963495f * 3.07920140172638f;

-                                    break;

-

-                                default:

-                                    hollowVolume = 0;

-                                    break;

-                            }

-                            volume *= (1.0f - hollowVolume);

-                        }

-                    }

-                    break;

-

-                default:

-                    break;

-            }

-

-            float taperX1;

-            float taperY1;

-            float taperX;

-            float taperY;

-            float pathBegin;

-            float pathEnd;

-            float profileBegin;

-            float profileEnd;

-

-            if (_pbs.PathCurve == (byte)Extrusion.Straight || _pbs.PathCurve == (byte)Extrusion.Flexible)

-            {

-                taperX1 = _pbs.PathScaleX * 0.01f;

-                if (taperX1 > 1.0f)

-                    taperX1 = 2.0f - taperX1;

-                taperX = 1.0f - taperX1;

-

-                taperY1 = _pbs.PathScaleY * 0.01f;

-                if (taperY1 > 1.0f)

-                    taperY1 = 2.0f - taperY1;

-                taperY = 1.0f - taperY1;

-            }

-            else

-            {

-                taperX = _pbs.PathTaperX * 0.01f;

-                if (taperX < 0.0f)

-                    taperX = -taperX;

-                taperX1 = 1.0f - taperX;

-

-                taperY = _pbs.PathTaperY * 0.01f;

-                if (taperY < 0.0f)

-                    taperY = -taperY;

-                taperY1 = 1.0f - taperY;

-            }

-

-            volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY);

-

-            pathBegin = (float)_pbs.PathBegin * 2.0e-5f;

-            pathEnd = 1.0f - (float)_pbs.PathEnd * 2.0e-5f;

-            volume *= (pathEnd - pathBegin);

-

-            // this is crude aproximation

-            profileBegin = (float)_pbs.ProfileBegin * 2.0e-5f;

-            profileEnd = 1.0f - (float)_pbs.ProfileEnd * 2.0e-5f;

-            volume *= (profileEnd - profileBegin);

-

-            return volume;

-        }

-

-

-        private void CalcPrimBodyData()

-        {

-            float volume;

-

-            if (prim_geom == IntPtr.Zero)

-            {

-                // Ubit let's have a initial basic OOB

-                primOOBsize.X = _size.X;

-                primOOBsize.Y = _size.Y;

-                primOOBsize.Z = _size.Z;

-                primOOBoffset = Vector3.Zero;

-            }

-            else

-            {

-                d.AABB AABB;

-                d.GeomGetAABB(prim_geom, out AABB); // get the AABB from engine geom

-

-                primOOBsize.X = (AABB.MaxX - AABB.MinX);

-                primOOBsize.Y = (AABB.MaxY - AABB.MinY);

-                primOOBsize.Z = (AABB.MaxZ - AABB.MinZ);

-                if (!hasOOBoffsetFromMesh)

-                {

-                    primOOBoffset.X = (AABB.MaxX + AABB.MinX) * 0.5f;

-                    primOOBoffset.Y = (AABB.MaxY + AABB.MinY) * 0.5f;

-                    primOOBoffset.Z = (AABB.MaxZ + AABB.MinZ) * 0.5f;

-                }

-            }

-

-            // also its own inertia and mass

-            // keep using basic shape mass for now

-            volume = CalculatePrimVolume();

-

-            primVolume = volume;

-            primMass = m_density * volume;

+            primMass = m_density * primVolume;

 

             if (primMass <= 0)

                 primMass = 0.0001f;//ckrinke: Mass must be greater then zero.

@@ -2484,17 +2142,31 @@ namespace OpenSim.Region.Physics.OdePlugin
 

             _mass = primMass; // just in case

 

-            d.MassSetBoxTotal(out primdMass, primMass, primOOBsize.X, primOOBsize.Y, primOOBsize.Z);

+            d.MassSetBoxTotal(out primdMass, primMass, m_OBB.X, m_OBB.Y, m_OBB.Z);

 

             d.MassTranslate(ref primdMass,

-                                primOOBoffset.X,

-                                primOOBoffset.Y,

-                                primOOBoffset.Z);

+                                m_OBBOffset.X,

+                                m_OBBOffset.Y,

+                                m_OBBOffset.Z);

 

-            primOOBsize *= 0.5f; // let obb size be a corner coords

-            primOOBradiusSQ = primOOBsize.LengthSquared();

-        }

+            primOOBradiusSQ = m_OBB.LengthSquared();

 

+            if (_triMeshData != IntPtr.Zero)

+            {

+                float pc = m_physCost;

+                float psf = primOOBradiusSQ;

+                psf *= 1.33f * .2f;

+                pc *= psf;

+                if (pc < 0.1f)

+                    pc = 0.1f;

+

+                m_physCost = pc;

+            }

+            else

+                m_physCost = 0.1f;

+

+            m_streamCost = 1.0f;

+        }

 

         #endregion

 

@@ -2575,6 +2247,14 @@ namespace OpenSim.Region.Physics.OdePlugin
                 _orientation.Y = qtmp.Y;

                 _orientation.Z = qtmp.Z;

                 _orientation.W = qtmp.W;

+/*

+// Debug

+                float qlen = _orientation.Length();

+                if (qlen > 1.01f || qlen < 0.99)

+                    m_log.WarnFormat("[PHYSICS]: Got nonnorm quaternion from geom in Object {0} norm {1}", Name, qlen);

+//

+*/

+                _orientation.Normalize();

 

                 d.Vector3 lpos = d.GeomGetPosition(prim_geom);

                 _position.X = lpos.X;

@@ -2684,27 +2364,6 @@ namespace OpenSim.Region.Physics.OdePlugin
 

         private void changeadd()

         {

-            CreateGeom();

-

-            if (prim_geom != IntPtr.Zero)

-            {

-                d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);

-                d.Quaternion myrot = new d.Quaternion();

-                myrot.X = _orientation.X;

-                myrot.Y = _orientation.Y;

-                myrot.Z = _orientation.Z;

-                myrot.W = _orientation.W;

-                d.GeomSetQuaternion(prim_geom, ref myrot);

-

-                if (!m_isphysical)

-                {

-                    SetInStaticSpace(this);

-                    UpdateCollisionCatFlags();

-                    ApplyCollisionCatFlags();

-                }

-                else 

-                    MakeBody();

-            }

         }

 

         private void changeAngularLock(Vector3 newLock)

@@ -2774,6 +2433,9 @@ namespace OpenSim.Region.Physics.OdePlugin
                 _target_velocity = Vector3.Zero;

                 if (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)

                     m_vehicle.Stop();

+

+                _zeroFlag = false;

+                base.RequestPhysicsterseUpdate();

             }

 

             if (Body != IntPtr.Zero)

@@ -3148,7 +2810,63 @@ namespace OpenSim.Region.Physics.OdePlugin
             resetCollisionAccounting();

         }

 

-        private void changeprimsizeshape()

+        private void changeSize(Vector3 newSize)

+        {

+        }

+

+        private void changeShape(PrimitiveBaseShape newShape)

+        {

+        }

+

+        private void changeAddPhysRep(ODEPhysRepData repData)

+        {

+            _size = repData.size; //??

+            _pbs = repData.pbs;

+            m_shapetype = repData.shapetype;

+

+            m_mesh = repData.mesh;

+

+            m_assetID = repData.assetID;

+            m_meshState = repData.meshState;

+

+            m_hasOBB = repData.hasOBB;

+            m_OBBOffset = repData.OBBOffset;

+            m_OBB = repData.OBB;

+

+            primVolume = repData.volume;

+

+            CreateGeom();

+

+            if (prim_geom != IntPtr.Zero)

+            {

+                d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);

+                d.Quaternion myrot = new d.Quaternion();

+                myrot.X = _orientation.X;

+                myrot.Y = _orientation.Y;

+                myrot.Z = _orientation.Z;

+                myrot.W = _orientation.W;

+                d.GeomSetQuaternion(prim_geom, ref myrot);

+            }

+

+            if (!m_isphysical)

+            {

+                SetInStaticSpace(this);

+                UpdateCollisionCatFlags();

+                ApplyCollisionCatFlags();

+            }

+            else

+                MakeBody();

+

+            if ((m_meshState & MeshState.NeedMask) != 0)

+            {

+                repData.size = _size;

+                repData.pbs = _pbs;

+                repData.shapetype = m_shapetype;

+                _parent_scene.m_meshWorker.RequestMesh(repData);

+            }

+        }

+

+        private void changePhysRepData(ODEPhysRepData repData)

         {

             CheckDelaySelect();

 

@@ -3170,16 +2888,22 @@ namespace OpenSim.Region.Physics.OdePlugin
 

             RemoveGeom();

 

-            // we don't need to do space calculation because the client sends a position update also.

-            if (_size.X <= 0)

-                _size.X = 0.01f;

-            if (_size.Y <= 0)

-                _size.Y = 0.01f;

-            if (_size.Z <= 0)

-                _size.Z = 0.01f;

-            // Construction of new prim

+            _size = repData.size;

+            _pbs = repData.pbs;

+            m_shapetype = repData.shapetype;

 

-            CreateGeom();

+            m_mesh = repData.mesh;

+

+            m_assetID = repData.assetID;

+            m_meshState = repData.meshState;

+

+            m_hasOBB = repData.hasOBB;

+            m_OBBOffset = repData.OBBOffset;

+            m_OBB = repData.OBB;

+

+            primVolume = repData.volume;

+

+            CreateGeom();          

 

             if (prim_geom != IntPtr.Zero)

             {

@@ -3202,29 +2926,24 @@ namespace OpenSim.Region.Physics.OdePlugin
                     }

                 }

                 else

-                        MakeBody();

+                    MakeBody();

             }

-

             else

             {

+                SetInStaticSpace(this);

                 UpdateCollisionCatFlags();

                 ApplyCollisionCatFlags();

             }

 

             resetCollisionAccounting();

-        }

-

-        private void changeSize(Vector3 newSize)

-        {

-            _size = newSize;

-            changeprimsizeshape();

-        }

 

-        private void changeShape(PrimitiveBaseShape newShape)

-        {

-            if(newShape != null)

-                _pbs = newShape;

-            changeprimsizeshape();

+            if ((m_meshState & MeshState.NeedMask) != 0)

+            {

+                repData.size = _size;

+                repData.pbs = _pbs;

+                repData.shapetype = m_shapetype;

+                _parent_scene.m_meshWorker.RequestMesh(repData);

+            }

         }

 

         private void changeFloatOnWater(bool newval)

@@ -3891,7 +3610,7 @@ namespace OpenSim.Region.Physics.OdePlugin
 

         public bool DoAChange(changes what, object arg)

         {

-            if (prim_geom == IntPtr.Zero && what != changes.Add && what != changes.Remove)

+            if (prim_geom == IntPtr.Zero && what != changes.Add && what != changes.AddPhysRep && what != changes.Remove)

             {

                 return false;

             }

@@ -3902,6 +3621,11 @@ namespace OpenSim.Region.Physics.OdePlugin
                 case changes.Add:

                     changeadd();

                     break;

+

+                case changes.AddPhysRep:

+                    changeAddPhysRep((ODEPhysRepData)arg);

+                    break;

+

                 case changes.Remove:

                     //If its being removed, we don't want to rebuild the physical rep at all, so ignore this stuff...

                     //When we return true, it destroys all of the prims in the linkset anyway

@@ -3984,6 +3708,10 @@ namespace OpenSim.Region.Physics.OdePlugin
                     changeShape((PrimitiveBaseShape)arg);

                     break;

 

+                case changes.PhysRepData:

+                    changePhysRepData((ODEPhysRepData) arg);

+                    break;

+

                 case changes.CollidesWater:

                     changeFloatOnWater((bool)arg);

                     break;

@@ -4072,6 +3800,8 @@ namespace OpenSim.Region.Physics.OdePlugin
                     donullchange();

                     break;

 

+

+

                 default:

                     donullchange();

                     break;

diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODERayCastRequestManager.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODERayCastRequestManager.cs
index 21fe9c0..799a324 100644
--- a/OpenSim/Region/Physics/UbitOdePlugin/ODERayCastRequestManager.cs
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODERayCastRequestManager.cs
@@ -129,7 +129,7 @@ namespace OpenSim.Region.Physics.OdePlugin
             req.length = length;
             req.Normal = direction;
             req.Origin = position;
-            req.filter = RayFilterFlags.AllPrims;
+            req.filter = RayFilterFlags.AllPrims | RayFilterFlags.land;
 
             m_PendingRequests.Enqueue(req);
         }
@@ -288,7 +288,10 @@ namespace OpenSim.Region.Physics.OdePlugin
                             catflags |= CollisionCategories.Water;
 
                         if (catflags != 0)
+                        {
+                            d.GeomSetCollideBits(ray, (uint)catflags);
                             doSpaceRay(req);
+                        }
                     }
                     else
                     {
@@ -314,7 +317,8 @@ namespace OpenSim.Region.Physics.OdePlugin
         /// 
 
         private const RayFilterFlags FilterActiveSpace = RayFilterFlags.agent | RayFilterFlags.physical | RayFilterFlags.LSLPhanton;
-        private const RayFilterFlags FilterStaticSpace = RayFilterFlags.water | RayFilterFlags.land | RayFilterFlags.nonphysical | RayFilterFlags.LSLPhanton;
+//        private const RayFilterFlags FilterStaticSpace = RayFilterFlags.water | RayFilterFlags.land | RayFilterFlags.nonphysical | RayFilterFlags.LSLPhanton;
+        private const RayFilterFlags FilterStaticSpace = RayFilterFlags.water | RayFilterFlags.nonphysical | RayFilterFlags.LSLPhanton;
 
         private void doSpaceRay(ODERayRequest req)
         {
@@ -323,6 +327,16 @@ namespace OpenSim.Region.Physics.OdePlugin
                 d.SpaceCollide2(ray, m_scene.ActiveSpace, IntPtr.Zero, nearCallback);
             if ((CurrentRayFilter & FilterStaticSpace) != 0 && (m_contactResults.Count < CurrentMaxCount))
                 d.SpaceCollide2(ray, m_scene.StaticSpace, IntPtr.Zero, nearCallback);
+            if ((CurrentRayFilter & RayFilterFlags.land) != 0 && (m_contactResults.Count < CurrentMaxCount))
+            {
+                // current ode land to ray collisions is very bad
+                // so for now limit its range badly
+
+                if (req.length > 30.0f)
+                    d.GeomRaySetLength(ray, 30.0f);
+
+                d.SpaceCollide2(ray, m_scene.GroundSpace, IntPtr.Zero, nearCallback);
+            }
 
             if (req.callbackMethod is RaycastCallback)
             {
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs b/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
index f126644..b98f177 100644
--- a/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
+++ b/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
@@ -60,6 +60,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         public int lastframe;
     }
 
+
     // colision flags of things others can colide with
     // rays, sensors, probes removed since can't  be colided with
     // The top space where things are placed provided further selection
@@ -109,7 +110,7 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         light = 7 // compatibility with old viewers
     }
-
+    
     public enum changes : int
     {
         Add = 0,                // arg null. finishs the prim creation. should be used internally only ( to remove later ?)
@@ -147,6 +148,8 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         Size,
         Shape,
+        PhysRepData,
+        AddPhysRep,
 
         CollidesWater,
         VolumeDtc,
@@ -230,11 +233,6 @@ namespace OpenSim.Region.Physics.OdePlugin
         private float minimumGroundFlightOffset = 3f;
         public float maximumMassObject = 10000.01f;
 
-        public bool meshSculptedPrim = true;
-        public bool forceSimplePrimMeshing = false;
-
-        public float meshSculptLOD = 32;
-        public float MeshSculptphysicalLOD = 32;
 
         public float geomDefaultDensity = 10.000006836f;
 
@@ -302,6 +300,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         public IntPtr TopSpace; // the global space
         public IntPtr ActiveSpace; // space for active prims
         public IntPtr StaticSpace; // space for the static things around
+        public IntPtr GroundSpace; // space for ground
 
         // some speedup variables
         private int spaceGridMaxX;
@@ -313,7 +312,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         private IntPtr[] staticPrimspaceOffRegion;
 
         public Object OdeLock;
-        private static Object SimulationLock;
+        public static Object SimulationLock;
 
         public IMesher mesher;
 
@@ -328,7 +327,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         private PhysicsScene m_parentScene = null;
 
         private ODERayCastRequestManager m_rayCastManager;
-
+        public ODEMeshWorker m_meshWorker;
 
 /* maybe needed if ode uses tls
         private void checkThread()
@@ -361,6 +360,8 @@ namespace OpenSim.Region.Physics.OdePlugin
             nearCallback = near;
 
             m_rayCastManager = new ODERayCastRequestManager(this);
+            
+
             lock (OdeLock)
                 {
                 // Create the world and the first space
@@ -372,6 +373,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                     // now the major subspaces
                     ActiveSpace = d.HashSpaceCreate(TopSpace);
                     StaticSpace = d.HashSpaceCreate(TopSpace);
+                    GroundSpace = d.HashSpaceCreate(TopSpace);
                     }
                 catch
                     {
@@ -381,10 +383,12 @@ namespace OpenSim.Region.Physics.OdePlugin
                 d.HashSpaceSetLevels(TopSpace, -2, 8);
                 d.HashSpaceSetLevels(ActiveSpace, -2, 8);
                 d.HashSpaceSetLevels(StaticSpace, -2, 8);
+                d.HashSpaceSetLevels(GroundSpace, 0, 8);
 
                 // demote to second level
                 d.SpaceSetSublevel(ActiveSpace, 1);
                 d.SpaceSetSublevel(StaticSpace, 1);
+                d.SpaceSetSublevel(GroundSpace, 1);
 
                 d.GeomSetCategoryBits(ActiveSpace, (uint)(CollisionCategories.Space |
                                                         CollisionCategories.Geom |
@@ -402,6 +406,9 @@ namespace OpenSim.Region.Physics.OdePlugin
                                                         ));
                 d.GeomSetCollideBits(StaticSpace, 0);
 
+                d.GeomSetCategoryBits(GroundSpace, (uint)(CollisionCategories.Land));
+                d.GeomSetCollideBits(GroundSpace, 0);
+
                 contactgroup = d.JointGroupCreate(0);
                 //contactgroup
 
@@ -440,9 +447,11 @@ namespace OpenSim.Region.Physics.OdePlugin
 
             int contactsPerCollision = 80;
 
+            IConfig physicsconfig = null;
+
             if (m_config != null)
             {
-                IConfig physicsconfig = m_config.Configs["ODEPhysicsSettings"];
+                physicsconfig = m_config.Configs["ODEPhysicsSettings"];
                 if (physicsconfig != null)
                 {
                     gravityx = physicsconfig.GetFloat("world_gravityx", gravityx);
@@ -469,27 +478,7 @@ namespace OpenSim.Region.Physics.OdePlugin
 
                     geomDefaultDensity = physicsconfig.GetFloat("geometry_default_density", geomDefaultDensity);
                     bodyFramesAutoDisable = physicsconfig.GetInt("body_frames_auto_disable", bodyFramesAutoDisable);
-/*
-                    bodyPIDD = physicsconfig.GetFloat("body_pid_derivative", bodyPIDD);
-                    bodyPIDG = physicsconfig.GetFloat("body_pid_gain", bodyPIDG);
-*/
-                    forceSimplePrimMeshing = physicsconfig.GetBoolean("force_simple_prim_meshing", forceSimplePrimMeshing);
-                    meshSculptedPrim = physicsconfig.GetBoolean("mesh_sculpted_prim", meshSculptedPrim);
-                    meshSculptLOD = physicsconfig.GetFloat("mesh_lod", meshSculptLOD);
-                    MeshSculptphysicalLOD = physicsconfig.GetFloat("mesh_physical_lod", MeshSculptphysicalLOD);
-/*
-                    if (Environment.OSVersion.Platform == PlatformID.Unix)
-                    {
-                        avPIDD = physicsconfig.GetFloat("av_pid_derivative_linux", avPIDD);
-                        avPIDP = physicsconfig.GetFloat("av_pid_proportional_linux", avPIDP);
-                    }
-                    else
-                    {
- 
-                        avPIDD = physicsconfig.GetFloat("av_pid_derivative_win", avPIDD);
-                        avPIDP = physicsconfig.GetFloat("av_pid_proportional_win", avPIDP);
-                    }
-*/
+
                     physics_logging = physicsconfig.GetBoolean("physics_logging", false);
                     physics_logging_interval = physicsconfig.GetInt("physics_logging_interval", 0);
                     physics_logging_append_existing_logfile = physicsconfig.GetBoolean("physics_logging_append_existing_logfile", false);
@@ -499,6 +488,8 @@ namespace OpenSim.Region.Physics.OdePlugin
                 }
             }
 
+            m_meshWorker = new ODEMeshWorker(this, m_log, meshmerizer, physicsconfig);
+
             HalfOdeStep = ODE_STEPSIZE * 0.5f;
             odetimestepMS = (int)(1000.0f * ODE_STEPSIZE +0.5f);
 
@@ -727,6 +718,32 @@ namespace OpenSim.Region.Physics.OdePlugin
 
                 if (b1 != IntPtr.Zero && b2 != IntPtr.Zero && d.AreConnectedExcluding(b1, b2, d.JointType.Contact))
                     return;
+/*
+// debug
+                PhysicsActor dp2;
+                if (d.GeomGetClass(g1) == d.GeomClassID.HeightfieldClass)
+                {
+                    d.AABB aabb;
+                    d.GeomGetAABB(g2, out aabb);
+                    float x = aabb.MaxX - aabb.MinX;
+                    float y = aabb.MaxY - aabb.MinY;
+                    float z = aabb.MaxZ - aabb.MinZ;
+                    if (x > 60.0f || y > 60.0f || z > 60.0f)
+                    {
+                        if (!actor_name_map.TryGetValue(g2, out dp2))
+                            m_log.WarnFormat("[PHYSICS]: failed actor mapping for geom 2");
+                        else
+                            m_log.WarnFormat("[PHYSICS]: land versus large prim geo {0},size {1}, AABBsize <{2},{3},{4}>, at {5} ori {6},({7})",
+                                dp2.Name, dp2.Size, x, y, z,
+                                dp2.Position.ToString(),
+                                dp2.Orientation.ToString(),
+                                dp2.Orientation.Length());
+                        return;
+                    }
+                }
+//
+*/
+
 
                 if(d.GeomGetCategoryBits(g1) == (uint)CollisionCategories.VolumeDtc ||
                     d.GeomGetCategoryBits(g1) == (uint)CollisionCategories.VolumeDtc)
@@ -1225,6 +1242,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                         chr.CollidingObj = false;
                         // do colisions with static space
                         d.SpaceCollide2(StaticSpace, chr.Shell, IntPtr.Zero, nearCallback);
+                        // no coll with gnd
                     }
                 }
                 catch (AccessViolationException)
@@ -1253,7 +1271,10 @@ namespace OpenSim.Region.Physics.OdePlugin
                         if (!prm.m_outbounds)
                         {
                             if (d.BodyIsEnabled(prm.Body))
+                            {
                                 d.SpaceCollide2(StaticSpace, prm.collide_geom, IntPtr.Zero, nearCallback);
+                                d.SpaceCollide2(GroundSpace, prm.collide_geom, IntPtr.Zero, nearCallback);
+                            }
                         }
                     }
                 }
@@ -1295,6 +1316,15 @@ namespace OpenSim.Region.Physics.OdePlugin
                 _collisionEventPrimRemove.Add(obj);
         }
 
+        public override float TimeDilation
+        {
+            get { return m_timeDilation; }
+        }
+
+        public override bool SupportsNINJAJoints
+        {
+            get { return false; }
+        }
 
         #region Add/Remove Entities
 
@@ -1350,117 +1380,59 @@ namespace OpenSim.Region.Physics.OdePlugin
             ((OdeCharacter) actor).Destroy();
         }
 
-        private PhysicsActor AddPrim(String name, Vector3 position, Vector3 size, Quaternion rotation,
-                                     PrimitiveBaseShape pbs, bool isphysical, uint localID)
-        {
-            Vector3 pos = position;
-            Vector3 siz = size;
-            Quaternion rot = rotation;
 
-            OdePrim newPrim;
-            lock (OdeLock)
+        public void addActivePrim(OdePrim activatePrim)
+        {
+            // adds active prim..   
+            lock (_activeprims)
             {
-                newPrim = new OdePrim(name, this, pos, siz, rot, pbs, isphysical,false,0,localID);
-
-                lock (_prims)
-                    _prims.Add(newPrim);
+                if (!_activeprims.Contains(activatePrim))
+                    _activeprims.Add(activatePrim);
             }
-            return newPrim;
         }
 
-        private PhysicsActor AddPrim(String name, Vector3 position, Vector3 size, Quaternion rotation,
-                                     PrimitiveBaseShape pbs, bool isphysical, bool isPhantom, uint localID)
+        public void addActiveGroups(OdePrim activatePrim)
         {
-            Vector3 pos = position;
-            Vector3 siz = size;
-            Quaternion rot = rotation;
-
-            OdePrim newPrim;
-            lock (OdeLock)
+            lock (_activegroups)
             {
-                newPrim = new OdePrim(name, this, pos, siz, rot, pbs, isphysical, isPhantom, 0, localID);
-
-                lock (_prims)
-                    _prims.Add(newPrim);
+                if (!_activegroups.Contains(activatePrim))
+                    _activegroups.Add(activatePrim);
             }
-            return newPrim;
         }
 
         private PhysicsActor AddPrim(String name, Vector3 position, Vector3 size, Quaternion rotation,
                                      PrimitiveBaseShape pbs, bool isphysical, bool isPhantom, byte shapeType, uint localID)
         {
-            Vector3 pos = position;
-            Vector3 siz = size;
-            Quaternion rot = rotation;
-
             OdePrim newPrim;
             lock (OdeLock)
             {
-                newPrim = new OdePrim(name, this, pos, siz, rot, pbs, isphysical, isPhantom, shapeType, localID);
-
+                newPrim = new OdePrim(name, this, position, size, rotation, pbs, isphysical, isPhantom, shapeType, localID);
                 lock (_prims)
                     _prims.Add(newPrim);
             }
             return newPrim;
         }
 
-        public void addActivePrim(OdePrim activatePrim)
-        {
-            // adds active prim..   
-            lock (_activeprims)
-            {
-                if (!_activeprims.Contains(activatePrim))
-                    _activeprims.Add(activatePrim);
-            }
-        }
-
-        public void addActiveGroups(OdePrim activatePrim)
-        {
-            lock (_activegroups)
-            {
-                if (!_activegroups.Contains(activatePrim))
-                    _activegroups.Add(activatePrim);
-            }
-        }
-
         public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
                                                   Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, uint localid)
         {
-            return AddPrim(primName, position, size, rotation, pbs, isPhysical, isPhantom, localid);
+            return AddPrim(primName, position, size, rotation, pbs, isPhysical, isPhantom, 0 , localid);
         }
 
 
         public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
                                                   Vector3 size, Quaternion rotation, bool isPhysical, uint localid)
         {
-#if SPAM
-            m_log.DebugFormat("[PHYSICS]: Adding physics actor to {0}", primName);
-#endif
-
-            return AddPrim(primName, position, size, rotation, pbs, isPhysical, localid);
+            return AddPrim(primName, position, size, rotation, pbs, isPhysical,false, 0, localid);
         }
 
         public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
                                                   Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, byte shapeType, uint localid)
         {
-#if SPAM
-            m_log.DebugFormat("[PHYSICS]: Adding physics actor to {0}", primName);
-#endif
 
             return AddPrim(primName, position, size, rotation, pbs, isPhysical,isPhantom, shapeType, localid);
         }
 
-        public override float TimeDilation
-        {
-            get { return m_timeDilation; }
-        }
-
-        public override bool SupportsNINJAJoints
-        {
-            get { return false; }
-        }
-
-
         public void remActivePrim(OdePrim deactivatePrim)
         {
             lock (_activeprims)
@@ -1513,6 +1485,28 @@ namespace OpenSim.Region.Physics.OdePlugin
             }
 
         }
+
+        public bool havePrim(OdePrim prm)
+        {
+            lock (_prims)
+                return _prims.Contains(prm);
+        }
+
+        public bool haveActor(PhysicsActor actor)
+        {
+            if (actor is OdePrim)
+            {
+                lock (_prims)
+                    return _prims.Contains((OdePrim)actor);
+            }
+            else if (actor is OdeCharacter)
+            {
+                lock (_characters)
+                    return _characters.Contains((OdeCharacter)actor);
+            }
+            return false;
+        }
+
         #endregion
 
         #region Space Separation Calculation
@@ -1615,135 +1609,6 @@ namespace OpenSim.Region.Physics.OdePlugin
  
         #endregion
 
-        /// <summary>
-        /// Routine to figure out if we need to mesh this prim with our mesher
-        /// </summary>
-        /// <param name="pbs"></param>
-        /// <returns></returns>
-        public bool needsMeshing(PrimitiveBaseShape pbs)
-        {
-            // check sculpts or meshs 
-            if (pbs.SculptEntry)
-            {
-                if (meshSculptedPrim)
-                    return true;
-
-                if (pbs.SculptType == (byte)SculptType.Mesh) // always do meshs
-                    return true;
-
-                return false;
-            }
-
-            if (forceSimplePrimMeshing)
-                return true;
-
-            // if it's a standard box or sphere with no cuts, hollows, twist or top shear, return false since ODE can use an internal representation for the prim
-
-            if ((pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight)
-                    || (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1
-                    && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z))
-            {
-
-                if (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0
-                    && pbs.ProfileHollow == 0
-                    && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0
-                    && pbs.PathBegin == 0 && pbs.PathEnd == 0
-                    && pbs.PathTaperX == 0 && pbs.PathTaperY == 0
-                    && pbs.PathScaleX == 100 && pbs.PathScaleY == 100
-                    && pbs.PathShearX == 0 && pbs.PathShearY == 0)
-                {
-#if SPAM
-                m_log.Warn("NonMesh");
-#endif
-                    return false;
-                }
-            }
-
-            //  following code doesn't give meshs to boxes and spheres ever
-            // and it's odd..  so for now just return true if asked to force meshs
-            // hopefully mesher will fail if doesn't suport so things still get basic boxes
-
-            int iPropertiesNotSupportedDefault = 0;
-
-            if (pbs.ProfileHollow != 0)
-                iPropertiesNotSupportedDefault++;
-
-            if ((pbs.PathBegin != 0) || pbs.PathEnd != 0)
-                iPropertiesNotSupportedDefault++;
-
-            if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0))
-                iPropertiesNotSupportedDefault++; 
-
-            if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0)
-                iPropertiesNotSupportedDefault++;
-
-            if ((pbs.PathScaleX != 100) || (pbs.PathScaleY != 100))
-                iPropertiesNotSupportedDefault++;
-
-            if ((pbs.PathShearX != 0) || (pbs.PathShearY != 0))
-                iPropertiesNotSupportedDefault++;
-
-            if (pbs.ProfileShape == ProfileShape.Circle && pbs.PathCurve == (byte)Extrusion.Straight)
-                iPropertiesNotSupportedDefault++;
-
-            if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1 && (pbs.Scale.X != pbs.Scale.Y || pbs.Scale.Y != pbs.Scale.Z || pbs.Scale.Z != pbs.Scale.X))
-                iPropertiesNotSupportedDefault++;
-
-            if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte) Extrusion.Curve1)
-                iPropertiesNotSupportedDefault++;
-
-            // test for torus
-            if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Square)
-            {
-                if (pbs.PathCurve == (byte)Extrusion.Curve1)
-                {
-                    iPropertiesNotSupportedDefault++;
-                }
-            }
-            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
-            {
-                if (pbs.PathCurve == (byte)Extrusion.Straight)
-                {
-                    iPropertiesNotSupportedDefault++;
-                }
-
-                // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits
-                else if (pbs.PathCurve == (byte)Extrusion.Curve1)
-                {
-                    iPropertiesNotSupportedDefault++;
-                }
-            }
-            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle)
-            {
-                if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2)
-                {
-                    iPropertiesNotSupportedDefault++;
-                }
-            }
-            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle)
-            {
-                if (pbs.PathCurve == (byte)Extrusion.Straight)
-                {
-                    iPropertiesNotSupportedDefault++;
-                }
-                else if (pbs.PathCurve == (byte)Extrusion.Curve1)
-                {
-                    iPropertiesNotSupportedDefault++;
-                }
-            }
-
-            if (iPropertiesNotSupportedDefault == 0)
-            {
-#if SPAM
-                m_log.Warn("NonMesh");
-#endif
-                return false;
-            }
-#if SPAM
-            m_log.Debug("Mesh");
-#endif
-            return true; 
-        }
 
         /// <summary>
         /// Called to queue a change to a actor
@@ -1766,8 +1631,52 @@ namespace OpenSim.Region.Physics.OdePlugin
         /// </summary>
         /// <param name="prim"></param>
         public override void AddPhysicsActorTaint(PhysicsActor prim)
+        {
+        }
+
+        // does all pending changes generated during region load process
+        public override void PrepareSimulation()
+        {
+            lock (OdeLock)
             {
+                if (world == IntPtr.Zero)
+                {
+                    ChangesQueue.Clear();
+                    return;
+                }
+
+                ODEchangeitem item;
+
+                int donechanges = 0;
+                if (ChangesQueue.Count > 0)
+                {
+                    m_log.InfoFormat("[ODE] start processing pending actor operations");
+                    int tstart = Util.EnvironmentTickCount();
+
+                    while (ChangesQueue.Dequeue(out item))
+                    {
+                        if (item.actor != null)
+                        {
+                            try
+                            {
+                                if (item.actor is OdeCharacter)
+                                    ((OdeCharacter)item.actor).DoAChange(item.what, item.arg);
+                                else if (((OdePrim)item.actor).DoAChange(item.what, item.arg))
+                                    RemovePrimThreadLocked((OdePrim)item.actor);
+                            }
+                            catch
+                            {
+                                m_log.WarnFormat("[PHYSICS]: Operation failed for a actor {0} {1}",
+                                    item.actor.Name, item.what.ToString());
+                            }
+                        }
+                        donechanges++;
+                    }
+                    int time = Util.EnvironmentTickCountSubtract(tstart);
+                    m_log.InfoFormat("[ODE] finished {0} operations in {1}ms", donechanges, time);
+                }
             }
+        }
 
         /// <summary>
         /// This is our main simulate loop
@@ -1813,21 +1722,17 @@ namespace OpenSim.Region.Physics.OdePlugin
                 lock(OdeLock)
             {
                 if (world == IntPtr.Zero)
+                {
+                    ChangesQueue.Clear();
                     return 0;
+                }
 
-                // adjust number of iterations per step
+                ODEchangeitem item;
+
+
+                
+                d.WorldSetQuickStepNumIterations(world, curphysiteractions);
 
-//                try
-//                {
-                    d.WorldSetQuickStepNumIterations(world, curphysiteractions);
-/*                }
-                catch (StackOverflowException)
-                {
-                    m_log.Error("[PHYSICS]: The operating system wasn't able to allocate enough memory for the simulation.  Restarting the sim.");
-//                    ode.drelease(world);
-                    base.TriggerPhysicsBasedRestart();
-                }
-*/
                 while (step_time > HalfOdeStep && nodeframes < 10) //limit number of steps so we don't say here for ever
                 {
                     try
@@ -1835,14 +1740,12 @@ namespace OpenSim.Region.Physics.OdePlugin
                         // clear pointer/counter to contacts to pass into joints
                         m_global_contactcount = 0;
 
-                        ODEchangeitem item;
-                        
-                        if(ChangesQueue.Count >0)
+                        if (ChangesQueue.Count > 0)
                         {
                             int ttmpstart = Util.EnvironmentTickCount();
                             int ttmp;
 
-                            while(ChangesQueue.Dequeue(out item))
+                            while (ChangesQueue.Dequeue(out item))
                             {
                                 if (item.actor != null)
                                 {
@@ -1851,12 +1754,13 @@ namespace OpenSim.Region.Physics.OdePlugin
                                         if (item.actor is OdeCharacter)
                                             ((OdeCharacter)item.actor).DoAChange(item.what, item.arg);
                                         else if (((OdePrim)item.actor).DoAChange(item.what, item.arg))
-                                                RemovePrimThreadLocked((OdePrim)item.actor);
+                                            RemovePrimThreadLocked((OdePrim)item.actor);
                                     }
                                     catch
                                     {
-                                        m_log.Warn("[PHYSICS]: doChange failed for a actor");
-                                    };
+                                        m_log.WarnFormat("[PHYSICS]: doChange failed for a actor {0} {1}",
+                                            item.actor.Name, item.what.ToString());
+                                    }
                                 }
                                 ttmp = Util.EnvironmentTickCountSubtract(ttmpstart);
                                 if (ttmp > 20)
@@ -1994,10 +1898,47 @@ namespace OpenSim.Region.Physics.OdePlugin
                     mesher.ExpireReleaseMeshs();
                     m_lastMeshExpire = now;
                 }
+
+// information block running in debug only
 /*
-                int nactivegeoms = d.SpaceGetNumGeoms(ActiveSpace);
-                int nstaticgeoms = d.SpaceGetNumGeoms(StaticSpace);
+                int ntopactivegeoms = d.SpaceGetNumGeoms(ActiveSpace);
+                int ntopstaticgeoms = d.SpaceGetNumGeoms(StaticSpace);
+                int ngroundgeoms = d.SpaceGetNumGeoms(GroundSpace);
+
+                int nactivegeoms = 0;
+                int nactivespaces = 0;
+
+                int nstaticgeoms = 0;
+                int nstaticspaces = 0;
+                IntPtr sp;
+
+                for (int i = 0; i < ntopactivegeoms; i++)
+                {
+                    sp = d.SpaceGetGeom(ActiveSpace, i);
+                    if (d.GeomIsSpace(sp))
+                    {
+                        nactivespaces++;
+                        nactivegeoms += d.SpaceGetNumGeoms(sp);
+                    }
+                    else
+                        nactivegeoms++;
+                }
+
+                for (int i = 0; i < ntopstaticgeoms; i++)
+                {
+                    sp = d.SpaceGetGeom(StaticSpace, i);
+                    if (d.GeomIsSpace(sp))
+                    {
+                        nstaticspaces++;
+                        nstaticgeoms += d.SpaceGetNumGeoms(sp);
+                    }
+                    else
+                        nstaticgeoms++;
+                }
+
                 int ntopgeoms = d.SpaceGetNumGeoms(TopSpace);
+
+                int totgeoms = nstaticgeoms + nactivegeoms + ngroundgeoms + 1; // one ray
                 int nbodies = d.NTotalBodies;
                 int ngeoms = d.NTotalGeoms;
 */
@@ -2294,7 +2235,9 @@ namespace OpenSim.Region.Physics.OdePlugin
                                                  offset, thickness, wrap);
 
                 d.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
-                GroundGeom = d.CreateHeightfield(StaticSpace, HeightmapData, 1);
+
+                GroundGeom = d.CreateHeightfield(GroundSpace, HeightmapData, 1);
+
                 if (GroundGeom != IntPtr.Zero)
                 {
                     d.GeomSetCategoryBits(GroundGeom, (uint)(CollisionCategories.Land));
@@ -2415,12 +2358,13 @@ namespace OpenSim.Region.Physics.OdePlugin
                                                  thickness, wrap);
 
 //                d.GeomUbitTerrainDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
-                GroundGeom = d.CreateUbitTerrain(StaticSpace, HeightmapData, 1);
+                GroundGeom = d.CreateUbitTerrain(GroundSpace, HeightmapData, 1);
                 if (GroundGeom != IntPtr.Zero)
                 {
                     d.GeomSetCategoryBits(GroundGeom, (uint)(CollisionCategories.Land));
                     d.GeomSetCollideBits(GroundGeom, 0);
 
+
                     PhysicsActor pa = new NullPhysicsActor();
                     pa.Name = "Terrain";
                     pa.PhysicsActorType = (int)ActorTypes.Ground;
@@ -2599,6 +2543,9 @@ namespace OpenSim.Region.Physics.OdePlugin
 */
         public override void Dispose()
         {
+            if (m_meshWorker != null)
+                m_meshWorker.Stop();
+
             lock (OdeLock)
             {
                 m_rayCastManager.Dispose();
@@ -2633,6 +2580,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                         d.GeomDestroy(GroundGeom);
                 }
 
+
                 RegionTerrain.Clear();
 
                 if (TerrainHeightFieldHeightsHandlers.Count > 0)