normalise physics plugins to return fps as (simulated time / requested simulation time). improved a bit old ode simulations per call math

6 files changed, 3319 insertions, 1906 deletions

diff --git a/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsScene.cs b/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsScene.cs
index 06a205e..0d28c8e 100644
--- a/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsScene.cs
+++ b/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsScene.cs
@@ -175,7 +175,7 @@ namespace OpenSim.Region.Physics.BasicPhysicsPlugin
                 actor.Velocity = actorVelocity;
             }
 
-            return fps;
+            return 1.0f;
         }
 
         public override void GetResults()
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
index 8a19944..8af9e88 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
@@ -710,7 +710,8 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         // The physics engine returns the number of milliseconds it simulated this call.
         // These are summed and normalized to one second and divided by 1000 to give the reported physics FPS.
         // Multiply by a fixed nominal frame rate to give a rate similar to the simulator (usually 55).
-        m_simulatedTime +=  (float)numSubSteps * m_fixedTimeStep * 1000f * NominalFrameRate;
+//        m_simulatedTime +=  (float)numSubSteps * m_fixedTimeStep * 1000f * NominalFrameRate;
+        m_simulatedTime += (float)numSubSteps * m_fixedTimeStep * 1000f;
     }
 
     // Called by a BSPhysObject to note that it has changed properties and this information
@@ -797,7 +798,8 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
         // Return the framerate simulated to give the above returned results.
         // (Race condition here but this is just bookkeeping so rare mistakes do not merit a lock).
-        float simTime = m_simulatedTime;
+        // undo math above
+        float simTime = m_simulatedTime / timeStep;
         m_simulatedTime = 0f;
         return simTime;
     }
diff --git a/OpenSim/Region/Physics/ChOdePlugin/OdePlugin.cs b/OpenSim/Region/Physics/ChOdePlugin/OdePlugin.cs
index 00baa21..900e67b 100644
--- a/OpenSim/Region/Physics/ChOdePlugin/OdePlugin.cs
+++ b/OpenSim/Region/Physics/ChOdePlugin/OdePlugin.cs
@@ -1669,11 +1669,6 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
         {
-            return AddAvatar(avName, position, size, isFlying);
-        }
-
-        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
-        {
             Vector3 pos;
             pos.X = position.X;
             pos.Y = position.Y;
@@ -3163,7 +3158,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                 }
             } // end lock OdeLock
             
-            return fps * 1000.0f;               //NB This is a FRAME COUNT, not a time! AND is divide by 1000 in SimStatusReporter!
+            return fps * (float)ODE_STEPSIZE * 1000.0f / timeStep;
         } // end Simulate
 
         public override void GetResults()
diff --git a/OpenSim/Region/Physics/OdePlugin/OdeScene.cs b/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
index 3cfb0c4..559fcbc 100644
--- a/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
+++ b/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
@@ -25,50 +25,67 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-// Revision 2011/12/13 by Ubit Umarov
+// Ubit changes for varsize regions
+// using a large Heightfield geometry for terrain
+// ODE ode should handle it fine
+// EXCEPT raycasts, those need to have limited range
+// (even in normal regions)
+// or aplication stack will just blowup
+
+
+//#define USE_DRAWSTUFF
 //#define SPAM
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+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 OdeAPI;
+using Ode.NET;
+using OpenMetaverse;
+#if USE_DRAWSTUFF
+using Drawstuff.NET;
+#endif 
 using OpenSim.Framework;
 using OpenSim.Region.Physics.Manager;
-using OpenMetaverse;
 
 namespace OpenSim.Region.Physics.OdePlugin
 {
-     // 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
-    // ie physical are in active space nonphysical in static
-    // this should be exclusive as possible
+    public enum StatusIndicators : int
+    {
+        Generic = 0,
+        Start = 1,
+        End = 2
+    }
+
+//    public struct sCollisionData
+//    {
+//        public uint ColliderLocalId;
+//        public uint CollidedWithLocalId;
+//        public int NumberOfCollisions;
+//        public int CollisionType;
+//        public int StatusIndicator;
+//        public int lastframe;
+//    }
 
     [Flags]
-    public enum CollisionCategories : uint
+    public enum CollisionCategories : int
     {
         Disabled = 0,
-        //by 'things' types
-        Space =         0x01,
-        Geom =          0x02, // aka prim/part
-        Character =     0x04,
-        Land =          0x08,
-        Water =         0x010,
-
-        // by state
-        Phantom =       0x01000,
-        VolumeDtc =     0x02000,
-        Selected =      0x04000,
-        NoShape =       0x08000,
-
-
-        All =           0xffffffff
+        Geom = 0x00000001,
+        Body = 0x00000002,
+        Space = 0x00000004,
+        Character = 0x00000008,
+        Land = 0x00000010,
+        Water = 0x00000020,
+        Wind = 0x00000040,
+        Sensor = 0x00000080,
+        Selected = 0x00000100
     }
 
     /// <summary>
@@ -89,213 +106,402 @@ namespace OpenSim.Region.Physics.OdePlugin
         /// <summary></summary>
         Plastic = 5,
         /// <summary></summary>
-        Rubber = 6,
-
-        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 ?)
-        Remove,
-        Link,               // arg AuroraODEPrim new parent prim or null to delink. Makes the prim part of a object with prim parent as root
-        //  or removes from a object if arg is null
-        DeLink,
-        Position,           // arg Vector3 new position in world coords. Changes prim position. Prim must know if it is root or child
-        Orientation,        // arg Quaternion new orientation in world coords. Changes prim position. Prim must know it it is root or child
-        PosOffset,          // not in use
-        // arg Vector3 new position in local coords. Changes prim position in object
-        OriOffset,          // not in use
-        // arg Vector3 new position in local coords. Changes prim position in object
-        Velocity,
-        AngVelocity,
-        Acceleration,
-        Force,
-        Torque,
-        Momentum,
-
-        AddForce,
-        AddAngForce,
-        AngLock,
-
-        Buoyancy,
-
-        PIDTarget,
-        PIDTau,
-        PIDActive,
-
-        PIDHoverHeight,
-        PIDHoverType,
-        PIDHoverTau,
-        PIDHoverActive,
-
-        Size,
-        AvatarSize,
-        Shape,
-        PhysRepData,
-        AddPhysRep,
-
-        CollidesWater,
-        VolumeDtc,
-
-        Physical,
-        Phantom,
-        Selected,
-        disabled,
-        building,
-
-        VehicleType,
-        VehicleFloatParam,
-        VehicleVectorParam,
-        VehicleRotationParam,
-        VehicleFlags,
-        SetVehicle,
-
-        Null             //keep this last used do dim the methods array. does nothing but pulsing the prim
-    }
-
-    public struct ODEchangeitem
-    {
-        public PhysicsActor actor;
-        public OdeCharacter character;
-        public changes what;
-        public Object arg;
+        Rubber = 6
     }
 
-    
-
     public class OdeScene : PhysicsScene
     {
         private readonly ILog m_log;
         // private Dictionary<string, sCollisionData> m_storedCollisions = new Dictionary<string, sCollisionData>();
 
-        public bool OdeUbitLib = false;
-        public bool m_suportCombine = false; // mega suport not tested
+        /// <summary>
+        /// Provide a sync object so that only one thread calls d.Collide() at a time across all OdeScene instances.
+        /// </summary>
+        /// <remarks>
+        /// With ODE as of r1755 (though also tested on r1860), only one thread can call d.Collide() at a
+        /// time, even where physics objects are in entirely different ODE worlds.  This is because generating contacts
+        /// uses a static cache at the ODE level.
+        ///
+        /// Without locking, simulators running multiple regions will eventually crash with a native stack trace similar
+        /// to
+        ///
+        /// mono() [0x489171]
+        /// mono() [0x4d154f]
+        /// /lib/x86_64-linux-gnu/libpthread.so.0(+0xfc60) [0x7f6ded592c60]
+        /// .../opensim/bin/libode-x86_64.so(_ZN6Opcode11OBBCollider8_CollideEPKNS_14AABBNoLeafNodeE+0xd7a) [0x7f6dd822628a]
+        ///
+        /// ODE provides an experimental option to cache in thread local storage but compiling ODE with this option
+        /// causes OpenSimulator to immediately crash with a native stack trace similar to
+        ///
+        /// mono() [0x489171]
+        /// mono() [0x4d154f]
+        /// /lib/x86_64-linux-gnu/libpthread.so.0(+0xfc60) [0x7f03c9849c60]
+        /// .../opensim/bin/libode-x86_64.so(_Z12dCollideCCTLP6dxGeomS0_iP12dContactGeomi+0x92) [0x7f03b44bcf82]
+        /// </remarks>
+        internal static Object UniversalColliderSyncObject = new Object();
 
-//        private int threadid = 0;
-//        private Random fluidRandomizer = new Random(Environment.TickCount);
+        /// <summary>
+        /// Is stats collecting enabled for this ODE scene?
+        /// </summary>
+        public bool CollectStats { get; set; }
 
-//        const d.ContactFlags comumContactFlags = d.ContactFlags.SoftERP | d.ContactFlags.SoftCFM |d.ContactFlags.Approx1 | d.ContactFlags.Bounce;
+        /// <summary>
+        /// Statistics for this scene.
+        /// </summary>
+        private Dictionary<string, float> m_stats = new Dictionary<string, float>();
+
+        /// <summary>
+        /// Stat name for total number of avatars in this ODE scene.
+        /// </summary>
+        public const string ODETotalAvatarsStatName = "ODETotalAvatars";
+
+        /// <summary>
+        /// Stat name for total number of prims in this ODE scene.
+        /// </summary>
+        public const string ODETotalPrimsStatName = "ODETotalPrims";
+
+        /// <summary>
+        /// Stat name for total number of prims with active physics in this ODE scene.
+        /// </summary>
+        public const string ODEActivePrimsStatName = "ODEActivePrims";
+
+        /// <summary>
+        /// Stat name for the total time spent in ODE frame processing.
+        /// </summary>
+        /// <remarks>
+        /// A sanity check for the main scene loop physics time.
+        /// </remarks>
+        public const string ODETotalFrameMsStatName = "ODETotalFrameMS";
+
+        /// <summary>
+        /// Stat name for time spent processing avatar taints per frame
+        /// </summary>
+        public const string ODEAvatarTaintMsStatName = "ODEAvatarTaintFrameMS";
 
-        const d.ContactFlags comumContactFlags = d.ContactFlags.Bounce | d.ContactFlags.Approx1 | d.ContactFlags.Slip1 | d.ContactFlags.Slip2;
-        const float comumContactERP = 0.7f;
-        const float comumContactCFM = 0.0001f;
-        const float comumContactSLIP = 0f;
-        
-        float frictionMovementMult = 0.8f;
+        /// <summary>
+        /// Stat name for time spent processing prim taints per frame
+        /// </summary>
+        public const string ODEPrimTaintMsStatName = "ODEPrimTaintFrameMS";
 
-        float TerrainBounce = 0.1f;
-        float TerrainFriction = 0.3f;
+        /// <summary>
+        /// Stat name for time spent calculating avatar forces per frame.
+        /// </summary>
+        public const string ODEAvatarForcesFrameMsStatName = "ODEAvatarForcesFrameMS";
 
-        public float AvatarFriction = 0;// 0.9f * 0.5f;
+        /// <summary>
+        /// Stat name for time spent calculating prim forces per frame
+        /// </summary>
+        public const string ODEPrimForcesFrameMsStatName = "ODEPrimForcesFrameMS";
+
+        /// <summary>
+        /// Stat name for time spent fulfilling raycasting requests per frame
+        /// </summary>
+        public const string ODERaycastingFrameMsStatName = "ODERaycastingFrameMS";
+
+        /// <summary>
+        /// Stat name for time spent in native code that actually steps through the simulation.
+        /// </summary>
+        public const string ODENativeStepFrameMsStatName = "ODENativeStepFrameMS";
+
+        /// <summary>
+        /// Stat name for the number of milliseconds that ODE spends in native space collision code.
+        /// </summary>
+        public const string ODENativeSpaceCollisionFrameMsStatName = "ODENativeSpaceCollisionFrameMS";
+
+        /// <summary>
+        /// Stat name for milliseconds that ODE spends in native geom collision code.
+        /// </summary>
+        public const string ODENativeGeomCollisionFrameMsStatName = "ODENativeGeomCollisionFrameMS";
+
+        /// <summary>
+        /// Time spent in collision processing that is not spent in native space or geom collision code.
+        /// </summary>
+        public const string ODEOtherCollisionFrameMsStatName = "ODEOtherCollisionFrameMS";
+
+        /// <summary>
+        /// Stat name for time spent notifying listeners of collisions
+        /// </summary>
+        public const string ODECollisionNotificationFrameMsStatName = "ODECollisionNotificationFrameMS";
+
+        /// <summary>
+        /// Stat name for milliseconds spent updating avatar position and velocity
+        /// </summary>
+        public const string ODEAvatarUpdateFrameMsStatName = "ODEAvatarUpdateFrameMS";
+
+        /// <summary>
+        /// Stat name for the milliseconds spent updating prim position and velocity
+        /// </summary>
+        public const string ODEPrimUpdateFrameMsStatName = "ODEPrimUpdateFrameMS";
+
+        /// <summary>
+        /// Stat name for avatar collisions with another entity.
+        /// </summary>
+        public const string ODEAvatarContactsStatsName = "ODEAvatarContacts";
+
+        /// <summary>
+        /// Stat name for prim collisions with another entity.
+        /// </summary>
+        public const string ODEPrimContactsStatName = "ODEPrimContacts";
+
+        /// <summary>
+        /// Used to hold tick numbers for stat collection purposes.
+        /// </summary>
+        private int m_nativeCollisionStartTick;
+
+        /// <summary>
+        /// A messy way to tell if we need to avoid adding a collision time because this was already done in the callback.
+        /// </summary>
+        private bool m_inCollisionTiming;
+
+        /// <summary>
+        /// A temporary holder for the number of avatar collisions in a frame, so we can work out how many object
+        /// collisions occured using the _perloopcontact if stats collection is enabled.
+        /// </summary>
+        private int m_tempAvatarCollisionsThisFrame;
+
+        /// <summary>
+        /// Used in calculating physics frame time dilation
+        /// </summary>
+        private int tickCountFrameRun;
+
+        /// <summary>
+        /// Used in calculating physics frame time dilation
+        /// </summary>
+        private int latertickcount;
+
+        private Random fluidRandomizer = new Random(Environment.TickCount);
+
+        public bool m_suportCombine = true;
 
-        // this netx dimensions are only relevant for terrain partition (mega regions)
-        // WorldExtents below has the simulation dimensions
-        // they should be identical except on mega regions
         private uint m_regionWidth = Constants.RegionSize;
         private uint m_regionHeight = Constants.RegionSize;
 
-        public float ODE_STEPSIZE = 0.020f;
-        public float HalfOdeStep = 0.01f;
-        public int odetimestepMS = 20; // rounded
-        private float metersInSpace = 25.6f;
+        private float ODE_STEPSIZE = 0.0178f;
+        private float metersInSpace = 29.9f;
         private float m_timeDilation = 1.0f;
 
-        private DateTime m_lastframe;
-        private DateTime m_lastMeshExpire;
-
         public float gravityx = 0f;
         public float gravityy = 0f;
         public float gravityz = -9.8f;
 
+        public float AvatarTerminalVelocity { get; set; }
+
+        private float contactsurfacelayer = 0.001f;
+
+        private int worldHashspaceLow = -4;
+        private int worldHashspaceHigh = 128;
+
+        private int smallHashspaceLow = -4;
+        private int smallHashspaceHigh = 66;
+
         private float waterlevel = 0f;
         private int framecount = 0;
+        //private int m_returncollisions = 10;
+
+        private readonly IntPtr contactgroup;
+
+//        internal IntPtr WaterGeom;
 
-//        private int m_meshExpireCntr;
+        private float nmTerrainContactFriction = 255.0f;
+        private float nmTerrainContactBounce = 0.1f;
+        private float nmTerrainContactERP = 0.1025f;
+
+        private float mTerrainContactFriction = 75f;
+        private float mTerrainContactBounce = 0.1f;
+        private float mTerrainContactERP = 0.05025f;
+
+        private float nmAvatarObjectContactFriction = 250f;
+        private float nmAvatarObjectContactBounce = 0.1f;
+
+        private float mAvatarObjectContactFriction = 75f;
+        private float mAvatarObjectContactBounce = 0.1f;
+
+        private float avPIDD = 3200f;
+        private float avPIDP = 1400f;
+        private float avCapRadius = 0.37f;
+        private float avStandupTensor = 2000000f;
+
+        /// <summary>
+        /// true = old compatibility mode with leaning capsule; false = new corrected mode
+        /// </summary>
+        /// <remarks>
+        /// Even when set to false, the capsule still tilts but this is done in a different way.
+        /// </remarks>
+        public bool IsAvCapsuleTilted { get; private set; }
 
-        private float avDensity = 3f;
+        private float avDensity = 80f;
+//        private float avHeightFudgeFactor = 0.52f;
         private float avMovementDivisorWalk = 1.3f;
         private float avMovementDivisorRun = 0.8f;
         private float minimumGroundFlightOffset = 3f;
         public float maximumMassObject = 10000.01f;
 
+        public bool meshSculptedPrim = true;
+        public bool forceSimplePrimMeshing = false;
+
+        public float meshSculptLOD = 32;
+        public float MeshSculptphysicalLOD = 16;
 
         public float geomDefaultDensity = 10.000006836f;
 
+        public int geomContactPointsStartthrottle = 3;
+        public int geomUpdatesPerThrottledUpdate = 15;
+        private const int avatarExpectedContacts = 3;
+
         public float bodyPIDD = 35f;
         public float bodyPIDG = 25;
 
-        public int bodyFramesAutoDisable = 5;
+        public int geomCrossingFailuresBeforeOutofbounds = 5;
+
+        public float bodyMotorJointMaxforceTensor = 2;
+
+        public int bodyFramesAutoDisable = 20;
+
+        private float[] _watermap;
+        private bool m_filterCollisions = true;
 
         private d.NearCallback nearCallback;
+        public d.TriCallback triCallback;
+        public d.TriArrayCallback triArrayCallback;
 
-        private HashSet<OdeCharacter> _characters = new HashSet<OdeCharacter>();
-        private HashSet<OdePrim> _prims = new HashSet<OdePrim>();
-        private HashSet<OdePrim> _activeprims = new HashSet<OdePrim>();
-        private HashSet<OdePrim> _activegroups = new HashSet<OdePrim>();
+        /// <summary>
+        /// Avatars in the physics scene.
+        /// </summary>
+        private readonly HashSet<OdeCharacter> _characters = new HashSet<OdeCharacter>();
 
-        public OpenSim.Framework.LocklessQueue<ODEchangeitem> ChangesQueue = new OpenSim.Framework.LocklessQueue<ODEchangeitem>();
+        /// <summary>
+        /// Prims in the physics scene.
+        /// </summary>
+        private readonly HashSet<OdePrim> _prims = new HashSet<OdePrim>();
 
         /// <summary>
-        /// A list of actors that should receive collision events.
+        /// Prims in the physics scene that are subject to physics, not just collisions.
         /// </summary>
-        private List<PhysicsActor> _collisionEventPrim = new List<PhysicsActor>();
-        private List<PhysicsActor> _collisionEventPrimRemove = new List<PhysicsActor>();
-        
-        private HashSet<OdeCharacter> _badCharacter = new HashSet<OdeCharacter>();
-//        public Dictionary<IntPtr, String> geom_name_map = new Dictionary<IntPtr, String>();
-        public Dictionary<IntPtr, PhysicsActor> actor_name_map = new Dictionary<IntPtr, PhysicsActor>();
+        private readonly HashSet<OdePrim> _activeprims = new HashSet<OdePrim>();
 
-        private float contactsurfacelayer = 0.001f;
+        /// <summary>
+        /// Prims that the simulator has created/deleted/updated and so need updating in ODE.
+        /// </summary>
+        private readonly HashSet<OdePrim> _taintedPrims = new HashSet<OdePrim>();
 
-        private int contactsPerCollision = 80;
-        internal IntPtr ContactgeomsArray = IntPtr.Zero;
-        private IntPtr GlobalContactsArray = IntPtr.Zero;
-        private d.Contact SharedTmpcontact = new d.Contact();
+        /// <summary>
+        /// Record a character that has taints to be processed.
+        /// </summary>
+        private readonly HashSet<OdeCharacter> _taintedActors = new HashSet<OdeCharacter>();
 
-        const int maxContactsbeforedeath = 4000;
-        private volatile int m_global_contactcount = 0;
+        /// <summary>
+        /// Keep record of contacts in the physics loop so that we can remove duplicates.
+        /// </summary>
+        private readonly List<d.ContactGeom> _perloopContact = new List<d.ContactGeom>();
 
-        private IntPtr contactgroup;
+        /// <summary>
+        /// A dictionary of actors that should receive collision events.
+        /// </summary>
+        private readonly Dictionary<uint, PhysicsActor> m_collisionEventActors = new Dictionary<uint, PhysicsActor>();
 
-        public ContactData[] m_materialContactsData = new ContactData[8];
+        /// <summary>
+        /// A dictionary of collision event changes that are waiting to be processed.
+        /// </summary>
+        private readonly Dictionary<uint, PhysicsActor> m_collisionEventActorsChanges = new Dictionary<uint, PhysicsActor>();
 
-        private Dictionary<Vector3, IntPtr> RegionTerrain = new Dictionary<Vector3, IntPtr>();
-        private Dictionary<IntPtr, float[]> TerrainHeightFieldHeights = new Dictionary<IntPtr, float[]>();
-        private Dictionary<IntPtr, GCHandle> TerrainHeightFieldHeightsHandlers = new Dictionary<IntPtr, GCHandle>();
-       
-        private int m_physicsiterations = 15;
-        private const float m_SkipFramesAtms = 0.40f; // Drop frames gracefully at a 400 ms lag
-//        private PhysicsActor PANull = new NullPhysicsActor();
-        private float step_time = 0.0f;
+        /// <summary>
+        /// Maps a unique geometry id (a memory location) to a physics actor name.
+        /// </summary>
+        /// <remarks>
+        /// Only actors participating in collisions have geometries.  This has to be maintained separately from
+        /// actor_name_map because terrain and water currently don't conceptually have a physics actor of their own
+        /// apart from the singleton PANull
+        /// </remarks>
+        public Dictionary<IntPtr, String> geom_name_map = new Dictionary<IntPtr, String>();
 
-        public IntPtr world;
+        /// <summary>
+        /// Maps a unique geometry id (a memory location) to a physics actor.
+        /// </summary>
+        /// <remarks>
+        /// Only actors participating in collisions have geometries.
+        /// </remarks>
+        public Dictionary<IntPtr, PhysicsActor> actor_name_map = new Dictionary<IntPtr, PhysicsActor>();
+
+        /// <summary>
+        /// Defects list to remove characters that no longer have finite positions due to some other bug.
+        /// </summary>
+        /// <remarks>
+        /// Used repeatedly in Simulate() but initialized once here.
+        /// </remarks>
+        private readonly List<OdeCharacter> defects = new List<OdeCharacter>();
+
+        private bool m_NINJA_physics_joints_enabled = false;
+        //private Dictionary<String, IntPtr> jointpart_name_map = new Dictionary<String,IntPtr>();
+        private readonly Dictionary<String, List<PhysicsJoint>> joints_connecting_actor = new Dictionary<String, List<PhysicsJoint>>();
+        private d.ContactGeom[] contacts;
 
+        /// <summary>
+        /// Lock only briefly. accessed by external code (to request new joints) and by OdeScene.Simulate() to move those joints into pending/active
+        /// </summary>
+        private readonly List<PhysicsJoint> requestedJointsToBeCreated = new List<PhysicsJoint>();
 
-        // split the spaces acording to contents type
-        // ActiveSpace contains characters and active prims
-        // StaticSpace contains land and other that is mostly static in enviroment
-        // this can contain subspaces, like the grid in staticspace
-        // as now space only contains this 2 top spaces
+        /// <summary>
+        /// can lock for longer. accessed only by OdeScene.
+        /// </summary>
+        private readonly List<PhysicsJoint> pendingJoints = new List<PhysicsJoint>();
 
-        public IntPtr TopSpace; // the global space
-        public IntPtr ActiveSpace; // space for active prims
-        public IntPtr CharsSpace; // space for active prims
-        public IntPtr StaticSpace; // space for the static things around
-        public IntPtr GroundSpace; // space for ground
+        /// <summary>
+        /// can lock for longer. accessed only by OdeScene.
+        /// </summary>
+        private readonly List<PhysicsJoint> activeJoints = new List<PhysicsJoint>();
 
-        // some speedup variables
-        private int spaceGridMaxX;
-        private int spaceGridMaxY;
-        private float spacesPerMeterX;
-        private float spacesPerMeterY;
+        /// <summary>
+        /// lock only briefly. accessed by external code (to request deletion of joints) and by OdeScene.Simulate() to move those joints out of pending/active
+        /// </summary>
+        private readonly List<string> requestedJointsToBeDeleted = new List<string>();
+
+        private Object externalJointRequestsLock = new Object();
+        private readonly Dictionary<String, PhysicsJoint> SOPName_to_activeJoint = new Dictionary<String, PhysicsJoint>();
+        private readonly Dictionary<String, PhysicsJoint> SOPName_to_pendingJoint = new Dictionary<String, PhysicsJoint>();
+        private readonly DoubleDictionary<Vector3, IntPtr, IntPtr> RegionTerrain = new DoubleDictionary<Vector3, IntPtr, IntPtr>();
+        private readonly Dictionary<IntPtr,float[]> TerrainHeightFieldHeights = new Dictionary<IntPtr, float[]>();
+
+        private d.Contact contact;
+        private d.Contact TerrainContact;
+        private d.Contact AvatarMovementprimContact;
+        private d.Contact AvatarMovementTerrainContact;
+        private d.Contact WaterContact;
+        private d.Contact[,] m_materialContacts;
+
+//Ckrinke: Comment out until used. We declare it, initialize it, but do not use it
+//Ckrinke        private int m_randomizeWater = 200;
+        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;
+//Ckrinke: Comment out until used. We declare it, initialize it, but do not use it
+//Ckrinke        private int ms = 0;
+        public IntPtr world;
+        //private bool returncollisions = false;
+        // private uint obj1LocalID = 0;
+        private uint obj2LocalID = 0;
+        //private int ctype = 0;
+        private OdeCharacter cc1;
+        private OdePrim cp1;
+        private OdeCharacter cc2;
+        private OdePrim cp2;
+        private int p1ExpectedPoints = 0;
+        private int p2ExpectedPoints = 0;
+        //private int cStartStop = 0;
+        //private string cDictKey = "";
+
+        public IntPtr space;
+
+        //private IntPtr tmpSpace;
+        // split static geometry collision handling into spaces of 30 meters
+        public IntPtr[,] staticPrimspace;
 
-        // split static geometry collision into a grid as before
-        private IntPtr[,] staticPrimspace;
-        private IntPtr[] staticPrimspaceOffRegion;
+        /// <summary>
+        /// Used to lock the entire physics scene.  Locked during the main part of Simulate()
+        /// </summary>
+        internal Object OdeLock = new Object();
 
-        public Object OdeLock;
-        public static Object SimulationLock;
+        private bool _worldInitialized = false;
 
         public IMesher mesher;
 
@@ -305,357 +511,503 @@ namespace OpenSim.Region.Physics.OdePlugin
         public int physics_logging_interval = 0;
         public bool physics_logging_append_existing_logfile = false;
 
+        private bool avplanted = false;
+        private bool av_av_collisions_off = false;
+
+        public d.Vector3 xyz = new d.Vector3(128.1640f, 128.3079f, 25.7600f);
+        public d.Vector3 hpr = new d.Vector3(125.5000f, -17.0000f, 0.0000f);
+
+        private volatile int m_global_contactcount = 0;
+
         private Vector3 m_worldOffset = Vector3.Zero;
         public Vector2 WorldExtents = new Vector2((int)Constants.RegionSize, (int)Constants.RegionSize);
         private PhysicsScene m_parentScene = null;
 
-        private ODERayCastRequestManager m_rayCastManager;
-        public ODEMeshWorker m_meshWorker;
+        float spacesPerMeterX;
+        float spacesPerMeterY;
+        int spaceGridMaxX;
+        int spaceGridMaxY;
 
-/* maybe needed if ode uses tls
-        private void checkThread()
-        {
+        private ODERayCastRequestManager m_rayCastManager;
 
-            int th = Thread.CurrentThread.ManagedThreadId;
-            if(th != threadid)
-            {
-                threadid = th;
-                d.AllocateODEDataForThread(~0U);
-            }
-        }
- */
         /// <summary>
         /// Initiailizes the scene
         /// Sets many properties that ODE requires to be stable
         /// These settings need to be tweaked 'exactly' right or weird stuff happens.
         /// </summary>
-        public OdeScene(string sceneIdentifier)
-            {
-            m_log 
-                = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType.ToString() + "." + sceneIdentifier);
-
-//            checkThread();
-            Name = sceneIdentifier;
+        /// <param value="name">Name of the scene.  Useful in debug messages.</param>
+        public OdeScene(string engineType, string name)
+        {
+            m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType.ToString() + "." + name);
 
-            OdeLock = new Object();
-            SimulationLock = new Object();
+            Name = name;
+            EngineType = engineType;
 
             nearCallback = near;
+            triCallback = TriCallback;
+            triArrayCallback = TriArrayCallback;
+            m_rayCastManager = new ODERayCastRequestManager(this);
 
-            m_rayCastManager = new ODERayCastRequestManager(this);         
+            // Create the world and the first space
+            world = d.WorldCreate();
+            space = d.HashSpaceCreate(IntPtr.Zero);
 
-            lock (OdeLock)
-                {
-                // 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);
-                    }
-                catch
-                    {
-                    // i must RtC#FM 
-                    // i did!
-                    }
+            contactgroup = d.JointGroupCreate(0);
 
-                d.HashSpaceSetLevels(TopSpace, -2, 8);
-                d.HashSpaceSetLevels(ActiveSpace, -2, 8);
-                d.HashSpaceSetLevels(CharsSpace, -4, 3);
-                d.HashSpaceSetLevels(StaticSpace, -2, 8);
-                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);
-
-                d.GeomSetCategoryBits(ActiveSpace, (uint)(CollisionCategories.Space |
-                                                        CollisionCategories.Geom |
-                                                        CollisionCategories.Character |
-                                                        CollisionCategories.Phantom |
-                                                        CollisionCategories.VolumeDtc
-                                                        ));
-                d.GeomSetCollideBits(ActiveSpace, (uint)(CollisionCategories.Space |
-                                                        CollisionCategories.Geom |
-                                                        CollisionCategories.Character |
-                                                        CollisionCategories.Phantom |
-                                                        CollisionCategories.VolumeDtc
-                                                        ));
-                d.GeomSetCategoryBits(CharsSpace, (uint)(CollisionCategories.Space |
-                                        CollisionCategories.Geom |
-                                        CollisionCategories.Character |
-                                        CollisionCategories.Phantom |
-                                        CollisionCategories.VolumeDtc
-                                        ));
-                d.GeomSetCollideBits(CharsSpace, 0);
-
-                d.GeomSetCategoryBits(StaticSpace, (uint)(CollisionCategories.Space |
-                                                        CollisionCategories.Geom |
-//                                                        CollisionCategories.Land |
-//                                                        CollisionCategories.Water |
-                                                        CollisionCategories.Phantom |
-                                                        CollisionCategories.VolumeDtc
-                                                        ));
-                d.GeomSetCollideBits(StaticSpace, 0);
-
-                d.GeomSetCategoryBits(GroundSpace, (uint)(CollisionCategories.Land));
-                d.GeomSetCollideBits(GroundSpace, 0);
-
-                contactgroup = d.JointGroupCreate(maxContactsbeforedeath + 1);
-                //contactgroup
-
-                d.WorldSetAutoDisableFlag(world, false);
-            }
+            d.WorldSetAutoDisableFlag(world, false);
+
+            #if USE_DRAWSTUFF
+            Thread viewthread = new Thread(new ParameterizedThreadStart(startvisualization));
+            viewthread.Start();
+            #endif
+
+ //           _watermap = new float[258 * 258];
+
+            // Zero out the prim spaces array (we split our space into smaller spaces so
+            // we can hit test less.
+        }
+
+#if USE_DRAWSTUFF
+        public void startvisualization(object o)
+        {
+            ds.Functions fn;
+            fn.version = ds.VERSION;
+            fn.start = new ds.CallbackFunction(start);
+            fn.step = new ds.CallbackFunction(step);
+            fn.command = new ds.CallbackFunction(command);
+            fn.stop = null;
+            fn.path_to_textures = "./textures";
+            string[] args = new string[0];
+            ds.SimulationLoop(args.Length, args, 352, 288, ref fn);
         }
+#endif
 
         public override void Initialise(IMesher meshmerizer, IConfigSource config, Vector3 regionExtent)
         {
-            WorldExtents.X =  regionExtent.X;
+            WorldExtents.X = regionExtent.X;
             m_regionWidth = (uint)regionExtent.X;
-            WorldExtents.Y =  regionExtent.Y;
+            WorldExtents.Y = regionExtent.Y;
             m_regionHeight = (uint)regionExtent.Y;
-
             m_suportCombine = false;
             Initialise(meshmerizer, config);
         }
 
-
+        // Initialize the mesh plugin
         public override void Initialise(IMesher meshmerizer, IConfigSource config)
         {
-//            checkThread();
+            InitializeExtraStats();
+
             mesher = meshmerizer;
             m_config = config;
+            // Defaults
 
-            string ode_config = d.GetConfiguration();
-            if (ode_config != null && ode_config != "")
+            if (Environment.OSVersion.Platform == PlatformID.Unix)
             {
-                m_log.WarnFormat("ODE configuration: {0}", ode_config);
-
-                if (ode_config.Contains("ODE_Ubit"))
-                {
-                    OdeUbitLib = true;
-                }
+                avPIDD = 3200.0f;
+                avPIDP = 1400.0f;
+                avStandupTensor = 2000000f;
+            }
+            else
+            {
+                avPIDD = 2200.0f;
+                avPIDP = 900.0f;
+                avStandupTensor = 550000f;
             }
-
-            // Defaults
 
             int contactsPerCollision = 80;
 
-            IConfig physicsconfig = null;
-
             if (m_config != null)
             {
-                physicsconfig = m_config.Configs["ODEPhysicsSettings"];
+                IConfig physicsconfig = m_config.Configs["ODEPhysicsSettings"];
                 if (physicsconfig != null)
                 {
-                    gravityx = physicsconfig.GetFloat("world_gravityx", gravityx);
-                    gravityy = physicsconfig.GetFloat("world_gravityy", gravityy);
-                    gravityz = physicsconfig.GetFloat("world_gravityz", gravityz);
-
-                    metersInSpace = physicsconfig.GetFloat("meters_in_small_space", metersInSpace);
+                    CollectStats = physicsconfig.GetBoolean("collect_stats", false);
 
-//                    contactsurfacelayer = physicsconfig.GetFloat("world_contact_surface_layer", contactsurfacelayer);
+                    gravityx = physicsconfig.GetFloat("world_gravityx", 0f);
+                    gravityy = physicsconfig.GetFloat("world_gravityy", 0f);
+                    gravityz = physicsconfig.GetFloat("world_gravityz", -9.8f);
 
-                    ODE_STEPSIZE = physicsconfig.GetFloat("world_stepsize", ODE_STEPSIZE);
-
-                    avDensity = physicsconfig.GetFloat("av_density", avDensity);
-                    avMovementDivisorWalk = physicsconfig.GetFloat("av_movement_divisor_walk", avMovementDivisorWalk);
-                    avMovementDivisorRun = physicsconfig.GetFloat("av_movement_divisor_run", avMovementDivisorRun);
-
-                    contactsPerCollision = physicsconfig.GetInt("contacts_per_collision", contactsPerCollision);
-
-                    geomDefaultDensity = physicsconfig.GetFloat("geometry_default_density", geomDefaultDensity);
-                    bodyFramesAutoDisable = physicsconfig.GetInt("body_frames_auto_disable", bodyFramesAutoDisable);
-
-                    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);
-
-                    minimumGroundFlightOffset = physicsconfig.GetFloat("minimum_ground_flight_offset", minimumGroundFlightOffset);
-                    maximumMassObject = physicsconfig.GetFloat("maximum_mass_object", maximumMassObject);
-                }
-            }
-
-
-            d.WorldSetCFM(world, comumContactCFM);
-            d.WorldSetERP(world, comumContactERP);
+                    float avatarTerminalVelocity = physicsconfig.GetFloat("avatar_terminal_velocity", 54f);
+                    AvatarTerminalVelocity = Util.Clamp<float>(avatarTerminalVelocity, 0, 255f);
+                    if (AvatarTerminalVelocity != avatarTerminalVelocity)
+                    {
+                        m_log.WarnFormat(
+                            "[ODE SCENE]: avatar_terminal_velocity of {0} is invalid.  Clamping to {1}",
+                            avatarTerminalVelocity, AvatarTerminalVelocity);
+                    }
 
-            d.WorldSetGravity(world, gravityx, gravityy, gravityz);
+                    worldHashspaceLow = physicsconfig.GetInt("world_hashspace_size_low", -4);
+                    worldHashspaceHigh = physicsconfig.GetInt("world_hashspace_size_high", 128);
 
-            d.WorldSetLinearDamping(world, 0.002f);
-            d.WorldSetAngularDamping(world, 0.002f);
-            d.WorldSetAngularDampingThreshold(world, 0f);
-            d.WorldSetLinearDampingThreshold(world, 0f);
-            d.WorldSetMaxAngularSpeed(world, 100f);
+                    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);
 
-            d.WorldSetQuickStepNumIterations(world, m_physicsiterations);
+                    contactsurfacelayer = physicsconfig.GetFloat("world_contact_surface_layer", 0.001f);
 
-            d.WorldSetContactSurfaceLayer(world, contactsurfacelayer);
-            d.WorldSetContactMaxCorrectingVel(world, 60.0f);
+                    nmTerrainContactFriction = physicsconfig.GetFloat("nm_terraincontact_friction", 255.0f);
+                    nmTerrainContactBounce = physicsconfig.GetFloat("nm_terraincontact_bounce", 0.1f);
+                    nmTerrainContactERP = physicsconfig.GetFloat("nm_terraincontact_erp", 0.1025f);
 
-            m_meshWorker = new ODEMeshWorker(this, m_log, meshmerizer, physicsconfig);
+                    mTerrainContactFriction = physicsconfig.GetFloat("m_terraincontact_friction", 75f);
+                    mTerrainContactBounce = physicsconfig.GetFloat("m_terraincontact_bounce", 0.05f);
+                    mTerrainContactERP = physicsconfig.GetFloat("m_terraincontact_erp", 0.05025f);
 
-            HalfOdeStep = ODE_STEPSIZE * 0.5f;
-            odetimestepMS = (int)(1000.0f * ODE_STEPSIZE +0.5f);
+                    nmAvatarObjectContactFriction = physicsconfig.GetFloat("objectcontact_friction", 250f);
+                    nmAvatarObjectContactBounce = physicsconfig.GetFloat("objectcontact_bounce", 0.2f);
 
-            ContactgeomsArray = Marshal.AllocHGlobal(contactsPerCollision * d.ContactGeom.unmanagedSizeOf);
-            GlobalContactsArray = Marshal.AllocHGlobal(maxContactsbeforedeath * d.Contact.unmanagedSizeOf);
+                    mAvatarObjectContactFriction = physicsconfig.GetFloat("m_avatarobjectcontact_friction", 75f);
+                    mAvatarObjectContactBounce = physicsconfig.GetFloat("m_avatarobjectcontact_bounce", 0.1f);
 
-            SharedTmpcontact.geom.g1 = IntPtr.Zero;
-            SharedTmpcontact.geom.g2 = IntPtr.Zero;
+                    ODE_STEPSIZE = physicsconfig.GetFloat("world_stepsize", ODE_STEPSIZE);
+                    m_physicsiterations = physicsconfig.GetInt("world_internal_steps_without_collisions", 10);
 
-            SharedTmpcontact.geom.side1 = -1;
-            SharedTmpcontact.geom.side2 = -1;
+                    avDensity = physicsconfig.GetFloat("av_density", 80f);
+//                    avHeightFudgeFactor = physicsconfig.GetFloat("av_height_fudge_factor", 0.52f);
+                    avMovementDivisorWalk = physicsconfig.GetFloat("av_movement_divisor_walk", 1.3f);
+                    avMovementDivisorRun = physicsconfig.GetFloat("av_movement_divisor_run", 0.8f);
+                    avCapRadius = physicsconfig.GetFloat("av_capsule_radius", 0.37f);
+                    avplanted = physicsconfig.GetBoolean("av_planted", false);
+                    av_av_collisions_off = physicsconfig.GetBoolean("av_av_collisions_off", false);
 
-            SharedTmpcontact.surface.mode = comumContactFlags;
-            SharedTmpcontact.surface.mu = 0;
-            SharedTmpcontact.surface.bounce = 0;
-            SharedTmpcontact.surface.soft_cfm = comumContactCFM;
-            SharedTmpcontact.surface.soft_erp = comumContactERP;
-            SharedTmpcontact.surface.slip1 = comumContactSLIP;
-            SharedTmpcontact.surface.slip2 = comumContactSLIP;
+                    IsAvCapsuleTilted = physicsconfig.GetBoolean("av_capsule_tilted", false);
 
-            m_materialContactsData[(int)Material.Stone].mu = 0.8f;
-            m_materialContactsData[(int)Material.Stone].bounce = 0.4f;
+                    contactsPerCollision = physicsconfig.GetInt("contacts_per_collision", 80);
 
-            m_materialContactsData[(int)Material.Metal].mu = 0.3f;
-            m_materialContactsData[(int)Material.Metal].bounce = 0.4f;
+                    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);
 
-            m_materialContactsData[(int)Material.Glass].mu = 0.2f;
-            m_materialContactsData[(int)Material.Glass].bounce = 0.7f;
+                    geomDefaultDensity = physicsconfig.GetFloat("geometry_default_density", 10.000006836f);
+                    bodyFramesAutoDisable = physicsconfig.GetInt("body_frames_auto_disable", 20);
 
-            m_materialContactsData[(int)Material.Wood].mu = 0.6f;
-            m_materialContactsData[(int)Material.Wood].bounce = 0.5f;
+                    bodyPIDD = physicsconfig.GetFloat("body_pid_derivative", 35f);
+                    bodyPIDG = physicsconfig.GetFloat("body_pid_gain", 25f);
 
-            m_materialContactsData[(int)Material.Flesh].mu = 0.9f;
-            m_materialContactsData[(int)Material.Flesh].bounce = 0.3f;
+                    forceSimplePrimMeshing = physicsconfig.GetBoolean("force_simple_prim_meshing", forceSimplePrimMeshing);
+                    meshSculptedPrim = physicsconfig.GetBoolean("mesh_sculpted_prim", true);
+                    meshSculptLOD = physicsconfig.GetFloat("mesh_lod", 32f);
+                    MeshSculptphysicalLOD = physicsconfig.GetFloat("mesh_physical_lod", 16f);
+                    m_filterCollisions = physicsconfig.GetBoolean("filter_collisions", false);
+                    
+                    
 
-            m_materialContactsData[(int)Material.Plastic].mu = 0.4f;
-            m_materialContactsData[(int)Material.Plastic].bounce = 0.7f;
+                    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);
+                    }
 
-            m_materialContactsData[(int)Material.Rubber].mu = 0.9f;
-            m_materialContactsData[(int)Material.Rubber].bounce = 0.95f;
+                    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);
 
-            m_materialContactsData[(int)Material.light].mu = 0.0f;
-            m_materialContactsData[(int)Material.light].bounce = 0.0f;
+                    m_NINJA_physics_joints_enabled = physicsconfig.GetBoolean("use_NINJA_physics_joints", false);
+                    minimumGroundFlightOffset = physicsconfig.GetFloat("minimum_ground_flight_offset", 3f);
+                    maximumMassObject = physicsconfig.GetFloat("maximum_mass_object", 10000.01f);
+                }
+            }
 
+            contacts = new d.ContactGeom[contactsPerCollision];
 
             spacesPerMeterX = 1.0f / metersInSpace;
-            spacesPerMeterY = spacesPerMeterX;
+            spacesPerMeterY = 1.0f / metersInSpace;
+
             spaceGridMaxX = (int)(WorldExtents.X * spacesPerMeterX);
             spaceGridMaxY = (int)(WorldExtents.Y * spacesPerMeterY);
 
+            // ubit: limit number of spaces
             if (spaceGridMaxX > 40)
             {
                 spaceGridMaxX = 40;
                 spacesPerMeterX = WorldExtents.X / spaceGridMaxX;
             }
-
             if (spaceGridMaxY > 40)
             {
                 spaceGridMaxY = 40;
-                spacesPerMeterY = WorldExtents.Y / spaceGridMaxY;
+                spacesPerMeterY = WorldExtents.X / spaceGridMaxY;
             }
 
-            staticPrimspace = new IntPtr[spaceGridMaxX, spaceGridMaxY];
+            staticPrimspace = new IntPtr[spaceGridMaxX, spaceGridMaxY]; 
 
-            // create all spaces now
-            int i, j;
-            IntPtr newspace;
+            // make this index limits
+            spaceGridMaxX--;
+            spaceGridMaxY--;
 
-            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--;
+            // Centeral contact friction and bounce
+            // ckrinke 11/10/08 Enabling soft_erp but not soft_cfm until I figure out why
+            // an avatar falls through in Z but not in X or Y when walking on a prim.
+            contact.surface.mode |= d.ContactFlags.SoftERP;
+            contact.surface.mu = nmAvatarObjectContactFriction;
+            contact.surface.bounce = nmAvatarObjectContactBounce;
+            contact.surface.soft_cfm = 0.010f;
+            contact.surface.soft_erp = 0.010f;
+
+            // Terrain contact friction and Bounce
+            // This is the *non* moving version.   Use this when an avatar
+            // isn't moving to keep it in place better
+            TerrainContact.surface.mode |= d.ContactFlags.SoftERP;
+            TerrainContact.surface.mu = nmTerrainContactFriction;
+            TerrainContact.surface.bounce = nmTerrainContactBounce;
+            TerrainContact.surface.soft_erp = nmTerrainContactERP;
+
+            WaterContact.surface.mode |= (d.ContactFlags.SoftERP | d.ContactFlags.SoftCFM);
+            WaterContact.surface.mu = 0f; // No friction
+            WaterContact.surface.bounce = 0.0f; // No bounce
+            WaterContact.surface.soft_cfm = 0.010f;
+            WaterContact.surface.soft_erp = 0.010f;
+
+            // Prim contact friction and bounce
+            // THis is the *non* moving version of friction and bounce
+            // Use this when an avatar comes in contact with a prim
+            // and is moving
+            AvatarMovementprimContact.surface.mu = mAvatarObjectContactFriction;
+            AvatarMovementprimContact.surface.bounce = mAvatarObjectContactBounce;
+
+            // Terrain contact friction bounce and various error correcting calculations
+            // Use this when an avatar is in contact with the terrain and moving.
+            AvatarMovementTerrainContact.surface.mode |= d.ContactFlags.SoftERP;
+            AvatarMovementTerrainContact.surface.mu = mTerrainContactFriction;
+            AvatarMovementTerrainContact.surface.bounce = mTerrainContactBounce;
+            AvatarMovementTerrainContact.surface.soft_erp = mTerrainContactERP;
 
-            // create 4 off world spaces (x<0,x>max,y<0,y>max)
-            staticPrimspaceOffRegion = new IntPtr[4];
+            /*
+                <summary></summary>
+                Stone = 0,
+                /// <summary></summary>
+                Metal = 1,
+                /// <summary></summary>
+                Glass = 2,
+                /// <summary></summary>
+                Wood = 3,
+                /// <summary></summary>
+                Flesh = 4,
+                /// <summary></summary>
+                Plastic = 5,
+                /// <summary></summary>
+                Rubber = 6
+             */
+
+            m_materialContacts = new d.Contact[7,2];
+
+            m_materialContacts[(int)Material.Stone, 0] = new d.Contact();
+            m_materialContacts[(int)Material.Stone, 0].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Stone, 0].surface.mu = nmAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Stone, 0].surface.bounce = nmAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Stone, 0].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Stone, 0].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Stone, 1] = new d.Contact();
+            m_materialContacts[(int)Material.Stone, 1].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Stone, 1].surface.mu = mAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Stone, 1].surface.bounce = mAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Stone, 1].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Stone, 1].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Metal, 0] = new d.Contact();
+            m_materialContacts[(int)Material.Metal, 0].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Metal, 0].surface.mu = nmAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Metal, 0].surface.bounce = nmAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Metal, 0].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Metal, 0].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Metal, 1] = new d.Contact();
+            m_materialContacts[(int)Material.Metal, 1].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Metal, 1].surface.mu = mAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Metal, 1].surface.bounce = mAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Metal, 1].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Metal, 1].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Glass, 0] = new d.Contact();
+            m_materialContacts[(int)Material.Glass, 0].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Glass, 0].surface.mu = 1f;
+            m_materialContacts[(int)Material.Glass, 0].surface.bounce = 0.5f;
+            m_materialContacts[(int)Material.Glass, 0].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Glass, 0].surface.soft_erp = 0.010f;
 
-            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);
+            /*
+                private float nmAvatarObjectContactFriction = 250f;
+                private float nmAvatarObjectContactBounce = 0.1f;
 
-                    staticPrimspaceOffRegion[i] = newspace;
+                private float mAvatarObjectContactFriction = 75f;
+                private float mAvatarObjectContactBounce = 0.1f;
+            */
+            m_materialContacts[(int)Material.Glass, 1] = new d.Contact();
+            m_materialContacts[(int)Material.Glass, 1].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Glass, 1].surface.mu = 1f;
+            m_materialContacts[(int)Material.Glass, 1].surface.bounce = 0.5f;
+            m_materialContacts[(int)Material.Glass, 1].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Glass, 1].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Wood, 0] = new d.Contact();
+            m_materialContacts[(int)Material.Wood, 0].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Wood, 0].surface.mu = nmAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Wood, 0].surface.bounce = nmAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Wood, 0].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Wood, 0].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Wood, 1] = new d.Contact();
+            m_materialContacts[(int)Material.Wood, 1].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Wood, 1].surface.mu = mAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Wood, 1].surface.bounce = mAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Wood, 1].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Wood, 1].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Flesh, 0] = new d.Contact();
+            m_materialContacts[(int)Material.Flesh, 0].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Flesh, 0].surface.mu = nmAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Flesh, 0].surface.bounce = nmAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Flesh, 0].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Flesh, 0].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Flesh, 1] = new d.Contact();
+            m_materialContacts[(int)Material.Flesh, 1].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Flesh, 1].surface.mu = mAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Flesh, 1].surface.bounce = mAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Flesh, 1].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Flesh, 1].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Plastic, 0] = new d.Contact();
+            m_materialContacts[(int)Material.Plastic, 0].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Plastic, 0].surface.mu = nmAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Plastic, 0].surface.bounce = nmAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Plastic, 0].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Plastic, 0].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Plastic, 1] = new d.Contact();
+            m_materialContacts[(int)Material.Plastic, 1].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Plastic, 1].surface.mu = mAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Plastic, 1].surface.bounce = mAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Plastic, 1].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Plastic, 1].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Rubber, 0] = new d.Contact();
+            m_materialContacts[(int)Material.Rubber, 0].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Rubber, 0].surface.mu = nmAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Rubber, 0].surface.bounce = nmAvatarObjectContactBounce;
+            m_materialContacts[(int)Material.Rubber, 0].surface.soft_cfm = 0.010f;
+            m_materialContacts[(int)Material.Rubber, 0].surface.soft_erp = 0.010f;
+
+            m_materialContacts[(int)Material.Rubber, 1] = new d.Contact();
+            m_materialContacts[(int)Material.Rubber, 1].surface.mode |= d.ContactFlags.SoftERP;
+            m_materialContacts[(int)Material.Rubber, 1].surface.mu = mAvatarObjectContactFriction;
+            m_materialContacts[(int)Material.Rubber, 1].surface.bounce = mAvatarObjectContactBounce;
+            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);
+
+            // Set the gravity,, don't disable things automatically (we set it explicitly on some things)
+
+            d.WorldSetGravity(world, gravityx, gravityy, gravityz);
+            d.WorldSetContactSurfaceLayer(world, contactsurfacelayer);
+
+            d.WorldSetLinearDamping(world, 256f);
+            d.WorldSetAngularDamping(world, 256f);
+            d.WorldSetAngularDampingThreshold(world, 256f);
+            d.WorldSetLinearDampingThreshold(world, 256f);
+            d.WorldSetMaxAngularSpeed(world, 256f);
+
+            // Set how many steps we go without running collision testing
+            // This is in addition to the step size.
+            // Essentially Steps * m_physicsiterations
+            d.WorldSetQuickStepNumIterations(world, m_physicsiterations);
+            //d.WorldSetContactMaxCorrectingVel(world, 1000.0f);
+
+            for (int i = 0; i < staticPrimspace.GetLength(0); i++)
+            {
+                for (int j = 0; j < staticPrimspace.GetLength(1); j++)
+                {
+                    staticPrimspace[i, j] = IntPtr.Zero;
                 }
+            }
 
-            m_lastframe = DateTime.UtcNow;
-            m_lastMeshExpire = m_lastframe;
+            _worldInitialized = true;
         }
 
-        internal void waitForSpaceUnlock(IntPtr space)
-        {
-            //if (space != IntPtr.Zero)
-                //while (d.SpaceLockQuery(space)) { } // Wait and do nothing
-        }
+//        internal void waitForSpaceUnlock(IntPtr space)
+//        {
+//            //if (space != IntPtr.Zero)
+//                //while (d.SpaceLockQuery(space)) { } // Wait and do nothing
+//        }
+
+//        /// <summary>
+//        /// Debug space message for printing the space that a prim/avatar is in.
+//        /// </summary>
+//        /// <param name="pos"></param>
+//        /// <returns>Returns which split up space the given position is in.</returns>
+//        public string whichspaceamIin(Vector3 pos)
+//        {
+//            return calculateSpaceForGeom(pos).ToString();
+//        }
 
         #region Collision Detection
 
-        // sets a global contact for a joint for contactgeom , and base contact description)
-
-        
-
-        private IntPtr CreateContacJoint(ref d.ContactGeom contactGeom)
+        /// <summary>
+        /// Collides two geometries.
+        /// </summary>
+        /// <returns></returns>
+        /// <param name='geom1'></param>
+        /// <param name='geom2'>/param>
+        /// <param name='maxContacts'></param>
+        /// <param name='contactsArray'></param>
+        /// <param name='contactGeomSize'></param>
+        private int CollideGeoms(
+            IntPtr geom1, IntPtr geom2, int maxContacts, Ode.NET.d.ContactGeom[] contactsArray, int contactGeomSize)
         {
-            if (m_global_contactcount >= maxContactsbeforedeath)
-                return IntPtr.Zero;
+            int count;
+
+            lock (OdeScene.UniversalColliderSyncObject)
+            {
+                // We do this inside the lock so that we don't count any delay in acquiring it
+                if (CollectStats)
+                    m_nativeCollisionStartTick = Util.EnvironmentTickCount();
 
-            m_global_contactcount++;
+                count = d.Collide(geom1, geom2, maxContacts, contactsArray, contactGeomSize);
+            }
 
-            SharedTmpcontact.geom.depth = contactGeom.depth;
-            SharedTmpcontact.geom.pos = contactGeom.pos;
-            SharedTmpcontact.geom.normal = contactGeom.normal;
+            // We do this outside the lock so that any waiting threads aren't held up, though the effect is probably
+            // negligable
+            if (CollectStats)
+                m_stats[ODENativeGeomCollisionFrameMsStatName]
+                    += Util.EnvironmentTickCountSubtract(m_nativeCollisionStartTick);
 
-            IntPtr contact = new IntPtr(GlobalContactsArray.ToInt64() + (Int64)(m_global_contactcount * d.Contact.unmanagedSizeOf));
-            Marshal.StructureToPtr(SharedTmpcontact, contact, true);
-            return d.JointCreateContactPtr(world, contactgroup, contact);
+            return count;
         }
 
-        private bool GetCurContactGeom(int index, ref d.ContactGeom newcontactgeom)
+        /// <summary>
+        /// Collide two spaces or a space and a geometry.
+        /// </summary>
+        /// <param name='space1'></param>
+        /// <param name='space2'>/param>
+        /// <param name='data'></param>
+        private void CollideSpaces(IntPtr space1, IntPtr space2, IntPtr data)
         {
-            if (ContactgeomsArray == IntPtr.Zero || index >= contactsPerCollision)
-                return false;
+            if (CollectStats)
+            {
+                m_inCollisionTiming = true;
+                m_nativeCollisionStartTick = Util.EnvironmentTickCount();
+            }
 
-            IntPtr contactptr = new IntPtr(ContactgeomsArray.ToInt64() + (Int64)(index * d.ContactGeom.unmanagedSizeOf));
-            newcontactgeom = (d.ContactGeom)Marshal.PtrToStructure(contactptr, typeof(d.ContactGeom));
-            return true;
+            d.SpaceCollide2(space1, space2, data, nearCallback);
+
+            if (CollectStats && m_inCollisionTiming)
+            {
+                m_stats[ODENativeSpaceCollisionFrameMsStatName]
+                    += Util.EnvironmentTickCountSubtract(m_nativeCollisionStartTick);
+                m_inCollisionTiming = false;
+            }
         }
 
         /// <summary>
@@ -664,50 +1016,76 @@ namespace OpenSim.Region.Physics.OdePlugin
         /// <param name="space">The space that contains the geoms.  Remember, spaces are also geoms</param>
         /// <param name="g1">a geometry or space</param>
         /// <param name="g2">another geometry or space</param>
-        /// 
-
         private void near(IntPtr space, IntPtr g1, IntPtr g2)
         {
-            //  no lock here!  It's invoked from within Simulate(), which is thread-locked
+            if (CollectStats && m_inCollisionTiming)
+            {
+                m_stats[ODENativeSpaceCollisionFrameMsStatName]
+                    += Util.EnvironmentTickCountSubtract(m_nativeCollisionStartTick);
+                m_inCollisionTiming = false;
+            }
 
-            if (m_global_contactcount >= maxContactsbeforedeath)
-                return;
+//            m_log.DebugFormat("[PHYSICS]: Colliding {0} and {1} in {2}", g1, g2, space);
+            //  no lock here!  It's invoked from within Simulate(), which is thread-locked
 
             // Test if we're colliding a geom with a space.
             // If so we have to drill down into the space recursively
 
-            if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
-                return;
-
             if (d.GeomIsSpace(g1) || d.GeomIsSpace(g2))
             {
+                if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
+                    return;
+                
+                // Separating static prim geometry spaces.
                 // 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);
+                    CollideSpaces(g1, g2, IntPtr.Zero);
                 }
                 catch (AccessViolationException)
                 {
-                    m_log.Warn("[PHYSICS]: Unable to collide test a space");
+                    m_log.Error("[ODE SCENE]: Unable to collide test a space");
                     return;
                 }
-                //here one should check collisions of geoms inside a space
-                // but on each space we only should have geoms that not colide amoung each other
-                // so we don't dig inside spaces
+                //Colliding a space or a geom with a space or a geom. so drill down
+
+                //Collide all geoms in each space..
+                //if (d.GeomIsSpace(g1)) d.SpaceCollide(g1, IntPtr.Zero, nearCallback);
+                //if (d.GeomIsSpace(g2)) d.SpaceCollide(g2, IntPtr.Zero, nearCallback);
                 return;
             }
 
-            // get geom bodies to check if we already a joint contact
-            // guess this shouldn't happen now
+            if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
+                return;
+
             IntPtr b1 = d.GeomGetBody(g1);
             IntPtr b2 = d.GeomGetBody(g2);
 
             // d.GeomClassID id = d.GeomGetClass(g1);
 
+            String name1 = null;
+            String name2 = null;
+
+            if (!geom_name_map.TryGetValue(g1, out name1))
+            {
+                name1 = "null";
+            }
+            if (!geom_name_map.TryGetValue(g2, out name2))
+            {
+                name2 = "null";
+            }
+
+            //if (id == d.GeomClassId.TriMeshClass)
+            //{
+                //               m_log.InfoFormat("near: A collision was detected between {1} and {2}", 0, name1, name2);
+                //m_log.Debug("near: A collision was detected between {1} and {2}", 0, name1, name2);
+            //}
+
             // Figure out how many contact points we have
             int count = 0;
+
             try
             {
                 // Colliding Geom To Geom
@@ -718,496 +1096,1032 @@ 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;
-                                    }
-                                }
-                //
-                */
 
+                count = CollideGeoms(g1, g2, contacts.Length, contacts, d.ContactGeom.SizeOf);
 
-                if (d.GeomGetCategoryBits(g1) == (uint)CollisionCategories.VolumeDtc ||
-                    d.GeomGetCategoryBits(g2) == (uint)CollisionCategories.VolumeDtc)
-                {
-                    int cflags;
-                    unchecked
-                    {
-                        cflags = (int)(1 | d.CONTACTS_UNIMPORTANT);
-                    }
-                    count = d.CollidePtr(g1, g2, cflags, ContactgeomsArray, d.ContactGeom.unmanagedSizeOf);
-                }
-                else
-                    count = d.CollidePtr(g1, g2, (contactsPerCollision & 0xffff), ContactgeomsArray, d.ContactGeom.unmanagedSizeOf);
+                // All code after this is only relevant if we have any collisions
+                if (count <= 0)
+                    return;
+
+                if (count > contacts.Length)
+                    m_log.Error("[ODE SCENE]: Got " + count + " contacts when we asked for a maximum of " + contacts.Length);
             }
             catch (SEHException)
             {
-                m_log.Error("[PHYSICS]: The Operating system shut down ODE because of corrupt memory.  This could be a result of really irregular terrain.  If this repeats continuously, restart using Basic Physics and terrain fill your terrain.  Restarting the sim.");
-                //                ode.drelease(world);
+                m_log.Error(
+                    "[ODE SCENE]: The Operating system shut down ODE because of corrupt memory.  This could be a result of really irregular terrain.  If this repeats continuously, restart using Basic Physics and terrain fill your terrain.  Restarting the sim.");
                 base.TriggerPhysicsBasedRestart();
             }
             catch (Exception e)
             {
-                m_log.WarnFormat("[PHYSICS]: Unable to collide test an object: {0}", e.Message);
+                m_log.ErrorFormat("[ODE SCENE]: Unable to collide test an object: {0}", e.Message);
                 return;
             }
 
-            // contacts done
-            if (count == 0)
-                return;
-
-            // try get physical actors 
             PhysicsActor p1;
             PhysicsActor p2;
-
+            
+            p1ExpectedPoints = 0;
+            p2ExpectedPoints = 0;
+            
             if (!actor_name_map.TryGetValue(g1, out p1))
             {
-                m_log.WarnFormat("[PHYSICS]: failed actor mapping for geom 1");
-                return;
+                p1 = PANull;
             }
 
             if (!actor_name_map.TryGetValue(g2, out p2))
             {
-                m_log.WarnFormat("[PHYSICS]: failed actor mapping for geom 2");
-                return;
+                p2 = PANull;
             }
 
-            // update actors collision score
-            if (p1.CollisionScore >= float.MaxValue - count)
+            ContactPoint maxDepthContact = new ContactPoint();
+            if (p1.CollisionScore + count >= float.MaxValue)
                 p1.CollisionScore = 0;
             p1.CollisionScore += count;
 
-            if (p2.CollisionScore >= float.MaxValue - count)
+            if (p2.CollisionScore + count >= float.MaxValue)
                 p2.CollisionScore = 0;
             p2.CollisionScore += count;
 
-            // get first contact
-            d.ContactGeom curContact = new d.ContactGeom();
-
-            if (!GetCurContactGeom(0, ref curContact))
-                return;
-
-            ContactPoint maxDepthContact = new ContactPoint();
-
-            // do volume detection case
-            if ((p1.IsVolumeDtc || p2.IsVolumeDtc))
+            for (int i = 0; i < count; i++)
             {
-                maxDepthContact = new ContactPoint(
-                    new Vector3(curContact.pos.X, curContact.pos.Y, curContact.pos.Z),
-                    new Vector3(curContact.normal.X, curContact.normal.Y, curContact.normal.Z),
-                    curContact.depth, false
+                d.ContactGeom curContact = contacts[i];
+
+                if (curContact.depth > maxDepthContact.PenetrationDepth)
+                {
+                    maxDepthContact = new ContactPoint(
+                        new Vector3(curContact.pos.X, curContact.pos.Y, curContact.pos.Z),
+                        new Vector3(curContact.normal.X, curContact.normal.Y, curContact.normal.Z),
+                        curContact.depth
                     );
+                }
 
-                collision_accounting_events(p1, p2, maxDepthContact);
-                return;
-            }
+                //m_log.Warn("[CCOUNT]: " + count);
+                IntPtr joint;
+                // If we're colliding with terrain, use 'TerrainContact' instead of contact.
+                // allows us to have different settings
+                
+                // We only need to test p2 for 'jump crouch purposes'
+                if (p2 is OdeCharacter && p1.PhysicsActorType == (int)ActorTypes.Prim)
+                {
+                    // Testing if the collision is at the feet of the avatar
+
+                    //m_log.DebugFormat("[PHYSICS]: {0} - {1} - {2} - {3}", curContact.pos.Z, p2.Position.Z, (p2.Position.Z - curContact.pos.Z), (p2.Size.Z * 0.6f));
+                    if ((p2.Position.Z - curContact.pos.Z) > (p2.Size.Z * 0.6f))
+                        p2.IsColliding = true;
+                }
+                else
+                {
+                    p2.IsColliding = true;
+                }
+                
+                //if ((framecount % m_returncollisions) == 0)
 
-            // big messy collision analises
+                switch (p1.PhysicsActorType)
+                {
+                    case (int)ActorTypes.Agent:
+                        p1ExpectedPoints = avatarExpectedContacts;
+                        p2.CollidingObj = true;
+                        break;
+                    case (int)ActorTypes.Prim:
+                        if (p1 != null && p1 is OdePrim)
+                            p1ExpectedPoints = ((OdePrim) p1).ExpectedCollisionContacts;
 
-            float mu = 0;
-            float bounce = 0;
-//            bool IgnoreNegSides = false;
+                        if (p2.Velocity.LengthSquared() > 0.0f)
+                            p2.CollidingObj = true;
+                        break;
+                    case (int)ActorTypes.Unknown:
+                        p2.CollidingGround = true;
+                        break;
+                    default:
+                        p2.CollidingGround = true;
+                        break;
+                }
 
-            ContactData contactdata1 = new ContactData(0, 0, false);
-            ContactData contactdata2 = new ContactData(0, 0, false);
+                // we don't want prim or avatar to explode
 
-            bool dop1ava = false;
-            bool dop2ava = false;
-            bool ignore = false;
+                #region InterPenetration Handling - Unintended physics explosions
+# region disabled code1
 
-            switch (p1.PhysicsActorType)
-            {
-                case (int)ActorTypes.Agent:
+                if (curContact.depth >= 0.08f)
+                {
+                    //This is disabled at the moment only because it needs more tweaking
+                    //It will eventually be uncommented
+                    /*
+                    if (contact.depth >= 1.00f)
                     {
-                        dop1ava = true;
-                        switch (p2.PhysicsActorType)
-                        {
-                            case (int)ActorTypes.Agent:
-                            case (int)ActorTypes.Prim:
-                                break;
-
-                            default:
-                                ignore = true; // avatar to terrain and water ignored
-                                break;
-                        }
-                        break;
+                        //m_log.Debug("[PHYSICS]: " + contact.depth.ToString());
                     }
 
-                case (int)ActorTypes.Prim:
+                    //If you interpenetrate a prim with an agent
+                    if ((p2.PhysicsActorType == (int) ActorTypes.Agent &&
+                         p1.PhysicsActorType == (int) ActorTypes.Prim) ||
+                        (p1.PhysicsActorType == (int) ActorTypes.Agent &&
+                         p2.PhysicsActorType == (int) ActorTypes.Prim))
                     {
-                        switch (p2.PhysicsActorType)
+                        
+                        //contact.depth = contact.depth * 4.15f;
+                        /*
+                        if (p2.PhysicsActorType == (int) ActorTypes.Agent)
                         {
-                            case (int)ActorTypes.Agent:
-                                dop2ava = true;
-                                break;
-
-                            case (int)ActorTypes.Prim:
-                                Vector3 relV = p1.Velocity - p2.Velocity;
-                                float relVlenSQ = relV.LengthSquared();
-                                if (relVlenSQ > 0.0001f)
-                                {
-                                    p1.CollidingObj = true;
-                                    p2.CollidingObj = true;
-                                }
-                                p1.getContactData(ref contactdata1);
-                                p2.getContactData(ref contactdata2);
-                                bounce = contactdata1.bounce * contactdata2.bounce;
-                                mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
+                            p2.CollidingObj = true;
+                            contact.depth = 0.003f;
+                            p2.Velocity = p2.Velocity + new PhysicsVector(0, 0, 2.5f);
+                            OdeCharacter character = (OdeCharacter) p2;
+                            character.SetPidStatus(true);
+                            contact.pos = new d.Vector3(contact.pos.X + (p1.Size.X / 2), contact.pos.Y + (p1.Size.Y / 2), contact.pos.Z + (p1.Size.Z / 2));
 
-                                if (relVlenSQ > 0.01f)
-                                    mu *= frictionMovementMult;
+                        }
+                        else
+                        {
 
-                                break;
+                            //contact.depth = 0.0000000f;
+                        }
+                        if (p1.PhysicsActorType == (int) ActorTypes.Agent)
+                        {
 
-                            case (int)ActorTypes.Ground:
-                                p1.getContactData(ref contactdata1);
-                                bounce = contactdata1.bounce * TerrainBounce;
-                                mu = (float)Math.Sqrt(contactdata1.mu * TerrainFriction);
-
-                                if (Math.Abs(p1.Velocity.X) > 0.1f || Math.Abs(p1.Velocity.Y) > 0.1f)
-                                    mu *= frictionMovementMult;
-                                p1.CollidingGround = true;
-                                /*
-                                                            if (d.GeomGetClass(g1) == d.GeomClassID.TriMeshClass)
-                                                            {
-                                                                if (curContact.side1 > 0)
-                                                                    IgnoreNegSides = true;
-                                                            }
-                                 */
-                                break;
+                            p1.CollidingObj = true;
+                            contact.depth = 0.003f;
+                            p1.Velocity = p1.Velocity + new PhysicsVector(0, 0, 2.5f);
+                            contact.pos = new d.Vector3(contact.pos.X + (p2.Size.X / 2), contact.pos.Y + (p2.Size.Y / 2), contact.pos.Z + (p2.Size.Z / 2));
+                            OdeCharacter character = (OdeCharacter)p1;
+                            character.SetPidStatus(true);
+                        }
+                        else
+                        {
 
-                            case (int)ActorTypes.Water:
-                            default:
-                                ignore = true;
-                                break;
+                            //contact.depth = 0.0000000f;
                         }
+                          
+                        
+                     
                     }
-                    break;
-
-                case (int)ActorTypes.Ground:
-                    if (p2.PhysicsActorType == (int)ActorTypes.Prim)
+*/
+                    // If you interpenetrate a prim with another prim
+                /*
+                    if (p1.PhysicsActorType == (int) ActorTypes.Prim && p2.PhysicsActorType == (int) ActorTypes.Prim)
                     {
-                        p2.CollidingGround = true;
-                        p2.getContactData(ref contactdata2);
-                        bounce = contactdata2.bounce * TerrainBounce;
-                        mu = (float)Math.Sqrt(contactdata2.mu * TerrainFriction);
-
-//                        if (curContact.side1 > 0) // should be 2 ?
-//                            IgnoreNegSides = true;
+                        #region disabledcode2
+                        //OdePrim op1 = (OdePrim)p1;
+                        //OdePrim op2 = (OdePrim)p2;
+                        //op1.m_collisionscore++;
+                        //op2.m_collisionscore++;
+
+                        //if (op1.m_collisionscore > 8000 || op2.m_collisionscore > 8000)
+                        //{
+                            //op1.m_taintdisable = true;
+                            //AddPhysicsActorTaint(p1);
+                            //op2.m_taintdisable = true;
+                            //AddPhysicsActorTaint(p2);
+                        //}
+
+                        //if (contact.depth >= 0.25f)
+                        //{
+                            // Don't collide, one or both prim will expld.
+
+                            //op1.m_interpenetrationcount++;
+                            //op2.m_interpenetrationcount++;
+                            //interpenetrations_before_disable = 200;
+                            //if (op1.m_interpenetrationcount >= interpenetrations_before_disable)
+                            //{
+                                //op1.m_taintdisable = true;
+                                //AddPhysicsActorTaint(p1);
+                            //}
+                            //if (op2.m_interpenetrationcount >= interpenetrations_before_disable)
+                            //{
+                               // op2.m_taintdisable = true;
+                                //AddPhysicsActorTaint(p2);
+                            //}
+
+                            //contact.depth = contact.depth / 8f;
+                            //contact.normal = new d.Vector3(0, 0, 1);
+                        //}
+                        //if (op1.m_disabled || op2.m_disabled)
+                        //{
+                            //Manually disabled objects stay disabled
+                            //contact.depth = 0f;
+                        //}
+                        #endregion
+                    }
+                    */
+#endregion
+                    if (curContact.depth >= 1.00f)
+                    {
+                        //m_log.Info("[P]: " + contact.depth.ToString());
+                        if ((p2.PhysicsActorType == (int) ActorTypes.Agent &&
+                             p1.PhysicsActorType == (int) ActorTypes.Unknown) ||
+                            (p1.PhysicsActorType == (int) ActorTypes.Agent &&
+                             p2.PhysicsActorType == (int) ActorTypes.Unknown))
+                        {
+                            if (p2.PhysicsActorType == (int) ActorTypes.Agent)
+                            {
+                                if (p2 is OdeCharacter)
+                                {
+                                    OdeCharacter character = (OdeCharacter) p2;
+
+                                    //p2.CollidingObj = true;
+                                    curContact.depth = 0.00000003f;
+                                    p2.Velocity = p2.Velocity + new Vector3(0f, 0f, 0.5f);
+                                    curContact.pos =
+                                        new d.Vector3(curContact.pos.X + (p1.Size.X/2),
+                                                      curContact.pos.Y + (p1.Size.Y/2),
+                                                      curContact.pos.Z + (p1.Size.Z/2));
+                                    character.SetPidStatus(true);
+                                }
+                            }
 
-                        if (Math.Abs(p2.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y) > 0.1f)
-                            mu *= frictionMovementMult;
+                            if (p1.PhysicsActorType == (int) ActorTypes.Agent)
+                            {
+                                if (p1 is OdeCharacter)
+                                {
+                                    OdeCharacter character = (OdeCharacter) p1;
+
+                                    //p2.CollidingObj = true;
+                                    curContact.depth = 0.00000003f;
+                                    p1.Velocity = p1.Velocity + new Vector3(0f, 0f, 0.5f);
+                                    curContact.pos =
+                                        new d.Vector3(curContact.pos.X + (p1.Size.X/2),
+                                                      curContact.pos.Y + (p1.Size.Y/2),
+                                                      curContact.pos.Z + (p1.Size.Z/2));
+                                    character.SetPidStatus(true);
+                                }
+                            }
+                        }
                     }
-                    else
-                        ignore = true;
-                    break;
+                }
 
-                case (int)ActorTypes.Water:
-                default:
-                    break;
-            }
+                #endregion
 
-            if (ignore)
-                return;
+                // Logic for collision handling
+                // Note, that if *all* contacts are skipped (VolumeDetect)
+                // The prim still detects (and forwards) collision events but 
+                // appears to be phantom for the world
+                Boolean skipThisContact = false;
 
-            IntPtr Joint;
-            bool FeetCollision = false;
-            int ncontacts = 0;
+                if ((p1 is OdePrim) && (((OdePrim)p1).m_isVolumeDetect))
+                    skipThisContact = true;   // No collision on volume detect prims
 
-            int i = 0;
+                if (av_av_collisions_off)
+                    if ((p1 is OdeCharacter) && (p2 is OdeCharacter))
+                        skipThisContact = true;
 
-            maxDepthContact = new ContactPoint();
-            maxDepthContact.PenetrationDepth = float.MinValue;
-            ContactPoint minDepthContact = new ContactPoint();
-            minDepthContact.PenetrationDepth = float.MaxValue;
+                if (!skipThisContact && (p2 is OdePrim) && (((OdePrim)p2).m_isVolumeDetect))
+                    skipThisContact = true;   // No collision on volume detect prims
 
-            SharedTmpcontact.geom.depth = 0;
-            SharedTmpcontact.surface.mu = mu;
-            SharedTmpcontact.surface.bounce = bounce;
+                if (!skipThisContact && curContact.depth < 0f)
+                    skipThisContact = true;
 
-            d.ContactGeom altContact = new d.ContactGeom();
-            bool useAltcontact = false;
-            bool noskip = true;
+                if (!skipThisContact && checkDupe(curContact, p2.PhysicsActorType))
+                    skipThisContact = true;
 
-            while (true)
-            {
-//                if (!(IgnoreNegSides && curContact.side1 < 0))
+                const int maxContactsbeforedeath = 4000;
+                joint = IntPtr.Zero;
+
+                if (!skipThisContact)
                 {
-                    noskip = true;
-                    useAltcontact = false;
+                    _perloopContact.Add(curContact);
 
-                    if (dop1ava)
+                    if (name1 == "Terrain" || name2 == "Terrain")
                     {
-                        if ((((OdeCharacter)p1).Collide(g1, g2, false, ref curContact, ref altContact , ref useAltcontact, ref FeetCollision)))
+                        if ((p2.PhysicsActorType == (int) ActorTypes.Agent) &&
+                            (Math.Abs(p2.Velocity.X) > 0.01f || Math.Abs(p2.Velocity.Y) > 0.01f))
+                        {
+                            p2ExpectedPoints = avatarExpectedContacts;
+                            // Avatar is moving on terrain, use the movement terrain contact
+                            AvatarMovementTerrainContact.geom = curContact;
+
+                            if (m_global_contactcount < maxContactsbeforedeath)
+                            {
+                                joint = d.JointCreateContact(world, contactgroup, ref AvatarMovementTerrainContact);
+                                m_global_contactcount++;
+                            }
+                        }
+                        else
                         {
                             if (p2.PhysicsActorType == (int)ActorTypes.Agent)
                             {
-                                p1.CollidingObj = true;
-                                p2.CollidingObj = true;
+                                p2ExpectedPoints = avatarExpectedContacts;
+                                // Avatar is standing on terrain, use the non moving terrain contact
+                                TerrainContact.geom = curContact;
+
+                                if (m_global_contactcount < maxContactsbeforedeath)
+                                {
+                                    joint = d.JointCreateContact(world, contactgroup, ref TerrainContact);
+                                    m_global_contactcount++;
+                                }
                             }
-                            else if (p2.Velocity.LengthSquared() > 0.0f)
-                                    p2.CollidingObj = true;
+                            else
+                            {
+                                if (p2.PhysicsActorType == (int)ActorTypes.Prim && p1.PhysicsActorType == (int)ActorTypes.Prim)
+                                {
+                                    // prim prim contact
+                                    // int pj294950 = 0;
+                                    int movintYN = 0;
+                                    int material = (int) Material.Wood;
+                                    // prim terrain contact
+                                    if (Math.Abs(p2.Velocity.X) > 0.01f || Math.Abs(p2.Velocity.Y) > 0.01f)
+                                    {
+                                        movintYN = 1;
+                                    }
+
+                                    if (p2 is OdePrim)
+                                    {
+                                        material = ((OdePrim) p2).m_material;
+                                        p2ExpectedPoints = ((OdePrim)p2).ExpectedCollisionContacts;
+                                    }
+                                   
+                                    // Unnessesary because p1 is defined above
+                                    //if (p1 is OdePrim)
+                                    // { 
+                                    //     p1ExpectedPoints = ((OdePrim)p1).ExpectedCollisionContacts;
+                                    // }
+                                    //m_log.DebugFormat("Material: {0}", material);
+
+                                    m_materialContacts[material, movintYN].geom = curContact;
+
+                                    if (m_global_contactcount < maxContactsbeforedeath)
+                                    {
+                                        joint = d.JointCreateContact(world, contactgroup, ref m_materialContacts[material, movintYN]);
+                                        m_global_contactcount++;
+                                    }
+                                }
+                                else
+                                {
+                                    int movintYN = 0;
+                                    // prim terrain contact
+                                    if (Math.Abs(p2.Velocity.X) > 0.01f || Math.Abs(p2.Velocity.Y) > 0.01f)
+                                    {
+                                        movintYN = 1;
+                                    }
+
+                                    int material = (int)Material.Wood;
+
+                                    if (p2 is OdePrim)
+                                    {
+                                        material = ((OdePrim)p2).m_material;
+                                        p2ExpectedPoints = ((OdePrim)p2).ExpectedCollisionContacts;
+                                    }
+
+                                    //m_log.DebugFormat("Material: {0}", material);
+                                    m_materialContacts[material, movintYN].geom = curContact;
+
+                                    if (m_global_contactcount < maxContactsbeforedeath)
+                                    {
+                                        joint = d.JointCreateContact(world, contactgroup, ref m_materialContacts[material, movintYN]);
+                                        m_global_contactcount++;
+                                    }
+                                }
+                            }
+                        }
+                        //if (p2.PhysicsActorType == (int)ActorTypes.Prim)
+                        //{
+                        //m_log.Debug("[PHYSICS]: prim contacting with ground");
+                        //}
+                    }
+                    else if (name1 == "Water" || name2 == "Water")
+                    {
+                        /*
+                        if ((p2.PhysicsActorType == (int) ActorTypes.Prim))
+                        {
                         }
                         else
-                            noskip = false;
+                        {
+                        }
+                        */
+                        //WaterContact.surface.soft_cfm = 0.0000f;
+                        //WaterContact.surface.soft_erp = 0.00000f;
+                        if (curContact.depth > 0.1f)
+                        {
+                            curContact.depth *= 52;
+                            //contact.normal = new d.Vector3(0, 0, 1);
+                            //contact.pos = new d.Vector3(0, 0, contact.pos.Z - 5f);
+                        }
+
+                        WaterContact.geom = curContact;
+
+                        if (m_global_contactcount < maxContactsbeforedeath)
+                        {
+                            joint = d.JointCreateContact(world, contactgroup, ref WaterContact);
+                            m_global_contactcount++;
+                        }
+                        //m_log.Info("[PHYSICS]: Prim Water Contact" + contact.depth);
                     }
-                    else if (dop2ava)
+                    else
                     {
-                        if ((((OdeCharacter)p2).Collide(g2, g1, true, ref curContact, ref altContact , ref useAltcontact, ref FeetCollision)))
+                        if ((p2.PhysicsActorType == (int)ActorTypes.Agent))
+                        {
+                            p2ExpectedPoints = avatarExpectedContacts;
+                            if ((Math.Abs(p2.Velocity.X) > 0.01f || Math.Abs(p2.Velocity.Y) > 0.01f))
+                            {
+                                // Avatar is moving on a prim, use the Movement prim contact
+                                AvatarMovementprimContact.geom = curContact;
+
+                                if (m_global_contactcount < maxContactsbeforedeath)
+                                {
+                                    joint = d.JointCreateContact(world, contactgroup, ref AvatarMovementprimContact);
+                                    m_global_contactcount++;
+                                }
+                            }
+                            else
+                            {
+                                // Avatar is standing still on a prim, use the non movement contact
+                                contact.geom = curContact;
+
+                                if (m_global_contactcount < maxContactsbeforedeath)
+                                {
+                                    joint = d.JointCreateContact(world, contactgroup, ref contact);
+                                    m_global_contactcount++;
+                                }
+                            }
+                        }
+                        else if (p2.PhysicsActorType == (int)ActorTypes.Prim)
                         {
-                            if (p1.PhysicsActorType == (int)ActorTypes.Agent)
+                            //p1.PhysicsActorType
+                            int material = (int)Material.Wood;
+
+                            if (p2 is OdePrim)
+                            {
+                                material = ((OdePrim)p2).m_material;
+                                p2ExpectedPoints = ((OdePrim)p2).ExpectedCollisionContacts;
+                            }
+                            
+                            //m_log.DebugFormat("Material: {0}", material);
+                            m_materialContacts[material, 0].geom = curContact;
+
+                            if (m_global_contactcount < maxContactsbeforedeath)
                             {
-                                p1.CollidingObj = true;
-                                p2.CollidingObj = true;
+                                joint = d.JointCreateContact(world, contactgroup, ref m_materialContacts[material, 0]);
+                                m_global_contactcount++;
                             }
-                            else if (p2.Velocity.LengthSquared() > 0.0f)
-                                p1.CollidingObj = true;
                         }
-                        else
-                            noskip = false;
                     }
 
-                    if (noskip)
+                    if (m_global_contactcount < maxContactsbeforedeath && joint != IntPtr.Zero) // stack collide!
                     {
-                        if(useAltcontact)
-                            Joint = CreateContacJoint(ref altContact);
-                        else
-                            Joint = CreateContacJoint(ref curContact);
+                        d.JointAttach(joint, b1, b2);
+                        m_global_contactcount++;
+                    }
+                }
 
-                        if (Joint == IntPtr.Zero)
-                            break;
+                collision_accounting_events(p1, p2, maxDepthContact);
+                
+                if (count > ((p1ExpectedPoints + p2ExpectedPoints) * 0.25) + (geomContactPointsStartthrottle))
+                {
+                    // If there are more then 3 contact points, it's likely
+                    // that we've got a pile of objects, so ...
+                    // We don't want to send out hundreds of terse updates over and over again
+                    // so lets throttle them and send them again after it's somewhat sorted out.
+                    p2.ThrottleUpdates = true;
+                }
+                //m_log.Debug(count.ToString());
+                //m_log.Debug("near: A collision was detected between {1} and {2}", 0, name1, name2);
+            }
+        }
+
+        private bool checkDupe(d.ContactGeom contactGeom, int atype)
+        {
+            if (!m_filterCollisions)
+                return false;
 
-                        d.JointAttach(Joint, b1, b2);
+            bool result = false;
 
-                        ncontacts++;
+            ActorTypes at = (ActorTypes)atype;
 
-                        if (curContact.depth > maxDepthContact.PenetrationDepth)
+            foreach (d.ContactGeom contact in _perloopContact)
+            {
+                //if ((contact.g1 == contactGeom.g1 && contact.g2 == contactGeom.g2))
+                //{
+                    // || (contact.g2 == contactGeom.g1 && contact.g1 == contactGeom.g2)
+                if (at == ActorTypes.Agent)
+                {
+                    if (((Math.Abs(contactGeom.normal.X - contact.normal.X) < 1.026f)
+                        && (Math.Abs(contactGeom.normal.Y - contact.normal.Y) < 0.303f)
+                        && (Math.Abs(contactGeom.normal.Z - contact.normal.Z) < 0.065f)))
+                    {
+                        if (Math.Abs(contact.depth - contactGeom.depth) < 0.052f)
                         {
-                            maxDepthContact.Position.X = curContact.pos.X;
-                            maxDepthContact.Position.Y = curContact.pos.Y;
-                            maxDepthContact.Position.Z = curContact.pos.Z;
-                            maxDepthContact.PenetrationDepth = curContact.depth;
-                            maxDepthContact.CharacterFeet = FeetCollision;
+                            //contactGeom.depth *= .00005f;
+                           //m_log.DebugFormat("[Collsion]: Depth {0}", Math.Abs(contact.depth - contactGeom.depth));
+                            // m_log.DebugFormat("[Collision]: <{0},{1},{2}>", Math.Abs(contactGeom.normal.X - contact.normal.X), Math.Abs(contactGeom.normal.Y - contact.normal.Y), Math.Abs(contactGeom.normal.Z - contact.normal.Z));
+                            result = true;
+                            break;
                         }
+//                        else
+//                        {
+//                            //m_log.DebugFormat("[Collsion]: Depth {0}", Math.Abs(contact.depth - contactGeom.depth));
+//                        }
+                    }
+//                    else
+//                    {
+//                        //m_log.DebugFormat("[Collision]: <{0},{1},{2}>", Math.Abs(contactGeom.normal.X - contact.normal.X), Math.Abs(contactGeom.normal.Y - contact.normal.Y), Math.Abs(contactGeom.normal.Z - contact.normal.Z));
+//                        //int i = 0;
+//                    }
+                } 
+                else if (at == ActorTypes.Prim)
+                {
+                    //d.AABB aabb1 = new d.AABB();
+                    //d.AABB aabb2 = new d.AABB();
 
-                        if (curContact.depth < minDepthContact.PenetrationDepth)
+                    //d.GeomGetAABB(contactGeom.g2, out aabb2);
+                    //d.GeomGetAABB(contactGeom.g1, out aabb1);
+                    //aabb1.
+                    if (((Math.Abs(contactGeom.normal.X - contact.normal.X) < 1.026f) && (Math.Abs(contactGeom.normal.Y - contact.normal.Y) < 0.303f) && (Math.Abs(contactGeom.normal.Z - contact.normal.Z) < 0.065f)))
+                    {
+                        if (contactGeom.normal.X == contact.normal.X && contactGeom.normal.Y == contact.normal.Y && contactGeom.normal.Z == contact.normal.Z)
                         {
-                            minDepthContact.PenetrationDepth = curContact.depth;
-                            minDepthContact.SurfaceNormal.X = curContact.normal.X;
-                            minDepthContact.SurfaceNormal.Y = curContact.normal.Y;
-                            minDepthContact.SurfaceNormal.Z = curContact.normal.Z;
+                            if (Math.Abs(contact.depth - contactGeom.depth) < 0.272f)
+                            {
+                                result = true;
+                                break;
+                            }
                         }
+                        //m_log.DebugFormat("[Collision]: Depth {0}", Math.Abs(contact.depth - contactGeom.depth));
+                        //m_log.DebugFormat("[Collision]: <{0},{1},{2}>", Math.Abs(contactGeom.normal.X - contact.normal.X), Math.Abs(contactGeom.normal.Y - contact.normal.Y), Math.Abs(contactGeom.normal.Z - contact.normal.Z));
                     }
                 }
-                if (++i >= count)
-                    break;
-
-                if (!GetCurContactGeom(i, ref curContact))
-                    break;
             }
 
-            if (ncontacts > 0)
-            {
-                maxDepthContact.SurfaceNormal.X = minDepthContact.SurfaceNormal.X;
-                maxDepthContact.SurfaceNormal.Y = minDepthContact.SurfaceNormal.Y;
-                maxDepthContact.SurfaceNormal.Z = minDepthContact.SurfaceNormal.Z;
-
-                collision_accounting_events(p1, p2, maxDepthContact);
-            }
+            return result;
         }
 
         private void collision_accounting_events(PhysicsActor p1, PhysicsActor p2, ContactPoint contact)
         {
-            uint obj2LocalID = 0;
+            // obj1LocalID = 0;
+            //returncollisions = false;
+            obj2LocalID = 0;
+            //ctype = 0;
+            //cStartStop = 0;
+            if (!p2.SubscribedEvents() && !p1.SubscribedEvents())
+                return;
+
+            switch ((ActorTypes)p2.PhysicsActorType)
+            {
+                case ActorTypes.Agent:
+                    cc2 = (OdeCharacter)p2;
 
-            bool p1events = p1.SubscribedEvents();
-            bool p2events = p2.SubscribedEvents();
+                    // obj1LocalID = cc2.m_localID;
+                    switch ((ActorTypes)p1.PhysicsActorType)
+                    {
+                        case ActorTypes.Agent:
+                            cc1 = (OdeCharacter)p1;
+                            obj2LocalID = cc1.LocalID;
+                            cc1.AddCollisionEvent(cc2.LocalID, contact);
+                            //ctype = (int)CollisionCategories.Character;
+
+                            //if (cc1.CollidingObj)
+                            //cStartStop = (int)StatusIndicators.Generic;
+                            //else
+                            //cStartStop = (int)StatusIndicators.Start;
+
+                            //returncollisions = true;
+                            break;
 
-            if (p1.IsVolumeDtc)
-                p2events = false;
-            if (p2.IsVolumeDtc)
-                p1events = false;
+                        case ActorTypes.Prim:
+                            if (p1 is OdePrim)
+                            {
+                                cp1 = (OdePrim) p1;
+                                obj2LocalID = cp1.LocalID;
+                                cp1.AddCollisionEvent(cc2.LocalID, contact);
+                            }
+                            //ctype = (int)CollisionCategories.Geom;
 
-            if (!p2events && !p1events)
-                return;
+                            //if (cp1.CollidingObj)
+                            //cStartStop = (int)StatusIndicators.Generic;
+                            //else
+                            //cStartStop = (int)StatusIndicators.Start;
 
-            Vector3 vel = Vector3.Zero;
-            if (p2 != null && p2.IsPhysical)
-                vel = p2.Velocity;
+                            //returncollisions = true;
+                            break;
 
-            if (p1 != null && p1.IsPhysical)
-                vel -= p1.Velocity;
+                        case ActorTypes.Ground:
+                        case ActorTypes.Unknown:
+                            obj2LocalID = 0;
+                            //ctype = (int)CollisionCategories.Land;
+                            //returncollisions = true;
+                            break;
+                    }
 
-            contact.RelativeSpeed = Vector3.Dot(vel, contact.SurfaceNormal);
+                    cc2.AddCollisionEvent(obj2LocalID, contact);
+                    break;
 
-            switch ((ActorTypes)p1.PhysicsActorType)
-            {
-                case ActorTypes.Agent:
                 case ActorTypes.Prim:
+
+                    if (p2 is OdePrim)
                     {
-                        switch ((ActorTypes)p2.PhysicsActorType)
+                        cp2 = (OdePrim) p2;
+
+                        // obj1LocalID = cp2.m_localID;
+                        switch ((ActorTypes) p1.PhysicsActorType)
                         {
                             case ActorTypes.Agent:
+                                if (p1 is OdeCharacter)
+                                {
+                                    cc1 = (OdeCharacter) p1;
+                                    obj2LocalID = cc1.LocalID;
+                                    cc1.AddCollisionEvent(cp2.LocalID, contact);
+                                    //ctype = (int)CollisionCategories.Character;
+
+                                    //if (cc1.CollidingObj)
+                                    //cStartStop = (int)StatusIndicators.Generic;
+                                    //else
+                                    //cStartStop = (int)StatusIndicators.Start;
+                                    //returncollisions = true;
+                                }
+                                break;
                             case ActorTypes.Prim:
-                                if (p2events)
+
+                                if (p1 is OdePrim)
                                 {
-                                    AddCollisionEventReporting(p2);
-                                    p2.AddCollisionEvent(p1.ParentActor.LocalID, contact);
+                                    cp1 = (OdePrim) p1;
+                                    obj2LocalID = cp1.LocalID;
+                                    cp1.AddCollisionEvent(cp2.LocalID, contact);
+                                    //ctype = (int)CollisionCategories.Geom;
+
+                                    //if (cp1.CollidingObj)
+                                    //cStartStop = (int)StatusIndicators.Generic;
+                                    //else
+                                    //cStartStop = (int)StatusIndicators.Start;
+
+                                    //returncollisions = true;
                                 }
-                                obj2LocalID = p2.ParentActor.LocalID;
                                 break;
 
                             case ActorTypes.Ground:
                             case ActorTypes.Unknown:
-                            default:
                                 obj2LocalID = 0;
+                                //ctype = (int)CollisionCategories.Land;
+
+                                //returncollisions = true;
                                 break;
                         }
-                        if (p1events)
+
+                        cp2.AddCollisionEvent(obj2LocalID, contact);
+                    }
+                    break;
+            }
+            //if (returncollisions)
+            //{
+
+                //lock (m_storedCollisions)
+                //{
+                    //cDictKey = obj1LocalID.ToString() + obj2LocalID.ToString() + cStartStop.ToString() + ctype.ToString();
+                    //if (m_storedCollisions.ContainsKey(cDictKey))
+                    //{
+                        //sCollisionData objd = m_storedCollisions[cDictKey];
+                        //objd.NumberOfCollisions += 1;
+                        //objd.lastframe = framecount;
+                        //m_storedCollisions[cDictKey] = objd;
+                    //}
+                    //else
+                    //{
+                        //sCollisionData objd = new sCollisionData();
+                        //objd.ColliderLocalId = obj1LocalID;
+                        //objd.CollidedWithLocalId = obj2LocalID;
+                        //objd.CollisionType = ctype;
+                        //objd.NumberOfCollisions = 1;
+                        //objd.lastframe = framecount;
+                        //objd.StatusIndicator = cStartStop;
+                        //m_storedCollisions.Add(cDictKey, objd);
+                    //}
+                //}
+           // }
+        }
+
+        private int TriArrayCallback(IntPtr trimesh, IntPtr refObject, int[] triangleIndex, int triCount)
+        {
+            /*            String name1 = null;
+                        String name2 = null;
+
+                        if (!geom_name_map.TryGetValue(trimesh, out name1))
                         {
-                            contact.SurfaceNormal = -contact.SurfaceNormal;
-                            AddCollisionEventReporting(p1);
-                            p1.AddCollisionEvent(obj2LocalID, contact);
+                            name1 = "null";
                         }
-                        break;
-                    }
-                case ActorTypes.Ground:
-                case ActorTypes.Unknown:
-                default:
-                    {
-                        if (p2events && !p2.IsVolumeDtc)
+                        if (!geom_name_map.TryGetValue(refObject, out name2))
                         {
-                            AddCollisionEventReporting(p2);
-                            p2.AddCollisionEvent(0, contact);
+                            name2 = "null";
                         }
-                        break;
-                    }
-            }
+
+                        m_log.InfoFormat("TriArrayCallback: A collision was detected between {1} and {2}", 0, name1, name2);
+            */
+            return 1;
+        }
+
+        private int TriCallback(IntPtr trimesh, IntPtr refObject, int triangleIndex)
+        {
+//            String name1 = null;
+//            String name2 = null;
+//
+//            if (!geom_name_map.TryGetValue(trimesh, out name1))
+//            {
+//                name1 = "null";
+//            }
+//
+//            if (!geom_name_map.TryGetValue(refObject, out name2))
+//            {
+//                name2 = "null";
+//            }
+
+            //            m_log.InfoFormat("TriCallback: A collision was detected between {1} and {2}. Index was {3}", 0, name1, name2, triangleIndex);
+
+            d.Vector3 v0 = new d.Vector3();
+            d.Vector3 v1 = new d.Vector3();
+            d.Vector3 v2 = new d.Vector3();
+
+            d.GeomTriMeshGetTriangle(trimesh, 0, ref v0, ref v1, ref v2);
+            //            m_log.DebugFormat("Triangle {0} is <{1},{2},{3}>, <{4},{5},{6}>, <{7},{8},{9}>", triangleIndex, v0.X, v0.Y, v0.Z, v1.X, v1.Y, v1.Z, v2.X, v2.Y, v2.Z);
+
+            return 1;
         }
 
         /// <summary>
         /// This is our collision testing routine in ODE
         /// </summary>
-        /// <param name="timeStep"></param>
         private void collision_optimized()
         {
-            lock (_characters)
-                {
+            _perloopContact.Clear();
+
+            foreach (OdeCharacter chr in _characters)
+            {
+                // Reset the collision values to false
+                // since we don't know if we're colliding yet
+                if (chr.Shell == IntPtr.Zero || chr.Body == IntPtr.Zero)
+                    continue;
+                
+                chr.IsColliding = false;
+                chr.CollidingGround = false;
+                chr.CollidingObj = false;
+                
+                // Test the avatar's geometry for collision with the space
+                // This will return near and the space that they are the closest to
+                // And we'll run this again against the avatar and the space segment
+                // This will return with a bunch of possible objects in the space segment
+                // and we'll run it again on all of them.
                 try
                 {
-                    foreach (OdeCharacter chr in _characters)
-                    {
-                        if (chr == null || chr.Body == IntPtr.Zero)
-                            continue;
-
-                        chr.IsColliding = false;
-                        //                    chr.CollidingGround = false; not done here
-                        chr.CollidingObj = false;
-                        // do colisions with static space
-                        d.SpaceCollide2(chr.collider, StaticSpace, IntPtr.Zero, nearCallback);
-
-                        // no coll with gnd
-                    }
-                    // chars with chars
-                    d.SpaceCollide(CharsSpace, IntPtr.Zero, nearCallback);
-
+                    CollideSpaces(space, chr.Shell, IntPtr.Zero);
                 }
                 catch (AccessViolationException)
                 {
-                    m_log.Warn("[PHYSICS]: Unable to collide Character to static space");
+                    m_log.ErrorFormat("[ODE SCENE]: Unable to space collide {0}", Name);
                 }
-
+                
+                //float terrainheight = GetTerrainHeightAtXY(chr.Position.X, chr.Position.Y);
+                //if (chr.Position.Z + (chr.Velocity.Z * timeStep) < terrainheight + 10)
+                //{
+                //chr.Position.Z = terrainheight + 10.0f;
+                //forcedZ = true;
+                //}
             }
 
-            lock (_activeprims)
+            if (CollectStats)
             {
-                foreach (OdePrim aprim in _activeprims)
-                {
-                    aprim.CollisionScore = 0;
-                    aprim.IsColliding = false;
-                }
+                m_tempAvatarCollisionsThisFrame = _perloopContact.Count;
+                m_stats[ODEAvatarContactsStatsName] += m_tempAvatarCollisionsThisFrame;
             }
 
-            // collide active prims with static enviroment
-            lock (_activegroups)
+            List<OdePrim> removeprims = null;
+            foreach (OdePrim chr in _activeprims)
             {
-                try
+                if (chr.Body != IntPtr.Zero && d.BodyIsEnabled(chr.Body) && (!chr.m_disabled))
                 {
-                    foreach (OdePrim prm in _activegroups)
+                    try
                     {
-                        if (!prm.m_outbounds)
+                        lock (chr)
                         {
-                            if (d.BodyIsEnabled(prm.Body))
+                            if (space != IntPtr.Zero && chr.prim_geom != IntPtr.Zero && chr.m_taintremove == false)
                             {
-                                d.SpaceCollide2(StaticSpace, prm.collide_geom, IntPtr.Zero, nearCallback);
-                                d.SpaceCollide2(GroundSpace, prm.collide_geom, IntPtr.Zero, nearCallback);
+                                CollideSpaces(space, chr.prim_geom, IntPtr.Zero);
+                            }
+                            else
+                            {
+                                if (removeprims == null)
+                                {
+                                    removeprims = new List<OdePrim>();
+                                }
+                                removeprims.Add(chr);
+                                m_log.Error(
+                                    "[ODE SCENE]: unable to collide test active prim against space.  The space was zero, the geom was zero or it was in the process of being removed.  Removed it from the active prim list.  This needs to be fixed!");
                             }
                         }
                     }
-                }
-                catch (AccessViolationException)
-                {
-                    m_log.Warn("[PHYSICS]: Unable to collide Active prim to static space");
+                    catch (AccessViolationException)
+                    {
+                        m_log.Error("[ODE SCENE]: Unable to space collide");
+                    }
                 }
             }
-            // colide active amoung them
-            try
+
+            if (CollectStats)
+                m_stats[ODEPrimContactsStatName] += _perloopContact.Count - m_tempAvatarCollisionsThisFrame;
+
+            if (removeprims != null)
             {
-                d.SpaceCollide(ActiveSpace, IntPtr.Zero, nearCallback);
+                foreach (OdePrim chr in removeprims)
+                {
+                    _activeprims.Remove(chr);
+                }
             }
-            catch (AccessViolationException)
+        }
+
+        #endregion
+
+        public override void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents)
+        {
+            if (!m_suportCombine)
+                return;
+            m_worldOffset = offset;
+            WorldExtents = new Vector2(extents.X, extents.Y);
+            m_parentScene = pScene;
+        }
+
+        // Recovered for use by fly height. Kitto Flora
+        internal float GetTerrainHeightAtXY(float x, float y)
+        {
+            IntPtr heightFieldGeom = IntPtr.Zero;
+            int offsetX = 0;
+            int offsetY = 0;
+
+            if (m_suportCombine)
             {
-                m_log.Warn("[PHYSICS]: Unable to collide Active with Characters space");
+                offsetX = ((int)(x / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
+                offsetY = ((int)(y / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
             }
-            // and with chars
-            try
+
+            if(RegionTerrain.TryGetValue(new Vector3(offsetX,offsetY,0), out heightFieldGeom))
             {
-                d.SpaceCollide2(CharsSpace,ActiveSpace, IntPtr.Zero, nearCallback);
+                if (heightFieldGeom != IntPtr.Zero)
+                {
+                    if (TerrainHeightFieldHeights.ContainsKey(heightFieldGeom))
+                    {
+
+                        int index;
+
+
+                        if ((int)x > WorldExtents.X || (int)y > WorldExtents.Y ||
+                            (int)x < 0.001f || (int)y < 0.001f)
+                            return 0;
+
+                        x = x - offsetX + 1f;
+                        y = y - offsetY + 1f;
+
+                        index = (int)((int)x * ((int)Constants.RegionSize + 2) + (int)y);
+
+                        if (index < TerrainHeightFieldHeights[heightFieldGeom].Length)
+                        {
+                            //m_log.DebugFormat("x{0} y{1} = {2}", x, y, (float)TerrainHeightFieldHeights[heightFieldGeom][index]);
+                            return (float)TerrainHeightFieldHeights[heightFieldGeom][index];
+                        }
+                            
+                        else
+                            return 0f;
+                    }
+                    else
+                    {
+                        return 0f;
+                    }
+
+                }
+                else
+                {
+                    return 0f;
+                }
+
             }
-            catch (AccessViolationException)
+            else
             {
-                m_log.Warn("[PHYSICS]: Unable to collide in Active space");
+                return 0f;
             }
-            //            _perloopContact.Clear();
-        }
+        } 
+// End recovered. Kitto Flora
 
-        #endregion
         /// <summary>
         /// Add actor to the list that should receive collision events in the simulate loop.
         /// </summary>
         /// <param name="obj"></param>
-        public void AddCollisionEventReporting(PhysicsActor obj)
+        internal void AddCollisionEventReporting(PhysicsActor obj)
         {
-            if (!_collisionEventPrim.Contains(obj))
-                _collisionEventPrim.Add(obj);
+//            m_log.DebugFormat("[PHYSICS]: Adding {0} {1} to collision event reporting", obj.SOPName, obj.LocalID);
+            
+            lock (m_collisionEventActorsChanges)
+                m_collisionEventActorsChanges[obj.LocalID] = obj;
         }
 
         /// <summary>
         /// Remove actor from the list that should receive collision events in the simulate loop.
         /// </summary>
         /// <param name="obj"></param>
-        public void RemoveCollisionEventReporting(PhysicsActor obj)
+        internal void RemoveCollisionEventReporting(PhysicsActor obj)
+        {
+//            m_log.DebugFormat("[PHYSICS]: Removing {0} {1} from collision event reporting", obj.SOPName, obj.LocalID);
+
+            lock (m_collisionEventActorsChanges)
+                m_collisionEventActorsChanges[obj.LocalID] = null;
+        }
+
+        #region Add/Remove Entities
+
+        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        {                       
+            OdeCharacter newAv
+                = new OdeCharacter(
+                    avName, this, position, velocity, size, avPIDD, avPIDP,
+                    avCapRadius, avStandupTensor, avDensity,
+                    avMovementDivisorWalk, avMovementDivisorRun);
+
+            newAv.Flying = isFlying;
+            newAv.MinimumGroundFlightOffset = minimumGroundFlightOffset;
+            newAv.m_avatarplanted = avplanted;
+
+            return newAv;
+        }
+
+        public override void RemoveAvatar(PhysicsActor actor)
         {
-            if (_collisionEventPrim.Contains(obj) && !_collisionEventPrimRemove.Contains(obj))
-                _collisionEventPrimRemove.Add(obj);
+//            m_log.DebugFormat(
+//                "[ODE SCENE]: Removing physics character {0} {1} from physics scene {2}",
+//                actor.Name, actor.LocalID, Name);
+
+            ((OdeCharacter) actor).Destroy();
+        }
+
+        internal void AddCharacter(OdeCharacter chr)
+        {
+            chr.m_avatarplanted = avplanted;
+            if (!_characters.Contains(chr))
+            {
+                _characters.Add(chr);
+
+//                m_log.DebugFormat(
+//                    "[ODE SCENE]: Adding physics character {0} {1} to physics scene {2}.  Count now {3}",
+//                    chr.Name, chr.LocalID, Name, _characters.Count);
+
+                if (chr.bad)
+                    m_log.ErrorFormat("[ODE SCENE]: Added BAD actor {0} to characters list", chr.m_uuid);
+            }
+            else
+            {
+                m_log.ErrorFormat(
+                    "[ODE SCENE]: Tried to add character {0} {1} but they are already in the set!",
+                    chr.Name, chr.LocalID);
+            }
+        }
+
+        internal void RemoveCharacter(OdeCharacter chr)
+        {
+            if (_characters.Contains(chr))
+            {
+                _characters.Remove(chr);
+
+//                m_log.DebugFormat(
+//                    "[ODE SCENE]: Removing physics character {0} {1} from physics scene {2}.  Count now {3}",
+//                    chr.Name, chr.LocalID, Name, _characters.Count);
+            }
+            else
+            {
+                m_log.ErrorFormat(
+                    "[ODE SCENE]: Tried to remove character {0} {1} but they are not in the list!",
+                    chr.Name, chr.LocalID);
+            }
+        }
+
+        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)
+            {
+                newPrim = new OdePrim(name, this, pos, siz, rot, pbs, isphysical);
+
+                lock (_prims)
+                    _prims.Add(newPrim);
+            }
+            newPrim.LocalID = localID;
+            return newPrim;
+        }
+
+        /// <summary>
+        /// Make this prim subject to physics.
+        /// </summary>
+        /// <param name="prim"></param>
+        internal void ActivatePrim(OdePrim prim)
+        {
+            // adds active prim..   (ones that should be iterated over in collisions_optimized
+            if (!_activeprims.Contains(prim))
+                _activeprims.Add(prim);
+            //else
+              //  m_log.Warn("[PHYSICS]: Double Entry in _activeprims detected, potential crash immenent");
+        }
+
+        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, uint localid)
+        {
+//            m_log.DebugFormat("[ODE SCENE]: Adding physics prim {0} {1} to physics scene {2}", primName, localid, Name);
+
+            return AddPrim(primName, position, size, rotation, pbs, isPhysical, localid);
         }
 
         public override float TimeDilation
@@ -1217,131 +2131,362 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         public override bool SupportsNINJAJoints
         {
-            get { return false; }
+            get { return m_NINJA_physics_joints_enabled; }
         }
 
-        #region Add/Remove Entities
+        // internal utility function: must be called within a lock (OdeLock)
+        private void InternalAddActiveJoint(PhysicsJoint joint)
+        {
+            activeJoints.Add(joint);
+            SOPName_to_activeJoint.Add(joint.ObjectNameInScene, joint);
+        }
 
-        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        // internal utility function: must be called within a lock (OdeLock)
+        private void InternalAddPendingJoint(OdePhysicsJoint joint)
         {
-            return null;
+            pendingJoints.Add(joint);
+            SOPName_to_pendingJoint.Add(joint.ObjectNameInScene, joint);
         }
 
-        public override PhysicsActor AddAvatar(uint localID, string avName, Vector3 position, Vector3 size, float feetOffset, bool isFlying)
+        // internal utility function: must be called within a lock (OdeLock)
+        private void InternalRemovePendingJoint(PhysicsJoint joint)
         {
-             OdeCharacter newAv = new OdeCharacter(localID, avName, this, position,
-                size, feetOffset, avDensity, avMovementDivisorWalk, avMovementDivisorRun);
-            newAv.Flying = isFlying;
-            newAv.MinimumGroundFlightOffset = minimumGroundFlightOffset;
-            
-            return newAv;
+            pendingJoints.Remove(joint);
+            SOPName_to_pendingJoint.Remove(joint.ObjectNameInScene);
+        }
+
+        // internal utility function: must be called within a lock (OdeLock)
+        private void InternalRemoveActiveJoint(PhysicsJoint joint)
+        {
+            activeJoints.Remove(joint);
+            SOPName_to_activeJoint.Remove(joint.ObjectNameInScene);
         }
 
-        public void AddCharacter(OdeCharacter chr)
+        public override void DumpJointInfo()
         {
-            lock (_characters)
+            string hdr = "[NINJA] JOINTINFO: ";
+            foreach (PhysicsJoint j in pendingJoints)
+            {
+                m_log.Debug(hdr + " pending joint, Name: " + j.ObjectNameInScene + " raw parms:" + j.RawParams);
+            }
+            m_log.Debug(hdr + pendingJoints.Count + " total pending joints");
+            foreach (string jointName in SOPName_to_pendingJoint.Keys)
+            {
+                m_log.Debug(hdr + " pending joints dict contains Name: " + jointName);
+            }
+            m_log.Debug(hdr + SOPName_to_pendingJoint.Keys.Count + " total pending joints dict entries");
+            foreach (PhysicsJoint j in activeJoints)
+            {
+                m_log.Debug(hdr + " active joint, Name: " + j.ObjectNameInScene + " raw parms:" + j.RawParams);
+            }
+            m_log.Debug(hdr + activeJoints.Count + " total active joints");
+            foreach (string jointName in SOPName_to_activeJoint.Keys)
+            {
+                m_log.Debug(hdr + " active joints dict contains Name: " + jointName);
+            }
+            m_log.Debug(hdr + SOPName_to_activeJoint.Keys.Count + " total active joints dict entries");
+
+            m_log.Debug(hdr + " Per-body joint connectivity information follows.");
+            m_log.Debug(hdr + joints_connecting_actor.Keys.Count + " bodies are connected by joints.");
+            foreach (string actorName in joints_connecting_actor.Keys)
             {
-                if (!_characters.Contains(chr))
+                m_log.Debug(hdr + " Actor " + actorName + " has the following joints connecting it");
+                foreach (PhysicsJoint j in joints_connecting_actor[actorName])
                 {
-                    _characters.Add(chr);
-                    if (chr.bad)
-                        m_log.DebugFormat("[PHYSICS] Added BAD actor {0} to characters list", chr.m_uuid);
+                    m_log.Debug(hdr + " * joint Name: " + j.ObjectNameInScene + " raw parms:" + j.RawParams);
                 }
+                m_log.Debug(hdr + joints_connecting_actor[actorName].Count + " connecting joints total for this actor");
             }
         }
 
-        public void RemoveCharacter(OdeCharacter chr)
+        public override void RequestJointDeletion(string ObjectNameInScene)
         {
-            lock (_characters)
+            lock (externalJointRequestsLock)
             {
-                if (_characters.Contains(chr))
+                if (!requestedJointsToBeDeleted.Contains(ObjectNameInScene)) // forbid same deletion request from entering twice to prevent spurious deletions processed asynchronously
                 {
-                    _characters.Remove(chr);
+                    requestedJointsToBeDeleted.Add(ObjectNameInScene);
                 }
             }
         }
 
-        public void BadCharacter(OdeCharacter chr)
+        private void DeleteRequestedJoints()
         {
-            lock (_badCharacter)
+            List<string> myRequestedJointsToBeDeleted;
+            lock (externalJointRequestsLock)
             {
-                if (!_badCharacter.Contains(chr))
-                    _badCharacter.Add(chr);
+                // make a local copy of the shared list for processing (threading issues)
+                myRequestedJointsToBeDeleted = new List<string>(requestedJointsToBeDeleted);
             }
-        }
 
-        public override void RemoveAvatar(PhysicsActor actor)
-        {
-            //m_log.Debug("[PHYSICS]:ODELOCK");
-            ((OdeCharacter) actor).Destroy();
-        }
+            foreach (string jointName in myRequestedJointsToBeDeleted)
+            {
+                lock (OdeLock)
+                {
+                    //m_log.Debug("[NINJA] trying to deleting requested joint " + jointName);
+                    if (SOPName_to_activeJoint.ContainsKey(jointName) || SOPName_to_pendingJoint.ContainsKey(jointName))
+                    {
+                        OdePhysicsJoint joint = null;
+                        if (SOPName_to_activeJoint.ContainsKey(jointName))
+                        {
+                            joint = SOPName_to_activeJoint[jointName] as OdePhysicsJoint;
+                            InternalRemoveActiveJoint(joint);
+                        }
+                        else if (SOPName_to_pendingJoint.ContainsKey(jointName))
+                        {
+                            joint = SOPName_to_pendingJoint[jointName] as OdePhysicsJoint;
+                            InternalRemovePendingJoint(joint);
+                        }
 
+                        if (joint != null)
+                        {
+                            //m_log.Debug("joint.BodyNames.Count is " + joint.BodyNames.Count + " and contents " + joint.BodyNames);
+                            for (int iBodyName = 0; iBodyName < 2; iBodyName++)
+                            {
+                                string bodyName = joint.BodyNames[iBodyName];
+                                if (bodyName != "NULL")
+                                {
+                                    joints_connecting_actor[bodyName].Remove(joint);
+                                    if (joints_connecting_actor[bodyName].Count == 0)
+                                    {
+                                        joints_connecting_actor.Remove(bodyName);
+                                    }
+                                }
+                            }
 
-        public void addActivePrim(OdePrim activatePrim)
-        {
-            // adds active prim..   
-            lock (_activeprims)
+                            DoJointDeactivated(joint);
+                            if (joint.jointID != IntPtr.Zero)
+                            {
+                                d.JointDestroy(joint.jointID);
+                                joint.jointID = IntPtr.Zero;
+                                //DoJointErrorMessage(joint, "successfully destroyed joint " + jointName);
+                            }
+                            else
+                            {
+                                //m_log.Warn("[NINJA] Ignoring re-request to destroy joint " + jointName);
+                            }
+                        }
+                        else
+                        {
+                            // DoJointErrorMessage(joint, "coult not find joint to destroy based on name " + jointName);
+                        }
+                    }
+                    else
+                    {
+                        // DoJointErrorMessage(joint, "WARNING - joint removal failed, joint " + jointName);
+                    }
+                }
+            }
+
+            // remove processed joints from the shared list
+            lock (externalJointRequestsLock)
             {
-                if (!_activeprims.Contains(activatePrim))
-                    _activeprims.Add(activatePrim);
+                foreach (string jointName in myRequestedJointsToBeDeleted)
+                {
+                    requestedJointsToBeDeleted.Remove(jointName);
+                }
             }
         }
 
-        public void addActiveGroups(OdePrim activatePrim)
+        // for pending joints we don't know if their associated bodies exist yet or not.
+        // the joint is actually created during processing of the taints
+        private void CreateRequestedJoints()
         {
-            lock (_activegroups)
+            List<PhysicsJoint> myRequestedJointsToBeCreated;
+            lock (externalJointRequestsLock)
+            {
+                // make a local copy of the shared list for processing (threading issues)
+                myRequestedJointsToBeCreated = new List<PhysicsJoint>(requestedJointsToBeCreated);
+            }
+
+            foreach (PhysicsJoint joint in myRequestedJointsToBeCreated)
+            {
+                lock (OdeLock)
+                {
+                    if (SOPName_to_pendingJoint.ContainsKey(joint.ObjectNameInScene) && SOPName_to_pendingJoint[joint.ObjectNameInScene] != null)
+                    {
+                        DoJointErrorMessage(joint, "WARNING: ignoring request to re-add already pending joint Name:" + joint.ObjectNameInScene + " type:" + joint.Type + " parms: " + joint.RawParams + " pos: " + joint.Position + " rot:" + joint.Rotation);
+                        continue;
+                    }
+                    if (SOPName_to_activeJoint.ContainsKey(joint.ObjectNameInScene) && SOPName_to_activeJoint[joint.ObjectNameInScene] != null)
+                    {
+                        DoJointErrorMessage(joint, "WARNING: ignoring request to re-add already active joint Name:" + joint.ObjectNameInScene + " type:" + joint.Type + " parms: " + joint.RawParams + " pos: " + joint.Position + " rot:" + joint.Rotation);
+                        continue;
+                    }
+
+                    InternalAddPendingJoint(joint as OdePhysicsJoint);
+
+                    if (joint.BodyNames.Count >= 2)
+                    {
+                        for (int iBodyName = 0; iBodyName < 2; iBodyName++)
+                        {
+                            string bodyName = joint.BodyNames[iBodyName];
+                            if (bodyName != "NULL")
+                            {
+                                if (!joints_connecting_actor.ContainsKey(bodyName))
+                                {
+                                    joints_connecting_actor.Add(bodyName, new List<PhysicsJoint>());
+                                }
+                                joints_connecting_actor[bodyName].Add(joint);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // remove processed joints from shared list
+            lock (externalJointRequestsLock)
             {
-                if (!_activegroups.Contains(activatePrim))
-                    _activegroups.Add(activatePrim);
+                foreach (PhysicsJoint joint in myRequestedJointsToBeCreated)
+                {
+                    requestedJointsToBeCreated.Remove(joint);
+                }
             }
         }
 
-        private PhysicsActor AddPrim(String name, Vector3 position, Vector3 size, Quaternion rotation,
-                                     PrimitiveBaseShape pbs, bool isphysical, bool isPhantom, byte shapeType, uint localID)
+        /// <summary>
+        /// Add a request for joint creation.
+        /// </summary>
+        /// <remarks>
+        /// this joint will just be added to a waiting list that is NOT processed during the main
+        /// Simulate() loop (to avoid deadlocks). After Simulate() is finished, we handle unprocessed joint requests.
+        /// </remarks>
+        /// <param name="objectNameInScene"></param>
+        /// <param name="jointType"></param>
+        /// <param name="position"></param>
+        /// <param name="rotation"></param>
+        /// <param name="parms"></param>
+        /// <param name="bodyNames"></param>
+        /// <param name="trackedBodyName"></param>
+        /// <param name="localRotation"></param>
+        /// <returns></returns>
+        public override PhysicsJoint RequestJointCreation(
+            string objectNameInScene, PhysicsJointType jointType, Vector3 position,
+            Quaternion rotation, string parms, List<string> bodyNames, string trackedBodyName, Quaternion localRotation)
         {
-            OdePrim newPrim;
-            lock (OdeLock)
+            OdePhysicsJoint joint = new OdePhysicsJoint();
+            joint.ObjectNameInScene = objectNameInScene;
+            joint.Type = jointType;
+            joint.Position = position;
+            joint.Rotation = rotation;
+            joint.RawParams = parms;
+            joint.BodyNames = new List<string>(bodyNames);
+            joint.TrackedBodyName = trackedBodyName;
+            joint.LocalRotation = localRotation;
+            joint.jointID = IntPtr.Zero;
+            joint.ErrorMessageCount = 0;
+
+            lock (externalJointRequestsLock)
             {
-                newPrim = new OdePrim(name, this, position, size, rotation, pbs, isphysical, isPhantom, shapeType, localID);
-                lock (_prims)
-                    _prims.Add(newPrim);
+                if (!requestedJointsToBeCreated.Contains(joint)) // forbid same creation request from entering twice 
+                {
+                    requestedJointsToBeCreated.Add(joint);
+                }
             }
-            return newPrim;
+
+            return joint;
         }
 
-        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
-                                                  Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, uint localid)
+        private void RemoveAllJointsConnectedToActor(PhysicsActor actor)
         {
-            return AddPrim(primName, position, size, rotation, pbs, isPhysical, isPhantom, 0 , localid);
+            //m_log.Debug("RemoveAllJointsConnectedToActor: start");
+            if (actor.SOPName != null && joints_connecting_actor.ContainsKey(actor.SOPName) && joints_connecting_actor[actor.SOPName] != null)
+            {
+                List<PhysicsJoint> jointsToRemove = new List<PhysicsJoint>();
+                //TODO: merge these 2 loops (originally it was needed to avoid altering a list being iterated over, but it is no longer needed due to the joint request queue mechanism)
+                foreach (PhysicsJoint j in joints_connecting_actor[actor.SOPName])
+                {
+                    jointsToRemove.Add(j);
+                }
+                foreach (PhysicsJoint j in jointsToRemove)
+                {
+                    //m_log.Debug("RemoveAllJointsConnectedToActor: about to request deletion of " + j.ObjectNameInScene);
+                    RequestJointDeletion(j.ObjectNameInScene);
+                    //m_log.Debug("RemoveAllJointsConnectedToActor: done request deletion of " + j.ObjectNameInScene);
+                    j.TrackedBodyName = null; // *IMMEDIATELY* prevent any further movement of this joint (else a deleted actor might cause spurious tracking motion of the joint for a few frames, leading to the joint proxy object disappearing)
+                }
+            }
         }
 
-
-        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
-                                                  Vector3 size, Quaternion rotation, bool isPhysical, uint localid)
+        public override void RemoveAllJointsConnectedToActorThreadLocked(PhysicsActor actor)
         {
-            return AddPrim(primName, position, size, rotation, pbs, isPhysical,false, 0, localid);
+            //m_log.Debug("RemoveAllJointsConnectedToActorThreadLocked: start");
+            lock (OdeLock)
+            {
+                //m_log.Debug("RemoveAllJointsConnectedToActorThreadLocked: got lock");
+                RemoveAllJointsConnectedToActor(actor);
+            }
         }
 
-        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
-                                                  Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, byte shapeType, uint localid)
+        // normally called from within OnJointMoved, which is called from within a lock (OdeLock)
+        public override Vector3 GetJointAnchor(PhysicsJoint joint)
         {
+            Debug.Assert(joint.IsInPhysicsEngine);
+            d.Vector3 pos = new d.Vector3();
 
-            return AddPrim(primName, position, size, rotation, pbs, isPhysical,isPhantom, shapeType, localid);
+            if (!(joint is OdePhysicsJoint))
+            {
+                DoJointErrorMessage(joint, "warning: non-ODE joint requesting anchor: " + joint.ObjectNameInScene);
+            }
+            else
+            {
+                OdePhysicsJoint odeJoint = (OdePhysicsJoint)joint;
+                switch (odeJoint.Type)
+                {
+                    case PhysicsJointType.Ball:
+                        d.JointGetBallAnchor(odeJoint.jointID, out pos);
+                        break;
+                    case PhysicsJointType.Hinge:
+                        d.JointGetHingeAnchor(odeJoint.jointID, out pos);
+                        break;
+                }
+            }
+            return new Vector3(pos.X, pos.Y, pos.Z);
         }
 
-        public void remActivePrim(OdePrim deactivatePrim)
+        /// <summary>
+        /// Get joint axis.
+        /// </summary>
+        /// <remarks>
+        /// normally called from within OnJointMoved, which is called from within a lock (OdeLock)
+        /// WARNING: ODE sometimes returns <0,0,0> as the joint axis! Therefore this function
+        /// appears to be unreliable. Fortunately we can compute the joint axis ourselves by
+        /// keeping track of the joint's original orientation relative to one of the involved bodies.
+        /// </remarks>
+        /// <param name="joint"></param>
+        /// <returns></returns>
+        public override Vector3 GetJointAxis(PhysicsJoint joint)
         {
-            lock (_activeprims)
+            Debug.Assert(joint.IsInPhysicsEngine);
+            d.Vector3 axis = new d.Vector3();
+
+            if (!(joint is OdePhysicsJoint))
             {
-                _activeprims.Remove(deactivatePrim);
+                DoJointErrorMessage(joint, "warning: non-ODE joint requesting anchor: " + joint.ObjectNameInScene);
             }
-        }
-        public void remActiveGroup(OdePrim deactivatePrim)
-        {
-            lock (_activegroups)
+            else
             {
-                _activegroups.Remove(deactivatePrim);
+                OdePhysicsJoint odeJoint = (OdePhysicsJoint)joint;
+                switch (odeJoint.Type)
+                {
+                    case PhysicsJointType.Ball:
+                        DoJointErrorMessage(joint, "warning - axis requested for ball joint: " + joint.ObjectNameInScene);
+                        break;
+                    case PhysicsJointType.Hinge:
+                        d.JointGetHingeAxis(odeJoint.jointID, out axis);
+                        break;
+                }
             }
+            return new Vector3(axis.X, axis.Y, axis.Z);
+        }
+
+        /// <summary>
+        /// Stop this prim being subject to physics
+        /// </summary>
+        /// <param name="prim"></param>
+        internal void DeactivatePrim(OdePrim prim)
+        {
+            _activeprims.Remove(prim);
         }
 
         public override void RemovePrim(PhysicsActor prim)
@@ -1350,46 +2495,111 @@ namespace OpenSim.Region.Physics.OdePlugin
             // removed in the next physics simulate pass.
             if (prim is OdePrim)
             {
-//                lock (OdeLock)
+                lock (OdeLock)
                 {
-                    
-                    OdePrim p = (OdePrim)prim;
+                    OdePrim p = (OdePrim) prim;
+
                     p.setPrimForRemoval();
+                    AddPhysicsActorTaint(prim);
                 }
             }
         }
 
-        public void RemovePrimThreadLocked(OdePrim prim)
+        /// <summary>
+        /// This is called from within simulate but outside the locked portion
+        /// We need to do our own locking here
+        /// (Note: As of 20110801 this no longer appears to be true - this is being called within lock (odeLock) in
+        /// Simulate() -- justincc).
+        ///
+        /// Essentially, we need to remove the prim from our space segment, whatever segment it's in.
+        ///
+        /// If there are no more prim in the segment, we need to empty (spacedestroy)the segment and reclaim memory
+        /// that the space was using.
+        /// </summary>
+        /// <param name="prim"></param>
+        internal void RemovePrimThreadLocked(OdePrim prim)
         {
-            //Console.WriteLine("RemovePrimThreadLocked " +  prim.m_primName);
+//            m_log.DebugFormat("[ODE SCENE]: Removing physical prim {0} {1}", prim.Name, prim.LocalID);
+
             lock (prim)
             {
-//                RemoveCollisionEventReporting(prim);
-                lock (_prims)
-                    _prims.Remove(prim);
-            }
+                RemoveCollisionEventReporting(prim);
 
-        }
+                if (prim.prim_geom != IntPtr.Zero)
+                {
+                    prim.ResetTaints();
 
-        public bool havePrim(OdePrim prm)
-        {
-            lock (_prims)
-                return _prims.Contains(prm);
-        }
+                    if (prim.IsPhysical)
+                    {
+                        prim.disableBody();
+                        if (prim.childPrim)
+                        {
+                            prim.childPrim = false;
+                            prim.Body = IntPtr.Zero;
+                            prim.m_disabled = true;
+                            prim.IsPhysical = false;
+                        }
 
-        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);
+
+                    }
+                    // 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);
+                }
             }
-            return false;
         }
 
         #endregion
@@ -1397,436 +2607,669 @@ namespace OpenSim.Region.Physics.OdePlugin
         #region Space Separation Calculation
 
         /// <summary>
-        /// Called when a static prim moves or becomes static
-        /// Places the prim in a space one the static sub-spaces grid
+        /// Takes a space pointer and zeros out the array we're using to hold the spaces
+        /// </summary>
+        /// <param name="pSpace"></param>
+        private void resetSpaceArrayItemToZero(IntPtr pSpace)
+        {
+            for (int x = 0; x < staticPrimspace.GetLength(0); x++)
+            {
+                for (int y = 0; y < staticPrimspace.GetLength(1); y++)
+                {
+                    if (staticPrimspace[x, y] == pSpace)
+                        staticPrimspace[x, y] = IntPtr.Zero;
+                }
+            }
+        }
+
+//        private void resetSpaceArrayItemToZero(int arrayitemX, int arrayitemY)
+//        {
+//            staticPrimspace[arrayitemX, arrayitemY] = IntPtr.Zero;
+//        }
+
+        /// <summary>
+        /// Called when a static prim moves.  Allocates a space for the prim based on its position
         /// </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)
+        internal IntPtr recalculateSpaceForGeom(IntPtr geom, Vector3 pos, IntPtr currentspace)
         {
-            // moves a prim into another static sub-space or from another space into a static sub-space
-
-            // Called ODEPrim so
+            // Called from setting the Position and Size of an ODEPrim so
             // it's already in locked space.
 
-            if (geom == IntPtr.Zero) // shouldn't happen
-                return IntPtr.Zero;
+            // we don't want to remove the main space
+            // we don't need to test physical here because this function should
+            // never be called if the prim is physical(active)
 
-            // get the static sub-space for current position
-            IntPtr newspace = calculateSpaceForGeom(pos);
-
-            if (newspace == currentspace) // if we are there all done
-                return newspace;
-
-            // else remove it from its current space
-            if (currentspace != IntPtr.Zero && d.SpaceQuery(currentspace, geom))
+            // All physical prim end up in the root space
+            //Thread.Sleep(20);
+            if (currentspace != space)
             {
-                if (d.GeomIsSpace(currentspace))
+                //m_log.Info("[SPACE]: C:" + currentspace.ToString() + " g:" + geom.ToString());
+                //if (currentspace == IntPtr.Zero)
+               //{
+                    //int adfadf = 0;
+                //}
+                if (d.SpaceQuery(currentspace, geom) && currentspace != IntPtr.Zero)
                 {
-                    waitForSpaceUnlock(currentspace);
-                    d.SpaceRemove(currentspace, geom);
-
-                    if (d.SpaceGetSublevel(currentspace) > 2 && d.SpaceGetNumGeoms(currentspace) == 0)
+                    if (d.GeomIsSpace(currentspace))
+                    {
+//                        waitForSpaceUnlock(currentspace);
+                        d.SpaceRemove(currentspace, geom);
+                    }
+                    else
                     {
-                        d.SpaceDestroy(currentspace);
+                        m_log.Info("[ODE SCENE]: Invalid Scene passed to 'recalculatespace':" + currentspace +
+                                   " Geom:" + geom);
                     }
                 }
                 else
                 {
-                    m_log.Info("[Physics]: Invalid or empty Space passed to 'MoveGeomToStaticSpace':" + currentspace +
-                                   " Geom:" + geom);
+                    IntPtr sGeomIsIn = d.GeomGetSpace(geom);
+                    if (sGeomIsIn != IntPtr.Zero)
+                    {
+                        if (d.GeomIsSpace(currentspace))
+                        {
+//                            waitForSpaceUnlock(sGeomIsIn);
+                            d.SpaceRemove(sGeomIsIn, geom);
+                        }
+                        else
+                        {
+                            m_log.Info("[ODE SCENE]: Invalid Scene passed to 'recalculatespace':" +
+                                       sGeomIsIn + " Geom:" + geom);
+                        }
+                    }
+                }
+
+                //If there are no more geometries in the sub-space, we don't need it in the main space anymore
+                if (d.SpaceGetNumGeoms(currentspace) == 0)
+                {
+                    if (currentspace != IntPtr.Zero)
+                    {
+                        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
+                        {
+                            m_log.Info("[ODE SCENE]: Invalid Scene passed to 'recalculatespace':" +
+                                       currentspace + " 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);
-                if (currentspace != IntPtr.Zero)
+                // this is a physical object that got disabled. ;.;
+                if (currentspace != IntPtr.Zero && geom != IntPtr.Zero)
                 {
-                    if (d.GeomIsSpace(currentspace))
+                    if (d.SpaceQuery(currentspace, geom))
                     {
-                        waitForSpaceUnlock(currentspace);
-                        d.SpaceRemove(currentspace, geom);
-
-                        if (d.SpaceGetSublevel(currentspace) > 2 && d.SpaceGetNumGeoms(currentspace) == 0)
+                        if (d.GeomIsSpace(currentspace))
                         {
-                            d.SpaceDestroy(currentspace);
+//                            waitForSpaceUnlock(currentspace);
+                            d.SpaceRemove(currentspace, geom);
+                        }
+                        else
+                        {
+                            m_log.Info("[ODE SCENE]: Invalid Scene passed to 'recalculatespace':" +
+                                       currentspace + " Geom:" + geom);
+                        }
+                    }
+                    else
+                    {
+                        IntPtr sGeomIsIn = d.GeomGetSpace(geom);
+                        if (sGeomIsIn != IntPtr.Zero)
+                        {
+                            if (d.GeomIsSpace(sGeomIsIn))
+                            {
+//                                waitForSpaceUnlock(sGeomIsIn);
+                                d.SpaceRemove(sGeomIsIn, geom);
+                            }
+                            else
+                            {
+                                m_log.Info("[ODE SCENE]: Invalid Scene passed to 'recalculatespace':" +
+                                           sGeomIsIn + " Geom:" + geom);
+                            }
                         }
-
                     }
                 }
             }
 
-            // put the geom in the newspace
-            waitForSpaceUnlock(newspace);
-            d.SpaceAdd(newspace, geom);
+            // The routines in the Position and Size sections do the 'inserting' into the space,
+            // so all we have to do is make sure that the space that we're putting the prim into
+            // is in the 'main' space.
+            int[] iprimspaceArrItem = calculateSpaceArrayItemFromPos(pos);
+            IntPtr newspace = calculateSpaceForGeom(pos);
+
+            if (newspace == IntPtr.Zero)
+            {
+                newspace = createprimspace(iprimspaceArrItem[0], iprimspaceArrItem[1]);
+                d.HashSpaceSetLevels(newspace, smallHashspaceLow, smallHashspaceHigh);
+            }
 
-            // let caller know this newspace
             return newspace;
         }
 
         /// <summary>
+        /// Creates a new space at X Y
+        /// </summary>
+        /// <param name="iprimspaceArrItemX"></param>
+        /// <param name="iprimspaceArrItemY"></param>
+        /// <returns>A pointer to the created space</returns>
+        internal IntPtr createprimspace(int iprimspaceArrItemX, int iprimspaceArrItemY)
+        {
+            // creating a new space for prim and inserting it into main space.
+            staticPrimspace[iprimspaceArrItemX, iprimspaceArrItemY] = d.HashSpaceCreate(IntPtr.Zero);
+            d.GeomSetCategoryBits(staticPrimspace[iprimspaceArrItemX, iprimspaceArrItemY], (int)CollisionCategories.Space);
+//            waitForSpaceUnlock(space);
+            d.SpaceSetSublevel(space, 1);
+            d.SpaceAdd(space, staticPrimspace[iprimspaceArrItemX, iprimspaceArrItemY]);
+            
+            return staticPrimspace[iprimspaceArrItemX, iprimspaceArrItemY];
+        }
+
+        /// <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)
+        internal IntPtr calculateSpaceForGeom(Vector3 pos)
+        {
+            int[] xyspace = calculateSpaceArrayItemFromPos(pos);
+            //m_log.Info("[Physics]: Attempting to use arrayItem: " + xyspace[0].ToString() + "," + xyspace[1].ToString());
+            return staticPrimspace[xyspace[0], xyspace[1]];
+        }
+
+        /// <summary>
+        /// Holds the space allocation logic
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <returns>an array item based on the position</returns>
+        internal int[] calculateSpaceArrayItemFromPos(Vector3 pos)
         {
-            int x, y;
+            int[] returnint = new int[2];
 
-            if (pos.X < 0)
-                return staticPrimspaceOffRegion[0];
+            returnint[0] = (int) (pos.X * spacesPerMeterX);
 
-            if (pos.Y < 0)
-                return staticPrimspaceOffRegion[2];
+            if (returnint[0] > spaceGridMaxX)
+                returnint[0] = spaceGridMaxX;
+            if (returnint[0] < 0)
+                returnint[0] = 0;
 
-            x = (int)(pos.X * spacesPerMeterX);
-            if (x > spaceGridMaxX)
-                return staticPrimspaceOffRegion[1];
-            
-            y = (int)(pos.Y * spacesPerMeterY);
-            if (y > spaceGridMaxY)
-                return staticPrimspaceOffRegion[3];
+            returnint[1] = (int)(pos.Y * spacesPerMeterY);
+            if (returnint[1] > spaceGridMaxY)
+                returnint[1] = spaceGridMaxY;
+            if (returnint[1] < 0)
+                returnint[1] = 0;
 
-            return staticPrimspace[x, y];
+            return returnint;
         }
- 
-        #endregion
 
+        #endregion
 
         /// <summary>
-        /// Called to queue a change to a actor
-        /// to use in place of old taint mechanism so changes do have a time sequence
+        /// Routine to figure out if we need to mesh this prim with our mesher
         /// </summary>
-
-        public void AddChange(PhysicsActor actor, changes what, Object arg)
+        /// <param name="pbs"></param>
+        /// <returns></returns>
+        internal bool needsMeshing(PrimitiveBaseShape pbs)
         {
-            ODEchangeitem item = new ODEchangeitem();
-            item.actor = actor;
-            item.what = what;
-            item.arg = arg;
-            ChangesQueue.Enqueue(item);
-        }
+            // most of this is redundant now as the mesher will return null if it cant mesh a prim
+            // but we still need to check for sculptie meshing being enabled so this is the most
+            // convenient place to do it for now...
 
-        /// <summary>
-        /// Called after our prim properties are set Scale, position etc.
-        /// We use this event queue like method to keep changes to the physical scene occuring in the threadlocked mutex
-        /// This assures us that we have no race conditions
-        /// </summary>
-        /// <param name="prim"></param>
-        public override void AddPhysicsActorTaint(PhysicsActor prim)
-        {
-        }
+        //    //if (pbs.PathCurve == (byte)Primitive.PathCurve.Circle && pbs.ProfileCurve == (byte)Primitive.ProfileCurve.Circle && pbs.PathScaleY <= 0.75f)
+        //    //m_log.Debug("needsMeshing: " + " pathCurve: " + pbs.PathCurve.ToString() + " profileCurve: " + pbs.ProfileCurve.ToString() + " pathScaleY: " + Primitive.UnpackPathScale(pbs.PathScaleY).ToString());
+            int iPropertiesNotSupportedDefault = 0;
 
-        // does all pending changes generated during region load process
-        public override void PrepareSimulation()
-        {
-            lock (OdeLock)
+            if (pbs.SculptEntry && !meshSculptedPrim)
             {
-                if (world == IntPtr.Zero)
+#if SPAM
+                m_log.Warn("NonMesh");
+#endif
+                return false;
+            }
+
+            // 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 (!forceSimplePrimMeshing && !pbs.SculptEntry)
+            {
+                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))
                 {
-                    ChangesQueue.Clear();
-                    return;
+
+                    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;
+                    }
                 }
+            }
+
+            if (pbs.ProfileHollow != 0)
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathBegin != 0) || pbs.PathEnd != 0)
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0))
+                iPropertiesNotSupportedDefault++; 
 
-                ODEchangeitem item;
+            if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0)
+                iPropertiesNotSupportedDefault++;
 
-                int donechanges = 0;
-                if (ChangesQueue.Count > 0)
+            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)
                 {
-                    m_log.InfoFormat("[ODE] start processing pending actor operations");
-                    int tstart = Util.EnvironmentTickCount();
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Straight)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
 
-                    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);
+                // 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 (pbs.SculptEntry && meshSculptedPrim)
+                iPropertiesNotSupportedDefault++;
+
+            if (iPropertiesNotSupportedDefault == 0)
+            {
+#if SPAM
+                m_log.Warn("NonMesh");
+#endif
+                return false;
+            }
+#if SPAM
+            m_log.Debug("Mesh");
+#endif
+            return true; 
+        }
+
+        /// <summary>
+        /// Called after our prim properties are set Scale, position etc.
+        /// </summary>
+        /// <remarks>
+        /// We use this event queue like method to keep changes to the physical scene occuring in the threadlocked mutex
+        /// This assures us that we have no race conditions
+        /// </remarks>
+        /// <param name="actor"></param>
+        public override void AddPhysicsActorTaint(PhysicsActor actor)
+        {
+            if (actor is OdePrim)
+            {
+                OdePrim taintedprim = ((OdePrim)actor);
+                lock (_taintedPrims)
+                    _taintedPrims.Add(taintedprim);
+            }
+            else if (actor is OdeCharacter)
+            {
+                OdeCharacter taintedchar = ((OdeCharacter)actor);
+                lock (_taintedActors)
+                {
+                    _taintedActors.Add(taintedchar);
+                    if (taintedchar.bad)
+                        m_log.ErrorFormat("[ODE SCENE]: Added BAD actor {0} to tainted actors", taintedchar.m_uuid);
                 }
             }
         }
 
         /// <summary>
         /// This is our main simulate loop
+        /// </summary>
+        /// <remarks>
         /// It's thread locked by a Mutex in the scene.
         /// It holds Collisions, it instructs ODE to step through the physical reactions
         /// It moves the objects around in memory
         /// It calls the methods that report back to the object owners.. (scenepresence, SceneObjectGroup)
-        /// </summary>
+        /// </remarks>
         /// <param name="timeStep"></param>
-        /// <returns></returns>
+        /// <returns>The number of frames simulated over that period.</returns>
         public override float Simulate(float timeStep)
         {
-            DateTime now = DateTime.UtcNow;
-            TimeSpan timedif = now - m_lastframe;
-            timeStep = (float)timedif.TotalSeconds;
-            m_lastframe = now;
-            
-            // acumulate time so we can reduce error
-            step_time += timeStep;
+            if (!_worldInitialized) return 11f;
 
-            if (step_time < HalfOdeStep)
-                return 0;
+            int startFrameTick = CollectStats ? Util.EnvironmentTickCount() : 0;
+            int tempTick = 0, tempTick2 = 0;
 
-            if (framecount < 0)
+            if (framecount >= int.MaxValue)
                 framecount = 0;
 
             framecount++;
 
-//            int curphysiteractions;
+            float fps = 0;
 
-            // if in trouble reduce step resolution
-//            if (step_time >= m_SkipFramesAtms)
-//                curphysiteractions = m_physicsiterations / 2;
-//            else
-//                curphysiteractions = m_physicsiterations;
+            step_time += timeStep;
 
-//            checkThread();
-            int nodeframes = 0;
+            float HalfOdeStep = ODE_STEPSIZE * 0.5f;
+            if (step_time < HalfOdeStep)
+                return 0;
 
-            lock (SimulationLock)
-                lock(OdeLock)
+
+            // 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
+            // caller that is adding or removing the collision event.
+            lock (m_collisionEventActorsChanges)
             {
-                if (world == IntPtr.Zero)
+                foreach (KeyValuePair<uint, PhysicsActor> kvp in m_collisionEventActorsChanges)
                 {
-                    ChangesQueue.Clear();
-                    return 0;
+                    if (kvp.Value == null)
+                        m_collisionEventActors.Remove(kvp.Key);
+                    else
+                        m_collisionEventActors[kvp.Key] = kvp.Value;
                 }
 
-                ODEchangeitem item;
-                
-//                d.WorldSetQuickStepNumIterations(world, curphysiteractions);
+                m_collisionEventActorsChanges.Clear();
+            }
+
+            if (SupportsNINJAJoints)
+            {
+                DeleteRequestedJoints(); // this must be outside of the lock (OdeLock) to avoid deadlocks
+                CreateRequestedJoints(); // this must be outside of the lock (OdeLock) to avoid deadlocks
+            }
 
-                int loopstartMS = Util.EnvironmentTickCount();
-                int looptimeMS = 0;
-             
+            lock (OdeLock)
+            {
+                // Process 10 frames if the sim is running normal..
+                // process 5 frames if the sim is running slow
+                //try
+                //{
+                    //d.WorldSetQuickStepNumIterations(world, m_physicsiterations);
+                //}
+                //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();
+                //}
+
+                // 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
+
+
+                // 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 (step_time > HalfOdeStep)
                 {
                     try
                     {
-                        // clear pointer/counter to contacts to pass into joints
-                        m_global_contactcount = 0;
+                        if (CollectStats)
+                            tempTick = Util.EnvironmentTickCount();
+
+                        lock (_taintedActors)
+                        {
+                            foreach (OdeCharacter character in _taintedActors)
+                                character.ProcessTaints();
 
-                        if (ChangesQueue.Count > 0)
+                            _taintedActors.Clear();
+                        }
+
+                        if (CollectStats)
+                        {
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODEAvatarTaintMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
+                        }
+
+                        lock (_taintedPrims)
                         {
-                            int changestartMS = Util.EnvironmentTickCount();
-                            int ttmp;
-                            while (ChangesQueue.Dequeue(out item))
+                            foreach (OdePrim prim in _taintedPrims)
                             {
-                                if (item.actor != null)
+                                if (prim.m_taintremove)
                                 {
-                                    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]: doChange failed for a actor {0} {1}",
-                                            item.actor.Name, item.what.ToString());
-                                    }
+//                                    Console.WriteLine("Simulate calls RemovePrimThreadLocked for {0}", prim.Name);
+                                    RemovePrimThreadLocked(prim);
                                 }
-                                ttmp = Util.EnvironmentTickCountSubtract(changestartMS);
-                                if (ttmp > 20)
-                                    break;
+                                else
+                                {
+//                                    Console.WriteLine("Simulate calls ProcessTaints for {0}", prim.Name);
+                                    prim.ProcessTaints();
+                                }
+
+                                prim.m_collisionscore = 0;
+
+                                // This loop can block up the Heartbeat for a very long time on large regions.
+                                // We need to let the Watchdog know that the Heartbeat is not dead
+                                // NOTE: This is currently commented out, but if things like OAR loading are
+                                // timing the heartbeat out we will need to uncomment it
+                                //Watchdog.UpdateThread();
                             }
+
+                            if (SupportsNINJAJoints)
+                                SimulatePendingNINJAJoints();
+
+                            _taintedPrims.Clear();
+                        }
+
+                        if (CollectStats)
+                        {
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODEPrimTaintMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
                         }
 
                         // Move characters
-                        lock (_characters)
+                        foreach (OdeCharacter actor in _characters)
+                            actor.Move(defects);
+
+                        if (defects.Count != 0)
                         {
-                            List<OdeCharacter> defects = new List<OdeCharacter>();
-                            foreach (OdeCharacter actor in _characters)
-                            {
-                                if (actor != null)
-                                    actor.Move(defects);
-                            }
-                            if (defects.Count != 0)
+                            foreach (OdeCharacter actor in defects)
                             {
-                                foreach (OdeCharacter defect in defects)
-                                {
-                                    RemoveCharacter(defect);
-                                }
-                                defects.Clear();
+                                m_log.ErrorFormat(
+                                    "[ODE SCENE]: Removing physics character {0} {1} from physics scene {2} due to defect found when moving",
+                                    actor.Name, actor.LocalID, Name);
+
+                                RemoveCharacter(actor);
+                                actor.DestroyOdeStructures();
                             }
+
+                            defects.Clear();
+                        }
+
+                        if (CollectStats)
+                        {
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODEAvatarForcesFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
                         }
 
                         // Move other active objects
-                        lock (_activegroups)
+                        foreach (OdePrim prim in _activeprims)
                         {
-                            foreach (OdePrim aprim in _activegroups)
-                            {
-                                aprim.Move();
-                            }
+                            prim.m_collisionscore = 0;
+                            prim.Move(timeStep);
+                        }
+
+                        if (CollectStats)
+                        {
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODEPrimForcesFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
                         }
- 
+
+                        //if ((framecount % m_randomizeWater) == 0)
+                           // randomizeWater(waterlevel);
+
+                        //int RayCastTimeMS = m_rayCastManager.ProcessQueuedRequests();
                         m_rayCastManager.ProcessQueuedRequests();
 
+                        if (CollectStats)
+                        {
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODERaycastingFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
+                        }
+
                         collision_optimized();
 
-                        foreach (PhysicsActor obj in _collisionEventPrim)
+                        if (CollectStats)
+                        {
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODEOtherCollisionFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
+                        }
+
+                        foreach (PhysicsActor obj in m_collisionEventActors.Values)
                         {
-                            if (obj == null)
-                                continue;
+//                                m_log.DebugFormat("[PHYSICS]: Assessing {0} {1} for collision events", obj.SOPName, obj.LocalID);
 
                             switch ((ActorTypes)obj.PhysicsActorType)
                             {
                                 case ActorTypes.Agent:
                                     OdeCharacter cobj = (OdeCharacter)obj;
-                                    cobj.AddCollisionFrameTime((int)(odetimestepMS));
+                                    cobj.AddCollisionFrameTime(100);
                                     cobj.SendCollisions();
                                     break;
 
                                 case ActorTypes.Prim:
                                     OdePrim pobj = (OdePrim)obj;
-                                    if (pobj.Body == IntPtr.Zero || (d.BodyIsEnabled(pobj.Body) && !pobj.m_outbounds))
-                                    if (!pobj.m_outbounds)
-                                    {
-                                        pobj.AddCollisionFrameTime((int)(odetimestepMS));
-                                        pobj.SendCollisions();
-                                    }
+                                    pobj.SendCollisions();
                                     break;
                             }
                         }
 
-                        foreach (PhysicsActor obj in _collisionEventPrimRemove)
-                            _collisionEventPrim.Remove(obj);
-
-                        _collisionEventPrimRemove.Clear();
+//                        if (m_global_contactcount > 0)
+//                            m_log.DebugFormat(
+//                                "[PHYSICS]: Collision contacts to process this frame = {0}", m_global_contactcount);
 
-                        // do a ode simulation step
-                        d.WorldQuickStep(world, ODE_STEPSIZE);
-//                        d.WorldStep(world, ODE_STEPSIZE);
-                        d.JointGroupEmpty(contactgroup);
+                        m_global_contactcount = 0;
 
-                        // update managed ideia of physical data and do updates to core
-        /*
-                        lock (_characters)
+                        if (CollectStats)
                         {
-                            foreach (OdeCharacter actor in _characters)
-                            {
-                                if (actor != null)
-                                {
-                                    if (actor.bad)
-                                        m_log.WarnFormat("[PHYSICS]: BAD Actor {0} in _characters list was not removed?", actor.m_uuid);
-
-                                    actor.UpdatePositionAndVelocity();
-                                }
-                            }
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODECollisionNotificationFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
                         }
-        */
 
-                        lock (_activegroups)
-                        {
-                            {
-                                foreach (OdePrim actor in _activegroups)
-                                {
-                                    if (actor.IsPhysical)
-                                    {
-                                        actor.UpdatePositionAndVelocity(framecount);
-                                    }
-                                }
-                            }
-                        }
+                        d.WorldQuickStep(world, ODE_STEPSIZE);
+
+                        if (CollectStats)
+                            m_stats[ODENativeStepFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick);
+
+                        d.JointGroupEmpty(contactgroup);
                     }
                     catch (Exception e)
                     {
-                        m_log.ErrorFormat("[PHYSICS]: {0}, {1}, {2}", e.Message, e.TargetSite, e);
-//                        ode.dunlock(world);
+                        m_log.ErrorFormat("[ODE SCENE]: {0}, {1}, {2}", e.Message, e.TargetSite, e);
                     }
 
                     step_time -= ODE_STEPSIZE;
-                    nodeframes++;
+                    fps += ODE_STEPSIZE;
+                }
 
-                    looptimeMS = Util.EnvironmentTickCountSubtract(loopstartMS);
-                    if (looptimeMS > 100)
-                        break;
+                if (CollectStats)
+                    tempTick = Util.EnvironmentTickCount();
+
+                foreach (OdeCharacter actor in _characters)
+                {
+                    if (actor.bad)
+                        m_log.ErrorFormat("[ODE SCENE]: BAD Actor {0} in _characters list was not removed?", actor.m_uuid);
+
+                    actor.UpdatePositionAndVelocity(defects);
                 }
 
-                lock (_badCharacter)
+                if (defects.Count != 0)
                 {
-                    if (_badCharacter.Count > 0)
+                    foreach (OdeCharacter actor in defects)
                     {
-                        foreach (OdeCharacter chr in _badCharacter)
-                        {
-                            RemoveCharacter(chr);
-                        }
+                        m_log.ErrorFormat(
+                            "[ODE SCENE]: Removing physics character {0} {1} from physics scene {2} due to defect found when updating position and velocity",
+                            actor.Name, actor.LocalID, Name);
 
-                        _badCharacter.Clear();
+                        RemoveCharacter(actor);
+                        actor.DestroyOdeStructures();
                     }
-                }
 
-                timedif = now - m_lastMeshExpire;
+                    defects.Clear();
+                }
 
-                if (timedif.Seconds > 10)
+                if (CollectStats)
                 {
-                    mesher.ExpireReleaseMeshs();
-                    m_lastMeshExpire = now;
+                    tempTick2 = Util.EnvironmentTickCount();
+                    m_stats[ODEAvatarUpdateFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                    tempTick = tempTick2;
                 }
 
-// information block running in debug only
-/*
-                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;
+                //if (timeStep < 0.2f)
 
-                for (int i = 0; i < ntopactivegeoms; i++)
+                foreach (OdePrim prim in _activeprims)
                 {
-                    sp = d.SpaceGetGeom(ActiveSpace, i);
-                    if (d.GeomIsSpace(sp))
+                    if (prim.IsPhysical && (d.BodyIsEnabled(prim.Body) || !prim._zeroFlag))
                     {
-                        nactivespaces++;
-                        nactivegeoms += d.SpaceGetNumGeoms(sp);
-                    }
-                    else
-                        nactivegeoms++;
-                }
+                        prim.UpdatePositionAndVelocity();
 
-                for (int i = 0; i < ntopstaticgeoms; i++)
-                {
-                    sp = d.SpaceGetGeom(StaticSpace, i);
-                    if (d.GeomIsSpace(sp))
-                    {
-                        nstaticspaces++;
-                        nstaticgeoms += d.SpaceGetNumGeoms(sp);
+                        if (SupportsNINJAJoints)
+                            SimulateActorPendingJoints(prim);
                     }
-                    else
-                        nstaticgeoms++;
                 }
 
-                int ntopgeoms = d.SpaceGetNumGeoms(TopSpace);
+                if (CollectStats)
+                    m_stats[ODEPrimUpdateFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick);
+
+                //DumpJointInfo();
 
-                int totgeoms = nstaticgeoms + nactivegeoms + ngroundgeoms + 1; // one ray
-                int nbodies = d.NTotalBodies;
-                int ngeoms = d.NTotalGeoms;
-*/
                 // 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?
@@ -1845,314 +3288,535 @@ namespace OpenSim.Region.Physics.OdePlugin
 
                     d.WorldExportDIF(world, fname, physics_logging_append_existing_logfile, prefix);
                 }
-                
-                // think time dilation as to do with dinamic step size that we dont' have
-                // even so tell something to world
-                if (looptimeMS < 100) // we did the requested loops
-                    m_timeDilation = 1.0f;
-                else if (step_time > 0)
-                {
-                    m_timeDilation = timeStep / step_time;
-                    if (m_timeDilation > 1)
-                        m_timeDilation = 1;
-                    if (step_time > m_SkipFramesAtms)
-                        step_time = 0;
-                    m_lastframe = DateTime.UtcNow; // skip also the time lost
-                }
-            }
-
-//            return nodeframes * ODE_STEPSIZE; // return real simulated time
-            return 1000 * nodeframes; // return steps for now * 1000 to keep core happy
-        }
-
-        /// <summary>
-        public override void GetResults()
-        {
-        }
-
-        public override bool IsThreaded
-        {
-            // for now we won't be multithreaded
-            get { return (false); }
-        }
-
-        public float GetTerrainHeightAtXY(float x, float y)
-        {
-
-            int offsetX = 0;
-            int offsetY = 0;
-
-            if (m_suportCombine)
-            {
-                offsetX = ((int)(x / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
-                offsetY = ((int)(y / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
-            }
-
-            // get region map
-            IntPtr heightFieldGeom = IntPtr.Zero;
-            if (!RegionTerrain.TryGetValue(new Vector3(offsetX, offsetY, 0), out heightFieldGeom))
-                return 0f;
-
-            if (heightFieldGeom == IntPtr.Zero)
-                return 0f;
-
-            if (!TerrainHeightFieldHeights.ContainsKey(heightFieldGeom))
-                return 0f;
 
-            // TerrainHeightField for ODE as offset 1m
-            x += 1f - offsetX;
-            y += 1f - offsetY;
+                latertickcount = Util.EnvironmentTickCountSubtract(tickCountFrameRun);
 
-            // make position fit into array
-            if (x < 0)
-                x = 0;
-            if (y < 0)
-                y = 0;
+                // OpenSimulator above does 10 fps.  10 fps = means that the main thread loop and physics
+                // has a max of 100 ms to run theoretically.
+                // If the main loop stalls, it calls Simulate later which makes the tick count ms larger.
+                // If Physics stalls, it takes longer which makes the tick count ms larger.
 
-            // integer indexs
-            int ix;
-            int iy;
-            //  interpolators offset
-            float dx;
-            float dy;
-
-            int regsizeX = (int)m_regionWidth + 3; // map size see setterrain number of samples
-            int regsizeY = (int)m_regionHeight + 3; // map size see setterrain number of samples
-            int regsize = regsizeX;
-
-            if (OdeUbitLib)
-            {
-                if (x < regsizeX - 1)
-                {
-                    ix = (int)x;
-                    dx = x - (float)ix;
-                }
-                else // out world use external height
-                {
-                    ix = regsizeX - 2;
-                    dx = 0;
-                }
-                if (y < regsizeY - 1)
+                if (latertickcount < 100)
                 {
-                    iy = (int)y;
-                    dy = y - (float)iy;
+                    m_timeDilation = 1.0f;
                 }
                 else
                 {
-                    iy = regsizeY - 2;
-                    dy = 0;
+                    m_timeDilation = 100f / latertickcount;
+                    //m_timeDilation = Math.Min((Math.Max(100 - (Util.EnvironmentTickCount() - tickCountFrameRun), 1) / 100f), 1.0f);
                 }
-            }
-            else
-            {
-                // we  still have square fixed size regions
-                // also flip x and y because of how map is done for ODE fliped axis
-                // so ix,iy,dx and dy are inter exchanged
 
-                regsize = regsizeY;
+                tickCountFrameRun = Util.EnvironmentTickCount();
 
-                if (x < regsizeX - 1)
-                {
-                    iy = (int)x;
-                    dy = x - (float)iy;
-                }
-                else // out world use external height
-                {
-                    iy = regsizeX - 2;
-                    dy = 0;
-                }
-                if (y < regsizeY - 1)
-                {
-                    ix = (int)y;
-                    dx = y - (float)ix;
-                }
-                else
-                {
-                    ix = regsizeY - 2;
-                    dx = 0;
-                }
+                if (CollectStats)
+                    m_stats[ODETotalFrameMsStatName] += Util.EnvironmentTickCountSubtract(startFrameTick);
             }
 
-            float h0;
-            float h1;
-            float h2;
+            fps *= 1000.0f/timeStep;
+            return fps;
+        }
 
-            iy *= regsize;
-            iy += ix; // all indexes have iy + ix
+        /// <summary>
+        /// Simulate pending NINJA joints.
+        /// </summary>
+        /// <remarks>
+        /// Called by the main Simulate() loop if NINJA joints are active.  Should not be called from anywhere else.
+        /// </remarks>
+        private void SimulatePendingNINJAJoints()
+        {
+            // Create pending joints, if possible
 
-            float[] heights = TerrainHeightFieldHeights[heightFieldGeom];
-            /*
-                        if ((dx + dy) <= 1.0f)
+            // joints can only be processed after ALL bodies are processed (and exist in ODE), since creating
+            // a joint requires specifying the body id of both involved bodies
+            if (pendingJoints.Count > 0)
+            {
+                List<PhysicsJoint> successfullyProcessedPendingJoints = new List<PhysicsJoint>();
+                //DoJointErrorMessage(joints_connecting_actor, "taint: " + pendingJoints.Count + " pending joints");
+                foreach (PhysicsJoint joint in pendingJoints)
+                {
+                    //DoJointErrorMessage(joint, "taint: time to create joint with parms: " + joint.RawParams);
+                    string[] jointParams = joint.RawParams.Split(" ".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries);
+                    List<IntPtr> jointBodies = new List<IntPtr>();
+                    bool allJointBodiesAreReady = true;
+                    foreach (string jointParam in jointParams)
+                    {
+                        if (jointParam == "NULL")
                         {
-                            h0 = ((float)heights[iy]); // 0,0 vertice
-                            h1 = (((float)heights[iy + 1]) - h0) * dx; // 1,0 vertice minus 0,0
-                            h2 = (((float)heights[iy + regsize]) - h0) * dy; // 0,1 vertice minus 0,0
+                            //DoJointErrorMessage(joint, "attaching NULL joint to world");
+                            jointBodies.Add(IntPtr.Zero);
                         }
                         else
                         {
-                            h0 = ((float)heights[iy + regsize + 1]); // 1,1 vertice
-                            h1 = (((float)heights[iy + 1]) - h0) * (1 - dy); // 1,1 vertice minus 1,0
-                            h2 = (((float)heights[iy + regsize]) - h0) * (1 - dx); // 1,1 vertice minus 0,1
+                            //DoJointErrorMessage(joint, "looking for prim name: " + jointParam);
+                            bool foundPrim = false;
+                            lock (_prims)
+                            {
+                                foreach (OdePrim prim in _prims) // FIXME: inefficient
+                                {
+                                    if (prim.SOPName == jointParam)
+                                    {
+                                        //DoJointErrorMessage(joint, "found for prim name: " + jointParam);
+                                        if (prim.IsPhysical && prim.Body != IntPtr.Zero)
+                                        {
+                                            jointBodies.Add(prim.Body);
+                                            foundPrim = true;
+                                            break;
+                                        }
+                                        else
+                                        {
+                                            DoJointErrorMessage(joint, "prim name " + jointParam +
+                                                " exists but is not (yet) physical; deferring joint creation. " +
+                                                "IsPhysical property is " + prim.IsPhysical +
+                                                " and body is " + prim.Body);
+                                            foundPrim = false;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                            if (foundPrim)
+                            {
+                                // all is fine
+                            }
+                            else
+                            {
+                                allJointBodiesAreReady = false;
+                                break;
+                            }
                         }
-            */
-            h0 = ((float)heights[iy]); // 0,0 vertice
+                    }
 
-            if (dy>dx)
-            {
-                iy += regsize;
-                h2 = (float)heights[iy]; // 0,1 vertice
-                h1 = (h2 - h0) * dy; // 0,1 vertice minus 0,0
-                h2 = ((float)heights[iy + 1] - h2) * dx; // 1,1 vertice minus 0,1
-            }
-            else
-            {
-                iy++;
-                h2 = (float)heights[iy]; // vertice 1,0
-                h1 = (h2 - h0) * dx; // 1,0 vertice minus 0,0
-                h2 = (((float)heights[iy + regsize]) - h2) * dy; // 1,1 vertice minus 1,0
-            }
+                    if (allJointBodiesAreReady)
+                    {
+                        //DoJointErrorMessage(joint, "allJointBodiesAreReady for " + joint.ObjectNameInScene + " with parms " + joint.RawParams);
+                        if (jointBodies[0] == jointBodies[1])
+                        {
+                            DoJointErrorMessage(joint, "ERROR: joint cannot be created; the joint bodies are the same, body1==body2. Raw body is " + jointBodies[0] + ". raw parms: " + joint.RawParams);
+                        }
+                        else
+                        {
+                            switch (joint.Type)
+                            {
+                                case PhysicsJointType.Ball:
+                                    {
+                                        IntPtr odeJoint;
+                                        //DoJointErrorMessage(joint, "ODE creating ball joint ");
+                                        odeJoint = d.JointCreateBall(world, IntPtr.Zero);
+                                        //DoJointErrorMessage(joint, "ODE attaching ball joint: " + odeJoint + " with b1:" + jointBodies[0] + " b2:" + jointBodies[1]);
+                                        d.JointAttach(odeJoint, jointBodies[0], jointBodies[1]);
+                                        //DoJointErrorMessage(joint, "ODE setting ball anchor: " + odeJoint + " to vec:" + joint.Position);
+                                        d.JointSetBallAnchor(odeJoint,
+                                                            joint.Position.X,
+                                                            joint.Position.Y,
+                                                            joint.Position.Z);
+                                        //DoJointErrorMessage(joint, "ODE joint setting OK");
+                                        //DoJointErrorMessage(joint, "The ball joint's bodies are here: b0: ");
+                                        //DoJointErrorMessage(joint, "" + (jointBodies[0] != IntPtr.Zero ? "" + d.BodyGetPosition(jointBodies[0]) : "fixed environment"));
+                                        //DoJointErrorMessage(joint, "The ball joint's bodies are here: b1: ");
+                                        //DoJointErrorMessage(joint, "" + (jointBodies[1] != IntPtr.Zero ? "" + d.BodyGetPosition(jointBodies[1]) : "fixed environment"));
+
+                                        if (joint is OdePhysicsJoint)
+                                        {
+                                            ((OdePhysicsJoint)joint).jointID = odeJoint;
+                                        }
+                                        else
+                                        {
+                                            DoJointErrorMessage(joint, "WARNING: non-ode joint in ODE!");
+                                        }
+                                    }
+                                    break;
+                                case PhysicsJointType.Hinge:
+                                    {
+                                        IntPtr odeJoint;
+                                        //DoJointErrorMessage(joint, "ODE creating hinge joint ");
+                                        odeJoint = d.JointCreateHinge(world, IntPtr.Zero);
+                                        //DoJointErrorMessage(joint, "ODE attaching hinge joint: " + odeJoint + " with b1:" + jointBodies[0] + " b2:" + jointBodies[1]);
+                                        d.JointAttach(odeJoint, jointBodies[0], jointBodies[1]);
+                                        //DoJointErrorMessage(joint, "ODE setting hinge anchor: " + odeJoint + " to vec:" + joint.Position);
+                                        d.JointSetHingeAnchor(odeJoint,
+                                                              joint.Position.X,
+                                                              joint.Position.Y,
+                                                              joint.Position.Z);
+                                        // We use the orientation of the x-axis of the joint's coordinate frame
+                                        // as the axis for the hinge.
+
+                                        // Therefore, we must get the joint's coordinate frame based on the
+                                        // joint.Rotation field, which originates from the orientation of the 
+                                        // joint's proxy object in the scene.
+
+                                        // The joint's coordinate frame is defined as the transformation matrix
+                                        // that converts a vector from joint-local coordinates into world coordinates.
+                                        // World coordinates are defined as the XYZ coordinate system of the sim,
+                                        // as shown in the top status-bar of the viewer.
+
+                                        // Once we have the joint's coordinate frame, we extract its X axis (AtAxis)
+                                        // and use that as the hinge axis.
+
+                                        //joint.Rotation.Normalize();
+                                        Matrix4 proxyFrame = Matrix4.CreateFromQuaternion(joint.Rotation);
+
+                                        // Now extract the X axis of the joint's coordinate frame.
+
+                                        // Do not try to use proxyFrame.AtAxis or you will become mired in the
+                                        // tar pit of transposed, inverted, and generally messed-up orientations.
+                                        // (In other words, Matrix4.AtAxis() is borked.)
+                                        // Vector3 jointAxis = proxyFrame.AtAxis; <--- this path leadeth to madness
+
+                                        // Instead, compute the X axis of the coordinate frame by transforming
+                                        // the (1,0,0) vector. At least that works.
+
+                                        //m_log.Debug("PHY: making axis: complete matrix is " + proxyFrame);
+                                        Vector3 jointAxis = Vector3.Transform(Vector3.UnitX, proxyFrame);
+                                        //m_log.Debug("PHY: making axis: hinge joint axis is " + jointAxis);
+                                        //DoJointErrorMessage(joint, "ODE setting hinge axis: " + odeJoint + " to vec:" + jointAxis);
+                                        d.JointSetHingeAxis(odeJoint,
+                                                            jointAxis.X,
+                                                            jointAxis.Y,
+                                                            jointAxis.Z);
+                                        //d.JointSetHingeParam(odeJoint, (int)dParam.CFM, 0.1f);
+                                        if (joint is OdePhysicsJoint)
+                                        {
+                                            ((OdePhysicsJoint)joint).jointID = odeJoint;
+                                        }
+                                        else
+                                        {
+                                            DoJointErrorMessage(joint, "WARNING: non-ode joint in ODE!");
+                                        }
+                                    }
+                                    break;
+                            }
+                            successfullyProcessedPendingJoints.Add(joint);
+                        }
+                    }
+                    else
+                    {
+                        DoJointErrorMessage(joint, "joint could not yet be created; still pending");
+                    }
+                }
 
-            return h0 + h1 + h2;
+                foreach (PhysicsJoint successfullyProcessedJoint in successfullyProcessedPendingJoints)
+                {
+                    //DoJointErrorMessage(successfullyProcessedJoint, "finalizing succesfully procsssed joint " + successfullyProcessedJoint.ObjectNameInScene + " parms " + successfullyProcessedJoint.RawParams);
+                    //DoJointErrorMessage(successfullyProcessedJoint, "removing from pending");
+                    InternalRemovePendingJoint(successfullyProcessedJoint);
+                    //DoJointErrorMessage(successfullyProcessedJoint, "adding to active");
+                    InternalAddActiveJoint(successfullyProcessedJoint);
+                    //DoJointErrorMessage(successfullyProcessedJoint, "done");
+                }
+            }
         }
 
-        public Vector3 GetTerrainNormalAtXY(float x, float y)
+        /// <summary>
+        /// Simulate the joint proxies of a NINJA actor.
+        /// </summary>
+        /// <remarks>
+        /// Called as part of the Simulate() loop if NINJA physics is active.  Must only be called from there.
+        /// </remarks>
+        /// <param name="actor"></param>
+        private void SimulateActorPendingJoints(OdePrim actor)
         {
-            int offsetX = 0;
-            int offsetY = 0;
-
-            if (m_suportCombine)
+            // If an actor moved, move its joint proxy objects as well.
+            // There seems to be an event PhysicsActor.OnPositionUpdate that could be used
+            // for this purpose but it is never called! So we just do the joint
+            // movement code here.
+
+            if (actor.SOPName != null &&
+                joints_connecting_actor.ContainsKey(actor.SOPName) &&
+                joints_connecting_actor[actor.SOPName] != null &&
+                joints_connecting_actor[actor.SOPName].Count > 0)
             {
-                offsetX = ((int)(x / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
-                offsetY = ((int)(y / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
+                foreach (PhysicsJoint affectedJoint in joints_connecting_actor[actor.SOPName])
+                {
+                    if (affectedJoint.IsInPhysicsEngine)
+                    {
+                        DoJointMoved(affectedJoint);
+                    }
+                    else
+                    {
+                        DoJointErrorMessage(affectedJoint, "a body connected to a joint was moved, but the joint doesn't exist yet! this will lead to joint error. joint was: " + affectedJoint.ObjectNameInScene + " parms:" + affectedJoint.RawParams);
+                    }
+                }
             }
+        }
 
-            // get region map
-            IntPtr heightFieldGeom = IntPtr.Zero;
-            Vector3 norm = new Vector3(0, 0, 1);
-
-            if (!RegionTerrain.TryGetValue(new Vector3(offsetX, offsetY, 0), out heightFieldGeom))
-                return norm; ;
-
-            if (heightFieldGeom == IntPtr.Zero)
-                return norm;
-
-            if (!TerrainHeightFieldHeights.ContainsKey(heightFieldGeom))
-                return norm;
-
-            // TerrainHeightField for ODE as offset 1m
-            x += 1f - offsetX;
-            y += 1f - offsetY;
-
-            // make position fit into array
-            if (x < 0)
-                x = 0;
-            if (y < 0)
-                y = 0;
-
-            // integer indexs
-            int ix;
-            int iy;
-            //  interpolators offset
-            float dx;
-            float dy;
+        public override void GetResults()
+        {
+        }
 
-            int regsizeX = (int)m_regionWidth + 3; // map size see setterrain number of samples
-            int regsizeY = (int)m_regionHeight + 3; // map size see setterrain number of samples
-            int regsize = regsizeX;
+        public override bool IsThreaded
+        {
+            // for now we won't be multithreaded
+            get { return false; }
+        }
 
-            int xstep = 1;
-            int ystep = regsizeX;
-            bool firstTri = false;
+/* godd try.. but not a fix
+        #region ODE Specific Terrain Fixes
+        private float[] ResizeTerrain512NearestNeighbour(float[] heightMap)
+        {
+            float[] returnarr = new float[262144];
+            float[,] resultarr = new float[(int)WorldExtents.X, (int)WorldExtents.Y];
 
-            if (OdeUbitLib)
+            // Filling out the array into its multi-dimensional components
+            for (int y = 0; y < WorldExtents.Y; y++)
             {
-                if (x < regsizeX - 1)
-                {
-                    ix = (int)x;
-                    dx = x - (float)ix;
-                }
-                else // out world use external height
-                {
-                    ix = regsizeX - 2;
-                    dx = 0;
-                }
-                if (y < regsizeY - 1)
-                {
-                    iy = (int)y;
-                    dy = y - (float)iy;
-                }
-                else
+                for (int x = 0; x < WorldExtents.X; x++)
                 {
-                    iy = regsizeY - 2;
-                    dy = 0;
+                    resultarr[y, x] = heightMap[y * (int)WorldExtents.Y + x];
                 }
-                firstTri = dy > dx;
             }
 
-            else
+            // Resize using Nearest Neighbour
+
+            // This particular way is quick but it only works on a multiple of the original
+
+            // The idea behind this method can be described with the following diagrams
+            // second pass and third pass happen in the same loop really..  just separated
+            // them to show what this does.
+
+            // First Pass
+            // ResultArr:
+            // 1,1,1,1,1,1
+            // 1,1,1,1,1,1
+            // 1,1,1,1,1,1
+            // 1,1,1,1,1,1
+            // 1,1,1,1,1,1
+            // 1,1,1,1,1,1
+
+            // Second Pass
+            // ResultArr2:
+            // 1,,1,,1,,1,,1,,1,
+            // ,,,,,,,,,,
+            // 1,,1,,1,,1,,1,,1,
+            // ,,,,,,,,,,
+            // 1,,1,,1,,1,,1,,1,
+            // ,,,,,,,,,,
+            // 1,,1,,1,,1,,1,,1,
+            // ,,,,,,,,,,
+            // 1,,1,,1,,1,,1,,1,
+            // ,,,,,,,,,,
+            // 1,,1,,1,,1,,1,,1,
+
+            // Third pass fills in the blanks
+            // ResultArr2:
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+
+            // X,Y = .
+            // X+1,y = ^
+            // X,Y+1 = *
+            // X+1,Y+1 = #
+
+            // Filling in like this;
+            // .*
+            // ^#
+            // 1st .
+            // 2nd *
+            // 3rd ^
+            // 4th #
+            // on single loop.
+
+            float[,] resultarr2 = new float[512, 512];
+            for (int y = 0; y < WorldExtents.Y; y++)
             {
-                xstep = regsizeY;
-                ystep = 1;
-                regsize = regsizeY;
-
-                // we  still have square fixed size regions
-                // also flip x and y because of how map is done for ODE fliped axis
-                // so ix,iy,dx and dy are inter exchanged
-                if (x < regsizeX - 1)
-                {
-                    iy = (int)x;
-                    dy = x - (float)iy;
-                }
-                else // out world use external height
-                {
-                    iy = regsizeX - 2;
-                    dy = 0;
-                }
-                if (y < regsizeY - 1)
+                for (int x = 0; x < WorldExtents.X; x++)
                 {
-                    ix = (int)y;
-                    dx = y - (float)ix;
+                    resultarr2[y * 2, x * 2] = resultarr[y, x];
+
+                    if (y < WorldExtents.Y)
+                    {
+                        resultarr2[(y * 2) + 1, x * 2] = resultarr[y, x];
+                    }
+                    if (x < WorldExtents.X)
+                    {
+                        resultarr2[y * 2, (x * 2) + 1] = resultarr[y, x];
+                    }
+                    if (x < WorldExtents.X && y < WorldExtents.Y)
+                    {
+                        resultarr2[(y * 2) + 1, (x * 2) + 1] = resultarr[y, x];
+                    }
                 }
-                else
+            }
+
+            //Flatten out the array
+            int i = 0;
+            for (int y = 0; y < 512; y++)
+            {
+                for (int x = 0; x < 512; x++)
                 {
-                    ix = regsizeY - 2;
-                    dx = 0;
+                    if (resultarr2[y, x] <= 0)
+                        returnarr[i] = 0.0000001f;
+                    else
+                        returnarr[i] = resultarr2[y, x];
+
+                    i++;
                 }
-                firstTri = dx > dy;
             }
 
-            float h0;
-            float h1;
-            float h2;
+            return returnarr;
+        }
 
-            iy *= regsize;
-            iy += ix; // all indexes have iy + ix
+        private float[] ResizeTerrain512Interpolation(float[] heightMap)
+        {
+            float[] returnarr = new float[262144];
+            float[,] resultarr = new float[512,512];
 
-            float[] heights = TerrainHeightFieldHeights[heightFieldGeom];
+            // Filling out the array into its multi-dimensional components
+            for (int y = 0; y < 256; y++)
+            {
+                for (int x = 0; x < 256; x++)
+                {
+                    resultarr[y, x] = heightMap[y * 256 + x];
+                }
+            }
 
-            if (firstTri)
+            // Resize using interpolation
+
+            // This particular way is quick but it only works on a multiple of the original
+
+            // The idea behind this method can be described with the following diagrams
+            // second pass and third pass happen in the same loop really..  just separated
+            // them to show what this does.
+
+            // First Pass
+            // ResultArr:
+            // 1,1,1,1,1,1
+            // 1,1,1,1,1,1
+            // 1,1,1,1,1,1
+            // 1,1,1,1,1,1
+            // 1,1,1,1,1,1
+            // 1,1,1,1,1,1
+
+            // Second Pass
+            // ResultArr2:
+            // 1,,1,,1,,1,,1,,1,
+            // ,,,,,,,,,,
+            // 1,,1,,1,,1,,1,,1,
+            // ,,,,,,,,,,
+            // 1,,1,,1,,1,,1,,1,
+            // ,,,,,,,,,,
+            // 1,,1,,1,,1,,1,,1,
+            // ,,,,,,,,,,
+            // 1,,1,,1,,1,,1,,1,
+            // ,,,,,,,,,,
+            // 1,,1,,1,,1,,1,,1,
+
+            // Third pass fills in the blanks
+            // ResultArr2:
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+            // 1,1,1,1,1,1,1,1,1,1,1,1
+
+            // X,Y = .
+            // X+1,y = ^
+            // X,Y+1 = *
+            // X+1,Y+1 = #
+
+            // Filling in like this;
+            // .*
+            // ^#
+            // 1st .
+            // 2nd *
+            // 3rd ^
+            // 4th #
+            // on single loop.
+
+            float[,] resultarr2 = new float[512,512];
+            for (int y = 0; y < (int)Constants.RegionSize; y++)
             {
-                h1 = ((float)heights[iy]); // 0,0 vertice
-                iy += ystep;
-                h0 = (float)heights[iy]; // 0,1
-                h2 = (float)heights[iy+xstep]; // 1,1 vertice
-                norm.X = h0 - h2;
-                norm.Y = h1 - h0;              
+                for (int x = 0; x < (int)Constants.RegionSize; x++)
+                {
+                    resultarr2[y*2, x*2] = resultarr[y, x];
+
+                    if (y < (int)Constants.RegionSize)
+                    {
+                        if (y + 1 < (int)Constants.RegionSize)
+                        {
+                            if (x + 1 < (int)Constants.RegionSize)
+                            {
+                                resultarr2[(y*2) + 1, x*2] = ((resultarr[y, x] + resultarr[y + 1, x] +
+                                                               resultarr[y, x + 1] + resultarr[y + 1, x + 1])/4);
+                            }
+                            else
+                            {
+                                resultarr2[(y*2) + 1, x*2] = ((resultarr[y, x] + resultarr[y + 1, x])/2);
+                            }
+                        }
+                        else
+                        {
+                            resultarr2[(y*2) + 1, x*2] = resultarr[y, x];
+                        }
+                    }
+                    if (x < (int)Constants.RegionSize)
+                    {
+                        if (x + 1 < (int)Constants.RegionSize)
+                        {
+                            if (y + 1 < (int)Constants.RegionSize)
+                            {
+                                resultarr2[y*2, (x*2) + 1] = ((resultarr[y, x] + resultarr[y + 1, x] +
+                                                               resultarr[y, x + 1] + resultarr[y + 1, x + 1])/4);
+                            }
+                            else
+                            {
+                                resultarr2[y*2, (x*2) + 1] = ((resultarr[y, x] + resultarr[y, x + 1])/2);
+                            }
+                        }
+                        else
+                        {
+                            resultarr2[y*2, (x*2) + 1] = resultarr[y, x];
+                        }
+                    }
+                    if (x < (int)Constants.RegionSize && y < (int)Constants.RegionSize)
+                    {
+                        if ((x + 1 < (int)Constants.RegionSize) && (y + 1 < (int)Constants.RegionSize))
+                        {
+                            resultarr2[(y*2) + 1, (x*2) + 1] = ((resultarr[y, x] + resultarr[y + 1, x] +
+                                                                 resultarr[y, x + 1] + resultarr[y + 1, x + 1])/4);
+                        }
+                        else
+                        {
+                            resultarr2[(y*2) + 1, (x*2) + 1] = resultarr[y, x];
+                        }
+                    }
+                }
             }
-            else
+            //Flatten out the array
+            int i = 0;
+            for (int y = 0; y < 512; y++)
             {
-                h2 = ((float)heights[iy]); // 0,0 vertice
-                iy += xstep;
-                h0 = ((float)heights[iy]); // 1,0 vertice
-                h1 = (float)heights[iy+ystep]; // vertice 1,1
-                norm.X = h2 - h0;
-                norm.Y = h0 - h1;
+                for (int x = 0; x < 512; x++)
+                {
+                    if (Single.IsNaN(resultarr2[y, x]) || Single.IsInfinity(resultarr2[y, x]))
+                    {
+                        m_log.Warn("[ODE SCENE]: Non finite heightfield element detected.  Setting it to 0");
+                        resultarr2[y, x] = 0;
+                    }
+                    returnarr[i] = resultarr2[y, x];
+                    i++;
+                }
             }
-            norm.Z = 1;
-            norm.Normalize();
-            return norm;
+
+            return returnarr;
         }
 
+        #endregion
+*/
         public override void SetTerrain(float[] heightMap)
         {
             if (m_worldOffset != Vector3.Zero && m_parentScene != null)
@@ -2168,27 +3832,15 @@ namespace OpenSim.Region.Physics.OdePlugin
             }
         }
 
-        public override void CombineTerrain(float[] heightMap, Vector3 pOffset)
-        {
-            if(m_suportCombine)
-                SetTerrain(heightMap, pOffset);
-        }
-
-        public void SetTerrain(float[] heightMap, Vector3 pOffset)
-        {
-            if (OdeUbitLib)
-                UbitSetTerrain(heightMap, pOffset);
-            else
-                OriSetTerrain(heightMap, pOffset);
-        }
-
-        public void OriSetTerrain(float[] heightMap, Vector3 pOffset)
+        private void SetTerrain(float[] heightMap, Vector3 pOffset)
         {
-            // assumes 1m size grid and constante size square regions
-            // needs to know about sims around in future
+            int startTime = Util.EnvironmentTickCount();
+            m_log.DebugFormat("[ODE SCENE]: Setting terrain for {0} with offset {1}", Name, pOffset);
 
+            
             float[] _heightmap;
 
+            // ok im lasy this are just a aliases
             uint regionsizeX = m_regionWidth;
             uint regionsizeY = m_regionHeight;
 
@@ -2206,7 +3858,7 @@ namespace OpenSim.Region.Physics.OdePlugin
             const float thickness = 10f;
             const int wrap = 0;
 
- 
+
             float hfmin = float.MaxValue;
             float hfmax = float.MinValue;
             float val;
@@ -2215,6 +3867,7 @@ namespace OpenSim.Region.Physics.OdePlugin
 
             uint maxXX = regionsizeX - 1;
             uint maxYY = regionsizeY - 1;
+
             // flipping map adding one margin all around so things don't fall in edges
 
             uint xt = 0;
@@ -2232,7 +3885,7 @@ namespace OpenSim.Region.Physics.OdePlugin
 
                     val = heightMap[yy + xx];
                     if (val < 0.0f)
-                        val = 0.0f; // no neg terrain as in chode
+                        val = 0.0f;
                     _heightmap[xt + y] = val;
 
                     if (hfmin > val)
@@ -2251,179 +3904,61 @@ namespace OpenSim.Region.Physics.OdePlugin
                     RegionTerrain.Remove(pOffset);
                     if (GroundGeom != IntPtr.Zero)
                     {
-                        actor_name_map.Remove(GroundGeom);
-                        d.GeomDestroy(GroundGeom);
-
                         if (TerrainHeightFieldHeights.ContainsKey(GroundGeom))
-                            {
-                            TerrainHeightFieldHeightsHandlers[GroundGeom].Free();
-                            TerrainHeightFieldHeightsHandlers.Remove(GroundGeom);
+                        {
                             TerrainHeightFieldHeights.Remove(GroundGeom);
-                            }
+                        }
+                        d.SpaceRemove(space, GroundGeom);
+                        d.GeomDestroy(GroundGeom);
                     }
+
                 }
                 IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
-
-                GCHandle _heightmaphandler = GCHandle.Alloc(_heightmap, GCHandleType.Pinned);
-
-                d.GeomHeightfieldDataBuildSingle(HeightmapData, _heightmaphandler.AddrOfPinnedObject(), 0, heightmapWidth , heightmapHeight,
+                d.GeomHeightfieldDataBuildSingle(HeightmapData, _heightmap, 0, heightmapWidth, heightmapHeight,
                                                  (int)heightmapWidthSamples, (int)heightmapHeightSamples, scale,
                                                  offset, thickness, wrap);
 
                 d.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
-
-                GroundGeom = d.CreateHeightfield(GroundSpace, HeightmapData, 1);
-
+                GroundGeom = d.CreateHeightfield(space, 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;
-                    actor_name_map[GroundGeom] = pa;
-
-//                    geom_name_map[GroundGeom] = "Terrain";
-
-                    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);
-
-
-                    q1 = q1 * q2;
+                    d.GeomSetCategoryBits(GroundGeom, (int)(CollisionCategories.Land));
+                    d.GeomSetCollideBits(GroundGeom, (int)(CollisionCategories.Space));
 
-                    Vector3 v3;
-                    float angle;
-                    q1.GetAxisAngle(out v3, out angle);
-
-                    d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
-                    d.GeomSetRotation(GroundGeom, ref R);
-                    d.GeomSetPosition(GroundGeom, pOffset.X + m_regionWidth * 0.5f, pOffset.Y + m_regionHeight * 0.5f, 0);
-                    RegionTerrain.Add(pOffset, GroundGeom);
-                    TerrainHeightFieldHeights.Add(GroundGeom, _heightmap);
-                    TerrainHeightFieldHeightsHandlers.Add(GroundGeom, _heightmaphandler);
                 }
-            }
-        }
-
-        public void UbitSetTerrain(float[] heightMap, Vector3 pOffset)
-        {
-            // assumes 1m size grid and constante size square regions
-            // needs to know about sims around in future
-
-            float[] _heightmap;
-
-            uint regionsizeX = m_regionWidth;
-            uint regionsizeY = m_regionHeight;
-
-            uint heightmapWidth = regionsizeX + 2;
-            uint heightmapHeight = regionsizeY + 2;
-
-            uint heightmapWidthSamples = heightmapWidth + 1;
-            uint heightmapHeightSamples = heightmapHeight + 1;
-
-            _heightmap = new float[heightmapWidthSamples * heightmapHeightSamples];
-
-
-            float hfmin = float.MaxValue;
-//            float hfmax = float.MinValue;
-            float val;
+                geom_name_map[GroundGeom] = "Terrain";
 
+                d.Matrix3 R = new d.Matrix3();
 
-            uint maxXX = regionsizeX - 1;
-            uint maxYY = regionsizeY - 1;
-            // adding one margin all around so things don't fall in edges
+                Quaternion q1 = Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 1.5707f);
+                Quaternion q2 = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), 1.5707f);
 
-            uint xx;
-            uint yy = 0;
-            uint yt = 0;
+                q1 = q1 * q2;
+                Vector3 v3;
+                float angle;
+                q1.GetAxisAngle(out v3, out angle);
 
-            for (uint y = 0; y < heightmapHeightSamples; y++)
-            {
-                if (y > 1 && y < maxYY)
-                    yy += regionsizeX;
-                xx = 0;
-                for (uint x = 0; x < heightmapWidthSamples; x++)
-                {
-                    if (x > 1 && x < maxXX)
-                        xx++;
-
-                    val = heightMap[yy + xx];
-                    if (val < 0.0f)
-                        val = 0.0f; // no neg terrain as in chode
-                    _heightmap[yt + x] = val;
-
-                    if (hfmin > val)
-                        hfmin = val;
-//                    if (hfmax < val)
-//                        hfmax = val;
-                }
-                yt += heightmapWidthSamples;
-            }
-            lock (OdeLock)
-            {
-                IntPtr GroundGeom = IntPtr.Zero;
-                if (RegionTerrain.TryGetValue(pOffset, out GroundGeom))
+                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, 0);
+                IntPtr testGround = IntPtr.Zero;
+                if (RegionTerrain.TryGetValue(pOffset, out testGround))
                 {
                     RegionTerrain.Remove(pOffset);
-                    if (GroundGeom != IntPtr.Zero)
-                    {
-                        actor_name_map.Remove(GroundGeom);
-                        d.GeomDestroy(GroundGeom);
-
-                        if (TerrainHeightFieldHeights.ContainsKey(GroundGeom))
-                        {
-                            if (TerrainHeightFieldHeightsHandlers[GroundGeom].IsAllocated)
-                                TerrainHeightFieldHeightsHandlers[GroundGeom].Free();
-                            TerrainHeightFieldHeightsHandlers.Remove(GroundGeom);
-                            TerrainHeightFieldHeights.Remove(GroundGeom);
-                        }
-                    }
-                }
-                IntPtr HeightmapData = d.GeomUbitTerrainDataCreate();
-
-                const int wrap = 0;
-                float thickness = hfmin;
-                if (thickness < 0)
-                    thickness = 1;
-
-                GCHandle _heightmaphandler = GCHandle.Alloc(_heightmap, GCHandleType.Pinned);
-
-                d.GeomUbitTerrainDataBuild(HeightmapData, _heightmaphandler.AddrOfPinnedObject(), 0, 1.0f,
-                                                 (int)heightmapWidthSamples, (int)heightmapHeightSamples,
-                                                 thickness, wrap);
-
-//                d.GeomUbitTerrainDataSetBounds(HeightmapData, hfmin - 1, hfmax + 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;
-                    actor_name_map[GroundGeom] = pa;
-
-//                    geom_name_map[GroundGeom] = "Terrain";
-
-                    d.GeomSetPosition(GroundGeom, pOffset.X + m_regionWidth * 0.5f, pOffset.Y + m_regionHeight * 0.5f, 0);
-                    RegionTerrain.Add(pOffset, GroundGeom);
-                    TerrainHeightFieldHeights.Add(GroundGeom, _heightmap);
-                    TerrainHeightFieldHeightsHandlers.Add(GroundGeom, _heightmaphandler);
                 }
+                RegionTerrain.Add(pOffset, GroundGeom, GroundGeom);
+                TerrainHeightFieldHeights.Add(GroundGeom,_heightmap);
             }
-        }
 
+            m_log.DebugFormat(
+                "[ODE SCENE]: Setting terrain for {0} took {1}ms", Name, Util.EnvironmentTickCountSubtract(startTime));
+        }
 
         public override void DeleteTerrain()
         {
         }
 
-        public float GetWaterLevel()
+        internal float GetWaterLevel()
         {
             return waterlevel;
         }
@@ -2432,158 +3967,111 @@ namespace OpenSim.Region.Physics.OdePlugin
         {
             return m_suportCombine;
         }
+
+        public override void SetWaterLevel(float baseheight)
+        {
+            waterlevel = baseheight;
+//            randomizeWater(waterlevel);
+        }
+
 /*
-        public override void UnCombine(PhysicsScene pScene)
+        private void randomizeWater(float baseheight)
         {
-            IntPtr localGround = IntPtr.Zero;
-//            float[] localHeightfield;
-            bool proceed = false;
-            List<IntPtr> geomDestroyList = new List<IntPtr>();
+            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 (RegionTerrain.TryGetValue(Vector3.Zero, out localGround))
+                if (WaterGeom != IntPtr.Zero)
                 {
-                    foreach (IntPtr geom in TerrainHeightFieldHeights.Keys)
-                    {
-                        if (geom == localGround)
-                        {
-//                            localHeightfield = TerrainHeightFieldHeights[geom];
-                            proceed = true;
-                        }
-                        else
-                        {
-                            geomDestroyList.Add(geom);
-                        }
-                    }
+                    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));
+                }
 
-                    if (proceed)
-                    {
-                        m_worldOffset = Vector3.Zero;
-                        WorldExtents = new Vector2((int)Constants.RegionSize, (int)Constants.RegionSize);
-                        m_parentScene = null;
+                geom_name_map[WaterGeom] = "Water";
 
-                        foreach (IntPtr g in geomDestroyList)
-                        {
-                            // removingHeightField needs to be done or the garbage collector will
-                            // collect the terrain data before we tell ODE to destroy it causing 
-                            // memory corruption
-                            if (TerrainHeightFieldHeights.ContainsKey(g))
-                            {
-//                                float[] removingHeightField = TerrainHeightFieldHeights[g];
-                                TerrainHeightFieldHeights.Remove(g);
+                d.Matrix3 R = new d.Matrix3();
 
-                                if (RegionTerrain.ContainsKey(g))
-                                {
-                                    RegionTerrain.Remove(g);
-                                }
+                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));
 
-                                d.GeomDestroy(g);
-                                //removingHeightField = new float[0];
-                            }
-                        }
+                q1 = q1 * q2;
+                //q1 = q1 * q3;
+                Vector3 v3;
+                float angle;
+                q1.GetAxisAngle(out v3, out angle);
 
-                    }
-                    else
-                    {
-                        m_log.Warn("[PHYSICS]: Couldn't proceed with UnCombine.  Region has inconsistant data.");
-                    }
-                }
+                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 SetWaterLevel(float baseheight)
-        {
-            waterlevel = baseheight;
-        }
-
         public override void Dispose()
         {
-            if (m_meshWorker != null)
-                m_meshWorker.Stop();
+            _worldInitialized = false;
+
+            m_rayCastManager.Dispose();
+            m_rayCastManager = null;
 
             lock (OdeLock)
             {
-                m_rayCastManager.Dispose();
-                m_rayCastManager = null;
-
                 lock (_prims)
                 {
-                    ChangesQueue.Clear();
                     foreach (OdePrim prm in _prims)
                     {
-                        prm.DoAChange(changes.Remove, null);
-                        _collisionEventPrim.Remove(prm);
-                    }
-                    _prims.Clear();
-                }
-
-                OdeCharacter[] chtorem;
-                lock (_characters)
-                {
-                    chtorem = new OdeCharacter[_characters.Count];
-                    _characters.CopyTo(chtorem);
-                }
-
-                ChangesQueue.Clear();
-                foreach (OdeCharacter ch in chtorem)
-                    ch.DoAChange(changes.Remove, null);
-
-                               
-                foreach (IntPtr GroundGeom in RegionTerrain.Values)
-                {
-                    if (GroundGeom != IntPtr.Zero)
-                        d.GeomDestroy(GroundGeom);
-                }
-
-
-                RegionTerrain.Clear();
-
-                if (TerrainHeightFieldHeightsHandlers.Count > 0)
-                {
-                    foreach (GCHandle gch in TerrainHeightFieldHeightsHandlers.Values)
-                    {
-                        if (gch.IsAllocated)
-                            gch.Free();
+                        RemovePrim(prm);
                     }
                 }
 
-                TerrainHeightFieldHeightsHandlers.Clear();
-                TerrainHeightFieldHeights.Clear();
-
-                if (ContactgeomsArray != IntPtr.Zero)
-                    Marshal.FreeHGlobal(ContactgeomsArray);
-                if (GlobalContactsArray != IntPtr.Zero)
-                    Marshal.FreeHGlobal(GlobalContactsArray);
-
-
+                //foreach (OdeCharacter act in _characters)
+                //{
+                    //RemoveAvatar(act);
+                //}
                 d.WorldDestroy(world);
-                world = IntPtr.Zero;
                 //d.CloseODE();
             }
+
         }
 
         public override Dictionary<uint, float> GetTopColliders()
         {
-            Dictionary<uint, float> returncolliders = new Dictionary<uint, float>();
-            int cnt = 0;
+            Dictionary<uint, float> topColliders;
+
             lock (_prims)
             {
-                foreach (OdePrim prm in _prims)
-                {
-                    if (prm.CollisionScore > 0)
-                    {
-                        returncolliders.Add(prm.LocalID, prm.CollisionScore);
-                        cnt++;
-                        prm.CollisionScore = 0f;
-                        if (cnt > 25)
-                        {
-                            break;
-                        }
-                    }
-                }
+                List<OdePrim> orderedPrims = new List<OdePrim>(_prims);
+                orderedPrims.OrderByDescending(p => p.CollisionScore);
+                topColliders = orderedPrims.Take(25).ToDictionary(p => p.LocalID, p => p.CollisionScore);
+
+                foreach (OdePrim p in _prims)
+                    p.CollisionScore = 0;
             }
-            return returncolliders;
+
+            return topColliders;
         }
 
         public override bool SupportsRayCast()
@@ -2595,16 +4083,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         {
             if (retMethod != null)
             {
-                ODERayRequest req = new ODERayRequest();
-                req.actor = null;
-                req.callbackMethod = retMethod;
-                req.length = length;
-                req.Normal = direction;
-                req.Origin = position;
-                req.Count = 0;
-                req.filter = RayFilterFlags.AllPrims;
-
-                m_rayCastManager.QueueRequest(req);
+                m_rayCastManager.QueueRequest(position, direction, length, retMethod);
             }
         }
 
@@ -2612,260 +4091,202 @@ namespace OpenSim.Region.Physics.OdePlugin
         {
             if (retMethod != null)
             {
-                ODERayRequest req = new ODERayRequest();
-                req.actor = null;
-                req.callbackMethod = retMethod;
-                req.length = length;
-                req.Normal = direction;
-                req.Origin = position;
-                req.Count = Count;
-                req.filter = RayFilterFlags.AllPrims;
-
-                m_rayCastManager.QueueRequest(req);
+                m_rayCastManager.QueueRequest(position, direction, length, Count, retMethod);
             }
         }
 
-       
         public override List<ContactResult> RaycastWorld(Vector3 position, Vector3 direction, float length, int Count)
         {
-            List<ContactResult> ourresults = new List<ContactResult>();
-            object SyncObject = new object();
-
+            ContactResult[] ourResults = null;
             RayCallback retMethod = delegate(List<ContactResult> results)
             {
-                lock (SyncObject)
-                {
-                    ourresults = results;
-                    Monitor.PulseAll(SyncObject);
-                }
+                ourResults = new ContactResult[results.Count];
+                results.CopyTo(ourResults, 0);
             };
-
-            ODERayRequest req = new ODERayRequest();
-            req.actor = null;
-            req.callbackMethod = retMethod;
-            req.length = length;
-            req.Normal = direction;
-            req.Origin = position;
-            req.Count = Count;
-            req.filter = RayFilterFlags.AllPrims;
-
-            lock (SyncObject)
+            int waitTime = 0;
+            m_rayCastManager.QueueRequest(position, direction, length, Count, retMethod);
+            while (ourResults == null && waitTime < 1000)
             {
-                m_rayCastManager.QueueRequest(req);
-                if (!Monitor.Wait(SyncObject, 500))
-                    return null;
-                else
-                    return ourresults;
+                Thread.Sleep(1);
+                waitTime++;
             }
+            if (ourResults == null)
+                return new List<ContactResult> ();
+            return new List<ContactResult>(ourResults);
         }
 
-        public override bool SupportsRaycastWorldFiltered()
-        {
-            return true;
-        }
-
-        public override object RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags filter)
+#if USE_DRAWSTUFF
+        // Keyboard callback
+        public void command(int cmd)
         {
-            object SyncObject = new object();
-            List<ContactResult> ourresults = new List<ContactResult>();
-
-            RayCallback retMethod = delegate(List<ContactResult> results)
-            {
-                lock (SyncObject)
-                {
-                    ourresults = results;
-                    Monitor.PulseAll(SyncObject);
-                }
-            };
+            IntPtr geom;
+            d.Mass mass;
+            d.Vector3 sides = new d.Vector3(d.RandReal() * 0.5f + 0.1f, d.RandReal() * 0.5f + 0.1f, d.RandReal() * 0.5f + 0.1f);
 
-            ODERayRequest req = new ODERayRequest();
-            req.actor = null;
-            req.callbackMethod = retMethod;
-            req.length = length;
-            req.Normal = direction;
-            req.Origin = position;
-            req.Count = Count;
-            req.filter = filter;
+            
 
-            lock (SyncObject)
+            Char ch = Char.ToLower((Char)cmd);
+            switch ((Char)ch)
             {
-                m_rayCastManager.QueueRequest(req);
-                if (!Monitor.Wait(SyncObject, 500))
-                    return null;
-                else
-                    return ourresults;
-            }
-        }
-
-        public override List<ContactResult> RaycastActor(PhysicsActor actor, Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags flags)
-        {
-            if (actor == null)
-                return new List<ContactResult>();
-
-            IntPtr geom;
-            if (actor is OdePrim)
-                geom = ((OdePrim)actor).prim_geom;
-            else if (actor is OdeCharacter)
-                geom = ((OdePrim)actor).prim_geom;
-            else
-                return new List<ContactResult>();
-
-            if (geom == IntPtr.Zero)
-                return new List<ContactResult>();
+                case 'w':
+                    try
+                    {
+                        Vector3 rotate = (new Vector3(1, 0, 0) * Quaternion.CreateFromEulers(hpr.Z * Utils.DEG_TO_RAD, hpr.Y * Utils.DEG_TO_RAD, hpr.X * Utils.DEG_TO_RAD));
 
-            List<ContactResult> ourResults = null;
-            object SyncObject = new object();
+                        xyz.X += rotate.X; xyz.Y += rotate.Y; xyz.Z += rotate.Z;
+                        ds.SetViewpoint(ref xyz, ref hpr);
+                    }
+                    catch (ArgumentException)
+                    { hpr.X = 0; }
+                    break;
 
-            RayCallback retMethod = delegate(List<ContactResult> results)
-            {
-                lock (SyncObject)
-                {
-                    ourResults = results;
-                    Monitor.PulseAll(SyncObject);
-                }
-            };
+                case 'a':
+                    hpr.X++;
+                    ds.SetViewpoint(ref xyz, ref hpr);
+                    break;
 
-            ODERayRequest req = new ODERayRequest();
-            req.actor = actor;
-            req.callbackMethod = retMethod;
-            req.length = length;
-            req.Normal = direction;
-            req.Origin = position;
-            req.Count = Count;
-            req.filter = flags;
+                case 's':
+                    try
+                    {
+                        Vector3 rotate2 = (new Vector3(-1, 0, 0) * Quaternion.CreateFromEulers(hpr.Z * Utils.DEG_TO_RAD, hpr.Y * Utils.DEG_TO_RAD, hpr.X * Utils.DEG_TO_RAD));
 
-            lock (SyncObject)
-            {
-                m_rayCastManager.QueueRequest(req);
-                if (!Monitor.Wait(SyncObject, 500))
-                    return new List<ContactResult>();
+                        xyz.X += rotate2.X; xyz.Y += rotate2.Y; xyz.Z += rotate2.Z;
+                        ds.SetViewpoint(ref xyz, ref hpr);
+                    }
+                    catch (ArgumentException)
+                    { hpr.X = 0; }
+                    break;
+                case 'd':
+                    hpr.X--;
+                    ds.SetViewpoint(ref xyz, ref hpr);
+                    break;
+                case 'r':
+                    xyz.Z++;
+                    ds.SetViewpoint(ref xyz, ref hpr);
+                    break;
+                case 'f':
+                    xyz.Z--;
+                    ds.SetViewpoint(ref xyz, ref hpr);
+                    break;
+                case 'e':
+                    xyz.Y++;
+                    ds.SetViewpoint(ref xyz, ref hpr);
+                    break;
+                case 'q':
+                    xyz.Y--;
+                    ds.SetViewpoint(ref xyz, ref hpr);
+                    break;
             }
-
-            if (ourResults == null)
-                return new List<ContactResult>();
-            return ourResults;
         }
 
-        public override List<ContactResult> BoxProbe(Vector3 position, Vector3 size, Quaternion orientation, int Count, RayFilterFlags flags)
+        public void step(int pause)
         {
-            List<ContactResult> ourResults = null;
-            object SyncObject = new object();
-
-            ProbeBoxCallback retMethod = delegate(List<ContactResult> results)
+            
+            ds.SetColor(1.0f, 1.0f, 0.0f);
+            ds.SetTexture(ds.Texture.Wood);
+            lock (_prims)
             {
-                lock (SyncObject)
+                foreach (OdePrim prm in _prims)
                 {
-                    ourResults = results;
-                    Monitor.PulseAll(SyncObject);
-                }
-            };
+                    //IntPtr body = d.GeomGetBody(prm.prim_geom);
+                    if (prm.prim_geom != IntPtr.Zero)
+                    {
+                        d.Vector3 pos;
+                        d.GeomCopyPosition(prm.prim_geom, out pos);
+                        //d.BodyCopyPosition(body, out pos);
 
-            ODERayRequest req = new ODERayRequest();
-            req.actor = null;
-            req.callbackMethod = retMethod;
-            req.Normal = size;
-            req.Origin = position;
-            req.orientation = orientation;
-            req.Count = Count;
-            req.filter = flags;
+                        d.Matrix3 R;
+                        d.GeomCopyRotation(prm.prim_geom, out R);
+                        //d.BodyCopyRotation(body, out R);
 
-            lock (SyncObject)
-            {
-                m_rayCastManager.QueueRequest(req);
-                if (!Monitor.Wait(SyncObject, 500))
-                    return new List<ContactResult>();
-            }
 
-            if (ourResults == null)
-                return new List<ContactResult>();
-            return ourResults;
-        }
+                        d.Vector3 sides = new d.Vector3();
+                        sides.X = prm.Size.X;
+                        sides.Y = prm.Size.Y;
+                        sides.Z = prm.Size.Z;
 
-        public override List<ContactResult> SphereProbe(Vector3 position, float radius, int Count, RayFilterFlags flags)
-        {
-            List<ContactResult> ourResults = null;
-            object SyncObject = new object();
+                        ds.DrawBox(ref pos, ref R, ref sides);
+                    }
+                }
+            }
+            ds.SetColor(1.0f, 0.0f, 0.0f);
 
-            ProbeSphereCallback retMethod = delegate(List<ContactResult> results)
+            foreach (OdeCharacter chr in _characters)
             {
-                ourResults = results;
-                Monitor.PulseAll(SyncObject);
-            };
+                if (chr.Shell != IntPtr.Zero)
+                {
+                    IntPtr body = d.GeomGetBody(chr.Shell);
 
-            ODERayRequest req = new ODERayRequest();
-            req.actor = null;
-            req.callbackMethod = retMethod;
-            req.length = radius;
-            req.Origin = position;
-            req.Count = Count;
-            req.filter = flags;
+                    d.Vector3 pos;
+                    d.GeomCopyPosition(chr.Shell, out pos);
+                    //d.BodyCopyPosition(body, out pos);
 
+                    d.Matrix3 R;
+                    d.GeomCopyRotation(chr.Shell, out R);
+                    //d.BodyCopyRotation(body, out R);
 
-            lock (SyncObject)
-            {
-                m_rayCastManager.QueueRequest(req);
-                if (!Monitor.Wait(SyncObject, 500))
-                    return new List<ContactResult>();
-            }
+                    ds.DrawCapsule(ref pos, ref R, chr.Size.Z, 0.35f);
+                    d.Vector3 sides = new d.Vector3();
+                    sides.X = 0.5f;
+                    sides.Y = 0.5f;
+                    sides.Z = 0.5f;
 
-            if (ourResults == null)
-                return new List<ContactResult>();
-            return ourResults;
+                    ds.DrawBox(ref pos, ref R, ref sides);
+                }
+            }
         }
 
-        public override List<ContactResult> PlaneProbe(PhysicsActor actor, Vector4 plane, int Count, RayFilterFlags flags)
+        public void start(int unused)
         {
-            IntPtr geom = IntPtr.Zero;;
+            ds.SetViewpoint(ref xyz, ref hpr);
+        }
+#endif
 
-            if (actor != null)
-            {
-                if (actor is OdePrim)
-                    geom = ((OdePrim)actor).prim_geom;
-                else if (actor is OdeCharacter)
-                    geom = ((OdePrim)actor).prim_geom;
-            }
+        public override Dictionary<string, float> GetStats()
+        {
+            if (!CollectStats)
+                return null;
 
-            List<ContactResult> ourResults = null;
-            object SyncObject = new object();
+            Dictionary<string, float> returnStats;
 
-            ProbePlaneCallback retMethod = delegate(List<ContactResult> results)
+            lock (OdeLock)
             {
-                ourResults = results;
-                Monitor.PulseAll(SyncObject);
-            };
+                returnStats = new Dictionary<string, float>(m_stats);
 
-            ODERayRequest req = new ODERayRequest();
-            req.actor = null;
-            req.callbackMethod = retMethod;
-            req.length = plane.W;
-            req.Normal.X = plane.X;
-            req.Normal.Y = plane.Y;
-            req.Normal.Z = plane.Z;
-            req.Count = Count;
-            req.filter = flags;
+                // FIXME: This is a SUPER DUMB HACK until we can establish stats that aren't subject to a division by
+                // 3 from the SimStatsReporter.
+                returnStats[ODETotalAvatarsStatName] = _characters.Count * 3;
+                returnStats[ODETotalPrimsStatName] = _prims.Count * 3;
+                returnStats[ODEActivePrimsStatName] = _activeprims.Count * 3;
 
-            lock (SyncObject)
-            {
-                m_rayCastManager.QueueRequest(req);
-                if (!Monitor.Wait(SyncObject, 500))
-                    return new List<ContactResult>();
+                InitializeExtraStats();
             }
 
-            if (ourResults == null)
-                return new List<ContactResult>();
-            return ourResults;
+            returnStats[ODEOtherCollisionFrameMsStatName]
+                = returnStats[ODEOtherCollisionFrameMsStatName]
+                    - returnStats[ODENativeSpaceCollisionFrameMsStatName]
+                    - returnStats[ODENativeGeomCollisionFrameMsStatName];
+
+            return returnStats;
         }
 
-        public override int SitAvatar(PhysicsActor actor, Vector3 AbsolutePosition, Vector3 CameraPosition, Vector3 offset, Vector3 AvatarSize, SitAvatarCallback PhysicsSitResponse)
+        private void InitializeExtraStats()
         {
-            Util.FireAndForget( delegate
-            {
-                ODESitAvatar sitAvatar = new ODESitAvatar(this, m_rayCastManager);
-                if(sitAvatar != null)
-                    sitAvatar.Sit(actor, AbsolutePosition, CameraPosition, offset, AvatarSize, PhysicsSitResponse);
-            });
-            return 1;
+            m_stats[ODETotalFrameMsStatName] = 0;
+            m_stats[ODEAvatarTaintMsStatName] = 0;
+            m_stats[ODEPrimTaintMsStatName] = 0;
+            m_stats[ODEAvatarForcesFrameMsStatName] = 0;
+            m_stats[ODEPrimForcesFrameMsStatName] = 0;
+            m_stats[ODERaycastingFrameMsStatName] = 0;
+            m_stats[ODENativeStepFrameMsStatName] = 0;
+            m_stats[ODENativeSpaceCollisionFrameMsStatName] = 0;
+            m_stats[ODENativeGeomCollisionFrameMsStatName] = 0;
+            m_stats[ODEOtherCollisionFrameMsStatName] = 0;
+            m_stats[ODECollisionNotificationFrameMsStatName] = 0;
+            m_stats[ODEAvatarContactsStatsName] = 0;
+            m_stats[ODEPrimContactsStatName] = 0;
+            m_stats[ODEAvatarUpdateFrameMsStatName] = 0;
+            m_stats[ODEPrimUpdateFrameMsStatName] = 0;
         }
-
     }
 }
diff --git a/OpenSim/Region/Physics/POSPlugin/POSScene.cs b/OpenSim/Region/Physics/POSPlugin/POSScene.cs
index 080c6ab..061304a 100644
--- a/OpenSim/Region/Physics/POSPlugin/POSScene.cs
+++ b/OpenSim/Region/Physics/POSPlugin/POSScene.cs
@@ -238,7 +238,7 @@ namespace OpenSim.Region.Physics.POSPlugin
                     character._velocity.Z = (character.Position.Z - oldposZ)/timeStep;
                 }
             }
-            return fps;
+            return 1.0f;
         }
 
         public override void GetResults()
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs b/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
index 26e8e54..e0f4c66 100644
--- a/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
+++ b/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
@@ -1224,16 +1224,13 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
         {
-            return AddAvatar(avName, position, size, isFlying);
+            return null;
         }
 
         public override PhysicsActor AddAvatar(uint localID, string avName, Vector3 position, Vector3 size, float feetOffset, bool isFlying)
         {
-            Vector3 pos;
-            pos.X = position.X;
-            pos.Y = position.Y;
-            pos.Z = position.Z;
-            OdeCharacter newAv = new OdeCharacter(localID,avName, this, pos, size, feetOffset, avDensity, avMovementDivisorWalk, avMovementDivisorRun);
+             OdeCharacter newAv = new OdeCharacter(localID, avName, this, position,
+                size, feetOffset, avDensity, avMovementDivisorWalk, avMovementDivisorRun);
             newAv.Flying = isFlying;
             newAv.MinimumGroundFlightOffset = minimumGroundFlightOffset;
             
@@ -1863,9 +1860,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                     m_lastframe = DateTime.UtcNow; // skip also the time lost
                 }
             }
-
-//            return nodeframes * ODE_STEPSIZE; // return real simulated time
-            return 1000 * nodeframes; // return steps for now * 1000 to keep core happy
+            return (float)nodeframes * ODE_STEPSIZE / timeStep * 1000.0f;
         }
 
         /// <summary>