1 files changed, 183 insertions, 284 deletions

diff --git a/OpenSim/Region/PhysicsModules/ubOde/ODEScene.cs b/OpenSim/Region/PhysicsModules/ubOde/ODEScene.cs
index 004ee7f..0003085 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODEScene.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODEScene.cs
@@ -34,15 +34,10 @@ using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Threading;
-using System.IO;
-using System.Diagnostics;
 using log4net;
 using Nini.Config;
-using Mono.Addins;
-using OdeAPI;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Scenes;
-using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.PhysicsModules.SharedBase;
 using OpenMetaverse;
 
@@ -179,12 +174,13 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
 //        const d.ContactFlags comumContactFlags = d.ContactFlags.SoftERP | d.ContactFlags.SoftCFM |d.ContactFlags.Approx1 | d.ContactFlags.Bounce;
 
-        const d.ContactFlags comumContactFlags = d.ContactFlags.Bounce | d.ContactFlags.Approx1 | d.ContactFlags.Slip1 | d.ContactFlags.Slip2;
+//        const d.ContactFlags comumContactFlags = d.ContactFlags.Bounce | d.ContactFlags.Approx1 | d.ContactFlags.Slip1 | d.ContactFlags.Slip2;
+        const SafeNativeMethods.ContactFlags comumContactFlags = SafeNativeMethods.ContactFlags.Bounce | SafeNativeMethods.ContactFlags.Approx1;
         const float comumContactERP = 0.75f;
         const float comumContactCFM = 0.0001f;
         const float comumContactSLIP = 0f;
 
-        float frictionMovementMult = 0.8f;
+//        float frictionMovementMult = 0.2f;
 
         float TerrainBounce = 0.001f;
         float TerrainFriction = 0.3f;
@@ -200,7 +196,6 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         public float ODE_STEPSIZE = 0.020f;
         public float HalfOdeStep = 0.01f;
         public int odetimestepMS = 20; // rounded
-        private float metersInSpace = 25.6f;
         private float m_timeDilation = 1.0f;
 
         private double m_lastframe;
@@ -228,7 +223,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
         public int bodyFramesAutoDisable = 5;
 
-        private d.NearCallback nearCallback;
+        private SafeNativeMethods.NearCallback nearCallback;
 
         private Dictionary<uint,OdePrim> _prims = new Dictionary<uint,OdePrim>();
         private HashSet<OdeCharacter> _characters = new HashSet<OdeCharacter>();
@@ -251,7 +246,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         private int contactsPerCollision = 80;
         internal IntPtr ContactgeomsArray = IntPtr.Zero;
         private IntPtr GlobalContactsArray = IntPtr.Zero;
-        private d.Contact SharedTmpcontact = new d.Contact();
+        private SafeNativeMethods.Contact SharedTmpcontact = new SafeNativeMethods.Contact();
 
         const int maxContactsbeforedeath = 6000;
         private volatile int m_global_contactcount = 0;
@@ -283,16 +278,6 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         public IntPtr StaticSpace; // space for the static things around
         public IntPtr GroundSpace; // space for ground
 
-        // some speedup variables
-        private int spaceGridMaxX;
-        private int spaceGridMaxY;
-        private float spacesPerMeterX;
-        private float spacesPerMeterY;
-
-        // split static geometry collision into a grid as before
-        private IntPtr[,] staticPrimspace;
-        private IntPtr[] staticPrimspaceOffRegion;
-
         public Object OdeLock;
         public static Object SimulationLock;
 
@@ -366,7 +351,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         /// </summary>
         private void Initialization()
         {
-            d.AllocateODEDataForThread(~0U);
+            SafeNativeMethods.AllocateODEDataForThread(~0U);
 
             SimulationLock = new Object();
 
@@ -384,14 +369,24 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 // Create the world and the first space
                 try
                 {
-                    world = d.WorldCreate();
-                    TopSpace = d.HashSpaceCreate(IntPtr.Zero);
-
-                    // now the major subspaces
-                    ActiveSpace = d.HashSpaceCreate(TopSpace);
-                    CharsSpace = d.HashSpaceCreate(TopSpace);
-                    StaticSpace = d.HashSpaceCreate(TopSpace);
-                    GroundSpace = d.HashSpaceCreate(TopSpace);
+                    world = SafeNativeMethods.WorldCreate();
+                    TopSpace = SafeNativeMethods.SimpleSpaceCreate(IntPtr.Zero);
+                    ActiveSpace = SafeNativeMethods.SimpleSpaceCreate(TopSpace);
+                    CharsSpace = SafeNativeMethods.SimpleSpaceCreate(TopSpace);
+                    GroundSpace = SafeNativeMethods.SimpleSpaceCreate(TopSpace);
+                    float sx = WorldExtents.X + 16;
+                    float sy = WorldExtents.Y + 16;
+                    SafeNativeMethods.Vector3 ex =new SafeNativeMethods.Vector3(sx, sy, 0);
+                    SafeNativeMethods.Vector3 px =new SafeNativeMethods.Vector3(sx * 0.5f, sx  * 0.5f, 0);
+                    if(sx < sy)
+                        sx = sy;
+                    sx = (float)Math.Log(sx) * 1.442695f + 0.5f;
+                    int dp = (int)sx - 2;
+                    if(dp > 8)
+                        dp = 8;
+                    else if(dp < 4)
+                        dp = 4;
+                    StaticSpace = SafeNativeMethods.QuadTreeSpaceCreate(TopSpace, ref px, ref ex, dp);
                 }
                 catch
                 {
@@ -399,54 +394,48 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     // i did!
                 }
 
-                d.HashSpaceSetLevels(TopSpace, -5, 12);
-                d.HashSpaceSetLevels(ActiveSpace, -5, 10);
-                d.HashSpaceSetLevels(CharsSpace, -4, 3);
-                d.HashSpaceSetLevels(StaticSpace, -5, 12);
-                d.HashSpaceSetLevels(GroundSpace, 0, 8);
-
                 // demote to second level
-                d.SpaceSetSublevel(ActiveSpace, 1);
-                d.SpaceSetSublevel(CharsSpace, 1);
-                d.SpaceSetSublevel(StaticSpace, 1);
-                d.SpaceSetSublevel(GroundSpace, 1);
+                SafeNativeMethods.SpaceSetSublevel(ActiveSpace, 1);
+                SafeNativeMethods.SpaceSetSublevel(CharsSpace, 1);
+                SafeNativeMethods.SpaceSetSublevel(StaticSpace, 1);
+                SafeNativeMethods.SpaceSetSublevel(GroundSpace, 1);
 
-                d.GeomSetCategoryBits(ActiveSpace, (uint)(CollisionCategories.Space |
+                SafeNativeMethods.GeomSetCategoryBits(ActiveSpace, (uint)(CollisionCategories.Space |
                                                         CollisionCategories.Geom |
                                                         CollisionCategories.Character |
                                                         CollisionCategories.Phantom |
                                                         CollisionCategories.VolumeDtc
                                                         ));
-                d.GeomSetCollideBits(ActiveSpace, (uint)(CollisionCategories.Space |
+                SafeNativeMethods.GeomSetCollideBits(ActiveSpace, (uint)(CollisionCategories.Space |
                                                         CollisionCategories.Geom |
                                                         CollisionCategories.Character |
                                                         CollisionCategories.Phantom |
                                                         CollisionCategories.VolumeDtc
                                                         ));
-                d.GeomSetCategoryBits(CharsSpace, (uint)(CollisionCategories.Space |
+                SafeNativeMethods.GeomSetCategoryBits(CharsSpace, (uint)(CollisionCategories.Space |
                                         CollisionCategories.Geom |
                                         CollisionCategories.Character |
                                         CollisionCategories.Phantom |
                                         CollisionCategories.VolumeDtc
                                         ));
-                d.GeomSetCollideBits(CharsSpace, 0);
+                SafeNativeMethods.GeomSetCollideBits(CharsSpace, 0);
 
-                d.GeomSetCategoryBits(StaticSpace, (uint)(CollisionCategories.Space |
+                SafeNativeMethods.GeomSetCategoryBits(StaticSpace, (uint)(CollisionCategories.Space |
                                                         CollisionCategories.Geom |
                                                         //                                                        CollisionCategories.Land |
                                                         //                                                        CollisionCategories.Water |
                                                         CollisionCategories.Phantom |
                                                         CollisionCategories.VolumeDtc
                                                         ));
-                d.GeomSetCollideBits(StaticSpace, 0);
+                SafeNativeMethods.GeomSetCollideBits(StaticSpace, 0);
 
-                d.GeomSetCategoryBits(GroundSpace, (uint)(CollisionCategories.Land));
-                d.GeomSetCollideBits(GroundSpace, 0);
+                SafeNativeMethods.GeomSetCategoryBits(GroundSpace, (uint)(CollisionCategories.Land));
+                SafeNativeMethods.GeomSetCollideBits(GroundSpace, 0);
 
-                contactgroup = d.JointGroupCreate(maxContactsbeforedeath + 1);
+                contactgroup = SafeNativeMethods.JointGroupCreate(maxContactsbeforedeath + 1);
                 //contactgroup
 
-                d.WorldSetAutoDisableFlag(world, false);
+                SafeNativeMethods.WorldSetAutoDisableFlag(world, false);
             }
 
 
@@ -468,8 +457,6 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     gravityy = physicsconfig.GetFloat("world_gravityy", gravityy);
                     gravityz = physicsconfig.GetFloat("world_gravityz", gravityz);
 
-                    metersInSpace = physicsconfig.GetFloat("meters_in_small_space", metersInSpace);
-
                     //                    contactsurfacelayer = physicsconfig.GetFloat("world_contact_surface_layer", contactsurfacelayer);
 
                     ODE_STEPSIZE = physicsconfig.GetFloat("world_stepsize", ODE_STEPSIZE);
@@ -498,27 +485,27 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             maximumAngularVelocity = 0.49f * heartbeat *(float)Math.PI;
             maxAngVelocitySQ = maximumAngularVelocity * maximumAngularVelocity;
 
-            d.WorldSetCFM(world, comumContactCFM);
-            d.WorldSetERP(world, comumContactERP);
+            SafeNativeMethods.WorldSetCFM(world, comumContactCFM);
+            SafeNativeMethods.WorldSetERP(world, comumContactERP);
 
-            d.WorldSetGravity(world, gravityx, gravityy, gravityz);
+            SafeNativeMethods.WorldSetGravity(world, gravityx, gravityy, gravityz);
 
-            d.WorldSetLinearDamping(world, 0.001f);
-            d.WorldSetAngularDamping(world, 0.002f);
-            d.WorldSetAngularDampingThreshold(world, 0f);
-            d.WorldSetLinearDampingThreshold(world, 0f);
-            d.WorldSetMaxAngularSpeed(world, maximumAngularVelocity);
+            SafeNativeMethods.WorldSetLinearDamping(world, 0.001f);
+            SafeNativeMethods.WorldSetAngularDamping(world, 0.002f);
+            SafeNativeMethods.WorldSetAngularDampingThreshold(world, 0f);
+            SafeNativeMethods.WorldSetLinearDampingThreshold(world, 0f);
+            SafeNativeMethods.WorldSetMaxAngularSpeed(world, maximumAngularVelocity);
 
-            d.WorldSetQuickStepNumIterations(world, m_physicsiterations);
+            SafeNativeMethods.WorldSetQuickStepNumIterations(world, m_physicsiterations);
 
-            d.WorldSetContactSurfaceLayer(world, contactsurfacelayer);
-            d.WorldSetContactMaxCorrectingVel(world, 60.0f);
+            SafeNativeMethods.WorldSetContactSurfaceLayer(world, contactsurfacelayer);
+            SafeNativeMethods.WorldSetContactMaxCorrectingVel(world, 60.0f);
 
             HalfOdeStep = ODE_STEPSIZE * 0.5f;
             odetimestepMS = (int)(1000.0f * ODE_STEPSIZE + 0.5f);
 
-            ContactgeomsArray = Marshal.AllocHGlobal(contactsPerCollision * d.ContactGeom.unmanagedSizeOf);
-            GlobalContactsArray = Marshal.AllocHGlobal((maxContactsbeforedeath + 100) * d.Contact.unmanagedSizeOf);
+            ContactgeomsArray = Marshal.AllocHGlobal(contactsPerCollision * SafeNativeMethods.ContactGeom.unmanagedSizeOf);
+            GlobalContactsArray = Marshal.AllocHGlobal((maxContactsbeforedeath + 100) * SafeNativeMethods.Contact.unmanagedSizeOf);
 
             SharedTmpcontact.geom.g1 = IntPtr.Zero;
             SharedTmpcontact.geom.g2 = IntPtr.Zero;
@@ -559,76 +546,6 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             m_materialContactsData[(int)Material.light].mu = 0.0f;
             m_materialContactsData[(int)Material.light].bounce = 0.0f;
 
-
-            spacesPerMeterX = 1.0f / metersInSpace;
-            spacesPerMeterY = spacesPerMeterX;
-            spaceGridMaxX = (int)(WorldExtents.X * spacesPerMeterX);
-            spaceGridMaxY = (int)(WorldExtents.Y * spacesPerMeterY);
-
-            if (spaceGridMaxX > 24)
-            {
-                spaceGridMaxX = 24;
-                spacesPerMeterX = spaceGridMaxX / WorldExtents.X;
-            }
-
-            if (spaceGridMaxY > 24)
-            {
-                spaceGridMaxY = 24;
-                spacesPerMeterY = spaceGridMaxY / WorldExtents.Y;
-            }
-
-            staticPrimspace = new IntPtr[spaceGridMaxX, spaceGridMaxY];
-
-            // create all spaces now
-            int i, j;
-            IntPtr newspace;
-
-            for (i = 0; i < spaceGridMaxX; i++)
-                for (j = 0; j < spaceGridMaxY; j++)
-                {
-                    newspace = d.HashSpaceCreate(StaticSpace);
-                    d.GeomSetCategoryBits(newspace, (int)CollisionCategories.Space);
-                    waitForSpaceUnlock(newspace);
-                    d.SpaceSetSublevel(newspace, 2);
-                    d.HashSpaceSetLevels(newspace, -2, 8);
-                    d.GeomSetCategoryBits(newspace, (uint)(CollisionCategories.Space |
-                                        CollisionCategories.Geom |
-                                        CollisionCategories.Land |
-                                        CollisionCategories.Water |
-                                        CollisionCategories.Phantom |
-                                        CollisionCategories.VolumeDtc
-                                        ));
-                    d.GeomSetCollideBits(newspace, 0);
-
-                    staticPrimspace[i, j] = newspace;
-                }
-
-            // let this now be index limit
-            spaceGridMaxX--;
-            spaceGridMaxY--;
-
-            // create 4 off world spaces (x<0,x>max,y<0,y>max)
-            staticPrimspaceOffRegion = new IntPtr[4];
-
-            for (i = 0; i < 4; i++)
-            {
-                newspace = d.HashSpaceCreate(StaticSpace);
-                d.GeomSetCategoryBits(newspace, (int)CollisionCategories.Space);
-                waitForSpaceUnlock(newspace);
-                d.SpaceSetSublevel(newspace, 2);
-                d.HashSpaceSetLevels(newspace, -2, 8);
-                d.GeomSetCategoryBits(newspace, (uint)(CollisionCategories.Space |
-                                    CollisionCategories.Geom |
-                                    CollisionCategories.Land |
-                                    CollisionCategories.Water |
-                                    CollisionCategories.Phantom |
-                                    CollisionCategories.VolumeDtc
-                                    ));
-                d.GeomSetCollideBits(newspace, 0);
-
-                staticPrimspaceOffRegion[i] = newspace;
-            }
-
             m_lastframe = Util.GetTimeStamp();
             m_lastMeshExpire = m_lastframe;
             step_time = -1;
@@ -643,7 +560,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         #region Collision Detection
 
         // sets a global contact for a joint for contactgeom , and base contact description)
-        private IntPtr CreateContacJoint(ref d.ContactGeom contactGeom,bool smooth)
+        private IntPtr CreateContacJoint(ref SafeNativeMethods.ContactGeom contactGeom,bool smooth)
         {
             if (m_global_contactcount >= maxContactsbeforedeath)
                 return IntPtr.Zero;
@@ -656,18 +573,18 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             SharedTmpcontact.geom.pos = contactGeom.pos;
             SharedTmpcontact.geom.normal = contactGeom.normal;
 
-            IntPtr contact = new IntPtr(GlobalContactsArray.ToInt64() + (Int64)(m_global_contactcount * d.Contact.unmanagedSizeOf));
+            IntPtr contact = new IntPtr(GlobalContactsArray.ToInt64() + (Int64)(m_global_contactcount * SafeNativeMethods.Contact.unmanagedSizeOf));
             Marshal.StructureToPtr(SharedTmpcontact, contact, true);
-            return d.JointCreateContactPtr(world, contactgroup, contact);
+            return SafeNativeMethods.JointCreateContactPtr(world, contactgroup, contact);
         }
 
-        private bool GetCurContactGeom(int index, ref d.ContactGeom newcontactgeom)
+        private bool GetCurContactGeom(int index, ref SafeNativeMethods.ContactGeom newcontactgeom)
         {
             if (ContactgeomsArray == IntPtr.Zero || index >= contactsPerCollision)
                 return false;
 
-            IntPtr contactptr = new IntPtr(ContactgeomsArray.ToInt64() + (Int64)(index * d.ContactGeom.unmanagedSizeOf));
-            newcontactgeom = (d.ContactGeom)Marshal.PtrToStructure(contactptr, typeof(d.ContactGeom));
+            IntPtr contactptr = new IntPtr(ContactgeomsArray.ToInt64() + (Int64)(index * SafeNativeMethods.ContactGeom.unmanagedSizeOf));
+            newcontactgeom = (SafeNativeMethods.ContactGeom)Marshal.PtrToStructure(contactptr, typeof(SafeNativeMethods.ContactGeom));
             return true;
         }
 
@@ -692,14 +609,14 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
                 return;
 
-            if (d.GeomIsSpace(g1) || d.GeomIsSpace(g2))
+            if (SafeNativeMethods.GeomIsSpace(g1) || SafeNativeMethods.GeomIsSpace(g2))
             {
                 // We'll be calling near recursivly if one
                 // of them is a space to find all of the
                 // contact points in the space
                 try
                 {
-                    d.SpaceCollide2(g1, g2, IntPtr.Zero, nearCallback);
+                    SafeNativeMethods.SpaceCollide2(g1, g2, IntPtr.Zero, nearCallback);
                 }
                 catch (AccessViolationException)
                 {
@@ -714,8 +631,8 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
             // get geom bodies to check if we already a joint contact
             // guess this shouldn't happen now
-            IntPtr b1 = d.GeomGetBody(g1);
-            IntPtr b2 = d.GeomGetBody(g2);
+            IntPtr b1 = SafeNativeMethods.GeomGetBody(g1);
+            IntPtr b2 = SafeNativeMethods.GeomGetBody(g2);
 
             // d.GeomClassID id = d.GeomGetClass(g1);
 
@@ -757,19 +674,18 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 //
                 */
 
-
-                if (d.GeomGetCategoryBits(g1) == (uint)CollisionCategories.VolumeDtc ||
-                    d.GeomGetCategoryBits(g2) == (uint)CollisionCategories.VolumeDtc)
+                if (SafeNativeMethods.GeomGetCategoryBits(g1) == (uint)CollisionCategories.VolumeDtc ||
+                    SafeNativeMethods.GeomGetCategoryBits(g2) == (uint)CollisionCategories.VolumeDtc)
                 {
                     int cflags;
                     unchecked
                     {
-                        cflags = (int)(1 | d.CONTACTS_UNIMPORTANT);
+                        cflags = (int)(1 | SafeNativeMethods.CONTACTS_UNIMPORTANT);
                     }
-                    count = d.CollidePtr(g1, g2, cflags, ContactgeomsArray, d.ContactGeom.unmanagedSizeOf);
+                    count = SafeNativeMethods.CollidePtr(g1, g2, cflags, ContactgeomsArray, SafeNativeMethods.ContactGeom.unmanagedSizeOf);
                 }
                 else
-                    count = d.CollidePtr(g1, g2, (contactsPerCollision & 0xffff), ContactgeomsArray, d.ContactGeom.unmanagedSizeOf);
+                    count = SafeNativeMethods.CollidePtr(g1, g2, (contactsPerCollision & 0xffff), ContactgeomsArray, SafeNativeMethods.ContactGeom.unmanagedSizeOf);
             }
             catch (SEHException)
             {
@@ -805,7 +721,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
 
             // get first contact
-            d.ContactGeom curContact = new d.ContactGeom();
+            SafeNativeMethods.ContactGeom curContact = new SafeNativeMethods.ContactGeom();
 
             if (!GetCurContactGeom(0, ref curContact))
                 return;
@@ -866,9 +782,9 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                 break;
 
                             case (int)ActorTypes.Prim:
-                                Vector3 relV = p1.rootVelocity - p2.rootVelocity;
-                                float relVlenSQ = relV.LengthSquared();
-                                if (relVlenSQ > 0.0001f)
+//                                Vector3 relV = p1.rootVelocity - p2.rootVelocity;
+//                                float relVlenSQ = relV.LengthSquared();
+//                                if (relVlenSQ > 0.0001f)
                                 {
                                     p1.CollidingObj = true;
                                     p2.CollidingObj = true;
@@ -878,11 +794,11 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                 bounce = contactdata1.bounce * contactdata2.bounce;
                                 mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
 
-                                if (relVlenSQ > 0.01f)
-                                    mu *= frictionMovementMult;
+//                                if (relVlenSQ > 0.01f)
+//                                    mu *= frictionMovementMult;
 
-                                if(d.GeomGetClass(g2) == d.GeomClassID.TriMeshClass &&
-                                    d.GeomGetClass(g1) == d.GeomClassID.TriMeshClass)
+                                if(SafeNativeMethods.GeomGetClass(g2) == SafeNativeMethods.GeomClassID.TriMeshClass &&
+                                    SafeNativeMethods.GeomGetClass(g1) == SafeNativeMethods.GeomClassID.TriMeshClass)
                                     smoothMesh = true;
                                 break;
 
@@ -891,12 +807,12 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                 bounce = contactdata1.bounce * TerrainBounce;
                                 mu = (float)Math.Sqrt(contactdata1.mu * TerrainFriction);
 
-                                Vector3 v1 = p1.rootVelocity;
-                                if (Math.Abs(v1.X) > 0.1f || Math.Abs(v1.Y) > 0.1f)
-                                    mu *= frictionMovementMult;
+//                                Vector3 v1 = p1.rootVelocity;
+//                                if (Math.Abs(v1.X) > 0.1f || Math.Abs(v1.Y) > 0.1f)
+//                                    mu *= frictionMovementMult;
                                 p1.CollidingGround = true;
 
-                                if(d.GeomGetClass(g1) == d.GeomClassID.TriMeshClass)
+                                if(SafeNativeMethods.GeomGetClass(g1) == SafeNativeMethods.GeomClassID.TriMeshClass)
                                     smoothMesh = true;
                                 break;
 
@@ -918,11 +834,11 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
 //                        if (curContact.side1 > 0) // should be 2 ?
 //                            IgnoreNegSides = true;
-                        Vector3 v2 = p2.rootVelocity;
-                        if (Math.Abs(v2.X) > 0.1f || Math.Abs(v2.Y) > 0.1f)
-                            mu *= frictionMovementMult;
+//                        Vector3 v2 = p2.rootVelocity;
+//                        if (Math.Abs(v2.X) > 0.1f || Math.Abs(v2.Y) > 0.1f)
+//                            mu *= frictionMovementMult;
 
-                        if(d.GeomGetClass(g2) == d.GeomClassID.TriMeshClass)
+                        if(SafeNativeMethods.GeomGetClass(g2) == SafeNativeMethods.GeomClassID.TriMeshClass)
                             smoothMesh = true;
                     }
                     else
@@ -952,7 +868,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             SharedTmpcontact.surface.mu = mu;
             SharedTmpcontact.surface.bounce = bounce;
 
-            d.ContactGeom altContact = new d.ContactGeom();
+            SafeNativeMethods.ContactGeom altContact = new SafeNativeMethods.ContactGeom();
             bool useAltcontact;
             bool noskip;
 
@@ -1004,7 +920,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     if (Joint == IntPtr.Zero)
                         break;
 
-                    d.JointAttach(Joint, b1, b2);
+                    SafeNativeMethods.JointAttach(Joint, b1, b2);
 
                     ncontacts++;
 
@@ -1152,12 +1068,12 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                             continue;
 
                         // do colisions with static space
-                        d.SpaceCollide2(chr.collider, StaticSpace, IntPtr.Zero, nearCallback);
+                        SafeNativeMethods.SpaceCollide2(chr.collider, StaticSpace, IntPtr.Zero, nearCallback);
 
                         // no coll with gnd
                     }
                     // chars with chars
-                    d.SpaceCollide(CharsSpace, IntPtr.Zero, nearCallback);
+                    SafeNativeMethods.SpaceCollide(CharsSpace, IntPtr.Zero, nearCallback);
 
                 }
                 catch (AccessViolationException)
@@ -1173,7 +1089,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 {
                     aprim.CollisionScore = 0;
                     aprim.IsColliding = false;
-                    if(!aprim.m_outbounds && d.BodyIsEnabled(aprim.Body))
+                    if(!aprim.m_outbounds && SafeNativeMethods.BodyIsEnabled(aprim.Body))
                         aprim.clearSleeperCollisions();
                 }
             }
@@ -1184,11 +1100,11 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 {
                     foreach (OdePrim aprim in _activegroups)
                     {
-                        if(!aprim.m_outbounds && d.BodyIsEnabled(aprim.Body) &&
+                        if(!aprim.m_outbounds && SafeNativeMethods.BodyIsEnabled(aprim.Body) &&
                                 aprim.collide_geom != IntPtr.Zero)
                         {
-                            d.SpaceCollide2(StaticSpace, aprim.collide_geom, IntPtr.Zero, nearCallback);
-                            d.SpaceCollide2(GroundSpace, aprim.collide_geom, IntPtr.Zero, nearCallback);
+                            SafeNativeMethods.SpaceCollide2(StaticSpace, aprim.collide_geom, IntPtr.Zero, nearCallback);
+                            SafeNativeMethods.SpaceCollide2(GroundSpace, aprim.collide_geom, IntPtr.Zero, nearCallback);
                         }
                     }
                 }
@@ -1201,7 +1117,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             // colide active amoung them
             try
             {
-                d.SpaceCollide(ActiveSpace, IntPtr.Zero, nearCallback);
+                SafeNativeMethods.SpaceCollide(ActiveSpace, IntPtr.Zero, nearCallback);
             }
             catch (Exception e)
             {
@@ -1211,7 +1127,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             // and with chars
             try
             {
-                d.SpaceCollide2(CharsSpace,ActiveSpace, IntPtr.Zero, nearCallback);
+                SafeNativeMethods.SpaceCollide2(CharsSpace,ActiveSpace, IntPtr.Zero, nearCallback);
             }
             catch (Exception e)
             {
@@ -1306,9 +1222,12 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         public override void RemoveAvatar(PhysicsActor actor)
         {
             //m_log.Debug("[PHYSICS]:ODELOCK");
+            if (world == IntPtr.Zero)
+                return;
+
             lock (OdeLock)
             {
-                d.AllocateODEDataForThread(0);
+                SafeNativeMethods.AllocateODEDataForThread(0);
                 ((OdeCharacter) actor).Destroy();
             }
         }
@@ -1460,39 +1379,35 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
         /// <summary>
         /// Called when a static prim moves or becomes static
-        /// Places the prim in a space one the static sub-spaces grid
+        /// Places the prim in a space one the static space
         /// </summary>
         /// <param name="geom">the pointer to the geom that moved</param>
-        /// <param name="pos">the position that the geom moved to</param>
         /// <param name="currentspace">a pointer to the space it was in before it was moved.</param>
         /// <returns>a pointer to the new space it's in</returns>
-        public IntPtr MoveGeomToStaticSpace(IntPtr geom, Vector3 pos, IntPtr currentspace)
+        public IntPtr MoveGeomToStaticSpace(IntPtr geom, IntPtr currentspace)
         {
-            // moves a prim into another static sub-space or from another space into a static sub-space
+            // moves a prim into static sub-space
 
             // Called ODEPrim so
             // it's already in locked space.
 
             if (geom == IntPtr.Zero) // shouldn't happen
                 return IntPtr.Zero;
-
-            // get the static sub-space for current position
-            IntPtr newspace = calculateSpaceForGeom(pos);
-
-            if (newspace == currentspace) // if we are there all done
-                return newspace;
+            
+            if (StaticSpace == currentspace) // if we are there all done
+                return StaticSpace;
 
             // else remove it from its current space
-            if (currentspace != IntPtr.Zero && d.SpaceQuery(currentspace, geom))
+            if (currentspace != IntPtr.Zero && SafeNativeMethods.SpaceQuery(currentspace, geom))
             {
-                if (d.GeomIsSpace(currentspace))
+                if (SafeNativeMethods.GeomIsSpace(currentspace))
                 {
                     waitForSpaceUnlock(currentspace);
-                    d.SpaceRemove(currentspace, geom);
+                    SafeNativeMethods.SpaceRemove(currentspace, geom);
 
-                    if (d.SpaceGetSublevel(currentspace) > 2 && d.SpaceGetNumGeoms(currentspace) == 0)
+                    if (SafeNativeMethods.SpaceGetSublevel(currentspace) > 2 && SafeNativeMethods.SpaceGetNumGeoms(currentspace) == 0)
                     {
-                        d.SpaceDestroy(currentspace);
+                        SafeNativeMethods.SpaceDestroy(currentspace);
                     }
                 }
                 else
@@ -1501,59 +1416,33 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                    " Geom:" + geom);
                 }
             }
-            else // odd currentspace is null or doesn't contain the geom? lets try the geom ideia of current space
+            else
             {
-                currentspace = d.GeomGetSpace(geom);
+                currentspace = SafeNativeMethods.GeomGetSpace(geom);
                 if (currentspace != IntPtr.Zero)
                 {
-                    if (d.GeomIsSpace(currentspace))
+                    if (SafeNativeMethods.GeomIsSpace(currentspace))
                     {
                         waitForSpaceUnlock(currentspace);
-                        d.SpaceRemove(currentspace, geom);
+                        SafeNativeMethods.SpaceRemove(currentspace, geom);
 
-                        if (d.SpaceGetSublevel(currentspace) > 2 && d.SpaceGetNumGeoms(currentspace) == 0)
+                        if (SafeNativeMethods.SpaceGetSublevel(currentspace) > 2 && SafeNativeMethods.SpaceGetNumGeoms(currentspace) == 0)
                         {
-                            d.SpaceDestroy(currentspace);
+                            SafeNativeMethods.SpaceDestroy(currentspace);
                         }
-
                     }
                 }
             }
 
             // put the geom in the newspace
-            waitForSpaceUnlock(newspace);
-            d.SpaceAdd(newspace, geom);
-
-            // let caller know this newspace
-            return newspace;
-        }
-
-        /// <summary>
-        /// Calculates the space the prim should be in by its position
-        /// </summary>
-        /// <param name="pos"></param>
-        /// <returns>a pointer to the space. This could be a new space or reused space.</returns>
-        public IntPtr calculateSpaceForGeom(Vector3 pos)
-        {
-            int x, y;
-
-            if (pos.X < 0)
-                return staticPrimspaceOffRegion[0];
-
-            if (pos.Y < 0)
-                return staticPrimspaceOffRegion[2];
-
-            x = (int)(pos.X * spacesPerMeterX);
-            if (x > spaceGridMaxX)
-                return staticPrimspaceOffRegion[1];
-
-            y = (int)(pos.Y * spacesPerMeterY);
-            if (y > spaceGridMaxY)
-                return staticPrimspaceOffRegion[3];
+            waitForSpaceUnlock(StaticSpace);
+            if(SafeNativeMethods.SpaceQuery(StaticSpace, geom))
+                m_log.Info("[Physics]: 'MoveGeomToStaticSpace' geom already in static space:" + geom);
+            else
+                SafeNativeMethods.SpaceAdd(StaticSpace, geom);
 
-            return staticPrimspace[x, y];
+            return StaticSpace;
         }
-
         #endregion
 
 
@@ -1592,7 +1481,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     return;
                 }
 
-                d.AllocateODEDataForThread(~0U);
+                SafeNativeMethods.AllocateODEDataForThread(~0U);
 
                 ODEchangeitem item;
 
@@ -1641,6 +1530,9 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         /// <returns></returns>
         public override float Simulate(float reqTimeStep)
         {
+            if (world == IntPtr.Zero)
+                return 0;
+
             double now = Util.GetTimeStamp();
             double timeStep = now - m_lastframe;
             m_lastframe = now;
@@ -1679,11 +1571,17 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 double maxChangestime = (int)(reqTimeStep * 500f); // half the time
                 double maxLoopTime = (int)(reqTimeStep * 1200f); // 1.2 the time
 
-//                double collisionTime = 0;
-//                double qstepTIme = 0;
-//                double tmpTime = 0;
-
-                d.AllocateODEDataForThread(~0U);
+/*
+                double collisionTime = 0;
+                double qstepTIme = 0;
+                double tmpTime = 0;
+                double changestot = 0;
+                double collisonRepo = 0;
+                double updatesTime = 0;
+                double moveTime = 0;
+                double rayTime = 0;
+*/
+                SafeNativeMethods.AllocateODEDataForThread(~0U);
 
                 if (ChangesQueue.Count > 0)
                 {
@@ -1719,6 +1617,8 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                         m_global_contactcount = 0;
 
 
+//                        tmpTime =  Util.GetTimeStampMS();
+
                         // Move characters
                         lock (_characters)
                         {
@@ -1746,13 +1646,17 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                 aprim.Move();
                             }
                         }
+//                        moveTime += Util.GetTimeStampMS() - tmpTime;
 
+//                        tmpTime =  Util.GetTimeStampMS();
                         m_rayCastManager.ProcessQueuedRequests();
+//                        rayTime += Util.GetTimeStampMS() - tmpTime;
 
 //                        tmpTime =  Util.GetTimeStampMS();
                         collision_optimized();
 //                        collisionTime += Util.GetTimeStampMS() - tmpTime;
 
+//                        tmpTime =  Util.GetTimeStampMS();
                         lock(_collisionEventPrimRemove)
                         {
                             foreach (PhysicsActor obj in _collisionEventPrimRemove)
@@ -1781,7 +1685,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                         pobj.SendCollisions((int)(odetimestepMS));
                                         if(pobj.Body != IntPtr.Zero && !pobj.m_isSelected &&
                                             !pobj.m_disabled && !pobj.m_building &&
-                                            !d.BodyIsEnabled(pobj.Body))
+                                            !SafeNativeMethods.BodyIsEnabled(pobj.Body))
                                         sleepers.Add(pobj);
                                     }
                                     break;
@@ -1791,11 +1695,13 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                         foreach(OdePrim prm in sleepers)
                             prm.SleeperAddCollisionEvents();
                         sleepers.Clear();
+//                        collisonRepo += Util.GetTimeStampMS() - tmpTime;
+
  
                         // do a ode simulation step
 //                        tmpTime =  Util.GetTimeStampMS();
-                        d.WorldQuickStep(world, ODE_STEPSIZE);
-                        d.JointGroupEmpty(contactgroup);
+                        SafeNativeMethods.WorldQuickStep(world, ODE_STEPSIZE);
+                        SafeNativeMethods.JointGroupEmpty(contactgroup);
 //                        qstepTIme += Util.GetTimeStampMS() - tmpTime;
 
                         // update managed ideia of physical data and do updates to core
@@ -1814,7 +1720,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                             }
                         }
         */
-
+//                        tmpTime =  Util.GetTimeStampMS();
                         lock (_activegroups)
                         {
                             {
@@ -1827,6 +1733,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                 }
                             }
                         }
+//                        updatesTime += Util.GetTimeStampMS() - tmpTime;
                     }
                     catch (Exception e)
                     {
@@ -1834,10 +1741,12 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 //                        ode.dunlock(world);
                     }
 
+
                     step_time -= ODE_STEPSIZE;
                     nodeframes++;
 
                     looptimeMS = Util.GetTimeStampMS() - loopstartMS;
+
                     if (looptimeMS > maxLoopTime)
                         break;
                 }
@@ -1854,9 +1763,9 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                         _badCharacter.Clear();
                     }
                 }
-
-// information block for in debug breakpoint only
 /*
+// information block for in debug breakpoint only
+
                 int ntopactivegeoms = d.SpaceGetNumGeoms(ActiveSpace);
                 int ntopstaticgeoms = d.SpaceGetNumGeoms(StaticSpace);
                 int ngroundgeoms = d.SpaceGetNumGeoms(GroundSpace);
@@ -1898,33 +1807,23 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 int nbodies = d.NTotalBodies;
                 int ngeoms = d.NTotalGeoms;
 */
+
 /*
                 looptimeMS /= nodeframes;
-                if(looptimeMS > 0.080)
-                {
-                    collisionTime /= nodeframes;
-                    qstepTIme /= nodeframes;    
-                }
-*/
-                // Finished with all sim stepping. If requested, dump world state to file for debugging.
-                // TODO: This call to the export function is already inside lock (OdeLock) - but is an extra lock needed?
-                // TODO: This overwrites all dump files in-place. Should this be a growing logfile, or separate snapshots?
-                if (physics_logging && (physics_logging_interval > 0) && (framecount % physics_logging_interval == 0))
+                collisionTime /= nodeframes;
+                qstepTIme /= nodeframes;
+                changestot /= nodeframes; 
+                collisonRepo /= nodeframes;
+                updatesTime /= nodeframes;
+                moveTime /= nodeframes;
+                rayTime /= nodeframes;
+
+                if(looptimeMS > .05)
                 {
-                    string fname = "state-" + world.ToString() + ".DIF"; // give each physics world a separate filename
-                    string prefix = "world" + world.ToString(); // prefix for variable names in exported .DIF file
 
-                    if (physics_logging_append_existing_logfile)
-                    {
-                        string header = "-------------- START OF PHYSICS FRAME " + framecount.ToString() + " --------------";
-                        TextWriter fwriter = File.AppendText(fname);
-                        fwriter.WriteLine(header);
-                        fwriter.Close();
-                    }
 
-                    d.WorldExportDIF(world, fname, physics_logging_append_existing_logfile, prefix);
                 }
-
+*/
                 fps = (float)nodeframes * ODE_STEPSIZE / reqTimeStep;
 
                 if(step_time < HalfOdeStep)
@@ -2285,35 +2184,35 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
             lock (OdeLock)
             {
-                d.AllocateODEDataForThread(~0U);
+                SafeNativeMethods.AllocateODEDataForThread(~0U);
 
                 if (TerrainGeom != IntPtr.Zero)
                 {
                     actor_name_map.Remove(TerrainGeom);
-                    d.GeomDestroy(TerrainGeom);
+                    SafeNativeMethods.GeomDestroy(TerrainGeom);
 
                 }
 
                 if (TerrainHeightFieldHeightsHandler.IsAllocated)
                     TerrainHeightFieldHeightsHandler.Free();
 
-                IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
+                IntPtr HeightmapData = SafeNativeMethods.GeomHeightfieldDataCreate();
 
                 TerrainHeightFieldHeightsHandler = GCHandle.Alloc(_heightmap, GCHandleType.Pinned);
 
-                d.GeomHeightfieldDataBuildSingle(HeightmapData, TerrainHeightFieldHeightsHandler.AddrOfPinnedObject(), 0,
+                SafeNativeMethods.GeomHeightfieldDataBuildSingle(HeightmapData, TerrainHeightFieldHeightsHandler.AddrOfPinnedObject(), 0,
                                                 heightmapHeight, heightmapWidth ,
                                                  (int)heightmapHeightSamples, (int)heightmapWidthSamples, scale,
                                                 offset, thickness, wrap);
 
-                d.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
+                SafeNativeMethods.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
 
-                TerrainGeom = d.CreateHeightfield(GroundSpace, HeightmapData, 1);
+                TerrainGeom = SafeNativeMethods.CreateHeightfield(GroundSpace, HeightmapData, 1);
 
                 if (TerrainGeom != IntPtr.Zero)
                 {
-                    d.GeomSetCategoryBits(TerrainGeom, (uint)(CollisionCategories.Land));
-                    d.GeomSetCollideBits(TerrainGeom, 0);
+                    SafeNativeMethods.GeomSetCategoryBits(TerrainGeom, (uint)(CollisionCategories.Land));
+                    SafeNativeMethods.GeomSetCollideBits(TerrainGeom, 0);
 
                     PhysicsActor pa = new NullPhysicsActor();
                     pa.Name = "Terrain";
@@ -2322,14 +2221,14 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
 //                    geom_name_map[GroundGeom] = "Terrain";
 
-                    d.Quaternion q = new d.Quaternion();
+                    SafeNativeMethods.Quaternion q = new SafeNativeMethods.Quaternion();
                     q.X = 0.5f;
                     q.Y = 0.5f;
                     q.Z = 0.5f;
                     q.W = 0.5f;
 
-                    d.GeomSetQuaternion(TerrainGeom, ref q);
-                    d.GeomSetPosition(TerrainGeom, m_regionWidth * 0.5f, m_regionHeight * 0.5f, 0.0f);
+                    SafeNativeMethods.GeomSetQuaternion(TerrainGeom, ref q);
+                    SafeNativeMethods.GeomSetPosition(TerrainGeom, m_regionWidth * 0.5f, m_regionHeight * 0.5f, 0.0f);
                     TerrainHeightFieldHeight = _heightmap;
                 }
                 else
@@ -2397,7 +2296,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 if (TerrainGeom != IntPtr.Zero)
                 {
                     actor_name_map.Remove(TerrainGeom);
-                    d.GeomDestroy(TerrainGeom);
+                    SafeNativeMethods.GeomDestroy(TerrainGeom);
                 }
 
                 if (TerrainHeightFieldHeightsHandler.IsAllocated)
@@ -2405,7 +2304,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
                 TerrainHeightFieldHeight = null;
 
-                IntPtr HeightmapData = d.GeomOSTerrainDataCreate();
+                IntPtr HeightmapData = SafeNativeMethods.GeomOSTerrainDataCreate();
 
                 const int wrap = 0;
                 float thickness = hfmin;
@@ -2414,16 +2313,16 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
                 TerrainHeightFieldHeightsHandler = GCHandle.Alloc(_heightmap, GCHandleType.Pinned);
 
-                d.GeomOSTerrainDataBuild(HeightmapData, TerrainHeightFieldHeightsHandler.AddrOfPinnedObject(), 0, 1.0f,
+                SafeNativeMethods.GeomOSTerrainDataBuild(HeightmapData, TerrainHeightFieldHeightsHandler.AddrOfPinnedObject(), 0, 1.0f,
                                                  (int)heightmapWidthSamples, (int)heightmapHeightSamples,
                                                  thickness, wrap);
 
 //                d.GeomOSTerrainDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
-                TerrainGeom = d.CreateOSTerrain(GroundSpace, HeightmapData, 1);
+                TerrainGeom = SafeNativeMethods.CreateOSTerrain(GroundSpace, HeightmapData, 1);
                 if (TerrainGeom != IntPtr.Zero)
                 {
-                    d.GeomSetCategoryBits(TerrainGeom, (uint)(CollisionCategories.Land));
-                    d.GeomSetCollideBits(TerrainGeom, 0);
+                    SafeNativeMethods.GeomSetCategoryBits(TerrainGeom, (uint)(CollisionCategories.Land));
+                    SafeNativeMethods.GeomSetCollideBits(TerrainGeom, 0);
 
                     PhysicsActor pa = new NullPhysicsActor();
                     pa.Name = "Terrain";
@@ -2432,7 +2331,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
 //                    geom_name_map[GroundGeom] = "Terrain";
 
-                    d.GeomSetPosition(TerrainGeom, m_regionWidth * 0.5f, m_regionHeight * 0.5f, 0.0f);
+                    SafeNativeMethods.GeomSetPosition(TerrainGeom, m_regionWidth * 0.5f, m_regionHeight * 0.5f, 0.0f);
                     TerrainHeightFieldHeight = _heightmap;
                  }
                  else
@@ -2462,7 +2361,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 if (world == IntPtr.Zero)
                     return;
 
-                d.AllocateODEDataForThread(~0U);
+                SafeNativeMethods.AllocateODEDataForThread(~0U);
 
                 if (m_meshWorker != null)
                     m_meshWorker.Stop();
@@ -2496,7 +2395,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     ch.DoAChange(changes.Remove, null);
 
                 if (TerrainGeom != IntPtr.Zero)
-                        d.GeomDestroy(TerrainGeom);
+                        SafeNativeMethods.GeomDestroy(TerrainGeom);
                 TerrainGeom = IntPtr.Zero;
 
                 if (TerrainHeightFieldHeightsHandler.IsAllocated)
@@ -2515,7 +2414,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     GlobalContactsArray = IntPtr.Zero;
                 }
 
-                d.WorldDestroy(world);
+                SafeNativeMethods.WorldDestroy(world);
                 world = IntPtr.Zero;
                 //d.CloseODE();
             }