1 files changed, 127 insertions, 263 deletions

diff --git a/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs b/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs
index 8cc7f28..4e95b7a 100644
--- a/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs
+++ b/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs
@@ -40,6 +40,7 @@ using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.ExceptionServices;
 using System.Runtime.InteropServices;
 using System.Threading;
 using log4net;
@@ -111,11 +112,9 @@ namespace OpenSim.Region.PhysicsModule.ODE
         Rubber = 6
     }
 
-    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "ODEPhysicsScene")]
-    public class OdeScene : PhysicsScene, INonSharedRegionModule
+    public class OdeScene : PhysicsScene
     {
         private readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType.ToString());
-        private bool m_Enabled = false;
 
         // private Dictionary<string, sCollisionData> m_storedCollisions = new Dictionary<string, sCollisionData>();
 
@@ -293,11 +292,8 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
         private float contactsurfacelayer = 0.001f;
 
-        private int worldHashspaceLow = -4;
-        private int worldHashspaceHigh = 128;
-
-        private int smallHashspaceLow = -4;
-        private int smallHashspaceHigh = 66;
+        private int HashspaceLow = -5;
+        private int HashspaceHigh = 12;
 
         private float waterlevel = 0f;
         private int framecount = 0;
@@ -356,10 +352,6 @@ namespace OpenSim.Region.PhysicsModule.ODE
         public float bodyPIDD = 35f;
         public float bodyPIDG = 25;
 
-        public int geomCrossingFailuresBeforeOutofbounds = 5;
-
-        public float bodyMotorJointMaxforceTensor = 2;
-
         public int bodyFramesAutoDisable = 20;
 
         private float[] _watermap;
@@ -478,7 +470,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
         private int m_physicsiterations = 10;
         private const float m_SkipFramesAtms = 0.40f; // Drop frames gracefully at a 400 ms lag
         private readonly PhysicsActor PANull = new NullPhysicsActor();
-//        private float step_time = 0.0f;
+        private float step_time = 0.0f;
 //Ckrinke: Comment out until used. We declare it, initialize it, but do not use it
 //Ckrinke        private int ms = 0;
         public IntPtr world;
@@ -534,89 +526,37 @@ namespace OpenSim.Region.PhysicsModule.ODE
         int spaceGridMaxY;
 
         private ODERayCastRequestManager m_rayCastManager;
+        
+                public Scene m_frameWorkScene = null;
 
+        public OdeScene(Scene pscene, IConfigSource psourceconfig, string pname)
+                {
+                        m_config = psourceconfig;
+                        m_frameWorkScene = pscene;
+                        
+            EngineType = pname;
+            PhysicsSceneName = EngineType + "/" + pscene.RegionInfo.RegionName;
 
-        #region INonSharedRegionModule
-        public string Name
-        {
-            get { return "OpenDynamicsEngine"; }
-        }
-
-        public Type ReplaceableInterface
-        {
-            get { return null; }
-        }
-
-        public void Initialise(IConfigSource source)
-        {
-            // TODO: Move this out of Startup
-            IConfig config = source.Configs["Startup"];
-            if (config != null)
-            {
-                string physics = config.GetString("physics", string.Empty);
-                if (physics == Name)
-                {
-                    m_Enabled = true;
-                    m_config = source;
-
-                    // We do this so that OpenSimulator on Windows loads the correct native ODE library depending on whether
-                    // it's running as a 32-bit process or a 64-bit one.  By invoking LoadLibary here, later DLLImports
-                    // will find it already loaded later on.
-                    //
-                    // This isn't necessary for other platforms (e.g. Mac OSX and Linux) since the DLL used can be
-                    // controlled in Ode.NET.dll.config
-                    if (Util.IsWindows())
-                        Util.LoadArchSpecificWindowsDll("ode.dll");
-
-                    // Initializing ODE only when a scene is created allows alternative ODE plugins to co-habit (according to
-                    // http://opensimulator.org/mantis/view.php?id=2750).
-                    d.InitODE();
-
-                }
-            }
-
-        }
-
-        public void Close()
-        {
-        }
-
-        public void AddRegion(Scene scene)
-        {
-            if (!m_Enabled)
-                return;
-
-            EngineType = Name;
-            PhysicsSceneName = EngineType + "/" + scene.RegionInfo.RegionName;
-
-            scene.RegisterModuleInterface<PhysicsScene>(this);
-            Vector3 extent = new Vector3(scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY, scene.RegionInfo.RegionSizeZ);
+            pscene.RegisterModuleInterface<PhysicsScene>(this);
+            Vector3 extent = new Vector3(pscene.RegionInfo.RegionSizeX, pscene.RegionInfo.RegionSizeY, pscene.RegionInfo.RegionSizeZ);
             Initialise(extent);
             InitialiseFromConfig(m_config);
 
             // This may not be that good since terrain may not be avaiable at this point
-            base.Initialise(scene.PhysicsRequestAsset, 
-                (scene.Heightmap != null ? scene.Heightmap.GetFloatsSerialised() : new float[(int)(extent.X * extent.Y)]), 
-                (float)scene.RegionInfo.RegionSettings.WaterHeight);
+            base.Initialise(pscene.PhysicsRequestAsset, 
+                (pscene.Heightmap != null ? pscene.Heightmap.GetFloatsSerialised() : new float[(int)(extent.X * extent.Y)]), 
+                (float)pscene.RegionInfo.RegionSettings.WaterHeight);
 
         }
 
-        public void RemoveRegion(Scene scene)
+         public void RegionLoaded()
         {
-            if (!m_Enabled)
-                return;
-        }
-
-        public void RegionLoaded(Scene scene)
-        {
-            if (!m_Enabled)
-                return;
-
-            mesher = scene.RequestModuleInterface<IMesher>();
+            mesher = m_frameWorkScene.RequestModuleInterface<IMesher>();
             if (mesher == null)
                 m_log.WarnFormat("[ODE SCENE]: No mesher in {0}. Things will not work well.", PhysicsSceneName);
+                                
+                        m_frameWorkScene.PhysicsEnabled = true;                         
         }
-        #endregion
 
         /// <summary>
         /// Initiailizes the scene
@@ -633,8 +573,8 @@ namespace OpenSim.Region.PhysicsModule.ODE
             m_suportCombine = false;
                         
             nearCallback = near;
-            triCallback = TriCallback;
-            triArrayCallback = TriArrayCallback;
+//            triCallback = TriCallback;
+//            triArrayCallback = TriArrayCallback;
             m_rayCastManager = new ODERayCastRequestManager(this);
 
             // Create the world and the first space
@@ -679,18 +619,9 @@ namespace OpenSim.Region.PhysicsModule.ODE
             m_config = config;
             // Defaults
 
-            if (Environment.OSVersion.Platform == PlatformID.Unix)
-            {
-                avPIDD = 3200.0f;
-                avPIDP = 1400.0f;
-                avStandupTensor = 2000000f;
-            }
-            else
-            {
-                avPIDD = 2200.0f;
-                avPIDP = 900.0f;
-                avStandupTensor = 550000f;
-            }
+            avPIDD = 2200.0f;
+            avPIDP = 900.0f;
+            avStandupTensor = 550000f;
 
             int contactsPerCollision = 80;
 
@@ -714,12 +645,10 @@ namespace OpenSim.Region.PhysicsModule.ODE
                             avatarTerminalVelocity, AvatarTerminalVelocity);
                     }
 
-                    worldHashspaceLow = physicsconfig.GetInt("world_hashspace_size_low", -4);
-                    worldHashspaceHigh = physicsconfig.GetInt("world_hashspace_size_high", 128);
+                    HashspaceLow = physicsconfig.GetInt("world_hashspace_level_low", -5);
+                    HashspaceHigh = physicsconfig.GetInt("world_hashspace_level_high", 12);
 
                     metersInSpace = physicsconfig.GetFloat("meters_in_small_space", 29.9f);
-                    smallHashspaceLow = physicsconfig.GetInt("small_hashspace_size_low", -4);
-                    smallHashspaceHigh = physicsconfig.GetInt("small_hashspace_size_high", 66);
 
                     contactsurfacelayer = physicsconfig.GetFloat("world_contact_surface_layer", 0.001f);
 
@@ -738,7 +667,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                     mAvatarObjectContactBounce = physicsconfig.GetFloat("m_avatarobjectcontact_bounce", 0.1f);
 
                     ODE_STEPSIZE = physicsconfig.GetFloat("world_stepsize", ODE_STEPSIZE);
-                    m_physicsiterations = physicsconfig.GetInt("world_internal_steps_without_collisions", 10);
+                    m_physicsiterations = physicsconfig.GetInt("world_solver_iterations", 10);
 
                     avDensity = physicsconfig.GetFloat("av_density", 80f);
 //                    avHeightFudgeFactor = physicsconfig.GetFloat("av_height_fudge_factor", 0.52f);
@@ -754,7 +683,6 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
                     geomContactPointsStartthrottle = physicsconfig.GetInt("geom_contactpoints_start_throttling", 5);
                     geomUpdatesPerThrottledUpdate = physicsconfig.GetInt("geom_updates_before_throttled_update", 15);
-                    geomCrossingFailuresBeforeOutofbounds = physicsconfig.GetInt("geom_crossing_failures_before_outofbounds", 5);
 
                     geomDefaultDensity = physicsconfig.GetFloat("geometry_default_density", 10.000006836f);
                     bodyFramesAutoDisable = physicsconfig.GetInt("body_frames_auto_disable", 20);
@@ -767,23 +695,10 @@ namespace OpenSim.Region.PhysicsModule.ODE
                     meshSculptLOD = physicsconfig.GetFloat("mesh_lod", 32f);
                     MeshSculptphysicalLOD = physicsconfig.GetFloat("mesh_physical_lod", 16f);
                     m_filterCollisions = physicsconfig.GetBoolean("filter_collisions", false);
-                    
-                    
 
-                    if (Environment.OSVersion.Platform == PlatformID.Unix)
-                    {
-                        avPIDD = physicsconfig.GetFloat("av_pid_derivative_linux", 2200.0f);
-                        avPIDP = physicsconfig.GetFloat("av_pid_proportional_linux", 900.0f);
-                        avStandupTensor = physicsconfig.GetFloat("av_capsule_standup_tensor_linux", 550000f);
-                        bodyMotorJointMaxforceTensor = physicsconfig.GetFloat("body_motor_joint_maxforce_tensor_linux", 5f);
-                    }
-                    else
-                    {
-                        avPIDD = physicsconfig.GetFloat("av_pid_derivative_win", 2200.0f);
-                        avPIDP = physicsconfig.GetFloat("av_pid_proportional_win", 900.0f);
-                        avStandupTensor = physicsconfig.GetFloat("av_capsule_standup_tensor_win", 550000f);
-                        bodyMotorJointMaxforceTensor = physicsconfig.GetFloat("body_motor_joint_maxforce_tensor_win", 5f);
-                    }
+                    avPIDD = physicsconfig.GetFloat("av_pid_derivative", 2200.0f);
+                    avPIDP = physicsconfig.GetFloat("av_pid_proportional", 900.0f);
+                    avStandupTensor = physicsconfig.GetFloat("av_capsule_standup_tensor", 550000f);
 
                     physics_logging = physicsconfig.GetBoolean("physics_logging", false);
                     physics_logging_interval = physicsconfig.GetInt("physics_logging_interval", 0);
@@ -812,7 +727,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
             if (spaceGridMaxY > 24)
             {
                 spaceGridMaxY = 24;
-                spacesPerMeterY = spaceGridMaxY / WorldExtents.Y ;
+                spacesPerMeterY = spaceGridMaxY / WorldExtents.Y;
             }
 
             staticPrimspace = new IntPtr[spaceGridMaxX, spaceGridMaxY]; 
@@ -984,7 +899,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
             m_materialContacts[(int)Material.Rubber, 1].surface.soft_cfm = 0.010f;
             m_materialContacts[(int)Material.Rubber, 1].surface.soft_erp = 0.010f;
 
-            d.HashSpaceSetLevels(space, worldHashspaceLow, worldHashspaceHigh);
+            d.HashSpaceSetLevels(space, HashspaceLow, HashspaceHigh);
 
             // Set the gravity,, don't disable things automatically (we set it explicitly on some things)
 
@@ -1864,10 +1779,10 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 //}
            // }
         }
-
+/*
         private int TriArrayCallback(IntPtr trimesh, IntPtr refObject, int[] triangleIndex, int triCount)
         {
-            /*            String name1 = null;
+                        String name1 = null;
                         String name2 = null;
 
                         if (!geom_name_map.TryGetValue(trimesh, out name1))
@@ -1880,7 +1795,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                         }
 
                         m_log.InfoFormat("TriArrayCallback: A collision was detected between {1} and {2}", 0, name1, name2);
-            */
+            
             return 1;
         }
 
@@ -1910,7 +1825,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
             return 1;
         }
-
+*/
         /// <summary>
         /// This is our collision testing routine in ODE
         /// </summary>
@@ -2042,7 +1957,8 @@ namespace OpenSim.Region.PhysicsModule.ODE
                         x = x - offsetX + 1f;
                         y = y - offsetY + 1f;
 
-                        index = (int)((int)x * ((int)m_regionHeight +3) + (int)y);
+                        // map is rotated
+                        index = (int)x * ((int)m_regionHeight + 3) + (int)y;
 
                         if (index < TerrainHeightFieldHeights[heightFieldGeom].Length)
                         {
@@ -2620,59 +2536,13 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
 
                     }
-                    // we don't want to remove the main space
-
-                    // If the geometry is in the targetspace, remove it from the target space
-                    //m_log.Warn(prim.m_targetSpace);
-
-                    //if (prim.m_targetSpace != IntPtr.Zero)
-                    //{
-                    //if (d.SpaceQuery(prim.m_targetSpace, prim.prim_geom))
-                    //{
-
-                    //if (d.GeomIsSpace(prim.m_targetSpace))
-                    //{
-                    //waitForSpaceUnlock(prim.m_targetSpace);
-                    //d.SpaceRemove(prim.m_targetSpace, prim.prim_geom);
                     prim.m_targetSpace = IntPtr.Zero;
-                    //}
-                    //else
-                    //{
-                    // m_log.Info("[Physics]: Invalid Scene passed to 'removeprim from scene':" +
-                    //((OdePrim)prim).m_targetSpace.ToString());
-                    //}
-
-                    //}
-                    //}
-                    //m_log.Warn(prim.prim_geom);
-
                     if (!prim.RemoveGeom())
                         m_log.Warn("[ODE SCENE]: Unable to remove prim from physics scene");
 
                     lock (_prims)
                         _prims.Remove(prim);
 
-                    //If there are no more geometries in the sub-space, we don't need it in the main space anymore
-                    //if (d.SpaceGetNumGeoms(prim.m_targetSpace) == 0)
-                    //{
-                    //if (prim.m_targetSpace != null)
-                    //{
-                    //if (d.GeomIsSpace(prim.m_targetSpace))
-                    //{
-                    //waitForSpaceUnlock(prim.m_targetSpace);
-                    //d.SpaceRemove(space, prim.m_targetSpace);
-                    // free up memory used by the space.
-                    //d.SpaceDestroy(prim.m_targetSpace);
-                    //int[] xyspace = calculateSpaceArrayItemFromPos(prim.Position);
-                    //resetSpaceArrayItemToZero(xyspace[0], xyspace[1]);
-                    //}
-                    //else
-                    //{
-                    //m_log.Info("[Physics]: Invalid Scene passed to 'removeprim from scene':" +
-                    //((OdePrim) prim).m_targetSpace.ToString());
-                    //}
-                    //}
-                    //}
 
                     if (SupportsNINJAJoints)
                         RemoveAllJointsConnectedToActorThreadLocked(prim);
@@ -2768,12 +2638,9 @@ namespace OpenSim.Region.PhysicsModule.ODE
                     {
                         if (d.GeomIsSpace(currentspace))
                         {
-//                            waitForSpaceUnlock(currentspace);
-//                            waitForSpaceUnlock(space);
                             d.SpaceRemove(space, currentspace);
                             // free up memory used by the space.
 
-                            //d.SpaceDestroy(currentspace);
                             resetSpaceArrayItemToZero(currentspace);
                         }
                         else
@@ -2831,7 +2698,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
             if (newspace == IntPtr.Zero)
             {
                 newspace = createprimspace(iprimspaceArrItem[0], iprimspaceArrItem[1]);
-                d.HashSpaceSetLevels(newspace, smallHashspaceLow, smallHashspaceHigh);
+                d.HashSpaceSetLevels(newspace, HashspaceLow, HashspaceHigh);
             }
 
             return newspace;
@@ -3052,6 +2919,46 @@ namespace OpenSim.Region.PhysicsModule.ODE
             }
         }
 
+        // does all pending changes generated during region load process
+        public override void ProcessPreSimulation()
+        {
+            lock (OdeLock)
+            {
+                if (world == IntPtr.Zero)
+                {
+                    _taintedPrims.Clear();;
+                    return;
+                }
+
+                int donechanges = 0;
+                if (_taintedPrims.Count > 0)
+                {
+                    m_log.InfoFormat("[Ode] start processing pending actor operations");
+                    int tstart = Util.EnvironmentTickCount();
+
+                    lock (_taintedPrims)
+                    {
+                        foreach (OdePrim prim in _taintedPrims)
+                        {
+                            if (prim.m_taintremove)
+                                RemovePrimThreadLocked(prim);
+                            else
+                                prim.ProcessTaints();
+
+                            prim.m_collisionscore = 0;
+                            donechanges++;
+                        }
+                        _taintedPrims.Clear();
+                    }
+                   
+                    int time = Util.EnvironmentTickCountSubtract(tstart);
+                    m_log.InfoFormat("[Ode] finished {0} operations in {1}ms", donechanges, time);
+                }
+                m_log.InfoFormat("[Ode] {0} prim actors loaded",_prims.Count);
+            }
+        }
+
+
         /// <summary>
         /// This is our main simulate loop
         /// </summary>
@@ -3077,26 +2984,12 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
             float fps = 0;
 
-            float timeLeft = timeStep;
+            step_time += timeStep;
+
+            float HalfOdeStep = ODE_STEPSIZE * 0.5f;
+            if (step_time < HalfOdeStep)
+                return 0;
 
-            //m_log.Info(timeStep.ToString());
-//            step_time += timeSte
-//            
-//            // If We're loaded down by something else,
-//            // or debugging with the Visual Studio project on pause
-//            // skip a few frames to catch up gracefully.
-//            // without shooting the physicsactors all over the place
-//
-//            if (step_time >= m_SkipFramesAtms)
-//            {
-//                // Instead of trying to catch up, it'll do 5 physics frames only
-//                step_time = ODE_STEPSIZE;
-//                m_physicsiterations = 5;
-//            }
-//            else
-//            {
-//                m_physicsiterations = 10;
-//            }
 
             // We change _collisionEventPrimChanges to avoid locking _collisionEventPrim itself and causing potential
             // deadlock if the collision event tries to lock something else later on which is already locked by a
@@ -3138,11 +3031,11 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 // Figure out the Frames Per Second we're going at.
                 //(step_time == 0.004f, there's 250 of those per second.   Times the step time/step size
 
-                fps = (timeStep / ODE_STEPSIZE) * 1000;
+
                 // HACK: Using a time dilation of 1.0 to debug rubberbanding issues
                 //m_timeDilation = Math.Min((step_time / ODE_STEPSIZE) / (0.09375f / ODE_STEPSIZE), 1.0f);
 
-                while (timeLeft > 0.0f)
+                while (step_time > HalfOdeStep)
                 {
                     try
                     {
@@ -3307,7 +3200,8 @@ namespace OpenSim.Region.PhysicsModule.ODE
                         m_log.ErrorFormat("[ODE SCENE]: {0}, {1}, {2}", e.Message, e.TargetSite, e);
                     }
 
-                    timeLeft -= ODE_STEPSIZE;
+                    step_time -= ODE_STEPSIZE;
+                    fps += ODE_STEPSIZE;
                 }
 
                 if (CollectStats)
@@ -3403,6 +3297,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                     m_stats[ODETotalFrameMsStatName] += Util.EnvironmentTickCountSubtract(startFrameTick);
             }
 
+            fps *= 1.0f/timeStep;
             return fps;
         }
 
@@ -3675,7 +3570,6 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
             _heightmap = new float[heightmapWidthSamples * heightmapHeightSamples];
 
-
             const float scale = 1.0f;
             const float offset = 0.0f;
             const float thickness = 10f;
@@ -3740,7 +3634,8 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
                 d.GeomHeightfieldDataBuildSingle(HeightmapData, _heightmap, 0,
                             heightmapWidth, heightmapHeight,
-                            (int)heightmapWidthSamples, (int)heightmapHeightSamples,
+                            (int)heightmapWidthSamples,
+                            (int)heightmapHeightSamples,
                             scale, offset, thickness, wrap);
 
                 d.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
@@ -3765,7 +3660,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
                 d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
                 d.GeomSetRotation(GroundGeom, ref R);
-                d.GeomSetPosition(GroundGeom, pOffset.X + regionsizeX * 0.5f, pOffset.Y + regionsizeY * 0.5f, 0f);
+                d.GeomSetPosition(GroundGeom, pOffset.X + regionsizeX * 0.5f, pOffset.Y + regionsizeY * 0.5f, 0.0f);
                 IntPtr testGround = IntPtr.Zero;
                 if (RegionTerrain.TryGetValue(pOffset, out testGround))
                 {
@@ -3796,74 +3691,24 @@ namespace OpenSim.Region.PhysicsModule.ODE
         public override void SetWaterLevel(float baseheight)
         {
             waterlevel = baseheight;
-//            randomizeWater(waterlevel);
         }
 
-/*
-        private void randomizeWater(float baseheight)
+        [HandleProcessCorruptedStateExceptions]
+        public override void Dispose()
         {
-            uint heightmapWidth = m_regionWidth + 2;
-            uint heightmapHeight = m_regionHeight + 2;
-            uint heightmapWidthSamples = m_regionWidth + 2;
-            uint heightmapHeightSamples = m_regionHeight + 2;
-            float scale = 1.0f;
-            float offset = 0.0f;
-            float thickness = 2.9f;
-            int wrap = 0;
-
-            for (int i = 0; i < (258 * 258); i++)
-            {
-                _watermap[i] = (baseheight-0.1f) + ((float)fluidRandomizer.Next(1,9) / 10f);
-                // m_log.Info((baseheight - 0.1f) + ((float)fluidRandomizer.Next(1, 9) / 10f));
-            }
-
             lock (OdeLock)
             {
-                if (WaterGeom != IntPtr.Zero)
-                {
-                    d.SpaceRemove(space, WaterGeom);
-                }
-                IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
-                d.GeomHeightfieldDataBuildSingle(HeightmapData, _watermap, 0, heightmapWidth, heightmapHeight,
-                                                    (int)heightmapWidthSamples, (int)heightmapHeightSamples, scale,
-                                                    offset, thickness, wrap);
-                d.GeomHeightfieldDataSetBounds(HeightmapData, m_regionWidth, m_regionHeight);
-                WaterGeom = d.CreateHeightfield(space, HeightmapData, 1);
-                if (WaterGeom != IntPtr.Zero)
-                {
-                    d.GeomSetCategoryBits(WaterGeom, (int)(CollisionCategories.Water));
-                    d.GeomSetCollideBits(WaterGeom, (int)(CollisionCategories.Space));
-                }
-
-                geom_name_map[WaterGeom] = "Water";
-
-                d.Matrix3 R = new d.Matrix3();
-
-                Quaternion q1 = Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 1.5707f);
-                Quaternion q2 = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), 1.5707f);
-                //Axiom.Math.Quaternion q3 = Axiom.Math.Quaternion.FromAngleAxis(3.14f, new Axiom.Math.Vector3(0, 0, 1));
-
-                q1 = q1 * q2;
-                //q1 = q1 * q3;
-                Vector3 v3;
-                float angle;
-                q1.GetAxisAngle(out v3, out angle);
+                if(world == IntPtr.Zero)
+                    return;
 
-                d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
-                d.GeomSetRotation(WaterGeom, ref R);
-                d.GeomSetPosition(WaterGeom, 128, 128, 0);
-            }
-        }
-*/
-        public override void Dispose()
-        {
-            _worldInitialized = false;
+                _worldInitialized = false;
 
-            m_rayCastManager.Dispose();
-            m_rayCastManager = null;
+                if (m_rayCastManager != null)
+                {
+                    m_rayCastManager.Dispose();
+                    m_rayCastManager = null;
+                }
 
-            lock (OdeLock)
-            {
                 lock (_prims)
                 {
                     foreach (OdePrim prm in _prims)
@@ -3876,10 +3721,29 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 //{
                     //RemoveAvatar(act);
                 //}
-                d.WorldDestroy(world);
+                IntPtr GroundGeom = IntPtr.Zero;
+                if (RegionTerrain.TryGetValue(m_worldOffset, out GroundGeom))
+                {
+                    RegionTerrain.Remove(m_worldOffset);
+                    if (GroundGeom != IntPtr.Zero)
+                    {
+                        if (TerrainHeightFieldHeights.ContainsKey(GroundGeom))
+                            TerrainHeightFieldHeights.Remove(GroundGeom);
+                        d.GeomDestroy(GroundGeom);
+                    }
+                 }
+
+                try
+                {
+                    d.WorldDestroy(world);
+                    world = IntPtr.Zero;
+                }
+                catch (AccessViolationException e)
+                {
+                    m_log.ErrorFormat("[ODE SCENE]: exception {0}", e.Message);
+                }
                 //d.CloseODE();
             }
-
         }
 
         public override Dictionary<uint, float> GetTopColliders()