Merge branch 'mbworknew1' into ubitworkvarnew

118 files changed, 67931 insertions, 0 deletions

diff --git a/OpenSim/Region/PhysicsModules/BasicPhysics/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/BasicPhysics/AssemblyInfo.cs
new file mode 100644
index 0000000..1765ae0
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BasicPhysics/AssemblyInfo.cs
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+using Mono.Addins;
+
+// Information about this assembly is defined by the following
+// attributes.
+//
+// change them to the information which is associated with the assembly
+// you compile.
+
+[assembly : AssemblyTitle("BasicPhysicsModule")]
+[assembly : AssemblyDescription("")]
+[assembly : AssemblyConfiguration("")]
+[assembly : AssemblyCompany("http://opensimulator.org")]
+[assembly : AssemblyProduct("BasicPhysicsModule")]
+[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers")]
+[assembly : AssemblyTrademark("")]
+[assembly : AssemblyCulture("")]
+
+// This sets the default COM visibility of types in the assembly to invisible.
+// If you need to expose a type to COM, use [ComVisible(true)] on that type.
+
+[assembly : ComVisible(false)]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all values by your own or you can build default build and revision
+// numbers with the '*' character (the default):
+
+[assembly : AssemblyVersion("0.8.2.*")]
+
+[assembly: Addin("OpenSim.Region.PhysicsModule.BasicPhysics", OpenSim.VersionInfo.VersionNumber)]
+[assembly: AddinDependency("OpenSim.Region.Framework", OpenSim.VersionInfo.VersionNumber)]
diff --git a/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsActor.cs b/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsActor.cs
new file mode 100644
index 0000000..e7b30ba
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsActor.cs
@@ -0,0 +1,303 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+namespace OpenSim.Region.PhysicsModule.BasicPhysics
+{
+    public class BasicActor : PhysicsActor
+    {
+        public BasicActor(Vector3 size)
+        {
+            Size = size;
+        }
+
+        public override int PhysicsActorType
+        {
+            get { return (int) ActorTypes.Agent; }
+            set { return; }
+        }
+
+        public override Vector3 RotationalVelocity { get; set; }
+
+        public override bool SetAlwaysRun
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override uint LocalID
+        {
+            set { return; }
+        }
+
+        public override bool Grabbed
+        {
+            set { return; }
+        }
+
+        public override bool Selected
+        {
+            set { return; }
+        }
+
+        public override float Buoyancy
+        {
+            get { return 0f; }
+            set { return; }
+        }
+
+        public override bool FloatOnWater
+        {
+            set { return; }
+        }
+
+        public override bool IsPhysical
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool ThrottleUpdates
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Flying { get; set; }
+
+        public override bool IsColliding { get; set; }
+
+        public override bool CollidingGround
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool CollidingObj
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Stopped
+        {
+            get { return false; }
+        }
+
+        public override Vector3 Position { get; set; }
+
+        public override Vector3 Size { get; set; }
+
+        public override PrimitiveBaseShape Shape
+        {
+            set { return; }
+        }
+
+        public override float Mass
+        {
+            get { return 0f; }
+        }
+
+        public override Vector3 Force
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override int VehicleType
+        {
+            get { return 0; }
+            set { return; }
+        }
+
+        public override void VehicleFloatParam(int param, float value)
+        {
+
+        }
+
+        public override void VehicleVectorParam(int param, Vector3 value)
+        {
+
+        }
+
+        public override void VehicleRotationParam(int param, Quaternion rotation)
+        {
+
+        }
+
+        public override void VehicleFlags(int param, bool remove)
+        {
+
+        }
+
+        public override void SetVolumeDetect(int param)
+        {
+
+        }
+
+        public override Vector3 CenterOfMass
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override Vector3 GeometricCenter
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override Vector3 Velocity { get; set; }
+
+        public override Vector3 Torque
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override float CollisionScore
+        {
+            get { return 0f; }
+            set { }
+        }
+
+        public override Quaternion Orientation
+        {
+            get { return Quaternion.Identity; }
+            set { }
+        }
+
+        public override Vector3 Acceleration { get; set; }
+
+        public override bool Kinematic
+        {
+            get { return true; }
+            set { }
+        }
+
+        public override void link(PhysicsActor obj)
+        {
+        }
+
+        public override void delink()
+        {
+        }
+
+        public override void LockAngularMotion(Vector3 axis)
+        {
+        }
+
+        public override void AddForce(Vector3 force, bool pushforce)
+        {
+        }
+
+        public override void AddAngularForce(Vector3 force, bool pushforce)
+        {
+        }
+
+        public override void SetMomentum(Vector3 momentum)
+        {
+        }
+
+        public override void CrossingFailure()
+        {
+        }
+
+        public override Vector3 PIDTarget
+        {
+            set { return; }
+        }
+
+        public override bool PIDActive
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override float PIDTau
+        {
+            set { return; }
+        }
+
+        public override float PIDHoverHeight
+        {
+            set { return; }
+        }
+
+        public override bool PIDHoverActive
+        {
+            set { return; }
+        }
+
+        public override PIDHoverType PIDHoverType
+        {
+            set { return; }
+        }
+
+        public override float PIDHoverTau
+        {
+            set { return; }
+        }
+
+        public override Quaternion APIDTarget 
+        { 
+            set { return; }
+        }
+        
+        public override bool APIDActive
+        { 
+            set { return; }
+        }
+        
+        public override float APIDStrength
+        { 
+            set { return; }
+        }
+        
+        public override float APIDDamping
+        { 
+            set { return; }
+        }
+
+        public override void SubscribeEvents(int ms)
+        {
+        }
+
+        public override void UnSubscribeEvents()
+        {
+        }
+
+        public override bool SubscribedEvents()
+        {
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsPrim.cs b/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsPrim.cs
new file mode 100644
index 0000000..5383f1b
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsPrim.cs
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+namespace OpenSim.Region.PhysicsModule.BasicPhysics
+{
+    public class BasicPhysicsPrim : PhysicsActor
+    {
+        private Vector3 _size;
+//        private PrimitiveBaseShape _shape;
+
+        public BasicPhysicsPrim(
+            string name, uint localId, Vector3 position, Vector3 size, Quaternion orientation, PrimitiveBaseShape shape)
+        {
+            Name = name;
+            LocalID = localId;
+            Position = position;
+            Size = size;
+            Orientation = orientation;
+            Shape = shape;
+        }
+
+        public override int PhysicsActorType
+        {
+            get { return (int) ActorTypes.Agent; }
+            set { return; }
+        }
+
+        public override Vector3 RotationalVelocity { get; set; }
+
+        public override bool SetAlwaysRun
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override uint LocalID
+        {
+            set { return; }
+        }
+
+        public override bool Grabbed
+        {
+            set { return; }
+        }
+
+        public override bool Selected
+        {
+            set { return; }
+        }
+
+        public override float Buoyancy
+        {
+            get { return 0f; }
+            set { return; }
+        }
+
+        public override bool FloatOnWater
+        {
+            set { return; }
+        }
+
+        public override bool IsPhysical
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool ThrottleUpdates
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Flying { get; set; }
+
+        public override bool IsColliding { get; set; }
+
+        public override bool CollidingGround
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool CollidingObj
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Stopped
+        {
+            get { return false; }
+        }
+
+        public override Vector3 Position { get; set; }
+
+        public override Vector3 Size
+        {
+            get { return _size; }
+            set {
+                  _size = value;
+                  _size.Z = _size.Z / 2.0f;
+                }
+        }
+
+        public override PrimitiveBaseShape Shape
+        {
+//            set { _shape = value; }
+            set {}
+        }
+
+        public override float Mass
+        {
+            get { return 0f; }
+        }
+
+        public override Vector3 Force
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override int VehicleType
+        {
+            get { return 0; }
+            set { return; }
+        }
+
+        public override void VehicleFloatParam(int param, float value)
+        {
+
+        }
+
+        public override void VehicleVectorParam(int param, Vector3 value)
+        {
+
+        }
+
+        public override void VehicleRotationParam(int param, Quaternion rotation)
+        {
+
+        }
+
+        public override void VehicleFlags(int param, bool remove)
+        {
+
+        }
+
+        public override void SetVolumeDetect(int param)
+        {
+
+        }
+
+        public override Vector3 CenterOfMass
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override Vector3 GeometricCenter
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override Vector3 Velocity { get; set; }
+
+        public override Vector3 Torque
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override float CollisionScore
+        {
+            get { return 0f; }
+            set { }
+        }
+
+        public override Quaternion Orientation { get; set; }
+
+        public override Vector3 Acceleration { get; set; }
+
+        public override bool Kinematic
+        {
+            get { return true; }
+            set { }
+        }
+
+        public override void link(PhysicsActor obj)
+        {
+        }
+
+        public override void delink()
+        {
+        }
+
+        public override void LockAngularMotion(Vector3 axis)
+        {
+        }
+
+        public override void AddForce(Vector3 force, bool pushforce)
+        {
+        }
+
+        public override void AddAngularForce(Vector3 force, bool pushforce)
+        {
+        }
+
+        public override void SetMomentum(Vector3 momentum)
+        {
+        }
+
+        public override void CrossingFailure()
+        {
+        }
+
+        public override Vector3 PIDTarget
+        {
+            set { return; }
+        }
+
+        public override bool PIDActive
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override float PIDTau
+        {
+            set { return; }
+        }
+
+        public override float PIDHoverHeight
+        {
+            set { return; }
+        }
+
+        public override bool PIDHoverActive
+        {
+            set { return; }
+        }
+
+        public override PIDHoverType PIDHoverType
+        {
+            set { return; }
+        }
+
+        public override float PIDHoverTau
+        {
+            set { return; }
+        }
+
+        public override Quaternion APIDTarget 
+        { 
+            set { return; }
+        }
+        
+        public override bool APIDActive
+        { 
+            set { return; }
+        }
+        
+        public override float APIDStrength
+        { 
+            set { return; }
+        }
+        
+        public override float APIDDamping
+        { 
+            set { return; }
+        }
+
+        public override void SubscribeEvents(int ms)
+        {
+        }
+
+        public override void UnSubscribeEvents()
+        {
+        }
+
+        public override bool SubscribedEvents()
+        {
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsScene.cs b/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsScene.cs
new file mode 100644
index 0000000..ac2c1f3
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsScene.cs
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using Nini.Config;
+using Mono.Addins;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+
+namespace OpenSim.Region.PhysicsModule.BasicPhysics
+{
+    /// <summary>
+    /// This is an incomplete extremely basic physics implementation
+    /// </summary>
+    /// <remarks>
+    /// Not useful for anything at the moment apart from some regression testing in other components where some form
+    /// of physics plugin is needed.
+    /// </remarks>
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "BasicPhysicsScene")]
+    public class BasicScene : PhysicsScene, INonSharedRegionModule
+    {
+        private List<BasicActor> _actors = new List<BasicActor>();
+        private List<BasicPhysicsPrim> _prims = new List<BasicPhysicsPrim>();
+        private float[] _heightMap;
+        private Vector3 m_regionExtent;
+
+        private bool m_Enabled = false;
+
+        //protected internal string sceneIdentifier;
+        #region INonSharedRegionModule
+        public string Name
+        {
+            get { return "basicphysics"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            // TODO: Move this out of Startup
+            IConfig config = source.Configs["Startup"];
+            if (config != null)
+            {
+                string physics = config.GetString("physics", string.Empty);
+                if (physics == Name)
+                    m_Enabled = true;
+            }
+
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            EngineType = Name;
+            PhysicsSceneName = EngineType + "/" + scene.RegionInfo.RegionName;
+
+            scene.RegisterModuleInterface<PhysicsScene>(this);
+            m_regionExtent = new Vector3(scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY, scene.RegionInfo.RegionSizeZ);
+            base.Initialise(scene.PhysicsRequestAsset,
+                (scene.Heightmap != null ? scene.Heightmap.GetFloatsSerialised() : new float[scene.RegionInfo.RegionSizeX * scene.RegionInfo.RegionSizeY]),
+                (float)scene.RegionInfo.RegionSettings.WaterHeight);
+
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+        }
+        #endregion
+
+        public override void Dispose() {}
+
+        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, uint localid)
+        {
+            BasicPhysicsPrim prim = new BasicPhysicsPrim(primName, localid, position, size, rotation, pbs);
+            prim.IsPhysical = isPhysical;
+
+            _prims.Add(prim);
+
+            return prim;
+        }
+
+        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        {
+            BasicActor act = new BasicActor(size);
+            act.Position = position;
+            act.Velocity = velocity;
+            act.Flying = isFlying;
+            _actors.Add(act);
+            return act;
+        }
+
+        public override void RemovePrim(PhysicsActor actor)
+        {
+            BasicPhysicsPrim prim = (BasicPhysicsPrim)actor;
+            if (_prims.Contains(prim))
+                _prims.Remove(prim);
+        }
+
+        public override void RemoveAvatar(PhysicsActor actor)
+        {
+            BasicActor act = (BasicActor)actor;
+            if (_actors.Contains(act))
+                _actors.Remove(act);
+        }
+
+        public override void AddPhysicsActorTaint(PhysicsActor prim)
+        {
+        }
+
+        public override float Simulate(float timeStep)
+        {
+//            Console.WriteLine("Simulating");
+
+            float fps = 0;
+            for (int i = 0; i < _actors.Count; ++i)
+            {
+                BasicActor actor = _actors[i];
+                Vector3 actorPosition = actor.Position;
+                Vector3 actorVelocity = actor.Velocity;
+
+                //Console.WriteLine(
+                //    "Processing actor {0}, starting pos {1}, starting vel {2}", i, actorPosition, actorVelocity);
+
+                actorPosition.X += actor.Velocity.X * timeStep;
+                actorPosition.Y += actor.Velocity.Y * timeStep;
+
+                if (actor.Position.Y < 0)
+                {
+                    actorPosition.Y = 0.1F;
+                }
+                else if (actor.Position.Y >= m_regionExtent.Y)
+                {
+                    actorPosition.Y = (m_regionExtent.Y - 0.1f);
+                }
+
+                if (actor.Position.X < 0)
+                {
+                    actorPosition.X = 0.1F;
+                }
+                else if (actor.Position.X >= m_regionExtent.X)
+                {
+                    actorPosition.X = (m_regionExtent.X - 0.1f);
+                }
+
+                float terrainHeight = 0;
+                if (_heightMap != null)
+                    terrainHeight = _heightMap[(int)actor.Position.Y * (int)m_regionExtent.Y + (int)actor.Position.X];
+
+                float height = terrainHeight + actor.Size.Z;
+//                Console.WriteLine("height {0}, actorPosition {1}", height, actorPosition);
+
+                if (actor.Flying)
+                {
+                    if (actor.Position.Z + (actor.Velocity.Z * timeStep) < terrainHeight + 2)
+                    {
+                        actorPosition.Z = height;
+                        actorVelocity.Z = 0;
+                        actor.IsColliding = true;
+                    }
+                    else
+                    {
+                        actorPosition.Z += actor.Velocity.Z * timeStep;
+                        actor.IsColliding = false;
+                    }
+                }
+                else
+                {
+                    actorPosition.Z = height;
+                    actorVelocity.Z = 0;
+                    actor.IsColliding = true;
+                }
+
+                actor.Position = actorPosition;
+                actor.Velocity = actorVelocity;
+            }
+
+            return 1.0f;
+        }
+
+        public override void GetResults()
+        {
+        }
+
+        public override bool IsThreaded
+        {
+            get { return (false); // for now we won't be multithreaded
+            }
+        }
+
+        public override void SetTerrain(float[] heightMap)
+        {
+            _heightMap = heightMap;
+        }
+
+        public override void DeleteTerrain()
+        {
+        }
+
+        public override void SetWaterLevel(float baseheight)
+        {
+        }
+
+        public override Dictionary<uint, float> GetTopColliders()
+        {
+            Dictionary<uint, float> returncolliders = new Dictionary<uint, float>();
+            return returncolliders;
+        }
+
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs b/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs
new file mode 100755
index 0000000..c4a923c
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs
@@ -0,0 +1,2120 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+
+using OpenSim.Framework;
+
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public sealed class BSAPIUnman : BSAPITemplate
+{
+
+private sealed class BulletWorldUnman : BulletWorld
+{
+    public IntPtr ptr;
+    public BulletWorldUnman(uint id, BSScene physScene, IntPtr xx)
+        : base(id, physScene)
+    {
+        ptr = xx;
+    }
+}
+
+private sealed class BulletBodyUnman : BulletBody
+{
+    public IntPtr ptr;
+    public BulletBodyUnman(uint id, IntPtr xx)
+        : base(id)
+    {
+        ptr = xx;
+    }
+    public override bool HasPhysicalBody
+    {
+        get { return ptr != IntPtr.Zero; }
+    }
+    public override void Clear()
+    {
+        ptr = IntPtr.Zero;
+    }
+    public override string AddrString
+    {
+        get { return ptr.ToString("X"); }
+    }
+}
+
+private sealed class BulletShapeUnman : BulletShape
+{
+    public IntPtr ptr;
+    public BulletShapeUnman(IntPtr xx, BSPhysicsShapeType typ)
+        : base()
+    {
+        ptr = xx;
+        shapeType = typ;
+    }
+    public override bool HasPhysicalShape
+    {
+        get { return ptr != IntPtr.Zero; }
+    }
+    public override void Clear()
+    {
+        ptr = IntPtr.Zero;
+    }
+    public override BulletShape Clone()
+    {
+        return new BulletShapeUnman(ptr, shapeType);
+    }
+    public override bool ReferenceSame(BulletShape other)
+    {
+        BulletShapeUnman otheru = other as BulletShapeUnman;
+        return (otheru != null) && (this.ptr == otheru.ptr);
+
+    }
+    public override string AddrString
+    {
+        get { return ptr.ToString("X"); }
+    }
+}
+private sealed class BulletConstraintUnman : BulletConstraint
+{
+    public BulletConstraintUnman(IntPtr xx) : base()
+    {
+        ptr = xx;
+    }
+    public IntPtr ptr;
+
+    public override void Clear()
+    {
+        ptr = IntPtr.Zero;
+    }
+    public override bool HasPhysicalConstraint { get { return ptr != IntPtr.Zero; } }
+
+    // Used for log messages for a unique display of the memory/object allocated to this instance
+    public override string AddrString
+    {
+        get { return ptr.ToString("X"); }
+    }
+}
+
+// We pin the memory passed between the managed and unmanaged code.
+GCHandle m_paramsHandle;
+private GCHandle m_collisionArrayPinnedHandle;
+private GCHandle m_updateArrayPinnedHandle;
+
+// Handle to the callback used by the unmanaged code to call into the managed code.
+// Used for debug logging.
+// Need to store the handle in a persistant variable so it won't be freed.
+private BSAPICPP.DebugLogCallback m_DebugLogCallbackHandle;
+
+private BSScene PhysicsScene { get; set; }
+
+public override string BulletEngineName { get { return "BulletUnmanaged"; } }
+public override string BulletEngineVersion { get; protected set; }
+
+public BSAPIUnman(string paramName, BSScene physScene)
+{
+    PhysicsScene = physScene;
+
+    // Do something fancy with the paramName to get the right DLL implementation
+    //     like "Bullet-2.80-OpenCL-Intel" loading the version for Intel based OpenCL implementation, etc.
+    if (Util.IsWindows())
+        Util.LoadArchSpecificWindowsDll("BulletSim.dll");
+    // If not Windows, loading is performed by the
+    // Mono loader as specified in
+    // "bin/Physics/OpenSim.Region.Physics.BulletSPlugin.dll.config".
+}
+
+// Initialization and simulation
+public override BulletWorld Initialize(Vector3 maxPosition, ConfigurationParameters parms,
+                                                                                        int maxCollisions,  ref CollisionDesc[] collisionArray,
+                                                                                        int maxUpdates, ref EntityProperties[] updateArray
+                                            )
+{
+    // Pin down the memory that will be used to pass object collisions and updates back from unmanaged code
+    m_paramsHandle = GCHandle.Alloc(parms, GCHandleType.Pinned);
+    m_collisionArrayPinnedHandle = GCHandle.Alloc(collisionArray, GCHandleType.Pinned);
+    m_updateArrayPinnedHandle = GCHandle.Alloc(updateArray, GCHandleType.Pinned);
+
+    // If Debug logging level, enable logging from the unmanaged code
+    m_DebugLogCallbackHandle = null;
+    if (BSScene.m_log.IsDebugEnabled && PhysicsScene.PhysicsLogging.Enabled)
+    {
+        BSScene.m_log.DebugFormat("{0}: Initialize: Setting debug callback for unmanaged code", BSScene.LogHeader);
+        if (PhysicsScene.PhysicsLogging.Enabled)
+            // The handle is saved in a variable to make sure it doesn't get freed after this call
+            m_DebugLogCallbackHandle = new BSAPICPP.DebugLogCallback(BulletLoggerPhysLog);
+        else
+            m_DebugLogCallbackHandle = new BSAPICPP.DebugLogCallback(BulletLogger);
+    }
+
+    // Get the version of the DLL
+    // TODO: this doesn't work yet. Something wrong with marshaling the returned string.
+    // BulletEngineVersion = BulletSimAPI.GetVersion2();
+    BulletEngineVersion = "";
+
+    // Call the unmanaged code with the buffers and other information
+    return new BulletWorldUnman(0, PhysicsScene, BSAPICPP.Initialize2(maxPosition, m_paramsHandle.AddrOfPinnedObject(),
+                                    maxCollisions, m_collisionArrayPinnedHandle.AddrOfPinnedObject(),
+                                    maxUpdates, m_updateArrayPinnedHandle.AddrOfPinnedObject(),
+                                    m_DebugLogCallbackHandle));
+
+}
+
+// Called directly from unmanaged code so don't do much
+private void BulletLogger(string msg)
+{
+    BSScene.m_log.Debug("[BULLETS UNMANAGED]:" + msg);
+}
+
+// Called directly from unmanaged code so don't do much
+private void BulletLoggerPhysLog(string msg)
+{
+    PhysicsScene.DetailLog("[BULLETS UNMANAGED]:" + msg);
+}
+
+public override int PhysicsStep(BulletWorld world, float timeStep, int maxSubSteps, float fixedTimeStep,
+                                        out int updatedEntityCount, out int collidersCount)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return BSAPICPP.PhysicsStep2(worldu.ptr, timeStep, maxSubSteps, fixedTimeStep, out updatedEntityCount, out collidersCount);
+}
+
+public override void Shutdown(BulletWorld world)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BSAPICPP.Shutdown2(worldu.ptr);
+
+    if (m_paramsHandle.IsAllocated)
+    {
+        m_paramsHandle.Free();
+    }
+    if (m_collisionArrayPinnedHandle.IsAllocated)
+    {
+        m_collisionArrayPinnedHandle.Free();
+    }
+    if (m_updateArrayPinnedHandle.IsAllocated)
+    {
+        m_updateArrayPinnedHandle.Free();
+    }
+}
+
+public override bool PushUpdate(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.PushUpdate2(bodyu.ptr);
+}
+
+public override bool UpdateParameter(BulletWorld world, uint localID, String parm, float value)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return BSAPICPP.UpdateParameter2(worldu.ptr, localID, parm, value);
+}
+
+// =====================================================================================
+// Mesh, hull, shape and body creation helper routines
+public override BulletShape CreateMeshShape(BulletWorld world,
+                int indicesCount, int[] indices,
+                int verticesCount, float[] vertices)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return new BulletShapeUnman(
+                    BSAPICPP.CreateMeshShape2(worldu.ptr, indicesCount, indices, verticesCount, vertices),
+                    BSPhysicsShapeType.SHAPE_MESH);
+}
+
+public override BulletShape CreateGImpactShape(BulletWorld world,
+                int indicesCount, int[] indices,
+                int verticesCount, float[] vertices)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return new BulletShapeUnman(
+                    BSAPICPP.CreateGImpactShape2(worldu.ptr, indicesCount, indices, verticesCount, vertices),
+                    BSPhysicsShapeType.SHAPE_GIMPACT);
+}
+
+public override BulletShape CreateHullShape(BulletWorld world, int hullCount, float[] hulls)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return new BulletShapeUnman(
+                    BSAPICPP.CreateHullShape2(worldu.ptr, hullCount, hulls),
+                    BSPhysicsShapeType.SHAPE_HULL);
+}
+
+public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletShapeUnman shapeu = meshShape as BulletShapeUnman;
+    return new BulletShapeUnman(
+                    BSAPICPP.BuildHullShapeFromMesh2(worldu.ptr, shapeu.ptr, parms),
+                    BSPhysicsShapeType.SHAPE_HULL);
+}
+
+public override BulletShape BuildConvexHullShapeFromMesh(BulletWorld world, BulletShape meshShape)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletShapeUnman shapeu = meshShape as BulletShapeUnman;
+    return new BulletShapeUnman(
+                    BSAPICPP.BuildConvexHullShapeFromMesh2(worldu.ptr, shapeu.ptr),
+                    BSPhysicsShapeType.SHAPE_CONVEXHULL);
+}
+
+public override BulletShape CreateConvexHullShape(BulletWorld world,
+                int indicesCount, int[] indices,
+                int verticesCount, float[] vertices)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return new BulletShapeUnman(
+                    BSAPICPP.CreateConvexHullShape2(worldu.ptr, indicesCount, indices, verticesCount, vertices),
+                    BSPhysicsShapeType.SHAPE_CONVEXHULL);
+}
+
+public override BulletShape BuildNativeShape(BulletWorld world, ShapeData shapeData)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return new BulletShapeUnman(BSAPICPP.BuildNativeShape2(worldu.ptr, shapeData), shapeData.Type);
+}
+
+public override bool IsNativeShape(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    if (shapeu != null && shapeu.HasPhysicalShape)
+        return BSAPICPP.IsNativeShape2(shapeu.ptr);
+    return false;
+}
+
+public override void SetShapeCollisionMargin(BulletShape shape, float margin)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    if (shapeu != null && shapeu.HasPhysicalShape)
+        BSAPICPP.SetShapeCollisionMargin(shapeu.ptr, margin);
+}
+
+public override BulletShape BuildCapsuleShape(BulletWorld world, float radius, float height, Vector3 scale)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return new BulletShapeUnman(
+                   BSAPICPP.BuildCapsuleShape2(worldu.ptr, radius, height, scale),
+                   BSPhysicsShapeType.SHAPE_CAPSULE);
+}
+
+public override BulletShape CreateCompoundShape(BulletWorld world, bool enableDynamicAabbTree)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return new BulletShapeUnman(
+                    BSAPICPP.CreateCompoundShape2(worldu.ptr, enableDynamicAabbTree),
+                    BSPhysicsShapeType.SHAPE_COMPOUND);
+
+}
+
+public override int GetNumberOfCompoundChildren(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    if (shapeu != null && shapeu.HasPhysicalShape)
+        return BSAPICPP.GetNumberOfCompoundChildren2(shapeu.ptr);
+    return 0;
+}
+
+public override void AddChildShapeToCompoundShape(BulletShape shape, BulletShape addShape, Vector3 pos, Quaternion rot)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    BulletShapeUnman addShapeu = addShape as BulletShapeUnman;
+    BSAPICPP.AddChildShapeToCompoundShape2(shapeu.ptr, addShapeu.ptr, pos, rot);
+}
+
+public override BulletShape GetChildShapeFromCompoundShapeIndex(BulletShape shape, int indx)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return new BulletShapeUnman(BSAPICPP.GetChildShapeFromCompoundShapeIndex2(shapeu.ptr, indx), BSPhysicsShapeType.SHAPE_UNKNOWN);
+}
+
+public override BulletShape RemoveChildShapeFromCompoundShapeIndex(BulletShape shape, int indx)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return new BulletShapeUnman(BSAPICPP.RemoveChildShapeFromCompoundShapeIndex2(shapeu.ptr, indx), BSPhysicsShapeType.SHAPE_UNKNOWN);
+}
+
+public override void RemoveChildShapeFromCompoundShape(BulletShape shape, BulletShape removeShape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    BulletShapeUnman removeShapeu = removeShape as BulletShapeUnman;
+    BSAPICPP.RemoveChildShapeFromCompoundShape2(shapeu.ptr, removeShapeu.ptr);
+}
+
+public override void UpdateChildTransform(BulletShape pShape, int childIndex, Vector3 pos, Quaternion rot, bool shouldRecalculateLocalAabb)
+{
+    BulletShapeUnman shapeu = pShape as BulletShapeUnman;
+    BSAPICPP.UpdateChildTransform2(shapeu.ptr, childIndex, pos, rot, shouldRecalculateLocalAabb);
+}
+
+public override void RecalculateCompoundShapeLocalAabb(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    BSAPICPP.RecalculateCompoundShapeLocalAabb2(shapeu.ptr);
+}
+
+public override BulletShape DuplicateCollisionShape(BulletWorld world, BulletShape srcShape, uint id)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletShapeUnman srcShapeu = srcShape as BulletShapeUnman;
+    return new BulletShapeUnman(BSAPICPP.DuplicateCollisionShape2(worldu.ptr, srcShapeu.ptr, id), srcShape.shapeType);
+}
+
+public override bool DeleteCollisionShape(BulletWorld world, BulletShape shape)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.DeleteCollisionShape2(worldu.ptr, shapeu.ptr);
+}
+
+public override CollisionObjectTypes GetBodyType(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return (CollisionObjectTypes)BSAPICPP.GetBodyType2(bodyu.ptr);
+}
+
+public override BulletBody CreateBodyFromShape(BulletWorld world, BulletShape shape, uint id, Vector3 pos, Quaternion rot)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return new BulletBodyUnman(id, BSAPICPP.CreateBodyFromShape2(worldu.ptr, shapeu.ptr, id, pos, rot));
+}
+
+public override BulletBody CreateBodyWithDefaultMotionState(BulletShape shape, uint id, Vector3 pos, Quaternion rot)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return new BulletBodyUnman(id, BSAPICPP.CreateBodyWithDefaultMotionState2(shapeu.ptr, id, pos, rot));
+}
+
+public override BulletBody CreateGhostFromShape(BulletWorld world, BulletShape shape, uint id, Vector3 pos, Quaternion rot)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return new BulletBodyUnman(id, BSAPICPP.CreateGhostFromShape2(worldu.ptr, shapeu.ptr, id, pos, rot));
+}
+
+public override void DestroyObject(BulletWorld world, BulletBody obj)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.DestroyObject2(worldu.ptr, bodyu.ptr);
+}
+
+// =====================================================================================
+// Terrain creation and helper routines
+public override BulletShape CreateGroundPlaneShape(uint id, float height, float collisionMargin)
+{
+    return new BulletShapeUnman(BSAPICPP.CreateGroundPlaneShape2(id, height, collisionMargin), BSPhysicsShapeType.SHAPE_GROUNDPLANE);
+}
+
+public override BulletShape CreateTerrainShape(uint id, Vector3 size, float minHeight, float maxHeight, float[] heightMap,
+                                float scaleFactor, float collisionMargin)
+{
+    return new BulletShapeUnman(BSAPICPP.CreateTerrainShape2(id, size, minHeight, maxHeight, heightMap, scaleFactor, collisionMargin),
+                                                BSPhysicsShapeType.SHAPE_TERRAIN);
+}
+
+// =====================================================================================
+// Constraint creation and helper routines
+public override BulletConstraint Create6DofConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frame1loc, Quaternion frame1rot,
+                    Vector3 frame2loc, Quaternion frame2rot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu1 = obj1 as BulletBodyUnman;
+    BulletBodyUnman bodyu2 = obj2 as BulletBodyUnman;
+    return new BulletConstraintUnman(BSAPICPP.Create6DofConstraint2(worldu.ptr, bodyu1.ptr, bodyu2.ptr, frame1loc, frame1rot,
+                    frame2loc, frame2rot, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
+}
+
+public override BulletConstraint Create6DofConstraintToPoint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 joinPoint,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu1 = obj1 as BulletBodyUnman;
+    BulletBodyUnman bodyu2 = obj2 as BulletBodyUnman;
+    return new BulletConstraintUnman(BSAPICPP.Create6DofConstraintToPoint2(worldu.ptr, bodyu1.ptr, bodyu2.ptr,
+                    joinPoint, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
+}
+
+public override BulletConstraint Create6DofConstraintFixed(BulletWorld world, BulletBody obj1,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool useLinearReferenceFrameB, bool disableCollisionsBetweenLinkedBodies)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu1 = obj1 as BulletBodyUnman;
+    return new BulletConstraintUnman(BSAPICPP.Create6DofConstraintFixed2(worldu.ptr, bodyu1.ptr,
+                    frameInBloc, frameInBrot, useLinearReferenceFrameB, disableCollisionsBetweenLinkedBodies));
+}
+
+public override BulletConstraint Create6DofSpringConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frame1loc, Quaternion frame1rot,
+                    Vector3 frame2loc, Quaternion frame2rot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu1 = obj1 as BulletBodyUnman;
+    BulletBodyUnman bodyu2 = obj2 as BulletBodyUnman;
+    return new BulletConstraintUnman(BSAPICPP.Create6DofSpringConstraint2(worldu.ptr, bodyu1.ptr, bodyu2.ptr, frame1loc, frame1rot,
+                    frame2loc, frame2rot, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
+}
+
+public override BulletConstraint CreateHingeConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 pivotinA, Vector3 pivotinB,
+                    Vector3 axisInA, Vector3 axisInB,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu1 = obj1 as BulletBodyUnman;
+    BulletBodyUnman bodyu2 = obj2 as BulletBodyUnman;
+    return new BulletConstraintUnman(BSAPICPP.CreateHingeConstraint2(worldu.ptr, bodyu1.ptr, bodyu2.ptr,
+                    pivotinA, pivotinB, axisInA, axisInB, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
+}
+
+public override BulletConstraint CreateSliderConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frame1loc, Quaternion frame1rot,
+                    Vector3 frame2loc, Quaternion frame2rot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu1 = obj1 as BulletBodyUnman;
+    BulletBodyUnman bodyu2 = obj2 as BulletBodyUnman;
+    return new BulletConstraintUnman(BSAPICPP.CreateSliderConstraint2(worldu.ptr, bodyu1.ptr, bodyu2.ptr, frame1loc, frame1rot,
+                    frame2loc, frame2rot, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
+}
+
+public override BulletConstraint CreateConeTwistConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frame1loc, Quaternion frame1rot,
+                    Vector3 frame2loc, Quaternion frame2rot,
+                    bool disableCollisionsBetweenLinkedBodies)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu1 = obj1 as BulletBodyUnman;
+    BulletBodyUnman bodyu2 = obj2 as BulletBodyUnman;
+    return new BulletConstraintUnman(BSAPICPP.CreateConeTwistConstraint2(worldu.ptr, bodyu1.ptr, bodyu2.ptr, frame1loc, frame1rot,
+                                        frame2loc, frame2rot, disableCollisionsBetweenLinkedBodies));
+}
+
+public override BulletConstraint CreateGearConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 axisInA, Vector3 axisInB,
+                    float ratio, bool disableCollisionsBetweenLinkedBodies)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu1 = obj1 as BulletBodyUnman;
+    BulletBodyUnman bodyu2 = obj2 as BulletBodyUnman;
+    return new BulletConstraintUnman(BSAPICPP.CreateGearConstraint2(worldu.ptr, bodyu1.ptr, bodyu2.ptr, axisInA, axisInB,
+                                        ratio, disableCollisionsBetweenLinkedBodies));
+}
+
+public override BulletConstraint CreatePoint2PointConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 pivotInA, Vector3 pivotInB,
+                    bool disableCollisionsBetweenLinkedBodies)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu1 = obj1 as BulletBodyUnman;
+    BulletBodyUnman bodyu2 = obj2 as BulletBodyUnman;
+    return new BulletConstraintUnman(BSAPICPP.CreatePoint2PointConstraint2(worldu.ptr, bodyu1.ptr, bodyu2.ptr, pivotInA, pivotInB,
+                                        disableCollisionsBetweenLinkedBodies));
+}
+
+public override void SetConstraintEnable(BulletConstraint constrain, float numericTrueFalse)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    BSAPICPP.SetConstraintEnable2(constrainu.ptr, numericTrueFalse);
+}
+
+public override void SetConstraintNumSolverIterations(BulletConstraint constrain, float iterations)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    BSAPICPP.SetConstraintNumSolverIterations2(constrainu.ptr, iterations);
+}
+
+public override bool SetFrames(BulletConstraint constrain,
+                Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SetFrames2(constrainu.ptr, frameA, frameArot, frameB, frameBrot);
+}
+
+public override bool SetLinearLimits(BulletConstraint constrain, Vector3 low, Vector3 hi)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SetLinearLimits2(constrainu.ptr, low, hi);
+}
+
+public override bool SetAngularLimits(BulletConstraint constrain, Vector3 low, Vector3 hi)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SetAngularLimits2(constrainu.ptr, low, hi);
+}
+
+public override bool UseFrameOffset(BulletConstraint constrain, float enable)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.UseFrameOffset2(constrainu.ptr, enable);
+}
+
+public override bool TranslationalLimitMotor(BulletConstraint constrain, float enable, float targetVel, float maxMotorForce)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.TranslationalLimitMotor2(constrainu.ptr, enable, targetVel, maxMotorForce);
+}
+
+public override bool SetBreakingImpulseThreshold(BulletConstraint constrain, float threshold)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SetBreakingImpulseThreshold2(constrainu.ptr, threshold);
+}
+
+public override bool HingeSetLimits(BulletConstraint constrain, float low, float high, float softness, float bias, float relaxation)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.HingeSetLimits2(constrainu.ptr, low, high, softness, bias, relaxation);
+}
+
+public override bool SpringEnable(BulletConstraint constrain, int index, float numericTrueFalse)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.ConstraintSpringEnable2(constrainu.ptr, index, numericTrueFalse);
+}
+
+public override bool SpringSetEquilibriumPoint(BulletConstraint constrain, int index, float equilibriumPoint)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.ConstraintSpringSetEquilibriumPoint2(constrainu.ptr, index, equilibriumPoint);
+}
+
+public override bool SpringSetStiffness(BulletConstraint constrain, int index, float stiffnesss)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.ConstraintSpringSetStiffness2(constrainu.ptr, index, stiffnesss);
+}
+
+public override bool SpringSetDamping(BulletConstraint constrain, int index, float damping)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.ConstraintSpringSetDamping2(constrainu.ptr, index, damping);
+}
+
+public override bool SliderSetLimits(BulletConstraint constrain, int lowerUpper, int linAng, float val)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SliderSetLimits2(constrainu.ptr, lowerUpper, linAng, val);
+}
+
+public override bool SliderSet(BulletConstraint constrain, int softRestDamp, int dirLimOrtho, int linAng, float val)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SliderSet2(constrainu.ptr, softRestDamp, dirLimOrtho, linAng, val);
+}
+
+public override bool SliderMotorEnable(BulletConstraint constrain, int linAng, float numericTrueFalse)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SliderMotorEnable2(constrainu.ptr, linAng, numericTrueFalse);
+}
+
+public override bool SliderMotor(BulletConstraint constrain, int forceVel, int linAng, float val)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SliderMotor2(constrainu.ptr, forceVel, linAng, val);
+}
+
+public override bool CalculateTransforms(BulletConstraint constrain)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.CalculateTransforms2(constrainu.ptr);
+}
+
+public override bool SetConstraintParam(BulletConstraint constrain, ConstraintParams paramIndex, float value, ConstraintParamAxis axis)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SetConstraintParam2(constrainu.ptr, paramIndex, value, axis);
+}
+
+public override bool DestroyConstraint(BulletWorld world, BulletConstraint constrain)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.DestroyConstraint2(worldu.ptr, constrainu.ptr);
+}
+
+// =====================================================================================
+// btCollisionWorld entries
+public override void UpdateSingleAabb(BulletWorld world, BulletBody obj)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.UpdateSingleAabb2(worldu.ptr, bodyu.ptr);
+}
+
+public override void UpdateAabbs(BulletWorld world)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BSAPICPP.UpdateAabbs2(worldu.ptr);
+}
+
+public override bool GetForceUpdateAllAabbs(BulletWorld world)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return BSAPICPP.GetForceUpdateAllAabbs2(worldu.ptr);
+}
+
+public override void SetForceUpdateAllAabbs(BulletWorld world, bool force)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BSAPICPP.SetForceUpdateAllAabbs2(worldu.ptr, force);
+}
+
+// =====================================================================================
+// btDynamicsWorld entries
+public override bool AddObjectToWorld(BulletWorld world, BulletBody obj)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+
+    // Bullet resets several variables when an object is added to the world.
+    //   Gravity is reset to world default depending on the static/dynamic
+    //   type. Of course, the collision flags in the broadphase proxy are initialized to default.
+    Vector3 origGrav = BSAPICPP.GetGravity2(bodyu.ptr);
+
+    bool ret = BSAPICPP.AddObjectToWorld2(worldu.ptr, bodyu.ptr);
+
+    if (ret)
+    {
+        BSAPICPP.SetGravity2(bodyu.ptr, origGrav);
+        obj.ApplyCollisionMask(world.physicsScene);
+    }
+    return ret;
+}
+
+public override bool RemoveObjectFromWorld(BulletWorld world, BulletBody obj)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.RemoveObjectFromWorld2(worldu.ptr, bodyu.ptr);
+}
+
+public override bool ClearCollisionProxyCache(BulletWorld world, BulletBody obj)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.ClearCollisionProxyCache2(worldu.ptr, bodyu.ptr);
+}
+
+public override bool AddConstraintToWorld(BulletWorld world, BulletConstraint constrain, bool disableCollisionsBetweenLinkedObjects)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.AddConstraintToWorld2(worldu.ptr, constrainu.ptr, disableCollisionsBetweenLinkedObjects);
+}
+
+public override bool RemoveConstraintFromWorld(BulletWorld world, BulletConstraint constrain)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.RemoveConstraintFromWorld2(worldu.ptr, constrainu.ptr);
+}
+// =====================================================================================
+// btCollisionObject entries
+public override Vector3 GetAnisotripicFriction(BulletConstraint constrain)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.GetAnisotripicFriction2(constrainu.ptr);
+}
+
+public override Vector3 SetAnisotripicFriction(BulletConstraint constrain, Vector3 frict)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SetAnisotripicFriction2(constrainu.ptr, frict);
+}
+
+public override bool HasAnisotripicFriction(BulletConstraint constrain)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.HasAnisotripicFriction2(constrainu.ptr);
+}
+
+public override void SetContactProcessingThreshold(BulletBody obj, float val)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetContactProcessingThreshold2(bodyu.ptr, val);
+}
+
+public override float GetContactProcessingThreshold(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetContactProcessingThreshold2(bodyu.ptr);
+}
+
+public override bool IsStaticObject(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.IsStaticObject2(bodyu.ptr);
+}
+
+public override bool IsKinematicObject(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.IsKinematicObject2(bodyu.ptr);
+}
+
+public override bool IsStaticOrKinematicObject(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.IsStaticOrKinematicObject2(bodyu.ptr);
+}
+
+public override bool HasContactResponse(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.HasContactResponse2(bodyu.ptr);
+}
+
+public override void SetCollisionShape(BulletWorld world, BulletBody obj, BulletShape shape)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    if (worldu != null && bodyu != null)
+    {
+        // Special case to allow the caller to zero out the reference to any physical shape
+        if (shapeu != null)
+            BSAPICPP.SetCollisionShape2(worldu.ptr, bodyu.ptr, shapeu.ptr);
+        else
+            BSAPICPP.SetCollisionShape2(worldu.ptr, bodyu.ptr, IntPtr.Zero);
+    }
+}
+
+public override BulletShape GetCollisionShape(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return new BulletShapeUnman(BSAPICPP.GetCollisionShape2(bodyu.ptr), BSPhysicsShapeType.SHAPE_UNKNOWN);
+}
+
+public override int GetActivationState(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetActivationState2(bodyu.ptr);
+}
+
+public override void SetActivationState(BulletBody obj, int state)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetActivationState2(bodyu.ptr, state);
+}
+
+public override void SetDeactivationTime(BulletBody obj, float dtime)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetDeactivationTime2(bodyu.ptr, dtime);
+}
+
+public override float GetDeactivationTime(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetDeactivationTime2(bodyu.ptr);
+}
+
+public override void ForceActivationState(BulletBody obj, ActivationState state)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ForceActivationState2(bodyu.ptr, state);
+}
+
+public override void Activate(BulletBody obj, bool forceActivation)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.Activate2(bodyu.ptr, forceActivation);
+}
+
+public override bool IsActive(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.IsActive2(bodyu.ptr);
+}
+
+public override void SetRestitution(BulletBody obj, float val)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetRestitution2(bodyu.ptr, val);
+}
+
+public override float GetRestitution(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetRestitution2(bodyu.ptr);
+}
+
+public override void SetFriction(BulletBody obj, float val)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetFriction2(bodyu.ptr, val);
+}
+
+public override float GetFriction(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetFriction2(bodyu.ptr);
+}
+
+public override Vector3 GetPosition(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetPosition2(bodyu.ptr);
+}
+
+public override Quaternion GetOrientation(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetOrientation2(bodyu.ptr);
+}
+
+public override void SetTranslation(BulletBody obj, Vector3 position, Quaternion rotation)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetTranslation2(bodyu.ptr, position, rotation);
+}
+
+    /*
+public override IntPtr GetBroadphaseHandle(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetBroadphaseHandle2(bodyu.ptr);
+}
+
+public override void SetBroadphaseHandle(BulletBody obj, IntPtr handle)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetUserPointer2(bodyu.ptr, handle);
+}
+     */
+
+public override void SetInterpolationLinearVelocity(BulletBody obj, Vector3 vel)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetInterpolationLinearVelocity2(bodyu.ptr, vel);
+}
+
+public override void SetInterpolationAngularVelocity(BulletBody obj, Vector3 vel)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetInterpolationAngularVelocity2(bodyu.ptr, vel);
+}
+
+public override void SetInterpolationVelocity(BulletBody obj, Vector3 linearVel, Vector3 angularVel)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetInterpolationVelocity2(bodyu.ptr, linearVel, angularVel);
+}
+
+public override float GetHitFraction(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetHitFraction2(bodyu.ptr);
+}
+
+public override void SetHitFraction(BulletBody obj, float val)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetHitFraction2(bodyu.ptr, val);
+}
+
+public override CollisionFlags GetCollisionFlags(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetCollisionFlags2(bodyu.ptr);
+}
+
+public override CollisionFlags SetCollisionFlags(BulletBody obj, CollisionFlags flags)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.SetCollisionFlags2(bodyu.ptr, flags);
+}
+
+public override CollisionFlags AddToCollisionFlags(BulletBody obj, CollisionFlags flags)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.AddToCollisionFlags2(bodyu.ptr, flags);
+}
+
+public override CollisionFlags RemoveFromCollisionFlags(BulletBody obj, CollisionFlags flags)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.RemoveFromCollisionFlags2(bodyu.ptr, flags);
+}
+
+public override float GetCcdMotionThreshold(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetCcdMotionThreshold2(bodyu.ptr);
+}
+
+
+public override void SetCcdMotionThreshold(BulletBody obj, float val)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetCcdMotionThreshold2(bodyu.ptr, val);
+}
+
+public override float GetCcdSweptSphereRadius(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetCcdSweptSphereRadius2(bodyu.ptr);
+}
+
+public override void SetCcdSweptSphereRadius(BulletBody obj, float val)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetCcdSweptSphereRadius2(bodyu.ptr, val);
+}
+
+public override IntPtr GetUserPointer(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetUserPointer2(bodyu.ptr);
+}
+
+public override void SetUserPointer(BulletBody obj, IntPtr val)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetUserPointer2(bodyu.ptr, val);
+}
+
+// =====================================================================================
+// btRigidBody entries
+public override void ApplyGravity(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ApplyGravity2(bodyu.ptr);
+}
+
+public override void SetGravity(BulletBody obj, Vector3 val)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetGravity2(bodyu.ptr, val);
+}
+
+public override Vector3 GetGravity(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetGravity2(bodyu.ptr);
+}
+
+public override void SetDamping(BulletBody obj, float lin_damping, float ang_damping)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetDamping2(bodyu.ptr, lin_damping, ang_damping);
+}
+
+public override void SetLinearDamping(BulletBody obj, float lin_damping)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetLinearDamping2(bodyu.ptr, lin_damping);
+}
+
+public override void SetAngularDamping(BulletBody obj, float ang_damping)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetAngularDamping2(bodyu.ptr, ang_damping);
+}
+
+public override float GetLinearDamping(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetLinearDamping2(bodyu.ptr);
+}
+
+public override float GetAngularDamping(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetAngularDamping2(bodyu.ptr);
+}
+
+public override float GetLinearSleepingThreshold(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetLinearSleepingThreshold2(bodyu.ptr);
+}
+
+public override void ApplyDamping(BulletBody obj, float timeStep)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ApplyDamping2(bodyu.ptr, timeStep);
+}
+
+public override void SetMassProps(BulletBody obj, float mass, Vector3 inertia)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetMassProps2(bodyu.ptr, mass, inertia);
+}
+
+public override Vector3 GetLinearFactor(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetLinearFactor2(bodyu.ptr);
+}
+
+public override void SetLinearFactor(BulletBody obj, Vector3 factor)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetLinearFactor2(bodyu.ptr, factor);
+}
+
+public override void SetCenterOfMassByPosRot(BulletBody obj, Vector3 pos, Quaternion rot)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetCenterOfMassByPosRot2(bodyu.ptr, pos, rot);
+}
+
+// Add a force to the object as if its mass is one.
+// Deep down in Bullet: m_totalForce += force*m_linearFactor;
+public override void ApplyCentralForce(BulletBody obj, Vector3 force)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ApplyCentralForce2(bodyu.ptr, force);
+}
+
+// Set the force being applied to the object as if its mass is one.
+public override void SetObjectForce(BulletBody obj, Vector3 force)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetObjectForce2(bodyu.ptr, force);
+}
+
+public override Vector3 GetTotalForce(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetTotalForce2(bodyu.ptr);
+}
+
+public override Vector3 GetTotalTorque(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetTotalTorque2(bodyu.ptr);
+}
+
+public override Vector3 GetInvInertiaDiagLocal(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetInvInertiaDiagLocal2(bodyu.ptr);
+}
+
+public override void SetInvInertiaDiagLocal(BulletBody obj, Vector3 inert)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetInvInertiaDiagLocal2(bodyu.ptr, inert);
+}
+
+public override void SetSleepingThresholds(BulletBody obj, float lin_threshold, float ang_threshold)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetSleepingThresholds2(bodyu.ptr, lin_threshold, ang_threshold);
+}
+
+// Deep down in Bullet: m_totalTorque += torque*m_angularFactor;
+public override void ApplyTorque(BulletBody obj, Vector3 torque)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ApplyTorque2(bodyu.ptr, torque);
+}
+
+// Apply force at the given point. Will add torque to the object.
+// Deep down in Bullet: applyCentralForce(force);
+//                              applyTorque(rel_pos.cross(force*m_linearFactor));
+public override void ApplyForce(BulletBody obj, Vector3 force, Vector3 pos)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ApplyForce2(bodyu.ptr, force, pos);
+}
+
+// Apply impulse to the object. Same as "ApplycentralForce" but force scaled by object's mass.
+// Deep down in Bullet: m_linearVelocity += impulse *m_linearFactor * m_inverseMass;
+public override void ApplyCentralImpulse(BulletBody obj, Vector3 imp)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ApplyCentralImpulse2(bodyu.ptr, imp);
+}
+
+// Apply impulse to the object's torque. Force is scaled by object's mass.
+// Deep down in Bullet: m_angularVelocity += m_invInertiaTensorWorld * torque * m_angularFactor;
+public override void ApplyTorqueImpulse(BulletBody obj, Vector3 imp)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ApplyTorqueImpulse2(bodyu.ptr, imp);
+}
+
+// Apply impulse at the point given. For is scaled by object's mass and effects both linear and angular forces.
+// Deep down in Bullet: applyCentralImpulse(impulse);
+//                              applyTorqueImpulse(rel_pos.cross(impulse*m_linearFactor));
+public override void ApplyImpulse(BulletBody obj, Vector3 imp, Vector3 pos)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ApplyImpulse2(bodyu.ptr, imp, pos);
+}
+
+public override void ClearForces(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ClearForces2(bodyu.ptr);
+}
+
+public override void ClearAllForces(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.ClearAllForces2(bodyu.ptr);
+}
+
+public override void UpdateInertiaTensor(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.UpdateInertiaTensor2(bodyu.ptr);
+}
+
+public override Vector3 GetLinearVelocity(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetLinearVelocity2(bodyu.ptr);
+}
+
+public override Vector3 GetAngularVelocity(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetAngularVelocity2(bodyu.ptr);
+}
+
+public override void SetLinearVelocity(BulletBody obj, Vector3 vel)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetLinearVelocity2(bodyu.ptr, vel);
+}
+
+public override void SetAngularVelocity(BulletBody obj, Vector3 angularVelocity)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetAngularVelocity2(bodyu.ptr, angularVelocity);
+}
+
+public override Vector3 GetVelocityInLocalPoint(BulletBody obj, Vector3 pos)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetVelocityInLocalPoint2(bodyu.ptr, pos);
+}
+
+public override void Translate(BulletBody obj, Vector3 trans)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.Translate2(bodyu.ptr, trans);
+}
+
+public override void UpdateDeactivation(BulletBody obj, float timeStep)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.UpdateDeactivation2(bodyu.ptr, timeStep);
+}
+
+public override bool WantsSleeping(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.WantsSleeping2(bodyu.ptr);
+}
+
+public override void SetAngularFactor(BulletBody obj, float factor)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetAngularFactor2(bodyu.ptr, factor);
+}
+
+public override void SetAngularFactorV(BulletBody obj, Vector3 factor)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BSAPICPP.SetAngularFactorV2(bodyu.ptr, factor);
+}
+
+public override Vector3 GetAngularFactor(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetAngularFactor2(bodyu.ptr);
+}
+
+public override bool IsInWorld(BulletWorld world, BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.IsInWorld2(bodyu.ptr);
+}
+
+public override void AddConstraintRef(BulletBody obj, BulletConstraint constrain)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    BSAPICPP.AddConstraintRef2(bodyu.ptr, constrainu.ptr);
+}
+
+public override void RemoveConstraintRef(BulletBody obj, BulletConstraint constrain)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    BSAPICPP.RemoveConstraintRef2(bodyu.ptr, constrainu.ptr);
+}
+
+public override BulletConstraint GetConstraintRef(BulletBody obj, int index)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return new BulletConstraintUnman(BSAPICPP.GetConstraintRef2(bodyu.ptr, index));
+}
+
+public override int GetNumConstraintRefs(BulletBody obj)
+{
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.GetNumConstraintRefs2(bodyu.ptr);
+}
+
+public override bool SetCollisionGroupMask(BulletBody body, uint filter, uint mask)
+{
+    BulletBodyUnman bodyu = body as BulletBodyUnman;
+    return BSAPICPP.SetCollisionGroupMask2(bodyu.ptr, filter, mask);
+}
+
+// =====================================================================================
+// btCollisionShape entries
+
+public override float GetAngularMotionDisc(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.GetAngularMotionDisc2(shapeu.ptr);
+}
+
+public override float GetContactBreakingThreshold(BulletShape shape, float defaultFactor)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.GetContactBreakingThreshold2(shapeu.ptr, defaultFactor);
+}
+
+public override bool IsPolyhedral(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.IsPolyhedral2(shapeu.ptr);
+}
+
+public override bool IsConvex2d(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.IsConvex2d2(shapeu.ptr);
+}
+
+public override bool IsConvex(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.IsConvex2(shapeu.ptr);
+}
+
+public override bool IsNonMoving(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.IsNonMoving2(shapeu.ptr);
+}
+
+public override bool IsConcave(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.IsConcave2(shapeu.ptr);
+}
+
+public override bool IsCompound(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.IsCompound2(shapeu.ptr);
+}
+
+public override bool IsSoftBody(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.IsSoftBody2(shapeu.ptr);
+}
+
+public override bool IsInfinite(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.IsInfinite2(shapeu.ptr);
+}
+
+public override void SetLocalScaling(BulletShape shape, Vector3 scale)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    BSAPICPP.SetLocalScaling2(shapeu.ptr, scale);
+}
+
+public override Vector3 GetLocalScaling(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.GetLocalScaling2(shapeu.ptr);
+}
+
+public override Vector3 CalculateLocalInertia(BulletShape shape, float mass)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.CalculateLocalInertia2(shapeu.ptr, mass);
+}
+
+public override int GetShapeType(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.GetShapeType2(shapeu.ptr);
+}
+
+public override void SetMargin(BulletShape shape, float val)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    BSAPICPP.SetMargin2(shapeu.ptr, val);
+}
+
+public override float GetMargin(BulletShape shape)
+{
+    BulletShapeUnman shapeu = shape as BulletShapeUnman;
+    return BSAPICPP.GetMargin2(shapeu.ptr);
+}
+
+// =====================================================================================
+// Debugging
+public override void DumpRigidBody(BulletWorld world, BulletBody collisionObject)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu = collisionObject as BulletBodyUnman;
+    BSAPICPP.DumpRigidBody2(worldu.ptr, bodyu.ptr);
+}
+
+public override void DumpCollisionShape(BulletWorld world, BulletShape collisionShape)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletShapeUnman shapeu = collisionShape as BulletShapeUnman;
+    BSAPICPP.DumpCollisionShape2(worldu.ptr, shapeu.ptr);
+}
+
+public override void DumpConstraint(BulletWorld world, BulletConstraint constrain)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    BSAPICPP.DumpConstraint2(worldu.ptr, constrainu.ptr);
+}
+
+public override void DumpActivationInfo(BulletWorld world)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BSAPICPP.DumpActivationInfo2(worldu.ptr);
+}
+
+public override void DumpAllInfo(BulletWorld world)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BSAPICPP.DumpAllInfo2(worldu.ptr);
+}
+
+public override void DumpPhysicsStatistics(BulletWorld world)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BSAPICPP.DumpPhysicsStatistics2(worldu.ptr);
+}
+public override void ResetBroadphasePool(BulletWorld world)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BSAPICPP.ResetBroadphasePool(worldu.ptr);
+}
+public override void ResetConstraintSolver(BulletWorld world)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BSAPICPP.ResetConstraintSolver(worldu.ptr);
+}
+
+// =====================================================================================
+// =====================================================================================
+// =====================================================================================
+// =====================================================================================
+// =====================================================================================
+// The actual interface to the unmanaged code
+static class BSAPICPP
+{
+// ===============================================================================
+// Link back to the managed code for outputting log messages
+[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+public delegate void DebugLogCallback([MarshalAs(UnmanagedType.LPStr)]string msg);
+
+// ===============================================================================
+// Initialization and simulation
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms,
+                                                                                        int maxCollisions,  IntPtr collisionArray,
+                                                                                        int maxUpdates, IntPtr updateArray,
+                                            DebugLogCallback logRoutine);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSteps, float fixedTimeStep,
+                        out int updatedEntityCount, out int collidersCount);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void Shutdown2(IntPtr sim);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool PushUpdate2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool UpdateParameter2(IntPtr world, uint localID, String parm, float value);
+
+// =====================================================================================
+// Mesh, hull, shape and body creation helper routines
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateMeshShape2(IntPtr world,
+                int indicesCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices,
+                int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices );
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateGImpactShape2(IntPtr world,
+                int indicesCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices,
+                int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices );
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateHullShape2(IntPtr world,
+                int hullCount, [MarshalAs(UnmanagedType.LPArray)] float[] hulls);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr BuildHullShapeFromMesh2(IntPtr world, IntPtr meshShape, HACDParams parms);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr BuildConvexHullShapeFromMesh2(IntPtr world, IntPtr meshShape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateConvexHullShape2(IntPtr world,
+                int indicesCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices,
+                int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices );
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr BuildNativeShape2(IntPtr world, ShapeData shapeData);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsNativeShape2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetShapeCollisionMargin(IntPtr shape, float margin);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr BuildCapsuleShape2(IntPtr world, float radius, float height, Vector3 scale);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateCompoundShape2(IntPtr sim, bool enableDynamicAabbTree);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern int GetNumberOfCompoundChildren2(IntPtr cShape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void AddChildShapeToCompoundShape2(IntPtr cShape, IntPtr addShape, Vector3 pos, Quaternion rot);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr GetChildShapeFromCompoundShapeIndex2(IntPtr cShape, int indx);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr RemoveChildShapeFromCompoundShapeIndex2(IntPtr cShape, int indx);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void RemoveChildShapeFromCompoundShape2(IntPtr cShape, IntPtr removeShape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void UpdateChildTransform2(IntPtr pShape, int childIndex, Vector3 pos, Quaternion rot, bool shouldRecalculateLocalAabb);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void RecalculateCompoundShapeLocalAabb2(IntPtr cShape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr DuplicateCollisionShape2(IntPtr sim, IntPtr srcShape, uint id);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool DeleteCollisionShape2(IntPtr world, IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern int GetBodyType2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateBodyFromShape2(IntPtr sim, IntPtr shape, uint id, Vector3 pos, Quaternion rot);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateBodyWithDefaultMotionState2(IntPtr shape, uint id, Vector3 pos, Quaternion rot);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateGhostFromShape2(IntPtr sim, IntPtr shape, uint id, Vector3 pos, Quaternion rot);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void DestroyObject2(IntPtr sim, IntPtr obj);
+
+// =====================================================================================
+// Terrain creation and helper routines
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateGroundPlaneShape2(uint id, float height, float collisionMargin);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateTerrainShape2(uint id, Vector3 size, float minHeight, float maxHeight,
+                                            [MarshalAs(UnmanagedType.LPArray)] float[] heightMap,
+                                            float scaleFactor, float collisionMargin);
+
+// =====================================================================================
+// Constraint creation and helper routines
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr Create6DofConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2,
+                    Vector3 frame1loc, Quaternion frame1rot,
+                    Vector3 frame2loc, Quaternion frame2rot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr Create6DofConstraintToPoint2(IntPtr world, IntPtr obj1, IntPtr obj2,
+                    Vector3 joinPoint,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr Create6DofConstraintFixed2(IntPtr world, IntPtr obj1,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool useLinearReferenceFrameB, bool disableCollisionsBetweenLinkedBodies);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr Create6DofSpringConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2,
+                    Vector3 frame1loc, Quaternion frame1rot,
+                    Vector3 frame2loc, Quaternion frame2rot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateHingeConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2,
+                    Vector3 pivotinA, Vector3 pivotinB,
+                    Vector3 axisInA, Vector3 axisInB,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateSliderConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2,
+                    Vector3 frameInAloc, Quaternion frameInArot,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateConeTwistConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2,
+                    Vector3 frameInAloc, Quaternion frameInArot,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool disableCollisionsBetweenLinkedBodies);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateGearConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2,
+                    Vector3 axisInA, Vector3 axisInB,
+                    float ratio, bool disableCollisionsBetweenLinkedBodies);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreatePoint2PointConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2,
+                    Vector3 pivotInA, Vector3 pivotInB,
+                    bool disableCollisionsBetweenLinkedBodies);
+
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetConstraintEnable2(IntPtr constrain, float numericTrueFalse);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetConstraintNumSolverIterations2(IntPtr constrain, float iterations);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SetFrames2(IntPtr constrain,
+                Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SetLinearLimits2(IntPtr constrain, Vector3 low, Vector3 hi);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SetAngularLimits2(IntPtr constrain, Vector3 low, Vector3 hi);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool UseFrameOffset2(IntPtr constrain, float enable);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool TranslationalLimitMotor2(IntPtr constrain, float enable, float targetVel, float maxMotorForce);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SetBreakingImpulseThreshold2(IntPtr constrain, float threshold);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool HingeSetLimits2(IntPtr constrain, float low, float high, float softness, float bias, float relaxation);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool ConstraintSpringEnable2(IntPtr constrain, int index, float numericTrueFalse);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool ConstraintSpringSetEquilibriumPoint2(IntPtr constrain, int index, float equilibriumPoint);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool ConstraintSpringSetStiffness2(IntPtr constrain, int index, float stiffness);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool ConstraintSpringSetDamping2(IntPtr constrain, int index, float damping);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SliderSetLimits2(IntPtr constrain, int lowerUpper, int linAng, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SliderSet2(IntPtr constrain, int softRestDamp, int dirLimOrtho, int linAng, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SliderMotorEnable2(IntPtr constrain, int linAng, float numericTrueFalse);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SliderMotor2(IntPtr constrain, int forceVel, int linAng, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool CalculateTransforms2(IntPtr constrain);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SetConstraintParam2(IntPtr constrain, ConstraintParams paramIndex, float value, ConstraintParamAxis axis);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool DestroyConstraint2(IntPtr world, IntPtr constrain);
+
+// =====================================================================================
+// btCollisionWorld entries
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void UpdateSingleAabb2(IntPtr world, IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void UpdateAabbs2(IntPtr world);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool GetForceUpdateAllAabbs2(IntPtr world);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetForceUpdateAllAabbs2(IntPtr world, bool force);
+
+// =====================================================================================
+// btDynamicsWorld entries
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool AddObjectToWorld2(IntPtr world, IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool RemoveObjectFromWorld2(IntPtr world, IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool ClearCollisionProxyCache2(IntPtr world, IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool AddConstraintToWorld2(IntPtr world, IntPtr constrain, bool disableCollisionsBetweenLinkedObjects);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool RemoveConstraintFromWorld2(IntPtr world, IntPtr constrain);
+// =====================================================================================
+// btCollisionObject entries
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetAnisotripicFriction2(IntPtr constrain);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 SetAnisotripicFriction2(IntPtr constrain, Vector3 frict);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool HasAnisotripicFriction2(IntPtr constrain);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetContactProcessingThreshold2(IntPtr obj, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetContactProcessingThreshold2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsStaticObject2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsKinematicObject2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsStaticOrKinematicObject2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool HasContactResponse2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetCollisionShape2(IntPtr sim, IntPtr obj, IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr GetCollisionShape2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern int GetActivationState2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetActivationState2(IntPtr obj, int state);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetDeactivationTime2(IntPtr obj, float dtime);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetDeactivationTime2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ForceActivationState2(IntPtr obj, ActivationState state);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void Activate2(IntPtr obj, bool forceActivation);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsActive2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetRestitution2(IntPtr obj, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetRestitution2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetFriction2(IntPtr obj, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetFriction2(IntPtr obj);
+
+    /* Haven't defined the type 'Transform'
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Transform GetWorldTransform2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void setWorldTransform2(IntPtr obj, Transform trans);
+     */
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetPosition2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Quaternion GetOrientation2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetTranslation2(IntPtr obj, Vector3 position, Quaternion rotation);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr GetBroadphaseHandle2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetBroadphaseHandle2(IntPtr obj, IntPtr handle);
+
+    /*
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Transform GetInterpolationWorldTransform2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetInterpolationWorldTransform2(IntPtr obj, Transform trans);
+     */
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetInterpolationLinearVelocity2(IntPtr obj, Vector3 vel);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetInterpolationAngularVelocity2(IntPtr obj, Vector3 vel);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetInterpolationVelocity2(IntPtr obj, Vector3 linearVel, Vector3 angularVel);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetHitFraction2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetHitFraction2(IntPtr obj, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern CollisionFlags GetCollisionFlags2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern CollisionFlags SetCollisionFlags2(IntPtr obj, CollisionFlags flags);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern CollisionFlags AddToCollisionFlags2(IntPtr obj, CollisionFlags flags);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern CollisionFlags RemoveFromCollisionFlags2(IntPtr obj, CollisionFlags flags);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetCcdMotionThreshold2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetCcdMotionThreshold2(IntPtr obj, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetCcdSweptSphereRadius2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetCcdSweptSphereRadius2(IntPtr obj, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr GetUserPointer2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetUserPointer2(IntPtr obj, IntPtr val);
+
+// =====================================================================================
+// btRigidBody entries
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyGravity2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetGravity2(IntPtr obj, Vector3 val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetGravity2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetDamping2(IntPtr obj, float lin_damping, float ang_damping);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetLinearDamping2(IntPtr obj, float lin_damping);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetAngularDamping2(IntPtr obj, float ang_damping);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetLinearDamping2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetAngularDamping2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetLinearSleepingThreshold2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetAngularSleepingThreshold2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyDamping2(IntPtr obj, float timeStep);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetMassProps2(IntPtr obj, float mass, Vector3 inertia);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetLinearFactor2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetLinearFactor2(IntPtr obj, Vector3 factor);
+
+    /*
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetCenterOfMassTransform2(IntPtr obj, Transform trans);
+     */
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetCenterOfMassByPosRot2(IntPtr obj, Vector3 pos, Quaternion rot);
+
+// Add a force to the object as if its mass is one.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyCentralForce2(IntPtr obj, Vector3 force);
+
+// Set the force being applied to the object as if its mass is one.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetObjectForce2(IntPtr obj, Vector3 force);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetTotalForce2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetTotalTorque2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetInvInertiaDiagLocal2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetInvInertiaDiagLocal2(IntPtr obj, Vector3 inert);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetSleepingThresholds2(IntPtr obj, float lin_threshold, float ang_threshold);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyTorque2(IntPtr obj, Vector3 torque);
+
+// Apply force at the given point. Will add torque to the object.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyForce2(IntPtr obj, Vector3 force, Vector3 pos);
+
+// Apply impulse to the object. Same as "ApplycentralForce" but force scaled by object's mass.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyCentralImpulse2(IntPtr obj, Vector3 imp);
+
+// Apply impulse to the object's torque. Force is scaled by object's mass.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyTorqueImpulse2(IntPtr obj, Vector3 imp);
+
+// Apply impulse at the point given. For is scaled by object's mass and effects both linear and angular forces.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyImpulse2(IntPtr obj, Vector3 imp, Vector3 pos);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ClearForces2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ClearAllForces2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void UpdateInertiaTensor2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetCenterOfMassPosition2(IntPtr obj);
+
+    /*
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Transform GetCenterOfMassTransform2(IntPtr obj);
+     */
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetLinearVelocity2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetAngularVelocity2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetLinearVelocity2(IntPtr obj, Vector3 val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetAngularVelocity2(IntPtr obj, Vector3 angularVelocity);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetVelocityInLocalPoint2(IntPtr obj, Vector3 pos);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void Translate2(IntPtr obj, Vector3 trans);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void UpdateDeactivation2(IntPtr obj, float timeStep);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool WantsSleeping2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetAngularFactor2(IntPtr obj, float factor);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetAngularFactorV2(IntPtr obj, Vector3 factor);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetAngularFactor2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsInWorld2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void AddConstraintRef2(IntPtr obj, IntPtr constrain);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void RemoveConstraintRef2(IntPtr obj, IntPtr constrain);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr GetConstraintRef2(IntPtr obj, int index);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern int GetNumConstraintRefs2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SetCollisionGroupMask2(IntPtr body, uint filter, uint mask);
+
+// =====================================================================================
+// btCollisionShape entries
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetAngularMotionDisc2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetContactBreakingThreshold2(IntPtr shape, float defaultFactor);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsPolyhedral2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsConvex2d2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsConvex2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsNonMoving2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsConcave2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsCompound2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsSoftBody2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsInfinite2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetLocalScaling2(IntPtr shape, Vector3 scale);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetLocalScaling2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 CalculateLocalInertia2(IntPtr shape, float mass);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern int GetShapeType2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetMargin2(IntPtr shape, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetMargin2(IntPtr shape);
+
+// =====================================================================================
+// Debugging
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void DumpRigidBody2(IntPtr sim, IntPtr collisionObject);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void DumpCollisionShape2(IntPtr sim, IntPtr collisionShape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void DumpMapInfo2(IntPtr sim, IntPtr manInfo);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void DumpConstraint2(IntPtr sim, IntPtr constrain);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void DumpActivationInfo2(IntPtr sim);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void DumpAllInfo2(IntPtr sim);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void DumpPhysicsStatistics2(IntPtr sim);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ResetBroadphasePool(IntPtr sim);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ResetConstraintSolver(IntPtr sim);
+
+}
+
+}
+
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs b/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs
new file mode 100755
index 0000000..887311d
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs
@@ -0,0 +1,2589 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+using OpenSim.Framework;
+
+using OpenMetaverse;
+
+using BulletXNA;
+using BulletXNA.LinearMath;
+using BulletXNA.BulletCollision;
+using BulletXNA.BulletDynamics;
+using BulletXNA.BulletCollision.CollisionDispatch;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public sealed class BSAPIXNA : BSAPITemplate
+{
+private sealed class BulletWorldXNA : BulletWorld
+{
+    public DiscreteDynamicsWorld world;
+    public BulletWorldXNA(uint id, BSScene physScene, DiscreteDynamicsWorld xx)
+        : base(id, physScene)
+    {
+        world = xx;
+    }
+}
+
+private sealed class BulletBodyXNA : BulletBody
+{
+    public CollisionObject body;
+    public RigidBody rigidBody { get { return RigidBody.Upcast(body); } }
+
+    public BulletBodyXNA(uint id, CollisionObject xx)
+        : base(id)
+    {
+        body = xx;
+    }
+    public override bool HasPhysicalBody
+    {
+        get { return body != null; }
+    }
+    public override void Clear()
+    {
+        body = null;
+    }
+    public override string AddrString
+    {
+        get { return "XNARigidBody"; }
+    }
+}
+
+private sealed class BulletShapeXNA : BulletShape
+{
+    public CollisionShape shape;
+    public BulletShapeXNA(CollisionShape xx, BSPhysicsShapeType typ)
+        : base()
+    {
+        shape = xx;
+        shapeType = typ;
+    }
+    public override bool HasPhysicalShape
+    {
+        get { return shape != null; }
+    }
+    public override void Clear()
+    {
+        shape = null;
+    }
+    public override BulletShape Clone()
+    {
+        return new BulletShapeXNA(shape, shapeType);
+    }
+    public override bool ReferenceSame(BulletShape other)
+    {
+        BulletShapeXNA otheru = other as BulletShapeXNA;
+        return (otheru != null) && (this.shape == otheru.shape);
+
+    }
+    public override string AddrString
+    {
+        get { return "XNACollisionShape"; }
+    }
+}
+private sealed class BulletConstraintXNA : BulletConstraint
+{
+    public TypedConstraint constrain;
+    public BulletConstraintXNA(TypedConstraint xx) : base()
+    {
+        constrain = xx;
+    }
+
+    public override void Clear()
+    {
+        constrain = null;
+    }
+    public override bool HasPhysicalConstraint { get { return constrain != null; } }
+
+    // Used for log messages for a unique display of the memory/object allocated to this instance
+    public override string AddrString
+    {
+        get { return "XNAConstraint"; }
+    }
+}
+    internal int m_maxCollisions;
+    internal CollisionDesc[] UpdatedCollisions;
+    internal int LastCollisionDesc = 0;
+    internal int m_maxUpdatesPerFrame;
+    internal int LastEntityProperty = 0;
+
+    internal EntityProperties[] UpdatedObjects;
+    internal Dictionary<uint, GhostObject> specialCollisionObjects;
+
+    private static int m_collisionsThisFrame;
+    private BSScene PhysicsScene { get; set; }
+
+    public override string BulletEngineName { get { return "BulletXNA"; } }
+    public override string BulletEngineVersion { get; protected set; }
+
+    public BSAPIXNA(string paramName, BSScene physScene)
+    {
+        PhysicsScene = physScene;
+    }
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="p"></param>
+    /// <param name="p_2"></param>
+    public override bool RemoveObjectFromWorld(BulletWorld pWorld, BulletBody pBody)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody body = ((BulletBodyXNA)pBody).rigidBody;
+        CollisionObject collisionObject = ((BulletBodyXNA)pBody).body;
+        if (body != null)
+            world.RemoveRigidBody(body);
+        else if (collisionObject != null)
+            world.RemoveCollisionObject(collisionObject);
+        else
+            return false;
+        return true;
+    }
+
+    public override bool ClearCollisionProxyCache(BulletWorld pWorld, BulletBody pBody)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody body = ((BulletBodyXNA)pBody).rigidBody;
+        CollisionObject collisionObject = ((BulletBodyXNA)pBody).body;
+        if (body != null && collisionObject != null && collisionObject.GetBroadphaseHandle() != null)
+        {
+            world.RemoveCollisionObject(collisionObject);
+            world.AddCollisionObject(collisionObject);
+        }
+        return true;
+    }
+
+    public override bool AddConstraintToWorld(BulletWorld pWorld, BulletConstraint pConstraint, bool pDisableCollisionsBetweenLinkedObjects)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        TypedConstraint constraint = (pConstraint as BulletConstraintXNA).constrain;
+        world.AddConstraint(constraint, pDisableCollisionsBetweenLinkedObjects);
+
+        return true;
+
+    }
+
+    public override bool RemoveConstraintFromWorld(BulletWorld pWorld, BulletConstraint pConstraint)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        TypedConstraint constraint = (pConstraint as BulletConstraintXNA).constrain;
+        world.RemoveConstraint(constraint);
+        return true;
+    }
+
+    public override void SetRestitution(BulletBody pCollisionObject, float pRestitution)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        collisionObject.SetRestitution(pRestitution);
+    }
+
+    public override int GetShapeType(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return (int)shape.GetShapeType();
+    }
+    public override void SetMargin(BulletShape pShape, float pMargin)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        shape.SetMargin(pMargin);
+    }
+
+    public override float GetMargin(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.GetMargin();
+    }
+
+    public override void SetLocalScaling(BulletShape pShape, Vector3 pScale)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        IndexedVector3 vec = new IndexedVector3(pScale.X, pScale.Y, pScale.Z);
+        shape.SetLocalScaling(ref vec);
+
+    }
+
+    public override void SetContactProcessingThreshold(BulletBody pCollisionObject, float contactprocessingthreshold)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        collisionObject.SetContactProcessingThreshold(contactprocessingthreshold);
+    }
+
+    public override void SetCcdMotionThreshold(BulletBody pCollisionObject, float pccdMotionThreashold)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        collisionObject.SetCcdMotionThreshold(pccdMotionThreashold);
+    }
+
+    public override void SetCcdSweptSphereRadius(BulletBody pCollisionObject, float pCcdSweptSphereRadius)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        collisionObject.SetCcdSweptSphereRadius(pCcdSweptSphereRadius);
+    }
+
+    public override void SetAngularFactorV(BulletBody pBody, Vector3 pAngularFactor)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        body.SetAngularFactor(new IndexedVector3(pAngularFactor.X, pAngularFactor.Y, pAngularFactor.Z));
+    }
+
+    public override CollisionFlags AddToCollisionFlags(BulletBody pCollisionObject, CollisionFlags pcollisionFlags)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        CollisionFlags existingcollisionFlags = (CollisionFlags)(uint)collisionObject.GetCollisionFlags();
+        existingcollisionFlags |= pcollisionFlags;
+        collisionObject.SetCollisionFlags((BulletXNA.BulletCollision.CollisionFlags)(uint)existingcollisionFlags);
+        return (CollisionFlags) (uint) existingcollisionFlags;
+    }
+
+    public override bool AddObjectToWorld(BulletWorld pWorld, BulletBody pBody)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        CollisionObject cbody = (pBody as BulletBodyXNA).body;
+        RigidBody rbody = cbody as RigidBody;
+
+        // Bullet resets several variables when an object is added to the world. In particular,
+        //   BulletXNA resets position and rotation. Gravity is also reset depending on the static/dynamic
+        //   type. Of course, the collision flags in the broadphase proxy are initialized to default.
+        IndexedMatrix origPos = cbody.GetWorldTransform();
+        if (rbody != null)
+        {
+            IndexedVector3 origGrav = rbody.GetGravity();
+            world.AddRigidBody(rbody);
+            rbody.SetGravity(origGrav);
+        }
+        else
+        {
+            world.AddCollisionObject(cbody);
+        }
+        cbody.SetWorldTransform(origPos);
+
+        pBody.ApplyCollisionMask(pWorld.physicsScene);
+
+        //if (body.GetBroadphaseHandle() != null)
+        //    world.UpdateSingleAabb(body);
+        return true;
+    }
+
+    public override void ForceActivationState(BulletBody pCollisionObject, ActivationState pActivationState)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        collisionObject.ForceActivationState((BulletXNA.BulletCollision.ActivationState)(uint)pActivationState);
+    }
+
+    public override void UpdateSingleAabb(BulletWorld pWorld, BulletBody pCollisionObject)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        world.UpdateSingleAabb(collisionObject);
+    }
+
+    public override void UpdateAabbs(BulletWorld pWorld) {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        world.UpdateAabbs();
+    }
+    public override bool GetForceUpdateAllAabbs(BulletWorld pWorld) {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        return world.GetForceUpdateAllAabbs();
+
+    }
+    public override void SetForceUpdateAllAabbs(BulletWorld pWorld, bool pForce)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        world.SetForceUpdateAllAabbs(pForce);
+    }
+
+    public override bool SetCollisionGroupMask(BulletBody pCollisionObject, uint pGroup, uint pMask)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        collisionObject.GetBroadphaseHandle().m_collisionFilterGroup = (BulletXNA.BulletCollision.CollisionFilterGroups) pGroup;
+        collisionObject.GetBroadphaseHandle().m_collisionFilterGroup = (BulletXNA.BulletCollision.CollisionFilterGroups) pGroup;
+        if ((uint) collisionObject.GetBroadphaseHandle().m_collisionFilterGroup == 0)
+            return false;
+        return true;
+    }
+
+    public override void ClearAllForces(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        IndexedVector3 zeroVector = new IndexedVector3(0, 0, 0);
+        collisionObject.SetInterpolationLinearVelocity(ref zeroVector);
+        collisionObject.SetInterpolationAngularVelocity(ref zeroVector);
+        IndexedMatrix bodytransform = collisionObject.GetWorldTransform();
+
+        collisionObject.SetInterpolationWorldTransform(ref bodytransform);
+
+        if (collisionObject is RigidBody)
+        {
+            RigidBody rigidbody = collisionObject as RigidBody;
+            rigidbody.SetLinearVelocity(zeroVector);
+            rigidbody.SetAngularVelocity(zeroVector);
+            rigidbody.ClearForces();
+        }
+    }
+
+    public override void SetInterpolationAngularVelocity(BulletBody pCollisionObject, Vector3 pVector3)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        IndexedVector3 vec = new IndexedVector3(pVector3.X, pVector3.Y, pVector3.Z);
+        collisionObject.SetInterpolationAngularVelocity(ref vec);
+    }
+
+    public override void SetAngularVelocity(BulletBody pBody, Vector3 pVector3)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 vec = new IndexedVector3(pVector3.X, pVector3.Y, pVector3.Z);
+        body.SetAngularVelocity(ref vec);
+    }
+    public override Vector3 GetTotalForce(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 iv3 = body.GetTotalForce();
+        return new Vector3(iv3.X, iv3.Y, iv3.Z);
+    }
+    public override Vector3 GetTotalTorque(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 iv3 = body.GetTotalTorque();
+        return new Vector3(iv3.X, iv3.Y, iv3.Z);
+    }
+    public override Vector3 GetInvInertiaDiagLocal(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 iv3 = body.GetInvInertiaDiagLocal();
+        return new Vector3(iv3.X, iv3.Y, iv3.Z);
+    }
+    public override void SetInvInertiaDiagLocal(BulletBody pBody, Vector3 inert)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 iv3 = new IndexedVector3(inert.X, inert.Y, inert.Z);
+        body.SetInvInertiaDiagLocal(ref iv3);
+    }
+    public override void ApplyForce(BulletBody pBody, Vector3 force, Vector3 pos)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 forceiv3 = new IndexedVector3(force.X, force.Y, force.Z);
+        IndexedVector3 posiv3 = new IndexedVector3(pos.X, pos.Y, pos.Z);
+        body.ApplyForce(ref forceiv3, ref posiv3);
+    }
+    public override void ApplyImpulse(BulletBody pBody, Vector3 imp, Vector3 pos)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 impiv3 = new IndexedVector3(imp.X, imp.Y, imp.Z);
+        IndexedVector3 posiv3 = new IndexedVector3(pos.X, pos.Y, pos.Z);
+        body.ApplyImpulse(ref impiv3, ref posiv3);
+    }
+
+    public override void ClearForces(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        body.ClearForces();
+    }
+
+    public override void SetTranslation(BulletBody pCollisionObject, Vector3 _position, Quaternion _orientation)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        IndexedVector3 vposition = new IndexedVector3(_position.X, _position.Y, _position.Z);
+        IndexedQuaternion vquaternion = new IndexedQuaternion(_orientation.X, _orientation.Y, _orientation.Z,
+                                                              _orientation.W);
+        IndexedMatrix mat = IndexedMatrix.CreateFromQuaternion(vquaternion);
+        mat._origin = vposition;
+        collisionObject.SetWorldTransform(mat);
+
+    }
+
+    public override Vector3 GetPosition(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        IndexedVector3 pos = collisionObject.GetInterpolationWorldTransform()._origin;
+        return new Vector3(pos.X, pos.Y, pos.Z);
+    }
+
+    public override Vector3 CalculateLocalInertia(BulletShape pShape, float pphysMass)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        IndexedVector3 inertia = IndexedVector3.Zero;
+        shape.CalculateLocalInertia(pphysMass, out inertia);
+        return new Vector3(inertia.X, inertia.Y, inertia.Z);
+    }
+
+    public override void SetMassProps(BulletBody pBody, float pphysMass, Vector3 plocalInertia)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        if (body != null) // Can't set mass props on collision object.
+        {
+            IndexedVector3 inertia = new IndexedVector3(plocalInertia.X, plocalInertia.Y, plocalInertia.Z);
+            body.SetMassProps(pphysMass, inertia);
+        }
+    }
+
+
+    public override void SetObjectForce(BulletBody pBody, Vector3 _force)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 force = new IndexedVector3(_force.X, _force.Y, _force.Z);
+        body.SetTotalForce(ref force);
+    }
+
+    public override void SetFriction(BulletBody pCollisionObject, float _currentFriction)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        collisionObject.SetFriction(_currentFriction);
+    }
+
+    public override void SetLinearVelocity(BulletBody pBody, Vector3 _velocity)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 velocity = new IndexedVector3(_velocity.X, _velocity.Y, _velocity.Z);
+        body.SetLinearVelocity(velocity);
+    }
+
+    public override void Activate(BulletBody pCollisionObject, bool pforceactivation)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        collisionObject.Activate(pforceactivation);
+
+    }
+
+    public override Quaternion GetOrientation(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        IndexedQuaternion mat = collisionObject.GetInterpolationWorldTransform().GetRotation();
+        return new Quaternion(mat.X, mat.Y, mat.Z, mat.W);
+    }
+
+    public override CollisionFlags RemoveFromCollisionFlags(BulletBody pCollisionObject, CollisionFlags pcollisionFlags)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        CollisionFlags existingcollisionFlags = (CollisionFlags)(uint)collisionObject.GetCollisionFlags();
+        existingcollisionFlags &= ~pcollisionFlags;
+        collisionObject.SetCollisionFlags((BulletXNA.BulletCollision.CollisionFlags)(uint)existingcollisionFlags);
+        return (CollisionFlags)(uint)existingcollisionFlags;
+    }
+
+    public override float GetCcdMotionThreshold(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        return collisionObject.GetCcdSquareMotionThreshold();
+    }
+
+    public override float GetCcdSweptSphereRadius(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        return collisionObject.GetCcdSweptSphereRadius();
+
+    }
+
+    public override IntPtr GetUserPointer(BulletBody pCollisionObject)
+    {
+        CollisionObject shape = (pCollisionObject as BulletBodyXNA).body;
+        return (IntPtr)shape.GetUserPointer();
+    }
+
+    public override void SetUserPointer(BulletBody pCollisionObject, IntPtr val)
+    {
+        CollisionObject shape = (pCollisionObject as BulletBodyXNA).body;
+        shape.SetUserPointer(val);
+    }
+
+    public override void SetGravity(BulletBody pBody, Vector3 pGravity)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        if (body != null) // Can't set collisionobject.set gravity
+        {
+            IndexedVector3 gravity = new IndexedVector3(pGravity.X, pGravity.Y, pGravity.Z);
+            body.SetGravity(gravity);
+        }
+    }
+
+    public override bool DestroyConstraint(BulletWorld pWorld, BulletConstraint pConstraint)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        TypedConstraint constraint = (pConstraint as BulletConstraintXNA).constrain;
+        world.RemoveConstraint(constraint);
+        return true;
+    }
+
+    public override bool SetLinearLimits(BulletConstraint pConstraint, Vector3 low, Vector3 high)
+    {
+        Generic6DofConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofConstraint;
+        IndexedVector3 lowlimit = new IndexedVector3(low.X, low.Y, low.Z);
+        IndexedVector3 highlimit = new IndexedVector3(high.X, high.Y, high.Z);
+        constraint.SetLinearLowerLimit(lowlimit);
+        constraint.SetLinearUpperLimit(highlimit);
+        return true;
+    }
+
+    public override bool SetAngularLimits(BulletConstraint pConstraint, Vector3 low, Vector3 high)
+    {
+        Generic6DofConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofConstraint;
+        IndexedVector3 lowlimit = new IndexedVector3(low.X, low.Y, low.Z);
+        IndexedVector3 highlimit = new IndexedVector3(high.X, high.Y, high.Z);
+        constraint.SetAngularLowerLimit(lowlimit);
+        constraint.SetAngularUpperLimit(highlimit);
+        return true;
+    }
+
+    public override void SetConstraintNumSolverIterations(BulletConstraint pConstraint, float cnt)
+    {
+        Generic6DofConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofConstraint;
+        constraint.SetOverrideNumSolverIterations((int)cnt);
+    }
+
+    public override bool CalculateTransforms(BulletConstraint pConstraint)
+    {
+        Generic6DofConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofConstraint;
+        constraint.CalculateTransforms();
+        return true;
+    }
+
+    public override void SetConstraintEnable(BulletConstraint pConstraint, float p_2)
+    {
+        Generic6DofConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofConstraint;
+        constraint.SetEnabled((p_2 == 0) ? false : true);
+    }
+
+
+    public override BulletConstraint Create6DofConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
+                                    Vector3 pframe1, Quaternion pframe1rot, Vector3 pframe2, Quaternion pframe2rot,
+                                    bool puseLinearReferenceFrameA, bool pdisableCollisionsBetweenLinkedBodies)
+
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody body1 = (pBody1 as BulletBodyXNA).rigidBody;
+        RigidBody body2 = (pBody2 as BulletBodyXNA).rigidBody;
+        IndexedVector3 frame1v = new IndexedVector3(pframe1.X, pframe1.Y, pframe1.Z);
+        IndexedQuaternion frame1rot = new IndexedQuaternion(pframe1rot.X, pframe1rot.Y, pframe1rot.Z, pframe1rot.W);
+        IndexedMatrix frame1 = IndexedMatrix.CreateFromQuaternion(frame1rot);
+        frame1._origin = frame1v;
+
+        IndexedVector3 frame2v = new IndexedVector3(pframe2.X, pframe2.Y, pframe2.Z);
+        IndexedQuaternion frame2rot = new IndexedQuaternion(pframe2rot.X, pframe2rot.Y, pframe2rot.Z, pframe2rot.W);
+        IndexedMatrix frame2 = IndexedMatrix.CreateFromQuaternion(frame2rot);
+        frame2._origin = frame1v;
+
+        Generic6DofConstraint consttr = new Generic6DofConstraint(body1, body2, ref frame1, ref frame2,
+                                                                  puseLinearReferenceFrameA);
+        consttr.CalculateTransforms();
+        world.AddConstraint(consttr,pdisableCollisionsBetweenLinkedBodies);
+
+        return new BulletConstraintXNA(consttr);
+    }
+
+    public override BulletConstraint Create6DofConstraintFixed(BulletWorld pWorld, BulletBody pBody1,
+                                        Vector3 pframe1, Quaternion pframe1rot,
+                                        bool pUseLinearReferenceFrameB, bool pdisableCollisionsBetweenLinkedBodies)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody body1 = (pBody1 as BulletBodyXNA).rigidBody;
+        IndexedVector3 frame1v = new IndexedVector3(pframe1.X, pframe1.Y, pframe1.Z);
+        IndexedQuaternion frame1rot = new IndexedQuaternion(pframe1rot.X, pframe1rot.Y, pframe1rot.Z, pframe1rot.W);
+        IndexedMatrix frame1 = IndexedMatrix.CreateFromQuaternion(frame1rot);
+        frame1._origin = frame1v;
+
+        Generic6DofConstraint consttr = new Generic6DofConstraint(body1, ref frame1, pUseLinearReferenceFrameB);
+        consttr.CalculateTransforms();
+        world.AddConstraint(consttr,pdisableCollisionsBetweenLinkedBodies);
+
+        return new BulletConstraintXNA(consttr);
+    }
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="pWorld"></param>
+    /// <param name="pBody1"></param>
+    /// <param name="pBody2"></param>
+    /// <param name="pjoinPoint"></param>
+    /// <param name="puseLinearReferenceFrameA"></param>
+    /// <param name="pdisableCollisionsBetweenLinkedBodies"></param>
+    /// <returns></returns>
+    public override BulletConstraint Create6DofConstraintToPoint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2, Vector3 pjoinPoint, bool puseLinearReferenceFrameA, bool pdisableCollisionsBetweenLinkedBodies)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody body1 = (pBody1 as BulletBodyXNA).rigidBody;
+        RigidBody body2 = (pBody2 as BulletBodyXNA).rigidBody;
+        IndexedMatrix frame1 = new IndexedMatrix(IndexedBasisMatrix.Identity, new IndexedVector3(0, 0, 0));
+        IndexedMatrix frame2 = new IndexedMatrix(IndexedBasisMatrix.Identity, new IndexedVector3(0, 0, 0));
+
+        IndexedVector3 joinPoint = new IndexedVector3(pjoinPoint.X, pjoinPoint.Y, pjoinPoint.Z);
+        IndexedMatrix mat = IndexedMatrix.Identity;
+        mat._origin = new IndexedVector3(pjoinPoint.X, pjoinPoint.Y, pjoinPoint.Z);
+        frame1._origin = body1.GetWorldTransform().Inverse()*joinPoint;
+        frame2._origin = body2.GetWorldTransform().Inverse()*joinPoint;
+
+        Generic6DofConstraint consttr = new Generic6DofConstraint(body1, body2, ref frame1, ref frame2, puseLinearReferenceFrameA);
+        consttr.CalculateTransforms();
+        world.AddConstraint(consttr, pdisableCollisionsBetweenLinkedBodies);
+
+        return new BulletConstraintXNA(consttr);
+    }
+    //SetFrames(m_constraint.ptr, frameA, frameArot, frameB, frameBrot);
+    public override bool SetFrames(BulletConstraint pConstraint, Vector3 pframe1, Quaternion pframe1rot, Vector3 pframe2, Quaternion pframe2rot)
+    {
+        Generic6DofConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofConstraint;
+        IndexedVector3 frame1v = new IndexedVector3(pframe1.X, pframe1.Y, pframe1.Z);
+        IndexedQuaternion frame1rot = new IndexedQuaternion(pframe1rot.X, pframe1rot.Y, pframe1rot.Z, pframe1rot.W);
+        IndexedMatrix frame1 = IndexedMatrix.CreateFromQuaternion(frame1rot);
+        frame1._origin = frame1v;
+
+        IndexedVector3 frame2v = new IndexedVector3(pframe2.X, pframe2.Y, pframe2.Z);
+        IndexedQuaternion frame2rot = new IndexedQuaternion(pframe2rot.X, pframe2rot.Y, pframe2rot.Z, pframe2rot.W);
+        IndexedMatrix frame2 = IndexedMatrix.CreateFromQuaternion(frame2rot);
+        frame2._origin = frame2v;
+        constraint.SetFrames(ref frame1, ref frame2);
+        return true;
+    }
+
+    public override Vector3 GetLinearVelocity(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 iv3 = body.GetLinearVelocity();
+        return new Vector3(iv3.X, iv3.Y, iv3.Z);
+    }
+    public override Vector3 GetAngularVelocity(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 iv3 = body.GetAngularVelocity();
+        return new Vector3(iv3.X, iv3.Y, iv3.Z);
+    }
+    public override Vector3 GetVelocityInLocalPoint(BulletBody pBody, Vector3 pos)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 posiv3 = new IndexedVector3(pos.X, pos.Y, pos.Z);
+        IndexedVector3 iv3 = body.GetVelocityInLocalPoint(ref posiv3);
+        return new Vector3(iv3.X, iv3.Y, iv3.Z);
+    }
+    public override void Translate(BulletBody pCollisionObject, Vector3 trans)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        collisionObject.Translate(new IndexedVector3(trans.X,trans.Y,trans.Z));
+    }
+    public override void UpdateDeactivation(BulletBody pBody, float timeStep)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        body.UpdateDeactivation(timeStep);
+    }
+
+    public override bool WantsSleeping(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        return body.WantsSleeping();
+    }
+
+    public override void SetAngularFactor(BulletBody pBody, float factor)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        body.SetAngularFactor(factor);
+    }
+
+    public override Vector3 GetAngularFactor(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 iv3 =  body.GetAngularFactor();
+        return new Vector3(iv3.X, iv3.Y, iv3.Z);
+    }
+
+    public override bool IsInWorld(BulletWorld pWorld, BulletBody pCollisionObject)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        return world.IsInWorld(collisionObject);
+    }
+
+    public override void AddConstraintRef(BulletBody pBody, BulletConstraint pConstraint)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        TypedConstraint constrain = (pConstraint as BulletConstraintXNA).constrain;
+        body.AddConstraintRef(constrain);
+    }
+
+    public override void RemoveConstraintRef(BulletBody pBody, BulletConstraint pConstraint)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        TypedConstraint constrain = (pConstraint as BulletConstraintXNA).constrain;
+        body.RemoveConstraintRef(constrain);
+    }
+
+    public override BulletConstraint GetConstraintRef(BulletBody pBody, int index)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        return new BulletConstraintXNA(body.GetConstraintRef(index));
+    }
+
+    public override int GetNumConstraintRefs(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        return body.GetNumConstraintRefs();
+    }
+
+    public override void SetInterpolationLinearVelocity(BulletBody pCollisionObject, Vector3 VehicleVelocity)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        IndexedVector3 velocity = new IndexedVector3(VehicleVelocity.X, VehicleVelocity.Y, VehicleVelocity.Z);
+        collisionObject.SetInterpolationLinearVelocity(ref velocity);
+    }
+
+    public override bool UseFrameOffset(BulletConstraint pConstraint, float onOff)
+    {
+        Generic6DofConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofConstraint;
+        constraint.SetUseFrameOffset((onOff == 0) ? false : true);
+        return true;
+    }
+    //SetBreakingImpulseThreshold(m_constraint.ptr, threshold);
+    public override bool SetBreakingImpulseThreshold(BulletConstraint pConstraint, float threshold)
+    {
+        Generic6DofConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofConstraint;
+        constraint.SetBreakingImpulseThreshold(threshold);
+        return true;
+    }
+    public override bool HingeSetLimits(BulletConstraint pConstraint, float low, float high, float softness, float bias, float relaxation)
+    {
+        HingeConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as HingeConstraint;
+        if (softness == HINGE_NOT_SPECIFIED)
+            constraint.SetLimit(low, high);
+        else
+            constraint.SetLimit(low, high, softness, bias, relaxation);
+        return true;
+    }
+    public override bool SpringEnable(BulletConstraint pConstraint, int index, float numericTrueFalse)
+    {
+        Generic6DofSpringConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofSpringConstraint;
+        constraint.EnableSpring(index, (numericTrueFalse == 0f ? false : true));
+        return true;
+    }
+
+    public override bool SpringSetEquilibriumPoint(BulletConstraint pConstraint, int index, float equilibriumPoint)
+    {
+        Generic6DofSpringConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofSpringConstraint;
+        if (index == SPRING_NOT_SPECIFIED)
+        {
+            constraint.SetEquilibriumPoint();
+        }
+        else
+        {
+            if (equilibriumPoint == SPRING_NOT_SPECIFIED)
+                constraint.SetEquilibriumPoint(index);
+            else
+                constraint.SetEquilibriumPoint(index, equilibriumPoint);
+        }
+        return true;
+    }
+
+    public override bool SpringSetStiffness(BulletConstraint pConstraint, int index, float stiffness)
+    {
+        Generic6DofSpringConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofSpringConstraint;
+        constraint.SetStiffness(index, stiffness);
+        return true;
+    }
+
+    public override bool SpringSetDamping(BulletConstraint pConstraint, int index, float damping)
+    {
+        Generic6DofSpringConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofSpringConstraint;
+        constraint.SetDamping(index, damping);
+        return true;
+    }
+
+    public override bool SliderSetLimits(BulletConstraint pConstraint, int lowerUpper, int linAng, float val)
+    {
+        SliderConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as SliderConstraint;
+                switch (lowerUpper)
+                {
+                        case SLIDER_LOWER_LIMIT:
+                                switch (linAng)
+                                {
+                                        case SLIDER_LINEAR:
+                                                constraint.SetLowerLinLimit(val);
+                                                break;
+                                        case SLIDER_ANGULAR:
+                                                constraint.SetLowerAngLimit(val);
+                                                break;
+                                }
+                                break;
+                        case SLIDER_UPPER_LIMIT:
+                                switch (linAng)
+                                {
+                                        case SLIDER_LINEAR:
+                                                constraint.SetUpperLinLimit(val);
+                                                break;
+                                        case SLIDER_ANGULAR:
+                                                constraint.SetUpperAngLimit(val);
+                                                break;
+                                }
+                                break;
+                }
+        return true;
+    }
+    public override bool SliderSet(BulletConstraint pConstraint, int softRestDamp, int dirLimOrtho, int linAng, float val)
+    {
+        SliderConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as SliderConstraint;
+                switch (softRestDamp)
+                {
+                        case SLIDER_SET_SOFTNESS:
+                                switch (dirLimOrtho)
+                                {
+                                        case SLIDER_SET_DIRECTION:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetSoftnessDirLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetSoftnessDirAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_LIMIT:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetSoftnessLimLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetSoftnessLimAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_ORTHO:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetSoftnessOrthoLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetSoftnessOrthoAng(val); break;
+                                                }
+                                                break;
+                                }
+                                break;
+                        case SLIDER_SET_RESTITUTION:
+                                switch (dirLimOrtho)
+                                {
+                                        case SLIDER_SET_DIRECTION:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetRestitutionDirLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetRestitutionDirAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_LIMIT:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetRestitutionLimLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetRestitutionLimAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_ORTHO:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetRestitutionOrthoLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetRestitutionOrthoAng(val); break;
+                                                }
+                                                break;
+                                }
+                                break;
+                        case SLIDER_SET_DAMPING:
+                                switch (dirLimOrtho)
+                                {
+                                        case SLIDER_SET_DIRECTION:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetDampingDirLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetDampingDirAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_LIMIT:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetDampingLimLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetDampingLimAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_ORTHO:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetDampingOrthoLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetDampingOrthoAng(val); break;
+                                                }
+                                                break;
+                                }
+                                break;
+                }
+        return true;
+    }
+    public override bool SliderMotorEnable(BulletConstraint pConstraint, int linAng, float numericTrueFalse)
+    {
+        SliderConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as SliderConstraint;
+                switch (linAng)
+                {
+                        case SLIDER_LINEAR:
+                                constraint.SetPoweredLinMotor(numericTrueFalse == 0.0 ? false : true);
+                                break;
+                        case SLIDER_ANGULAR:
+                                constraint.SetPoweredAngMotor(numericTrueFalse == 0.0 ? false : true);
+                                break;
+                }
+        return true;
+    }
+    public override bool SliderMotor(BulletConstraint pConstraint, int forceVel, int linAng, float val)
+    {
+        SliderConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as SliderConstraint;
+                switch (forceVel)
+                {
+                        case SLIDER_MOTOR_VELOCITY:
+                                switch (linAng)
+                                {
+                                        case SLIDER_LINEAR:
+                                                constraint.SetTargetLinMotorVelocity(val);
+                                                break;
+                                        case SLIDER_ANGULAR:
+                                                constraint.SetTargetAngMotorVelocity(val);
+                                                break;
+                                }
+                                break;
+                        case SLIDER_MAX_MOTOR_FORCE:
+                                switch (linAng)
+                                {
+                                        case SLIDER_LINEAR:
+                                                constraint.SetMaxLinMotorForce(val);
+                                                break;
+                                        case SLIDER_ANGULAR:
+                                                constraint.SetMaxAngMotorForce(val);
+                                                break;
+                                }
+                                break;
+                }
+        return true;
+    }
+
+    //BulletSimAPI.SetAngularDamping(Prim.PhysBody.ptr, angularDamping);
+    public override void SetAngularDamping(BulletBody pBody, float angularDamping)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        float lineardamping = body.GetLinearDamping();
+        body.SetDamping(lineardamping, angularDamping);
+
+    }
+
+    public override void UpdateInertiaTensor(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        if (body != null)  // can't update inertia tensor on CollisionObject
+            body.UpdateInertiaTensor();
+    }
+
+    public override void RecalculateCompoundShapeLocalAabb(BulletShape pCompoundShape)
+    {
+        CompoundShape shape = (pCompoundShape as BulletShapeXNA).shape as CompoundShape;
+        shape.RecalculateLocalAabb();
+    }
+
+    //BulletSimAPI.GetCollisionFlags(PhysBody.ptr)
+    public override CollisionFlags GetCollisionFlags(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        uint flags = (uint)collisionObject.GetCollisionFlags();
+        return (CollisionFlags) flags;
+    }
+
+    public override void SetDamping(BulletBody pBody, float pLinear, float pAngular)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        body.SetDamping(pLinear, pAngular);
+    }
+    //PhysBody.ptr, PhysicsScene.Params.deactivationTime);
+    public override void SetDeactivationTime(BulletBody pCollisionObject, float pDeactivationTime)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        collisionObject.SetDeactivationTime(pDeactivationTime);
+    }
+    //SetSleepingThresholds(PhysBody.ptr, PhysicsScene.Params.linearSleepingThreshold, PhysicsScene.Params.angularSleepingThreshold);
+    public override void SetSleepingThresholds(BulletBody pBody, float plinearSleepingThreshold, float pangularSleepingThreshold)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        body.SetSleepingThresholds(plinearSleepingThreshold, pangularSleepingThreshold);
+    }
+
+    public override CollisionObjectTypes GetBodyType(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        return (CollisionObjectTypes)(int) collisionObject.GetInternalType();
+    }
+
+    public override void ApplyGravity(BulletBody pBody)
+    {
+
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        body.ApplyGravity();
+    }
+
+    public override Vector3 GetGravity(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 gravity = body.GetGravity();
+        return new Vector3(gravity.X, gravity.Y, gravity.Z);
+    }
+
+    public override void SetLinearDamping(BulletBody pBody, float lin_damping)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        float angularDamping = body.GetAngularDamping();
+        body.SetDamping(lin_damping, angularDamping);
+    }
+
+    public override float GetLinearDamping(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        return body.GetLinearDamping();
+    }
+
+    public override float GetAngularDamping(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        return body.GetAngularDamping();
+    }
+
+    public override float GetLinearSleepingThreshold(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        return body.GetLinearSleepingThreshold();
+    }
+
+    public override void ApplyDamping(BulletBody pBody, float timeStep)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        body.ApplyDamping(timeStep);
+    }
+
+    public override Vector3 GetLinearFactor(BulletBody pBody)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 linearFactor = body.GetLinearFactor();
+        return new Vector3(linearFactor.X, linearFactor.Y, linearFactor.Z);
+    }
+
+    public override void SetLinearFactor(BulletBody pBody, Vector3 factor)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        body.SetLinearFactor(new IndexedVector3(factor.X, factor.Y, factor.Z));
+    }
+
+    public override void SetCenterOfMassByPosRot(BulletBody pBody, Vector3 pos, Quaternion rot)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedQuaternion quat = new IndexedQuaternion(rot.X, rot.Y, rot.Z,rot.W);
+        IndexedMatrix mat = IndexedMatrix.CreateFromQuaternion(quat);
+        mat._origin = new IndexedVector3(pos.X, pos.Y, pos.Z);
+        body.SetCenterOfMassTransform( ref mat);
+        /* TODO: double check this */
+    }
+
+    //BulletSimAPI.ApplyCentralForce(PhysBody.ptr, fSum);
+    public override void ApplyCentralForce(BulletBody pBody, Vector3 pfSum)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 fSum = new IndexedVector3(pfSum.X, pfSum.Y, pfSum.Z);
+        body.ApplyCentralForce(ref fSum);
+    }
+    public override void ApplyCentralImpulse(BulletBody pBody, Vector3 pfSum)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 fSum = new IndexedVector3(pfSum.X, pfSum.Y, pfSum.Z);
+        body.ApplyCentralImpulse(ref fSum);
+    }
+    public override void ApplyTorque(BulletBody pBody, Vector3 pfSum)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 fSum = new IndexedVector3(pfSum.X, pfSum.Y, pfSum.Z);
+        body.ApplyTorque(ref fSum);
+    }
+    public override void ApplyTorqueImpulse(BulletBody pBody, Vector3 pfSum)
+    {
+        RigidBody body = (pBody as BulletBodyXNA).rigidBody;
+        IndexedVector3 fSum = new IndexedVector3(pfSum.X, pfSum.Y, pfSum.Z);
+        body.ApplyTorqueImpulse(ref fSum);
+    }
+
+    public override void DestroyObject(BulletWorld pWorld, BulletBody pBody)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        CollisionObject co = (pBody as BulletBodyXNA).rigidBody;
+        RigidBody bo = co as RigidBody;
+        if (bo == null)
+        {
+
+            if (world.IsInWorld(co))
+            {
+                world.RemoveCollisionObject(co);
+            }
+        }
+        else
+        {
+
+            if (world.IsInWorld(bo))
+            {
+                world.RemoveRigidBody(bo);
+            }
+        }
+        if (co != null)
+        {
+            if (co.GetUserPointer() != null)
+            {
+                uint localId = (uint) co.GetUserPointer();
+                if (specialCollisionObjects.ContainsKey(localId))
+                {
+                    specialCollisionObjects.Remove(localId);
+                }
+            }
+        }
+
+    }
+
+    public override void Shutdown(BulletWorld pWorld)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        world.Cleanup();
+    }
+
+    public override BulletShape DuplicateCollisionShape(BulletWorld pWorld, BulletShape pShape, uint id)
+    {
+        CollisionShape shape1 = (pShape as BulletShapeXNA).shape;
+
+        // TODO:  Turn this from a reference copy to a Value Copy.
+        BulletShapeXNA shape2 = new BulletShapeXNA(shape1, BSShapeTypeFromBroadPhaseNativeType(shape1.GetShapeType()));
+
+        return shape2;
+    }
+
+    public override bool DeleteCollisionShape(BulletWorld pWorld, BulletShape pShape)
+    {
+        //TODO:
+        return false;
+    }
+    //(sim.ptr, shape.ptr, prim.LocalID, prim.RawPosition, prim.RawOrientation);
+
+    public override BulletBody CreateBodyFromShape(BulletWorld pWorld, BulletShape pShape, uint pLocalID, Vector3 pRawPosition, Quaternion pRawOrientation)
+    {
+        CollisionWorld world = (pWorld as BulletWorldXNA).world;
+        IndexedMatrix mat =
+            IndexedMatrix.CreateFromQuaternion(new IndexedQuaternion(pRawOrientation.X, pRawOrientation.Y,
+                                                                     pRawOrientation.Z, pRawOrientation.W));
+        mat._origin = new IndexedVector3(pRawPosition.X, pRawPosition.Y, pRawPosition.Z);
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        //UpdateSingleAabb(world, shape);
+        // TODO: Feed Update array into null
+        SimMotionState motionState = new SimMotionState(this, pLocalID, mat, null);
+        RigidBody body = new RigidBody(0,motionState,shape,IndexedVector3.Zero);
+        RigidBodyConstructionInfo constructionInfo = new RigidBodyConstructionInfo(0, motionState, shape, IndexedVector3.Zero)
+                                                         {
+                                                             m_mass = 0
+                                                         };
+        /*
+            m_mass = mass;
+                        m_motionState =motionState;
+                        m_collisionShape = collisionShape;
+                        m_localInertia = localInertia;
+                        m_linearDamping = 0f;
+                        m_angularDamping = 0f;
+                        m_friction = 0.5f;
+                        m_restitution = 0f;
+                        m_linearSleepingThreshold = 0.8f;
+                        m_angularSleepingThreshold = 1f;
+                        m_additionalDamping = false;
+                        m_additionalDampingFactor = 0.005f;
+                        m_additionalLinearDampingThresholdSqr = 0.01f;
+                        m_additionalAngularDampingThresholdSqr = 0.01f;
+                        m_additionalAngularDampingFactor = 0.01f;
+            m_startWorldTransform = IndexedMatrix.Identity;
+        */
+        body.SetUserPointer(pLocalID);
+
+        return new BulletBodyXNA(pLocalID, body);
+    }
+
+
+    public override BulletBody CreateBodyWithDefaultMotionState( BulletShape pShape, uint pLocalID, Vector3 pRawPosition, Quaternion pRawOrientation)
+    {
+
+        IndexedMatrix mat =
+            IndexedMatrix.CreateFromQuaternion(new IndexedQuaternion(pRawOrientation.X, pRawOrientation.Y,
+                                                                     pRawOrientation.Z, pRawOrientation.W));
+        mat._origin = new IndexedVector3(pRawPosition.X, pRawPosition.Y, pRawPosition.Z);
+
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+
+        // TODO: Feed Update array into null
+        RigidBody body = new RigidBody(0, new DefaultMotionState( mat, IndexedMatrix.Identity), shape, IndexedVector3.Zero);
+        body.SetWorldTransform(mat);
+        body.SetUserPointer(pLocalID);
+        return new BulletBodyXNA(pLocalID, body);
+    }
+    //(m_mapInfo.terrainBody.ptr, CollisionFlags.CF_STATIC_OBJECT);
+    public override CollisionFlags SetCollisionFlags(BulletBody pCollisionObject, CollisionFlags collisionFlags)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        collisionObject.SetCollisionFlags((BulletXNA.BulletCollision.CollisionFlags) (uint) collisionFlags);
+        return (CollisionFlags)collisionObject.GetCollisionFlags();
+    }
+
+    public override Vector3 GetAnisotripicFriction(BulletConstraint pconstrain)
+    {
+
+        /* TODO */
+        return Vector3.Zero;
+    }
+    public override Vector3 SetAnisotripicFriction(BulletConstraint pconstrain, Vector3 frict) { /* TODO */ return Vector3.Zero; }
+    public override bool HasAnisotripicFriction(BulletConstraint pconstrain) { /* TODO */ return false; }
+    public override float GetContactProcessingThreshold(BulletBody pBody) { /* TODO */ return 0f; }
+    public override bool IsStaticObject(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        return collisionObject.IsStaticObject();
+
+    }
+    public override bool IsKinematicObject(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        return collisionObject.IsKinematicObject();
+    }
+    public override bool IsStaticOrKinematicObject(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        return collisionObject.IsStaticOrKinematicObject();
+    }
+    public override bool HasContactResponse(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        return collisionObject.HasContactResponse();
+    }
+    public override int GetActivationState(BulletBody pBody) { /* TODO */ return 0; }
+    public override void SetActivationState(BulletBody pBody, int state) { /* TODO */ }
+    public override float GetDeactivationTime(BulletBody pBody) { /* TODO */ return 0f; }
+    public override bool IsActive(BulletBody pBody) { /* TODO */ return false; }
+    public override float GetRestitution(BulletBody pBody) { /* TODO */ return 0f; }
+    public override float GetFriction(BulletBody pBody) { /* TODO */ return 0f; }
+    public override void SetInterpolationVelocity(BulletBody pBody, Vector3 linearVel, Vector3 angularVel) { /* TODO */ }
+    public override float GetHitFraction(BulletBody pBody) { /* TODO */ return 0f; }
+
+    //(m_mapInfo.terrainBody.ptr, PhysicsScene.Params.terrainHitFraction);
+    public override void SetHitFraction(BulletBody pCollisionObject, float pHitFraction)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        collisionObject.SetHitFraction(pHitFraction);
+    }
+    //BuildCapsuleShape(physicsScene.World.ptr, 1f, 1f, prim.Scale);
+    public override BulletShape BuildCapsuleShape(BulletWorld pWorld, float pRadius, float pHeight, Vector3 pScale)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        IndexedVector3 scale = new IndexedVector3(pScale.X, pScale.Y, pScale.Z);
+        CapsuleShapeZ capsuleShapeZ = new CapsuleShapeZ(pRadius, pHeight);
+        capsuleShapeZ.SetMargin(world.WorldSettings.Params.collisionMargin);
+        capsuleShapeZ.SetLocalScaling(ref scale);
+
+        return new BulletShapeXNA(capsuleShapeZ, BSPhysicsShapeType.SHAPE_CAPSULE); ;
+    }
+
+    public override BulletWorld Initialize(Vector3 maxPosition, ConfigurationParameters parms,
+                                            int maxCollisions, ref CollisionDesc[] collisionArray,
+                                            int maxUpdates, ref EntityProperties[] updateArray
+                                            )
+    {
+
+        UpdatedObjects = updateArray;
+        UpdatedCollisions = collisionArray;
+        /* TODO */
+        ConfigurationParameters[] configparms = new ConfigurationParameters[1];
+        configparms[0] = parms;
+        Vector3 worldExtent = maxPosition;
+        m_maxCollisions = maxCollisions;
+        m_maxUpdatesPerFrame = maxUpdates;
+        specialCollisionObjects = new Dictionary<uint, GhostObject>();
+
+        return new BulletWorldXNA(1, PhysicsScene, BSAPIXNA.Initialize2(worldExtent, configparms, maxCollisions, ref collisionArray, maxUpdates, ref updateArray, null));
+    }
+
+    private static DiscreteDynamicsWorld Initialize2(Vector3 worldExtent,
+                        ConfigurationParameters[] o,
+                        int mMaxCollisionsPerFrame, ref CollisionDesc[] collisionArray,
+                        int mMaxUpdatesPerFrame, ref EntityProperties[] updateArray,
+                        object mDebugLogCallbackHandle)
+    {
+        CollisionWorld.WorldData.ParamData p = new CollisionWorld.WorldData.ParamData();
+
+        p.angularDamping = BSParam.AngularDamping;
+        p.defaultFriction = o[0].defaultFriction;
+        p.defaultFriction = o[0].defaultFriction;
+        p.defaultDensity = o[0].defaultDensity;
+        p.defaultRestitution = o[0].defaultRestitution;
+        p.collisionMargin = o[0].collisionMargin;
+        p.gravity = o[0].gravity;
+
+        p.linearDamping = BSParam.LinearDamping;
+        p.angularDamping = BSParam.AngularDamping;
+        p.deactivationTime = BSParam.DeactivationTime;
+        p.linearSleepingThreshold = BSParam.LinearSleepingThreshold;
+        p.angularSleepingThreshold = BSParam.AngularSleepingThreshold;
+        p.ccdMotionThreshold = BSParam.CcdMotionThreshold;
+        p.ccdSweptSphereRadius = BSParam.CcdSweptSphereRadius;
+        p.contactProcessingThreshold = BSParam.ContactProcessingThreshold;
+
+        p.terrainImplementation = BSParam.TerrainImplementation;
+        p.terrainFriction = BSParam.TerrainFriction;
+
+        p.terrainHitFraction = BSParam.TerrainHitFraction;
+        p.terrainRestitution = BSParam.TerrainRestitution;
+        p.terrainCollisionMargin = BSParam.TerrainCollisionMargin;
+
+        p.avatarFriction = BSParam.AvatarFriction;
+        p.avatarStandingFriction = BSParam.AvatarStandingFriction;
+        p.avatarDensity = BSParam.AvatarDensity;
+        p.avatarRestitution = BSParam.AvatarRestitution;
+        p.avatarCapsuleWidth = BSParam.AvatarCapsuleWidth;
+        p.avatarCapsuleDepth = BSParam.AvatarCapsuleDepth;
+        p.avatarCapsuleHeight = BSParam.AvatarCapsuleHeight;
+        p.avatarContactProcessingThreshold = BSParam.AvatarContactProcessingThreshold;
+
+        p.vehicleAngularDamping = BSParam.VehicleAngularDamping;
+
+        p.maxPersistantManifoldPoolSize = o[0].maxPersistantManifoldPoolSize;
+        p.maxCollisionAlgorithmPoolSize = o[0].maxCollisionAlgorithmPoolSize;
+        p.shouldDisableContactPoolDynamicAllocation = o[0].shouldDisableContactPoolDynamicAllocation;
+        p.shouldForceUpdateAllAabbs = o[0].shouldForceUpdateAllAabbs;
+        p.shouldRandomizeSolverOrder = o[0].shouldRandomizeSolverOrder;
+        p.shouldSplitSimulationIslands = o[0].shouldSplitSimulationIslands;
+        p.shouldEnableFrictionCaching = o[0].shouldEnableFrictionCaching;
+        p.numberOfSolverIterations = o[0].numberOfSolverIterations;
+
+        p.linksetImplementation = BSParam.LinksetImplementation;
+        p.linkConstraintUseFrameOffset = BSParam.NumericBool(BSParam.LinkConstraintUseFrameOffset);
+        p.linkConstraintEnableTransMotor = BSParam.NumericBool(BSParam.LinkConstraintEnableTransMotor);
+        p.linkConstraintTransMotorMaxVel = BSParam.LinkConstraintTransMotorMaxVel;
+        p.linkConstraintTransMotorMaxForce = BSParam.LinkConstraintTransMotorMaxForce;
+        p.linkConstraintERP = BSParam.LinkConstraintERP;
+        p.linkConstraintCFM = BSParam.LinkConstraintCFM;
+        p.linkConstraintSolverIterations = BSParam.LinkConstraintSolverIterations;
+        p.physicsLoggingFrames = o[0].physicsLoggingFrames;
+        DefaultCollisionConstructionInfo ccci = new DefaultCollisionConstructionInfo();
+
+        DefaultCollisionConfiguration cci = new DefaultCollisionConfiguration();
+        CollisionDispatcher m_dispatcher = new CollisionDispatcher(cci);
+
+
+        if (p.maxPersistantManifoldPoolSize > 0)
+            cci.m_persistentManifoldPoolSize = (int)p.maxPersistantManifoldPoolSize;
+        if (p.shouldDisableContactPoolDynamicAllocation !=0)
+            m_dispatcher.SetDispatcherFlags(DispatcherFlags.CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION);
+        //if (p.maxCollisionAlgorithmPoolSize >0 )
+
+        DbvtBroadphase m_broadphase = new DbvtBroadphase();
+        //IndexedVector3 aabbMin = new IndexedVector3(0, 0, 0);
+        //IndexedVector3 aabbMax = new IndexedVector3(256, 256, 256);
+
+        //AxisSweep3Internal m_broadphase2 = new AxisSweep3Internal(ref aabbMin, ref aabbMax, Convert.ToInt32(0xfffe), 0xffff, ushort.MaxValue/2, null, true);
+        m_broadphase.GetOverlappingPairCache().SetInternalGhostPairCallback(new GhostPairCallback());
+
+        SequentialImpulseConstraintSolver m_solver = new SequentialImpulseConstraintSolver();
+
+        DiscreteDynamicsWorld world = new DiscreteDynamicsWorld(m_dispatcher, m_broadphase, m_solver, cci);
+
+        world.LastCollisionDesc = 0;
+        world.LastEntityProperty = 0;
+
+        world.WorldSettings.Params = p;
+        world.SetForceUpdateAllAabbs(p.shouldForceUpdateAllAabbs != 0);
+        world.GetSolverInfo().m_solverMode = SolverMode.SOLVER_USE_WARMSTARTING | SolverMode.SOLVER_SIMD;
+        if (p.shouldRandomizeSolverOrder != 0)
+            world.GetSolverInfo().m_solverMode |= SolverMode.SOLVER_RANDMIZE_ORDER;
+
+        world.GetSimulationIslandManager().SetSplitIslands(p.shouldSplitSimulationIslands != 0);
+        //world.GetDispatchInfo().m_enableSatConvex Not implemented in C# port
+
+        if (p.shouldEnableFrictionCaching != 0)
+            world.GetSolverInfo().m_solverMode |= SolverMode.SOLVER_ENABLE_FRICTION_DIRECTION_CACHING;
+
+        if (p.numberOfSolverIterations > 0)
+            world.GetSolverInfo().m_numIterations = (int) p.numberOfSolverIterations;
+
+
+        world.GetSolverInfo().m_damping = world.WorldSettings.Params.linearDamping;
+        world.GetSolverInfo().m_restitution = world.WorldSettings.Params.defaultRestitution;
+        world.GetSolverInfo().m_globalCfm = 0.0f;
+        world.GetSolverInfo().m_tau = 0.6f;
+        world.GetSolverInfo().m_friction = 0.3f;
+        world.GetSolverInfo().m_maxErrorReduction = 20f;
+        world.GetSolverInfo().m_numIterations = 10;
+        world.GetSolverInfo().m_erp = 0.2f;
+        world.GetSolverInfo().m_erp2 = 0.1f;
+        world.GetSolverInfo().m_sor = 1.0f;
+        world.GetSolverInfo().m_splitImpulse = false;
+        world.GetSolverInfo().m_splitImpulsePenetrationThreshold = -0.02f;
+        world.GetSolverInfo().m_linearSlop = 0.0f;
+        world.GetSolverInfo().m_warmstartingFactor = 0.85f;
+        world.GetSolverInfo().m_restingContactRestitutionThreshold = 2;
+        world.SetForceUpdateAllAabbs(true);
+
+        //BSParam.TerrainImplementation = 0;
+        world.SetGravity(new IndexedVector3(0,0,p.gravity));
+
+        // Turn off Pooling since globals and pooling are bad for threading.
+        BulletGlobals.VoronoiSimplexSolverPool.SetPoolingEnabled(false);
+        BulletGlobals.SubSimplexConvexCastPool.SetPoolingEnabled(false);
+        BulletGlobals.ManifoldPointPool.SetPoolingEnabled(false);
+        BulletGlobals.CastResultPool.SetPoolingEnabled(false);
+        BulletGlobals.SphereShapePool.SetPoolingEnabled(false);
+        BulletGlobals.DbvtNodePool.SetPoolingEnabled(false);
+        BulletGlobals.SingleRayCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.SubSimplexClosestResultPool.SetPoolingEnabled(false);
+        BulletGlobals.GjkPairDetectorPool.SetPoolingEnabled(false);
+        BulletGlobals.DbvtTreeColliderPool.SetPoolingEnabled(false);
+        BulletGlobals.SingleSweepCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.BroadphaseRayTesterPool.SetPoolingEnabled(false);
+        BulletGlobals.ClosestNotMeConvexResultCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.GjkEpaPenetrationDepthSolverPool.SetPoolingEnabled(false);
+        BulletGlobals.ContinuousConvexCollisionPool.SetPoolingEnabled(false);
+        BulletGlobals.DbvtStackDataBlockPool.SetPoolingEnabled(false);
+
+        BulletGlobals.BoxBoxCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.CompoundCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.ConvexConcaveCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.ConvexConvexAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.ConvexPlaneAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.SphereBoxCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.SphereSphereCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.SphereTriangleCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.GImpactCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.GjkEpaSolver2MinkowskiDiffPool.SetPoolingEnabled(false);
+        BulletGlobals.PersistentManifoldPool.SetPoolingEnabled(false);
+        BulletGlobals.ManifoldResultPool.SetPoolingEnabled(false);
+        BulletGlobals.GJKPool.SetPoolingEnabled(false);
+        BulletGlobals.GIM_ShapeRetrieverPool.SetPoolingEnabled(false);
+        BulletGlobals.TriangleShapePool.SetPoolingEnabled(false);
+        BulletGlobals.SphereTriangleDetectorPool.SetPoolingEnabled(false);
+        BulletGlobals.CompoundLeafCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.GjkConvexCastPool.SetPoolingEnabled(false);
+        BulletGlobals.LocalTriangleSphereCastCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.BridgeTriangleRaycastCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.BridgeTriangleConcaveRaycastCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.BridgeTriangleConvexcastCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.MyNodeOverlapCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.ClosestRayResultCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.DebugDrawcallbackPool.SetPoolingEnabled(false);
+
+        return world;
+    }
+    //m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_STOP_CFM, cfm, ConstraintParamAxis.AXIS_ALL
+    public override bool SetConstraintParam(BulletConstraint pConstraint, ConstraintParams paramIndex, float paramvalue, ConstraintParamAxis axis)
+    {
+        Generic6DofConstraint constrain = (pConstraint as BulletConstraintXNA).constrain as Generic6DofConstraint;
+        if (axis == ConstraintParamAxis.AXIS_LINEAR_ALL || axis == ConstraintParamAxis.AXIS_ALL)
+        {
+            constrain.SetParam((BulletXNA.BulletDynamics.ConstraintParams) (int) paramIndex, paramvalue, 0);
+            constrain.SetParam((BulletXNA.BulletDynamics.ConstraintParams) (int) paramIndex, paramvalue, 1);
+            constrain.SetParam((BulletXNA.BulletDynamics.ConstraintParams) (int) paramIndex, paramvalue, 2);
+        }
+        if (axis == ConstraintParamAxis.AXIS_ANGULAR_ALL || axis == ConstraintParamAxis.AXIS_ALL)
+        {
+            constrain.SetParam((BulletXNA.BulletDynamics.ConstraintParams)(int)paramIndex, paramvalue, 3);
+            constrain.SetParam((BulletXNA.BulletDynamics.ConstraintParams)(int)paramIndex, paramvalue, 4);
+            constrain.SetParam((BulletXNA.BulletDynamics.ConstraintParams)(int)paramIndex, paramvalue, 5);
+        }
+        if (axis == ConstraintParamAxis.AXIS_LINEAR_ALL)
+        {
+            constrain.SetParam((BulletXNA.BulletDynamics.ConstraintParams)(int)paramIndex, paramvalue, (int)axis);
+        }
+        return true;
+    }
+
+    public override bool PushUpdate(BulletBody pCollisionObject)
+    {
+        bool ret = false;
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        RigidBody rb = collisionObject as RigidBody;
+        if (rb != null)
+        {
+            SimMotionState sms = rb.GetMotionState() as SimMotionState;
+            if (sms != null)
+            {
+                IndexedMatrix wt = IndexedMatrix.Identity;
+                sms.GetWorldTransform(out wt);
+                sms.SetWorldTransform(ref wt, true);
+                ret = true;
+            }
+        }
+        return ret;
+
+    }
+
+    public override float GetAngularMotionDisc(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.GetAngularMotionDisc();
+    }
+    public override float GetContactBreakingThreshold(BulletShape pShape, float defaultFactor)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.GetContactBreakingThreshold(defaultFactor);
+    }
+    public override bool IsCompound(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.IsCompound();
+    }
+    public override bool IsSoftBody(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.IsSoftBody();
+    }
+    public override bool IsPolyhedral(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.IsPolyhedral();
+    }
+    public override bool IsConvex2d(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.IsConvex2d();
+    }
+    public override bool IsConvex(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.IsConvex();
+    }
+    public override bool IsNonMoving(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.IsNonMoving();
+    }
+    public override bool IsConcave(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.IsConcave();
+    }
+    public override bool IsInfinite(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        return shape.IsInfinite();
+    }
+    public override bool IsNativeShape(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        bool ret;
+        switch (shape.GetShapeType())
+        {
+            case BroadphaseNativeTypes.BOX_SHAPE_PROXYTYPE:
+                case BroadphaseNativeTypes.CONE_SHAPE_PROXYTYPE:
+                case BroadphaseNativeTypes.SPHERE_SHAPE_PROXYTYPE:
+                case BroadphaseNativeTypes.CYLINDER_SHAPE_PROXYTYPE:
+                ret = true;
+                break;
+            default:
+                ret = false;
+                break;
+        }
+        return ret;
+    }
+
+    public override void SetShapeCollisionMargin(BulletShape pShape, float pMargin)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        shape.SetMargin(pMargin);
+    }
+
+    //sim.ptr, shape.ptr,prim.LocalID, prim.RawPosition, prim.RawOrientation
+    public override BulletBody CreateGhostFromShape(BulletWorld pWorld, BulletShape pShape, uint pLocalID, Vector3 pRawPosition, Quaternion pRawOrientation)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        IndexedMatrix bodyTransform = new IndexedMatrix();
+        bodyTransform._origin = new IndexedVector3(pRawPosition.X, pRawPosition.Y, pRawPosition.Z);
+        bodyTransform.SetRotation(new IndexedQuaternion(pRawOrientation.X,pRawOrientation.Y,pRawOrientation.Z,pRawOrientation.W));
+        GhostObject gObj = new PairCachingGhostObject();
+        gObj.SetWorldTransform(bodyTransform);
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        gObj.SetCollisionShape(shape);
+        gObj.SetUserPointer(pLocalID);
+
+        if (specialCollisionObjects.ContainsKey(pLocalID))
+            specialCollisionObjects[pLocalID] = gObj;
+        else
+            specialCollisionObjects.Add(pLocalID, gObj);
+
+        // TODO: Add to Special CollisionObjects!
+        return new BulletBodyXNA(pLocalID, gObj);
+    }
+
+    public override void SetCollisionShape(BulletWorld pWorld, BulletBody pCollisionObject, BulletShape pShape)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
+        if (pShape == null)
+        {
+            collisionObject.SetCollisionShape(new EmptyShape());
+        }
+        else
+        {
+            CollisionShape shape = (pShape as BulletShapeXNA).shape;
+            collisionObject.SetCollisionShape(shape);
+        }
+    }
+    public override BulletShape GetCollisionShape(BulletBody pCollisionObject)
+    {
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        CollisionShape shape = collisionObject.GetCollisionShape();
+        return new BulletShapeXNA(shape, BSShapeTypeFromBroadPhaseNativeType(shape.GetShapeType()));
+    }
+
+    //(PhysicsScene.World.ptr, nativeShapeData)
+    public override BulletShape BuildNativeShape(BulletWorld pWorld, ShapeData pShapeData)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        CollisionShape shape = null;
+        switch (pShapeData.Type)
+        {
+            case BSPhysicsShapeType.SHAPE_BOX:
+                shape = new BoxShape(new IndexedVector3(0.5f,0.5f,0.5f));
+                break;
+            case BSPhysicsShapeType.SHAPE_CONE:
+                shape = new ConeShapeZ(0.5f, 1.0f);
+                break;
+            case BSPhysicsShapeType.SHAPE_CYLINDER:
+                shape = new CylinderShapeZ(new IndexedVector3(0.5f, 0.5f, 0.5f));
+                break;
+            case BSPhysicsShapeType.SHAPE_SPHERE:
+                shape = new SphereShape(0.5f);
+                break;
+
+        }
+        if (shape != null)
+        {
+            IndexedVector3 scaling = new IndexedVector3(pShapeData.Scale.X, pShapeData.Scale.Y, pShapeData.Scale.Z);
+            shape.SetMargin(world.WorldSettings.Params.collisionMargin);
+            shape.SetLocalScaling(ref scaling);
+
+        }
+        return new BulletShapeXNA(shape, pShapeData.Type);
+    }
+    //PhysicsScene.World.ptr, false
+    public override BulletShape CreateCompoundShape(BulletWorld pWorld, bool enableDynamicAabbTree)
+    {
+        return new BulletShapeXNA(new CompoundShape(enableDynamicAabbTree), BSPhysicsShapeType.SHAPE_COMPOUND);
+    }
+
+    public override int GetNumberOfCompoundChildren(BulletShape pCompoundShape)
+    {
+        CompoundShape compoundshape = (pCompoundShape as BulletShapeXNA).shape as CompoundShape;
+        return compoundshape.GetNumChildShapes();
+    }
+    //LinksetRoot.PhysShape.ptr, newShape.ptr, displacementPos, displacementRot
+    public override void AddChildShapeToCompoundShape(BulletShape pCShape, BulletShape paddShape, Vector3 displacementPos, Quaternion displacementRot)
+    {
+        IndexedMatrix relativeTransform = new IndexedMatrix();
+        CompoundShape compoundshape = (pCShape as BulletShapeXNA).shape as CompoundShape;
+        CollisionShape addshape = (paddShape as BulletShapeXNA).shape;
+
+        relativeTransform._origin = new IndexedVector3(displacementPos.X, displacementPos.Y, displacementPos.Z);
+        relativeTransform.SetRotation(new IndexedQuaternion(displacementRot.X,displacementRot.Y,displacementRot.Z,displacementRot.W));
+        compoundshape.AddChildShape(ref relativeTransform, addshape);
+
+    }
+
+    public override BulletShape RemoveChildShapeFromCompoundShapeIndex(BulletShape pCShape, int pii)
+    {
+        CompoundShape compoundshape = (pCShape as BulletShapeXNA).shape as CompoundShape;
+        CollisionShape ret = null;
+        ret = compoundshape.GetChildShape(pii);
+        compoundshape.RemoveChildShapeByIndex(pii);
+        return new BulletShapeXNA(ret, BSShapeTypeFromBroadPhaseNativeType(ret.GetShapeType()));
+    }
+
+    public override BulletShape GetChildShapeFromCompoundShapeIndex(BulletShape cShape, int indx) {
+
+        if (cShape == null)
+            return null;
+        CompoundShape compoundShape = (cShape as BulletShapeXNA).shape as CompoundShape;
+        CollisionShape shape = compoundShape.GetChildShape(indx);
+        BulletShape retShape = new BulletShapeXNA(shape, BSShapeTypeFromBroadPhaseNativeType(shape.GetShapeType()));
+
+
+        return retShape;
+    }
+
+    public BSPhysicsShapeType BSShapeTypeFromBroadPhaseNativeType(BroadphaseNativeTypes pin)
+    {
+        BSPhysicsShapeType ret = BSPhysicsShapeType.SHAPE_UNKNOWN;
+        switch (pin)
+        {
+            case BroadphaseNativeTypes.BOX_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_BOX;
+                break;
+            case BroadphaseNativeTypes.TRIANGLE_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+
+            case BroadphaseNativeTypes.TETRAHEDRAL_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_CONVEXHULL;
+                break;
+            case BroadphaseNativeTypes.CONVEX_HULL_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_HULL;
+                break;
+            case BroadphaseNativeTypes.CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.CUSTOM_POLYHEDRAL_SHAPE_TYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            //implicit convex shapes
+            case BroadphaseNativeTypes.IMPLICIT_CONVEX_SHAPES_START_HERE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.SPHERE_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_SPHERE;
+                break;
+            case BroadphaseNativeTypes.MULTI_SPHERE_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.CAPSULE_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_CAPSULE;
+                break;
+            case BroadphaseNativeTypes.CONE_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_CONE;
+                break;
+            case BroadphaseNativeTypes.CONVEX_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_CONVEXHULL;
+                break;
+            case BroadphaseNativeTypes.CYLINDER_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_CYLINDER;
+                break;
+            case BroadphaseNativeTypes.UNIFORM_SCALING_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.MINKOWSKI_SUM_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.BOX_2D_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.CONVEX_2D_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.CUSTOM_CONVEX_SHAPE_TYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            //concave shape
+            case BroadphaseNativeTypes.CONCAVE_SHAPES_START_HERE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            //keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy!
+            case BroadphaseNativeTypes.TRIANGLE_MESH_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_MESH;
+                break;
+            case BroadphaseNativeTypes.SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_MESH;
+                break;
+            ///used for demo integration FAST/Swift collision library and Bullet
+            case BroadphaseNativeTypes.FAST_CONCAVE_MESH_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_MESH;
+                break;
+            //terrain
+            case BroadphaseNativeTypes.TERRAIN_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_HEIGHTMAP;
+                break;
+            ///Used for GIMPACT Trimesh integration
+            case BroadphaseNativeTypes.GIMPACT_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_GIMPACT;
+                break;
+            ///Multimaterial mesh
+            case BroadphaseNativeTypes.MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_MESH;
+                break;
+
+            case BroadphaseNativeTypes.EMPTY_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.STATIC_PLANE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_GROUNDPLANE;
+                break;
+            case BroadphaseNativeTypes.CUSTOM_CONCAVE_SHAPE_TYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.CONCAVE_SHAPES_END_HERE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+
+            case BroadphaseNativeTypes.COMPOUND_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_COMPOUND;
+                break;
+
+            case BroadphaseNativeTypes.SOFTBODY_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_MESH;
+                break;
+            case BroadphaseNativeTypes.HFFLUID_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+            case BroadphaseNativeTypes.INVALID_SHAPE_PROXYTYPE:
+                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                break;
+        }
+        return ret;
+    }
+
+    public override void RemoveChildShapeFromCompoundShape(BulletShape cShape, BulletShape removeShape) { /* TODO */ }
+    public override void UpdateChildTransform(BulletShape pShape, int childIndex, Vector3 pos, Quaternion rot, bool shouldRecalculateLocalAabb) { /* TODO */ }
+
+    public override BulletShape CreateGroundPlaneShape(uint pLocalId, float pheight, float pcollisionMargin)
+    {
+        StaticPlaneShape m_planeshape = new StaticPlaneShape(new IndexedVector3(0,0,1),(int)pheight );
+        m_planeshape.SetMargin(pcollisionMargin);
+        m_planeshape.SetUserPointer(pLocalId);
+        return new BulletShapeXNA(m_planeshape, BSPhysicsShapeType.SHAPE_GROUNDPLANE);
+    }
+
+    public override BulletConstraint Create6DofSpringConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
+                                    Vector3 pframe1, Quaternion pframe1rot, Vector3 pframe2, Quaternion pframe2rot,
+                                    bool puseLinearReferenceFrameA, bool pdisableCollisionsBetweenLinkedBodies)
+
+    {
+        Generic6DofSpringConstraint constrain = null;
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody body1 = (pBody1 as BulletBodyXNA).rigidBody;
+        RigidBody body2 = (pBody2 as BulletBodyXNA).rigidBody;
+        if (body1 != null && body2 != null)
+        {
+            IndexedVector3 frame1v = new IndexedVector3(pframe1.X, pframe1.Y, pframe1.Z);
+            IndexedQuaternion frame1rot = new IndexedQuaternion(pframe1rot.X, pframe1rot.Y, pframe1rot.Z, pframe1rot.W);
+            IndexedMatrix frame1 = IndexedMatrix.CreateFromQuaternion(frame1rot);
+            frame1._origin = frame1v;
+
+            IndexedVector3 frame2v = new IndexedVector3(pframe2.X, pframe2.Y, pframe2.Z);
+            IndexedQuaternion frame2rot = new IndexedQuaternion(pframe2rot.X, pframe2rot.Y, pframe2rot.Z, pframe2rot.W);
+            IndexedMatrix frame2 = IndexedMatrix.CreateFromQuaternion(frame2rot);
+            frame2._origin = frame1v;
+
+            constrain = new Generic6DofSpringConstraint(body1, body2, ref frame1, ref frame2, puseLinearReferenceFrameA);
+            world.AddConstraint(constrain, pdisableCollisionsBetweenLinkedBodies);
+
+            constrain.CalculateTransforms();
+        }
+
+        return new BulletConstraintXNA(constrain);
+    }
+
+    public override BulletConstraint CreateHingeConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
+                        Vector3 ppivotInA, Vector3 ppivotInB, Vector3 paxisInA, Vector3 paxisInB,
+                        bool puseLinearReferenceFrameA, bool pdisableCollisionsBetweenLinkedBodies)
+    {
+        HingeConstraint constrain = null;
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody rb1 = (pBody1 as BulletBodyXNA).rigidBody;
+        RigidBody rb2 = (pBody2 as BulletBodyXNA).rigidBody;
+        if (rb1 != null && rb2 != null)
+        {
+            IndexedVector3 pivotInA = new IndexedVector3(ppivotInA.X, ppivotInA.Y, ppivotInA.Z);
+            IndexedVector3 pivotInB = new IndexedVector3(ppivotInB.X, ppivotInB.Y, ppivotInB.Z);
+            IndexedVector3 axisInA = new IndexedVector3(paxisInA.X, paxisInA.Y, paxisInA.Z);
+            IndexedVector3 axisInB = new IndexedVector3(paxisInB.X, paxisInB.Y, paxisInB.Z);
+            constrain = new HingeConstraint(rb1, rb2, ref pivotInA, ref pivotInB, ref axisInA, ref axisInB, puseLinearReferenceFrameA);
+            world.AddConstraint(constrain, pdisableCollisionsBetweenLinkedBodies);
+        }
+        return new BulletConstraintXNA(constrain);
+    }
+
+    public override BulletConstraint CreateSliderConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
+                        Vector3 pframe1, Quaternion pframe1rot,
+                        Vector3 pframe2, Quaternion pframe2rot,
+                        bool puseLinearReferenceFrameA, bool pdisableCollisionsBetweenLinkedBodies)
+    {
+        SliderConstraint constrain = null;
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody rb1 = (pBody1 as BulletBodyXNA).rigidBody;
+        RigidBody rb2 = (pBody2 as BulletBodyXNA).rigidBody;
+        if (rb1 != null && rb2 != null)
+        {
+            IndexedVector3 frame1v = new IndexedVector3(pframe1.X, pframe1.Y, pframe1.Z);
+            IndexedQuaternion frame1rot = new IndexedQuaternion(pframe1rot.X, pframe1rot.Y, pframe1rot.Z, pframe1rot.W);
+            IndexedMatrix frame1 = IndexedMatrix.CreateFromQuaternion(frame1rot);
+            frame1._origin = frame1v;
+
+            IndexedVector3 frame2v = new IndexedVector3(pframe2.X, pframe2.Y, pframe2.Z);
+            IndexedQuaternion frame2rot = new IndexedQuaternion(pframe2rot.X, pframe2rot.Y, pframe2rot.Z, pframe2rot.W);
+            IndexedMatrix frame2 = IndexedMatrix.CreateFromQuaternion(frame2rot);
+            frame2._origin = frame1v;
+
+            constrain = new SliderConstraint(rb1, rb2, ref frame1, ref frame2, puseLinearReferenceFrameA);
+            world.AddConstraint(constrain, pdisableCollisionsBetweenLinkedBodies);
+        }
+        return new BulletConstraintXNA(constrain);
+    }
+
+    public override BulletConstraint CreateConeTwistConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
+                        Vector3 pframe1, Quaternion pframe1rot,
+                        Vector3 pframe2, Quaternion pframe2rot,
+                        bool pdisableCollisionsBetweenLinkedBodies)
+    {
+        ConeTwistConstraint constrain = null;
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody rb1 = (pBody1 as BulletBodyXNA).rigidBody;
+        RigidBody rb2 = (pBody2 as BulletBodyXNA).rigidBody;
+        if (rb1 != null && rb2 != null)
+        {
+            IndexedVector3 frame1v = new IndexedVector3(pframe1.X, pframe1.Y, pframe1.Z);
+            IndexedQuaternion frame1rot = new IndexedQuaternion(pframe1rot.X, pframe1rot.Y, pframe1rot.Z, pframe1rot.W);
+            IndexedMatrix frame1 = IndexedMatrix.CreateFromQuaternion(frame1rot);
+            frame1._origin = frame1v;
+
+            IndexedVector3 frame2v = new IndexedVector3(pframe2.X, pframe2.Y, pframe2.Z);
+            IndexedQuaternion frame2rot = new IndexedQuaternion(pframe2rot.X, pframe2rot.Y, pframe2rot.Z, pframe2rot.W);
+            IndexedMatrix frame2 = IndexedMatrix.CreateFromQuaternion(frame2rot);
+            frame2._origin = frame1v;
+
+            constrain = new ConeTwistConstraint(rb1, rb2, ref frame1, ref frame2);
+            world.AddConstraint(constrain, pdisableCollisionsBetweenLinkedBodies);
+        }
+        return new BulletConstraintXNA(constrain);
+    }
+
+    public override BulletConstraint CreateGearConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
+                        Vector3 paxisInA, Vector3 paxisInB,
+                        float pratio, bool pdisableCollisionsBetweenLinkedBodies)
+    {
+        Generic6DofConstraint constrain = null;
+        /*   BulletXNA does not have a gear constraint
+        GearConstraint constrain = null;
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody rb1 = (pBody1 as BulletBodyXNA).rigidBody;
+        RigidBody rb2 = (pBody2 as BulletBodyXNA).rigidBody;
+        if (rb1 != null && rb2 != null)
+        {
+            IndexedVector3 axis1 = new IndexedVector3(paxisInA.X, paxisInA.Y, paxisInA.Z);
+            IndexedVector3 axis2 = new IndexedVector3(paxisInB.X, paxisInB.Y, paxisInB.Z);
+            constrain = new GearConstraint(rb1, rb2, ref axis1, ref axis2, pratio);
+            world.AddConstraint(constrain, pdisableCollisionsBetweenLinkedBodies);
+        }
+        */
+        return new BulletConstraintXNA(constrain);
+    }
+
+    public override BulletConstraint CreatePoint2PointConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
+                        Vector3 ppivotInA, Vector3 ppivotInB,
+                        bool pdisableCollisionsBetweenLinkedBodies)
+    {
+        Point2PointConstraint constrain = null;
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody rb1 = (pBody1 as BulletBodyXNA).rigidBody;
+        RigidBody rb2 = (pBody2 as BulletBodyXNA).rigidBody;
+        if (rb1 != null && rb2 != null)
+        {
+            IndexedVector3 pivotInA = new IndexedVector3(ppivotInA.X, ppivotInA.Y, ppivotInA.Z);
+            IndexedVector3 pivotInB = new IndexedVector3(ppivotInB.X, ppivotInB.Y, ppivotInB.Z);
+            constrain = new Point2PointConstraint(rb1, rb2, ref pivotInA, ref pivotInB);
+            world.AddConstraint(constrain, pdisableCollisionsBetweenLinkedBodies);
+        }
+        return new BulletConstraintXNA(constrain);
+    }
+
+    public override BulletShape CreateHullShape(BulletWorld pWorld, int pHullCount, float[] pConvHulls)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        CompoundShape compoundshape = new CompoundShape(false);
+
+        compoundshape.SetMargin(world.WorldSettings.Params.collisionMargin);
+        int ii = 1;
+
+        for (int i = 0; i < pHullCount; i++)
+        {
+            int vertexCount = (int) pConvHulls[ii];
+
+            IndexedVector3 centroid = new IndexedVector3(pConvHulls[ii + 1], pConvHulls[ii + 2], pConvHulls[ii + 3]);
+            IndexedMatrix childTrans = IndexedMatrix.Identity;
+            childTrans._origin = centroid;
+
+            List<IndexedVector3> virts = new List<IndexedVector3>();
+            int ender = ((ii + 4) + (vertexCount*3));
+            for (int iii = ii + 4; iii < ender; iii+=3)
+            {
+
+                virts.Add(new IndexedVector3(pConvHulls[iii], pConvHulls[iii + 1], pConvHulls[iii +2]));
+            }
+            ConvexHullShape convexShape = new ConvexHullShape(virts, vertexCount);
+            convexShape.SetMargin(world.WorldSettings.Params.collisionMargin);
+            compoundshape.AddChildShape(ref childTrans, convexShape);
+            ii += (vertexCount*3 + 4);
+        }
+
+        return new BulletShapeXNA(compoundshape, BSPhysicsShapeType.SHAPE_HULL);
+    }
+
+    public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms)
+    {
+        /* TODO */ return null;
+    }
+
+    public override BulletShape BuildConvexHullShapeFromMesh(BulletWorld world, BulletShape meshShape)
+    {
+        /* TODO */ return null;
+    }
+
+    public override BulletShape CreateConvexHullShape(BulletWorld pWorld, int pIndicesCount, int[] indices, int pVerticesCount, float[] verticesAsFloats)
+    {
+        /* TODO */ return null;
+    }
+
+    public override BulletShape CreateMeshShape(BulletWorld pWorld, int pIndicesCount, int[] indices, int pVerticesCount, float[] verticesAsFloats)
+    {
+        //DumpRaw(indices,verticesAsFloats,pIndicesCount,pVerticesCount);
+
+        for (int iter = 0; iter < pVerticesCount; iter++)
+        {
+            if (verticesAsFloats[iter] > 0 && verticesAsFloats[iter] < 0.0001) verticesAsFloats[iter] = 0;
+            if (verticesAsFloats[iter] < 0 && verticesAsFloats[iter] > -0.0001) verticesAsFloats[iter] = 0;
+        }
+
+        ObjectArray<int> indicesarr = new ObjectArray<int>(indices);
+        ObjectArray<float> vertices = new ObjectArray<float>(verticesAsFloats);
+        DumpRaw(indicesarr,vertices,pIndicesCount,pVerticesCount);
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        IndexedMesh mesh = new IndexedMesh();
+        mesh.m_indexType = PHY_ScalarType.PHY_INTEGER;
+        mesh.m_numTriangles = pIndicesCount/3;
+        mesh.m_numVertices = pVerticesCount;
+        mesh.m_triangleIndexBase = indicesarr;
+        mesh.m_vertexBase = vertices;
+        mesh.m_vertexStride = 3;
+        mesh.m_vertexType = PHY_ScalarType.PHY_FLOAT;
+        mesh.m_triangleIndexStride = 3;
+
+        TriangleIndexVertexArray tribuilder = new TriangleIndexVertexArray();
+        tribuilder.AddIndexedMesh(mesh, PHY_ScalarType.PHY_INTEGER);
+        BvhTriangleMeshShape meshShape = new BvhTriangleMeshShape(tribuilder, true,true);
+        meshShape.SetMargin(world.WorldSettings.Params.collisionMargin);
+       // world.UpdateSingleAabb(meshShape);
+        return new BulletShapeXNA(meshShape, BSPhysicsShapeType.SHAPE_MESH);
+
+    }
+    public override BulletShape CreateGImpactShape(BulletWorld pWorld, int pIndicesCount, int[] indices, int pVerticesCount, float[] verticesAsFloats)
+    {
+        // TODO:
+        return null;
+    }
+    public static void DumpRaw(ObjectArray<int>indices, ObjectArray<float> vertices, int pIndicesCount,int pVerticesCount )
+    {
+
+        String fileName = "objTest3.raw";
+        String completePath = System.IO.Path.Combine(Util.configDir(), fileName);
+        StreamWriter sw = new StreamWriter(completePath);
+        IndexedMesh mesh = new IndexedMesh();
+
+        mesh.m_indexType = PHY_ScalarType.PHY_INTEGER;
+        mesh.m_numTriangles = pIndicesCount / 3;
+        mesh.m_numVertices = pVerticesCount;
+        mesh.m_triangleIndexBase = indices;
+        mesh.m_vertexBase = vertices;
+        mesh.m_vertexStride = 3;
+        mesh.m_vertexType = PHY_ScalarType.PHY_FLOAT;
+        mesh.m_triangleIndexStride = 3;
+
+        TriangleIndexVertexArray tribuilder = new TriangleIndexVertexArray();
+        tribuilder.AddIndexedMesh(mesh, PHY_ScalarType.PHY_INTEGER);
+
+
+
+        for (int i = 0; i < pVerticesCount; i++)
+        {
+
+            string s = vertices[indices[i * 3]].ToString("0.0000");
+            s += " " + vertices[indices[i * 3 + 1]].ToString("0.0000");
+            s += " " + vertices[indices[i * 3 + 2]].ToString("0.0000");
+
+            sw.Write(s + "\n");
+        }
+
+        sw.Close();
+    }
+    public static void DumpRaw(int[] indices, float[] vertices, int pIndicesCount, int pVerticesCount)
+    {
+
+        String fileName = "objTest6.raw";
+        String completePath = System.IO.Path.Combine(Util.configDir(), fileName);
+        StreamWriter sw = new StreamWriter(completePath);
+        IndexedMesh mesh = new IndexedMesh();
+
+        mesh.m_indexType = PHY_ScalarType.PHY_INTEGER;
+        mesh.m_numTriangles = pIndicesCount / 3;
+        mesh.m_numVertices = pVerticesCount;
+        mesh.m_triangleIndexBase = indices;
+        mesh.m_vertexBase = vertices;
+        mesh.m_vertexStride = 3;
+        mesh.m_vertexType = PHY_ScalarType.PHY_FLOAT;
+        mesh.m_triangleIndexStride = 3;
+
+        TriangleIndexVertexArray tribuilder = new TriangleIndexVertexArray();
+        tribuilder.AddIndexedMesh(mesh, PHY_ScalarType.PHY_INTEGER);
+
+
+        sw.WriteLine("Indices");
+        sw.WriteLine(string.Format("int[] indices = new int[{0}];",pIndicesCount));
+        for (int iter = 0; iter < indices.Length; iter++)
+        {
+            sw.WriteLine(string.Format("indices[{0}]={1};",iter,indices[iter]));
+        }
+        sw.WriteLine("VerticesFloats");
+        sw.WriteLine(string.Format("float[] vertices = new float[{0}];", pVerticesCount));
+        for (int iter = 0; iter < vertices.Length; iter++)
+        {
+            sw.WriteLine(string.Format("Vertices[{0}]={1};", iter, vertices[iter].ToString("0.0000")));
+        }
+
+            // for (int i = 0; i < pVerticesCount; i++)
+            // {
+            //
+            //     string s = vertices[indices[i * 3]].ToString("0.0000");
+            //     s += " " + vertices[indices[i * 3 + 1]].ToString("0.0000");
+            //    s += " " + vertices[indices[i * 3 + 2]].ToString("0.0000");
+            //
+            //     sw.Write(s + "\n");
+            //}
+
+            sw.Close();
+    }
+
+    public override BulletShape CreateTerrainShape(uint id, Vector3 size, float minHeight, float maxHeight, float[] heightMap,
+                                                                float scaleFactor, float collisionMargin)
+    {
+        const int upAxis = 2;
+        HeightfieldTerrainShape terrainShape = new HeightfieldTerrainShape((int)size.X, (int)size.Y,
+                                                                           heightMap,  scaleFactor,
+                                                                           minHeight, maxHeight, upAxis,
+                                                                            false);
+        terrainShape.SetMargin(collisionMargin);
+        terrainShape.SetUseDiamondSubdivision(true);
+        terrainShape.SetUserPointer(id);
+        return new BulletShapeXNA(terrainShape, BSPhysicsShapeType.SHAPE_TERRAIN);
+    }
+
+    public override bool TranslationalLimitMotor(BulletConstraint pConstraint, float ponOff, float targetVelocity, float maxMotorForce)
+    {
+        TypedConstraint tconstrain = (pConstraint as BulletConstraintXNA).constrain;
+        bool onOff = ponOff != 0;
+        bool ret = false;
+
+        switch (tconstrain.GetConstraintType())
+        {
+            case TypedConstraintType.D6_CONSTRAINT_TYPE:
+                Generic6DofConstraint constrain = tconstrain as Generic6DofConstraint;
+                constrain.GetTranslationalLimitMotor().m_enableMotor[0] = onOff;
+                constrain.GetTranslationalLimitMotor().m_targetVelocity[0] = targetVelocity;
+                constrain.GetTranslationalLimitMotor().m_maxMotorForce[0] = maxMotorForce;
+                ret = true;
+                break;
+        }
+
+
+        return ret;
+
+    }
+
+    public override int PhysicsStep(BulletWorld world, float timeStep, int maxSubSteps, float fixedTimeStep,
+                        out int updatedEntityCount, out int collidersCount)
+    {
+        /* TODO */
+        updatedEntityCount = 0;
+        collidersCount = 0;
+
+
+        int ret = PhysicsStep2(world,timeStep,maxSubSteps,fixedTimeStep,out updatedEntityCount,out world.physicsScene.m_updateArray, out collidersCount, out world.physicsScene.m_collisionArray);
+
+        return ret;
+    }
+
+    private int PhysicsStep2(BulletWorld pWorld, float timeStep, int m_maxSubSteps, float m_fixedTimeStep,
+                    out int updatedEntityCount, out EntityProperties[] updatedEntities,
+                    out int collidersCount, out CollisionDesc[] colliders)
+    {
+        int epic = PhysicsStepint(pWorld, timeStep, m_maxSubSteps, m_fixedTimeStep, out updatedEntityCount, out updatedEntities,
+                                out collidersCount, out colliders, m_maxCollisions, m_maxUpdatesPerFrame);
+        return epic;
+    }
+
+    private int PhysicsStepint(BulletWorld pWorld,float timeStep, int m_maxSubSteps, float m_fixedTimeStep, out int updatedEntityCount,
+        out  EntityProperties[] updatedEntities, out int collidersCount, out CollisionDesc[] colliders, int maxCollisions, int maxUpdates)
+    {
+        int numSimSteps = 0;
+        Array.Clear(UpdatedObjects, 0, UpdatedObjects.Length);
+        Array.Clear(UpdatedCollisions, 0, UpdatedCollisions.Length);
+        LastEntityProperty=0;
+
+
+
+
+
+
+        LastCollisionDesc=0;
+
+        updatedEntityCount = 0;
+        collidersCount = 0;
+
+
+        if (pWorld is BulletWorldXNA)
+        {
+            DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+
+            world.LastCollisionDesc = 0;
+            world.LastEntityProperty = 0;
+            numSimSteps = world.StepSimulation(timeStep, m_maxSubSteps, m_fixedTimeStep);
+
+            PersistentManifold contactManifold;
+            CollisionObject objA;
+            CollisionObject objB;
+            ManifoldPoint manifoldPoint;
+            PairCachingGhostObject pairCachingGhostObject;
+
+            m_collisionsThisFrame = 0;
+            int numManifolds = world.GetDispatcher().GetNumManifolds();
+            for (int j = 0; j < numManifolds; j++)
+            {
+                contactManifold = world.GetDispatcher().GetManifoldByIndexInternal(j);
+                int numContacts = contactManifold.GetNumContacts();
+                if (numContacts == 0)
+                    continue;
+
+                objA = contactManifold.GetBody0() as CollisionObject;
+                objB = contactManifold.GetBody1() as CollisionObject;
+
+                manifoldPoint = contactManifold.GetContactPoint(0);
+                //IndexedVector3 contactPoint = manifoldPoint.GetPositionWorldOnB();
+               // IndexedVector3 contactNormal = -manifoldPoint.m_normalWorldOnB; // make relative to A
+
+                RecordCollision(this, objA, objB, manifoldPoint.GetPositionWorldOnB(), -manifoldPoint.m_normalWorldOnB, manifoldPoint.GetDistance());
+                m_collisionsThisFrame ++;
+                if (m_collisionsThisFrame >= 9999999)
+                    break;
+
+
+            }
+
+            foreach (GhostObject ghostObject in specialCollisionObjects.Values)
+            {
+                pairCachingGhostObject = ghostObject as PairCachingGhostObject;
+                if (pairCachingGhostObject != null)
+                {
+                    RecordGhostCollisions(pairCachingGhostObject);
+                }
+
+            }
+
+
+            updatedEntityCount = LastEntityProperty;
+            updatedEntities = UpdatedObjects;
+
+            collidersCount = LastCollisionDesc;
+            colliders = UpdatedCollisions;
+
+
+        }
+        else
+        {
+            //if (updatedEntities is null)
+            //updatedEntities = new List<BulletXNA.EntityProperties>();
+            //updatedEntityCount = 0;
+
+
+            //collidersCount = 0;
+
+            updatedEntities = new EntityProperties[0];
+
+
+            colliders = new CollisionDesc[0];
+
+        }
+        return numSimSteps;
+    }
+    public void RecordGhostCollisions(PairCachingGhostObject obj)
+    {
+        IOverlappingPairCache cache = obj.GetOverlappingPairCache();
+        ObjectArray<BroadphasePair> pairs = cache.GetOverlappingPairArray();
+
+        DiscreteDynamicsWorld world = (PhysicsScene.World as BulletWorldXNA).world;
+        PersistentManifoldArray manifoldArray = new PersistentManifoldArray();
+        BroadphasePair collisionPair;
+        PersistentManifold contactManifold;
+
+        CollisionObject objA;
+        CollisionObject objB;
+
+        ManifoldPoint pt;
+
+        int numPairs = pairs.Count;
+
+        for (int i = 0; i < numPairs; i++)
+        {
+            manifoldArray.Clear();
+            if (LastCollisionDesc < UpdatedCollisions.Length)
+                break;
+            collisionPair = world.GetPairCache().FindPair(pairs[i].m_pProxy0, pairs[i].m_pProxy1);
+            if (collisionPair == null)
+                continue;
+
+            collisionPair.m_algorithm.GetAllContactManifolds(manifoldArray);
+            for (int j = 0; j < manifoldArray.Count; j++)
+            {
+                contactManifold = manifoldArray[j];
+                int numContacts = contactManifold.GetNumContacts();
+                objA = contactManifold.GetBody0() as CollisionObject;
+                objB = contactManifold.GetBody1() as CollisionObject;
+                for (int p = 0; p < numContacts; p++)
+                {
+                    pt = contactManifold.GetContactPoint(p);
+                    if (pt.GetDistance() < 0.0f)
+                    {
+                        RecordCollision(this, objA, objB, pt.GetPositionWorldOnA(), -pt.m_normalWorldOnB,pt.GetDistance());
+                        break;
+                    }
+                }
+            }
+        }
+
+    }
+    private static void RecordCollision(BSAPIXNA world, CollisionObject objA, CollisionObject objB, IndexedVector3 contact, IndexedVector3 norm, float penetration)
+    {
+
+        IndexedVector3 contactNormal = norm;
+        if ((objA.GetCollisionFlags() & BulletXNA.BulletCollision.CollisionFlags.BS_WANTS_COLLISIONS) == 0 &&
+            (objB.GetCollisionFlags() & BulletXNA.BulletCollision.CollisionFlags.BS_WANTS_COLLISIONS) == 0)
+        {
+            return;
+        }
+        uint idA = (uint)objA.GetUserPointer();
+        uint idB = (uint)objB.GetUserPointer();
+        if (idA > idB)
+        {
+            uint temp = idA;
+            idA = idB;
+            idB = temp;
+            contactNormal = -contactNormal;
+        }
+
+        //ulong collisionID = ((ulong) idA << 32) | idB;
+
+        CollisionDesc cDesc = new CollisionDesc()
+                                            {
+                                                aID = idA,
+                                                bID = idB,
+                                                point = new Vector3(contact.X,contact.Y,contact.Z),
+                                                normal = new Vector3(contactNormal.X,contactNormal.Y,contactNormal.Z),
+                                                penetration = penetration
+
+                                            };
+        if (world.LastCollisionDesc < world.UpdatedCollisions.Length)
+            world.UpdatedCollisions[world.LastCollisionDesc++] = (cDesc);
+        m_collisionsThisFrame++;
+
+
+    }
+    private static EntityProperties GetDebugProperties(BulletWorld pWorld, BulletBody pCollisionObject)
+    {
+        EntityProperties ent = new EntityProperties();
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
+        IndexedMatrix transform = collisionObject.GetWorldTransform();
+        IndexedVector3 LinearVelocity = collisionObject.GetInterpolationLinearVelocity();
+        IndexedVector3 AngularVelocity = collisionObject.GetInterpolationAngularVelocity();
+        IndexedQuaternion rotation = transform.GetRotation();
+        ent.Acceleration = Vector3.Zero;
+        ent.ID = (uint)collisionObject.GetUserPointer();
+        ent.Position = new Vector3(transform._origin.X,transform._origin.Y,transform._origin.Z);
+        ent.Rotation = new Quaternion(rotation.X,rotation.Y,rotation.Z,rotation.W);
+        ent.Velocity = new Vector3(LinearVelocity.X, LinearVelocity.Y, LinearVelocity.Z);
+        ent.RotationalVelocity = new Vector3(AngularVelocity.X, AngularVelocity.Y, AngularVelocity.Z);
+        return ent;
+    }
+
+    public override bool UpdateParameter(BulletWorld world, uint localID, String parm, float value) { /* TODO */
+        return false; }
+
+    public override Vector3 GetLocalScaling(BulletShape pShape)
+    {
+        CollisionShape shape = (pShape as BulletShapeXNA).shape;
+        IndexedVector3 scale = shape.GetLocalScaling();
+        return new Vector3(scale.X,scale.Y,scale.Z);
+    }
+
+    public bool RayCastGround(BulletWorld pWorld, Vector3 _RayOrigin, float pRayHeight, BulletBody NotMe)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        if (world != null)
+        {
+            if (NotMe is BulletBodyXNA && NotMe.HasPhysicalBody)
+            {
+                CollisionObject AvoidBody = (NotMe as BulletBodyXNA).body;
+
+                IndexedVector3 rOrigin = new IndexedVector3(_RayOrigin.X, _RayOrigin.Y, _RayOrigin.Z);
+                IndexedVector3 rEnd = new IndexedVector3(_RayOrigin.X, _RayOrigin.Y, _RayOrigin.Z - pRayHeight);
+                using (
+                    ClosestNotMeRayResultCallback rayCallback =
+                                            new ClosestNotMeRayResultCallback(rOrigin, rEnd, AvoidBody)
+                    )
+                {
+                    world.RayTest(ref rOrigin, ref rEnd, rayCallback);
+                    if (rayCallback.HasHit())
+                    {
+                        IndexedVector3 hitLocation = rayCallback.m_hitPointWorld;
+                    }
+                    return rayCallback.HasHit();
+                }
+           }
+        }
+        return false;
+    }
+}
+
+
+
+
+    public class SimMotionState : DefaultMotionState
+    {
+        public RigidBody Rigidbody;
+        public Vector3 ZeroVect;
+
+        private IndexedMatrix m_xform;
+
+        private EntityProperties m_properties;
+        private EntityProperties m_lastProperties;
+        private BSAPIXNA m_world;
+
+        const float POSITION_TOLERANCE = 0.05f;
+        const float VELOCITY_TOLERANCE = 0.001f;
+        const float ROTATION_TOLERANCE = 0.01f;
+        const float ANGULARVELOCITY_TOLERANCE = 0.01f;
+
+        public SimMotionState(BSAPIXNA pWorld, uint id, IndexedMatrix starTransform, object frameUpdates)
+        {
+            IndexedQuaternion OrientationQuaterion = starTransform.GetRotation();
+            m_properties = new EntityProperties()
+                               {
+                                   ID = id,
+                                   Position = new Vector3(starTransform._origin.X, starTransform._origin.Y,starTransform._origin.Z),
+                                   Rotation = new Quaternion(OrientationQuaterion.X,OrientationQuaterion.Y,OrientationQuaterion.Z,OrientationQuaterion.W)
+                               };
+            m_lastProperties = new EntityProperties()
+            {
+                ID = id,
+                Position = new Vector3(starTransform._origin.X, starTransform._origin.Y, starTransform._origin.Z),
+                Rotation = new Quaternion(OrientationQuaterion.X, OrientationQuaterion.Y, OrientationQuaterion.Z, OrientationQuaterion.W)
+            };
+            m_world = pWorld;
+            m_xform = starTransform;
+        }
+
+        public override void GetWorldTransform(out IndexedMatrix worldTrans)
+        {
+            worldTrans = m_xform;
+        }
+
+        public override void SetWorldTransform(IndexedMatrix worldTrans)
+        {
+            SetWorldTransform(ref worldTrans);
+        }
+
+        public override void SetWorldTransform(ref IndexedMatrix worldTrans)
+        {
+            SetWorldTransform(ref worldTrans, false);
+        }
+        public void SetWorldTransform(ref IndexedMatrix worldTrans, bool force)
+        {
+            m_xform = worldTrans;
+            // Put the new transform into m_properties
+            IndexedQuaternion OrientationQuaternion = m_xform.GetRotation();
+            IndexedVector3 LinearVelocityVector = Rigidbody.GetLinearVelocity();
+            IndexedVector3 AngularVelocityVector = Rigidbody.GetAngularVelocity();
+            m_properties.Position = new Vector3(m_xform._origin.X, m_xform._origin.Y, m_xform._origin.Z);
+            m_properties.Rotation = new Quaternion(OrientationQuaternion.X, OrientationQuaternion.Y,
+                                                   OrientationQuaternion.Z, OrientationQuaternion.W);
+            // A problem with stock Bullet is that we don't get an event when an object is deactivated.
+            // This means that the last non-zero values for linear and angular velocity
+            // are left in the viewer who does dead reconning and the objects look like
+            // they float off.
+            // BulletSim ships with a patch to Bullet which creates such an event.
+            m_properties.Velocity = new Vector3(LinearVelocityVector.X, LinearVelocityVector.Y, LinearVelocityVector.Z);
+            m_properties.RotationalVelocity = new Vector3(AngularVelocityVector.X, AngularVelocityVector.Y, AngularVelocityVector.Z);
+
+            if (force
+
+                || !AlmostEqual(ref m_lastProperties.Position, ref m_properties.Position, POSITION_TOLERANCE)
+                || !AlmostEqual(ref m_properties.Rotation, ref m_lastProperties.Rotation, ROTATION_TOLERANCE)
+                // If the Velocity and AngularVelocity are zero, most likely the object has
+                //    been deactivated. If they both are zero and they have become zero recently,
+                //    make sure a property update is sent so the zeros make it to the viewer.
+                || ((m_properties.Velocity == ZeroVect && m_properties.RotationalVelocity == ZeroVect)
+                    &&
+                    (m_properties.Velocity != m_lastProperties.Velocity ||
+                     m_properties.RotationalVelocity != m_lastProperties.RotationalVelocity))
+                //      If Velocity and AngularVelocity are non-zero but have changed, send an update.
+                || !AlmostEqual(ref m_properties.Velocity, ref m_lastProperties.Velocity, VELOCITY_TOLERANCE)
+                ||
+                !AlmostEqual(ref m_properties.RotationalVelocity, ref m_lastProperties.RotationalVelocity,
+                             ANGULARVELOCITY_TOLERANCE)
+                )
+
+
+            {
+                // Add this update to the list of updates for this frame.
+                m_lastProperties = m_properties;
+                if (m_world.LastEntityProperty < m_world.UpdatedObjects.Length)
+                    m_world.UpdatedObjects[m_world.LastEntityProperty++]=(m_properties);
+
+                //(*m_updatesThisFrame)[m_properties.ID] = &m_properties;
+            }
+
+
+
+
+        }
+        public override void SetRigidBody(RigidBody body)
+        {
+            Rigidbody = body;
+        }
+        internal static bool AlmostEqual(ref Vector3 v1, ref Vector3 v2, float nEpsilon)
+        {
+            return
+            (((v1.X - nEpsilon) < v2.X) && (v2.X < (v1.X + nEpsilon))) &&
+            (((v1.Y - nEpsilon) < v2.Y) && (v2.Y < (v1.Y + nEpsilon))) &&
+            (((v1.Z - nEpsilon) < v2.Z) && (v2.Z < (v1.Z + nEpsilon)));
+        }
+
+        internal static bool AlmostEqual(ref Quaternion v1, ref Quaternion v2, float nEpsilon)
+        {
+            return
+            (((v1.X - nEpsilon) < v2.X) && (v2.X < (v1.X + nEpsilon))) &&
+            (((v1.Y - nEpsilon) < v2.Y) && (v2.Y < (v1.Y + nEpsilon))) &&
+            (((v1.Z - nEpsilon) < v2.Z) && (v2.Z < (v1.Z + nEpsilon))) &&
+            (((v1.W - nEpsilon) < v2.W) && (v2.W < (v1.W + nEpsilon)));
+        }
+
+    }
+}
+
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorAvatarMove.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorAvatarMove.cs
new file mode 100755
index 0000000..0191893
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorAvatarMove.cs
@@ -0,0 +1,457 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public class BSActorAvatarMove : BSActor
+{
+    BSVMotor m_velocityMotor;
+
+    // Set to true if we think we're going up stairs.
+    //    This state is remembered because collisions will turn on and off as we go up stairs.
+    int m_walkingUpStairs;
+    // The amount the step up is applying. Used to smooth stair walking.
+    float m_lastStepUp;
+
+    // Jumping happens over several frames. If use applies up force while colliding, start the
+    //    jump and allow the jump to continue for this number of frames.
+    int m_jumpFrames = 0;
+    float m_jumpVelocity = 0f;
+
+    public BSActorAvatarMove(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_velocityMotor = null;
+        m_walkingUpStairs = 0;
+        m_physicsScene.DetailLog("{0},BSActorAvatarMove,constructor", m_controllingPrim.LocalID);
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        base.SetEnabled(false);
+        DeactivateAvatarMove();
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorAvatarMove,refresh", m_controllingPrim.LocalID);
+
+        // If the object is physically active, add the hoverer prestep action
+        if (isActive)
+        {
+            ActivateAvatarMove();
+        }
+        else
+        {
+            DeactivateAvatarMove();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        // Nothing to do for the hoverer since it is all software at pre-step action time.
+    }
+
+    // Usually called when target velocity changes to set the current velocity and the target
+    //     into the movement motor.
+    public void SetVelocityAndTarget(OMV.Vector3 vel, OMV.Vector3 targ, bool inTaintTime)
+    {
+        m_physicsScene.TaintedObject(inTaintTime, m_controllingPrim.LocalID, "BSActorAvatarMove.setVelocityAndTarget", delegate()
+        {
+            if (m_velocityMotor != null)
+            {
+//                    if (targ == OMV.Vector3.Zero)
+//                        Util.PrintCallStack();
+//
+//                    Console.WriteLine("SetVelocityAndTarget, {0} {1}", vel, targ);
+                m_velocityMotor.Reset();
+                m_velocityMotor.SetTarget(targ);
+                m_velocityMotor.SetCurrent(vel);
+                m_velocityMotor.Enabled = true;
+            }
+        });
+    }
+
+    // If a hover motor has not been created, create one and start the hovering.
+    private void ActivateAvatarMove()
+    {
+        if (m_velocityMotor == null)
+        {
+            // Infinite decay and timescale values so motor only changes current to target values.
+            m_velocityMotor = new BSVMotor("BSCharacter.Velocity",
+                                                0.2f,                       // time scale
+                                                BSMotor.Infinite,           // decay time scale
+                                                1f                          // efficiency
+            );
+            m_velocityMotor.ErrorZeroThreshold = BSParam.AvatarStopZeroThreshold;
+            // _velocityMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG so motor will output detail log messages.
+            SetVelocityAndTarget(m_controllingPrim.RawVelocity, m_controllingPrim.TargetVelocity, true /* inTaintTime */);
+
+            m_physicsScene.BeforeStep += Mover;
+            m_controllingPrim.OnPreUpdateProperty += Process_OnPreUpdateProperty;
+
+            m_walkingUpStairs = 0;
+        }
+    }
+
+    private void DeactivateAvatarMove()
+    {
+        if (m_velocityMotor != null)
+        {
+            m_controllingPrim.OnPreUpdateProperty -= Process_OnPreUpdateProperty;
+            m_physicsScene.BeforeStep -= Mover;
+            m_velocityMotor = null;
+        }
+    }
+
+    // Called just before the simulation step. Update the vertical position for hoverness.
+    private void Mover(float timeStep)
+    {
+        // Don't do movement while the object is selected.
+        if (!isActive)
+            return;
+
+        // TODO: Decide if the step parameters should be changed depending on the avatar's
+        //     state (flying, colliding, ...). There is code in ODE to do this.
+
+        // COMMENTARY: when the user is making the avatar walk, except for falling, the velocity
+        //   specified for the avatar is the one that should be used. For falling, if the avatar
+        //   is not flying and is not colliding then it is presumed to be falling and the Z
+        //   component is not fooled with (thus allowing gravity to do its thing).
+        // When the avatar is standing, though, the user has specified a velocity of zero and
+        //   the avatar should be standing. But if the avatar is pushed by something in the world
+        //   (raising elevator platform, moving vehicle, ...) the avatar should be allowed to
+        //   move. Thus, the velocity cannot be forced to zero. The problem is that small velocity
+        //   errors can creap in and the avatar will slowly float off in some direction.
+        // So, the problem is that, when an avatar is standing, we cannot tell creaping error
+        //   from real pushing.
+        // The code below uses whether the collider is static or moving to decide whether to zero motion.
+
+        m_velocityMotor.Step(timeStep);
+        m_controllingPrim.IsStationary = false;
+
+        // If we're not supposed to be moving, make sure things are zero.
+        if (m_velocityMotor.ErrorIsZero() && m_velocityMotor.TargetValue == OMV.Vector3.Zero)
+        {
+            // The avatar shouldn't be moving
+            m_velocityMotor.Zero();
+
+            if (m_controllingPrim.IsColliding)
+            {
+                // If we are colliding with a stationary object, presume we're standing and don't move around
+                if (!m_controllingPrim.ColliderIsMoving && !m_controllingPrim.ColliderIsVolumeDetect)
+                {
+                    m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,collidingWithStationary,zeroingMotion", m_controllingPrim.LocalID);
+                    m_controllingPrim.IsStationary = true;
+                    m_controllingPrim.ZeroMotion(true /* inTaintTime */);
+                }
+
+                // Standing has more friction on the ground
+                if (m_controllingPrim.Friction != BSParam.AvatarStandingFriction)
+                {
+                    m_controllingPrim.Friction = BSParam.AvatarStandingFriction;
+                    m_physicsScene.PE.SetFriction(m_controllingPrim.PhysBody, m_controllingPrim.Friction);
+                }
+            }
+            else
+            {
+                if (m_controllingPrim.Flying)
+                {
+                    // Flying and not colliding and velocity nearly zero.
+                    m_controllingPrim.ZeroMotion(true /* inTaintTime */);
+                }
+                else
+                {
+                    //We are falling but are not touching any keys make sure not falling too fast
+                    if (m_controllingPrim.RawVelocity.Z < BSParam.AvatarTerminalVelocity)
+                    {
+
+                        OMV.Vector3 slowingForce = new OMV.Vector3(0f, 0f, BSParam.AvatarTerminalVelocity - m_controllingPrim.RawVelocity.Z) * m_controllingPrim.Mass;
+                        m_physicsScene.PE.ApplyCentralImpulse(m_controllingPrim.PhysBody, slowingForce);
+                    }
+
+                }
+            }
+
+            m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,taint,stopping,target={1},colliding={2}",
+                            m_controllingPrim.LocalID, m_velocityMotor.TargetValue, m_controllingPrim.IsColliding);
+        }
+        else
+        {
+            // Supposed to be moving.
+            OMV.Vector3 stepVelocity = m_velocityMotor.CurrentValue;
+
+            if (m_controllingPrim.Friction != BSParam.AvatarFriction)
+            {
+                // Probably starting to walk. Set friction to moving friction.
+                m_controllingPrim.Friction = BSParam.AvatarFriction;
+                m_physicsScene.PE.SetFriction(m_controllingPrim.PhysBody, m_controllingPrim.Friction);
+            }
+
+            if (!m_controllingPrim.Flying && !m_controllingPrim.IsColliding)
+            {
+                stepVelocity.Z = m_controllingPrim.RawVelocity.Z;
+            }
+
+            // Colliding and not flying with an upward force. The avatar must be trying to jump.
+            if (!m_controllingPrim.Flying && m_controllingPrim.IsColliding && stepVelocity.Z > 0)
+            {
+                // We allow the upward force to happen for this many frames.
+                m_jumpFrames = BSParam.AvatarJumpFrames;
+                m_jumpVelocity = stepVelocity.Z;
+            }
+
+            // The case where the avatar is not colliding and is not flying is special.
+            // The avatar is either falling or jumping and the user can be applying force to the avatar
+            //     (force in some direction or force up or down).
+            // If the avatar has negative Z velocity and is not colliding, presume we're falling and keep the velocity.
+            // If the user is trying to apply upward force but we're not colliding, assume the avatar
+            //     is trying to jump and don't apply the upward force if not touching the ground any more.
+            if (!m_controllingPrim.Flying && !m_controllingPrim.IsColliding)
+            {
+                // If upward velocity is being applied, this must be a jump and only allow that to go on so long
+                if (m_jumpFrames > 0)
+                {
+                    // Since not touching the ground, only apply upward force for so long.
+                    m_jumpFrames--;
+                    stepVelocity.Z = m_jumpVelocity;
+                }
+                else
+                {
+                    
+                    // Since we're not affected by anything, the avatar must be falling and we do not want that to be too fast.
+                    if (m_controllingPrim.RawVelocity.Z < BSParam.AvatarTerminalVelocity)
+                    {
+                        
+                        stepVelocity.Z = BSParam.AvatarTerminalVelocity;
+                    }
+                    else
+                    {
+                        stepVelocity.Z = m_controllingPrim.RawVelocity.Z;
+                    }
+                }
+                // DetailLog("{0},BSCharacter.MoveMotor,taint,overrideStepZWithWorldZ,stepVel={1}", LocalID, stepVelocity);
+            }
+
+            //Alicia: Maintain minimum height when flying.
+            // SL has a flying effect that keeps the avatar flying above the ground by some margin
+            if (m_controllingPrim.Flying)
+            {
+                float hover_height = m_physicsScene.TerrainManager.GetTerrainHeightAtXYZ(m_controllingPrim.RawPosition)
+                                                        + BSParam.AvatarFlyingGroundMargin;
+
+                if( m_controllingPrim.Position.Z < hover_height)
+                {
+                    stepVelocity.Z += BSParam.AvatarFlyingGroundUpForce;
+                }
+            }
+
+            // 'stepVelocity' is now the speed we'd like the avatar to move in. Turn that into an instantanous force.
+            OMV.Vector3 moveForce = (stepVelocity - m_controllingPrim.RawVelocity) * m_controllingPrim.Mass;
+
+            // Add special movement force to allow avatars to walk up stepped surfaces.
+            moveForce += WalkUpStairs();
+
+            m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,move,stepVel={1},vel={2},mass={3},moveForce={4}",
+                            m_controllingPrim.LocalID, stepVelocity, m_controllingPrim.RawVelocity, m_controllingPrim.Mass, moveForce);
+            m_physicsScene.PE.ApplyCentralImpulse(m_controllingPrim.PhysBody, moveForce);
+        }
+    }
+
+    // Called just as the property update is received from the physics engine.
+    // Do any mode necessary for avatar movement.
+    private void Process_OnPreUpdateProperty(ref EntityProperties entprop)
+    {
+        // Don't change position if standing on a stationary object.
+        if (m_controllingPrim.IsStationary)
+        {
+            entprop.Position = m_controllingPrim.RawPosition;
+            entprop.Velocity = OMV.Vector3.Zero;
+            m_physicsScene.PE.SetTranslation(m_controllingPrim.PhysBody, entprop.Position, entprop.Rotation);
+        }
+
+    }
+
+    // Decide if the character is colliding with a low object and compute a force to pop the
+    //    avatar up so it can walk up and over the low objects.
+    private OMV.Vector3 WalkUpStairs()
+    {
+        OMV.Vector3 ret = OMV.Vector3.Zero;
+
+        m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs,IsColliding={1},flying={2},targSpeed={3},collisions={4},avHeight={5}",
+                        m_controllingPrim.LocalID, m_controllingPrim.IsColliding, m_controllingPrim.Flying,
+                        m_controllingPrim.TargetVelocitySpeed, m_controllingPrim.CollisionsLastTick.Count, m_controllingPrim.Size.Z);
+
+        // Check for stairs climbing if colliding, not flying and moving forward
+        if ( m_controllingPrim.IsColliding
+                    && !m_controllingPrim.Flying
+                    && m_controllingPrim.TargetVelocitySpeed > 0.1f )
+        {
+            // The range near the character's feet where we will consider stairs
+            // float nearFeetHeightMin = m_controllingPrim.RawPosition.Z - (m_controllingPrim.Size.Z / 2f) + 0.05f;
+            // Note: there is a problem with the computation of the capsule height. Thus RawPosition is off
+            //    from the height. Revisit size and this computation when height is scaled properly.
+            float nearFeetHeightMin = m_controllingPrim.RawPosition.Z - (m_controllingPrim.Size.Z / 2f) - BSParam.AvatarStepGroundFudge;
+            float nearFeetHeightMax = nearFeetHeightMin + BSParam.AvatarStepHeight;
+
+            // Look for a collision point that is near the character's feet and is oriented the same as the charactor is.
+            // Find the highest 'good' collision.
+            OMV.Vector3 highestTouchPosition = OMV.Vector3.Zero;
+            foreach (KeyValuePair<uint, ContactPoint> kvp in m_controllingPrim.CollisionsLastTick.m_objCollisionList)
+            {
+                // Don't care about collisions with the terrain
+                if (kvp.Key > m_physicsScene.TerrainManager.HighestTerrainID)
+                {
+                    BSPhysObject collisionObject;
+                    if (m_physicsScene.PhysObjects.TryGetValue(kvp.Key, out collisionObject))
+                    {
+                        if (!collisionObject.IsVolumeDetect)
+                        {
+                            OMV.Vector3 touchPosition = kvp.Value.Position;
+                            m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs,min={1},max={2},touch={3}",
+                                            m_controllingPrim.LocalID, nearFeetHeightMin, nearFeetHeightMax, touchPosition);
+                            if (touchPosition.Z >= nearFeetHeightMin && touchPosition.Z <= nearFeetHeightMax)
+                            {
+                                // This contact is within the 'near the feet' range.
+                                // The step is presumed to be more or less vertical. Thus the Z component should
+                                //    be nearly horizontal.
+                                OMV.Vector3 directionFacing = OMV.Vector3.UnitX * m_controllingPrim.RawOrientation;
+                                OMV.Vector3 touchNormal = OMV.Vector3.Normalize(kvp.Value.SurfaceNormal);
+                                const float PIOver2 = 1.571f; // Used to make unit vector axis into approx radian angles
+                                // m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs,avNormal={1},colNormal={2},diff={3}",
+                                //             m_controllingPrim.LocalID, directionFacing, touchNormal,
+                                //             Math.Abs(OMV.Vector3.Distance(directionFacing, touchNormal)) );
+                                if ((Math.Abs(directionFacing.Z) * PIOver2) < BSParam.AvatarStepAngle
+                                    && (Math.Abs(touchNormal.Z) * PIOver2) < BSParam.AvatarStepAngle)
+                                {
+                                    // The normal should be our contact point to the object so it is pointing away
+                                    //    thus the difference between our facing orientation and the normal should be small.
+                                    float diff = Math.Abs(OMV.Vector3.Distance(directionFacing, touchNormal));
+                                    if (diff < BSParam.AvatarStepApproachFactor)
+                                    {
+                                        if (highestTouchPosition.Z < touchPosition.Z)
+                                            highestTouchPosition = touchPosition;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            m_walkingUpStairs = 0;
+            // If there is a good step sensing, move the avatar over the step.
+            if (highestTouchPosition != OMV.Vector3.Zero)
+            {
+                // Remember that we are going up stairs. This is needed because collisions
+                //    will stop when we move up so this smoothes out that effect.
+                m_walkingUpStairs = BSParam.AvatarStepSmoothingSteps;
+
+                m_lastStepUp = highestTouchPosition.Z - nearFeetHeightMin;
+                ret = ComputeStairCorrection(m_lastStepUp);
+                m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs,touchPos={1},nearFeetMin={2},ret={3}",
+                        m_controllingPrim.LocalID, highestTouchPosition, nearFeetHeightMin, ret);
+            }
+        }
+        else
+        {
+            // If we used to be going up stairs but are not now, smooth the case where collision goes away while
+            //    we are bouncing up the stairs.
+            if (m_walkingUpStairs > 0)
+            {
+                m_walkingUpStairs--;
+                ret = ComputeStairCorrection(m_lastStepUp);
+            }
+        }
+
+        return ret;
+    }
+
+    private OMV.Vector3 ComputeStairCorrection(float stepUp)
+    {
+        OMV.Vector3 ret = OMV.Vector3.Zero;
+        OMV.Vector3 displacement = OMV.Vector3.Zero;
+
+        if (stepUp > 0f)
+        {
+            // Found the stairs contact point. Push up a little to raise the character.
+            if (BSParam.AvatarStepForceFactor > 0f)
+            {
+                float upForce = stepUp * m_controllingPrim.Mass * BSParam.AvatarStepForceFactor;
+                ret = new OMV.Vector3(0f, 0f, upForce);
+            }
+
+            // Also move the avatar up for the new height
+            if (BSParam.AvatarStepUpCorrectionFactor > 0f)
+            {
+                // Move the avatar up related to the height of the collision
+                displacement = new OMV.Vector3(0f, 0f, stepUp * BSParam.AvatarStepUpCorrectionFactor);
+                m_controllingPrim.ForcePosition = m_controllingPrim.RawPosition + displacement;
+            }
+            else
+            {
+                if (BSParam.AvatarStepUpCorrectionFactor < 0f)
+                {
+                    // Move the avatar up about the specified step height
+                    displacement = new OMV.Vector3(0f, 0f, BSParam.AvatarStepHeight);
+                    m_controllingPrim.ForcePosition = m_controllingPrim.RawPosition + displacement;
+                }
+            }
+            m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs.ComputeStairCorrection,stepUp={1},isp={2},force={3}",
+                                        m_controllingPrim.LocalID, stepUp, displacement, ret);
+
+        }
+        return ret;
+    }
+}
+}
+
+
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorHover.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorHover.cs
new file mode 100755
index 0000000..7ff171e
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorHover.cs
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public class BSActorHover : BSActor
+{
+    private BSFMotor m_hoverMotor;
+
+    public BSActorHover(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_hoverMotor = null;
+        m_physicsScene.DetailLog("{0},BSActorHover,constructor", m_controllingPrim.LocalID);
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        get { return Enabled; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        Enabled = false;
+        DeactivateHover();
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorHover,refresh", m_controllingPrim.LocalID);
+
+        // If not active any more, turn me off
+        if (!m_controllingPrim.HoverActive)
+        {
+            SetEnabled(false);
+        }
+
+        // If the object is physically active, add the hoverer prestep action
+        if (isActive)
+        {
+            ActivateHover();
+        }
+        else
+        {
+            DeactivateHover();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        // Nothing to do for the hoverer since it is all software at pre-step action time.
+    }
+
+    // If a hover motor has not been created, create one and start the hovering.
+    private void ActivateHover()
+    {
+        if (m_hoverMotor == null)
+        {
+            // Turning the target on
+            m_hoverMotor = new BSFMotor("BSActorHover",
+                                        m_controllingPrim.HoverTau,               // timeScale
+                                        BSMotor.Infinite,           // decay time scale
+                                        1f                          // efficiency
+            );
+            m_hoverMotor.SetTarget(ComputeCurrentHoverHeight());
+            m_hoverMotor.SetCurrent(m_controllingPrim.RawPosition.Z);
+            m_hoverMotor.PhysicsScene = m_physicsScene; // DEBUG DEBUG so motor will output detail log messages.
+
+            m_physicsScene.BeforeStep += Hoverer;
+        }
+    }
+
+    private void DeactivateHover()
+    {
+        if (m_hoverMotor != null)
+        {
+            m_physicsScene.BeforeStep -= Hoverer;
+            m_hoverMotor = null;
+        }
+    }
+
+    // Called just before the simulation step. Update the vertical position for hoverness.
+    private void Hoverer(float timeStep)
+    {
+        // Don't do hovering while the object is selected.
+        if (!isActive)
+            return;
+
+        m_hoverMotor.SetCurrent(m_controllingPrim.RawPosition.Z);
+        m_hoverMotor.SetTarget(ComputeCurrentHoverHeight());
+        float targetHeight = m_hoverMotor.Step(timeStep);
+
+        // 'targetHeight' is where we'd like the Z of the prim to be at this moment.
+        // Compute the amount of force to push us there.
+        float moveForce = (targetHeight - m_controllingPrim.RawPosition.Z) * m_controllingPrim.RawMass;
+        // Undo anything the object thinks it's doing at the moment
+        moveForce = -m_controllingPrim.RawVelocity.Z * m_controllingPrim.Mass;
+
+        m_physicsScene.PE.ApplyCentralImpulse(m_controllingPrim.PhysBody, new OMV.Vector3(0f, 0f, moveForce));
+        m_physicsScene.DetailLog("{0},BSPrim.Hover,move,targHt={1},moveForce={2},mass={3}",
+                        m_controllingPrim.LocalID, targetHeight, moveForce, m_controllingPrim.RawMass);
+    }
+
+    // Based on current position, determine what we should be hovering at now.
+    // Must recompute often. What if we walked offa cliff>
+    private float ComputeCurrentHoverHeight()
+    {
+        float ret = m_controllingPrim.HoverHeight;
+        float groundHeight = m_physicsScene.TerrainManager.GetTerrainHeightAtXYZ(m_controllingPrim.RawPosition);
+
+        switch (m_controllingPrim.HoverType)
+        {
+            case PIDHoverType.Ground:
+                ret = groundHeight + m_controllingPrim.HoverHeight;
+                break;
+            case PIDHoverType.GroundAndWater:
+                float waterHeight = m_physicsScene.TerrainManager.GetWaterLevelAtXYZ(m_controllingPrim.RawPosition);
+                if (groundHeight > waterHeight)
+                {
+                    ret = groundHeight + m_controllingPrim.HoverHeight;
+                }
+                else
+                {
+                    ret = waterHeight + m_controllingPrim.HoverHeight;
+                }
+                break;
+        }
+        return ret;
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorLockAxis.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorLockAxis.cs
new file mode 100755
index 0000000..78c1b6a
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorLockAxis.cs
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public class BSActorLockAxis : BSActor
+{
+    private BSConstraint LockAxisConstraint = null;
+    private bool HaveRegisteredForBeforeStepCallback = false;
+
+    // The lock access flags (which axises were locked) when the contraint was built.
+    // Used to see if locking has changed since when the constraint was built.
+    OMV.Vector3 LockAxisLinearFlags;
+    OMV.Vector3 LockAxisAngularFlags;
+
+    public BSActorLockAxis(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_physicsScene.DetailLog("{0},BSActorLockAxis,constructor", m_controllingPrim.LocalID);
+        LockAxisConstraint = null;
+        HaveRegisteredForBeforeStepCallback = false;
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        Enabled = false;
+        UnRegisterForBeforeStepCallback();
+        RemoveAxisLockConstraint();
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        // Since the axis logging is done with a constraint, Refresh() time is good for
+        //    changing parameters but this needs to wait until the prim/linkset is physically
+        //    constructed. Therefore, the constraint itself is placed at pre-step time.
+
+        // If all the axis are free, we don't need to exist
+        // Refresh() only turns off. Enabling is done by InitializeAxisActor()
+        //      whenever parameters are changed.
+        //      This leaves 'enable' free to turn off an actor when it is not wanted to run.
+        if (m_controllingPrim.LockedAngularAxis == m_controllingPrim.LockedAxisFree
+                && m_controllingPrim.LockedLinearAxis == m_controllingPrim.LockedAxisFree)
+        {
+            Enabled = false;
+        }
+
+        if (isActive)
+        {
+            RegisterForBeforeStepCallback();
+        }
+        else
+        {
+            RemoveDependencies();
+            UnRegisterForBeforeStepCallback();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        RemoveAxisLockConstraint();
+    }
+
+    private void RegisterForBeforeStepCallback()
+    {
+        if (!HaveRegisteredForBeforeStepCallback)
+        {
+            m_physicsScene.BeforeStep += PhysicsScene_BeforeStep;
+            HaveRegisteredForBeforeStepCallback = true;
+        }
+    }
+
+    private void UnRegisterForBeforeStepCallback()
+    {
+        if (HaveRegisteredForBeforeStepCallback)
+        {
+            m_physicsScene.BeforeStep -= PhysicsScene_BeforeStep;
+            HaveRegisteredForBeforeStepCallback = false;
+        }
+    }
+
+    private void PhysicsScene_BeforeStep(float timestep)
+    {
+        // If all the axis are free, we don't need to exist
+        if (m_controllingPrim.LockedAngularAxis == m_controllingPrim.LockedAxisFree
+                && m_controllingPrim.LockedLinearAxis == m_controllingPrim.LockedAxisFree)
+        {
+            Enabled = false;
+        }
+
+        // If the object is physically active, add the axis locking constraint
+        if (isActive)
+        {
+            // Check to see if the locking parameters have changed
+            if (m_controllingPrim.LockedLinearAxis != this.LockAxisLinearFlags
+                || m_controllingPrim.LockedAngularAxis != this.LockAxisAngularFlags)
+            {
+                // The locking has changed. Remove the old constraint and build a new one
+                RemoveAxisLockConstraint();
+            }
+
+            AddAxisLockConstraint();
+        }
+        else
+        {
+            RemoveAxisLockConstraint();
+        }
+    }
+
+    // Note that this relies on being called at TaintTime
+    private void AddAxisLockConstraint()
+    {
+        if (LockAxisConstraint == null)
+        {
+            // Lock that axis by creating a 6DOF constraint that has one end in the world and
+            //    the other in the object.
+            // http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=20817
+            // http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=26380
+
+            // Remove any existing axis constraint (just to be sure)
+            RemoveAxisLockConstraint();
+
+            BSConstraint6Dof axisConstrainer = new BSConstraint6Dof(m_physicsScene.World, m_controllingPrim.PhysBody,
+                                OMV.Vector3.Zero, OMV.Quaternion.Identity,
+                                false /* useLinearReferenceFrameB */, true /* disableCollisionsBetweenLinkedBodies */);
+            LockAxisConstraint = axisConstrainer;
+            m_physicsScene.Constraints.AddConstraint(LockAxisConstraint);
+
+            // Remember the clocking being inforced so we can notice if they have changed
+            LockAxisLinearFlags = m_controllingPrim.LockedLinearAxis;
+            LockAxisAngularFlags = m_controllingPrim.LockedAngularAxis;
+
+            // The constraint is tied to the world and oriented to the prim.
+
+            if (!axisConstrainer.SetLinearLimits(m_controllingPrim.LockedLinearAxisLow, m_controllingPrim.LockedLinearAxisHigh))
+            {
+                m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,failedSetLinearLimits",
+                        m_controllingPrim.LocalID);
+            }
+
+            if (!axisConstrainer.SetAngularLimits(m_controllingPrim.LockedAngularAxisLow, m_controllingPrim.LockedAngularAxisHigh))
+            {
+                m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,failedSetAngularLimits",
+                        m_controllingPrim.LocalID);
+            }
+
+            m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,create,linLow={1},linHi={2},angLow={3},angHi={4}",
+                                        m_controllingPrim.LocalID,
+                                        m_controllingPrim.LockedLinearAxisLow,
+                                        m_controllingPrim.LockedLinearAxisHigh,
+                                        m_controllingPrim.LockedAngularAxisLow,
+                                        m_controllingPrim.LockedAngularAxisHigh);
+
+            // Constants from one of the posts mentioned above and used in Bullet's ConstraintDemo.
+            axisConstrainer.TranslationalLimitMotor(true /* enable */, 5.0f, 0.1f);
+
+            axisConstrainer.RecomputeConstraintVariables(m_controllingPrim.RawMass);
+
+            RegisterForBeforeStepCallback();
+        }
+    }
+
+    private void RemoveAxisLockConstraint()
+    {
+        UnRegisterForBeforeStepCallback();
+        if (LockAxisConstraint != null)
+        {
+            m_physicsScene.Constraints.RemoveAndDestroyConstraint(LockAxisConstraint);
+            LockAxisConstraint = null;
+            m_physicsScene.DetailLog("{0},BSActorLockAxis.RemoveAxisLockConstraint,destroyingConstraint", m_controllingPrim.LocalID);
+        }
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs
new file mode 100755
index 0000000..3db8f2c
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public class BSActorMoveToTarget : BSActor
+{
+    private BSVMotor m_targetMotor;
+
+    public BSActorMoveToTarget(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_targetMotor = null;
+        m_physicsScene.DetailLog("{0},BSActorMoveToTarget,constructor", m_controllingPrim.LocalID);
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        // MoveToTarget only works on physical prims
+        get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        Enabled = false;
+        DeactivateMoveToTarget();
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorMoveToTarget,refresh,enabled={1},active={2},target={3},tau={4}",
+            m_controllingPrim.LocalID, Enabled, m_controllingPrim.MoveToTargetActive,
+            m_controllingPrim.MoveToTargetTarget, m_controllingPrim.MoveToTargetTau );
+
+        // If not active any more...
+        if (!m_controllingPrim.MoveToTargetActive)
+        {
+            Enabled = false;
+        }
+
+        if (isActive)
+        {
+            ActivateMoveToTarget();
+        }
+        else
+        {
+            DeactivateMoveToTarget();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        // Nothing to do for the moveToTarget since it is all software at pre-step action time.
+    }
+
+    // If a hover motor has not been created, create one and start the hovering.
+    private void ActivateMoveToTarget()
+    {
+        if (m_targetMotor == null)
+        {
+            // We're taking over after this.
+            m_controllingPrim.ZeroMotion(true);
+
+            /* Someday use the PID controller
+            m_targetMotor = new BSPIDVMotor("BSActorMoveToTarget-" + m_controllingPrim.LocalID.ToString());
+            m_targetMotor.TimeScale = m_controllingPrim.MoveToTargetTau;
+            m_targetMotor.Efficiency = 1f;
+             */
+            m_targetMotor = new BSVMotor("BSActorMoveToTarget-" + m_controllingPrim.LocalID.ToString(),
+                                        m_controllingPrim.MoveToTargetTau,  // timeScale
+                                        BSMotor.Infinite,                   // decay time scale
+                                        1f                                  // efficiency
+            );
+            m_targetMotor.PhysicsScene = m_physicsScene; // DEBUG DEBUG so motor will output detail log messages.
+            m_targetMotor.SetTarget(m_controllingPrim.MoveToTargetTarget);
+            m_targetMotor.SetCurrent(m_controllingPrim.RawPosition);
+
+            // m_physicsScene.BeforeStep += Mover;
+            m_physicsScene.BeforeStep += Mover2;
+        }
+        else
+        {
+            // If already allocated, make sure the target and other paramters are current
+            m_targetMotor.SetTarget(m_controllingPrim.MoveToTargetTarget);
+            m_targetMotor.SetCurrent(m_controllingPrim.RawPosition);
+        }
+    }
+
+    private void DeactivateMoveToTarget()
+    {
+        if (m_targetMotor != null)
+        {
+            // m_physicsScene.BeforeStep -= Mover;
+            m_physicsScene.BeforeStep -= Mover2;
+            m_targetMotor = null;
+        }
+    }
+
+    // Origional mover that set the objects position to move to the target.
+    // The problem was that gravity would keep trying to push the object down so
+    //    the overall downward velocity would increase to infinity.
+    // Called just before the simulation step.
+    private void Mover(float timeStep)
+    {
+        // Don't do hovering while the object is selected.
+        if (!isActive)
+            return;
+
+        OMV.Vector3 origPosition = m_controllingPrim.RawPosition;     // DEBUG DEBUG (for printout below)
+
+        // 'movePosition' is where we'd like the prim to be at this moment.
+        OMV.Vector3 movePosition = m_controllingPrim.RawPosition + m_targetMotor.Step(timeStep);
+
+        // If we are very close to our target, turn off the movement motor.
+        if (m_targetMotor.ErrorIsZero())
+        {
+            m_physicsScene.DetailLog("{0},BSActorMoveToTarget.Mover,zeroMovement,movePos={1},pos={2},mass={3}",
+                                    m_controllingPrim.LocalID, movePosition, m_controllingPrim.RawPosition, m_controllingPrim.Mass);
+            m_controllingPrim.ForcePosition = m_targetMotor.TargetValue;
+            m_controllingPrim.ForceVelocity = OMV.Vector3.Zero;
+            // Setting the position does not cause the physics engine to generate a property update. Force it.
+            m_physicsScene.PE.PushUpdate(m_controllingPrim.PhysBody);
+        }
+        else
+        {
+            m_controllingPrim.ForcePosition = movePosition;
+            // Setting the position does not cause the physics engine to generate a property update. Force it.
+            m_physicsScene.PE.PushUpdate(m_controllingPrim.PhysBody);
+        }
+        m_physicsScene.DetailLog("{0},BSActorMoveToTarget.Mover,move,fromPos={1},movePos={2}",
+                                        m_controllingPrim.LocalID, origPosition, movePosition);
+    }
+
+    // Version of mover that applies forces to move the physical object to the target.
+    // Also overcomes gravity so the object doesn't just drop to the ground.
+    // Called just before the simulation step.
+    private void Mover2(float timeStep)
+    {
+        // Don't do hovering while the object is selected.
+        if (!isActive)
+            return;
+
+        OMV.Vector3 origPosition = m_controllingPrim.RawPosition;     // DEBUG DEBUG (for printout below)
+        OMV.Vector3 addedForce = OMV.Vector3.Zero;
+
+        // CorrectionVector is the movement vector required this step
+        OMV.Vector3 correctionVector = m_targetMotor.Step(timeStep, m_controllingPrim.RawPosition);
+
+        // If we are very close to our target, turn off the movement motor.
+        if (m_targetMotor.ErrorIsZero())
+        {
+            m_physicsScene.DetailLog("{0},BSActorMoveToTarget.Mover3,zeroMovement,pos={1},mass={2}",
+                                    m_controllingPrim.LocalID, m_controllingPrim.RawPosition, m_controllingPrim.Mass);
+            m_controllingPrim.ForcePosition = m_targetMotor.TargetValue;
+            m_controllingPrim.ForceVelocity = OMV.Vector3.Zero;
+            // Setting the position does not cause the physics engine to generate a property update. Force it.
+            m_physicsScene.PE.PushUpdate(m_controllingPrim.PhysBody);
+        }
+        else
+        {
+            // First force to move us there -- the motor return a timestep scaled value.
+            addedForce = correctionVector / timeStep;
+            // Remove the existing velocity (only the moveToTarget force counts)
+            addedForce -= m_controllingPrim.RawVelocity;
+            // Overcome gravity. 
+            addedForce -= m_controllingPrim.Gravity;
+
+            // Add enough force to overcome the mass of the object
+            addedForce *= m_controllingPrim.Mass;
+
+            m_controllingPrim.AddForce(addedForce, false /* pushForce */, true /* inTaintTime */);
+        }
+        m_physicsScene.DetailLog("{0},BSActorMoveToTarget.Mover3,move,fromPos={1},addedForce={2}",
+                                        m_controllingPrim.LocalID, origPosition, addedForce);
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorSetForce.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorSetForce.cs
new file mode 100755
index 0000000..ecb4b7f
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorSetForce.cs
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public class BSActorSetForce : BSActor
+{
+    BSFMotor m_forceMotor;
+
+    public BSActorSetForce(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_forceMotor = null;
+        m_physicsScene.DetailLog("{0},BSActorSetForce,constructor", m_controllingPrim.LocalID);
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        Enabled = false;
+        DeactivateSetForce();
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorSetForce,refresh", m_controllingPrim.LocalID);
+
+        // If not active any more, get rid of me (shouldn't ever happen, but just to be safe)
+        if (m_controllingPrim.RawForce == OMV.Vector3.Zero)
+        {
+            m_physicsScene.DetailLog("{0},BSActorSetForce,refresh,notSetForce,removing={1}", m_controllingPrim.LocalID, ActorName);
+            Enabled = false;
+            return;
+        }
+
+        // If the object is physically active, add the hoverer prestep action
+        if (isActive)
+        {
+            ActivateSetForce();
+        }
+        else
+        {
+            DeactivateSetForce();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        // Nothing to do for the hoverer since it is all software at pre-step action time.
+    }
+
+    // If a hover motor has not been created, create one and start the hovering.
+    private void ActivateSetForce()
+    {
+        if (m_forceMotor == null)
+        {
+            // A fake motor that might be used someday
+            m_forceMotor = new BSFMotor("setForce", 1f, 1f, 1f);
+
+            m_physicsScene.BeforeStep += Mover;
+        }
+    }
+
+    private void DeactivateSetForce()
+    {
+        if (m_forceMotor != null)
+        {
+            m_physicsScene.BeforeStep -= Mover;
+            m_forceMotor = null;
+        }
+    }
+
+    // Called just before the simulation step. Update the vertical position for hoverness.
+    private void Mover(float timeStep)
+    {
+        // Don't do force while the object is selected.
+        if (!isActive)
+            return;
+
+        m_physicsScene.DetailLog("{0},BSActorSetForce,preStep,force={1}", m_controllingPrim.LocalID, m_controllingPrim.RawForce);
+        if (m_controllingPrim.PhysBody.HasPhysicalBody)
+        {
+            m_physicsScene.PE.ApplyCentralForce(m_controllingPrim.PhysBody, m_controllingPrim.RawForce);
+            m_controllingPrim.ActivateIfPhysical(false);
+        }
+
+        // TODO:
+    }
+}
+}
+
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorSetTorque.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorSetTorque.cs
new file mode 100755
index 0000000..a1cf4db
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorSetTorque.cs
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public class BSActorSetTorque : BSActor
+{
+    BSFMotor m_torqueMotor;
+
+    public BSActorSetTorque(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_torqueMotor = null;
+        m_physicsScene.DetailLog("{0},BSActorSetTorque,constructor", m_controllingPrim.LocalID);
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        Enabled = false;
+        DeactivateSetTorque();
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorSetTorque,refresh,torque={1}", m_controllingPrim.LocalID, m_controllingPrim.RawTorque);
+
+        // If not active any more, get rid of me (shouldn't ever happen, but just to be safe)
+        if (m_controllingPrim.RawTorque == OMV.Vector3.Zero)
+        {
+            m_physicsScene.DetailLog("{0},BSActorSetTorque,refresh,notSetTorque,disabling={1}", m_controllingPrim.LocalID, ActorName);
+            Enabled = false;
+            return;
+        }
+
+        // If the object is physically active, add the hoverer prestep action
+        if (isActive)
+        {
+            ActivateSetTorque();
+        }
+        else
+        {
+            DeactivateSetTorque();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        // Nothing to do for the hoverer since it is all software at pre-step action time.
+    }
+
+    // If a hover motor has not been created, create one and start the hovering.
+    private void ActivateSetTorque()
+    {
+        if (m_torqueMotor == null)
+        {
+            // A fake motor that might be used someday
+            m_torqueMotor = new BSFMotor("setTorque", 1f, 1f, 1f);
+
+            m_physicsScene.BeforeStep += Mover;
+        }
+    }
+
+    private void DeactivateSetTorque()
+    {
+        if (m_torqueMotor != null)
+        {
+            m_physicsScene.BeforeStep -= Mover;
+            m_torqueMotor = null;
+        }
+    }
+
+    // Called just before the simulation step. Update the vertical position for hoverness.
+    private void Mover(float timeStep)
+    {
+        // Don't do force while the object is selected.
+        if (!isActive)
+            return;
+
+        m_physicsScene.DetailLog("{0},BSActorSetTorque,preStep,force={1}", m_controllingPrim.LocalID, m_controllingPrim.RawTorque);
+        if (m_controllingPrim.PhysBody.HasPhysicalBody)
+        {
+            m_controllingPrim.AddAngularForce(m_controllingPrim.RawTorque, false, true);
+            m_controllingPrim.ActivateIfPhysical(false);
+        }
+
+        // TODO:
+    }
+}
+}
+
+
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActors.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActors.cs
new file mode 100755
index 0000000..851347b
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActors.cs
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public class BSActorCollection
+{
+    private Dictionary<string, BSActor> m_actors;
+
+    public BSActorCollection()
+    {
+        m_actors = new Dictionary<string, BSActor>();
+    }
+    public void Add(string name, BSActor actor)
+    {
+        lock (m_actors)
+        {
+            if (!m_actors.ContainsKey(name))
+            {
+                m_actors[name] = actor;
+            }
+        }
+    }
+    public bool RemoveAndRelease(string name)
+    {
+        bool ret = false;
+        lock (m_actors)
+        {
+            if (m_actors.ContainsKey(name))
+            {
+                BSActor beingRemoved = m_actors[name];
+                m_actors.Remove(name);
+                beingRemoved.Dispose();
+                ret = true;
+            }
+        }
+        return ret;
+    }
+    public void Clear()
+    {
+        lock (m_actors)
+        {
+            ForEachActor(a => a.Dispose());
+            m_actors.Clear();
+        }
+    }
+    public void Dispose()
+    {
+        Clear();
+    }
+    public bool HasActor(string name)
+    {
+        return m_actors.ContainsKey(name);
+    }
+    public bool TryGetActor(string actorName, out BSActor theActor)
+    {
+        return m_actors.TryGetValue(actorName, out theActor);
+    }
+    public void ForEachActor(Action<BSActor> act)
+    {
+        lock (m_actors)
+        {
+            foreach (KeyValuePair<string, BSActor> kvp in m_actors)
+                act(kvp.Value);
+        }
+    }
+
+    public void Enable(bool enabl)
+    {
+        ForEachActor(a => a.SetEnabled(enabl));
+    }
+    public void Refresh()
+    {
+        ForEachActor(a => a.Refresh());
+    }
+    public void RemoveDependencies()
+    {
+        ForEachActor(a => a.RemoveDependencies());
+    }
+}
+
+// =============================================================================
+/// <summary>
+/// Each physical object can have 'actors' who are pushing the object around.
+/// This can be used for hover, locking axis, making vehicles, etc.
+/// Each physical object can have multiple actors acting on it.
+///
+/// An actor usually registers itself with physics scene events (pre-step action)
+/// and modifies the parameters on the host physical object.
+/// </summary>
+public abstract class BSActor
+{
+    protected BSScene m_physicsScene { get; private set; }
+    protected BSPhysObject m_controllingPrim { get; private set; }
+    public virtual bool Enabled { get; set; }
+    public string ActorName { get; private set; }
+
+    public BSActor(BSScene physicsScene, BSPhysObject pObj, string actorName)
+    {
+        m_physicsScene = physicsScene;
+        m_controllingPrim = pObj;
+        ActorName = actorName;
+        Enabled = true;
+    }
+
+    // Return 'true' if activily updating the prim
+    public virtual bool isActive
+    {
+        get { return Enabled; }
+    }
+
+    // Turn the actor on an off. Only used by ActorCollection to set all enabled/disabled.
+    // Anyone else should assign true/false to 'Enabled'.
+    public void SetEnabled(bool setEnabled)
+    {
+        Enabled = setEnabled;
+    }
+    // Release any connections and resources used by the actor.
+    public abstract void Dispose();
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    public abstract void Refresh();
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    public abstract void RemoveDependencies();
+
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs b/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs
new file mode 100644
index 0000000..7756b10
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs
@@ -0,0 +1,763 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS {
+
+    // Constraint type values as defined by Bullet
+public enum ConstraintType : int
+{
+        POINT2POINT_CONSTRAINT_TYPE = 3,
+        HINGE_CONSTRAINT_TYPE,
+        CONETWIST_CONSTRAINT_TYPE,
+        D6_CONSTRAINT_TYPE,
+        SLIDER_CONSTRAINT_TYPE,
+        CONTACT_CONSTRAINT_TYPE,
+        D6_SPRING_CONSTRAINT_TYPE,
+        GEAR_CONSTRAINT_TYPE,           // added in Bullet 2.82
+        FIXED_CONSTRAINT_TYPE,          // added in Bullet 2.82
+        MAX_CONSTRAINT_TYPE,            // last type defined by Bullet
+    //
+    BS_FIXED_CONSTRAINT_TYPE = 1234    // BulletSim constraint that is fixed and unmoving
+}
+
+// ===============================================================================
+[StructLayout(LayoutKind.Sequential)]
+public struct ConvexHull
+{
+        Vector3 Offset;
+        int VertexCount;
+        Vector3[] Vertices;
+}
+public enum BSPhysicsShapeType
+{
+        SHAPE_UNKNOWN   = 0,
+        SHAPE_CAPSULE   = 1,
+        SHAPE_BOX       = 2,
+        SHAPE_CONE      = 3,
+        SHAPE_CYLINDER  = 4,
+        SHAPE_SPHERE    = 5,
+        SHAPE_MESH      = 6,
+        SHAPE_HULL      = 7,
+    // following defined by BulletSim
+        SHAPE_GROUNDPLANE  = 20,
+        SHAPE_TERRAIN   = 21,
+        SHAPE_COMPOUND  = 22,
+        SHAPE_HEIGHTMAP = 23,
+    SHAPE_AVATAR    = 24,
+    SHAPE_CONVEXHULL= 25,
+    SHAPE_GIMPACT   = 26,
+};
+
+// The native shapes have predefined shape hash keys
+public enum FixedShapeKey : ulong
+{
+    KEY_NONE        = 0,
+    KEY_BOX         = 1,
+    KEY_SPHERE      = 2,
+    KEY_CONE        = 3,
+    KEY_CYLINDER    = 4,
+    KEY_CAPSULE     = 5,
+    KEY_AVATAR      = 6,
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ShapeData
+{
+    public UInt32 ID;
+    public BSPhysicsShapeType Type;
+    public Vector3 Position;
+    public Quaternion Rotation;
+    public Vector3 Velocity;
+    public Vector3 Scale;
+    public float Mass;
+    public float Buoyancy;
+    public System.UInt64 HullKey;
+    public System.UInt64 MeshKey;
+    public float Friction;
+    public float Restitution;
+    public float Collidable;    // true of things bump into this
+    public float Static;        // true if a static object. Otherwise gravity, etc.
+    public float Solid;         // true if object cannot be passed through
+    public Vector3 Size;
+
+    // note that bools are passed as floats since bool size changes by language and architecture
+    public const float numericTrue = 1f;
+    public const float numericFalse = 0f;
+}
+[StructLayout(LayoutKind.Sequential)]
+public struct SweepHit
+{
+    public UInt32 ID;
+    public float Fraction;
+    public Vector3 Normal;
+    public Vector3 Point;
+}
+[StructLayout(LayoutKind.Sequential)]
+public struct RaycastHit
+{
+    public UInt32 ID;
+    public float Fraction;
+    public Vector3 Normal;
+}
+[StructLayout(LayoutKind.Sequential)]
+public struct CollisionDesc
+{
+    public UInt32 aID;
+    public UInt32 bID;
+    public Vector3 point;
+    public Vector3 normal;
+    public float penetration;
+}
+[StructLayout(LayoutKind.Sequential)]
+public struct EntityProperties
+{
+    public UInt32 ID;
+    public Vector3 Position;
+    public Quaternion Rotation;
+    public Vector3 Velocity;
+    public Vector3 Acceleration;
+    public Vector3 RotationalVelocity;
+
+    public override string ToString()
+    {
+        StringBuilder buff = new StringBuilder();
+        buff.Append("<i=");
+        buff.Append(ID.ToString());
+        buff.Append(",p=");
+        buff.Append(Position.ToString());
+        buff.Append(",r=");
+        buff.Append(Rotation.ToString());
+        buff.Append(",v=");
+        buff.Append(Velocity.ToString());
+        buff.Append(",a=");
+        buff.Append(Acceleration.ToString());
+        buff.Append(",rv=");
+        buff.Append(RotationalVelocity.ToString());
+        buff.Append(">");
+        return buff.ToString();
+    }
+}
+
+// Format of this structure must match the definition in the C++ code
+// NOTE: adding the X causes compile breaks if used. These are unused symbols
+//      that can be removed from both here and the unmanaged definition of this structure.
+[StructLayout(LayoutKind.Sequential)]
+public struct ConfigurationParameters
+{
+    public float defaultFriction;
+    public float defaultDensity;
+    public float defaultRestitution;
+    public float collisionMargin;
+    public float gravity;
+
+        public float maxPersistantManifoldPoolSize;
+        public float maxCollisionAlgorithmPoolSize;
+        public float shouldDisableContactPoolDynamicAllocation;
+        public float shouldForceUpdateAllAabbs;
+        public float shouldRandomizeSolverOrder;
+        public float shouldSplitSimulationIslands;
+        public float shouldEnableFrictionCaching;
+        public float numberOfSolverIterations;
+    public float useSingleSidedMeshes;
+        public float globalContactBreakingThreshold;
+
+    public float physicsLoggingFrames;
+
+    public const float numericTrue = 1f;
+    public const float numericFalse = 0f;
+}
+
+// Parameters passed for the conversion of a mesh to a hull using Bullet's HACD library.
+[StructLayout(LayoutKind.Sequential)]
+public struct HACDParams
+{
+                                            // usual default values
+        public float maxVerticesPerHull;                // 100
+        public float minClusters;                               // 2
+        public float compacityWeight;                   // 0.1
+        public float volumeWeight;                              // 0.0
+        public float concavity;                             // 100
+        public float addExtraDistPoints;                // false
+        public float addNeighboursDistPoints;   // false
+        public float addFacesPoints;                    // false
+        public float shouldAdjustCollisionMargin;       // false
+    // VHACD
+        public float whichHACD;                             // zero if Bullet HACD, non-zero says VHACD
+        // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html
+        public float vHACDresolution;                   // 100,000 max number of voxels generated during voxelization stage
+        public float vHACDdepth;                                // 20 max number of clipping stages
+        public float vHACDconcavity;                    // 0.0025 maximum concavity
+        public float vHACDplaneDownsampling;    // 4 granularity of search for best clipping plane
+        public float vHACDconvexHullDownsampling;       // 4 precision of hull gen process
+        public float vHACDalpha;                                // 0.05 bias toward clipping along symmetry planes
+        public float vHACDbeta;                             // 0.05 bias toward clipping along revolution axis
+        public float vHACDgamma;                                // 0.00125 max concavity when merging
+        public float vHACDpca;                                  // 0 on/off normalizing mesh before decomp
+        public float vHACDmode;                             // 0 0:voxel based, 1: tetrahedron based
+        public float vHACDmaxNumVerticesPerCH;  // 64 max triangles per convex hull
+        public float vHACDminVolumePerCH;               // 0.0001 sampling of generated convex hulls
+}
+
+// The states a bullet collision object can have
+public enum ActivationState : uint
+{
+    ACTIVE_TAG = 1,
+    ISLAND_SLEEPING,
+    WANTS_DEACTIVATION,
+    DISABLE_DEACTIVATION,
+    DISABLE_SIMULATION,
+}
+
+public enum CollisionObjectTypes : int
+{
+    CO_COLLISION_OBJECT             = 1 << 0,
+    CO_RIGID_BODY                   = 1 << 1,
+    CO_GHOST_OBJECT                 = 1 << 2,
+    CO_SOFT_BODY                    = 1 << 3,
+    CO_HF_FLUID                     = 1 << 4,
+    CO_USER_TYPE                    = 1 << 5,
+}
+
+// Values used by Bullet and BulletSim to control object properties.
+// Bullet's "CollisionFlags" has more to do with operations on the
+//    object (if collisions happen, if gravity effects it, ...).
+public enum CollisionFlags : uint
+{
+    CF_STATIC_OBJECT                 = 1 << 0,
+    CF_KINEMATIC_OBJECT              = 1 << 1,
+    CF_NO_CONTACT_RESPONSE           = 1 << 2,
+    CF_CUSTOM_MATERIAL_CALLBACK      = 1 << 3,
+    CF_CHARACTER_OBJECT              = 1 << 4,
+    CF_DISABLE_VISUALIZE_OBJECT      = 1 << 5,
+    CF_DISABLE_SPU_COLLISION_PROCESS = 1 << 6,
+    // Following used by BulletSim to control collisions and updates
+    BS_SUBSCRIBE_COLLISION_EVENTS    = 1 << 10, // return collision events from unmanaged to managed
+    BS_FLOATS_ON_WATER               = 1 << 11, // the object should float at water level
+    BS_VEHICLE_COLLISIONS            = 1 << 12, // return collisions for vehicle ground checking
+    BS_RETURN_ROOT_COMPOUND_SHAPE    = 1 << 13, // return the pos/rot of the root shape in a compound shape
+    BS_NONE                          = 0,
+    BS_ALL                           = 0x7FFF   // collision flags are a signed short
+};
+
+// Values f collisions groups and masks
+public enum CollisionFilterGroups : uint
+{
+    // Don't use the bit definitions!!  Define the use in a
+    //   filter/mask definition below. This way collision interactions
+    //   are more easily found and debugged.
+    BNoneGroup              = 0,
+    BDefaultGroup           = 1 << 0,   // 0001
+    BStaticGroup            = 1 << 1,   // 0002
+    BKinematicGroup         = 1 << 2,   // 0004
+    BDebrisGroup            = 1 << 3,   // 0008
+    BSensorTrigger          = 1 << 4,   // 0010
+    BCharacterGroup         = 1 << 5,   // 0020
+    BAllGroup               = 0x0007FFF,        // collision flags are a signed short
+    // Filter groups defined by BulletSim
+    BGroundPlaneGroup       = 1 << 8,  // 0400
+    BTerrainGroup           = 1 << 9,  // 0800
+    BRaycastGroup           = 1 << 10,  // 1000
+    BSolidGroup             = 1 << 11,  // 2000
+    // BLinksetGroup        = xx  // a linkset proper is either static or dynamic
+    BLinksetChildGroup      = 1 << 12,  // 4000
+};
+
+// CFM controls the 'hardness' of the constraint. 0=fixed, 0..1=violatable. Default=0
+// ERP controls amount of correction per tick. Usable range=0.1..0.8. Default=0.2.
+public enum ConstraintParams : int
+{
+    BT_CONSTRAINT_ERP = 1,  // this one is not used in Bullet as of 20120730
+    BT_CONSTRAINT_STOP_ERP,
+    BT_CONSTRAINT_CFM,
+    BT_CONSTRAINT_STOP_CFM,
+};
+public enum ConstraintParamAxis : int
+{
+    AXIS_LINEAR_X = 0,
+    AXIS_LINEAR_Y,
+    AXIS_LINEAR_Z,
+    AXIS_ANGULAR_X,
+    AXIS_ANGULAR_Y,
+    AXIS_ANGULAR_Z,
+    AXIS_LINEAR_ALL = 20,    // added by BulletSim so we don't have to do zillions of calls
+    AXIS_ANGULAR_ALL,
+    AXIS_ALL
+};
+
+public abstract class BSAPITemplate
+{
+// Returns the name of the underlying Bullet engine
+public abstract string BulletEngineName { get; }
+public abstract string BulletEngineVersion { get; protected set;}
+
+// Initialization and simulation
+public abstract BulletWorld Initialize(Vector3 maxPosition, ConfigurationParameters parms,
+                                                                                        int maxCollisions,  ref CollisionDesc[] collisionArray,
+                                                                                        int maxUpdates, ref EntityProperties[] updateArray
+                                            );
+
+public abstract int PhysicsStep(BulletWorld world, float timeStep, int maxSubSteps, float fixedTimeStep,
+                        out int updatedEntityCount, out int collidersCount);
+
+public abstract bool UpdateParameter(BulletWorld world, UInt32 localID, String parm, float value);
+
+public abstract void Shutdown(BulletWorld sim);
+
+public abstract bool PushUpdate(BulletBody obj);
+
+// =====================================================================================
+// Mesh, hull, shape and body creation helper routines
+public abstract BulletShape CreateMeshShape(BulletWorld world,
+                int indicesCount, int[] indices,
+                int verticesCount, float[] vertices );
+
+public abstract BulletShape CreateGImpactShape(BulletWorld world,
+                int indicesCount, int[] indices,
+                int verticesCount, float[] vertices );
+
+public abstract BulletShape CreateHullShape(BulletWorld world,
+                int hullCount, float[] hulls);
+
+public abstract BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms);
+
+public abstract BulletShape BuildConvexHullShapeFromMesh(BulletWorld world, BulletShape meshShape);
+
+public abstract BulletShape CreateConvexHullShape(BulletWorld world,
+                int indicesCount, int[] indices,
+                int verticesCount, float[] vertices );
+
+public abstract BulletShape BuildNativeShape(BulletWorld world, ShapeData shapeData);
+
+public abstract bool IsNativeShape(BulletShape shape);
+
+public abstract void SetShapeCollisionMargin(BulletShape shape, float margin);
+
+public abstract BulletShape BuildCapsuleShape(BulletWorld world, float radius, float height, Vector3 scale);
+
+public abstract BulletShape CreateCompoundShape(BulletWorld sim, bool enableDynamicAabbTree);
+
+public abstract int GetNumberOfCompoundChildren(BulletShape cShape);
+
+public abstract void AddChildShapeToCompoundShape(BulletShape cShape, BulletShape addShape, Vector3 pos, Quaternion rot);
+
+public abstract BulletShape GetChildShapeFromCompoundShapeIndex(BulletShape cShape, int indx);
+
+public abstract BulletShape RemoveChildShapeFromCompoundShapeIndex(BulletShape cShape, int indx);
+
+public abstract void RemoveChildShapeFromCompoundShape(BulletShape cShape, BulletShape removeShape);
+
+public abstract void UpdateChildTransform(BulletShape pShape, int childIndex, Vector3 pos, Quaternion rot, bool shouldRecalculateLocalAabb);
+
+public abstract void RecalculateCompoundShapeLocalAabb(BulletShape cShape);
+
+public abstract BulletShape DuplicateCollisionShape(BulletWorld sim, BulletShape srcShape, UInt32 id);
+
+public abstract bool DeleteCollisionShape(BulletWorld world, BulletShape shape);
+
+public abstract CollisionObjectTypes GetBodyType(BulletBody obj);
+
+public abstract BulletBody CreateBodyFromShape(BulletWorld sim, BulletShape shape, UInt32 id, Vector3 pos, Quaternion rot);
+
+public abstract BulletBody CreateBodyWithDefaultMotionState(BulletShape shape, UInt32 id, Vector3 pos, Quaternion rot);
+
+public abstract BulletBody CreateGhostFromShape(BulletWorld sim, BulletShape shape, UInt32 id, Vector3 pos, Quaternion rot);
+
+public abstract void DestroyObject(BulletWorld sim, BulletBody obj);
+
+// =====================================================================================
+public abstract BulletShape CreateGroundPlaneShape(UInt32 id, float height, float collisionMargin);
+
+public abstract BulletShape CreateTerrainShape(UInt32 id, Vector3 size, float minHeight, float maxHeight, float[] heightMap,
+                                                                float scaleFactor, float collisionMargin);
+
+// =====================================================================================
+// Constraint creation and helper routines
+public abstract BulletConstraint Create6DofConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frame1loc, Quaternion frame1rot,
+                    Vector3 frame2loc, Quaternion frame2rot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
+
+public abstract BulletConstraint Create6DofConstraintToPoint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 joinPoint,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
+
+public abstract BulletConstraint Create6DofConstraintFixed(BulletWorld world, BulletBody obj1,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool useLinearReferenceFrameB, bool disableCollisionsBetweenLinkedBodies);
+
+public abstract BulletConstraint Create6DofSpringConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frame1loc, Quaternion frame1rot,
+                    Vector3 frame2loc, Quaternion frame2rot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
+
+public abstract BulletConstraint CreateHingeConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 pivotinA, Vector3 pivotinB,
+                    Vector3 axisInA, Vector3 axisInB,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
+
+public abstract BulletConstraint CreateSliderConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frameInAloc, Quaternion frameInArot,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
+
+public abstract BulletConstraint CreateConeTwistConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frameInAloc, Quaternion frameInArot,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool disableCollisionsBetweenLinkedBodies);
+
+public abstract BulletConstraint CreateGearConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 axisInA, Vector3 axisInB,
+                    float ratio, bool disableCollisionsBetweenLinkedBodies);
+
+public abstract BulletConstraint CreatePoint2PointConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 pivotInA, Vector3 pivotInB,
+                    bool disableCollisionsBetweenLinkedBodies);
+
+public abstract void SetConstraintEnable(BulletConstraint constrain, float numericTrueFalse);
+
+public abstract void SetConstraintNumSolverIterations(BulletConstraint constrain, float iterations);
+
+public abstract bool SetFrames(BulletConstraint constrain,
+                Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot);
+
+public abstract bool SetLinearLimits(BulletConstraint constrain, Vector3 low, Vector3 hi);
+
+public abstract bool SetAngularLimits(BulletConstraint constrain, Vector3 low, Vector3 hi);
+
+public abstract bool UseFrameOffset(BulletConstraint constrain, float enable);
+
+public abstract bool TranslationalLimitMotor(BulletConstraint constrain, float enable, float targetVel, float maxMotorForce);
+
+public abstract bool SetBreakingImpulseThreshold(BulletConstraint constrain, float threshold);
+
+public const int HINGE_NOT_SPECIFIED = -1;
+public abstract bool HingeSetLimits(BulletConstraint constrain, float low, float high, float softness, float bias, float relaxation);
+
+public abstract bool SpringEnable(BulletConstraint constrain, int index, float numericTrueFalse);
+
+public const int SPRING_NOT_SPECIFIED = -1;
+public abstract bool SpringSetEquilibriumPoint(BulletConstraint constrain, int index, float equilibriumPoint);
+
+public abstract bool SpringSetStiffness(BulletConstraint constrain, int index, float stiffnesss);
+
+public abstract bool SpringSetDamping(BulletConstraint constrain, int index, float damping);
+
+public const int SLIDER_LOWER_LIMIT = 0;
+public const int SLIDER_UPPER_LIMIT = 1;
+public const int SLIDER_LINEAR = 2;
+public const int SLIDER_ANGULAR = 3;
+public abstract bool SliderSetLimits(BulletConstraint constrain, int lowerUpper, int linAng, float val);
+
+public const int SLIDER_SET_SOFTNESS = 4;
+public const int SLIDER_SET_RESTITUTION = 5;
+public const int SLIDER_SET_DAMPING = 6;
+public const int SLIDER_SET_DIRECTION = 7;
+public const int SLIDER_SET_LIMIT = 8;
+public const int SLIDER_SET_ORTHO = 9;
+public abstract bool SliderSet(BulletConstraint constrain, int softRestDamp, int dirLimOrtho, int linAng, float val);
+
+public abstract bool SliderMotorEnable(BulletConstraint constrain, int linAng, float numericTrueFalse);
+
+public const int SLIDER_MOTOR_VELOCITY = 10;
+public const int SLIDER_MAX_MOTOR_FORCE = 11;
+public abstract bool SliderMotor(BulletConstraint constrain, int forceVel, int linAng, float val);
+
+public abstract bool CalculateTransforms(BulletConstraint constrain);
+
+public abstract bool SetConstraintParam(BulletConstraint constrain, ConstraintParams paramIndex, float value, ConstraintParamAxis axis);
+
+public abstract bool DestroyConstraint(BulletWorld world, BulletConstraint constrain);
+
+// =====================================================================================
+// btCollisionWorld entries
+public abstract void UpdateSingleAabb(BulletWorld world, BulletBody obj);
+
+public abstract void UpdateAabbs(BulletWorld world);
+
+public abstract bool GetForceUpdateAllAabbs(BulletWorld world);
+
+public abstract void SetForceUpdateAllAabbs(BulletWorld world, bool force);
+
+// =====================================================================================
+// btDynamicsWorld entries
+// public abstract bool AddObjectToWorld(BulletWorld world, BulletBody obj, Vector3 pos, Quaternion rot);
+public abstract bool AddObjectToWorld(BulletWorld world, BulletBody obj);
+
+public abstract bool RemoveObjectFromWorld(BulletWorld world, BulletBody obj);
+
+public abstract bool ClearCollisionProxyCache(BulletWorld world, BulletBody obj);
+
+public abstract bool AddConstraintToWorld(BulletWorld world, BulletConstraint constrain, bool disableCollisionsBetweenLinkedObjects);
+
+public abstract bool RemoveConstraintFromWorld(BulletWorld world, BulletConstraint constrain);
+// =====================================================================================
+// btCollisionObject entries
+public abstract Vector3 GetAnisotripicFriction(BulletConstraint constrain);
+
+public abstract Vector3 SetAnisotripicFriction(BulletConstraint constrain, Vector3 frict);
+
+public abstract bool HasAnisotripicFriction(BulletConstraint constrain);
+
+public abstract void SetContactProcessingThreshold(BulletBody obj, float val);
+
+public abstract float GetContactProcessingThreshold(BulletBody obj);
+
+public abstract bool IsStaticObject(BulletBody obj);
+
+public abstract bool IsKinematicObject(BulletBody obj);
+
+public abstract bool IsStaticOrKinematicObject(BulletBody obj);
+
+public abstract bool HasContactResponse(BulletBody obj);
+
+public abstract void SetCollisionShape(BulletWorld sim, BulletBody obj, BulletShape shape);
+
+public abstract BulletShape GetCollisionShape(BulletBody obj);
+
+public abstract int GetActivationState(BulletBody obj);
+
+public abstract void SetActivationState(BulletBody obj, int state);
+
+public abstract void SetDeactivationTime(BulletBody obj, float dtime);
+
+public abstract float GetDeactivationTime(BulletBody obj);
+
+public abstract void ForceActivationState(BulletBody obj, ActivationState state);
+
+public abstract void Activate(BulletBody obj, bool forceActivation);
+
+public abstract bool IsActive(BulletBody obj);
+
+public abstract void SetRestitution(BulletBody obj, float val);
+
+public abstract float GetRestitution(BulletBody obj);
+
+public abstract void SetFriction(BulletBody obj, float val);
+
+public abstract float GetFriction(BulletBody obj);
+
+public abstract Vector3 GetPosition(BulletBody obj);
+
+public abstract Quaternion GetOrientation(BulletBody obj);
+
+public abstract void SetTranslation(BulletBody obj, Vector3 position, Quaternion rotation);
+
+// public abstract IntPtr GetBroadphaseHandle(BulletBody obj);
+
+// public abstract void SetBroadphaseHandle(BulletBody obj, IntPtr handle);
+
+public abstract void SetInterpolationLinearVelocity(BulletBody obj, Vector3 vel);
+
+public abstract void SetInterpolationAngularVelocity(BulletBody obj, Vector3 vel);
+
+public abstract void SetInterpolationVelocity(BulletBody obj, Vector3 linearVel, Vector3 angularVel);
+
+public abstract float GetHitFraction(BulletBody obj);
+
+public abstract void SetHitFraction(BulletBody obj, float val);
+
+public abstract CollisionFlags GetCollisionFlags(BulletBody obj);
+
+public abstract CollisionFlags SetCollisionFlags(BulletBody obj, CollisionFlags flags);
+
+public abstract CollisionFlags AddToCollisionFlags(BulletBody obj, CollisionFlags flags);
+
+public abstract CollisionFlags RemoveFromCollisionFlags(BulletBody obj, CollisionFlags flags);
+
+public abstract float GetCcdMotionThreshold(BulletBody obj);
+
+public abstract void SetCcdMotionThreshold(BulletBody obj, float val);
+
+public abstract float GetCcdSweptSphereRadius(BulletBody obj);
+
+public abstract void SetCcdSweptSphereRadius(BulletBody obj, float val);
+
+public abstract IntPtr GetUserPointer(BulletBody obj);
+
+public abstract void SetUserPointer(BulletBody obj, IntPtr val);
+
+// =====================================================================================
+// btRigidBody entries
+public abstract void ApplyGravity(BulletBody obj);
+
+public abstract void SetGravity(BulletBody obj, Vector3 val);
+
+public abstract Vector3 GetGravity(BulletBody obj);
+
+public abstract void SetDamping(BulletBody obj, float lin_damping, float ang_damping);
+
+public abstract void SetLinearDamping(BulletBody obj, float lin_damping);
+
+public abstract void SetAngularDamping(BulletBody obj, float ang_damping);
+
+public abstract float GetLinearDamping(BulletBody obj);
+
+public abstract float GetAngularDamping(BulletBody obj);
+
+public abstract float GetLinearSleepingThreshold(BulletBody obj);
+
+public abstract void ApplyDamping(BulletBody obj, float timeStep);
+
+public abstract void SetMassProps(BulletBody obj, float mass, Vector3 inertia);
+
+public abstract Vector3 GetLinearFactor(BulletBody obj);
+
+public abstract void SetLinearFactor(BulletBody obj, Vector3 factor);
+
+public abstract void SetCenterOfMassByPosRot(BulletBody obj, Vector3 pos, Quaternion rot);
+
+// Add a force to the object as if its mass is one.
+public abstract void ApplyCentralForce(BulletBody obj, Vector3 force);
+
+// Set the force being applied to the object as if its mass is one.
+public abstract void SetObjectForce(BulletBody obj, Vector3 force);
+
+public abstract Vector3 GetTotalForce(BulletBody obj);
+
+public abstract Vector3 GetTotalTorque(BulletBody obj);
+
+public abstract Vector3 GetInvInertiaDiagLocal(BulletBody obj);
+
+public abstract void SetInvInertiaDiagLocal(BulletBody obj, Vector3 inert);
+
+public abstract void SetSleepingThresholds(BulletBody obj, float lin_threshold, float ang_threshold);
+
+public abstract void ApplyTorque(BulletBody obj, Vector3 torque);
+
+// Apply force at the given point. Will add torque to the object.
+public abstract void ApplyForce(BulletBody obj, Vector3 force, Vector3 pos);
+
+// Apply impulse to the object. Same as "ApplycentralForce" but force scaled by object's mass.
+public abstract void ApplyCentralImpulse(BulletBody obj, Vector3 imp);
+
+// Apply impulse to the object's torque. Force is scaled by object's mass.
+public abstract void ApplyTorqueImpulse(BulletBody obj, Vector3 imp);
+
+// Apply impulse at the point given. For is scaled by object's mass and effects both linear and angular forces.
+public abstract void ApplyImpulse(BulletBody obj, Vector3 imp, Vector3 pos);
+
+public abstract void ClearForces(BulletBody obj);
+
+public abstract void ClearAllForces(BulletBody obj);
+
+public abstract void UpdateInertiaTensor(BulletBody obj);
+
+public abstract Vector3 GetLinearVelocity(BulletBody obj);
+
+public abstract Vector3 GetAngularVelocity(BulletBody obj);
+
+public abstract void SetLinearVelocity(BulletBody obj, Vector3 val);
+
+public abstract void SetAngularVelocity(BulletBody obj, Vector3 angularVelocity);
+
+public abstract Vector3 GetVelocityInLocalPoint(BulletBody obj, Vector3 pos);
+
+public abstract void Translate(BulletBody obj, Vector3 trans);
+
+public abstract void UpdateDeactivation(BulletBody obj, float timeStep);
+
+public abstract bool WantsSleeping(BulletBody obj);
+
+public abstract void SetAngularFactor(BulletBody obj, float factor);
+
+public abstract void SetAngularFactorV(BulletBody obj, Vector3 factor);
+
+public abstract Vector3 GetAngularFactor(BulletBody obj);
+
+public abstract bool IsInWorld(BulletWorld world, BulletBody obj);
+
+public abstract void AddConstraintRef(BulletBody obj, BulletConstraint constrain);
+
+public abstract void RemoveConstraintRef(BulletBody obj, BulletConstraint constrain);
+
+public abstract BulletConstraint GetConstraintRef(BulletBody obj, int index);
+
+public abstract int GetNumConstraintRefs(BulletBody obj);
+
+public abstract bool SetCollisionGroupMask(BulletBody body, UInt32 filter, UInt32 mask);
+
+// =====================================================================================
+// btCollisionShape entries
+
+public abstract float GetAngularMotionDisc(BulletShape shape);
+
+public abstract float GetContactBreakingThreshold(BulletShape shape, float defaultFactor);
+
+public abstract bool IsPolyhedral(BulletShape shape);
+
+public abstract bool IsConvex2d(BulletShape shape);
+
+public abstract bool IsConvex(BulletShape shape);
+
+public abstract bool IsNonMoving(BulletShape shape);
+
+public abstract bool IsConcave(BulletShape shape);
+
+public abstract bool IsCompound(BulletShape shape);
+
+public abstract bool IsSoftBody(BulletShape shape);
+
+public abstract bool IsInfinite(BulletShape shape);
+
+public abstract void SetLocalScaling(BulletShape shape, Vector3 scale);
+
+public abstract Vector3 GetLocalScaling(BulletShape shape);
+
+public abstract Vector3 CalculateLocalInertia(BulletShape shape, float mass);
+
+public abstract int GetShapeType(BulletShape shape);
+
+public abstract void SetMargin(BulletShape shape, float val);
+
+public abstract float GetMargin(BulletShape shape);
+
+// =====================================================================================
+// Debugging
+public virtual void DumpRigidBody(BulletWorld sim, BulletBody collisionObject) { }
+
+public virtual void DumpCollisionShape(BulletWorld sim, BulletShape collisionShape) { }
+
+public virtual void DumpConstraint(BulletWorld sim, BulletConstraint constrain) { }
+
+public virtual void DumpActivationInfo(BulletWorld sim) { }
+
+public virtual void DumpAllInfo(BulletWorld sim) { }
+
+public virtual void DumpPhysicsStatistics(BulletWorld sim) { }
+
+public virtual void ResetBroadphasePool(BulletWorld sim) { }
+
+public virtual void ResetConstraintSolver(BulletWorld sim) { }
+
+};
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs b/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs
new file mode 100644
index 0000000..83fc3a6
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs
@@ -0,0 +1,813 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using log4net;
+using OMV = OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public sealed class BSCharacter : BSPhysObject
+{
+    private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+    private static readonly string LogHeader = "[BULLETS CHAR]";
+
+    // private bool _stopped;
+    private OMV.Vector3 _size;
+    private bool _grabbed;
+    private bool _selected;
+    private float _mass;
+    private float _avatarVolume;
+    private float _collisionScore;
+    private OMV.Vector3 _acceleration;
+    private int _physicsActorType;
+    private bool _isPhysical;
+    private bool _flying;
+    private bool _setAlwaysRun;
+    private bool _throttleUpdates;
+    private bool _floatOnWater;
+    private OMV.Vector3 _rotationalVelocity;
+    private bool _kinematic;
+    private float _buoyancy;
+
+    private BSActorAvatarMove m_moveActor;
+    private const string AvatarMoveActorName = "BSCharacter.AvatarMove";
+
+    private OMV.Vector3 _PIDTarget;
+    private float _PIDTau;
+
+//        public override OMV.Vector3 RawVelocity 
+//        { get { return base.RawVelocity; } 
+//            set { 
+//                if (value != base.RawVelocity)
+//                    Util.PrintCallStack();
+//                Console.WriteLine("Set rawvel to {0}", value);
+//                base.RawVelocity = value; }
+//        }
+
+    // Avatars are always complete (in the physics engine sense)
+    public override bool IsIncomplete { get { return false; } }
+
+    public BSCharacter(
+            uint localID, String avName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 vel, OMV.Vector3 size, bool isFlying)
+
+            : base(parent_scene, localID, avName, "BSCharacter")
+    {
+        _physicsActorType = (int)ActorTypes.Agent;
+        RawPosition = pos;        
+
+        _flying = isFlying;
+        RawOrientation = OMV.Quaternion.Identity;
+        RawVelocity = vel;
+        _buoyancy = ComputeBuoyancyFromFlying(isFlying);
+        Friction = BSParam.AvatarStandingFriction;
+        Density = BSParam.AvatarDensity;
+
+        // Old versions of ScenePresence passed only the height. If width and/or depth are zero,
+        //     replace with the default values.
+        _size = size;
+        if (_size.X == 0f) _size.X = BSParam.AvatarCapsuleDepth;
+        if (_size.Y == 0f) _size.Y = BSParam.AvatarCapsuleWidth;
+
+        // The dimensions of the physical capsule are kept in the scale.
+        // Physics creates a unit capsule which is scaled by the physics engine.
+        Scale = ComputeAvatarScale(_size);
+        // set _avatarVolume and _mass based on capsule size, _density and Scale
+        ComputeAvatarVolumeAndMass();
+
+        DetailLog(
+            "{0},BSCharacter.create,call,size={1},scale={2},density={3},volume={4},mass={5},pos={6},vel={7}",
+            LocalID, _size, Scale, Density, _avatarVolume, RawMass, pos, vel);
+
+        // do actual creation in taint time
+        PhysScene.TaintedObject(LocalID, "BSCharacter.create", delegate()
+        {
+            DetailLog("{0},BSCharacter.create,taint", LocalID);
+
+            // New body and shape into PhysBody and PhysShape
+            PhysScene.Shapes.GetBodyAndShape(true, PhysScene.World, this);
+
+            // The avatar's movement is controlled by this motor that speeds up and slows down
+            //    the avatar seeking to reach the motor's target speed.
+            // This motor runs as a prestep action for the avatar so it will keep the avatar
+            //    standing as well as moving. Destruction of the avatar will destroy the pre-step action.
+            m_moveActor = new BSActorAvatarMove(PhysScene, this, AvatarMoveActorName);
+            PhysicalActors.Add(AvatarMoveActorName, m_moveActor);
+
+            SetPhysicalProperties();
+
+            IsInitialized = true;
+        });
+        return;
+    }
+
+    // called when this character is being destroyed and the resources should be released
+    public override void Destroy()
+    {
+        IsInitialized = false;
+
+        base.Destroy();
+
+        DetailLog("{0},BSCharacter.Destroy", LocalID);
+        PhysScene.TaintedObject(LocalID, "BSCharacter.destroy", delegate()
+        {
+            PhysScene.Shapes.DereferenceBody(PhysBody, null /* bodyCallback */);
+            PhysBody.Clear();
+            PhysShape.Dereference(PhysScene);
+            PhysShape = new BSShapeNull();
+        });
+    }
+
+    private void SetPhysicalProperties()
+    {
+        PhysScene.PE.RemoveObjectFromWorld(PhysScene.World, PhysBody);
+
+        ForcePosition = RawPosition;
+
+        // Set the velocity
+        if (m_moveActor != null)
+            m_moveActor.SetVelocityAndTarget(RawVelocity, RawVelocity, false);
+
+        ForceVelocity = RawVelocity;
+        TargetVelocity = RawVelocity;
+
+        // This will enable or disable the flying buoyancy of the avatar.
+        // Needs to be reset especially when an avatar is recreated after crossing a region boundry.
+        Flying = _flying;
+
+        PhysScene.PE.SetRestitution(PhysBody, BSParam.AvatarRestitution);
+        PhysScene.PE.SetMargin(PhysShape.physShapeInfo, PhysScene.Params.collisionMargin);
+        PhysScene.PE.SetLocalScaling(PhysShape.physShapeInfo, Scale);
+        PhysScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
+        if (BSParam.CcdMotionThreshold > 0f)
+        {
+            PhysScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
+            PhysScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
+        }
+
+        UpdatePhysicalMassProperties(RawMass, false);
+
+        // Make so capsule does not fall over
+        PhysScene.PE.SetAngularFactorV(PhysBody, OMV.Vector3.Zero);
+
+        // The avatar mover sets some parameters.
+        PhysicalActors.Refresh();
+
+        PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_CHARACTER_OBJECT);
+
+        PhysScene.PE.AddObjectToWorld(PhysScene.World, PhysBody);
+
+        // PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.ACTIVE_TAG);
+        PhysScene.PE.ForceActivationState(PhysBody, ActivationState.DISABLE_DEACTIVATION);
+        PhysScene.PE.UpdateSingleAabb(PhysScene.World, PhysBody);
+
+        // Do this after the object has been added to the world
+        if (BSParam.AvatarToAvatarCollisionsByDefault)
+            PhysBody.collisionType = CollisionType.Avatar;
+        else
+            PhysBody.collisionType = CollisionType.PhantomToOthersAvatar;
+
+        PhysBody.ApplyCollisionMask(PhysScene);
+    }
+
+    public override void RequestPhysicsterseUpdate()
+    {
+        base.RequestPhysicsterseUpdate();
+    }
+
+    // No one calls this method so I don't know what it could possibly mean
+    public override bool Stopped { get { return false; } }
+
+    public override OMV.Vector3 Size {
+        get
+        {
+            // Avatar capsule size is kept in the scale parameter.
+            return _size;
+        }
+
+        set {
+            // This is how much the avatar size is changing. Positive means getting bigger.
+            // The avatar altitude must be adjusted for this change.
+            float heightChange = value.Z - _size.Z;
+
+            _size = value;
+            // Old versions of ScenePresence passed only the height. If width and/or depth are zero,
+            //     replace with the default values.
+            if (_size.X == 0f) _size.X = BSParam.AvatarCapsuleDepth;
+            if (_size.Y == 0f) _size.Y = BSParam.AvatarCapsuleWidth;
+
+            Scale = ComputeAvatarScale(_size);
+            ComputeAvatarVolumeAndMass();
+            DetailLog("{0},BSCharacter.setSize,call,size={1},scale={2},density={3},volume={4},mass={5}",
+                            LocalID, _size, Scale, Density, _avatarVolume, RawMass);
+
+            PhysScene.TaintedObject(LocalID, "BSCharacter.setSize", delegate()
+            {
+                if (PhysBody.HasPhysicalBody && PhysShape.physShapeInfo.HasPhysicalShape)
+                {
+                    PhysScene.PE.SetLocalScaling(PhysShape.physShapeInfo, Scale);
+                    UpdatePhysicalMassProperties(RawMass, true);
+
+                    // Adjust the avatar's position to account for the increase/decrease in size
+                    ForcePosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, RawPosition.Z + heightChange / 2f);
+
+                    // Make sure this change appears as a property update event
+                    PhysScene.PE.PushUpdate(PhysBody);
+                }
+            });
+
+        }
+    }
+
+    public override PrimitiveBaseShape Shape
+    {
+        set { BaseShape = value; }
+    }
+
+    public override bool Grabbed {
+        set { _grabbed = value; }
+    }
+    public override bool Selected {
+        set { _selected = value; }
+    }
+    public override bool IsSelected
+    {
+        get { return _selected; }
+    }
+    public override void CrossingFailure() { return; }
+    public override void link(PhysicsActor obj) { return; }
+    public override void delink() { return; }
+
+    // Set motion values to zero.
+    // Do it to the properties so the values get set in the physics engine.
+    // Push the setting of the values to the viewer.
+    // Called at taint time!
+    public override void ZeroMotion(bool inTaintTime)
+    {
+        RawVelocity = OMV.Vector3.Zero;
+        _acceleration = OMV.Vector3.Zero;
+        _rotationalVelocity = OMV.Vector3.Zero;
+
+        // Zero some other properties directly into the physics engine
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.ZeroMotion", delegate()
+        {
+            if (PhysBody.HasPhysicalBody)
+                PhysScene.PE.ClearAllForces(PhysBody);
+        });
+    }
+
+    public override void ZeroAngularMotion(bool inTaintTime)
+    {
+        _rotationalVelocity = OMV.Vector3.Zero;
+
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.ZeroMotion", delegate()
+        {
+            if (PhysBody.HasPhysicalBody)
+            {
+                PhysScene.PE.SetInterpolationAngularVelocity(PhysBody, OMV.Vector3.Zero);
+                PhysScene.PE.SetAngularVelocity(PhysBody, OMV.Vector3.Zero);
+                // The next also get rid of applied linear force but the linear velocity is untouched.
+                PhysScene.PE.ClearForces(PhysBody);
+            }
+        });
+    }
+
+
+    public override void LockAngularMotion(OMV.Vector3 axis) { return; }
+
+    public override OMV.Vector3 Position {
+        get {
+            // Don't refetch the position because this function is called a zillion times
+            // RawPosition = PhysicsScene.PE.GetObjectPosition(Scene.World, LocalID);
+            return RawPosition;
+        }
+        set {
+            RawPosition = value;
+
+            PhysScene.TaintedObject(LocalID, "BSCharacter.setPosition", delegate()
+            {
+                DetailLog("{0},BSCharacter.SetPosition,taint,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
+                PositionSanityCheck();
+                ForcePosition = RawPosition;
+            });
+        }
+    }
+    public override OMV.Vector3 ForcePosition {
+        get {
+            RawPosition = PhysScene.PE.GetPosition(PhysBody);
+            return RawPosition;
+        }
+        set {
+            RawPosition = value;
+            if (PhysBody.HasPhysicalBody)
+            {
+                PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
+            }
+        }
+    }
+
+
+    // Check that the current position is sane and, if not, modify the position to make it so.
+    // Check for being below terrain or on water.
+    // Returns 'true' of the position was made sane by some action.
+    private bool PositionSanityCheck()
+    {
+        bool ret = false;
+
+        // TODO: check for out of bounds
+        if (!PhysScene.TerrainManager.IsWithinKnownTerrain(RawPosition))
+        {
+            // The character is out of the known/simulated area.
+            // Force the avatar position to be within known. ScenePresence will use the position
+            //    plus the velocity to decide if the avatar is moving out of the region.
+            RawPosition = PhysScene.TerrainManager.ClampPositionIntoKnownTerrain(RawPosition);
+            DetailLog("{0},BSCharacter.PositionSanityCheck,notWithinKnownTerrain,clampedPos={1}", LocalID, RawPosition);
+            return true;
+        }
+
+        // If below the ground, move the avatar up
+        float terrainHeight = PhysScene.TerrainManager.GetTerrainHeightAtXYZ(RawPosition);
+        if (Position.Z < terrainHeight)
+        {
+            DetailLog("{0},BSCharacter.PositionSanityCheck,adjustForUnderGround,pos={1},terrain={2}", LocalID, RawPosition, terrainHeight);
+            RawPosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, terrainHeight + BSParam.AvatarBelowGroundUpCorrectionMeters);
+            ret = true;
+        }
+        if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0)
+        {
+            float waterHeight = PhysScene.TerrainManager.GetWaterLevelAtXYZ(RawPosition);
+            if (Position.Z < waterHeight)
+            {
+                RawPosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, waterHeight);
+                ret = true;
+            }
+        }
+
+        return ret;
+    }
+
+    // A version of the sanity check that also makes sure a new position value is
+    //    pushed back to the physics engine. This routine would be used by anyone
+    //    who is not already pushing the value.
+    private bool PositionSanityCheck(bool inTaintTime)
+    {
+        bool ret = false;
+        if (PositionSanityCheck())
+        {
+            // The new position value must be pushed into the physics engine but we can't
+            //    just assign to "Position" because of potential call loops.
+            PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.PositionSanityCheck", delegate()
+            {
+                DetailLog("{0},BSCharacter.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
+                ForcePosition = RawPosition;
+            });
+            ret = true;
+        }
+        return ret;
+    }
+
+    public override float Mass { get { return _mass; } }
+
+    // used when we only want this prim's mass and not the linkset thing
+    public override float RawMass {
+        get {return _mass; }
+    }
+    public override void UpdatePhysicalMassProperties(float physMass, bool inWorld)
+    {
+        OMV.Vector3 localInertia = PhysScene.PE.CalculateLocalInertia(PhysShape.physShapeInfo, physMass);
+        PhysScene.PE.SetMassProps(PhysBody, physMass, localInertia);
+    }
+
+    public override OMV.Vector3 Force {
+        get { return RawForce; }
+        set {
+            RawForce = value;
+            // m_log.DebugFormat("{0}: Force = {1}", LogHeader, _force);
+            PhysScene.TaintedObject(LocalID, "BSCharacter.SetForce", delegate()
+            {
+                DetailLog("{0},BSCharacter.setForce,taint,force={1}", LocalID, RawForce);
+                if (PhysBody.HasPhysicalBody)
+                    PhysScene.PE.SetObjectForce(PhysBody, RawForce);
+            });
+        }
+    }
+
+    // Avatars don't do vehicles
+    public override int VehicleType { get { return (int)Vehicle.TYPE_NONE; } set { return; } }
+    public override void VehicleFloatParam(int param, float value) { }
+    public override void VehicleVectorParam(int param, OMV.Vector3 value) {}
+    public override void VehicleRotationParam(int param, OMV.Quaternion rotation) { }
+    public override void VehicleFlags(int param, bool remove) { }
+
+    // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more
+    public override void SetVolumeDetect(int param) { return; }
+    public override bool IsVolumeDetect { get { return false; } }
+
+    public override OMV.Vector3 GeometricCenter { get { return OMV.Vector3.Zero; } }
+    public override OMV.Vector3 CenterOfMass { get { return OMV.Vector3.Zero; } }
+
+    // Sets the target in the motor. This starts the changing of the avatar's velocity.
+    public override OMV.Vector3 TargetVelocity
+    {
+        get
+        {
+            return base.m_targetVelocity;
+        }
+        set
+        {
+            DetailLog("{0},BSCharacter.setTargetVelocity,call,vel={1}", LocalID, value);
+            m_targetVelocity = value;
+            OMV.Vector3 targetVel = value;
+            if (_setAlwaysRun && !_flying)
+                targetVel *= new OMV.Vector3(BSParam.AvatarAlwaysRunFactor, BSParam.AvatarAlwaysRunFactor, 1f);
+
+            if (m_moveActor != null)
+                m_moveActor.SetVelocityAndTarget(RawVelocity, targetVel, false /* inTaintTime */);
+        }
+    }
+    // Directly setting velocity means this is what the user really wants now.
+    public override OMV.Vector3 Velocity {
+        get { return RawVelocity; }
+        set {
+            RawVelocity = value;
+                OMV.Vector3 vel = RawVelocity;
+
+            DetailLog("{0}: set Velocity = {1}", LocalID, value);
+
+            PhysScene.TaintedObject(LocalID, "BSCharacter.setVelocity", delegate()
+            {
+                if (m_moveActor != null)
+                    m_moveActor.SetVelocityAndTarget(vel, vel, true /* inTaintTime */);
+
+                DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, vel);
+                ForceVelocity = vel;
+            });
+        }
+    }
+
+    public override OMV.Vector3 ForceVelocity {
+        get { return RawVelocity; }
+        set {
+            PhysScene.AssertInTaintTime("BSCharacter.ForceVelocity");
+//                Util.PrintCallStack();
+            DetailLog("{0}: set ForceVelocity = {1}", LocalID, value);
+
+            RawVelocity = value;
+            PhysScene.PE.SetLinearVelocity(PhysBody, RawVelocity);
+            PhysScene.PE.Activate(PhysBody, true);
+        }
+    }
+
+    public override OMV.Vector3 Torque {
+        get { return RawTorque; }
+        set { RawTorque = value;
+        }
+    }
+
+    public override float CollisionScore {
+        get { return _collisionScore; }
+        set { _collisionScore = value;
+        }
+    }
+    public override OMV.Vector3 Acceleration {
+        get { return _acceleration; }
+        set { _acceleration = value; }
+    }
+    public override OMV.Quaternion Orientation {
+        get { return RawOrientation; }
+        set {
+            // Orientation is set zillions of times when an avatar is walking. It's like
+            //      the viewer doesn't trust us.
+            if (RawOrientation != value)
+            {
+                RawOrientation = value;
+                PhysScene.TaintedObject(LocalID, "BSCharacter.setOrientation", delegate()
+                {
+                    // Bullet assumes we know what we are doing when forcing orientation
+                    //    so it lets us go against all the rules and just compensates for them later.
+                    // This forces rotation to be only around the Z axis and doesn't change any of the other axis.
+                    // This keeps us from flipping the capsule over which the veiwer does not understand.
+                    float oRoll, oPitch, oYaw;
+                    RawOrientation.GetEulerAngles(out oRoll, out oPitch, out oYaw);
+                    OMV.Quaternion trimmedOrientation = OMV.Quaternion.CreateFromEulers(0f, 0f, oYaw);
+                    // DetailLog("{0},BSCharacter.setOrientation,taint,val={1},valDir={2},conv={3},convDir={4}",
+                    //                 LocalID, RawOrientation, OMV.Vector3.UnitX * RawOrientation,
+                    //                 trimmedOrientation, OMV.Vector3.UnitX * trimmedOrientation);
+                    ForceOrientation = trimmedOrientation;
+                });
+            }
+        }
+    }
+    // Go directly to Bullet to get/set the value.
+    public override OMV.Quaternion ForceOrientation
+    {
+        get
+        {
+            RawOrientation = PhysScene.PE.GetOrientation(PhysBody);
+            return RawOrientation;
+        }
+        set
+        {
+            RawOrientation = value;
+            if (PhysBody.HasPhysicalBody)
+            {
+                // RawPosition = PhysicsScene.PE.GetPosition(BSBody);
+                PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
+            }
+        }
+    }
+    public override int PhysicsActorType {
+        get { return _physicsActorType; }
+        set { _physicsActorType = value;
+        }
+    }
+    public override bool IsPhysical {
+        get { return _isPhysical; }
+        set { _isPhysical = value;
+        }
+    }
+    public override bool IsSolid {
+        get { return true; }
+    }
+    public override bool IsStatic {
+        get { return false; }
+    }
+    public override bool IsPhysicallyActive {
+        get { return true; }
+    }
+    public override bool Flying {
+        get { return _flying; }
+        set {
+            _flying = value;
+
+            // simulate flying by changing the effect of gravity
+            Buoyancy = ComputeBuoyancyFromFlying(_flying);
+        }
+    }
+    // Flying is implimented by changing the avatar's buoyancy.
+    // Would this be done better with a vehicle type?
+    private float ComputeBuoyancyFromFlying(bool ifFlying) {
+        return ifFlying ? 1f : 0f;
+    }
+    public override bool
+        SetAlwaysRun {
+        get { return _setAlwaysRun; }
+        set { _setAlwaysRun = value; }
+    }
+    public override bool ThrottleUpdates {
+        get { return _throttleUpdates; }
+        set { _throttleUpdates = value; }
+    }
+    public override bool FloatOnWater {
+        set {
+            _floatOnWater = value;
+            PhysScene.TaintedObject(LocalID, "BSCharacter.setFloatOnWater", delegate()
+            {
+                if (PhysBody.HasPhysicalBody)
+                {
+                    if (_floatOnWater)
+                        CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
+                    else
+                        CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
+                }
+            });
+        }
+    }
+    public override OMV.Vector3 RotationalVelocity {
+        get { return _rotationalVelocity; }
+        set { _rotationalVelocity = value; }
+    }
+    public override OMV.Vector3 ForceRotationalVelocity {
+        get { return _rotationalVelocity; }
+        set { _rotationalVelocity = value; }
+    }
+    public override bool Kinematic {
+        get { return _kinematic; }
+        set { _kinematic = value; }
+    }
+    // neg=fall quickly, 0=1g, 1=0g, pos=float up
+    public override float Buoyancy {
+        get { return _buoyancy; }
+        set { _buoyancy = value;
+            PhysScene.TaintedObject(LocalID, "BSCharacter.setBuoyancy", delegate()
+            {
+                DetailLog("{0},BSCharacter.setBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
+                ForceBuoyancy = _buoyancy;
+            });
+        }
+    }
+    public override float ForceBuoyancy {
+        get { return _buoyancy; }
+        set {
+            PhysScene.AssertInTaintTime("BSCharacter.ForceBuoyancy");
+
+            _buoyancy = value;
+            DetailLog("{0},BSCharacter.setForceBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
+            // Buoyancy is faked by changing the gravity applied to the object
+            float  grav = BSParam.Gravity * (1f - _buoyancy);
+            Gravity = new OMV.Vector3(0f, 0f, grav);
+            if (PhysBody.HasPhysicalBody)
+                PhysScene.PE.SetGravity(PhysBody, Gravity);
+        }
+    }
+
+    // Used for MoveTo
+    public override OMV.Vector3 PIDTarget {
+        set { _PIDTarget = value; }
+    }
+
+    public override bool PIDActive { get; set; }
+
+    public override float PIDTau {
+        set { _PIDTau = value; }
+    }
+
+    public override void AddForce(OMV.Vector3 force, bool pushforce)
+    {
+        // Since this force is being applied in only one step, make this a force per second.
+        OMV.Vector3 addForce = force / PhysScene.LastTimeStep;
+        AddForce(addForce, pushforce, false);
+    }
+    public override void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
+        if (force.IsFinite())
+        {
+            OMV.Vector3 addForce = Util.ClampV(force, BSParam.MaxAddForceMagnitude);
+            // DetailLog("{0},BSCharacter.addForce,call,force={1}", LocalID, addForce);
+
+            PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.AddForce", delegate()
+            {
+                // Bullet adds this central force to the total force for this tick
+                // DetailLog("{0},BSCharacter.addForce,taint,force={1}", LocalID, addForce);
+                if (PhysBody.HasPhysicalBody)
+                {
+                    PhysScene.PE.ApplyCentralForce(PhysBody, addForce);
+                }
+            });
+        }
+        else
+        {
+            m_log.WarnFormat("{0}: Got a NaN force applied to a character. LocalID={1}", LogHeader, LocalID);
+            return;
+        }
+    }
+
+    public override void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
+    }
+    public override void SetMomentum(OMV.Vector3 momentum) {
+    }
+
+    private OMV.Vector3 ComputeAvatarScale(OMV.Vector3 size)
+    {
+        OMV.Vector3 newScale = size;
+
+        // Bullet's capsule total height is the "passed height + radius * 2";
+        // The base capsule is 1 unit in diameter and 2 units in height (passed radius=0.5, passed height = 1)
+        // The number we pass in for 'scaling' is the multiplier to get that base
+        //     shape to be the size desired.
+        // So, when creating the scale for the avatar height, we take the passed height
+        //     (size.Z) and remove the caps.
+        // An oddity of the Bullet capsule implementation is that it presumes the Y
+        //     dimension is the radius of the capsule. Even though some of the code allows
+        //     for a asymmetrical capsule, other parts of the code presume it is cylindrical.
+
+        // Scale is multiplier of radius with one of "0.5"
+
+        float heightAdjust = BSParam.AvatarHeightMidFudge;
+        if (BSParam.AvatarHeightLowFudge != 0f || BSParam.AvatarHeightHighFudge != 0f)
+        {
+            const float AVATAR_LOW = 1.1f;
+            const float AVATAR_MID = 1.775f; // 1.87f
+            const float AVATAR_HI = 2.45f;
+            // An avatar is between 1.1 and 2.45 meters. Midpoint is 1.775m.
+            float midHeightOffset = size.Z - AVATAR_MID;
+            if (midHeightOffset < 0f)
+            {
+                // Small avatar. Add the adjustment based on the distance from midheight
+                heightAdjust += ((-1f * midHeightOffset) / (AVATAR_MID - AVATAR_LOW)) * BSParam.AvatarHeightLowFudge;
+            }
+            else
+            {
+                // Large avatar. Add the adjustment based on the distance from midheight
+                heightAdjust += ((midHeightOffset) / (AVATAR_HI - AVATAR_MID)) * BSParam.AvatarHeightHighFudge;
+            }
+        }
+        if (BSParam.AvatarShape == BSShapeCollection.AvatarShapeCapsule)
+        {
+            newScale.X = size.X / 2f;
+            newScale.Y = size.Y / 2f;
+            // The total scale height is the central cylindar plus the caps on the two ends.
+            newScale.Z = (size.Z + (Math.Min(size.X, size.Y) * 2) + heightAdjust) / 2f;
+        }
+        else
+        {
+            newScale.Z = size.Z + heightAdjust;
+        }
+        // m_log.DebugFormat("{0} ComputeAvatarScale: size={1},adj={2},scale={3}", LogHeader, size, heightAdjust, newScale);
+
+        // If smaller than the endcaps, just fake like we're almost that small
+        if (newScale.Z < 0)
+            newScale.Z = 0.1f;
+
+        DetailLog("{0},BSCharacter.ComputerAvatarScale,size={1},lowF={2},midF={3},hiF={4},adj={5},newScale={6}",
+            LocalID, size, BSParam.AvatarHeightLowFudge, BSParam.AvatarHeightMidFudge, BSParam.AvatarHeightHighFudge, heightAdjust, newScale);
+
+        return newScale;
+    }
+
+    // set _avatarVolume and _mass based on capsule size, _density and Scale
+    private void ComputeAvatarVolumeAndMass()
+    {
+        _avatarVolume = (float)(
+                        Math.PI
+                        * Size.X / 2f
+                        * Size.Y / 2f    // the area of capsule cylinder
+                        * Size.Z         // times height of capsule cylinder
+                      + 1.33333333f
+                        * Math.PI
+                        * Size.X / 2f
+                        * Math.Min(Size.X, Size.Y) / 2
+                        * Size.Y / 2f    // plus the volume of the capsule end caps
+                        );
+        _mass = Density * BSParam.DensityScaleFactor * _avatarVolume;
+    }
+
+    // The physics engine says that properties have updated. Update same and inform
+    // the world that things have changed.
+    public override void UpdateProperties(EntityProperties entprop)
+    {
+        // Let anyone (like the actors) modify the updated properties before they are pushed into the object and the simulator.
+        TriggerPreUpdatePropertyAction(ref entprop);
+
+        RawPosition = entprop.Position;
+        RawOrientation = entprop.Rotation;
+
+        // Smooth velocity. OpenSimulator is VERY sensitive to changes in velocity of the avatar
+        //    and will send agent updates to the clients if velocity changes by more than
+        //    0.001m/s. Bullet introduces a lot of jitter in the velocity which causes many
+        //    extra updates.
+        //
+        // XXX: Contrary to the above comment, setting an update threshold here above 0.4 actually introduces jitter to 
+        // avatar movement rather than removes it.  The larger the threshold, the bigger the jitter.
+        // This is most noticeable in level flight and can be seen with
+        // the "show updates" option in a viewer.  With an update threshold, the RawVelocity cycles between a lower
+        // bound and an upper bound, where the difference between the two is enough to trigger a large delta v update
+        // and subsequently trigger an update in ScenePresence.SendTerseUpdateToAllClients().  The cause of this cycle (feedback?)
+        // has not yet been identified.
+        //
+        // If there is a threshold below 0.4 or no threshold check at all (as in ODE), then RawVelocity stays constant and extra
+        // updates are not triggered in ScenePresence.SendTerseUpdateToAllClients().
+//        if (!entprop.Velocity.ApproxEquals(RawVelocity, 0.1f))
+            RawVelocity = entprop.Velocity;
+
+        _acceleration = entprop.Acceleration;
+        _rotationalVelocity = entprop.RotationalVelocity;
+
+        // Do some sanity checking for the avatar. Make sure it's above ground and inbounds.
+        if (PositionSanityCheck(true))
+        {
+            DetailLog("{0},BSCharacter.UpdateProperties,updatePosForSanity,pos={1}", LocalID, RawPosition);
+            entprop.Position = RawPosition;
+        }
+
+        // remember the current and last set values
+        LastEntityProperties = CurrentEntityProperties;
+        CurrentEntityProperties = entprop;
+
+        // Tell the linkset about value changes
+        // Linkset.UpdateProperties(UpdatedProperties.EntPropUpdates, this);
+
+        // Avatars don't report their changes the usual way. Changes are checked for in the heartbeat loop.
+        // PhysScene.PostUpdate(this);
+
+        DetailLog("{0},BSCharacter.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
+                LocalID, RawPosition, RawOrientation, RawVelocity, _acceleration, _rotationalVelocity);
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraint.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraint.cs
new file mode 100755
index 0000000..e42e868
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraint.cs
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+public abstract class BSConstraint : IDisposable
+{
+    private static string LogHeader = "[BULLETSIM CONSTRAINT]";
+
+    protected BulletWorld m_world;
+    protected BSScene PhysicsScene;
+    protected BulletBody m_body1;
+    protected BulletBody m_body2;
+    protected BulletConstraint m_constraint;
+    protected bool m_enabled = false;
+
+    public BulletBody Body1 { get { return m_body1; } }
+    public BulletBody Body2 { get { return m_body2; } }
+    public BulletConstraint Constraint { get { return m_constraint; } }
+    public abstract ConstraintType Type { get; }
+    public bool IsEnabled { get { return m_enabled; } }
+
+    public BSConstraint(BulletWorld world)
+    {
+        m_world = world;
+        PhysicsScene = m_world.physicsScene;
+    }
+
+    public virtual void Dispose()
+    {
+        if (m_enabled)
+        {
+            m_enabled = false;
+            if (m_constraint.HasPhysicalConstraint)
+            {
+                bool success = PhysicsScene.PE.DestroyConstraint(m_world, m_constraint);
+                m_world.physicsScene.DetailLog("{0},BSConstraint.Dispose,taint,id1={1},body1={2},id2={3},body2={4},success={5}",
+                                    m_body1.ID,
+                                    m_body1.ID, m_body1.AddrString,
+                                    m_body2.ID, m_body2.AddrString,
+                                    success);
+                m_constraint.Clear();
+            }
+        }
+    }
+
+    public virtual bool SetLinearLimits(Vector3 low, Vector3 high)
+    {
+        bool ret = false;
+        if (m_enabled)
+        {
+            m_world.physicsScene.DetailLog("{0},BSConstraint.SetLinearLimits,taint,low={1},high={2}", m_body1.ID, low, high);
+            ret = PhysicsScene.PE.SetLinearLimits(m_constraint, low, high);
+        }
+        return ret;
+    }
+
+    public virtual bool SetAngularLimits(Vector3 low, Vector3 high)
+    {
+        bool ret = false;
+        if (m_enabled)
+        {
+            m_world.physicsScene.DetailLog("{0},BSConstraint.SetAngularLimits,taint,low={1},high={2}", m_body1.ID, low, high);
+            ret = PhysicsScene.PE.SetAngularLimits(m_constraint, low, high);
+        }
+        return ret;
+    }
+
+    public virtual bool SetSolverIterations(float cnt)
+    {
+        bool ret = false;
+        if (m_enabled)
+        {
+            PhysicsScene.PE.SetConstraintNumSolverIterations(m_constraint, cnt);
+            ret = true;
+        }
+        return ret;
+    }
+
+    public virtual bool CalculateTransforms()
+    {
+        bool ret = false;
+        if (m_enabled)
+        {
+            // Recompute the internal transforms
+            PhysicsScene.PE.CalculateTransforms(m_constraint);
+            ret = true;
+        }
+        return ret;
+    }
+
+    // Reset this constraint making sure it has all its internal structures
+    //    recomputed and is enabled and ready to go.
+    public virtual bool RecomputeConstraintVariables(float mass)
+    {
+        bool ret = false;
+        if (m_enabled)
+        {
+            ret = CalculateTransforms();
+            if (ret)
+            {
+                // Setting an object's mass to zero (making it static like when it's selected)
+                //     automatically disables the constraints.
+                // If the link is enabled, be sure to set the constraint itself to enabled.
+                PhysicsScene.PE.SetConstraintEnable(m_constraint, BSParam.NumericBool(true));
+            }
+            else
+            {
+                m_world.physicsScene.Logger.ErrorFormat("{0} CalculateTransforms failed. A={1}, B={2}", LogHeader, Body1.ID, Body2.ID);
+            }
+        }
+        return ret;
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraint6Dof.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraint6Dof.cs
new file mode 100755
index 0000000..4bcde2b
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraint6Dof.cs
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+public class BSConstraint6Dof : BSConstraint
+{
+    private static string LogHeader = "[BULLETSIM 6DOF CONSTRAINT]";
+
+    public override ConstraintType Type { get { return ConstraintType.D6_CONSTRAINT_TYPE; } }
+
+    public BSConstraint6Dof(BulletWorld world, BulletBody obj1, BulletBody obj2) :base(world)
+    {
+        m_body1 = obj1;
+        m_body2 = obj2;
+        m_enabled = false;
+    }
+
+    // Create a btGeneric6DofConstraint
+    public BSConstraint6Dof(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frame1, Quaternion frame1rot,
+                    Vector3 frame2, Quaternion frame2rot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+        : base(world)
+    {
+        m_body1 = obj1;
+        m_body2 = obj2;
+        m_constraint = PhysicsScene.PE.Create6DofConstraint(m_world, m_body1, m_body2,
+                                frame1, frame1rot,
+                                frame2, frame2rot,
+                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+        m_enabled = true;
+        PhysicsScene.DetailLog("{0},BS6DofConstraint,create,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
+                            m_body1.ID, world.worldID,
+                            obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
+        PhysicsScene.DetailLog("{0},BS6DofConstraint,create,  f1Loc={1},f1Rot={2},f2Loc={3},f2Rot={4},usefA={5},disCol={6}",
+                            m_body1.ID, frame1, frame1rot, frame2, frame2rot, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+    }
+
+    // 6 Dof constraint based on a midpoint between the two constrained bodies
+    public BSConstraint6Dof(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 joinPoint,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+        : base(world)
+    {
+        m_body1 = obj1;
+        m_body2 = obj2;
+        if (!obj1.HasPhysicalBody || !obj2.HasPhysicalBody)
+        {
+            world.physicsScene.DetailLog("{0},BS6DOFConstraint,badBodyPtr,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
+                            BSScene.DetailLogZero, world.worldID,
+                            obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
+            world.physicsScene.Logger.ErrorFormat("{0} Attempt to build 6DOF constraint with missing bodies: wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
+                            LogHeader, world.worldID, obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
+            m_enabled = false;
+        }
+        else
+        {
+            m_constraint = PhysicsScene.PE.Create6DofConstraintToPoint(m_world, m_body1, m_body2,
+                                    joinPoint,
+                                    useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+
+            PhysicsScene.DetailLog("{0},BS6DofConstraint,createMidPoint,wID={1}, csrt={2}, rID={3}, rBody={4}, cID={5}, cBody={6}",
+                                m_body1.ID, world.worldID, m_constraint.AddrString,
+                                obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
+
+            if (!m_constraint.HasPhysicalConstraint)
+            {
+                world.physicsScene.Logger.ErrorFormat("{0} Failed creation of 6Dof constraint. rootID={1}, childID={2}",
+                                LogHeader, obj1.ID, obj2.ID);
+                m_enabled = false;
+            }
+            else
+            {
+                m_enabled = true;
+            }
+        }
+    }
+
+    // A 6 Dof constraint that is fixed in the world and constrained to a on-the-fly created static object
+    public BSConstraint6Dof(BulletWorld world, BulletBody obj1, Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool useLinearReferenceFrameB, bool disableCollisionsBetweenLinkedBodies)
+        : base(world)
+    {
+        m_body1 = obj1;
+        m_body2 = obj1; // Look out for confusion down the road
+        m_constraint = PhysicsScene.PE.Create6DofConstraintFixed(m_world, m_body1,
+                                frameInBloc, frameInBrot,
+                                useLinearReferenceFrameB, disableCollisionsBetweenLinkedBodies);
+        m_enabled = true;
+        PhysicsScene.DetailLog("{0},BS6DofConstraint,createFixed,wID={1},rID={2},rBody={3}",
+                                    m_body1.ID, world.worldID, obj1.ID, obj1.AddrString);
+        PhysicsScene.DetailLog("{0},BS6DofConstraint,createFixed,  fBLoc={1},fBRot={2},usefA={3},disCol={4}",
+                            m_body1.ID, frameInBloc, frameInBrot, useLinearReferenceFrameB, disableCollisionsBetweenLinkedBodies);
+    }
+
+    public bool SetFrames(Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot)
+    {
+        bool ret = false;
+        if (m_enabled)
+        {
+            PhysicsScene.PE.SetFrames(m_constraint, frameA, frameArot, frameB, frameBrot);
+            ret = true;
+        }
+        return ret;
+    }
+
+    public bool SetCFMAndERP(float cfm, float erp)
+    {
+        bool ret = false;
+        if (m_enabled)
+        {
+            PhysicsScene.PE.SetConstraintParam(m_constraint, ConstraintParams.BT_CONSTRAINT_STOP_CFM, cfm, ConstraintParamAxis.AXIS_ALL);
+            PhysicsScene.PE.SetConstraintParam(m_constraint, ConstraintParams.BT_CONSTRAINT_STOP_ERP, erp, ConstraintParamAxis.AXIS_ALL);
+            PhysicsScene.PE.SetConstraintParam(m_constraint, ConstraintParams.BT_CONSTRAINT_CFM, cfm, ConstraintParamAxis.AXIS_ALL);
+            ret = true;
+        }
+        return ret;
+    }
+
+    public bool UseFrameOffset(bool useOffset)
+    {
+        bool ret = false;
+        float onOff = useOffset ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse;
+        if (m_enabled)
+            ret = PhysicsScene.PE.UseFrameOffset(m_constraint, onOff);
+        return ret;
+    }
+
+    public bool TranslationalLimitMotor(bool enable, float targetVelocity, float maxMotorForce)
+    {
+        bool ret = false;
+        float onOff = enable ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse;
+        if (m_enabled)
+        {
+            ret = PhysicsScene.PE.TranslationalLimitMotor(m_constraint, onOff, targetVelocity, maxMotorForce);
+            m_world.physicsScene.DetailLog("{0},BS6DOFConstraint,TransLimitMotor,enable={1},vel={2},maxForce={3}",
+                            BSScene.DetailLogZero, enable, targetVelocity, maxMotorForce);
+        }
+        return ret;
+    }
+
+    public bool SetBreakingImpulseThreshold(float threshold)
+    {
+        bool ret = false;
+        if (m_enabled)
+            ret = PhysicsScene.PE.SetBreakingImpulseThreshold(m_constraint, threshold);
+        return ret;
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintCollection.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintCollection.cs
new file mode 100755
index 0000000..5746ac1
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintCollection.cs
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using log4net;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+public sealed class BSConstraintCollection : IDisposable
+{
+    // private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+    // private static readonly string LogHeader = "[CONSTRAINT COLLECTION]";
+
+    delegate bool ConstraintAction(BSConstraint constrain);
+
+    private List<BSConstraint> m_constraints;
+    private BulletWorld m_world;
+
+    public BSConstraintCollection(BulletWorld world)
+    {
+        m_world = world;
+        m_constraints = new List<BSConstraint>();
+    }
+
+    public void Dispose()
+    {
+        this.Clear();
+    }
+
+    public void Clear()
+    {
+        lock (m_constraints)
+        {
+            foreach (BSConstraint cons in m_constraints)
+            {
+                cons.Dispose();
+            }
+            m_constraints.Clear();
+        }
+    }
+
+    public bool AddConstraint(BSConstraint cons)
+    {
+        lock (m_constraints)
+        {
+            // There is only one constraint between any bodies. Remove any old just to make sure.
+            RemoveAndDestroyConstraint(cons.Body1, cons.Body2);
+
+            m_constraints.Add(cons);
+        }
+
+        return true;
+    }
+
+    // Get the constraint between two bodies. There can be only one.
+    // Return 'true' if a constraint was found.
+    public bool TryGetConstraint(BulletBody body1, BulletBody body2, out BSConstraint returnConstraint)
+    {
+        bool found = false;
+        BSConstraint foundConstraint = null;
+
+        uint lookingID1 = body1.ID;
+        uint lookingID2 = body2.ID;
+        lock (m_constraints)
+        {
+            foreach (BSConstraint constrain in m_constraints)
+            {
+                if ((constrain.Body1.ID == lookingID1 && constrain.Body2.ID == lookingID2)
+                    || (constrain.Body1.ID == lookingID2 && constrain.Body2.ID == lookingID1))
+                {
+                    foundConstraint = constrain;
+                    found = true;
+                    break;
+                }
+            }
+        }
+        returnConstraint = foundConstraint;
+        return found;
+    }
+
+    // Remove any constraint between the passed bodies.
+    // Presumed there is only one such constraint possible.
+    // Return 'true' if a constraint was found and destroyed.
+    public bool RemoveAndDestroyConstraint(BulletBody body1, BulletBody body2)
+    {
+        bool ret = false;
+        lock (m_constraints)
+        {
+            BSConstraint constrain;
+            if (this.TryGetConstraint(body1, body2, out constrain))
+            {
+                // remove the constraint from our collection
+                ret = RemoveAndDestroyConstraint(constrain);
+            }
+        }
+
+        return ret;
+    }
+
+    // The constraint MUST exist in the collection
+    // Could be called if the constraint was previously removed.
+    // Return 'true' if the constraint was actually removed and disposed.
+    public bool RemoveAndDestroyConstraint(BSConstraint constrain)
+    {
+        bool removed = false;
+        lock (m_constraints)
+        {
+            // remove the constraint from our collection
+            removed = m_constraints.Remove(constrain);
+        }
+        // Dispose() is safe to call multiple times
+        constrain.Dispose();
+        return removed;
+    }
+
+    // Remove all constraints that reference the passed body.
+    // Return 'true' if any constraints were destroyed.
+    public bool RemoveAndDestroyConstraint(BulletBody body1)
+    {
+        List<BSConstraint> toRemove = new List<BSConstraint>();
+        uint lookingID = body1.ID;
+        lock (m_constraints)
+        {
+            foreach (BSConstraint constrain in m_constraints)
+            {
+                if (constrain.Body1.ID == lookingID || constrain.Body2.ID == lookingID)
+                {
+                    toRemove.Add(constrain);
+                }
+            }
+            foreach (BSConstraint constrain in toRemove)
+            {
+                m_constraints.Remove(constrain);
+                constrain.Dispose();
+            }
+        }
+        return (toRemove.Count > 0);
+    }
+
+    public bool RecalculateAllConstraints()
+    {
+        bool ret = false;
+        lock (m_constraints)
+        {
+            foreach (BSConstraint constrain in m_constraints)
+            {
+                constrain.CalculateTransforms();
+                ret = true;
+            }
+        }
+        return ret;
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintConeTwist.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintConeTwist.cs
new file mode 100755
index 0000000..e7566a8
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintConeTwist.cs
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+public sealed class BSConstraintConeTwist : BSConstraint
+{
+    public override ConstraintType Type { get { return ConstraintType.CONETWIST_CONSTRAINT_TYPE; } }
+
+    public BSConstraintConeTwist(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frameInAloc, Quaternion frameInArot,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool disableCollisionsBetweenLinkedBodies)
+        : base(world)
+    {
+        m_body1 = obj1;
+        m_body2 = obj2;
+        m_constraint = PhysicsScene.PE.CreateConeTwistConstraint(world, obj1, obj2,
+                                frameInAloc, frameInArot, frameInBloc, frameInBrot,
+                                disableCollisionsBetweenLinkedBodies);
+        m_enabled = true;
+    }
+}
+
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintHinge.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintHinge.cs
new file mode 100755
index 0000000..d20538d
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintHinge.cs
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+public sealed class BSConstraintHinge : BSConstraint
+{
+    public override ConstraintType Type { get { return ConstraintType.HINGE_CONSTRAINT_TYPE; } }
+
+    public BSConstraintHinge(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 pivotInA, Vector3 pivotInB,
+                    Vector3 axisInA, Vector3 axisInB,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+        : base(world)
+    {
+        m_body1 = obj1;
+        m_body2 = obj2;
+        m_constraint = PhysicsScene.PE.CreateHingeConstraint(world, obj1, obj2,
+                                pivotInA, pivotInB, axisInA, axisInB,
+                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+        m_enabled = true;
+    }
+
+}
+
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSlider.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSlider.cs
new file mode 100755
index 0000000..83d42af
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSlider.cs
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+public sealed class BSConstraintSlider : BSConstraint
+{
+    public override ConstraintType Type { get { return ConstraintType.SLIDER_CONSTRAINT_TYPE; } }
+
+    public BSConstraintSlider(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frameInAloc, Quaternion frameInArot,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+        : base(world)
+    {
+        m_body1 = obj1;
+        m_body2 = obj2;
+        m_constraint = PhysicsScene.PE.CreateSliderConstraint(world, obj1, obj2,
+                                frameInAloc, frameInArot, frameInBloc, frameInBrot,
+                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+        m_enabled = true;
+    }
+
+}
+
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSpring.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSpring.cs
new file mode 100755
index 0000000..563a1b1
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSpring.cs
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+public sealed class BSConstraintSpring : BSConstraint6Dof
+{
+    public override ConstraintType Type { get { return ConstraintType.D6_SPRING_CONSTRAINT_TYPE; } }
+
+    public BSConstraintSpring(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frame1Loc, Quaternion frame1Rot,
+                    Vector3 frame2Loc, Quaternion frame2Rot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+        :base(world, obj1, obj2)
+    {
+        m_constraint = PhysicsScene.PE.Create6DofSpringConstraint(world, obj1, obj2,
+                                frame1Loc, frame1Rot, frame2Loc, frame2Rot,
+                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+        m_enabled = true;
+
+        PhysicsScene.DetailLog("{0},BSConstraintSpring,create,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
+                            obj1.ID, world.worldID, obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
+        PhysicsScene.DetailLog("{0},BSConstraintSpring,create,  f1Loc={1},f1Rot={2},f2Loc={3},f2Rot={4},usefA={5},disCol={6}",
+                    m_body1.ID, frame1Loc, frame1Rot, frame2Loc, frame2Rot, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+    }
+
+    public bool SetAxisEnable(int pIndex, bool pAxisEnable)
+    {
+        PhysicsScene.DetailLog("{0},BSConstraintSpring.SetEnable,obj1ID={1},obj2ID={2},indx={3},enable={4}",
+                                        m_body1.ID, m_body1.ID, m_body2.ID, pIndex, pAxisEnable);
+        PhysicsScene.PE.SpringEnable(m_constraint, pIndex, BSParam.NumericBool(pAxisEnable));
+        return true;
+    }
+
+    public bool SetStiffness(int pIndex, float pStiffness)
+    {
+        PhysicsScene.DetailLog("{0},BSConstraintSpring.SetStiffness,obj1ID={1},obj2ID={2},indx={3},stiff={4}",
+                                        m_body1.ID, m_body1.ID, m_body2.ID, pIndex, pStiffness);
+        PhysicsScene.PE.SpringSetStiffness(m_constraint, pIndex, pStiffness);
+        return true;
+    }
+
+    public bool SetDamping(int pIndex, float pDamping)
+    {
+        PhysicsScene.DetailLog("{0},BSConstraintSpring.SetDamping,obj1ID={1},obj2ID={2},indx={3},damp={4}",
+                                        m_body1.ID, m_body1.ID, m_body2.ID, pIndex, pDamping);
+        PhysicsScene.PE.SpringSetDamping(m_constraint, pIndex, pDamping);
+        return true;
+    }
+
+    public bool SetEquilibriumPoint(int pIndex, float pEqPoint)
+    {
+        PhysicsScene.DetailLog("{0},BSConstraintSpring.SetEquilibriumPoint,obj1ID={1},obj2ID={2},indx={3},eqPoint={4}",
+                                        m_body1.ID, m_body1.ID, m_body2.ID, pIndex, pEqPoint);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, pIndex, pEqPoint);
+        return true;
+    }
+
+    public bool SetEquilibriumPoint(Vector3 linearEq, Vector3 angularEq)
+    {
+        PhysicsScene.DetailLog("{0},BSConstraintSpring.SetEquilibriumPoint,obj1ID={1},obj2ID={2},linearEq={3},angularEq={4}",
+                                        m_body1.ID, m_body1.ID, m_body2.ID, linearEq, angularEq);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 0, linearEq.X);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 1, linearEq.Y);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 2, linearEq.Z);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 3, angularEq.X);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 4, angularEq.Y);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 5, angularEq.Z);
+        return true;
+    }
+
+}
+
+}
\ No newline at end of file
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs b/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs
new file mode 100644
index 0000000..0fc5577
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs
@@ -0,0 +1,1800 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The quotations from http://wiki.secondlife.com/wiki/Linden_Vehicle_Tutorial
+ * are Copyright (c) 2009 Linden Research, Inc and are used under their license
+ * of Creative Commons Attribution-Share Alike 3.0
+ * (http://creativecommons.org/licenses/by-sa/3.0/).
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+    public sealed class BSDynamics : BSActor
+    {
+#pragma warning disable 414
+        private static string LogHeader = "[BULLETSIM VEHICLE]";
+#pragma warning restore 414
+
+        // the prim this dynamic controller belongs to
+        private BSPrimLinkable ControllingPrim { get; set; }
+
+        private bool m_haveRegisteredForSceneEvents;
+
+        // mass of the vehicle fetched each time we're calles
+        private float m_vehicleMass;
+
+        // Vehicle properties
+        public Vehicle Type { get; set; }
+
+        // private Quaternion m_referenceFrame = Quaternion.Identity;   // Axis modifier
+        private VehicleFlag m_flags = (VehicleFlag) 0;                  // Boolean settings:
+                                                                        // HOVER_TERRAIN_ONLY
+                                                                        // HOVER_GLOBAL_HEIGHT
+                                                                        // NO_DEFLECTION_UP
+                                                                        // HOVER_WATER_ONLY
+                                                                        // HOVER_UP_ONLY
+                                                                        // LIMIT_MOTOR_UP
+                                                                        // LIMIT_ROLL_ONLY
+        private Vector3 m_BlockingEndPoint = Vector3.Zero;
+        private Quaternion m_RollreferenceFrame = Quaternion.Identity;
+        private Quaternion m_referenceFrame = Quaternion.Identity;
+
+        // Linear properties
+        private BSVMotor m_linearMotor = new BSVMotor("LinearMotor");
+        private Vector3 m_linearMotorDirection = Vector3.Zero;          // velocity requested by LSL, decayed by time
+        private Vector3 m_linearMotorOffset = Vector3.Zero;             // the point of force can be offset from the center
+        private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero;   // velocity requested by LSL
+        private Vector3 m_linearFrictionTimescale = Vector3.Zero;
+        private float m_linearMotorDecayTimescale = 1;
+        private float m_linearMotorTimescale = 1;
+        private Vector3 m_lastLinearVelocityVector = Vector3.Zero;
+        private Vector3 m_lastPositionVector = Vector3.Zero;
+        // private bool m_LinearMotorSetLastFrame = false;
+        // private Vector3 m_linearMotorOffset = Vector3.Zero;
+
+        //Angular properties
+        private BSVMotor m_angularMotor = new BSVMotor("AngularMotor");
+        private Vector3 m_angularMotorDirection = Vector3.Zero;         // angular velocity requested by LSL motor
+        // private int m_angularMotorApply = 0;                            // application frame counter
+        private Vector3 m_angularMotorVelocity = Vector3.Zero;          // current angular motor velocity
+        private float m_angularMotorTimescale = 1;                      // motor angular velocity ramp up rate
+        private float m_angularMotorDecayTimescale = 1;                 // motor angular velocity decay rate
+        private Vector3 m_angularFrictionTimescale = Vector3.Zero;      // body angular velocity  decay rate
+        private Vector3 m_lastAngularVelocity = Vector3.Zero;
+        private Vector3 m_lastVertAttractor = Vector3.Zero;             // what VA was last applied to body
+
+        //Deflection properties
+        private BSVMotor m_angularDeflectionMotor = new BSVMotor("AngularDeflection");
+        private float m_angularDeflectionEfficiency = 0;
+        private float m_angularDeflectionTimescale = 0;
+        private float m_linearDeflectionEfficiency = 0;
+        private float m_linearDeflectionTimescale = 0;
+
+        //Banking properties
+        private float m_bankingEfficiency = 0;
+        private float m_bankingMix = 1;
+        private float m_bankingTimescale = 0;
+
+        //Hover and Buoyancy properties
+        private BSVMotor m_hoverMotor = new BSVMotor("Hover");
+        private float m_VhoverHeight = 0f;
+        private float m_VhoverEfficiency = 0f;
+        private float m_VhoverTimescale = 0f;
+        private float m_VhoverTargetHeight = -1.0f;     // if <0 then no hover, else its the current target height
+        // Modifies gravity. Slider between -1 (double-gravity) and 1 (full anti-gravity)
+        private float m_VehicleBuoyancy = 0f;
+        private Vector3 m_VehicleGravity = Vector3.Zero;    // Gravity computed when buoyancy set
+
+        //Attractor properties
+        private BSVMotor m_verticalAttractionMotor = new BSVMotor("VerticalAttraction");
+        private float m_verticalAttractionEfficiency = 1.0f; // damped
+        private float m_verticalAttractionCutoff = 500f;     // per the documentation
+        // Timescale > cutoff  means no vert attractor.
+        private float m_verticalAttractionTimescale = 510f;
+
+        // Just some recomputed constants:
+#pragma warning disable 414
+        static readonly float TwoPI = ((float)Math.PI) * 2f; 
+        static readonly float FourPI = ((float)Math.PI) * 4f; 
+        static readonly float PIOverFour = ((float)Math.PI) / 4f;
+        static readonly float PIOverTwo = ((float)Math.PI) / 2f;
+#pragma warning restore 414
+
+        public BSDynamics(BSScene myScene, BSPrim myPrim, string actorName)
+            : base(myScene, myPrim, actorName)
+        {
+            Type = Vehicle.TYPE_NONE;
+            m_haveRegisteredForSceneEvents = false;
+
+            ControllingPrim = myPrim as BSPrimLinkable;
+            if (ControllingPrim == null)
+            {
+                // THIS CANNOT HAPPEN!!
+            }
+            VDetailLog("{0},Creation", ControllingPrim.LocalID);
+        }
+
+        // Return 'true' if this vehicle is doing vehicle things
+        public bool IsActive
+        {
+            get { return (Type != Vehicle.TYPE_NONE && ControllingPrim.IsPhysicallyActive); }
+        }
+
+        // Return 'true' if this a vehicle that should be sitting on the ground
+        public bool IsGroundVehicle
+        {
+            get { return (Type == Vehicle.TYPE_CAR || Type == Vehicle.TYPE_SLED); }
+        }
+
+        #region Vehicle parameter setting
+        public void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
+        {
+            VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
+            float clampTemp;
+
+            switch (pParam)
+            {
+                case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
+                    m_angularDeflectionEfficiency = ClampInRange(0f, pValue, 1f);
+                    break;
+                case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
+                    m_angularDeflectionTimescale = ClampInRange(0.25f, pValue, 120);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
+                    m_angularMotorDecayTimescale = ClampInRange(0.25f, pValue, 120);
+                    m_angularMotor.TargetValueDecayTimeScale = m_angularMotorDecayTimescale;
+                    break;
+                case Vehicle.ANGULAR_MOTOR_TIMESCALE:
+                    m_angularMotorTimescale = ClampInRange(0.25f, pValue, 120);
+                    m_angularMotor.TimeScale = m_angularMotorTimescale;
+                    break;
+                case Vehicle.BANKING_EFFICIENCY:
+                    m_bankingEfficiency = ClampInRange(-1f, pValue, 1f);
+                    break;
+                case Vehicle.BANKING_MIX:
+                    m_bankingMix = ClampInRange(0.01f, pValue, 1);
+                    break;
+                case Vehicle.BANKING_TIMESCALE:
+                    m_bankingTimescale = ClampInRange(0.25f, pValue, 120);
+                    break;
+                case Vehicle.BUOYANCY:
+                    m_VehicleBuoyancy = ClampInRange(-1f, pValue, 1f);
+                    m_VehicleGravity = ControllingPrim.ComputeGravity(m_VehicleBuoyancy);
+                    break;
+                case Vehicle.HOVER_EFFICIENCY:
+                    m_VhoverEfficiency = ClampInRange(0.01f, pValue, 1f);
+                    break;
+                case Vehicle.HOVER_HEIGHT:
+                    m_VhoverHeight = ClampInRange(0f, pValue, 1000000f);
+                    break;
+                case Vehicle.HOVER_TIMESCALE:
+                    m_VhoverTimescale = ClampInRange(0.01f, pValue, 120);
+                    break;
+                case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
+                    m_linearDeflectionEfficiency = ClampInRange(0f, pValue, 1f);
+                    break;
+                case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
+                    m_linearDeflectionTimescale = ClampInRange(0.01f, pValue, 120);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
+                    m_linearMotorDecayTimescale = ClampInRange(0.01f, pValue, 120);
+                    m_linearMotor.TargetValueDecayTimeScale = m_linearMotorDecayTimescale;
+                    break;
+                case Vehicle.LINEAR_MOTOR_TIMESCALE:
+                    m_linearMotorTimescale = ClampInRange(0.01f, pValue, 120);
+                    m_linearMotor.TimeScale = m_linearMotorTimescale;
+                    break;
+                case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
+                    m_verticalAttractionEfficiency = ClampInRange(0.1f, pValue, 1f);
+                    m_verticalAttractionMotor.Efficiency = m_verticalAttractionEfficiency;
+                    break;
+                case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
+                    m_verticalAttractionTimescale = ClampInRange(0.01f, pValue, 120);
+                    m_verticalAttractionMotor.TimeScale = m_verticalAttractionTimescale;
+                    break;
+
+                // These are vector properties but the engine lets you use a single float value to
+                // set all of the components to the same value
+                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    clampTemp = ClampInRange(0.01f, pValue, 120);
+                    m_angularFrictionTimescale = new Vector3(clampTemp, clampTemp, clampTemp);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DIRECTION:
+                    clampTemp = ClampInRange(-TwoPI, pValue, TwoPI);
+                    m_angularMotorDirection = new Vector3(clampTemp, clampTemp, clampTemp);
+                    m_angularMotor.Zero();
+                    m_angularMotor.SetTarget(m_angularMotorDirection);
+                    break;
+                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    clampTemp = ClampInRange(0.01f, pValue, 120);
+                    m_linearFrictionTimescale = new Vector3(clampTemp, clampTemp, clampTemp);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    clampTemp = ClampInRange(-BSParam.MaxLinearVelocity, pValue, BSParam.MaxLinearVelocity);
+                    m_linearMotorDirection = new Vector3(clampTemp, clampTemp, clampTemp);
+                    m_linearMotorDirectionLASTSET = new Vector3(clampTemp, clampTemp, clampTemp);
+                    m_linearMotor.SetTarget(m_linearMotorDirection);
+                    break;
+                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    clampTemp = ClampInRange(-1000, pValue, 1000);
+                    m_linearMotorOffset = new Vector3(clampTemp, clampTemp, clampTemp);
+                    break;
+
+            }
+        }//end ProcessFloatVehicleParam
+
+        internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
+        {
+            VDetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
+            switch (pParam)
+            {
+                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    pValue.X = ClampInRange(0.25f, pValue.X, 120);
+                    pValue.Y = ClampInRange(0.25f, pValue.Y, 120);
+                    pValue.Z = ClampInRange(0.25f, pValue.Z, 120);
+                    m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DIRECTION:
+                    // Limit requested angular speed to 2 rps= 4 pi rads/sec
+                    pValue.X = ClampInRange(-FourPI, pValue.X, FourPI);
+                    pValue.Y = ClampInRange(-FourPI, pValue.Y, FourPI);
+                    pValue.Z = ClampInRange(-FourPI, pValue.Z, FourPI);
+                    m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    m_angularMotor.Zero();
+                    m_angularMotor.SetTarget(m_angularMotorDirection);
+                    break;
+                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    pValue.X = ClampInRange(0.25f, pValue.X, 120);
+                    pValue.Y = ClampInRange(0.25f, pValue.Y, 120);
+                    pValue.Z = ClampInRange(0.25f, pValue.Z, 120);
+                    m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    pValue.X = ClampInRange(-BSParam.MaxLinearVelocity, pValue.X, BSParam.MaxLinearVelocity);
+                    pValue.Y = ClampInRange(-BSParam.MaxLinearVelocity, pValue.Y, BSParam.MaxLinearVelocity);
+                    pValue.Z = ClampInRange(-BSParam.MaxLinearVelocity, pValue.Z, BSParam.MaxLinearVelocity);
+                    m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    m_linearMotor.SetTarget(m_linearMotorDirection);
+                    break;
+                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    // Not sure the correct range to limit this variable
+                    pValue.X = ClampInRange(-1000, pValue.X, 1000);
+                    pValue.Y = ClampInRange(-1000, pValue.Y, 1000);
+                    pValue.Z = ClampInRange(-1000, pValue.Z, 1000);
+                    m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.BLOCK_EXIT:
+                    // Not sure the correct range to limit this variable
+                    pValue.X = ClampInRange(-10000, pValue.X, 10000);
+                    pValue.Y = ClampInRange(-10000, pValue.Y, 10000);
+                    pValue.Z = ClampInRange(-10000, pValue.Z, 10000);
+                    m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+            }
+        }//end ProcessVectorVehicleParam
+
+        internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
+        {
+            VDetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
+            switch (pParam)
+            {
+                case Vehicle.REFERENCE_FRAME:
+                    m_referenceFrame = pValue;
+                    break;
+                case Vehicle.ROLL_FRAME:
+                    m_RollreferenceFrame = pValue;
+                    break;
+            }
+        }//end ProcessRotationVehicleParam
+
+        internal void ProcessVehicleFlags(int pParam, bool remove)
+        {
+            VDetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", ControllingPrim.LocalID, pParam, remove);
+            VehicleFlag parm = (VehicleFlag)pParam;
+            if (pParam == -1)
+                m_flags = (VehicleFlag)0;
+            else
+            {
+                if (remove)
+                    m_flags &= ~parm;
+                else
+                    m_flags |= parm;
+            }
+        }
+
+        public void ProcessTypeChange(Vehicle pType)
+        {
+            VDetailLog("{0},ProcessTypeChange,type={1}", ControllingPrim.LocalID, pType);
+            // Set Defaults For Type
+            Type = pType;
+            switch (pType)
+            {
+                case Vehicle.TYPE_NONE:
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 0;
+                    m_linearMotorDecayTimescale = 0;
+                    m_linearFrictionTimescale = new Vector3(0, 0, 0);
+
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorDecayTimescale = 0;
+                    m_angularMotorTimescale = 0;
+                    m_angularFrictionTimescale = new Vector3(0, 0, 0);
+
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 0;
+                    m_VhoverTimescale = 0;
+                    m_VehicleBuoyancy = 0;
+
+                    m_linearDeflectionEfficiency = 1;
+                    m_linearDeflectionTimescale = 1;
+
+                    m_angularDeflectionEfficiency = 0;
+                    m_angularDeflectionTimescale = 1000;
+
+                    m_verticalAttractionEfficiency = 0;
+                    m_verticalAttractionTimescale = 0;
+
+                    m_bankingEfficiency = 0;
+                    m_bankingTimescale = 1000;
+                    m_bankingMix = 1;
+
+                    m_referenceFrame = Quaternion.Identity;
+                    m_flags = (VehicleFlag)0;
+
+                    break;
+
+                case Vehicle.TYPE_SLED:
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 1000;
+                    m_linearMotorDecayTimescale = 120;
+                    m_linearFrictionTimescale = new Vector3(30, 1, 1000);
+
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 1000;
+                    m_angularMotorDecayTimescale = 120;
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 10;    // TODO: this looks wrong!!
+                    m_VhoverTimescale = 10;
+                    m_VehicleBuoyancy = 0;
+
+                    m_linearDeflectionEfficiency = 1;
+                    m_linearDeflectionTimescale = 1;
+
+                    m_angularDeflectionEfficiency = 1;
+                    m_angularDeflectionTimescale = 1000;
+
+                    m_verticalAttractionEfficiency = 0;
+                    m_verticalAttractionTimescale = 0;
+
+                    m_bankingEfficiency = 0;
+                    m_bankingTimescale = 10;
+                    m_bankingMix = 1;
+
+                    m_referenceFrame = Quaternion.Identity;
+                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY
+                                | VehicleFlag.HOVER_TERRAIN_ONLY
+                                | VehicleFlag.HOVER_GLOBAL_HEIGHT
+                                | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP
+                            | VehicleFlag.LIMIT_ROLL_ONLY
+                            | VehicleFlag.LIMIT_MOTOR_UP);
+
+                    break;
+                case Vehicle.TYPE_CAR:
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 1;
+                    m_linearMotorDecayTimescale = 60;
+                    m_linearFrictionTimescale = new Vector3(100, 2, 1000);
+
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 1;
+                    m_angularMotorDecayTimescale = 0.8f;
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 0;
+                    m_VhoverTimescale = 1000;
+                    m_VehicleBuoyancy = 0;
+
+                    m_linearDeflectionEfficiency = 1;
+                    m_linearDeflectionTimescale = 2;
+
+                    m_angularDeflectionEfficiency = 0;
+                    m_angularDeflectionTimescale = 10;
+
+                    m_verticalAttractionEfficiency = 1f;
+                    m_verticalAttractionTimescale = 10f;
+
+                    m_bankingEfficiency = -0.2f;
+                    m_bankingMix = 1;
+                    m_bankingTimescale = 1;
+
+                    m_referenceFrame = Quaternion.Identity;
+                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY
+                                | VehicleFlag.HOVER_TERRAIN_ONLY
+                                | VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP
+                                | VehicleFlag.LIMIT_ROLL_ONLY
+                                | VehicleFlag.LIMIT_MOTOR_UP
+                                | VehicleFlag.HOVER_UP_ONLY);
+                    break;
+                case Vehicle.TYPE_BOAT:
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 5;
+                    m_linearMotorDecayTimescale = 60;
+                    m_linearFrictionTimescale = new Vector3(10, 3, 2);
+
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 4;
+                    m_angularMotorDecayTimescale = 4;
+                    m_angularFrictionTimescale = new Vector3(10,10,10);
+
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 0.5f;
+                    m_VhoverTimescale = 2;
+                    m_VehicleBuoyancy = 1;
+
+                    m_linearDeflectionEfficiency = 0.5f;
+                    m_linearDeflectionTimescale = 3;
+
+                    m_angularDeflectionEfficiency = 0.5f;
+                    m_angularDeflectionTimescale = 5;
+
+                    m_verticalAttractionEfficiency = 0.5f;
+                    m_verticalAttractionTimescale = 5f;
+
+                    m_bankingEfficiency = -0.3f;
+                    m_bankingMix = 0.8f;
+                    m_bankingTimescale = 1;
+
+                    m_referenceFrame = Quaternion.Identity;
+                    m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY
+                                    | VehicleFlag.HOVER_GLOBAL_HEIGHT
+                                    | VehicleFlag.LIMIT_ROLL_ONLY
+                                    | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP
+                                    | VehicleFlag.LIMIT_MOTOR_UP
+                                    | VehicleFlag.HOVER_WATER_ONLY);
+                    break;
+                case Vehicle.TYPE_AIRPLANE:
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 2;
+                    m_linearMotorDecayTimescale = 60;
+                    m_linearFrictionTimescale = new Vector3(200, 10, 5);
+
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 4;
+                    m_angularMotorDecayTimescale = 4;
+                    m_angularFrictionTimescale = new Vector3(20, 20, 20);
+
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 0.5f;
+                    m_VhoverTimescale = 1000;
+                    m_VehicleBuoyancy = 0;
+
+                    m_linearDeflectionEfficiency = 0.5f;
+                    m_linearDeflectionTimescale = 3;
+
+                    m_angularDeflectionEfficiency = 1;
+                    m_angularDeflectionTimescale = 2;
+
+                    m_verticalAttractionEfficiency = 0.9f;
+                    m_verticalAttractionTimescale = 2f;
+
+                    m_bankingEfficiency = 1;
+                    m_bankingMix = 0.7f;
+                    m_bankingTimescale = 2;
+
+                    m_referenceFrame = Quaternion.Identity;
+                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY
+                                    | VehicleFlag.HOVER_TERRAIN_ONLY
+                                    | VehicleFlag.HOVER_GLOBAL_HEIGHT
+                                    | VehicleFlag.HOVER_UP_ONLY
+                                    | VehicleFlag.NO_DEFLECTION_UP
+                                    | VehicleFlag.LIMIT_MOTOR_UP);
+                    m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
+                    break;
+                case Vehicle.TYPE_BALLOON:
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 5;
+                    m_linearFrictionTimescale = new Vector3(5, 5, 5);
+                    m_linearMotorDecayTimescale = 60;
+
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 6;
+                    m_angularFrictionTimescale = new Vector3(10, 10, 10);
+                    m_angularMotorDecayTimescale = 10;
+
+                    m_VhoverHeight = 5;
+                    m_VhoverEfficiency = 0.8f;
+                    m_VhoverTimescale = 10;
+                    m_VehicleBuoyancy = 1;
+
+                    m_linearDeflectionEfficiency = 0;
+                    m_linearDeflectionTimescale = 5;
+
+                    m_angularDeflectionEfficiency = 0;
+                    m_angularDeflectionTimescale = 5;
+
+                    m_verticalAttractionEfficiency = 1f;
+                    m_verticalAttractionTimescale = 100f;
+
+                    m_bankingEfficiency = 0;
+                    m_bankingMix = 0.7f;
+                    m_bankingTimescale = 5;
+
+                    m_referenceFrame = Quaternion.Identity;
+
+                    m_referenceFrame = Quaternion.Identity;
+                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY
+                                    | VehicleFlag.HOVER_TERRAIN_ONLY
+                                    | VehicleFlag.HOVER_UP_ONLY
+                                    | VehicleFlag.NO_DEFLECTION_UP
+                                    | VehicleFlag.LIMIT_MOTOR_UP);
+                    m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY
+                                    | VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    break;
+            }
+
+            m_linearMotor = new BSVMotor("LinearMotor", m_linearMotorTimescale, m_linearMotorDecayTimescale, 1f);
+            // m_linearMotor.PhysicsScene = m_physicsScene;  // DEBUG DEBUG DEBUG (enables detail logging)
+
+            m_angularMotor = new BSVMotor("AngularMotor", m_angularMotorTimescale, m_angularMotorDecayTimescale, 1f);
+            // m_angularMotor.PhysicsScene = m_physicsScene;  // DEBUG DEBUG DEBUG (enables detail logging)
+
+            /*  Not implemented
+            m_verticalAttractionMotor = new BSVMotor("VerticalAttraction", m_verticalAttractionTimescale,
+                                BSMotor.Infinite, BSMotor.InfiniteVector,
+                                m_verticalAttractionEfficiency);
+            // Z goes away and we keep X and Y
+            m_verticalAttractionMotor.PhysicsScene = PhysicsScene;  // DEBUG DEBUG DEBUG (enables detail logging)
+             */
+
+            if (this.Type == Vehicle.TYPE_NONE)
+            {
+                UnregisterForSceneEvents();
+            }
+            else
+            {
+                RegisterForSceneEvents();
+            }
+
+            // Update any physical parameters based on this type.
+            Refresh();
+        }
+        #endregion // Vehicle parameter setting
+
+        // BSActor.Refresh()
+        public override void Refresh()
+        {
+            // If asking for a refresh, reset the physical parameters before the next simulation step.
+            // Called whether active or not since the active state may be updated before the next step.
+            m_physicsScene.PostTaintObject("BSDynamics.Refresh", ControllingPrim.LocalID, delegate()
+            {
+                SetPhysicalParameters();
+            });
+        }
+
+        // Some of the properties of this prim may have changed.
+        // Do any updating needed for a vehicle
+        private void SetPhysicalParameters()
+        {
+            if (IsActive)
+            {
+                // Remember the mass so we don't have to fetch it every step
+                m_vehicleMass = ControllingPrim.TotalMass;
+
+                // Friction affects are handled by this vehicle code
+                // m_physicsScene.PE.SetFriction(ControllingPrim.PhysBody, BSParam.VehicleFriction);
+                // m_physicsScene.PE.SetRestitution(ControllingPrim.PhysBody, BSParam.VehicleRestitution);
+                ControllingPrim.Linkset.SetPhysicalFriction(BSParam.VehicleFriction);
+                ControllingPrim.Linkset.SetPhysicalRestitution(BSParam.VehicleRestitution);
+
+                // Moderate angular movement introduced by Bullet.
+                // TODO: possibly set AngularFactor and LinearFactor for the type of vehicle.
+                //     Maybe compute linear and angular factor and damping from params.
+                m_physicsScene.PE.SetAngularDamping(ControllingPrim.PhysBody, BSParam.VehicleAngularDamping);
+                m_physicsScene.PE.SetLinearFactor(ControllingPrim.PhysBody, BSParam.VehicleLinearFactor);
+                m_physicsScene.PE.SetAngularFactorV(ControllingPrim.PhysBody, BSParam.VehicleAngularFactor);
+
+                // Vehicles report collision events so we know when it's on the ground
+                // m_physicsScene.PE.AddToCollisionFlags(ControllingPrim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
+                ControllingPrim.Linkset.AddToPhysicalCollisionFlags(CollisionFlags.BS_VEHICLE_COLLISIONS);
+
+                // Vector3 inertia = m_physicsScene.PE.CalculateLocalInertia(ControllingPrim.PhysShape.physShapeInfo, m_vehicleMass);
+                // ControllingPrim.Inertia = inertia * BSParam.VehicleInertiaFactor;
+                // m_physicsScene.PE.SetMassProps(ControllingPrim.PhysBody, m_vehicleMass, ControllingPrim.Inertia);
+                // m_physicsScene.PE.UpdateInertiaTensor(ControllingPrim.PhysBody);
+                ControllingPrim.Linkset.ComputeAndSetLocalInertia(BSParam.VehicleInertiaFactor, m_vehicleMass);
+
+                // Set the gravity for the vehicle depending on the buoyancy
+                // TODO: what should be done if prim and vehicle buoyancy differ?
+                m_VehicleGravity = ControllingPrim.ComputeGravity(m_VehicleBuoyancy);
+                // The actual vehicle gravity is set to zero in Bullet so we can do all the application of same.
+                // m_physicsScene.PE.SetGravity(ControllingPrim.PhysBody, Vector3.Zero);
+                ControllingPrim.Linkset.SetPhysicalGravity(Vector3.Zero);
+
+                VDetailLog("{0},BSDynamics.SetPhysicalParameters,mass={1},inert={2},vehGrav={3},aDamp={4},frict={5},rest={6},lFact={7},aFact={8}",
+                        ControllingPrim.LocalID, m_vehicleMass, ControllingPrim.Inertia, m_VehicleGravity,
+                        BSParam.VehicleAngularDamping, BSParam.VehicleFriction, BSParam.VehicleRestitution,
+                        BSParam.VehicleLinearFactor, BSParam.VehicleAngularFactor
+                        );
+            }
+            else
+            {
+                if (ControllingPrim.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.RemoveFromCollisionFlags(ControllingPrim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
+                // ControllingPrim.Linkset.RemoveFromPhysicalCollisionFlags(CollisionFlags.BS_VEHICLE_COLLISIONS);
+            }
+        }
+
+        // BSActor.RemoveBodyDependencies
+        public override void RemoveDependencies()
+        {
+            Refresh();
+        }
+
+        // BSActor.Release()
+        public override void Dispose()
+        {
+            VDetailLog("{0},Dispose", ControllingPrim.LocalID);
+            UnregisterForSceneEvents();
+            Type = Vehicle.TYPE_NONE;
+            Enabled = false;
+            return;
+        }
+
+        private void RegisterForSceneEvents()
+        {
+            if (!m_haveRegisteredForSceneEvents)
+            {
+                m_physicsScene.BeforeStep += this.Step;
+                m_physicsScene.AfterStep += this.PostStep;
+                ControllingPrim.OnPreUpdateProperty += this.PreUpdateProperty;
+                m_haveRegisteredForSceneEvents = true;
+            }
+        }
+
+        private void UnregisterForSceneEvents()
+        {
+            if (m_haveRegisteredForSceneEvents)
+            {
+                m_physicsScene.BeforeStep -= this.Step;
+                m_physicsScene.AfterStep -= this.PostStep;
+                ControllingPrim.OnPreUpdateProperty -= this.PreUpdateProperty;
+                m_haveRegisteredForSceneEvents = false;
+            }
+        }
+
+        private void PreUpdateProperty(ref EntityProperties entprop)
+        {
+            // A temporary kludge to suppress the rotational effects introduced on vehicles by Bullet
+            // TODO: handle physics introduced by Bullet with computed vehicle physics.
+            if (IsActive)
+            {
+                entprop.RotationalVelocity = Vector3.Zero;
+            }
+        }
+
+        #region Known vehicle value functions
+        // Vehicle physical parameters that we buffer from constant getting and setting.
+        // The "m_known*" values are unknown until they are fetched and the m_knownHas flag is set.
+        //      Changing is remembered and the parameter is stored back into the physics engine only if updated.
+        //      This does two things: 1) saves continuious calls into unmanaged code, and
+        //      2) signals when a physics property update must happen back to the simulator
+        //      to update values modified for the vehicle.
+        private int m_knownChanged;
+        private int m_knownHas;
+        private float m_knownTerrainHeight;
+        private float m_knownWaterLevel;
+        private Vector3 m_knownPosition;
+        private Vector3 m_knownVelocity;
+        private Vector3 m_knownForce;
+        private Vector3 m_knownForceImpulse;
+        private Quaternion m_knownOrientation;
+        private Vector3 m_knownRotationalVelocity;
+        private Vector3 m_knownRotationalForce;
+        private Vector3 m_knownRotationalImpulse;
+
+        private const int m_knownChangedPosition           = 1 << 0;
+        private const int m_knownChangedVelocity           = 1 << 1;
+        private const int m_knownChangedForce              = 1 << 2;
+        private const int m_knownChangedForceImpulse       = 1 << 3;
+        private const int m_knownChangedOrientation        = 1 << 4;
+        private const int m_knownChangedRotationalVelocity = 1 << 5;
+        private const int m_knownChangedRotationalForce    = 1 << 6;
+        private const int m_knownChangedRotationalImpulse  = 1 << 7;
+        private const int m_knownChangedTerrainHeight      = 1 << 8;
+        private const int m_knownChangedWaterLevel         = 1 << 9;
+
+        public void ForgetKnownVehicleProperties()
+        {
+            m_knownHas = 0;
+            m_knownChanged = 0;
+        }
+        // Push all the changed values back into the physics engine
+        public void PushKnownChanged()
+        {
+            if (m_knownChanged != 0)
+            {
+                if ((m_knownChanged & m_knownChangedPosition) != 0)
+                    ControllingPrim.ForcePosition = m_knownPosition;
+
+                if ((m_knownChanged & m_knownChangedOrientation) != 0)
+                    ControllingPrim.ForceOrientation = m_knownOrientation;
+
+                if ((m_knownChanged & m_knownChangedVelocity) != 0)
+                {
+                    ControllingPrim.ForceVelocity = m_knownVelocity;
+                    // Fake out Bullet by making it think the velocity is the same as last time.
+                    // Bullet does a bunch of smoothing for changing parameters.
+                    //    Since the vehicle is demanding this setting, we override Bullet's smoothing
+                    //    by telling Bullet the value was the same last time.
+                    // PhysicsScene.PE.SetInterpolationLinearVelocity(Prim.PhysBody, m_knownVelocity);
+                }
+
+                if ((m_knownChanged & m_knownChangedForce) != 0)
+                    ControllingPrim.AddForce((Vector3)m_knownForce, false /*pushForce*/, true /*inTaintTime*/);
+
+                if ((m_knownChanged & m_knownChangedForceImpulse) != 0)
+                    ControllingPrim.AddForceImpulse((Vector3)m_knownForceImpulse, false /*pushforce*/, true /*inTaintTime*/);
+
+                if ((m_knownChanged & m_knownChangedRotationalVelocity) != 0)
+                {
+                    ControllingPrim.ForceRotationalVelocity = m_knownRotationalVelocity;
+                    // PhysicsScene.PE.SetInterpolationAngularVelocity(Prim.PhysBody, m_knownRotationalVelocity);
+                }
+
+                if ((m_knownChanged & m_knownChangedRotationalImpulse) != 0)
+                    ControllingPrim.ApplyTorqueImpulse((Vector3)m_knownRotationalImpulse, true /*inTaintTime*/);
+
+                if ((m_knownChanged & m_knownChangedRotationalForce) != 0)
+                {
+                    ControllingPrim.AddAngularForce((Vector3)m_knownRotationalForce, false /*pushForce*/, true /*inTaintTime*/);
+                }
+
+                // If we set one of the values (ie, the physics engine didn't do it) we must force
+                //      an UpdateProperties event to send the changes up to the simulator.
+                m_physicsScene.PE.PushUpdate(ControllingPrim.PhysBody);
+            }
+            m_knownChanged = 0;
+        }
+
+        // Since the computation of terrain height can be a little involved, this routine
+        //    is used to fetch the height only once for each vehicle simulation step.
+        Vector3 lastRememberedHeightPos = new Vector3(-1, -1, -1);
+        private float GetTerrainHeight(Vector3 pos)
+        {
+            if ((m_knownHas & m_knownChangedTerrainHeight) == 0 || pos != lastRememberedHeightPos)
+            {
+                lastRememberedHeightPos = pos;
+                m_knownTerrainHeight = ControllingPrim.PhysScene.TerrainManager.GetTerrainHeightAtXYZ(pos);
+                m_knownHas |= m_knownChangedTerrainHeight;
+            }
+            return m_knownTerrainHeight;
+        }
+
+        // Since the computation of water level can be a little involved, this routine
+        //    is used ot fetch the level only once for each vehicle simulation step.
+        Vector3 lastRememberedWaterHeightPos = new Vector3(-1, -1, -1);
+        private float GetWaterLevel(Vector3 pos)
+        {
+            if ((m_knownHas & m_knownChangedWaterLevel) == 0 || pos != lastRememberedWaterHeightPos)
+            {
+                lastRememberedWaterHeightPos = pos;
+                m_knownWaterLevel = ControllingPrim.PhysScene.TerrainManager.GetWaterLevelAtXYZ(pos);
+                m_knownHas |= m_knownChangedWaterLevel;
+            }
+            return m_knownWaterLevel;
+        }
+
+        private Vector3 VehiclePosition
+        {
+            get
+            {
+                if ((m_knownHas & m_knownChangedPosition) == 0)
+                {
+                    m_knownPosition = ControllingPrim.ForcePosition;
+                    m_knownHas |= m_knownChangedPosition;
+                }
+                return m_knownPosition;
+            }
+            set
+            {
+                m_knownPosition = value;
+                m_knownChanged |= m_knownChangedPosition;
+                m_knownHas |= m_knownChangedPosition;
+            }
+        }
+
+        private Quaternion VehicleOrientation
+        {
+            get
+            {
+                if ((m_knownHas & m_knownChangedOrientation) == 0)
+                {
+                    m_knownOrientation = ControllingPrim.ForceOrientation;
+                    m_knownHas |= m_knownChangedOrientation;
+                }
+                return m_knownOrientation;
+            }
+            set
+            {
+                m_knownOrientation = value;
+                m_knownChanged |= m_knownChangedOrientation;
+                m_knownHas |= m_knownChangedOrientation;
+            }
+        }
+
+        private Vector3 VehicleVelocity
+        {
+            get
+            {
+                if ((m_knownHas & m_knownChangedVelocity) == 0)
+                {
+                    m_knownVelocity = ControllingPrim.ForceVelocity;
+                    m_knownHas |= m_knownChangedVelocity;
+                }
+                return m_knownVelocity;
+            }
+            set
+            {
+                m_knownVelocity = value;
+                m_knownChanged |= m_knownChangedVelocity;
+                m_knownHas |= m_knownChangedVelocity;
+            }
+        }
+
+        private void VehicleAddForce(Vector3 pForce)
+        {
+            if ((m_knownHas & m_knownChangedForce) == 0)
+            {
+                m_knownForce = Vector3.Zero;
+                m_knownHas |= m_knownChangedForce;
+            }
+            m_knownForce += pForce;
+            m_knownChanged |= m_knownChangedForce;
+        }
+
+        private void VehicleAddForceImpulse(Vector3 pImpulse)
+        {
+            if ((m_knownHas & m_knownChangedForceImpulse) == 0)
+            {
+                m_knownForceImpulse = Vector3.Zero;
+                m_knownHas |= m_knownChangedForceImpulse;
+            }
+            m_knownForceImpulse += pImpulse;
+            m_knownChanged |= m_knownChangedForceImpulse;
+        }
+
+        private Vector3 VehicleRotationalVelocity
+        {
+            get
+            {
+                if ((m_knownHas & m_knownChangedRotationalVelocity) == 0)
+                {
+                    m_knownRotationalVelocity = ControllingPrim.ForceRotationalVelocity;
+                    m_knownHas |= m_knownChangedRotationalVelocity;
+                }
+                return (Vector3)m_knownRotationalVelocity;
+            }
+            set
+            {
+                m_knownRotationalVelocity = value;
+                m_knownChanged |= m_knownChangedRotationalVelocity;
+                m_knownHas |= m_knownChangedRotationalVelocity;
+            }
+        }
+        private void VehicleAddAngularForce(Vector3 aForce)
+        {
+            if ((m_knownHas & m_knownChangedRotationalForce) == 0)
+            {
+                m_knownRotationalForce = Vector3.Zero;
+            }
+            m_knownRotationalForce += aForce;
+            m_knownChanged |= m_knownChangedRotationalForce;
+            m_knownHas |= m_knownChangedRotationalForce;
+        }
+        private void VehicleAddRotationalImpulse(Vector3 pImpulse)
+        {
+            if ((m_knownHas & m_knownChangedRotationalImpulse) == 0)
+            {
+                m_knownRotationalImpulse = Vector3.Zero;
+                m_knownHas |= m_knownChangedRotationalImpulse;
+            }
+            m_knownRotationalImpulse += pImpulse;
+            m_knownChanged |= m_knownChangedRotationalImpulse;
+        }
+
+        // Vehicle relative forward velocity
+        private Vector3 VehicleForwardVelocity
+        {
+            get
+            {
+                return VehicleVelocity * Quaternion.Inverse(Quaternion.Normalize(VehicleFrameOrientation));
+            }
+        }
+
+        private float VehicleForwardSpeed
+        {
+            get
+            {
+                return VehicleForwardVelocity.X;
+            }
+        }
+        private Quaternion VehicleFrameOrientation
+        {
+            get
+            {
+                return VehicleOrientation * m_referenceFrame;
+            }
+        }
+
+        #endregion // Known vehicle value functions
+
+        // One step of the vehicle properties for the next 'pTimestep' seconds.
+        internal void Step(float pTimestep)
+        {
+            if (!IsActive) return;
+
+            ForgetKnownVehicleProperties();
+
+            MoveLinear(pTimestep);
+            MoveAngular(pTimestep);
+
+            LimitRotation(pTimestep);
+
+            // remember the position so next step we can limit absolute movement effects
+            m_lastPositionVector = VehiclePosition;
+
+            // If we forced the changing of some vehicle parameters, update the values and
+            //      for the physics engine to note the changes so an UpdateProperties event will happen.
+            PushKnownChanged();
+
+            if (m_physicsScene.VehiclePhysicalLoggingEnabled)
+                m_physicsScene.PE.DumpRigidBody(m_physicsScene.World, ControllingPrim.PhysBody);
+
+            VDetailLog("{0},BSDynamics.Step,done,pos={1}, force={2},velocity={3},angvel={4}",
+                    ControllingPrim.LocalID, VehiclePosition, m_knownForce, VehicleVelocity, VehicleRotationalVelocity);
+        }
+
+        // Called after the simulation step
+        internal void PostStep(float pTimestep)
+        {
+            if (!IsActive) return;
+
+            if (m_physicsScene.VehiclePhysicalLoggingEnabled)
+                m_physicsScene.PE.DumpRigidBody(m_physicsScene.World, ControllingPrim.PhysBody);
+        }
+
+        // Apply the effect of the linear motor and other linear motions (like hover and float).
+        private void MoveLinear(float pTimestep)
+        {
+            ComputeLinearVelocity(pTimestep);
+
+            ComputeLinearDeflection(pTimestep);
+
+            ComputeLinearTerrainHeightCorrection(pTimestep);
+
+            ComputeLinearHover(pTimestep);
+
+            ComputeLinearBlockingEndPoint(pTimestep);
+
+            ComputeLinearMotorUp(pTimestep);
+
+            ApplyGravity(pTimestep);
+
+            // If not changing some axis, reduce out velocity
+            if ((m_flags & (VehicleFlag.NO_X | VehicleFlag.NO_Y | VehicleFlag.NO_Z)) != 0)
+            {
+                Vector3 vel = VehicleVelocity;
+                if ((m_flags & (VehicleFlag.NO_X)) != 0)
+                {
+                    vel.X = 0;
+                }
+                if ((m_flags & (VehicleFlag.NO_Y)) != 0)
+                {
+                    vel.Y = 0;
+                }
+                if ((m_flags & (VehicleFlag.NO_Z)) != 0)
+                {
+                    vel.Z = 0;
+                }
+                VehicleVelocity = vel;
+            }
+
+            // ==================================================================
+            // Clamp high or low velocities
+            float newVelocityLengthSq = VehicleVelocity.LengthSquared();
+            if (newVelocityLengthSq > BSParam.VehicleMaxLinearVelocitySquared)
+            {
+                Vector3 origVelW = VehicleVelocity;         // DEBUG DEBUG
+                VehicleVelocity /= VehicleVelocity.Length();
+                VehicleVelocity *= BSParam.VehicleMaxLinearVelocity;
+                VDetailLog("{0},  MoveLinear,clampMax,origVelW={1},lenSq={2},maxVelSq={3},,newVelW={4}",
+                            ControllingPrim.LocalID, origVelW, newVelocityLengthSq, BSParam.VehicleMaxLinearVelocitySquared, VehicleVelocity);
+            }
+            else if (newVelocityLengthSq < BSParam.VehicleMinLinearVelocitySquared)
+            {
+                Vector3 origVelW = VehicleVelocity;         // DEBUG DEBUG
+                VDetailLog("{0},  MoveLinear,clampMin,origVelW={1},lenSq={2}",
+                            ControllingPrim.LocalID, origVelW, newVelocityLengthSq);
+                VehicleVelocity = Vector3.Zero;
+            }
+
+            VDetailLog("{0},  MoveLinear,done,isColl={1},newVel={2}", ControllingPrim.LocalID, ControllingPrim.HasSomeCollision, VehicleVelocity );
+
+        } // end MoveLinear()
+
+        public void ComputeLinearVelocity(float pTimestep)
+        {
+            // Step the motor from the current value. Get the correction needed this step.
+            Vector3 origVelW = VehicleVelocity;             // DEBUG
+            Vector3 currentVelV = VehicleForwardVelocity;
+            Vector3 linearMotorCorrectionV = m_linearMotor.Step(pTimestep, currentVelV);
+
+            // Friction reduces vehicle motion based on absolute speed. Slow vehicle down by friction.
+            Vector3 frictionFactorV = ComputeFrictionFactor(m_linearFrictionTimescale, pTimestep);
+            linearMotorCorrectionV -= (currentVelV * frictionFactorV);
+
+            // Motor is vehicle coordinates. Rotate it to world coordinates
+            Vector3 linearMotorVelocityW = linearMotorCorrectionV * VehicleFrameOrientation;
+
+            // If we're a ground vehicle, don't add any upward Z movement
+            if ((m_flags & VehicleFlag.LIMIT_MOTOR_UP) != 0)
+            {
+                if (linearMotorVelocityW.Z > 0f)
+                    linearMotorVelocityW.Z = 0f;
+            }
+
+            // Add this correction to the velocity to make it faster/slower.
+            VehicleVelocity += linearMotorVelocityW;
+
+            VDetailLog("{0},  MoveLinear,velocity,origVelW={1},velV={2},tgt={3},correctV={4},correctW={5},newVelW={6},fricFact={7}",
+                        ControllingPrim.LocalID, origVelW, currentVelV, m_linearMotor.TargetValue, linearMotorCorrectionV,
+                        linearMotorVelocityW, VehicleVelocity, frictionFactorV);
+        }
+
+        //Given a Deflection Effiency and a Velocity, Returns a Velocity that is Partially Deflected onto the X Axis
+        //Clamped so that a DeflectionTimescale of less then 1 does not increase force over original velocity
+        private void ComputeLinearDeflection(float pTimestep)
+        {
+            Vector3 linearDeflectionV = Vector3.Zero;
+            Vector3 velocityV = VehicleForwardVelocity;
+
+            if (BSParam.VehicleEnableLinearDeflection)
+            {
+                // Velocity in Y and Z dimensions is movement to the side or turning.
+                // Compute deflection factor from the to the side and rotational velocity
+                linearDeflectionV.Y = SortedClampInRange(0, (velocityV.Y * m_linearDeflectionEfficiency) / m_linearDeflectionTimescale, velocityV.Y);
+                linearDeflectionV.Z = SortedClampInRange(0, (velocityV.Z * m_linearDeflectionEfficiency) / m_linearDeflectionTimescale, velocityV.Z);
+
+                // Velocity to the side and around is corrected and moved into the forward direction
+                linearDeflectionV.X += Math.Abs(linearDeflectionV.Y);
+                linearDeflectionV.X += Math.Abs(linearDeflectionV.Z);
+
+                // Scale the deflection to the fractional simulation time
+                linearDeflectionV *= pTimestep;
+
+                // Subtract the sideways and rotational velocity deflection factors while adding the correction forward
+                linearDeflectionV *= new Vector3(1, -1, -1);
+
+                // Correction is vehicle relative. Convert to world coordinates.
+                Vector3 linearDeflectionW = linearDeflectionV * VehicleFrameOrientation;
+
+                // Optionally, if not colliding, don't effect world downward velocity. Let falling things fall.
+                if (BSParam.VehicleLinearDeflectionNotCollidingNoZ && !m_controllingPrim.HasSomeCollision)
+                {
+                    linearDeflectionW.Z = 0f;
+                }
+
+                VehicleVelocity += linearDeflectionW;
+
+                VDetailLog("{0},  MoveLinear,LinearDeflection,linDefEff={1},linDefTS={2},linDeflectionV={3}",
+                            ControllingPrim.LocalID, m_linearDeflectionEfficiency, m_linearDeflectionTimescale, linearDeflectionV);
+            }
+        }
+
+        public void ComputeLinearTerrainHeightCorrection(float pTimestep)
+        {
+            // If below the terrain, move us above the ground a little.
+            // TODO: Consider taking the rotated size of the object or possibly casting a ray.
+            if (VehiclePosition.Z < GetTerrainHeight(VehiclePosition))
+            {
+                // Force position because applying force won't get the vehicle through the terrain
+                Vector3 newPosition = VehiclePosition;
+                newPosition.Z = GetTerrainHeight(VehiclePosition) + 1f;
+                VehiclePosition = newPosition;
+                VDetailLog("{0},  MoveLinear,terrainHeight,terrainHeight={1},pos={2}",
+                        ControllingPrim.LocalID, GetTerrainHeight(VehiclePosition), VehiclePosition);
+            }
+        }
+
+        public void ComputeLinearHover(float pTimestep)
+        {
+            // m_VhoverEfficiency: 0=bouncy, 1=totally damped
+            // m_VhoverTimescale: time to achieve height
+            if ((m_flags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0 && (m_VhoverHeight > 0) && (m_VhoverTimescale < 300))
+            {
+                // We should hover, get the target height
+                if ((m_flags & VehicleFlag.HOVER_WATER_ONLY) != 0)
+                {
+                    m_VhoverTargetHeight = GetWaterLevel(VehiclePosition) + m_VhoverHeight;
+                }
+                if ((m_flags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0)
+                {
+                    m_VhoverTargetHeight = GetTerrainHeight(VehiclePosition) + m_VhoverHeight;
+                }
+                if ((m_flags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != 0)
+                {
+                    m_VhoverTargetHeight = m_VhoverHeight;
+                }
+                if ((m_flags & VehicleFlag.HOVER_UP_ONLY) != 0)
+                {
+                    // If body is already heigher, use its height as target height
+                    if (VehiclePosition.Z > m_VhoverTargetHeight)
+                    {
+                        m_VhoverTargetHeight = VehiclePosition.Z;
+
+                        // A 'misfeature' of this flag is that if the vehicle is above it's hover height,
+                        //     the vehicle's buoyancy goes away. This is an SL bug that got used by so many
+                        //    scripts that it could not be changed.
+                        // So, if above the height, reapply gravity if buoyancy had it turned off.
+                        if (m_VehicleBuoyancy != 0)
+                        {
+                            Vector3 appliedGravity = ControllingPrim.ComputeGravity(ControllingPrim.Buoyancy) * m_vehicleMass;
+                            VehicleAddForce(appliedGravity);
+                        }
+                    }
+                }
+
+                if ((m_flags & VehicleFlag.LOCK_HOVER_HEIGHT) != 0)
+                {
+                    if (Math.Abs(VehiclePosition.Z - m_VhoverTargetHeight) > 0.2f)
+                    {
+                        Vector3 pos = VehiclePosition;
+                        pos.Z = m_VhoverTargetHeight;
+                        VehiclePosition = pos;
+
+                        VDetailLog("{0},  MoveLinear,hover,pos={1},lockHoverHeight", ControllingPrim.LocalID, pos);
+                    }
+                }
+                else
+                {
+                    // Error is positive if below the target and negative if above.
+                    Vector3 hpos = VehiclePosition;
+                    float verticalError = m_VhoverTargetHeight - hpos.Z;
+                    float verticalCorrection = verticalError / m_VhoverTimescale;
+                    verticalCorrection *= m_VhoverEfficiency;
+
+                    hpos.Z += verticalCorrection;
+                    VehiclePosition = hpos;
+
+                    // Since we are hovering, we need to do the opposite of falling -- get rid of world Z
+                    Vector3 vel = VehicleVelocity;
+                    vel.Z = 0f;
+                    VehicleVelocity = vel;
+
+                    /*
+                    float verticalCorrectionVelocity = verticalError / m_VhoverTimescale;
+                    Vector3 verticalCorrection = new Vector3(0f, 0f, verticalCorrectionVelocity);
+                    verticalCorrection *= m_vehicleMass;
+
+                    // TODO: implement m_VhoverEfficiency correctly
+                    VehicleAddForceImpulse(verticalCorrection);
+                     */
+
+                    VDetailLog("{0},  MoveLinear,hover,pos={1},eff={2},hoverTS={3},height={4},target={5},err={6},corr={7}",
+                                    ControllingPrim.LocalID, VehiclePosition, m_VhoverEfficiency,
+                                    m_VhoverTimescale, m_VhoverHeight, m_VhoverTargetHeight,
+                                    verticalError, verticalCorrection);
+                }
+            }
+        }
+
+        public bool ComputeLinearBlockingEndPoint(float pTimestep)
+        {
+            bool changed = false;
+
+            Vector3 pos = VehiclePosition;
+            Vector3 posChange = pos - m_lastPositionVector;
+            if (m_BlockingEndPoint != Vector3.Zero)
+            {
+                if (pos.X >= (m_BlockingEndPoint.X - (float)1))
+                {
+                    pos.X -= posChange.X + 1;
+                    changed = true;
+                }
+                if (pos.Y >= (m_BlockingEndPoint.Y - (float)1))
+                {
+                    pos.Y -= posChange.Y + 1;
+                    changed = true;
+                }
+                if (pos.Z >= (m_BlockingEndPoint.Z - (float)1))
+                {
+                    pos.Z -= posChange.Z + 1;
+                    changed = true;
+                }
+                if (pos.X <= 0)
+                {
+                    pos.X += posChange.X + 1;
+                    changed = true;
+                }
+                if (pos.Y <= 0)
+                {
+                    pos.Y += posChange.Y + 1;
+                    changed = true;
+                }
+                if (changed)
+                {
+                    VehiclePosition = pos;
+                    VDetailLog("{0},  MoveLinear,blockingEndPoint,block={1},origPos={2},pos={3}",
+                                ControllingPrim.LocalID, m_BlockingEndPoint, posChange, pos);
+                }
+            }
+            return changed;
+        }
+
+        // From http://wiki.secondlife.com/wiki/LlSetVehicleFlags :
+        //    Prevent ground vehicles from motoring into the sky. This flag has a subtle effect when
+        //    used with conjunction with banking: the strength of the banking will decay when the
+        //    vehicle no longer experiences collisions. The decay timescale is the same as
+        //    VEHICLE_BANKING_TIMESCALE. This is to help prevent ground vehicles from steering
+        //    when they are in mid jump.
+        // TODO: this code is wrong. Also, what should it do for boats (height from water)?
+        //    This is just using the ground and a general collision check. Should really be using
+        //    a downward raycast to find what is below.
+        public void ComputeLinearMotorUp(float pTimestep)
+        {
+            if ((m_flags & (VehicleFlag.LIMIT_MOTOR_UP)) != 0)
+            {
+                // This code tries to decide if the object is not on the ground and then pushing down
+                /*
+                float targetHeight = Type == Vehicle.TYPE_BOAT ? GetWaterLevel(VehiclePosition) : GetTerrainHeight(VehiclePosition);
+                distanceAboveGround = VehiclePosition.Z - targetHeight;
+                // Not colliding if the vehicle is off the ground
+                if (!Prim.HasSomeCollision)
+                {
+                    // downForce = new Vector3(0, 0, -distanceAboveGround / m_bankingTimescale);
+                    VehicleVelocity += new Vector3(0, 0, -distanceAboveGround);
+                }
+                // TODO: this calculation is wrong. From the description at
+                //     (http://wiki.secondlife.com/wiki/Category:LSL_Vehicle), the downForce
+                //     has a decay factor. This says this force should
+                //     be computed with a motor.
+                // TODO: add interaction with banking.
+                VDetailLog("{0},  MoveLinear,limitMotorUp,distAbove={1},colliding={2},ret={3}",
+                                Prim.LocalID, distanceAboveGround, Prim.HasSomeCollision, ret);
+                 */
+
+                // Another approach is to measure if we're going up. If going up and not colliding,
+                //     the vehicle is in the air.  Fix that by pushing down.
+                if (!ControllingPrim.HasSomeCollision && VehicleVelocity.Z > 0.1)
+                {
+                    // Get rid of any of the velocity vector that is pushing us up.
+                    float upVelocity = VehicleVelocity.Z;
+                    VehicleVelocity += new Vector3(0, 0, -upVelocity);
+
+                    /*
+                    // If we're pointed up into the air, we should nose down
+                    Vector3 pointingDirection = Vector3.UnitX * VehicleOrientation;
+                    // The rotation around the Y axis is pitch up or down
+                    if (pointingDirection.Y > 0.01f)
+                    {
+                        float angularCorrectionForce = -(float)Math.Asin(pointingDirection.Y);
+                        Vector3 angularCorrectionVector = new Vector3(0f, angularCorrectionForce, 0f);
+                        // Rotate into world coordinates and apply to vehicle
+                        angularCorrectionVector *= VehicleOrientation;
+                        VehicleAddAngularForce(angularCorrectionVector);
+                        VDetailLog("{0},  MoveLinear,limitMotorUp,newVel={1},pntDir={2},corrFrc={3},aCorr={4}",
+                                    Prim.LocalID, VehicleVelocity, pointingDirection, angularCorrectionForce, angularCorrectionVector);
+                    }
+                        */
+                    VDetailLog("{0},  MoveLinear,limitMotorUp,collide={1},upVel={2},newVel={3}",
+                                    ControllingPrim.LocalID, ControllingPrim.HasSomeCollision, upVelocity, VehicleVelocity);
+                }
+            }
+        }
+
+        private void ApplyGravity(float pTimeStep)
+        {
+            Vector3 appliedGravity = m_VehicleGravity * m_vehicleMass;
+
+            // Hack to reduce downward force if the vehicle is probably sitting on the ground
+            if (ControllingPrim.HasSomeCollision && IsGroundVehicle)
+                appliedGravity *= BSParam.VehicleGroundGravityFudge;
+
+            VehicleAddForce(appliedGravity);
+
+            VDetailLog("{0},  MoveLinear,applyGravity,vehGrav={1},collid={2},fudge={3},mass={4},appliedForce={5}",
+                            ControllingPrim.LocalID, m_VehicleGravity,
+                            ControllingPrim.HasSomeCollision, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity);
+        }
+
+        // =======================================================================
+        // =======================================================================
+        // Apply the effect of the angular motor.
+        // The 'contribution' is how much angular correction velocity each function wants.
+        //     All the contributions are added together and the resulting velocity is
+        //     set directly on the vehicle.
+        private void MoveAngular(float pTimestep)
+        {
+            ComputeAngularTurning(pTimestep);
+
+            ComputeAngularVerticalAttraction();
+
+            ComputeAngularDeflection();
+
+            ComputeAngularBanking();
+
+            // ==================================================================
+            if (VehicleRotationalVelocity.ApproxEquals(Vector3.Zero, 0.0001f))
+            {
+                // The vehicle is not adding anything angular wise.
+                VehicleRotationalVelocity = Vector3.Zero;
+                VDetailLog("{0},  MoveAngular,done,zero", ControllingPrim.LocalID);
+            }
+            else
+            {
+                VDetailLog("{0},  MoveAngular,done,nonZero,angVel={1}", ControllingPrim.LocalID, VehicleRotationalVelocity);
+            }
+
+            // ==================================================================
+            //Offset section
+            if (m_linearMotorOffset != Vector3.Zero)
+            {
+                //Offset of linear velocity doesn't change the linear velocity,
+                //   but causes a torque to be applied, for example...
+                //
+                //      IIIII     >>>   IIIII
+                //      IIIII     >>>    IIIII
+                //      IIIII     >>>     IIIII
+                //          ^
+                //          |  Applying a force at the arrow will cause the object to move forward, but also rotate
+                //
+                //
+                // The torque created is the linear velocity crossed with the offset
+
+                // TODO: this computation should be in the linear section
+                //    because that is where we know the impulse being applied.
+                Vector3 torqueFromOffset = Vector3.Zero;
+                // torqueFromOffset = Vector3.Cross(m_linearMotorOffset, appliedImpulse);
+                if (float.IsNaN(torqueFromOffset.X))
+                    torqueFromOffset.X = 0;
+                if (float.IsNaN(torqueFromOffset.Y))
+                    torqueFromOffset.Y = 0;
+                if (float.IsNaN(torqueFromOffset.Z))
+                    torqueFromOffset.Z = 0;
+
+                VehicleAddAngularForce(torqueFromOffset * m_vehicleMass);
+                VDetailLog("{0},  BSDynamic.MoveAngular,motorOffset,applyTorqueImpulse={1}", ControllingPrim.LocalID, torqueFromOffset);
+            }
+
+        }
+
+        private void ComputeAngularTurning(float pTimestep)
+        {
+            // The user wants this many radians per second angular change?
+            Vector3 origVehicleRotationalVelocity = VehicleRotationalVelocity;      // DEBUG DEBUG
+            Vector3 currentAngularV = VehicleRotationalVelocity * Quaternion.Inverse(VehicleFrameOrientation);
+            Vector3 angularMotorContributionV = m_angularMotor.Step(pTimestep, currentAngularV);
+
+            // ==================================================================
+            // From http://wiki.secondlife.com/wiki/LlSetVehicleFlags :
+            //    This flag prevents linear deflection parallel to world z-axis. This is useful
+            //    for preventing ground vehicles with large linear deflection, like bumper cars,
+            //    from climbing their linear deflection into the sky.
+            // That is, NO_DEFLECTION_UP says angular motion should not add any pitch or roll movement
+            // TODO: This is here because this is where ODE put it but documentation says it
+            //    is a linear effect. Where should this check go?
+            //if ((m_flags & (VehicleFlag.NO_DEFLECTION_UP)) != 0)
+            // {
+            //    angularMotorContributionV.X = 0f;
+            //    angularMotorContributionV.Y = 0f;
+            //  }
+
+            // Reduce any velocity by friction.
+            Vector3 frictionFactorW = ComputeFrictionFactor(m_angularFrictionTimescale, pTimestep);
+            angularMotorContributionV -= (currentAngularV * frictionFactorW);
+
+            Vector3 angularMotorContributionW = angularMotorContributionV * VehicleFrameOrientation;
+            VehicleRotationalVelocity += angularMotorContributionW;
+
+            VDetailLog("{0},  MoveAngular,angularTurning,curAngVelV={1},origVehRotVel={2},vehRotVel={3},frictFact={4}, angContribV={5},angContribW={6}",
+                        ControllingPrim.LocalID, currentAngularV, origVehicleRotationalVelocity, VehicleRotationalVelocity, frictionFactorW, angularMotorContributionV, angularMotorContributionW);
+        }
+
+        // From http://wiki.secondlife.com/wiki/Linden_Vehicle_Tutorial:
+        //      Some vehicles, like boats, should always keep their up-side up. This can be done by
+        //      enabling the "vertical attractor" behavior that springs the vehicle's local z-axis to
+        //      the world z-axis (a.k.a. "up"). To take advantage of this feature you would set the
+        //      VEHICLE_VERTICAL_ATTRACTION_TIMESCALE to control the period of the spring frequency,
+        //      and then set the VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY to control the damping. An
+        //      efficiency of 0.0 will cause the spring to wobble around its equilibrium, while an
+        //      efficiency of 1.0 will cause the spring to reach its equilibrium with exponential decay.
+        public void ComputeAngularVerticalAttraction()
+        {
+
+            // If vertical attaction timescale is reasonable
+            if (BSParam.VehicleEnableAngularVerticalAttraction && m_verticalAttractionTimescale < m_verticalAttractionCutoff)
+            {
+                Vector3 vehicleUpAxis = Vector3.UnitZ * VehicleFrameOrientation;
+                switch (BSParam.VehicleAngularVerticalAttractionAlgorithm)
+                {
+                    case 0:
+                        {
+                            //Another formula to try got from :
+                            //http://answers.unity3d.com/questions/10425/how-to-stabilize-angular-motion-alignment-of-hover.html
+
+                            // Flipping what was originally a timescale into a speed variable and then multiplying it by 2
+                            //    since only computing half the distance between the angles.
+                            float verticalAttractionSpeed = (1 / m_verticalAttractionTimescale) * 2.0f;
+
+                            // Make a prediction of where the up axis will be when this is applied rather then where it is now as
+                            //     this makes for a smoother adjustment and less fighting between the various forces.
+                            Vector3 predictedUp = vehicleUpAxis * Quaternion.CreateFromAxisAngle(VehicleRotationalVelocity, 0f);
+
+                            // This is only half the distance to the target so it will take 2 seconds to complete the turn.
+                            Vector3 torqueVector = Vector3.Cross(predictedUp, Vector3.UnitZ);
+
+                            if ((m_flags & VehicleFlag.LIMIT_ROLL_ONLY) != 0)
+                            {
+                                Vector3 vehicleForwardAxis = Vector3.UnitX * VehicleFrameOrientation;
+                                torqueVector = ProjectVector(torqueVector, vehicleForwardAxis);
+                            }
+
+                            // Scale vector by our timescale since it is an acceleration it is r/s^2 or radians a timescale squared
+                            Vector3 vertContributionV = torqueVector * verticalAttractionSpeed * verticalAttractionSpeed;
+
+                            VehicleRotationalVelocity += vertContributionV;
+
+                            VDetailLog("{0},  MoveAngular,verticalAttraction,vertAttrSpeed={1},upAxis={2},PredictedUp={3},torqueVector={4},contrib={5}",
+                                            ControllingPrim.LocalID,
+                                            verticalAttractionSpeed,
+                                            vehicleUpAxis,
+                                            predictedUp,
+                                            torqueVector,
+                                            vertContributionV);
+                            break;
+                        }
+                    case 1:
+                        {
+                            // Possible solution derived from a discussion at:
+                            // http://stackoverflow.com/questions/14939657/computing-vector-from-quaternion-works-computing-quaternion-from-vector-does-no
+
+                            // Create a rotation that is only the vehicle's rotation around Z
+                            Vector3 currentEulerW = Vector3.Zero;
+                            VehicleFrameOrientation.GetEulerAngles(out currentEulerW.X, out currentEulerW.Y, out currentEulerW.Z);
+                            Quaternion justZOrientation = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, currentEulerW.Z);
+
+                            // Create the axis that is perpendicular to the up vector and the rotated up vector.
+                            Vector3 differenceAxisW = Vector3.Cross(Vector3.UnitZ * justZOrientation, Vector3.UnitZ * VehicleFrameOrientation);
+                            // Compute the angle between those to vectors.
+                            double differenceAngle = Math.Acos((double)Vector3.Dot(Vector3.UnitZ, Vector3.Normalize(Vector3.UnitZ * VehicleFrameOrientation)));
+                            // 'differenceAngle' is the angle to rotate and 'differenceAxis' is the plane to rotate in to get the vehicle vertical
+
+                            // Reduce the change by the time period it is to change in. Timestep is handled when velocity is applied.
+                            // TODO: add 'efficiency'.
+                            // differenceAngle /= m_verticalAttractionTimescale;
+
+                            // Create the quaterian representing the correction angle
+                            Quaternion correctionRotationW = Quaternion.CreateFromAxisAngle(differenceAxisW, (float)differenceAngle);
+
+                            // Turn that quaternion into Euler values to make it into velocities to apply.
+                            Vector3 vertContributionW = Vector3.Zero;
+                            correctionRotationW.GetEulerAngles(out vertContributionW.X, out vertContributionW.Y, out vertContributionW.Z);
+                            vertContributionW *= -1f;
+                            vertContributionW /= m_verticalAttractionTimescale;
+
+                            VehicleRotationalVelocity += vertContributionW;
+
+                            VDetailLog("{0},  MoveAngular,verticalAttraction,upAxis={1},diffAxis={2},diffAng={3},corrRot={4},contrib={5}",
+                                            ControllingPrim.LocalID,
+                                            vehicleUpAxis,
+                                            differenceAxisW,
+                                            differenceAngle,
+                                            correctionRotationW,
+                                            vertContributionW);
+                            break;
+                        }
+                    case 2:
+                        {
+                            Vector3 vertContributionV = Vector3.Zero;
+                            Vector3 origRotVelW = VehicleRotationalVelocity;        // DEBUG DEBUG
+
+                            // Take a vector pointing up and convert it from world to vehicle relative coords.
+                            Vector3 verticalError = Vector3.Normalize(Vector3.UnitZ * VehicleFrameOrientation);
+
+                            // If vertical attraction correction is needed, the vector that was pointing up (UnitZ)
+                            //    is now:
+                            //    leaning to one side: rotated around the X axis with the Y value going
+                            //        from zero (nearly straight up) to one (completely to the side)) or
+                            //    leaning front-to-back: rotated around the Y axis with the value of X being between
+                            //         zero and one.
+                            // The value of Z is how far the rotation is off with 1 meaning none and 0 being 90 degrees.
+
+                            // Y error means needed rotation around X axis and visa versa.
+                            // Since the error goes from zero to one, the asin is the corresponding angle.
+                            vertContributionV.X = (float)Math.Asin(verticalError.Y);
+                            // (Tilt forward (positive X) needs to tilt back (rotate negative) around Y axis.)
+                            vertContributionV.Y = -(float)Math.Asin(verticalError.X);
+
+                            // If verticalError.Z is negative, the vehicle is upside down. Add additional push.
+                            if (verticalError.Z < 0f)
+                            {
+                                vertContributionV.X += Math.Sign(vertContributionV.X) * PIOverFour;
+                                // vertContribution.Y -= PIOverFour;
+                            }
+
+                            // 'vertContrbution' is now the necessary angular correction to correct tilt in one second.
+                            //     Correction happens over a number of seconds.
+                            Vector3 unscaledContribVerticalErrorV = vertContributionV;     // DEBUG DEBUG
+
+                            // The correction happens over the user's time period
+                            vertContributionV /= m_verticalAttractionTimescale;
+
+                            // Rotate the vehicle rotation to the world coordinates.
+                            VehicleRotationalVelocity += (vertContributionV * VehicleFrameOrientation);
+
+                            VDetailLog("{0},  MoveAngular,verticalAttraction,,upAxis={1},origRotVW={2},vertError={3},unscaledV={4},eff={5},ts={6},vertContribV={7}",
+                                            ControllingPrim.LocalID,
+                                            vehicleUpAxis,
+                                            origRotVelW,
+                                            verticalError,
+                                            unscaledContribVerticalErrorV,
+                                            m_verticalAttractionEfficiency,
+                                            m_verticalAttractionTimescale,
+                                            vertContributionV);
+                            break;
+                        }
+                    default:
+                        {
+                            break;
+                        }
+                }
+            }
+        }
+
+        // Angular correction to correct the direction the vehicle is pointing to be
+        //      the direction is should want to be pointing.
+        // The vehicle is moving in some direction and correct its orientation to it is pointing
+        //     in that direction.
+        // TODO: implement reference frame.
+        public void ComputeAngularDeflection()
+        {   
+
+            if (BSParam.VehicleEnableAngularDeflection && m_angularDeflectionEfficiency != 0 && VehicleForwardSpeed > 0.2)
+            {
+                Vector3 deflectContributionV = Vector3.Zero;
+
+                // The direction the vehicle is moving
+                Vector3 movingDirection = VehicleVelocity;
+                movingDirection.Normalize();
+
+                // If the vehicle is going backward, it is still pointing forward
+                movingDirection *= Math.Sign(VehicleForwardSpeed);
+
+                // The direction the vehicle is pointing
+                Vector3 pointingDirection = Vector3.UnitX * VehicleFrameOrientation;
+                //Predict where the Vehicle will be pointing after AngularVelocity change is applied. This will keep
+                //   from overshooting and allow this correction to merge with the Vertical Attraction peacefully.
+                Vector3 predictedPointingDirection = pointingDirection * Quaternion.CreateFromAxisAngle(VehicleRotationalVelocity, 0f);
+                predictedPointingDirection.Normalize();
+
+                // The difference between what is and what should be.
+               // Vector3 deflectionError = movingDirection - predictedPointingDirection;
+                Vector3 deflectionError = Vector3.Cross(movingDirection, predictedPointingDirection);
+
+                // Don't try to correct very large errors (not our job)
+                // if (Math.Abs(deflectionError.X) > PIOverFour) deflectionError.X = PIOverTwo * Math.Sign(deflectionError.X);
+                // if (Math.Abs(deflectionError.Y) > PIOverFour) deflectionError.Y = PIOverTwo * Math.Sign(deflectionError.Y);
+                // if (Math.Abs(deflectionError.Z) > PIOverFour) deflectionError.Z = PIOverTwo * Math.Sign(deflectionError.Z);
+                if (Math.Abs(deflectionError.X) > PIOverFour) deflectionError.X = 0f;
+                if (Math.Abs(deflectionError.Y) > PIOverFour) deflectionError.Y = 0f;
+                if (Math.Abs(deflectionError.Z) > PIOverFour) deflectionError.Z = 0f;
+
+                // ret = m_angularDeflectionCorrectionMotor(1f, deflectionError);
+
+                // Scale the correction by recovery timescale and efficiency
+                //    Not modeling a spring so clamp the scale to no more then the arc
+                deflectContributionV = (-deflectionError) * ClampInRange(0, m_angularDeflectionEfficiency/m_angularDeflectionTimescale,1f);
+                //deflectContributionV /= m_angularDeflectionTimescale;
+
+                VehicleRotationalVelocity += deflectContributionV;
+                VDetailLog("{0},  MoveAngular,Deflection,movingDir={1},pointingDir={2},deflectError={3},ret={4}",
+                    ControllingPrim.LocalID, movingDirection, pointingDirection, deflectionError, deflectContributionV);
+                VDetailLog("{0},  MoveAngular,Deflection,fwdSpd={1},defEff={2},defTS={3},PredictedPointingDir={4}",
+                    ControllingPrim.LocalID, VehicleForwardSpeed, m_angularDeflectionEfficiency, m_angularDeflectionTimescale, predictedPointingDirection);
+            }
+        }
+
+        // Angular change to rotate the vehicle around the Z axis when the vehicle
+        //     is tipped around the X axis.
+        // From http://wiki.secondlife.com/wiki/Linden_Vehicle_Tutorial:
+        //      The vertical attractor feature must be enabled in order for the banking behavior to
+        //      function. The way banking works is this: a rotation around the vehicle's roll-axis will
+        //      produce a angular velocity around the yaw-axis, causing the vehicle to turn. The magnitude
+        //      of the yaw effect will be proportional to the
+        //          VEHICLE_BANKING_EFFICIENCY, the angle of the roll rotation, and sometimes the vehicle's
+        //                 velocity along its preferred axis of motion.
+        //          The VEHICLE_BANKING_EFFICIENCY can vary between -1 and +1. When it is positive then any
+        //                  positive rotation (by the right-hand rule) about the roll-axis will effect a
+        //                  (negative) torque around the yaw-axis, making it turn to the right--that is the
+        //                  vehicle will lean into the turn, which is how real airplanes and motorcycle's work.
+        //                  Negating the banking coefficient will make it so that the vehicle leans to the
+        //                  outside of the turn (not very "physical" but might allow interesting vehicles so why not?).
+        //           The VEHICLE_BANKING_MIX is a fake (i.e. non-physical) parameter that is useful for making
+        //                  banking vehicles do what you want rather than what the laws of physics allow.
+        //                  For example, consider a real motorcycle...it must be moving forward in order for
+        //                  it to turn while banking, however video-game motorcycles are often configured
+        //                  to turn in place when at a dead stop--because they are often easier to control
+        //                  that way using the limited interface of the keyboard or game controller. The
+        //                  VEHICLE_BANKING_MIX enables combinations of both realistic and non-realistic
+        //                  banking by functioning as a slider between a banking that is correspondingly
+        //                  totally static (0.0) and totally dynamic (1.0). By "static" we mean that the
+        //                  banking effect depends only on the vehicle's rotation about its roll-axis compared
+        //                  to "dynamic" where the banking is also proportional to its velocity along its
+        //                  roll-axis. Finding the best value of the "mixture" will probably require trial and error.
+        //      The time it takes for the banking behavior to defeat a preexisting angular velocity about the
+        //      world z-axis is determined by the VEHICLE_BANKING_TIMESCALE. So if you want the vehicle to
+        //      bank quickly then give it a banking timescale of about a second or less, otherwise you can
+        //      make a sluggish vehicle by giving it a timescale of several seconds.
+        public void ComputeAngularBanking()
+        {
+            if (BSParam.VehicleEnableAngularBanking && m_bankingEfficiency != 0 && m_verticalAttractionTimescale < m_verticalAttractionCutoff)
+            {
+                Vector3 bankingContributionV = Vector3.Zero;
+
+                // Rotate a UnitZ vector (pointing up) to how the vehicle is oriented.
+                // As the vehicle rolls to the right or left, the Y value will increase from
+                //     zero (straight up) to 1 or -1 (full tilt right  or left)
+                Vector3 rollComponents = Vector3.UnitZ * VehicleFrameOrientation;
+
+                // Figure out the yaw value for this much roll.
+                float yawAngle = m_angularMotorDirection.X * m_bankingEfficiency;
+                //        actual error  =       static turn error            +           dynamic turn error
+                float mixedYawAngle =(yawAngle * (1f - m_bankingMix)) + ((yawAngle * m_bankingMix) * VehicleForwardSpeed);
+
+                // TODO: the banking effect should not go to infinity but what to limit it to?
+                //     And what should happen when this is being added to a user defined yaw that is already PI*4?
+                mixedYawAngle = ClampInRange(-FourPI, mixedYawAngle, FourPI);
+
+                // Build the force vector to change rotation from what it is to what it should be
+                bankingContributionV.Z = -mixedYawAngle;
+
+                // Don't do it all at once. Fudge because 1 second is too fast with most user defined roll as PI*4.
+                bankingContributionV /= m_bankingTimescale * BSParam.VehicleAngularBankingTimescaleFudge;
+
+                VehicleRotationalVelocity += bankingContributionV;
+
+
+                VDetailLog("{0},  MoveAngular,Banking,rollComp={1},speed={2},rollComp={3},yAng={4},mYAng={5},ret={6}",
+                            ControllingPrim.LocalID, rollComponents, VehicleForwardSpeed, rollComponents, yawAngle, mixedYawAngle, bankingContributionV);
+            }
+        }
+
+        // This is from previous instantiations of XXXDynamics.cs.
+        // Applies roll reference frame.
+        // TODO: is this the right way to separate the code to do this operation?
+        //    Should this be in MoveAngular()?
+        internal void LimitRotation(float timestep)
+        {
+            Quaternion rotq = VehicleOrientation;
+            Quaternion m_rot = rotq;
+            if (m_RollreferenceFrame != Quaternion.Identity)
+            {
+                if (rotq.X >= m_RollreferenceFrame.X)
+                {
+                    m_rot.X = rotq.X - (m_RollreferenceFrame.X / 2);
+                }
+                if (rotq.Y >= m_RollreferenceFrame.Y)
+                {
+                    m_rot.Y = rotq.Y - (m_RollreferenceFrame.Y / 2);
+                }
+                if (rotq.X <= -m_RollreferenceFrame.X)
+                {
+                    m_rot.X = rotq.X + (m_RollreferenceFrame.X / 2);
+                }
+                if (rotq.Y <= -m_RollreferenceFrame.Y)
+                {
+                    m_rot.Y = rotq.Y + (m_RollreferenceFrame.Y / 2);
+                }
+            }
+            if ((m_flags & VehicleFlag.LOCK_ROTATION) != 0)
+            {
+                m_rot.X = 0;
+                m_rot.Y = 0;
+            }
+            if (rotq != m_rot)
+            {
+                VehicleOrientation = m_rot;
+                VDetailLog("{0},  LimitRotation,done,orig={1},new={2}", ControllingPrim.LocalID, rotq, m_rot);
+            }
+
+        }
+
+        // Given a friction vector (reduction in seconds) and a timestep, return the factor to reduce
+        //     some value by to apply this friction.
+        private Vector3 ComputeFrictionFactor(Vector3 friction, float pTimestep)
+        {
+            Vector3 frictionFactor = Vector3.Zero;
+            if (friction != BSMotor.InfiniteVector)
+            {
+                // frictionFactor = (Vector3.One / FrictionTimescale) * timeStep;
+                // Individual friction components can be 'infinite' so compute each separately.
+                frictionFactor.X = (friction.X == BSMotor.Infinite) ? 0f : (1f / friction.X);
+                frictionFactor.Y = (friction.Y == BSMotor.Infinite) ? 0f : (1f / friction.Y);
+                frictionFactor.Z = (friction.Z == BSMotor.Infinite) ? 0f : (1f / friction.Z);
+                frictionFactor *= pTimestep;
+            }
+            return frictionFactor;
+        }
+
+        private float SortedClampInRange(float clampa, float val, float clampb)
+        {
+            if (clampa > clampb)
+            {
+                float temp = clampa;
+                clampa = clampb;
+                clampb = temp;
+            }
+           return ClampInRange(clampa, val, clampb);
+
+        }
+
+        //Given a Vector and a unit vector will return the amount of the vector is on the same axis as the unit.
+        private Vector3 ProjectVector(Vector3 vector, Vector3 onNormal)
+        {
+            float vectorDot = Vector3.Dot(vector, onNormal);
+            return onNormal * vectorDot;
+
+        }
+
+        private float ClampInRange(float low, float val, float high)
+        {
+            return Math.Max(low, Math.Min(val, high));
+            // return Utils.Clamp(val, low, high);
+        }
+
+        // Invoke the detailed logger and output something if it's enabled.
+        private void VDetailLog(string msg, params Object[] args)
+        {
+            if (ControllingPrim.PhysScene.VehicleLoggingEnabled)
+                ControllingPrim.PhysScene.DetailLog(msg, args);
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs b/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs
new file mode 100755
index 0000000..8312239
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs
@@ -0,0 +1,503 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+public abstract class BSLinkset
+{
+    // private static string LogHeader = "[BULLETSIM LINKSET]";
+
+    public enum LinksetImplementation
+    {
+        Constraint   = 0,   // linkset tied together with constraints
+        Compound     = 1,   // linkset tied together as a compound object
+        Manual       = 2    // linkset tied together manually (code moves all the pieces)
+    }
+    // Create the correct type of linkset for this child
+    public static BSLinkset Factory(BSScene physScene, BSPrimLinkable parent)
+    {
+        BSLinkset ret = null;
+
+        switch (parent.LinksetType)
+        {
+            case LinksetImplementation.Constraint:
+                ret = new BSLinksetConstraints(physScene, parent);
+                break;
+            case LinksetImplementation.Compound:
+                ret = new BSLinksetCompound(physScene, parent);
+                break;
+            case LinksetImplementation.Manual:
+                // ret = new BSLinksetManual(physScene, parent);
+                break;
+            default:
+                ret = new BSLinksetCompound(physScene, parent);
+                break;
+        }
+        if (ret == null)
+        {
+            physScene.Logger.ErrorFormat("[BULLETSIM LINKSET] Factory could not create linkset. Parent name={1}, ID={2}", parent.Name, parent.LocalID);
+        }
+        return ret;
+    }
+
+    public class BSLinkInfo
+    {
+        public BSPrimLinkable member;
+        public BSLinkInfo(BSPrimLinkable pMember)
+        {
+            member = pMember;
+        }
+        public virtual void ResetLink() { }
+        public virtual void SetLinkParameters(BSConstraint constrain) { }
+        // Returns 'true' if physical property updates from the child should be reported to the simulator
+        public virtual bool ShouldUpdateChildProperties() { return false; }
+    }
+
+    public LinksetImplementation LinksetImpl { get; protected set; }
+
+    public BSPrimLinkable LinksetRoot { get; protected set; }
+
+    protected BSScene m_physicsScene { get; private set; }
+
+    static int m_nextLinksetID = 1;
+    public int LinksetID { get; private set; }
+
+    // The children under the root in this linkset.
+    // protected HashSet<BSPrimLinkable> m_children;
+    protected Dictionary<BSPrimLinkable, BSLinkInfo> m_children;
+
+    // We lock the diddling of linkset classes to prevent any badness.
+    // This locks the modification of the instances of this class. Changes
+    //    to the physical representation is done via the tainting mechenism.
+    protected object m_linksetActivityLock = new Object();
+
+    // We keep the prim's mass in the linkset structure since it could be dependent on other prims
+    public float LinksetMass { get; protected set; }
+
+    public virtual bool LinksetIsColliding { get { return false; } }
+
+    public OMV.Vector3 CenterOfMass
+    {
+        get { return ComputeLinksetCenterOfMass(); }
+    }
+
+    public OMV.Vector3 GeometricCenter
+    {
+        get { return ComputeLinksetGeometricCenter(); }
+    }
+
+    protected BSLinkset(BSScene scene, BSPrimLinkable parent)
+    {
+        // A simple linkset of one (no children)
+        LinksetID = m_nextLinksetID++;
+        // We create LOTS of linksets.
+        if (m_nextLinksetID <= 0)
+            m_nextLinksetID = 1;
+        m_physicsScene = scene;
+        LinksetRoot = parent;
+        m_children = new Dictionary<BSPrimLinkable, BSLinkInfo>();
+        LinksetMass = parent.RawMass;
+        Rebuilding = false;
+        RebuildScheduled = false;
+
+        parent.ClearDisplacement();
+    }
+
+    // Link to a linkset where the child knows the parent.
+    // Parent changing should not happen so do some sanity checking.
+    // We return the parent's linkset so the child can track its membership.
+    // Called at runtime.
+    public BSLinkset AddMeToLinkset(BSPrimLinkable child)
+    {
+        lock (m_linksetActivityLock)
+        {
+            // Don't add the root to its own linkset
+            if (!IsRoot(child))
+                AddChildToLinkset(child);
+            LinksetMass = ComputeLinksetMass();
+        }
+        return this;
+    }
+
+    // Remove a child from a linkset.
+    // Returns a new linkset for the child which is a linkset of one (just the
+    //    orphened child).
+    // Called at runtime.
+    public BSLinkset RemoveMeFromLinkset(BSPrimLinkable child, bool inTaintTime)
+    {
+        lock (m_linksetActivityLock)
+        {
+            if (IsRoot(child))
+            {
+                // Cannot remove the root from a linkset.
+                return this;
+            }
+            RemoveChildFromLinkset(child, inTaintTime);
+            LinksetMass = ComputeLinksetMass();
+        }
+
+        // The child is down to a linkset of just itself
+        return BSLinkset.Factory(m_physicsScene, child);
+    }
+
+    // Return 'true' if the passed object is the root object of this linkset
+    public bool IsRoot(BSPrimLinkable requestor)
+    {
+        return (requestor.LocalID == LinksetRoot.LocalID);
+    }
+
+    public int NumberOfChildren { get { return m_children.Count; } }
+
+    // Return 'true' if this linkset has any children (more than the root member)
+    public bool HasAnyChildren { get { return (m_children.Count > 0); } }
+
+    // Return 'true' if this child is in this linkset
+    public bool HasChild(BSPrimLinkable child)
+    {
+        bool ret = false;
+        lock (m_linksetActivityLock)
+        {
+            ret = m_children.ContainsKey(child);
+        }
+        return ret;
+    }
+
+    // Perform an action on each member of the linkset including root prim.
+    // Depends on the action on whether this should be done at taint time.
+    public delegate bool ForEachMemberAction(BSPrimLinkable obj);
+    public virtual bool ForEachMember(ForEachMemberAction action)
+    {
+        bool ret = false;
+        lock (m_linksetActivityLock)
+        {
+            action(LinksetRoot);
+            foreach (BSPrimLinkable po in m_children.Keys)
+            {
+                if (action(po))
+                    break;
+            }
+        }
+        return ret;
+    }
+
+    public bool TryGetLinkInfo(BSPrimLinkable child, out BSLinkInfo foundInfo)
+    {
+        bool ret = false;
+        BSLinkInfo found = null;
+        lock (m_linksetActivityLock)
+        {
+            ret = m_children.TryGetValue(child, out found);
+        }
+        foundInfo = found;
+        return ret;
+    }
+    // Perform an action on each member of the linkset including root prim.
+    // Depends on the action on whether this should be done at taint time.
+    public delegate bool ForEachLinkInfoAction(BSLinkInfo obj);
+    public virtual bool ForEachLinkInfo(ForEachLinkInfoAction action)
+    {
+        bool ret = false;
+        lock (m_linksetActivityLock)
+        {
+            foreach (BSLinkInfo po in m_children.Values)
+            {
+                if (action(po))
+                    break;
+            }
+        }
+        return ret;
+    }
+
+    // Check the type of the link and return 'true' if the link is flexible and the
+    //    updates from the child should be sent to the simulator so things change.
+    public virtual bool ShouldReportPropertyUpdates(BSPrimLinkable child)
+    {
+        bool ret = false;
+
+        BSLinkInfo linkInfo;
+        if (m_children.TryGetValue(child, out linkInfo))
+        {
+            ret = linkInfo.ShouldUpdateChildProperties();
+        }
+
+        return ret;
+    }
+
+    // Called after a simulation step to post a collision with this object.
+    // Return 'true' if linkset processed the collision. 'false' says the linkset didn't have
+    //     anything to add for the collision and it should be passed through normal processing.
+    // Default processing for a linkset.
+    public virtual bool HandleCollide(uint collidingWith, BSPhysObject collidee,
+                                OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
+    {
+        bool ret = false;
+
+        // prims in the same linkset cannot collide with each other
+        BSPrimLinkable convCollidee = collidee as BSPrimLinkable;
+        if (convCollidee != null && (LinksetID == convCollidee.Linkset.LinksetID))
+        {
+            // By returning 'true', we tell the caller the collision has been 'handled' so it won't
+            //     do anything about this collision and thus, effectivily, ignoring the collision.
+            ret = true;
+        }
+        else
+        {
+            // Not a collision between members of the linkset. Must be a real collision.
+            // So the linkset root can know if there is a collision anywhere in the linkset.
+            LinksetRoot.SomeCollisionSimulationStep = m_physicsScene.SimulationStep;
+        }
+
+        return ret;
+    }
+
+    // I am the root of a linkset and a new child is being added
+    // Called while LinkActivity is locked.
+    protected abstract void AddChildToLinkset(BSPrimLinkable child);
+
+    // I am the root of a linkset and one of my children is being removed.
+    // Safe to call even if the child is not really in my linkset.
+    protected abstract void RemoveChildFromLinkset(BSPrimLinkable child, bool inTaintTime);
+
+    // When physical properties are changed the linkset needs to recalculate
+    //   its internal properties.
+    // May be called at runtime or taint-time.
+    public virtual void Refresh(BSPrimLinkable requestor)
+    {
+        LinksetMass = ComputeLinksetMass();
+    }
+
+    // Flag denoting the linkset is in the process of being rebuilt.
+    // Used to know not the schedule a rebuild in the middle of a rebuild.
+    // Because of potential update calls that could want to schedule another rebuild.
+    protected bool Rebuilding { get; set; }
+
+    // Flag saying a linkset rebuild has been scheduled.
+    // This is turned on when the rebuild is requested and turned off when
+    //     the rebuild is complete. Used to limit modifications to the
+    //     linkset parameters while the linkset is in an intermediate state.
+    // Protected by a "lock(m_linsetActivityLock)" on the BSLinkset object
+    public bool RebuildScheduled { get; protected set; }
+
+    // The object is going dynamic (physical). Do any setup necessary
+    //     for a dynamic linkset.
+    // Only the state of the passed object can be modified. The rest of the linkset
+    //     has not yet been fully constructed.
+    // Return 'true' if any properties updated on the passed object.
+    // Called at taint-time!
+    public abstract bool MakeDynamic(BSPrimLinkable child);
+
+    public virtual bool AllPartsComplete
+    {
+        get {
+            bool ret = true; 
+            this.ForEachMember((member) =>
+            {
+                if ((!member.IsInitialized) || member.IsIncomplete || member.PrimAssetState == BSPhysObject.PrimAssetCondition.Waiting)
+                {
+                    ret = false;
+                    return true;    // exit loop
+                }
+                return false;       // continue loop
+            });
+            return ret;
+        }
+    }
+
+    // The object is going static (non-physical). Do any setup necessary
+    //     for a static linkset.
+    // Return 'true' if any properties updated on the passed object.
+    // Called at taint-time!
+    public abstract bool MakeStatic(BSPrimLinkable child);
+
+    // Called when a parameter update comes from the physics engine for any object
+    //      of the linkset is received.
+    // Passed flag is update came from physics engine (true) or the user (false).
+    // Called at taint-time!!
+    public abstract void UpdateProperties(UpdatedProperties whichUpdated, BSPrimLinkable physObject);
+
+    // Routine used when rebuilding the body of the root of the linkset
+    // Destroy all the constraints have have been made to root.
+    // This is called when the root body is changing.
+    // Returns 'true' of something was actually removed and would need restoring
+    // Called at taint-time!!
+    public abstract bool RemoveDependencies(BSPrimLinkable child);
+
+    // ================================================================
+    // Some physical setting happen to all members of the linkset
+    public virtual void SetPhysicalFriction(float friction)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.SetFriction(member.PhysBody, friction);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void SetPhysicalRestitution(float restitution)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.SetRestitution(member.PhysBody, restitution);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void SetPhysicalGravity(OMV.Vector3 gravity)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.SetGravity(member.PhysBody, gravity);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void ComputeAndSetLocalInertia(OMV.Vector3 inertiaFactor, float linksetMass)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                {
+                    OMV.Vector3 inertia = m_physicsScene.PE.CalculateLocalInertia(member.PhysShape.physShapeInfo, linksetMass);
+                    member.Inertia = inertia * inertiaFactor;
+                    m_physicsScene.PE.SetMassProps(member.PhysBody, linksetMass, member.Inertia);
+                    m_physicsScene.PE.UpdateInertiaTensor(member.PhysBody);
+                    DetailLog("{0},BSLinkset.ComputeAndSetLocalInertia,m.mass={1}, inertia={2}", member.LocalID, linksetMass, member.Inertia);
+
+                }
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void SetPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.SetCollisionFlags(member.PhysBody, collFlags);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void AddToPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.AddToCollisionFlags(member.PhysBody, collFlags);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void RemoveFromPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.RemoveFromCollisionFlags(member.PhysBody, collFlags);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    // ================================================================
+    protected virtual float ComputeLinksetMass()
+    {
+        float mass = LinksetRoot.RawMass;
+        if (HasAnyChildren)
+        {
+            lock (m_linksetActivityLock)
+            {
+                foreach (BSPrimLinkable bp in m_children.Keys)
+                {
+                    mass += bp.RawMass;
+                }
+            }
+        }
+        return mass;
+    }
+
+    // Computes linkset's center of mass in world coordinates.
+    protected virtual OMV.Vector3 ComputeLinksetCenterOfMass()
+    {
+        OMV.Vector3 com;
+        lock (m_linksetActivityLock)
+        {
+            com = LinksetRoot.Position * LinksetRoot.RawMass;
+            float totalMass = LinksetRoot.RawMass;
+
+            foreach (BSPrimLinkable bp in m_children.Keys)
+            {
+                com += bp.Position * bp.RawMass;
+                totalMass += bp.RawMass;
+            }
+            if (totalMass != 0f)
+                com /= totalMass;
+        }
+
+        return com;
+    }
+
+    protected virtual OMV.Vector3 ComputeLinksetGeometricCenter()
+    {
+        OMV.Vector3 com;
+        lock (m_linksetActivityLock)
+        {
+            com = LinksetRoot.Position;
+
+            foreach (BSPrimLinkable bp in m_children.Keys)
+            {
+                com += bp.Position;
+            }
+            com /= (m_children.Count + 1);
+        }
+
+        return com;
+    }
+
+    #region Extension
+    public virtual object Extension(string pFunct, params object[] pParams)
+    {
+        return null;
+    }
+    #endregion // Extension
+
+    // Invoke the detailed logger and output something if it's enabled.
+    protected void DetailLog(string msg, params Object[] args)
+    {
+        if (m_physicsScene.PhysicsLogging.Enabled)
+            m_physicsScene.DetailLog(msg, args);
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSLinksetCompound.cs b/OpenSim/Region/PhysicsModules/BulletS/BSLinksetCompound.cs
new file mode 100755
index 0000000..953ddee
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSLinksetCompound.cs
@@ -0,0 +1,477 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OpenSim.Framework;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+public sealed class BSLinksetCompound : BSLinkset
+{
+#pragma warning disable 414
+    private static string LogHeader = "[BULLETSIM LINKSET COMPOUND]";
+#pragma warning restore 414
+
+    public BSLinksetCompound(BSScene scene, BSPrimLinkable parent)
+        : base(scene, parent)
+    {
+        LinksetImpl = LinksetImplementation.Compound;
+    }
+
+    // ================================================================
+    // Changing the physical property of the linkset only needs to change the root
+    public override void SetPhysicalFriction(float friction)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetFriction(LinksetRoot.PhysBody, friction);
+    }
+    public override void SetPhysicalRestitution(float restitution)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetRestitution(LinksetRoot.PhysBody, restitution);
+    }
+    public override void SetPhysicalGravity(OMV.Vector3 gravity)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetGravity(LinksetRoot.PhysBody, gravity);
+    }
+    public override void ComputeAndSetLocalInertia(OMV.Vector3 inertiaFactor, float linksetMass)
+    {
+        OMV.Vector3 inertia = m_physicsScene.PE.CalculateLocalInertia(LinksetRoot.PhysShape.physShapeInfo, linksetMass);
+        LinksetRoot.Inertia = inertia * inertiaFactor;
+        m_physicsScene.PE.SetMassProps(LinksetRoot.PhysBody, linksetMass, LinksetRoot.Inertia);
+        m_physicsScene.PE.UpdateInertiaTensor(LinksetRoot.PhysBody);
+    }
+    public override void SetPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetCollisionFlags(LinksetRoot.PhysBody, collFlags);
+    }
+    public override void AddToPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.AddToCollisionFlags(LinksetRoot.PhysBody, collFlags);
+    }
+    public override void RemoveFromPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.RemoveFromCollisionFlags(LinksetRoot.PhysBody, collFlags);
+    }
+    // ================================================================
+
+    // When physical properties are changed the linkset needs to recalculate
+    //   its internal properties.
+    public override void Refresh(BSPrimLinkable requestor)
+    {
+        // Something changed so do the rebuilding thing
+        ScheduleRebuild(requestor);
+        base.Refresh(requestor);
+    }
+
+    // Schedule a refresh to happen after all the other taint processing.
+    private void ScheduleRebuild(BSPrimLinkable requestor)
+    {
+        // When rebuilding, it is possible to set properties that would normally require a rebuild.
+        //    If already rebuilding, don't request another rebuild.
+        //    If a linkset with just a root prim (simple non-linked prim) don't bother rebuilding.
+        lock (m_linksetActivityLock)
+        {
+            if (!RebuildScheduled && !Rebuilding && HasAnyChildren)
+            {
+                InternalScheduleRebuild(requestor);
+            }
+        }
+    }
+
+    // Must be called with m_linksetActivityLock or race conditions will haunt you.
+    private void InternalScheduleRebuild(BSPrimLinkable requestor)
+    {
+        DetailLog("{0},BSLinksetCompound.InternalScheduleRebuild,,rebuilding={1},hasChildren={2}",
+                            requestor.LocalID, Rebuilding, HasAnyChildren);
+        RebuildScheduled = true;
+        m_physicsScene.PostTaintObject("BSLinksetCompound.ScheduleRebuild", LinksetRoot.LocalID, delegate()
+        {
+            if (HasAnyChildren)
+            {
+                if (this.AllPartsComplete)
+                {
+                    RecomputeLinksetCompound();
+                }
+                else
+                {
+                    DetailLog("{0},BSLinksetCompound.InternalScheduleRebuild,,rescheduling because not all children complete",
+                                                    requestor.LocalID);
+                    InternalScheduleRebuild(requestor);
+                }
+            }
+            RebuildScheduled = false;
+        });
+    }
+
+    // The object is going dynamic (physical). Do any setup necessary for a dynamic linkset.
+    // Only the state of the passed object can be modified. The rest of the linkset
+    //     has not yet been fully constructed.
+    // Return 'true' if any properties updated on the passed object.
+    // Called at taint-time!
+    public override bool MakeDynamic(BSPrimLinkable child)
+    {
+        bool ret = false;
+        DetailLog("{0},BSLinksetCompound.MakeDynamic,call,IsRoot={1}", child.LocalID, IsRoot(child));
+        if (IsRoot(child))
+        {
+            // The root is going dynamic. Rebuild the linkset so parts and mass get computed properly.
+            Refresh(LinksetRoot);
+        }
+        return ret;
+    }
+
+    // The object is going static (non-physical). We do not do anything for static linksets.
+    // Return 'true' if any properties updated on the passed object.
+    // Called at taint-time!
+    public override bool MakeStatic(BSPrimLinkable child)
+    {
+        bool ret = false;
+
+        DetailLog("{0},BSLinksetCompound.MakeStatic,call,IsRoot={1}", child.LocalID, IsRoot(child));
+        child.ClearDisplacement();
+        if (IsRoot(child))
+        {
+            // Schedule a rebuild to verify that the root shape is set to the real shape.
+            Refresh(LinksetRoot);
+        }
+        return ret;
+    }
+
+    // 'physicalUpdate' is true if these changes came directly from the physics engine. Don't need to rebuild then.
+    // Called at taint-time.
+    public override void UpdateProperties(UpdatedProperties whichUpdated, BSPrimLinkable updated)
+    {
+        if (!LinksetRoot.IsPhysicallyActive)
+        {
+            // No reason to do this physical stuff for static linksets.
+            DetailLog("{0},BSLinksetCompound.UpdateProperties,notPhysical", LinksetRoot.LocalID);
+            return;
+        }
+
+        // The user moving a child around requires the rebuilding of the linkset compound shape
+        // One problem is this happens when a border is crossed -- the simulator implementation
+        //    stores the position into the group which causes the move of the object
+        //    but it also means all the child positions get updated.
+        //    What would cause an unnecessary rebuild so we make sure the linkset is in a
+        //    region before bothering to do a rebuild.
+        if (!IsRoot(updated) && m_physicsScene.TerrainManager.IsWithinKnownTerrain(LinksetRoot.RawPosition))
+        {
+            // If a child of the linkset is updating only the position or rotation, that can be done
+            //    without rebuilding the linkset.
+            // If a handle for the child can be fetch, we update the child here. If a rebuild was
+            //    scheduled by someone else, the rebuild will just replace this setting.
+
+            bool updatedChild = false;
+            // Anything other than updating position or orientation usually means a physical update
+            //     and that is caused by us updating the object.
+            if ((whichUpdated & ~(UpdatedProperties.Position | UpdatedProperties.Orientation)) == 0)
+            {
+                // Find the physical instance of the child
+                if (!RebuildScheduled   // if rebuilding, let the rebuild do it
+                        && !LinksetRoot.IsIncomplete    // if waiting for assets or whatever, don't change
+                        && LinksetRoot.PhysShape.HasPhysicalShape   // there must be a physical shape assigned
+                        && m_physicsScene.PE.IsCompound(LinksetRoot.PhysShape.physShapeInfo))
+                {
+                    // It is possible that the linkset is still under construction and the child is not yet
+                    //    inserted into the compound shape. A rebuild of the linkset in a pre-step action will
+                    //    build the whole thing with the new position or rotation.
+                    // The index must be checked because Bullet references the child array but does no validity
+                    //    checking of the child index passed.
+                    int numLinksetChildren = m_physicsScene.PE.GetNumberOfCompoundChildren(LinksetRoot.PhysShape.physShapeInfo);
+                    if (updated.LinksetChildIndex < numLinksetChildren)
+                    {
+                        BulletShape linksetChildShape = m_physicsScene.PE.GetChildShapeFromCompoundShapeIndex(LinksetRoot.PhysShape.physShapeInfo, updated.LinksetChildIndex);
+                        if (linksetChildShape.HasPhysicalShape)
+                        {
+                            // Found the child shape within the compound shape
+                            m_physicsScene.PE.UpdateChildTransform(LinksetRoot.PhysShape.physShapeInfo, updated.LinksetChildIndex,
+                                                                        updated.RawPosition - LinksetRoot.RawPosition,
+                                                                        updated.RawOrientation * OMV.Quaternion.Inverse(LinksetRoot.RawOrientation),
+                                                                        true /* shouldRecalculateLocalAabb */);
+                            updatedChild = true;
+                            DetailLog("{0},BSLinksetCompound.UpdateProperties,changeChildPosRot,whichUpdated={1},pos={2},rot={3}",
+                                                        updated.LocalID, whichUpdated, updated.RawPosition, updated.RawOrientation);
+                        }
+                        else    // DEBUG DEBUG
+                        {       // DEBUG DEBUG
+                            DetailLog("{0},BSLinksetCompound.UpdateProperties,couldNotUpdateChild,noChildShape,shape={1}",
+                                                                        updated.LocalID, linksetChildShape);
+                        }       // DEBUG DEBUG
+                    }
+                    else    // DEBUG DEBUG
+                    {       // DEBUG DEBUG
+                        // the child is not yet in the compound shape. This is non-fatal.
+                        DetailLog("{0},BSLinksetCompound.UpdateProperties,couldNotUpdateChild,childNotInCompoundShape,numChildren={1},index={2}",
+                                                                    updated.LocalID, numLinksetChildren, updated.LinksetChildIndex);
+                    }       // DEBUG DEBUG
+                }
+                else    // DEBUG DEBUG
+                {       // DEBUG DEBUG
+                    DetailLog("{0},BSLinksetCompound.UpdateProperties,couldNotUpdateChild,noBodyOrNotCompound", updated.LocalID);
+                }       // DEBUG DEBUG
+
+                if (!updatedChild)
+                {
+                    // If couldn't do the individual child, the linkset needs a rebuild to incorporate the new child info.
+                    // Note: there are several ways through this code that will not update the child if
+                    //    the linkset is being rebuilt. In this case, scheduling a rebuild is a NOOP since
+                    //    there will already be a rebuild scheduled.
+                    DetailLog("{0},BSLinksetCompound.UpdateProperties,couldNotUpdateChild.schedulingRebuild,whichUpdated={1}",
+                                                                    updated.LocalID, whichUpdated);
+                    Refresh(updated);
+                }
+            }
+        }
+    }
+
+    // Routine called when rebuilding the body of some member of the linkset.
+    // If one of the bodies is being changed, the linkset needs rebuilding.
+    // For instance, a linkset is built and then a mesh asset is read in and the mesh is recreated.
+    // Returns 'true' of something was actually removed and would need restoring
+    // Called at taint-time!!
+    public override bool RemoveDependencies(BSPrimLinkable child)
+    {
+        bool ret = false;
+
+        DetailLog("{0},BSLinksetCompound.RemoveDependencies,refreshIfChild,rID={1},rBody={2},isRoot={3}",
+                        child.LocalID, LinksetRoot.LocalID, LinksetRoot.PhysBody, IsRoot(child));
+
+        Refresh(child);
+
+        return ret;
+    }
+
+    // ================================================================
+
+    // Add a new child to the linkset.
+    // Called while LinkActivity is locked.
+    protected override void AddChildToLinkset(BSPrimLinkable child)
+    {
+        if (!HasChild(child))
+        {
+            m_children.Add(child, new BSLinkInfo(child));
+
+            DetailLog("{0},BSLinksetCompound.AddChildToLinkset,call,child={1}", LinksetRoot.LocalID, child.LocalID);
+
+            // Rebuild the compound shape with the new child shape included
+            Refresh(child);
+        }
+        return;
+    }
+
+    // Remove the specified child from the linkset.
+    // Safe to call even if the child is not really in the linkset.
+    protected override void RemoveChildFromLinkset(BSPrimLinkable child, bool inTaintTime)
+    {
+        child.ClearDisplacement();
+
+        if (m_children.Remove(child))
+        {
+            DetailLog("{0},BSLinksetCompound.RemoveChildFromLinkset,call,rID={1},rBody={2},cID={3},cBody={4}",
+                            child.LocalID,
+                            LinksetRoot.LocalID, LinksetRoot.PhysBody.AddrString,
+                            child.LocalID, child.PhysBody.AddrString);
+
+            // Cause the child's body to be rebuilt and thus restored to normal operation
+            child.ForceBodyShapeRebuild(inTaintTime);
+
+            if (!HasAnyChildren)
+            {
+                // The linkset is now empty. The root needs rebuilding.
+                LinksetRoot.ForceBodyShapeRebuild(inTaintTime);
+            }
+            else
+            {
+                // Rebuild the compound shape with the child removed
+                Refresh(LinksetRoot);
+            }
+        }
+        return;
+    }
+
+    // Called before the simulation step to make sure the compound based linkset
+    //    is all initialized.
+    // Constraint linksets are rebuilt every time.
+    // Note that this works for rebuilding just the root after a linkset is taken apart.
+    // Called at taint time!!
+    private bool UseBulletSimRootOffsetHack = false;    // Attempt to have Bullet track the coords of root compound shape
+    private void RecomputeLinksetCompound()
+    {
+        try
+        {
+            Rebuilding = true;
+
+            // No matter what is being done, force the root prim's PhysBody and PhysShape to get set
+            //     to what they should be as if the root was not in a linkset.
+            // Not that bad since we only get into this routine if there are children in the linkset and
+            //     something has been updated/changed.
+            // Have to do the rebuild before checking for physical because this might be a linkset
+            //     being destructed and going non-physical.
+            LinksetRoot.ForceBodyShapeRebuild(true);
+
+            // There is no reason to build all this physical stuff for a non-physical or empty linkset.
+            if (!LinksetRoot.IsPhysicallyActive || !HasAnyChildren)
+            {
+                DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,notPhysicalOrNoChildren", LinksetRoot.LocalID);
+                return; // Note the 'finally' clause at the botton which will get executed.
+            }
+
+            // Get a new compound shape to build the linkset shape in.
+            BSShape linksetShape = BSShapeCompound.GetReference(m_physicsScene);
+
+            // Compute a displacement for each component so it is relative to the center-of-mass.
+            // Bullet presumes an object's origin (relative <0,0,0>) is its center-of-mass
+            OMV.Vector3 centerOfMassW = ComputeLinksetCenterOfMass();
+
+            OMV.Quaternion invRootOrientation = OMV.Quaternion.Normalize(OMV.Quaternion.Inverse(LinksetRoot.RawOrientation));
+            OMV.Vector3 origRootPosition = LinksetRoot.RawPosition;
+
+            // 'centerDisplacementV' is the vehicle relative distance from the simulator root position to the center-of-mass
+            OMV.Vector3 centerDisplacementV = (centerOfMassW - LinksetRoot.RawPosition) * invRootOrientation;
+            if (UseBulletSimRootOffsetHack || !BSParam.LinksetOffsetCenterOfMass)
+            {
+                // Zero everything if center-of-mass displacement is not being done.
+                centerDisplacementV = OMV.Vector3.Zero;
+                LinksetRoot.ClearDisplacement();
+            }
+            else
+            {
+                // The actual center-of-mass could have been set by the user.
+                centerDisplacementV = LinksetRoot.SetEffectiveCenterOfMassDisplacement(centerDisplacementV);
+            }
+
+            DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,COM,rootPos={1},com={2},comDisp={3}",
+                                LinksetRoot.LocalID, origRootPosition, centerOfMassW, centerDisplacementV);
+
+            // Add the shapes of all the components of the linkset
+            int memberIndex = 1;
+            ForEachMember((cPrim) =>
+            {
+                if (IsRoot(cPrim))
+                {
+                    // Root shape is always index zero.
+                    cPrim.LinksetChildIndex = 0;
+                }
+                else
+                {
+                    cPrim.LinksetChildIndex = memberIndex;
+                    memberIndex++;
+                }
+
+                // Get a reference to the shape of the child for adding of that shape to the linkset compound shape
+                BSShape childShape = cPrim.PhysShape.GetReference(m_physicsScene, cPrim);
+
+                // Offset the child shape from the center-of-mass and rotate it to root relative.
+                OMV.Vector3 offsetPos = (cPrim.RawPosition - origRootPosition) * invRootOrientation - centerDisplacementV;
+                OMV.Quaternion offsetRot = OMV.Quaternion.Normalize(cPrim.RawOrientation) * invRootOrientation;
+
+                // Add the child shape to the compound shape being built
+                if (childShape.physShapeInfo.HasPhysicalShape)
+                {
+                    m_physicsScene.PE.AddChildShapeToCompoundShape(linksetShape.physShapeInfo, childShape.physShapeInfo, offsetPos, offsetRot);
+                    DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addChild,indx={1},cShape={2},offPos={3},offRot={4}",
+                                LinksetRoot.LocalID, cPrim.LinksetChildIndex, childShape, offsetPos, offsetRot);
+
+                    // Since we are borrowing the shape of the child, disable the origional child body
+                    if (!IsRoot(cPrim))
+                    {
+                        m_physicsScene.PE.AddToCollisionFlags(cPrim.PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
+                        m_physicsScene.PE.ForceActivationState(cPrim.PhysBody, ActivationState.DISABLE_SIMULATION);
+                        // We don't want collisions from the old linkset children.
+                        m_physicsScene.PE.RemoveFromCollisionFlags(cPrim.PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                        cPrim.PhysBody.collisionType = CollisionType.LinksetChild;
+                    }
+                }
+                else
+                {
+                    // The linkset must be in an intermediate state where all the children have not yet
+                    //    been constructed. This sometimes happens on startup when everything is getting
+                    //    built and some shapes have to wait for assets to be read in.
+                    // Just skip this linkset for the moment and cause the shape to be rebuilt next tick.
+                    // One problem might be that the shape is broken somehow and it never becomes completely
+                    //    available. This might cause the rebuild to happen over and over.
+                    InternalScheduleRebuild(LinksetRoot);
+                    DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addChildWithNoShape,indx={1},cShape={2},offPos={3},offRot={4}",
+                                    LinksetRoot.LocalID, cPrim.LinksetChildIndex, childShape, offsetPos, offsetRot);
+                    // Output an annoying warning. It should only happen once but if it keeps coming out,
+                    //    the user knows there is something wrong and will report it.
+                    m_physicsScene.Logger.WarnFormat("{0} Linkset rebuild warning. If this happens more than one or two times, please report in Mantis 7191", LogHeader);
+                    m_physicsScene.Logger.WarnFormat("{0} pName={1}, childIdx={2}, shape={3}",
+                                    LogHeader, LinksetRoot.Name, cPrim.LinksetChildIndex, childShape);
+
+                    // This causes the loop to bail on building the rest of this linkset.
+                    // The rebuild operation will fix it up next tick or declare the object unbuildable.
+                    return true;
+                }
+
+                return false;   // 'false' says to move onto the next child in the list
+            });
+
+            // Replace the root shape with the built compound shape.
+            // Object removed and added to world to get collision cache rebuilt for new shape.
+            LinksetRoot.PhysShape.Dereference(m_physicsScene);
+            LinksetRoot.PhysShape = linksetShape;
+            m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, LinksetRoot.PhysBody);
+            m_physicsScene.PE.SetCollisionShape(m_physicsScene.World, LinksetRoot.PhysBody, linksetShape.physShapeInfo);
+            m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, LinksetRoot.PhysBody);
+            DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addBody,body={1},shape={2}",
+                                        LinksetRoot.LocalID, LinksetRoot.PhysBody, linksetShape);
+
+            // With all of the linkset packed into the root prim, it has the mass of everyone.
+            LinksetMass = ComputeLinksetMass();
+            LinksetRoot.UpdatePhysicalMassProperties(LinksetMass, true);
+
+            if (UseBulletSimRootOffsetHack)
+            {
+                // Enable the physical position updator to return the position and rotation of the root shape.
+                // This enables a feature in the C++ code to return the world coordinates of the first shape in the
+                //     compound shape. This aleviates the need to offset the returned physical position by the
+                //     center-of-mass offset.
+                // TODO: either debug this feature or remove it.
+                m_physicsScene.PE.AddToCollisionFlags(LinksetRoot.PhysBody, CollisionFlags.BS_RETURN_ROOT_COMPOUND_SHAPE);
+            }
+        }
+        finally
+        {
+            Rebuilding = false;
+        }
+
+        // See that the Aabb surrounds the new shape
+        m_physicsScene.PE.RecalculateCompoundShapeLocalAabb(LinksetRoot.PhysShape.physShapeInfo);
+    }
+}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSLinksetConstraints.cs b/OpenSim/Region/PhysicsModules/BulletS/BSLinksetConstraints.cs
new file mode 100755
index 0000000..c4b4c86
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSLinksetConstraints.cs
@@ -0,0 +1,852 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public sealed class BSLinksetConstraints : BSLinkset
+{
+    // private static string LogHeader = "[BULLETSIM LINKSET CONSTRAINTS]";
+
+    public class BSLinkInfoConstraint : BSLinkInfo
+    {
+        public ConstraintType constraintType;
+        public BSConstraint constraint;
+        public OMV.Vector3 linearLimitLow;
+        public OMV.Vector3 linearLimitHigh;
+        public OMV.Vector3 angularLimitLow;
+        public OMV.Vector3 angularLimitHigh;
+        public bool useFrameOffset;
+        public bool enableTransMotor;
+        public float transMotorMaxVel;
+        public float transMotorMaxForce;
+        public float cfm;
+        public float erp;
+        public float solverIterations;
+        //
+        public OMV.Vector3 frameInAloc;
+        public OMV.Quaternion frameInArot;
+        public OMV.Vector3 frameInBloc;
+        public OMV.Quaternion frameInBrot;
+        public bool useLinearReferenceFrameA;
+        // Spring
+        public bool[] springAxisEnable;
+        public float[] springDamping;
+        public float[] springStiffness;
+        public OMV.Vector3 springLinearEquilibriumPoint;
+        public OMV.Vector3 springAngularEquilibriumPoint;
+
+        public BSLinkInfoConstraint(BSPrimLinkable pMember)
+            : base(pMember)
+        {
+            constraint = null;
+            ResetLink();
+            member.PhysScene.DetailLog("{0},BSLinkInfoConstraint.creation", member.LocalID);
+        }
+
+        // Set all the parameters for this constraint to a fixed, non-movable constraint.
+        public override void ResetLink()
+        {
+            // constraintType = ConstraintType.D6_CONSTRAINT_TYPE;
+            constraintType = ConstraintType.BS_FIXED_CONSTRAINT_TYPE;
+            linearLimitLow = OMV.Vector3.Zero;
+            linearLimitHigh = OMV.Vector3.Zero;
+            angularLimitLow = OMV.Vector3.Zero;
+            angularLimitHigh = OMV.Vector3.Zero;
+            useFrameOffset = BSParam.LinkConstraintUseFrameOffset;
+            enableTransMotor = BSParam.LinkConstraintEnableTransMotor;
+            transMotorMaxVel = BSParam.LinkConstraintTransMotorMaxVel;
+            transMotorMaxForce = BSParam.LinkConstraintTransMotorMaxForce;
+            cfm = BSParam.LinkConstraintCFM;
+            erp = BSParam.LinkConstraintERP;
+            solverIterations = BSParam.LinkConstraintSolverIterations;
+            frameInAloc = OMV.Vector3.Zero;
+            frameInArot = OMV.Quaternion.Identity;
+            frameInBloc = OMV.Vector3.Zero;
+            frameInBrot = OMV.Quaternion.Identity;
+            useLinearReferenceFrameA = true;
+            springAxisEnable = new bool[6];
+            springDamping = new float[6];
+            springStiffness = new float[6];
+            for (int ii = 0; ii < springAxisEnable.Length; ii++)
+            {
+                springAxisEnable[ii] = false;
+                springDamping[ii] = BSAPITemplate.SPRING_NOT_SPECIFIED;
+                springStiffness[ii] = BSAPITemplate.SPRING_NOT_SPECIFIED;
+            }
+            springLinearEquilibriumPoint = OMV.Vector3.Zero;
+            springAngularEquilibriumPoint = OMV.Vector3.Zero;
+            member.PhysScene.DetailLog("{0},BSLinkInfoConstraint.ResetLink", member.LocalID);
+        }
+
+        // Given a constraint, apply the current constraint parameters to same.
+        public override void SetLinkParameters(BSConstraint constrain)
+        {
+            member.PhysScene.DetailLog("{0},BSLinkInfoConstraint.SetLinkParameters,type={1}", member.LocalID, constraintType);
+            switch (constraintType)
+            {
+                case ConstraintType.BS_FIXED_CONSTRAINT_TYPE:
+                case ConstraintType.D6_CONSTRAINT_TYPE:
+                    BSConstraint6Dof constrain6dof = constrain as BSConstraint6Dof;
+                    if (constrain6dof != null)
+                    {
+                        // NOTE: D6_SPRING_CONSTRAINT_TYPE should be updated if you change any of this code.
+                        // zero linear and angular limits makes the objects unable to move in relation to each other
+                        constrain6dof.SetLinearLimits(linearLimitLow, linearLimitHigh);
+                        constrain6dof.SetAngularLimits(angularLimitLow, angularLimitHigh);
+
+                        // tweek the constraint to increase stability
+                        constrain6dof.UseFrameOffset(useFrameOffset);
+                        constrain6dof.TranslationalLimitMotor(enableTransMotor, transMotorMaxVel, transMotorMaxForce);
+                        constrain6dof.SetCFMAndERP(cfm, erp);
+                        if (solverIterations != 0f)
+                        {
+                            constrain6dof.SetSolverIterations(solverIterations);
+                        }
+                    }
+                    break;
+                case ConstraintType.D6_SPRING_CONSTRAINT_TYPE:
+                    BSConstraintSpring constrainSpring = constrain as BSConstraintSpring;
+                    if (constrainSpring != null)
+                    {
+                        // zero linear and angular limits makes the objects unable to move in relation to each other
+                        constrainSpring.SetLinearLimits(linearLimitLow, linearLimitHigh);
+                        constrainSpring.SetAngularLimits(angularLimitLow, angularLimitHigh);
+
+                        // tweek the constraint to increase stability
+                        constrainSpring.UseFrameOffset(useFrameOffset);
+                        constrainSpring.TranslationalLimitMotor(enableTransMotor, transMotorMaxVel, transMotorMaxForce);
+                        constrainSpring.SetCFMAndERP(cfm, erp);
+                        if (solverIterations != 0f)
+                        {
+                            constrainSpring.SetSolverIterations(solverIterations);
+                        }
+                        for (int ii = 0; ii < springAxisEnable.Length; ii++)
+                        {
+                            constrainSpring.SetAxisEnable(ii, springAxisEnable[ii]);
+                            if (springDamping[ii] != BSAPITemplate.SPRING_NOT_SPECIFIED)
+                                constrainSpring.SetDamping(ii, springDamping[ii]);
+                            if (springStiffness[ii] != BSAPITemplate.SPRING_NOT_SPECIFIED)
+                                constrainSpring.SetStiffness(ii, springStiffness[ii]);
+                        }
+                        constrainSpring.CalculateTransforms();
+
+                        if (springLinearEquilibriumPoint != OMV.Vector3.Zero)
+                            constrainSpring.SetEquilibriumPoint(springLinearEquilibriumPoint, springAngularEquilibriumPoint);
+                        else
+                            constrainSpring.SetEquilibriumPoint(BSAPITemplate.SPRING_NOT_SPECIFIED, BSAPITemplate.SPRING_NOT_SPECIFIED);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        // Return 'true' if the property updates from the physics engine should be reported
+        //    to the simulator.
+        // If the constraint is fixed, we don't need to report as the simulator and viewer will
+        //    report the right things.
+        public override bool ShouldUpdateChildProperties()
+        {
+            bool ret = true;
+            if (constraintType == ConstraintType.BS_FIXED_CONSTRAINT_TYPE)
+                ret = false;
+
+            return ret;
+        }
+    }
+
+    public BSLinksetConstraints(BSScene scene, BSPrimLinkable parent) : base(scene, parent)
+    {
+        LinksetImpl = LinksetImplementation.Constraint;
+    }
+
+    private static string LogHeader = "[BULLETSIM LINKSET CONSTRAINT]";
+
+    // When physical properties are changed the linkset needs to recalculate
+    //   its internal properties.
+    // This is queued in the 'post taint' queue so the
+    //   refresh will happen once after all the other taints are applied.
+    public override void Refresh(BSPrimLinkable requestor)
+    {
+        ScheduleRebuild(requestor);
+        base.Refresh(requestor);
+
+    }
+
+    private void ScheduleRebuild(BSPrimLinkable requestor)
+    {
+        DetailLog("{0},BSLinksetConstraint.ScheduleRebuild,,rebuilding={1},hasChildren={2},actuallyScheduling={3}",
+                            requestor.LocalID, Rebuilding, HasAnyChildren, (!Rebuilding && HasAnyChildren));
+
+        // When rebuilding, it is possible to set properties that would normally require a rebuild.
+        //    If already rebuilding, don't request another rebuild.
+        //    If a linkset with just a root prim (simple non-linked prim) don't bother rebuilding.
+        lock (this)
+        {
+            if (!RebuildScheduled)
+            {
+                if (!Rebuilding && HasAnyChildren)
+                {
+                    RebuildScheduled = true;
+                    // Queue to happen after all the other taint processing
+                    m_physicsScene.PostTaintObject("BSLinksetContraints.Refresh", requestor.LocalID, delegate()
+                    {
+                        if (HasAnyChildren)
+                        {
+                            // Constraints that have not been changed are not rebuild but make sure
+                            //     the constraint of the requestor is rebuilt.
+                            PhysicallyUnlinkAChildFromRoot(LinksetRoot, requestor);
+                            // Rebuild the linkset and all its constraints.
+                            RecomputeLinksetConstraints();
+                        }
+                        RebuildScheduled = false;
+                    });
+                }
+            }
+        }
+    }
+
+    // The object is going dynamic (physical). Do any setup necessary
+    //     for a dynamic linkset.
+    // Only the state of the passed object can be modified. The rest of the linkset
+    //     has not yet been fully constructed.
+    // Return 'true' if any properties updated on the passed object.
+    // Called at taint-time!
+    public override bool MakeDynamic(BSPrimLinkable child)
+    {
+        bool ret = false;
+        DetailLog("{0},BSLinksetConstraints.MakeDynamic,call,IsRoot={1}", child.LocalID, IsRoot(child));
+        if (IsRoot(child))
+        {
+            // The root is going dynamic. Rebuild the linkset so parts and mass get computed properly.
+            Refresh(LinksetRoot);
+        }
+        return ret;
+    }
+
+    // The object is going static (non-physical). Do any setup necessary for a static linkset.
+    // Return 'true' if any properties updated on the passed object.
+    // This doesn't normally happen -- OpenSim removes the objects from the physical
+    //     world if it is a static linkset.
+    // Called at taint-time!
+    public override bool MakeStatic(BSPrimLinkable child)
+    {
+        bool ret = false;
+
+        DetailLog("{0},BSLinksetConstraint.MakeStatic,call,IsRoot={1}", child.LocalID, IsRoot(child));
+        child.ClearDisplacement();
+        if (IsRoot(child))
+        {
+            // Schedule a rebuild to verify that the root shape is set to the real shape.
+            Refresh(LinksetRoot);
+        }
+        return ret;
+    }
+
+    // Called at taint-time!!
+    public override void UpdateProperties(UpdatedProperties whichUpdated, BSPrimLinkable pObj)
+    {
+        // Nothing to do for constraints on property updates
+    }
+
+    // Routine called when rebuilding the body of some member of the linkset.
+    // Destroy all the constraints have have been made to root and set
+    //     up to rebuild the constraints before the next simulation step.
+    // Returns 'true' of something was actually removed and would need restoring
+    // Called at taint-time!!
+    public override bool RemoveDependencies(BSPrimLinkable child)
+    {
+        bool ret = false;
+
+        DetailLog("{0},BSLinksetConstraint.RemoveDependencies,removeChildrenForRoot,rID={1},rBody={2}",
+                                    child.LocalID, LinksetRoot.LocalID, LinksetRoot.PhysBody.AddrString);
+
+        lock (m_linksetActivityLock)
+        {
+            // Just undo all the constraints for this linkset. Rebuild at the end of the step.
+            ret = PhysicallyUnlinkAllChildrenFromRoot(LinksetRoot);
+            // Cause the constraints, et al to be rebuilt before the next simulation step.
+            Refresh(LinksetRoot);
+        }
+        return ret;
+    }
+
+    // ================================================================
+
+    // Add a new child to the linkset.
+    // Called while LinkActivity is locked.
+    protected override void AddChildToLinkset(BSPrimLinkable child)
+    {
+        if (!HasChild(child))
+        {
+            m_children.Add(child, new BSLinkInfoConstraint(child));
+
+            DetailLog("{0},BSLinksetConstraints.AddChildToLinkset,call,child={1}", LinksetRoot.LocalID, child.LocalID);
+
+            // Cause constraints and assorted properties to be recomputed before the next simulation step.
+            Refresh(LinksetRoot);
+        }
+        return;
+    }
+
+    // Remove the specified child from the linkset.
+    // Safe to call even if the child is not really in my linkset.
+    protected override void RemoveChildFromLinkset(BSPrimLinkable child, bool inTaintTime)
+    {
+        if (m_children.Remove(child))
+        {
+            BSPrimLinkable rootx = LinksetRoot; // capture the root and body as of now
+            BSPrimLinkable childx = child;
+
+            DetailLog("{0},BSLinksetConstraints.RemoveChildFromLinkset,call,rID={1},rBody={2},cID={3},cBody={4}",
+                            childx.LocalID,
+                            rootx.LocalID, rootx.PhysBody.AddrString,
+                            childx.LocalID, childx.PhysBody.AddrString);
+
+            m_physicsScene.TaintedObject(inTaintTime, childx.LocalID, "BSLinksetConstraints.RemoveChildFromLinkset", delegate()
+            {
+                PhysicallyUnlinkAChildFromRoot(rootx, childx);
+            });
+            // See that the linkset parameters are recomputed at the end of the taint time.
+            Refresh(LinksetRoot);
+        }
+        else
+        {
+            // Non-fatal occurance.
+            // PhysicsScene.Logger.ErrorFormat("{0}: Asked to remove child from linkset that was not in linkset", LogHeader);
+        }
+        return;
+    }
+
+    // Create a constraint between me (root of linkset) and the passed prim (the child).
+    // Called at taint time!
+    private void PhysicallyLinkAChildToRoot(BSPrimLinkable rootPrim, BSPrimLinkable childPrim)
+    {
+        // Don't build the constraint when asked. Put it off until just before the simulation step.
+        Refresh(rootPrim);
+    }
+
+    // Create a static constraint between the two passed objects
+    private BSConstraint BuildConstraint(BSPrimLinkable rootPrim, BSLinkInfo li)
+    {
+        BSLinkInfoConstraint linkInfo = li as BSLinkInfoConstraint;
+        if (linkInfo == null)
+            return null;
+
+        // Zero motion for children so they don't interpolate
+        li.member.ZeroMotion(true);
+
+        BSConstraint constrain = null;
+
+        switch (linkInfo.constraintType)
+        {
+            case ConstraintType.BS_FIXED_CONSTRAINT_TYPE:
+            case ConstraintType.D6_CONSTRAINT_TYPE:
+                // Relative position normalized to the root prim
+                // Essentually a vector pointing from center of rootPrim to center of li.member
+                OMV.Vector3 childRelativePosition = linkInfo.member.Position - rootPrim.Position;
+
+                // real world coordinate of midpoint between the two objects
+                OMV.Vector3 midPoint = rootPrim.Position + (childRelativePosition / 2);
+
+                DetailLog("{0},BSLinksetConstraint.BuildConstraint,6Dof,rBody={1},cBody={2},rLoc={3},cLoc={4},midLoc={5}",
+                                                rootPrim.LocalID, rootPrim.PhysBody, linkInfo.member.PhysBody,
+                                                rootPrim.Position, linkInfo.member.Position, midPoint);
+
+                // create a constraint that allows no freedom of movement between the two objects
+                // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818
+
+                constrain = new BSConstraint6Dof(
+                                    m_physicsScene.World, rootPrim.PhysBody, linkInfo.member.PhysBody, midPoint, true, true );
+
+                /* NOTE: below is an attempt to build constraint with full frame computation, etc.
+                 *     Using the midpoint is easier since it lets the Bullet code manipulate the transforms
+                 *     of the objects.
+                 * Code left for future programmers.
+                // ==================================================================================
+                // relative position normalized to the root prim
+                OMV.Quaternion invThisOrientation = OMV.Quaternion.Inverse(rootPrim.Orientation);
+                OMV.Vector3 childRelativePosition = (liConstraint.member.Position - rootPrim.Position) * invThisOrientation;
+
+                // relative rotation of the child to the parent
+                OMV.Quaternion childRelativeRotation = invThisOrientation * liConstraint.member.Orientation;
+                OMV.Quaternion inverseChildRelativeRotation = OMV.Quaternion.Inverse(childRelativeRotation);
+
+                DetailLog("{0},BSLinksetConstraint.PhysicallyLinkAChildToRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, liConstraint.member.LocalID);
+                constrain = new BS6DofConstraint(
+                                PhysicsScene.World, rootPrim.Body, liConstraint.member.Body,
+                                OMV.Vector3.Zero,
+                                OMV.Quaternion.Inverse(rootPrim.Orientation),
+                                OMV.Vector3.Zero,
+                                OMV.Quaternion.Inverse(liConstraint.member.Orientation),
+                                true,
+                                true
+                                );
+                // ==================================================================================
+                */
+
+                break;
+            case ConstraintType.D6_SPRING_CONSTRAINT_TYPE:
+                constrain = new BSConstraintSpring(m_physicsScene.World, rootPrim.PhysBody, linkInfo.member.PhysBody,
+                                linkInfo.frameInAloc, linkInfo.frameInArot, linkInfo.frameInBloc, linkInfo.frameInBrot,
+                                linkInfo.useLinearReferenceFrameA,
+                                true /*disableCollisionsBetweenLinkedBodies*/);
+                DetailLog("{0},BSLinksetConstraint.BuildConstraint,spring,root={1},rBody={2},child={3},cBody={4},rLoc={5},cLoc={6}",
+                                                rootPrim.LocalID,
+                                                rootPrim.LocalID, rootPrim.PhysBody.AddrString,
+                                                linkInfo.member.LocalID, linkInfo.member.PhysBody.AddrString,
+                                                rootPrim.Position, linkInfo.member.Position);
+
+                break;
+            default:
+                break;
+        }
+
+        linkInfo.SetLinkParameters(constrain);
+
+        m_physicsScene.Constraints.AddConstraint(constrain);
+
+        return constrain;
+    }
+
+    // Remove linkage between the linkset root and a particular child
+    // The root and child bodies are passed in because we need to remove the constraint between
+    //      the bodies that were present at unlink time.
+    // Called at taint time!
+    private bool PhysicallyUnlinkAChildFromRoot(BSPrimLinkable rootPrim, BSPrimLinkable childPrim)
+    {
+        bool ret = false;
+        DetailLog("{0},BSLinksetConstraint.PhysicallyUnlinkAChildFromRoot,taint,root={1},rBody={2},child={3},cBody={4}",
+                            rootPrim.LocalID,
+                            rootPrim.LocalID, rootPrim.PhysBody.AddrString,
+                            childPrim.LocalID, childPrim.PhysBody.AddrString);
+
+        // If asked to unlink root from root, just remove all the constraints
+        if (rootPrim == childPrim || childPrim == LinksetRoot)
+        {
+            PhysicallyUnlinkAllChildrenFromRoot(LinksetRoot);
+            ret = true;
+        }
+        else
+        {
+            // Find the constraint for this link and get rid of it from the overall collection and from my list
+            if (m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.PhysBody, childPrim.PhysBody))
+            {
+                // Make the child refresh its location
+                m_physicsScene.PE.PushUpdate(childPrim.PhysBody);
+                ret = true;
+            }
+        }
+
+        return ret;
+    }
+
+    // Remove linkage between myself and any possible children I might have.
+    // Returns 'true' of any constraints were destroyed.
+    // Called at taint time!
+    private bool PhysicallyUnlinkAllChildrenFromRoot(BSPrimLinkable rootPrim)
+    {
+        DetailLog("{0},BSLinksetConstraint.PhysicallyUnlinkAllChildren,taint", rootPrim.LocalID);
+
+        return m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.PhysBody);
+    }
+
+    // Call each of the constraints that make up this linkset and recompute the
+    //    various transforms and variables. Create constraints of not created yet.
+    // Called before the simulation step to make sure the constraint based linkset
+    //    is all initialized.
+    // Called at taint time!!
+    private void RecomputeLinksetConstraints()
+    {
+        float linksetMass = LinksetMass;
+        LinksetRoot.UpdatePhysicalMassProperties(linksetMass, true);
+
+        DetailLog("{0},BSLinksetConstraint.RecomputeLinksetConstraints,set,rBody={1},linksetMass={2}",
+                            LinksetRoot.LocalID, LinksetRoot.PhysBody.AddrString, linksetMass);
+
+        try
+        {
+            Rebuilding = true;
+
+            // There is no reason to build all this physical stuff for a non-physical linkset.
+            if (!LinksetRoot.IsPhysicallyActive || !HasAnyChildren)
+            {
+                DetailLog("{0},BSLinksetConstraint.RecomputeLinksetCompound,notPhysicalOrNoChildren", LinksetRoot.LocalID);
+                return; // Note the 'finally' clause at the botton which will get executed.
+            }
+
+            ForEachLinkInfo((li) =>
+            {
+                // A child in the linkset physically shows the mass of the whole linkset.
+                // This allows Bullet to apply enough force on the child to move the whole linkset.
+                // (Also do the mass stuff before recomputing the constraint so mass is not zero.)
+                li.member.UpdatePhysicalMassProperties(linksetMass, true);
+
+                BSConstraint constrain;
+                if (!m_physicsScene.Constraints.TryGetConstraint(LinksetRoot.PhysBody, li.member.PhysBody, out constrain))
+                {
+                    // If constraint doesn't exist yet, create it.
+                    constrain = BuildConstraint(LinksetRoot, li);
+                }
+                li.SetLinkParameters(constrain);
+                constrain.RecomputeConstraintVariables(linksetMass);
+
+                // PhysicsScene.PE.DumpConstraint(PhysicsScene.World, constrain.Constraint);    // DEBUG DEBUG
+                return false;   // 'false' says to keep processing other members
+            });
+        }
+        finally
+        {
+            Rebuilding = false;
+        }
+    }
+
+    #region Extension
+    public override object Extension(string pFunct, params object[] pParams)
+    {
+        object ret = null;
+        switch (pFunct)
+        {
+            // pParams = [ BSPhysObject root, BSPhysObject child, integer linkType ]
+            case ExtendedPhysics.PhysFunctChangeLinkType:
+                if (pParams.Length > 2)
+                {
+                    int requestedType = (int)pParams[2];
+                    DetailLog("{0},BSLinksetConstraint.ChangeLinkType,requestedType={1}", LinksetRoot.LocalID, requestedType);
+                    if (requestedType == (int)ConstraintType.BS_FIXED_CONSTRAINT_TYPE
+                        || requestedType == (int)ConstraintType.D6_CONSTRAINT_TYPE
+                        || requestedType == (int)ConstraintType.D6_SPRING_CONSTRAINT_TYPE
+                        || requestedType == (int)ConstraintType.HINGE_CONSTRAINT_TYPE
+                        || requestedType == (int)ConstraintType.CONETWIST_CONSTRAINT_TYPE
+                        || requestedType == (int)ConstraintType.SLIDER_CONSTRAINT_TYPE)
+                    {
+                        BSPrimLinkable child = pParams[1] as BSPrimLinkable;
+                        if (child != null)
+                        {
+                            DetailLog("{0},BSLinksetConstraint.ChangeLinkType,rootID={1},childID={2},type={3}",
+                                                    LinksetRoot.LocalID, LinksetRoot.LocalID, child.LocalID, requestedType);
+                            m_physicsScene.TaintedObject(child.LocalID, "BSLinksetConstraint.PhysFunctChangeLinkType", delegate()
+                            {
+                                // Pick up all the constraints currently created.
+                                RemoveDependencies(child);
+
+                                BSLinkInfo linkInfo = null;
+                                if (TryGetLinkInfo(child, out linkInfo))
+                                {
+                                    BSLinkInfoConstraint linkInfoC = linkInfo as BSLinkInfoConstraint;
+                                    if (linkInfoC != null)
+                                    {
+                                        linkInfoC.constraintType = (ConstraintType)requestedType;
+                                        ret = (object)true;
+                                        DetailLog("{0},BSLinksetConstraint.ChangeLinkType,link={1},type={2}",
+                                                    linkInfo.member.LocalID, linkInfo.member.LocalID, linkInfoC.constraintType);
+                                    }
+                                    else
+                                    {
+                                        DetailLog("{0},BSLinksetConstraint.ChangeLinkType,linkInfoNotConstraint,childID={1}", LinksetRoot.LocalID, child.LocalID);
+                                    }
+                                }
+                                else
+                                {
+                                    DetailLog("{0},BSLinksetConstraint.ChangeLinkType,noLinkInfoForChild,childID={1}", LinksetRoot.LocalID, child.LocalID);
+                                }
+                                // Cause the whole linkset to be rebuilt in post-taint time.
+                                Refresh(child);
+                            });
+                        }
+                        else
+                        {
+                            DetailLog("{0},BSLinksetConstraint.SetLinkType,childNotBSPrimLinkable", LinksetRoot.LocalID);
+                        }
+                    }
+                    else
+                    {
+                        DetailLog("{0},BSLinksetConstraint.SetLinkType,illegalRequestedType,reqested={1},spring={2}",
+                                        LinksetRoot.LocalID, requestedType, ((int)ConstraintType.D6_SPRING_CONSTRAINT_TYPE));
+                    }
+                }
+                break;
+            // pParams = [ BSPhysObject root, BSPhysObject child ]
+            case ExtendedPhysics.PhysFunctGetLinkType:
+                if (pParams.Length > 0)
+                {
+                    BSPrimLinkable child = pParams[1] as BSPrimLinkable;
+                    if (child != null)
+                    {
+                        BSLinkInfo linkInfo = null;
+                        if (TryGetLinkInfo(child, out linkInfo))
+                        {
+                            BSLinkInfoConstraint linkInfoC = linkInfo as BSLinkInfoConstraint;
+                            if (linkInfoC != null)
+                            {
+                                ret = (object)(int)linkInfoC.constraintType;
+                                DetailLog("{0},BSLinksetConstraint.GetLinkType,link={1},type={2}",
+                                            linkInfo.member.LocalID, linkInfo.member.LocalID, linkInfoC.constraintType);
+
+                            }
+                        }
+                    }
+                }
+                break;
+            // pParams = [ BSPhysObject root, BSPhysObject child, int op, object opParams, int op, object opParams, ... ]
+            case ExtendedPhysics.PhysFunctChangeLinkParams:
+                // There should be two parameters: the childActor and a list of parameters to set
+                if (pParams.Length > 2)
+                {
+                    BSPrimLinkable child = pParams[1] as BSPrimLinkable;
+                    BSLinkInfo baseLinkInfo = null;
+                    if (TryGetLinkInfo(child, out baseLinkInfo))
+                    {
+                        BSLinkInfoConstraint linkInfo = baseLinkInfo as BSLinkInfoConstraint;
+                        if (linkInfo != null)
+                        {
+                            int valueInt;
+                            float valueFloat;
+                            bool valueBool;
+                            OMV.Vector3 valueVector;
+                            OMV.Vector3 valueVector2;
+                            OMV.Quaternion valueQuaternion;
+                            int axisLow, axisHigh;
+
+                            int opIndex = 2;
+                            while (opIndex < pParams.Length)
+                            {
+                                int thisOp = 0;
+                                string errMsg = "";
+                                try
+                                {
+                                    thisOp = (int)pParams[opIndex];
+                                    DetailLog("{0},BSLinksetConstraint.ChangeLinkParams2,op={1},val={2}",
+                                                        linkInfo.member.LocalID, thisOp, pParams[opIndex + 1]);
+                                    switch (thisOp)
+                                    {
+                                        case ExtendedPhysics.PHYS_PARAM_LINK_TYPE:
+                                            valueInt = (int)pParams[opIndex + 1];
+                                            ConstraintType valueType = (ConstraintType)valueInt;
+                                            if (valueType == ConstraintType.BS_FIXED_CONSTRAINT_TYPE
+                                                || valueType == ConstraintType.D6_CONSTRAINT_TYPE
+                                                || valueType == ConstraintType.D6_SPRING_CONSTRAINT_TYPE
+                                                || valueType == ConstraintType.HINGE_CONSTRAINT_TYPE
+                                                || valueType == ConstraintType.CONETWIST_CONSTRAINT_TYPE
+                                                || valueType == ConstraintType.SLIDER_CONSTRAINT_TYPE)
+                                            {
+                                                linkInfo.constraintType = valueType;
+                                            }
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_FRAMEINA_LOC:
+                                            errMsg = "PHYS_PARAM_FRAMEINA_LOC takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.frameInAloc = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_FRAMEINA_ROT:
+                                            errMsg = "PHYS_PARAM_FRAMEINA_ROT takes one parameter of type rotation";
+                                            valueQuaternion = (OMV.Quaternion)pParams[opIndex + 1];
+                                            linkInfo.frameInArot = valueQuaternion;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_FRAMEINB_LOC:
+                                            errMsg = "PHYS_PARAM_FRAMEINB_LOC takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.frameInBloc = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_FRAMEINB_ROT:
+                                            errMsg = "PHYS_PARAM_FRAMEINB_ROT takes one parameter of type rotation";
+                                            valueQuaternion = (OMV.Quaternion)pParams[opIndex + 1];
+                                            linkInfo.frameInBrot = valueQuaternion;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_LINEAR_LIMIT_LOW:
+                                            errMsg = "PHYS_PARAM_LINEAR_LIMIT_LOW takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.linearLimitLow = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_LINEAR_LIMIT_HIGH:
+                                            errMsg = "PHYS_PARAM_LINEAR_LIMIT_HIGH takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.linearLimitHigh = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_ANGULAR_LIMIT_LOW:
+                                            errMsg = "PHYS_PARAM_ANGULAR_LIMIT_LOW takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.angularLimitLow = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_ANGULAR_LIMIT_HIGH:
+                                            errMsg = "PHYS_PARAM_ANGULAR_LIMIT_HIGH takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.angularLimitHigh = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_USE_FRAME_OFFSET:
+                                            errMsg = "PHYS_PARAM_USE_FRAME_OFFSET takes one parameter of type integer (bool)";
+                                            valueBool = ((int)pParams[opIndex + 1]) != 0;
+                                            linkInfo.useFrameOffset = valueBool;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_ENABLE_TRANSMOTOR:
+                                            errMsg = "PHYS_PARAM_ENABLE_TRANSMOTOR takes one parameter of type integer (bool)";
+                                            valueBool = ((int)pParams[opIndex + 1]) != 0;
+                                            linkInfo.enableTransMotor = valueBool;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_TRANSMOTOR_MAXVEL:
+                                            errMsg = "PHYS_PARAM_TRANSMOTOR_MAXVEL takes one parameter of type float";
+                                            valueFloat = (float)pParams[opIndex + 1];
+                                            linkInfo.transMotorMaxVel = valueFloat;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_TRANSMOTOR_MAXFORCE:
+                                            errMsg = "PHYS_PARAM_TRANSMOTOR_MAXFORCE takes one parameter of type float";
+                                            valueFloat = (float)pParams[opIndex + 1];
+                                            linkInfo.transMotorMaxForce = valueFloat;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_CFM:
+                                            errMsg = "PHYS_PARAM_CFM takes one parameter of type float";
+                                            valueFloat = (float)pParams[opIndex + 1];
+                                            linkInfo.cfm = valueFloat;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_ERP:
+                                            errMsg = "PHYS_PARAM_ERP takes one parameter of type float";
+                                            valueFloat = (float)pParams[opIndex + 1];
+                                            linkInfo.erp = valueFloat;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_SOLVER_ITERATIONS:
+                                            errMsg = "PHYS_PARAM_SOLVER_ITERATIONS takes one parameter of type float";
+                                            valueFloat = (float)pParams[opIndex + 1];
+                                            linkInfo.solverIterations = valueFloat;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_SPRING_AXIS_ENABLE:
+                                            errMsg = "PHYS_PARAM_SPRING_AXIS_ENABLE takes two parameters of types integer and integer (bool)";
+                                            valueInt = (int)pParams[opIndex + 1];
+                                            valueBool = ((int)pParams[opIndex + 2]) != 0;
+                                            GetAxisRange(valueInt, out axisLow, out axisHigh);
+                                            for (int ii = axisLow; ii <= axisHigh; ii++)
+                                                linkInfo.springAxisEnable[ii] = valueBool;
+                                            opIndex += 3;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_SPRING_DAMPING:
+                                            errMsg = "PHYS_PARAM_SPRING_DAMPING takes two parameters of types integer and float";
+                                            valueInt = (int)pParams[opIndex + 1];
+                                            valueFloat = (float)pParams[opIndex + 2];
+                                            GetAxisRange(valueInt, out axisLow, out axisHigh);
+                                            for (int ii = axisLow; ii <= axisHigh; ii++)
+                                                linkInfo.springDamping[ii] = valueFloat;
+                                            opIndex += 3;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_SPRING_STIFFNESS:
+                                            errMsg = "PHYS_PARAM_SPRING_STIFFNESS takes two parameters of types integer and float";
+                                            valueInt = (int)pParams[opIndex + 1];
+                                            valueFloat = (float)pParams[opIndex + 2];
+                                            GetAxisRange(valueInt, out axisLow, out axisHigh);
+                                            for (int ii = axisLow; ii <= axisHigh; ii++)
+                                                linkInfo.springStiffness[ii] = valueFloat;
+                                            opIndex += 3;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_SPRING_EQUILIBRIUM_POINT:
+                                            errMsg = "PHYS_PARAM_SPRING_EQUILIBRIUM_POINT takes two parameters of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            valueVector2 = (OMV.Vector3)pParams[opIndex + 2];
+                                            linkInfo.springLinearEquilibriumPoint = valueVector;
+                                            linkInfo.springAngularEquilibriumPoint = valueVector2;
+                                            opIndex += 3;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_USE_LINEAR_FRAMEA:
+                                            errMsg = "PHYS_PARAM_USE_LINEAR_FRAMEA takes one parameter of type integer (bool)";
+                                            valueBool = ((int)pParams[opIndex + 1]) != 0;
+                                            linkInfo.useLinearReferenceFrameA = valueBool;
+                                            opIndex += 2;
+                                            break;
+                                        default:
+                                            break;
+                                    }
+                                }
+                                catch (InvalidCastException e)
+                                {
+                                    m_physicsScene.Logger.WarnFormat("{0} value of wrong type in physSetLinksetParams: {1}, err={2}",
+                                                        LogHeader, errMsg, e);
+                                }
+                                catch (Exception e)
+                                {
+                                    m_physicsScene.Logger.WarnFormat("{0} bad parameters in physSetLinksetParams: {1}", LogHeader, e);
+                                }
+                            }
+                        }
+                        // Something changed so a rebuild is in order
+                        Refresh(child);
+                    }
+                }
+            break;
+            default:
+                ret = base.Extension(pFunct, pParams);
+                break;
+        }
+        return ret;
+    }
+
+    // Bullet constraints keep some limit parameters for each linear and angular axis.
+    // Setting same is easier if there is an easy way to see all or types.
+    // This routine returns the array limits for the set of axis.
+    private void GetAxisRange(int rangeSpec, out int low, out int high)
+    {
+        switch (rangeSpec)
+        {
+            case ExtendedPhysics.PHYS_AXIS_LINEAR_ALL:
+                low = 0;
+                high = 2;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_ANGULAR_ALL:
+                low = 3;
+                high = 5;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_ALL:
+                low = 0;
+                high = 5;
+                break;
+            default:
+                low = high = rangeSpec;
+                break;
+        }
+        return;
+    }
+    #endregion // Extension
+
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSMaterials.cs b/OpenSim/Region/PhysicsModules/BulletS/BSMaterials.cs
new file mode 100755
index 0000000..0e44d03
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSMaterials.cs
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Reflection;
+using Nini.Config;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+public struct MaterialAttributes
+{
+    // Material type values that correspond with definitions for LSL
+    public enum Material : int
+    {
+        Stone = 0,
+        Metal,
+        Glass,
+        Wood,
+        Flesh,
+        Plastic,
+        Rubber,
+        Light,
+        // Hereafter are BulletSim additions
+        Avatar,
+        NumberOfTypes   // the count of types in the enum.
+    }
+
+    // Names must be in the order of the above enum.
+    // These names must coorespond to the lower case field names in the MaterialAttributes
+    //     structure as reflection is used to select the field to put the value in.
+    public static readonly string[] MaterialAttribs = { "Density", "Friction", "Restitution"};
+
+    public MaterialAttributes(string t, float d, float f, float r)
+    {
+        type = t;
+        density = d;
+        friction = f;
+        restitution = r;
+    }
+    public string type;
+    public float density;
+    public float friction;
+    public float restitution;
+}
+
+public static class BSMaterials
+{
+    // Attributes for each material type
+    private static readonly MaterialAttributes[] Attributes;
+
+    // Map of material name to material type code
+    public static readonly Dictionary<string, MaterialAttributes.Material> MaterialMap;
+
+    static BSMaterials()
+    {
+        // Attribute sets for both the non-physical and physical instances of materials.
+        Attributes = new MaterialAttributes[(int)MaterialAttributes.Material.NumberOfTypes * 2];
+
+        // Map of name to type code.
+        MaterialMap = new Dictionary<string, MaterialAttributes.Material>();
+        MaterialMap.Add("Stone", MaterialAttributes.Material.Stone);
+        MaterialMap.Add("Metal", MaterialAttributes.Material.Metal);
+        MaterialMap.Add("Glass", MaterialAttributes.Material.Glass);
+        MaterialMap.Add("Wood", MaterialAttributes.Material.Wood);
+        MaterialMap.Add("Flesh", MaterialAttributes.Material.Flesh);
+        MaterialMap.Add("Plastic", MaterialAttributes.Material.Plastic);
+        MaterialMap.Add("Rubber", MaterialAttributes.Material.Rubber);
+        MaterialMap.Add("Light", MaterialAttributes.Material.Light);
+        MaterialMap.Add("Avatar", MaterialAttributes.Material.Avatar);
+    }
+
+    // This is where all the default material attributes are defined.
+    public static void InitializeFromDefaults(ConfigurationParameters parms)
+    {
+        // Values from http://wiki.secondlife.com/wiki/PRIM_MATERIAL
+        float dDensity = parms.defaultDensity;
+        float dFriction = parms.defaultFriction;
+        float dRestitution = parms.defaultRestitution;
+        Attributes[(int)MaterialAttributes.Material.Stone] =
+                    new MaterialAttributes("stone",dDensity, 0.8f, 0.4f);
+        Attributes[(int)MaterialAttributes.Material.Metal] =
+                    new MaterialAttributes("metal",dDensity, 0.3f, 0.4f);
+        Attributes[(int)MaterialAttributes.Material.Glass] =
+                    new MaterialAttributes("glass",dDensity, 0.2f, 0.7f);
+        Attributes[(int)MaterialAttributes.Material.Wood] =
+                    new MaterialAttributes("wood",dDensity, 0.6f, 0.5f);
+        Attributes[(int)MaterialAttributes.Material.Flesh] =
+                    new MaterialAttributes("flesh",dDensity, 0.9f, 0.3f);
+        Attributes[(int)MaterialAttributes.Material.Plastic] =
+                    new MaterialAttributes("plastic",dDensity, 0.4f, 0.7f);
+        Attributes[(int)MaterialAttributes.Material.Rubber] =
+                    new MaterialAttributes("rubber",dDensity, 0.9f, 0.9f);
+        Attributes[(int)MaterialAttributes.Material.Light] =
+                    new MaterialAttributes("light",dDensity, dFriction, dRestitution);
+        Attributes[(int)MaterialAttributes.Material.Avatar] =
+                    new MaterialAttributes("avatar",3.5f, 0.2f, 0f);
+
+        Attributes[(int)MaterialAttributes.Material.Stone + (int)MaterialAttributes.Material.NumberOfTypes] =
+                    new MaterialAttributes("stonePhysical",dDensity, 0.8f, 0.4f);
+        Attributes[(int)MaterialAttributes.Material.Metal + (int)MaterialAttributes.Material.NumberOfTypes] =
+                    new MaterialAttributes("metalPhysical",dDensity, 0.3f, 0.4f);
+        Attributes[(int)MaterialAttributes.Material.Glass + (int)MaterialAttributes.Material.NumberOfTypes] =
+                    new MaterialAttributes("glassPhysical",dDensity, 0.2f, 0.7f);
+        Attributes[(int)MaterialAttributes.Material.Wood + (int)MaterialAttributes.Material.NumberOfTypes] =
+                    new MaterialAttributes("woodPhysical",dDensity, 0.6f, 0.5f);
+        Attributes[(int)MaterialAttributes.Material.Flesh + (int)MaterialAttributes.Material.NumberOfTypes] =
+                    new MaterialAttributes("fleshPhysical",dDensity, 0.9f, 0.3f);
+        Attributes[(int)MaterialAttributes.Material.Plastic + (int)MaterialAttributes.Material.NumberOfTypes] =
+                    new MaterialAttributes("plasticPhysical",dDensity, 0.4f, 0.7f);
+        Attributes[(int)MaterialAttributes.Material.Rubber + (int)MaterialAttributes.Material.NumberOfTypes] =
+                    new MaterialAttributes("rubberPhysical",dDensity, 0.9f, 0.9f);
+        Attributes[(int)MaterialAttributes.Material.Light + (int)MaterialAttributes.Material.NumberOfTypes] =
+                    new MaterialAttributes("lightPhysical",dDensity, dFriction, dRestitution);
+        Attributes[(int)MaterialAttributes.Material.Avatar + (int)MaterialAttributes.Material.NumberOfTypes] =
+                    new MaterialAttributes("avatarPhysical",3.5f, 0.2f, 0f);
+    }
+
+    // Under the [BulletSim] section, one can change the individual material
+    //    attribute values. The format of the configuration parameter is:
+    //        <materialName><Attribute>["Physical"] = floatValue
+    //    For instance:
+    //        [BulletSim]
+    //             StoneFriction = 0.2
+    //             FleshRestitutionPhysical = 0.8
+    // Materials can have different parameters for their static and
+    //    physical instantiations. When setting the non-physical value,
+    //    both values are changed. Setting the physical value only changes
+    //    the physical value.
+    public static void InitializefromParameters(IConfig pConfig)
+    {
+        foreach (KeyValuePair<string, MaterialAttributes.Material> kvp in MaterialMap)
+        {
+            string matName = kvp.Key;
+            foreach (string attribName in MaterialAttributes.MaterialAttribs)
+            {
+                string paramName = matName + attribName;
+                if (pConfig.Contains(paramName))
+                {
+                    float paramValue = pConfig.GetFloat(paramName);
+                    SetAttributeValue((int)kvp.Value, attribName, paramValue);
+                    // set the physical value also
+                    SetAttributeValue((int)kvp.Value + (int)MaterialAttributes.Material.NumberOfTypes, attribName, paramValue);
+                }
+                paramName += "Physical";
+                if (pConfig.Contains(paramName))
+                {
+                    float paramValue = pConfig.GetFloat(paramName);
+                    SetAttributeValue((int)kvp.Value + (int)MaterialAttributes.Material.NumberOfTypes, attribName, paramValue);
+                }
+            }
+        }
+    }
+
+    // Use reflection to set the value in the attribute structure.
+    private static void SetAttributeValue(int matType, string attribName, float val)
+    {
+        // Get the current attribute values for this material
+        MaterialAttributes thisAttrib = Attributes[matType];
+        // Find the field for the passed attribute name (eg, find field named 'friction')
+        FieldInfo fieldInfo = thisAttrib.GetType().GetField(attribName.ToLower());
+        if (fieldInfo != null)
+        {
+            fieldInfo.SetValue(thisAttrib, val);
+            // Copy new attributes back to array -- since MaterialAttributes is 'struct', passed by value, not reference.
+            Attributes[matType] = thisAttrib;
+        }
+    }
+
+    // Given a material type, return a structure of attributes.
+    public static MaterialAttributes GetAttributes(MaterialAttributes.Material type, bool isPhysical)
+    {
+        int ind = (int)type;
+        if (isPhysical) ind += (int)MaterialAttributes.Material.NumberOfTypes;
+        return Attributes[ind];
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSMotors.cs b/OpenSim/Region/PhysicsModules/BulletS/BSMotors.cs
new file mode 100755
index 0000000..2faf2d4
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSMotors.cs
@@ -0,0 +1,451 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+using OpenSim.Framework;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public abstract class BSMotor
+{
+    // Timescales and other things can be turned off by setting them to 'infinite'.
+    public const float Infinite = 12345.6f;
+    public readonly static Vector3 InfiniteVector = new Vector3(BSMotor.Infinite, BSMotor.Infinite, BSMotor.Infinite);
+
+    public BSMotor(string useName)
+    {
+        UseName = useName;
+        PhysicsScene = null;
+        Enabled = true;
+    }
+    public virtual bool Enabled { get; set; }
+    public virtual void Reset() { }
+    public virtual void Zero() { }
+    public virtual void GenerateTestOutput(float timeStep) { }
+
+    // A name passed at motor creation for easily identifyable debugging messages.
+    public string UseName { get; private set; }
+
+    // Used only for outputting debug information. Might not be set so check for null.
+    public BSScene PhysicsScene { get; set; }
+    protected void MDetailLog(string msg, params Object[] parms)
+    {
+        if (PhysicsScene != null)
+        {
+            PhysicsScene.DetailLog(msg, parms);
+        }
+    }
+}
+
+// Motor which moves CurrentValue to TargetValue over TimeScale seconds.
+// The TargetValue decays in TargetValueDecayTimeScale.
+// This motor will "zero itself" over time in that the targetValue will
+//    decay to zero and the currentValue will follow it to that zero.
+//    The overall effect is for the returned correction value to go from large
+//    values to small and eventually zero values.
+// TimeScale and TargetDelayTimeScale may be 'infinite' which means no decay.
+
+// For instance, if something is moving at speed X and the desired speed is Y,
+//    CurrentValue is X and TargetValue is Y. As the motor is stepped, new
+//    values of CurrentValue are returned that approach the TargetValue.
+// The feature of decaying TargetValue is so vehicles will eventually
+//    come to a stop rather than run forever. This can be disabled by
+//    setting TargetValueDecayTimescale to 'infinite'.
+// The change from CurrentValue to TargetValue is linear over TimeScale seconds.
+public class BSVMotor : BSMotor
+{
+    // public Vector3 FrameOfReference { get; set; }
+    // public Vector3 Offset { get; set; }
+
+    public virtual float TimeScale { get; set; }
+    public virtual float TargetValueDecayTimeScale { get; set; }
+    public virtual float Efficiency { get; set; }
+
+    public virtual float ErrorZeroThreshold { get; set; }
+
+    public virtual Vector3 TargetValue { get; protected set; }
+    public virtual Vector3 CurrentValue { get; protected set; }
+    public virtual Vector3 LastError { get; protected set; }
+
+    public virtual bool ErrorIsZero()
+    {
+        return ErrorIsZero(LastError);
+    }
+    public virtual bool ErrorIsZero(Vector3 err)
+    {
+        return (err == Vector3.Zero || err.ApproxEquals(Vector3.Zero, ErrorZeroThreshold));
+    }
+
+    public BSVMotor(string useName)
+        : base(useName)
+    {
+        TimeScale = TargetValueDecayTimeScale = BSMotor.Infinite;
+        Efficiency = 1f;
+        CurrentValue = TargetValue = Vector3.Zero;
+        ErrorZeroThreshold = 0.001f;
+    }
+    public BSVMotor(string useName, float timeScale, float decayTimeScale, float efficiency)
+        : this(useName)
+    {
+        TimeScale = timeScale;
+        TargetValueDecayTimeScale = decayTimeScale;
+        Efficiency = efficiency;
+        CurrentValue = TargetValue = Vector3.Zero;
+    }
+    public void SetCurrent(Vector3 current)
+    {
+        CurrentValue = current;
+    }
+    public void SetTarget(Vector3 target)
+    {
+        TargetValue = target;
+    }
+    public override void Zero()
+    {
+        base.Zero();
+        CurrentValue = TargetValue = Vector3.Zero;
+    }
+
+    // Compute the next step and return the new current value.
+    // Returns the correction needed to move 'current' to 'target'.
+    public virtual Vector3 Step(float timeStep)
+    {
+        if (!Enabled) return TargetValue;
+
+        Vector3 origTarget = TargetValue;       // DEBUG
+        Vector3 origCurrVal = CurrentValue;     // DEBUG
+
+        Vector3 correction = Vector3.Zero;
+        Vector3 error = TargetValue - CurrentValue;
+        if (!ErrorIsZero(error))
+        {
+            correction = StepError(timeStep, error);
+
+            CurrentValue += correction;
+
+            // The desired value reduces to zero which also reduces the difference with current.
+            // If the decay time is infinite, don't decay at all.
+            float decayFactor = 0f;
+            if (TargetValueDecayTimeScale != BSMotor.Infinite)
+            {
+                decayFactor = (1.0f / TargetValueDecayTimeScale) * timeStep;
+                TargetValue *= (1f - decayFactor);
+            }
+
+            MDetailLog("{0},  BSVMotor.Step,nonZero,{1},origCurr={2},origTarget={3},timeStep={4},err={5},corr={6}",
+                                BSScene.DetailLogZero, UseName, origCurrVal, origTarget,
+                                timeStep, error, correction);
+            MDetailLog("{0},  BSVMotor.Step,nonZero,{1},tgtDecayTS={2},decayFact={3},tgt={4},curr={5}",
+                                BSScene.DetailLogZero, UseName, TargetValueDecayTimeScale, decayFactor, TargetValue, CurrentValue);
+        }
+        else
+        {
+            // Difference between what we have and target is small. Motor is done.
+            if (TargetValue.ApproxEquals(Vector3.Zero, ErrorZeroThreshold))
+            {
+                // The target can step down to nearly zero but not get there.  If close to zero
+                //     it is really zero.
+                TargetValue = Vector3.Zero;
+            }
+            CurrentValue = TargetValue;
+            MDetailLog("{0},  BSVMotor.Step,zero,{1},origTgt={2},origCurr={3},currTgt={4},currCurr={5}",
+                        BSScene.DetailLogZero, UseName, origCurrVal, origTarget, TargetValue, CurrentValue);
+        }
+        LastError = error;
+
+        return correction;
+    }
+    // version of step that sets the current value before doing the step
+    public virtual Vector3 Step(float timeStep, Vector3 current)
+    {
+        CurrentValue = current;
+        return Step(timeStep);
+    }
+    // Given and error, computer a correction for this step.
+    // Simple scaling of the error by the timestep.
+    public virtual Vector3 StepError(float timeStep, Vector3 error)
+    {
+        if (!Enabled) return Vector3.Zero;
+
+        Vector3 returnCorrection = Vector3.Zero;
+        if (!ErrorIsZero(error))
+        {
+            // correction =  error / secondsItShouldTakeToCorrect
+            Vector3 correctionAmount;
+            if (TimeScale == 0f || TimeScale == BSMotor.Infinite)
+                correctionAmount = error * timeStep;
+            else
+                correctionAmount = error / TimeScale * timeStep;
+
+            returnCorrection = correctionAmount;
+            MDetailLog("{0},  BSVMotor.Step,nonZero,{1},timeStep={2},timeScale={3},err={4},corr={5}",
+                                    BSScene.DetailLogZero, UseName, timeStep, TimeScale, error, correctionAmount);
+        }
+        return returnCorrection;
+    }
+
+    // The user sets all the parameters and calls this which outputs values until error is zero.
+    public override void GenerateTestOutput(float timeStep)
+    {
+        // maximum number of outputs to generate.
+        int maxOutput = 50;
+        MDetailLog("{0},BSVMotor.Test,{1},===================================== BEGIN Test Output", BSScene.DetailLogZero, UseName);
+        MDetailLog("{0},BSVMotor.Test,{1},timeScale={2},targDlyTS={3},eff={4},curr={5},tgt={6}",
+                                BSScene.DetailLogZero, UseName,
+                                TimeScale, TargetValueDecayTimeScale, Efficiency,
+                                CurrentValue, TargetValue);
+
+        LastError = BSMotor.InfiniteVector;
+        while (maxOutput-- > 0 && !ErrorIsZero())
+        {
+            Vector3 lastStep = Step(timeStep);
+            MDetailLog("{0},BSVMotor.Test,{1},cur={2},tgt={3},lastError={4},lastStep={5}",
+                            BSScene.DetailLogZero, UseName, CurrentValue, TargetValue, LastError, lastStep);
+        }
+        MDetailLog("{0},BSVMotor.Test,{1},===================================== END Test Output", BSScene.DetailLogZero, UseName);
+
+
+    }
+
+    public override string ToString()
+    {
+        return String.Format("<{0},curr={1},targ={2},lastErr={3},decayTS={4}>",
+            UseName, CurrentValue, TargetValue, LastError, TargetValueDecayTimeScale);
+    }
+}
+
+// ============================================================================
+// ============================================================================
+public class BSFMotor : BSMotor
+{
+    public virtual float TimeScale { get; set; }
+    public virtual float TargetValueDecayTimeScale { get; set; }
+    public virtual float Efficiency { get; set; }
+
+    public virtual float ErrorZeroThreshold { get; set; }
+
+    public virtual float TargetValue { get; protected set; }
+    public virtual float CurrentValue { get; protected set; }
+    public virtual float LastError { get; protected set; }
+
+    public virtual bool ErrorIsZero()
+    {
+        return ErrorIsZero(LastError);
+    }
+    public virtual bool ErrorIsZero(float err)
+    {
+        return (err >= -ErrorZeroThreshold && err <= ErrorZeroThreshold);
+    }
+
+    public BSFMotor(string useName, float timeScale, float decayTimescale, float efficiency)
+        : base(useName)
+    {
+        TimeScale = TargetValueDecayTimeScale = BSMotor.Infinite;
+        Efficiency = 1f;
+        CurrentValue = TargetValue = 0f;
+        ErrorZeroThreshold = 0.01f;
+    }
+    public void SetCurrent(float current)
+    {
+        CurrentValue = current;
+    }
+    public void SetTarget(float target)
+    {
+        TargetValue = target;
+    }
+    public override void Zero()
+    {
+        base.Zero();
+        CurrentValue = TargetValue = 0f;
+    }
+
+    public virtual float Step(float timeStep)
+    {
+        if (!Enabled) return TargetValue;
+
+        float origTarget = TargetValue;       // DEBUG
+        float origCurrVal = CurrentValue;     // DEBUG
+
+        float correction = 0f;
+        float error = TargetValue - CurrentValue;
+        if (!ErrorIsZero(error))
+        {
+            correction = StepError(timeStep, error);
+
+            CurrentValue += correction;
+
+            // The desired value reduces to zero which also reduces the difference with current.
+            // If the decay time is infinite, don't decay at all.
+            float decayFactor = 0f;
+            if (TargetValueDecayTimeScale != BSMotor.Infinite)
+            {
+                decayFactor = (1.0f / TargetValueDecayTimeScale) * timeStep;
+                TargetValue *= (1f - decayFactor);
+            }
+
+            MDetailLog("{0},  BSFMotor.Step,nonZero,{1},origCurr={2},origTarget={3},timeStep={4},err={5},corr={6}",
+                                BSScene.DetailLogZero, UseName, origCurrVal, origTarget,
+                                timeStep, error, correction);
+            MDetailLog("{0},  BSFMotor.Step,nonZero,{1},tgtDecayTS={2},decayFact={3},tgt={4},curr={5}",
+                                BSScene.DetailLogZero, UseName, TargetValueDecayTimeScale, decayFactor, TargetValue, CurrentValue);
+        }
+        else
+        {
+            // Difference between what we have and target is small. Motor is done.
+            if (Util.InRange<float>(TargetValue, -ErrorZeroThreshold, ErrorZeroThreshold))
+            {
+                // The target can step down to nearly zero but not get there.  If close to zero
+                //     it is really zero.
+                TargetValue = 0f;
+            }
+            CurrentValue = TargetValue;
+            MDetailLog("{0},  BSFMotor.Step,zero,{1},origTgt={2},origCurr={3},ret={4}",
+                        BSScene.DetailLogZero, UseName, origCurrVal, origTarget, CurrentValue);
+        }
+        LastError = error;
+
+        return CurrentValue;
+    }
+
+    public virtual float StepError(float timeStep, float error)
+    {
+        if (!Enabled) return 0f;
+
+        float returnCorrection = 0f;
+        if (!ErrorIsZero(error))
+        {
+            // correction =  error / secondsItShouldTakeToCorrect
+            float correctionAmount;
+            if (TimeScale == 0f || TimeScale == BSMotor.Infinite)
+                correctionAmount = error * timeStep;
+            else
+                correctionAmount = error / TimeScale * timeStep;
+
+            returnCorrection = correctionAmount;
+            MDetailLog("{0},  BSFMotor.Step,nonZero,{1},timeStep={2},timeScale={3},err={4},corr={5}",
+                                    BSScene.DetailLogZero, UseName, timeStep, TimeScale, error, correctionAmount);
+        }
+        return returnCorrection;
+    }
+
+    public override string ToString()
+    {
+        return String.Format("<{0},curr={1},targ={2},lastErr={3},decayTS={4}>",
+            UseName, CurrentValue, TargetValue, LastError, TargetValueDecayTimeScale);
+    }
+
+}
+
+// ============================================================================
+// ============================================================================
+// Proportional, Integral, Derivitive ("PID") Motor
+// Good description at http://www.answers.com/topic/pid-controller . Includes processes for choosing p, i and d factors.
+public class BSPIDVMotor : BSVMotor
+{
+    // Larger makes more overshoot, smaller means converge quicker. Range of 0.1 to 10.
+    public Vector3 proportionFactor { get; set; }
+    public Vector3 integralFactor { get; set; }
+    public Vector3 derivFactor { get; set; }
+
+    // The factors are vectors for the three dimensions. This is the proportional of each
+    //    that is applied. This could be multiplied through the actual factors but it
+    //    is sometimes easier to manipulate the factors and their mix separately.
+    public Vector3 FactorMix;
+
+    // Arbritrary factor range.
+    // EfficiencyHigh means move quickly to the correct number. EfficiencyLow means might over correct.
+    public float EfficiencyHigh = 0.4f;
+    public float EfficiencyLow = 4.0f;
+
+    // Running integration of the error
+    Vector3 RunningIntegration { get; set; }
+
+    public BSPIDVMotor(string useName)
+        : base(useName)
+    {
+        proportionFactor = new Vector3(1.00f, 1.00f, 1.00f);
+        integralFactor = new Vector3(1.00f, 1.00f, 1.00f);
+        derivFactor = new Vector3(1.00f, 1.00f, 1.00f);
+        FactorMix = new Vector3(0.5f, 0.25f, 0.25f);
+        RunningIntegration = Vector3.Zero;
+        LastError = Vector3.Zero;
+    }
+
+    public override void Zero()
+    {
+        base.Zero();
+    }
+
+    public override float Efficiency
+    {
+        get { return base.Efficiency; }
+        set
+        {
+            base.Efficiency = Util.Clamp(value, 0f, 1f);
+
+            // Compute factors based on efficiency.
+            // If efficiency is high (1f), use a factor value that moves the error value to zero with little overshoot.
+            // If efficiency is low (0f), use a factor value that overcorrects.
+            // TODO: might want to vary contribution of different factor depending on efficiency.
+            // float factor = ((1f - this.Efficiency) * EfficiencyHigh + EfficiencyLow) / 3f;
+            float factor = (1f - this.Efficiency) * EfficiencyHigh + EfficiencyLow;
+
+            proportionFactor = new Vector3(factor, factor, factor);
+            integralFactor = new Vector3(factor, factor, factor);
+            derivFactor = new Vector3(factor, factor, factor);
+
+            MDetailLog("{0},  BSPIDVMotor.setEfficiency,eff={1},factor={2}", BSScene.DetailLogZero, Efficiency, factor);
+        }
+    }
+
+    // Advance the PID computation on this error.
+    public override Vector3 StepError(float timeStep, Vector3 error)
+    {
+        if (!Enabled) return Vector3.Zero;
+
+        // Add up the error so we can integrate over the accumulated errors
+        RunningIntegration += error * timeStep;
+
+        // A simple derivitive is the rate of change from the last error.
+        Vector3 derivitive = (error - LastError) * timeStep;
+
+        // Correction = (proportionOfPresentError + accumulationOfPastError + rateOfChangeOfError)
+        Vector3 ret   =   error / TimeScale * timeStep   * proportionFactor * FactorMix.X
+                        + RunningIntegration / TimeScale * integralFactor   * FactorMix.Y
+                        + derivitive / TimeScale         * derivFactor      * FactorMix.Z
+                        ;
+
+        MDetailLog("{0},  BSPIDVMotor.step,ts={1},err={2},lerr={3},runnInt={4},deriv={5},ret={6}",
+                        BSScene.DetailLogZero, timeStep, error, LastError, RunningIntegration, derivitive, ret);
+
+        return ret;
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs
new file mode 100755
index 0000000..c296008
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs
@@ -0,0 +1,927 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using OpenMetaverse;
+using Nini.Config;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public static class BSParam
+{
+    private static string LogHeader = "[BULLETSIM PARAMETERS]";
+
+    // Tuning notes:
+    // From: http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=6575
+    //    Contact points can be added even if the distance is positive. The constraint solver can deal with
+    //    contacts with positive distances as well as negative (penetration). Contact points are discarded
+    //    if the distance exceeds a certain threshold.
+    //    Bullet has a contact processing threshold and a contact breaking threshold.
+    //    If the distance is larger than the contact breaking threshold, it will be removed after one frame.
+    //    If the distance is larger than the contact processing threshold, the constraint solver will ignore it.
+
+    //    This is separate/independent from the collision margin. The collision margin increases the object a bit
+    //    to improve collision detection performance and accuracy.
+    // ===================
+    // From:
+
+    /// <summary>
+    /// Set whether physics is active or not.
+    /// </summary>
+    /// <remarks>
+    /// Can be enabled and disabled to start and stop physics.
+    /// </remarks>
+    public static bool Active { get; private set; }
+
+    public static bool UseSeparatePhysicsThread { get; private set; }
+    public static float PhysicsTimeStep { get; private set; }
+
+    // Level of Detail values kept as float because that's what the Meshmerizer wants
+    public static float MeshLOD { get; private set; }
+    public static float MeshCircularLOD { get; private set; }
+    public static float MeshMegaPrimLOD { get; private set; }
+    public static float MeshMegaPrimThreshold { get; private set; }
+    public static float SculptLOD { get; private set; }
+
+    public static int CrossingFailuresBeforeOutOfBounds { get; private set; }
+    public static float UpdateVelocityChangeThreshold { get; private set; }
+
+    public static float MinimumObjectMass { get; private set; }
+    public static float MaximumObjectMass { get; private set; }
+    public static float MaxLinearVelocity { get; private set; }
+    public static float MaxLinearVelocitySquared { get; private set; }
+    public static float MaxAngularVelocity { get; private set; }
+    public static float MaxAngularVelocitySquared { get; private set; }
+    public static float MaxAddForceMagnitude { get; private set; }
+    public static float MaxAddForceMagnitudeSquared { get; private set; }
+    public static float DensityScaleFactor { get; private set; }
+
+    public static float LinearDamping { get; private set; }
+    public static float AngularDamping { get; private set; }
+    public static float DeactivationTime { get; private set; }
+    public static float LinearSleepingThreshold { get; private set; }
+    public static float AngularSleepingThreshold { get; private set; }
+        public static float CcdMotionThreshold { get; private set; }
+        public static float CcdSweptSphereRadius { get; private set; }
+    public static float ContactProcessingThreshold { get; private set; }
+
+    public static bool ShouldMeshSculptedPrim { get; private set; }   // cause scuplted prims to get meshed
+    public static bool ShouldForceSimplePrimMeshing { get; private set; }   // if a cube or sphere, let Bullet do internal shapes
+    public static bool ShouldUseHullsForPhysicalObjects { get; private set; }   // 'true' if should create hulls for physical objects
+    public static bool ShouldRemoveZeroWidthTriangles { get; private set; }
+    public static bool ShouldUseBulletHACD { get; set; }
+    public static bool ShouldUseSingleConvexHullForPrims { get; set; }
+    public static bool ShouldUseGImpactShapeForPrims { get; set; }
+    public static bool ShouldUseAssetHulls { get; set; }
+
+    public static float TerrainImplementation { get; set; }
+    public static int TerrainMeshMagnification { get; private set; }
+    public static float TerrainGroundPlane { get; private set; }
+    public static float TerrainFriction { get; private set; }
+    public static float TerrainHitFraction { get; private set; }
+    public static float TerrainRestitution { get; private set; }
+    public static float TerrainContactProcessingThreshold { get; private set; }
+    public static float TerrainCollisionMargin { get; private set; }
+
+    public static float DefaultFriction { get; private set; }
+    public static float DefaultDensity { get; private set; }
+    public static float DefaultRestitution { get; private set; }
+    public static float CollisionMargin { get; private set; }
+    public static float Gravity { get; private set; }
+
+    // Physics Engine operation
+        public static float MaxPersistantManifoldPoolSize { get; private set; }
+        public static float MaxCollisionAlgorithmPoolSize { get; private set; }
+        public static bool ShouldDisableContactPoolDynamicAllocation { get; private set; }
+        public static bool ShouldForceUpdateAllAabbs { get; private set; }
+        public static bool ShouldRandomizeSolverOrder { get; private set; }
+        public static bool ShouldSplitSimulationIslands { get; private set; }
+        public static bool ShouldEnableFrictionCaching { get; private set; }
+        public static float NumberOfSolverIterations { get; private set; }
+    public static bool UseSingleSidedMeshes { get; private set; }
+    public static float GlobalContactBreakingThreshold { get; private set; }
+    public static float PhysicsUnmanLoggingFrames { get; private set; }
+
+    // Avatar parameters
+    public static bool AvatarToAvatarCollisionsByDefault { get; private set; }
+    public static float AvatarFriction { get; private set; }
+    public static float AvatarStandingFriction { get; private set; }
+    public static float AvatarAlwaysRunFactor { get; private set; }
+    public static float AvatarDensity { get; private set; }
+    public static float AvatarRestitution { get; private set; }
+    public static int AvatarShape { get; private set; }
+    public static float AvatarCapsuleWidth { get; private set; }
+    public static float AvatarCapsuleDepth { get; private set; }
+    public static float AvatarCapsuleHeight { get; private set; }
+    public static float AvatarHeightLowFudge { get; private set; }
+    public static float AvatarHeightMidFudge { get; private set; }
+    public static float AvatarHeightHighFudge { get; private set; }
+    public static float AvatarFlyingGroundMargin { get; private set; }
+    public static float AvatarFlyingGroundUpForce { get; private set; }
+    public static float AvatarTerminalVelocity { get; private set; }
+        public static float AvatarContactProcessingThreshold { get; private set; }
+    public static float AvatarStopZeroThreshold { get; private set; }
+        public static int AvatarJumpFrames { get; private set; }
+        public static float AvatarBelowGroundUpCorrectionMeters { get; private set; }
+        public static float AvatarStepHeight { get; private set; }
+        public static float AvatarStepAngle { get; private set; }
+        public static float AvatarStepGroundFudge { get; private set; }
+        public static float AvatarStepApproachFactor { get; private set; }
+        public static float AvatarStepForceFactor { get; private set; }
+        public static float AvatarStepUpCorrectionFactor { get; private set; }
+        public static int AvatarStepSmoothingSteps { get; private set; }
+
+    // Vehicle parameters
+    public static float VehicleMaxLinearVelocity { get; private set; }
+    public static float VehicleMaxLinearVelocitySquared { get; private set; }
+    public static float VehicleMinLinearVelocity { get; private set; }
+    public static float VehicleMinLinearVelocitySquared { get; private set; }
+    public static float VehicleMaxAngularVelocity { get; private set; }
+    public static float VehicleMaxAngularVelocitySq { get; private set; }
+    public static float VehicleAngularDamping { get; private set; }
+    public static float VehicleFriction { get; private set; }
+    public static float VehicleRestitution { get; private set; }
+    public static Vector3 VehicleLinearFactor { get; private set; }
+    public static Vector3 VehicleAngularFactor { get; private set; }
+    public static Vector3 VehicleInertiaFactor { get; private set; }
+    public static float VehicleGroundGravityFudge { get; private set; }
+    public static float VehicleAngularBankingTimescaleFudge { get; private set; }
+    public static bool VehicleEnableLinearDeflection { get; private set; }
+    public static bool VehicleLinearDeflectionNotCollidingNoZ { get; private set; }
+    public static bool VehicleEnableAngularVerticalAttraction { get; private set; }
+    public static int VehicleAngularVerticalAttractionAlgorithm { get; private set; }
+    public static bool VehicleEnableAngularDeflection { get; private set; }
+    public static bool VehicleEnableAngularBanking { get; private set; }
+
+    // Convex Hulls
+    // Parameters for convex hull routine that ships with Bullet
+    public static int CSHullMaxDepthSplit { get; private set; }
+    public static int CSHullMaxDepthSplitForSimpleShapes { get; private set; }
+    public static float CSHullConcavityThresholdPercent { get; private set; }
+    public static float CSHullVolumeConservationThresholdPercent { get; private set; }
+    public static int CSHullMaxVertices { get; private set; }
+    public static float CSHullMaxSkinWidth { get; private set; }
+        public static float BHullMaxVerticesPerHull { get; private set; }               // 100
+        public static float BHullMinClusters { get; private set; }                              // 2
+        public static float BHullCompacityWeight { get; private set; }                  // 0.1
+        public static float BHullVolumeWeight { get; private set; }                             // 0.0
+        public static float BHullConcavity { get; private set; }                                    // 100
+        public static bool BHullAddExtraDistPoints { get; private set; }                // false
+        public static bool BHullAddNeighboursDistPoints { get; private set; }   // false
+        public static bool BHullAddFacesPoints { get; private set; }                    // false
+        public static bool BHullShouldAdjustCollisionMargin { get; private set; }       // false
+        public static float WhichHACD { get; private set; }                                 // zero if Bullet HACD, non-zero says VHACD
+    // Parameters for VHACD 2.0: http://code.google.com/p/v-hacd
+    // To enable, set both ShouldUseBulletHACD=true and WhichHACD=1
+        // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html
+        public static float VHACDresolution { get; private set; }                       // 100,000 max number of voxels generated during voxelization stage
+        public static float VHACDdepth { get; private set; }                            // 20 max number of clipping stages
+        public static float VHACDconcavity { get; private set; }                        // 0.0025 maximum concavity
+        public static float VHACDplaneDownsampling { get; private set; }        // 4 granularity of search for best clipping plane
+        public static float VHACDconvexHullDownsampling { get; private set; }   // 4 precision of hull gen process
+        public static float VHACDalpha { get; private set; }                            // 0.05 bias toward clipping along symmetry planes
+        public static float VHACDbeta { get; private set; }                                 // 0.05 bias toward clipping along revolution axis
+        public static float VHACDgamma { get; private set; }                            // 0.00125 max concavity when merging
+        public static float VHACDpca { get; private set; }                                      // 0 on/off normalizing mesh before decomp
+        public static float VHACDmode { get; private set; }                                 // 0 0:voxel based, 1: tetrahedron based
+        public static float VHACDmaxNumVerticesPerCH { get; private set; }      // 64 max triangles per convex hull
+        public static float VHACDminVolumePerCH { get; private set; }           // 0.0001 sampling of generated convex hulls
+
+    // Linkset implementation parameters
+    public static float LinksetImplementation { get; private set; }
+    public static bool LinksetOffsetCenterOfMass { get; private set; }
+    public static bool LinkConstraintUseFrameOffset { get; private set; }
+    public static bool LinkConstraintEnableTransMotor { get; private set; }
+    public static float LinkConstraintTransMotorMaxVel { get; private set; }
+    public static float LinkConstraintTransMotorMaxForce { get; private set; }
+    public static float LinkConstraintERP { get; private set; }
+    public static float LinkConstraintCFM { get; private set; }
+    public static float LinkConstraintSolverIterations { get; private set; }
+
+    public static float PID_D { get; private set; }    // derivative
+    public static float PID_P { get; private set; }    // proportional
+
+    // Various constants that come from that other virtual world that shall not be named.
+    public const float MinGravityZ = -1f;
+    public const float MaxGravityZ = 28f;
+    public const float MinFriction = 0f;
+    public const float MaxFriction = 255f;
+    public const float MinDensity = 0.01f;
+    public const float MaxDensity = 22587f;
+    public const float MinRestitution = 0f;
+    public const float MaxRestitution = 1f;
+
+    // =====================================================================================
+    // =====================================================================================
+
+    // Base parameter definition that gets and sets parameter values via a string
+    public abstract class ParameterDefnBase
+    {
+        public string name;         // string name of the parameter
+        public string desc;         // a short description of what the parameter means
+        public ParameterDefnBase(string pName, string pDesc)
+        {
+            name = pName;
+            desc = pDesc;
+        }
+        // Set the parameter value to the default
+        public abstract void AssignDefault(BSScene s);
+        // Get the value as a string
+        public abstract string GetValue(BSScene s);
+        // Set the value to this string value
+        public abstract void SetValue(BSScene s, string valAsString);
+        // set the value on a particular object (usually sets in physics engine)
+        public abstract void SetOnObject(BSScene s, BSPhysObject obj);
+        public abstract bool HasSetOnObject { get; }
+    }
+
+    // Specific parameter definition for a parameter of a specific type.
+    public delegate T PGetValue<T>(BSScene s);
+    public delegate void PSetValue<T>(BSScene s, T val);
+    public delegate void PSetOnObject<T>(BSScene scene, BSPhysObject obj);
+    public sealed class ParameterDefn<T> : ParameterDefnBase
+    {
+        private T defaultValue;
+        private PSetValue<T> setter;
+        private PGetValue<T> getter;
+        private PSetOnObject<T> objectSet;
+        public ParameterDefn(string pName, string pDesc, T pDefault, PGetValue<T> pGetter, PSetValue<T> pSetter)
+            : base(pName, pDesc)
+        {
+            defaultValue = pDefault;
+            setter = pSetter;
+            getter = pGetter;
+            objectSet = null;
+        }
+        public ParameterDefn(string pName, string pDesc, T pDefault, PGetValue<T> pGetter, PSetValue<T> pSetter, PSetOnObject<T> pObjSetter)
+            : base(pName, pDesc)
+        {
+            defaultValue = pDefault;
+            setter = pSetter;
+            getter = pGetter;
+            objectSet = pObjSetter;
+        }
+        // Simple parameter variable where property name is the same as the INI file name
+        //     and the value is only a simple get and set.
+        public ParameterDefn(string pName, string pDesc, T pDefault)
+            : base(pName, pDesc)
+        {
+            defaultValue = pDefault;
+            setter = (s, v) => { SetValueByName(s, name, v); };
+            getter = (s) => { return GetValueByName(s, name); };
+            objectSet = null;
+        }
+        // Use reflection to find the property named 'pName' in BSParam and assign 'val' to same.
+        private void SetValueByName(BSScene s, string pName, T val)
+        {
+            PropertyInfo prop = typeof(BSParam).GetProperty(pName, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
+            if (prop == null)
+            {
+                // This should only be output when someone adds a new INI parameter and misspells the name.
+                s.Logger.ErrorFormat("{0} SetValueByName: did not find '{1}'. Verify specified property name is the same as the given INI parameters name.", LogHeader, pName);
+            }
+            else
+            {
+                prop.SetValue(null, val, null);
+            }
+        }
+        // Use reflection to find the property named 'pName' in BSParam and return the value in same.
+        private T GetValueByName(BSScene s, string pName)
+        {
+            PropertyInfo prop = typeof(BSParam).GetProperty(pName, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
+            if (prop == null)
+            {
+                // This should only be output when someone adds a new INI parameter and misspells the name.
+                s.Logger.ErrorFormat("{0} GetValueByName: did not find '{1}'. Verify specified property name is the same as the given INI parameter name.", LogHeader, pName);
+            }
+            return (T)prop.GetValue(null, null);
+        }
+        public override void AssignDefault(BSScene s)
+        {
+            setter(s, defaultValue);
+        }
+        public override string GetValue(BSScene s)
+        {
+            return getter(s).ToString();
+        }
+        public override void SetValue(BSScene s, string valAsString)
+        {
+            // Get the generic type of the setter
+            Type genericType = setter.GetType().GetGenericArguments()[0];
+            // Find the 'Parse' method on that type
+            System.Reflection.MethodInfo parser = null;
+            try
+            {
+                parser = genericType.GetMethod("Parse", new Type[] { typeof(String) } );
+            }
+            catch (Exception e)
+            {
+                s.Logger.ErrorFormat("{0} Exception getting parser for type '{1}': {2}", LogHeader, genericType, e);
+                parser = null;
+            }
+            if (parser != null)
+            {
+                // Parse the input string
+                try
+                {
+                    T setValue = (T)parser.Invoke(genericType, new Object[] { valAsString });
+                    // Store the parsed value
+                    setter(s, setValue);
+                    // s.Logger.DebugFormat("{0} Parameter {1} = {2}", LogHeader, name, setValue);
+                }
+                catch
+                {
+                    s.Logger.ErrorFormat("{0} Failed parsing parameter value '{1}' as type '{2}'", LogHeader, valAsString, genericType);
+                }
+            }
+            else
+            {
+                s.Logger.ErrorFormat("{0} Could not find parameter parser for type '{1}'", LogHeader, genericType);
+            }
+        }
+        public override bool HasSetOnObject
+        {
+            get { return objectSet != null; }
+        }
+        public override void SetOnObject(BSScene s, BSPhysObject obj)
+        {
+            if (objectSet != null)
+                objectSet(s, obj);
+        }
+    }
+
+    // List of all of the externally visible parameters.
+    // For each parameter, this table maps a text name to getter and setters.
+    // To add a new externally referencable/settable parameter, add the paramter storage
+    //    location somewhere in the program and make an entry in this table with the
+    //    getters and setters.
+    // It is easiest to find an existing definition and copy it.
+    //
+    // A ParameterDefn<T>() takes the following parameters:
+    //    -- the text name of the parameter. This is used for console input and ini file.
+    //    -- a short text description of the parameter. This shows up in the console listing.
+    //    -- a default value
+    //    -- a delegate for getting the value
+    //    -- a delegate for setting the value
+    //    -- an optional delegate to update the value in the world. Most often used to
+    //          push the new value to an in-world object.
+    //
+    // The single letter parameters for the delegates are:
+    //    s = BSScene
+    //    o = BSPhysObject
+    //    v = value (appropriate type)
+    private static ParameterDefnBase[] ParameterDefinitions =
+    {
+        new ParameterDefn<bool>("Active", "If 'true', false then physics is not active",
+            false ),
+        new ParameterDefn<bool>("UseSeparatePhysicsThread", "If 'true', the physics engine runs independent from the simulator heartbeat",
+            false ),
+        new ParameterDefn<float>("PhysicsTimeStep", "If separate thread, seconds to simulate each interval",
+            0.089f ),
+
+        new ParameterDefn<bool>("MeshSculptedPrim", "Whether to create meshes for sculpties",
+            true,
+            (s) => { return ShouldMeshSculptedPrim; },
+            (s,v) => { ShouldMeshSculptedPrim = v; } ),
+        new ParameterDefn<bool>("ForceSimplePrimMeshing", "If true, only use primitive meshes for objects",
+            false,
+            (s) => { return ShouldForceSimplePrimMeshing; },
+            (s,v) => { ShouldForceSimplePrimMeshing = v; } ),
+        new ParameterDefn<bool>("UseHullsForPhysicalObjects", "If true, create hulls for physical objects",
+            true,
+            (s) => { return ShouldUseHullsForPhysicalObjects; },
+            (s,v) => { ShouldUseHullsForPhysicalObjects = v; } ),
+        new ParameterDefn<bool>("ShouldRemoveZeroWidthTriangles", "If true, remove degenerate triangles from meshes",
+            true ),
+        new ParameterDefn<bool>("ShouldUseBulletHACD", "If true, use the Bullet version of HACD",
+            false ),
+        new ParameterDefn<bool>("ShouldUseSingleConvexHullForPrims", "If true, use a single convex hull shape for physical prims",
+            true ),
+        new ParameterDefn<bool>("ShouldUseGImpactShapeForPrims", "If true, use a GImpact shape for prims with cuts and twists",
+            false ),
+        new ParameterDefn<bool>("ShouldUseAssetHulls", "If true, use hull if specified in the mesh asset info",
+            true ),
+
+        new ParameterDefn<int>("CrossingFailuresBeforeOutOfBounds", "How forgiving we are about getting into adjactent regions",
+            5 ),
+        new ParameterDefn<float>("UpdateVelocityChangeThreshold", "Change in updated velocity required before reporting change to simulator",
+            0.1f ),
+
+        new ParameterDefn<float>("MeshLevelOfDetail", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)",
+            32f,
+            (s) => { return MeshLOD; },
+            (s,v) => { MeshLOD = v; } ),
+        new ParameterDefn<float>("MeshLevelOfDetailCircular", "Level of detail for prims with circular cuts or shapes",
+            32f,
+            (s) => { return MeshCircularLOD; },
+            (s,v) => { MeshCircularLOD = v; } ),
+        new ParameterDefn<float>("MeshLevelOfDetailMegaPrimThreshold", "Size (in meters) of a mesh before using MeshMegaPrimLOD",
+            10f,
+            (s) => { return MeshMegaPrimThreshold; },
+            (s,v) => { MeshMegaPrimThreshold = v; } ),
+        new ParameterDefn<float>("MeshLevelOfDetailMegaPrim", "Level of detail to render meshes larger than threshold meters",
+            32f,
+            (s) => { return MeshMegaPrimLOD; },
+            (s,v) => { MeshMegaPrimLOD = v; } ),
+        new ParameterDefn<float>("SculptLevelOfDetail", "Level of detail to render sculpties (32, 16, 8 or 4. 32=most detailed)",
+            32f,
+            (s) => { return SculptLOD; },
+            (s,v) => { SculptLOD = v; } ),
+
+        new ParameterDefn<int>("MaxSubStep", "In simulation step, maximum number of substeps",
+            10,
+            (s) => { return s.m_maxSubSteps; },
+            (s,v) => { s.m_maxSubSteps = (int)v; } ),
+        new ParameterDefn<float>("FixedTimeStep", "In simulation step, seconds of one substep (1/60)",
+            1f / 60f,
+            (s) => { return s.m_fixedTimeStep; },
+            (s,v) => { s.m_fixedTimeStep = v; } ),
+        new ParameterDefn<float>("NominalFrameRate", "The base frame rate we claim",
+            55f,
+            (s) => { return s.NominalFrameRate; },
+            (s,v) => { s.NominalFrameRate = (int)v; } ),
+        new ParameterDefn<int>("MaxCollisionsPerFrame", "Max collisions returned at end of each frame",
+            2048,
+            (s) => { return s.m_maxCollisionsPerFrame; },
+            (s,v) => { s.m_maxCollisionsPerFrame = (int)v; } ),
+        new ParameterDefn<int>("MaxUpdatesPerFrame", "Max updates returned at end of each frame",
+            8000,
+            (s) => { return s.m_maxUpdatesPerFrame; },
+            (s,v) => { s.m_maxUpdatesPerFrame = (int)v; } ),
+
+        new ParameterDefn<float>("MinObjectMass", "Minimum object mass (0.0001)",
+            0.0001f,
+            (s) => { return MinimumObjectMass; },
+            (s,v) => { MinimumObjectMass = v; } ),
+        new ParameterDefn<float>("MaxObjectMass", "Maximum object mass (10000.01)",
+            10000.01f,
+            (s) => { return MaximumObjectMass; },
+            (s,v) => { MaximumObjectMass = v; } ),
+        new ParameterDefn<float>("MaxLinearVelocity", "Maximum velocity magnitude that can be assigned to an object",
+            1000.0f,
+            (s) => { return MaxLinearVelocity; },
+            (s,v) => { MaxLinearVelocity = v; MaxLinearVelocitySquared = v * v; } ),
+        new ParameterDefn<float>("MaxAngularVelocity", "Maximum rotational velocity magnitude that can be assigned to an object",
+            1000.0f,
+            (s) => { return MaxAngularVelocity; },
+            (s,v) => { MaxAngularVelocity = v;  MaxAngularVelocitySquared = v * v; } ),
+        // LL documentation says thie number should be 20f for llApplyImpulse and 200f for llRezObject
+        new ParameterDefn<float>("MaxAddForceMagnitude", "Maximum force that can be applied by llApplyImpulse (SL says 20f)",
+            20000.0f,
+            (s) => { return MaxAddForceMagnitude; },
+            (s,v) => { MaxAddForceMagnitude = v; MaxAddForceMagnitudeSquared = v * v; } ),
+        // Density is passed around as 100kg/m3. This scales that to 1kg/m3.
+        // Reduce by power of 100 because Bullet doesn't seem to handle objects with large mass very well
+        new ParameterDefn<float>("DensityScaleFactor", "Conversion for simulator/viewer density (100kg/m3) to physical density (1kg/m3)",
+            0.01f ),
+
+        new ParameterDefn<float>("PID_D", "Derivitive factor for motion smoothing",
+            2200f ),
+        new ParameterDefn<float>("PID_P", "Parameteric factor for motion smoothing",
+            900f ),
+
+        new ParameterDefn<float>("DefaultFriction", "Friction factor used on new objects",
+            0.2f,
+            (s) => { return DefaultFriction; },
+            (s,v) => { DefaultFriction = v; s.UnmanagedParams[0].defaultFriction = v; } ),
+        // For historical reasons, the viewer and simulator multiply the density by 100
+        new ParameterDefn<float>("DefaultDensity", "Density for new objects" ,
+            1000.0006836f,  // Aluminum g/cm3 * 100
+            (s) => { return DefaultDensity; },
+            (s,v) => { DefaultDensity = v; s.UnmanagedParams[0].defaultDensity = v; } ),
+        new ParameterDefn<float>("DefaultRestitution", "Bouncyness of an object" ,
+            0f,
+            (s) => { return DefaultRestitution; },
+            (s,v) => { DefaultRestitution = v; s.UnmanagedParams[0].defaultRestitution = v; } ),
+        new ParameterDefn<float>("CollisionMargin", "Margin around objects before collisions are calculated (must be zero!)",
+            0.04f,
+            (s) => { return CollisionMargin; },
+            (s,v) => { CollisionMargin = v; s.UnmanagedParams[0].collisionMargin = v; } ),
+        new ParameterDefn<float>("Gravity", "Vertical force of gravity (negative means down)",
+            -9.80665f,
+            (s) => { return Gravity; },
+            (s,v) => { Gravity = v; s.UnmanagedParams[0].gravity = v; },
+            (s,o) => { s.PE.SetGravity(o.PhysBody, new Vector3(0f,0f,Gravity)); } ),
+
+
+        new ParameterDefn<float>("LinearDamping", "Factor to damp linear movement per second (0.0 - 1.0)",
+            0f,
+            (s) => { return LinearDamping; },
+            (s,v) => { LinearDamping = v; },
+            (s,o) => { s.PE.SetDamping(o.PhysBody, LinearDamping, AngularDamping); } ),
+        new ParameterDefn<float>("AngularDamping", "Factor to damp angular movement per second (0.0 - 1.0)",
+            0f,
+            (s) => { return AngularDamping; },
+            (s,v) => { AngularDamping = v; },
+            (s,o) => { s.PE.SetDamping(o.PhysBody, LinearDamping, AngularDamping); } ),
+        new ParameterDefn<float>("DeactivationTime", "Seconds before considering an object potentially static",
+            0.2f,
+            (s) => { return DeactivationTime; },
+            (s,v) => { DeactivationTime = v; },
+            (s,o) => { s.PE.SetDeactivationTime(o.PhysBody, DeactivationTime); } ),
+        new ParameterDefn<float>("LinearSleepingThreshold", "Seconds to measure linear movement before considering static",
+            0.8f,
+            (s) => { return LinearSleepingThreshold; },
+            (s,v) => { LinearSleepingThreshold = v;},
+            (s,o) => { s.PE.SetSleepingThresholds(o.PhysBody, LinearSleepingThreshold, AngularSleepingThreshold); } ),
+        new ParameterDefn<float>("AngularSleepingThreshold", "Seconds to measure angular movement before considering static",
+            1.0f,
+            (s) => { return AngularSleepingThreshold; },
+            (s,v) => { AngularSleepingThreshold = v;},
+            (s,o) => { s.PE.SetSleepingThresholds(o.PhysBody, LinearSleepingThreshold, AngularSleepingThreshold); } ),
+        new ParameterDefn<float>("CcdMotionThreshold", "Continuious collision detection threshold (0 means no CCD)" ,
+            0.0f,     // set to zero to disable
+            (s) => { return CcdMotionThreshold; },
+            (s,v) => { CcdMotionThreshold = v;},
+            (s,o) => { s.PE.SetCcdMotionThreshold(o.PhysBody, CcdMotionThreshold); } ),
+        new ParameterDefn<float>("CcdSweptSphereRadius", "Continuious collision detection test radius" ,
+            0.2f,
+            (s) => { return CcdSweptSphereRadius; },
+            (s,v) => { CcdSweptSphereRadius = v;},
+            (s,o) => { s.PE.SetCcdSweptSphereRadius(o.PhysBody, CcdSweptSphereRadius); } ),
+        new ParameterDefn<float>("ContactProcessingThreshold", "Distance above which contacts can be discarded (0 means no discard)" ,
+            0.0f,
+            (s) => { return ContactProcessingThreshold; },
+            (s,v) => { ContactProcessingThreshold = v;},
+            (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ),
+
+            new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)",
+            (float)BSTerrainPhys.TerrainImplementation.Heightmap ),
+        new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" ,
+            2 ),
+        new ParameterDefn<float>("TerrainGroundPlane", "Altitude of ground plane used to keep things from falling to infinity" ,
+            -500.0f ),
+        new ParameterDefn<float>("TerrainFriction", "Factor to reduce movement against terrain surface" ,
+            0.3f ),
+        new ParameterDefn<float>("TerrainHitFraction", "Distance to measure hit collisions" ,
+            0.8f ),
+        new ParameterDefn<float>("TerrainRestitution", "Bouncyness" ,
+            0f ),
+        new ParameterDefn<float>("TerrainContactProcessingThreshold", "Distance from terrain to stop processing collisions" ,
+            0.0f ),
+        new ParameterDefn<float>("TerrainCollisionMargin", "Margin where collision checking starts" ,
+            0.04f ),
+
+        new ParameterDefn<bool>("AvatarToAvatarCollisionsByDefault", "Should avatars collide with other avatars by default?",
+            true),
+        new ParameterDefn<float>("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.",
+            0.2f ),
+        new ParameterDefn<float>("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.",
+            0.95f ),
+        new ParameterDefn<float>("AvatarAlwaysRunFactor", "Speed multiplier if avatar is set to always run",
+            1.3f ),
+            // For historical reasons, density is reported  * 100
+        new ParameterDefn<float>("AvatarDensity", "Density of an avatar. Changed on avatar recreation. Scaled times 100.",
+            3500f) ,    // 3.5 * 100
+        new ParameterDefn<float>("AvatarRestitution", "Bouncyness. Changed on avatar recreation.",
+            0f ),
+        new ParameterDefn<int>("AvatarShape", "Code for avatar physical shape: 0:capsule, 1:cube, 2:ovoid, 2:mesh",
+            BSShapeCollection.AvatarShapeCube ) ,
+        new ParameterDefn<float>("AvatarCapsuleWidth", "The distance between the sides of the avatar capsule",
+            0.6f ) ,
+        new ParameterDefn<float>("AvatarCapsuleDepth", "The distance between the front and back of the avatar capsule",
+            0.45f ),
+        new ParameterDefn<float>("AvatarCapsuleHeight", "Default height of space around avatar",
+            1.5f ),
+        new ParameterDefn<float>("AvatarHeightLowFudge", "A fudge factor to make small avatars stand on the ground",
+            0f ),
+        new ParameterDefn<float>("AvatarHeightMidFudge", "A fudge distance to adjust average sized avatars to be standing on ground",
+            0f ),
+        new ParameterDefn<float>("AvatarHeightHighFudge", "A fudge factor to make tall avatars stand on the ground",
+            0f ),
+        new ParameterDefn<float>("AvatarFlyingGroundMargin", "Meters avatar is kept above the ground when flying",
+            5f ),
+        new ParameterDefn<float>("AvatarFlyingGroundUpForce", "Upward force applied to the avatar to keep it at flying ground margin",
+            2.0f ),
+        new ParameterDefn<float>("AvatarTerminalVelocity", "Terminal Velocity of falling avatar",
+            -54.0f ),
+            new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions",
+            0.1f ),
+            new ParameterDefn<float>("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped",
+            0.1f ),
+            new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground",
+            1.0f ),
+            new ParameterDefn<int>("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.",
+            4 ),
+            new ParameterDefn<float>("AvatarStepHeight", "Height of a step obstacle to consider step correction",
+            0.999f ) ,
+            new ParameterDefn<float>("AvatarStepAngle", "The angle (in radians) for a vertical surface to be considered a step",
+            0.3f ) ,
+            new ParameterDefn<float>("AvatarStepGroundFudge", "Fudge factor subtracted from avatar base when comparing collision height",
+            0.1f ) ,
+            new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)",
+            2f ),
+            new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step",
+            0f ),
+            new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step",
+            0.8f ),
+            new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs",
+            1 ),
+
+        new ParameterDefn<float>("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle",
+            1000.0f,
+            (s) => { return (float)VehicleMaxLinearVelocity; },
+            (s,v) => { VehicleMaxLinearVelocity = v; VehicleMaxLinearVelocitySquared = v * v; } ),
+        new ParameterDefn<float>("VehicleMinLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle",
+            0.001f,
+            (s) => { return (float)VehicleMinLinearVelocity; },
+            (s,v) => { VehicleMinLinearVelocity = v; VehicleMinLinearVelocitySquared = v * v; } ),
+        new ParameterDefn<float>("VehicleMaxAngularVelocity", "Maximum rotational velocity magnitude that can be assigned to a vehicle",
+            12.0f,
+            (s) => { return (float)VehicleMaxAngularVelocity; },
+            (s,v) => { VehicleMaxAngularVelocity = v; VehicleMaxAngularVelocitySq = v * v; } ),
+        new ParameterDefn<float>("VehicleAngularDamping", "Factor to damp vehicle angular movement per second (0.0 - 1.0)",
+            0.0f ),
+        new ParameterDefn<Vector3>("VehicleLinearFactor", "Fraction of physical linear changes applied to vehicle (<0,0,0> to <1,1,1>)",
+            new Vector3(1f, 1f, 1f) ),
+        new ParameterDefn<Vector3>("VehicleAngularFactor", "Fraction of physical angular changes applied to vehicle (<0,0,0> to <1,1,1>)",
+            new Vector3(1f, 1f, 1f) ),
+        new ParameterDefn<Vector3>("VehicleInertiaFactor", "Fraction of physical inertia applied (<0,0,0> to <1,1,1>)",
+            new Vector3(1f, 1f, 1f) ),
+        new ParameterDefn<float>("VehicleFriction", "Friction of vehicle on the ground (0.0 - 1.0)",
+            0.0f ),
+        new ParameterDefn<float>("VehicleRestitution", "Bouncyness factor for vehicles (0.0 - 1.0)",
+            0.0f ),
+        new ParameterDefn<float>("VehicleGroundGravityFudge", "Factor to multiply gravity if a ground vehicle is probably on the ground (0.0 - 1.0)",
+            0.2f ),
+        new ParameterDefn<float>("VehicleAngularBankingTimescaleFudge", "Factor to multiple angular banking timescale. Tune to increase realism.",
+            60.0f ),
+        new ParameterDefn<bool>("VehicleEnableLinearDeflection", "Turn on/off vehicle linear deflection effect",
+            true ),
+        new ParameterDefn<bool>("VehicleLinearDeflectionNotCollidingNoZ", "Turn on/off linear deflection Z effect on non-colliding vehicles",
+            true ),
+        new ParameterDefn<bool>("VehicleEnableAngularVerticalAttraction", "Turn on/off vehicle angular vertical attraction effect",
+            true ),
+        new ParameterDefn<int>("VehicleAngularVerticalAttractionAlgorithm", "Select vertical attraction algo. You need to look at the source.",
+            0 ),
+        new ParameterDefn<bool>("VehicleEnableAngularDeflection", "Turn on/off vehicle angular deflection effect",
+            true ),
+        new ParameterDefn<bool>("VehicleEnableAngularBanking", "Turn on/off vehicle angular banking effect",
+            true ),
+
+            new ParameterDefn<float>("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)",
+            0f,
+            (s) => { return MaxPersistantManifoldPoolSize; },
+            (s,v) => { MaxPersistantManifoldPoolSize = v; s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ),
+            new ParameterDefn<float>("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)",
+            0f,
+            (s) => { return MaxCollisionAlgorithmPoolSize; },
+            (s,v) => { MaxCollisionAlgorithmPoolSize = v; s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ),
+            new ParameterDefn<bool>("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count",
+            false,
+            (s) => { return ShouldDisableContactPoolDynamicAllocation; },
+            (s,v) => { ShouldDisableContactPoolDynamicAllocation = v;
+                        s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = NumericBool(v); } ),
+            new ParameterDefn<bool>("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step",
+            false,
+            (s) => { return ShouldForceUpdateAllAabbs; },
+            (s,v) => { ShouldForceUpdateAllAabbs = v; s.UnmanagedParams[0].shouldForceUpdateAllAabbs = NumericBool(v); } ),
+            new ParameterDefn<bool>("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction",
+            true,
+            (s) => { return ShouldRandomizeSolverOrder; },
+            (s,v) => { ShouldRandomizeSolverOrder = v; s.UnmanagedParams[0].shouldRandomizeSolverOrder = NumericBool(v); } ),
+            new ParameterDefn<bool>("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands",
+            true,
+            (s) => { return ShouldSplitSimulationIslands; },
+            (s,v) => { ShouldSplitSimulationIslands = v; s.UnmanagedParams[0].shouldSplitSimulationIslands = NumericBool(v); } ),
+            new ParameterDefn<bool>("ShouldEnableFrictionCaching", "Enable friction computation caching",
+            true,
+            (s) => { return ShouldEnableFrictionCaching; },
+            (s,v) => { ShouldEnableFrictionCaching = v; s.UnmanagedParams[0].shouldEnableFrictionCaching = NumericBool(v); } ),
+            new ParameterDefn<float>("NumberOfSolverIterations", "Number of internal iterations (0 means default)",
+            0f,     // zero says use Bullet default
+            (s) => { return NumberOfSolverIterations; },
+            (s,v) => { NumberOfSolverIterations = v; s.UnmanagedParams[0].numberOfSolverIterations = v; } ),
+            new ParameterDefn<bool>("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.",
+            true,
+            (s) => { return UseSingleSidedMeshes; },
+            (s,v) => { UseSingleSidedMeshes = v; s.UnmanagedParams[0].useSingleSidedMeshes = NumericBool(v); } ),
+            new ParameterDefn<float>("GlobalContactBreakingThreshold", "Amount of shape radius before breaking a collision contact (0 says Bullet default (0.2))",
+            0f,
+            (s) => { return GlobalContactBreakingThreshold; },
+            (s,v) => { GlobalContactBreakingThreshold = v; s.UnmanagedParams[0].globalContactBreakingThreshold = v; } ),
+            new ParameterDefn<float>("PhysicsUnmanLoggingFrames", "If non-zero, frames between output of detailed unmanaged physics statistics",
+            0f,
+            (s) => { return PhysicsUnmanLoggingFrames; },
+            (s,v) => { PhysicsUnmanLoggingFrames = v; s.UnmanagedParams[0].physicsLoggingFrames = v; } ),
+
+            new ParameterDefn<int>("CSHullMaxDepthSplit", "CS impl: max depth to split for hull. 1-10 but > 7 is iffy",
+            7 ),
+            new ParameterDefn<int>("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes",
+            2 ),
+            new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)",
+            5f ),
+            new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)",
+            5f ),
+            new ParameterDefn<int>("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.",
+            32 ),
+            new ParameterDefn<float>("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.",
+            0f ),
+
+            new ParameterDefn<float>("BHullMaxVerticesPerHull", "Bullet impl: max number of vertices per created hull",
+            200f ),
+            new ParameterDefn<float>("BHullMinClusters", "Bullet impl: minimum number of hulls to create per mesh",
+            10f ),
+            new ParameterDefn<float>("BHullCompacityWeight", "Bullet impl: weight factor for how compact to make hulls",
+            20f ),
+            new ParameterDefn<float>("BHullVolumeWeight", "Bullet impl: weight factor for volume in created hull",
+            0.1f ),
+            new ParameterDefn<float>("BHullConcavity", "Bullet impl: weight factor for how convex a created hull can be",
+            10f ),
+            new ParameterDefn<bool>("BHullAddExtraDistPoints", "Bullet impl: whether to add extra vertices for long distance vectors",
+            true ),
+            new ParameterDefn<bool>("BHullAddNeighboursDistPoints", "Bullet impl: whether to add extra vertices between neighbor hulls",
+            true ),
+            new ParameterDefn<bool>("BHullAddFacesPoints", "Bullet impl: whether to add extra vertices to break up hull faces",
+            true ),
+            new ParameterDefn<bool>("BHullShouldAdjustCollisionMargin", "Bullet impl: whether to shrink resulting hulls to account for collision margin",
+            false ),
+
+            new ParameterDefn<float>("WhichHACD", "zero if Bullet HACD, non-zero says VHACD",
+            0f ),
+            new ParameterDefn<float>("VHACDresolution", "max number of voxels generated during voxelization stage",
+            100000f ),
+            new ParameterDefn<float>("VHACDdepth", "max number of clipping stages",
+            20f ),
+            new ParameterDefn<float>("VHACDconcavity", "maximum concavity",
+            0.0025f ),
+            new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane",
+            4f ),
+            new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process",
+            4f ),
+            new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes",
+            0.05f ),
+            new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis",
+            0.05f ),
+            new ParameterDefn<float>("VHACDgamma", "max concavity when merging",
+            0.00125f ),
+            new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp",
+            0f ),
+            new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based",
+            0f ),
+            new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull",
+            64f ),
+            new ParameterDefn<float>("VHACDminVolumePerCH",     "sampling of generated convex hulls",
+            0.0001f ),
+
+            new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)",
+            (float)BSLinkset.LinksetImplementation.Compound ),
+            new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same",
+            true ),
+            new ParameterDefn<bool>("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.",
+            false ),
+            new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints",
+            true ),
+            new ParameterDefn<float>("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints",
+            5.0f ),
+            new ParameterDefn<float>("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints",
+            0.1f ),
+            new ParameterDefn<float>("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1",
+            0.1f ),
+            new ParameterDefn<float>("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2",
+            0.1f ),
+            new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)",
+            40 ),
+
+        new ParameterDefn<int>("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)",
+            0,
+            (s) => { return s.PhysicsMetricDumpFrames; },
+            (s,v) => { s.PhysicsMetricDumpFrames = v; } ),
+        new ParameterDefn<float>("ResetBroadphasePool", "Setting this is any value resets the broadphase collision pool",
+            0f,
+            (s) => { return 0f; },
+            (s,v) => { BSParam.ResetBroadphasePoolTainted(s, v, false /* inTaintTime */); } ),
+        new ParameterDefn<float>("ResetConstraintSolver", "Setting this is any value resets the constraint solver",
+            0f,
+            (s) => { return 0f; },
+            (s,v) => { BSParam.ResetConstraintSolverTainted(s, v); } ),
+    };
+
+    // Convert a boolean to our numeric true and false values
+    public static float NumericBool(bool b)
+    {
+        return (b ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse);
+    }
+
+    // Convert numeric true and false values to a boolean
+    public static bool BoolNumeric(float b)
+    {
+        return (b == ConfigurationParameters.numericTrue ? true : false);
+    }
+
+    // Search through the parameter definitions and return the matching
+    //    ParameterDefn structure.
+    // Case does not matter as names are compared after converting to lower case.
+    // Returns 'false' if the parameter is not found.
+    internal static bool TryGetParameter(string paramName, out ParameterDefnBase defn)
+    {
+        bool ret = false;
+        ParameterDefnBase foundDefn = null;
+        string pName = paramName.ToLower();
+
+        foreach (ParameterDefnBase parm in ParameterDefinitions)
+        {
+            if (pName == parm.name.ToLower())
+            {
+                foundDefn = parm;
+                ret = true;
+                break;
+            }
+        }
+        defn = foundDefn;
+        return ret;
+    }
+
+    // Pass through the settable parameters and set the default values
+    internal static void SetParameterDefaultValues(BSScene physicsScene)
+    {
+        foreach (ParameterDefnBase parm in ParameterDefinitions)
+        {
+            parm.AssignDefault(physicsScene);
+        }
+    }
+
+    // Get user set values out of the ini file.
+    internal static void SetParameterConfigurationValues(BSScene physicsScene, IConfig cfg)
+    {
+        foreach (ParameterDefnBase parm in ParameterDefinitions)
+        {
+            parm.SetValue(physicsScene, cfg.GetString(parm.name, parm.GetValue(physicsScene)));
+        }
+    }
+
+    internal static PhysParameterEntry[] SettableParameters = new PhysParameterEntry[1];
+
+    // This creates an array in the correct format for returning the list of
+    //    parameters. This is used by the 'list' option of the 'physics' command.
+    internal static void BuildParameterTable()
+    {
+        if (SettableParameters.Length < ParameterDefinitions.Length)
+        {
+            List<PhysParameterEntry> entries = new List<PhysParameterEntry>();
+            for (int ii = 0; ii < ParameterDefinitions.Length; ii++)
+            {
+                ParameterDefnBase pd = ParameterDefinitions[ii];
+                entries.Add(new PhysParameterEntry(pd.name, pd.desc));
+            }
+
+            // make the list alphabetical for ease of finding anything
+            entries.Sort((ppe1, ppe2) => { return ppe1.name.CompareTo(ppe2.name); });
+
+            SettableParameters = entries.ToArray();
+        }
+    }
+
+    // =====================================================================
+    // =====================================================================
+    // There are parameters that, when set, cause things to happen in the physics engine.
+    // This causes the broadphase collision cache to be cleared.
+    private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v, bool inTaintTime)
+    {
+        BSScene physScene = pPhysScene;
+        physScene.TaintedObject(inTaintTime, "BSParam.ResetBroadphasePoolTainted", delegate()
+        {
+            physScene.PE.ResetBroadphasePool(physScene.World);
+        });
+    }
+
+    // This causes the constraint solver cache to be cleared and reset.
+    private static void ResetConstraintSolverTainted(BSScene pPhysScene, float v)
+    {
+        BSScene physScene = pPhysScene;
+        physScene.TaintedObject(BSScene.DetailLogZero, "BSParam.ResetConstraintSolver", delegate()
+        {
+            physScene.PE.ResetConstraintSolver(physScene.World);
+        });
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
new file mode 100755
index 0000000..da3fc18
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
@@ -0,0 +1,620 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OMV = OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+/*
+ * Class to wrap all objects.
+ * The rest of BulletSim doesn't need to keep checking for avatars or prims
+ *        unless the difference is significant.
+ *
+ *  Variables in the physicsl objects are in three forms:
+ *      VariableName: used by the simulator and performs taint operations, etc
+ *      RawVariableName: direct reference to the BulletSim storage for the variable value
+ *      ForceVariableName: direct reference (store and fetch) to the value in the physics engine.
+ *  The last one should only be referenced in taint-time.
+ */
+
+/*
+ * As of 20121221, the following are the call sequences (going down) for different script physical functions:
+ * llApplyImpulse       llApplyRotImpulse           llSetTorque             llSetForce
+ * SOP.ApplyImpulse     SOP.ApplyAngularImpulse     SOP.SetAngularImpulse   SOP.SetForce
+ * SOG.ApplyImpulse     SOG.ApplyAngularImpulse     SOG.SetAngularImpulse
+ * PA.AddForce          PA.AddAngularForce          PA.Torque = v           PA.Force = v
+ * BS.ApplyCentralForce BS.ApplyTorque
+ */
+
+// Flags used to denote which properties updates when making UpdateProperties calls to linksets, etc.
+public enum UpdatedProperties : uint
+{
+    Position                = 1 << 0,
+    Orientation             = 1 << 1,
+    Velocity                = 1 << 2,
+    Acceleration            = 1 << 3,
+    RotationalVelocity      = 1 << 4,
+    EntPropUpdates          = Position | Orientation | Velocity | Acceleration | RotationalVelocity,
+}
+public abstract class BSPhysObject : PhysicsActor
+{
+    protected BSPhysObject()
+    {
+    }
+    protected BSPhysObject(BSScene parentScene, uint localID, string name, string typeName)
+    {
+        IsInitialized = false;
+
+        PhysScene = parentScene;
+        LocalID = localID;
+        PhysObjectName = name;
+        Name = name;    // PhysicsActor also has the name of the object. Someday consolidate.
+        TypeName = typeName;
+
+        // Oddity if object is destroyed and recreated very quickly it could still have the old body.
+        if (!PhysBody.HasPhysicalBody)
+            PhysBody = new BulletBody(localID);
+
+        // Clean out anything that might be in the physical actor list.
+        // Again, a workaround for destroying and recreating an object very quickly.
+        PhysicalActors.Dispose();
+
+        UserSetCenterOfMassDisplacement = null;
+
+        PrimAssetState = PrimAssetCondition.Unknown;
+
+        // Initialize variables kept in base.
+        // Beware that these cause taints to be queued whch can cause race conditions on startup.
+        GravModifier = 1.0f;
+        Gravity = new OMV.Vector3(0f, 0f, BSParam.Gravity);
+        HoverActive = false;
+
+        // Default material type. Also sets Friction, Restitution and Density.
+        SetMaterial((int)MaterialAttributes.Material.Wood);
+
+        CollisionsLastTickStep = -1;
+
+        SubscribedEventsMs = 0;
+        // Crazy values that will never be true
+        CollidingStep = BSScene.NotASimulationStep;
+        CollidingGroundStep = BSScene.NotASimulationStep;
+        CollisionAccumulation = BSScene.NotASimulationStep;
+        ColliderIsMoving = false;
+        CollisionScore = 0;
+
+        // All axis free.
+        LockedLinearAxis = LockedAxisFree;
+        LockedAngularAxis = LockedAxisFree;
+    }
+
+    // Tell the object to clean up.
+    public virtual void Destroy()
+    {
+        PhysicalActors.Enable(false);
+        PhysScene.TaintedObject(LocalID, "BSPhysObject.Destroy", delegate()
+        {
+            PhysicalActors.Dispose();
+        });
+    }
+
+    public BSScene PhysScene { get; protected set; }
+    // public override uint LocalID { get; set; } // Use the LocalID definition in PhysicsActor
+    public string PhysObjectName { get; protected set; }
+    public string TypeName { get; protected set; }
+
+    // Set to 'true' when the object is completely initialized.
+    // This mostly prevents property updates and collisions until the object is completely here.
+    public bool IsInitialized { get; protected set; }
+
+    // Set to 'true' if an object (mesh/linkset/sculpty) is not completely constructed.
+    // This test is used to prevent some updates to the object when it only partially exists.
+    // There are several reasons and object might be incomplete:
+    //     Its underlying mesh/sculpty is an asset which must be fetched from the asset store
+    //     It is a linkset who is being added to or removed from
+    //     It is changing state (static to physical, for instance) which requires rebuilding
+    // This is a computed value based on the underlying physical object construction
+    abstract public bool IsIncomplete { get; }
+
+    // Return the object mass without calculating it or having side effects
+    public abstract float RawMass { get; }
+    // Set the raw mass but also update physical mass properties (inertia, ...)
+    // 'inWorld' true if the object has already been added to the dynamic world.
+    public abstract void UpdatePhysicalMassProperties(float mass, bool inWorld);
+
+    // The gravity being applied to the object. A function of default grav, GravityModifier and Buoyancy.
+    public virtual OMV.Vector3 Gravity { get; set; }
+    // The last value calculated for the prim's inertia
+    public OMV.Vector3 Inertia { get; set; }
+
+    // Reference to the physical body (btCollisionObject) of this object
+    public BulletBody PhysBody = new BulletBody(0);
+    // Reference to the physical shape (btCollisionShape) of this object
+    public BSShape PhysShape = new BSShapeNull();
+
+    // The physical representation of the prim might require an asset fetch.
+    // The asset state is first 'Unknown' then 'Waiting' then either 'Failed' or 'Fetched'.
+    public enum PrimAssetCondition
+    {
+        Unknown, Waiting, FailedAssetFetch, FailedMeshing, Fetched
+    }
+    public PrimAssetCondition PrimAssetState { get; set; }
+    public virtual bool AssetFailed()
+    {
+        return ( (this.PrimAssetState == PrimAssetCondition.FailedAssetFetch)
+              || (this.PrimAssetState == PrimAssetCondition.FailedMeshing) );
+    }
+
+    // The objects base shape information. Null if not a prim type shape.
+    public PrimitiveBaseShape BaseShape { get; protected set; }
+
+    // When the physical properties are updated, an EntityProperty holds the update values.
+    // Keep the current and last EntityProperties to enable computation of differences
+    //      between the current update and the previous values.
+    public EntityProperties CurrentEntityProperties { get; set; }
+    public EntityProperties LastEntityProperties { get; set; }
+
+    public virtual OMV.Vector3 Scale { get; set; }
+
+    // It can be confusing for an actor to know if it should move or update an object
+    //    depeneding on the setting of 'selected', 'physical, ...
+    // This flag is the true test -- if true, the object is being acted on in the physical world
+    public abstract bool IsPhysicallyActive { get; }
+
+    // Detailed state of the object.
+    public abstract bool IsSolid { get; }
+    public abstract bool IsStatic { get; }
+    public abstract bool IsSelected { get; }
+    public abstract bool IsVolumeDetect { get; }
+
+    // Materialness
+    public MaterialAttributes.Material Material { get; private set; }
+    public override void SetMaterial(int material)
+    {
+        Material = (MaterialAttributes.Material)material;
+
+        // Setting the material sets the material attributes also.
+        // TODO: decide if this is necessary -- the simulator does this.
+        MaterialAttributes matAttrib = BSMaterials.GetAttributes(Material, false);
+        Friction = matAttrib.friction;
+        Restitution = matAttrib.restitution;
+        Density = matAttrib.density;
+        // DetailLog("{0},{1}.SetMaterial,Mat={2},frict={3},rest={4},den={5}", LocalID, TypeName, Material, Friction, Restitution, Density);
+    }
+
+    public override float Density
+    {
+        get
+        {
+            return base.Density;
+        }
+        set
+        {
+            DetailLog("{0},BSPhysObject.Density,set,den={1}", LocalID, value);
+            base.Density = value;
+        }
+    }
+
+    // Stop all physical motion.
+    public abstract void ZeroMotion(bool inTaintTime);
+    public abstract void ZeroAngularMotion(bool inTaintTime);
+
+    // Update the physical location and motion of the object. Called with data from Bullet.
+    public abstract void UpdateProperties(EntityProperties entprop);
+
+    public virtual OMV.Vector3 RawPosition { get; set; }
+    public abstract OMV.Vector3 ForcePosition { get; set; }
+
+    public virtual OMV.Quaternion RawOrientation { get; set; }
+    public abstract OMV.Quaternion ForceOrientation { get; set; }
+
+    public virtual OMV.Vector3 RawVelocity { get; set; }
+    public abstract OMV.Vector3 ForceVelocity { get; set; }
+
+    public OMV.Vector3 RawForce { get; set; }
+    public OMV.Vector3 RawTorque { get; set; }
+    public override void AddAngularForce(OMV.Vector3 force, bool pushforce)
+    {
+        AddAngularForce(force, pushforce, false);
+    }
+    public abstract void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime);
+    public abstract void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime);
+
+    public abstract OMV.Vector3 ForceRotationalVelocity { get; set; }
+
+    public abstract float ForceBuoyancy { get; set; }
+
+    public virtual bool ForceBodyShapeRebuild(bool inTaintTime) { return false; }
+
+    public override bool PIDActive 
+    {
+        get { return MoveToTargetActive; }
+        set { MoveToTargetActive = value; } 
+    }
+
+    public override OMV.Vector3 PIDTarget { set { MoveToTargetTarget = value; } }
+    public override float PIDTau { set { MoveToTargetTau = value; } }
+
+    public bool MoveToTargetActive { get; set; }
+    public OMV.Vector3 MoveToTargetTarget { get; set; }
+    public float MoveToTargetTau { get; set; }
+
+    // Used for llSetHoverHeight and maybe vehicle height. Hover Height will override MoveTo target's Z
+    public override bool PIDHoverActive { set { HoverActive = value; } }
+    public override float PIDHoverHeight { set { HoverHeight = value; } }
+    public override PIDHoverType PIDHoverType { set { HoverType = value; } }
+    public override float PIDHoverTau { set { HoverTau = value; } }
+
+    public bool HoverActive { get; set; }
+    public float HoverHeight { get;  set; }
+    public PIDHoverType HoverType { get;  set; }
+    public float HoverTau { get; set; }
+
+    // For RotLookAt
+    public override OMV.Quaternion APIDTarget { set { return; } }
+    public override bool APIDActive { set { return; } }
+    public override float APIDStrength { set { return; } }
+    public override float APIDDamping { set { return; } }
+
+    // The current velocity forward
+    public virtual float ForwardSpeed
+    {
+        get
+        {
+            OMV.Vector3 characterOrientedVelocity = RawVelocity * OMV.Quaternion.Inverse(OMV.Quaternion.Normalize(RawOrientation));
+            return characterOrientedVelocity.X;
+        }
+    }
+    // The forward speed we are trying to achieve (TargetVelocity)
+    public virtual float TargetVelocitySpeed
+    {
+        get
+        {
+            OMV.Vector3 characterOrientedVelocity = TargetVelocity * OMV.Quaternion.Inverse(OMV.Quaternion.Normalize(RawOrientation));
+            return characterOrientedVelocity.X;
+        }
+    }
+
+    // The user can optionally set the center of mass. The user's setting will override any
+    //    computed center-of-mass (like in linksets).
+    // Note this is a displacement from the root's coordinates. Zero means use the root prim as center-of-mass.
+    public OMV.Vector3? UserSetCenterOfMassDisplacement { get; set; }
+
+    public OMV.Vector3 LockedLinearAxis;   // zero means locked. one means free.
+    public OMV.Vector3 LockedAngularAxis;  // zero means locked. one means free.
+    public const float FreeAxis = 1f;
+    public const float LockedAxis = 0f;
+    public readonly OMV.Vector3 LockedAxisFree = new OMV.Vector3(FreeAxis, FreeAxis, FreeAxis);  // All axis are free
+
+    // If an axis is locked (flagged above) then the limits of that axis are specified here.
+    // Linear axis limits are relative to the object's starting coordinates.
+    // Angular limits are limited to -PI to +PI
+    public OMV.Vector3 LockedLinearAxisLow;
+    public OMV.Vector3 LockedLinearAxisHigh;
+    public OMV.Vector3 LockedAngularAxisLow;
+    public OMV.Vector3 LockedAngularAxisHigh;
+
+    // Enable physical actions. Bullet will keep sleeping non-moving physical objects so
+    //     they need waking up when parameters are changed.
+    // Called in taint-time!!
+    public void ActivateIfPhysical(bool forceIt)
+    {
+        if (PhysBody.HasPhysicalBody)
+        {
+            if (IsPhysical)
+            {
+                // Physical objects might need activating
+                PhysScene.PE.Activate(PhysBody, forceIt);
+            }
+            else
+            {
+                // Clear the collision cache since we've changed some properties.
+                PhysScene.PE.ClearCollisionProxyCache(PhysScene.World, PhysBody);
+            }
+        }
+    }
+
+    // 'actors' act on the physical object to change or constrain its motion. These can range from
+    //       hovering to complex vehicle motion.
+    // May be called at non-taint time as this just adds the actor to the action list and the real
+    //    work is done during the simulation step.
+    // Note that, if the actor is already in the list and we are disabling same, the actor is just left
+    //    in the list disabled.
+    public delegate BSActor CreateActor();
+    public void EnableActor(bool enableActor, string actorName, CreateActor creator)
+    {
+        lock (PhysicalActors)
+        {
+            BSActor theActor;
+            if (PhysicalActors.TryGetActor(actorName, out theActor))
+            {
+                // The actor already exists so just turn it on or off
+                DetailLog("{0},BSPhysObject.EnableActor,enablingExistingActor,name={1},enable={2}", LocalID, actorName, enableActor);
+                theActor.Enabled = enableActor;
+            }
+            else
+            {
+                // The actor does not exist. If it should, create it.
+                if (enableActor)
+                {
+                    DetailLog("{0},BSPhysObject.EnableActor,creatingActor,name={1}", LocalID, actorName);
+                    theActor = creator();
+                    PhysicalActors.Add(actorName, theActor);
+                    theActor.Enabled = true;
+                }
+                else
+                {
+                    DetailLog("{0},BSPhysObject.EnableActor,notCreatingActorSinceNotEnabled,name={1}", LocalID, actorName);
+                }
+            }
+        }
+    }
+
+    #region Collisions
+
+    // Requested number of milliseconds between collision events. Zero means disabled.
+    protected int SubscribedEventsMs { get; set; }
+    // Given subscription, the time that a collision may be passed up
+    protected int NextCollisionOkTime { get; set; }
+    // The simulation step that last had a collision
+    protected long CollidingStep { get; set; }
+    // The simulation step that last had a collision with the ground
+    protected long CollidingGroundStep { get; set; }
+    // The simulation step that last collided with an object
+    protected long CollidingObjectStep { get; set; }
+    // The collision flags we think are set in Bullet
+    protected CollisionFlags CurrentCollisionFlags { get; set; }
+    // On a collision, check the collider and remember if the last collider was moving
+    //    Used to modify the standing of avatars (avatars on stationary things stand still)
+    public bool ColliderIsMoving;
+    // 'true' if the last collider was a volume detect object
+    public bool ColliderIsVolumeDetect;
+    // Used by BSCharacter to manage standing (and not slipping)
+    public bool IsStationary;
+
+    // Count of collisions for this object
+    protected long CollisionAccumulation { get; set; }
+
+    public override bool IsColliding {
+        get { return (CollidingStep == PhysScene.SimulationStep); }
+        set {
+            if (value)
+                CollidingStep = PhysScene.SimulationStep;
+            else
+                CollidingStep = BSScene.NotASimulationStep;
+            }
+    }
+    // Complex objects (like linksets) need to know if there is a collision on any part of
+    //    their shape. 'IsColliding' has an existing definition of reporting a collision on
+    //    only this specific prim or component of linksets.
+    // 'HasSomeCollision' is defined as reporting if there is a collision on any part of
+    //    the complex body that this prim is the root of.
+    public virtual bool HasSomeCollision
+    {
+        get { return IsColliding; }
+        set { IsColliding = value; }
+    }
+    public override bool CollidingGround {
+        get { return (CollidingGroundStep == PhysScene.SimulationStep); }
+        set
+        {
+            if (value)
+                CollidingGroundStep = PhysScene.SimulationStep;
+            else
+                CollidingGroundStep = BSScene.NotASimulationStep;
+        }
+    }
+    public override bool CollidingObj {
+        get { return (CollidingObjectStep == PhysScene.SimulationStep); }
+        set {
+            if (value)
+                CollidingObjectStep = PhysScene.SimulationStep;
+            else
+                CollidingObjectStep = BSScene.NotASimulationStep;
+        }
+    }
+
+    // The collisions that have been collected for the next collision reporting (throttled by subscription)
+    protected CollisionEventUpdate CollisionCollection = new CollisionEventUpdate();
+    // This is the collision collection last reported to the Simulator.
+    public CollisionEventUpdate CollisionsLastReported = new CollisionEventUpdate();
+    // Remember the collisions recorded in the last tick for fancy collision checking
+    //     (like a BSCharacter walking up stairs).
+    public CollisionEventUpdate CollisionsLastTick = new CollisionEventUpdate();
+    private long CollisionsLastTickStep = -1;
+
+    // The simulation step is telling this object about a collision.
+    // Return 'true' if a collision was processed and should be sent up.
+    // Return 'false' if this object is not enabled/subscribed/appropriate for or has already seen this collision.
+    // Called at taint time from within the Step() function
+    public delegate bool CollideCall(uint collidingWith, BSPhysObject collidee, OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth);
+    public virtual bool Collide(uint collidingWith, BSPhysObject collidee,
+                    OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
+    {
+        bool ret = false;
+
+        // The following lines make IsColliding(), CollidingGround() and CollidingObj work
+        CollidingStep = PhysScene.SimulationStep;
+        if (collidingWith <= PhysScene.TerrainManager.HighestTerrainID)
+        {
+            CollidingGroundStep = PhysScene.SimulationStep;
+        }
+        else
+        {
+            CollidingObjectStep = PhysScene.SimulationStep;
+        }
+
+        CollisionAccumulation++;
+
+        // For movement tests, remember if we are colliding with an object that is moving.
+        ColliderIsMoving = collidee != null ? (collidee.RawVelocity != OMV.Vector3.Zero) : false;
+        ColliderIsVolumeDetect = collidee != null ? (collidee.IsVolumeDetect) : false;
+
+        // Make a collection of the collisions that happened the last simulation tick.
+        // This is different than the collection created for sending up to the simulator as it is cleared every tick.
+        if (CollisionsLastTickStep != PhysScene.SimulationStep)
+        {
+            CollisionsLastTick = new CollisionEventUpdate();
+            CollisionsLastTickStep = PhysScene.SimulationStep;
+        }
+        CollisionsLastTick.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+
+        // If someone has subscribed for collision events log the collision so it will be reported up
+        if (SubscribedEvents()) {
+            lock (PhysScene.CollisionLock)
+            {
+                CollisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+            }
+            DetailLog("{0},{1}.Collision.AddCollider,call,with={2},point={3},normal={4},depth={5},colliderMoving={6}",
+                            LocalID, TypeName, collidingWith, contactPoint, contactNormal, pentrationDepth, ColliderIsMoving);
+
+            ret = true;
+        }
+        return ret;
+    }
+
+    // Send the collected collisions into the simulator.
+    // Called at taint time from within the Step() function thus no locking problems
+    //      with CollisionCollection and ObjectsWithNoMoreCollisions.
+    // Called with BSScene.CollisionLock locked to protect the collision lists.
+    // Return 'true' if there were some actual collisions passed up
+    public virtual bool SendCollisions()
+    {
+        bool ret = true;
+
+        // If no collisions this call but there were collisions last call, force the collision
+        //     event to be happen right now so quick collision_end.
+        bool force = (CollisionCollection.Count == 0 && CollisionsLastReported.Count != 0);
+
+        // throttle the collisions to the number of milliseconds specified in the subscription
+        if (force || (PhysScene.SimulationNowTime >= NextCollisionOkTime))
+        {
+            NextCollisionOkTime = PhysScene.SimulationNowTime + SubscribedEventsMs;
+
+            // We are called if we previously had collisions. If there are no collisions
+            //   this time, send up one last empty event so OpenSim can sense collision end.
+            if (CollisionCollection.Count == 0)
+            {
+                // If I have no collisions this time, remove me from the list of objects with collisions.
+                ret = false;
+            }
+
+            DetailLog("{0},{1}.SendCollisionUpdate,call,numCollisions={2}", LocalID, TypeName, CollisionCollection.Count);
+            base.SendCollisionUpdate(CollisionCollection);
+
+            // Remember the collisions from this tick for some collision specific processing.
+            CollisionsLastReported = CollisionCollection;
+
+            // The CollisionCollection instance is passed around in the simulator.
+            // Make sure we don't have a handle to that one and that a new one is used for next time.
+            //    This fixes an interesting 'gotcha'. If we call CollisionCollection.Clear() here,
+            //    a race condition is created for the other users of this instance.
+            CollisionCollection = new CollisionEventUpdate();
+        }
+        return ret;
+    }
+
+    // Subscribe for collision events.
+    // Parameter is the millisecond rate the caller wishes collision events to occur.
+    public override void SubscribeEvents(int ms) {
+        // DetailLog("{0},{1}.SubscribeEvents,subscribing,ms={2}", LocalID, TypeName, ms);
+        SubscribedEventsMs = ms;
+        if (ms > 0)
+        {
+            // make sure first collision happens
+            NextCollisionOkTime = Util.EnvironmentTickCountSubtract(SubscribedEventsMs);
+
+            PhysScene.TaintedObject(LocalID, TypeName+".SubscribeEvents", delegate()
+            {
+                if (PhysBody.HasPhysicalBody)
+                    CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+            });
+        }
+        else
+        {
+            // Subscribing for zero or less is the same as unsubscribing
+            UnSubscribeEvents();
+        }
+    }
+    public override void UnSubscribeEvents() {
+        // DetailLog("{0},{1}.UnSubscribeEvents,unsubscribing", LocalID, TypeName);
+        SubscribedEventsMs = 0;
+        PhysScene.TaintedObject(LocalID, TypeName+".UnSubscribeEvents", delegate()
+        {
+            // Make sure there is a body there because sometimes destruction happens in an un-ideal order.
+            if (PhysBody.HasPhysicalBody)
+                CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+        });
+    }
+    // Return 'true' if the simulator wants collision events
+    public override bool SubscribedEvents() {
+        return (SubscribedEventsMs > 0);
+    }
+    // Because 'CollisionScore' is called many times while sorting, it should not be recomputed
+    //    each time called. So this is built to be light weight for each collision and to do
+    //    all the processing when the user asks for the info.
+    public void ComputeCollisionScore()
+    {
+        // Scale the collision count by the time since the last collision.
+        // The "+1" prevents dividing by zero.
+        long timeAgo = PhysScene.SimulationStep - CollidingStep + 1;
+        CollisionScore = CollisionAccumulation / timeAgo;
+    }
+    public override float CollisionScore { get; set; }
+
+    #endregion // Collisions
+
+    #region Per Simulation Step actions
+
+    public BSActorCollection PhysicalActors = new BSActorCollection();
+
+    // When an update to the physical properties happens, this event is fired to let
+    //    different actors to modify the update before it is passed around
+    public delegate void PreUpdatePropertyAction(ref EntityProperties entprop);
+    public event PreUpdatePropertyAction OnPreUpdateProperty;
+    protected void TriggerPreUpdatePropertyAction(ref EntityProperties entprop)
+    {
+        PreUpdatePropertyAction actions = OnPreUpdateProperty;
+        if (actions != null)
+            actions(ref entprop);
+    }
+
+    #endregion // Per Simulation Step actions
+
+    // High performance detailed logging routine used by the physical objects.
+    protected void DetailLog(string msg, params Object[] args)
+    {
+        if (PhysScene.PhysicsLogging.Enabled)
+            PhysScene.DetailLog(msg, args);
+    }
+
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs
new file mode 100644
index 0000000..6f27ac7
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs
@@ -0,0 +1,1895 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Reflection;
+using System.Collections.Generic;
+using System.Xml;
+using log4net;
+using OMV = OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+    [Serializable]
+public class BSPrim : BSPhysObject
+{
+    protected static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+    private static readonly string LogHeader = "[BULLETS PRIM]";
+
+    // _size is what the user passed. Scale is what we pass to the physics engine with the mesh.
+    private OMV.Vector3 _size;  // the multiplier for each mesh dimension as passed by the user
+
+    private bool _grabbed;
+    private bool _isSelected;
+    private bool _isVolumeDetect;
+
+    private float _mass;    // the mass of this object
+    private OMV.Vector3 _acceleration;
+    private int _physicsActorType;
+    private bool _isPhysical;
+    private bool _flying;
+    private bool _setAlwaysRun;
+    private bool _throttleUpdates;
+    private bool _floatOnWater;
+    private OMV.Vector3 _rotationalVelocity;
+    private bool _kinematic;
+    private float _buoyancy;
+
+    private int CrossingFailures { get; set; }
+
+    // Keep a handle to the vehicle actor so it is easy to set parameters on same.
+    public const string VehicleActorName = "BasicVehicle";
+
+    // Parameters for the hover actor
+    public const string HoverActorName = "BSPrim.HoverActor";
+    // Parameters for the axis lock actor
+    public const String LockedAxisActorName = "BSPrim.LockedAxis";
+    // Parameters for the move to target actor
+    public const string MoveToTargetActorName = "BSPrim.MoveToTargetActor";
+    // Parameters for the setForce and setTorque actors
+    public const string SetForceActorName = "BSPrim.SetForceActor";
+    public const string SetTorqueActorName = "BSPrim.SetTorqueActor";
+
+    public BSPrim(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size,
+                       OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
+            : base(parent_scene, localID, primName, "BSPrim")
+    {
+        // m_log.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID);
+        _physicsActorType = (int)ActorTypes.Prim;
+        RawPosition = pos;
+        _size = size;
+        Scale = size;   // prims are the size the user wants them to be (different for BSCharactes).
+        RawOrientation = rotation;
+        _buoyancy = 0f;
+        RawVelocity = OMV.Vector3.Zero;
+        _rotationalVelocity = OMV.Vector3.Zero;
+        BaseShape = pbs;
+        _isPhysical = pisPhysical;
+        _isVolumeDetect = false;
+
+        _mass = CalculateMass();
+
+        DetailLog("{0},BSPrim.constructor,pbs={1}", LocalID, BSScene.PrimitiveBaseShapeToString(pbs));
+        // DetailLog("{0},BSPrim.constructor,call", LocalID);
+        // do the actual object creation at taint time
+        PhysScene.TaintedObject(LocalID, "BSPrim.create", delegate()
+        {
+            // Make sure the object is being created with some sanity.
+            ExtremeSanityCheck(true /* inTaintTime */);
+
+            CreateGeomAndObject(true);
+
+            CurrentCollisionFlags = PhysScene.PE.GetCollisionFlags(PhysBody);
+
+            IsInitialized = true;
+        });
+    }
+
+    // called when this prim is being destroyed and we should free all the resources
+    public override void Destroy()
+    {
+        // m_log.DebugFormat("{0}: Destroy, id={1}", LogHeader, LocalID);
+        IsInitialized = false;
+
+        base.Destroy();
+
+        // Undo any vehicle properties
+        this.VehicleType = (int)Vehicle.TYPE_NONE;
+
+        PhysScene.TaintedObject(LocalID, "BSPrim.Destroy", delegate()
+        {
+            DetailLog("{0},BSPrim.Destroy,taint,", LocalID);
+            // If there are physical body and shape, release my use of same.
+            PhysScene.Shapes.DereferenceBody(PhysBody, null);
+            PhysBody.Clear();
+            PhysShape.Dereference(PhysScene);
+            PhysShape = new BSShapeNull();
+        });
+    }
+
+    // No one uses this property.
+    public override bool Stopped {
+        get { return false; }
+    }
+
+    public override bool IsIncomplete {
+        get {
+            return ShapeRebuildScheduled;
+        }
+    }
+
+    // 'true' if this object's shape is in need of a rebuild and a rebuild has been queued.
+    // The prim is still available but its underlying shape will change soon.
+    // This is protected by a 'lock(this)'.
+    public bool ShapeRebuildScheduled { get; protected set; }
+
+    public override OMV.Vector3 Size {
+        get { return _size; }
+        set {
+            // We presume the scale and size are the same. If scale must be changed for
+            //     the physical shape, that is done when the geometry is built.
+            _size = value;
+            Scale = _size;
+            ForceBodyShapeRebuild(false);
+        }
+    }
+
+    public override PrimitiveBaseShape Shape {
+        set {
+            BaseShape = value;
+            DetailLog("{0},BSPrim.changeShape,pbs={1}", LocalID, BSScene.PrimitiveBaseShapeToString(BaseShape));
+            PrimAssetState = PrimAssetCondition.Unknown;
+            ForceBodyShapeRebuild(false);
+        }
+    }
+    // Cause the body and shape of the prim to be rebuilt if necessary.
+    // If there are no changes required, this is quick and does not make changes to the prim.
+    // If rebuilding is necessary (like changing from static to physical), that will happen.
+    // The 'ShapeRebuildScheduled' tells any checker that the body/shape may change shortly.
+    // The return parameter is not used by anyone.
+    public override bool ForceBodyShapeRebuild(bool inTaintTime)
+    {
+        if (inTaintTime)
+        {
+            // If called in taint time, do the operation immediately
+            _mass = CalculateMass();   // changing the shape changes the mass
+            CreateGeomAndObject(true);
+        }
+        else
+        {
+            lock (this)
+            {
+                // If a rebuild is not already in the queue
+                if (!ShapeRebuildScheduled)
+                {
+                    // Remember that a rebuild is queued -- this is used to flag an incomplete object
+                    ShapeRebuildScheduled = true;
+                    PhysScene.TaintedObject(LocalID, "BSPrim.ForceBodyShapeRebuild", delegate()
+                    {
+                        _mass = CalculateMass();   // changing the shape changes the mass
+                        CreateGeomAndObject(true);
+                        ShapeRebuildScheduled = false;
+                    });
+                }
+            }
+        }
+        return true;
+    }
+    public override bool Grabbed {
+        set { _grabbed = value;
+        }
+    }
+    public override bool Selected {
+        set
+        {
+            if (value != _isSelected)
+            {
+                _isSelected = value;
+                PhysScene.TaintedObject(LocalID, "BSPrim.setSelected", delegate()
+                {
+                    DetailLog("{0},BSPrim.selected,taint,selected={1}", LocalID, _isSelected);
+                    SetObjectDynamic(false);
+                });
+            }
+        }
+    }
+    public override bool IsSelected
+    {
+        get { return _isSelected; }
+    }
+
+    public override void CrossingFailure()
+    {
+        CrossingFailures++;
+        if (CrossingFailures > BSParam.CrossingFailuresBeforeOutOfBounds)
+        {
+            base.RaiseOutOfBounds(RawPosition);
+        }
+        else if (CrossingFailures == BSParam.CrossingFailuresBeforeOutOfBounds)
+        {
+            m_log.WarnFormat("{0} Too many crossing failures for {1}", LogHeader, Name);
+        }
+        return;
+    }
+
+    // link me to the specified parent
+    public override void link(PhysicsActor obj) {
+    }
+
+    // delink me from my linkset
+    public override void delink() {
+    }
+
+    // Set motion values to zero.
+    // Do it to the properties so the values get set in the physics engine.
+    // Push the setting of the values to the viewer.
+    // Called at taint time!
+    public override void ZeroMotion(bool inTaintTime)
+    {
+        RawVelocity = OMV.Vector3.Zero;
+        _acceleration = OMV.Vector3.Zero;
+        _rotationalVelocity = OMV.Vector3.Zero;
+
+        // Zero some other properties in the physics engine
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ZeroMotion", delegate()
+        {
+            if (PhysBody.HasPhysicalBody)
+                PhysScene.PE.ClearAllForces(PhysBody);
+        });
+    }
+    public override void ZeroAngularMotion(bool inTaintTime)
+    {
+        _rotationalVelocity = OMV.Vector3.Zero;
+        // Zero some other properties in the physics engine
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ZeroMotion", delegate()
+        {
+            // DetailLog("{0},BSPrim.ZeroAngularMotion,call,rotVel={1}", LocalID, _rotationalVelocity);
+            if (PhysBody.HasPhysicalBody)
+            {
+                PhysScene.PE.SetInterpolationAngularVelocity(PhysBody, _rotationalVelocity);
+                PhysScene.PE.SetAngularVelocity(PhysBody, _rotationalVelocity);
+            }
+        });
+    }
+
+    public override void LockAngularMotion(OMV.Vector3 axis)
+    {
+        DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis);
+
+        ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR, 0f, 0f);
+        if (axis.X != 1)
+        {
+            ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_X, 0f, 0f);
+        }
+        if (axis.Y != 1)
+        {
+            ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Y, 0f, 0f);
+        }
+        if (axis.Z != 1)
+        {
+            ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Z, 0f, 0f);
+        }
+
+        InitializeAxisActor();
+
+        return;
+    }
+
+    public override OMV.Vector3 Position {
+        get {
+            // don't do the GetObjectPosition for root elements because this function is called a zillion times.
+            // RawPosition = ForcePosition;
+            return RawPosition;
+        }
+        set {
+            // If the position must be forced into the physics engine, use ForcePosition.
+            // All positions are given in world positions.
+            if (RawPosition == value)
+            {
+                DetailLog("{0},BSPrim.setPosition,call,positionNotChanging,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
+                return;
+            }
+            RawPosition = value;
+            PositionSanityCheck(false);
+
+            PhysScene.TaintedObject(LocalID, "BSPrim.setPosition", delegate()
+            {
+                DetailLog("{0},BSPrim.SetPosition,taint,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
+                ForcePosition = RawPosition;
+            });
+        }
+    }
+
+    // NOTE: overloaded by BSPrimDisplaced to handle offset for center-of-gravity.
+    public override OMV.Vector3 ForcePosition {
+        get {
+            RawPosition = PhysScene.PE.GetPosition(PhysBody);
+            return RawPosition;
+        }
+        set {
+            RawPosition = value;
+            if (PhysBody.HasPhysicalBody)
+            {
+                PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
+                ActivateIfPhysical(false);
+            }
+        }
+    }
+
+    // Check that the current position is sane and, if not, modify the position to make it so.
+    // Check for being below terrain and being out of bounds.
+    // Returns 'true' of the position was made sane by some action.
+    private bool PositionSanityCheck(bool inTaintTime)
+    {
+        bool ret = false;
+
+        // We don't care where non-physical items are placed
+        if (!IsPhysicallyActive)
+            return ret;
+
+        if (!PhysScene.TerrainManager.IsWithinKnownTerrain(RawPosition))
+        {
+            // The physical object is out of the known/simulated area.
+            // Upper levels of code will handle the transition to other areas so, for
+            //     the time, we just ignore the position.
+            return ret;
+        }
+
+        float terrainHeight = PhysScene.TerrainManager.GetTerrainHeightAtXYZ(RawPosition);
+        OMV.Vector3 upForce = OMV.Vector3.Zero;
+        float approxSize = Math.Max(Size.X, Math.Max(Size.Y, Size.Z));
+        if ((RawPosition.Z + approxSize / 2f) < terrainHeight)
+        {
+            DetailLog("{0},BSPrim.PositionAdjustUnderGround,call,pos={1},terrain={2}", LocalID, RawPosition, terrainHeight);
+            float targetHeight = terrainHeight + (Size.Z / 2f);
+            // If the object is below ground it just has to be moved up because pushing will
+            //     not get it through the terrain
+            RawPosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, targetHeight);
+            if (inTaintTime)
+            {
+                ForcePosition = RawPosition;
+            }
+            // If we are throwing the object around, zero its other forces
+            ZeroMotion(inTaintTime);
+            ret = true;
+        }
+
+        if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0)
+        {
+            float waterHeight = PhysScene.TerrainManager.GetWaterLevelAtXYZ(RawPosition);
+            // TODO: a floating motor so object will bob in the water
+            if (Math.Abs(RawPosition.Z - waterHeight) > 0.1f)
+            {
+                // Upforce proportional to the distance away from the water. Correct the error in 1 sec.
+                upForce.Z = (waterHeight - RawPosition.Z) * 1f;
+
+                // Apply upforce and overcome gravity.
+                OMV.Vector3 correctionForce = upForce - PhysScene.DefaultGravity;
+                DetailLog("{0},BSPrim.PositionSanityCheck,applyForce,pos={1},upForce={2},correctionForce={3}", LocalID, RawPosition, upForce, correctionForce);
+                AddForce(correctionForce, false, inTaintTime);
+                ret = true;
+            }
+        }
+
+        return ret;
+    }
+
+    // Occasionally things will fly off and really get lost.
+    // Find the wanderers and bring them back.
+    // Return 'true' if some parameter need some sanity.
+    private bool ExtremeSanityCheck(bool inTaintTime)
+    {
+        bool ret = false;
+
+        int wayOverThere = -1000;
+        int wayOutThere = 10000;
+        // There have been instances of objects getting thrown way out of bounds and crashing
+        //    the border crossing code.
+        if (   RawPosition.X < wayOverThere || RawPosition.X > wayOutThere
+            || RawPosition.Y < wayOverThere || RawPosition.X > wayOutThere
+            || RawPosition.Z < wayOverThere || RawPosition.X > wayOutThere)
+        {
+            RawPosition = new OMV.Vector3(10, 10, 50);
+            ZeroMotion(inTaintTime);
+            ret = true;
+        }
+        if (RawVelocity.LengthSquared() > BSParam.MaxLinearVelocitySquared)
+        {
+            RawVelocity = Util.ClampV(RawVelocity, BSParam.MaxLinearVelocity);
+            ret = true;
+        }
+        if (_rotationalVelocity.LengthSquared() > BSParam.MaxAngularVelocitySquared)
+        {
+            _rotationalVelocity = Util.ClampV(_rotationalVelocity, BSParam.MaxAngularVelocity);
+            ret = true;
+        }
+
+        return ret;
+    }
+
+    // Return the effective mass of the object.
+        // The definition of this call is to return the mass of the prim.
+        // If the simulator cares about the mass of the linkset, it will sum it itself.
+    public override float Mass
+    {
+        get { return _mass; }
+    }
+    // TotalMass returns the mass of the large object the prim may be in (overridden by linkset code)
+    public virtual float TotalMass
+    {
+        get { return _mass; }
+    }
+    // used when we only want this prim's mass and not the linkset thing
+    public override float RawMass {
+        get { return _mass; }
+    }
+    // Set the physical mass to the passed mass.
+    // Note that this does not change _mass!
+    public override void UpdatePhysicalMassProperties(float physMass, bool inWorld)
+    {
+        if (PhysBody.HasPhysicalBody && PhysShape.HasPhysicalShape)
+        {
+            if (IsStatic)
+            {
+                PhysScene.PE.SetGravity(PhysBody, PhysScene.DefaultGravity);
+                Inertia = OMV.Vector3.Zero;
+                PhysScene.PE.SetMassProps(PhysBody, 0f, Inertia);
+                PhysScene.PE.UpdateInertiaTensor(PhysBody);
+            }
+            else
+            {
+                if (inWorld)
+                {
+                    // Changing interesting properties doesn't change proxy and collision cache
+                    //    information. The Bullet solution is to re-add the object to the world
+                    //    after parameters are changed.
+                    PhysScene.PE.RemoveObjectFromWorld(PhysScene.World, PhysBody);
+                }
+
+                // The computation of mass props requires gravity to be set on the object.
+                Gravity = ComputeGravity(Buoyancy);
+                PhysScene.PE.SetGravity(PhysBody, Gravity);
+
+                // OMV.Vector3 currentScale = PhysScene.PE.GetLocalScaling(PhysShape.physShapeInfo);   // DEBUG DEBUG
+                // DetailLog("{0},BSPrim.UpdateMassProperties,currentScale{1},shape={2}", LocalID, currentScale, PhysShape.physShapeInfo);   // DEBUG DEBUG
+
+                Inertia = PhysScene.PE.CalculateLocalInertia(PhysShape.physShapeInfo, physMass);
+                PhysScene.PE.SetMassProps(PhysBody, physMass, Inertia);
+                PhysScene.PE.UpdateInertiaTensor(PhysBody);
+
+                DetailLog("{0},BSPrim.UpdateMassProperties,mass={1},localInertia={2},grav={3},inWorld={4}",
+                                            LocalID, physMass, Inertia, Gravity, inWorld);
+
+                if (inWorld)
+                {
+                    AddObjectToPhysicalWorld();
+                }
+            }
+        }
+    }
+
+    // Return what gravity should be set to this very moment
+    public OMV.Vector3 ComputeGravity(float buoyancy)
+    {
+        OMV.Vector3 ret = PhysScene.DefaultGravity;
+
+        if (!IsStatic)
+        {
+            ret *= (1f - buoyancy);
+            ret *= GravModifier;
+        }
+
+        return ret;
+    }
+
+    // Is this used?
+    public override OMV.Vector3 CenterOfMass
+    {
+        get { return RawPosition; }
+    }
+
+    // Is this used?
+    public override OMV.Vector3 GeometricCenter
+    {
+        get { return RawPosition; }
+    }
+
+    public override OMV.Vector3 Force {
+        get { return RawForce; }
+        set {
+            RawForce = value;
+            EnableActor(RawForce != OMV.Vector3.Zero, SetForceActorName, delegate()
+            {
+                return new BSActorSetForce(PhysScene, this, SetForceActorName);
+            });
+
+            // Call update so actor Refresh() is called to start things off
+            PhysScene.TaintedObject(LocalID, "BSPrim.setForce", delegate()
+            {
+                UpdatePhysicalParameters();
+            });
+        }
+    }
+
+    // Find and return a handle to the current vehicle actor.
+    // Return 'null' if there is no vehicle actor.
+    public BSDynamics GetVehicleActor(bool createIfNone)
+    {
+        BSDynamics ret = null;
+        BSActor actor;
+        if (PhysicalActors.TryGetActor(VehicleActorName, out actor))
+        {
+            ret = actor as BSDynamics;
+        }
+        else
+        {
+            if (createIfNone)
+            {
+                ret = new BSDynamics(PhysScene, this, VehicleActorName);
+                PhysicalActors.Add(ret.ActorName, ret);
+            }
+        }
+        return ret;
+    }
+
+    public override int VehicleType {
+        get {
+            int ret = (int)Vehicle.TYPE_NONE;
+            BSDynamics vehicleActor = GetVehicleActor(false /* createIfNone */);
+            if (vehicleActor != null)
+                ret = (int)vehicleActor.Type;
+            return ret;
+        }
+        set {
+            Vehicle type = (Vehicle)value;
+
+            PhysScene.TaintedObject(LocalID, "setVehicleType", delegate()
+            {
+                // Some vehicle scripts change vehicle type on the fly as an easy way to
+                //    change all the parameters. Like a plane changing to CAR when on the
+                //    ground. In this case, don't want to zero motion.
+                // ZeroMotion(true /* inTaintTime */);
+                if (type == Vehicle.TYPE_NONE)
+                {
+                    // Vehicle type is 'none' so get rid of any actor that may have been allocated.
+                    BSDynamics vehicleActor = GetVehicleActor(false /* createIfNone */);
+                    if (vehicleActor != null)
+                    {
+                        PhysicalActors.RemoveAndRelease(vehicleActor.ActorName);
+                    }
+                }
+                else
+                {
+                    // Vehicle type is not 'none' so create an actor and set it running.
+                    BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+                    if (vehicleActor != null)
+                    {
+                        vehicleActor.ProcessTypeChange(type);
+                        ActivateIfPhysical(false);
+                    }
+                }
+            });
+        }
+    }
+    public override void VehicleFloatParam(int param, float value)
+    {
+        PhysScene.TaintedObject(LocalID, "BSPrim.VehicleFloatParam", delegate()
+        {
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+            if (vehicleActor != null)
+            {
+                vehicleActor.ProcessFloatVehicleParam((Vehicle)param, value);
+                ActivateIfPhysical(false);
+            }
+        });
+    }
+    public override void VehicleVectorParam(int param, OMV.Vector3 value)
+    {
+        PhysScene.TaintedObject(LocalID, "BSPrim.VehicleVectorParam", delegate()
+        {
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+            if (vehicleActor != null)
+            {
+                vehicleActor.ProcessVectorVehicleParam((Vehicle)param, value);
+                ActivateIfPhysical(false);
+            }
+        });
+    }
+    public override void VehicleRotationParam(int param, OMV.Quaternion rotation)
+    {
+        PhysScene.TaintedObject(LocalID, "BSPrim.VehicleRotationParam", delegate()
+        {
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+            if (vehicleActor != null)
+            {
+                vehicleActor.ProcessRotationVehicleParam((Vehicle)param, rotation);
+                ActivateIfPhysical(false);
+            }
+        });
+    }
+    public override void VehicleFlags(int param, bool remove)
+    {
+        PhysScene.TaintedObject(LocalID, "BSPrim.VehicleFlags", delegate()
+        {
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+            if (vehicleActor != null)
+            {
+                vehicleActor.ProcessVehicleFlags(param, remove);
+            }
+        });
+    }
+
+    // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more
+    public override void SetVolumeDetect(int param) {
+        bool newValue = (param != 0);
+        if (_isVolumeDetect != newValue)
+        {
+            _isVolumeDetect = newValue;
+            PhysScene.TaintedObject(LocalID, "BSPrim.SetVolumeDetect", delegate()
+            {
+                // DetailLog("{0},setVolumeDetect,taint,volDetect={1}", LocalID, _isVolumeDetect);
+                SetObjectDynamic(true);
+            });
+        }
+        return;
+    }
+    public override bool IsVolumeDetect
+    {
+        get { return _isVolumeDetect; }
+    }
+    public override void SetMaterial(int material)
+    {
+        base.SetMaterial(material);
+        PhysScene.TaintedObject(LocalID, "BSPrim.SetMaterial", delegate()
+        {
+            UpdatePhysicalParameters();
+        });
+    }
+    public override float Friction
+    {
+        get { return base.Friction; }
+        set
+        {
+            if (base.Friction != value)
+            {
+                base.Friction = value;
+                PhysScene.TaintedObject(LocalID, "BSPrim.setFriction", delegate()
+                {
+                    UpdatePhysicalParameters();
+                });
+            }
+        }
+    }
+    public override float Restitution
+    {
+        get { return base.Restitution; }
+        set
+        {
+            if (base.Restitution != value)
+            {
+                base.Restitution = value;
+                PhysScene.TaintedObject(LocalID, "BSPrim.setRestitution", delegate()
+                {
+                    UpdatePhysicalParameters();
+                });
+            }
+        }
+    }
+    // The simulator/viewer keep density as 100kg/m3.
+    // Remember to use BSParam.DensityScaleFactor to create the physical density.
+    public override float Density
+    {
+        get { return base.Density; }
+        set
+        {
+            if (base.Density != value)
+            {
+                base.Density = value;
+                PhysScene.TaintedObject(LocalID, "BSPrim.setDensity", delegate()
+                {
+                    UpdatePhysicalParameters();
+                });
+            }
+        }
+    }
+    public override float GravModifier
+    {
+        get { return base.GravModifier; }
+        set
+        {
+            if (base.GravModifier != value)
+            {
+                base.GravModifier = value;
+                PhysScene.TaintedObject(LocalID, "BSPrim.setGravityModifier", delegate()
+                {
+                    UpdatePhysicalParameters();
+                });
+            }
+        }
+    }
+    public override OMV.Vector3 Velocity {
+        get { return RawVelocity; }
+        set {
+            RawVelocity = value;
+            PhysScene.TaintedObject(LocalID, "BSPrim.setVelocity", delegate()
+            {
+                // DetailLog("{0},BSPrim.SetVelocity,taint,vel={1}", LocalID, RawVelocity);
+                ForceVelocity = RawVelocity;
+            });
+        }
+    }
+    public override OMV.Vector3 ForceVelocity {
+        get { return RawVelocity; }
+        set {
+            PhysScene.AssertInTaintTime("BSPrim.ForceVelocity");
+
+            RawVelocity = Util.ClampV(value, BSParam.MaxLinearVelocity);
+            if (PhysBody.HasPhysicalBody)
+            {
+                DetailLog("{0},BSPrim.ForceVelocity,taint,vel={1}", LocalID, RawVelocity);
+                PhysScene.PE.SetLinearVelocity(PhysBody, RawVelocity);
+                ActivateIfPhysical(false);
+            }
+        }
+    }
+    public override OMV.Vector3 Torque {
+        get { return RawTorque; }
+        set {
+            RawTorque = value;
+            EnableActor(RawTorque != OMV.Vector3.Zero, SetTorqueActorName, delegate()
+            {
+                return new BSActorSetTorque(PhysScene, this, SetTorqueActorName);
+            });
+            DetailLog("{0},BSPrim.SetTorque,call,torque={1}", LocalID, RawTorque);
+
+            // Call update so actor Refresh() is called to start things off
+            PhysScene.TaintedObject(LocalID, "BSPrim.setTorque", delegate()
+            {
+                UpdatePhysicalParameters();
+            });
+        }
+    }
+    public override OMV.Vector3 Acceleration {
+        get { return _acceleration; }
+        set { _acceleration = value; }
+    }
+
+    public override OMV.Quaternion Orientation {
+        get {
+            return RawOrientation;
+        }
+        set {
+            if (RawOrientation == value)
+                return;
+            RawOrientation = value;
+
+            PhysScene.TaintedObject(LocalID, "BSPrim.setOrientation", delegate()
+            {
+                ForceOrientation = RawOrientation;
+            });
+        }
+    }
+    // Go directly to Bullet to get/set the value.
+    public override OMV.Quaternion ForceOrientation
+    {
+        get
+        {
+            RawOrientation = PhysScene.PE.GetOrientation(PhysBody);
+            return RawOrientation;
+        }
+        set
+        {
+            RawOrientation = value;
+            if (PhysBody.HasPhysicalBody)
+                PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
+        }
+    }
+    public override int PhysicsActorType {
+        get { return _physicsActorType; }
+        set { _physicsActorType = value; }
+    }
+    public override bool IsPhysical {
+        get { return _isPhysical; }
+        set {
+            if (_isPhysical != value)
+            {
+                _isPhysical = value;
+                PhysScene.TaintedObject(LocalID, "BSPrim.setIsPhysical", delegate()
+                {
+                    DetailLog("{0},setIsPhysical,taint,isPhys={1}", LocalID, _isPhysical);
+                    SetObjectDynamic(true);
+                    // whether phys-to-static or static-to-phys, the object is not moving.
+                    ZeroMotion(true);
+
+                });
+            }
+        }
+    }
+
+    // An object is static (does not move) if selected or not physical
+    public override bool IsStatic
+    {
+        get { return _isSelected || !IsPhysical; }
+    }
+
+    // An object is solid if it's not phantom and if it's not doing VolumeDetect
+    public override bool IsSolid
+    {
+        get { return !IsPhantom && !_isVolumeDetect; }
+    }
+
+    // The object is moving and is actively being dynamic in the physical world
+    public override bool IsPhysicallyActive
+    {
+        get { return !_isSelected && IsPhysical; }
+    }
+
+    // Make gravity work if the object is physical and not selected
+    // Called at taint-time!!
+    private void SetObjectDynamic(bool forceRebuild)
+    {
+        // Recreate the physical object if necessary
+        CreateGeomAndObject(forceRebuild);
+    }
+
+    // Convert the simulator's physical properties into settings on BulletSim objects.
+    // There are four flags we're interested in:
+    //     IsStatic: Object does not move, otherwise the object has mass and moves
+    //     isSolid: other objects bounce off of this object
+    //     isVolumeDetect: other objects pass through but can generate collisions
+    //     collisionEvents: whether this object returns collision events
+    // NOTE: overloaded by BSPrimLinkable to also update linkset physical parameters.
+    public virtual void UpdatePhysicalParameters()
+    {
+        if (!PhysBody.HasPhysicalBody)
+        {
+            // This would only happen if updates are called for during initialization when the body is not set up yet.
+            // DetailLog("{0},BSPrim.UpdatePhysicalParameters,taint,calledWithNoPhysBody", LocalID);
+            return;
+        }
+
+        // Mangling all the physical properties requires the object not be in the physical world.
+        // This is a NOOP if the object is not in the world (BulletSim and Bullet ignore objects not found).
+        PhysScene.PE.RemoveObjectFromWorld(PhysScene.World, PhysBody);
+
+        // Set up the object physicalness (does gravity and collisions move this object)
+        MakeDynamic(IsStatic);
+
+        // Update vehicle specific parameters (after MakeDynamic() so can change physical parameters)
+        PhysicalActors.Refresh();
+
+        // Arrange for collision events if the simulator wants them
+        EnableCollisions(SubscribedEvents());
+
+        // Make solid or not (do things bounce off or pass through this object).
+        MakeSolid(IsSolid);
+
+        AddObjectToPhysicalWorld();
+
+        // Rebuild its shape
+        PhysScene.PE.UpdateSingleAabb(PhysScene.World, PhysBody);
+
+        DetailLog("{0},BSPrim.UpdatePhysicalParameters,taintExit,static={1},solid={2},mass={3},collide={4},cf={5:X},cType={6},body={7},shape={8}",
+                                    LocalID, IsStatic, IsSolid, Mass, SubscribedEvents(),
+                                    CurrentCollisionFlags, PhysBody.collisionType, PhysBody, PhysShape);
+    }
+
+    // "Making dynamic" means changing to and from static.
+    // When static, gravity does not effect the object and it is fixed in space.
+    // When dynamic, the object can fall and be pushed by others.
+    // This is independent of its 'solidness' which controls what passes through
+    //    this object and what interacts with it.
+    protected virtual void MakeDynamic(bool makeStatic)
+    {
+        if (makeStatic)
+        {
+            // Become a Bullet 'static' object type
+            CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_STATIC_OBJECT);
+            // Stop all movement
+            ZeroMotion(true);
+
+            // Set various physical properties so other object interact properly
+            PhysScene.PE.SetFriction(PhysBody, Friction);
+            PhysScene.PE.SetRestitution(PhysBody, Restitution);
+            PhysScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
+
+            // Mass is zero which disables a bunch of physics stuff in Bullet
+            UpdatePhysicalMassProperties(0f, false);
+            // Set collision detection parameters
+            if (BSParam.CcdMotionThreshold > 0f)
+            {
+                PhysScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
+                PhysScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
+            }
+
+            // The activation state is 'disabled' so Bullet will not try to act on it.
+            // PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.DISABLE_SIMULATION);
+            // Start it out sleeping and physical actions could wake it up.
+            PhysScene.PE.ForceActivationState(PhysBody, ActivationState.ISLAND_SLEEPING);
+
+            // This collides like a static object
+            PhysBody.collisionType = CollisionType.Static;
+        }
+        else
+        {
+            // Not a Bullet static object
+            CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.CF_STATIC_OBJECT);
+
+            // Set various physical properties so other object interact properly
+            PhysScene.PE.SetFriction(PhysBody, Friction);
+            PhysScene.PE.SetRestitution(PhysBody, Restitution);
+            // DetailLog("{0},BSPrim.MakeDynamic,frict={1},rest={2}", LocalID, Friction, Restitution);
+
+            // per http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=3382
+            // Since this can be called multiple times, only zero forces when becoming physical
+            // PhysicsScene.PE.ClearAllForces(BSBody);
+
+            // For good measure, make sure the transform is set through to the motion state
+            ForcePosition = RawPosition;
+            ForceVelocity = RawVelocity;
+            ForceRotationalVelocity = _rotationalVelocity;
+
+            // A dynamic object has mass
+            UpdatePhysicalMassProperties(RawMass, false);
+
+            // Set collision detection parameters
+            if (BSParam.CcdMotionThreshold > 0f)
+            {
+                PhysScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
+                PhysScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
+            }
+
+            // Various values for simulation limits
+            PhysScene.PE.SetDamping(PhysBody, BSParam.LinearDamping, BSParam.AngularDamping);
+            PhysScene.PE.SetDeactivationTime(PhysBody, BSParam.DeactivationTime);
+            PhysScene.PE.SetSleepingThresholds(PhysBody, BSParam.LinearSleepingThreshold, BSParam.AngularSleepingThreshold);
+            PhysScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
+
+            // This collides like an object.
+            PhysBody.collisionType = CollisionType.Dynamic;
+
+            // Force activation of the object so Bullet will act on it.
+            // Must do the ForceActivationState2() to overcome the DISABLE_SIMULATION from static objects.
+            PhysScene.PE.ForceActivationState(PhysBody, ActivationState.ACTIVE_TAG);
+        }
+    }
+
+    // "Making solid" means that other object will not pass through this object.
+    // To make transparent, we create a Bullet ghost object.
+    // Note: This expects to be called from the UpdatePhysicalParameters() routine as
+    //     the functions after this one set up the state of a possibly newly created collision body.
+    private void MakeSolid(bool makeSolid)
+    {
+        CollisionObjectTypes bodyType = (CollisionObjectTypes)PhysScene.PE.GetBodyType(PhysBody);
+        if (makeSolid)
+        {
+            // Verify the previous code created the correct shape for this type of thing.
+            if ((bodyType & CollisionObjectTypes.CO_RIGID_BODY) == 0)
+            {
+                m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for solidity. id={1}, type={2}", LogHeader, LocalID, bodyType);
+            }
+            CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
+        }
+        else
+        {
+            if ((bodyType & CollisionObjectTypes.CO_GHOST_OBJECT) == 0)
+            {
+                m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for non-solidness. id={1}, type={2}", LogHeader, LocalID, bodyType);
+            }
+            CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
+
+            // Change collision info from a static object to a ghosty collision object
+            PhysBody.collisionType = CollisionType.VolumeDetect;
+        }
+    }
+
+    // Turn on or off the flag controlling whether collision events are returned to the simulator.
+    private void EnableCollisions(bool wantsCollisionEvents)
+    {
+        if (wantsCollisionEvents)
+        {
+            CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+        }
+        else
+        {
+            CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+        }
+    }
+
+    // Add me to the physical world.
+    // Object MUST NOT already be in the world.
+    // This routine exists because some assorted properties get mangled by adding to the world.
+    internal void AddObjectToPhysicalWorld()
+    {
+        if (PhysBody.HasPhysicalBody)
+        {
+            PhysScene.PE.AddObjectToWorld(PhysScene.World, PhysBody);
+        }
+        else
+        {
+            m_log.ErrorFormat("{0} Attempt to add physical object without body. id={1}", LogHeader, LocalID);
+            DetailLog("{0},BSPrim.AddObjectToPhysicalWorld,addObjectWithoutBody,cType={1}", LocalID, PhysBody.collisionType);
+        }
+    }
+
+    // prims don't fly
+    public override bool Flying {
+        get { return _flying; }
+        set {
+            _flying = value;
+        }
+    }
+    public override bool SetAlwaysRun {
+        get { return _setAlwaysRun; }
+        set { _setAlwaysRun = value; }
+    }
+    public override bool ThrottleUpdates {
+        get { return _throttleUpdates; }
+        set { _throttleUpdates = value; }
+    }
+    public bool IsPhantom {
+        get {
+            // SceneObjectPart removes phantom objects from the physics scene
+            // so, although we could implement touching and such, we never
+            // are invoked as a phantom object
+            return false;
+        }
+    }
+    public override bool FloatOnWater {
+        set {
+            _floatOnWater = value;
+            PhysScene.TaintedObject(LocalID, "BSPrim.setFloatOnWater", delegate()
+            {
+                if (_floatOnWater)
+                    CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
+                else
+                    CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
+            });
+        }
+    }
+    public override OMV.Vector3 RotationalVelocity {
+        get {
+            return _rotationalVelocity;
+        }
+        set {
+            _rotationalVelocity = value;
+            Util.ClampV(_rotationalVelocity, BSParam.MaxAngularVelocity);
+            // m_log.DebugFormat("{0}: RotationalVelocity={1}", LogHeader, _rotationalVelocity);
+            PhysScene.TaintedObject(LocalID, "BSPrim.setRotationalVelocity", delegate()
+            {
+                ForceRotationalVelocity = _rotationalVelocity;
+            });
+        }
+    }
+    public override OMV.Vector3 ForceRotationalVelocity {
+        get {
+            return _rotationalVelocity;
+        }
+        set {
+            _rotationalVelocity = Util.ClampV(value, BSParam.MaxAngularVelocity);
+            if (PhysBody.HasPhysicalBody)
+            {
+                DetailLog("{0},BSPrim.ForceRotationalVel,taint,rotvel={1}", LocalID, _rotationalVelocity);
+                PhysScene.PE.SetAngularVelocity(PhysBody, _rotationalVelocity);
+                // PhysicsScene.PE.SetInterpolationAngularVelocity(PhysBody, _rotationalVelocity);
+                ActivateIfPhysical(false);
+            }
+        }
+    }
+    public override bool Kinematic {
+        get { return _kinematic; }
+        set { _kinematic = value;
+            // m_log.DebugFormat("{0}: Kinematic={1}", LogHeader, _kinematic);
+        }
+    }
+    public override float Buoyancy {
+        get { return _buoyancy; }
+        set {
+            _buoyancy = value;
+            PhysScene.TaintedObject(LocalID, "BSPrim.setBuoyancy", delegate()
+            {
+                ForceBuoyancy = _buoyancy;
+            });
+        }
+    }
+    public override float ForceBuoyancy {
+        get { return _buoyancy; }
+        set {
+            _buoyancy = value;
+            // DetailLog("{0},BSPrim.setForceBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
+            // Force the recalculation of the various inertia,etc variables in the object
+            UpdatePhysicalMassProperties(RawMass, true);
+            DetailLog("{0},BSPrim.ForceBuoyancy,buoy={1},mass={2},grav={3}", LocalID, _buoyancy, RawMass, Gravity);
+            ActivateIfPhysical(false);
+        }
+    }
+
+    public override bool PIDActive 
+    {
+        get
+        {
+            return MoveToTargetActive;
+        }
+
+        set 
+        {
+            MoveToTargetActive = value;
+
+            EnableActor(MoveToTargetActive, MoveToTargetActorName, delegate()
+            {
+                return new BSActorMoveToTarget(PhysScene, this, MoveToTargetActorName);
+            });
+
+            // Call update so actor Refresh() is called to start things off
+            PhysScene.TaintedObject(LocalID, "BSPrim.PIDActive", delegate()
+            {
+                UpdatePhysicalParameters();
+            });
+        }
+    }
+
+    public override OMV.Vector3 PIDTarget
+    {
+        set
+        {
+            base.PIDTarget = value;
+            BSActor actor;
+            if (PhysicalActors.TryGetActor(MoveToTargetActorName, out actor))
+            {
+                // if the actor exists, tell it to refresh its values.
+                actor.Refresh();
+            }
+            
+        }
+    }
+    // Used for llSetHoverHeight and maybe vehicle height
+    // Hover Height will override MoveTo target's Z
+    public override bool PIDHoverActive {
+        set {
+            base.HoverActive = value;
+            EnableActor(HoverActive, HoverActorName, delegate()
+            {
+                return new BSActorHover(PhysScene, this, HoverActorName);
+            });
+
+            // Call update so actor Refresh() is called to start things off
+            PhysScene.TaintedObject(LocalID, "BSPrim.PIDHoverActive", delegate()
+            {
+                UpdatePhysicalParameters();
+            });
+        }
+    }
+
+    public override void AddForce(OMV.Vector3 force, bool pushforce) {
+        // Per documentation, max force is limited.
+        OMV.Vector3 addForce = Util.ClampV(force, BSParam.MaxAddForceMagnitude);
+
+        // Since this force is being applied in only one step, make this a force per second.
+        addForce /= PhysScene.LastTimeStep;
+        AddForce(addForce, pushforce, false /* inTaintTime */);
+    }
+
+    // Applying a force just adds this to the total force on the object.
+    // This added force will only last the next simulation tick.
+    public override void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
+        // for an object, doesn't matter if force is a pushforce or not
+        if (IsPhysicallyActive)
+        {
+            if (force.IsFinite())
+            {
+                // DetailLog("{0},BSPrim.addForce,call,force={1}", LocalID, addForce);
+
+                OMV.Vector3 addForce = force;
+                PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.AddForce", delegate()
+                {
+                    // Bullet adds this central force to the total force for this tick.
+                    // Deep down in Bullet:
+                    //      linearVelocity += totalForce / mass * timeStep;
+                    DetailLog("{0},BSPrim.addForce,taint,force={1}", LocalID, addForce);
+                    if (PhysBody.HasPhysicalBody)
+                    {
+                        PhysScene.PE.ApplyCentralForce(PhysBody, addForce);
+                        ActivateIfPhysical(false);
+                    }
+                });
+            }
+            else
+            {
+                m_log.WarnFormat("{0}: AddForce: Got a NaN force applied to a prim. LocalID={1}", LogHeader, LocalID);
+                return;
+            }
+        }
+    }
+
+    public void AddForceImpulse(OMV.Vector3 impulse, bool pushforce, bool inTaintTime) {
+        // for an object, doesn't matter if force is a pushforce or not
+        if (!IsPhysicallyActive)
+        {
+            if (impulse.IsFinite())
+            {
+                OMV.Vector3 addImpulse = Util.ClampV(impulse, BSParam.MaxAddForceMagnitude);
+                // DetailLog("{0},BSPrim.addForceImpulse,call,impulse={1}", LocalID, impulse);
+
+                PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.AddImpulse", delegate()
+                {
+                    // Bullet adds this impulse immediately to the velocity
+                    DetailLog("{0},BSPrim.addForceImpulse,taint,impulseforce={1}", LocalID, addImpulse);
+                    if (PhysBody.HasPhysicalBody)
+                    {
+                        PhysScene.PE.ApplyCentralImpulse(PhysBody, addImpulse);
+                        ActivateIfPhysical(false);
+                    }
+                });
+            }
+            else
+            {
+                m_log.WarnFormat("{0}: AddForceImpulse: Got a NaN impulse applied to a prim. LocalID={1}", LogHeader, LocalID);
+                return;
+            }
+        }
+    }
+
+    // BSPhysObject.AddAngularForce()
+    public override void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime)
+    {
+        if (force.IsFinite())
+        {
+            OMV.Vector3 angForce = force;
+            PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.AddAngularForce", delegate()
+            {
+                if (PhysBody.HasPhysicalBody)
+                {
+                    DetailLog("{0},BSPrim.AddAngularForce,taint,angForce={1}", LocalID, angForce);
+                    PhysScene.PE.ApplyTorque(PhysBody, angForce);
+                    ActivateIfPhysical(false);
+                }
+            });
+        }
+        else
+        {
+            m_log.WarnFormat("{0}: Got a NaN force applied to a prim. LocalID={1}", LogHeader, LocalID);
+            return;
+        }
+    }
+
+    // A torque impulse.
+    // ApplyTorqueImpulse adds torque directly to the angularVelocity.
+    // AddAngularForce accumulates the force and applied it to the angular velocity all at once.
+    // Computed as: angularVelocity += impulse * inertia;
+    public void ApplyTorqueImpulse(OMV.Vector3 impulse, bool inTaintTime)
+    {
+        OMV.Vector3 applyImpulse = impulse;
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ApplyTorqueImpulse", delegate()
+        {
+            if (PhysBody.HasPhysicalBody)
+            {
+                PhysScene.PE.ApplyTorqueImpulse(PhysBody, applyImpulse);
+                ActivateIfPhysical(false);
+            }
+        });
+    }
+
+    public override void SetMomentum(OMV.Vector3 momentum) {
+        // DetailLog("{0},BSPrim.SetMomentum,call,mom={1}", LocalID, momentum);
+    }
+    #region Mass Calculation
+
+    private float CalculateMass()
+    {
+        float volume = _size.X * _size.Y * _size.Z; // default
+        float tmp;
+
+        float returnMass = 0;
+        float hollowAmount = (float)BaseShape.ProfileHollow * 2.0e-5f;
+        float hollowVolume = hollowAmount * hollowAmount;
+
+        switch (BaseShape.ProfileShape)
+        {
+            case ProfileShape.Square:
+                // default box
+
+                if (BaseShape.PathCurve == (byte)Extrusion.Straight)
+                    {
+                    if (hollowAmount > 0.0)
+                        {
+                        switch (BaseShape.HollowShape)
+                            {
+                            case HollowShape.Square:
+                            case HollowShape.Same:
+                                break;
+
+                            case HollowShape.Circle:
+
+                                hollowVolume *= 0.78539816339f;
+                                break;
+
+                            case HollowShape.Triangle:
+
+                                hollowVolume *= (0.5f * .5f);
+                                break;
+
+                            default:
+                                hollowVolume = 0;
+                                break;
+                            }
+                        volume *= (1.0f - hollowVolume);
+                        }
+                    }
+
+                else if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                    //a tube
+
+                    volume *= 0.78539816339e-2f * (float)(200 - BaseShape.PathScaleX);
+                    tmp= 1.0f -2.0e-2f * (float)(200 - BaseShape.PathScaleY);
+                    volume -= volume*tmp*tmp;
+
+                    if (hollowAmount > 0.0)
+                        {
+                        hollowVolume *= hollowAmount;
+
+                        switch (BaseShape.HollowShape)
+                            {
+                            case HollowShape.Square:
+                            case HollowShape.Same:
+                                break;
+
+                            case HollowShape.Circle:
+                                hollowVolume *= 0.78539816339f;;
+                                break;
+
+                            case HollowShape.Triangle:
+                                hollowVolume *= 0.5f * 0.5f;
+                                break;
+                            default:
+                                hollowVolume = 0;
+                                break;
+                            }
+                        volume *= (1.0f - hollowVolume);
+                        }
+                    }
+
+                break;
+
+            case ProfileShape.Circle:
+
+                if (BaseShape.PathCurve == (byte)Extrusion.Straight)
+                    {
+                    volume *= 0.78539816339f; // elipse base
+
+                    if (hollowAmount > 0.0)
+                        {
+                        switch (BaseShape.HollowShape)
+                            {
+                            case HollowShape.Same:
+                            case HollowShape.Circle:
+                                break;
+
+                            case HollowShape.Square:
+                                hollowVolume *= 0.5f * 2.5984480504799f;
+                                break;
+
+                            case HollowShape.Triangle:
+                                hollowVolume *= .5f * 1.27323954473516f;
+                                break;
+
+                            default:
+                                hollowVolume = 0;
+                                break;
+                            }
+                        volume *= (1.0f - hollowVolume);
+                        }
+                    }
+
+                else if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                    volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - BaseShape.PathScaleX);
+                    tmp = 1.0f - .02f * (float)(200 - BaseShape.PathScaleY);
+                    volume *= (1.0f - tmp * tmp);
+
+                    if (hollowAmount > 0.0)
+                        {
+
+                        // calculate the hollow volume by it's shape compared to the prim shape
+                        hollowVolume *= hollowAmount;
+
+                        switch (BaseShape.HollowShape)
+                            {
+                            case HollowShape.Same:
+                            case HollowShape.Circle:
+                                break;
+
+                            case HollowShape.Square:
+                                hollowVolume *= 0.5f * 2.5984480504799f;
+                                break;
+
+                            case HollowShape.Triangle:
+                                hollowVolume *= .5f * 1.27323954473516f;
+                                break;
+
+                            default:
+                                hollowVolume = 0;
+                                break;
+                            }
+                        volume *= (1.0f - hollowVolume);
+                        }
+                    }
+                break;
+
+            case ProfileShape.HalfCircle:
+                if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
+                {
+                volume *= 0.52359877559829887307710723054658f;
+                }
+                break;
+
+            case ProfileShape.EquilateralTriangle:
+
+                if (BaseShape.PathCurve == (byte)Extrusion.Straight)
+                    {
+                    volume *= 0.32475953f;
+
+                    if (hollowAmount > 0.0)
+                        {
+
+                        // calculate the hollow volume by it's shape compared to the prim shape
+                        switch (BaseShape.HollowShape)
+                            {
+                            case HollowShape.Same:
+                            case HollowShape.Triangle:
+                                hollowVolume *= .25f;
+                                break;
+
+                            case HollowShape.Square:
+                                hollowVolume *= 0.499849f * 3.07920140172638f;
+                                break;
+
+                            case HollowShape.Circle:
+                                // Hollow shape is a perfect cyllinder in respect to the cube's scale
+                                // Cyllinder hollow volume calculation
+
+                                hollowVolume *= 0.1963495f * 3.07920140172638f;
+                                break;
+
+                            default:
+                                hollowVolume = 0;
+                                break;
+                            }
+                        volume *= (1.0f - hollowVolume);
+                        }
+                    }
+                else if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                    volume *= 0.32475953f;
+                    volume *= 0.01f * (float)(200 - BaseShape.PathScaleX);
+                    tmp = 1.0f - .02f * (float)(200 - BaseShape.PathScaleY);
+                    volume *= (1.0f - tmp * tmp);
+
+                    if (hollowAmount > 0.0)
+                        {
+
+                        hollowVolume *= hollowAmount;
+
+                        switch (BaseShape.HollowShape)
+                            {
+                            case HollowShape.Same:
+                            case HollowShape.Triangle:
+                                hollowVolume *= .25f;
+                                break;
+
+                            case HollowShape.Square:
+                                hollowVolume *= 0.499849f * 3.07920140172638f;
+                                break;
+
+                            case HollowShape.Circle:
+
+                                hollowVolume *= 0.1963495f * 3.07920140172638f;
+                                break;
+
+                            default:
+                                hollowVolume = 0;
+                                break;
+                            }
+                        volume *= (1.0f - hollowVolume);
+                        }
+                    }
+                    break;
+
+            default:
+                break;
+            }
+
+
+
+        float taperX1;
+        float taperY1;
+        float taperX;
+        float taperY;
+        float pathBegin;
+        float pathEnd;
+        float profileBegin;
+        float profileEnd;
+
+        if (BaseShape.PathCurve == (byte)Extrusion.Straight || BaseShape.PathCurve == (byte)Extrusion.Flexible)
+            {
+            taperX1 = BaseShape.PathScaleX * 0.01f;
+            if (taperX1 > 1.0f)
+                taperX1 = 2.0f - taperX1;
+            taperX = 1.0f - taperX1;
+
+            taperY1 = BaseShape.PathScaleY * 0.01f;
+            if (taperY1 > 1.0f)
+                taperY1 = 2.0f - taperY1;
+            taperY = 1.0f - taperY1;
+            }
+        else
+            {
+            taperX = BaseShape.PathTaperX * 0.01f;
+            if (taperX < 0.0f)
+                taperX = -taperX;
+            taperX1 = 1.0f - taperX;
+
+            taperY = BaseShape.PathTaperY * 0.01f;
+            if (taperY < 0.0f)
+                taperY = -taperY;
+            taperY1 = 1.0f - taperY;
+
+            }
+
+
+        volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY);
+
+        pathBegin = (float)BaseShape.PathBegin * 2.0e-5f;
+        pathEnd = 1.0f - (float)BaseShape.PathEnd * 2.0e-5f;
+        volume *= (pathEnd - pathBegin);
+
+        // this is crude aproximation
+        profileBegin = (float)BaseShape.ProfileBegin * 2.0e-5f;
+        profileEnd = 1.0f - (float)BaseShape.ProfileEnd * 2.0e-5f;
+        volume *= (profileEnd - profileBegin);
+
+        returnMass = Density * BSParam.DensityScaleFactor * volume;
+
+        returnMass = Util.Clamp(returnMass, BSParam.MinimumObjectMass, BSParam.MaximumObjectMass);
+        // DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3}", LocalID, Density, volume, returnMass);
+        DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3},pathB={4},pathE={5},profB={6},profE={7},siz={8}",
+                            LocalID, Density, volume, returnMass, pathBegin, pathEnd, profileBegin, profileEnd, _size);
+
+        return returnMass;
+    }// end CalculateMass
+    #endregion Mass Calculation
+
+    // Rebuild the geometry and object.
+    // This is called when the shape changes so we need to recreate the mesh/hull.
+    // Called at taint-time!!!
+    public void CreateGeomAndObject(bool forceRebuild)
+    {
+        // Create the correct physical representation for this type of object.
+        // Updates base.PhysBody and base.PhysShape with the new information.
+        // Ignore 'forceRebuild'. 'GetBodyAndShape' makes the right choices and changes of necessary.
+        PhysScene.Shapes.GetBodyAndShape(false /*forceRebuild */, PhysScene.World, this, delegate(BulletBody pBody, BulletShape pShape)
+        {
+            // Called if the current prim body is about to be destroyed.
+            // Remove all the physical dependencies on the old body.
+            // (Maybe someday make the changing of BSShape an event to be subscribed to by BSLinkset, ...)
+            // Note: this virtual function is overloaded by BSPrimLinkable to remove linkset constraints.
+            RemoveDependencies();
+        });
+
+        // Make sure the properties are set on the new object
+        UpdatePhysicalParameters();
+        return;
+    }
+
+    // Called at taint-time
+    protected virtual void RemoveDependencies()
+    {
+        PhysicalActors.RemoveDependencies();
+    }
+
+    #region Extension
+    public override object Extension(string pFunct, params object[] pParams)
+    {
+        DetailLog("{0} BSPrim.Extension,op={1}", LocalID, pFunct);
+        object ret = null;
+        switch (pFunct)
+        {
+            case ExtendedPhysics.PhysFunctAxisLockLimits:
+                ret = SetAxisLockLimitsExtension(pParams);
+                break;
+            default:
+                ret = base.Extension(pFunct, pParams);
+                break;
+        }
+        return ret;
+    }
+
+    private void InitializeAxisActor()
+    {
+        EnableActor(LockedAngularAxis != LockedAxisFree || LockedLinearAxis != LockedAxisFree,
+                                    LockedAxisActorName, delegate()
+        {
+            return new BSActorLockAxis(PhysScene, this, LockedAxisActorName);
+        });
+
+        // Update parameters so the new actor's Refresh() action is called at the right time.
+        PhysScene.TaintedObject(LocalID, "BSPrim.LockAxis", delegate()
+        {
+            UpdatePhysicalParameters();
+        });
+    }
+
+    // Passed an array of an array of parameters, set the axis locking.
+    // This expects an int (PHYS_AXIS_*) followed by none or two limit floats
+    //    followed by another int and floats, etc.
+    private object SetAxisLockLimitsExtension(object[] pParams)
+    {
+        DetailLog("{0} SetAxisLockLimitsExtension. parmlen={1}", LocalID, pParams.GetLength(0));
+        object ret = null;
+        try
+        {
+            if (pParams.GetLength(0) > 1)
+            {
+                int index = 2;
+                while (index < pParams.GetLength(0))
+                {
+                    var funct = pParams[index];
+                    DetailLog("{0} SetAxisLockLimitsExtension. op={1}, index={2}", LocalID, funct, index);
+                    if (funct is Int32 || funct is Int64)
+                    {
+                        switch ((int)funct)
+                        {
+                            // Those that take no parameters
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Z:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Z:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Z:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Z:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK:
+                                ApplyAxisLimits((int)funct, 0f, 0f);
+                                index += 1;
+                                break;
+                            // Those that take two parameters (the limits)
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Z:
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Z:
+                                ApplyAxisLimits((int)funct, (float)pParams[index + 1], (float)pParams[index + 2]);
+                                index += 3;
+                                break;
+                            default:
+                                m_log.WarnFormat("{0} SetSxisLockLimitsExtension. Unknown op={1}", LogHeader, funct);
+                                index += 1;
+                                break;
+                        }
+                    }
+                }
+                InitializeAxisActor();
+                ret = (object)index;
+            }
+        }
+        catch (Exception e)
+        {
+            m_log.WarnFormat("{0} SetSxisLockLimitsExtension exception in object {1}: {2}", LogHeader, this.Name, e);
+            ret = null;
+        }
+        return ret;    // not implemented yet
+    }
+
+        // Set the locking parameters.
+        // If an axis is locked, the limits for the axis are set to zero,
+        // If the axis is being constrained, the high and low value are passed and set.
+        // When done here, LockedXXXAxis flags are set and LockedXXXAxixLow/High are set to the range.
+    protected void ApplyAxisLimits(int funct, float low, float high)
+    {
+        DetailLog("{0} ApplyAxisLimits. op={1}, low={2}, high={3}", LocalID, funct, low, high);
+        float linearMax = 23000f;
+        float angularMax = (float)Math.PI;
+
+        switch (funct)
+        {
+            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR:
+                this.LockedLinearAxis = new OMV.Vector3(LockedAxis, LockedAxis, LockedAxis);
+                this.LockedLinearAxisLow = OMV.Vector3.Zero;
+                this.LockedLinearAxisHigh = OMV.Vector3.Zero;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_X:
+                this.LockedLinearAxis.X = LockedAxis;
+                this.LockedLinearAxisLow.X = 0f;
+                this.LockedLinearAxisHigh.X = 0f;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_X:
+                this.LockedLinearAxis.X = LockedAxis;
+                this.LockedLinearAxisLow.X = Util.Clip(low, -linearMax, linearMax);
+                this.LockedLinearAxisHigh.X = Util.Clip(high, -linearMax, linearMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Y:
+                this.LockedLinearAxis.Y = LockedAxis;
+                this.LockedLinearAxisLow.Y = 0f;
+                this.LockedLinearAxisHigh.Y = 0f;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Y:
+                this.LockedLinearAxis.Y = LockedAxis;
+                this.LockedLinearAxisLow.Y = Util.Clip(low, -linearMax, linearMax);
+                this.LockedLinearAxisHigh.Y = Util.Clip(high, -linearMax, linearMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Z:
+                this.LockedLinearAxis.Z = LockedAxis;
+                this.LockedLinearAxisLow.Z = 0f;
+                this.LockedLinearAxisHigh.Z = 0f;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Z:
+                this.LockedLinearAxis.Z = LockedAxis;
+                this.LockedLinearAxisLow.Z = Util.Clip(low, -linearMax, linearMax);
+                this.LockedLinearAxisHigh.Z = Util.Clip(high, -linearMax, linearMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR:
+                this.LockedAngularAxis = new OMV.Vector3(LockedAxis, LockedAxis, LockedAxis);
+                this.LockedAngularAxisLow = OMV.Vector3.Zero;
+                this.LockedAngularAxisHigh = OMV.Vector3.Zero;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_X:
+                this.LockedAngularAxis.X = LockedAxis;
+                this.LockedAngularAxisLow.X = 0;
+                this.LockedAngularAxisHigh.X = 0;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_X:
+                this.LockedAngularAxis.X = LockedAxis;
+                this.LockedAngularAxisLow.X = Util.Clip(low, -angularMax, angularMax);
+                this.LockedAngularAxisHigh.X = Util.Clip(high, -angularMax, angularMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Y:
+                this.LockedAngularAxis.Y = LockedAxis;
+                this.LockedAngularAxisLow.Y = 0;
+                this.LockedAngularAxisHigh.Y = 0;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Y:
+                this.LockedAngularAxis.Y = LockedAxis;
+                this.LockedAngularAxisLow.Y = Util.Clip(low, -angularMax, angularMax);
+                this.LockedAngularAxisHigh.Y = Util.Clip(high, -angularMax, angularMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Z:
+                this.LockedAngularAxis.Z = LockedAxis;
+                this.LockedAngularAxisLow.Z = 0;
+                this.LockedAngularAxisHigh.Z = 0;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Z:
+                this.LockedAngularAxis.Z = LockedAxis;
+                this.LockedAngularAxisLow.Z = Util.Clip(low, -angularMax, angularMax);
+                this.LockedAngularAxisHigh.Z = Util.Clip(high, -angularMax, angularMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR:
+                this.LockedLinearAxis = LockedAxisFree;
+                this.LockedLinearAxisLow = new OMV.Vector3(-linearMax, -linearMax, -linearMax);
+                this.LockedLinearAxisHigh = new OMV.Vector3(linearMax, linearMax, linearMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_X:
+                this.LockedLinearAxis.X = FreeAxis;
+                this.LockedLinearAxisLow.X = -linearMax;
+                this.LockedLinearAxisHigh.X = linearMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Y:
+                this.LockedLinearAxis.Y = FreeAxis;
+                this.LockedLinearAxisLow.Y = -linearMax;
+                this.LockedLinearAxisHigh.Y = linearMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Z:
+                this.LockedLinearAxis.Z = FreeAxis;
+                this.LockedLinearAxisLow.Z = -linearMax;
+                this.LockedLinearAxisHigh.Z = linearMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR:
+                this.LockedAngularAxis = LockedAxisFree;
+                this.LockedAngularAxisLow = new OMV.Vector3(-angularMax, -angularMax, -angularMax);
+                this.LockedAngularAxisHigh = new OMV.Vector3(angularMax, angularMax, angularMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_X:
+                this.LockedAngularAxis.X = FreeAxis;
+                this.LockedAngularAxisLow.X = -angularMax;
+                this.LockedAngularAxisHigh.X = angularMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Y:
+                this.LockedAngularAxis.Y = FreeAxis;
+                this.LockedAngularAxisLow.Y = -angularMax;
+                this.LockedAngularAxisHigh.Y = angularMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Z:
+                this.LockedAngularAxis.Z = FreeAxis;
+                this.LockedAngularAxisLow.Z = -angularMax;
+                this.LockedAngularAxisHigh.Z = angularMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK:
+                ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR, 0f, 0f);
+                ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR, 0f, 0f);
+                break;
+            default:
+                break;
+        }
+        return;
+    }
+    #endregion  // Extension
+
+    // The physics engine says that properties have updated. Update same and inform
+    // the world that things have changed.
+    // NOTE: BSPrim.UpdateProperties is overloaded by BSPrimLinkable which modifies updates from root and children prims.
+    // NOTE: BSPrim.UpdateProperties is overloaded by BSPrimDisplaced which handles mapping physical position to simulator position.
+    public override void UpdateProperties(EntityProperties entprop)
+    {
+        // Let anyone (like the actors) modify the updated properties before they are pushed into the object and the simulator.
+        TriggerPreUpdatePropertyAction(ref entprop);
+
+        // DetailLog("{0},BSPrim.UpdateProperties,entry,entprop={1}", LocalID, entprop);   // DEBUG DEBUG
+
+        // Assign directly to the local variables so the normal set actions do not happen
+        RawPosition = entprop.Position;
+        RawOrientation = entprop.Rotation;
+        // DEBUG DEBUG DEBUG -- smooth velocity changes a bit. The simulator seems to be
+        //    very sensitive to velocity changes.
+        if (entprop.Velocity == OMV.Vector3.Zero || !entprop.Velocity.ApproxEquals(RawVelocity, BSParam.UpdateVelocityChangeThreshold))
+            RawVelocity = entprop.Velocity;
+        _acceleration = entprop.Acceleration;
+        _rotationalVelocity = entprop.RotationalVelocity;
+
+        // DetailLog("{0},BSPrim.UpdateProperties,afterAssign,entprop={1}", LocalID, entprop);   // DEBUG DEBUG
+
+        // The sanity check can change the velocity and/or position.
+        if (PositionSanityCheck(true /* inTaintTime */ ))
+        {
+            entprop.Position = RawPosition;
+            entprop.Velocity = RawVelocity;
+            entprop.RotationalVelocity = _rotationalVelocity;
+            entprop.Acceleration = _acceleration;
+        }
+
+        OMV.Vector3 direction = OMV.Vector3.UnitX * RawOrientation;   // DEBUG DEBUG DEBUG
+        DetailLog("{0},BSPrim.UpdateProperties,call,entProp={1},dir={2}", LocalID, entprop, direction);
+
+        // remember the current and last set values
+        LastEntityProperties = CurrentEntityProperties;
+        CurrentEntityProperties = entprop;
+
+        PhysScene.PostUpdate(this);
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPrimDisplaced.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPrimDisplaced.cs
new file mode 100755
index 0000000..d8ed56b
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPrimDisplaced.cs
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public class BSPrimDisplaced : BSPrim
+{
+    // The purpose of this subclass is to do any mapping between what the simulator thinks
+    //    the prim position and orientation is and what the physical position/orientation.
+    //    This difference happens because Bullet assumes the center-of-mass is the <0,0,0>
+    //    of the prim/linkset. The simulator, on the other hand, tracks the location of
+    //    the prim/linkset by the location of the root prim. So, if center-of-mass is anywhere
+    //    but the origin of the root prim, the physical origin is displaced from the simulator origin.
+    //
+    // This routine works by capturing ForcePosition and
+    //    adjusting the simulator values (being set) into the physical values.
+    //    The conversion is also done in the opposite direction (physical origin -> simulator origin).
+    //
+    // The updateParameter call is also captured and the values from the physics engine
+    //    are converted into simulator origin values before being passed to the base
+    //    class.
+
+    // PositionDisplacement is the vehicle relative distance from the root prim position to the center-of-mass.
+    public virtual OMV.Vector3 PositionDisplacement { get; set; }
+
+    public BSPrimDisplaced(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size,
+                       OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
+        : base(localID, primName, parent_scene, pos, size, rotation, pbs, pisPhysical)
+    {
+        ClearDisplacement();
+    }
+
+    // Clears any center-of-mass displacement introduced by linksets, etc.
+    // Does not clear the displacement set by the user.
+    public void ClearDisplacement()
+    {
+        if (UserSetCenterOfMassDisplacement.HasValue)
+            PositionDisplacement = (OMV.Vector3)UserSetCenterOfMassDisplacement;
+        else
+            PositionDisplacement = OMV.Vector3.Zero;
+    }
+
+    // Set this sets and computes the displacement from the passed prim to the center-of-mass.
+    // A user set value for center-of-mass overrides whatever might be passed in here.
+    // The displacement is in local coordinates (relative to root prim in linkset oriented coordinates).
+    // Returns the relative offset from the root position to the center-of-mass.
+    // Called at taint time.
+    public virtual Vector3 SetEffectiveCenterOfMassDisplacement(Vector3 centerOfMassDisplacement)
+    {
+        PhysScene.AssertInTaintTime("BSPrimDisplaced.SetEffectiveCenterOfMassDisplacement");
+        Vector3 comDisp;
+        if (UserSetCenterOfMassDisplacement.HasValue)
+            comDisp = (OMV.Vector3)UserSetCenterOfMassDisplacement;
+        else
+            comDisp = centerOfMassDisplacement;
+
+        // Eliminate any jitter caused be very slight differences in masses and positions
+        if (comDisp.ApproxEquals(Vector3.Zero, 0.01f) )
+            comDisp = Vector3.Zero;
+
+        DetailLog("{0},BSPrimDisplaced.SetEffectiveCenterOfMassDisplacement,userSet={1},comDisp={2}",
+                                    LocalID, UserSetCenterOfMassDisplacement.HasValue, comDisp);
+        if ( !comDisp.ApproxEquals(PositionDisplacement, 0.01f) )
+        {
+            // Displacement setting is changing.
+            // The relationship between the physical object and simulated object must be aligned.
+            PositionDisplacement = comDisp;
+            this.ForcePosition = RawPosition;
+        }
+
+        return PositionDisplacement;
+    }
+
+    // 'ForcePosition' is the one way to set the physical position of the body in the physics engine.
+    // Displace the simulator idea of position (center of root prim) to the physical position.
+    public override Vector3 ForcePosition
+    {
+        get {
+            OMV.Vector3 physPosition = PhysScene.PE.GetPosition(PhysBody);
+            if (PositionDisplacement != OMV.Vector3.Zero)
+            {
+                // If there is some displacement, return the physical position (center-of-mass)
+                //     location minus the displacement to give the center of the root prim.
+                OMV.Vector3 displacement = PositionDisplacement * ForceOrientation;
+                DetailLog("{0},BSPrimDisplaced.ForcePosition,get,physPos={1},disp={2},simPos={3}",
+                                LocalID, physPosition, displacement, physPosition - displacement);
+                physPosition -= displacement;
+            }
+            RawPosition = physPosition;
+            return physPosition;
+        }
+        set
+        {
+            if (PositionDisplacement != OMV.Vector3.Zero)
+            {
+                // This value is the simulator's idea of where the prim is: the center of the root prim
+                RawPosition = value;
+
+                // Move the passed root prim postion to the center-of-mass position and set in the physics engine.
+                OMV.Vector3 displacement = PositionDisplacement * RawOrientation;
+                OMV.Vector3 displacedPos = RawPosition + displacement;
+                DetailLog("{0},BSPrimDisplaced.ForcePosition,set,simPos={1},disp={2},physPos={3}",
+                                        LocalID, RawPosition, displacement, displacedPos);
+                if (PhysBody.HasPhysicalBody)
+                {
+                    PhysScene.PE.SetTranslation(PhysBody, displacedPos, RawOrientation);
+                    ActivateIfPhysical(false);
+                }
+            }
+            else
+            {
+                base.ForcePosition = value;
+            }
+        }
+    }
+
+    // These are also overridden by BSPrimLinkable if the prim can be part of a linkset
+    public override OMV.Vector3 CenterOfMass
+    {
+        get { return RawPosition; }
+    }
+
+    public override OMV.Vector3 GeometricCenter
+    {
+        get { return RawPosition; }
+    }
+
+    public override void UpdateProperties(EntityProperties entprop)
+    {
+        // Undo any center-of-mass displacement that might have been done.
+        if (PositionDisplacement != OMV.Vector3.Zero)
+        {
+            // The origional shape was offset from 'zero' by PositionDisplacement.
+            // These physical location must be back converted to be centered around the displaced
+            //     root shape.
+
+            // Move the returned center-of-mass location to the root prim location.
+            OMV.Vector3 displacement = PositionDisplacement * entprop.Rotation;
+            OMV.Vector3 displacedPos = entprop.Position - displacement;
+            DetailLog("{0},BSPrimDisplaced.UpdateProperties,physPos={1},disp={2},simPos={3}",
+                                    LocalID, entprop.Position, displacement, displacedPos);
+            entprop.Position = displacedPos;
+        }
+
+        base.UpdateProperties(entprop);
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPrimLinkable.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPrimLinkable.cs
new file mode 100755
index 0000000..55b5da0
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPrimLinkable.cs
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Framework;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public class BSPrimLinkable : BSPrimDisplaced
+{
+    // The purpose of this subclass is to add linkset functionality to the prim. This overrides
+    //    operations necessary for keeping the linkset created and, additionally, this
+    //    calls the linkset implementation for its creation and management.
+
+#pragma warning disable 414
+    private static readonly string LogHeader = "[BULLETS PRIMLINKABLE]";
+#pragma warning restore 414
+
+    // This adds the overrides for link() and delink() so the prim is linkable.
+
+    public BSLinkset Linkset { get; set; }
+    // The index of this child prim.
+    public int LinksetChildIndex { get; set; }
+
+    public BSLinkset.LinksetImplementation LinksetType { get; set; }
+
+    public BSPrimLinkable(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size,
+                       OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
+        : base(localID, primName, parent_scene, pos, size, rotation, pbs, pisPhysical)
+    {
+        // Default linkset implementation for this prim
+        LinksetType = (BSLinkset.LinksetImplementation)BSParam.LinksetImplementation;
+
+        Linkset = BSLinkset.Factory(PhysScene, this);
+
+        Linkset.Refresh(this);
+    }
+
+    public override void Destroy()
+    {
+        Linkset = Linkset.RemoveMeFromLinkset(this, false /* inTaintTime */);
+        base.Destroy();
+    }
+
+    public override void link(OpenSim.Region.PhysicsModules.SharedBase.PhysicsActor obj)
+    {
+        BSPrimLinkable parent = obj as BSPrimLinkable;
+        if (parent != null)
+        {
+            BSPhysObject parentBefore = Linkset.LinksetRoot;    // DEBUG
+            int childrenBefore = Linkset.NumberOfChildren;      // DEBUG
+
+            Linkset = parent.Linkset.AddMeToLinkset(this);
+
+            DetailLog("{0},BSPrimLinkable.link,call,parentBefore={1}, childrenBefore=={2}, parentAfter={3}, childrenAfter={4}",
+                LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren);
+        }
+        return;
+    }
+
+    public override void delink()
+    {
+        // TODO: decide if this parent checking needs to happen at taint time
+        // Race condition here: if link() and delink() in same simulation tick, the delink will not happen
+
+        BSPhysObject parentBefore = Linkset.LinksetRoot;        // DEBUG
+        int childrenBefore = Linkset.NumberOfChildren;          // DEBUG
+
+        Linkset = Linkset.RemoveMeFromLinkset(this, false /* inTaintTime*/);
+
+        DetailLog("{0},BSPrimLinkable.delink,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}, ",
+            LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren);
+        return;
+    }
+
+    // When simulator changes position, this might be moving a child of the linkset.
+    public override OMV.Vector3 Position
+    {
+        get { return base.Position; }
+        set
+        {
+            base.Position = value;
+            PhysScene.TaintedObject(LocalID, "BSPrimLinkable.setPosition", delegate()
+            {
+                Linkset.UpdateProperties(UpdatedProperties.Position, this);
+            });
+        }
+    }
+
+    // When simulator changes orientation, this might be moving a child of the linkset.
+    public override OMV.Quaternion Orientation
+    {
+        get { return base.Orientation; }
+        set
+        {
+            base.Orientation = value;
+            PhysScene.TaintedObject(LocalID, "BSPrimLinkable.setOrientation", delegate()
+            {
+                Linkset.UpdateProperties(UpdatedProperties.Orientation, this);
+            });
+        }
+    }
+
+    public override float TotalMass
+    {
+        get { return Linkset.LinksetMass; }
+    }
+
+    public override OMV.Vector3 CenterOfMass
+    {
+        get { return Linkset.CenterOfMass; }
+    }
+
+    public override OMV.Vector3 GeometricCenter
+    {
+        get { return Linkset.GeometricCenter; }
+    }
+
+    // Refresh the linkset structure and parameters when the prim's physical parameters are changed.
+    public override void UpdatePhysicalParameters()
+    {
+        base.UpdatePhysicalParameters();
+        // Recompute any linkset parameters.
+        // When going from non-physical to physical, this re-enables the constraints that
+        //     had been automatically disabled when the mass was set to zero.
+        // For compound based linksets, this enables and disables interactions of the children.
+        if (Linkset != null)    // null can happen during initialization
+            Linkset.Refresh(this);
+    }
+
+    // When the prim is made dynamic or static, the linkset needs to change.
+    protected override void MakeDynamic(bool makeStatic)
+    {
+        base.MakeDynamic(makeStatic);
+        if (Linkset != null)    // null can happen during initialization
+        {
+            if (makeStatic)
+                Linkset.MakeStatic(this);
+            else
+                Linkset.MakeDynamic(this);
+        }
+    }
+
+    // Body is being taken apart. Remove physical dependencies and schedule a rebuild.
+    protected override void RemoveDependencies()
+    {
+        Linkset.RemoveDependencies(this);
+        base.RemoveDependencies();
+    }
+
+    // Called after a simulation step for the changes in physical object properties.
+    // Do any filtering/modification needed for linksets.
+    public override void UpdateProperties(EntityProperties entprop)
+    {
+        if (Linkset.IsRoot(this) || Linkset.ShouldReportPropertyUpdates(this))
+        {
+            // Properties are only updated for the roots of a linkset.
+            // TODO: this will have to change when linksets are articulated.
+            base.UpdateProperties(entprop);
+        }
+            /*
+        else
+        {
+            // For debugging, report the movement of children
+            DetailLog("{0},BSPrim.UpdateProperties,child,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
+                    LocalID, entprop.Position, entprop.Rotation, entprop.Velocity,
+                    entprop.Acceleration, entprop.RotationalVelocity);
+        }
+             */
+        // The linkset might like to know about changing locations
+        Linkset.UpdateProperties(UpdatedProperties.EntPropUpdates, this);
+    }
+
+    // Called after a simulation step to post a collision with this object.
+    // This returns 'true' if the collision has been queued and the SendCollisions call must
+    //     be made at the end of the simulation step.
+    public override bool Collide(uint collidingWith, BSPhysObject collidee,
+                    OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
+    {
+        bool ret = false;
+        // Ask the linkset if it wants to handle the collision
+        if (!Linkset.HandleCollide(collidingWith, collidee, contactPoint, contactNormal, pentrationDepth))
+        {
+            // The linkset didn't handle it so pass the collision through normal processing
+            ret = base.Collide(collidingWith, collidee, contactPoint, contactNormal, pentrationDepth);
+        }
+        return ret;
+    }
+
+    // A linkset reports any collision on any part of the linkset.
+    public long SomeCollisionSimulationStep = 0;
+    public override bool HasSomeCollision
+    {
+        get
+        {
+            return (SomeCollisionSimulationStep == PhysScene.SimulationStep) || base.IsColliding;
+        }
+        set
+        {
+            if (value)
+                SomeCollisionSimulationStep = PhysScene.SimulationStep;
+            else
+                SomeCollisionSimulationStep = 0;
+
+            base.HasSomeCollision = value;
+        }
+    }
+
+    // Convert the existing linkset of this prim into a new type.
+    public bool ConvertLinkset(BSLinkset.LinksetImplementation newType)
+    {
+        bool ret = false;
+        if (LinksetType != newType)
+        {
+            DetailLog("{0},BSPrimLinkable.ConvertLinkset,oldT={1},newT={2}", LocalID, LinksetType, newType);
+
+            // Set the implementation type first so the call to BSLinkset.Factory gets the new type.
+            this.LinksetType = newType;
+
+            BSLinkset oldLinkset = this.Linkset;
+            BSLinkset newLinkset = BSLinkset.Factory(PhysScene, this);
+
+            this.Linkset = newLinkset;
+
+            // Pick up any physical dependencies this linkset might have in the physics engine.
+            oldLinkset.RemoveDependencies(this);
+
+            // Create a list of the children (mainly because can't interate through a list that's changing)
+            List<BSPrimLinkable> children = new List<BSPrimLinkable>();
+            oldLinkset.ForEachMember((child) =>
+            {
+                if (!oldLinkset.IsRoot(child))
+                    children.Add(child);
+                return false;   // 'false' says to continue to next member
+            });
+
+            // Remove the children from the old linkset and add to the new (will be a new instance from the factory)
+            foreach (BSPrimLinkable child in children)
+            {
+                oldLinkset.RemoveMeFromLinkset(child, true /*inTaintTime*/);
+            }
+            foreach (BSPrimLinkable child in children)
+            {
+                newLinkset.AddMeToLinkset(child);
+                child.Linkset = newLinkset;
+            }
+
+            // Force the shape and linkset to get reconstructed
+            newLinkset.Refresh(this);
+            this.ForceBodyShapeRebuild(true /* inTaintTime */);
+        }
+        return ret;
+    }
+
+    #region Extension
+    public override object Extension(string pFunct, params object[] pParams)
+    {
+        DetailLog("{0} BSPrimLinkable.Extension,op={1},nParam={2}", LocalID, pFunct, pParams.Length);
+        object ret = null;
+        switch (pFunct)
+        {
+            // physGetLinksetType();
+            // pParams = [ BSPhysObject root, null ]
+            case ExtendedPhysics.PhysFunctGetLinksetType:
+            {
+                ret = (object)LinksetType;
+                DetailLog("{0},BSPrimLinkable.Extension.physGetLinksetType,type={1}", LocalID, ret);
+                break;
+            }
+            // physSetLinksetType(type);
+            // pParams = [ BSPhysObject root, null, integer type ]
+            case ExtendedPhysics.PhysFunctSetLinksetType:
+            {
+                if (pParams.Length > 2)
+                {
+                    BSLinkset.LinksetImplementation linksetType = (BSLinkset.LinksetImplementation)pParams[2];
+                    if (Linkset.IsRoot(this))
+                    {
+                        PhysScene.TaintedObject(LocalID, "BSPrim.PhysFunctSetLinksetType", delegate()
+                        {
+                            // Cause the linkset type to change
+                            DetailLog("{0},BSPrimLinkable.Extension.physSetLinksetType, oldType={1},newType={2}",
+                                                LocalID, Linkset.LinksetImpl, linksetType);
+                            ConvertLinkset(linksetType);
+                        });
+                    }
+                    ret = (object)(int)linksetType;
+                }
+                break;
+            }
+            // physChangeLinkType(linknum, typeCode);
+            // pParams = [ BSPhysObject root, BSPhysObject child, integer linkType ]
+            case ExtendedPhysics.PhysFunctChangeLinkType:
+            {
+                ret = Linkset.Extension(pFunct, pParams);
+                break;
+            }
+            // physGetLinkType(linknum);
+            // pParams = [ BSPhysObject root, BSPhysObject child ]
+            case ExtendedPhysics.PhysFunctGetLinkType:
+            {
+                ret = Linkset.Extension(pFunct, pParams);
+                break;
+            }
+            // physChangeLinkParams(linknum, [code, value, code, value, ...]);
+            // pParams = [ BSPhysObject root, BSPhysObject child, object[] [ string op, object opParam, string op, object opParam, ... ] ]
+            case ExtendedPhysics.PhysFunctChangeLinkParams:
+            {
+                ret = Linkset.Extension(pFunct, pParams);
+                break;
+            }
+            default:
+                ret = base.Extension(pFunct, pParams);
+                break;
+        }
+        return ret;
+    }
+    #endregion  // Extension
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs b/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs
new file mode 100644
index 0000000..452ce55
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs
@@ -0,0 +1,1333 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using Nini.Config;
+using log4net;
+using OpenMetaverse;
+using Mono.Addins;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "BulletSPhysicsScene")]
+    public sealed class BSScene : PhysicsScene, IPhysicsParameters, INonSharedRegionModule
+    {
+        internal static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+        internal static readonly string LogHeader = "[BULLETS SCENE]";
+
+        private bool m_Enabled = false;
+        private IConfigSource m_Config;
+
+        // The name of the region we're working for.
+        public string RegionName { get; private set; }
+
+        public string BulletSimVersion = "?";
+
+        // The handle to the underlying managed or unmanaged version of Bullet being used.
+        public string BulletEngineName { get; private set; }
+        public BSAPITemplate PE;
+
+        // If the physics engine is running on a separate thread
+        public Thread m_physicsThread;
+
+        public Dictionary<uint, BSPhysObject> PhysObjects;
+        public BSShapeCollection Shapes;
+
+        // Keeping track of the objects with collisions so we can report begin and end of a collision
+        public HashSet<BSPhysObject> ObjectsWithCollisions = new HashSet<BSPhysObject>();
+        public HashSet<BSPhysObject> ObjectsWithNoMoreCollisions = new HashSet<BSPhysObject>();
+
+        // All the collision processing is protected with this lock object
+        public Object CollisionLock = new Object();
+
+        // Properties are updated here
+        public Object UpdateLock = new Object();
+        public HashSet<BSPhysObject> ObjectsWithUpdates = new HashSet<BSPhysObject>();
+
+        // Keep track of all the avatars so we can send them a collision event
+        //    every tick so OpenSim will update its animation.
+        private HashSet<BSPhysObject> AvatarsInScene = new HashSet<BSPhysObject>();
+        private Object AvatarsInSceneLock = new Object();
+
+        // let my minuions use my logger
+        public ILog Logger { get { return m_log; } }
+
+        public IMesher mesher;
+        public uint WorldID { get; private set; }
+        public BulletWorld World { get; private set; }
+
+        // All the constraints that have been allocated in this instance.
+        public BSConstraintCollection Constraints { get; private set; }
+
+        // Simulation parameters
+        //internal float m_physicsStepTime;   // if running independently, the interval simulated by default
+
+        internal int m_maxSubSteps;
+        internal float m_fixedTimeStep;
+
+        internal float m_simulatedTime;     // the time simulated previously. Used for physics framerate calc.
+
+        internal long m_simulationStep = 0; // The current simulation step.
+        public long SimulationStep { get { return m_simulationStep; } }
+        // A number to use for SimulationStep that is probably not any step value
+        // Used by the collision code (which remembers the step when a collision happens) to remember not any simulation step.
+        public static long NotASimulationStep = -1234;
+
+        internal float LastTimeStep { get; private set; }   // The simulation time from the last invocation of Simulate()
+
+        internal float NominalFrameRate { get; set; }       // Parameterized ideal frame rate that simulation is scaled to
+
+        // Physical objects can register for prestep or poststep events
+        public delegate void PreStepAction(float timeStep);
+        public delegate void PostStepAction(float timeStep);
+        public event PreStepAction BeforeStep;
+        public event PostStepAction AfterStep;
+
+        // A value of the time 'now' so all the collision and update routines do not have to get their own
+        // Set to 'now' just before all the prims and actors are called for collisions and updates
+        public int SimulationNowTime { get; private set; }
+
+        // True if initialized and ready to do simulation steps
+        private bool m_initialized = false;
+
+        // Flag which is true when processing taints.
+        // Not guaranteed to be correct all the time (don't depend on this) but good for debugging.
+        public bool InTaintTime { get; private set; }
+
+        // Pinned memory used to pass step information between managed and unmanaged
+        internal int m_maxCollisionsPerFrame;
+        internal CollisionDesc[] m_collisionArray;
+
+        internal int m_maxUpdatesPerFrame;
+        internal EntityProperties[] m_updateArray;
+
+        /// <summary>
+        /// Used to control physics simulation timing if Bullet is running on its own thread.
+        /// </summary>
+        private ManualResetEvent m_updateWaitEvent;
+
+        public const uint TERRAIN_ID = 0;       // OpenSim senses terrain with a localID of zero
+        public const uint GROUNDPLANE_ID = 1;
+        public const uint CHILDTERRAIN_ID = 2;  // Terrain allocated based on our mega-prim childre start here
+
+        public float SimpleWaterLevel { get; set; }
+        public BSTerrainManager TerrainManager { get; private set; }
+
+        public ConfigurationParameters Params
+        {
+            get { return UnmanagedParams[0]; }
+        }
+        public Vector3 DefaultGravity
+        {
+            get { return new Vector3(0f, 0f, Params.gravity); }
+        }
+        // Just the Z value of the gravity
+        public float DefaultGravityZ
+        {
+            get { return Params.gravity; }
+        }
+
+        // When functions in the unmanaged code must be called, it is only
+        //   done at a known time just before the simulation step. The taint
+        //   system saves all these function calls and executes them in
+        //   order before the simulation.
+        public delegate void TaintCallback();
+        private struct TaintCallbackEntry
+        {
+            public String originator;
+            public String ident;
+            public TaintCallback callback;
+            public TaintCallbackEntry(string pIdent, TaintCallback pCallBack)
+            {
+                originator = BSScene.DetailLogZero;
+                ident = pIdent;
+                callback = pCallBack;
+            }
+            public TaintCallbackEntry(string pOrigin, string pIdent, TaintCallback pCallBack)
+            {
+                originator = pOrigin;
+                ident = pIdent;
+                callback = pCallBack;
+            }
+        }
+        private Object _taintLock = new Object();   // lock for using the next object
+        private List<TaintCallbackEntry> _taintOperations;
+        private Dictionary<string, TaintCallbackEntry> _postTaintOperations;
+        private List<TaintCallbackEntry> _postStepOperations;
+
+        // A pointer to an instance if this structure is passed to the C++ code
+        // Used to pass basic configuration values to the unmanaged code.
+        internal ConfigurationParameters[] UnmanagedParams;
+
+        // Sometimes you just have to log everything.
+        public LogWriter PhysicsLogging;
+        private bool m_physicsLoggingEnabled;
+        private string m_physicsLoggingDir;
+        private string m_physicsLoggingPrefix;
+        private int m_physicsLoggingFileMinutes;
+        private bool m_physicsLoggingDoFlush;
+        private bool m_physicsPhysicalDumpEnabled;
+        public int PhysicsMetricDumpFrames { get; set; }
+        // 'true' of the vehicle code is to log lots of details
+        public bool VehicleLoggingEnabled { get; private set; }
+        public bool VehiclePhysicalLoggingEnabled { get; private set; }
+
+        #region INonSharedRegionModule
+        public string Name
+        {
+            get { return "BulletSim"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            // TODO: Move this out of Startup
+            IConfig config = source.Configs["Startup"];
+            if (config != null)
+            {
+                string physics = config.GetString("physics", string.Empty);
+                if (physics == Name)
+                {
+                    m_Enabled = true;
+                    m_Config = source;
+                }
+            }
+
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            EngineType = Name;
+            RegionName = scene.RegionInfo.RegionName;
+            PhysicsSceneName = EngineType + "/" + RegionName;
+
+            scene.RegisterModuleInterface<PhysicsScene>(this);
+            Vector3 extent = new Vector3(scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY, scene.RegionInfo.RegionSizeZ);
+            Initialise(m_Config, extent);
+
+            base.Initialise(scene.PhysicsRequestAsset,
+                (scene.Heightmap != null ? scene.Heightmap.GetFloatsSerialised() : new float[scene.RegionInfo.RegionSizeX * scene.RegionInfo.RegionSizeY]),
+                (float)scene.RegionInfo.RegionSettings.WaterHeight);
+
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            mesher = scene.RequestModuleInterface<IMesher>();
+            if (mesher == null)
+                m_log.WarnFormat("{0} No mesher. Things will not work well.", LogHeader);
+
+            scene.PhysicsEnabled = true;
+        }
+        #endregion
+
+        #region Initialization
+
+        private void Initialise(IConfigSource config, Vector3 regionExtent)
+        {
+            _taintOperations = new List<TaintCallbackEntry>();
+            _postTaintOperations = new Dictionary<string, TaintCallbackEntry>();
+            _postStepOperations = new List<TaintCallbackEntry>();
+            PhysObjects = new Dictionary<uint, BSPhysObject>();
+            Shapes = new BSShapeCollection(this);
+
+            m_simulatedTime = 0f;
+            LastTimeStep = 0.1f;
+
+            // Allocate pinned memory to pass parameters.
+            UnmanagedParams = new ConfigurationParameters[1];
+
+            // Set default values for physics parameters plus any overrides from the ini file
+            GetInitialParameterValues(config);
+
+            // Force some parameters to values depending on other configurations
+            // Only use heightmap terrain implementation if terrain larger than legacy size
+            if ((uint)regionExtent.X > Constants.RegionSize || (uint)regionExtent.Y > Constants.RegionSize)
+            {
+                m_log.WarnFormat("{0} Forcing terrain implementation to heightmap for large region", LogHeader);
+                BSParam.TerrainImplementation = (float)BSTerrainPhys.TerrainImplementation.Heightmap;
+            }
+
+            // Get the connection to the physics engine (could be native or one of many DLLs)
+            PE = SelectUnderlyingBulletEngine(BulletEngineName);
+
+            // Enable very detailed logging.
+            // By creating an empty logger when not logging, the log message invocation code
+            //     can be left in and every call doesn't have to check for null.
+            if (m_physicsLoggingEnabled)
+            {
+                PhysicsLogging = new LogWriter(m_physicsLoggingDir, m_physicsLoggingPrefix, m_physicsLoggingFileMinutes, m_physicsLoggingDoFlush);
+                PhysicsLogging.ErrorLogger = m_log; // for DEBUG. Let's the logger output its own error messages.
+            }
+            else
+            {
+                PhysicsLogging = new LogWriter();
+            }
+
+            // Allocate memory for returning of the updates and collisions from the physics engine
+            m_collisionArray = new CollisionDesc[m_maxCollisionsPerFrame];
+            m_updateArray = new EntityProperties[m_maxUpdatesPerFrame];
+
+            // The bounding box for the simulated world. The origin is 0,0,0 unless we're
+            //    a child in a mega-region.
+            // Bullet actually doesn't care about the extents of the simulated
+            //    area. It tracks active objects no matter where they are.
+            Vector3 worldExtent = regionExtent;
+
+            World = PE.Initialize(worldExtent, Params, m_maxCollisionsPerFrame, ref m_collisionArray, m_maxUpdatesPerFrame, ref m_updateArray);
+
+            Constraints = new BSConstraintCollection(World);
+
+            TerrainManager = new BSTerrainManager(this, worldExtent);
+            TerrainManager.CreateInitialGroundPlaneAndTerrain();
+
+            // Put some informational messages into the log file.
+            m_log.InfoFormat("{0} Linksets implemented with {1}", LogHeader, (BSLinkset.LinksetImplementation)BSParam.LinksetImplementation);
+
+            InTaintTime = false;
+            m_initialized = true;
+
+            // If the physics engine runs on its own thread, start same.
+            if (BSParam.UseSeparatePhysicsThread)
+            {
+                // The physics simulation should happen independently of the heartbeat loop
+                m_physicsThread 
+                    = WorkManager.StartThread(
+                        BulletSPluginPhysicsThread, 
+                        string.Format("{0} ({1})", BulletEngineName, RegionName), 
+                        ThreadPriority.Normal, 
+                        true, 
+                        true);
+            }
+        }
+
+        // All default parameter values are set here. There should be no values set in the
+        // variable definitions.
+        private void GetInitialParameterValues(IConfigSource config)
+        {
+            ConfigurationParameters parms = new ConfigurationParameters();
+            UnmanagedParams[0] = parms;
+
+            BSParam.SetParameterDefaultValues(this);
+
+            if (config != null)
+            {
+                // If there are specifications in the ini file, use those values
+                IConfig pConfig = config.Configs["BulletSim"];
+                if (pConfig != null)
+                {
+                    BSParam.SetParameterConfigurationValues(this, pConfig);
+
+                    // There are two Bullet implementations to choose from
+                    BulletEngineName = pConfig.GetString("BulletEngine", "BulletUnmanaged");
+
+                    // Very detailed logging for physics debugging
+                    // TODO: the boolean values can be moved to the normal parameter processing.
+                    m_physicsLoggingEnabled = pConfig.GetBoolean("PhysicsLoggingEnabled", false);
+                    m_physicsLoggingDir = pConfig.GetString("PhysicsLoggingDir", ".");
+                    m_physicsLoggingPrefix = pConfig.GetString("PhysicsLoggingPrefix", "physics-%REGIONNAME%-");
+                    m_physicsLoggingFileMinutes = pConfig.GetInt("PhysicsLoggingFileMinutes", 5);
+                    m_physicsLoggingDoFlush = pConfig.GetBoolean("PhysicsLoggingDoFlush", false);
+                    m_physicsPhysicalDumpEnabled = pConfig.GetBoolean("PhysicsPhysicalDumpEnabled", false);
+                    // Very detailed logging for vehicle debugging
+                    VehicleLoggingEnabled = pConfig.GetBoolean("VehicleLoggingEnabled", false);
+                    VehiclePhysicalLoggingEnabled = pConfig.GetBoolean("VehiclePhysicalLoggingEnabled", false);
+
+                    // Do any replacements in the parameters
+                    m_physicsLoggingPrefix = m_physicsLoggingPrefix.Replace("%REGIONNAME%", RegionName);
+                }
+                else
+                {
+                    // Nothing in the configuration INI file so assume unmanaged and other defaults.
+                    BulletEngineName = "BulletUnmanaged";
+                    m_physicsLoggingEnabled = false;
+                    VehicleLoggingEnabled = false;
+                }
+
+                // The material characteristics.
+                BSMaterials.InitializeFromDefaults(Params);
+                if (pConfig != null)
+                {
+                    // Let the user add new and interesting material property values.
+                    BSMaterials.InitializefromParameters(pConfig);
+                }
+            }
+        }
+
+        // A helper function that handles a true/false parameter and returns the proper float number encoding
+        float ParamBoolean(IConfig config, string parmName, float deflt)
+        {
+            float ret = deflt;
+            if (config.Contains(parmName))
+            {
+                ret = ConfigurationParameters.numericFalse;
+                if (config.GetBoolean(parmName, false))
+                {
+                    ret = ConfigurationParameters.numericTrue;
+                }
+            }
+            return ret;
+        }
+
+        // Select the connection to the actual Bullet implementation.
+        // The main engine selection is the engineName up to the first hypen.
+        // So "Bullet-2.80-OpenCL-Intel" specifies the 'bullet' class here and the whole name
+        //     is passed to the engine to do its special selection, etc.
+        private BSAPITemplate SelectUnderlyingBulletEngine(string engineName)
+        {
+            // For the moment, do a simple switch statement.
+            // Someday do fancyness with looking up the interfaces in the assembly.
+            BSAPITemplate ret = null;
+
+            string selectionName = engineName.ToLower();
+            int hyphenIndex = engineName.IndexOf("-");
+            if (hyphenIndex > 0)
+                selectionName = engineName.ToLower().Substring(0, hyphenIndex - 1);
+
+            switch (selectionName)
+            {
+                case "bullet":
+                case "bulletunmanaged":
+                    ret = new BSAPIUnman(engineName, this);
+                    break;
+                case "bulletxna":
+                    ret = new BSAPIXNA(engineName, this);
+                    // Disable some features that are not implemented in BulletXNA
+                    m_log.InfoFormat("{0} Disabling some physics features not implemented by BulletXNA", LogHeader);
+                    m_log.InfoFormat("{0}    Disabling ShouldUseBulletHACD", LogHeader);
+                    BSParam.ShouldUseBulletHACD = false;
+                    m_log.InfoFormat("{0}    Disabling ShouldUseSingleConvexHullForPrims", LogHeader);
+                    BSParam.ShouldUseSingleConvexHullForPrims = false;
+                    m_log.InfoFormat("{0}    Disabling ShouldUseGImpactShapeForPrims", LogHeader);
+                    BSParam.ShouldUseGImpactShapeForPrims = false;
+                    m_log.InfoFormat("{0}    Setting terrain implimentation to Heightmap", LogHeader);
+                    BSParam.TerrainImplementation = (float)BSTerrainPhys.TerrainImplementation.Heightmap;
+                    break;
+            }
+
+            if (ret == null)
+            {
+                m_log.ErrorFormat("{0} COULD NOT SELECT BULLET ENGINE: '[BulletSim]PhysicsEngine' must be either 'BulletUnmanaged-*' or 'BulletXNA-*'", LogHeader);
+            }
+            else
+            {
+                m_log.InfoFormat("{0} Selected bullet engine {1} -> {2}/{3}", LogHeader, engineName, ret.BulletEngineName, ret.BulletEngineVersion);
+            }
+
+            return ret;
+        }
+
+        public override void Dispose()
+        {
+            // m_log.DebugFormat("{0}: Dispose()", LogHeader);
+
+            // make sure no stepping happens while we're deleting stuff
+            m_initialized = false;
+
+            lock (PhysObjects)
+            {
+                foreach (KeyValuePair<uint, BSPhysObject> kvp in PhysObjects)
+                {
+                    kvp.Value.Destroy();
+                }
+                PhysObjects.Clear();
+            }
+
+            // Now that the prims are all cleaned up, there should be no constraints left
+            if (Constraints != null)
+            {
+                Constraints.Dispose();
+                Constraints = null;
+            }
+
+            if (Shapes != null)
+            {
+                Shapes.Dispose();
+                Shapes = null;
+            }
+
+            if (TerrainManager != null)
+            {
+                TerrainManager.ReleaseGroundPlaneAndTerrain();
+                TerrainManager.Dispose();
+                TerrainManager = null;
+            }
+
+            // Anything left in the unmanaged code should be cleaned out
+            PE.Shutdown(World);
+
+            // Not logging any more
+            PhysicsLogging.Close();
+        }
+        #endregion // Construction and Initialization
+
+        #region Prim and Avatar addition and removal
+
+        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        {
+            m_log.ErrorFormat("{0}: CALL TO AddAvatar in BSScene. NOT IMPLEMENTED", LogHeader);
+            return null;
+        }
+
+        public override PhysicsActor AddAvatar(uint localID, string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        {
+            // m_log.DebugFormat("{0}: AddAvatar: {1}", LogHeader, avName);
+
+            if (!m_initialized) return null;
+
+            BSCharacter actor = new BSCharacter(localID, avName, this, position, velocity, size, isFlying);
+            lock (PhysObjects)
+                PhysObjects.Add(localID, actor);
+
+            // TODO: Remove kludge someday.
+            // We must generate a collision for avatars whether they collide or not.
+            // This is required by OpenSim to update avatar animations, etc.
+            lock (AvatarsInSceneLock)
+                AvatarsInScene.Add(actor);
+
+            return actor;
+        }
+
+        public override void RemoveAvatar(PhysicsActor actor)
+        {
+            // m_log.DebugFormat("{0}: RemoveAvatar", LogHeader);
+
+            if (!m_initialized) return;
+
+            BSCharacter bsactor = actor as BSCharacter;
+            if (bsactor != null)
+            {
+                try
+                {
+                    lock (PhysObjects)
+                        PhysObjects.Remove(bsactor.LocalID);
+                    // Remove kludge someday
+                    lock (AvatarsInSceneLock)
+                        AvatarsInScene.Remove(bsactor);
+                }
+                catch (Exception e)
+                {
+                    m_log.WarnFormat("{0}: Attempt to remove avatar that is not in physics scene: {1}", LogHeader, e);
+                }
+                bsactor.Destroy();
+                // bsactor.dispose();
+            }
+            else
+            {
+                m_log.ErrorFormat("{0}: Requested to remove avatar that is not a BSCharacter. ID={1}, type={2}",
+                                            LogHeader, actor.LocalID, actor.GetType().Name);
+            }
+        }
+
+        public override void RemovePrim(PhysicsActor prim)
+        {
+            if (!m_initialized) return;
+
+            BSPhysObject bsprim = prim as BSPhysObject;
+            if (bsprim != null)
+            {
+                DetailLog("{0},RemovePrim,call", bsprim.LocalID);
+                // m_log.DebugFormat("{0}: RemovePrim. id={1}/{2}", LogHeader, bsprim.Name, bsprim.LocalID);
+                try
+                {
+                    lock (PhysObjects) PhysObjects.Remove(bsprim.LocalID);
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat("{0}: Attempt to remove prim that is not in physics scene: {1}", LogHeader, e);
+                }
+                bsprim.Destroy();
+                // bsprim.dispose();
+            }
+            else
+            {
+                m_log.ErrorFormat("{0}: Attempt to remove prim that is not a BSPrim type.", LogHeader);
+            }
+        }
+
+        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, uint localID)
+        {
+            // m_log.DebugFormat("{0}: AddPrimShape2: {1}", LogHeader, primName);
+
+            if (!m_initialized) return null;
+
+            // DetailLog("{0},BSScene.AddPrimShape,call", localID);
+
+            BSPhysObject prim = new BSPrimLinkable(localID, primName, this, position, size, rotation, pbs, isPhysical);
+            lock (PhysObjects) PhysObjects.Add(localID, prim);
+            return prim;
+        }
+
+        // This is a call from the simulator saying that some physical property has been updated.
+        // The BulletSim driver senses the changing of relevant properties so this taint
+        // information call is not needed.
+        public override void AddPhysicsActorTaint(PhysicsActor prim) { }
+
+        #endregion // Prim and Avatar addition and removal
+
+        #region Simulation
+
+        // Call from the simulator to send physics information to the simulator objects.
+        // This pushes all the collision and property update events into the objects in
+        //    the simulator and, since it is on the heartbeat thread, there is an implicit
+        //    locking of those data structures from other heartbeat events.
+        // If the physics engine is running on a separate thread, the update information
+        //    will be in the ObjectsWithCollions and ObjectsWithUpdates structures.
+        public override float Simulate(float timeStep)
+        {
+            if (!BSParam.UseSeparatePhysicsThread)
+            {
+                DoPhysicsStep(timeStep);
+            }
+            return SendUpdatesToSimulator(timeStep);
+        }
+
+        // Call the physics engine to do one 'timeStep' and collect collisions and updates
+        //    into ObjectsWithCollisions and ObjectsWithUpdates data structures.
+        private void DoPhysicsStep(float timeStep)
+        {
+            // prevent simulation until we've been initialized
+            if (!m_initialized) return;
+
+            LastTimeStep = timeStep;
+
+            int updatedEntityCount = 0;
+            int collidersCount = 0;
+
+            int beforeTime = Util.EnvironmentTickCount();
+            int simTime = 0;
+
+            int numTaints = _taintOperations.Count;
+            InTaintTime = true; // Only used for debugging so locking is not necessary.
+
+            // update the prim states while we know the physics engine is not busy
+            ProcessTaints();
+
+            // Some of the physical objects requre individual, pre-step calls
+            //      (vehicles and avatar movement, in particular)
+            TriggerPreStepEvent(timeStep);
+
+            // the prestep actions might have added taints
+            numTaints += _taintOperations.Count;
+            ProcessTaints();
+
+            InTaintTime = false; // Only used for debugging so locking is not necessary.
+
+            // The following causes the unmanaged code to output ALL the values found in ALL the objects in the world.
+            // Only enable this in a limited test world with few objects.
+            if (m_physicsPhysicalDumpEnabled)
+                PE.DumpAllInfo(World);
+
+            // step the physical world one interval
+            m_simulationStep++;
+            int numSubSteps = 0;
+            try
+            {
+                numSubSteps = PE.PhysicsStep(World, timeStep, m_maxSubSteps, m_fixedTimeStep, out updatedEntityCount, out collidersCount);
+
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("{0},PhysicsStep Exception: nTaints={1}, substeps={2}, updates={3}, colliders={4}, e={5}",
+                            LogHeader, numTaints, numSubSteps, updatedEntityCount, collidersCount, e);
+                DetailLog("{0},PhysicsStepException,call, nTaints={1}, substeps={2}, updates={3}, colliders={4}",
+                            DetailLogZero, numTaints, numSubSteps, updatedEntityCount, collidersCount);
+                updatedEntityCount = 0;
+                collidersCount = 0;
+            }
+
+            // Make the physics engine dump useful statistics periodically
+            if (PhysicsMetricDumpFrames != 0 && ((m_simulationStep % PhysicsMetricDumpFrames) == 0))
+                PE.DumpPhysicsStatistics(World);
+
+            // Get a value for 'now' so all the collision and update routines don't have to get their own.
+            SimulationNowTime = Util.EnvironmentTickCount();
+
+            // Send collision information to the colliding objects. The objects decide if the collision
+            //     is 'real' (like linksets don't collide with themselves) and the individual objects
+            //     know if the simulator has subscribed to collisions.
+            lock (CollisionLock)
+            {
+                if (collidersCount > 0)
+                {
+                    lock (PhysObjects)
+                    {
+                        for (int ii = 0; ii < collidersCount; ii++)
+                        {
+                            uint cA = m_collisionArray[ii].aID;
+                            uint cB = m_collisionArray[ii].bID;
+                            Vector3 point = m_collisionArray[ii].point;
+                            Vector3 normal = m_collisionArray[ii].normal;
+                            float penetration = m_collisionArray[ii].penetration;
+                            SendCollision(cA, cB, point, normal, penetration);
+                            SendCollision(cB, cA, point, -normal, penetration);
+                        }
+                    }
+                }
+            }
+
+            // If any of the objects had updated properties, tell the managed objects about the update
+            //     and remember that there was a change so it will be passed to the simulator.
+            lock (UpdateLock)
+            {
+                if (updatedEntityCount > 0)
+                {
+                    lock (PhysObjects)
+                    {
+                        for (int ii = 0; ii < updatedEntityCount; ii++)
+                        {
+                            EntityProperties entprop = m_updateArray[ii];
+                            BSPhysObject pobj;
+                            if (PhysObjects.TryGetValue(entprop.ID, out pobj))
+                            {
+                                if (pobj.IsInitialized)
+                                    pobj.UpdateProperties(entprop);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Some actors want to know when the simulation step is complete.
+            TriggerPostStepEvent(timeStep);
+
+            simTime = Util.EnvironmentTickCountSubtract(beforeTime);
+            if (PhysicsLogging.Enabled)
+            {
+                DetailLog("{0},DoPhysicsStep,complete,frame={1}, nTaints={2}, simTime={3}, substeps={4}, updates={5}, colliders={6}, objWColl={7}",
+                                        DetailLogZero, m_simulationStep, numTaints, simTime, numSubSteps,
+                                        updatedEntityCount, collidersCount, ObjectsWithCollisions.Count);
+            }
+
+            // The following causes the unmanaged code to output ALL the values found in ALL the objects in the world.
+            // Only enable this in a limited test world with few objects.
+            if (m_physicsPhysicalDumpEnabled)
+                PE.DumpAllInfo(World);
+
+            // 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;
+        }
+
+        // Called by a BSPhysObject to note that it has changed properties and this information
+        //    should be passed up to the simulator at the proper time.
+        // Note: this is called by the BSPhysObject from invocation via DoPhysicsStep() above so
+        //    this is is under UpdateLock.
+        public void PostUpdate(BSPhysObject updatee)
+        {
+            lock (UpdateLock)
+            {
+                ObjectsWithUpdates.Add(updatee);
+            }
+        }
+
+        // The simulator thinks it is physics time so return all the collisions and position
+        //     updates that were collected in actual physics simulation.
+        private float SendUpdatesToSimulator(float timeStep)
+        {
+            if (!m_initialized) return 5.0f;
+
+            DetailLog("{0},SendUpdatesToSimulator,collisions={1},updates={2},simedTime={3}",
+                BSScene.DetailLogZero, ObjectsWithCollisions.Count, ObjectsWithUpdates.Count, m_simulatedTime);
+            // Push the collisions into the simulator.
+            lock (CollisionLock)
+            {
+                if (ObjectsWithCollisions.Count > 0)
+                {
+                    foreach (BSPhysObject bsp in ObjectsWithCollisions)
+                        if (!bsp.SendCollisions())
+                        {
+                            // If the object is done colliding, see that it's removed from the colliding list
+                            ObjectsWithNoMoreCollisions.Add(bsp);
+                        }
+                }
+
+                // This is a kludge to get avatar movement updates.
+                // The simulator expects collisions for avatars even if there are have been no collisions.
+                //    The event updates avatar animations and stuff.
+                // If you fix avatar animation updates, remove this overhead and let normal collision processing happen.
+                // Note that we get a copy of the list to search because SendCollision() can take a while.
+                HashSet<BSPhysObject> tempAvatarsInScene;
+                lock (AvatarsInSceneLock)
+                {
+                    tempAvatarsInScene = new HashSet<BSPhysObject>(AvatarsInScene);
+                }
+                foreach (BSPhysObject actor in tempAvatarsInScene)
+                {
+                    if (!ObjectsWithCollisions.Contains(actor))   // don't call avatars twice
+                        actor.SendCollisions();
+                }
+                tempAvatarsInScene = null;
+
+                // Objects that are done colliding are removed from the ObjectsWithCollisions list.
+                // Not done above because it is inside an iteration of ObjectWithCollisions.
+                // This complex collision processing is required to create an empty collision
+                //     event call after all real collisions have happened on an object. This allows
+                //     the simulator to generate the 'collision end' event.
+                if (ObjectsWithNoMoreCollisions.Count > 0)
+                {
+                    foreach (BSPhysObject po in ObjectsWithNoMoreCollisions)
+                        ObjectsWithCollisions.Remove(po);
+                    ObjectsWithNoMoreCollisions.Clear();
+                }
+            }
+
+            // Call the simulator for each object that has physics property updates.
+            HashSet<BSPhysObject> updatedObjects = null;
+            lock (UpdateLock)
+            {
+                if (ObjectsWithUpdates.Count > 0)
+                {
+                    updatedObjects = ObjectsWithUpdates;
+                    ObjectsWithUpdates = new HashSet<BSPhysObject>();
+                }
+            }
+            if (updatedObjects != null)
+            {
+                foreach (BSPhysObject obj in updatedObjects)
+                {
+                    obj.RequestPhysicsterseUpdate();
+                }
+                updatedObjects.Clear();
+            }
+
+            // 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;
+            m_simulatedTime = 0f;
+            return simTime;
+        }
+
+        // Something has collided
+        private void SendCollision(uint localID, uint collidingWith, Vector3 collidePoint, Vector3 collideNormal, float penetration)
+        {
+            if (localID <= TerrainManager.HighestTerrainID)
+            {
+                return;         // don't send collisions to the terrain
+            }
+
+            BSPhysObject collider;
+            // NOTE that PhysObjects was locked before the call to SendCollision().
+            if (!PhysObjects.TryGetValue(localID, out collider))
+            {
+                // If the object that is colliding cannot be found, just ignore the collision.
+                DetailLog("{0},BSScene.SendCollision,colliderNotInObjectList,id={1},with={2}", DetailLogZero, localID, collidingWith);
+                return;
+            }
+
+            // Note: the terrain is not in the physical object list so 'collidee' can be null when Collide() is called.
+            BSPhysObject collidee = null;
+            PhysObjects.TryGetValue(collidingWith, out collidee);
+
+            // DetailLog("{0},BSScene.SendCollision,collide,id={1},with={2}", DetailLogZero, localID, collidingWith);
+
+            if (collider.IsInitialized)
+            {
+                if (collider.Collide(collidingWith, collidee, collidePoint, collideNormal, penetration))
+                {
+                    // If a collision was 'good', remember to send it to the simulator
+                    lock (CollisionLock)
+                    {
+                        ObjectsWithCollisions.Add(collider);
+                    }
+                }
+            }
+
+            return;
+        }
+
+        public void BulletSPluginPhysicsThread()
+        {
+            Thread.CurrentThread.Priority = ThreadPriority.Highest;
+            m_updateWaitEvent = new ManualResetEvent(false);
+
+            while (m_initialized)
+            {
+                int beginSimulationRealtimeMS = Util.EnvironmentTickCount();
+
+                if (BSParam.Active)
+                    DoPhysicsStep(BSParam.PhysicsTimeStep);
+
+                int simulationRealtimeMS = Util.EnvironmentTickCountSubtract(beginSimulationRealtimeMS);
+                int simulationTimeVsRealtimeDifferenceMS = ((int)(BSParam.PhysicsTimeStep*1000f)) - simulationRealtimeMS;
+
+                if (simulationTimeVsRealtimeDifferenceMS > 0)
+                {
+                    // The simulation of the time interval took less than realtime.
+                    // Do a wait for the rest of realtime.
+                     m_updateWaitEvent.WaitOne(simulationTimeVsRealtimeDifferenceMS);
+                    //Thread.Sleep(simulationTimeVsRealtimeDifferenceMS);
+                }
+                else
+                {
+                    // The simulation took longer than realtime.
+                    // Do some scaling of simulation time.
+                    // TODO.
+                    DetailLog("{0},BulletSPluginPhysicsThread,longerThanRealtime={1}", BSScene.DetailLogZero, simulationTimeVsRealtimeDifferenceMS);
+                }
+
+                Watchdog.UpdateThread();
+            }
+
+            Watchdog.RemoveThread();
+        }
+
+        #endregion // Simulation
+
+        public override void GetResults() { }
+
+        #region Terrain
+
+        public override void SetTerrain(float[] heightMap) {
+            TerrainManager.SetTerrain(heightMap);
+        }
+
+        public override void SetWaterLevel(float baseheight)
+        {
+            SimpleWaterLevel = baseheight;
+        }
+
+        public override void DeleteTerrain()
+        {
+            // m_log.DebugFormat("{0}: DeleteTerrain()", LogHeader);
+        }
+
+        // Although no one seems to check this, I do support combining.
+        public override bool SupportsCombining()
+        {
+            return TerrainManager.SupportsCombining();
+        }
+        // This call says I am a child to region zero in a mega-region. 'pScene' is that
+        //    of region zero, 'offset' is my offset from regions zero's origin, and
+        //    'extents' is the largest XY that is handled in my region.
+        public override void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents)
+        {
+            TerrainManager.Combine(pScene, offset, extents);
+        }
+
+        // Unhook all the combining that I know about.
+        public override void UnCombine(PhysicsScene pScene)
+        {
+            TerrainManager.UnCombine(pScene);
+        }
+
+        #endregion // Terrain
+
+        public override Dictionary<uint, float> GetTopColliders()
+        {
+            Dictionary<uint, float> topColliders;
+
+            lock (PhysObjects)
+            {
+                foreach (KeyValuePair<uint, BSPhysObject> kvp in PhysObjects)
+                {
+                    kvp.Value.ComputeCollisionScore();
+                }
+
+                List<BSPhysObject> orderedPrims = new List<BSPhysObject>(PhysObjects.Values);
+                orderedPrims.OrderByDescending(p => p.CollisionScore);
+                topColliders = orderedPrims.Take(25).ToDictionary(p => p.LocalID, p => p.CollisionScore);
+            }
+
+            return topColliders;
+        }
+
+        public override bool IsThreaded { get { return false;  } }
+
+        #region Extensions
+        public override object Extension(string pFunct, params object[] pParams)
+        {
+            DetailLog("{0} BSScene.Extension,op={1}", DetailLogZero, pFunct);
+            return base.Extension(pFunct, pParams);
+        }
+        #endregion // Extensions
+
+        public static string PrimitiveBaseShapeToString(PrimitiveBaseShape pbs)
+        {
+            float pathShearX = pbs.PathShearX < 128 ? (float)pbs.PathShearX * 0.01f : (float)(pbs.PathShearX - 256) * 0.01f;
+            float pathShearY = pbs.PathShearY < 128 ? (float)pbs.PathShearY * 0.01f : (float)(pbs.PathShearY - 256) * 0.01f;
+            float pathBegin = (float)pbs.PathBegin * 2.0e-5f;
+            float pathEnd = 1.0f - (float)pbs.PathEnd * 2.0e-5f;
+            float pathScaleX = (float)(200 - pbs.PathScaleX) * 0.01f;
+            float pathScaleY = (float)(200 - pbs.PathScaleY) * 0.01f;
+            float pathTaperX = pbs.PathTaperX * 0.01f;
+            float pathTaperY = pbs.PathTaperY * 0.01f;
+
+            float profileBegin = (float)pbs.ProfileBegin * 2.0e-5f;
+            float profileEnd = 1.0f - (float)pbs.ProfileEnd * 2.0e-5f;
+            float profileHollow = (float)pbs.ProfileHollow * 2.0e-5f;
+            if (profileHollow > 0.95f)
+                profileHollow = 0.95f;
+
+            StringBuilder buff = new StringBuilder();
+            buff.Append("shape=");
+            buff.Append(((ProfileShape)pbs.ProfileShape).ToString());
+            buff.Append(",");
+            buff.Append("hollow=");
+            buff.Append(((HollowShape)pbs.HollowShape).ToString());
+            buff.Append(",");
+            buff.Append("pathCurve=");
+            buff.Append(((Extrusion)pbs.PathCurve).ToString());
+            buff.Append(",");
+            buff.Append("profCurve=");
+            buff.Append(((Extrusion)pbs.ProfileCurve).ToString());
+            buff.Append(",");
+            buff.Append("profHollow=");
+            buff.Append(profileHollow.ToString());
+            buff.Append(",");
+            buff.Append("pathBegEnd=");
+            buff.Append(pathBegin.ToString());
+            buff.Append("/");
+            buff.Append(pathEnd.ToString());
+            buff.Append(",");
+            buff.Append("profileBegEnd=");
+            buff.Append(profileBegin.ToString());
+            buff.Append("/");
+            buff.Append(profileEnd.ToString());
+            buff.Append(",");
+            buff.Append("scaleXY=");
+            buff.Append(pathScaleX.ToString());
+            buff.Append("/");
+            buff.Append(pathScaleY.ToString());
+            buff.Append(",");
+            buff.Append("shearXY=");
+            buff.Append(pathShearX.ToString());
+            buff.Append("/");
+            buff.Append(pathShearY.ToString());
+            buff.Append(",");
+            buff.Append("taperXY=");
+            buff.Append(pbs.PathTaperX.ToString());
+            buff.Append("/");
+            buff.Append(pbs.PathTaperY.ToString());
+            buff.Append(",");
+            buff.Append("skew=");
+            buff.Append(pbs.PathSkew.ToString());
+            buff.Append(",");
+            buff.Append("twist/Beg=");
+            buff.Append(pbs.PathTwist.ToString());
+            buff.Append("/");
+            buff.Append(pbs.PathTwistBegin.ToString());
+
+            return buff.ToString();
+        }
+
+        #region Taints
+        // The simulation execution order is:
+        // Simulate()
+        //    DoOneTimeTaints
+        //    TriggerPreStepEvent
+        //    DoOneTimeTaints
+        //    Step()
+        //       ProcessAndSendToSimulatorCollisions
+        //       ProcessAndSendToSimulatorPropertyUpdates
+        //    TriggerPostStepEvent
+
+        // Calls to the PhysicsActors can't directly call into the physics engine
+        //       because it might be busy. We delay changes to a known time.
+        // We rely on C#'s closure to save and restore the context for the delegate.
+        public void TaintedObject(string pOriginator, string pIdent, TaintCallback pCallback)
+        {
+            TaintedObject(false /*inTaintTime*/, pOriginator, pIdent, pCallback);
+        }
+        public void TaintedObject(uint pOriginator, String pIdent, TaintCallback pCallback)
+        {
+            TaintedObject(false /*inTaintTime*/, m_physicsLoggingEnabled ? pOriginator.ToString() : BSScene.DetailLogZero, pIdent, pCallback);
+        }
+        public void TaintedObject(bool inTaintTime, String pIdent, TaintCallback pCallback)
+        {
+            TaintedObject(inTaintTime, BSScene.DetailLogZero, pIdent, pCallback);
+        }
+        public void TaintedObject(bool inTaintTime, uint pOriginator, String pIdent, TaintCallback pCallback)
+        {
+            TaintedObject(inTaintTime, m_physicsLoggingEnabled ? pOriginator.ToString() : BSScene.DetailLogZero, pIdent, pCallback);
+        }
+        // Sometimes a potentially tainted operation can be used in and out of taint time.
+        // This routine executes the command immediately if in taint-time otherwise it is queued.
+        public void TaintedObject(bool inTaintTime, string pOriginator, string pIdent, TaintCallback pCallback)
+        {
+            if (!m_initialized) return;
+
+            if (inTaintTime)
+                pCallback();
+            else
+            {
+                lock (_taintLock)
+                {
+                    _taintOperations.Add(new TaintCallbackEntry(pOriginator, pIdent, pCallback));
+                }
+            }
+        }
+
+        private void TriggerPreStepEvent(float timeStep)
+        {
+            PreStepAction actions = BeforeStep;
+            if (actions != null)
+                actions(timeStep);
+
+        }
+
+        private void TriggerPostStepEvent(float timeStep)
+        {
+            PostStepAction actions = AfterStep;
+            if (actions != null)
+                actions(timeStep);
+
+        }
+
+        // When someone tries to change a property on a BSPrim or BSCharacter, the object queues
+        // a callback into itself to do the actual property change. That callback is called
+        // here just before the physics engine is called to step the simulation.
+        public void ProcessTaints()
+        {
+            ProcessRegularTaints();
+            ProcessPostTaintTaints();
+        }
+
+        private void ProcessRegularTaints()
+        {
+            if (m_initialized && _taintOperations.Count > 0)  // save allocating new list if there is nothing to process
+            {
+                // swizzle a new list into the list location so we can process what's there
+                List<TaintCallbackEntry> oldList;
+                lock (_taintLock)
+                {
+                    oldList = _taintOperations;
+                    _taintOperations = new List<TaintCallbackEntry>();
+                }
+
+                foreach (TaintCallbackEntry tcbe in oldList)
+                {
+                    try
+                    {
+                        DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", tcbe.originator, tcbe.ident); // DEBUG DEBUG DEBUG
+                        tcbe.callback();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("{0}: ProcessTaints: {1}: Exception: {2}", LogHeader, tcbe.ident, e);
+                    }
+                }
+                oldList.Clear();
+            }
+        }
+
+        // Schedule an update to happen after all the regular taints are processed.
+        // Note that new requests for the same operation ("ident") for the same object ("ID")
+        //     will replace any previous operation by the same object.
+        public void PostTaintObject(String ident, uint ID, TaintCallback callback)
+        {
+            string IDAsString = ID.ToString();
+            string uniqueIdent = ident + "-" + IDAsString;
+            lock (_taintLock)
+            {
+                _postTaintOperations[uniqueIdent] = new TaintCallbackEntry(IDAsString, uniqueIdent, callback);
+            }
+
+            return;
+        }
+
+        // Taints that happen after the normal taint processing but before the simulation step.
+        private void ProcessPostTaintTaints()
+        {
+            if (m_initialized && _postTaintOperations.Count > 0)
+            {
+                Dictionary<string, TaintCallbackEntry> oldList;
+                lock (_taintLock)
+                {
+                    oldList = _postTaintOperations;
+                    _postTaintOperations = new Dictionary<string, TaintCallbackEntry>();
+                }
+
+                foreach (KeyValuePair<string,TaintCallbackEntry> kvp in oldList)
+                {
+                    try
+                    {
+                        DetailLog("{0},BSScene.ProcessPostTaintTaints,doTaint,id={1}", DetailLogZero, kvp.Key); // DEBUG DEBUG DEBUG
+                        kvp.Value.callback();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("{0}: ProcessPostTaintTaints: {1}: Exception: {2}", LogHeader, kvp.Key, e);
+                    }
+                }
+                oldList.Clear();
+            }
+        }
+
+        // Only used for debugging. Does not change state of anything so locking is not necessary.
+        public bool AssertInTaintTime(string whereFrom)
+        {
+            if (!InTaintTime)
+            {
+                DetailLog("{0},BSScene.AssertInTaintTime,NOT IN TAINT TIME,Region={1},Where={2}", DetailLogZero, RegionName, whereFrom);
+                m_log.ErrorFormat("{0} NOT IN TAINT TIME!! Region={1}, Where={2}", LogHeader, RegionName, whereFrom);
+                // Util.PrintCallStack(DetailLog);
+            }
+            return InTaintTime;
+        }
+
+        #endregion // Taints
+
+        #region IPhysicsParameters
+        // Get the list of parameters this physics engine supports
+        public PhysParameterEntry[] GetParameterList()
+        {
+            BSParam.BuildParameterTable();
+            return BSParam.SettableParameters;
+        }
+
+        // Set parameter on a specific or all instances.
+        // Return 'false' if not able to set the parameter.
+        // Setting the value in the m_params block will change the value the physics engine
+        //   will use the next time since it's pinned and shared memory.
+        // Some of the values require calling into the physics engine to get the new
+        //   value activated ('terrainFriction' for instance).
+        public bool SetPhysicsParameter(string parm, string val, uint localID)
+        {
+            bool ret = false;
+
+            BSParam.ParameterDefnBase theParam;
+            if (BSParam.TryGetParameter(parm, out theParam))
+            {
+                // Set the value in the C# code
+                theParam.SetValue(this, val);
+
+                // Optionally set the parameter in the unmanaged code
+                if (theParam.HasSetOnObject)
+                {
+                    // update all the localIDs specified
+                    // If the local ID is APPLY_TO_NONE, just change the default value
+                    // If the localID is APPLY_TO_ALL change the default value and apply the new value to all the lIDs
+                    // If the localID is a specific object, apply the parameter change to only that object
+                    List<uint> objectIDs = new List<uint>();
+                    switch (localID)
+                    {
+                        case PhysParameterEntry.APPLY_TO_NONE:
+                            // This will cause a call into the physical world if some operation is specified (SetOnObject).
+                            objectIDs.Add(TERRAIN_ID);
+                            TaintedUpdateParameter(parm, objectIDs, val);
+                            break;
+                        case PhysParameterEntry.APPLY_TO_ALL:
+                            lock (PhysObjects) objectIDs = new List<uint>(PhysObjects.Keys);
+                            TaintedUpdateParameter(parm, objectIDs, val);
+                            break;
+                        default:
+                            // setting only one localID
+                            objectIDs.Add(localID);
+                            TaintedUpdateParameter(parm, objectIDs, val);
+                            break;
+                    }
+                }
+
+                ret = true;
+            }
+            return ret;
+        }
+
+        // schedule the actual updating of the paramter to when the phys engine is not busy
+        private void TaintedUpdateParameter(string parm, List<uint> lIDs, string val)
+        {
+            string xval = val;
+            List<uint> xlIDs = lIDs;
+            string xparm = parm;
+            TaintedObject(DetailLogZero, "BSScene.UpdateParameterSet", delegate() {
+                BSParam.ParameterDefnBase thisParam;
+                if (BSParam.TryGetParameter(xparm, out thisParam))
+                {
+                    if (thisParam.HasSetOnObject)
+                    {
+                        foreach (uint lID in xlIDs)
+                        {
+                            BSPhysObject theObject = null;
+                            if (PhysObjects.TryGetValue(lID, out theObject))
+                                thisParam.SetOnObject(this, theObject);
+                        }
+                    }
+                }
+            });
+        }
+
+        // Get parameter.
+        // Return 'false' if not able to get the parameter.
+        public bool GetPhysicsParameter(string parm, out string value)
+        {
+            string val = String.Empty;
+            bool ret = false;
+            BSParam.ParameterDefnBase theParam;
+            if (BSParam.TryGetParameter(parm, out theParam))
+            {
+                val = theParam.GetValue(this);
+                ret = true;
+            }
+            value = val;
+            return ret;
+        }
+
+        #endregion IPhysicsParameters
+
+        // Invoke the detailed logger and output something if it's enabled.
+        public void DetailLog(string msg, params Object[] args)
+        {
+            PhysicsLogging.Write(msg, args);
+        }
+        // Used to fill in the LocalID when there isn't one. It's the correct number of characters.
+        public const string DetailLogZero = "0000000000";
+
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSShapeCollection.cs b/OpenSim/Region/PhysicsModules/BulletS/BSShapeCollection.cs
new file mode 100755
index 0000000..b100273
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSShapeCollection.cs
@@ -0,0 +1,425 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OMV = OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public sealed class BSShapeCollection : IDisposable
+{
+#pragma warning disable 414
+    private static string LogHeader = "[BULLETSIM SHAPE COLLECTION]";
+#pragma warning restore 414
+
+    private BSScene m_physicsScene { get; set; }
+
+    private Object m_collectionActivityLock = new Object();
+
+    private bool DDetail = false;
+
+    public BSShapeCollection(BSScene physScene)
+    {
+        m_physicsScene = physScene;
+        // Set the next to 'true' for very detailed shape update detailed logging (detailed details?)
+        // While detailed debugging is still active, this is better than commenting out all the
+        //     DetailLog statements. When debugging slows down, this and the protected logging
+        //     statements can be commented/removed.
+        DDetail = true;
+    }
+
+    public void Dispose()
+    {
+        // TODO!!!!!!!!!
+    }
+
+    // Callbacks called just before either the body or shape is destroyed.
+    // Mostly used for changing bodies out from under Linksets.
+    // Useful for other cases where parameters need saving.
+    // Passing 'null' says no callback.
+    public delegate void PhysicalDestructionCallback(BulletBody pBody, BulletShape pShape);
+
+    // Called to update/change the body and shape for an object.
+    // The object has some shape and body on it. Here we decide if that is the correct shape
+    //    for the current state of the object (static/dynamic/...).
+    // If bodyCallback is not null, it is called if either the body or the shape are changed
+    //    so dependencies (like constraints) can be removed before the physical object is dereferenced.
+    // Return 'true' if either the body or the shape changed.
+    // Called at taint-time.
+    public bool GetBodyAndShape(bool forceRebuild, BulletWorld sim, BSPhysObject prim, PhysicalDestructionCallback bodyCallback)
+    {
+        m_physicsScene.AssertInTaintTime("BSShapeCollection.GetBodyAndShape");
+
+        bool ret = false;
+
+        // This lock could probably be pushed down lower but building shouldn't take long
+        lock (m_collectionActivityLock)
+        {
+            // Do we have the correct geometry for this type of object?
+            // Updates prim.BSShape with information/pointers to shape.
+            // Returns 'true' of BSShape is changed to a new shape.
+            bool newGeom = CreateGeom(forceRebuild, prim, bodyCallback);
+            // If we had to select a new shape geometry for the object,
+            //    rebuild the body around it.
+            // Updates prim.BSBody with information/pointers to requested body
+            // Returns 'true' if BSBody was changed.
+            bool newBody = CreateBody((newGeom || forceRebuild), prim, m_physicsScene.World, bodyCallback);
+            ret = newGeom || newBody;
+        }
+        DetailLog("{0},BSShapeCollection.GetBodyAndShape,taintExit,force={1},ret={2},body={3},shape={4}",
+                                prim.LocalID, forceRebuild, ret, prim.PhysBody, prim.PhysShape);
+
+        return ret;
+    }
+
+    public bool GetBodyAndShape(bool forceRebuild, BulletWorld sim, BSPhysObject prim)
+    {
+        return GetBodyAndShape(forceRebuild, sim, prim, null);
+    }
+
+    // If the existing prim's shape is to be replaced, remove the tie to the existing shape
+    //     before replacing it.
+    private void DereferenceExistingShape(BSPhysObject prim, PhysicalDestructionCallback shapeCallback)
+    {
+        if (prim.PhysShape.HasPhysicalShape)
+        {
+            if (shapeCallback != null)
+                shapeCallback(prim.PhysBody, prim.PhysShape.physShapeInfo);
+            prim.PhysShape.Dereference(m_physicsScene);
+        }
+        prim.PhysShape = new BSShapeNull();
+    }
+
+    // Create the geometry information in Bullet for later use.
+    // The objects needs a hull if it's physical otherwise a mesh is enough.
+    // if 'forceRebuild' is true, the geometry is unconditionally rebuilt. For meshes and hulls,
+    //     shared geometries will be used. If the parameters of the existing shape are the same
+    //     as this request, the shape is not rebuilt.
+    // Info in prim.BSShape is updated to the new shape.
+    // Returns 'true' if the geometry was rebuilt.
+    // Called at taint-time!
+    public const int AvatarShapeCapsule = 0;
+    public const int AvatarShapeCube = 1;
+    public const int AvatarShapeOvoid = 2;
+    public const int AvatarShapeMesh = 3;
+    private bool CreateGeom(bool forceRebuild, BSPhysObject prim, PhysicalDestructionCallback shapeCallback)
+    {
+        bool ret = false;
+        bool haveShape = false;
+        bool nativeShapePossible = true;
+        PrimitiveBaseShape pbs = prim.BaseShape;
+
+        // Kludge to create the capsule for the avatar.
+        // TDOD: Remove/redo this when BSShapeAvatar is working!!
+        BSCharacter theChar = prim as BSCharacter;
+        if (theChar != null)
+        {
+            DereferenceExistingShape(prim, shapeCallback);
+            switch (BSParam.AvatarShape)
+            {
+                case AvatarShapeCapsule:
+                    prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+                                            BSPhysicsShapeType.SHAPE_CAPSULE, FixedShapeKey.KEY_CAPSULE);
+                    ret = true;
+                    haveShape = true;
+                    break;
+                case AvatarShapeCube:
+                    prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+                                            BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_CAPSULE);
+                    ret = true;
+                    haveShape = true;
+                    break;
+                case AvatarShapeOvoid:
+                    // Saddly, Bullet doesn't scale spheres so this doesn't work as an avatar shape
+                    prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+                                            BSPhysicsShapeType.SHAPE_SPHERE, FixedShapeKey.KEY_CAPSULE);
+                    ret = true;
+                    haveShape = true;
+                    break;
+                case AvatarShapeMesh:
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        // If the prim attributes are simple, this could be a simple Bullet native shape
+        // Native shapes work whether to object is static or physical.
+        if (!haveShape
+                && nativeShapePossible
+                && pbs != null
+                && PrimHasNoCuts(pbs)
+                && ( !pbs.SculptEntry || (pbs.SculptEntry && !BSParam.ShouldMeshSculptedPrim) )
+            )
+        {
+            // Get the scale of any existing shape so we can see if the new shape is same native type and same size.
+            OMV.Vector3 scaleOfExistingShape = OMV.Vector3.Zero;
+            if (prim.PhysShape.HasPhysicalShape)
+                scaleOfExistingShape = m_physicsScene.PE.GetLocalScaling(prim.PhysShape.physShapeInfo);
+
+            if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,maybeNative,force={1},primScale={2},primSize={3},primShape={4}",
+                        prim.LocalID, forceRebuild, prim.Scale, prim.Size, prim.PhysShape.physShapeInfo.shapeType);
+
+            // It doesn't look like Bullet scales native spheres so make sure the scales are all equal
+            if ((pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1)
+                                && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z)
+            {
+                haveShape = true;
+                if (forceRebuild
+                        || prim.PhysShape.ShapeType != BSPhysicsShapeType.SHAPE_SPHERE
+                    )
+                {
+                    DereferenceExistingShape(prim, shapeCallback);
+                    prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+                                            BSPhysicsShapeType.SHAPE_SPHERE, FixedShapeKey.KEY_SPHERE);
+                    ret = true;
+                }
+                if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,sphere,force={1},rebuilt={2},shape={3}",
+                                        prim.LocalID, forceRebuild, ret, prim.PhysShape);
+            }
+            // If we didn't make a sphere, maybe a box will work.
+            if (!haveShape && pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight)
+            {
+                haveShape = true;
+                if (forceRebuild
+                        || prim.Scale != scaleOfExistingShape
+                        || prim.PhysShape.ShapeType != BSPhysicsShapeType.SHAPE_BOX
+                        )
+                {
+                    DereferenceExistingShape(prim, shapeCallback);
+                    prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+                                            BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
+                    ret = true;
+                }
+                if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,box,force={1},rebuilt={2},shape={3}",
+                                        prim.LocalID, forceRebuild, ret, prim.PhysShape);
+            }
+        }
+
+        // If a simple shape is not happening, create a mesh and possibly a hull.
+        if (!haveShape && pbs != null)
+        {
+            ret = CreateGeomMeshOrHull(prim, shapeCallback);
+        }
+
+        return ret;
+    }
+
+    // return 'true' if this shape description does not include any cutting or twisting.
+    public static bool PrimHasNoCuts(PrimitiveBaseShape pbs)
+    {
+        return pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0
+            && pbs.ProfileHollow == 0
+            && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0
+            && pbs.PathBegin == 0 && pbs.PathEnd == 0
+            && pbs.PathTaperX == 0 && pbs.PathTaperY == 0
+            && pbs.PathScaleX == 100 && pbs.PathScaleY == 100
+            && pbs.PathShearX == 0 && pbs.PathShearY == 0;
+    }
+
+    // return 'true' if the prim's shape was changed.
+    private bool CreateGeomMeshOrHull(BSPhysObject prim, PhysicalDestructionCallback shapeCallback)
+    {
+
+        bool ret = false;
+        // Note that if it's a native shape, the check for physical/non-physical is not
+        //     made. Native shapes work in either case.
+        if (prim.IsPhysical && BSParam.ShouldUseHullsForPhysicalObjects)
+        {
+            // Use a simple, single mesh convex hull shape if the object is simple enough
+            BSShape potentialHull = null;
+
+            PrimitiveBaseShape pbs = prim.BaseShape;
+            // Use a simple, one section convex shape for prims that are probably convex (no cuts or twists)
+            if (BSParam.ShouldUseSingleConvexHullForPrims
+                && pbs != null
+                && !pbs.SculptEntry
+                && PrimHasNoCuts(pbs)
+                )
+            {
+                potentialHull = BSShapeConvexHull.GetReference(m_physicsScene, false /* forceRebuild */, prim);
+            }
+            // Use the GImpact shape if it is a prim that has some concaveness
+            if (potentialHull == null
+                && BSParam.ShouldUseGImpactShapeForPrims
+                && pbs != null
+                && !pbs.SculptEntry
+                )
+            {
+                    potentialHull = BSShapeGImpact.GetReference(m_physicsScene, false /* forceRebuild */, prim);
+            }
+            // If not any of the simple cases, just make a hull
+            if (potentialHull == null)
+            {
+                potentialHull = BSShapeHull.GetReference(m_physicsScene, false /*forceRebuild*/, prim);
+            }
+
+            // If the current shape is not what is on the prim at the moment, time to change.
+            if (!prim.PhysShape.HasPhysicalShape
+                        || potentialHull.ShapeType != prim.PhysShape.ShapeType
+                        || potentialHull.physShapeInfo.shapeKey != prim.PhysShape.physShapeInfo.shapeKey)
+            {
+                DereferenceExistingShape(prim, shapeCallback);
+                prim.PhysShape = potentialHull;
+                ret = true;
+            }
+            else
+            {
+                // The current shape on the prim is the correct one. We don't need the potential reference.
+                potentialHull.Dereference(m_physicsScene);
+            }
+            if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,hull,shape={1}", prim.LocalID, prim.PhysShape);
+        }
+        else
+        {
+            // Non-physical objects should be just meshes.
+            BSShape potentialMesh = BSShapeMesh.GetReference(m_physicsScene, false /*forceRebuild*/, prim);
+            // If the current shape is not what is on the prim at the moment, time to change.
+            if (!prim.PhysShape.HasPhysicalShape
+                        || potentialMesh.ShapeType != prim.PhysShape.ShapeType
+                        || potentialMesh.physShapeInfo.shapeKey != prim.PhysShape.physShapeInfo.shapeKey)
+            {
+                DereferenceExistingShape(prim, shapeCallback);
+                prim.PhysShape = potentialMesh;
+                ret = true;
+            }
+            else
+            {
+                // We don't need this reference to the mesh that is already being using.
+                potentialMesh.Dereference(m_physicsScene);
+            }
+            if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,mesh,shape={1}", prim.LocalID, prim.PhysShape);
+        }
+        return ret;
+    }
+
+    // Track another user of a body.
+    // We presume the caller has allocated the body.
+    // Bodies only have one user so the body is just put into the world if not already there.
+    private void ReferenceBody(BulletBody body)
+    {
+        lock (m_collectionActivityLock)
+        {
+            if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceBody,newBody,body={1}", body.ID, body);
+            if (!m_physicsScene.PE.IsInWorld(m_physicsScene.World, body))
+            {
+                m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, body);
+                if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceBody,addedToWorld,ref={1}", body.ID, body);
+            }
+        }
+    }
+
+    // Release the usage of a body.
+    // Called when releasing use of a BSBody. BSShape is handled separately.
+    // Called in taint time.
+    public void DereferenceBody(BulletBody body, PhysicalDestructionCallback bodyCallback )
+    {
+        if (!body.HasPhysicalBody)
+            return;
+
+        m_physicsScene.AssertInTaintTime("BSShapeCollection.DereferenceBody");
+
+        lock (m_collectionActivityLock)
+        {
+            if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceBody,DestroyingBody,body={1}", body.ID, body);
+            // If the caller needs to know the old body is going away, pass the event up.
+            if (bodyCallback != null)
+                bodyCallback(body, null);
+
+            // Removing an object not in the world is a NOOP
+            m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, body);
+
+            // Zero any reference to the shape so it is not freed when the body is deleted.
+            m_physicsScene.PE.SetCollisionShape(m_physicsScene.World, body, null);
+
+            m_physicsScene.PE.DestroyObject(m_physicsScene.World, body);
+        }
+    }
+
+    // Create a body object in Bullet.
+    // Updates prim.BSBody with the information about the new body if one is created.
+    // Returns 'true' if an object was actually created.
+    // Called at taint-time.
+    private bool CreateBody(bool forceRebuild, BSPhysObject prim, BulletWorld sim, PhysicalDestructionCallback bodyCallback)
+    {
+        bool ret = false;
+
+        // the mesh, hull or native shape must have already been created in Bullet
+        bool mustRebuild = !prim.PhysBody.HasPhysicalBody;
+
+        // If there is an existing body, verify it's of an acceptable type.
+        // If not a solid object, body is a GhostObject. Otherwise a RigidBody.
+        if (!mustRebuild)
+        {
+            CollisionObjectTypes bodyType = (CollisionObjectTypes)m_physicsScene.PE.GetBodyType(prim.PhysBody);
+            if (prim.IsSolid && bodyType != CollisionObjectTypes.CO_RIGID_BODY
+                || !prim.IsSolid && bodyType != CollisionObjectTypes.CO_GHOST_OBJECT)
+            {
+                // If the collisionObject is not the correct type for solidness, rebuild what's there
+                mustRebuild = true;
+                if (DDetail) DetailLog("{0},BSShapeCollection.CreateBody,forceRebuildBecauseChangingBodyType,bodyType={1}", prim.LocalID, bodyType);
+            }
+        }
+
+        if (mustRebuild || forceRebuild)
+        {
+            // Free any old body
+            DereferenceBody(prim.PhysBody, bodyCallback);
+
+            BulletBody aBody;
+            if (prim.IsSolid)
+            {
+                aBody = m_physicsScene.PE.CreateBodyFromShape(sim, prim.PhysShape.physShapeInfo, prim.LocalID, prim.RawPosition, prim.RawOrientation);
+                if (DDetail) DetailLog("{0},BSShapeCollection.CreateBody,rigid,body={1}", prim.LocalID, aBody);
+            }
+            else
+            {
+                aBody = m_physicsScene.PE.CreateGhostFromShape(sim, prim.PhysShape.physShapeInfo, prim.LocalID, prim.RawPosition, prim.RawOrientation);
+                if (DDetail) DetailLog("{0},BSShapeCollection.CreateBody,ghost,body={1}", prim.LocalID, aBody);
+            }
+
+            ReferenceBody(aBody);
+
+            prim.PhysBody = aBody;
+
+            ret = true;
+        }
+
+        return ret;
+    }
+
+    private void DetailLog(string msg, params Object[] args)
+    {
+        if (m_physicsScene.PhysicsLogging.Enabled)
+            m_physicsScene.DetailLog(msg, args);
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSShapes.cs b/OpenSim/Region/PhysicsModules/BulletS/BSShapes.cs
new file mode 100755
index 0000000..79f1a89
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSShapes.cs
@@ -0,0 +1,1465 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Region.PhysicsModules.Meshing;
+using OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+// Information class that holds stats for the shape. Which values mean
+//     something depends on the type of shape.
+// This information is used for debugging and stats and is not used
+//     for operational things.
+public class ShapeInfoInfo
+{
+    public int Vertices { get; set; }
+    private int m_hullCount;
+    private int[] m_verticesPerHull;
+    public ShapeInfoInfo()
+    {
+        Vertices = 0;
+        m_hullCount = 0;
+        m_verticesPerHull = null;
+    }
+    public int HullCount
+    {
+        set
+        {
+            m_hullCount = value;
+            m_verticesPerHull = new int[m_hullCount];
+            Array.Clear(m_verticesPerHull, 0, m_hullCount);
+        }
+        get { return m_hullCount; }
+    }
+    public void SetVerticesPerHull(int hullNum, int vertices)
+    {
+        if (m_verticesPerHull != null && hullNum < m_verticesPerHull.Length)
+        {
+            m_verticesPerHull[hullNum] = vertices;
+        }
+    }
+    public int GetVerticesPerHull(int hullNum)
+    {
+        if (m_verticesPerHull != null && hullNum < m_verticesPerHull.Length)
+        {
+            return m_verticesPerHull[hullNum];
+        }
+        return 0;
+    }
+    public override string ToString()
+    {
+        StringBuilder buff = new StringBuilder();
+        // buff.Append("ShapeInfo=<");
+        buff.Append("<");
+        if (Vertices > 0)
+        {
+            buff.Append("verts=");
+            buff.Append(Vertices.ToString());
+        }
+
+        if (Vertices > 0 && HullCount > 0) buff.Append(",");
+
+        if (HullCount > 0)
+        {
+            buff.Append("nHulls=");
+            buff.Append(HullCount.ToString());
+            buff.Append(",");
+            buff.Append("hullVerts=");
+            for (int ii = 0; ii < HullCount; ii++)
+            {
+                if (ii != 0) buff.Append(",");
+                buff.Append(GetVerticesPerHull(ii).ToString());
+            }
+        }
+        buff.Append(">");
+        return buff.ToString();
+    }
+}
+
+public abstract class BSShape
+{
+    private static string LogHeader = "[BULLETSIM SHAPE]";
+
+    public int referenceCount { get; set; }
+    public DateTime lastReferenced { get; set; }
+    public BulletShape physShapeInfo { get; set; }
+    public ShapeInfoInfo shapeInfo { get; private set; }
+
+    public BSShape()
+    {
+        referenceCount = 1;
+        lastReferenced = DateTime.Now;
+        physShapeInfo = new BulletShape();
+        shapeInfo = new ShapeInfoInfo();
+    }
+    public BSShape(BulletShape pShape)
+    {
+        referenceCount = 1;
+        lastReferenced = DateTime.Now;
+        physShapeInfo = pShape;
+        shapeInfo = new ShapeInfoInfo();
+    }
+
+    // Get another reference to this shape.
+    public abstract BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim);
+
+    // Called when this shape is being used again.
+    // Used internally. External callers should call instance.GetReference() to properly copy/reference
+    //       the shape.
+    protected virtual void IncrementReference()
+    {
+        referenceCount++;
+        lastReferenced = DateTime.Now;
+    }
+
+    // Called when this shape is done being used.
+    protected virtual void DecrementReference()
+    {
+        referenceCount--;
+        lastReferenced = DateTime.Now;
+    }
+
+    // Release the use of a physical shape.
+    public abstract void Dereference(BSScene physicsScene);
+
+    // Return 'true' if there is an allocated physics physical shape under this class instance.
+    public virtual bool HasPhysicalShape
+    {
+        get
+        {
+            if (physShapeInfo != null)
+                return physShapeInfo.HasPhysicalShape;
+            return false;
+        }
+    }
+    public virtual BSPhysicsShapeType ShapeType
+    {
+        get
+        {
+            BSPhysicsShapeType ret = BSPhysicsShapeType.SHAPE_UNKNOWN;
+            if (physShapeInfo != null && physShapeInfo.HasPhysicalShape)
+                ret = physShapeInfo.shapeType;
+            return ret;
+        }
+    }
+
+    // Returns a string for debugging that uniquily identifies the memory used by this instance
+    public virtual string AddrString
+    {
+        get
+        {
+            if (physShapeInfo != null)
+                return physShapeInfo.AddrString;
+            return "unknown";
+        }
+    }
+
+    public override string ToString()
+    {
+        StringBuilder buff = new StringBuilder();
+        if (physShapeInfo == null)
+        {
+            buff.Append("<noPhys");
+        }
+        else
+        {
+            buff.Append("<phy=");
+            buff.Append(physShapeInfo.ToString());
+        }
+        buff.Append(",c=");
+        buff.Append(referenceCount.ToString());
+        buff.Append(">");
+        return buff.ToString();
+    }
+
+    #region Common shape routines
+    // Create a hash of all the shape parameters to be used as a key for this particular shape.
+    public static System.UInt64 ComputeShapeKey(OMV.Vector3 size, PrimitiveBaseShape pbs, out float retLod)
+    {
+        // level of detail based on size and type of the object
+        float lod = BSParam.MeshLOD;
+        if (pbs.SculptEntry)
+            lod = BSParam.SculptLOD;
+
+        // Mega prims usually get more detail because one can interact with shape approximations at this size.
+        float maxAxis = Math.Max(size.X, Math.Max(size.Y, size.Z));
+        if (maxAxis > BSParam.MeshMegaPrimThreshold)
+            lod = BSParam.MeshMegaPrimLOD;
+
+        retLod = lod;
+        return pbs.GetMeshKey(size, lod);
+    }
+
+    // The creation of a mesh or hull can fail if an underlying asset is not available.
+    // There are two cases: 1) the asset is not in the cache and it needs to be fetched;
+    //     and 2) the asset cannot be converted (like failed decompression of JPEG2000s).
+    //     The first case causes the asset to be fetched. The second case requires
+    //     us to not loop forever.
+    // Called after creating a physical mesh or hull. If the physical shape was created,
+    //     just return.
+    public static BulletShape VerifyMeshCreated(BSScene physicsScene, BulletShape newShape, BSPhysObject prim)
+    {
+        // If the shape was successfully created, nothing more to do
+        if (newShape.HasPhysicalShape)
+            return newShape;
+
+        // VerifyMeshCreated is called after trying to create the mesh. If we think the asset had been
+        //    fetched but we end up here again, the meshing of the asset must have failed.
+        // Prevent trying to keep fetching the mesh by declaring failure.
+        if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched)
+        {
+            prim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedMeshing;
+            physicsScene.Logger.WarnFormat("{0} Fetched asset would not mesh. prim={1}, texture={2}",
+                                            LogHeader, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+            physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,setFailed,prim={1},tex={2}",
+                                            prim.LocalID, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+        }
+        else
+        {
+            // If this mesh has an underlying asset and we have not failed getting it before, fetch the asset
+            if (prim.BaseShape.SculptEntry
+                && !prim.AssetFailed()
+                && prim.PrimAssetState != BSPhysObject.PrimAssetCondition.Waiting
+                && prim.BaseShape.SculptTexture != OMV.UUID.Zero
+                )
+            {
+                physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,fetchAsset,objNam={1},tex={2}",
+                                            prim.LocalID, prim.PhysObjectName, prim.BaseShape.SculptTexture);
+                // Multiple requestors will know we're waiting for this asset
+                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Waiting;
+
+                BSPhysObject xprim = prim;
+                RequestAssetDelegate assetProvider = physicsScene.RequestAssetMethod;
+                if (assetProvider != null)
+                {
+                    BSPhysObject yprim = xprim; // probably not necessary, but, just in case.
+                    assetProvider(yprim.BaseShape.SculptTexture, delegate(AssetBase asset)
+                    {
+                        // physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,assetProviderCallback", xprim.LocalID);
+                        bool assetFound = false;
+                        string mismatchIDs = String.Empty;  // DEBUG DEBUG
+                        if (asset != null && yprim.BaseShape.SculptEntry)
+                        {
+                            if (yprim.BaseShape.SculptTexture.ToString() == asset.ID)
+                            {
+                                yprim.BaseShape.SculptData = asset.Data;
+                                // This will cause the prim to see that the filler shape is not the right
+                                //    one and try again to build the object.
+                                // No race condition with the normal shape setting since the rebuild is at taint time.
+                                yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.Fetched;
+                                yprim.ForceBodyShapeRebuild(false /* inTaintTime */);
+                                assetFound = true;
+                            }
+                            else
+                            {
+                                mismatchIDs = yprim.BaseShape.SculptTexture.ToString() + "/" + asset.ID;
+                            }
+                        }
+                        if (!assetFound)
+                        {
+                            yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedAssetFetch;
+                        }
+                        physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,fetchAssetCallback,found={1},isSculpt={2},ids={3}",
+                                    yprim.LocalID, assetFound, yprim.BaseShape.SculptEntry, mismatchIDs );
+                    });
+                }
+                else
+                {
+                    xprim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedAssetFetch;
+                    physicsScene.Logger.ErrorFormat("{0} Physical object requires asset but no asset provider. Name={1}",
+                                                LogHeader, physicsScene.PhysicsSceneName);
+                }
+            }
+            else
+            {
+                if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedAssetFetch)
+                {
+                    physicsScene.Logger.WarnFormat("{0} Mesh failed to fetch asset. prim={1}, texture={2}",
+                                                LogHeader, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+                    physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,wasFailed,prim={1},tex={2}",
+                                                prim.LocalID, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+                }
+                if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedMeshing)
+                {
+                    physicsScene.Logger.WarnFormat("{0} Mesh asset would not mesh. prim={1}, texture={2}",
+                                                LogHeader, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+                    physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,wasFailedMeshing,prim={1},tex={2}",
+                                                prim.LocalID, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+                }
+            }
+         }
+
+        // While we wait for the mesh defining asset to be loaded, stick in a simple box for the object.
+        BSShape fillShape = BSShapeNative.GetReference(physicsScene, prim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
+        physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,boxTempShape", prim.LocalID);
+
+        return fillShape.physShapeInfo;
+     }
+
+    public static String UsefulPrimInfo(BSScene pScene, BSPhysObject prim)
+    {
+        StringBuilder buff = new StringBuilder(prim.PhysObjectName);
+        buff.Append("/pos=");
+        buff.Append(prim.RawPosition.ToString());
+        if (pScene != null)
+        {
+            buff.Append("/rgn=");
+            buff.Append(pScene.PhysicsSceneName);
+        }
+        return buff.ToString();
+    }
+
+    #endregion // Common shape routines
+}
+
+// ============================================================================================================
+public class BSShapeNull : BSShape
+{
+    public BSShapeNull() : base()
+    {
+    }
+    public static BSShape GetReference() { return new BSShapeNull();  }
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim) { return new BSShapeNull();  }
+    public override void Dereference(BSScene physicsScene) { /* The magic of garbage collection will make this go away */ }
+}
+
+// ============================================================================================================
+// BSShapeNative is a wrapper for a Bullet 'native' shape -- cube and sphere.
+// They are odd in that they don't allocate meshes but are computated/procedural.
+// This means allocation and freeing is different than meshes.
+public class BSShapeNative : BSShape
+{
+    private static string LogHeader = "[BULLETSIM SHAPE NATIVE]";
+    public BSShapeNative(BulletShape pShape) : base(pShape)
+    {
+    }
+
+    public static BSShape GetReference(BSScene physicsScene, BSPhysObject prim,
+                                            BSPhysicsShapeType shapeType, FixedShapeKey shapeKey)
+    {
+        // Native shapes are not shared and are always built anew.
+        return new BSShapeNative(CreatePhysicalNativeShape(physicsScene, prim, shapeType, shapeKey));
+    }
+
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
+    {
+        // Native shapes are not shared so we return a new shape.
+        BSShape ret = null;
+        lock (physShapeInfo)
+        {
+            ret = new BSShapeNative(CreatePhysicalNativeShape(pPhysicsScene, pPrim,
+                                        physShapeInfo.shapeType, (FixedShapeKey)physShapeInfo.shapeKey));
+        }
+        return ret;
+    }
+
+    // Make this reference to the physical shape go away since native shapes are not shared.
+    public override void Dereference(BSScene physicsScene)
+    {
+        // Native shapes are not tracked and are released immediately
+        lock (physShapeInfo)
+        {
+            if (physShapeInfo.HasPhysicalShape)
+            {
+                physicsScene.DetailLog("{0},BSShapeNative.Dereference,deleteNativeShape,shape={1}", BSScene.DetailLogZero, this);
+                physicsScene.PE.DeleteCollisionShape(physicsScene.World, physShapeInfo);
+            }
+            physShapeInfo.Clear();
+            // Garbage collection will free up this instance.
+        }
+    }
+
+    private static BulletShape CreatePhysicalNativeShape(BSScene physicsScene, BSPhysObject prim,
+                                            BSPhysicsShapeType shapeType, FixedShapeKey shapeKey)
+    {
+        BulletShape newShape;
+
+        ShapeData nativeShapeData = new ShapeData();
+        nativeShapeData.Type = shapeType;
+        nativeShapeData.ID = prim.LocalID;
+        nativeShapeData.Scale = prim.Scale;
+        nativeShapeData.Size = prim.Scale;
+        nativeShapeData.MeshKey = (ulong)shapeKey;
+        nativeShapeData.HullKey = (ulong)shapeKey;
+
+        if (shapeType == BSPhysicsShapeType.SHAPE_CAPSULE)
+        {
+            newShape = physicsScene.PE.BuildCapsuleShape(physicsScene.World, 1f, 1f, prim.Scale);
+            physicsScene.DetailLog("{0},BSShapeNative,capsule,scale={1}", prim.LocalID, prim.Scale);
+        }
+        else
+        {
+            newShape = physicsScene.PE.BuildNativeShape(physicsScene.World, nativeShapeData);
+        }
+        if (!newShape.HasPhysicalShape)
+        {
+            physicsScene.Logger.ErrorFormat("{0} BuildPhysicalNativeShape failed. ID={1}, shape={2}",
+                                    LogHeader, prim.LocalID, shapeType);
+        }
+        newShape.shapeType = shapeType;
+        newShape.isNativeShape = true;
+        newShape.shapeKey = (UInt64)shapeKey;
+        return newShape;
+    }
+
+}
+
+// ============================================================================================================
+// BSShapeMesh is a simple mesh.
+public class BSShapeMesh : BSShape
+{
+    private static string LogHeader = "[BULLETSIM SHAPE MESH]";
+    public static Dictionary<System.UInt64, BSShapeMesh> Meshes = new Dictionary<System.UInt64, BSShapeMesh>();
+
+    public BSShapeMesh(BulletShape pShape) : base(pShape)
+    {
+    }
+    public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+    {
+        float lod;
+        System.UInt64 newMeshKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
+
+        BSShapeMesh retMesh = null;
+        lock (Meshes)
+        {
+            if (Meshes.TryGetValue(newMeshKey, out retMesh))
+            {
+                // The mesh has already been created. Return a new reference to same.
+                retMesh.IncrementReference();
+            }
+            else
+            {
+                retMesh = new BSShapeMesh(new BulletShape());
+                // An instance of this mesh has not been created. Build and remember same.
+                BulletShape newShape = retMesh.CreatePhysicalMesh(physicsScene, prim, newMeshKey, prim.BaseShape, prim.Size, lod);
+
+                // Check to see if mesh was created (might require an asset).
+                newShape = VerifyMeshCreated(physicsScene, newShape, prim);
+                if (!newShape.isNativeShape || prim.AssetFailed() )
+                {
+                    // If a mesh was what was created, remember the built shape for later sharing.
+                    // Also note that if meshing failed we put it in the mesh list as there is nothing else to do about the mesh.
+                    Meshes.Add(newMeshKey, retMesh);
+                }
+
+                retMesh.physShapeInfo = newShape;
+            }
+        }
+        physicsScene.DetailLog("{0},BSShapeMesh,getReference,mesh={1},size={2},lod={3}", prim.LocalID, retMesh, prim.Size, lod);
+        return retMesh;
+    }
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
+    {
+        BSShape ret = null;
+        // If the underlying shape is native, the actual shape has not been build (waiting for asset)
+        //     and we must create a copy of the native shape since they are never shared.
+        if (physShapeInfo.HasPhysicalShape && physShapeInfo.isNativeShape)
+        {
+            // TODO: decide when the native shapes should be freed. Check in Dereference?
+            ret = BSShapeNative.GetReference(pPhysicsScene, pPrim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
+        }
+        else
+        {
+            // Another reference to this shape is just counted.
+            IncrementReference();
+            ret = this;
+        }
+        return ret;
+    }
+    public override void Dereference(BSScene physicsScene)
+    {
+        lock (Meshes)
+        {
+            this.DecrementReference();
+            physicsScene.DetailLog("{0},BSShapeMesh.Dereference,shape={1}", BSScene.DetailLogZero, this);
+            // TODO: schedule aging and destruction of unused meshes.
+        }
+    }
+    // Loop through all the known meshes and return the description based on the physical address.
+    public static bool TryGetMeshByPtr(BulletShape pShape, out BSShapeMesh outMesh)
+    {
+        bool ret = false;
+        BSShapeMesh foundDesc = null;
+        lock (Meshes)
+        {
+            foreach (BSShapeMesh sm in Meshes.Values)
+            {
+                if (sm.physShapeInfo.ReferenceSame(pShape))
+                {
+                    foundDesc = sm;
+                    ret = true;
+                    break;
+                }
+
+            }
+        }
+        outMesh = foundDesc;
+        return ret;
+    }
+
+    public delegate BulletShape CreateShapeCall(BulletWorld world, int indicesCount, int[] indices, int verticesCount, float[] vertices );
+    private BulletShape CreatePhysicalMesh(BSScene physicsScene, BSPhysObject prim, System.UInt64 newMeshKey,
+                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
+    {
+        return BSShapeMesh.CreatePhysicalMeshShape(physicsScene, prim, newMeshKey, pbs, size, lod,
+                            (w, iC, i, vC, v) =>
+                            {
+                                shapeInfo.Vertices = vC;
+                                return physicsScene.PE.CreateMeshShape(w, iC, i, vC, v);
+                            });
+    }
+
+    // Code that uses the mesher to create the index/vertices info for a trimesh shape.
+    // This is used by the passed 'makeShape' call to create the Bullet mesh shape.
+    // The actual build call is passed so this logic can be used by several of the shapes that use a
+    //     simple mesh as their base shape.
+    public static BulletShape CreatePhysicalMeshShape(BSScene physicsScene, BSPhysObject prim, System.UInt64 newMeshKey,
+                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod, CreateShapeCall makeShape)
+    {
+        BulletShape newShape = new BulletShape();
+
+        IMesh meshData = null;
+        lock (physicsScene.mesher)
+        {
+            meshData = physicsScene.mesher.CreateMesh(prim.PhysObjectName, pbs, size, lod,
+                                            false,  // say it is not physical so a bounding box is not built
+                                            false,   // do not cache the mesh and do not use previously built versions
+                                            false,
+                                            false
+                                            );
+        }
+
+        if (meshData != null)
+        {
+            if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched)
+            {
+                // Release the fetched asset data once it has been used.
+                pbs.SculptData = new byte[0];
+                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Unknown;
+            }
+
+            int[] indices = meshData.getIndexListAsInt();
+            int realIndicesIndex = indices.Length;
+            float[] verticesAsFloats = meshData.getVertexListAsFloat();
+
+            if (BSParam.ShouldRemoveZeroWidthTriangles)
+            {
+                // Remove degenerate triangles. These are triangles with two of the vertices
+                //    are the same. This is complicated by the problem that vertices are not
+                //    made unique in sculpties so we have to compare the values in the vertex.
+                realIndicesIndex = 0;
+                for (int tri = 0; tri < indices.Length; tri += 3)
+                {
+                    // Compute displacements into vertex array for each vertex of the triangle
+                    int v1 = indices[tri + 0] * 3;
+                    int v2 = indices[tri + 1] * 3;
+                    int v3 = indices[tri + 2] * 3;
+                // Check to see if any two of the vertices are the same
+                    if (!( (  verticesAsFloats[v1 + 0] == verticesAsFloats[v2 + 0]
+                           && verticesAsFloats[v1 + 1] == verticesAsFloats[v2 + 1]
+                           && verticesAsFloats[v1 + 2] == verticesAsFloats[v2 + 2])
+                        || (  verticesAsFloats[v2 + 0] == verticesAsFloats[v3 + 0]
+                           && verticesAsFloats[v2 + 1] == verticesAsFloats[v3 + 1]
+                           && verticesAsFloats[v2 + 2] == verticesAsFloats[v3 + 2])
+                        || (  verticesAsFloats[v1 + 0] == verticesAsFloats[v3 + 0]
+                           && verticesAsFloats[v1 + 1] == verticesAsFloats[v3 + 1]
+                           && verticesAsFloats[v1 + 2] == verticesAsFloats[v3 + 2]) )
+                    )
+                    {
+                        // None of the vertices of the triangles are the same. This is a good triangle;
+                        indices[realIndicesIndex + 0] = indices[tri + 0];
+                        indices[realIndicesIndex + 1] = indices[tri + 1];
+                        indices[realIndicesIndex + 2] = indices[tri + 2];
+                        realIndicesIndex += 3;
+                    }
+                }
+            }
+            physicsScene.DetailLog("{0},BSShapeMesh.CreatePhysicalMesh,key={1},origTri={2},realTri={3},numVerts={4}",
+                        BSScene.DetailLogZero, newMeshKey.ToString("X"), indices.Length / 3, realIndicesIndex / 3, verticesAsFloats.Length / 3);
+
+            if (realIndicesIndex != 0)
+            {
+                newShape = makeShape(physicsScene.World, realIndicesIndex, indices, verticesAsFloats.Length / 3, verticesAsFloats);
+            }
+            else
+            {
+                // Force the asset condition to 'failed' so we won't try to keep fetching and processing this mesh.
+                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedMeshing;
+                physicsScene.Logger.DebugFormat("{0} All mesh triangles degenerate. Prim={1}", LogHeader, UsefulPrimInfo(physicsScene, prim) );
+                physicsScene.DetailLog("{0},BSShapeMesh.CreatePhysicalMesh,allDegenerate,key={1}", prim.LocalID, newMeshKey);
+            }
+        }
+        newShape.shapeKey = newMeshKey;
+
+        return newShape;
+    }
+}
+
+// ============================================================================================================
+// BSShapeHull is a physical shape representation htat is made up of many convex hulls.
+// The convex hulls are either supplied with the asset or are approximated by one of the
+//     convex hull creation routines (in OpenSim or in Bullet).
+public class BSShapeHull : BSShape
+{
+#pragma warning disable 414
+    private static string LogHeader = "[BULLETSIM SHAPE HULL]";
+#pragma warning restore 414
+
+    public static Dictionary<System.UInt64, BSShapeHull> Hulls = new Dictionary<System.UInt64, BSShapeHull>();
+
+
+    public BSShapeHull(BulletShape pShape) : base(pShape)
+    {
+    }
+    public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+    {
+        float lod;
+        System.UInt64 newHullKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
+
+        BSShapeHull retHull = null;
+        lock (Hulls)
+        {
+            if (Hulls.TryGetValue(newHullKey, out retHull))
+            {
+                // The mesh has already been created. Return a new reference to same.
+                retHull.IncrementReference();
+            }
+            else
+            {
+                retHull = new BSShapeHull(new BulletShape());
+                // An instance of this mesh has not been created. Build and remember same.
+                BulletShape newShape = retHull.CreatePhysicalHull(physicsScene, prim, newHullKey, prim.BaseShape, prim.Size, lod);
+
+                // Check to see if hull was created (might require an asset).
+                newShape = VerifyMeshCreated(physicsScene, newShape, prim);
+                if (!newShape.isNativeShape || prim.AssetFailed())
+                {
+                    // If a mesh was what was created, remember the built shape for later sharing.
+                    Hulls.Add(newHullKey, retHull);
+                }
+                retHull.physShapeInfo = newShape;
+            }
+        }
+        physicsScene.DetailLog("{0},BSShapeHull,getReference,hull={1},size={2},lod={3}", prim.LocalID, retHull, prim.Size, lod);
+        return retHull;
+    }
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
+    {
+        BSShape ret = null;
+        // If the underlying shape is native, the actual shape has not been build (waiting for asset)
+        //     and we must create a copy of the native shape since they are never shared.
+        if (physShapeInfo.HasPhysicalShape && physShapeInfo.isNativeShape)
+        {
+            // TODO: decide when the native shapes should be freed. Check in Dereference?
+            ret = BSShapeNative.GetReference(pPhysicsScene, pPrim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
+        }
+        else
+        {
+            // Another reference to this shape is just counted.
+            IncrementReference();
+            ret = this;
+        }
+        return ret;
+    }
+    public override void Dereference(BSScene physicsScene)
+    {
+        lock (Hulls)
+        {
+            this.DecrementReference();
+            physicsScene.DetailLog("{0},BSShapeHull.Dereference,shape={1}", BSScene.DetailLogZero, this);
+            // TODO: schedule aging and destruction of unused meshes.
+        }
+    }
+
+    List<ConvexResult> m_hulls;
+    private BulletShape CreatePhysicalHull(BSScene physicsScene, BSPhysObject prim, System.UInt64 newHullKey,
+                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
+    {
+        BulletShape newShape = new BulletShape();
+
+        IMesh meshData = null;
+        List<List<OMV.Vector3>> allHulls = null;
+        lock (physicsScene.mesher)
+        {
+            // Pass true for physicalness as this prevents the creation of bounding box which is not needed
+            meshData = physicsScene.mesher.CreateMesh(prim.PhysObjectName, pbs, size, lod, true /* isPhysical */, false /* shouldCache */, false, false);
+
+            // If we should use the asset's hull info, fetch it out of the locked mesher
+            if (meshData != null && BSParam.ShouldUseAssetHulls)
+            {
+                Meshmerizer realMesher = physicsScene.mesher as Meshmerizer;
+                if (realMesher != null)
+                {
+                    allHulls = realMesher.GetConvexHulls(size);
+                }
+                if (allHulls == null)
+                {
+                    physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,assetHulls,noAssetHull", prim.LocalID);
+                }
+            }
+        }
+
+        // If there is hull data in the mesh asset, build the hull from that
+        if (allHulls != null && BSParam.ShouldUseAssetHulls)
+        {
+            int hullCount = allHulls.Count;
+            shapeInfo.HullCount = hullCount;
+            int totalVertices = 1;      // include one for the count of the hulls
+            // Using the structure described for HACD hulls, create the memory sturcture
+            //     to pass the hull data to the creater.
+            foreach (List<OMV.Vector3> hullVerts in allHulls)
+            {
+                totalVertices += 4;                     // add four for the vertex count and centroid
+                totalVertices += hullVerts.Count * 3;   // one vertex is three dimensions
+            }
+            float[] convHulls = new float[totalVertices];
+
+            convHulls[0] = (float)hullCount;
+            int jj = 1;
+            int hullIndex = 0;
+            foreach (List<OMV.Vector3> hullVerts in allHulls)
+            {
+                convHulls[jj + 0] = hullVerts.Count;
+                convHulls[jj + 1] = 0f;   // centroid x,y,z
+                convHulls[jj + 2] = 0f;
+                convHulls[jj + 3] = 0f;
+                jj += 4;
+                foreach (OMV.Vector3 oneVert in hullVerts)
+                {
+                    convHulls[jj + 0] = oneVert.X;
+                    convHulls[jj + 1] = oneVert.Y;
+                    convHulls[jj + 2] = oneVert.Z;
+                    jj += 3;
+                }
+                shapeInfo.SetVerticesPerHull(hullIndex, hullVerts.Count);
+                hullIndex++;
+            }
+
+            // create the hull data structure in Bullet
+            newShape = physicsScene.PE.CreateHullShape(physicsScene.World, hullCount, convHulls);
+
+            physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,assetHulls,hulls={1},totVert={2},shape={3}",
+                                        prim.LocalID, hullCount, totalVertices, newShape);
+        }
+
+        // If no hull specified in the asset and we should use Bullet's HACD approximation...
+        if (!newShape.HasPhysicalShape && BSParam.ShouldUseBulletHACD)
+        {
+            // Build the hull shape from an existing mesh shape.
+            // The mesh should have already been created in Bullet.
+            physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,bulletHACD,entry", prim.LocalID);
+            BSShape meshShape = BSShapeMesh.GetReference(physicsScene, true, prim);
+
+            if (meshShape.physShapeInfo.HasPhysicalShape)
+            {
+                HACDParams parms = new HACDParams();
+                parms.maxVerticesPerHull = BSParam.BHullMaxVerticesPerHull;
+                parms.minClusters = BSParam.BHullMinClusters;
+                parms.compacityWeight = BSParam.BHullCompacityWeight;
+                parms.volumeWeight = BSParam.BHullVolumeWeight;
+                parms.concavity = BSParam.BHullConcavity;
+                parms.addExtraDistPoints = BSParam.NumericBool(BSParam.BHullAddExtraDistPoints);
+                parms.addNeighboursDistPoints = BSParam.NumericBool(BSParam.BHullAddNeighboursDistPoints);
+                parms.addFacesPoints = BSParam.NumericBool(BSParam.BHullAddFacesPoints);
+                parms.shouldAdjustCollisionMargin = BSParam.NumericBool(BSParam.BHullShouldAdjustCollisionMargin);
+                parms.whichHACD = 0;    // Use the HACD routine that comes with Bullet
+
+                physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,hullFromMesh,beforeCall", prim.LocalID, newShape.HasPhysicalShape);
+                newShape = physicsScene.PE.BuildHullShapeFromMesh(physicsScene.World, meshShape.physShapeInfo, parms);
+                physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,hullFromMesh,shape={1}", prim.LocalID, newShape);
+
+                // Now done with the mesh shape.
+                shapeInfo.HullCount = 1;
+                BSShapeMesh maybeMesh = meshShape as BSShapeMesh;
+                if (maybeMesh != null)
+                    shapeInfo.SetVerticesPerHull(0, maybeMesh.shapeInfo.Vertices);
+                meshShape.Dereference(physicsScene);
+            }
+            physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,bulletHACD,exit,hasBody={1}", prim.LocalID, newShape.HasPhysicalShape);
+        }
+
+        // If no other hull specifications, use our HACD hull approximation.
+        if (!newShape.HasPhysicalShape && meshData != null)
+        {
+            if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched)
+            {
+                // Release the fetched asset data once it has been used.
+                pbs.SculptData = new byte[0];
+                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Unknown;
+            }
+
+            int[] indices = meshData.getIndexListAsInt();
+            List<OMV.Vector3> vertices = meshData.getVertexList();
+
+            //format conversion from IMesh format to DecompDesc format
+            List<int> convIndices = new List<int>();
+            List<float3> convVertices = new List<float3>();
+            for (int ii = 0; ii < indices.GetLength(0); ii++)
+            {
+                convIndices.Add(indices[ii]);
+            }
+            foreach (OMV.Vector3 vv in vertices)
+            {
+                convVertices.Add(new float3(vv.X, vv.Y, vv.Z));
+            }
+
+            uint maxDepthSplit = (uint)BSParam.CSHullMaxDepthSplit;
+            if (BSParam.CSHullMaxDepthSplit != BSParam.CSHullMaxDepthSplitForSimpleShapes)
+            {
+                // Simple primitive shapes we know are convex so they are better implemented with
+                //    fewer hulls.
+                // Check for simple shape (prim without cuts) and reduce split parameter if so.
+                if (BSShapeCollection.PrimHasNoCuts(pbs))
+                {
+                    maxDepthSplit = (uint)BSParam.CSHullMaxDepthSplitForSimpleShapes;
+                }
+            }
+
+            // setup and do convex hull conversion
+            m_hulls = new List<ConvexResult>();
+            DecompDesc dcomp = new DecompDesc();
+            dcomp.mIndices = convIndices;
+            dcomp.mVertices = convVertices;
+            dcomp.mDepth = maxDepthSplit;
+            dcomp.mCpercent = BSParam.CSHullConcavityThresholdPercent;
+            dcomp.mPpercent = BSParam.CSHullVolumeConservationThresholdPercent;
+            dcomp.mMaxVertices = (uint)BSParam.CSHullMaxVertices;
+            dcomp.mSkinWidth = BSParam.CSHullMaxSkinWidth;
+            ConvexBuilder convexBuilder = new ConvexBuilder(HullReturn);
+            // create the hull into the _hulls variable
+            convexBuilder.process(dcomp);
+
+            physicsScene.DetailLog("{0},BSShapeCollection.CreatePhysicalHull,key={1},inVert={2},inInd={3},split={4},hulls={5}",
+                                BSScene.DetailLogZero, newHullKey, indices.GetLength(0), vertices.Count, maxDepthSplit, m_hulls.Count);
+
+            // Convert the vertices and indices for passing to unmanaged.
+            // The hull information is passed as a large floating point array.
+            // The format is:
+            //  convHulls[0] = number of hulls
+            //  convHulls[1] = number of vertices in first hull
+            //  convHulls[2] = hull centroid X coordinate
+            //  convHulls[3] = hull centroid Y coordinate
+            //  convHulls[4] = hull centroid Z coordinate
+            //  convHulls[5] = first hull vertex X
+            //  convHulls[6] = first hull vertex Y
+            //  convHulls[7] = first hull vertex Z
+            //  convHulls[8] = second hull vertex X
+            //  ...
+            //  convHulls[n] = number of vertices in second hull
+            //  convHulls[n+1] = second hull centroid X coordinate
+            //  ...
+            //
+            // TODO: is is very inefficient. Someday change the convex hull generator to return
+            //   data structures that do not need to be converted in order to pass to Bullet.
+            //   And maybe put the values directly into pinned memory rather than marshaling.
+            int hullCount = m_hulls.Count;
+            int totalVertices = 1;          // include one for the count of the hulls
+            foreach (ConvexResult cr in m_hulls)
+            {
+                totalVertices += 4;                         // add four for the vertex count and centroid
+                totalVertices += cr.HullIndices.Count * 3;  // we pass just triangles
+            }
+            float[] convHulls = new float[totalVertices];
+
+            convHulls[0] = (float)hullCount;
+            int jj = 1;
+            foreach (ConvexResult cr in m_hulls)
+            {
+                // copy vertices for index access
+                float3[] verts = new float3[cr.HullVertices.Count];
+                int kk = 0;
+                foreach (float3 ff in cr.HullVertices)
+                {
+                    verts[kk++] = ff;
+                }
+
+                // add to the array one hull's worth of data
+                convHulls[jj++] = cr.HullIndices.Count;
+                convHulls[jj++] = 0f;   // centroid x,y,z
+                convHulls[jj++] = 0f;
+                convHulls[jj++] = 0f;
+                foreach (int ind in cr.HullIndices)
+                {
+                    convHulls[jj++] = verts[ind].x;
+                    convHulls[jj++] = verts[ind].y;
+                    convHulls[jj++] = verts[ind].z;
+                }
+            }
+            // create the hull data structure in Bullet
+            newShape = physicsScene.PE.CreateHullShape(physicsScene.World, hullCount, convHulls);
+        }
+        newShape.shapeKey = newHullKey;
+        return newShape;
+    }
+    // Callback from convex hull creater with a newly created hull.
+    // Just add it to our collection of hulls for this shape.
+    private void HullReturn(ConvexResult result)
+    {
+        m_hulls.Add(result);
+        return;
+    }
+    // Loop through all the known hulls and return the description based on the physical address.
+    public static bool TryGetHullByPtr(BulletShape pShape, out BSShapeHull outHull)
+    {
+        bool ret = false;
+        BSShapeHull foundDesc = null;
+        lock (Hulls)
+        {
+            foreach (BSShapeHull sh in Hulls.Values)
+            {
+                if (sh.physShapeInfo.ReferenceSame(pShape))
+                {
+                    foundDesc = sh;
+                    ret = true;
+                    break;
+                }
+
+            }
+        }
+        outHull = foundDesc;
+        return ret;
+    }
+}
+
+// ============================================================================================================
+// BSShapeCompound is a wrapper for the Bullet compound shape which is built from multiple, separate
+//    meshes. Used by BulletSim for complex shapes like linksets.
+public class BSShapeCompound : BSShape
+{
+    private static string LogHeader = "[BULLETSIM SHAPE COMPOUND]";
+    public static Dictionary<string, BSShapeCompound> CompoundShapes = new Dictionary<string, BSShapeCompound>();
+
+    public BSShapeCompound(BulletShape pShape) : base(pShape)
+    {
+    }
+    public static BSShape GetReference(BSScene physicsScene)
+    {
+        // Base compound shapes are not shared so this returns a raw shape.
+        // A built compound shape can be reused in linksets.
+        BSShapeCompound ret = new BSShapeCompound(CreatePhysicalCompoundShape(physicsScene));
+        CompoundShapes.Add(ret.AddrString, ret);
+        return ret;
+    }
+    public override BSShape GetReference(BSScene physicsScene, BSPhysObject prim)
+    {
+        // Calling this reference means we want another handle to an existing compound shape
+        //     (usually linksets) so return this copy.
+        IncrementReference();
+        return this;
+    }
+    // Dereferencing a compound shape releases the hold on all the child shapes.
+    public override void Dereference(BSScene physicsScene)
+    {
+        lock (physShapeInfo)
+        {
+            this.DecrementReference();
+            physicsScene.DetailLog("{0},BSShapeCompound.Dereference,shape={1}", BSScene.DetailLogZero, this);
+            if (referenceCount <= 0)
+            {
+                if (!physicsScene.PE.IsCompound(physShapeInfo))
+                {
+                    // Failed the sanity check!!
+                    physicsScene.Logger.ErrorFormat("{0} Attempt to free a compound shape that is not compound!! type={1}, ptr={2}",
+                                                LogHeader, physShapeInfo.shapeType, physShapeInfo.AddrString);
+                    physicsScene.DetailLog("{0},BSShapeCollection.DereferenceCompound,notACompoundShape,type={1},ptr={2}",
+                                                BSScene.DetailLogZero, physShapeInfo.shapeType, physShapeInfo.AddrString);
+                    return;
+                }
+
+                int numChildren = physicsScene.PE.GetNumberOfCompoundChildren(physShapeInfo);
+                physicsScene.DetailLog("{0},BSShapeCollection.DereferenceCompound,shape={1},children={2}",
+                                        BSScene.DetailLogZero, physShapeInfo, numChildren);
+
+                // Loop through all the children dereferencing each.
+                for (int ii = numChildren - 1; ii >= 0; ii--)
+                {
+                    BulletShape childShape = physicsScene.PE.RemoveChildShapeFromCompoundShapeIndex(physShapeInfo, ii);
+                    DereferenceAnonCollisionShape(physicsScene, childShape);
+                }
+
+                lock (CompoundShapes)
+                    CompoundShapes.Remove(physShapeInfo.AddrString);
+                physicsScene.PE.DeleteCollisionShape(physicsScene.World, physShapeInfo);
+            }
+        }
+    }
+    public static bool TryGetCompoundByPtr(BulletShape pShape, out BSShapeCompound outCompound)
+    {
+        lock (CompoundShapes)
+        {
+            string addr = pShape.AddrString;
+            return CompoundShapes.TryGetValue(addr, out outCompound);
+        }
+    }
+    private static BulletShape CreatePhysicalCompoundShape(BSScene physicsScene)
+    {
+        BulletShape cShape = physicsScene.PE.CreateCompoundShape(physicsScene.World, false);
+        return cShape;
+    }
+    // Sometimes we have a pointer to a collision shape but don't know what type it is.
+    // Figure out type and call the correct dereference routine.
+    // Called at taint-time.
+    private void DereferenceAnonCollisionShape(BSScene physicsScene, BulletShape pShape)
+    {
+        // TODO: figure a better way to go through all the shape types and find a possible instance.
+        physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,shape={1}",
+                                            BSScene.DetailLogZero, pShape);
+        BSShapeMesh meshDesc;
+        if (BSShapeMesh.TryGetMeshByPtr(pShape, out meshDesc))
+        {
+            meshDesc.Dereference(physicsScene);
+            // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundMesh,shape={1}", BSScene.DetailLogZero, pShape);
+        }
+        else
+        {
+            BSShapeHull hullDesc;
+            if (BSShapeHull.TryGetHullByPtr(pShape, out hullDesc))
+            {
+                hullDesc.Dereference(physicsScene);
+                // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundHull,shape={1}", BSScene.DetailLogZero, pShape);
+            }
+            else
+            {
+                BSShapeConvexHull chullDesc;
+                if (BSShapeConvexHull.TryGetConvexHullByPtr(pShape, out chullDesc))
+                {
+                    chullDesc.Dereference(physicsScene);
+                    // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundConvexHull,shape={1}", BSScene.DetailLogZero, pShape);
+                }
+                else
+                {
+                    BSShapeGImpact gImpactDesc;
+                    if (BSShapeGImpact.TryGetGImpactByPtr(pShape, out gImpactDesc))
+                    {
+                        gImpactDesc.Dereference(physicsScene);
+                        // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundgImpact,shape={1}", BSScene.DetailLogZero, pShape);
+                    }
+                    else
+                    {
+                        // Didn't find it in the lists of specific types. It could be compound.
+                        BSShapeCompound compoundDesc;
+                        if (BSShapeCompound.TryGetCompoundByPtr(pShape, out compoundDesc))
+                        {
+                            compoundDesc.Dereference(physicsScene);
+                            // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,recursiveCompoundShape,shape={1}", BSScene.DetailLogZero, pShape);
+                        }
+                        else
+                        {
+                            // If none of the above, maybe it is a simple native shape.
+                            if (physicsScene.PE.IsNativeShape(pShape))
+                            {
+                                // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,assumingNative,shape={1}", BSScene.DetailLogZero, pShape);
+                                BSShapeNative nativeShape = new BSShapeNative(pShape);
+                                nativeShape.Dereference(physicsScene);
+                            }
+                            else
+                            {
+                                physicsScene.Logger.WarnFormat("{0} DereferenceAnonCollisionShape. Did not find shape. {1}",
+                                    LogHeader, pShape);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ============================================================================================================
+// BSShapeConvexHull is a wrapper for a Bullet single convex hull. A BSShapeHull contains multiple convex
+//     hull shapes. This is used for simple prims that are convex and thus can be made into a simple
+//     collision shape (a single hull). More complex physical shapes will be BSShapeHull's.
+public class BSShapeConvexHull : BSShape
+{
+#pragma warning disable 414
+    private static string LogHeader = "[BULLETSIM SHAPE CONVEX HULL]";
+#pragma warning restore 414
+
+    public static Dictionary<System.UInt64, BSShapeConvexHull> ConvexHulls = new Dictionary<System.UInt64, BSShapeConvexHull>();
+
+    public BSShapeConvexHull(BulletShape pShape) : base(pShape)
+    {
+    }
+    public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+    {
+        float lod;
+        System.UInt64 newMeshKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
+
+        physicsScene.DetailLog("{0},BSShapeConvexHull,getReference,newKey={1},size={2},lod={3}",
+                                prim.LocalID, newMeshKey.ToString("X"), prim.Size, lod);
+
+        BSShapeConvexHull retConvexHull = null;
+        lock (ConvexHulls)
+        {
+            if (ConvexHulls.TryGetValue(newMeshKey, out retConvexHull))
+            {
+                // The mesh has already been created. Return a new reference to same.
+                retConvexHull.IncrementReference();
+            }
+            else
+            {
+                retConvexHull = new BSShapeConvexHull(new BulletShape());
+                BulletShape convexShape = null;
+
+                // Get a handle to a mesh to build the hull from
+                BSShape baseMesh = BSShapeMesh.GetReference(physicsScene, false /* forceRebuild */, prim);
+                if (baseMesh.physShapeInfo.isNativeShape)
+                {
+                    // We get here if the mesh was not creatable. Could be waiting for an asset from the disk.
+                    // In the short term, we return the native shape and a later ForceBodyShapeRebuild should
+                    //     get back to this code with a buildable mesh.
+                    // TODO: not sure the temp native shape is freed when the mesh is rebuilt. When does this get freed?
+                    convexShape = baseMesh.physShapeInfo;
+                }
+                else
+                {
+                    convexShape = physicsScene.PE.BuildConvexHullShapeFromMesh(physicsScene.World, baseMesh.physShapeInfo);
+                    convexShape.shapeKey = newMeshKey;
+                    ConvexHulls.Add(convexShape.shapeKey, retConvexHull);
+                    physicsScene.DetailLog("{0},BSShapeConvexHull.GetReference,addingNewlyCreatedShape,shape={1}",
+                                        BSScene.DetailLogZero, convexShape);
+                }
+
+                // Done with the base mesh
+                baseMesh.Dereference(physicsScene);
+
+                retConvexHull.physShapeInfo = convexShape;
+            }
+        }
+        return retConvexHull;
+    }
+    public override BSShape GetReference(BSScene physicsScene, BSPhysObject prim)
+    {
+        // Calling this reference means we want another handle to an existing shape
+        //     (usually linksets) so return this copy.
+        IncrementReference();
+        return this;
+    }
+    // Dereferencing a compound shape releases the hold on all the child shapes.
+    public override void Dereference(BSScene physicsScene)
+    {
+        lock (ConvexHulls)
+        {
+            this.DecrementReference();
+            physicsScene.DetailLog("{0},BSShapeConvexHull.Dereference,shape={1}", BSScene.DetailLogZero, this);
+            // TODO: schedule aging and destruction of unused meshes.
+        }
+    }
+    // Loop through all the known hulls and return the description based on the physical address.
+    public static bool TryGetConvexHullByPtr(BulletShape pShape, out BSShapeConvexHull outHull)
+    {
+        bool ret = false;
+        BSShapeConvexHull foundDesc = null;
+        lock (ConvexHulls)
+        {
+            foreach (BSShapeConvexHull sh in ConvexHulls.Values)
+            {
+                if (sh.physShapeInfo.ReferenceSame(pShape))
+                {
+                    foundDesc = sh;
+                    ret = true;
+                    break;
+                }
+
+            }
+        }
+        outHull = foundDesc;
+        return ret;
+    }
+}
+// ============================================================================================================
+// BSShapeGImpact is a wrapper for the Bullet GImpact shape which is a collision mesh shape that
+//     can handle concave as well as convex shapes. Much slower computationally but creates smoother
+//     shapes than multiple convex hull approximations.
+public class BSShapeGImpact : BSShape
+{
+#pragma warning disable 414
+    private static string LogHeader = "[BULLETSIM SHAPE GIMPACT]";
+#pragma warning restore 414
+
+    public static Dictionary<System.UInt64, BSShapeGImpact> GImpacts = new Dictionary<System.UInt64, BSShapeGImpact>();
+
+    public BSShapeGImpact(BulletShape pShape) : base(pShape)
+    {
+    }
+    public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+    {
+        float lod;
+        System.UInt64 newMeshKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
+
+        physicsScene.DetailLog("{0},BSShapeGImpact,getReference,newKey={1},size={2},lod={3}",
+                                prim.LocalID, newMeshKey.ToString("X"), prim.Size, lod);
+
+        BSShapeGImpact retGImpact = null;
+        lock (GImpacts)
+        {
+            if (GImpacts.TryGetValue(newMeshKey, out retGImpact))
+            {
+                // The mesh has already been created. Return a new reference to same.
+                retGImpact.IncrementReference();
+            }
+            else
+            {
+                retGImpact = new BSShapeGImpact(new BulletShape());
+                BulletShape newShape = retGImpact.CreatePhysicalGImpact(physicsScene, prim, newMeshKey, prim.BaseShape, prim.Size, lod);
+
+                // Check to see if mesh was created (might require an asset).
+                newShape = VerifyMeshCreated(physicsScene, newShape, prim);
+                newShape.shapeKey = newMeshKey;
+                if (!newShape.isNativeShape || prim.AssetFailed())
+                {
+                    // If a mesh was what was created, remember the built shape for later sharing.
+                    // Also note that if meshing failed we put it in the mesh list as there is nothing
+                    //         else to do about the mesh.
+                    GImpacts.Add(newMeshKey, retGImpact);
+                }
+
+                retGImpact.physShapeInfo = newShape;
+            }
+        }
+        return retGImpact;
+    }
+
+    private BulletShape CreatePhysicalGImpact(BSScene physicsScene, BSPhysObject prim, System.UInt64 newMeshKey,
+                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
+    {
+        return BSShapeMesh.CreatePhysicalMeshShape(physicsScene, prim, newMeshKey, pbs, size, lod,
+                            (w, iC, i, vC, v) =>
+                            {
+                                shapeInfo.Vertices = vC;
+                                return physicsScene.PE.CreateGImpactShape(w, iC, i, vC, v);
+                            });
+    }
+
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
+    {
+        BSShape ret = null;
+        // If the underlying shape is native, the actual shape has not been build (waiting for asset)
+        //     and we must create a copy of the native shape since they are never shared.
+        if (physShapeInfo.HasPhysicalShape && physShapeInfo.isNativeShape)
+        {
+            // TODO: decide when the native shapes should be freed. Check in Dereference?
+            ret = BSShapeNative.GetReference(pPhysicsScene, pPrim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
+        }
+        else
+        {
+            // Another reference to this shape is just counted.
+            IncrementReference();
+            ret = this;
+        }
+        return ret;
+    }
+    // Dereferencing a compound shape releases the hold on all the child shapes.
+    public override void Dereference(BSScene physicsScene)
+    {
+        lock (GImpacts)
+        {
+            this.DecrementReference();
+            physicsScene.DetailLog("{0},BSShapeGImpact.Dereference,shape={1}", BSScene.DetailLogZero, this);
+            // TODO: schedule aging and destruction of unused meshes.
+        }
+    }
+    // Loop through all the known hulls and return the description based on the physical address.
+    public static bool TryGetGImpactByPtr(BulletShape pShape, out BSShapeGImpact outHull)
+    {
+        bool ret = false;
+        BSShapeGImpact foundDesc = null;
+        lock (GImpacts)
+        {
+            foreach (BSShapeGImpact sh in GImpacts.Values)
+            {
+                if (sh.physShapeInfo.ReferenceSame(pShape))
+                {
+                    foundDesc = sh;
+                    ret = true;
+                    break;
+                }
+
+            }
+        }
+        outHull = foundDesc;
+        return ret;
+    }
+}
+
+// ============================================================================================================
+// BSShapeAvatar is a specialized mesh shape for avatars.
+public class BSShapeAvatar : BSShape
+{
+#pragma warning disable 414
+    private static string LogHeader = "[BULLETSIM SHAPE AVATAR]";
+#pragma warning restore 414
+
+    public BSShapeAvatar()
+        : base()
+    {
+    }
+    public static BSShape GetReference(BSPhysObject prim)
+    {
+        return new BSShapeNull();
+    }
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
+    {
+        return new BSShapeNull();
+    }
+    public override void Dereference(BSScene physicsScene) { }
+
+    // From the front:
+    //     A---A
+    //    /     \
+    //   B-------B
+    //  /         \        +Z
+    // C-----------C        |
+    // \           /   -Y --+-- +Y
+    //  \         /         |
+    //   \       /         -Z
+    //    D-----D
+    //     \   /
+    //      E-E
+
+    // From the top A and E are just lines.
+    //              B, C and D are hexagons:
+    //
+    //     C1--C2            +X
+    //    /      \            |
+    //  C0        C3     -Y --+-- +Y
+    //    \      /            |
+    //     C5--C4            -X
+
+    // Zero goes directly through the middle so the offsets are from that middle axis
+    //     and up and down from a middle horizon (A and E are the same distance from the zero).
+    // The height, width and depth is one. All scaling is done by the simulator.
+
+    // Z component -- how far the level is from the middle zero
+    private const float Aup = 0.5f;
+    private const float Bup = 0.4f;
+    private const float Cup = 0.3f;
+    private const float Dup = -0.4f;
+    private const float Eup = -0.5f;
+
+    // Y component -- distance from center to x0 and x3
+    private const float Awid = 0.25f;
+    private const float Bwid = 0.3f;
+    private const float Cwid = 0.5f;
+    private const float Dwid = 0.3f;
+    private const float Ewid = 0.2f;
+
+    // Y component -- distance from center to x1, x2, x4 and x5
+    private const float Afwid = 0.0f;
+    private const float Bfwid = 0.2f;
+    private const float Cfwid = 0.4f;
+    private const float Dfwid = 0.2f;
+    private const float Efwid = 0.0f;
+
+    // X component -- distance from zero to the front or back of a level
+    private const float Adep = 0f;
+    private const float Bdep = 0.3f;
+    private const float Cdep = 0.5f;
+    private const float Ddep = 0.2f;
+    private const float Edep = 0f;
+
+    private OMV.Vector3[] avatarVertices = {
+           new OMV.Vector3( 0.0f, -Awid,  Aup),   // A0
+           new OMV.Vector3( 0.0f, +Awid,  Aup),   // A3
+
+           new OMV.Vector3( 0.0f, -Bwid,  Bup),   // B0
+           new OMV.Vector3(+Bdep, -Bfwid, Bup),   // B1
+           new OMV.Vector3(+Bdep, +Bfwid, Bup),   // B2
+           new OMV.Vector3( 0.0f, +Bwid,  Bup),   // B3
+           new OMV.Vector3(-Bdep, +Bfwid, Bup),   // B4
+           new OMV.Vector3(-Bdep, -Bfwid, Bup),   // B5
+
+           new OMV.Vector3( 0.0f, -Cwid,  Cup),   // C0
+           new OMV.Vector3(+Cdep, -Cfwid, Cup),   // C1
+           new OMV.Vector3(+Cdep, +Cfwid, Cup),   // C2
+           new OMV.Vector3( 0.0f, +Cwid,  Cup),   // C3
+           new OMV.Vector3(-Cdep, +Cfwid, Cup),   // C4
+           new OMV.Vector3(-Cdep, -Cfwid, Cup),   // C5
+
+           new OMV.Vector3( 0.0f, -Dwid,  Dup),   // D0
+           new OMV.Vector3(+Ddep, -Dfwid, Dup),   // D1
+           new OMV.Vector3(+Ddep, +Dfwid, Dup),   // D2
+           new OMV.Vector3( 0.0f, +Dwid,  Dup),   // D3
+           new OMV.Vector3(-Ddep, +Dfwid, Dup),   // D4
+           new OMV.Vector3(-Ddep, -Dfwid, Dup),   // D5
+
+           new OMV.Vector3( 0.0f, -Ewid,  Eup),   // E0
+           new OMV.Vector3( 0.0f, +Ewid,  Eup),   // E3
+    };
+
+    // Offsets of the vertices in the vertices array
+    private enum Ind : int
+    {
+        A0, A3,
+        B0, B1, B2, B3, B4, B5,
+        C0, C1, C2, C3, C4, C5,
+        D0, D1, D2, D3, D4, D5,
+        E0, E3
+    }
+
+    // Comments specify trianges and quads in clockwise direction
+    private Ind[] avatarIndices = {
+        Ind.A0, Ind.B0, Ind.B1,                         // A0,B0,B1
+        Ind.A0, Ind.B1, Ind.B2, Ind.B2, Ind.A3, Ind.A0, // A0,B1,B2,A3
+        Ind.A3, Ind.B2, Ind.B3,                         // A3,B2,B3
+        Ind.A3, Ind.B3, Ind.B4,                         // A3,B3,B4
+        Ind.A3, Ind.B4, Ind.B5, Ind.B5, Ind.A0, Ind.A3, // A3,B4,B5,A0
+        Ind.A0, Ind.B5, Ind.B0,                         // A0,B5,B0
+
+        Ind.B0, Ind.C0, Ind.C1, Ind.C1, Ind.B1, Ind.B0, // B0,C0,C1,B1
+        Ind.B1, Ind.C1, Ind.C2, Ind.C2, Ind.B2, Ind.B1, // B1,C1,C2,B2
+        Ind.B2, Ind.C2, Ind.C3, Ind.C3, Ind.B3, Ind.B2, // B2,C2,C3,B3
+        Ind.B3, Ind.C3, Ind.C4, Ind.C4, Ind.B4, Ind.B3, // B3,C3,C4,B4
+        Ind.B4, Ind.C4, Ind.C5, Ind.C5, Ind.B5, Ind.B4, // B4,C4,C5,B5
+        Ind.B5, Ind.C5, Ind.C0, Ind.C0, Ind.B0, Ind.B5, // B5,C5,C0,B0
+
+        Ind.C0, Ind.D0, Ind.D1, Ind.D1, Ind.C1, Ind.C0, // C0,D0,D1,C1
+        Ind.C1, Ind.D1, Ind.D2, Ind.D2, Ind.C2, Ind.C1, // C1,D1,D2,C2
+        Ind.C2, Ind.D2, Ind.D3, Ind.D3, Ind.C3, Ind.C2, // C2,D2,D3,C3
+        Ind.C3, Ind.D3, Ind.D4, Ind.D4, Ind.C4, Ind.C3, // C3,D3,D4,C4
+        Ind.C4, Ind.D4, Ind.D5, Ind.D5, Ind.C5, Ind.C4, // C4,D4,D5,C5
+        Ind.C5, Ind.D5, Ind.D0, Ind.D0, Ind.C0, Ind.C5, // C5,D5,D0,C0
+
+        Ind.E0, Ind.D0, Ind.D1,                         // E0,D0,D1
+        Ind.E0, Ind.D1, Ind.D2, Ind.D2, Ind.E3, Ind.E0, // E0,D1,D2,E3
+        Ind.E3, Ind.D2, Ind.D3,                         // E3,D2,D3
+        Ind.E3, Ind.D3, Ind.D4,                         // E3,D3,D4
+        Ind.E3, Ind.D4, Ind.D5, Ind.D5, Ind.E0, Ind.E3, // E3,D4,D5,E0
+        Ind.E0, Ind.D5, Ind.D0,                         // E0,D5,D0
+
+    };
+
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs
new file mode 100755
index 0000000..42fc11b
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using Nini.Config;
+using log4net;
+
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public sealed class BSTerrainHeightmap : BSTerrainPhys
+{
+    static string LogHeader = "[BULLETSIM TERRAIN HEIGHTMAP]";
+
+    BulletHMapInfo m_mapInfo = null;
+
+    // Constructor to build a default, flat heightmap terrain.
+    public BSTerrainHeightmap(BSScene physicsScene, Vector3 regionBase, uint id, Vector3 regionSize)
+        : base(physicsScene, regionBase, id)
+    {
+        Vector3 minTerrainCoords = new Vector3(0f, 0f, BSTerrainManager.HEIGHT_INITIALIZATION - BSTerrainManager.HEIGHT_EQUAL_FUDGE);
+        Vector3 maxTerrainCoords = new Vector3(regionSize.X, regionSize.Y, BSTerrainManager.HEIGHT_INITIALIZATION);
+        int totalHeights = (int)maxTerrainCoords.X * (int)maxTerrainCoords.Y;
+        float[] initialMap = new float[totalHeights];
+        for (int ii = 0; ii < totalHeights; ii++)
+        {
+            initialMap[ii] = BSTerrainManager.HEIGHT_INITIALIZATION;
+        }
+        m_mapInfo = new BulletHMapInfo(id, initialMap, regionSize.X, regionSize.Y);
+        m_mapInfo.minCoords = minTerrainCoords;
+        m_mapInfo.maxCoords = maxTerrainCoords;
+        m_mapInfo.terrainRegionBase = TerrainBase;
+        // Don't have to free any previous since we just got here.
+        BuildHeightmapTerrain();
+    }
+
+    // This minCoords and maxCoords passed in give the size of the terrain (min and max Z
+    //         are the high and low points of the heightmap).
+    public BSTerrainHeightmap(BSScene physicsScene, Vector3 regionBase, uint id, float[] initialMap,
+                                                    Vector3 minCoords, Vector3 maxCoords)
+        : base(physicsScene, regionBase, id)
+    {
+        m_mapInfo = new BulletHMapInfo(id, initialMap, maxCoords.X - minCoords.X, maxCoords.Y - minCoords.Y);
+        m_mapInfo.minCoords = minCoords;
+        m_mapInfo.maxCoords = maxCoords;
+        m_mapInfo.minZ = minCoords.Z;
+        m_mapInfo.maxZ = maxCoords.Z;
+        m_mapInfo.terrainRegionBase = TerrainBase;
+
+        // Don't have to free any previous since we just got here.
+        BuildHeightmapTerrain();
+    }
+
+    public override void Dispose()
+    {
+        ReleaseHeightMapTerrain();
+    }
+
+    // Using the information in m_mapInfo, create the physical representation of the heightmap.
+    private void BuildHeightmapTerrain()
+    {
+        // Create the terrain shape from the mapInfo
+        m_mapInfo.terrainShape = m_physicsScene.PE.CreateTerrainShape( m_mapInfo.ID,
+                                new Vector3(m_mapInfo.sizeX, m_mapInfo.sizeY, 0), m_mapInfo.minZ, m_mapInfo.maxZ,
+                                m_mapInfo.heightMap, 1f, BSParam.TerrainCollisionMargin);
+
+
+        // The terrain object initial position is at the center of the object
+        Vector3 centerPos;
+        centerPos.X = m_mapInfo.minCoords.X + (m_mapInfo.sizeX / 2f);
+        centerPos.Y = m_mapInfo.minCoords.Y + (m_mapInfo.sizeY / 2f);
+        centerPos.Z = m_mapInfo.minZ + ((m_mapInfo.maxZ - m_mapInfo.minZ) / 2f);
+
+        m_mapInfo.terrainBody = m_physicsScene.PE.CreateBodyWithDefaultMotionState(m_mapInfo.terrainShape,
+                                m_mapInfo.ID, centerPos, Quaternion.Identity);
+
+        // Set current terrain attributes
+        m_physicsScene.PE.SetFriction(m_mapInfo.terrainBody, BSParam.TerrainFriction);
+        m_physicsScene.PE.SetHitFraction(m_mapInfo.terrainBody, BSParam.TerrainHitFraction);
+        m_physicsScene.PE.SetRestitution(m_mapInfo.terrainBody, BSParam.TerrainRestitution);
+        m_physicsScene.PE.SetCollisionFlags(m_mapInfo.terrainBody, CollisionFlags.CF_STATIC_OBJECT);
+
+        m_mapInfo.terrainBody.collisionType = CollisionType.Terrain;
+
+        // Return the new terrain to the world of physical objects
+        m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, m_mapInfo.terrainBody);
+
+        // redo its bounding box now that it is in the world
+        m_physicsScene.PE.UpdateSingleAabb(m_physicsScene.World, m_mapInfo.terrainBody);
+
+        // Make it so the terrain will not move or be considered for movement.
+        m_physicsScene.PE.ForceActivationState(m_mapInfo.terrainBody, ActivationState.DISABLE_SIMULATION);
+
+        return;
+    }
+
+    // If there is information in m_mapInfo pointing to physical structures, release same.
+    private void ReleaseHeightMapTerrain()
+    {
+        if (m_mapInfo != null)
+        {
+            if (m_mapInfo.terrainBody.HasPhysicalBody)
+            {
+                m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, m_mapInfo.terrainBody);
+                // Frees both the body and the shape.
+                m_physicsScene.PE.DestroyObject(m_physicsScene.World, m_mapInfo.terrainBody);
+            }
+        }
+        m_mapInfo = null;
+    }
+
+    // The passed position is relative to the base of the region.
+    public override float GetTerrainHeightAtXYZ(Vector3 pos)
+    {
+        float ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;
+
+        int mapIndex = (int)pos.Y * (int)m_mapInfo.sizeY + (int)pos.X;
+        try
+        {
+            ret = m_mapInfo.heightMap[mapIndex];
+        }
+        catch
+        {
+            // Sometimes they give us wonky values of X and Y. Give a warning and return something.
+            m_physicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, pos={2}",
+                                LogHeader, m_mapInfo.terrainRegionBase, pos);
+            ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;
+        }
+        return ret;
+    }
+
+    // The passed position is relative to the base of the region.
+    public override float GetWaterLevelAtXYZ(Vector3 pos)
+    {
+        return m_physicsScene.SimpleWaterLevel;
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainManager.cs b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainManager.cs
new file mode 100755
index 0000000..d11baa6
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainManager.cs
@@ -0,0 +1,584 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using Nini.Config;
+using log4net;
+
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+
+// The physical implementation of the terrain is wrapped in this class.
+public abstract class BSTerrainPhys : IDisposable
+{
+    public enum TerrainImplementation
+    {
+        Heightmap   = 0,
+        Mesh        = 1
+    }
+
+    protected BSScene m_physicsScene { get; private set; }
+    // Base of the region in world coordinates. Coordinates inside the region are relative to this.
+    public Vector3 TerrainBase { get; private set; }
+    public uint ID { get; private set; }
+
+    public BSTerrainPhys(BSScene physicsScene, Vector3 regionBase, uint id)
+    {
+        m_physicsScene = physicsScene;
+        TerrainBase = regionBase;
+        ID = id;
+    }
+    public abstract void Dispose();
+    public abstract float GetTerrainHeightAtXYZ(Vector3 pos);
+    public abstract float GetWaterLevelAtXYZ(Vector3 pos);
+}
+
+// ==========================================================================================
+public sealed class BSTerrainManager : IDisposable
+{
+    static string LogHeader = "[BULLETSIM TERRAIN MANAGER]";
+
+    // These height values are fractional so the odd values will be
+    //     noticable when debugging.
+    public const float HEIGHT_INITIALIZATION = 24.987f;
+    public const float HEIGHT_INITIAL_LASTHEIGHT = 24.876f;
+    public const float HEIGHT_GETHEIGHT_RET = 24.765f;
+    public const float WATER_HEIGHT_GETHEIGHT_RET = 19.998f;
+
+    // If the min and max height are equal, we reduce the min by this
+    //    amount to make sure that a bounding box is built for the terrain.
+    public const float HEIGHT_EQUAL_FUDGE = 0.2f;
+
+    // Until the whole simulator is changed to pass us the region size, we rely on constants.
+    public Vector3 DefaultRegionSize = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
+
+    // The scene that I am part of
+    private BSScene m_physicsScene { get; set; }
+
+    // The ground plane created to keep thing from falling to infinity.
+    private BulletBody m_groundPlane;
+
+    // If doing mega-regions, if we're region zero we will be managing multiple
+    //    region terrains since region zero does the physics for the whole mega-region.
+    private Dictionary<Vector3, BSTerrainPhys> m_terrains;
+
+    // Flags used to know when to recalculate the height.
+    private bool m_terrainModified = false;
+
+    // If we are doing mega-regions, terrains are added from TERRAIN_ID to m_terrainCount.
+    // This is incremented before assigning to new region so it is the last ID allocated.
+    private uint m_terrainCount = BSScene.CHILDTERRAIN_ID - 1;
+    public uint HighestTerrainID { get {return m_terrainCount; } }
+
+    // If doing mega-regions, this holds our offset from region zero of
+    //     the mega-regions. "parentScene" points to the PhysicsScene of region zero.
+    private Vector3 m_worldOffset;
+    // If the parent region (region 0), this is the extent of the combined regions
+    //     relative to the origin of region zero
+    private Vector3 m_worldMax;
+    private PhysicsScene MegaRegionParentPhysicsScene { get; set; }
+
+    public BSTerrainManager(BSScene physicsScene, Vector3 regionSize)
+    {
+        m_physicsScene = physicsScene;
+        DefaultRegionSize = regionSize;
+
+        m_terrains = new Dictionary<Vector3,BSTerrainPhys>();
+
+        // Assume one region of default size
+        m_worldOffset = Vector3.Zero;
+        m_worldMax = new Vector3(DefaultRegionSize);
+        MegaRegionParentPhysicsScene = null;
+    }
+
+    public void Dispose()
+    {
+        ReleaseGroundPlaneAndTerrain();
+    }
+
+    // Create the initial instance of terrain and the underlying ground plane.
+    // This is called from the initialization routine so we presume it is
+    //    safe to call Bullet in real time. We hope no one is moving prims around yet.
+    public void CreateInitialGroundPlaneAndTerrain()
+    {
+        DetailLog("{0},BSTerrainManager.CreateInitialGroundPlaneAndTerrain,region={1}", BSScene.DetailLogZero, m_physicsScene.RegionName);
+        // The ground plane is here to catch things that are trying to drop to negative infinity
+        BulletShape groundPlaneShape = m_physicsScene.PE.CreateGroundPlaneShape(BSScene.GROUNDPLANE_ID, 1f, BSParam.TerrainCollisionMargin);
+        Vector3 groundPlaneAltitude = new Vector3(0f, 0f, BSParam.TerrainGroundPlane);
+        m_groundPlane = m_physicsScene.PE.CreateBodyWithDefaultMotionState(groundPlaneShape,
+                                        BSScene.GROUNDPLANE_ID, groundPlaneAltitude, Quaternion.Identity);
+
+        // Everything collides with the ground plane.
+        m_groundPlane.collisionType = CollisionType.Groundplane;
+
+        m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, m_groundPlane);
+        m_physicsScene.PE.UpdateSingleAabb(m_physicsScene.World, m_groundPlane);
+
+        // Ground plane does not move
+        m_physicsScene.PE.ForceActivationState(m_groundPlane, ActivationState.DISABLE_SIMULATION);
+
+        BSTerrainPhys initialTerrain = new BSTerrainHeightmap(m_physicsScene, Vector3.Zero, BSScene.TERRAIN_ID, DefaultRegionSize);
+        lock (m_terrains)
+        {
+            // Build an initial terrain and put it in the world. This quickly gets replaced by the real region terrain.
+            m_terrains.Add(Vector3.Zero, initialTerrain);
+        }
+    }
+
+    // Release all the terrain structures we might have allocated
+    public void ReleaseGroundPlaneAndTerrain()
+    {
+        DetailLog("{0},BSTerrainManager.ReleaseGroundPlaneAndTerrain,region={1}", BSScene.DetailLogZero, m_physicsScene.RegionName);
+        if (m_groundPlane.HasPhysicalBody)
+        {
+            if (m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, m_groundPlane))
+            {
+                m_physicsScene.PE.DestroyObject(m_physicsScene.World, m_groundPlane);
+            }
+            m_groundPlane.Clear();
+        }
+
+        ReleaseTerrain();
+    }
+
+    // Release all the terrain we have allocated
+    public void ReleaseTerrain()
+    {
+        lock (m_terrains)
+        {
+            foreach (KeyValuePair<Vector3, BSTerrainPhys> kvp in m_terrains)
+            {
+                kvp.Value.Dispose();
+            }
+            m_terrains.Clear();
+        }
+    }
+
+    // The simulator wants to set a new heightmap for the terrain.
+    public void SetTerrain(float[] heightMap) {
+        float[] localHeightMap = heightMap;
+        // If there are multiple requests for changes to the same terrain between ticks,
+        //      only do that last one.
+        m_physicsScene.PostTaintObject("TerrainManager.SetTerrain-"+ m_worldOffset.ToString(), 0, delegate()
+        {
+            if (m_worldOffset != Vector3.Zero && MegaRegionParentPhysicsScene != null)
+            {
+                // If a child of a mega-region, we shouldn't have any terrain allocated for us
+                ReleaseGroundPlaneAndTerrain();
+                // If doing the mega-prim stuff and we are the child of the zero region,
+                //    the terrain is added to our parent
+                if (MegaRegionParentPhysicsScene is BSScene)
+                {
+                    DetailLog("{0},SetTerrain.ToParent,offset={1},worldMax={2}", BSScene.DetailLogZero, m_worldOffset, m_worldMax);
+                    ((BSScene)MegaRegionParentPhysicsScene).TerrainManager.AddMegaRegionChildTerrain(
+                                        BSScene.CHILDTERRAIN_ID, localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize);
+                }
+            }
+            else
+            {
+                // If not doing the mega-prim thing, just change the terrain
+                DetailLog("{0},SetTerrain.Existing", BSScene.DetailLogZero);
+
+                UpdateTerrain(BSScene.TERRAIN_ID, localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize);
+            }
+        });
+    }
+
+    // Another region is calling this region and passing a terrain.
+    // A region that is not the mega-region root will pass its terrain to the root region so the root region
+    //      physics engine will have all the terrains.
+    private void AddMegaRegionChildTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords)
+    {
+        // Since we are called by another region's thread, the action must be rescheduled onto our processing thread.
+        m_physicsScene.PostTaintObject("TerrainManager.AddMegaRegionChild" + minCoords.ToString(), id, delegate()
+        {
+            UpdateTerrain(id, heightMap, minCoords, maxCoords);
+        });
+    }
+
+    // If called for terrain has has not been previously allocated, a new terrain will be built
+    //     based on the passed information. The 'id' should be either the terrain id or
+    //     BSScene.CHILDTERRAIN_ID. If the latter, a new child terrain ID will be allocated and used.
+    //     The latter feature is for creating child terrains for mega-regions.
+    // If there is an existing terrain body, a new
+    //     terrain shape is created and added to the body.
+    //     This call is most often used to update the heightMap and parameters of the terrain.
+    // (The above does suggest that some simplification/refactoring is in order.)
+    // Called during taint-time.
+    private void UpdateTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords)
+    {
+        // Find high and low points of passed heightmap.
+        // The min and max passed in is usually the area objects can be in (maximum
+        //     object height, for instance). The terrain wants the bounding box for the
+        //     terrain so replace passed min and max Z with the actual terrain min/max Z.
+        float minZ = float.MaxValue;
+        float maxZ = float.MinValue;
+        foreach (float height in heightMap)
+        {
+            if (height < minZ) minZ = height;
+            if (height > maxZ) maxZ = height;
+        }
+        if (minZ == maxZ)
+        {
+            // If min and max are the same, reduce min a little bit so a good bounding box is created.
+            minZ -= BSTerrainManager.HEIGHT_EQUAL_FUDGE;
+        }
+        minCoords.Z = minZ;
+        maxCoords.Z = maxZ;
+
+        DetailLog("{0},BSTerrainManager.UpdateTerrain,call,id={1},minC={2},maxC={3}",
+                            BSScene.DetailLogZero, id, minCoords, maxCoords);
+
+        Vector3 terrainRegionBase = new Vector3(minCoords.X, minCoords.Y, 0f);
+
+        lock (m_terrains)
+        {
+            BSTerrainPhys terrainPhys;
+            if (m_terrains.TryGetValue(terrainRegionBase, out terrainPhys))
+            {
+                // There is already a terrain in this spot. Free the old and build the new.
+                DetailLog("{0},BSTerrainManager.UpdateTerrain:UpdateExisting,call,id={1},base={2},minC={3},maxC={4}",
+                                BSScene.DetailLogZero, id, terrainRegionBase, minCoords, maxCoords);
+
+                // Remove old terrain from the collection
+                m_terrains.Remove(terrainRegionBase);
+                // Release any physical memory it may be using.
+                terrainPhys.Dispose();
+
+                if (MegaRegionParentPhysicsScene == null)
+                {
+                    // This terrain is not part of the mega-region scheme. Create vanilla terrain.
+                    BSTerrainPhys newTerrainPhys = BuildPhysicalTerrain(terrainRegionBase, id, heightMap, minCoords, maxCoords);
+                    m_terrains.Add(terrainRegionBase, newTerrainPhys);
+
+                    m_terrainModified = true;
+                }
+                else
+                {
+                    // It's possible that Combine() was called after this code was queued.
+                    // If we are a child of combined regions, we don't create any terrain for us.
+                    DetailLog("{0},BSTerrainManager.UpdateTerrain:AmACombineChild,taint", BSScene.DetailLogZero);
+
+                    // Get rid of any terrain that may have been allocated for us.
+                    ReleaseGroundPlaneAndTerrain();
+
+                    // I hate doing this, but just bail
+                    return;
+                }
+            }
+            else
+            {
+                // We don't know about this terrain so either we are creating a new terrain or
+                //    our mega-prim child is giving us a new terrain to add to the phys world
+
+                // if this is a child terrain, calculate a unique terrain id
+                uint newTerrainID = id;
+                if (newTerrainID >= BSScene.CHILDTERRAIN_ID)
+                    newTerrainID = ++m_terrainCount;
+
+                DetailLog("{0},BSTerrainManager.UpdateTerrain:NewTerrain,taint,newID={1},minCoord={2},maxCoord={3}",
+                                            BSScene.DetailLogZero, newTerrainID, minCoords, maxCoords);
+                BSTerrainPhys newTerrainPhys = BuildPhysicalTerrain(terrainRegionBase, id, heightMap, minCoords, maxCoords);
+                m_terrains.Add(terrainRegionBase, newTerrainPhys);
+
+                m_terrainModified = true;
+            }
+        }
+    }
+
+    // TODO: redo terrain implementation selection to allow other base types than heightMap.
+    private BSTerrainPhys BuildPhysicalTerrain(Vector3 terrainRegionBase, uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords)
+    {
+        m_physicsScene.Logger.DebugFormat("{0} Terrain for {1}/{2} created with {3}",
+                                            LogHeader, m_physicsScene.RegionName, terrainRegionBase,
+                                            (BSTerrainPhys.TerrainImplementation)BSParam.TerrainImplementation);
+        BSTerrainPhys newTerrainPhys = null;
+        switch ((int)BSParam.TerrainImplementation)
+        {
+            case (int)BSTerrainPhys.TerrainImplementation.Heightmap:
+                newTerrainPhys = new BSTerrainHeightmap(m_physicsScene, terrainRegionBase, id,
+                                            heightMap, minCoords, maxCoords);
+                break;
+            case (int)BSTerrainPhys.TerrainImplementation.Mesh:
+                newTerrainPhys = new BSTerrainMesh(m_physicsScene, terrainRegionBase, id,
+                                            heightMap, minCoords, maxCoords);
+                break;
+            default:
+                m_physicsScene.Logger.ErrorFormat("{0} Bad terrain implementation specified. Type={1}/{2},Region={3}/{4}",
+                                            LogHeader,
+                                            (int)BSParam.TerrainImplementation,
+                                            BSParam.TerrainImplementation,
+                                            m_physicsScene.RegionName, terrainRegionBase);
+                break;
+        }
+        return newTerrainPhys;
+    }
+
+    // Return 'true' of this position is somewhere in known physical terrain space
+    public bool IsWithinKnownTerrain(Vector3 pos)
+    {
+        Vector3 terrainBaseXYZ;
+        BSTerrainPhys physTerrain;
+        return GetTerrainPhysicalAtXYZ(pos, out physTerrain, out terrainBaseXYZ);
+    }
+
+    // Return a new position that is over known terrain if the position is outside our terrain.
+    public Vector3 ClampPositionIntoKnownTerrain(Vector3 pPos)
+    {
+        float edgeEpsilon = 0.1f;
+
+        Vector3 ret = pPos;
+
+        // First, base addresses are never negative so correct for that possible problem.
+        if (ret.X < 0f || ret.Y < 0f)
+        {
+            ret.X = Util.Clamp<float>(ret.X, 0f, 1000000f);
+            ret.Y = Util.Clamp<float>(ret.Y, 0f, 1000000f);
+            DetailLog("{0},BSTerrainManager.ClampPositionToKnownTerrain,zeroingNegXorY,oldPos={1},newPos={2}",
+                                        BSScene.DetailLogZero, pPos, ret);
+        }
+
+        // Can't do this function if we don't know about any terrain.
+        if (m_terrains.Count == 0)
+            return ret;
+
+        int loopPrevention = 10;
+        Vector3 terrainBaseXYZ;
+        BSTerrainPhys physTerrain;
+        while (!GetTerrainPhysicalAtXYZ(ret, out physTerrain, out terrainBaseXYZ))
+        {
+            // The passed position is not within a known terrain area.
+            // NOTE that GetTerrainPhysicalAtXYZ will set 'terrainBaseXYZ' to the base of the unfound region.
+
+            // Must be off the top of a region. Find an adjacent region to move into.
+            //     The returned terrain is always 'lower'. That is, closer to <0,0>.
+            Vector3 adjacentTerrainBase = FindAdjacentTerrainBase(terrainBaseXYZ);
+
+            if (adjacentTerrainBase.X < terrainBaseXYZ.X)
+            {
+                // moving down into a new region in the X dimension. New position will be the max in the new base.
+                ret.X = adjacentTerrainBase.X + DefaultRegionSize.X - edgeEpsilon;
+            }
+            if (adjacentTerrainBase.Y < terrainBaseXYZ.Y)
+            {
+                // moving down into a new region in the X dimension. New position will be the max in the new base.
+                ret.Y = adjacentTerrainBase.Y + DefaultRegionSize.Y - edgeEpsilon;
+            }
+            DetailLog("{0},BSTerrainManager.ClampPositionToKnownTerrain,findingAdjacentRegion,adjacentRegBase={1},oldPos={2},newPos={3}",
+                                        BSScene.DetailLogZero, adjacentTerrainBase, pPos, ret);
+
+            if (loopPrevention-- < 0f)
+            {
+                // The 'while' is a little dangerous so this prevents looping forever if the
+                //    mapping of the terrains ever gets messed up (like nothing at <0,0>) or
+                //    the list of terrains is in transition.
+                DetailLog("{0},BSTerrainManager.ClampPositionToKnownTerrain,suppressingFindAdjacentRegionLoop", BSScene.DetailLogZero);
+                break;
+            }
+        }
+
+        return ret;
+    }
+
+    // Given an X and Y, find the height of the terrain.
+    // Since we could be handling multiple terrains for a mega-region,
+    //    the base of the region is calcuated assuming all regions are
+    //    the same size and that is the default.
+    // Once the heightMapInfo is found, we have all the information to
+    //    compute the offset into the array.
+    private float lastHeightTX = 999999f;
+    private float lastHeightTY = 999999f;
+    private float lastHeight = HEIGHT_INITIAL_LASTHEIGHT;
+    public float GetTerrainHeightAtXYZ(Vector3 pos)
+    {
+        float tX = pos.X;
+        float tY = pos.Y;
+        // You'd be surprized at the number of times this routine is called
+        //    with the same parameters as last time.
+        if (!m_terrainModified && (lastHeightTX == tX) && (lastHeightTY == tY))
+            return lastHeight;
+        m_terrainModified = false;
+
+        lastHeightTX = tX;
+        lastHeightTY = tY;
+        float ret = HEIGHT_GETHEIGHT_RET;
+
+        Vector3 terrainBaseXYZ;
+        BSTerrainPhys physTerrain;
+        if (GetTerrainPhysicalAtXYZ(pos, out physTerrain, out terrainBaseXYZ))
+        {
+            ret = physTerrain.GetTerrainHeightAtXYZ(pos - terrainBaseXYZ);
+        }
+        else
+        {
+            m_physicsScene.Logger.ErrorFormat("{0} GetTerrainHeightAtXY: terrain not found: region={1}, x={2}, y={3}",
+                    LogHeader, m_physicsScene.RegionName, tX, tY);
+            DetailLog("{0},BSTerrainManager.GetTerrainHeightAtXYZ,terrainNotFound,pos={1},base={2}",
+                                BSScene.DetailLogZero, pos, terrainBaseXYZ);
+        }
+
+        lastHeight = ret;
+        return ret;
+    }
+
+    public float GetWaterLevelAtXYZ(Vector3 pos)
+    {
+        float ret = WATER_HEIGHT_GETHEIGHT_RET;
+
+        Vector3 terrainBaseXYZ;
+        BSTerrainPhys physTerrain;
+        if (GetTerrainPhysicalAtXYZ(pos, out physTerrain, out terrainBaseXYZ))
+        {
+            ret = physTerrain.GetWaterLevelAtXYZ(pos);
+        }
+        else
+        {
+            m_physicsScene.Logger.ErrorFormat("{0} GetWaterHeightAtXY: terrain not found: pos={1}, terrainBase={2}, height={3}",
+                    LogHeader, m_physicsScene.RegionName, pos, terrainBaseXYZ, ret);
+        }
+        return ret;
+    }
+
+    // Given an address, return 'true' of there is a description of that terrain and output
+    //    the descriptor class and the 'base' fo the addresses therein.
+    private bool GetTerrainPhysicalAtXYZ(Vector3 pos, out BSTerrainPhys outPhysTerrain, out Vector3 outTerrainBase)
+    {
+        bool ret = false;
+
+        Vector3 terrainBaseXYZ = Vector3.Zero;
+        if (pos.X < 0f || pos.Y < 0f)
+        {
+            // We don't handle negative addresses so just make up a base that will not be found.
+            terrainBaseXYZ = new Vector3(-DefaultRegionSize.X, -DefaultRegionSize.Y, 0f);
+        }
+        else
+        {
+            int offsetX = ((int)(pos.X / (int)DefaultRegionSize.X)) * (int)DefaultRegionSize.X;
+            int offsetY = ((int)(pos.Y / (int)DefaultRegionSize.Y)) * (int)DefaultRegionSize.Y;
+            terrainBaseXYZ = new Vector3(offsetX, offsetY, 0f);
+        }
+
+        BSTerrainPhys physTerrain = null;
+        lock (m_terrains)
+        {
+            ret = m_terrains.TryGetValue(terrainBaseXYZ, out physTerrain);
+        }
+        outTerrainBase = terrainBaseXYZ;
+        outPhysTerrain = physTerrain;
+        return ret;
+    }
+
+    // Given a terrain base, return a terrain base for a terrain that is closer to <0,0> than
+    //   this one. Usually used to return an out of bounds object to a known place.
+    private Vector3 FindAdjacentTerrainBase(Vector3 pTerrainBase)
+    {
+        Vector3 ret = pTerrainBase;
+
+        // Can't do this function if we don't know about any terrain.
+        if (m_terrains.Count == 0)
+            return ret;
+
+        // Just some sanity
+        ret.X = Util.Clamp<float>(ret.X, 0f, 1000000f);
+        ret.Y = Util.Clamp<float>(ret.Y, 0f, 1000000f);
+        ret.Z = 0f;
+
+        lock (m_terrains)
+        {
+            // Once down to the <0,0> region, we have to be done.
+            while (ret.X > 0f || ret.Y > 0f)
+            {
+                if (ret.X > 0f)
+                {
+                    ret.X = Math.Max(0f, ret.X - DefaultRegionSize.X);
+                    DetailLog("{0},BSTerrainManager.FindAdjacentTerrainBase,reducingX,terrainBase={1}", BSScene.DetailLogZero, ret);
+                    if (m_terrains.ContainsKey(ret))
+                        break;
+                }
+                if (ret.Y > 0f)
+                {
+                    ret.Y = Math.Max(0f, ret.Y - DefaultRegionSize.Y);
+                    DetailLog("{0},BSTerrainManager.FindAdjacentTerrainBase,reducingY,terrainBase={1}", BSScene.DetailLogZero, ret);
+                    if (m_terrains.ContainsKey(ret))
+                        break;
+                }
+            }
+        }
+
+        return ret;
+    }
+
+    // Although no one seems to check this, I do support combining.
+    public bool SupportsCombining()
+    {
+        return true;
+    }
+
+    // This routine is called two ways:
+    //    One with 'offset' and 'pScene' zero and null but 'extents' giving the maximum
+    //        extent of the combined regions. This is to inform the parent of the size
+    //        of the combined regions.
+    //    and one with 'offset' as the offset of the child region to the base region,
+    //        'pScene' pointing to the parent and 'extents' of zero. This informs the
+    //        child of its relative base and new parent.
+    public void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents)
+    {
+        m_worldOffset = offset;
+        m_worldMax = extents;
+        MegaRegionParentPhysicsScene = pScene;
+        if (pScene != null)
+        {
+            // We are a child.
+            // We want m_worldMax to be the highest coordinate of our piece of terrain.
+            m_worldMax = offset + DefaultRegionSize;
+        }
+        DetailLog("{0},BSTerrainManager.Combine,offset={1},extents={2},wOffset={3},wMax={4}",
+                        BSScene.DetailLogZero, offset, extents, m_worldOffset, m_worldMax);
+    }
+
+    // Unhook all the combining that I know about.
+    public void UnCombine(PhysicsScene pScene)
+    {
+        // Just like ODE, we don't do anything yet.
+        DetailLog("{0},BSTerrainManager.UnCombine", BSScene.DetailLogZero);
+    }
+
+
+    private void DetailLog(string msg, params Object[] args)
+    {
+        m_physicsScene.PhysicsLogging.Write(msg, args);
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainMesh.cs b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainMesh.cs
new file mode 100755
index 0000000..cd59b65
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainMesh.cs
@@ -0,0 +1,440 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using Nini.Config;
+using log4net;
+
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+public sealed class BSTerrainMesh : BSTerrainPhys
+{
+    static string LogHeader = "[BULLETSIM TERRAIN MESH]";
+
+    private float[] m_savedHeightMap;
+    int m_sizeX;
+    int m_sizeY;
+
+    BulletShape m_terrainShape;
+    BulletBody m_terrainBody;
+
+    public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id, Vector3 regionSize)
+        : base(physicsScene, regionBase, id)
+    {
+    }
+
+    public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id /* parameters for making mesh */)
+        : base(physicsScene, regionBase, id)
+    {
+    }
+
+    // Create terrain mesh from a heightmap.
+    public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id, float[] initialMap,
+                                                    Vector3 minCoords, Vector3 maxCoords)
+        : base(physicsScene, regionBase, id)
+    {
+        int indicesCount;
+        int[] indices;
+        int verticesCount;
+        float[] vertices;
+
+        m_savedHeightMap = initialMap;
+
+        m_sizeX = (int)(maxCoords.X - minCoords.X);
+        m_sizeY = (int)(maxCoords.Y - minCoords.Y);
+
+        bool meshCreationSuccess = false;
+        if (BSParam.TerrainMeshMagnification == 1)
+        {
+            // If a magnification of one, use the old routine that is tried and true.
+            meshCreationSuccess = BSTerrainMesh.ConvertHeightmapToMesh(m_physicsScene,
+                                            initialMap, m_sizeX, m_sizeY,       // input size
+                                            Vector3.Zero,                       // base for mesh
+                                            out indicesCount, out indices, out verticesCount, out vertices);
+        }
+        else
+        {
+            // Other magnifications use the newer routine
+            meshCreationSuccess = BSTerrainMesh.ConvertHeightmapToMesh2(m_physicsScene,
+                                            initialMap, m_sizeX, m_sizeY,       // input size
+                                            BSParam.TerrainMeshMagnification,
+                                            physicsScene.TerrainManager.DefaultRegionSize,
+                                            Vector3.Zero,                       // base for mesh
+                                            out indicesCount, out indices, out verticesCount, out vertices);
+        }
+        if (!meshCreationSuccess)
+        {
+            // DISASTER!!
+            m_physicsScene.DetailLog("{0},BSTerrainMesh.create,failedConversionOfHeightmap,id={1}", BSScene.DetailLogZero, ID);
+            m_physicsScene.Logger.ErrorFormat("{0} Failed conversion of heightmap to mesh! base={1}", LogHeader, TerrainBase);
+            // Something is very messed up and a crash is in our future.
+            return;
+        }
+
+        m_physicsScene.DetailLog("{0},BSTerrainMesh.create,meshed,id={1},indices={2},indSz={3},vertices={4},vertSz={5}",
+                                BSScene.DetailLogZero, ID, indicesCount, indices.Length, verticesCount, vertices.Length);
+
+        m_terrainShape = m_physicsScene.PE.CreateMeshShape(m_physicsScene.World, indicesCount, indices, verticesCount, vertices);
+        if (!m_terrainShape.HasPhysicalShape)
+        {
+            // DISASTER!!
+            m_physicsScene.DetailLog("{0},BSTerrainMesh.create,failedCreationOfShape,id={1}", BSScene.DetailLogZero, ID);
+            m_physicsScene.Logger.ErrorFormat("{0} Failed creation of terrain mesh! base={1}", LogHeader, TerrainBase);
+            // Something is very messed up and a crash is in our future.
+            return;
+        }
+
+        Vector3 pos = regionBase;
+        Quaternion rot = Quaternion.Identity;
+
+        m_terrainBody = m_physicsScene.PE.CreateBodyWithDefaultMotionState(m_terrainShape, ID, pos, rot);
+        if (!m_terrainBody.HasPhysicalBody)
+        {
+            // DISASTER!!
+            m_physicsScene.Logger.ErrorFormat("{0} Failed creation of terrain body! base={1}", LogHeader, TerrainBase);
+            // Something is very messed up and a crash is in our future.
+            return;
+        }
+        physicsScene.PE.SetShapeCollisionMargin(m_terrainShape, BSParam.TerrainCollisionMargin);
+
+        // Set current terrain attributes
+        m_physicsScene.PE.SetFriction(m_terrainBody, BSParam.TerrainFriction);
+        m_physicsScene.PE.SetHitFraction(m_terrainBody, BSParam.TerrainHitFraction);
+        m_physicsScene.PE.SetRestitution(m_terrainBody, BSParam.TerrainRestitution);
+        m_physicsScene.PE.SetContactProcessingThreshold(m_terrainBody, BSParam.TerrainContactProcessingThreshold);
+        m_physicsScene.PE.SetCollisionFlags(m_terrainBody, CollisionFlags.CF_STATIC_OBJECT);
+
+        // Static objects are not very massive.
+        m_physicsScene.PE.SetMassProps(m_terrainBody, 0f, Vector3.Zero);
+
+        // Put the new terrain to the world of physical objects
+        m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, m_terrainBody);
+
+        // Redo its bounding box now that it is in the world
+        m_physicsScene.PE.UpdateSingleAabb(m_physicsScene.World, m_terrainBody);
+
+        m_terrainBody.collisionType = CollisionType.Terrain;
+        m_terrainBody.ApplyCollisionMask(m_physicsScene);
+
+        if (BSParam.UseSingleSidedMeshes)
+        {
+            m_physicsScene.DetailLog("{0},BSTerrainMesh.settingCustomMaterial,id={1}", BSScene.DetailLogZero, id);
+            m_physicsScene.PE.AddToCollisionFlags(m_terrainBody, CollisionFlags.CF_CUSTOM_MATERIAL_CALLBACK);
+        }
+
+        // Make it so the terrain will not move or be considered for movement.
+        m_physicsScene.PE.ForceActivationState(m_terrainBody, ActivationState.DISABLE_SIMULATION);
+    }
+
+    public override void Dispose()
+    {
+        if (m_terrainBody.HasPhysicalBody)
+        {
+            m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, m_terrainBody);
+            // Frees both the body and the shape.
+            m_physicsScene.PE.DestroyObject(m_physicsScene.World, m_terrainBody);
+            m_terrainBody.Clear();
+            m_terrainShape.Clear();
+        }
+    }
+
+    public override float GetTerrainHeightAtXYZ(Vector3 pos)
+    {
+        // For the moment use the saved heightmap to get the terrain height.
+        // TODO: raycast downward to find the true terrain below the position.
+        float ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;
+
+        int mapIndex = (int)pos.Y * m_sizeY + (int)pos.X;
+        try
+        {
+            ret = m_savedHeightMap[mapIndex];
+        }
+        catch
+        {
+            // Sometimes they give us wonky values of X and Y. Give a warning and return something.
+            m_physicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, pos={2}",
+                                                LogHeader, TerrainBase, pos);
+            ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;
+        }
+        return ret;
+    }
+
+    // The passed position is relative to the base of the region.
+    public override float GetWaterLevelAtXYZ(Vector3 pos)
+    {
+        return m_physicsScene.SimpleWaterLevel;
+    }
+
+    // Convert the passed heightmap to mesh information suitable for CreateMeshShape2().
+    // Return 'true' if successfully created.
+    public static bool ConvertHeightmapToMesh( BSScene physicsScene,
+                                float[] heightMap, int sizeX, int sizeY,    // parameters of incoming heightmap
+                                Vector3 extentBase,                         // base to be added to all vertices
+                                out int indicesCountO, out int[] indicesO,
+                                out int verticesCountO, out float[] verticesO)
+    {
+        bool ret = false;
+
+        int indicesCount = 0;
+        int verticesCount = 0;
+        int[] indices = new int[0];
+        float[] vertices = new float[0];
+
+        // Simple mesh creation which assumes magnification == 1.
+        // TODO: do a more general solution that scales, adds new vertices and smoothes the result.
+
+        // Create an array of vertices that is sizeX+1 by sizeY+1 (note the loop
+        //    from zero to <= sizeX). The triangle indices are then generated as two triangles
+        //    per heightmap point. There are sizeX by sizeY of these squares. The extra row and
+        //    column of vertices are used to complete the triangles of the last row and column
+        //    of the heightmap.
+        try
+        {
+            // One vertice per heightmap value plus the vertices off the side and bottom edge.
+            int totalVertices = (sizeX + 1) * (sizeY + 1);
+            vertices = new float[totalVertices * 3];
+            int totalIndices = sizeX * sizeY * 6;
+            indices = new int[totalIndices];
+
+            if (physicsScene != null)
+                physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh,totVert={1},totInd={2},extentBase={3}",
+                                    BSScene.DetailLogZero, totalVertices, totalIndices, extentBase);
+            float minHeight = float.MaxValue;
+            // Note that sizeX+1 vertices are created since there is land between this and the next region.
+            for (int yy = 0; yy <= sizeY; yy++)
+            {
+                for (int xx = 0; xx <= sizeX; xx++)     // Hint: the "<=" means we go around sizeX + 1 times
+                {
+                    int offset = yy * sizeX + xx;
+                    // Extend the height with the height from the last row or column
+                    if (yy == sizeY) offset -= sizeX;
+                    if (xx == sizeX) offset -= 1;
+                    float height = heightMap[offset];
+                    minHeight = Math.Min(minHeight, height);
+                    vertices[verticesCount + 0] = (float)xx + extentBase.X;
+                    vertices[verticesCount + 1] = (float)yy + extentBase.Y;
+                    vertices[verticesCount + 2] = height + extentBase.Z;
+                    verticesCount += 3;
+                }
+            }
+            verticesCount = verticesCount / 3;
+
+            for (int yy = 0; yy < sizeY; yy++)
+            {
+                for (int xx = 0; xx < sizeX; xx++)
+                {
+                    int offset = yy * (sizeX + 1) + xx;
+                    // Each vertices is presumed to be the upper left corner of a box of two triangles
+                    indices[indicesCount + 0] = offset;
+                    indices[indicesCount + 1] = offset + 1;
+                    indices[indicesCount + 2] = offset + sizeX + 1; // accounting for the extra column
+                    indices[indicesCount + 3] = offset + 1;
+                    indices[indicesCount + 4] = offset + sizeX + 2;
+                    indices[indicesCount + 5] = offset + sizeX + 1;
+                    indicesCount += 6;
+                }
+            }
+
+            ret = true;
+        }
+        catch (Exception e)
+        {
+            if (physicsScene != null)
+                physicsScene.Logger.ErrorFormat("{0} Failed conversion of heightmap to mesh. For={1}/{2}, e={3}",
+                                                LogHeader, physicsScene.RegionName, extentBase, e);
+        }
+
+        indicesCountO = indicesCount;
+        indicesO = indices;
+        verticesCountO = verticesCount;
+        verticesO = vertices;
+
+        return ret;
+    }
+
+    private class HeightMapGetter
+    {
+        private float[] m_heightMap;
+        private int m_sizeX;
+        private int m_sizeY;
+        public HeightMapGetter(float[] pHeightMap, int pSizeX, int pSizeY)
+        {
+            m_heightMap = pHeightMap;
+            m_sizeX = pSizeX;
+            m_sizeY = pSizeY;
+        }
+        // The heightmap is extended as an infinite plane at the last height
+        public float GetHeight(int xx, int yy)
+        {
+            int offset = 0;
+            // Extend the height with the height from the last row or column
+            if (yy >= m_sizeY)
+                if (xx >= m_sizeX)
+                    offset = (m_sizeY - 1) * m_sizeX + (m_sizeX - 1);
+                else
+                    offset = (m_sizeY - 1) * m_sizeX + xx;
+            else
+                if (xx >= m_sizeX)
+                    offset = yy * m_sizeX + (m_sizeX - 1);
+                else
+                    offset = yy * m_sizeX + xx;
+
+            return m_heightMap[offset];
+        }
+    }
+
+    // Convert the passed heightmap to mesh information suitable for CreateMeshShape2().
+    // Version that handles magnification.
+    // Return 'true' if successfully created.
+    public static bool ConvertHeightmapToMesh2( BSScene physicsScene,
+                                float[] heightMap, int sizeX, int sizeY,    // parameters of incoming heightmap
+                                int magnification,                          // number of vertices per heighmap step
+                                Vector3 extent,                             // dimensions of the output mesh
+                                Vector3 extentBase,                         // base to be added to all vertices
+                                out int indicesCountO, out int[] indicesO,
+                                out int verticesCountO, out float[] verticesO)
+    {
+        bool ret = false;
+
+        int indicesCount = 0;
+        int verticesCount = 0;
+        int[] indices = new int[0];
+        float[] vertices = new float[0];
+
+        HeightMapGetter hmap = new HeightMapGetter(heightMap, sizeX, sizeY);
+
+        // The vertices dimension of the output mesh
+        int meshX = sizeX * magnification;
+        int meshY = sizeY * magnification;
+        // The output size of one mesh step
+        float meshXStep = extent.X / meshX;
+        float meshYStep = extent.Y / meshY;
+
+        // Create an array of vertices that is meshX+1 by meshY+1 (note the loop
+        //    from zero to <= meshX). The triangle indices are then generated as two triangles
+        //    per heightmap point. There are meshX by meshY of these squares. The extra row and
+        //    column of vertices are used to complete the triangles of the last row and column
+        //    of the heightmap.
+        try
+        {
+            // Vertices for the output heightmap plus one on the side and bottom to complete triangles
+            int totalVertices = (meshX + 1) * (meshY + 1);
+            vertices = new float[totalVertices * 3];
+            int totalIndices = meshX * meshY * 6;
+            indices = new int[totalIndices];
+
+            if (physicsScene != null)
+                physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh2,inSize={1},outSize={2},totVert={3},totInd={4},extentBase={5}",
+                                    BSScene.DetailLogZero, new Vector2(sizeX, sizeY), new Vector2(meshX, meshY),
+                                    totalVertices, totalIndices, extentBase);
+
+            float minHeight = float.MaxValue;
+            // Note that sizeX+1 vertices are created since there is land between this and the next region.
+            // Loop through the output vertices and compute the mediun height in between the input vertices
+            for (int yy = 0; yy <= meshY; yy++)
+            {
+                for (int xx = 0; xx <= meshX; xx++)     // Hint: the "<=" means we go around sizeX + 1 times
+                {
+                    float offsetY = (float)yy * (float)sizeY / (float)meshY;     // The Y that is closest to the mesh point
+                    int stepY = (int)offsetY;
+                    float fractionalY = offsetY - (float)stepY;
+                    float offsetX = (float)xx * (float)sizeX / (float)meshX;     // The X that is closest to the mesh point
+                    int stepX = (int)offsetX;
+                    float fractionalX = offsetX - (float)stepX;
+
+                    // physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh2,xx={1},yy={2},offX={3},stepX={4},fractX={5},offY={6},stepY={7},fractY={8}",
+                    //                 BSScene.DetailLogZero, xx, yy, offsetX, stepX, fractionalX, offsetY, stepY, fractionalY);
+
+                    // get the four corners of the heightmap square the mesh point is in
+                    float heightUL = hmap.GetHeight(stepX    , stepY    );
+                    float heightUR = hmap.GetHeight(stepX + 1, stepY    );
+                    float heightLL = hmap.GetHeight(stepX    , stepY + 1);
+                    float heightLR = hmap.GetHeight(stepX + 1, stepY + 1);
+
+                    // bilinear interplolation
+                    float height = heightUL * (1 - fractionalX) * (1 - fractionalY)
+                                 + heightUR * fractionalX       * (1 - fractionalY)
+                                 + heightLL * (1 - fractionalX) * fractionalY
+                                 + heightLR * fractionalX       * fractionalY;
+
+                    // physicsScene.DetailLog("{0},BSTerrainMesh.ConvertHeightMapToMesh2,heightUL={1},heightUR={2},heightLL={3},heightLR={4},heightMap={5}",
+                    //                 BSScene.DetailLogZero, heightUL, heightUR, heightLL, heightLR, height);
+
+                    minHeight = Math.Min(minHeight, height);
+
+                    vertices[verticesCount + 0] = (float)xx * meshXStep + extentBase.X;
+                    vertices[verticesCount + 1] = (float)yy * meshYStep + extentBase.Y;
+                    vertices[verticesCount + 2] = height + extentBase.Z;
+                    verticesCount += 3;
+                }
+            }
+            // The number of vertices generated
+            verticesCount /= 3;
+
+            // Loop through all the heightmap squares and create indices for the two triangles for that square
+            for (int yy = 0; yy < meshY; yy++)
+            {
+                for (int xx = 0; xx < meshX; xx++)
+                {
+                    int offset = yy * (meshX + 1) + xx;
+                    // Each vertices is presumed to be the upper left corner of a box of two triangles
+                    indices[indicesCount + 0] = offset;
+                    indices[indicesCount + 1] = offset + 1;
+                    indices[indicesCount + 2] = offset + meshX + 1; // accounting for the extra column
+                    indices[indicesCount + 3] = offset + 1;
+                    indices[indicesCount + 4] = offset + meshX + 2;
+                    indices[indicesCount + 5] = offset + meshX + 1;
+                    indicesCount += 6;
+                }
+            }
+
+            ret = true;
+        }
+        catch (Exception e)
+        {
+            if (physicsScene != null)
+                physicsScene.Logger.ErrorFormat("{0} Failed conversion of heightmap to mesh. For={1}/{2}, e={3}",
+                                                LogHeader, physicsScene.RegionName, extentBase, e);
+        }
+
+        indicesCountO = indicesCount;
+        indicesO = indices;
+        verticesCountO = verticesCount;
+        verticesO = vertices;
+
+        return ret;
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BulletSimData.cs b/OpenSim/Region/PhysicsModules/BulletS/BulletSimData.cs
new file mode 100755
index 0000000..3329395
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BulletSimData.cs
@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+// Classes to allow some type checking for the API
+// These hold pointers to allocated objects in the unmanaged space.
+// These classes are subclassed by the various physical implementations of
+// objects. In particular, there is a version for physical instances in
+// unmanaged memory ("unman") and one for in managed memory ("XNA").
+
+// Currently, the instances of these classes are a reference to a
+// physical representation and this has no releationship to other
+// instances. Someday, refarb the usage of these classes so each instance
+// refers to a particular physical instance and this class controls reference
+// counts and such. This should be done along with adding BSShapes.
+
+public class BulletWorld
+{
+    public BulletWorld(uint worldId, BSScene bss)
+    {
+        worldID = worldId;
+        physicsScene = bss;
+    }
+    public uint worldID;
+    // The scene is only in here so very low level routines have a handle to print debug/error messages
+    public BSScene physicsScene;
+}
+
+// An allocated Bullet btRigidBody
+public class BulletBody
+{
+    public BulletBody(uint id)
+    {
+        ID = id;
+        collisionType = CollisionType.Static;
+    }
+    public uint ID;
+    public CollisionType collisionType;
+
+    public virtual void Clear() { }
+    public virtual bool HasPhysicalBody { get { return false; } }
+
+    // Apply the specificed collision mask into the physical world
+    public virtual bool ApplyCollisionMask(BSScene physicsScene)
+    {
+        // Should assert the body has been added to the physical world.
+        // (The collision masks are stored in the collision proxy cache which only exists for
+        //    a collision body that is in the world.)
+        return physicsScene.PE.SetCollisionGroupMask(this,
+                                BulletSimData.CollisionTypeMasks[collisionType].group,
+                                BulletSimData.CollisionTypeMasks[collisionType].mask);
+    }
+
+    // Used for log messages for a unique display of the memory/object allocated to this instance
+    public virtual string AddrString
+    {
+        get { return "unknown"; }
+    }
+
+    public override string ToString()
+    {
+        StringBuilder buff = new StringBuilder();
+        buff.Append("<id=");
+        buff.Append(ID.ToString());
+        buff.Append(",p=");
+        buff.Append(AddrString);
+        buff.Append(",c=");
+        buff.Append(collisionType);
+        buff.Append(">");
+        return buff.ToString();
+    }
+}
+
+public class BulletShape
+{
+    public BulletShape()
+    {
+        shapeType = BSPhysicsShapeType.SHAPE_UNKNOWN;
+        shapeKey = (System.UInt64)FixedShapeKey.KEY_NONE;
+        isNativeShape = false;
+    }
+    public BSPhysicsShapeType shapeType;
+    public System.UInt64 shapeKey;
+    public bool isNativeShape;
+
+    public virtual void Clear() { }
+    public virtual bool HasPhysicalShape { get { return false; } }
+
+    // Make another reference to this physical object.
+    public virtual BulletShape Clone() { return new BulletShape(); }
+
+    // Return 'true' if this and other refer to the same physical object
+    public virtual bool ReferenceSame(BulletShape xx) { return false; }
+
+    // Used for log messages for a unique display of the memory/object allocated to this instance
+    public virtual string AddrString
+    {
+        get { return "unknown"; }
+    }
+
+    public override string ToString()
+    {
+        StringBuilder buff = new StringBuilder();
+        buff.Append("<p=");
+        buff.Append(AddrString);
+        buff.Append(",s=");
+        buff.Append(shapeType.ToString());
+        buff.Append(",k=");
+        buff.Append(shapeKey.ToString("X"));
+        buff.Append(",n=");
+        buff.Append(isNativeShape.ToString());
+        buff.Append(">");
+        return buff.ToString();
+    }
+}
+
+// An allocated Bullet btConstraint
+public class BulletConstraint
+{
+    public BulletConstraint()
+    {
+    }
+    public virtual void Clear() { }
+    public virtual bool HasPhysicalConstraint { get { return false; } }
+
+    // Used for log messages for a unique display of the memory/object allocated to this instance
+    public virtual string AddrString
+    {
+        get { return "unknown"; }
+    }
+}
+
+// An allocated HeightMapThing which holds various heightmap info.
+// Made a class rather than a struct so there would be only one
+//      instance of this and C# will pass around pointers rather
+//      than making copies.
+public class BulletHMapInfo
+{
+    public BulletHMapInfo(uint id, float[] hm, float pSizeX, float pSizeY) {
+        ID = id;
+        heightMap = hm;
+        terrainRegionBase = OMV.Vector3.Zero;
+        minCoords = new OMV.Vector3(100f, 100f, 25f);
+        maxCoords = new OMV.Vector3(101f, 101f, 26f);
+        minZ = maxZ = 0f;
+        sizeX = pSizeX;
+        sizeY = pSizeY;
+    }
+    public uint ID;
+    public float[] heightMap;
+    public OMV.Vector3 terrainRegionBase;
+    public OMV.Vector3 minCoords;
+    public OMV.Vector3 maxCoords;
+    public float sizeX, sizeY;
+    public float minZ, maxZ;
+    public BulletShape terrainShape;
+    public BulletBody terrainBody;
+}
+
+// The general class of collsion object.
+public enum CollisionType
+{
+    Avatar,
+    PhantomToOthersAvatar, // An avatar that it phantom to other avatars but not to anything else
+    Groundplane,
+    Terrain,
+    Static,
+    Dynamic,
+    VolumeDetect,
+    // Linkset, // A linkset should be either Static or Dynamic
+    LinksetChild,
+    Unknown
+};
+
+// Hold specification of group and mask collision flags for a CollisionType
+public struct CollisionTypeFilterGroup
+{
+    public CollisionTypeFilterGroup(CollisionType t, uint g, uint m)
+    {
+        type = t;
+        group = g;
+        mask = m;
+    }
+    public CollisionType type;
+    public uint group;
+    public uint mask;
+};
+
+public static class BulletSimData
+{
+
+// Map of collisionTypes to flags for collision groups and masks.
+// An object's 'group' is the collison groups this object belongs to
+// An object's 'filter' is the groups another object has to belong to in order to collide with me
+// A collision happens if ((obj1.group & obj2.filter) != 0) || ((obj2.group & obj1.filter) != 0)
+//
+// As mentioned above, don't use the CollisionFilterGroups definitions directly in the code
+//     but, instead, use references to this dictionary. Finding and debugging
+//     collision flag problems will be made easier.
+public static Dictionary<CollisionType, CollisionTypeFilterGroup> CollisionTypeMasks
+            = new Dictionary<CollisionType, CollisionTypeFilterGroup>()
+{
+    { CollisionType.Avatar,
+                new CollisionTypeFilterGroup(CollisionType.Avatar,
+                                (uint)CollisionFilterGroups.BCharacterGroup,
+                                (uint)(CollisionFilterGroups.BAllGroup))
+    },
+    { CollisionType.PhantomToOthersAvatar,
+        new CollisionTypeFilterGroup(CollisionType.PhantomToOthersAvatar,
+                                     (uint)CollisionFilterGroups.BCharacterGroup,
+                                     (uint)(CollisionFilterGroups.BAllGroup & ~CollisionFilterGroups.BCharacterGroup))
+    },
+    { CollisionType.Groundplane,
+                new CollisionTypeFilterGroup(CollisionType.Groundplane,
+                                (uint)CollisionFilterGroups.BGroundPlaneGroup,
+                                // (uint)CollisionFilterGroups.BAllGroup)
+                                (uint)(CollisionFilterGroups.BCharacterGroup | CollisionFilterGroups.BSolidGroup))
+    },
+    { CollisionType.Terrain,
+                new CollisionTypeFilterGroup(CollisionType.Terrain,
+                                (uint)CollisionFilterGroups.BTerrainGroup,
+                                (uint)(CollisionFilterGroups.BAllGroup & ~CollisionFilterGroups.BStaticGroup))
+    },
+    { CollisionType.Static,
+                new CollisionTypeFilterGroup(CollisionType.Static,
+                                (uint)CollisionFilterGroups.BStaticGroup,
+                                (uint)(CollisionFilterGroups.BCharacterGroup | CollisionFilterGroups.BSolidGroup))
+    },
+    { CollisionType.Dynamic,
+                new CollisionTypeFilterGroup(CollisionType.Dynamic,
+                                (uint)CollisionFilterGroups.BSolidGroup,
+                                (uint)(CollisionFilterGroups.BAllGroup))
+    },
+    { CollisionType.VolumeDetect,
+                new CollisionTypeFilterGroup(CollisionType.VolumeDetect,
+                                (uint)CollisionFilterGroups.BSensorTrigger,
+                                (uint)(~CollisionFilterGroups.BSensorTrigger))
+    },
+    { CollisionType.LinksetChild,
+                new CollisionTypeFilterGroup(CollisionType.LinksetChild,
+                                (uint)CollisionFilterGroups.BLinksetChildGroup,
+                                (uint)(CollisionFilterGroups.BNoneGroup))
+                                // (uint)(CollisionFilterGroups.BCharacterGroup | CollisionFilterGroups.BSolidGroup))
+    },
+};
+
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BulletSimTODO.txt b/OpenSim/Region/PhysicsModules/BulletS/BulletSimTODO.txt
new file mode 100755
index 0000000..0453376
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/BulletSimTODO.txt
@@ -0,0 +1,379 @@
+CURRENT PROBLEMS TO FIX AND/OR LOOK AT
+=================================================
+Vehicle buoyancy. Computed correctly? Possibly creating very large effective mass.
+    Interaction of llSetBuoyancy and vehicle buoyancy. Should be additive?
+    Negative buoyancy computed correctly
+Center-of-gravity
+Computation of mesh mass. How done? How should it be done?
+Enable vehicle border crossings (at least as poorly as ODE)
+        Terrain skirts
+        Avatar created in previous region and not new region when crossing border
+        Vehicle recreated in new sim at small Z value (offset from root value?) (DONE)
+User settable terrain mesh
+        Allow specifying as convex or concave and use different getHeight functions depending
+Boats, when turning nose down into the water
+        Acts like rotation around Z is also effecting rotation around X and Y
+Deleting a linkset while standing on the root will leave the physical shape of the root behind.
+        Not sure if it is because standing on it. Done with large prim linksets.
+Linkset child rotations.
+        Nebadon spiral tube has middle sections which are rotated wrong.
+        Select linked spiral tube. Delink and note where the middle section ends up.
+Teravus llMoveToTarget script debug
+        Mixing of hover, buoyancy/gravity, moveToTarget, into one force
+        Setting hover height to zero disables hover even if hover flags are on (from SL wiki)
+limitMotorUp calibration (more down?)
+llRotLookAt
+llLookAt
+Convert to avatar mesh capsule. Include rotation of capsule.
+Vehicle script tuning/debugging
+        Avanti speed script
+        Weapon shooter script
+Move material definitions (friction, ...) into simulator.
+osGetPhysicsEngineVerion() and create a version code for the C++ DLL
+One sided meshes? Should terrain be built into a closed shape?
+        When meshes get partially wedged into the terrain, they cannot push themselves out.
+        It is possible that Bullet processes collisions whether entering or leaving a mesh.
+        Ref: http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4869
+Small physical objects do not interact correctly
+    Create chain of .5x.5x.1 torui and make all but top physical so to hang.
+        The chain will fall apart and pairs will dance around on ground
+    Chains of 1x1x.2 will stay connected but will dance.
+    Chains above 2x2x.4 are more stable and get stablier as torui get larger.
+
+VEHICLES TODO LIST:
+=================================================
+LINEAR_MOTOR_DIRECTION values should be clamped to reasonable numbers.
+        What are the limits in SL?
+        Same for other velocity settings.
+UBit improvements to remove rubber-banding of avatars sitting on vehicle child prims:
+        https://github.com/UbitUmarov/Ubit-opensim
+Some vehicles should not be able to turn if no speed or off ground.
+Cannot edit/move a vehicle being ridden: it jumps back to the origional position.
+Neb car jiggling left and right
+        Happens on terrain and any other mesh object. Flat cubes are much smoother.
+        This has been reduced but not eliminated.
+Implement referenceFrame for all the motion routines.
+Verify llGetVel() is returning a smooth and good value for vehicle movement.
+llGetVel() should return the root's velocity if requested in a child prim.
+Implement function efficiency for lineaar and angular motion.
+Linkset explosion after three "rides" on Nebadon lite vehicle (LinksetConstraint)
+Remove vehicle angular velocity zeroing in BSPrim.UpdateProperties().
+        A kludge that isn't fixing the real problem of Bullet adding extra motion.
+Incorporate inter-relationship of angular corrections. For instance, angularDeflection
+        and angularMotorUp will compute same X or Y correction. When added together
+        creates over-correction and over-shoot and wabbling.
+Vehicle attributes are not restored when a vehicle is rezzed on region creation
+        Create vehicle, setup vehicle properties, restart region, vehicle is not reinitialized.
+What to do if vehicle and prim buoyancy differ?
+
+GENERAL TODO LIST:
+=================================================
+Resitution of a prim works on another prim but not on terrain.
+        The dropped prim doesn't bounce properly on the terrain.
+Add a sanity check for PIDTarget location.
+Level-of-detail for mesh creation. Prims with circular interiors require lod of 32.
+        Is much saved with lower LODs? At the moment, all set to 32.
+Collisions are inconsistant: arrows are supposed to hit and report collision. Often don't.
+        If arrow show at prim, collision reported about 1/3 of time. If collision reported,
+        both arrow and prim report it. The arrow bounces off the prim 9 out of 10 times.
+        Shooting 5m sphere "arrows" at 60m/s.
+llMoveToTarget objects are not effected by gravity until target is removed.
+Compute CCD parameters based on body size
+Can solver iterations be changed per body/shape? Can be for constraints but what
+        about regular vehicles?
+Implement llSetPhysicalMaterial.
+        extend it with Center-of-mass, rolling friction, density
+Implement llSetForceAndTorque.
+Change BSPrim.moveToTarget to used forces rather than changing position
+        Changing position allows one to move through walls
+Implement an avatar mesh shape. The Bullet capsule is way too limited.
+        Consider just hand creating a vertex/index array in a new BSShapeAvatar.
+Verify/fix phantom, volume-detect objects do not fall to infinity. Should stop at terrain.
+Revisit CollisionMargin. Builders notice the 0.04 spacing between prims.
+Duplicating a physical prim causes old prim to jump away
+        Dup a phys prim and the original become unselected and thus interacts w/ selected prim.
+Scenes with hundred of thousands of static objects take a lot of physics CPU time.
+Gun sending shooter flying.
+Collision margin (gap between physical objects lying on each other)
+Boundry checking (crashes related to crossing boundry)
+    Add check for border edge position for avatars and objects.
+    Verify the events are created for border crossings.
+Implement ShapeCollection.Dispose()
+Implement water as a plain or mesh so raycasting and collisions can happen with same.
+Add collision penetration return
+        Add field passed back by BulletSim.dll and fill with info in ManifoldConstact.GetDistance()
+Linkset.Position and Linkset.Orientation requre rewrite to properly return
+        child position. LinksetConstraint acts like it's at taint time!!
+Implement LockAngularMotion -- implements llSetStatus(ROTATE_AXIS_*, T/F)
+Should the different PID factors have non-equal contributions for different
+        values of Efficiency?
+Selecting and deselecting physical objects causes CPU processing time to jump
+        http://www.youtube.com/watch?v=Hjg57fWg8yI&hd=1
+        put thousand physical objects, select and deselect same. CPU time will be large.
+Re-implement buoyancy as a separate force on the object rather than diddling gravity.
+        Register a pre-step event to add the force.
+More efficient memory usage when passing hull information from BSPrim to BulletSim
+Physical and phantom will drop through the terrain
+
+
+LINKSETS
+======================================================
+Child prims do not report collisions
+Allow children of a linkset to be phantom:
+        http://opensim-dev.2196679.n2.nabble.com/Setting-a-single-child-prim-to-Phantom-tp7578513.html
+        Add OS_STATUS_PHANTOM_PRIM to llSetLinkPrimitaveParamsFast.
+Editing a child of a linkset causes the child to go phantom
+        Move a child prim once when it is physical and can never move it again without it going phantom
+Offset the center of the linkset to be the geometric center of all the prims
+        Not quite the same as the center-of-gravity
+Linksets should allow collisions to individual children
+        Add LocalID to children shapes in LinksetCompound and create events for individuals
+LinksetCompound: when one of the children changes orientation (like tires
+        turning on a vehicle, the whole compound object is rebuilt. Optimize this
+        so orientation/position of individual children can change without a rebuild.
+Verify/think through scripts in children of linksets. What do they reference
+        and return when getting position, velocity, ...
+Confirm constraint linksets still work after making all the changes for compound linksets.
+Use PostTaint callback to do rebuilds for constraint linksets to reduce rebuilding
+Add 'changed' flag or similar to reduce the number of times a linkset is rebuilt.
+        For compound linksets, add ability to remove or reposition individual child shapes.
+Speed up creation of large physical linksets
+        For instance, sitting in Neb's car (130 prims) takes several seconds to become physical.
+        REALLY bad for very large physical linksets (freezes the sim for many seconds).
+Eliminate collisions between objects in a linkset. (LinksetConstraint)
+    Have UserPointer point to struct with localID and linksetID?
+    Objects in original linkset still collide with each other?
+
+MORE
+======================================================
+Compute avatar size and scale correctly. Now it is a bit off from the capsule size.
+Create tests for different interface components
+        Have test objects/scripts measure themselves and turn color if correct/bad
+        Test functions in SL and calibrate correctness there
+        Create auto rezzer and tracker to run through the tests
+Do we need to do convex hulls all the time? Can complex meshes be left meshes?
+        There is some problem with meshes and collisions
+        Hulls are not as detailed as meshes. Hulled vehicles insides are different shape.
+Debounce avatar contact so legs don't keep folding up when standing.
+Add border extensions to terrain to help region crossings and objects leaving region.
+Use a different capsule shape for avatar when sitting
+        LL uses a pyrimidal shape scaled by the avatar's bounding box
+        http://wiki.secondlife.com/wiki/File:Avmeshforms.png
+Performance test with lots of avatars. Can BulletSim support a thousand?
+Optimize collisions in C++: only send up to the object subscribed to collisions.
+    Use collision subscription and remove the collsion(A,B) and collision(B,A)
+Check whether SimMotionState needs large if statement (see TODO).
+Implement 'top colliders' info.
+Avatar jump
+Performance measurement and changes to make quicker.
+Implement detailed physics stats (GetStats()).
+Measure performance improvement from hulls
+Test not using ghost objects for volume detect implementation.
+Performance of closures and delegates for taint processing
+        Are there faster ways?
+        Is any slowdown introduced by the existing implementation significant?
+Is there are more efficient method of implementing pre and post step actions?
+        See http://www.codeproject.com/Articles/29922/Weak-Events-in-C
+Physics Arena central pyramid: why is one side permiable?
+In SL, perfect spheres don't seem to have rolling friction. Add special case.
+Enforce physical parameter min/max:
+        Gravity: [-1, 28]
+        Friction: [0, 255]
+        Density: [1, 22587]
+        Restitution [0, 1]
+        http://wiki.secondlife.com/wiki/Physics_Material_Settings_test
+Avatar attachments have no mass? http://forums-archive.secondlife.com/54/f0/31796/1.html
+Keep avatar scaling correct. http://pennycow.blogspot.fr/2011/07/matter-of-scale.html
+
+INTERNAL IMPROVEMENT/CLEANUP
+=================================================
+Create the physical wrapper classes (BulletBody, BulletShape) by methods on
+        BSAPITemplate and make their actual implementation Bullet engine specific.
+        For the short term, just call the existing functions in ShapeCollection.
+Consider moving prim/character body and shape destruction in destroy()
+        to postTimeTime rather than protecting all the potential sets that
+        might have been queued up.
+Remove unused fields from ShapeData (not used in API2)
+Remove unused fields from pinned memory shared parameter block
+        Create parameter variables in BSScene to replace same.
+Breakout code for mesh/hull/compound/native into separate BSShape* classes
+    Standardize access to building and reference code.
+        The skeleton classes are in the sources but are not complete or linked in.
+Make BSBody and BSShape real classes to centralize creation/changin/destruction
+        Convert state and parameter calls from BulletSimAPI direct calls to
+                calls on BSBody and BSShape
+Generalize Dynamics and PID with standardized motors.
+Generalize Linkset and vehicles into PropertyManagers
+    Methods for Refresh, RemoveBodyDependencies, RestoreBodyDependencies
+        Potentially add events for shape destruction, etc.
+Better mechanism for resetting linkset set and vehicle parameters when body rebuilt.
+        BSPrim.CreateGeomAndObject is kludgy with the callbacks, etc.
+Implement linkset by setting position of children when root updated. (LinksetManual)
+        Linkset implementation using manual prim movement.
+LinkablePrim class? Would that simplify/centralize the linkset logic?
+BSScene.UpdateParameterSet() is broken. How to set params on objects?
+Add floating motor for BS_FLOATS_ON_WATER so prim and avatar will
+    bob at the water level. BSPrim.PositionSanityCheck()
+Should taints check for existance or activeness of target?
+        When destroying linksets/etc, taints can be generated for objects that are
+        actually gone when the taint happens. Crashes don't happen because the taint closure
+        keeps the object from being freed, but that is just an accident.
+        Possibly have an 'active' flag that is checked by the taint processor?
+Parameters for physics logging should be moved from BSScene to BSParam (at least boolean ones)
+Can some of the physical wrapper classes (BulletBody, BulletWorld, BulletShape) be 'sealed'?
+There are TOO MANY interfaces from BulletSim core to Bullet itself
+        Think of something to eliminate one or more of the layers
+
+THREADING
+=================================================
+Do taint action immediately if not actually executing Bullet.
+        Add lock around Bullet execution and just do taint actions if simulation is not happening.
+
+DONE DONE DONE DONE
+=================================================
+Cleanup code in BSDynamics by using motors. (Resolution: started)
+Consider implementing terrain with a mesh rather than heightmap. (Resolution: done)
+    Would have better and adjustable resolution.
+Build terrain mesh so heighmap is height of the center of the square meter.
+    Resolution: NOT DONE: SL and ODE define meter square as being at one corner with one diagional.
+Terrain as mesh. (Resolution: done)
+How are static linksets seen by the physics engine?
+    Resolution: they are not linked in physics. When moved, all the children are repositioned.
+Convert BSCharacter to use all API2 (Resolution: done)
+Avatar pushing difficult (too heavy?)
+Use asset service passed to BulletSim to get sculptie bodies, etc. (Resolution: done)
+Remove old code in DLL (all non-API2 stuff). (Resolution: done)
+Measurements of mega-physical prim performance (with graph) (Resolution: done, email)
+Debug Bullet internal stats output (why is timing all wrong?)
+        Resolution: Bullet stats logging only works with a single instance of Bullet (one region).
+Implement meshes or just verify that they work. (Resolution: they do!)
+Do prim hash codes work for sculpties and meshes? (Resolution: yes)
+Linkset implementation using compound shapes. (Resolution: implemented LinksetCompound)
+    Compound shapes will need the LocalID in the shapes and collision
+    processing to get it from there.
+Light cycle not banking (Resolution: It doesn't. Banking is roll adding yaw.)
+Package Bullet source mods for Bullet internal stats output
+        (Resolution: move code into WorldData.h rather than relying on patches)
+Single prim vehicles don't seem to properly vehiclize.
+        (Resolution: mass was not getting set properly for single prim linksets)
+Add material type linkage and input all the material property definitions.
+        Skeleton classes and table are in the sources but are not filled or used.
+        (Resolution: 
+Neb vehicle taking > 25ms of physics time!!
+        (Resolution: compound linksets were being rebuild WAY too often)
+Avatar height off after unsitting (floats off ground)
+        Editting appearance then moving restores.
+        Must not be initializing height when recreating capsule after unsit.
+        (Resolution: confusion of scale vs size for native objects removed)
+Light cycle falling over when driving (Resolution: implemented angularMotorUp)
+Should vehicle angular/linear movement friction happen after all the components
+        or does it only apply to the basic movement?
+        (Resolution: friction added before returning newly computed motor value.
+        What is expected by some vehicles (turning up friction to moderate speed))
+Tune terrain/object friction to be closer to SL.
+        (Resolution: added material type with friction and resolution)
+Smooth avatar movement with motor (DONE)
+        Should motor update be all at taint-time? (Yes, DONE)
+        Fix avatar slowly sliding when standing (zero motion when stopped) (DONE)
+        (Resolution: added BSVMotor for avatar starting and stopping)
+llApplyImpulse()
+        Compare mass/movement in OS and SL. Calibrate actions.  (DONE)
+        (Resolution: tested on SL and OS. AddForce scales the force for timestep)
+llSetBuoyancy() (DONE)
+        (Resolution: Bullet resets object gravity when added to world. Moved set gravity)
+Avatar density is WAY off. Compare and calibrate with what's in SL. (DONE)
+        (Resolution: set default density to 3.5 (from 60) which is closer to SL)
+Redo BulletSimAPI to allow native C# implementation of Bullet option (DONE)
+        (Resolution: added BSAPITemplate and then interfaces for C++ Bullet and C# BulletXNA
+Meshes rendering as bounding boxes (DONE)
+        (Resolution: Added test for mesh/sculpties in native shapes so it didn't think it was a box)
+llMoveToTarget (Resolution: added simple motor to update the position.)
+Angular motor direction is global coordinates rather than local coordinates (DONE)
+Add vehicle collisions so IsColliding is properly reported. (DONE)
+        Needed for banking, limitMotorUp, movementLimiting, ...
+        (Resolution: added CollisionFlags.BS_VEHICLE_COLLISION and code to use it)
+VehicleAddForce is not scaled by the simulation step but it is only
+        applied for one step. Should it be scaled? (DONE)
+        (Resolution: use force for timed things, Impulse for immediate, non-timed things)
+Complete implemention of preStepActions (DONE)
+        Replace vehicle step call with prestep event.
+        Is there a need for postStepActions? postStepTaints?
+Disable activity of passive linkset children. (DONE)
+        Since the linkset is a compound object, the old prims are left lying
+        around and need to be phantomized so they don't collide, ...
+Remove HeightmapInfo from terrain specification (DONE)
+    Since C++ code does not need terrain height, this structure et al are not needed.
+Surfboard go wonky when turning (DONE)
+        Angular motor direction is global coordinates rather than local coordinates?
+        (Resolution: made angular motor direction correct coordinate system)
+Mantis 6040 script http://opensimulator.org/mantis/view.php?id=6040 (DONE)
+        Msg Kayaker on OSGrid when working
+        (Resolution: LINEAR_DIRECTION is in vehicle coords. Test script does the
+        same in SL as in OS/BulletSim)
+Boats float low in the water (DONE)
+Boats floating at proper level (DONE)
+When is force introduced by SetForce removed? The prestep action could go forever. (DONE)
+        (Resolution: setForce registers a prestep action which keeps applying the force)
+Child movement in linkset (don't rebuild linkset) (DONE 20130122))
+Avatar standing on a moving object should start to move with the object. (DONE 20130125)
+Angular motion around Z moves the vehicle in world Z and not vehicle Z in ODE.
+        Verify that angular motion specified around Z moves in the vehicle coordinates.
+        DONE 20130120: BulletSim properly applies force in vehicle relative coordinates.
+Nebadon vehicles turning funny in arena (DONE)
+Lock axis (DONE 20130401)
+Terrain detail: double terrain mesh detail (DONE)
+Use the HACD convex hull routine in Bullet rather than the C# version.  
+        Speed up hullifying large meshes. (DONE)
+Vehicle ride, get up, ride again. Second time vehicle does not act correctly.
+        Have to rez new vehicle and delete the old to fix situation.
+        (DONE 20130520: normalize rotations)
+Hitting RESET on Nebadon's vehicle while riding causes vehicle to get into odd
+        position state where it will not settle onto ground properly, etc
+        (DONE 20130520: normalize rotations)
+Two of Nebadon vehicles in a sim max the CPU. This is new.
+        (DONE 20130520: two problems: if asset failed to mesh, constantly refetched
+        asset; vehicle was sending too many messages to all linkset members)
+Add material densities to the material types. (WILL NOT BE DONE: not how it is done)
+Avatars walking up stairs (DONE)
+Avatar movement
+        flying into a wall doesn't stop avatar who keeps appearing to move through the obstacle (DONE)
+        walking up stairs is not calibrated correctly (stairs out of Kepler cabin) (DONE)
+        avatar capsule rotation completed (NOT DONE - Bullet's capsule shape is not the solution)
+After getting off a vehicle, the root prim is phantom (can be walked through)
+    Need to force a position update for the root prim after compound shape destruction
+        (DONE)
+Explore btGImpactMeshShape as alternative to convex hulls for simplified physical objects.
+        Regular triangle meshes don't do physical collisions.
+        (DONE: discovered GImpact is VERY CPU intensive)
+Script changing rotation of child prim while vehicle moving (eg turning wheel) causes
+        the wheel to appear to jump back. Looks like sending position from previous update.
+        (DONE: redo of compound linksets fixed problem)
+Refarb compound linkset creation to create a pseudo-root for center-of-mass
+        Let children change their shape to physical indendently and just add shapes to compound
+        (DONE: redo of compound linkset fixed problem)
+Vehicle angular vertical attraction     (DONE: vegaslon code)
+vehicle angular banking (DONE: vegaslon code)
+Vehicle angular deflection      (DONE: vegaslon code)
+        Preferred orientation angular correction fix
+Vehicles (Move smoothly)
+For limitMotorUp, use raycast down to find if vehicle is in the air.
+        (WILL NOT BE DONE: gravity does the job well enough)
+BSPrim.Force should set a continious force on the prim. The force should be
+        applied each tick.  Some limits?
+        (DONE: added physical actors. Implemented SetForce, SetTorque, ...)
+Implement LSL physics controls. Like STATUS_ROTATE_X. (DONE)
+Add osGetPhysicsEngineName() so scripters can tell whether BulletSim or ODE
+Avatar rotation (check out changes to ScenePresence for physical rotation) (DONE)
+Avatar running (what does phys engine need to do?) (DONE: multiplies run factor by walking force)
+setForce should set a constant force. Different than AddImpulse. (DONE)
+Add PID motor for avatar movement (slow to stop, ...) (WNBD: current works ok)
+Avatar movement motor check for zero or small movement. Somehow suppress small movements
+        when avatar has stopped and is just standing. Simple test for near zero has
+        the problem of preventing starting up (increase from zero) especially when falling.
+        (DONE: avatar movement actor knows if standing on stationary object and zeros motion)
+Can the 'inTaintTime' flag be cleaned up and used? For instance, a call to
+        BSScene.TaintedObject() could immediately execute the callback if already in taint time.
+        (DONE)
+
+
+
diff --git a/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs b/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs
new file mode 100755
index 0000000..2ba3c5a
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs
@@ -0,0 +1,622 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+using Mono.Addins;
+using Nini.Config;
+using log4net;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule")]
+    public class ExtendedPhysics : INonSharedRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[EXTENDED PHYSICS]";
+
+        // =============================================================
+        // Since BulletSim is a plugin, this these values aren't defined easily in one place.
+        // This table must correspond to an identical table in BSScene.
+
+        // Per scene functions. See BSScene.
+
+        // Per avatar functions. See BSCharacter.
+
+        // Per prim functions. See BSPrim.
+        public const string PhysFunctGetLinksetType = "BulletSim.GetLinksetType";
+        public const string PhysFunctSetLinksetType = "BulletSim.SetLinksetType";
+        public const string PhysFunctChangeLinkFixed = "BulletSim.ChangeLinkFixed";
+        public const string PhysFunctChangeLinkType = "BulletSim.ChangeLinkType";
+        public const string PhysFunctGetLinkType = "BulletSim.GetLinkType";
+        public const string PhysFunctChangeLinkParams = "BulletSim.ChangeLinkParams";
+        public const string PhysFunctAxisLockLimits = "BulletSim.AxisLockLimits";
+
+        // =============================================================
+
+        private IConfig Configuration { get; set; }
+        private bool Enabled { get; set; }
+        private Scene BaseScene { get; set; }
+        private IScriptModuleComms Comms { get; set; }
+
+        #region INonSharedRegionModule
+
+        public string Name { get { return this.GetType().Name; } }
+
+        public void Initialise(IConfigSource config)
+        {
+            BaseScene = null;
+            Enabled = false;
+            Configuration = null;
+            Comms = null;
+
+            try
+            {
+                if ((Configuration = config.Configs["ExtendedPhysics"]) != null)
+                {
+                    Enabled = Configuration.GetBoolean("Enabled", Enabled);
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat("{0} Initialization error: {0}", LogHeader, e);
+            }
+
+            m_log.InfoFormat("{0} module {1} enabled", LogHeader, (Enabled ? "is" : "is not"));
+        }
+
+        public void Close()
+        {
+            if (BaseScene != null)
+            {
+                BaseScene.EventManager.OnObjectAddedToScene -= EventManager_OnObjectAddedToScene;
+                BaseScene.EventManager.OnSceneObjectPartUpdated -= EventManager_OnSceneObjectPartUpdated;
+                BaseScene = null;
+            }
+        }
+
+        public void AddRegion(Scene scene)
+        {
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (BaseScene != null && BaseScene == scene)
+            {
+                Close();
+            }
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!Enabled) return;
+
+            BaseScene = scene;
+
+            Comms = BaseScene.RequestModuleInterface<IScriptModuleComms>();
+            if (Comms == null)
+            {
+                m_log.WarnFormat("{0} ScriptModuleComms interface not defined", LogHeader);
+                Enabled = false;
+
+                return;
+            }
+ 
+            // Register as LSL functions all the [ScriptInvocation] marked methods.
+            Comms.RegisterScriptInvocations(this);
+            Comms.RegisterConstants(this);
+
+            // When an object is modified, we might need to update its extended physics parameters
+            BaseScene.EventManager.OnObjectAddedToScene += EventManager_OnObjectAddedToScene;
+            BaseScene.EventManager.OnSceneObjectPartUpdated += EventManager_OnSceneObjectPartUpdated;
+
+        }
+
+        public Type ReplaceableInterface { get { return null; } }
+
+        #endregion // INonSharedRegionModule
+
+        private void EventManager_OnObjectAddedToScene(SceneObjectGroup obj)
+        {
+        }
+
+        // Event generated when some property of a prim changes.
+        private void EventManager_OnSceneObjectPartUpdated(SceneObjectPart sop, bool isFullUpdate)
+        {
+        }
+
+        [ScriptConstant]
+        public const int PHYS_CENTER_OF_MASS =     1 << 0;
+
+        [ScriptInvocation]
+        public string physGetEngineType(UUID hostID, UUID scriptID)
+        {
+            string ret = string.Empty;
+
+            if (BaseScene.PhysicsScene != null)
+            {
+                ret = BaseScene.PhysicsScene.EngineType;
+            }
+
+            return ret;
+        }
+
+        // Code for specifying params.
+        // The choice if 14700 is arbitrary and only serves to catch parameter code misuse.
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_LINEAR     = 14700;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_LINEAR_X   = 14701;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_LINEAR_X  = 14702;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_LINEAR_Y   = 14703;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_LINEAR_Y  = 14704;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_LINEAR_Z   = 14705;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_LINEAR_Z  = 14706;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_ANGULAR    = 14707;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_ANGULAR_X  = 14708;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_ANGULAR_X = 14709;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_ANGULAR_Y  = 14710;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_ANGULAR_Y = 14711;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LOCK_ANGULAR_Z  = 14712;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LIMIT_ANGULAR_Z = 14713;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_LINEAR   = 14714;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_LINEAR_X = 14715;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_LINEAR_Y = 14716;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_LINEAR_Z = 14717;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_ANGULAR  = 14718;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_ANGULAR_X = 14719;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_ANGULAR_Y = 14720;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK_ANGULAR_Z = 14721;
+        [ScriptConstant]
+        public const int PHYS_AXIS_UNLOCK           = 14722;
+        // physAxisLockLimits()
+        [ScriptInvocation]
+        public int physAxisLock(UUID hostID, UUID scriptID, object[] parms)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            if (GetRootPhysActor(hostID, out rootPhysActor))
+            {
+                object[] parms2 = AddToBeginningOfArray(rootPhysActor, null, parms);
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctAxisLockLimits, parms2));
+            }
+
+            return ret;
+        }
+
+        [ScriptConstant]
+        public const int PHYS_LINKSET_TYPE_CONSTRAINT  = 0;
+        [ScriptConstant]
+        public const int PHYS_LINKSET_TYPE_COMPOUND    = 1;
+        [ScriptConstant]
+        public const int PHYS_LINKSET_TYPE_MANUAL      = 2;
+
+        [ScriptInvocation]
+        public int physSetLinksetType(UUID hostID, UUID scriptID, int linksetType)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            // The part that is requesting the change.
+            SceneObjectPart requestingPart = BaseScene.GetSceneObjectPart(hostID);
+
+            if (requestingPart != null)
+            {
+                // The change is always made to the root of a linkset.
+                SceneObjectGroup containingGroup = requestingPart.ParentGroup;
+                SceneObjectPart rootPart = containingGroup.RootPart;
+
+                if (rootPart != null)
+                {
+                    PhysicsActor rootPhysActor = rootPart.PhysActor;
+                    if (rootPhysActor != null)
+                    {
+                        if (rootPhysActor.IsPhysical)
+                        {
+                            // Change a physical linkset by making non-physical, waiting for one heartbeat so all
+                            //    the prim and linkset state is updated, changing the type and making the
+                            //    linkset physical again.
+                            containingGroup.ScriptSetPhysicsStatus(false);
+                            Thread.Sleep(150);  // longer than one heartbeat tick
+
+                            // A kludge for the moment.
+                            // Since compound linksets move the children but don't generate position updates to the
+                            //     simulator, it is possible for compound linkset children to have out-of-sync simulator
+                            //     and physical positions. The following causes the simulator to push the real child positions
+                            //     down into the physics engine to get everything synced.
+                            containingGroup.UpdateGroupPosition(containingGroup.AbsolutePosition);
+                            containingGroup.UpdateGroupRotationR(containingGroup.GroupRotation);
+
+                            object[] parms2 = { rootPhysActor, null, linksetType };
+                            ret = MakeIntError(rootPhysActor.Extension(PhysFunctSetLinksetType, parms2));
+                            Thread.Sleep(150);  // longer than one heartbeat tick
+
+                            containingGroup.ScriptSetPhysicsStatus(true);
+                        }
+                        else
+                        {
+                            // Non-physical linksets don't have a physical instantiation so there is no state to
+                            //    worry about being updated.
+                            object[] parms2 = { rootPhysActor, null, linksetType };
+                            ret = MakeIntError(rootPhysActor.Extension(PhysFunctSetLinksetType, parms2));
+                        }
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("{0} physSetLinksetType: root part does not have a physics actor. rootName={1}, hostID={2}",
+                                            LogHeader, rootPart.Name, hostID);
+                    }
+                }
+                else
+                {
+                    m_log.WarnFormat("{0} physSetLinksetType: root part does not exist. RequestingPartName={1}, hostID={2}",
+                                        LogHeader, requestingPart.Name, hostID);
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("{0} physSetLinsetType: cannot find script object in scene. hostID={1}", LogHeader, hostID);
+            }
+            return ret;
+        }
+
+        [ScriptInvocation]
+        public int physGetLinksetType(UUID hostID, UUID scriptID)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            if (GetRootPhysActor(hostID, out rootPhysActor))
+            {
+                object[] parms2 = { rootPhysActor, null };
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctGetLinksetType, parms2));
+            }
+            else
+            {
+                m_log.WarnFormat("{0} physGetLinsetType: cannot find script object in scene. hostID={1}", LogHeader, hostID);
+            }
+            return ret;
+        }
+
+        [ScriptConstant]
+        public const int PHYS_LINK_TYPE_FIXED  = 1234;
+        [ScriptConstant]
+        public const int PHYS_LINK_TYPE_HINGE  = 4;
+        [ScriptConstant]
+        public const int PHYS_LINK_TYPE_SPRING = 9;
+        [ScriptConstant]
+        public const int PHYS_LINK_TYPE_6DOF   = 6;
+        [ScriptConstant]
+        public const int PHYS_LINK_TYPE_SLIDER = 7;
+
+        // physChangeLinkType(integer linkNum, integer typeCode)
+        [ScriptInvocation]
+        public int physChangeLinkType(UUID hostID, UUID scriptID, int linkNum, int typeCode)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            PhysicsActor childPhysActor;
+
+            if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
+            {
+                object[] parms2 = { rootPhysActor, childPhysActor, typeCode };
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctChangeLinkType, parms2));
+            }
+
+            return ret;
+        }
+
+        // physGetLinkType(integer linkNum)
+        [ScriptInvocation]
+        public int physGetLinkType(UUID hostID, UUID scriptID, int linkNum)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            PhysicsActor childPhysActor;
+
+            if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
+            {
+                object[] parms2 = { rootPhysActor, childPhysActor };
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctGetLinkType, parms2));
+            }
+
+            return ret;
+        }
+
+        // physChangeLinkFixed(integer linkNum)
+        // Change the link between the root and the linkNum into a fixed, static physical connection.
+        [ScriptInvocation]
+        public int physChangeLinkFixed(UUID hostID, UUID scriptID, int linkNum)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            PhysicsActor childPhysActor;
+
+            if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
+            {
+                object[] parms2 = { rootPhysActor, childPhysActor , PHYS_LINK_TYPE_FIXED };
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctChangeLinkType, parms2));
+            }
+
+            return ret;
+        }
+
+        // Code for specifying params.
+        // The choice if 14400 is arbitrary and only serves to catch parameter code misuse.
+        public const int PHYS_PARAM_MIN                    = 14401;
+
+        [ScriptConstant]
+        public const int PHYS_PARAM_FRAMEINA_LOC           = 14401;
+        [ScriptConstant]
+        public const int PHYS_PARAM_FRAMEINA_ROT           = 14402;
+        [ScriptConstant]
+        public const int PHYS_PARAM_FRAMEINB_LOC           = 14403;
+        [ScriptConstant]
+        public const int PHYS_PARAM_FRAMEINB_ROT           = 14404;
+        [ScriptConstant]
+        public const int PHYS_PARAM_LINEAR_LIMIT_LOW       = 14405;
+        [ScriptConstant]
+        public const int PHYS_PARAM_LINEAR_LIMIT_HIGH      = 14406;
+        [ScriptConstant]
+        public const int PHYS_PARAM_ANGULAR_LIMIT_LOW      = 14407;
+        [ScriptConstant]
+        public const int PHYS_PARAM_ANGULAR_LIMIT_HIGH     = 14408;
+        [ScriptConstant]
+        public const int PHYS_PARAM_USE_FRAME_OFFSET       = 14409;
+        [ScriptConstant]
+        public const int PHYS_PARAM_ENABLE_TRANSMOTOR      = 14410;
+        [ScriptConstant]
+        public const int PHYS_PARAM_TRANSMOTOR_MAXVEL      = 14411;
+        [ScriptConstant]
+        public const int PHYS_PARAM_TRANSMOTOR_MAXFORCE    = 14412;
+        [ScriptConstant]
+        public const int PHYS_PARAM_CFM                    = 14413;
+        [ScriptConstant]
+        public const int PHYS_PARAM_ERP                    = 14414;
+        [ScriptConstant]
+        public const int PHYS_PARAM_SOLVER_ITERATIONS      = 14415;
+        [ScriptConstant]
+        public const int PHYS_PARAM_SPRING_AXIS_ENABLE     = 14416;
+        [ScriptConstant]
+        public const int PHYS_PARAM_SPRING_DAMPING         = 14417;
+        [ScriptConstant]
+        public const int PHYS_PARAM_SPRING_STIFFNESS       = 14418;
+        [ScriptConstant]
+        public const int PHYS_PARAM_LINK_TYPE              = 14419;
+        [ScriptConstant]
+        public const int PHYS_PARAM_USE_LINEAR_FRAMEA      = 14420;
+        [ScriptConstant]
+        public const int PHYS_PARAM_SPRING_EQUILIBRIUM_POINT = 14421;
+
+        public const int PHYS_PARAM_MAX                    = 14421;
+
+        // Used when specifying a parameter that has settings for the three linear and three angular axis
+        [ScriptConstant]
+        public const int PHYS_AXIS_ALL = -1;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LINEAR_ALL = -2;
+        [ScriptConstant]
+        public const int PHYS_AXIS_ANGULAR_ALL = -3;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LINEAR_X  = 0;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LINEAR_Y  = 1;
+        [ScriptConstant]
+        public const int PHYS_AXIS_LINEAR_Z  = 2;
+        [ScriptConstant]
+        public const int PHYS_AXIS_ANGULAR_X = 3;
+        [ScriptConstant]
+        public const int PHYS_AXIS_ANGULAR_Y = 4;
+        [ScriptConstant]
+        public const int PHYS_AXIS_ANGULAR_Z = 5;
+
+        // physChangeLinkParams(integer linkNum, [ PHYS_PARAM_*, value, PHYS_PARAM_*, value, ...])
+        [ScriptInvocation]
+        public int physChangeLinkParams(UUID hostID, UUID scriptID, int linkNum, object[] parms)
+        {
+            int ret = -1;
+            if (!Enabled) return ret;
+
+            PhysicsActor rootPhysActor;
+            PhysicsActor childPhysActor;
+
+            if (GetRootAndChildPhysActors(hostID, linkNum, out rootPhysActor, out childPhysActor))
+            {
+                object[] parms2 = AddToBeginningOfArray(rootPhysActor, childPhysActor, parms);
+                ret = MakeIntError(rootPhysActor.Extension(PhysFunctChangeLinkParams, parms2));
+            }
+
+            return ret;
+        }
+
+        private bool GetRootPhysActor(UUID hostID, out PhysicsActor rootPhysActor)
+        {
+            SceneObjectGroup containingGroup;
+            SceneObjectPart rootPart;
+            return GetRootPhysActor(hostID, out containingGroup, out rootPart, out rootPhysActor);
+        }
+
+        private bool GetRootPhysActor(UUID hostID, out SceneObjectGroup containingGroup, out SceneObjectPart rootPart, out PhysicsActor rootPhysActor)
+        {
+            bool ret = false;
+            rootPhysActor = null;
+            containingGroup = null;
+            rootPart = null;
+
+            SceneObjectPart requestingPart;
+
+            requestingPart = BaseScene.GetSceneObjectPart(hostID);
+            if (requestingPart != null)
+            {
+                // The type is is always on the root of a linkset.
+                containingGroup = requestingPart.ParentGroup;
+                if (containingGroup != null && !containingGroup.IsDeleted)
+                {
+                    rootPart = containingGroup.RootPart;
+                    if (rootPart != null)
+                    {
+                        rootPhysActor = rootPart.PhysActor;
+                        if (rootPhysActor != null)
+                        {
+                            ret = true;
+                        }
+                        else
+                        {
+                            m_log.WarnFormat("{0} GetRootAndChildPhysActors: Root part does not have a physics actor. rootName={1}, hostID={2}",
+                                            LogHeader, rootPart.Name, hostID);
+                        }
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("{0} GetRootAndChildPhysActors: Root part does not exist. RequestingPartName={1}, hostID={2}",
+                                        LogHeader, requestingPart.Name, hostID);
+                    }
+                }
+                else
+                {
+                    m_log.WarnFormat("{0} GetRootAndChildPhysActors: Containing group missing or deleted. hostID={1}", LogHeader, hostID);
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("{0} GetRootAndChildPhysActors: cannot find script object in scene. hostID={1}", LogHeader, hostID);
+            }
+
+            return ret;
+        }
+
+        // Find the root and child PhysActors based on the linkNum.
+        // Return 'true' if both are found and returned.
+        private bool GetRootAndChildPhysActors(UUID hostID, int linkNum, out PhysicsActor rootPhysActor, out PhysicsActor childPhysActor)
+        {
+            bool ret = false;
+            rootPhysActor = null;
+            childPhysActor = null;
+
+            SceneObjectGroup containingGroup;
+            SceneObjectPart rootPart;
+
+            if (GetRootPhysActor(hostID, out containingGroup, out rootPart, out rootPhysActor))
+            {
+                SceneObjectPart linkPart = containingGroup.GetLinkNumPart(linkNum);
+                if (linkPart != null)
+                {
+                    childPhysActor = linkPart.PhysActor;
+                    if (childPhysActor != null)
+                    {
+                        ret = true;
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("{0} GetRootAndChildPhysActors: Link part has no physical actor. rootName={1}, hostID={2}, linknum={3}",
+                                            LogHeader, rootPart.Name, hostID, linkNum);
+                    }
+                }
+                else
+                {
+                    m_log.WarnFormat("{0} GetRootAndChildPhysActors: Could not find linknum part. rootName={1}, hostID={2}, linknum={3}",
+                                        LogHeader, rootPart.Name, hostID, linkNum);
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("{0} GetRootAndChildPhysActors: Root part does not have a physics actor. rootName={1}, hostID={2}",
+                                LogHeader, rootPart.Name, hostID);
+            }
+
+            return ret;
+        }
+
+        // Return an array of objects with the passed object as the first object of a new array
+        private object[] AddToBeginningOfArray(object firstOne, object secondOne, object[] prevArray)
+        {
+            object[] newArray = new object[2 + prevArray.Length];
+            newArray[0] = firstOne;
+            newArray[1] = secondOne;
+            prevArray.CopyTo(newArray, 2);
+            return newArray;
+        }
+
+        // Extension() returns an object. Convert that object into the integer error we expect to return.
+        private int MakeIntError(object extensionRet)
+        {
+            int ret = -1;
+            if (extensionRet != null)
+            {
+                try
+                {
+                    ret = (int)extensionRet;
+                }
+                catch
+                {
+                    ret = -1;
+                }
+            }
+            return ret;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..5a33bdf
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Mono.Addins;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Region.Physics.BulletSPlugin")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("520ea11b-20cb-449d-ba05-c01015fed841")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.8.2.*")]
+
+[assembly: Addin("OpenSim.Region.PhysicsModule.BulletS", OpenSim.VersionInfo.VersionNumber)]
+[assembly: AddinDependency("OpenSim.Region.Framework", OpenSim.VersionInfo.VersionNumber)]
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/BasicVehicles.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/BasicVehicles.cs
new file mode 100755
index 0000000..35eba29
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/BasicVehicles.cs
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using NUnit.Framework;
+using log4net;
+
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModule.BulletS;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Tests.Common;
+
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS.Tests
+{
+[TestFixture]
+public class BasicVehicles : OpenSimTestCase
+{
+    // Documentation on attributes: http://www.nunit.org/index.php?p=attributes&r=2.6.1
+    // Documentation on assertions: http://www.nunit.org/index.php?p=assertions&r=2.6.1
+
+    BSScene PhysicsScene { get; set; }
+    BSPrim TestVehicle { get; set; }
+    Vector3 TestVehicleInitPosition { get; set; }
+    float simulationTimeStep = 0.089f;
+
+    [TestFixtureSetUp]
+    public void Init()
+    {
+        Dictionary<string, string> engineParams = new Dictionary<string, string>();
+        engineParams.Add("VehicleEnableAngularVerticalAttraction", "true");
+        engineParams.Add("VehicleAngularVerticalAttractionAlgorithm", "1");
+        PhysicsScene = BulletSimTestsUtil.CreateBasicPhysicsEngine(engineParams);
+
+        PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateSphere();
+        Vector3 pos = new Vector3(100.0f, 100.0f, 0f);
+        pos.Z = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos) + 2f;
+        TestVehicleInitPosition = pos;
+        Vector3 size = new Vector3(1f, 1f, 1f);
+        pbs.Scale = size;
+        Quaternion rot = Quaternion.Identity;
+        bool isPhys = false;
+        uint localID = 123;
+
+        PhysicsScene.AddPrimShape("testPrim", pbs, pos, size, rot, isPhys, localID);
+        TestVehicle = (BSPrim)PhysicsScene.PhysObjects[localID];
+        // The actual prim shape creation happens at taint time
+        PhysicsScene.ProcessTaints();
+
+    }
+
+    [TestFixtureTearDown]
+    public void TearDown()
+    {
+        if (PhysicsScene != null)
+        {
+            // The Dispose() will also free any physical objects in the scene
+            PhysicsScene.Dispose();
+            PhysicsScene = null;
+        }
+    }
+
+    [TestCase(2f, 0.2f,  0.25f,  0.25f,  0.25f)]
+    [TestCase(2f, 0.2f, -0.25f,  0.25f,  0.25f)]
+    [TestCase(2f, 0.2f,  0.25f, -0.25f,  0.25f)]
+    [TestCase(2f, 0.2f, -0.25f, -0.25f,  0.25f)]
+    // [TestCase(2f, 0.2f, 0.785f,   0.0f,  0.25f) /*, "Leaning 45 degrees to the side" */]
+    // [TestCase(2f, 0.2f, 1.650f,   0.0f,  0.25f) /*, "Leaning more than 90 degrees to the side" */]
+    // [TestCase(2f, 0.2f, 2.750f,   0.0f,  0.25f) /*, "Almost upside down, tipped right" */]
+    // [TestCase(2f, 0.2f,-2.750f,   0.0f,  0.25f) /*, "Almost upside down, tipped left" */]
+    // [TestCase(2f, 0.2f,   0.0f, 0.785f,  0.25f) /*, "Tipped back 45 degrees" */]
+    // [TestCase(2f, 0.2f,   0.0f, 1.650f,  0.25f) /*, "Tipped back more than 90 degrees" */]
+    // [TestCase(2f, 0.2f,   0.0f, 2.750f,  0.25f) /*, "Almost upside down, tipped back" */]
+    // [TestCase(2f, 0.2f,   0.0f,-2.750f,  0.25f) /*, "Almost upside down, tipped forward" */]
+    public void AngularVerticalAttraction(float timeScale, float efficiency, float initRoll, float initPitch, float initYaw)
+    {
+        // Enough simulation steps to cover the timescale the operation should take
+        int simSteps = (int)(timeScale / simulationTimeStep) + 1;
+
+        // Tip the vehicle
+        Quaternion initOrientation = Quaternion.CreateFromEulers(initRoll, initPitch, initYaw);
+        TestVehicle.Orientation = initOrientation;
+
+        TestVehicle.Position = TestVehicleInitPosition;
+
+        // The vehicle controller is not enabled directly (by setting a vehicle type).
+        //    Instead the appropriate values are set and calls are made just the parts of the
+        //    controller we want to exercise. Stepping the physics engine then applies
+        //    the actions of that one feature.
+        BSDynamics vehicleActor = TestVehicle.GetVehicleActor(true /* createIfNone */);
+        if (vehicleActor != null)
+        {
+            vehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, efficiency);
+            vehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, timeScale);
+            // vehicleActor.enableAngularVerticalAttraction = true;
+
+            TestVehicle.IsPhysical = true;
+            PhysicsScene.ProcessTaints();
+
+            // Step the simulator a bunch of times and vertical attraction should orient the vehicle up
+            for (int ii = 0; ii < simSteps; ii++)
+            {
+                vehicleActor.ForgetKnownVehicleProperties();
+                vehicleActor.ComputeAngularVerticalAttraction();
+                vehicleActor.PushKnownChanged();
+
+                PhysicsScene.Simulate(simulationTimeStep);
+            }
+        }
+
+        TestVehicle.IsPhysical = false;
+        PhysicsScene.ProcessTaints();
+
+        // After these steps, the vehicle should be upright
+        /*
+        float finalRoll, finalPitch, finalYaw;
+        TestVehicle.Orientation.GetEulerAngles(out finalRoll, out finalPitch, out finalYaw);
+        Assert.That(finalRoll, Is.InRange(-0.01f, 0.01f));
+        Assert.That(finalPitch, Is.InRange(-0.01f, 0.01f));
+        Assert.That(finalYaw, Is.InRange(initYaw - 0.1f, initYaw + 0.1f));
+         */
+
+        Vector3 upPointer = Vector3.UnitZ * TestVehicle.Orientation;
+        Assert.That(upPointer.Z, Is.GreaterThan(0.99f));
+    }
+}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTests.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTests.cs
new file mode 100755
index 0000000..0be1f4c
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTests.cs
@@ -0,0 +1,56 @@
+/*

+ * Copyright (c) Contributors, http://opensimulator.org/

+ * See CONTRIBUTORS.TXT for a full list of copyright holders.

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions are met:

+ *     * Redistributions of source code must retain the above copyright

+ *       notice, this list of conditions and the following disclaimer.

+ *     * Redistributions in binary form must reproduce the above copyright

+ *       notice, this list of conditions and the following disclaimer in the

+ *       documentation and/or other materials provided with the distribution.

+ *     * Neither the name of the OpenSimulator Project nor the

+ *       names of its contributors may be used to endorse or promote products

+ *       derived from this software without specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY

+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY

+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+

+using System;

+using System.Collections.Generic;

+using System.Linq;

+using System.Text;

+

+using NUnit.Framework;

+using log4net;

+

+using OpenSim.Tests.Common;

+

+namespace OpenSim.Region.PhysicsModule.BulletS.Tests

+{

+[TestFixture]

+public class BulletSimTests : OpenSimTestCase

+{

+    // Documentation on attributes: http://www.nunit.org/index.php?p=attributes&r=2.6.1

+    // Documentation on assertions: http://www.nunit.org/index.php?p=assertions&r=2.6.1

+

+    [TestFixtureSetUp]

+    public void Init()

+    {

+    }

+

+    [TestFixtureTearDown]

+    public void TearDown()

+    {

+    }

+}

+}

diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs
new file mode 100755
index 0000000..4eeea4d
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Text;
+
+using Nini.Config;
+
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Region.PhysicsModules.Meshing;
+using OpenSim.Region.Framework.Interfaces;
+
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS.Tests
+{
+// Utility functions for building up and tearing down the sample physics environments
+public static class BulletSimTestsUtil
+{
+    // 'engineName' is the Bullet engine to use. Either null (for unmanaged), "BulletUnmanaged" or "BulletXNA"
+    // 'params' is a set of keyValue pairs to set in the engine's configuration file (override defaults)
+    //      May be 'null' if there are no overrides.
+    public static BSScene CreateBasicPhysicsEngine(Dictionary<string,string> paramOverrides)
+    {
+        IConfigSource openSimINI = new IniConfigSource();
+        IConfig startupConfig = openSimINI.AddConfig("Startup");
+        startupConfig.Set("physics", "BulletSim");
+        startupConfig.Set("meshing", "Meshmerizer");
+        startupConfig.Set("cacheSculptMaps", "false");  // meshmerizer shouldn't save maps
+
+        IConfig bulletSimConfig = openSimINI.AddConfig("BulletSim");
+        // If the caller cares, specify the bullet engine otherwise it will default to "BulletUnmanaged".
+        // bulletSimConfig.Set("BulletEngine", "BulletUnmanaged");
+        // bulletSimConfig.Set("BulletEngine", "BulletXNA");
+        bulletSimConfig.Set("MeshSculptedPrim", "false");
+        bulletSimConfig.Set("ForceSimplePrimMeshing", "true");
+        if (paramOverrides != null)
+        {
+            foreach (KeyValuePair<string, string> kvp in paramOverrides)
+            {
+                bulletSimConfig.Set(kvp.Key, kvp.Value);
+            }
+        }
+
+        // If a special directory exists, put detailed logging therein.
+        // This allows local testing/debugging without having to worry that the build engine will output logs.
+        if (Directory.Exists("physlogs"))
+        {
+            bulletSimConfig.Set("PhysicsLoggingDir","./physlogs");
+            bulletSimConfig.Set("PhysicsLoggingEnabled","True");
+            bulletSimConfig.Set("PhysicsLoggingDoFlush","True");
+            bulletSimConfig.Set("VehicleLoggingEnabled","True");
+        }
+
+        Vector3 regionExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
+       
+        RegionInfo info = new RegionInfo();
+        info.RegionName = "BSTestRegion";
+        info.RegionSizeX = info.RegionSizeY = info.RegionSizeZ = Constants.RegionSize;
+        OpenSim.Region.Framework.Scenes.Scene scene = new OpenSim.Region.Framework.Scenes.Scene(info);
+
+        IMesher mesher = new OpenSim.Region.PhysicsModules.Meshing.Meshmerizer();
+        INonSharedRegionModule mod = mesher as INonSharedRegionModule;
+        mod.Initialise(openSimINI);
+        mod.AddRegion(scene);
+        mod.RegionLoaded(scene);
+
+        BSScene pScene = new BSScene();
+        mod = (pScene as INonSharedRegionModule);
+        mod.Initialise(openSimINI);
+        mod.AddRegion(scene);
+        mod.RegionLoaded(scene);
+
+        // Since the asset requestor is not initialized, any mesh or sculptie will be a cube.
+        // In the future, add a fake asset fetcher to get meshes and sculpts.
+        // bsScene.RequestAssetMethod = ???;
+
+        return pScene;
+    }
+
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs
new file mode 100644
index 0000000..c0cf19a
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using NUnit.Framework;
+using log4net;
+
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModule.BulletS;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Tests.Common;
+
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS.Tests
+{
+[TestFixture]
+public class HullCreation : OpenSimTestCase
+{
+    // Documentation on attributes: http://www.nunit.org/index.php?p=attributes&r=2.6.1
+    // Documentation on assertions: http://www.nunit.org/index.php?p=assertions&r=2.6.1
+
+    BSScene PhysicsScene { get; set; }
+    Vector3 ObjectInitPosition;
+
+    [TestFixtureSetUp]
+    public void Init()
+    {
+
+    }
+
+    [TestFixtureTearDown]
+    public void TearDown()
+    {
+        if (PhysicsScene != null)
+        {
+            // The Dispose() will also free any physical objects in the scene
+            PhysicsScene.Dispose();
+            PhysicsScene = null;
+        }
+    }
+
+    [TestCase(7, 2, 5f, 5f, 32, 0f)]    /* default hull parameters */
+    public void GeomHullConvexDecomp( int maxDepthSplit,
+                                        int maxDepthSplitForSimpleShapes,
+                                        float concavityThresholdPercent,
+                                        float volumeConservationThresholdPercent,
+                                        int maxVertices,
+                                        float maxSkinWidth)
+    {
+        // Setup the physics engine to use the C# version of convex decomp
+        Dictionary<string, string> engineParams = new Dictionary<string, string>();
+        engineParams.Add("MeshSculptedPrim", "true"); // ShouldMeshSculptedPrim
+        engineParams.Add("ForceSimplePrimMeshing", "false"); // ShouldForceSimplePrimMeshing
+        engineParams.Add("UseHullsForPhysicalObjects", "true"); // ShouldUseHullsForPhysicalObjects
+        engineParams.Add("ShouldRemoveZeroWidthTriangles", "true");
+        engineParams.Add("ShouldUseBulletHACD", "false");
+        engineParams.Add("ShouldUseSingleConvexHullForPrims", "true");
+        engineParams.Add("ShouldUseGImpactShapeForPrims", "false");
+        engineParams.Add("ShouldUseAssetHulls", "true");
+
+        engineParams.Add("CSHullMaxDepthSplit", maxDepthSplit.ToString());
+        engineParams.Add("CSHullMaxDepthSplitForSimpleShapes", maxDepthSplitForSimpleShapes.ToString());
+        engineParams.Add("CSHullConcavityThresholdPercent", concavityThresholdPercent.ToString());
+        engineParams.Add("CSHullVolumeConservationThresholdPercent", volumeConservationThresholdPercent.ToString());
+        engineParams.Add("CSHullMaxVertices", maxVertices.ToString());
+        engineParams.Add("CSHullMaxSkinWidth", maxSkinWidth.ToString());
+
+        PhysicsScene = BulletSimTestsUtil.CreateBasicPhysicsEngine(engineParams);
+
+        PrimitiveBaseShape pbs;
+        Vector3 pos;
+        Vector3 size;
+        Quaternion rot;
+        bool isPhys;
+
+        // Cylinder
+        pbs = PrimitiveBaseShape.CreateCylinder();
+        pos = new Vector3(100.0f, 100.0f, 0f);
+        pos.Z = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos) + 10f;
+        ObjectInitPosition = pos;
+        size = new Vector3(2f, 2f, 2f);
+        pbs.Scale = size;
+        rot = Quaternion.Identity;
+        isPhys = true;
+        uint cylinderLocalID = 123;
+        PhysicsScene.AddPrimShape("testCylinder", pbs, pos, size, rot, isPhys, cylinderLocalID);
+        BSPrim primTypeCylinder = (BSPrim)PhysicsScene.PhysObjects[cylinderLocalID];
+
+        // Hollow Cylinder
+        pbs = PrimitiveBaseShape.CreateCylinder();
+        pbs.ProfileHollow = (ushort)(0.70f * 50000);
+        pos = new Vector3(110.0f, 110.0f, 0f);
+        pos.Z = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos) + 10f;
+        ObjectInitPosition = pos;
+        size = new Vector3(2f, 2f, 2f);
+        pbs.Scale = size;
+        rot = Quaternion.Identity;
+        isPhys = true;
+        uint hollowCylinderLocalID = 124;
+        PhysicsScene.AddPrimShape("testHollowCylinder", pbs, pos, size, rot, isPhys, hollowCylinderLocalID);
+        BSPrim primTypeHollowCylinder = (BSPrim)PhysicsScene.PhysObjects[hollowCylinderLocalID];
+
+        // Torus
+        // ProfileCurve = Circle, PathCurve = Curve1
+        pbs = PrimitiveBaseShape.CreateSphere();
+        pbs.ProfileShape = (byte)ProfileShape.Circle;
+        pbs.PathCurve = (byte)Extrusion.Curve1;
+        pbs.PathScaleX = 100;   // default hollow info as set in the viewer
+        pbs.PathScaleY = (int)(.25f / 0.01f) + 200;
+        pos = new Vector3(120.0f, 120.0f, 0f);
+        pos.Z = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos) + 10f;
+        ObjectInitPosition = pos;
+        size = new Vector3(2f, 4f, 4f);
+        pbs.Scale = size;
+        rot = Quaternion.Identity;
+        isPhys = true;
+        uint torusLocalID = 125;
+        PhysicsScene.AddPrimShape("testTorus", pbs, pos, size, rot, isPhys, torusLocalID);
+        BSPrim primTypeTorus = (BSPrim)PhysicsScene.PhysObjects[torusLocalID];
+        
+        // The actual prim shape creation happens at taint time
+        PhysicsScene.ProcessTaints();
+
+        // Check out the created hull shapes and report their characteristics
+        ReportShapeGeom(primTypeCylinder);
+        ReportShapeGeom(primTypeHollowCylinder);
+        ReportShapeGeom(primTypeTorus);
+    }
+
+    [TestCase]
+    public void GeomHullBulletHACD()
+    {
+        // Cylinder
+        // Hollow Cylinder
+        // Torus
+    }
+
+    private void ReportShapeGeom(BSPrim prim)
+    {
+        if (prim != null)
+        {
+            if (prim.PhysShape.HasPhysicalShape)
+            {
+                BSShape physShape = prim.PhysShape;
+                string shapeType = physShape.GetType().ToString();
+                switch (shapeType)
+                {
+                    case "OpenSim.Region.Physics.BulletSPlugin.BSShapeNative":
+                        BSShapeNative nShape = physShape as BSShapeNative;
+                        prim.PhysScene.DetailLog("{0}, type={1}", prim.Name, shapeType);
+                        break;
+                    case "OpenSim.Region.Physics.BulletSPlugin.BSShapeMesh":
+                        BSShapeMesh mShape = physShape as BSShapeMesh;
+                        prim.PhysScene.DetailLog("{0}, mesh, shapeInfo={1}", prim.Name, mShape.shapeInfo);
+                        break;
+                    case "OpenSim.Region.Physics.BulletSPlugin.BSShapeHull":
+                        // BSShapeHull hShape = physShape as BSShapeHull;
+                        // prim.PhysScene.DetailLog("{0}, hull, shapeInfo={1}", prim.Name, hShape.shapeInfo);
+                        break;
+                    case "OpenSim.Region.Physics.BulletSPlugin.BSShapeConvexHull":
+                        BSShapeConvexHull chShape = physShape as BSShapeConvexHull;
+                        prim.PhysScene.DetailLog("{0}, convexHull, shapeInfo={1}", prim.Name, chShape.shapeInfo);
+                        break;
+                    case "OpenSim.Region.Physics.BulletSPlugin.BSShapeCompound":
+                        BSShapeCompound cShape = physShape as BSShapeCompound;
+                        prim.PhysScene.DetailLog("{0}, type={1}", prim.Name, shapeType);
+                        break;
+                    default:
+                        prim.PhysScene.DetailLog("{0}, type={1}", prim.Name, shapeType);
+                        break;
+                }
+            }
+        }
+    }
+}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/CTri.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/CTri.cs
new file mode 100644
index 0000000..7ad689e
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/CTri.cs
@@ -0,0 +1,341 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class Wpoint
+    {
+        public float3 mPoint;
+        public float mWeight;
+
+        public Wpoint(float3 p, float w)
+        {
+            mPoint = p;
+            mWeight = w;
+        }
+    }
+
+    public class CTri
+    {
+        private const int WSCALE = 4;
+
+        public float3 mP1;
+        public float3 mP2;
+        public float3 mP3;
+        public float3 mNear1;
+        public float3 mNear2;
+        public float3 mNear3;
+        public float3 mNormal;
+        public float mPlaneD;
+        public float mConcavity;
+        public float mC1;
+        public float mC2;
+        public float mC3;
+        public int mI1;
+        public int mI2;
+        public int mI3;
+        public int mProcessed; // already been added...
+
+        public CTri(float3 p1, float3 p2, float3 p3, int i1, int i2, int i3)
+        {
+            mProcessed = 0;
+            mI1 = i1;
+            mI2 = i2;
+            mI3 = i3;
+
+            mP1 = new float3(p1);
+            mP2 = new float3(p2);
+            mP3 = new float3(p3);
+
+            mNear1 = new float3();
+            mNear2 = new float3();
+            mNear3 = new float3();
+
+            mNormal = new float3();
+            mPlaneD = mNormal.ComputePlane(mP1, mP2, mP3);
+        }
+
+        public float Facing(CTri t)
+        {
+            return float3.dot(mNormal, t.mNormal);
+        }
+
+        public bool clip(float3 start, ref float3 end)
+        {
+            float3 sect = new float3();
+            bool hit = lineIntersectsTriangle(start, end, mP1, mP2, mP3, ref sect);
+
+            if (hit)
+                end = sect;
+            return hit;
+        }
+
+        public bool Concave(float3 p, ref float distance, ref float3 n)
+        {
+            n.NearestPointInTriangle(p, mP1, mP2, mP3);
+            distance = p.Distance(n);
+            return true;
+        }
+
+        public void addTri(int[] indices, int i1, int i2, int i3, ref int tcount)
+        {
+            indices[tcount * 3 + 0] = i1;
+            indices[tcount * 3 + 1] = i2;
+            indices[tcount * 3 + 2] = i3;
+            tcount++;
+        }
+
+        public float getVolume()
+        {
+            int[] indices = new int[8 * 3];
+
+            int tcount = 0;
+
+            addTri(indices, 0, 1, 2, ref tcount);
+            addTri(indices, 3, 4, 5, ref tcount);
+
+            addTri(indices, 0, 3, 4, ref tcount);
+            addTri(indices, 0, 4, 1, ref tcount);
+
+            addTri(indices, 1, 4, 5, ref tcount);
+            addTri(indices, 1, 5, 2, ref tcount);
+
+            addTri(indices, 0, 3, 5, ref tcount);
+            addTri(indices, 0, 5, 2, ref tcount);
+
+            List<float3> vertices = new List<float3> { mP1, mP2, mP3, mNear1, mNear2, mNear3 };
+            List<int> indexList = new List<int>(indices);
+
+            float v = Concavity.computeMeshVolume(vertices, indexList);
+            return v;
+        }
+
+        public float raySect(float3 p, float3 dir, ref float3 sect)
+        {
+            float4 plane = new float4();
+
+            plane.x = mNormal.x;
+            plane.y = mNormal.y;
+            plane.z = mNormal.z;
+            plane.w = mPlaneD;
+
+            float3 dest = p + dir * 100000f;
+
+            intersect(p, dest, ref sect, plane);
+
+            return sect.Distance(p); // return the intersection distance
+        }
+
+        public float planeDistance(float3 p)
+        {
+            float4 plane = new float4();
+
+            plane.x = mNormal.x;
+            plane.y = mNormal.y;
+            plane.z = mNormal.z;
+            plane.w = mPlaneD;
+
+            return DistToPt(p, plane);
+        }
+
+        public bool samePlane(CTri t)
+        {
+            const float THRESH = 0.001f;
+            float dd = Math.Abs(t.mPlaneD - mPlaneD);
+            if (dd > THRESH)
+                return false;
+            dd = Math.Abs(t.mNormal.x - mNormal.x);
+            if (dd > THRESH)
+                return false;
+            dd = Math.Abs(t.mNormal.y - mNormal.y);
+            if (dd > THRESH)
+                return false;
+            dd = Math.Abs(t.mNormal.z - mNormal.z);
+            if (dd > THRESH)
+                return false;
+            return true;
+        }
+
+        public bool hasIndex(int i)
+        {
+            if (i == mI1 || i == mI2 || i == mI3)
+                return true;
+            return false;
+        }
+
+        public bool sharesEdge(CTri t)
+        {
+            bool ret = false;
+            uint count = 0;
+
+            if (t.hasIndex(mI1))
+                count++;
+            if (t.hasIndex(mI2))
+                count++;
+            if (t.hasIndex(mI3))
+                count++;
+
+            if (count >= 2)
+                ret = true;
+
+            return ret;
+        }
+
+        public float area()
+        {
+            float a = mConcavity * mP1.Area(mP2, mP3);
+            return a;
+        }
+
+        public void addWeighted(List<Wpoint> list)
+        {
+            Wpoint p1 = new Wpoint(mP1, mC1);
+            Wpoint p2 = new Wpoint(mP2, mC2);
+            Wpoint p3 = new Wpoint(mP3, mC3);
+
+            float3 d1 = mNear1 - mP1;
+            float3 d2 = mNear2 - mP2;
+            float3 d3 = mNear3 - mP3;
+
+            d1 *= WSCALE;
+            d2 *= WSCALE;
+            d3 *= WSCALE;
+
+            d1 = d1 + mP1;
+            d2 = d2 + mP2;
+            d3 = d3 + mP3;
+
+            Wpoint p4 = new Wpoint(d1, mC1);
+            Wpoint p5 = new Wpoint(d2, mC2);
+            Wpoint p6 = new Wpoint(d3, mC3);
+
+            list.Add(p1);
+            list.Add(p2);
+            list.Add(p3);
+
+            list.Add(p4);
+            list.Add(p5);
+            list.Add(p6);
+        }
+
+        private static float DistToPt(float3 p, float4 plane)
+            {
+                    float x = p.x;
+                    float y = p.y;
+                    float z = p.z;
+                    float d = x*plane.x + y*plane.y + z*plane.z + plane.w;
+                    return d;
+            }
+
+        private static void intersect(float3 p1, float3 p2, ref float3 split, float4 plane)
+        {
+            float dp1 = DistToPt(p1, plane);
+
+            float3 dir = new float3();
+            dir.x = p2[0] - p1[0];
+            dir.y = p2[1] - p1[1];
+            dir.z = p2[2] - p1[2];
+
+            float dot1 = dir[0] * plane[0] + dir[1] * plane[1] + dir[2] * plane[2];
+            float dot2 = dp1 - plane[3];
+
+            float t = -(plane[3] + dot2) / dot1;
+
+            split.x = (dir[0] * t) + p1[0];
+            split.y = (dir[1] * t) + p1[1];
+            split.z = (dir[2] * t) + p1[2];
+        }
+
+        private static bool rayIntersectsTriangle(float3 p, float3 d, float3 v0, float3 v1, float3 v2, out float t)
+        {
+            t = 0f;
+
+            float3 e1, e2, h, s, q;
+            float a, f, u, v;
+
+            e1 = v1 - v0;
+            e2 = v2 - v0;
+            h = float3.cross(d, e2);
+            a = float3.dot(e1, h);
+
+            if (a > -0.00001f && a < 0.00001f)
+                return false;
+
+            f = 1f / a;
+            s = p - v0;
+            u = f * float3.dot(s, h);
+
+            if (u < 0.0f || u > 1.0f)
+                return false;
+
+            q = float3.cross(s, e1);
+            v = f * float3.dot(d, q);
+            if (v < 0.0f || u + v > 1.0f)
+                return false;
+
+            // at this stage we can compute t to find out where
+            // the intersection point is on the line
+            t = f * float3.dot(e2, q);
+            if (t > 0f) // ray intersection
+                return true;
+            else // this means that there is a line intersection but not a ray intersection
+                return false;
+        }
+
+        private static bool lineIntersectsTriangle(float3 rayStart, float3 rayEnd, float3 p1, float3 p2, float3 p3, ref float3 sect)
+        {
+            float3 dir = rayEnd - rayStart;
+
+            float d = (float)Math.Sqrt(dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2]);
+            float r = 1.0f / d;
+
+            dir *= r;
+
+            float t;
+            bool ret = rayIntersectsTriangle(rayStart, dir, p1, p2, p3, out t);
+
+            if (ret)
+            {
+                if (t > d)
+                {
+                    sect.x = rayStart.x + dir.x * t;
+                    sect.y = rayStart.y + dir.y * t;
+                    sect.z = rayStart.z + dir.z * t;
+                }
+                else
+                {
+                    ret = false;
+                }
+            }
+
+            return ret;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Concavity.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Concavity.cs
new file mode 100644
index 0000000..4140d25
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Concavity.cs
@@ -0,0 +1,233 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public static class Concavity
+    {
+        // compute's how 'concave' this object is and returns the total volume of the
+        // convex hull as well as the volume of the 'concavity' which was found.
+        public static float computeConcavity(List<float3> vertices, List<int> indices, ref float4 plane, ref float volume)
+        {
+            float cret = 0f;
+            volume = 1f;
+
+            HullResult result = new HullResult();
+            HullDesc desc = new HullDesc();
+
+            desc.MaxFaces = 256;
+            desc.MaxVertices = 256;
+            desc.SetHullFlag(HullFlag.QF_TRIANGLES);
+            desc.Vertices = vertices;
+
+            HullError ret = HullUtils.CreateConvexHull(desc, ref result);
+
+            if (ret == HullError.QE_OK)
+            {
+                volume = computeMeshVolume2(result.OutputVertices, result.Indices);
+
+                // ok..now..for each triangle on the original mesh..
+                // we extrude the points to the nearest point on the hull.
+                List<CTri> tris = new List<CTri>();
+
+                for (int i = 0; i < result.Indices.Count / 3; i++)
+                {
+                    int i1 = result.Indices[i * 3 + 0];
+                    int i2 = result.Indices[i * 3 + 1];
+                    int i3 = result.Indices[i * 3 + 2];
+
+                    float3 p1 = result.OutputVertices[i1];
+                    float3 p2 = result.OutputVertices[i2];
+                    float3 p3 = result.OutputVertices[i3];
+
+                    CTri t = new CTri(p1, p2, p3, i1, i2, i3);
+                    tris.Add(t);
+                }
+
+                // we have not pre-computed the plane equation for each triangle in the convex hull..
+                float totalVolume = 0;
+
+                List<CTri> ftris = new List<CTri>(); // 'feature' triangles.
+                List<CTri> input_mesh = new List<CTri>();
+
+                for (int i = 0; i < indices.Count / 3; i++)
+                {
+                    int i1 = indices[i * 3 + 0];
+                    int i2 = indices[i * 3 + 1];
+                    int i3 = indices[i * 3 + 2];
+
+                    float3 p1 = vertices[i1];
+                    float3 p2 = vertices[i2];
+                    float3 p3 = vertices[i3];
+
+                    CTri t = new CTri(p1, p2, p3, i1, i2, i3);
+                    input_mesh.Add(t);
+                }
+
+                for (int i = 0; i < indices.Count / 3; i++)
+                {
+                    int i1 = indices[i * 3 + 0];
+                    int i2 = indices[i * 3 + 1];
+                    int i3 = indices[i * 3 + 2];
+
+                    float3 p1 = vertices[i1];
+                    float3 p2 = vertices[i2];
+                    float3 p3 = vertices[i3];
+
+                    CTri t = new CTri(p1, p2, p3, i1, i2, i3);
+
+                    featureMatch(t, tris, input_mesh);
+
+                    if (t.mConcavity > 0.05f)
+                    {
+                        float v = t.getVolume();
+                        totalVolume += v;
+                        ftris.Add(t);
+                    }
+                }
+
+                SplitPlane.computeSplitPlane(vertices, indices, ref plane);
+                cret = totalVolume;
+            }
+
+            return cret;
+        }
+
+        public static bool featureMatch(CTri m, List<CTri> tris, List<CTri> input_mesh)
+        {
+            bool ret = false;
+            float neardot = 0.707f;
+            m.mConcavity = 0;
+
+            for (int i = 0; i < tris.Count; i++)
+            {
+                CTri t = tris[i];
+
+                if (t.samePlane(m))
+                {
+                    ret = false;
+                    break;
+                }
+
+                float dot = float3.dot(t.mNormal, m.mNormal);
+
+                if (dot > neardot)
+                {
+                    float d1 = t.planeDistance(m.mP1);
+                    float d2 = t.planeDistance(m.mP2);
+                    float d3 = t.planeDistance(m.mP3);
+
+                    if (d1 > 0.001f || d2 > 0.001f || d3 > 0.001f) // can't be near coplaner!
+                    {
+                        neardot = dot;
+
+                        t.raySect(m.mP1, m.mNormal, ref m.mNear1);
+                        t.raySect(m.mP2, m.mNormal, ref m.mNear2);
+                        t.raySect(m.mP3, m.mNormal, ref m.mNear3);
+
+                        ret = true;
+                    }
+                }
+            }
+
+            if (ret)
+            {
+                m.mC1 = m.mP1.Distance(m.mNear1);
+                m.mC2 = m.mP2.Distance(m.mNear2);
+                m.mC3 = m.mP3.Distance(m.mNear3);
+
+                m.mConcavity = m.mC1;
+
+                if (m.mC2 > m.mConcavity)
+                    m.mConcavity = m.mC2;
+                if (m.mC3 > m.mConcavity)
+                    m.mConcavity = m.mC3;
+            }
+
+            return ret;
+        }
+
+        private static float det(float3 p1, float3 p2, float3 p3)
+        {
+            return p1.x * p2.y * p3.z + p2.x * p3.y * p1.z + p3.x * p1.y * p2.z - p1.x * p3.y * p2.z - p2.x * p1.y * p3.z - p3.x * p2.y * p1.z;
+        }
+
+        public static float computeMeshVolume(List<float3> vertices, List<int> indices)
+        {
+            float volume = 0f;
+
+            for (int i = 0; i < indices.Count / 3; i++)
+            {
+                float3 p1 = vertices[indices[i * 3 + 0]];
+                float3 p2 = vertices[indices[i * 3 + 1]];
+                float3 p3 = vertices[indices[i * 3 + 2]];
+
+                volume += det(p1, p2, p3); // compute the volume of the tetrahedran relative to the origin.
+            }
+
+            volume *= (1.0f / 6.0f);
+            if (volume < 0f)
+                return -volume;
+            return volume;
+        }
+
+        public static float computeMeshVolume2(List<float3> vertices, List<int> indices)
+        {
+            float volume = 0f;
+
+            float3 p0 = vertices[0];
+            for (int i = 0; i < indices.Count / 3; i++)
+            {
+                float3 p1 = vertices[indices[i * 3 + 0]];
+                float3 p2 = vertices[indices[i * 3 + 1]];
+                float3 p3 = vertices[indices[i * 3 + 2]];
+
+                volume += tetVolume(p0, p1, p2, p3); // compute the volume of the tetrahedron relative to the root vertice
+            }
+
+            return volume * (1.0f / 6.0f);
+        }
+
+        private static float tetVolume(float3 p0, float3 p1, float3 p2, float3 p3)
+        {
+            float3 a = p1 - p0;
+            float3 b = p2 - p0;
+            float3 c = p3 - p0;
+
+            float3 cross = float3.cross(b, c);
+            float volume = float3.dot(a, cross);
+
+            if (volume < 0f)
+                return -volume;
+            return volume;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexBuilder.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexBuilder.cs
new file mode 100644
index 0000000..70c3a2b
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexBuilder.cs
@@ -0,0 +1,411 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class DecompDesc
+    {
+        public List<float3> mVertices;
+        public List<int> mIndices;
+
+        // options
+        public uint mDepth; // depth to split, a maximum of 10, generally not over 7.
+        public float mCpercent; // the concavity threshold percentage. 0=20 is reasonable.
+        public float mPpercent; // the percentage volume conservation threshold to collapse hulls. 0-30 is reasonable.
+
+        // hull output limits.
+        public uint mMaxVertices; // maximum number of vertices in the output hull. Recommended 32 or less.
+        public float mSkinWidth; // a skin width to apply to the output hulls.
+
+        public ConvexDecompositionCallback mCallback; // the interface to receive back the results.
+
+        public DecompDesc()
+        {
+            mDepth = 5;
+            mCpercent = 5;
+            mPpercent = 5;
+            mMaxVertices = 32;
+        }
+    }
+
+    public class CHull
+    {
+        public float[] mMin = new float[3];
+        public float[] mMax = new float[3];
+        public float mVolume;
+        public float mDiagonal;
+        public ConvexResult mResult;
+
+        public CHull(ConvexResult result)
+        {
+            mResult = new ConvexResult(result);
+            mVolume = Concavity.computeMeshVolume(result.HullVertices, result.HullIndices);
+
+            mDiagonal = getBoundingRegion(result.HullVertices, mMin, mMax);
+
+            float dx = mMax[0] - mMin[0];
+            float dy = mMax[1] - mMin[1];
+            float dz = mMax[2] - mMin[2];
+
+            dx *= 0.1f; // inflate 1/10th on each edge
+            dy *= 0.1f; // inflate 1/10th on each edge
+            dz *= 0.1f; // inflate 1/10th on each edge
+
+            mMin[0] -= dx;
+            mMin[1] -= dy;
+            mMin[2] -= dz;
+
+            mMax[0] += dx;
+            mMax[1] += dy;
+            mMax[2] += dz;
+        }
+
+        public void Dispose()
+        {
+            mResult = null;
+        }
+
+        public bool overlap(CHull h)
+        {
+            return overlapAABB(mMin, mMax, h.mMin, h.mMax);
+        }
+
+        // returns the d1Giagonal distance
+        private static float getBoundingRegion(List<float3> points, float[] bmin, float[] bmax)
+        {
+            float3 first = points[0];
+
+            bmin[0] = first.x;
+            bmin[1] = first.y;
+            bmin[2] = first.z;
+
+            bmax[0] = first.x;
+            bmax[1] = first.y;
+            bmax[2] = first.z;
+
+            for (int i = 1; i < points.Count; i++)
+            {
+                float3 p = points[i];
+
+                if (p[0] < bmin[0]) bmin[0] = p[0];
+                if (p[1] < bmin[1]) bmin[1] = p[1];
+                if (p[2] < bmin[2]) bmin[2] = p[2];
+
+                if (p[0] > bmax[0]) bmax[0] = p[0];
+                if (p[1] > bmax[1]) bmax[1] = p[1];
+                if (p[2] > bmax[2]) bmax[2] = p[2];
+            }
+
+            float dx = bmax[0] - bmin[0];
+            float dy = bmax[1] - bmin[1];
+            float dz = bmax[2] - bmin[2];
+
+            return (float)Math.Sqrt(dx * dx + dy * dy + dz * dz);
+        }
+
+        // return true if the two AABB's overlap.
+        private static bool overlapAABB(float[] bmin1, float[] bmax1, float[] bmin2, float[] bmax2)
+        {
+            if (bmax2[0] < bmin1[0]) return false; // if the maximum is less than our minimum on any axis
+            if (bmax2[1] < bmin1[1]) return false;
+            if (bmax2[2] < bmin1[2]) return false;
+
+            if (bmin2[0] > bmax1[0]) return false; // if the minimum is greater than our maximum on any axis
+            if (bmin2[1] > bmax1[1]) return false; // if the minimum is greater than our maximum on any axis
+            if (bmin2[2] > bmax1[2]) return false; // if the minimum is greater than our maximum on any axis
+
+            return true; // the extents overlap
+        }
+    }
+
+    public class ConvexBuilder
+    {
+        public List<CHull> mChulls = new List<CHull>();
+        private ConvexDecompositionCallback mCallback;
+
+        private int MAXDEPTH = 8;
+        private float CONCAVE_PERCENT = 1f;
+        private float MERGE_PERCENT = 2f;
+
+        public ConvexBuilder(ConvexDecompositionCallback callback)
+        {
+            mCallback = callback;
+        }
+
+        public void Dispose()
+        {
+            int i;
+            for (i = 0; i < mChulls.Count; i++)
+            {
+                CHull cr = mChulls[i];
+                cr.Dispose();
+            }
+        }
+
+        public bool isDuplicate(uint i1, uint i2, uint i3, uint ci1, uint ci2, uint ci3)
+        {
+            uint dcount = 0;
+
+            Debug.Assert(i1 != i2 && i1 != i3 && i2 != i3);
+            Debug.Assert(ci1 != ci2 && ci1 != ci3 && ci2 != ci3);
+
+            if (i1 == ci1 || i1 == ci2 || i1 == ci3)
+                dcount++;
+            if (i2 == ci1 || i2 == ci2 || i2 == ci3)
+                dcount++;
+            if (i3 == ci1 || i3 == ci2 || i3 == ci3)
+                dcount++;
+
+            return dcount == 3;
+        }
+
+        public void getMesh(ConvexResult cr, VertexPool vc, List<int> indices)
+        {
+            List<int> src = cr.HullIndices;
+
+            for (int i = 0; i < src.Count / 3; i++)
+            {
+                int i1 = src[i * 3 + 0];
+                int i2 = src[i * 3 + 1];
+                int i3 = src[i * 3 + 2];
+
+                float3 p1 = cr.HullVertices[i1];
+                float3 p2 = cr.HullVertices[i2];
+                float3 p3 = cr.HullVertices[i3];
+
+                i1 = vc.getIndex(p1);
+                i2 = vc.getIndex(p2);
+                i3 = vc.getIndex(p3);
+            }
+        }
+
+        public CHull canMerge(CHull a, CHull b)
+        {
+            if (!a.overlap(b)) // if their AABB's (with a little slop) don't overlap, then return.
+                return null;
+
+            CHull ret = null;
+
+            // ok..we are going to combine both meshes into a single mesh
+            // and then we are going to compute the concavity...
+
+            VertexPool vc = new VertexPool();
+
+            List<int> indices = new List<int>();
+
+            getMesh(a.mResult, vc, indices);
+            getMesh(b.mResult, vc, indices);
+
+            int vcount = vc.GetSize();
+            List<float3> vertices = vc.GetVertices();
+            int tcount = indices.Count / 3;
+
+            //don't do anything if hull is empty
+            if (tcount == 0)
+            {
+                vc.Clear();
+                return null;
+            }
+
+            HullResult hresult = new HullResult();
+            HullDesc desc = new HullDesc();
+
+            desc.SetHullFlag(HullFlag.QF_TRIANGLES);
+            desc.Vertices = vertices;
+
+            HullError hret = HullUtils.CreateConvexHull(desc, ref hresult);
+
+            if (hret == HullError.QE_OK)
+            {
+                float combineVolume = Concavity.computeMeshVolume(hresult.OutputVertices, hresult.Indices);
+                float sumVolume = a.mVolume + b.mVolume;
+
+                float percent = (sumVolume * 100) / combineVolume;
+                if (percent >= (100.0f - MERGE_PERCENT))
+                {
+                    ConvexResult cr = new ConvexResult(hresult.OutputVertices, hresult.Indices);
+                    ret = new CHull(cr);
+                }
+            }
+
+            vc.Clear();
+            return ret;
+        }
+
+        public bool combineHulls()
+        {
+            bool combine = false;
+
+            sortChulls(mChulls); // sort the convex hulls, largest volume to least...
+
+            List<CHull> output = new List<CHull>(); // the output hulls...
+
+            int i;
+            for (i = 0; i < mChulls.Count && !combine; ++i)
+            {
+                CHull cr = mChulls[i];
+
+                int j;
+                for (j = 0; j < mChulls.Count; j++)
+                {
+                    CHull match = mChulls[j];
+
+                    if (cr != match) // don't try to merge a hull with itself, that be stoopid
+                    {
+
+                        CHull merge = canMerge(cr, match); // if we can merge these two....
+
+                        if (merge != null)
+                        {
+                            output.Add(merge);
+
+                            ++i;
+                            while (i != mChulls.Count)
+                            {
+                                CHull cr2 = mChulls[i];
+                                if (cr2 != match)
+                                {
+                                    output.Add(cr2);
+                                }
+                                i++;
+                            }
+
+                            cr.Dispose();
+                            match.Dispose();
+                            combine = true;
+                            break;
+                        }
+                    }
+                }
+
+                if (combine)
+                {
+                    break;
+                }
+                else
+                {
+                    output.Add(cr);
+                }
+            }
+
+            if (combine)
+            {
+                mChulls.Clear();
+                mChulls = output;
+                output.Clear();
+            }
+
+            return combine;
+        }
+
+        public int process(DecompDesc desc)
+        {
+            int ret = 0;
+
+            MAXDEPTH = (int)desc.mDepth;
+            CONCAVE_PERCENT = desc.mCpercent;
+            MERGE_PERCENT = desc.mPpercent;
+
+            ConvexDecomposition.calcConvexDecomposition(desc.mVertices, desc.mIndices, ConvexDecompResult, 0f, 0, MAXDEPTH, CONCAVE_PERCENT, MERGE_PERCENT);
+
+            while (combineHulls()) // keep combinging hulls until I can't combine any more...
+                ;
+
+            int i;
+            for (i = 0; i < mChulls.Count; i++)
+            {
+                CHull cr = mChulls[i];
+
+                // before we hand it back to the application, we need to regenerate the hull based on the
+                // limits given by the user.
+
+                ConvexResult c = cr.mResult; // the high resolution hull...
+
+                HullResult result = new HullResult();
+                HullDesc hdesc = new HullDesc();
+
+                hdesc.SetHullFlag(HullFlag.QF_TRIANGLES);
+
+                hdesc.Vertices = c.HullVertices;
+                hdesc.MaxVertices = desc.mMaxVertices; // maximum number of vertices allowed in the output
+
+                if (desc.mSkinWidth != 0f)
+                {
+                    hdesc.SkinWidth = desc.mSkinWidth;
+                    hdesc.SetHullFlag(HullFlag.QF_SKIN_WIDTH); // do skin width computation.
+                }
+
+                HullError ret2 = HullUtils.CreateConvexHull(hdesc, ref result);
+
+                if (ret2 == HullError.QE_OK)
+                {
+                    ConvexResult r = new ConvexResult(result.OutputVertices, result.Indices);
+
+                    r.mHullVolume = Concavity.computeMeshVolume(result.OutputVertices, result.Indices); // the volume of the hull.
+
+                    // compute the best fit OBB
+                    //computeBestFitOBB(result.mNumOutputVertices, result.mOutputVertices, sizeof(float) * 3, r.mOBBSides, r.mOBBTransform);
+
+                    //r.mOBBVolume = r.mOBBSides[0] * r.mOBBSides[1] * r.mOBBSides[2]; // compute the OBB volume.
+
+                    //fm_getTranslation(r.mOBBTransform, r.mOBBCenter); // get the translation component of the 4x4 matrix.
+
+                    //fm_matrixToQuat(r.mOBBTransform, r.mOBBOrientation); // extract the orientation as a quaternion.
+
+                    //r.mSphereRadius = computeBoundingSphere(result.mNumOutputVertices, result.mOutputVertices, r.mSphereCenter);
+                    //r.mSphereVolume = fm_sphereVolume(r.mSphereRadius);
+
+                    mCallback(r);
+                }
+
+                result = null;
+                cr.Dispose();
+            }
+
+            ret = mChulls.Count;
+
+            mChulls.Clear();
+
+            return ret;
+        }
+
+        public void ConvexDecompResult(ConvexResult result)
+        {
+            CHull ch = new CHull(result);
+            mChulls.Add(ch);
+        }
+
+        public void sortChulls(List<CHull> hulls)
+        {
+            hulls.Sort(delegate(CHull a, CHull b) { return a.mVolume.CompareTo(b.mVolume); });
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexDecomposition.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexDecomposition.cs
new file mode 100644
index 0000000..5046bce
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexDecomposition.cs
@@ -0,0 +1,200 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public delegate void ConvexDecompositionCallback(ConvexResult result);
+
+    public class FaceTri
+    {
+        public float3 P1;
+        public float3 P2;
+        public float3 P3;
+
+        public FaceTri() { }
+
+        public FaceTri(List<float3> vertices, int i1, int i2, int i3)
+        {
+            P1 = new float3(vertices[i1]);
+            P2 = new float3(vertices[i2]);
+            P3 = new float3(vertices[i3]);
+        }
+    }
+
+    public static class ConvexDecomposition
+    {
+        private static void addTri(VertexPool vl, List<int> list, float3 p1, float3 p2, float3 p3)
+        {
+            int i1 = vl.getIndex(p1);
+            int i2 = vl.getIndex(p2);
+            int i3 = vl.getIndex(p3);
+
+            // do *not* process degenerate triangles!
+            if ( i1 != i2 && i1 != i3 && i2 != i3 )
+            {
+                list.Add(i1);
+                list.Add(i2);
+                list.Add(i3);
+            }
+        }
+
+        public static void calcConvexDecomposition(List<float3> vertices, List<int> indices, ConvexDecompositionCallback callback, float masterVolume, int depth,
+            int maxDepth, float concavePercent, float mergePercent)
+        {
+            float4 plane = new float4();
+            bool split = false;
+
+            if (depth < maxDepth)
+            {
+                float volume = 0f;
+                float c = Concavity.computeConcavity(vertices, indices, ref plane, ref volume);
+
+                if (depth == 0)
+                {
+                    masterVolume = volume;
+                }
+
+                float percent = (c * 100.0f) / masterVolume;
+
+                if (percent > concavePercent) // if great than 5% of the total volume is concave, go ahead and keep splitting.
+                {
+                    split = true;
+                }
+            }
+
+            if (depth >= maxDepth || !split)
+            {
+                HullResult result = new HullResult();
+                HullDesc desc = new HullDesc();
+
+                desc.SetHullFlag(HullFlag.QF_TRIANGLES);
+
+                desc.Vertices = vertices;
+
+                HullError ret = HullUtils.CreateConvexHull(desc, ref result);
+
+                if (ret == HullError.QE_OK)
+                {
+                    ConvexResult r = new ConvexResult(result.OutputVertices, result.Indices);
+                    callback(r);
+                }
+
+                return;
+            }
+
+            List<int> ifront = new List<int>();
+            List<int> iback = new List<int>();
+
+            VertexPool vfront = new VertexPool();
+            VertexPool vback = new VertexPool();
+
+            // ok..now we are going to 'split' all of the input triangles against this plane!
+            for (int i = 0; i < indices.Count / 3; i++)
+            {
+                int i1 = indices[i * 3 + 0];
+                int i2 = indices[i * 3 + 1];
+                int i3 = indices[i * 3 + 2];
+
+                FaceTri t = new FaceTri(vertices, i1, i2, i3);
+
+                float3[] front = new float3[4];
+                float3[] back = new float3[4];
+
+                int fcount = 0;
+                int bcount = 0;
+
+                PlaneTriResult result = PlaneTri.planeTriIntersection(plane, t, 0.00001f, ref front, out fcount, ref back, out bcount);
+
+                if (fcount > 4 || bcount > 4)
+                {
+                    result = PlaneTri.planeTriIntersection(plane, t, 0.00001f, ref front, out fcount, ref back, out bcount);
+                }
+
+                switch (result)
+                {
+                    case PlaneTriResult.PTR_FRONT:
+                        Debug.Assert(fcount == 3);
+                        addTri(vfront, ifront, front[0], front[1], front[2]);
+                        break;
+                    case PlaneTriResult.PTR_BACK:
+                        Debug.Assert(bcount == 3);
+                        addTri(vback, iback, back[0], back[1], back[2]);
+                        break;
+                    case PlaneTriResult.PTR_SPLIT:
+                        Debug.Assert(fcount >= 3 && fcount <= 4);
+                        Debug.Assert(bcount >= 3 && bcount <= 4);
+
+                        addTri(vfront, ifront, front[0], front[1], front[2]);
+                        addTri(vback, iback, back[0], back[1], back[2]);
+
+                        if (fcount == 4)
+                        {
+                            addTri(vfront, ifront, front[0], front[2], front[3]);
+                        }
+
+                        if (bcount == 4)
+                        {
+                            addTri(vback, iback, back[0], back[2], back[3]);
+                        }
+
+                        break;
+                }
+            }
+
+            // ok... here we recursively call
+            if (ifront.Count > 0)
+            {
+                int vcount = vfront.GetSize();
+                List<float3> vertices2 = vfront.GetVertices();
+                for (int i = 0; i < vertices2.Count; i++)
+                    vertices2[i] = new float3(vertices2[i]);
+                int tcount = ifront.Count / 3;
+
+                calcConvexDecomposition(vertices2, ifront, callback, masterVolume, depth + 1, maxDepth, concavePercent, mergePercent);
+            }
+
+            ifront.Clear();
+            vfront.Clear();
+
+            if (iback.Count > 0)
+            {
+                int vcount = vback.GetSize();
+                List<float3> vertices2 = vback.GetVertices();
+                int tcount = iback.Count / 3;
+
+                calcConvexDecomposition(vertices2, iback, callback, masterVolume, depth + 1, maxDepth, concavePercent, mergePercent);
+            }
+
+            iback.Clear();
+            vback.Clear();
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexResult.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexResult.cs
new file mode 100644
index 0000000..44e3e50
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexResult.cs
@@ -0,0 +1,74 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class ConvexResult
+    {
+        public List<float3> HullVertices;
+        public List<int> HullIndices;
+
+        public float mHullVolume; // the volume of the convex hull.
+
+        //public float[] OBBSides = new float[3]; // the width, height and breadth of the best fit OBB
+        //public float[] OBBCenter = new float[3]; // the center of the OBB
+        //public float[] OBBOrientation = new float[4]; // the quaternion rotation of the OBB.
+        //public float[] OBBTransform = new float[16]; // the 4x4 transform of the OBB.
+        //public float OBBVolume; // the volume of the OBB
+
+        //public float SphereRadius; // radius and center of best fit sphere
+        //public float[] SphereCenter = new float[3];
+        //public float SphereVolume; // volume of the best fit sphere
+
+        public ConvexResult()
+        {
+            HullVertices = new List<float3>();
+            HullIndices = new List<int>();
+        }
+
+        public ConvexResult(List<float3> hvertices, List<int> hindices)
+        {
+            HullVertices = hvertices;
+            HullIndices = hindices;
+        }
+
+        public ConvexResult(ConvexResult r)
+        {
+            HullVertices = new List<float3>(r.HullVertices);
+            HullIndices = new List<int>(r.HullIndices);
+        }
+
+        public void Dispose()
+        {
+            HullVertices = null;
+            HullIndices = null;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullClasses.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullClasses.cs
new file mode 100644
index 0000000..8a0164e
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullClasses.cs
@@ -0,0 +1,171 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class HullResult
+    {
+        public bool Polygons = true; // true if indices represents polygons, false indices are triangles
+        public List<float3> OutputVertices = new List<float3>();
+        public List<int> Indices;
+
+        // If triangles, then indices are array indexes into the vertex list.
+        // If polygons, indices are in the form (number of points in face) (p1, p2, p3, ..) etc..
+    }
+
+    public class PHullResult
+    {
+        public List<float3> Vertices = new List<float3>();
+        public List<int> Indices = new List<int>();
+    }
+
+    [Flags]
+    public enum HullFlag : int
+    {
+        QF_DEFAULT = 0,
+        QF_TRIANGLES = (1 << 0), // report results as triangles, not polygons.
+        QF_SKIN_WIDTH = (1 << 2) // extrude hull based on this skin width
+    }
+
+    public enum HullError : int
+    {
+        QE_OK, // success!
+        QE_FAIL // failed.
+    }
+
+    public class HullDesc
+    {
+        public HullFlag Flags; // flags to use when generating the convex hull.
+        public List<float3> Vertices;
+        public float NormalEpsilon; // the epsilon for removing duplicates. This is a normalized value, if normalized bit is on.
+        public float SkinWidth;
+        public uint MaxVertices; // maximum number of vertices to be considered for the hull!
+        public uint MaxFaces;
+
+        public HullDesc()
+        {
+            Flags = HullFlag.QF_DEFAULT;
+            Vertices = new List<float3>();
+            NormalEpsilon = 0.001f;
+            MaxVertices = 4096;
+            MaxFaces = 4096;
+            SkinWidth = 0.01f;
+        }
+
+        public HullDesc(HullFlag flags, List<float3> vertices)
+        {
+            Flags = flags;
+            Vertices = new List<float3>(vertices);
+            NormalEpsilon = 0.001f;
+            MaxVertices = 4096;
+            MaxFaces = 4096;
+            SkinWidth = 0.01f;
+        }
+
+        public bool HasHullFlag(HullFlag flag)
+        {
+            return (Flags & flag) != 0;
+        }
+
+        public void SetHullFlag(HullFlag flag)
+        {
+            Flags |= flag;
+        }
+
+        public void ClearHullFlag(HullFlag flag)
+        {
+            Flags &= ~flag;
+        }
+    }
+
+    public class ConvexH
+    {
+        public struct HalfEdge
+        {
+            public short ea; // the other half of the edge (index into edges list)
+            public byte v; // the vertex at the start of this edge (index into vertices list)
+            public byte p; // the facet on which this edge lies (index into facets list)
+
+            public HalfEdge(short _ea, byte _v, byte _p)
+            {
+                ea = _ea;
+                v = _v;
+                p = _p;
+            }
+
+            public HalfEdge(HalfEdge e)
+            {
+                ea = e.ea;
+                v = e.v;
+                p = e.p;
+            }
+        }
+
+        public List<float3> vertices = new List<float3>();
+        public List<HalfEdge> edges = new List<HalfEdge>();
+        public List<Plane> facets = new List<Plane>();
+
+        public ConvexH(int vertices_size, int edges_size, int facets_size)
+        {
+            vertices = new List<float3>(vertices_size);
+            edges = new List<HalfEdge>(edges_size);
+            facets = new List<Plane>(facets_size);
+        }
+    }
+
+    public class VertFlag
+    {
+        public byte planetest;
+        public byte junk;
+        public byte undermap;
+        public byte overmap;
+    }
+
+    public class EdgeFlag
+    {
+        public byte planetest;
+        public byte fixes;
+        public short undermap;
+        public short overmap;
+    }
+
+    public class PlaneFlag
+    {
+        public byte undermap;
+        public byte overmap;
+    }
+
+    public class Coplanar
+    {
+        public ushort ea;
+        public byte v0;
+        public byte v1;
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullTriangle.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullTriangle.cs
new file mode 100644
index 0000000..d3f0052
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullTriangle.cs
@@ -0,0 +1,99 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class HullTriangle : int3
+    {
+        public int3 n = new int3();
+        public int id;
+        public int vmax;
+        public float rise;
+        private List<HullTriangle> tris;
+
+        public HullTriangle(int a, int b, int c, List<HullTriangle> tris)
+            : base(a, b, c)
+        {
+            this.tris = tris;
+
+            n = new int3(-1, -1, -1);
+            id = tris.Count;
+            tris.Add(this);
+            vmax = -1;
+            rise = 0.0f;
+        }
+
+        public void Dispose()
+        {
+            Debug.Assert(tris[id] == this);
+            tris[id] = null;
+        }
+
+        public int neib(int a, int b)
+        {
+            int i;
+
+            for (i = 0; i < 3; i++)
+            {
+                int i1 = (i + 1) % 3;
+                int i2 = (i + 2) % 3;
+                if ((this)[i] == a && (this)[i1] == b)
+                    return n[i2];
+                if ((this)[i] == b && (this)[i1] == a)
+                    return n[i2];
+            }
+
+            Debug.Assert(false);
+            return -1;
+        }
+
+        public void setneib(int a, int b, int value)
+        {
+            int i;
+
+            for (i = 0; i < 3; i++)
+            {
+                int i1 = (i + 1) % 3;
+                int i2 = (i + 2) % 3;
+                if ((this)[i] == a && (this)[i1] == b)
+                {
+                    n[i2] = value;
+                    return;
+                }
+                if ((this)[i] == b && (this)[i1] == a)
+                {
+                    n[i2] = value;
+                    return;
+                }
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullUtils.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullUtils.cs
new file mode 100644
index 0000000..3903254
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullUtils.cs
@@ -0,0 +1,1868 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public static class HullUtils
+    {
+        public static int argmin(float[] a, int n)
+        {
+            int r = 0;
+            for (int i = 1; i < n; i++)
+            {
+                if (a[i] < a[r])
+                {
+                    r = i;
+                }
+            }
+            return r;
+        }
+
+        public static float clampf(float a)
+        {
+            return Math.Min(1.0f, Math.Max(0.0f, a));
+        }
+
+        public static float Round(float a, float precision)
+        {
+            return (float)Math.Floor(0.5f + a / precision) * precision;
+        }
+
+        public static float Interpolate(float f0, float f1, float alpha)
+        {
+            return f0 * (1 - alpha) + f1 * alpha;
+        }
+
+        public static void Swap<T>(ref T a, ref T b)
+        {
+            T tmp = a;
+            a = b;
+            b = tmp;
+        }
+
+        public static bool above(List<float3> vertices, int3 t, float3 p, float epsilon)
+        {
+            float3 vtx = vertices[t.x];
+            float3 n = TriNormal(vtx, vertices[t.y], vertices[t.z]);
+            return (float3.dot(n, p - vtx) > epsilon); // EPSILON???
+        }
+
+        public static int hasedge(int3 t, int a, int b)
+        {
+            for (int i = 0; i < 3; i++)
+            {
+                int i1 = (i + 1) % 3;
+                if (t[i] == a && t[i1] == b)
+                    return 1;
+            }
+            return 0;
+        }
+
+        public static bool hasvert(int3 t, int v)
+        {
+            return (t[0] == v || t[1] == v || t[2] == v);
+        }
+
+        public static int shareedge(int3 a, int3 b)
+        {
+            int i;
+            for (i = 0; i < 3; i++)
+            {
+                int i1 = (i + 1) % 3;
+                if (hasedge(a, b[i1], b[i]) != 0)
+                    return 1;
+            }
+            return 0;
+        }
+
+        public static void b2bfix(HullTriangle s, HullTriangle t, List<HullTriangle> tris)
+        {
+            int i;
+            for (i = 0; i < 3; i++)
+            {
+                int i1 = (i + 1) % 3;
+                int i2 = (i + 2) % 3;
+                int a = (s)[i1];
+                int b = (s)[i2];
+                Debug.Assert(tris[s.neib(a, b)].neib(b, a) == s.id);
+                Debug.Assert(tris[t.neib(a, b)].neib(b, a) == t.id);
+                tris[s.neib(a, b)].setneib(b, a, t.neib(b, a));
+                tris[t.neib(b, a)].setneib(a, b, s.neib(a, b));
+            }
+        }
+
+        public static void removeb2b(HullTriangle s, HullTriangle t, List<HullTriangle> tris)
+        {
+            b2bfix(s, t, tris);
+            s.Dispose();
+            t.Dispose();
+        }
+
+        public static void checkit(HullTriangle t, List<HullTriangle> tris)
+        {
+            int i;
+            Debug.Assert(tris[t.id] == t);
+            for (i = 0; i < 3; i++)
+            {
+                int i1 = (i + 1) % 3;
+                int i2 = (i + 2) % 3;
+                int a = (t)[i1];
+                int b = (t)[i2];
+                Debug.Assert(a != b);
+                Debug.Assert(tris[t.n[i]].neib(b, a) == t.id);
+            }
+        }
+
+        public static void extrude(HullTriangle t0, int v, List<HullTriangle> tris)
+        {
+            int3 t = t0;
+            int n = tris.Count;
+            HullTriangle ta = new HullTriangle(v, t[1], t[2], tris);
+            ta.n = new int3(t0.n[0], n + 1, n + 2);
+            tris[t0.n[0]].setneib(t[1], t[2], n + 0);
+            HullTriangle tb = new HullTriangle(v, t[2], t[0], tris);
+            tb.n = new int3(t0.n[1], n + 2, n + 0);
+            tris[t0.n[1]].setneib(t[2], t[0], n + 1);
+            HullTriangle tc = new HullTriangle(v, t[0], t[1], tris);
+            tc.n = new int3(t0.n[2], n + 0, n + 1);
+            tris[t0.n[2]].setneib(t[0], t[1], n + 2);
+            checkit(ta, tris);
+            checkit(tb, tris);
+            checkit(tc, tris);
+            if (hasvert(tris[ta.n[0]], v))
+                removeb2b(ta, tris[ta.n[0]], tris);
+            if (hasvert(tris[tb.n[0]], v))
+                removeb2b(tb, tris[tb.n[0]], tris);
+            if (hasvert(tris[tc.n[0]], v))
+                removeb2b(tc, tris[tc.n[0]], tris);
+            t0.Dispose();
+        }
+
+        public static HullTriangle extrudable(float epsilon, List<HullTriangle> tris)
+        {
+            int i;
+            HullTriangle t = null;
+            for (i = 0; i < tris.Count; i++)
+            {
+                if (t == null || (tris.Count > i && (object)tris[i] != null && t.rise < tris[i].rise))
+                {
+                    t = tris[i];
+                }
+            }
+            return (t.rise > epsilon) ? t : null;
+        }
+
+        public static Quaternion RotationArc(float3 v0, float3 v1)
+        {
+            Quaternion q = new Quaternion();
+            v0 = float3.normalize(v0); // Comment these two lines out if you know its not needed.
+            v1 = float3.normalize(v1); // If vector is already unit length then why do it again?
+            float3 c = float3.cross(v0, v1);
+            float d = float3.dot(v0, v1);
+            if (d <= -1.0f) // 180 about x axis
+            {
+                return new Quaternion(1f, 0f, 0f, 0f);
+            }
+            float s = (float)Math.Sqrt((1 + d) * 2f);
+            q.x = c.x / s;
+            q.y = c.y / s;
+            q.z = c.z / s;
+            q.w = s / 2.0f;
+            return q;
+        }
+
+        public static float3 PlaneLineIntersection(Plane plane, float3 p0, float3 p1)
+        {
+            // returns the point where the line p0-p1 intersects the plane n&d
+            float3 dif = p1 - p0;
+            float dn = float3.dot(plane.normal, dif);
+            float t = -(plane.dist + float3.dot(plane.normal, p0)) / dn;
+            return p0 + (dif * t);
+        }
+
+        public static float3 LineProject(float3 p0, float3 p1, float3 a)
+        {
+            float3 w = new float3();
+            w = p1 - p0;
+            float t = float3.dot(w, (a - p0)) / (w.x * w.x + w.y * w.y + w.z * w.z);
+            return p0 + w * t;
+        }
+
+        public static float3 PlaneProject(Plane plane, float3 point)
+        {
+            return point - plane.normal * (float3.dot(point, plane.normal) + plane.dist);
+        }
+
+        public static float LineProjectTime(float3 p0, float3 p1, float3 a)
+        {
+            float3 w = new float3();
+            w = p1 - p0;
+            float t = float3.dot(w, (a - p0)) / (w.x * w.x + w.y * w.y + w.z * w.z);
+            return t;
+        }
+
+        public static float3 ThreePlaneIntersection(Plane p0, Plane p1, Plane p2)
+        {
+            float3x3 mp = float3x3.Transpose(new float3x3(p0.normal, p1.normal, p2.normal));
+            float3x3 mi = float3x3.Inverse(mp);
+            float3 b = new float3(p0.dist, p1.dist, p2.dist);
+            return -b * mi;
+        }
+
+        public static bool PolyHit(List<float3> vert, float3 v0, float3 v1)
+        {
+            float3 impact = new float3();
+            float3 normal = new float3();
+            return PolyHit(vert, v0, v1, out impact, out normal);
+        }
+
+        public static bool PolyHit(List<float3> vert, float3 v0, float3 v1, out float3 impact)
+        {
+            float3 normal = new float3();
+            return PolyHit(vert, v0, v1, out impact, out normal);
+        }
+
+        public static bool PolyHit(List<float3> vert, float3 v0, float3 v1, out float3 impact, out float3 normal)
+        {
+            float3 the_point = new float3();
+
+            impact = null;
+            normal = null;
+
+            int i;
+            float3 nrml = new float3(0, 0, 0);
+            for (i = 0; i < vert.Count; i++)
+            {
+                int i1 = (i + 1) % vert.Count;
+                int i2 = (i + 2) % vert.Count;
+                nrml = nrml + float3.cross(vert[i1] - vert[i], vert[i2] - vert[i1]);
+            }
+
+            float m = float3.magnitude(nrml);
+            if (m == 0.0)
+            {
+                return false;
+            }
+            nrml = nrml * (1.0f / m);
+            float dist = -float3.dot(nrml, vert[0]);
+            float d0;
+            float d1;
+            if ((d0 = float3.dot(v0, nrml) + dist) < 0 || (d1 = float3.dot(v1, nrml) + dist) > 0)
+            {
+                return false;
+            }
+
+            // By using the cached plane distances d0 and d1
+            // we can optimize the following:
+            //     the_point = planelineintersection(nrml,dist,v0,v1);
+            float a = d0 / (d0 - d1);
+            the_point = v0 * (1 - a) + v1 * a;
+
+
+            bool inside = true;
+            for (int j = 0; inside && j < vert.Count; j++)
+            {
+                // let inside = 0 if outside
+                float3 pp1 = new float3();
+                float3 pp2 = new float3();
+                float3 side = new float3();
+                pp1 = vert[j];
+                pp2 = vert[(j + 1) % vert.Count];
+                side = float3.cross((pp2 - pp1), (the_point - pp1));
+                inside = (float3.dot(nrml, side) >= 0.0);
+            }
+            if (inside)
+            {
+                if (normal != null)
+                {
+                    normal = nrml;
+                }
+                if (impact != null)
+                {
+                    impact = the_point;
+                }
+            }
+            return inside;
+        }
+
+        public static bool BoxInside(float3 p, float3 bmin, float3 bmax)
+        {
+            return (p.x >= bmin.x && p.x <= bmax.x && p.y >= bmin.y && p.y <= bmax.y && p.z >= bmin.z && p.z <= bmax.z);
+        }
+
+        public static bool BoxIntersect(float3 v0, float3 v1, float3 bmin, float3 bmax, float3 impact)
+        {
+            if (BoxInside(v0, bmin, bmax))
+            {
+                impact = v0;
+                return true;
+            }
+            if (v0.x <= bmin.x && v1.x >= bmin.x)
+            {
+                float a = (bmin.x - v0.x) / (v1.x - v0.x);
+                //v.x = bmin.x;
+                float vy = (1 - a) * v0.y + a * v1.y;
+                float vz = (1 - a) * v0.z + a * v1.z;
+                if (vy >= bmin.y && vy <= bmax.y && vz >= bmin.z && vz <= bmax.z)
+                {
+                    impact.x = bmin.x;
+                    impact.y = vy;
+                    impact.z = vz;
+                    return true;
+                }
+            }
+            else if (v0.x >= bmax.x && v1.x <= bmax.x)
+            {
+                float a = (bmax.x - v0.x) / (v1.x - v0.x);
+                //v.x = bmax.x;
+                float vy = (1 - a) * v0.y + a * v1.y;
+                float vz = (1 - a) * v0.z + a * v1.z;
+                if (vy >= bmin.y && vy <= bmax.y && vz >= bmin.z && vz <= bmax.z)
+                {
+                    impact.x = bmax.x;
+                    impact.y = vy;
+                    impact.z = vz;
+                    return true;
+                }
+            }
+            if (v0.y <= bmin.y && v1.y >= bmin.y)
+            {
+                float a = (bmin.y - v0.y) / (v1.y - v0.y);
+                float vx = (1 - a) * v0.x + a * v1.x;
+                //v.y = bmin.y;
+                float vz = (1 - a) * v0.z + a * v1.z;
+                if (vx >= bmin.x && vx <= bmax.x && vz >= bmin.z && vz <= bmax.z)
+                {
+                    impact.x = vx;
+                    impact.y = bmin.y;
+                    impact.z = vz;
+                    return true;
+                }
+            }
+            else if (v0.y >= bmax.y && v1.y <= bmax.y)
+            {
+                float a = (bmax.y - v0.y) / (v1.y - v0.y);
+                float vx = (1 - a) * v0.x + a * v1.x;
+                // vy = bmax.y;
+                float vz = (1 - a) * v0.z + a * v1.z;
+                if (vx >= bmin.x && vx <= bmax.x && vz >= bmin.z && vz <= bmax.z)
+                {
+                    impact.x = vx;
+                    impact.y = bmax.y;
+                    impact.z = vz;
+                    return true;
+                }
+            }
+            if (v0.z <= bmin.z && v1.z >= bmin.z)
+            {
+                float a = (bmin.z - v0.z) / (v1.z - v0.z);
+                float vx = (1 - a) * v0.x + a * v1.x;
+                float vy = (1 - a) * v0.y + a * v1.y;
+                // v.z = bmin.z;
+                if (vy >= bmin.y && vy <= bmax.y && vx >= bmin.x && vx <= bmax.x)
+                {
+                    impact.x = vx;
+                    impact.y = vy;
+                    impact.z = bmin.z;
+                    return true;
+                }
+            }
+            else if (v0.z >= bmax.z && v1.z <= bmax.z)
+            {
+                float a = (bmax.z - v0.z) / (v1.z - v0.z);
+                float vx = (1 - a) * v0.x + a * v1.x;
+                float vy = (1 - a) * v0.y + a * v1.y;
+                // v.z = bmax.z;
+                if (vy >= bmin.y && vy <= bmax.y && vx >= bmin.x && vx <= bmax.x)
+                {
+                    impact.x = vx;
+                    impact.y = vy;
+                    impact.z = bmax.z;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public static float DistanceBetweenLines(float3 ustart, float3 udir, float3 vstart, float3 vdir, float3 upoint)
+        {
+            return DistanceBetweenLines(ustart, udir, vstart, vdir, upoint, null);
+        }
+
+        public static float DistanceBetweenLines(float3 ustart, float3 udir, float3 vstart, float3 vdir)
+        {
+            return DistanceBetweenLines(ustart, udir, vstart, vdir, null, null);
+        }
+
+        public static float DistanceBetweenLines(float3 ustart, float3 udir, float3 vstart, float3 vdir, float3 upoint, float3 vpoint)
+        {
+            float3 cp = float3.normalize(float3.cross(udir, vdir));
+
+            float distu = -float3.dot(cp, ustart);
+            float distv = -float3.dot(cp, vstart);
+            float dist = (float)Math.Abs(distu - distv);
+            if (upoint != null)
+            {
+                Plane plane = new Plane();
+                plane.normal = float3.normalize(float3.cross(vdir, cp));
+                plane.dist = -float3.dot(plane.normal, vstart);
+                upoint = PlaneLineIntersection(plane, ustart, ustart + udir);
+            }
+            if (vpoint != null)
+            {
+                Plane plane = new Plane();
+                plane.normal = float3.normalize(float3.cross(udir, cp));
+                plane.dist = -float3.dot(plane.normal, ustart);
+                vpoint = PlaneLineIntersection(plane, vstart, vstart + vdir);
+            }
+            return dist;
+        }
+
+        public static float3 TriNormal(float3 v0, float3 v1, float3 v2)
+        {
+            // return the normal of the triangle
+            // inscribed by v0, v1, and v2
+            float3 cp = float3.cross(v1 - v0, v2 - v1);
+            float m = float3.magnitude(cp);
+            if (m == 0)
+                return new float3(1, 0, 0);
+            return cp * (1.0f / m);
+        }
+
+        public static int PlaneTest(Plane p, float3 v, float planetestepsilon)
+        {
+            float a = float3.dot(v, p.normal) + p.dist;
+            int flag = (a > planetestepsilon) ? (2) : ((a < -planetestepsilon) ? (1) : (0));
+            return flag;
+        }
+
+        public static int SplitTest(ref ConvexH convex, Plane plane, float planetestepsilon)
+        {
+            int flag = 0;
+            for (int i = 0; i < convex.vertices.Count; i++)
+            {
+                flag |= PlaneTest(plane, convex.vertices[i], planetestepsilon);
+            }
+            return flag;
+        }
+
+        public static Quaternion VirtualTrackBall(float3 cop, float3 cor, float3 dir1, float3 dir2)
+        {
+            // routine taken from game programming gems.
+            // Implement track ball functionality to spin stuf on the screen
+            //  cop   center of projection
+            //  cor   center of rotation
+            //  dir1  old mouse direction
+            //  dir2  new mouse direction
+            // pretend there is a sphere around cor.  Then find the points
+            // where dir1 and dir2 intersect that sphere.  Find the
+            // rotation that takes the first point to the second.
+            float m;
+            // compute plane
+            float3 nrml = cor - cop;
+            float fudgefactor = 1.0f / (float3.magnitude(nrml) * 0.25f); // since trackball proportional to distance from cop
+            nrml = float3.normalize(nrml);
+            float dist = -float3.dot(nrml, cor);
+            float3 u = PlaneLineIntersection(new Plane(nrml, dist), cop, cop + dir1);
+            u = u - cor;
+            u = u * fudgefactor;
+            m = float3.magnitude(u);
+            if (m > 1)
+            {
+                u /= m;
+            }
+            else
+            {
+                u = u - (nrml * (float)Math.Sqrt(1 - m * m));
+            }
+            float3 v = PlaneLineIntersection(new Plane(nrml, dist), cop, cop + dir2);
+            v = v - cor;
+            v = v * fudgefactor;
+            m = float3.magnitude(v);
+            if (m > 1)
+            {
+                v /= m;
+            }
+            else
+            {
+                v = v - (nrml * (float)Math.Sqrt(1 - m * m));
+            }
+            return RotationArc(u, v);
+        }
+
+        public static bool AssertIntact(ConvexH convex, float planetestepsilon)
+        {
+            int i;
+            int estart = 0;
+            for (i = 0; i < convex.edges.Count; i++)
+            {
+                if (convex.edges[estart].p != convex.edges[i].p)
+                {
+                    estart = i;
+                }
+                int inext = i + 1;
+                if (inext >= convex.edges.Count || convex.edges[inext].p != convex.edges[i].p)
+                {
+                    inext = estart;
+                }
+                Debug.Assert(convex.edges[inext].p == convex.edges[i].p);
+                int nb = convex.edges[i].ea;
+                Debug.Assert(nb != 255);
+                if (nb == 255 || nb == -1)
+                    return false;
+                Debug.Assert(nb != -1);
+                Debug.Assert(i == convex.edges[nb].ea);
+            }
+            for (i = 0; i < convex.edges.Count; i++)
+            {
+                Debug.Assert((0) == PlaneTest(convex.facets[convex.edges[i].p], convex.vertices[convex.edges[i].v], planetestepsilon));
+                if ((0) != PlaneTest(convex.facets[convex.edges[i].p], convex.vertices[convex.edges[i].v], planetestepsilon))
+                    return false;
+                if (convex.edges[estart].p != convex.edges[i].p)
+                {
+                    estart = i;
+                }
+                int i1 = i + 1;
+                if (i1 >= convex.edges.Count || convex.edges[i1].p != convex.edges[i].p)
+                {
+                    i1 = estart;
+                }
+                int i2 = i1 + 1;
+                if (i2 >= convex.edges.Count || convex.edges[i2].p != convex.edges[i].p)
+                {
+                    i2 = estart;
+                }
+                if (i == i2) // i sliced tangent to an edge and created 2 meaningless edges
+                    continue;
+                float3 localnormal = TriNormal(convex.vertices[convex.edges[i].v], convex.vertices[convex.edges[i1].v], convex.vertices[convex.edges[i2].v]);
+                Debug.Assert(float3.dot(localnormal, convex.facets[convex.edges[i].p].normal) > 0);
+                if (float3.dot(localnormal, convex.facets[convex.edges[i].p].normal) <= 0)
+                    return false;
+            }
+            return true;
+        }
+
+        public static ConvexH test_btbq(float planetestepsilon)
+        {
+            // back to back quads
+            ConvexH convex = new ConvexH(4, 8, 2);
+            convex.vertices[0] = new float3(0, 0, 0);
+            convex.vertices[1] = new float3(1, 0, 0);
+            convex.vertices[2] = new float3(1, 1, 0);
+            convex.vertices[3] = new float3(0, 1, 0);
+            convex.facets[0] = new Plane(new float3(0, 0, 1), 0);
+            convex.facets[1] = new Plane(new float3(0, 0, -1), 0);
+            convex.edges[0] = new ConvexH.HalfEdge(7, 0, 0);
+            convex.edges[1] = new ConvexH.HalfEdge(6, 1, 0);
+            convex.edges[2] = new ConvexH.HalfEdge(5, 2, 0);
+            convex.edges[3] = new ConvexH.HalfEdge(4, 3, 0);
+
+            convex.edges[4] = new ConvexH.HalfEdge(3, 0, 1);
+            convex.edges[5] = new ConvexH.HalfEdge(2, 3, 1);
+            convex.edges[6] = new ConvexH.HalfEdge(1, 2, 1);
+            convex.edges[7] = new ConvexH.HalfEdge(0, 1, 1);
+            AssertIntact(convex, planetestepsilon);
+            return convex;
+        }
+
+        public static ConvexH test_cube()
+        {
+            ConvexH convex = new ConvexH(8, 24, 6);
+            convex.vertices[0] = new float3(0, 0, 0);
+            convex.vertices[1] = new float3(0, 0, 1);
+            convex.vertices[2] = new float3(0, 1, 0);
+            convex.vertices[3] = new float3(0, 1, 1);
+            convex.vertices[4] = new float3(1, 0, 0);
+            convex.vertices[5] = new float3(1, 0, 1);
+            convex.vertices[6] = new float3(1, 1, 0);
+            convex.vertices[7] = new float3(1, 1, 1);
+
+            convex.facets[0] = new Plane(new float3(-1, 0, 0), 0);
+            convex.facets[1] = new Plane(new float3(1, 0, 0), -1);
+            convex.facets[2] = new Plane(new float3(0, -1, 0), 0);
+            convex.facets[3] = new Plane(new float3(0, 1, 0), -1);
+            convex.facets[4] = new Plane(new float3(0, 0, -1), 0);
+            convex.facets[5] = new Plane(new float3(0, 0, 1), -1);
+
+            convex.edges[0] = new ConvexH.HalfEdge(11, 0, 0);
+            convex.edges[1] = new ConvexH.HalfEdge(23, 1, 0);
+            convex.edges[2] = new ConvexH.HalfEdge(15, 3, 0);
+            convex.edges[3] = new ConvexH.HalfEdge(16, 2, 0);
+
+            convex.edges[4] = new ConvexH.HalfEdge(13, 6, 1);
+            convex.edges[5] = new ConvexH.HalfEdge(21, 7, 1);
+            convex.edges[6] = new ConvexH.HalfEdge(9, 5, 1);
+            convex.edges[7] = new ConvexH.HalfEdge(18, 4, 1);
+
+            convex.edges[8] = new ConvexH.HalfEdge(19, 0, 2);
+            convex.edges[9] = new ConvexH.HalfEdge(6, 4, 2);
+            convex.edges[10] = new ConvexH.HalfEdge(20, 5, 2);
+            convex.edges[11] = new ConvexH.HalfEdge(0, 1, 2);
+
+            convex.edges[12] = new ConvexH.HalfEdge(22, 3, 3);
+            convex.edges[13] = new ConvexH.HalfEdge(4, 7, 3);
+            convex.edges[14] = new ConvexH.HalfEdge(17, 6, 3);
+            convex.edges[15] = new ConvexH.HalfEdge(2, 2, 3);
+
+            convex.edges[16] = new ConvexH.HalfEdge(3, 0, 4);
+            convex.edges[17] = new ConvexH.HalfEdge(14, 2, 4);
+            convex.edges[18] = new ConvexH.HalfEdge(7, 6, 4);
+            convex.edges[19] = new ConvexH.HalfEdge(8, 4, 4);
+
+            convex.edges[20] = new ConvexH.HalfEdge(10, 1, 5);
+            convex.edges[21] = new ConvexH.HalfEdge(5, 5, 5);
+            convex.edges[22] = new ConvexH.HalfEdge(12, 7, 5);
+            convex.edges[23] = new ConvexH.HalfEdge(1, 3, 5);
+
+            return convex;
+        }
+
+        public static ConvexH ConvexHMakeCube(float3 bmin, float3 bmax)
+        {
+            ConvexH convex = test_cube();
+            convex.vertices[0] = new float3(bmin.x, bmin.y, bmin.z);
+            convex.vertices[1] = new float3(bmin.x, bmin.y, bmax.z);
+            convex.vertices[2] = new float3(bmin.x, bmax.y, bmin.z);
+            convex.vertices[3] = new float3(bmin.x, bmax.y, bmax.z);
+            convex.vertices[4] = new float3(bmax.x, bmin.y, bmin.z);
+            convex.vertices[5] = new float3(bmax.x, bmin.y, bmax.z);
+            convex.vertices[6] = new float3(bmax.x, bmax.y, bmin.z);
+            convex.vertices[7] = new float3(bmax.x, bmax.y, bmax.z);
+
+            convex.facets[0] = new Plane(new float3(-1, 0, 0), bmin.x);
+            convex.facets[1] = new Plane(new float3(1, 0, 0), -bmax.x);
+            convex.facets[2] = new Plane(new float3(0, -1, 0), bmin.y);
+            convex.facets[3] = new Plane(new float3(0, 1, 0), -bmax.y);
+            convex.facets[4] = new Plane(new float3(0, 0, -1), bmin.z);
+            convex.facets[5] = new Plane(new float3(0, 0, 1), -bmax.z);
+            return convex;
+        }
+
+        public static ConvexH ConvexHCrop(ref ConvexH convex, Plane slice, float planetestepsilon)
+        {
+            int i;
+            int vertcountunder = 0;
+            int vertcountover = 0;
+            List<int> vertscoplanar = new List<int>(); // existing vertex members of convex that are coplanar
+            List<int> edgesplit = new List<int>(); // existing edges that members of convex that cross the splitplane
+
+            Debug.Assert(convex.edges.Count < 480);
+
+            EdgeFlag[] edgeflag = new EdgeFlag[512];
+            VertFlag[] vertflag = new VertFlag[256];
+            PlaneFlag[] planeflag = new PlaneFlag[128];
+            ConvexH.HalfEdge[] tmpunderedges = new ConvexH.HalfEdge[512];
+            Plane[] tmpunderplanes = new Plane[128];
+            Coplanar[] coplanaredges = new Coplanar[512];
+            int coplanaredges_num = 0;
+
+            List<float3> createdverts = new List<float3>();
+
+            // do the side-of-plane tests
+            for (i = 0; i < convex.vertices.Count; i++)
+            {
+                vertflag[i].planetest = (byte)PlaneTest(slice, convex.vertices[i], planetestepsilon);
+                if (vertflag[i].planetest == (0))
+                {
+                    // ? vertscoplanar.Add(i);
+                    vertflag[i].undermap = (byte)vertcountunder++;
+                    vertflag[i].overmap = (byte)vertcountover++;
+                }
+                else if (vertflag[i].planetest == (1))
+                {
+                    vertflag[i].undermap = (byte)vertcountunder++;
+                }
+                else
+                {
+                    Debug.Assert(vertflag[i].planetest == (2));
+                    vertflag[i].overmap = (byte)vertcountover++;
+                    vertflag[i].undermap = 255; // for debugging purposes
+                }
+            }
+            int vertcountunderold = vertcountunder; // for debugging only
+
+            int under_edge_count = 0;
+            int underplanescount = 0;
+            int e0 = 0;
+
+            for (int currentplane = 0; currentplane < convex.facets.Count; currentplane++)
+            {
+                int estart = e0;
+                int enextface = 0;
+                int planeside = 0;
+                int e1 = e0 + 1;
+                int vout = -1;
+                int vin = -1;
+                int coplanaredge = -1;
+                do
+                {
+
+                    if (e1 >= convex.edges.Count || convex.edges[e1].p != currentplane)
+                    {
+                        enextface = e1;
+                        e1 = estart;
+                    }
+                    ConvexH.HalfEdge edge0 = convex.edges[e0];
+                    ConvexH.HalfEdge edge1 = convex.edges[e1];
+                    ConvexH.HalfEdge edgea = convex.edges[edge0.ea];
+
+                    planeside |= vertflag[edge0.v].planetest;
+                    //if((vertflag[edge0.v].planetest & vertflag[edge1.v].planetest)  == COPLANAR) {
+                    //  assert(ecop==-1);
+                    //  ecop=e;
+                    //}
+
+                    if (vertflag[edge0.v].planetest == (2) && vertflag[edge1.v].planetest == (2))
+                    {
+                        // both endpoints over plane
+                        edgeflag[e0].undermap = -1;
+                    }
+                    else if ((vertflag[edge0.v].planetest | vertflag[edge1.v].planetest) == (1))
+                    {
+                        // at least one endpoint under, the other coplanar or under
+
+                        edgeflag[e0].undermap = (short)under_edge_count;
+                        tmpunderedges[under_edge_count].v = vertflag[edge0.v].undermap;
+                        tmpunderedges[under_edge_count].p = (byte)underplanescount;
+                        if (edge0.ea < e0)
+                        {
+                            // connect the neighbors
+                            Debug.Assert(edgeflag[edge0.ea].undermap != -1);
+                            tmpunderedges[under_edge_count].ea = edgeflag[edge0.ea].undermap;
+                            tmpunderedges[edgeflag[edge0.ea].undermap].ea = (short)under_edge_count;
+                        }
+                        under_edge_count++;
+                    }
+                    else if ((vertflag[edge0.v].planetest | vertflag[edge1.v].planetest) == (0))
+                    {
+                        // both endpoints coplanar 
+                        // must check a 3rd point to see if UNDER
+                        int e2 = e1 + 1;
+                        if (e2 >= convex.edges.Count || convex.edges[e2].p != currentplane)
+                        {
+                            e2 = estart;
+                        }
+                        Debug.Assert(convex.edges[e2].p == currentplane);
+                        ConvexH.HalfEdge edge2 = convex.edges[e2];
+                        if (vertflag[edge2.v].planetest == (1))
+                        {
+
+                            edgeflag[e0].undermap = (short)under_edge_count;
+                            tmpunderedges[under_edge_count].v = vertflag[edge0.v].undermap;
+                            tmpunderedges[under_edge_count].p = (byte)underplanescount;
+                            tmpunderedges[under_edge_count].ea = -1;
+                            // make sure this edge is added to the "coplanar" list
+                            coplanaredge = under_edge_count;
+                            vout = vertflag[edge0.v].undermap;
+                            vin = vertflag[edge1.v].undermap;
+                            under_edge_count++;
+                        }
+                        else
+                        {
+                            edgeflag[e0].undermap = -1;
+                        }
+                    }
+                    else if (vertflag[edge0.v].planetest == (1) && vertflag[edge1.v].planetest == (2))
+                    {
+                        // first is under 2nd is over 
+
+                        edgeflag[e0].undermap = (short)under_edge_count;
+                        tmpunderedges[under_edge_count].v = vertflag[edge0.v].undermap;
+                        tmpunderedges[under_edge_count].p = (byte)underplanescount;
+                        if (edge0.ea < e0)
+                        {
+                            Debug.Assert(edgeflag[edge0.ea].undermap != -1);
+                            // connect the neighbors
+                            tmpunderedges[under_edge_count].ea = edgeflag[edge0.ea].undermap;
+                            tmpunderedges[edgeflag[edge0.ea].undermap].ea = (short)under_edge_count;
+                            vout = tmpunderedges[edgeflag[edge0.ea].undermap].v;
+                        }
+                        else
+                        {
+                            Plane p0 = convex.facets[edge0.p];
+                            Plane pa = convex.facets[edgea.p];
+                            createdverts.Add(ThreePlaneIntersection(p0, pa, slice));
+                            //createdverts.Add(PlaneProject(slice,PlaneLineIntersection(slice,convex.vertices[edge0.v],convex.vertices[edgea.v])));
+                            //createdverts.Add(PlaneLineIntersection(slice,convex.vertices[edge0.v],convex.vertices[edgea.v]));
+                            vout = vertcountunder++;
+                        }
+                        under_edge_count++;
+                        /// hmmm something to think about: i might be able to output this edge regarless of 
+                        // wheter or not we know v-in yet.  ok i;ll try this now:
+                        tmpunderedges[under_edge_count].v = (byte)vout;
+                        tmpunderedges[under_edge_count].p = (byte)underplanescount;
+                        tmpunderedges[under_edge_count].ea = -1;
+                        coplanaredge = under_edge_count;
+                        under_edge_count++;
+
+                        if (vin != -1)
+                        {
+                            // we previously processed an edge  where we came under
+                            // now we know about vout as well
+
+                            // ADD THIS EDGE TO THE LIST OF EDGES THAT NEED NEIGHBOR ON PARTITION PLANE!!
+                        }
+
+                    }
+                    else if (vertflag[edge0.v].planetest == (0) && vertflag[edge1.v].planetest == (2))
+                    {
+                        // first is coplanar 2nd is over 
+
+                        edgeflag[e0].undermap = -1;
+                        vout = vertflag[edge0.v].undermap;
+                        // I hate this but i have to make sure part of this face is UNDER before ouputting this vert
+                        int k = estart;
+                        Debug.Assert(edge0.p == currentplane);
+                        while (!((planeside & 1) != 0) && k < convex.edges.Count && convex.edges[k].p == edge0.p)
+                        {
+                            planeside |= vertflag[convex.edges[k].v].planetest;
+                            k++;
+                        }
+                        if ((planeside & 1) != 0)
+                        {
+                            tmpunderedges[under_edge_count].v = (byte)vout;
+                            tmpunderedges[under_edge_count].p = (byte)underplanescount;
+                            tmpunderedges[under_edge_count].ea = -1;
+                            coplanaredge = under_edge_count; // hmmm should make a note of the edge # for later on
+                            under_edge_count++;
+
+                        }
+                    }
+                    else if (vertflag[edge0.v].planetest == (2) && vertflag[edge1.v].planetest == (1))
+                    {
+                        // first is over next is under 
+                        // new vertex!!!
+                        Debug.Assert(vin == -1);
+                        if (e0 < edge0.ea)
+                        {
+                            Plane p0 = convex.facets[edge0.p];
+                            Plane pa = convex.facets[edgea.p];
+                            createdverts.Add(ThreePlaneIntersection(p0, pa, slice));
+                            //createdverts.Add(PlaneLineIntersection(slice,convex.vertices[edge0.v],convex.vertices[edgea.v]));
+                            //createdverts.Add(PlaneProject(slice,PlaneLineIntersection(slice,convex.vertices[edge0.v],convex.vertices[edgea.v])));
+                            vin = vertcountunder++;
+                        }
+                        else
+                        {
+                            // find the new vertex that was created by edge[edge0.ea]
+                            int nea = edgeflag[edge0.ea].undermap;
+                            Debug.Assert(tmpunderedges[nea].p == tmpunderedges[nea + 1].p);
+                            vin = tmpunderedges[nea + 1].v;
+                            Debug.Assert(vin < vertcountunder);
+                            Debug.Assert(vin >= vertcountunderold); // for debugging only
+                        }
+                        if (vout != -1)
+                        {
+                            // we previously processed an edge  where we went over
+                            // now we know vin too
+                            // ADD THIS EDGE TO THE LIST OF EDGES THAT NEED NEIGHBOR ON PARTITION PLANE!!
+                        }
+                        // output edge
+                        tmpunderedges[under_edge_count].v = (byte)vin;
+                        tmpunderedges[under_edge_count].p = (byte)underplanescount;
+                        edgeflag[e0].undermap = (short)under_edge_count;
+                        if (e0 > edge0.ea)
+                        {
+                            Debug.Assert(edgeflag[edge0.ea].undermap != -1);
+                            // connect the neighbors
+                            tmpunderedges[under_edge_count].ea = edgeflag[edge0.ea].undermap;
+                            tmpunderedges[edgeflag[edge0.ea].undermap].ea = (short)under_edge_count;
+                        }
+                        Debug.Assert(edgeflag[e0].undermap == under_edge_count);
+                        under_edge_count++;
+                    }
+                    else if (vertflag[edge0.v].planetest == (2) && vertflag[edge1.v].planetest == (0))
+                    {
+                        // first is over next is coplanar 
+
+                        edgeflag[e0].undermap = -1;
+                        vin = vertflag[edge1.v].undermap;
+                        Debug.Assert(vin != -1);
+                        if (vout != -1)
+                        {
+                            // we previously processed an edge  where we came under
+                            // now we know both endpoints
+                            // ADD THIS EDGE TO THE LIST OF EDGES THAT NEED NEIGHBOR ON PARTITION PLANE!!
+                        }
+
+                    }
+                    else
+                    {
+                        Debug.Assert(false);
+                    }
+
+
+                    e0 = e1;
+                    e1++; // do the modulo at the beginning of the loop
+
+                } while (e0 != estart);
+                e0 = enextface;
+                if ((planeside & 1) != 0)
+                {
+                    planeflag[currentplane].undermap = (byte)underplanescount;
+                    tmpunderplanes[underplanescount] = convex.facets[currentplane];
+                    underplanescount++;
+                }
+                else
+                {
+                    planeflag[currentplane].undermap = 0;
+                }
+                if (vout >= 0 && (planeside & 1) != 0)
+                {
+                    Debug.Assert(vin >= 0);
+                    Debug.Assert(coplanaredge >= 0);
+                    Debug.Assert(coplanaredge != 511);
+                    coplanaredges[coplanaredges_num].ea = (ushort)coplanaredge;
+                    coplanaredges[coplanaredges_num].v0 = (byte)vin;
+                    coplanaredges[coplanaredges_num].v1 = (byte)vout;
+                    coplanaredges_num++;
+                }
+            }
+
+            // add the new plane to the mix:
+            if (coplanaredges_num > 0)
+            {
+                tmpunderplanes[underplanescount++] = slice;
+            }
+            for (i = 0; i < coplanaredges_num - 1; i++)
+            {
+                if (coplanaredges[i].v1 != coplanaredges[i + 1].v0)
+                {
+                    int j = 0;
+                    for (j = i + 2; j < coplanaredges_num; j++)
+                    {
+                        if (coplanaredges[i].v1 == coplanaredges[j].v0)
+                        {
+                            Coplanar tmp = coplanaredges[i + 1];
+                            coplanaredges[i + 1] = coplanaredges[j];
+                            coplanaredges[j] = tmp;
+                            break;
+                        }
+                    }
+                    if (j >= coplanaredges_num)
+                    {
+                        Debug.Assert(j < coplanaredges_num);
+                        return null;
+                    }
+                }
+            }
+
+            ConvexH punder = new ConvexH(vertcountunder, under_edge_count + coplanaredges_num, underplanescount);
+            ConvexH under = punder;
+
+            {
+                int k = 0;
+                for (i = 0; i < convex.vertices.Count; i++)
+                {
+                    if (vertflag[i].planetest != (2))
+                    {
+                        under.vertices[k++] = convex.vertices[i];
+                    }
+                }
+                i = 0;
+                while (k < vertcountunder)
+                {
+                    under.vertices[k++] = createdverts[i++];
+                }
+                Debug.Assert(i == createdverts.Count);
+            }
+
+            for (i = 0; i < coplanaredges_num; i++)
+            {
+                ConvexH.HalfEdge edge = under.edges[under_edge_count + i];
+                edge.p = (byte)(underplanescount - 1);
+                edge.ea = (short)coplanaredges[i].ea;
+                edge.v = (byte)coplanaredges[i].v0;
+                under.edges[under_edge_count + i] = edge;
+
+                tmpunderedges[coplanaredges[i].ea].ea = (short)(under_edge_count + i);
+            }
+
+            under.edges = new List<ConvexH.HalfEdge>(tmpunderedges);
+            under.facets = new List<Plane>(tmpunderplanes);
+            return punder;
+        }
+
+        public static ConvexH ConvexHDup(ConvexH src)
+        {
+            ConvexH dst = new ConvexH(src.vertices.Count, src.edges.Count, src.facets.Count);
+            dst.vertices = new List<float3>(src.vertices.Count);
+            foreach (float3 f in src.vertices)
+                dst.vertices.Add(new float3(f));
+            dst.edges = new List<ConvexH.HalfEdge>(src.edges.Count);
+            foreach (ConvexH.HalfEdge e in src.edges)
+                dst.edges.Add(new ConvexH.HalfEdge(e));
+            dst.facets = new List<Plane>(src.facets.Count);
+            foreach (Plane p in src.facets)
+                dst.facets.Add(new Plane(p));
+            return dst;
+        }
+
+        public static int candidateplane(List<Plane> planes, int planes_count, ConvexH convex, float epsilon)
+        {
+            int p = 0;
+            float md = 0;
+            int i;
+            for (i = 0; i < planes_count; i++)
+            {
+                float d = 0;
+                for (int j = 0; j < convex.vertices.Count; j++)
+                {
+                    d = Math.Max(d, float3.dot(convex.vertices[j], planes[i].normal) + planes[i].dist);
+                }
+                if (i == 0 || d > md)
+                {
+                    p = i;
+                    md = d;
+                }
+            }
+            return (md > epsilon) ? p : -1;
+        }
+
+        public static float3 orth(float3 v)
+        {
+            float3 a = float3.cross(v, new float3(0f, 0f, 1f));
+            float3 b = float3.cross(v, new float3(0f, 1f, 0f));
+            return float3.normalize((float3.magnitude(a) > float3.magnitude(b)) ? a : b);
+        }
+
+        public static int maxdir(List<float3> p, int count, float3 dir)
+        {
+            Debug.Assert(count != 0);
+            int m = 0;
+            float currDotm = float3.dot(p[0], dir);
+            for (int i = 1; i < count; i++)
+            {
+                float currDoti = float3.dot(p[i], dir);
+                if (currDoti > currDotm)
+                {
+                    currDotm = currDoti;
+                    m = i;
+                }
+            }
+            return m;
+        }
+
+        public static int maxdirfiltered(List<float3> p, int count, float3 dir, byte[] allow)
+        {
+            //Debug.Assert(count != 0);
+            int m = 0;
+            float currDotm = float3.dot(p[0], dir);
+            float currDoti;
+
+            while (allow[m] == 0)
+                m++;
+
+            for (int i = 1; i < count; i++)
+            {
+                if (allow[i] != 0)
+                {
+                    currDoti = float3.dot(p[i], dir);
+                    if (currDoti > currDotm)
+                    {
+                        currDotm = currDoti;
+                        m = i;
+                    }
+                }
+            }
+            //Debug.Assert(m != -1);
+            return m;
+        }
+
+        public static int maxdirsterid(List<float3> p, int count, float3 dir, byte[] allow)
+        {
+            int m = -1;
+            while (m == -1)
+            {
+                m = maxdirfiltered(p, count, dir, allow);
+                if (allow[m] == 3)
+                    return m;
+                float3 u = orth(dir);
+                float3 v = float3.cross(u, dir);
+                int ma = -1;
+                for (float x = 0.0f; x <= 360.0f; x += 45.0f)
+                {
+                    int mb;
+                    {
+                        float s = (float)Math.Sin((3.14159264f / 180.0f) * (x));
+                        float c = (float)Math.Cos((3.14159264f / 180.0f) * (x));
+                        mb = maxdirfiltered(p, count, dir + (u * s + v * c) * 0.025f, allow);
+                    }
+                    if (ma == m && mb == m)
+                    {
+                        allow[m] = 3;
+                        return m;
+                    }
+                    if (ma != -1 && ma != mb) // Yuck - this is really ugly
+                    {
+                        int mc = ma;
+                        for (float xx = x - 40.0f; xx <= x; xx += 5.0f)
+                        {
+                            float s = (float)Math.Sin((3.14159264f / 180.0f) * (xx));
+                            float c = (float)Math.Cos((3.14159264f / 180.0f) * (xx));
+                            int md = maxdirfiltered(p, count, dir + (u * s + v * c) * 0.025f, allow);
+                            if (mc == m && md == m)
+                            {
+                                allow[m] = 3;
+                                return m;
+                            }
+                            mc = md;
+                        }
+                    }
+                    ma = mb;
+                }
+                allow[m] = 0;
+                m = -1;
+            }
+
+            Debug.Assert(false);
+            return m;
+        }
+
+        public static int4 FindSimplex(List<float3> verts, byte[] allow)
+        {
+            float3[] basis = new float3[3];
+            basis[0] = new float3(0.01f, 0.02f, 1.0f);
+            int p0 = maxdirsterid(verts, verts.Count, basis[0], allow);
+            int p1 = maxdirsterid(verts, verts.Count, -basis[0], allow);
+            basis[0] = verts[p0] - verts[p1];
+            if (p0 == p1 || basis[0] == new float3(0, 0, 0))
+                return new int4(-1, -1, -1, -1);
+            basis[1] = float3.cross(new float3(1, 0.02f, 0), basis[0]);
+            basis[2] = float3.cross(new float3(-0.02f, 1, 0), basis[0]);
+            basis[1] = float3.normalize((float3.magnitude(basis[1]) > float3.magnitude(basis[2])) ? basis[1] : basis[2]);
+            int p2 = maxdirsterid(verts, verts.Count, basis[1], allow);
+            if (p2 == p0 || p2 == p1)
+            {
+                p2 = maxdirsterid(verts, verts.Count, -basis[1], allow);
+            }
+            if (p2 == p0 || p2 == p1)
+                return new int4(-1, -1, -1, -1);
+            basis[1] = verts[p2] - verts[p0];
+            basis[2] = float3.normalize(float3.cross(basis[1], basis[0]));
+            int p3 = maxdirsterid(verts, verts.Count, basis[2], allow);
+            if (p3 == p0 || p3 == p1 || p3 == p2)
+                p3 = maxdirsterid(verts, verts.Count, -basis[2], allow);
+            if (p3 == p0 || p3 == p1 || p3 == p2)
+                return new int4(-1, -1, -1, -1);
+            Debug.Assert(!(p0 == p1 || p0 == p2 || p0 == p3 || p1 == p2 || p1 == p3 || p2 == p3));
+            if (float3.dot(verts[p3] - verts[p0], float3.cross(verts[p1] - verts[p0], verts[p2] - verts[p0])) < 0)
+            {
+                Swap(ref p2, ref p3);
+            }
+            return new int4(p0, p1, p2, p3);
+        }
+
+        public static float GetDist(float px, float py, float pz, float3 p2)
+        {
+            float dx = px - p2.x;
+            float dy = py - p2.y;
+            float dz = pz - p2.z;
+
+            return dx * dx + dy * dy + dz * dz;
+        }
+
+        public static void ReleaseHull(PHullResult result)
+        {
+            if (result.Indices != null)
+                result.Indices = null;
+            if (result.Vertices != null)
+                result.Vertices = null;
+        }
+
+        public static int calchullgen(List<float3> verts, int vlimit, List<HullTriangle> tris)
+        {
+            if (verts.Count < 4)
+                return 0;
+            if (vlimit == 0)
+                vlimit = 1000000000;
+            int j;
+            float3 bmin = new float3(verts[0]);
+            float3 bmax = new float3(verts[0]);
+            List<int> isextreme = new List<int>(verts.Count);
+            byte[] allow = new byte[verts.Count];
+            for (j = 0; j < verts.Count; j++)
+            {
+                allow[j] = 1;
+                isextreme.Add(0);
+                bmin = float3.VectorMin(bmin, verts[j]);
+                bmax = float3.VectorMax(bmax, verts[j]);
+            }
+            float epsilon = float3.magnitude(bmax - bmin) * 0.001f;
+
+            int4 p = FindSimplex(verts, allow);
+            if (p.x == -1) // simplex failed
+                return 0;
+
+            float3 center = (verts[p[0]] + verts[p[1]] + verts[p[2]] + verts[p[3]]) / 4.0f; // a valid interior point
+            HullTriangle t0 = new HullTriangle(p[2], p[3], p[1], tris);
+            t0.n = new int3(2, 3, 1);
+            HullTriangle t1 = new HullTriangle(p[3], p[2], p[0], tris);
+            t1.n = new int3(3, 2, 0);
+            HullTriangle t2 = new HullTriangle(p[0], p[1], p[3], tris);
+            t2.n = new int3(0, 1, 3);
+            HullTriangle t3 = new HullTriangle(p[1], p[0], p[2], tris);
+            t3.n = new int3(1, 0, 2);
+            isextreme[p[0]] = isextreme[p[1]] = isextreme[p[2]] = isextreme[p[3]] = 1;
+            checkit(t0, tris);
+            checkit(t1, tris);
+            checkit(t2, tris);
+            checkit(t3, tris);
+
+            for (j = 0; j < tris.Count; j++)
+            {
+                HullTriangle t = tris[j];
+                Debug.Assert((object)t != null);
+                Debug.Assert(t.vmax < 0);
+                float3 n = TriNormal(verts[(t)[0]], verts[(t)[1]], verts[(t)[2]]);
+                t.vmax = maxdirsterid(verts, verts.Count, n, allow);
+                t.rise = float3.dot(n, verts[t.vmax] - verts[(t)[0]]);
+            }
+            HullTriangle te;
+            vlimit -= 4;
+            while (vlimit > 0 && (te = extrudable(epsilon, tris)) != null)
+            {
+                int3 ti = te;
+                int v = te.vmax;
+                Debug.Assert(isextreme[v] == 0); // wtf we've already done this vertex
+                isextreme[v] = 1;
+                //if(v==p0 || v==p1 || v==p2 || v==p3) continue; // done these already
+                j = tris.Count;
+                while (j-- != 0)
+                {
+                    if (tris.Count <= j || (object)tris[j] == null)
+                        continue;
+                    int3 t = tris[j];
+                    if (above(verts, t, verts[v], 0.01f * epsilon))
+                    {
+                        extrude(tris[j], v, tris);
+                    }
+                }
+                // now check for those degenerate cases where we have a flipped triangle or a really skinny triangle
+                j = tris.Count;
+                while (j-- != 0)
+                {
+                    if (tris.Count <= j || (object)tris[j] == null)
+                        continue;
+                    if (!hasvert(tris[j], v))
+                        break;
+                    int3 nt = tris[j];
+                    if (above(verts, nt, center, 0.01f * epsilon) || float3.magnitude(float3.cross(verts[nt[1]] - verts[nt[0]], verts[nt[2]] - verts[nt[1]])) < epsilon * epsilon * 0.1f)
+                    {
+                        HullTriangle nb = tris[tris[j].n[0]];
+                        Debug.Assert(nb != null);
+                        Debug.Assert(!hasvert(nb, v));
+                        Debug.Assert(nb.id < j);
+                        extrude(nb, v, tris);
+                        j = tris.Count;
+                    }
+                }
+                j = tris.Count;
+                while (j-- != 0)
+                {
+                    HullTriangle t = tris[j];
+                    if (t == null)
+                        continue;
+                    if (t.vmax >= 0)
+                        break;
+                    float3 n = TriNormal(verts[(t)[0]], verts[(t)[1]], verts[(t)[2]]);
+                    t.vmax = maxdirsterid(verts, verts.Count, n, allow);
+                    if (isextreme[t.vmax] != 0)
+                    {
+                        t.vmax = -1; // already done that vertex - algorithm needs to be able to terminate.
+                    }
+                    else
+                    {
+                        t.rise = float3.dot(n, verts[t.vmax] - verts[(t)[0]]);
+                    }
+                }
+                vlimit--;
+            }
+            return 1;
+        }
+
+        public static bool calchull(List<float3> verts, out List<int> tris_out, int vlimit, List<HullTriangle> tris)
+        {
+            tris_out = null;
+
+            int rc = calchullgen(verts, vlimit, tris);
+            if (rc == 0)
+                return false;
+            List<int> ts = new List<int>();
+            for (int i = 0; i < tris.Count; i++)
+            {
+                if ((object)tris[i] != null)
+                {
+                    for (int j = 0; j < 3; j++)
+                        ts.Add((tris[i])[j]);
+                    tris[i] = null;
+                }
+            }
+
+            tris_out = ts;
+            tris.Clear();
+            return true;
+        }
+
+        public static int calchullpbev(List<float3> verts, int vlimit, out List<Plane> planes, float bevangle, List<HullTriangle> tris)
+        {
+            int i;
+            int j;
+            planes = new List<Plane>();
+            int rc = calchullgen(verts, vlimit, tris);
+            if (rc == 0)
+                return 0;
+            for (i = 0; i < tris.Count; i++)
+            {
+                if (tris[i] != null)
+                {
+                    Plane p = new Plane();
+                    HullTriangle t = tris[i];
+                    p.normal = TriNormal(verts[(t)[0]], verts[(t)[1]], verts[(t)[2]]);
+                    p.dist = -float3.dot(p.normal, verts[(t)[0]]);
+                    planes.Add(p);
+                    for (j = 0; j < 3; j++)
+                    {
+                        if (t.n[j] < t.id)
+                            continue;
+                        HullTriangle s = tris[t.n[j]];
+                        float3 snormal = TriNormal(verts[(s)[0]], verts[(s)[1]], verts[(s)[2]]);
+                        if (float3.dot(snormal, p.normal) >= Math.Cos(bevangle * (3.14159264f / 180.0f)))
+                            continue;
+                        float3 n = float3.normalize(snormal + p.normal);
+                        planes.Add(new Plane(n, -float3.dot(n, verts[maxdir(verts, verts.Count, n)])));
+                    }
+                }
+            }
+
+            tris.Clear();
+            return 1;
+        }
+
+        public static int overhull(List<Plane> planes, List<float3> verts, int maxplanes, out List<float3> verts_out, out List<int> faces_out, float inflate)
+        {
+            verts_out = null;
+            faces_out = null;
+
+            int i;
+            int j;
+            if (verts.Count < 4)
+                return 0;
+            maxplanes = Math.Min(maxplanes, planes.Count);
+            float3 bmin = new float3(verts[0]);
+            float3 bmax = new float3(verts[0]);
+            for (i = 0; i < verts.Count; i++)
+            {
+                bmin = float3.VectorMin(bmin, verts[i]);
+                bmax = float3.VectorMax(bmax, verts[i]);
+            }
+            //  float diameter = magnitude(bmax-bmin);
+            //  inflate *=diameter;   // RELATIVE INFLATION
+            bmin -= new float3(inflate, inflate, inflate);
+            bmax += new float3(inflate, inflate, inflate);
+            for (i = 0; i < planes.Count; i++)
+            {
+                planes[i].dist -= inflate;
+            }
+            float3 emin = new float3(bmin);
+            float3 emax = new float3(bmax);
+            float epsilon = float3.magnitude(emax - emin) * 0.025f;
+            float planetestepsilon = float3.magnitude(emax - emin) * (0.001f);
+            // todo: add bounding cube planes to force bevel. or try instead not adding the diameter expansion ??? must think.
+            // ConvexH *convex = ConvexHMakeCube(bmin - float3(diameter,diameter,diameter),bmax+float3(diameter,diameter,diameter));
+            ConvexH c = ConvexHMakeCube(new float3(bmin), new float3(bmax));
+            int k;
+            while (maxplanes-- != 0 && (k = candidateplane(planes, planes.Count, c, epsilon)) >= 0)
+            {
+                ConvexH tmp = c;
+                c = ConvexHCrop(ref tmp, planes[k], planetestepsilon);
+                if (c == null) // might want to debug this case better!!!
+                {
+                    c = tmp;
+                    break;
+                }
+                if (AssertIntact(c, planetestepsilon) == false) // might want to debug this case better too!!!
+                {
+                    c = tmp;
+                    break;
+                }
+                tmp.edges = null;
+                tmp.facets = null;
+                tmp.vertices = null;
+            }
+
+            Debug.Assert(AssertIntact(c, planetestepsilon));
+            //return c;
+            //C++ TO C# CONVERTER TODO TASK: The memory management function 'malloc' has no equivalent in C#:
+            faces_out = new List<int>(); //(int)malloc(sizeof(int) * (1 + c.facets.Count + c.edges.Count)); // new int[1+c->facets.count+c->edges.count];
+            int faces_count_out = 0;
+            i = 0;
+            faces_out[faces_count_out++] = -1;
+            k = 0;
+            while (i < c.edges.Count)
+            {
+                j = 1;
+                while (j + i < c.edges.Count && c.edges[i].p == c.edges[i + j].p)
+                {
+                    j++;
+                }
+                faces_out[faces_count_out++] = j;
+                while (j-- != 0)
+                {
+                    faces_out[faces_count_out++] = c.edges[i].v;
+                    i++;
+                }
+                k++;
+            }
+            faces_out[0] = k; // number of faces.
+            Debug.Assert(k == c.facets.Count);
+            Debug.Assert(faces_count_out == 1 + c.facets.Count + c.edges.Count);
+            verts_out = c.vertices; // new float3[c->vertices.count];
+            int verts_count_out = c.vertices.Count;
+            for (i = 0; i < c.vertices.Count; i++)
+            {
+                verts_out[i] = new float3(c.vertices[i]);
+            }
+
+            c.edges = null;
+            c.facets = null;
+            c.vertices = null;
+            return 1;
+        }
+
+        public static int overhullv(List<float3> verts, int maxplanes, out List<float3> verts_out, out List<int> faces_out, float inflate, float bevangle, int vlimit, List<HullTriangle> tris)
+        {
+            verts_out = null;
+            faces_out = null;
+
+            if (verts.Count == 0)
+                return 0;
+            List<Plane> planes = new List<Plane>();
+            int rc = calchullpbev(verts, vlimit, out planes, bevangle, tris);
+            if (rc == 0)
+                return 0;
+            return overhull(planes, verts, maxplanes, out verts_out, out faces_out, inflate);
+        }
+
+        public static void addPoint(ref uint vcount, List<float3> p, float x, float y, float z)
+        {
+            p.Add(new float3(x, y, z));
+            vcount++;
+        }
+
+        public static bool ComputeHull(List<float3> vertices, ref PHullResult result, int vlimit, float inflate)
+        {
+            List<HullTriangle> tris = new List<HullTriangle>();
+            List<int> faces;
+            List<float3> verts_out;
+
+            if (inflate == 0.0f)
+            {
+                List<int> tris_out;
+                bool ret = calchull(vertices, out tris_out, vlimit, tris);
+                if (ret == false)
+                    return false;
+
+                result.Indices = tris_out;
+                result.Vertices = vertices;
+                return true;
+            }
+            else
+            {
+                int ret = overhullv(vertices, 35, out verts_out, out faces, inflate, 120.0f, vlimit, tris);
+                if (ret == 0)
+                    return false;
+
+                List<int3> tris2 = new List<int3>();
+                int n = faces[0];
+                int k = 1;
+                for (int i = 0; i < n; i++)
+                {
+                    int pn = faces[k++];
+                    for (int j = 2; j < pn; j++)
+                        tris2.Add(new int3(faces[k], faces[k + j - 1], faces[k + j]));
+                    k += pn;
+                }
+                Debug.Assert(tris2.Count == faces.Count - 1 - (n * 3));
+
+                result.Indices = new List<int>(tris2.Count * 3);
+                for (int i = 0; i < tris2.Count; i++)
+                {
+                    result.Indices.Add(tris2[i].x);
+                    result.Indices.Add(tris2[i].y);
+                    result.Indices.Add(tris2[i].z);
+                }
+                result.Vertices = verts_out;
+
+                return true;
+            }
+        }
+
+        private static bool CleanupVertices(List<float3> svertices, out List<float3> vertices, float normalepsilon, out float3 scale)
+        {
+            const float EPSILON = 0.000001f;
+
+            vertices = new List<float3>();
+            scale = new float3(1f, 1f, 1f);
+
+            if (svertices.Count == 0)
+                return false;
+
+            uint vcount = 0;
+
+            float[] recip = new float[3];
+
+            float[] bmin = { Single.MaxValue, Single.MaxValue, Single.MaxValue };
+            float[] bmax = { Single.MinValue, Single.MinValue, Single.MinValue };
+
+            for (int i = 0; i < svertices.Count; i++)
+            {
+                float3 p = svertices[i];
+
+                for (int j = 0; j < 3; j++)
+                {
+                    if (p[j] < bmin[j])
+                        bmin[j] = p[j];
+                    if (p[j] > bmax[j])
+                        bmax[j] = p[j];
+                }
+            }
+
+            float dx = bmax[0] - bmin[0];
+            float dy = bmax[1] - bmin[1];
+            float dz = bmax[2] - bmin[2];
+
+            float3 center = new float3();
+
+            center.x = dx * 0.5f + bmin[0];
+            center.y = dy * 0.5f + bmin[1];
+            center.z = dz * 0.5f + bmin[2];
+
+            if (dx < EPSILON || dy < EPSILON || dz < EPSILON || svertices.Count < 3)
+            {
+                float len = Single.MaxValue;
+
+                if (dx > EPSILON && dx < len)
+                    len = dx;
+                if (dy > EPSILON && dy < len)
+                    len = dy;
+                if (dz > EPSILON && dz < len)
+                    len = dz;
+
+                if (len == Single.MaxValue)
+                {
+                    dx = dy = dz = 0.01f; // one centimeter
+                }
+                else
+                {
+                    if (dx < EPSILON) // 1/5th the shortest non-zero edge.
+                        dx = len * 0.05f;
+                    if (dy < EPSILON)
+                        dy = len * 0.05f;
+                    if (dz < EPSILON)
+                        dz = len * 0.05f;
+                }
+
+                float x1 = center[0] - dx;
+                float x2 = center[0] + dx;
+
+                float y1 = center[1] - dy;
+                float y2 = center[1] + dy;
+
+                float z1 = center[2] - dz;
+                float z2 = center[2] + dz;
+
+                addPoint(ref vcount, vertices, x1, y1, z1);
+                addPoint(ref vcount, vertices, x2, y1, z1);
+                addPoint(ref vcount, vertices, x2, y2, z1);
+                addPoint(ref vcount, vertices, x1, y2, z1);
+                addPoint(ref vcount, vertices, x1, y1, z2);
+                addPoint(ref vcount, vertices, x2, y1, z2);
+                addPoint(ref vcount, vertices, x2, y2, z2);
+                addPoint(ref vcount, vertices, x1, y2, z2);
+
+                return true; // return cube     
+            }
+            else
+            {
+                scale.x = dx;
+                scale.y = dy;
+                scale.z = dz;
+
+                recip[0] = 1f / dx;
+                recip[1] = 1f / dy;
+                recip[2] = 1f / dz;
+
+                center.x *= recip[0];
+                center.y *= recip[1];
+                center.z *= recip[2];
+            }
+
+            for (int i = 0; i < svertices.Count; i++)
+            {
+                float3 p = svertices[i];
+
+                float px = p[0];
+                float py = p[1];
+                float pz = p[2];
+
+                px = px * recip[0]; // normalize
+                py = py * recip[1]; // normalize
+                pz = pz * recip[2]; // normalize
+
+                if (true)
+                {
+                    int j;
+
+                    for (j = 0; j < vcount; j++)
+                    {
+                        float3 v = vertices[j];
+
+                        float x = v[0];
+                        float y = v[1];
+                        float z = v[2];
+
+                        float dx1 = Math.Abs(x - px);
+                        float dy1 = Math.Abs(y - py);
+                        float dz1 = Math.Abs(z - pz);
+
+                        if (dx1 < normalepsilon && dy1 < normalepsilon && dz1 < normalepsilon)
+                        {
+                            // ok, it is close enough to the old one
+                            // now let us see if it is further from the center of the point cloud than the one we already recorded.
+                            // in which case we keep this one instead.
+                            float dist1 = GetDist(px, py, pz, center);
+                            float dist2 = GetDist(v[0], v[1], v[2], center);
+
+                            if (dist1 > dist2)
+                            {
+                                v.x = px;
+                                v.y = py;
+                                v.z = pz;
+                            }
+
+                            break;
+                        }
+                    }
+
+                    if (j == vcount)
+                    {
+                        float3 dest = new float3(px, py, pz);
+                        vertices.Add(dest);
+                        vcount++;
+                    }
+                }
+            }
+
+            // ok..now make sure we didn't prune so many vertices it is now invalid.
+            if (true)
+            {
+                float[] bmin2 = { Single.MaxValue, Single.MaxValue, Single.MaxValue };
+                float[] bmax2 = { Single.MinValue, Single.MinValue, Single.MinValue };
+
+                for (int i = 0; i < vcount; i++)
+                {
+                    float3 p = vertices[i];
+                    for (int j = 0; j < 3; j++)
+                    {
+                        if (p[j] < bmin2[j])
+                            bmin2[j] = p[j];
+                        if (p[j] > bmax2[j])
+                            bmax2[j] = p[j];
+                    }
+                }
+
+                float dx2 = bmax2[0] - bmin2[0];
+                float dy2 = bmax2[1] - bmin2[1];
+                float dz2 = bmax2[2] - bmin2[2];
+
+                if (dx2 < EPSILON || dy2 < EPSILON || dz2 < EPSILON || vcount < 3)
+                {
+                    float cx = dx2 * 0.5f + bmin2[0];
+                    float cy = dy2 * 0.5f + bmin2[1];
+                    float cz = dz2 * 0.5f + bmin2[2];
+
+                    float len = Single.MaxValue;
+
+                    if (dx2 >= EPSILON && dx2 < len)
+                        len = dx2;
+                    if (dy2 >= EPSILON && dy2 < len)
+                        len = dy2;
+                    if (dz2 >= EPSILON && dz2 < len)
+                        len = dz2;
+
+                    if (len == Single.MaxValue)
+                    {
+                        dx2 = dy2 = dz2 = 0.01f; // one centimeter
+                    }
+                    else
+                    {
+                        if (dx2 < EPSILON) // 1/5th the shortest non-zero edge.
+                            dx2 = len * 0.05f;
+                        if (dy2 < EPSILON)
+                            dy2 = len * 0.05f;
+                        if (dz2 < EPSILON)
+                            dz2 = len * 0.05f;
+                    }
+
+                    float x1 = cx - dx2;
+                    float x2 = cx + dx2;
+
+                    float y1 = cy - dy2;
+                    float y2 = cy + dy2;
+
+                    float z1 = cz - dz2;
+                    float z2 = cz + dz2;
+
+                    vcount = 0; // add box
+
+                    addPoint(ref vcount, vertices, x1, y1, z1);
+                    addPoint(ref vcount, vertices, x2, y1, z1);
+                    addPoint(ref vcount, vertices, x2, y2, z1);
+                    addPoint(ref vcount, vertices, x1, y2, z1);
+                    addPoint(ref vcount, vertices, x1, y1, z2);
+                    addPoint(ref vcount, vertices, x2, y1, z2);
+                    addPoint(ref vcount, vertices, x2, y2, z2);
+                    addPoint(ref vcount, vertices, x1, y2, z2);
+
+                    return true;
+                }
+            }
+
+            return true;
+        }
+
+        private static void BringOutYourDead(List<float3> verts, out List<float3> overts, List<int> indices)
+        {
+            int[] used = new int[verts.Count];
+            int ocount = 0;
+
+            overts = new List<float3>();
+
+            for (int i = 0; i < indices.Count; i++)
+            {
+                int v = indices[i]; // original array index
+
+                Debug.Assert(v >= 0 && v < verts.Count);
+
+                if (used[v] != 0) // if already remapped
+                {
+                    indices[i] = used[v] - 1; // index to new array
+                }
+                else
+                {
+                    indices[i] = ocount; // new index mapping
+
+                    overts.Add(verts[v]); // copy old vert to new vert array
+
+                    ocount++; // increment output vert count
+
+                    Debug.Assert(ocount >= 0 && ocount <= verts.Count);
+
+                    used[v] = ocount; // assign new index remapping
+                }
+            }
+        }
+
+        public static HullError CreateConvexHull(HullDesc desc, ref HullResult result)
+        {
+            HullError ret = HullError.QE_FAIL;
+
+            PHullResult hr = new PHullResult();
+
+            uint vcount = (uint)desc.Vertices.Count;
+            if (vcount < 8)
+                vcount = 8;
+
+            List<float3> vsource;
+            float3 scale = new float3();
+
+            bool ok = CleanupVertices(desc.Vertices, out vsource, desc.NormalEpsilon, out scale); // normalize point cloud, remove duplicates!
+
+            if (ok)
+            {
+                if (true) // scale vertices back to their original size.
+                {
+                    for (int i = 0; i < vsource.Count; i++)
+                    {
+                        float3 v = vsource[i];
+                        v.x *= scale[0];
+                        v.y *= scale[1];
+                        v.z *= scale[2];
+                    }
+                }
+
+                float skinwidth = 0;
+                if (desc.HasHullFlag(HullFlag.QF_SKIN_WIDTH))
+                    skinwidth = desc.SkinWidth;
+
+                ok = ComputeHull(vsource, ref hr, (int)desc.MaxVertices, skinwidth);
+
+                if (ok)
+                {
+                    List<float3> vscratch;
+                    BringOutYourDead(hr.Vertices, out vscratch, hr.Indices);
+
+                    ret = HullError.QE_OK;
+
+                    if (desc.HasHullFlag(HullFlag.QF_TRIANGLES)) // if he wants the results as triangle!
+                    {
+                        result.Polygons = false;
+                        result.Indices = hr.Indices;
+                        result.OutputVertices = vscratch;
+                    }
+                    else
+                    {
+                        result.Polygons = true;
+                        result.OutputVertices = vscratch;
+
+                        if (true)
+                        {
+                            List<int> source = hr.Indices;
+                            List<int> dest = new List<int>();
+                            for (int i = 0; i < hr.Indices.Count / 3; i++)
+                            {
+                                dest.Add(3);
+                                dest.Add(source[i * 3 + 0]);
+                                dest.Add(source[i * 3 + 1]);
+                                dest.Add(source[i * 3 + 2]);
+                            }
+
+                            result.Indices = dest;
+                        }
+                    }
+                }
+            }
+
+            return ret;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/LICENSE.txt b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/LICENSE.txt
new file mode 100644
index 0000000..714ae89
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/LICENSE.txt
@@ -0,0 +1,28 @@
+ConvexDecompositionDotNet
+-------------------------
+
+The MIT License
+
+Copyright (c) 2010 Intel Corporation.
+All rights reserved.
+
+Based on the convexdecomposition library from 
+<http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Plane.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Plane.cs
new file mode 100644
index 0000000..da9ae0c
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Plane.cs
@@ -0,0 +1,99 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class Plane
+    {
+        public float3 normal = new float3();
+        public float dist; // distance below origin - the D from plane equasion Ax+By+Cz+D=0
+
+        public Plane(float3 n, float d)
+        {
+            normal = new float3(n);
+            dist = d;
+        }
+
+        public Plane(Plane p)
+        {
+            normal = new float3(p.normal);
+            dist = p.dist;
+        }
+
+        public Plane()
+        {
+            dist = 0;
+        }
+
+        public void Transform(float3 position, Quaternion orientation)
+        {
+            //   Transforms the plane to the space defined by the
+            //   given position/orientation
+            float3 newNormal = Quaternion.Inverse(orientation) * normal;
+            float3 origin = Quaternion.Inverse(orientation) * (-normal * dist - position);
+
+            normal = newNormal;
+            dist = -float3.dot(newNormal, origin);
+        }
+
+        public override int GetHashCode()
+        {
+            return normal.GetHashCode() ^ dist.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            Plane p = obj as Plane;
+            if (p == null)
+                return false;
+
+            return this == p;
+        }
+
+        public static bool operator ==(Plane a, Plane b)
+        {
+            return (a.normal == b.normal && a.dist == b.dist);
+        }
+
+        public static bool operator !=(Plane a, Plane b)
+        {
+            return !(a == b);
+        }
+
+        public static Plane PlaneFlip(Plane plane)
+        {
+            return new Plane(-plane.normal, -plane.dist);
+        }
+
+        public static bool coplanar(Plane a, Plane b)
+        {
+            return (a == b || a == PlaneFlip(b));
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/PlaneTri.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/PlaneTri.cs
new file mode 100644
index 0000000..42f7a22
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/PlaneTri.cs
@@ -0,0 +1,211 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public enum PlaneTriResult : int
+    {
+        PTR_FRONT,
+        PTR_BACK,
+        PTR_SPLIT
+    }
+
+    public static class PlaneTri
+    {
+        private static float DistToPt(float3 p, float4 plane)
+        {
+            return p.x * plane.x + p.y * plane.y + p.z * plane.z + plane.w;
+        }
+
+        private static PlaneTriResult getSidePlane(float3 p, float4 plane, float epsilon)
+        {
+            float d = DistToPt(p, plane);
+
+            if ((d + epsilon) > 0f)
+                return PlaneTriResult.PTR_FRONT; // it is 'in front' within the provided epsilon value.
+
+            return PlaneTriResult.PTR_BACK;
+        }
+
+        private static void add(float3 p, float3[] dest, ref int pcount)
+        {
+            dest[pcount++] = new float3(p);
+            Debug.Assert(pcount <= 4);
+        }
+
+        // assumes that the points are on opposite sides of the plane!
+        private static void intersect(float3 p1, float3 p2, float3 split, float4 plane)
+        {
+            float dp1 = DistToPt(p1, plane);
+            float[] dir = new float[3];
+
+            dir[0] = p2[0] - p1[0];
+            dir[1] = p2[1] - p1[1];
+            dir[2] = p2[2] - p1[2];
+
+            float dot1 = dir[0] * plane[0] + dir[1] * plane[1] + dir[2] * plane[2];
+            float dot2 = dp1 - plane[3];
+
+            float t = -(plane[3] + dot2) / dot1;
+
+            split.x = (dir[0] * t) + p1[0];
+            split.y = (dir[1] * t) + p1[1];
+            split.z = (dir[2] * t) + p1[2];
+        }
+
+        public static PlaneTriResult planeTriIntersection(float4 plane, FaceTri triangle, float epsilon, ref float3[] front, out int fcount, ref float3[] back, out int bcount)
+        {
+            fcount = 0;
+            bcount = 0;
+
+            // get the three vertices of the triangle.
+            float3 p1 = triangle.P1;
+            float3 p2 = triangle.P2;
+            float3 p3 = triangle.P3;
+
+            PlaneTriResult r1 = getSidePlane(p1, plane, epsilon); // compute the side of the plane each vertex is on
+            PlaneTriResult r2 = getSidePlane(p2, plane, epsilon);
+            PlaneTriResult r3 = getSidePlane(p3, plane, epsilon);
+
+            if (r1 == r2 && r1 == r3) // if all three vertices are on the same side of the plane.
+            {
+                if (r1 == PlaneTriResult.PTR_FRONT) // if all three are in front of the plane, then copy to the 'front' output triangle.
+                {
+                    add(p1, front, ref fcount);
+                    add(p2, front, ref fcount);
+                    add(p3, front, ref fcount);
+                }
+                else
+                {
+                    add(p1, back, ref bcount); // if all three are in 'back' then copy to the 'back' output triangle.
+                    add(p2, back, ref bcount);
+                    add(p3, back, ref bcount);
+                }
+                return r1; // if all three points are on the same side of the plane return result
+            }
+
+            // ok.. we need to split the triangle at the plane.
+
+            // First test ray segment P1 to P2
+            if (r1 == r2) // if these are both on the same side...
+            {
+                if (r1 == PlaneTriResult.PTR_FRONT)
+                {
+                    add(p1, front, ref fcount);
+                    add(p2, front, ref fcount);
+                }
+                else
+                {
+                    add(p1, back, ref bcount);
+                    add(p2, back, ref bcount);
+                }
+            }
+            else
+            {
+                float3 split = new float3();
+                intersect(p1, p2, split, plane);
+
+                if (r1 == PlaneTriResult.PTR_FRONT)
+                {
+
+                    add(p1, front, ref fcount);
+                    add(split, front, ref fcount);
+
+                    add(split, back, ref bcount);
+                    add(p2, back, ref bcount);
+
+                }
+                else
+                {
+                    add(p1, back, ref bcount);
+                    add(split, back, ref bcount);
+
+                    add(split, front, ref fcount);
+                    add(p2, front, ref fcount);
+                }
+
+            }
+
+            // Next test ray segment P2 to P3
+            if (r2 == r3) // if these are both on the same side...
+            {
+                if (r3 == PlaneTriResult.PTR_FRONT)
+                {
+                    add(p3, front, ref fcount);
+                }
+                else
+                {
+                    add(p3, back, ref bcount);
+                }
+            }
+            else
+            {
+                float3 split = new float3(); // split the point
+                intersect(p2, p3, split, plane);
+
+                if (r3 == PlaneTriResult.PTR_FRONT)
+                {
+                    add(split, front, ref fcount);
+                    add(split, back, ref bcount);
+
+                    add(p3, front, ref fcount);
+                }
+                else
+                {
+                    add(split, front, ref fcount);
+                    add(split, back, ref bcount);
+
+                    add(p3, back, ref bcount);
+                }
+            }
+
+            // Next test ray segment P3 to P1
+            if (r3 != r1) // if these are both on the same side...
+            {
+                float3 split = new float3(); // split the point
+                intersect(p3, p1, split, plane);
+
+                if (r1 == PlaneTriResult.PTR_FRONT)
+                {
+                    add(split, front, ref fcount);
+                    add(split, back, ref bcount);
+                }
+                else
+                {
+                    add(split, front, ref fcount);
+                    add(split, back, ref bcount);
+                }
+            }
+
+            return PlaneTriResult.PTR_SPLIT;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..c5867b2
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ConvexDecompositionDotNet")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Intel Corporation")]
+[assembly: AssemblyProduct("ConvexDecompositionDotNet")]
+[assembly: AssemblyCopyright("Copyright © Intel Corporation 2010")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("2a1c9467-1a17-4c8d-bf9f-4b4d86dd0cbb")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("0.8.2.*")]
+
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Quaternion.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Quaternion.cs
new file mode 100644
index 0000000..045f620
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Quaternion.cs
@@ -0,0 +1,209 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class Quaternion : float4
+    {
+        public Quaternion()
+        {
+            x = y = z = 0.0f;
+            w = 1.0f;
+        }
+
+        public Quaternion(float3 v, float t)
+        {
+            v = float3.normalize(v);
+            w = (float)Math.Cos(t / 2.0f);
+            v = v * (float)Math.Sin(t / 2.0f);
+            x = v.x;
+            y = v.y;
+            z = v.z;
+        }
+
+        public Quaternion(float _x, float _y, float _z, float _w)
+        {
+            x = _x;
+            y = _y;
+            z = _z;
+            w = _w;
+        }
+
+        public float angle()
+        {
+            return (float)Math.Acos(w) * 2.0f;
+        }
+
+        public float3 axis()
+        {
+            float3 a = new float3(x, y, z);
+            if (Math.Abs(angle()) < 0.0000001f)
+                return new float3(1f, 0f, 0f);
+            return a * (1 / (float)Math.Sin(angle() / 2.0f));
+        }
+
+        public float3 xdir()
+        {
+            return new float3(1 - 2 * (y * y + z * z), 2 * (x * y + w * z), 2 * (x * z - w * y));
+        }
+
+        public float3 ydir()
+        {
+            return new float3(2 * (x * y - w * z), 1 - 2 * (x * x + z * z), 2 * (y * z + w * x));
+        }
+
+        public float3 zdir()
+        {
+            return new float3(2 * (x * z + w * y), 2 * (y * z - w * x), 1 - 2 * (x * x + y * y));
+        }
+
+        public float3x3 getmatrix()
+        {
+            return new float3x3(xdir(), ydir(), zdir());
+        }
+
+        public static implicit operator float3x3(Quaternion q)
+        {
+            return q.getmatrix();
+        }
+
+        public static Quaternion operator *(Quaternion a, Quaternion b)
+        {
+            Quaternion c = new Quaternion();
+            c.w = a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z;
+            c.x = a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y;
+            c.y = a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x;
+            c.z = a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w;
+            return c;
+        }
+
+        public static float3 operator *(Quaternion q, float3 v)
+        {
+            // The following is equivalent to:
+            //return (q.getmatrix() * v);
+            float qx2 = q.x * q.x;
+            float qy2 = q.y * q.y;
+            float qz2 = q.z * q.z;
+
+            float qxqy = q.x * q.y;
+            float qxqz = q.x * q.z;
+            float qxqw = q.x * q.w;
+            float qyqz = q.y * q.z;
+            float qyqw = q.y * q.w;
+            float qzqw = q.z * q.w;
+            return new float3((1 - 2 * (qy2 + qz2)) * v.x + (2 * (qxqy - qzqw)) * v.y + (2 * (qxqz + qyqw)) * v.z, (2 * (qxqy + qzqw)) * v.x + (1 - 2 * (qx2 + qz2)) * v.y + (2 * (qyqz - qxqw)) * v.z, (2 * (qxqz - qyqw)) * v.x + (2 * (qyqz + qxqw)) * v.y + (1 - 2 * (qx2 + qy2)) * v.z);
+        }
+
+        public static Quaternion operator +(Quaternion a, Quaternion b)
+        {
+            return new Quaternion(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
+        }
+
+        public static Quaternion operator *(Quaternion a, float b)
+            {
+                    return new Quaternion(a.x *b, a.y *b, a.z *b, a.w *b);
+            }
+
+        public static Quaternion normalize(Quaternion a)
+        {
+            float m = (float)Math.Sqrt(a.w * a.w + a.x * a.x + a.y * a.y + a.z * a.z);
+            if (m < 0.000000001f)
+            {
+                a.w = 1;
+                a.x = a.y = a.z = 0;
+                return a;
+            }
+            return a * (1f / m);
+        }
+
+        public static float dot(Quaternion a, Quaternion b)
+        {
+            return (a.w * b.w + a.x * b.x + a.y * b.y + a.z * b.z);
+        }
+
+        public static Quaternion slerp(Quaternion a, Quaternion b, float interp)
+        {
+            if (dot(a, b) < 0.0)
+            {
+                a.w = -a.w;
+                a.x = -a.x;
+                a.y = -a.y;
+                a.z = -a.z;
+            }
+            float d = dot(a, b);
+            if (d >= 1.0)
+            {
+                return a;
+            }
+            float theta = (float)Math.Acos(d);
+            if (theta == 0.0f)
+            {
+                return (a);
+            }
+            return a * ((float)Math.Sin(theta - interp * theta) / (float)Math.Sin(theta)) + b * ((float)Math.Sin(interp * theta) / (float)Math.Sin(theta));
+        }
+
+        public static Quaternion Interpolate(Quaternion q0, Quaternion q1, float alpha)
+        {
+            return slerp(q0, q1, alpha);
+        }
+
+        public static Quaternion Inverse(Quaternion q)
+        {
+            return new Quaternion(-q.x, -q.y, -q.z, q.w);
+        }
+
+        public static Quaternion YawPitchRoll(float yaw, float pitch, float roll)
+        {
+            roll *= (3.14159264f / 180.0f);
+            yaw *= (3.14159264f / 180.0f);
+            pitch *= (3.14159264f / 180.0f);
+            return new Quaternion(new float3(0.0f, 0.0f, 1.0f), yaw) * new Quaternion(new float3(1.0f, 0.0f, 0.0f), pitch) * new Quaternion(new float3(0.0f, 1.0f, 0.0f), roll);
+        }
+
+        public static float Yaw(Quaternion q)
+        {
+            float3 v = q.ydir();
+            return (v.y == 0.0 && v.x == 0.0) ? 0.0f : (float)Math.Atan2(-v.x, v.y) * (180.0f / 3.14159264f);
+        }
+
+        public static float Pitch(Quaternion q)
+        {
+            float3 v = q.ydir();
+            return (float)Math.Atan2(v.z, Math.Sqrt(v.x * v.x + v.y * v.y)) * (180.0f / 3.14159264f);
+        }
+
+        public static float Roll(Quaternion q)
+        {
+            q = new Quaternion(new float3(0.0f, 0.0f, 1.0f), -Yaw(q) * (3.14159264f / 180.0f)) * q;
+            q = new Quaternion(new float3(1.0f, 0.0f, 0.0f), -Pitch(q) * (3.14159264f / 180.0f)) * q;
+            return (float)Math.Atan2(-q.xdir().z, q.xdir().x) * (180.0f / 3.14159264f);
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/README.txt b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/README.txt
new file mode 100644
index 0000000..fc53ae7
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/README.txt
@@ -0,0 +1,7 @@
+ConvexDecompositionDotNet
+=========================
+
+A C# port of the ConvexDecomposition library by John W. Ratcliff and Stan Melax. 
+The original C++ version is available at <http://codesuppository.googlecode.com/>. 
+See the blog post at <http://codesuppository.blogspot.com/2006/08/approximate-convexdecomposition.html> 
+for a thorough explanation of generating convex hulls from concave meshes.
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/SplitPlane.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/SplitPlane.cs
new file mode 100644
index 0000000..9f56bc5
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/SplitPlane.cs
@@ -0,0 +1,265 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class Rect3d
+    {
+        public float[] mMin = new float[3];
+        public float[] mMax = new float[3];
+
+        public Rect3d()
+        {
+        }
+
+        public Rect3d(float[] bmin, float[] bmax)
+        {
+            mMin[0] = bmin[0];
+            mMin[1] = bmin[1];
+            mMin[2] = bmin[2];
+
+            mMax[0] = bmax[0];
+            mMax[1] = bmax[1];
+            mMax[2] = bmax[2];
+        }
+
+        public void SetMin(float[] bmin)
+        {
+            mMin[0] = bmin[0];
+            mMin[1] = bmin[1];
+            mMin[2] = bmin[2];
+        }
+
+        public void SetMax(float[] bmax)
+        {
+            mMax[0] = bmax[0];
+            mMax[1] = bmax[1];
+            mMax[2] = bmax[2];
+        }
+
+        public void SetMin(float x, float y, float z)
+        {
+            mMin[0] = x;
+            mMin[1] = y;
+            mMin[2] = z;
+        }
+
+        public void SetMax(float x, float y, float z)
+        {
+            mMax[0] = x;
+            mMax[1] = y;
+            mMax[2] = z;
+        }
+    }
+
+    public static class SplitPlane
+    {
+        public static bool computeSplitPlane(List<float3> vertices, List<int> indices, ref float4 plane)
+        {
+            float[] bmin = { Single.MaxValue, Single.MaxValue, Single.MaxValue };
+            float[] bmax = { Single.MinValue, Single.MinValue, Single.MinValue };
+
+            for (int i = 0; i < vertices.Count; i++)
+            {
+                float3 p = vertices[i];
+
+                if (p[0] < bmin[0])
+                    bmin[0] = p[0];
+                if (p[1] < bmin[1])
+                    bmin[1] = p[1];
+                if (p[2] < bmin[2])
+                    bmin[2] = p[2];
+
+                if (p[0] > bmax[0])
+                    bmax[0] = p[0];
+                if (p[1] > bmax[1])
+                    bmax[1] = p[1];
+                if (p[2] > bmax[2])
+                    bmax[2] = p[2];
+            }
+
+            float dx = bmax[0] - bmin[0];
+            float dy = bmax[1] - bmin[1];
+            float dz = bmax[2] - bmin[2];
+
+            float laxis = dx;
+
+            int axis = 0;
+
+            if (dy > dx)
+            {
+                axis = 1;
+                laxis = dy;
+            }
+
+            if (dz > dx && dz > dy)
+            {
+                axis = 2;
+                laxis = dz;
+            }
+
+            float[] p1 = new float[3];
+            float[] p2 = new float[3];
+            float[] p3 = new float[3];
+
+            p3[0] = p2[0] = p1[0] = bmin[0] + dx * 0.5f;
+            p3[1] = p2[1] = p1[1] = bmin[1] + dy * 0.5f;
+            p3[2] = p2[2] = p1[2] = bmin[2] + dz * 0.5f;
+
+            Rect3d b = new Rect3d(bmin, bmax);
+
+            Rect3d b1 = new Rect3d();
+            Rect3d b2 = new Rect3d();
+
+            splitRect(axis, b, b1, b2, p1);
+
+            switch (axis)
+            {
+                case 0:
+                    p2[1] = bmin[1];
+                    p2[2] = bmin[2];
+
+                    if (dz > dy)
+                    {
+                        p3[1] = bmax[1];
+                        p3[2] = bmin[2];
+                    }
+                    else
+                    {
+                        p3[1] = bmin[1];
+                        p3[2] = bmax[2];
+                    }
+
+                    break;
+                case 1:
+                    p2[0] = bmin[0];
+                    p2[2] = bmin[2];
+
+                    if (dx > dz)
+                    {
+                        p3[0] = bmax[0];
+                        p3[2] = bmin[2];
+                    }
+                    else
+                    {
+                        p3[0] = bmin[0];
+                        p3[2] = bmax[2];
+                    }
+
+                    break;
+                case 2:
+                    p2[0] = bmin[0];
+                    p2[1] = bmin[1];
+
+                    if (dx > dy)
+                    {
+                        p3[0] = bmax[0];
+                        p3[1] = bmin[1];
+                    }
+                    else
+                    {
+                        p3[0] = bmin[0];
+                        p3[1] = bmax[1];
+                    }
+
+                    break;
+            }
+
+            computePlane(p1, p2, p3, plane);
+
+            return true;
+        }
+
+        internal static void computePlane(float[] A, float[] B, float[] C, float4 plane)
+        {
+            float vx = (B[0] - C[0]);
+            float vy = (B[1] - C[1]);
+            float vz = (B[2] - C[2]);
+
+            float wx = (A[0] - B[0]);
+            float wy = (A[1] - B[1]);
+            float wz = (A[2] - B[2]);
+
+            float vw_x = vy * wz - vz * wy;
+            float vw_y = vz * wx - vx * wz;
+            float vw_z = vx * wy - vy * wx;
+
+            float mag = (float)Math.Sqrt((vw_x * vw_x) + (vw_y * vw_y) + (vw_z * vw_z));
+
+            if (mag < 0.000001f)
+            {
+                mag = 0;
+            }
+            else
+            {
+                mag = 1.0f / mag;
+            }
+
+            float x = vw_x * mag;
+            float y = vw_y * mag;
+            float z = vw_z * mag;
+
+            float D = 0.0f - ((x * A[0]) + (y * A[1]) + (z * A[2]));
+
+            plane.x = x;
+            plane.y = y;
+            plane.z = z;
+            plane.w = D;
+        }
+
+        public static void splitRect(int axis, Rect3d source, Rect3d b1, Rect3d b2, float[] midpoint)
+        {
+            switch (axis)
+            {
+                case 0:
+                    b1.SetMin(source.mMin);
+                    b1.SetMax(midpoint[0], source.mMax[1], source.mMax[2]);
+
+                    b2.SetMin(midpoint[0], source.mMin[1], source.mMin[2]);
+                    b2.SetMax(source.mMax);
+                    break;
+                case 1:
+                    b1.SetMin(source.mMin);
+                    b1.SetMax(source.mMax[0], midpoint[1], source.mMax[2]);
+
+                    b2.SetMin(source.mMin[0], midpoint[1], source.mMin[2]);
+                    b2.SetMax(source.mMax);
+                    break;
+                case 2:
+                    b1.SetMin(source.mMin);
+                    b1.SetMax(source.mMax[0], source.mMax[1], midpoint[2]);
+
+                    b2.SetMin(source.mMin[0], source.mMin[1], midpoint[2]);
+                    b2.SetMax(source.mMax);
+                    break;
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/VertexLookup.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/VertexLookup.cs
new file mode 100644
index 0000000..bfe11e5
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/VertexLookup.cs
@@ -0,0 +1,70 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class VertexPool
+    {
+        private List<float3> mVertices = new List<float3>();
+        private Dictionary<float3, int> mIndices = new Dictionary<float3, int>();
+
+        public int getIndex(float3 vtx)
+        {
+            int idx;
+            if (mIndices.TryGetValue(vtx, out idx))
+                return idx;
+
+            idx = mVertices.Count;
+            mVertices.Add(vtx);
+            mIndices.Add(vtx, idx);
+            return idx;
+        }
+
+        public float3 Get(int idx)
+        {
+            return mVertices[idx];
+        }
+
+        public int GetSize()
+        {
+            return mVertices.Count;
+        }
+
+        public List<float3> GetVertices()
+        {
+            return mVertices;
+        }
+
+        public void Clear()
+        {
+            mVertices.Clear();
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float2.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float2.cs
new file mode 100644
index 0000000..e7358c1
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float2.cs
@@ -0,0 +1,70 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class float2
+    {
+        public float x;
+        public float y;
+
+        public float2()
+        {
+        }
+
+        public float2(float _x, float _y)
+        {
+            x = _x;
+            y = _y;
+        }
+
+        public float this[int i]
+        {
+            get
+            {
+                switch (i)
+                {
+                    case 0: return x;
+                    case 1: return y;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public static float2 operator -(float2 a, float2 b)
+        {
+            return new float2(a.x - b.x, a.y - b.y);
+        }
+
+        public static float2 operator +(float2 a, float2 b)
+        {
+            return new float2(a.x + b.x, a.y + b.y);
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3.cs
new file mode 100644
index 0000000..fde9b32
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3.cs
@@ -0,0 +1,444 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class float3 : IEquatable<float3>
+    {
+        public float x;
+        public float y;
+        public float z;
+
+        public float3()
+        {
+            x = 0;
+            y = 0;
+            z = 0;
+        }
+
+        public float3(float _x, float _y, float _z)
+        {
+            x = _x;
+            y = _y;
+            z = _z;
+        }
+
+        public float3(float3 f)
+        {
+            x = f.x;
+            y = f.y;
+            z = f.z;
+        }
+
+        public float this[int i]
+        {
+            get
+            {
+                switch (i)
+                {
+                    case 0: return x;
+                    case 1: return y;
+                    case 2: return z;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public float Distance(float3 a)
+        {
+            float3 d = new float3(a.x - x, a.y - y, a.z - z);
+            return d.Length();
+        }
+
+        public float Distance2(float3 a)
+        {
+            float dx = a.x - x;
+            float dy = a.y - y;
+            float dz = a.z - z;
+            return dx * dx + dy * dy + dz * dz;
+        }
+
+        public float Length()
+        {
+            return (float)Math.Sqrt(x * x + y * y + z * z);
+        }
+
+        public float Area(float3 p1, float3 p2)
+        {
+            float A = Partial(p1);
+            A += p1.Partial(p2);
+            A += p2.Partial(this);
+            return A * 0.5f;
+        }
+
+        public float Partial(float3 p)
+        {
+            return (x * p.y) - (p.x * y);
+        }
+
+        // Given a point and a line (defined by two points), compute the closest point
+        // in the line.  (The line is treated as infinitely long.)
+        public void NearestPointInLine(float3 point, float3 line0, float3 line1)
+        {
+            float3 nearestPoint = new float3();
+            float3 lineDelta = line1 - line0;
+
+            // Handle degenerate lines
+            if (lineDelta == float3.Zero)
+            {
+                nearestPoint = line0;
+            }
+            else
+            {
+                float delta = float3.dot(point - line0, lineDelta) / float3.dot(lineDelta, lineDelta);
+                nearestPoint = line0 + lineDelta * delta;
+            }
+
+            this.x = nearestPoint.x;
+            this.y = nearestPoint.y;
+            this.z = nearestPoint.z;
+        }
+
+        // Given a point and a line segment (defined by two points), compute the closest point
+        // in the line.  Cap the point at the endpoints of the line segment.
+        public void NearestPointInLineSegment(float3 point, float3 line0, float3 line1)
+        {
+            float3 nearestPoint = new float3();
+            float3 lineDelta = line1 - line0;
+
+            // Handle degenerate lines
+            if (lineDelta == Zero)
+            {
+                nearestPoint = line0;
+            }
+            else
+            {
+                float delta = float3.dot(point - line0, lineDelta) / float3.dot(lineDelta, lineDelta);
+
+                // Clamp the point to conform to the segment's endpoints
+                if (delta < 0)
+                    delta = 0;
+                else if (delta > 1)
+                    delta = 1;
+
+                nearestPoint = line0 + lineDelta * delta;
+            }
+
+            this.x = nearestPoint.x;
+            this.y = nearestPoint.y;
+            this.z = nearestPoint.z;
+        }
+
+        // Given a point and a triangle (defined by three points), compute the closest point
+        // in the triangle.  Clamp the point so it's confined to the area of the triangle.
+        public void NearestPointInTriangle(float3 point, float3 triangle0, float3 triangle1, float3 triangle2)
+        {
+            float3 nearestPoint = new float3();
+
+            float3 lineDelta0 = triangle1 - triangle0;
+            float3 lineDelta1 = triangle2 - triangle0;
+
+            // Handle degenerate triangles
+            if ((lineDelta0 == Zero) || (lineDelta1 == Zero))
+            {
+                nearestPoint.NearestPointInLineSegment(point, triangle1, triangle2);
+            }
+            else if (lineDelta0 == lineDelta1)
+            {
+                nearestPoint.NearestPointInLineSegment(point, triangle0, triangle1);
+            }
+            else
+            {
+                float3[] axis = new float3[3] { new float3(), new float3(), new float3() };
+                axis[0].NearestPointInLine(triangle0, triangle1, triangle2);
+                axis[1].NearestPointInLine(triangle1, triangle0, triangle2);
+                axis[2].NearestPointInLine(triangle2, triangle0, triangle1);
+
+                float3 axisDot = new float3();
+                axisDot.x = dot(triangle0 - axis[0], point - axis[0]);
+                axisDot.y = dot(triangle1 - axis[1], point - axis[1]);
+                axisDot.z = dot(triangle2 - axis[2], point - axis[2]);
+
+                bool bForce = true;
+                float bestMagnitude2 = 0;
+                float closeMagnitude2;
+                float3 closePoint = new float3();
+
+                if (axisDot.x < 0f)
+                {
+                    closePoint.NearestPointInLineSegment(point, triangle1, triangle2);
+                    closeMagnitude2 = point.Distance2(closePoint);
+                    if (bForce || (bestMagnitude2 > closeMagnitude2))
+                    {
+                        bForce = false;
+                        bestMagnitude2 = closeMagnitude2;
+                        nearestPoint = closePoint;
+                    }
+                }
+                if (axisDot.y < 0f)
+                {
+                    closePoint.NearestPointInLineSegment(point, triangle0, triangle2);
+                    closeMagnitude2 = point.Distance2(closePoint);
+                    if (bForce || (bestMagnitude2 > closeMagnitude2))
+                    {
+                        bForce = false;
+                        bestMagnitude2 = closeMagnitude2;
+                        nearestPoint = closePoint;
+                    }
+                }
+                if (axisDot.z < 0f)
+                {
+                    closePoint.NearestPointInLineSegment(point, triangle0, triangle1);
+                    closeMagnitude2 = point.Distance2(closePoint);
+                    if (bForce || (bestMagnitude2 > closeMagnitude2))
+                    {
+                        bForce = false;
+                        bestMagnitude2 = closeMagnitude2;
+                        nearestPoint = closePoint;
+                    }
+                }
+
+                // If bForce is true at this point, it means the nearest point lies
+                // inside the triangle; use the nearest-point-on-a-plane equation
+                if (bForce)
+                {
+                    float3 normal;
+
+                    // Get the normal of the polygon (doesn't have to be a unit vector)
+                    normal = float3.cross(lineDelta0, lineDelta1);
+
+                    float3 pointDelta = point - triangle0;
+                    float delta = float3.dot(normal, pointDelta) / float3.dot(normal, normal);
+
+                    nearestPoint = point - normal * delta;
+                }
+            }
+
+            this.x = nearestPoint.x;
+            this.y = nearestPoint.y;
+            this.z = nearestPoint.z;
+        }
+
+        public static float3 operator +(float3 a, float3 b)
+        {
+            return new float3(a.x + b.x, a.y + b.y, a.z + b.z);
+        }
+
+        public static float3 operator -(float3 a, float3 b)
+        {
+            return new float3(a.x - b.x, a.y - b.y, a.z - b.z);
+        }
+
+        public static float3 operator -(float3 a, float s)
+        {
+            return new float3(a.x - s, a.y - s, a.z - s);
+        }
+
+        public static float3 operator -(float3 v)
+        {
+            return new float3(-v.x, -v.y, -v.z);
+        }
+
+        public static float3 operator *(float3 v, float s)
+        {
+            return new float3(v.x * s, v.y * s, v.z * s);
+        }
+
+        public static float3 operator *(float s, float3 v)
+        {
+            return new float3(v.x * s, v.y * s, v.z * s);
+        }
+
+        public static float3 operator *(float3 v, float3x3 m)
+        {
+            return new float3((m.x.x * v.x + m.y.x * v.y + m.z.x * v.z), (m.x.y * v.x + m.y.y * v.y + m.z.y * v.z), (m.x.z * v.x + m.y.z * v.y + m.z.z * v.z));
+        }
+
+        public static float3 operator *(float3x3 m, float3 v)
+        {
+            return new float3(dot(m.x, v), dot(m.y, v), dot(m.z, v));
+        }
+
+        public static float3 operator /(float3 v, float s)
+        {
+            float sinv = 1.0f / s;
+            return new float3(v.x * sinv, v.y * sinv, v.z * sinv);
+        }
+
+        public bool Equals(float3 other)
+        {
+            return this == other;
+        }
+
+        public override bool Equals(object obj)
+        {
+            float3 f = obj as float3;
+            if (f == null)
+                return false;
+
+            return this == f;
+        }
+
+        public override int GetHashCode()
+        {
+            return x.GetHashCode() ^ y.GetHashCode() ^ z.GetHashCode();
+        }
+
+        public static bool operator ==(float3 a, float3 b)
+        {
+            // If both are null, or both are same instance, return true.
+            if (System.Object.ReferenceEquals(a, b))
+                return true;
+            // If one is null, but not both, return false.
+            if (((object)a == null) || ((object)b == null))
+                return false;
+
+            return (a.x == b.x && a.y == b.y && a.z == b.z);
+        }
+
+        public static bool operator !=(float3 a, float3 b)
+        {
+            return (a.x != b.x || a.y != b.y || a.z != b.z);
+        }
+
+        public static float dot(float3 a, float3 b)
+        {
+            return a.x * b.x + a.y * b.y + a.z * b.z;
+        }
+
+        public static float3 cmul(float3 v1, float3 v2)
+        {
+            return new float3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
+        }
+
+        public static float3 cross(float3 a, float3 b)
+        {
+            return new float3(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+        }
+
+        public static float3 Interpolate(float3 v0, float3 v1, float alpha)
+        {
+            return v0 * (1 - alpha) + v1 * alpha;
+        }
+
+        public static float3 Round(float3 a, int digits)
+        {
+            return new float3((float)Math.Round(a.x, digits), (float)Math.Round(a.y, digits), (float)Math.Round(a.z, digits));
+        }
+
+        public static float3 VectorMax(float3 a, float3 b)
+        {
+            return new float3(Math.Max(a.x, b.x), Math.Max(a.y, b.y), Math.Max(a.z, b.z));
+        }
+
+        public static float3 VectorMin(float3 a, float3 b)
+        {
+            return new float3(Math.Min(a.x, b.x), Math.Min(a.y, b.y), Math.Min(a.z, b.z));
+        }
+
+        public static float3 vabs(float3 v)
+        {
+            return new float3(Math.Abs(v.x), Math.Abs(v.y), Math.Abs(v.z));
+        }
+
+        public static float magnitude(float3 v)
+        {
+            return (float)Math.Sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+        }
+
+        public static float3 normalize(float3 v)
+        {
+            float d = magnitude(v);
+            if (d == 0)
+                d = 0.1f;
+            d = 1 / d;
+            return new float3(v.x * d, v.y * d, v.z * d);
+        }
+
+        public static float3 safenormalize(float3 v)
+        {
+            if (magnitude(v) <= 0.0f)
+                return new float3(1, 0, 0);
+            else
+                return normalize(v);
+        }
+
+        public static float Yaw(float3 v)
+        {
+            return (v.y == 0.0 && v.x == 0.0) ? 0.0f : (float)Math.Atan2(-v.x, v.y) * (180.0f / 3.14159264f);
+        }
+
+        public static float Pitch(float3 v)
+        {
+            return (float)Math.Atan2(v.z, Math.Sqrt(v.x * v.x + v.y * v.y)) * (180.0f / 3.14159264f);
+        }
+
+        public float ComputePlane(float3 A, float3 B, float3 C)
+        {
+            float vx, vy, vz, wx, wy, wz, vw_x, vw_y, vw_z, mag;
+
+            vx = (B.x - C.x);
+            vy = (B.y - C.y);
+            vz = (B.z - C.z);
+
+            wx = (A.x - B.x);
+            wy = (A.y - B.y);
+            wz = (A.z - B.z);
+
+            vw_x = vy * wz - vz * wy;
+            vw_y = vz * wx - vx * wz;
+            vw_z = vx * wy - vy * wx;
+
+            mag = (float)Math.Sqrt((vw_x * vw_x) + (vw_y * vw_y) + (vw_z * vw_z));
+
+            if (mag < 0.000001f)
+            {
+                mag = 0;
+            }
+            else
+            {
+                mag = 1.0f / mag;
+            }
+
+            x = vw_x * mag;
+            y = vw_y * mag;
+            z = vw_z * mag;
+
+            float D = 0.0f - ((x * A.x) + (y * A.y) + (z * A.z));
+            return D;
+        }
+
+        public override string ToString()
+        {
+            return String.Format("<{0}, {1}, {2}>", x, y, z);
+        }
+
+        public static readonly float3 Zero = new float3();
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3x3.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3x3.cs
new file mode 100644
index 0000000..c420fde
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3x3.cs
@@ -0,0 +1,195 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class float3x3
+    {
+        public float3 x = new float3();
+        public float3 y = new float3();
+        public float3 z = new float3();
+
+        public float3x3()
+        {
+        }
+
+        public float3x3(float xx, float xy, float xz, float yx, float yy, float yz, float zx, float zy, float zz)
+        {
+            x = new float3(xx, xy, xz);
+            y = new float3(yx, yy, yz);
+            z = new float3(zx, zy, zz);
+        }
+
+        public float3x3(float3 _x, float3 _y, float3 _z)
+        {
+            x = new float3(_x);
+            y = new float3(_y);
+            z = new float3(_z);
+        }
+
+        public float3 this[int i]
+        {
+            get
+            {
+                switch (i)
+                {
+                    case 0: return x;
+                    case 1: return y;
+                    case 2: return z;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public float this[int i, int j]
+        {
+            get
+            {
+                switch (i)
+                {
+                    case 0:
+                        switch (j)
+                        {
+                            case 0: return x.x;
+                            case 1: return x.y;
+                            case 2: return x.z;
+                        }
+                        break;
+                    case 1:
+                        switch (j)
+                        {
+                            case 0: return y.x;
+                            case 1: return y.y;
+                            case 2: return y.z;
+                        }
+                        break;
+                    case 2:
+                        switch (j)
+                        {
+                            case 0: return z.x;
+                            case 1: return z.y;
+                            case 2: return z.z;
+                        }
+                        break;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+            set
+            {
+                switch (i)
+                {
+                    case 0:
+                        switch (j)
+                        {
+                            case 0: x.x = value; return;
+                            case 1: x.y = value; return;
+                            case 2: x.z = value; return;
+                        }
+                        break;
+                    case 1:
+                        switch (j)
+                        {
+                            case 0: y.x = value; return;
+                            case 1: y.y = value; return;
+                            case 2: y.z = value; return;
+                        }
+                        break;
+                    case 2:
+                        switch (j)
+                        {
+                            case 0: z.x = value; return;
+                            case 1: z.y = value; return;
+                            case 2: z.z = value; return;
+                        }
+                        break;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public static float3x3 Transpose(float3x3 m)
+        {
+            return new float3x3(new float3(m.x.x, m.y.x, m.z.x), new float3(m.x.y, m.y.y, m.z.y), new float3(m.x.z, m.y.z, m.z.z));
+        }
+
+        public static float3x3 operator *(float3x3 a, float3x3 b)
+        {
+            return new float3x3(a.x * b, a.y * b, a.z * b);
+        }
+
+        public static float3x3 operator *(float3x3 a, float s)
+        {
+            return new float3x3(a.x * s, a.y * s, a.z * s);
+        }
+
+        public static float3x3 operator /(float3x3 a, float s)
+        {
+            float t = 1f / s;
+            return new float3x3(a.x * t, a.y * t, a.z * t);
+        }
+
+        public static float3x3 operator +(float3x3 a, float3x3 b)
+        {
+            return new float3x3(a.x + b.x, a.y + b.y, a.z + b.z);
+        }
+
+        public static float3x3 operator -(float3x3 a, float3x3 b)
+        {
+            return new float3x3(a.x - b.x, a.y - b.y, a.z - b.z);
+        }
+
+        public static float Determinant(float3x3 m)
+        {
+            return m.x.x * m.y.y * m.z.z + m.y.x * m.z.y * m.x.z + m.z.x * m.x.y * m.y.z - m.x.x * m.z.y * m.y.z - m.y.x * m.x.y * m.z.z - m.z.x * m.y.y * m.x.z;
+        }
+
+        public static float3x3 Inverse(float3x3 a)
+        {
+            float3x3 b = new float3x3();
+            float d = Determinant(a);
+            Debug.Assert(d != 0);
+            for (int i = 0; i < 3; i++)
+            {
+                for (int j = 0; j < 3; j++)
+                {
+                    int i1 = (i + 1) % 3;
+                    int i2 = (i + 2) % 3;
+                    int j1 = (j + 1) % 3;
+                    int j2 = (j + 2) % 3;
+
+                    // reverse indexs i&j to take transpose
+                    b[i, j] = (a[i1][j1] * a[i2][j2] - a[i1][j2] * a[i2][j1]) / d;
+                }
+            }
+            return b;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4.cs
new file mode 100644
index 0000000..b2b6fd3
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4.cs
@@ -0,0 +1,170 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class float4
+    {
+        public float x;
+        public float y;
+        public float z;
+        public float w;
+
+        public float4()
+        {
+            x = 0;
+            y = 0;
+            z = 0;
+            w = 0;
+        }
+
+        public float4(float _x, float _y, float _z, float _w)
+        {
+            x = _x;
+            y = _y;
+            z = _z;
+            w = _w;
+        }
+
+        public float4(float3 v, float _w)
+        {
+            x = v.x;
+            y = v.y;
+            z = v.z;
+            w = _w;
+        }
+
+        public float4(float4 f)
+        {
+            x = f.x;
+            y = f.y;
+            z = f.z;
+            w = f.w;
+        }
+
+        public float this[int i]
+        {
+            get
+            {
+                switch (i)
+                {
+                    case 0: return x;
+                    case 1: return y;
+                    case 2: return z;
+                    case 3: return w;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public float3 xyz()
+        {
+            return new float3(x, y, z);
+        }
+
+        public void setxyz(float3 xyz)
+        {
+            x = xyz.x;
+            y = xyz.y;
+            z = xyz.z;
+        }
+
+        public override int GetHashCode()
+        {
+            return x.GetHashCode() ^ y.GetHashCode() ^ z.GetHashCode() ^ w.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            float4 f = obj as float4;
+            if (f == null)
+                return false;
+
+            return this == f;
+        }
+
+        public static float4 Homogenize(float3 v3)
+        {
+            return Homogenize(v3, 1.0f);
+        }
+
+        //C++ TO C# CONVERTER NOTE: C# does not allow default values for parameters. Overloaded methods are inserted above.
+        //ORIGINAL LINE: float4 Homogenize(const float3 &v3, const float &w =1.0f)
+        public static float4 Homogenize(float3 v3, float w)
+        {
+            return new float4(v3.x, v3.y, v3.z, w);
+        }
+
+        public static float4 cmul(float4 a, float4 b)
+        {
+            return new float4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
+        }
+
+        public static float4 operator +(float4 a, float4 b)
+        {
+            return new float4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
+        }
+        public static float4 operator -(float4 a, float4 b)
+        {
+            return new float4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
+        }
+
+        public static float4 operator *(float4 v, float4x4 m)
+        {
+            return v.x * m.x + v.y * m.y + v.z * m.z + v.w * m.w; // yes this actually works
+        }
+
+        public static bool operator ==(float4 a, float4 b)
+        {
+            // If both are null, or both are same instance, return true.
+            if (System.Object.ReferenceEquals(a, b))
+                return true;
+            // If one is null, but not both, return false.
+            if (((object)a == null) || ((object)b == null))
+                return false;
+
+            return (a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w);
+        }
+
+        public static bool operator !=(float4 a, float4 b)
+        {
+            return !(a == b);
+        }
+
+        public static float4 operator *(float4 v, float s)
+        {
+            return new float4(v.x * s, v.y * s, v.z * s, v.w * s);
+        }
+
+        public static float4 operator *(float s, float4 v)
+        {
+            return new float4(v.x * s, v.y * s, v.z * s, v.w * s);
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4x4.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4x4.cs
new file mode 100644
index 0000000..087eba7
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4x4.cs
@@ -0,0 +1,284 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class float4x4
+    {
+        public float4 x = new float4();
+        public float4 y = new float4();
+        public float4 z = new float4();
+        public float4 w = new float4();
+
+        public float4x4()
+        {
+        }
+
+        public float4x4(float4 _x, float4 _y, float4 _z, float4 _w)
+        {
+            x = new float4(_x);
+            y = new float4(_y);
+            z = new float4(_z);
+            w = new float4(_w);
+        }
+
+        public float4x4(
+            float m00, float m01, float m02, float m03,
+            float m10, float m11, float m12, float m13,
+            float m20, float m21, float m22, float m23,
+            float m30, float m31, float m32, float m33)
+        {
+            x = new float4(m00, m01, m02, m03);
+            y = new float4(m10, m11, m12, m13);
+            z = new float4(m20, m21, m22, m23);
+            w = new float4(m30, m31, m32, m33);
+        }
+
+        public float4x4(float4x4 m)
+        {
+            x = new float4(m.x);
+            y = new float4(m.y);
+            z = new float4(m.z);
+            w = new float4(m.w);
+        }
+
+        public float4 this[int i]
+        {
+            get
+            {
+                switch (i)
+                {
+                    case 0: return x;
+                    case 1: return y;
+                    case 2: return z;
+                    case 3: return w;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+            set
+            {
+                switch (i)
+                {
+                    case 0: x = value; return;
+                    case 1: y = value; return;
+                    case 2: z = value; return;
+                    case 3: w = value; return;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            return x.GetHashCode() ^ y.GetHashCode() ^ z.GetHashCode() ^ w.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            float4x4 m = obj as float4x4;
+            if (m == null)
+                return false;
+
+            return this == m;
+        }
+
+        public static float4x4 operator *(float4x4 a, float4x4 b)
+        {
+            return new float4x4(a.x * b, a.y * b, a.z * b, a.w * b);
+        }
+
+        public static bool operator ==(float4x4 a, float4x4 b)
+        {
+            return (a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w);
+        }
+
+        public static bool operator !=(float4x4 a, float4x4 b)
+        {
+            return !(a == b);
+        }
+
+        public static float4x4 Inverse(float4x4 m)
+            {
+                    float4x4 d = new float4x4();
+                    //float dst = d.x.x;
+                    float[] tmp = new float[12]; // temp array for pairs
+                    float[] src = new float[16]; // array of transpose source matrix
+                    float det; // determinant
+                    // transpose matrix
+                    for (int i = 0; i < 4; i++)
+                    {
+                            src[i] = m[i].x;
+                            src[i + 4] = m[i].y;
+                            src[i + 8] = m[i].z;
+                            src[i + 12] = m[i].w;
+                    }
+                    // calculate pairs for first 8 elements (cofactors)
+                    tmp[0] = src[10] * src[15];
+                    tmp[1] = src[11] * src[14];
+                    tmp[2] = src[9] * src[15];
+                    tmp[3] = src[11] * src[13];
+                    tmp[4] = src[9] * src[14];
+                    tmp[5] = src[10] * src[13];
+                    tmp[6] = src[8] * src[15];
+                    tmp[7] = src[11] * src[12];
+                    tmp[8] = src[8] * src[14];
+                    tmp[9] = src[10] * src[12];
+                    tmp[10] = src[8] * src[13];
+                    tmp[11] = src[9] * src[12];
+                    // calculate first 8 elements (cofactors)
+                    d.x.x = tmp[0]*src[5] + tmp[3]*src[6] + tmp[4]*src[7];
+                    d.x.x -= tmp[1]*src[5] + tmp[2]*src[6] + tmp[5]*src[7];
+                    d.x.y = tmp[1]*src[4] + tmp[6]*src[6] + tmp[9]*src[7];
+                    d.x.y -= tmp[0]*src[4] + tmp[7]*src[6] + tmp[8]*src[7];
+                    d.x.z = tmp[2]*src[4] + tmp[7]*src[5] + tmp[10]*src[7];
+                    d.x.z -= tmp[3]*src[4] + tmp[6]*src[5] + tmp[11]*src[7];
+                    d.x.w = tmp[5]*src[4] + tmp[8]*src[5] + tmp[11]*src[6];
+                    d.x.w -= tmp[4]*src[4] + tmp[9]*src[5] + tmp[10]*src[6];
+                    d.y.x = tmp[1]*src[1] + tmp[2]*src[2] + tmp[5]*src[3];
+                    d.y.x -= tmp[0]*src[1] + tmp[3]*src[2] + tmp[4]*src[3];
+                    d.y.y = tmp[0]*src[0] + tmp[7]*src[2] + tmp[8]*src[3];
+                    d.y.y -= tmp[1]*src[0] + tmp[6]*src[2] + tmp[9]*src[3];
+                    d.y.z = tmp[3]*src[0] + tmp[6]*src[1] + tmp[11]*src[3];
+                    d.y.z -= tmp[2]*src[0] + tmp[7]*src[1] + tmp[10]*src[3];
+                    d.y.w = tmp[4]*src[0] + tmp[9]*src[1] + tmp[10]*src[2];
+                    d.y.w -= tmp[5]*src[0] + tmp[8]*src[1] + tmp[11]*src[2];
+                    // calculate pairs for second 8 elements (cofactors)
+                    tmp[0] = src[2]*src[7];
+                    tmp[1] = src[3]*src[6];
+                    tmp[2] = src[1]*src[7];
+                    tmp[3] = src[3]*src[5];
+                    tmp[4] = src[1]*src[6];
+                    tmp[5] = src[2]*src[5];
+                    tmp[6] = src[0]*src[7];
+                    tmp[7] = src[3]*src[4];
+                    tmp[8] = src[0]*src[6];
+                    tmp[9] = src[2]*src[4];
+                    tmp[10] = src[0]*src[5];
+                    tmp[11] = src[1]*src[4];
+                    // calculate second 8 elements (cofactors)
+                    d.z.x = tmp[0]*src[13] + tmp[3]*src[14] + tmp[4]*src[15];
+                    d.z.x -= tmp[1]*src[13] + tmp[2]*src[14] + tmp[5]*src[15];
+                    d.z.y = tmp[1]*src[12] + tmp[6]*src[14] + tmp[9]*src[15];
+                    d.z.y -= tmp[0]*src[12] + tmp[7]*src[14] + tmp[8]*src[15];
+                    d.z.z = tmp[2]*src[12] + tmp[7]*src[13] + tmp[10]*src[15];
+                    d.z.z -= tmp[3]*src[12] + tmp[6]*src[13] + tmp[11]*src[15];
+                    d.z.w = tmp[5]*src[12] + tmp[8]*src[13] + tmp[11]*src[14];
+                    d.z.w-= tmp[4]*src[12] + tmp[9]*src[13] + tmp[10]*src[14];
+                    d.w.x = tmp[2]*src[10] + tmp[5]*src[11] + tmp[1]*src[9];
+                    d.w.x-= tmp[4]*src[11] + tmp[0]*src[9] + tmp[3]*src[10];
+                    d.w.y = tmp[8]*src[11] + tmp[0]*src[8] + tmp[7]*src[10];
+                    d.w.y-= tmp[6]*src[10] + tmp[9]*src[11] + tmp[1]*src[8];
+                    d.w.z = tmp[6]*src[9] + tmp[11]*src[11] + tmp[3]*src[8];
+                    d.w.z-= tmp[10]*src[11] + tmp[2]*src[8] + tmp[7]*src[9];
+                    d.w.w = tmp[10]*src[10] + tmp[4]*src[8] + tmp[9]*src[9];
+                    d.w.w-= tmp[8]*src[9] + tmp[11]*src[10] + tmp[5]*src[8];
+                    // calculate determinant
+            det = src[0] * d.x.x + src[1] * d.x.y + src[2] * d.x.z + src[3] * d.x.w;
+                    // calculate matrix inverse
+                    det = 1/det;
+            for (int j = 0; j < 4; j++)
+                d[j] *= det;
+                    return d;
+            }
+
+        public static float4x4 MatrixRigidInverse(float4x4 m)
+        {
+            float4x4 trans_inverse = MatrixTranslation(-m.w.xyz());
+            float4x4 rot = new float4x4(m);
+            rot.w = new float4(0f, 0f, 0f, 1f);
+            return trans_inverse * MatrixTranspose(rot);
+        }
+        public static float4x4 MatrixTranspose(float4x4 m)
+        {
+            return new float4x4(m.x.x, m.y.x, m.z.x, m.w.x, m.x.y, m.y.y, m.z.y, m.w.y, m.x.z, m.y.z, m.z.z, m.w.z, m.x.w, m.y.w, m.z.w, m.w.w);
+        }
+        public static float4x4 MatrixPerspectiveFov(float fovy, float aspect, float zn, float zf)
+        {
+            float h = 1.0f / (float)Math.Tan(fovy / 2.0f); // view space height
+            float w = h / aspect; // view space width
+            return new float4x4(w, 0, 0, 0, 0, h, 0, 0, 0, 0, zf / (zn - zf), -1, 0, 0, zn * zf / (zn - zf), 0);
+        }
+        public static float4x4 MatrixTranslation(float3 t)
+        {
+            return new float4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, t.x, t.y, t.z, 1);
+        }
+        public static float4x4 MatrixRotationZ(float angle_radians)
+        {
+            float s = (float)Math.Sin(angle_radians);
+            float c = (float)Math.Cos(angle_radians);
+            return new float4x4(c, s, 0, 0, -s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+        }
+        public static float4x4 MatrixLookAt(float3 eye, float3 at, float3 up)
+        {
+            float4x4 m = new float4x4();
+            m.w.w = 1.0f;
+            m.w.setxyz(eye);
+            m.z.setxyz(float3.normalize(eye - at));
+            m.x.setxyz(float3.normalize(float3.cross(up, m.z.xyz())));
+            m.y.setxyz(float3.cross(m.z.xyz(), m.x.xyz()));
+            return MatrixRigidInverse(m);
+        }
+
+        public static float4x4 MatrixFromQuatVec(Quaternion q, float3 v)
+        {
+            // builds a 4x4 transformation matrix based on orientation q and translation v
+            float qx2 = q.x * q.x;
+            float qy2 = q.y * q.y;
+            float qz2 = q.z * q.z;
+
+            float qxqy = q.x * q.y;
+            float qxqz = q.x * q.z;
+            float qxqw = q.x * q.w;
+            float qyqz = q.y * q.z;
+            float qyqw = q.y * q.w;
+            float qzqw = q.z * q.w;
+
+            return new float4x4(
+                1 - 2 * (qy2 + qz2),
+                2 * (qxqy + qzqw),
+                2 * (qxqz - qyqw),
+                0,
+                2 * (qxqy - qzqw),
+                1 - 2 * (qx2 + qz2),
+                2 * (qyqz + qxqw),
+                0,
+                2 * (qxqz + qyqw),
+                2 * (qyqz - qxqw),
+                1 - 2 * (qx2 + qy2),
+                0,
+                v.x,
+                v.y,
+                v.z,
+                1.0f);
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int3.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int3.cs
new file mode 100644
index 0000000..90624eb
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int3.cs
@@ -0,0 +1,128 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class int3
+    {
+        public int x;
+        public int y;
+        public int z;
+
+        public int3()
+        {
+        }
+
+        public int3(int _x, int _y, int _z)
+        {
+            x = _x;
+            y = _y;
+            z = _z;
+        }
+
+        public int this[int i]
+        {
+            get
+            {
+                switch (i)
+                {
+                    case 0: return x;
+                    case 1: return y;
+                    case 2: return z;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+            set
+            {
+                switch (i)
+                {
+                    case 0: x = value; return;
+                    case 1: y = value; return;
+                    case 2: z = value; return;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            return x.GetHashCode() ^ y.GetHashCode() ^ z.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            int3 i = obj as int3;
+            if (i == null)
+                return false;
+
+            return this == i;
+        }
+
+        public static bool operator ==(int3 a, int3 b)
+        {
+            // If both are null, or both are same instance, return true.
+            if (System.Object.ReferenceEquals(a, b))
+                return true;
+            // If one is null, but not both, return false.
+            if (((object)a == null) || ((object)b == null))
+                return false;
+
+            for (int i = 0; i < 3; i++)
+            {
+                if (a[i] != b[i])
+                    return false;
+            }
+            return true;
+        }
+
+        public static bool operator !=(int3 a, int3 b)
+        {
+            return !(a == b);
+        }
+
+        public static int3 roll3(int3 a)
+        {
+            int tmp = a[0];
+            a[0] = a[1];
+            a[1] = a[2];
+            a[2] = tmp;
+            return a;
+        }
+
+        public static bool isa(int3 a, int3 b)
+        {
+            return (a == b || roll3(a) == b || a == roll3(b));
+        }
+
+        public static bool b2b(int3 a, int3 b)
+        {
+            return isa(a, new int3(b[2], b[1], b[0]));
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int4.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int4.cs
new file mode 100644
index 0000000..e9320c0
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int4.cs
@@ -0,0 +1,66 @@
+/* The MIT License
+ * 
+ * Copyright (c) 2010 Intel Corporation.
+ * All rights reserved.
+ *
+ * Based on the convexdecomposition library from 
+ * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+using System;
+
+namespace OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet
+{
+    public class int4
+    {
+        public int x;
+        public int y;
+        public int z;
+        public int w;
+
+        public int4()
+        {
+        }
+
+        public int4(int _x, int _y, int _z, int _w)
+        {
+            x = _x;
+            y = _y;
+            z = _z;
+            w = _w;
+        }
+
+        public int this[int i]
+        {
+            get
+            {
+                switch (i)
+                {
+                    case 0: return x;
+                    case 1: return y;
+                    case 2: return z;
+                    case 3: return w;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/HelperTypes.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/HelperTypes.cs
new file mode 100644
index 0000000..34a925d
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/HelperTypes.cs
@@ -0,0 +1,436 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using OpenMetaverse;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Region.PhysicsModules.Meshing;
+
+public class Vertex : IComparable<Vertex>
+{
+    Vector3 vector;
+
+    public float X
+    {
+        get { return vector.X; }
+        set { vector.X = value; }
+    }
+
+    public float Y
+    {
+        get { return vector.Y; }
+        set { vector.Y = value; }
+    }
+
+    public float Z
+    {
+        get { return vector.Z; }
+        set { vector.Z = value; }
+    }
+
+    public Vertex(float x, float y, float z)
+    {
+        vector.X = x;
+        vector.Y = y;
+        vector.Z = z;
+    }
+
+    public Vertex normalize()
+    {
+        float tlength = vector.Length();
+        if (tlength != 0f)
+        {
+            float mul = 1.0f / tlength;
+            return new Vertex(vector.X * mul, vector.Y * mul, vector.Z * mul);
+        }
+        else
+        {
+            return new Vertex(0f, 0f, 0f);
+        }
+    }
+
+    public Vertex cross(Vertex v)
+    {
+        return new Vertex(vector.Y * v.Z - vector.Z * v.Y, vector.Z * v.X - vector.X * v.Z, vector.X * v.Y - vector.Y * v.X);
+    }
+
+    // disable warning: mono compiler moans about overloading
+    // operators hiding base operator but should not according to C#
+    // language spec
+#pragma warning disable 0108
+    public static Vertex operator *(Vertex v, Quaternion q)
+    {
+        // From http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/
+
+        Vertex v2 = new Vertex(0f, 0f, 0f);
+
+        v2.X =   q.W * q.W * v.X +
+            2f * q.Y * q.W * v.Z -
+            2f * q.Z * q.W * v.Y +
+                 q.X * q.X * v.X +
+            2f * q.Y * q.X * v.Y +
+            2f * q.Z * q.X * v.Z -
+                 q.Z * q.Z * v.X -
+                 q.Y * q.Y * v.X;
+
+        v2.Y =
+            2f * q.X * q.Y * v.X +
+                 q.Y * q.Y * v.Y +
+            2f * q.Z * q.Y * v.Z +
+            2f * q.W * q.Z * v.X -
+                 q.Z * q.Z * v.Y +
+                 q.W * q.W * v.Y -
+            2f * q.X * q.W * v.Z -
+                 q.X * q.X * v.Y;
+
+        v2.Z =
+            2f * q.X * q.Z * v.X +
+            2f * q.Y * q.Z * v.Y +
+                 q.Z * q.Z * v.Z -
+            2f * q.W * q.Y * v.X -
+                 q.Y * q.Y * v.Z +
+            2f * q.W * q.X * v.Y -
+                 q.X * q.X * v.Z +
+                 q.W * q.W * v.Z;
+
+        return v2;
+    }
+
+    public static Vertex operator +(Vertex v1, Vertex v2)
+    {
+        return new Vertex(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z);
+    }
+
+    public static Vertex operator -(Vertex v1, Vertex v2)
+    {
+        return new Vertex(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z);
+    }
+
+    public static Vertex operator *(Vertex v1, Vertex v2)
+    {
+        return new Vertex(v1.X * v2.X, v1.Y * v2.Y, v1.Z * v2.Z);
+    }
+
+    public static Vertex operator +(Vertex v1, float am)
+    {
+        v1.X += am;
+        v1.Y += am;
+        v1.Z += am;
+        return v1;
+    }
+
+    public static Vertex operator -(Vertex v1, float am)
+    {
+        v1.X -= am;
+        v1.Y -= am;
+        v1.Z -= am;
+        return v1;
+    }
+
+    public static Vertex operator *(Vertex v1, float am)
+    {
+        v1.X *= am;
+        v1.Y *= am;
+        v1.Z *= am;
+        return v1;
+    }
+
+    public static Vertex operator /(Vertex v1, float am)
+    {
+        if (am == 0f)
+        {
+            return new Vertex(0f,0f,0f);
+        }
+        float mul = 1.0f / am;
+        v1.X *= mul;
+        v1.Y *= mul;
+        v1.Z *= mul;
+        return v1;
+    }
+#pragma warning restore 0108
+
+
+    public float dot(Vertex v)
+    {
+        return X * v.X + Y * v.Y + Z * v.Z;
+    }
+
+    public Vertex(Vector3 v)
+    {
+        vector = v;
+    }
+
+    public Vertex Clone()
+    {
+        return new Vertex(X, Y, Z);
+    }
+
+    public static Vertex FromAngle(double angle)
+    {
+        return new Vertex((float) Math.Cos(angle), (float) Math.Sin(angle), 0.0f);
+    }
+
+    public float Length()
+    {
+        return vector.Length();
+    }
+
+    public virtual bool Equals(Vertex v, float tolerance)
+    {
+        Vertex diff = this - v;
+        float d = diff.Length();
+        if (d < tolerance)
+            return true;
+
+        return false;
+    }
+
+
+    public int CompareTo(Vertex other)
+    {
+        if (X < other.X)
+            return -1;
+
+        if (X > other.X)
+            return 1;
+
+        if (Y < other.Y)
+            return -1;
+
+        if (Y > other.Y)
+            return 1;
+
+        if (Z < other.Z)
+            return -1;
+
+        if (Z > other.Z)
+            return 1;
+
+        return 0;
+    }
+
+    public static bool operator >(Vertex me, Vertex other)
+    {
+        return me.CompareTo(other) > 0;
+    }
+
+    public static bool operator <(Vertex me, Vertex other)
+    {
+        return me.CompareTo(other) < 0;
+    }
+
+    public String ToRaw()
+    {
+        // Why this stuff with the number formatter?
+        // Well, the raw format uses the english/US notation of numbers
+        // where the "," separates groups of 1000 while the "." marks the border between 1 and 10E-1.
+        // The german notation uses these characters exactly vice versa!
+        // The Float.ToString() routine is a localized one, giving different results depending on the country
+        // settings your machine works with. Unusable for a machine readable file format :-(
+        NumberFormatInfo nfi = new NumberFormatInfo();
+        nfi.NumberDecimalSeparator = ".";
+        nfi.NumberDecimalDigits = 3;
+
+        String s1 = X.ToString("N2", nfi) + " " + Y.ToString("N2", nfi) + " " + Z.ToString("N2", nfi);
+
+        return s1;
+    }
+}
+
+public class Triangle
+{
+    public Vertex v1;
+    public Vertex v2;
+    public Vertex v3;
+
+    private float radius_square;
+    private float cx;
+    private float cy;
+
+    public Triangle(Vertex _v1, Vertex _v2, Vertex _v3)
+    {
+        v1 = _v1;
+        v2 = _v2;
+        v3 = _v3;
+
+        CalcCircle();
+    }
+
+    public bool isInCircle(float x, float y)
+    {
+        float dx, dy;
+        float dd;
+
+        dx = x - cx;
+        dy = y - cy;
+
+        dd = dx*dx + dy*dy;
+        if (dd < radius_square)
+            return true;
+        else
+            return false;
+    }
+
+    public bool isDegraded()
+    {
+        // This means, the vertices of this triangle are somewhat strange.
+        // They either line up or at least two of them are identical
+        return (radius_square == 0.0);
+    }
+
+    private void CalcCircle()
+    {
+        // Calculate the center and the radius of a circle given by three points p1, p2, p3
+        // It is assumed, that the triangles vertices are already set correctly
+        double p1x, p2x, p1y, p2y, p3x, p3y;
+
+        // Deviation of this routine:
+        // A circle has the general equation (M-p)^2=r^2, where M and p are vectors
+        // this gives us three equations f(p)=r^2, each for one point p1, p2, p3
+        // putting respectively two equations together gives two equations
+        // f(p1)=f(p2) and f(p1)=f(p3)
+        // bringing all constant terms to one side brings them to the form
+        // M*v1=c1 resp.M*v2=c2 where v1=(p1-p2) and v2=(p1-p3) (still vectors)
+        // and c1, c2 are scalars (Naming conventions like the variables below)
+        // Now using the equations that are formed by the components of the vectors
+        // and isolate Mx lets you make one equation that only holds My
+        // The rest is straight forward and eaasy :-)
+        //
+
+        /* helping variables for temporary results */
+        double c1, c2;
+        double v1x, v1y, v2x, v2y;
+
+        double z, n;
+
+        double rx, ry;
+
+        // Readout the three points, the triangle consists of
+        p1x = v1.X;
+        p1y = v1.Y;
+
+        p2x = v2.X;
+        p2y = v2.Y;
+
+        p3x = v3.X;
+        p3y = v3.Y;
+
+        /* calc helping values first */
+        c1 = (p1x*p1x + p1y*p1y - p2x*p2x - p2y*p2y)/2;
+        c2 = (p1x*p1x + p1y*p1y - p3x*p3x - p3y*p3y)/2;
+
+        v1x = p1x - p2x;
+        v1y = p1y - p2y;
+
+        v2x = p1x - p3x;
+        v2y = p1y - p3y;
+
+        z = (c1*v2x - c2*v1x);
+        n = (v1y*v2x - v2y*v1x);
+
+        if (n == 0.0) // This is no triangle, i.e there are (at least) two points at the same location
+        {
+            radius_square = 0.0f;
+            return;
+        }
+
+        cy = (float) (z/n);
+
+        if (v2x != 0.0)
+        {
+            cx = (float) ((c2 - v2y*cy)/v2x);
+        }
+        else if (v1x != 0.0)
+        {
+            cx = (float) ((c1 - v1y*cy)/v1x);
+        }
+        else
+        {
+            Debug.Assert(false, "Malformed triangle"); /* Both terms zero means nothing good */
+        }
+
+        rx = (p1x - cx);
+        ry = (p1y - cy);
+
+        radius_square = (float) (rx*rx + ry*ry);
+    }
+
+    public override String ToString()
+    {
+        NumberFormatInfo nfi = new NumberFormatInfo();
+        nfi.CurrencyDecimalDigits = 2;
+        nfi.CurrencyDecimalSeparator = ".";
+
+        String s1 = "<" + v1.X.ToString(nfi) + "," + v1.Y.ToString(nfi) + "," + v1.Z.ToString(nfi) + ">";
+        String s2 = "<" + v2.X.ToString(nfi) + "," + v2.Y.ToString(nfi) + "," + v2.Z.ToString(nfi) + ">";
+        String s3 = "<" + v3.X.ToString(nfi) + "," + v3.Y.ToString(nfi) + "," + v3.Z.ToString(nfi) + ">";
+
+        return s1 + ";" + s2 + ";" + s3;
+    }
+
+    public Vector3 getNormal()
+    {
+        // Vertices
+
+        // Vectors for edges
+        Vector3 e1;
+        Vector3 e2;
+
+        e1 = new Vector3(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z);
+        e2 = new Vector3(v1.X - v3.X, v1.Y - v3.Y, v1.Z - v3.Z);
+
+        // Cross product for normal
+        Vector3 n = Vector3.Cross(e1, e2);
+
+        // Length
+        float l = n.Length();
+
+        // Normalized "normal"
+        n = n/l;
+
+        return n;
+    }
+
+    public void invertNormal()
+    {
+        Vertex vt;
+        vt = v1;
+        v1 = v2;
+        v2 = vt;
+    }
+
+    // Dumps a triangle in the "raw faces" format, blender can import. This is for visualisation and
+    // debugging purposes
+    public String ToStringRaw()
+    {
+        String output = v1.ToRaw() + " " + v2.ToRaw() + " " + v3.ToRaw();
+        return output;
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Mesh.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Mesh.cs
new file mode 100644
index 0000000..8c97f2f
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Mesh.cs
@@ -0,0 +1,408 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using PrimMesher;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.Meshing
+{
+    public class Mesh : IMesh
+    {
+        private Dictionary<Vertex, int> m_vertices;
+        private List<Triangle> m_triangles;
+        GCHandle m_pinnedVertexes;
+        GCHandle m_pinnedIndex;
+        IntPtr m_verticesPtr = IntPtr.Zero;
+        int m_vertexCount = 0;
+        IntPtr m_indicesPtr = IntPtr.Zero;
+        int m_indexCount = 0;
+        public float[] m_normals;
+        Vector3 _centroid;
+        int _centroidDiv;
+
+        private class vertexcomp : IEqualityComparer<Vertex>
+        {
+            public bool Equals(Vertex v1, Vertex v2)
+            {
+                if (v1.X == v2.X && v1.Y == v2.Y && v1.Z == v2.Z)
+                    return true;
+                else
+                    return false;
+            }
+            public int GetHashCode(Vertex v)
+            {
+                int a = v.X.GetHashCode();
+                int b = v.Y.GetHashCode();
+                int c = v.Z.GetHashCode();
+                return (a << 16) ^ (b << 8) ^ c;
+            }
+
+        }
+
+        public Mesh()
+        {
+            vertexcomp vcomp = new vertexcomp();
+
+            m_vertices = new Dictionary<Vertex, int>(vcomp);
+            m_triangles = new List<Triangle>();
+            _centroid = Vector3.Zero;
+            _centroidDiv = 0;
+        }
+
+        public Mesh Clone()
+        {
+            Mesh result = new Mesh();
+
+            foreach (Triangle t in m_triangles)
+            {
+                result.Add(new Triangle(t.v1.Clone(), t.v2.Clone(), t.v3.Clone()));
+            }
+            result._centroid = _centroid;
+            result._centroidDiv = _centroidDiv;
+            return result;
+        }
+
+        public void Add(Triangle triangle)
+        {
+            if (m_pinnedIndex.IsAllocated || m_pinnedVertexes.IsAllocated || m_indicesPtr != IntPtr.Zero || m_verticesPtr != IntPtr.Zero)
+                throw new NotSupportedException("Attempt to Add to a pinned Mesh");
+            // If a vertex of the triangle is not yet in the vertices list,
+            // add it and set its index to the current index count
+            // vertex == seems broken
+            // skip colapsed triangles
+            if ((triangle.v1.X == triangle.v2.X && triangle.v1.Y == triangle.v2.Y && triangle.v1.Z == triangle.v2.Z)
+                || (triangle.v1.X == triangle.v3.X && triangle.v1.Y == triangle.v3.Y && triangle.v1.Z == triangle.v3.Z)
+                || (triangle.v2.X == triangle.v3.X && triangle.v2.Y == triangle.v3.Y && triangle.v2.Z == triangle.v3.Z)
+                )               
+            {               
+                return;
+            }
+
+            if (m_vertices.Count == 0)
+            {
+                _centroidDiv = 0;
+                _centroid = Vector3.Zero;
+            }
+
+            if (!m_vertices.ContainsKey(triangle.v1))
+            {
+                m_vertices[triangle.v1] = m_vertices.Count;
+                _centroid.X += triangle.v1.X;
+                _centroid.Y += triangle.v1.Y;
+                _centroid.Z += triangle.v1.Z;
+                _centroidDiv++;
+            }
+            if (!m_vertices.ContainsKey(triangle.v2))
+            {
+                m_vertices[triangle.v2] = m_vertices.Count;
+                _centroid.X += triangle.v2.X;
+                _centroid.Y += triangle.v2.Y;
+                _centroid.Z += triangle.v2.Z;
+                _centroidDiv++;
+            }
+            if (!m_vertices.ContainsKey(triangle.v3))
+            {
+                m_vertices[triangle.v3] = m_vertices.Count;
+                _centroid.X += triangle.v3.X;
+                _centroid.Y += triangle.v3.Y;
+                _centroid.Z += triangle.v3.Z;
+                _centroidDiv++;
+            }
+            m_triangles.Add(triangle);
+        }
+
+        public Vector3 GetCentroid()
+        {
+            if (_centroidDiv > 0)
+                return new Vector3(_centroid.X / _centroidDiv, _centroid.Y / _centroidDiv, _centroid.Z / _centroidDiv);
+            else
+                return Vector3.Zero;
+        }
+
+        // not functional
+        public Vector3 GetOBB()
+        {
+            return new Vector3(0.5f, 0.5f, 0.5f);
+        }
+
+        public void CalcNormals()
+        {
+            int iTriangles = m_triangles.Count;
+
+            this.m_normals = new float[iTriangles * 3];
+
+            int i = 0;
+            foreach (Triangle t in m_triangles)
+            {
+                float ux, uy, uz;
+                float vx, vy, vz;
+                float wx, wy, wz;
+
+                ux = t.v1.X;
+                uy = t.v1.Y;
+                uz = t.v1.Z;
+
+                vx = t.v2.X;
+                vy = t.v2.Y;
+                vz = t.v2.Z;
+
+                wx = t.v3.X;
+                wy = t.v3.Y;
+                wz = t.v3.Z;
+
+
+                // Vectors for edges
+                float e1x, e1y, e1z;
+                float e2x, e2y, e2z;
+
+                e1x = ux - vx;
+                e1y = uy - vy;
+                e1z = uz - vz;
+
+                e2x = ux - wx;
+                e2y = uy - wy;
+                e2z = uz - wz;
+
+
+                // Cross product for normal
+                float nx, ny, nz;
+                nx = e1y * e2z - e1z * e2y;
+                ny = e1z * e2x - e1x * e2z;
+                nz = e1x * e2y - e1y * e2x;
+
+                // Length
+                float l = (float)Math.Sqrt(nx * nx + ny * ny + nz * nz);
+                float lReciprocal = 1.0f / l;
+
+                // Normalized "normal"
+                //nx /= l;
+                //ny /= l;
+                //nz /= l;
+
+                m_normals[i] = nx * lReciprocal;
+                m_normals[i + 1] = ny * lReciprocal;
+                m_normals[i + 2] = nz * lReciprocal;
+
+                i += 3;
+            }
+        }
+
+        public List<Vector3> getVertexList()
+        {
+            List<Vector3> result = new List<Vector3>();
+            foreach (Vertex v in m_vertices.Keys)
+            {
+                result.Add(new Vector3(v.X, v.Y, v.Z));
+            }
+            return result;
+        }
+
+        public float[] getVertexListAsFloat()
+        {
+            if (m_vertices == null)
+                throw new NotSupportedException();
+            float[] result = new float[m_vertices.Count * 3];
+            foreach (KeyValuePair<Vertex, int> kvp in m_vertices)
+            {
+                Vertex v = kvp.Key;
+                int i = kvp.Value;
+                result[3 * i + 0] = v.X;
+                result[3 * i + 1] = v.Y;
+                result[3 * i + 2] = v.Z;
+            }
+            return result;
+        }
+
+        public float[] getVertexListAsFloatLocked()
+        {
+            if (m_pinnedVertexes.IsAllocated)
+                return (float[])(m_pinnedVertexes.Target);
+
+            float[] result = getVertexListAsFloat();
+            m_pinnedVertexes = GCHandle.Alloc(result, GCHandleType.Pinned);
+            // Inform the garbage collector of this unmanaged allocation so it can schedule
+            // the next GC round more intelligently
+            GC.AddMemoryPressure(Buffer.ByteLength(result));
+
+            return result;
+        }
+
+        public void getVertexListAsPtrToFloatArray(out IntPtr vertices, out int vertexStride, out int vertexCount)
+        {
+            // A vertex is 3 floats
+            
+            vertexStride = 3 * sizeof(float);
+
+            // If there isn't an unmanaged array allocated yet, do it now
+            if (m_verticesPtr == IntPtr.Zero)
+            {
+                float[] vertexList = getVertexListAsFloat();
+                // Each vertex is 3 elements (floats)
+                m_vertexCount = vertexList.Length / 3;
+                int byteCount = m_vertexCount * vertexStride;
+                m_verticesPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(byteCount);
+                System.Runtime.InteropServices.Marshal.Copy(vertexList, 0, m_verticesPtr, m_vertexCount * 3);
+            }
+            vertices = m_verticesPtr;
+            vertexCount = m_vertexCount;
+        }
+
+        public int[] getIndexListAsInt()
+        {
+            if (m_triangles == null)
+                throw new NotSupportedException();
+            int[] result = new int[m_triangles.Count * 3];
+            for (int i = 0; i < m_triangles.Count; i++)
+            {
+                Triangle t = m_triangles[i];
+                result[3 * i + 0] = m_vertices[t.v1];
+                result[3 * i + 1] = m_vertices[t.v2];
+                result[3 * i + 2] = m_vertices[t.v3];
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// creates a list of index values that defines triangle faces. THIS METHOD FREES ALL NON-PINNED MESH DATA
+        /// </summary>
+        /// <returns></returns>
+        public int[] getIndexListAsIntLocked()
+        {
+            if (m_pinnedIndex.IsAllocated)
+                return (int[])(m_pinnedIndex.Target);
+        
+            int[] result = getIndexListAsInt();
+            m_pinnedIndex = GCHandle.Alloc(result, GCHandleType.Pinned);
+            // Inform the garbage collector of this unmanaged allocation so it can schedule
+            // the next GC round more intelligently
+            GC.AddMemoryPressure(Buffer.ByteLength(result));
+
+            return result;
+        }
+
+        public void getIndexListAsPtrToIntArray(out IntPtr indices, out int triStride, out int indexCount)
+        {
+            // If there isn't an unmanaged array allocated yet, do it now
+            if (m_indicesPtr == IntPtr.Zero)
+            {
+                int[] indexList = getIndexListAsInt();
+                m_indexCount = indexList.Length;
+                int byteCount = m_indexCount * sizeof(int);
+                m_indicesPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(byteCount);
+                System.Runtime.InteropServices.Marshal.Copy(indexList, 0, m_indicesPtr, m_indexCount);
+            }
+            // A triangle is 3 ints (indices)
+            triStride = 3 * sizeof(int);
+            indices = m_indicesPtr;
+            indexCount = m_indexCount;
+        }
+
+        public void releasePinned()
+        {
+            if (m_pinnedVertexes.IsAllocated)
+                m_pinnedVertexes.Free();
+            if (m_pinnedIndex.IsAllocated)
+                m_pinnedIndex.Free();
+            if (m_verticesPtr != IntPtr.Zero)
+            {
+                System.Runtime.InteropServices.Marshal.FreeHGlobal(m_verticesPtr);
+                m_verticesPtr = IntPtr.Zero;
+            }
+            if (m_indicesPtr != IntPtr.Zero)
+            {
+                System.Runtime.InteropServices.Marshal.FreeHGlobal(m_indicesPtr);
+                m_indicesPtr = IntPtr.Zero;
+            }
+        }
+
+        /// <summary>
+        /// frees up the source mesh data to minimize memory - call this method after calling get*Locked() functions
+        /// </summary>
+        public void releaseSourceMeshData()
+        {
+            m_triangles = null;
+            m_vertices = null;
+        }
+
+        public void Append(IMesh newMesh)
+        {
+            if (m_pinnedIndex.IsAllocated || m_pinnedVertexes.IsAllocated || m_indicesPtr != IntPtr.Zero || m_verticesPtr != IntPtr.Zero)
+                throw new NotSupportedException("Attempt to Append to a pinned Mesh");
+        
+            if (!(newMesh is Mesh))
+                return;
+
+            foreach (Triangle t in ((Mesh)newMesh).m_triangles)
+                Add(t);
+        }
+
+        // Do a linear transformation of  mesh.
+        public void TransformLinear(float[,] matrix, float[] offset)
+        {
+            if (m_pinnedIndex.IsAllocated || m_pinnedVertexes.IsAllocated || m_indicesPtr != IntPtr.Zero || m_verticesPtr != IntPtr.Zero)
+                throw new NotSupportedException("Attempt to TransformLinear a pinned Mesh");
+        
+            foreach (Vertex v in m_vertices.Keys)
+            {
+                if (v == null)
+                    continue;
+                float x, y, z;
+                x = v.X*matrix[0, 0] + v.Y*matrix[1, 0] + v.Z*matrix[2, 0];
+                y = v.X*matrix[0, 1] + v.Y*matrix[1, 1] + v.Z*matrix[2, 1];
+                z = v.X*matrix[0, 2] + v.Y*matrix[1, 2] + v.Z*matrix[2, 2];
+                v.X = x + offset[0];
+                v.Y = y + offset[1];
+                v.Z = z + offset[2];
+            }
+        }
+
+        public void DumpRaw(String path, String name, String title)
+        {
+            if (path == null)
+                return;
+            String fileName = name + "_" + title + ".raw";
+            String completePath = System.IO.Path.Combine(path, fileName);
+            StreamWriter sw = new StreamWriter(completePath);
+            foreach (Triangle t in m_triangles)
+            {
+                String s = t.ToStringRaw();
+                sw.WriteLine(s);
+            }
+            sw.Close();
+        }
+
+        public void TrimExcess()
+        {
+            m_triangles.TrimExcess();
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs
new file mode 100644
index 0000000..bae3449
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs
@@ -0,0 +1,1027 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+//#define SPAM
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.IO;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO.Compression;
+using PrimMesher;
+using log4net;
+using Nini.Config;
+using Mono.Addins;
+
+namespace OpenSim.Region.PhysicsModules.Meshing
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "Meshmerizer")]
+    public class Meshmerizer : IMesher, INonSharedRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[MESH]";
+
+        // Setting baseDir to a path will enable the dumping of raw files
+        // raw files can be imported by blender so a visual inspection of the results can be done
+#if SPAM
+        const string baseDir = "rawFiles";
+#else
+        private const string baseDir = null; //"rawFiles";
+#endif
+        private bool m_Enabled = false;
+
+        // If 'true', lots of DEBUG logging of asset parsing details
+        private bool debugDetail = false;
+
+        private bool cacheSculptMaps = true;
+        private string decodedSculptMapPath = null;
+        private bool useMeshiesPhysicsMesh = false;
+
+        private float minSizeForComplexMesh = 0.2f; // prims with all dimensions smaller than this will have a bounding box mesh
+
+        private List<List<Vector3>> mConvexHulls = null;
+        private List<Vector3> mBoundingHull = null;
+
+        // Mesh cache. Static so it can be shared across instances of this class
+        private static Dictionary<ulong, Mesh> m_uniqueMeshes = new Dictionary<ulong, Mesh>();
+
+        #region INonSharedRegionModule
+        public string Name
+        {
+            get { return "Meshmerizer"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            IConfig config = source.Configs["Startup"];
+            if (config != null)
+            {
+                string mesher = config.GetString("meshing", string.Empty);
+                if (mesher == Name)
+                {
+                    m_Enabled = true;
+
+                    IConfig mesh_config = source.Configs["Mesh"];
+
+                    decodedSculptMapPath = config.GetString("DecodedSculptMapPath", "j2kDecodeCache");
+                    cacheSculptMaps = config.GetBoolean("CacheSculptMaps", cacheSculptMaps);
+                    if (mesh_config != null)
+                    {
+                        useMeshiesPhysicsMesh = mesh_config.GetBoolean("UseMeshiesPhysicsMesh", useMeshiesPhysicsMesh);
+                        debugDetail = mesh_config.GetBoolean("LogMeshDetails", debugDetail);
+                    }
+
+                    try
+                    {
+                        if (!Directory.Exists(decodedSculptMapPath))
+                            Directory.CreateDirectory(decodedSculptMapPath);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.WarnFormat("[SCULPT]: Unable to create {0} directory: ", decodedSculptMapPath, e.Message);
+                    }
+
+                }
+            }
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            scene.RegisterModuleInterface<IMesher>(this);
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            scene.UnregisterModuleInterface<IMesher>(this);
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+        }
+        #endregion
+
+
+        /// <summary>
+        /// creates a simple box mesh of the specified size. This mesh is of very low vertex count and may
+        /// be useful as a backup proxy when level of detail is not needed or when more complex meshes fail
+        /// for some reason
+        /// </summary>
+        /// <param name="minX"></param>
+        /// <param name="maxX"></param>
+        /// <param name="minY"></param>
+        /// <param name="maxY"></param>
+        /// <param name="minZ"></param>
+        /// <param name="maxZ"></param>
+        /// <returns></returns>
+        private static Mesh CreateSimpleBoxMesh(float minX, float maxX, float minY, float maxY, float minZ, float maxZ)
+        {
+            Mesh box = new Mesh();
+            List<Vertex> vertices = new List<Vertex>();
+            // bottom
+
+            vertices.Add(new Vertex(minX, maxY, minZ));
+            vertices.Add(new Vertex(maxX, maxY, minZ));
+            vertices.Add(new Vertex(maxX, minY, minZ));
+            vertices.Add(new Vertex(minX, minY, minZ));
+
+            box.Add(new Triangle(vertices[0], vertices[1], vertices[2]));
+            box.Add(new Triangle(vertices[0], vertices[2], vertices[3]));
+
+            // top
+
+            vertices.Add(new Vertex(maxX, maxY, maxZ));
+            vertices.Add(new Vertex(minX, maxY, maxZ));
+            vertices.Add(new Vertex(minX, minY, maxZ));
+            vertices.Add(new Vertex(maxX, minY, maxZ));
+
+            box.Add(new Triangle(vertices[4], vertices[5], vertices[6]));
+            box.Add(new Triangle(vertices[4], vertices[6], vertices[7]));
+
+            // sides
+
+            box.Add(new Triangle(vertices[5], vertices[0], vertices[3]));
+            box.Add(new Triangle(vertices[5], vertices[3], vertices[6]));
+
+            box.Add(new Triangle(vertices[1], vertices[0], vertices[5]));
+            box.Add(new Triangle(vertices[1], vertices[5], vertices[4]));
+
+            box.Add(new Triangle(vertices[7], vertices[1], vertices[4]));
+            box.Add(new Triangle(vertices[7], vertices[2], vertices[1]));
+
+            box.Add(new Triangle(vertices[3], vertices[2], vertices[7]));
+            box.Add(new Triangle(vertices[3], vertices[7], vertices[6]));
+
+            return box;
+        }
+
+        /// <summary>
+        /// Creates a simple bounding box mesh for a complex input mesh
+        /// </summary>
+        /// <param name="meshIn"></param>
+        /// <returns></returns>
+        private static Mesh CreateBoundingBoxMesh(Mesh meshIn)
+        {
+            float minX = float.MaxValue;
+            float maxX = float.MinValue;
+            float minY = float.MaxValue;
+            float maxY = float.MinValue;
+            float minZ = float.MaxValue;
+            float maxZ = float.MinValue;
+
+            foreach (Vector3 v in meshIn.getVertexList())
+            {
+                if (v.X < minX) minX = v.X;
+                if (v.Y < minY) minY = v.Y;
+                if (v.Z < minZ) minZ = v.Z;
+
+                if (v.X > maxX) maxX = v.X;
+                if (v.Y > maxY) maxY = v.Y;
+                if (v.Z > maxZ) maxZ = v.Z;
+            }
+
+            return CreateSimpleBoxMesh(minX, maxX, minY, maxY, minZ, maxZ);
+        }
+
+        private void ReportPrimError(string message, string primName, PrimMesh primMesh)
+        {
+            m_log.Error(message);
+            m_log.Error("\nPrim Name: " + primName);
+            m_log.Error("****** PrimMesh Parameters ******\n" + primMesh.ParamsToDisplayString());
+        }
+
+        /// <summary>
+        /// Add a submesh to an existing list of coords and faces.
+        /// </summary>
+        /// <param name="subMeshData"></param>
+        /// <param name="size">Size of entire object</param>
+        /// <param name="coords"></param>
+        /// <param name="faces"></param>
+        private void AddSubMesh(OSDMap subMeshData, Vector3 size, List<Coord> coords, List<Face> faces)
+        {
+    //                                    Console.WriteLine("subMeshMap for {0} - {1}", primName, Util.GetFormattedXml((OSD)subMeshMap));
+    
+            // As per http://wiki.secondlife.com/wiki/Mesh/Mesh_Asset_Format, some Mesh Level
+            // of Detail Blocks (maps) contain just a NoGeometry key to signal there is no
+            // geometry for this submesh.
+            if (subMeshData.ContainsKey("NoGeometry") && ((OSDBoolean)subMeshData["NoGeometry"]))
+                return;
+    
+            OpenMetaverse.Vector3 posMax = ((OSDMap)subMeshData["PositionDomain"])["Max"].AsVector3();
+            OpenMetaverse.Vector3 posMin = ((OSDMap)subMeshData["PositionDomain"])["Min"].AsVector3();
+            ushort faceIndexOffset = (ushort)coords.Count;
+
+            byte[] posBytes = subMeshData["Position"].AsBinary();
+            for (int i = 0; i < posBytes.Length; i += 6)
+            {
+                ushort uX = Utils.BytesToUInt16(posBytes, i);
+                ushort uY = Utils.BytesToUInt16(posBytes, i + 2);
+                ushort uZ = Utils.BytesToUInt16(posBytes, i + 4);
+    
+                Coord c = new Coord(
+                Utils.UInt16ToFloat(uX, posMin.X, posMax.X) * size.X,
+                Utils.UInt16ToFloat(uY, posMin.Y, posMax.Y) * size.Y,
+                Utils.UInt16ToFloat(uZ, posMin.Z, posMax.Z) * size.Z);
+    
+                coords.Add(c);
+            }
+    
+            byte[] triangleBytes = subMeshData["TriangleList"].AsBinary();
+            for (int i = 0; i < triangleBytes.Length; i += 6)
+            {
+                ushort v1 = (ushort)(Utils.BytesToUInt16(triangleBytes, i) + faceIndexOffset);
+                ushort v2 = (ushort)(Utils.BytesToUInt16(triangleBytes, i + 2) + faceIndexOffset);
+                ushort v3 = (ushort)(Utils.BytesToUInt16(triangleBytes, i + 4) + faceIndexOffset);
+                Face f = new Face(v1, v2, v3);
+                faces.Add(f);
+            }
+        }
+
+        /// <summary>
+        /// Create a physics mesh from data that comes with the prim.  The actual data used depends on the prim type.
+        /// </summary>
+        /// <param name="primName"></param>
+        /// <param name="primShape"></param>
+        /// <param name="size"></param>
+        /// <param name="lod"></param>
+        /// <returns></returns>
+        private Mesh CreateMeshFromPrimMesher(string primName, PrimitiveBaseShape primShape, Vector3 size, float lod)
+        {
+//            m_log.DebugFormat(
+//                "[MESH]: Creating physics proxy for {0}, shape {1}",
+//                primName, (OpenMetaverse.SculptType)primShape.SculptType);
+
+            List<Coord> coords;
+            List<Face> faces;
+
+            if (primShape.SculptEntry)
+            {
+                if (((OpenMetaverse.SculptType)primShape.SculptType) == SculptType.Mesh)
+                {
+                    if (!useMeshiesPhysicsMesh)
+                        return null;
+
+                    if (!GenerateCoordsAndFacesFromPrimMeshData(primName, primShape, size, out coords, out faces))
+                        return null;
+                }
+                else
+                {
+                    if (!GenerateCoordsAndFacesFromPrimSculptData(primName, primShape, size, lod, out coords, out faces))
+                        return null;
+                }
+            }
+            else
+            {
+                if (!GenerateCoordsAndFacesFromPrimShapeData(primName, primShape, size, lod, out coords, out faces))
+                    return null;
+            }
+
+            // Remove the reference to any JPEG2000 sculpt data so it can be GCed
+            primShape.SculptData = Utils.EmptyBytes;
+
+            int numCoords = coords.Count;
+            int numFaces = faces.Count;
+
+            // Create the list of vertices
+            List<Vertex> vertices = new List<Vertex>();
+            for (int i = 0; i < numCoords; i++)
+            {
+                Coord c = coords[i];
+                vertices.Add(new Vertex(c.X, c.Y, c.Z));
+            }
+
+            Mesh mesh = new Mesh();
+            // Add the corresponding triangles to the mesh
+            for (int i = 0; i < numFaces; i++)
+            {
+                Face f = faces[i];
+                mesh.Add(new Triangle(vertices[f.v1], vertices[f.v2], vertices[f.v3]));
+            }
+
+            return mesh;
+        }
+
+        /// <summary>
+        /// Generate the co-ords and faces necessary to construct a mesh from the mesh data the accompanies a prim.
+        /// </summary>
+        /// <param name="primName"></param>
+        /// <param name="primShape"></param>
+        /// <param name="size"></param>
+        /// <param name="coords">Coords are added to this list by the method.</param>
+        /// <param name="faces">Faces are added to this list by the method.</param>
+        /// <returns>true if coords and faces were successfully generated, false if not</returns>
+        private bool GenerateCoordsAndFacesFromPrimMeshData(
+            string primName, PrimitiveBaseShape primShape, Vector3 size, out List<Coord> coords, out List<Face> faces)
+        {
+//            m_log.DebugFormat("[MESH]: experimental mesh proxy generation for {0}", primName);
+
+            coords = new List<Coord>();
+            faces = new List<Face>();
+            OSD meshOsd = null;
+
+            mConvexHulls = null;
+            mBoundingHull = null;
+
+            if (primShape.SculptData.Length <= 0)
+            {
+                // XXX: At the moment we can not log here since ODEPrim, for instance, ends up triggering this
+                // method twice - once before it has loaded sculpt data from the asset service and once afterwards.
+                // The first time will always call with unloaded SculptData if this needs to be uploaded.
+//                m_log.ErrorFormat("[MESH]: asset data for {0} is zero length", primName);
+                return false;
+            }
+
+            long start = 0;
+            using (MemoryStream data = new MemoryStream(primShape.SculptData))
+            {
+                try
+                {
+                    OSD osd = OSDParser.DeserializeLLSDBinary(data);
+                    if (osd is OSDMap)
+                        meshOsd = (OSDMap)osd;
+                    else
+                    {
+                        m_log.Warn("[Mesh}: unable to cast mesh asset to OSDMap");
+                        return false;
+                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.Error("[MESH]: Exception deserializing mesh asset header:" + e.ToString());
+                }
+
+                start = data.Position;
+            }
+
+            if (meshOsd is OSDMap)
+            {
+                OSDMap physicsParms = null;
+                OSDMap map = (OSDMap)meshOsd;
+                if (map.ContainsKey("physics_shape"))
+                {
+                    physicsParms = (OSDMap)map["physics_shape"]; // old asset format
+                    if (debugDetail) m_log.DebugFormat("{0} prim='{1}': using 'physics_shape' mesh data", LogHeader, primName);
+                }
+                else if (map.ContainsKey("physics_mesh"))
+                {
+                    physicsParms = (OSDMap)map["physics_mesh"]; // new asset format
+                    if (debugDetail) m_log.DebugFormat("{0} prim='{1}':using 'physics_mesh' mesh data", LogHeader, primName);
+                }
+                else if (map.ContainsKey("medium_lod"))
+                {
+                    physicsParms = (OSDMap)map["medium_lod"]; // if no physics mesh, try to fall back to medium LOD display mesh
+                    if (debugDetail) m_log.DebugFormat("{0} prim='{1}':using 'medium_lod' mesh data", LogHeader, primName);
+                }
+                else if (map.ContainsKey("high_lod"))
+                {
+                    physicsParms = (OSDMap)map["high_lod"]; // if all else fails, use highest LOD display mesh and hope it works :)
+                    if (debugDetail) m_log.DebugFormat("{0} prim='{1}':using 'high_lod' mesh data", LogHeader, primName);
+                }
+
+                if (map.ContainsKey("physics_convex"))
+                { // pull this out also in case physics engine can use it
+                    OSD convexBlockOsd = null;
+                    try
+                    {
+                        OSDMap convexBlock = (OSDMap)map["physics_convex"];
+                        {
+                            int convexOffset = convexBlock["offset"].AsInteger() + (int)start;
+                            int convexSize = convexBlock["size"].AsInteger();
+
+                            byte[] convexBytes = new byte[convexSize];
+                            
+                            System.Buffer.BlockCopy(primShape.SculptData, convexOffset, convexBytes, 0, convexSize);
+                            
+                            try
+                            {
+                                convexBlockOsd = DecompressOsd(convexBytes);
+                            }
+                            catch (Exception e)
+                            {
+                                m_log.ErrorFormat("{0} prim='{1}': exception decoding convex block: {2}", LogHeader, primName, e);
+                                //return false;
+                            }
+                        }
+                        
+                        if (convexBlockOsd != null && convexBlockOsd is OSDMap)
+                        {
+                            convexBlock = convexBlockOsd as OSDMap;
+
+                            if (debugDetail)
+                            {
+                                string keys = LogHeader + " keys found in convexBlock: ";
+                                foreach (KeyValuePair<string, OSD> kvp in convexBlock)
+                                    keys += "'" + kvp.Key + "' ";
+                                m_log.Debug(keys);
+                            }
+
+                            Vector3 min = new Vector3(-0.5f, -0.5f, -0.5f);
+                            if (convexBlock.ContainsKey("Min")) min = convexBlock["Min"].AsVector3();
+                            Vector3 max = new Vector3(0.5f, 0.5f, 0.5f);
+                            if (convexBlock.ContainsKey("Max")) max = convexBlock["Max"].AsVector3();
+
+                            List<Vector3> boundingHull = null;
+
+                            if (convexBlock.ContainsKey("BoundingVerts"))
+                            {
+                                byte[] boundingVertsBytes = convexBlock["BoundingVerts"].AsBinary();
+                                boundingHull = new List<Vector3>();
+                                for (int i = 0; i < boundingVertsBytes.Length; )
+                                {
+                                    ushort uX = Utils.BytesToUInt16(boundingVertsBytes, i); i += 2;
+                                    ushort uY = Utils.BytesToUInt16(boundingVertsBytes, i); i += 2;
+                                    ushort uZ = Utils.BytesToUInt16(boundingVertsBytes, i); i += 2;
+
+                                    Vector3 pos = new Vector3(
+                                        Utils.UInt16ToFloat(uX, min.X, max.X),
+                                        Utils.UInt16ToFloat(uY, min.Y, max.Y),
+                                        Utils.UInt16ToFloat(uZ, min.Z, max.Z)
+                                    );
+
+                                    boundingHull.Add(pos);
+                                }
+
+                                mBoundingHull = boundingHull;
+                                if (debugDetail) m_log.DebugFormat("{0} prim='{1}': parsed bounding hull. nVerts={2}", LogHeader, primName, mBoundingHull.Count);
+                            }
+
+                            if (convexBlock.ContainsKey("HullList"))
+                            {
+                                byte[] hullList = convexBlock["HullList"].AsBinary();
+
+                                byte[] posBytes = convexBlock["Positions"].AsBinary();
+
+                                List<List<Vector3>> hulls = new List<List<Vector3>>();
+                                int posNdx = 0;
+
+                                foreach (byte cnt in hullList)
+                                {
+                                    int count = cnt == 0 ? 256 : cnt;
+                                    List<Vector3> hull = new List<Vector3>();
+
+                                    for (int i = 0; i < count; i++)
+                                    {
+                                        ushort uX = Utils.BytesToUInt16(posBytes, posNdx); posNdx += 2;
+                                        ushort uY = Utils.BytesToUInt16(posBytes, posNdx); posNdx += 2;
+                                        ushort uZ = Utils.BytesToUInt16(posBytes, posNdx); posNdx += 2;
+
+                                        Vector3 pos = new Vector3(
+                                            Utils.UInt16ToFloat(uX, min.X, max.X),
+                                            Utils.UInt16ToFloat(uY, min.Y, max.Y),
+                                            Utils.UInt16ToFloat(uZ, min.Z, max.Z)
+                                        );
+
+                                        hull.Add(pos);
+                                    }
+
+                                    hulls.Add(hull);
+                                }
+
+                                mConvexHulls = hulls;
+                                if (debugDetail) m_log.DebugFormat("{0} prim='{1}': parsed hulls. nHulls={2}", LogHeader, primName, mConvexHulls.Count);
+                            }
+                            else
+                            {
+                                if (debugDetail) m_log.DebugFormat("{0} prim='{1}' has physics_convex but no HullList", LogHeader, primName);
+                            }
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.WarnFormat("{0} exception decoding convex block: {1}", LogHeader, e);
+                    }
+                }
+
+                if (physicsParms == null)
+                {
+                    m_log.WarnFormat("[MESH]: No recognized physics mesh found in mesh asset for {0}", primName);
+                    return false;
+                }
+
+                int physOffset = physicsParms["offset"].AsInteger() + (int)start;
+                int physSize = physicsParms["size"].AsInteger();
+
+                if (physOffset < 0 || physSize == 0)
+                    return false; // no mesh data in asset
+
+                OSD decodedMeshOsd = new OSD();
+                byte[] meshBytes = new byte[physSize];
+                System.Buffer.BlockCopy(primShape.SculptData, physOffset, meshBytes, 0, physSize);
+                //                        byte[] decompressed = new byte[physSize * 5];
+                try
+                {
+                    decodedMeshOsd = DecompressOsd(meshBytes);
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat("{0} prim='{1}': exception decoding physical mesh: {2}", LogHeader, primName, e);
+                    return false;
+                }
+
+                OSDArray decodedMeshOsdArray = null;
+
+                // physics_shape is an array of OSDMaps, one for each submesh
+                if (decodedMeshOsd is OSDArray)
+                {
+                    //                            Console.WriteLine("decodedMeshOsd for {0} - {1}", primName, Util.GetFormattedXml(decodedMeshOsd));
+
+                    decodedMeshOsdArray = (OSDArray)decodedMeshOsd;
+                    foreach (OSD subMeshOsd in decodedMeshOsdArray)
+                    {
+                        if (subMeshOsd is OSDMap)
+                            AddSubMesh(subMeshOsd as OSDMap, size, coords, faces);
+                    }
+                    if (debugDetail)
+                        m_log.DebugFormat("{0} {1}: mesh decoded. offset={2}, size={3}, nCoords={4}, nFaces={5}",
+                                            LogHeader, primName, physOffset, physSize, coords.Count, faces.Count);
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// decompresses a gzipped OSD object
+        /// </summary>
+        /// <param name="decodedOsd"></param> the OSD object
+        /// <param name="meshBytes"></param>
+        /// <returns></returns>
+        private static OSD DecompressOsd(byte[] meshBytes)
+        {
+            OSD decodedOsd = null;
+
+            using (MemoryStream inMs = new MemoryStream(meshBytes))
+            {
+                using (MemoryStream outMs = new MemoryStream())
+                {
+                    using (DeflateStream decompressionStream = new DeflateStream(inMs, CompressionMode.Decompress))
+                    {
+                        byte[] readBuffer = new byte[2048];
+                        inMs.Read(readBuffer, 0, 2); // skip first 2 bytes in header
+                        int readLen = 0;
+
+                        while ((readLen = decompressionStream.Read(readBuffer, 0, readBuffer.Length)) > 0)
+                            outMs.Write(readBuffer, 0, readLen);
+
+                        outMs.Flush();
+
+                        outMs.Seek(0, SeekOrigin.Begin);
+
+                        byte[] decompressedBuf = outMs.GetBuffer();
+
+                        decodedOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
+                    }
+                }
+            }
+            return decodedOsd;
+        }
+
+        /// <summary>
+        /// Generate the co-ords and faces necessary to construct a mesh from the sculpt data the accompanies a prim.
+        /// </summary>
+        /// <param name="primName"></param>
+        /// <param name="primShape"></param>
+        /// <param name="size"></param>
+        /// <param name="lod"></param>
+        /// <param name="coords">Coords are added to this list by the method.</param>
+        /// <param name="faces">Faces are added to this list by the method.</param>
+        /// <returns>true if coords and faces were successfully generated, false if not</returns>
+        private bool GenerateCoordsAndFacesFromPrimSculptData(
+            string primName, PrimitiveBaseShape primShape, Vector3 size, float lod, out List<Coord> coords, out List<Face> faces)
+        {
+            coords = new List<Coord>();
+            faces = new List<Face>();
+            PrimMesher.SculptMesh sculptMesh;
+            Image idata = null;
+            string decodedSculptFileName = "";
+
+            if (cacheSculptMaps && primShape.SculptTexture != UUID.Zero)
+            {
+                decodedSculptFileName = System.IO.Path.Combine(decodedSculptMapPath, "smap_" + primShape.SculptTexture.ToString());
+                try
+                {
+                    if (File.Exists(decodedSculptFileName))
+                    {
+                        idata = Image.FromFile(decodedSculptFileName);
+                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.Error("[SCULPT]: unable to load cached sculpt map " + decodedSculptFileName + " " + e.Message);
+
+                }
+                //if (idata != null)
+                //    m_log.Debug("[SCULPT]: loaded cached map asset for map ID: " + primShape.SculptTexture.ToString());
+            }
+
+            if (idata == null)
+            {
+                if (primShape.SculptData == null || primShape.SculptData.Length == 0)
+                    return false;
+
+                try
+                {
+                    OpenMetaverse.Imaging.ManagedImage managedImage;
+
+                    OpenMetaverse.Imaging.OpenJPEG.DecodeToImage(primShape.SculptData, out managedImage);
+
+                    if (managedImage == null)
+                    {
+                        // In some cases it seems that the decode can return a null bitmap without throwing
+                        // an exception
+                        m_log.WarnFormat("[PHYSICS]: OpenJPEG decoded sculpt data for {0} to a null bitmap.  Ignoring.", primName);
+
+                        return false;
+                    }
+
+                    if ((managedImage.Channels & OpenMetaverse.Imaging.ManagedImage.ImageChannels.Alpha) != 0)
+                        managedImage.ConvertChannels(managedImage.Channels & ~OpenMetaverse.Imaging.ManagedImage.ImageChannels.Alpha);
+
+                    Bitmap imgData = OpenMetaverse.Imaging.LoadTGAClass.LoadTGA(new MemoryStream(managedImage.ExportTGA()));
+                    idata = (Image)imgData;
+                    managedImage = null;
+
+                    if (cacheSculptMaps)
+                    {
+                        try { idata.Save(decodedSculptFileName, ImageFormat.MemoryBmp); }
+                        catch (Exception e) { m_log.Error("[SCULPT]: unable to cache sculpt map " + decodedSculptFileName + " " + e.Message); }
+                    }
+                }
+                catch (DllNotFoundException)
+                {
+                    m_log.Error("[PHYSICS]: OpenJpeg is not installed correctly on this system. Physics Proxy generation failed.  Often times this is because of an old version of GLIBC.  You must have version 2.4 or above!");
+                    return false;
+                }
+                catch (IndexOutOfRangeException)
+                {
+                    m_log.Error("[PHYSICS]: OpenJpeg was unable to decode this. Physics Proxy generation failed");
+                    return false;
+                }
+                catch (Exception ex)
+                {
+                    m_log.Error("[PHYSICS]: Unable to generate a Sculpty physics proxy. Sculpty texture decode failed: " + ex.Message);
+                    return false;
+                }
+            }
+
+            PrimMesher.SculptMesh.SculptType sculptType;
+            switch ((OpenMetaverse.SculptType)primShape.SculptType)
+            {
+                case OpenMetaverse.SculptType.Cylinder:
+                    sculptType = PrimMesher.SculptMesh.SculptType.cylinder;
+                    break;
+                case OpenMetaverse.SculptType.Plane:
+                    sculptType = PrimMesher.SculptMesh.SculptType.plane;
+                    break;
+                case OpenMetaverse.SculptType.Torus:
+                    sculptType = PrimMesher.SculptMesh.SculptType.torus;
+                    break;
+                case OpenMetaverse.SculptType.Sphere:
+                    sculptType = PrimMesher.SculptMesh.SculptType.sphere;
+                    break;
+                default:
+                    sculptType = PrimMesher.SculptMesh.SculptType.plane;
+                    break;
+            }
+
+            bool mirror = ((primShape.SculptType & 128) != 0);
+            bool invert = ((primShape.SculptType & 64) != 0);
+
+            sculptMesh = new PrimMesher.SculptMesh((Bitmap)idata, sculptType, (int)lod, false, mirror, invert);
+
+            idata.Dispose();
+
+            sculptMesh.DumpRaw(baseDir, primName, "primMesh");
+
+            sculptMesh.Scale(size.X, size.Y, size.Z);
+
+            coords = sculptMesh.coords;
+            faces = sculptMesh.faces;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Generate the co-ords and faces necessary to construct a mesh from the shape data the accompanies a prim.
+        /// </summary>
+        /// <param name="primName"></param>
+        /// <param name="primShape"></param>
+        /// <param name="size"></param>
+        /// <param name="coords">Coords are added to this list by the method.</param>
+        /// <param name="faces">Faces are added to this list by the method.</param>
+        /// <returns>true if coords and faces were successfully generated, false if not</returns>
+        private bool GenerateCoordsAndFacesFromPrimShapeData(
+            string primName, PrimitiveBaseShape primShape, Vector3 size, float lod, out List<Coord> coords, out List<Face> faces)
+        {
+            PrimMesh primMesh;
+            coords = new List<Coord>();
+            faces = new List<Face>();            
+
+            float pathShearX = primShape.PathShearX < 128 ? (float)primShape.PathShearX * 0.01f : (float)(primShape.PathShearX - 256) * 0.01f;
+            float pathShearY = primShape.PathShearY < 128 ? (float)primShape.PathShearY * 0.01f : (float)(primShape.PathShearY - 256) * 0.01f;
+            float pathBegin = (float)primShape.PathBegin * 2.0e-5f;
+            float pathEnd = 1.0f - (float)primShape.PathEnd * 2.0e-5f;
+            float pathScaleX = (float)(primShape.PathScaleX - 100) * 0.01f;
+            float pathScaleY = (float)(primShape.PathScaleY - 100) * 0.01f;
+
+            float profileBegin = (float)primShape.ProfileBegin * 2.0e-5f;
+            float profileEnd = 1.0f - (float)primShape.ProfileEnd * 2.0e-5f;
+            float profileHollow = (float)primShape.ProfileHollow * 2.0e-5f;
+            if (profileHollow > 0.95f)
+                profileHollow = 0.95f;
+
+            int sides = 4;
+            LevelOfDetail iLOD = (LevelOfDetail)lod;
+            if ((primShape.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle)
+                sides = 3;
+            else if ((primShape.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
+            {
+                switch (iLOD)
+                {
+                    case LevelOfDetail.High:    sides = 24;     break;
+                    case LevelOfDetail.Medium:  sides = 12;     break;
+                    case LevelOfDetail.Low:     sides = 6;      break;
+                    case LevelOfDetail.VeryLow: sides = 3;      break;
+                    default:                    sides = 24;     break;
+                }
+            }
+            else if ((primShape.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle)
+            { // half circle, prim is a sphere
+                switch (iLOD)
+                {
+                    case LevelOfDetail.High:    sides = 24;     break;
+                    case LevelOfDetail.Medium:  sides = 12;     break;
+                    case LevelOfDetail.Low:     sides = 6;      break;
+                    case LevelOfDetail.VeryLow: sides = 3;      break;
+                    default:                    sides = 24;     break;
+                }
+
+                profileBegin = 0.5f * profileBegin + 0.5f;
+                profileEnd = 0.5f * profileEnd + 0.5f;
+            }
+
+            int hollowSides = sides;
+            if (primShape.HollowShape == HollowShape.Circle)
+            {
+                switch (iLOD)
+                {
+                    case LevelOfDetail.High:    hollowSides = 24;     break;
+                    case LevelOfDetail.Medium:  hollowSides = 12;     break;
+                    case LevelOfDetail.Low:     hollowSides = 6;      break;
+                    case LevelOfDetail.VeryLow: hollowSides = 3;      break;
+                    default:                    hollowSides = 24;     break;
+                }
+            }
+            else if (primShape.HollowShape == HollowShape.Square)
+                hollowSides = 4;
+            else if (primShape.HollowShape == HollowShape.Triangle)
+                hollowSides = 3;
+
+            primMesh = new PrimMesh(sides, profileBegin, profileEnd, profileHollow, hollowSides);
+
+            if (primMesh.errorMessage != null)
+                if (primMesh.errorMessage.Length > 0)
+                    m_log.Error("[ERROR] " + primMesh.errorMessage);
+
+            primMesh.topShearX = pathShearX;
+            primMesh.topShearY = pathShearY;
+            primMesh.pathCutBegin = pathBegin;
+            primMesh.pathCutEnd = pathEnd;
+
+            if (primShape.PathCurve == (byte)Extrusion.Straight || primShape.PathCurve == (byte) Extrusion.Flexible)
+            {
+                primMesh.twistBegin = primShape.PathTwistBegin * 18 / 10;
+                primMesh.twistEnd = primShape.PathTwist * 18 / 10;
+                primMesh.taperX = pathScaleX;
+                primMesh.taperY = pathScaleY;
+
+                if (profileBegin < 0.0f || profileBegin >= profileEnd || profileEnd > 1.0f)
+                {
+                    ReportPrimError("*** CORRUPT PRIM!! ***", primName, primMesh);
+                    if (profileBegin < 0.0f) profileBegin = 0.0f;
+                    if (profileEnd > 1.0f) profileEnd = 1.0f;
+                }
+#if SPAM
+            m_log.Debug("****** PrimMesh Parameters (Linear) ******\n" + primMesh.ParamsToDisplayString());
+#endif
+                try
+                {
+                    primMesh.ExtrudeLinear();
+                }
+                catch (Exception ex)
+                {
+                    ReportPrimError("Extrusion failure: exception: " + ex.ToString(), primName, primMesh);
+                    return false;
+                }
+            }
+            else
+            {
+                primMesh.holeSizeX = (200 - primShape.PathScaleX) * 0.01f;
+                primMesh.holeSizeY = (200 - primShape.PathScaleY) * 0.01f;
+                primMesh.radius = 0.01f * primShape.PathRadiusOffset;
+                primMesh.revolutions = 1.0f + 0.015f * primShape.PathRevolutions;
+                primMesh.skew = 0.01f * primShape.PathSkew;
+                primMesh.twistBegin = primShape.PathTwistBegin * 36 / 10;
+                primMesh.twistEnd = primShape.PathTwist * 36 / 10;
+                primMesh.taperX = primShape.PathTaperX * 0.01f;
+                primMesh.taperY = primShape.PathTaperY * 0.01f;
+
+                if (profileBegin < 0.0f || profileBegin >= profileEnd || profileEnd > 1.0f)
+                {
+                    ReportPrimError("*** CORRUPT PRIM!! ***", primName, primMesh);
+                    if (profileBegin < 0.0f) profileBegin = 0.0f;
+                    if (profileEnd > 1.0f) profileEnd = 1.0f;
+                }
+#if SPAM
+            m_log.Debug("****** PrimMesh Parameters (Circular) ******\n" + primMesh.ParamsToDisplayString());
+#endif
+                try
+                {
+                    primMesh.ExtrudeCircular();
+                }
+                catch (Exception ex)
+                {
+                    ReportPrimError("Extrusion failure: exception: " + ex.ToString(), primName, primMesh);
+                    return false;
+                }
+            }
+
+            primMesh.DumpRaw(baseDir, primName, "primMesh");
+
+            primMesh.Scale(size.X, size.Y, size.Z);
+
+            coords = primMesh.coords;
+            faces = primMesh.faces;
+
+            return true;
+        }
+
+        /// <summary>
+        /// temporary prototype code - please do not use until the interface has been finalized!
+        /// </summary>
+        /// <param name="size">value to scale the hull points by</param>
+        /// <returns>a list of vertices in the bounding hull if it exists and has been successfully decoded, otherwise null</returns>
+        public List<Vector3> GetBoundingHull(Vector3 size)
+        {
+            if (mBoundingHull == null)
+                return null;
+
+            List<Vector3> verts = new List<Vector3>();
+            foreach (var vert in mBoundingHull)
+                verts.Add(vert * size);
+
+            return verts;
+        }
+
+        /// <summary>
+        /// temporary prototype code - please do not use until the interface has been finalized!
+        /// </summary>
+        /// <param name="size">value to scale the hull points by</param>
+        /// <returns>a list of hulls if they exist and have been successfully decoded, otherwise null</returns>
+        public List<List<Vector3>> GetConvexHulls(Vector3 size)
+        {
+            if (mConvexHulls == null)
+                return null;
+
+            List<List<Vector3>> hulls = new List<List<Vector3>>();
+            foreach (var hull in mConvexHulls)
+            {
+                List<Vector3> verts = new List<Vector3>();
+                foreach (var vert in hull)
+                    verts.Add(vert * size);
+                hulls.Add(verts);
+            }
+
+            return hulls;
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod)
+        {
+            return CreateMesh(primName, primShape, size, lod, false, true);
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool shouldCache, bool convex, bool forOde)
+        {
+            return CreateMesh(primName, primShape, size, lod, false);
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical)
+        {
+            return CreateMesh(primName, primShape, size, lod, isPhysical, true);
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool convex, bool forOde)
+        {
+            return CreateMesh(primName, primShape, size, lod, isPhysical, true);
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool shouldCache)
+        {
+#if SPAM
+            m_log.DebugFormat("[MESH]: Creating mesh for {0}", primName);
+#endif
+
+            Mesh mesh = null;
+            ulong key = 0;
+
+            // If this mesh has been created already, return it instead of creating another copy
+            // For large regions with 100k+ prims and hundreds of copies of each, this can save a GB or more of memory
+            if (shouldCache)
+            {
+                key = primShape.GetMeshKey(size, lod);
+                lock (m_uniqueMeshes)
+                {
+                    if (m_uniqueMeshes.TryGetValue(key, out mesh))
+                        return mesh;
+                }
+            }
+
+            if (size.X < 0.01f) size.X = 0.01f;
+            if (size.Y < 0.01f) size.Y = 0.01f;
+            if (size.Z < 0.01f) size.Z = 0.01f;
+
+            mesh = CreateMeshFromPrimMesher(primName, primShape, size, lod);
+
+            if (mesh != null)
+            {
+                if ((!isPhysical) && size.X < minSizeForComplexMesh && size.Y < minSizeForComplexMesh && size.Z < minSizeForComplexMesh)
+                {
+#if SPAM
+                m_log.Debug("Meshmerizer: prim " + primName + " has a size of " + size.ToString() + " which is below threshold of " + 
+                            minSizeForComplexMesh.ToString() + " - creating simple bounding box");
+#endif
+                    mesh = CreateBoundingBoxMesh(mesh);
+                    mesh.DumpRaw(baseDir, primName, "Z extruded");
+                }
+
+                // trim the vertex and triangle lists to free up memory
+                mesh.TrimExcess();
+
+                if (shouldCache)
+                {
+                    lock (m_uniqueMeshes)
+                    {
+                        m_uniqueMeshes.Add(key, mesh);
+                    }
+                }
+            }
+
+            return mesh;
+        }
+        public IMesh GetMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool convex)
+        {
+            return null;
+        }
+
+        public void ReleaseMesh(IMesh imesh) { }
+        public void ExpireReleaseMeshs() { }
+        public void ExpireFileCache() { }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/PrimMesher.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/PrimMesher.cs
new file mode 100644
index 0000000..4049ee1
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/PrimMesher.cs
@@ -0,0 +1,2324 @@
+/*
+ * Copyright (c) Contributors
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+
+namespace PrimMesher
+{
+    public struct Quat
+    {
+        /// <summary>X value</summary>
+        public float X;
+        /// <summary>Y value</summary>
+        public float Y;
+        /// <summary>Z value</summary>
+        public float Z;
+        /// <summary>W value</summary>
+        public float W;
+
+        public Quat(float x, float y, float z, float w)
+        {
+            X = x;
+            Y = y;
+            Z = z;
+            W = w;
+        }
+
+        public Quat(Coord axis, float angle)
+        {
+            axis = axis.Normalize();
+
+            angle *= 0.5f;
+            float c = (float)Math.Cos(angle);
+            float s = (float)Math.Sin(angle);
+
+            X = axis.X * s;
+            Y = axis.Y * s;
+            Z = axis.Z * s;
+            W = c;
+
+            Normalize();
+        }
+
+        public float Length()
+        {
+            return (float)Math.Sqrt(X * X + Y * Y + Z * Z + W * W);
+        }
+
+        public Quat Normalize()
+        {
+            const float MAG_THRESHOLD = 0.0000001f;
+            float mag = Length();
+
+            // Catch very small rounding errors when normalizing
+            if (mag > MAG_THRESHOLD)
+            {
+                float oomag = 1f / mag;
+                X *= oomag;
+                Y *= oomag;
+                Z *= oomag;
+                W *= oomag;
+            }
+            else
+            {
+                X = 0f;
+                Y = 0f;
+                Z = 0f;
+                W = 1f;
+            }
+
+            return this;
+        }
+
+        public static Quat operator *(Quat q1, Quat q2)
+        {
+            float x = q1.W * q2.X + q1.X * q2.W + q1.Y * q2.Z - q1.Z * q2.Y;
+            float y = q1.W * q2.Y - q1.X * q2.Z + q1.Y * q2.W + q1.Z * q2.X;
+            float z = q1.W * q2.Z + q1.X * q2.Y - q1.Y * q2.X + q1.Z * q2.W;
+            float w = q1.W * q2.W - q1.X * q2.X - q1.Y * q2.Y - q1.Z * q2.Z;
+            return new Quat(x, y, z, w);
+        }
+
+        public override string ToString()
+        {
+            return "< X: " + this.X.ToString() + ", Y: " + this.Y.ToString() + ", Z: " + this.Z.ToString() + ", W: " + this.W.ToString() + ">";
+        }
+    }
+
+    public struct Coord
+    {
+        public float X;
+        public float Y;
+        public float Z;
+
+        public Coord(float x, float y, float z)
+        {
+            this.X = x;
+            this.Y = y;
+            this.Z = z;
+        }
+
+        public float Length()
+        {
+            return (float)Math.Sqrt(this.X * this.X + this.Y * this.Y + this.Z * this.Z);
+        }
+
+        public Coord Invert()
+        {
+            this.X = -this.X;
+            this.Y = -this.Y;
+            this.Z = -this.Z;
+
+            return this;
+        }
+
+        public Coord Normalize()
+        {
+            const float MAG_THRESHOLD = 0.0000001f;
+            float mag = Length();
+
+            // Catch very small rounding errors when normalizing
+            if (mag > MAG_THRESHOLD)
+            {
+                float oomag = 1.0f / mag;
+                this.X *= oomag;
+                this.Y *= oomag;
+                this.Z *= oomag;
+            }
+            else
+            {
+                this.X = 0.0f;
+                this.Y = 0.0f;
+                this.Z = 0.0f;
+            }
+
+            return this;
+        }
+
+        public override string ToString()
+        {
+            return this.X.ToString() + " " + this.Y.ToString() + " " + this.Z.ToString();
+        }
+
+        public static Coord Cross(Coord c1, Coord c2)
+        {
+            return new Coord(
+                c1.Y * c2.Z - c2.Y * c1.Z,
+                c1.Z * c2.X - c2.Z * c1.X,
+                c1.X * c2.Y - c2.X * c1.Y
+                );
+        }
+
+        public static Coord operator +(Coord v, Coord a)
+        {
+            return new Coord(v.X + a.X, v.Y + a.Y, v.Z + a.Z);
+        }
+
+        public static Coord operator *(Coord v, Coord m)
+        {
+            return new Coord(v.X * m.X, v.Y * m.Y, v.Z * m.Z);
+        }
+
+        public static Coord operator *(Coord v, Quat q)
+        {
+            // From http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/
+
+            Coord c2 = new Coord(0.0f, 0.0f, 0.0f);
+
+            c2.X = q.W * q.W * v.X +
+                2f * q.Y * q.W * v.Z -
+                2f * q.Z * q.W * v.Y +
+                     q.X * q.X * v.X +
+                2f * q.Y * q.X * v.Y +
+                2f * q.Z * q.X * v.Z -
+                     q.Z * q.Z * v.X -
+                     q.Y * q.Y * v.X;
+
+            c2.Y =
+                2f * q.X * q.Y * v.X +
+                     q.Y * q.Y * v.Y +
+                2f * q.Z * q.Y * v.Z +
+                2f * q.W * q.Z * v.X -
+                     q.Z * q.Z * v.Y +
+                     q.W * q.W * v.Y -
+                2f * q.X * q.W * v.Z -
+                     q.X * q.X * v.Y;
+
+            c2.Z =
+                2f * q.X * q.Z * v.X +
+                2f * q.Y * q.Z * v.Y +
+                     q.Z * q.Z * v.Z -
+                2f * q.W * q.Y * v.X -
+                     q.Y * q.Y * v.Z +
+                2f * q.W * q.X * v.Y -
+                     q.X * q.X * v.Z +
+                     q.W * q.W * v.Z;
+
+            return c2;
+        }
+    }
+
+    public struct UVCoord
+    {
+        public float U;
+        public float V;
+
+
+        public UVCoord(float u, float v)
+        {
+            this.U = u;
+            this.V = v;
+        }
+
+        public UVCoord Flip()
+        {
+            this.U = 1.0f - this.U;
+            this.V = 1.0f - this.V;
+            return this;
+        }
+    }
+
+    public struct Face
+    {
+        public int primFace;
+
+        // vertices
+        public int v1;
+        public int v2;
+        public int v3;
+
+        //normals
+        public int n1;
+        public int n2;
+        public int n3;
+
+        // uvs
+        public int uv1;
+        public int uv2;
+        public int uv3;
+
+        public Face(int v1, int v2, int v3)
+        {
+            primFace = 0;
+
+            this.v1 = v1;
+            this.v2 = v2;
+            this.v3 = v3;
+
+            this.n1 = 0;
+            this.n2 = 0;
+            this.n3 = 0;
+
+            this.uv1 = 0;
+            this.uv2 = 0;
+            this.uv3 = 0;
+
+        }
+
+        public Face(int v1, int v2, int v3, int n1, int n2, int n3)
+        {
+            primFace = 0;
+
+            this.v1 = v1;
+            this.v2 = v2;
+            this.v3 = v3;
+
+            this.n1 = n1;
+            this.n2 = n2;
+            this.n3 = n3;
+
+            this.uv1 = 0;
+            this.uv2 = 0;
+            this.uv3 = 0;
+        }
+
+        public Coord SurfaceNormal(List<Coord> coordList)
+        {
+            Coord c1 = coordList[this.v1];
+            Coord c2 = coordList[this.v2];
+            Coord c3 = coordList[this.v3];
+
+            Coord edge1 = new Coord(c2.X - c1.X, c2.Y - c1.Y, c2.Z - c1.Z);
+            Coord edge2 = new Coord(c3.X - c1.X, c3.Y - c1.Y, c3.Z - c1.Z);
+
+            return Coord.Cross(edge1, edge2).Normalize();
+        }
+    }
+
+    public struct ViewerFace
+    {
+        public int primFaceNumber;
+
+        public Coord v1;
+        public Coord v2;
+        public Coord v3;
+
+        public int coordIndex1;
+        public int coordIndex2;
+        public int coordIndex3;
+
+        public Coord n1;
+        public Coord n2;
+        public Coord n3;
+
+        public UVCoord uv1;
+        public UVCoord uv2;
+        public UVCoord uv3;
+
+        public ViewerFace(int primFaceNumber)
+        {
+            this.primFaceNumber = primFaceNumber;
+
+            this.v1 = new Coord();
+            this.v2 = new Coord();
+            this.v3 = new Coord();
+
+            this.coordIndex1 = this.coordIndex2 = this.coordIndex3 = -1; // -1 means not assigned yet
+
+            this.n1 = new Coord();
+            this.n2 = new Coord();
+            this.n3 = new Coord();
+
+            this.uv1 = new UVCoord();
+            this.uv2 = new UVCoord();
+            this.uv3 = new UVCoord();
+        }
+
+        public void Scale(float x, float y, float z)
+        {
+            this.v1.X *= x;
+            this.v1.Y *= y;
+            this.v1.Z *= z;
+
+            this.v2.X *= x;
+            this.v2.Y *= y;
+            this.v2.Z *= z;
+
+            this.v3.X *= x;
+            this.v3.Y *= y;
+            this.v3.Z *= z;
+        }
+
+        public void AddPos(float x, float y, float z)
+        {
+            this.v1.X += x;
+            this.v2.X += x;
+            this.v3.X += x;
+
+            this.v1.Y += y;
+            this.v2.Y += y;
+            this.v3.Y += y;
+
+            this.v1.Z += z;
+            this.v2.Z += z;
+            this.v3.Z += z;
+        }
+
+        public void AddRot(Quat q)
+        {
+            this.v1 *= q;
+            this.v2 *= q;
+            this.v3 *= q;
+
+            this.n1 *= q;
+            this.n2 *= q;
+            this.n3 *= q;
+        }
+
+        public void CalcSurfaceNormal()
+        {
+
+            Coord edge1 = new Coord(this.v2.X - this.v1.X, this.v2.Y - this.v1.Y, this.v2.Z - this.v1.Z);
+            Coord edge2 = new Coord(this.v3.X - this.v1.X, this.v3.Y - this.v1.Y, this.v3.Z - this.v1.Z);
+
+            this.n1 = this.n2 = this.n3 = Coord.Cross(edge1, edge2).Normalize();
+        }
+    }
+
+    internal struct Angle
+    {
+        internal float angle;
+        internal float X;
+        internal float Y;
+
+        internal Angle(float angle, float x, float y)
+        {
+            this.angle = angle;
+            this.X = x;
+            this.Y = y;
+        }
+    }
+
+    internal class AngleList
+    {
+        private float iX, iY; // intersection point
+
+        private static Angle[] angles3 =
+        {
+            new Angle(0.0f, 1.0f, 0.0f),
+            new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f),
+            new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f),
+            new Angle(1.0f, 1.0f, 0.0f)
+        };
+
+        private static Coord[] normals3 =
+        {
+            new Coord(0.25f, 0.4330127019f, 0.0f).Normalize(),
+            new Coord(-0.5f, 0.0f, 0.0f).Normalize(),
+            new Coord(0.25f, -0.4330127019f, 0.0f).Normalize(),
+            new Coord(0.25f, 0.4330127019f, 0.0f).Normalize()
+        };
+
+        private static Angle[] angles4 =
+        {
+            new Angle(0.0f, 1.0f, 0.0f),
+            new Angle(0.25f, 0.0f, 1.0f),
+            new Angle(0.5f, -1.0f, 0.0f),
+            new Angle(0.75f, 0.0f, -1.0f),
+            new Angle(1.0f, 1.0f, 0.0f)
+        };
+
+        private static Coord[] normals4 = 
+        {
+            new Coord(0.5f, 0.5f, 0.0f).Normalize(),
+            new Coord(-0.5f, 0.5f, 0.0f).Normalize(),
+            new Coord(-0.5f, -0.5f, 0.0f).Normalize(),
+            new Coord(0.5f, -0.5f, 0.0f).Normalize(),
+            new Coord(0.5f, 0.5f, 0.0f).Normalize()
+        };
+
+        private static Angle[] angles24 =
+        {
+            new Angle(0.0f, 1.0f, 0.0f),
+            new Angle(0.041666666666666664f, 0.96592582628906831f, 0.25881904510252074f),
+            new Angle(0.083333333333333329f, 0.86602540378443871f, 0.5f),
+            new Angle(0.125f, 0.70710678118654757f, 0.70710678118654746f),
+            new Angle(0.16666666666666667f, 0.5f, 0.8660254037844386f),
+            new Angle(0.20833333333333331f, 0.25881904510252096f, 0.9659258262890682f),
+            new Angle(0.25f, 0.0f, 1.0f),
+            new Angle(0.29166666666666663f, -0.25881904510252063f, 0.96592582628906831f),
+            new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f),
+            new Angle(0.375f, -0.70710678118654746f, 0.70710678118654757f),
+            new Angle(0.41666666666666663f, -0.86602540378443849f, 0.5f),
+            new Angle(0.45833333333333331f, -0.9659258262890682f, 0.25881904510252102f),
+            new Angle(0.5f, -1.0f, 0.0f),
+            new Angle(0.54166666666666663f, -0.96592582628906842f, -0.25881904510252035f),
+            new Angle(0.58333333333333326f, -0.86602540378443882f, -0.5f),
+            new Angle(0.62499999999999989f, -0.70710678118654791f, -0.70710678118654713f),
+            new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f),
+            new Angle(0.70833333333333326f, -0.25881904510252152f, -0.96592582628906809f),
+            new Angle(0.75f, 0.0f, -1.0f),
+            new Angle(0.79166666666666663f, 0.2588190451025203f, -0.96592582628906842f),
+            new Angle(0.83333333333333326f, 0.5f, -0.86602540378443904f),
+            new Angle(0.875f, 0.70710678118654735f, -0.70710678118654768f),
+            new Angle(0.91666666666666663f, 0.86602540378443837f, -0.5f),
+            new Angle(0.95833333333333326f, 0.96592582628906809f, -0.25881904510252157f),
+            new Angle(1.0f, 1.0f, 0.0f)
+        };
+
+        private Angle interpolatePoints(float newPoint, Angle p1, Angle p2)
+        {
+            float m = (newPoint - p1.angle) / (p2.angle - p1.angle);
+            return new Angle(newPoint, p1.X + m * (p2.X - p1.X), p1.Y + m * (p2.Y - p1.Y));
+        }
+
+        private void intersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
+        { // ref: http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
+            double denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+            double uaNumerator = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
+
+            if (denom != 0.0)
+            {
+                double ua = uaNumerator / denom;
+                iX = (float)(x1 + ua * (x2 - x1));
+                iY = (float)(y1 + ua * (y2 - y1));
+            }
+        }
+
+        internal List<Angle> angles;
+        internal List<Coord> normals;
+
+        internal void makeAngles(int sides, float startAngle, float stopAngle)
+        {
+            angles = new List<Angle>();
+            normals = new List<Coord>();
+
+            double twoPi = System.Math.PI * 2.0;
+            float twoPiInv = 1.0f / (float)twoPi;
+
+            if (sides < 1)
+                throw new Exception("number of sides not greater than zero");
+            if (stopAngle <= startAngle)
+                throw new Exception("stopAngle not greater than startAngle");
+
+            if ((sides == 3 || sides == 4 || sides == 24))
+            {
+                startAngle *= twoPiInv;
+                stopAngle *= twoPiInv;
+
+                Angle[] sourceAngles;
+                if (sides == 3)
+                    sourceAngles = angles3;
+                else if (sides == 4)
+                    sourceAngles = angles4;
+                else sourceAngles = angles24;
+
+                int startAngleIndex = (int)(startAngle * sides);
+                int endAngleIndex = sourceAngles.Length - 1;
+                if (stopAngle < 1.0f)
+                    endAngleIndex = (int)(stopAngle * sides) + 1;
+                if (endAngleIndex == startAngleIndex)
+                    endAngleIndex++;
+
+                for (int angleIndex = startAngleIndex; angleIndex < endAngleIndex + 1; angleIndex++)
+                {
+                    angles.Add(sourceAngles[angleIndex]);
+                    if (sides == 3)
+                        normals.Add(normals3[angleIndex]);
+                    else if (sides == 4)
+                        normals.Add(normals4[angleIndex]);
+                }
+
+                if (startAngle > 0.0f)
+                    angles[0] = interpolatePoints(startAngle, angles[0], angles[1]);
+
+                if (stopAngle < 1.0f)
+                {
+                    int lastAngleIndex = angles.Count - 1;
+                    angles[lastAngleIndex] = interpolatePoints(stopAngle, angles[lastAngleIndex - 1], angles[lastAngleIndex]);
+                }
+            }
+            else
+            {
+                double stepSize = twoPi / sides;
+
+                int startStep = (int)(startAngle / stepSize);
+                double angle = stepSize * startStep;
+                int step = startStep;
+                double stopAngleTest = stopAngle;
+                if (stopAngle < twoPi)
+                {
+                    stopAngleTest = stepSize * ((int)(stopAngle / stepSize) + 1);
+                    if (stopAngleTest < stopAngle)
+                        stopAngleTest += stepSize;
+                    if (stopAngleTest > twoPi)
+                        stopAngleTest = twoPi;
+                }
+
+                while (angle <= stopAngleTest)
+                {
+                    Angle newAngle;
+                    newAngle.angle = (float)angle;
+                    newAngle.X = (float)System.Math.Cos(angle);
+                    newAngle.Y = (float)System.Math.Sin(angle);
+                    angles.Add(newAngle);
+                    step += 1;
+                    angle = stepSize * step;
+                }
+
+                if (startAngle > angles[0].angle)
+                {
+                    Angle newAngle;
+                    intersection(angles[0].X, angles[0].Y, angles[1].X, angles[1].Y, 0.0f, 0.0f, (float)Math.Cos(startAngle), (float)Math.Sin(startAngle));
+                    newAngle.angle = startAngle;
+                    newAngle.X = iX;
+                    newAngle.Y = iY;
+                    angles[0] = newAngle;
+                }
+
+                int index = angles.Count - 1;
+                if (stopAngle < angles[index].angle)
+                {
+                    Angle newAngle;
+                    intersection(angles[index - 1].X, angles[index - 1].Y, angles[index].X, angles[index].Y, 0.0f, 0.0f, (float)Math.Cos(stopAngle), (float)Math.Sin(stopAngle));
+                    newAngle.angle = stopAngle;
+                    newAngle.X = iX;
+                    newAngle.Y = iY;
+                    angles[index] = newAngle;
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// generates a profile for extrusion
+    /// </summary>
+    public class Profile
+    {
+        private const float twoPi = 2.0f * (float)Math.PI;
+
+        public string errorMessage = null;
+
+        public List<Coord> coords;
+        public List<Face> faces;
+        public List<Coord> vertexNormals;
+        public List<float> us;
+        public List<UVCoord> faceUVs;
+        public List<int> faceNumbers;
+
+        // use these for making individual meshes for each prim face
+        public List<int> outerCoordIndices = null;
+        public List<int> hollowCoordIndices = null;
+        public List<int> cut1CoordIndices = null;
+        public List<int> cut2CoordIndices = null;
+
+        public Coord faceNormal = new Coord(0.0f, 0.0f, 1.0f);
+        public Coord cutNormal1 = new Coord();
+        public Coord cutNormal2 = new Coord();
+
+        public int numOuterVerts = 0;
+        public int numHollowVerts = 0;
+
+        public int outerFaceNumber = -1;
+        public int hollowFaceNumber = -1;
+
+        public bool calcVertexNormals = false;
+        public int bottomFaceNumber = 0;
+        public int numPrimFaces = 0;
+
+        public Profile()
+        {
+            this.coords = new List<Coord>();
+            this.faces = new List<Face>();
+            this.vertexNormals = new List<Coord>();
+            this.us = new List<float>();
+            this.faceUVs = new List<UVCoord>();
+            this.faceNumbers = new List<int>();
+        }
+
+        public Profile(int sides, float profileStart, float profileEnd, float hollow, int hollowSides, bool createFaces, bool calcVertexNormals)
+        {
+            this.calcVertexNormals = calcVertexNormals;
+            this.coords = new List<Coord>();
+            this.faces = new List<Face>();
+            this.vertexNormals = new List<Coord>();
+            this.us = new List<float>();
+            this.faceUVs = new List<UVCoord>();
+            this.faceNumbers = new List<int>();
+
+            Coord center = new Coord(0.0f, 0.0f, 0.0f);
+
+            List<Coord> hollowCoords = new List<Coord>();
+            List<Coord> hollowNormals = new List<Coord>();
+            List<float> hollowUs = new List<float>();
+
+            if (calcVertexNormals)
+            {
+                this.outerCoordIndices = new List<int>();
+                this.hollowCoordIndices = new List<int>();
+                this.cut1CoordIndices = new List<int>();
+                this.cut2CoordIndices = new List<int>();
+            }
+
+            bool hasHollow = (hollow > 0.0f);
+
+            bool hasProfileCut = (profileStart > 0.0f || profileEnd < 1.0f);
+
+            AngleList angles = new AngleList();
+            AngleList hollowAngles = new AngleList();
+
+            float xScale = 0.5f;
+            float yScale = 0.5f;
+            if (sides == 4)  // corners of a square are sqrt(2) from center
+            {
+                xScale = 0.707107f;
+                yScale = 0.707107f;
+            }
+
+            float startAngle = profileStart * twoPi;
+            float stopAngle = profileEnd * twoPi;
+
+            try { angles.makeAngles(sides, startAngle, stopAngle); }
+            catch (Exception ex)
+            {
+
+                errorMessage = "makeAngles failed: Exception: " + ex.ToString()
+                + "\nsides: " + sides.ToString() + " startAngle: " + startAngle.ToString() + " stopAngle: " + stopAngle.ToString();
+
+                return;
+            }
+
+            this.numOuterVerts = angles.angles.Count;
+
+            // flag to create as few triangles as possible for 3 or 4 side profile
+            bool simpleFace = (sides < 5 && !hasHollow && !hasProfileCut);
+
+            if (hasHollow)
+            {
+                if (sides == hollowSides)
+                    hollowAngles = angles;
+                else
+                {
+                    try { hollowAngles.makeAngles(hollowSides, startAngle, stopAngle); }
+                    catch (Exception ex)
+                    {
+                        errorMessage = "makeAngles failed: Exception: " + ex.ToString()
+                        + "\nsides: " + sides.ToString() + " startAngle: " + startAngle.ToString() + " stopAngle: " + stopAngle.ToString();
+
+                        return;
+                    }
+                }
+                this.numHollowVerts = hollowAngles.angles.Count;
+            }
+            else if (!simpleFace)
+            {
+                this.coords.Add(center);
+                if (this.calcVertexNormals)
+                    this.vertexNormals.Add(new Coord(0.0f, 0.0f, 1.0f));
+                this.us.Add(0.0f);
+            }
+
+            float z = 0.0f;
+
+            Angle angle;
+            Coord newVert = new Coord();
+            if (hasHollow && hollowSides != sides)
+            {
+                int numHollowAngles = hollowAngles.angles.Count;
+                for (int i = 0; i < numHollowAngles; i++)
+                {
+                    angle = hollowAngles.angles[i];
+                    newVert.X = hollow * xScale * angle.X;
+                    newVert.Y = hollow * yScale * angle.Y;
+                    newVert.Z = z;
+
+                    hollowCoords.Add(newVert);
+                    if (this.calcVertexNormals)
+                    {
+                        if (hollowSides < 5)
+                            hollowNormals.Add(hollowAngles.normals[i].Invert());
+                        else
+                            hollowNormals.Add(new Coord(-angle.X, -angle.Y, 0.0f));
+
+                        if (hollowSides == 4)
+                            hollowUs.Add(angle.angle * hollow * 0.707107f);
+                        else
+                            hollowUs.Add(angle.angle * hollow);
+                    }
+                }
+            }
+
+            int index = 0;
+            int numAngles = angles.angles.Count;
+
+            for (int i = 0; i < numAngles; i++)
+            {
+                angle = angles.angles[i];
+                newVert.X = angle.X * xScale;
+                newVert.Y = angle.Y * yScale;
+                newVert.Z = z;
+                this.coords.Add(newVert);
+                if (this.calcVertexNormals)
+                {
+                    this.outerCoordIndices.Add(this.coords.Count - 1);
+
+                    if (sides < 5)
+                    {
+                        this.vertexNormals.Add(angles.normals[i]);
+                        float u = angle.angle;
+                        this.us.Add(u);
+                    }
+                    else
+                    {
+                        this.vertexNormals.Add(new Coord(angle.X, angle.Y, 0.0f));
+                        this.us.Add(angle.angle);
+                    }
+                }
+
+                if (hasHollow)
+                {
+                    if (hollowSides == sides)
+                    {
+                        newVert.X *= hollow;
+                        newVert.Y *= hollow;
+                        newVert.Z = z;
+                        hollowCoords.Add(newVert);
+                        if (this.calcVertexNormals)
+                        {
+                            if (sides < 5)
+                            {
+                                hollowNormals.Add(angles.normals[i].Invert());
+                            }
+
+                            else
+                                hollowNormals.Add(new Coord(-angle.X, -angle.Y, 0.0f));
+
+                            hollowUs.Add(angle.angle * hollow);
+                        }
+                    }
+                }
+                else if (!simpleFace && createFaces && angle.angle > 0.0001f)
+                {
+                    Face newFace = new Face();
+                    newFace.v1 = 0;
+                    newFace.v2 = index;
+                    newFace.v3 = index + 1;
+
+                    this.faces.Add(newFace);
+                }
+                index += 1;
+            }
+
+            if (hasHollow)
+            {
+                hollowCoords.Reverse();
+                if (this.calcVertexNormals)
+                {
+                    hollowNormals.Reverse();
+                    hollowUs.Reverse();
+                }
+
+                if (createFaces)
+                {
+                    int numTotalVerts = this.numOuterVerts + this.numHollowVerts;
+
+                    if (this.numOuterVerts == this.numHollowVerts)
+                    {
+                        Face newFace = new Face();
+
+                        for (int coordIndex = 0; coordIndex < this.numOuterVerts - 1; coordIndex++)
+                        {
+                            newFace.v1 = coordIndex;
+                            newFace.v2 = coordIndex + 1;
+                            newFace.v3 = numTotalVerts - coordIndex - 1;
+                            this.faces.Add(newFace);
+
+                            newFace.v1 = coordIndex + 1;
+                            newFace.v2 = numTotalVerts - coordIndex - 2;
+                            newFace.v3 = numTotalVerts - coordIndex - 1;
+                            this.faces.Add(newFace);
+                        }
+                    }
+                    else
+                    {
+                        if (this.numOuterVerts < this.numHollowVerts)
+                        {
+                            Face newFace = new Face();
+                            int j = 0; // j is the index for outer vertices
+                            int maxJ = this.numOuterVerts - 1;
+                            for (int i = 0; i < this.numHollowVerts; i++) // i is the index for inner vertices
+                            {
+                                if (j < maxJ)
+                                    if (angles.angles[j + 1].angle - hollowAngles.angles[i].angle < hollowAngles.angles[i].angle - angles.angles[j].angle + 0.000001f)
+                                    {
+                                        newFace.v1 = numTotalVerts - i - 1;
+                                        newFace.v2 = j;
+                                        newFace.v3 = j + 1;
+
+                                        this.faces.Add(newFace);
+                                        j += 1;
+                                    }
+
+                                newFace.v1 = j;
+                                newFace.v2 = numTotalVerts - i - 2;
+                                newFace.v3 = numTotalVerts - i - 1;
+
+                                this.faces.Add(newFace);
+                            }
+                        }
+                        else // numHollowVerts < numOuterVerts
+                        {
+                            Face newFace = new Face();
+                            int j = 0; // j is the index for inner vertices
+                            int maxJ = this.numHollowVerts - 1;
+                            for (int i = 0; i < this.numOuterVerts; i++)
+                            {
+                                if (j < maxJ)
+                                    if (hollowAngles.angles[j + 1].angle - angles.angles[i].angle < angles.angles[i].angle - hollowAngles.angles[j].angle + 0.000001f)
+                                    {
+                                        newFace.v1 = i;
+                                        newFace.v2 = numTotalVerts - j - 2;
+                                        newFace.v3 = numTotalVerts - j - 1;
+
+                                        this.faces.Add(newFace);
+                                        j += 1;
+                                    }
+
+                                newFace.v1 = numTotalVerts - j - 1;
+                                newFace.v2 = i;
+                                newFace.v3 = i + 1;
+
+                                this.faces.Add(newFace);
+                            }
+                        }
+                    }
+                }
+
+                if (calcVertexNormals)
+                {
+                    foreach (Coord hc in hollowCoords)
+                    {
+                        this.coords.Add(hc);
+                        hollowCoordIndices.Add(this.coords.Count - 1);
+                    }
+                }
+                else
+                    this.coords.AddRange(hollowCoords);
+
+                if (this.calcVertexNormals)
+                {
+                    this.vertexNormals.AddRange(hollowNormals);
+                    this.us.AddRange(hollowUs);
+
+                }
+            }
+
+            if (simpleFace && createFaces)
+            {
+                if (sides == 3)
+                    this.faces.Add(new Face(0, 1, 2));
+                else if (sides == 4)
+                {
+                    this.faces.Add(new Face(0, 1, 2));
+                    this.faces.Add(new Face(0, 2, 3));
+                }
+            }
+
+            if (calcVertexNormals && hasProfileCut)
+            {
+                int lastOuterVertIndex = this.numOuterVerts - 1;
+
+                if (hasHollow)
+                {
+                    this.cut1CoordIndices.Add(0);
+                    this.cut1CoordIndices.Add(this.coords.Count - 1);
+
+                    this.cut2CoordIndices.Add(lastOuterVertIndex + 1);
+                    this.cut2CoordIndices.Add(lastOuterVertIndex);
+
+                    this.cutNormal1.X = this.coords[0].Y - this.coords[this.coords.Count - 1].Y;
+                    this.cutNormal1.Y = -(this.coords[0].X - this.coords[this.coords.Count - 1].X);
+
+                    this.cutNormal2.X = this.coords[lastOuterVertIndex + 1].Y - this.coords[lastOuterVertIndex].Y;
+                    this.cutNormal2.Y = -(this.coords[lastOuterVertIndex + 1].X - this.coords[lastOuterVertIndex].X);
+                }
+
+                else
+                {
+                    this.cut1CoordIndices.Add(0);
+                    this.cut1CoordIndices.Add(1);
+
+                    this.cut2CoordIndices.Add(lastOuterVertIndex);
+                    this.cut2CoordIndices.Add(0);
+
+                    this.cutNormal1.X = this.vertexNormals[1].Y;
+                    this.cutNormal1.Y = -this.vertexNormals[1].X;
+
+                    this.cutNormal2.X = -this.vertexNormals[this.vertexNormals.Count - 2].Y;
+                    this.cutNormal2.Y = this.vertexNormals[this.vertexNormals.Count - 2].X;
+
+                }
+                this.cutNormal1.Normalize();
+                this.cutNormal2.Normalize();
+            }
+
+            this.MakeFaceUVs();
+
+            hollowCoords = null;
+            hollowNormals = null;
+            hollowUs = null;
+
+            if (calcVertexNormals)
+            { // calculate prim face numbers
+
+                // face number order is top, outer, hollow, bottom, start cut, end cut
+                // I know it's ugly but so is the whole concept of prim face numbers
+
+                int faceNum = 1; // start with outer faces
+                this.outerFaceNumber = faceNum;
+
+                int startVert = hasProfileCut && !hasHollow ? 1 : 0;
+                if (startVert > 0)
+                    this.faceNumbers.Add(-1);
+                for (int i = 0; i < this.numOuterVerts - 1; i++)
+                    this.faceNumbers.Add(sides < 5 && i <= sides ? faceNum++ : faceNum);
+
+                this.faceNumbers.Add(hasProfileCut ? -1 : faceNum++);
+
+                if (sides > 4 && (hasHollow || hasProfileCut))
+                    faceNum++;
+
+                if (sides < 5 && (hasHollow || hasProfileCut) && this.numOuterVerts < sides)
+                    faceNum++;
+
+                if (hasHollow)
+                {
+                    for (int i = 0; i < this.numHollowVerts; i++)
+                        this.faceNumbers.Add(faceNum);
+
+                    this.hollowFaceNumber = faceNum++;
+                }
+
+                this.bottomFaceNumber = faceNum++;
+
+                if (hasHollow && hasProfileCut)
+                    this.faceNumbers.Add(faceNum++);
+
+                for (int i = 0; i < this.faceNumbers.Count; i++)
+                    if (this.faceNumbers[i] == -1)
+                        this.faceNumbers[i] = faceNum++;
+
+                this.numPrimFaces = faceNum;
+            }
+
+        }
+
+        public void MakeFaceUVs()
+        {
+            this.faceUVs = new List<UVCoord>();
+            foreach (Coord c in this.coords)
+                this.faceUVs.Add(new UVCoord(1.0f - (0.5f + c.X), 1.0f - (0.5f - c.Y)));
+        }
+
+        public Profile Copy()
+        {
+            return this.Copy(true);
+        }
+
+        public Profile Copy(bool needFaces)
+        {
+            Profile copy = new Profile();
+
+            copy.coords.AddRange(this.coords);
+            copy.faceUVs.AddRange(this.faceUVs);
+
+            if (needFaces)
+                copy.faces.AddRange(this.faces);
+            if ((copy.calcVertexNormals = this.calcVertexNormals) == true)
+            {
+                copy.vertexNormals.AddRange(this.vertexNormals);
+                copy.faceNormal = this.faceNormal;
+                copy.cutNormal1 = this.cutNormal1;
+                copy.cutNormal2 = this.cutNormal2;
+                copy.us.AddRange(this.us);
+                copy.faceNumbers.AddRange(this.faceNumbers);
+
+                copy.cut1CoordIndices = new List<int>(this.cut1CoordIndices);
+                copy.cut2CoordIndices = new List<int>(this.cut2CoordIndices);
+                copy.hollowCoordIndices = new List<int>(this.hollowCoordIndices);
+                copy.outerCoordIndices = new List<int>(this.outerCoordIndices);
+            }
+            copy.numOuterVerts = this.numOuterVerts;
+            copy.numHollowVerts = this.numHollowVerts;
+
+            return copy;
+        }
+
+        public void AddPos(Coord v)
+        {
+            this.AddPos(v.X, v.Y, v.Z);
+        }
+
+        public void AddPos(float x, float y, float z)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+            Coord vert;
+
+            for (i = 0; i < numVerts; i++)
+            {
+                vert = this.coords[i];
+                vert.X += x;
+                vert.Y += y;
+                vert.Z += z;
+                this.coords[i] = vert;
+            }
+        }
+
+        public void AddRot(Quat q)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+
+            for (i = 0; i < numVerts; i++)
+                this.coords[i] *= q;
+
+            if (this.calcVertexNormals)
+            {
+                int numNormals = this.vertexNormals.Count;
+                for (i = 0; i < numNormals; i++)
+                    this.vertexNormals[i] *= q;
+
+                this.faceNormal *= q;
+                this.cutNormal1 *= q;
+                this.cutNormal2 *= q;
+
+            }
+        }
+
+        public void Scale(float x, float y)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+            Coord vert;
+
+            for (i = 0; i < numVerts; i++)
+            {
+                vert = this.coords[i];
+                vert.X *= x;
+                vert.Y *= y;
+                this.coords[i] = vert;
+            }
+        }
+
+        /// <summary>
+        /// Changes order of the vertex indices and negates the center vertex normal. Does not alter vertex normals of radial vertices
+        /// </summary>
+        public void FlipNormals()
+        {
+            int i;
+            int numFaces = this.faces.Count;
+            Face tmpFace;
+            int tmp;
+
+            for (i = 0; i < numFaces; i++)
+            {
+                tmpFace = this.faces[i];
+                tmp = tmpFace.v3;
+                tmpFace.v3 = tmpFace.v1;
+                tmpFace.v1 = tmp;
+                this.faces[i] = tmpFace;
+            }
+
+            if (this.calcVertexNormals)
+            {
+                int normalCount = this.vertexNormals.Count;
+                if (normalCount > 0)
+                {
+                    Coord n = this.vertexNormals[normalCount - 1];
+                    n.Z = -n.Z;
+                    this.vertexNormals[normalCount - 1] = n;
+                }
+            }
+
+            this.faceNormal.X = -this.faceNormal.X;
+            this.faceNormal.Y = -this.faceNormal.Y;
+            this.faceNormal.Z = -this.faceNormal.Z;
+
+            int numfaceUVs = this.faceUVs.Count;
+            for (i = 0; i < numfaceUVs; i++)
+            {
+                UVCoord uv = this.faceUVs[i];
+                uv.V = 1.0f - uv.V;
+                this.faceUVs[i] = uv;
+            }
+        }
+
+        public void AddValue2FaceVertexIndices(int num)
+        {
+            int numFaces = this.faces.Count;
+            Face tmpFace;
+            for (int i = 0; i < numFaces; i++)
+            {
+                tmpFace = this.faces[i];
+                tmpFace.v1 += num;
+                tmpFace.v2 += num;
+                tmpFace.v3 += num;
+
+                this.faces[i] = tmpFace;
+            }
+        }
+
+        public void AddValue2FaceNormalIndices(int num)
+        {
+            if (this.calcVertexNormals)
+            {
+                int numFaces = this.faces.Count;
+                Face tmpFace;
+                for (int i = 0; i < numFaces; i++)
+                {
+                    tmpFace = this.faces[i];
+                    tmpFace.n1 += num;
+                    tmpFace.n2 += num;
+                    tmpFace.n3 += num;
+
+                    this.faces[i] = tmpFace;
+                }
+            }
+        }
+
+        public void DumpRaw(String path, String name, String title)
+        {
+            if (path == null)
+                return;
+            String fileName = name + "_" + title + ".raw";
+            String completePath = System.IO.Path.Combine(path, fileName);
+            StreamWriter sw = new StreamWriter(completePath);
+
+            for (int i = 0; i < this.faces.Count; i++)
+            {
+                string s = this.coords[this.faces[i].v1].ToString();
+                s += " " + this.coords[this.faces[i].v2].ToString();
+                s += " " + this.coords[this.faces[i].v3].ToString();
+
+                sw.WriteLine(s);
+            }
+
+            sw.Close();
+        }
+    }
+
+    public struct PathNode
+    {
+        public Coord position;
+        public Quat rotation;
+        public float xScale;
+        public float yScale;
+        public float percentOfPath;
+    }
+
+    public enum PathType { Linear = 0, Circular = 1, Flexible = 2 }
+
+    public class Path
+    {
+        public List<PathNode> pathNodes = new List<PathNode>();
+
+        public float twistBegin = 0.0f;
+        public float twistEnd = 0.0f;
+        public float topShearX = 0.0f;
+        public float topShearY = 0.0f;
+        public float pathCutBegin = 0.0f;
+        public float pathCutEnd = 1.0f;
+        public float dimpleBegin = 0.0f;
+        public float dimpleEnd = 1.0f;
+        public float skew = 0.0f;
+        public float holeSizeX = 1.0f; // called pathScaleX in pbs
+        public float holeSizeY = 0.25f;
+        public float taperX = 0.0f;
+        public float taperY = 0.0f;
+        public float radius = 0.0f;
+        public float revolutions = 1.0f;
+        public int stepsPerRevolution = 24;
+
+        private const float twoPi = 2.0f * (float)Math.PI;
+
+        public void Create(PathType pathType, int steps)
+        {
+            if (this.taperX > 0.999f)
+                this.taperX = 0.999f;
+            if (this.taperX < -0.999f)
+                this.taperX = -0.999f;
+            if (this.taperY > 0.999f)
+                this.taperY = 0.999f;
+            if (this.taperY < -0.999f)
+                this.taperY = -0.999f;
+
+            if (pathType == PathType.Linear || pathType == PathType.Flexible)
+            {
+                int step = 0;
+
+                float length = this.pathCutEnd - this.pathCutBegin;
+                float twistTotal = twistEnd - twistBegin;
+                float twistTotalAbs = Math.Abs(twistTotal);
+                if (twistTotalAbs > 0.01f)
+                    steps += (int)(twistTotalAbs * 3.66); //  dahlia's magic number
+
+                float start = -0.5f;
+                float stepSize = length / (float)steps;
+                float percentOfPathMultiplier = stepSize * 0.999999f;
+                float xOffset = this.topShearX * this.pathCutBegin;
+                float yOffset = this.topShearY * this.pathCutBegin;
+                float zOffset = start;
+                float xOffsetStepIncrement = this.topShearX * length / steps;
+                float yOffsetStepIncrement = this.topShearY * length / steps;
+
+                float percentOfPath = this.pathCutBegin;
+                zOffset += percentOfPath;
+
+                // sanity checks
+
+                bool done = false;
+
+                while (!done)
+                {
+                    PathNode newNode = new PathNode();
+
+                    newNode.xScale = 1.0f;
+                    if (this.taperX == 0.0f)
+                        newNode.xScale = 1.0f;
+                    else if (this.taperX > 0.0f)
+                        newNode.xScale = 1.0f - percentOfPath * this.taperX;
+                    else newNode.xScale = 1.0f + (1.0f - percentOfPath) * this.taperX;
+
+                    newNode.yScale = 1.0f;
+                    if (this.taperY == 0.0f)
+                        newNode.yScale = 1.0f;
+                    else if (this.taperY > 0.0f)
+                        newNode.yScale = 1.0f - percentOfPath * this.taperY;
+                    else newNode.yScale = 1.0f + (1.0f - percentOfPath) * this.taperY;
+
+                    float twist = twistBegin + twistTotal * percentOfPath;
+
+                    newNode.rotation = new Quat(new Coord(0.0f, 0.0f, 1.0f), twist);
+                    newNode.position = new Coord(xOffset, yOffset, zOffset);
+                    newNode.percentOfPath = percentOfPath;
+
+                    pathNodes.Add(newNode);
+
+                    if (step < steps)
+                    {
+                        step += 1;
+                        percentOfPath += percentOfPathMultiplier;
+                        xOffset += xOffsetStepIncrement;
+                        yOffset += yOffsetStepIncrement;
+                        zOffset += stepSize;
+                        if (percentOfPath > this.pathCutEnd)
+                            done = true;
+                    }
+                    else done = true;
+                }
+            } // end of linear path code
+
+            else // pathType == Circular
+            {
+                float twistTotal = twistEnd - twistBegin;
+
+                // if the profile has a lot of twist, add more layers otherwise the layers may overlap
+                // and the resulting mesh may be quite inaccurate. This method is arbitrary and doesn't
+                // accurately match the viewer
+                float twistTotalAbs = Math.Abs(twistTotal);
+                if (twistTotalAbs > 0.01f)
+                {
+                    if (twistTotalAbs > Math.PI * 1.5f)
+                        steps *= 2;
+                    if (twistTotalAbs > Math.PI * 3.0f)
+                        steps *= 2;
+                }
+
+                float yPathScale = this.holeSizeY * 0.5f;
+                float pathLength = this.pathCutEnd - this.pathCutBegin;
+                float totalSkew = this.skew * 2.0f * pathLength;
+                float skewStart = this.pathCutBegin * 2.0f * this.skew - this.skew;
+                float xOffsetTopShearXFactor = this.topShearX * (0.25f + 0.5f * (0.5f - this.holeSizeY));
+                float yShearCompensation = 1.0f + Math.Abs(this.topShearY) * 0.25f;
+
+                // It's not quite clear what pushY (Y top shear) does, but subtracting it from the start and end
+                // angles appears to approximate it's effects on path cut. Likewise, adding it to the angle used
+                // to calculate the sine for generating the path radius appears to approximate it's effects there
+                // too, but there are some subtle differences in the radius which are noticeable as the prim size
+                // increases and it may affect megaprims quite a bit. The effect of the Y top shear parameter on
+                // the meshes generated with this technique appear nearly identical in shape to the same prims when
+                // displayed by the viewer.
+
+                float startAngle = (twoPi * this.pathCutBegin * this.revolutions) - this.topShearY * 0.9f;
+                float endAngle = (twoPi * this.pathCutEnd * this.revolutions) - this.topShearY * 0.9f;
+                float stepSize = twoPi / this.stepsPerRevolution;
+
+                int step = (int)(startAngle / stepSize);
+                float angle = startAngle;
+
+                bool done = false;
+                while (!done) // loop through the length of the path and add the layers
+                {
+                    PathNode newNode = new PathNode();
+
+                    float xProfileScale = (1.0f - Math.Abs(this.skew)) * this.holeSizeX;
+                    float yProfileScale = this.holeSizeY;
+
+                    float percentOfPath = angle / (twoPi * this.revolutions);
+                    float percentOfAngles = (angle - startAngle) / (endAngle - startAngle);
+
+                    if (this.taperX > 0.01f)
+                        xProfileScale *= 1.0f - percentOfPath * this.taperX;
+                    else if (this.taperX < -0.01f)
+                        xProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperX;
+
+                    if (this.taperY > 0.01f)
+                        yProfileScale *= 1.0f - percentOfPath * this.taperY;
+                    else if (this.taperY < -0.01f)
+                        yProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperY;
+
+                    newNode.xScale = xProfileScale;
+                    newNode.yScale = yProfileScale;
+
+                    float radiusScale = 1.0f;
+                    if (this.radius > 0.001f)
+                        radiusScale = 1.0f - this.radius * percentOfPath;
+                    else if (this.radius < 0.001f)
+                        radiusScale = 1.0f + this.radius * (1.0f - percentOfPath);
+
+                    float twist = twistBegin + twistTotal * percentOfPath;
+
+                    float xOffset = 0.5f * (skewStart + totalSkew * percentOfAngles);
+                    xOffset += (float)Math.Sin(angle) * xOffsetTopShearXFactor;
+
+                    float yOffset = yShearCompensation * (float)Math.Cos(angle) * (0.5f - yPathScale) * radiusScale;
+
+                    float zOffset = (float)Math.Sin(angle + this.topShearY) * (0.5f - yPathScale) * radiusScale;
+
+                    newNode.position = new Coord(xOffset, yOffset, zOffset);
+
+                    // now orient the rotation of the profile layer relative to it's position on the path
+                    // adding taperY to the angle used to generate the quat appears to approximate the viewer
+
+                    newNode.rotation = new Quat(new Coord(1.0f, 0.0f, 0.0f), angle + this.topShearY);
+
+                    // next apply twist rotation to the profile layer
+                    if (twistTotal != 0.0f || twistBegin != 0.0f)
+                        newNode.rotation *= new Quat(new Coord(0.0f, 0.0f, 1.0f), twist);
+
+                    newNode.percentOfPath = percentOfPath;
+
+                    pathNodes.Add(newNode);
+
+                    // calculate terms for next iteration
+                    // calculate the angle for the next iteration of the loop
+
+                    if (angle >= endAngle - 0.01)
+                        done = true;
+                    else
+                    {
+                        step += 1;
+                        angle = stepSize * step;
+                        if (angle > endAngle)
+                            angle = endAngle;
+                    }
+                }
+            }
+        }
+    }
+
+    public class PrimMesh
+    {
+        public string errorMessage = "";
+        private const float twoPi = 2.0f * (float)Math.PI;
+
+        public List<Coord> coords;
+        public List<Coord> normals;
+        public List<Face> faces;
+
+        public List<ViewerFace> viewerFaces;
+
+        private int sides = 4;
+        private int hollowSides = 4;
+        private float profileStart = 0.0f;
+        private float profileEnd = 1.0f;
+        private float hollow = 0.0f;
+        public int twistBegin = 0;
+        public int twistEnd = 0;
+        public float topShearX = 0.0f;
+        public float topShearY = 0.0f;
+        public float pathCutBegin = 0.0f;
+        public float pathCutEnd = 1.0f;
+        public float dimpleBegin = 0.0f;
+        public float dimpleEnd = 1.0f;
+        public float skew = 0.0f;
+        public float holeSizeX = 1.0f; // called pathScaleX in pbs
+        public float holeSizeY = 0.25f;
+        public float taperX = 0.0f;
+        public float taperY = 0.0f;
+        public float radius = 0.0f;
+        public float revolutions = 1.0f;
+        public int stepsPerRevolution = 24;
+
+        private int profileOuterFaceNumber = -1;
+        private int profileHollowFaceNumber = -1;
+
+        private bool hasProfileCut = false;
+        private bool hasHollow = false;
+        public bool calcVertexNormals = false;
+        private bool normalsProcessed = false;
+        public bool viewerMode = false;
+        public bool sphereMode = false;
+
+        public int numPrimFaces = 0;
+
+        /// <summary>
+        /// Human readable string representation of the parameters used to create a mesh.
+        /// </summary>
+        /// <returns></returns>
+        public string ParamsToDisplayString()
+        {
+            string s = "";
+            s += "sides..................: " + this.sides.ToString();
+            s += "\nhollowSides..........: " + this.hollowSides.ToString();
+            s += "\nprofileStart.........: " + this.profileStart.ToString();
+            s += "\nprofileEnd...........: " + this.profileEnd.ToString();
+            s += "\nhollow...............: " + this.hollow.ToString();
+            s += "\ntwistBegin...........: " + this.twistBegin.ToString();
+            s += "\ntwistEnd.............: " + this.twistEnd.ToString();
+            s += "\ntopShearX............: " + this.topShearX.ToString();
+            s += "\ntopShearY............: " + this.topShearY.ToString();
+            s += "\npathCutBegin.........: " + this.pathCutBegin.ToString();
+            s += "\npathCutEnd...........: " + this.pathCutEnd.ToString();
+            s += "\ndimpleBegin..........: " + this.dimpleBegin.ToString();
+            s += "\ndimpleEnd............: " + this.dimpleEnd.ToString();
+            s += "\nskew.................: " + this.skew.ToString();
+            s += "\nholeSizeX............: " + this.holeSizeX.ToString();
+            s += "\nholeSizeY............: " + this.holeSizeY.ToString();
+            s += "\ntaperX...............: " + this.taperX.ToString();
+            s += "\ntaperY...............: " + this.taperY.ToString();
+            s += "\nradius...............: " + this.radius.ToString();
+            s += "\nrevolutions..........: " + this.revolutions.ToString();
+            s += "\nstepsPerRevolution...: " + this.stepsPerRevolution.ToString();
+            s += "\nsphereMode...........: " + this.sphereMode.ToString();
+            s += "\nhasProfileCut........: " + this.hasProfileCut.ToString();
+            s += "\nhasHollow............: " + this.hasHollow.ToString();
+            s += "\nviewerMode...........: " + this.viewerMode.ToString();
+
+            return s;
+        }
+
+        public int ProfileOuterFaceNumber
+        {
+            get { return profileOuterFaceNumber; }
+        }
+
+        public int ProfileHollowFaceNumber
+        {
+            get { return profileHollowFaceNumber; }
+        }
+
+        public bool HasProfileCut
+        {
+            get { return hasProfileCut; }
+        }
+
+        public bool HasHollow
+        {
+            get { return hasHollow; }
+        }
+
+
+        /// <summary>
+        /// Constructs a PrimMesh object and creates the profile for extrusion.
+        /// </summary>
+        /// <param name="sides"></param>
+        /// <param name="profileStart"></param>
+        /// <param name="profileEnd"></param>
+        /// <param name="hollow"></param>
+        /// <param name="hollowSides"></param>
+        public PrimMesh(int sides, float profileStart, float profileEnd, float hollow, int hollowSides)
+        {
+            this.coords = new List<Coord>();
+            this.faces = new List<Face>();
+
+            this.sides = sides;
+            this.profileStart = profileStart;
+            this.profileEnd = profileEnd;
+            this.hollow = hollow;
+            this.hollowSides = hollowSides;
+
+            if (sides < 3)
+                this.sides = 3;
+            if (hollowSides < 3)
+                this.hollowSides = 3;
+            if (profileStart < 0.0f)
+                this.profileStart = 0.0f;
+            if (profileEnd > 1.0f)
+                this.profileEnd = 1.0f;
+            if (profileEnd < 0.02f)
+                this.profileEnd = 0.02f;
+            if (profileStart >= profileEnd)
+                this.profileStart = profileEnd - 0.02f;
+            if (hollow > 0.99f)
+                this.hollow = 0.99f;
+            if (hollow < 0.0f)
+                this.hollow = 0.0f;
+        }
+
+        /// <summary>
+        /// Extrudes a profile along a path.
+        /// </summary>
+        public void Extrude(PathType pathType)
+        {
+            bool needEndFaces = false;
+
+            this.coords = new List<Coord>();
+            this.faces = new List<Face>();
+
+            if (this.viewerMode)
+            {
+                this.viewerFaces = new List<ViewerFace>();
+                this.calcVertexNormals = true;
+            }
+
+            if (this.calcVertexNormals)
+                this.normals = new List<Coord>();
+
+            int steps = 1;
+
+            float length = this.pathCutEnd - this.pathCutBegin;
+            normalsProcessed = false;
+
+            if (this.viewerMode && this.sides == 3)
+            {
+                // prisms don't taper well so add some vertical resolution
+                // other prims may benefit from this but just do prisms for now
+                if (Math.Abs(this.taperX) > 0.01 || Math.Abs(this.taperY) > 0.01)
+                    steps = (int)(steps * 4.5 * length);
+            }
+
+            if (this.sphereMode)
+                this.hasProfileCut = this.profileEnd - this.profileStart < 0.4999f;
+            else
+                this.hasProfileCut = this.profileEnd - this.profileStart < 0.9999f;
+            this.hasHollow = (this.hollow > 0.001f);
+
+            float twistBegin = this.twistBegin / 360.0f * twoPi;
+            float twistEnd = this.twistEnd / 360.0f * twoPi;
+            float twistTotal = twistEnd - twistBegin;
+            float twistTotalAbs = Math.Abs(twistTotal);
+            if (twistTotalAbs > 0.01f)
+                steps += (int)(twistTotalAbs * 3.66); //  dahlia's magic number
+
+            float hollow = this.hollow;
+
+            if (pathType == PathType.Circular)
+            {
+                needEndFaces = false;
+                if (this.pathCutBegin != 0.0f || this.pathCutEnd != 1.0f)
+                    needEndFaces = true;
+                else if (this.taperX != 0.0f || this.taperY != 0.0f)
+                    needEndFaces = true;
+                else if (this.skew != 0.0f)
+                    needEndFaces = true;
+                else if (twistTotal != 0.0f)
+                    needEndFaces = true;
+                else if (this.radius != 0.0f)
+                    needEndFaces = true;
+            }
+            else needEndFaces = true;
+
+            // sanity checks
+            float initialProfileRot = 0.0f;
+            if (pathType == PathType.Circular)
+            {
+                if (this.sides == 3)
+                {
+                    initialProfileRot = (float)Math.PI;
+                    if (this.hollowSides == 4)
+                    {
+                        if (hollow > 0.7f)
+                            hollow = 0.7f;
+                        hollow *= 0.707f;
+                    }
+                    else hollow *= 0.5f;
+                }
+                else if (this.sides == 4)
+                {
+                    initialProfileRot = 0.25f * (float)Math.PI;
+                    if (this.hollowSides != 4)
+                        hollow *= 0.707f;
+                }
+                else if (this.sides > 4)
+                {
+                    initialProfileRot = (float)Math.PI;
+                    if (this.hollowSides == 4)
+                    {
+                        if (hollow > 0.7f)
+                            hollow = 0.7f;
+                        hollow /= 0.7f;
+                    }
+                }
+            }
+            else
+            {
+                if (this.sides == 3)
+                {
+                    if (this.hollowSides == 4)
+                    {
+                        if (hollow > 0.7f)
+                            hollow = 0.7f;
+                        hollow *= 0.707f;
+                    }
+                    else hollow *= 0.5f;
+                }
+                else if (this.sides == 4)
+                {
+                    initialProfileRot = 1.25f * (float)Math.PI;
+                    if (this.hollowSides != 4)
+                        hollow *= 0.707f;
+                }
+                else if (this.sides == 24 && this.hollowSides == 4)
+                    hollow *= 1.414f;
+            }
+
+            Profile profile = new Profile(this.sides, this.profileStart, this.profileEnd, hollow, this.hollowSides, true, calcVertexNormals);
+            this.errorMessage = profile.errorMessage;
+
+            this.numPrimFaces = profile.numPrimFaces;
+
+            int cut1FaceNumber = profile.bottomFaceNumber + 1;
+            int cut2FaceNumber = cut1FaceNumber + 1;
+            if (!needEndFaces)
+            {
+                cut1FaceNumber -= 2;
+                cut2FaceNumber -= 2;
+            }
+
+            profileOuterFaceNumber = profile.outerFaceNumber;
+            if (!needEndFaces)
+                profileOuterFaceNumber--;
+
+            if (hasHollow)
+            {
+                profileHollowFaceNumber = profile.hollowFaceNumber;
+                if (!needEndFaces)
+                    profileHollowFaceNumber--;
+            }
+
+            int cut1Vert = -1;
+            int cut2Vert = -1;
+            if (hasProfileCut)
+            {
+                cut1Vert = hasHollow ? profile.coords.Count - 1 : 0;
+                cut2Vert = hasHollow ? profile.numOuterVerts - 1 : profile.numOuterVerts;
+            }
+
+            if (initialProfileRot != 0.0f)
+            {
+                profile.AddRot(new Quat(new Coord(0.0f, 0.0f, 1.0f), initialProfileRot));
+                if (viewerMode)
+                    profile.MakeFaceUVs();
+            }
+
+            Coord lastCutNormal1 = new Coord();
+            Coord lastCutNormal2 = new Coord();
+            float thisV = 0.0f;
+            float lastV = 0.0f;
+
+            Path path = new Path();
+            path.twistBegin = twistBegin;
+            path.twistEnd = twistEnd;
+            path.topShearX = topShearX;
+            path.topShearY = topShearY;
+            path.pathCutBegin = pathCutBegin;
+            path.pathCutEnd = pathCutEnd;
+            path.dimpleBegin = dimpleBegin;
+            path.dimpleEnd = dimpleEnd;
+            path.skew = skew;
+            path.holeSizeX = holeSizeX;
+            path.holeSizeY = holeSizeY;
+            path.taperX = taperX;
+            path.taperY = taperY;
+            path.radius = radius;
+            path.revolutions = revolutions;
+            path.stepsPerRevolution = stepsPerRevolution;
+
+            path.Create(pathType, steps);
+
+            for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++)
+            {
+                PathNode node = path.pathNodes[nodeIndex];
+                Profile newLayer = profile.Copy();
+                newLayer.Scale(node.xScale, node.yScale);
+
+                newLayer.AddRot(node.rotation);
+                newLayer.AddPos(node.position);
+
+                if (needEndFaces && nodeIndex == 0)
+                {
+                    newLayer.FlipNormals();
+
+                    // add the bottom faces to the viewerFaces list
+                    if (this.viewerMode)
+                    {
+                        Coord faceNormal = newLayer.faceNormal;
+                        ViewerFace newViewerFace = new ViewerFace(profile.bottomFaceNumber);
+                        int numFaces = newLayer.faces.Count;
+                        List<Face> faces = newLayer.faces;
+
+                        for (int i = 0; i < numFaces; i++)
+                        {
+                            Face face = faces[i];
+                            newViewerFace.v1 = newLayer.coords[face.v1];
+                            newViewerFace.v2 = newLayer.coords[face.v2];
+                            newViewerFace.v3 = newLayer.coords[face.v3];
+
+                            newViewerFace.coordIndex1 = face.v1;
+                            newViewerFace.coordIndex2 = face.v2;
+                            newViewerFace.coordIndex3 = face.v3;
+
+                            newViewerFace.n1 = faceNormal;
+                            newViewerFace.n2 = faceNormal;
+                            newViewerFace.n3 = faceNormal;
+
+                            newViewerFace.uv1 = newLayer.faceUVs[face.v1];
+                            newViewerFace.uv2 = newLayer.faceUVs[face.v2];
+                            newViewerFace.uv3 = newLayer.faceUVs[face.v3];
+
+                            if (pathType == PathType.Linear)
+                            {
+                                newViewerFace.uv1.Flip();
+                                newViewerFace.uv2.Flip();
+                                newViewerFace.uv3.Flip();
+                            }
+
+                            this.viewerFaces.Add(newViewerFace);
+                        }
+                    }
+                } // if (nodeIndex == 0)
+
+                // append this layer
+
+                int coordsLen = this.coords.Count;
+                newLayer.AddValue2FaceVertexIndices(coordsLen);
+
+                this.coords.AddRange(newLayer.coords);
+
+                if (this.calcVertexNormals)
+                {
+                    newLayer.AddValue2FaceNormalIndices(this.normals.Count);
+                    this.normals.AddRange(newLayer.vertexNormals);
+                }
+
+                if (node.percentOfPath < this.pathCutBegin + 0.01f || node.percentOfPath > this.pathCutEnd - 0.01f)
+                    this.faces.AddRange(newLayer.faces);
+
+                // fill faces between layers
+
+                int numVerts = newLayer.coords.Count;
+                Face newFace1 = new Face();
+                Face newFace2 = new Face();
+
+                thisV = 1.0f - node.percentOfPath;
+
+                if (nodeIndex > 0)
+                {
+                    int startVert = coordsLen + 1;
+                    int endVert = this.coords.Count;
+
+                    if (sides < 5 || this.hasProfileCut || this.hasHollow)
+                        startVert--;
+
+                    for (int i = startVert; i < endVert; i++)
+                    {
+                        int iNext = i + 1;
+                        if (i == endVert - 1)
+                            iNext = startVert;
+
+                        int whichVert = i - startVert;
+
+                        newFace1.v1 = i;
+                        newFace1.v2 = i - numVerts;
+                        newFace1.v3 = iNext;
+
+                        newFace1.n1 = newFace1.v1;
+                        newFace1.n2 = newFace1.v2;
+                        newFace1.n3 = newFace1.v3;
+                        this.faces.Add(newFace1);
+
+                        newFace2.v1 = iNext;
+                        newFace2.v2 = i - numVerts;
+                        newFace2.v3 = iNext - numVerts;
+
+                        newFace2.n1 = newFace2.v1;
+                        newFace2.n2 = newFace2.v2;
+                        newFace2.n3 = newFace2.v3;
+                        this.faces.Add(newFace2);
+
+                        if (this.viewerMode)
+                        {
+                            // add the side faces to the list of viewerFaces here
+
+                            int primFaceNum = profile.faceNumbers[whichVert];
+                            if (!needEndFaces)
+                                primFaceNum -= 1;
+
+                            ViewerFace newViewerFace1 = new ViewerFace(primFaceNum);
+                            ViewerFace newViewerFace2 = new ViewerFace(primFaceNum);
+
+                            int uIndex = whichVert;
+                            if (!hasHollow && sides > 4 && uIndex < newLayer.us.Count - 1)
+                            {
+                                uIndex++;
+                            }
+
+                            float u1 = newLayer.us[uIndex];
+                            float u2 = 1.0f;
+                            if (uIndex < (int)newLayer.us.Count - 1)
+                                u2 = newLayer.us[uIndex + 1];
+
+                            if (whichVert == cut1Vert || whichVert == cut2Vert)
+                            {
+                                u1 = 0.0f;
+                                u2 = 1.0f;
+                            }
+                            else if (sides < 5)
+                            {
+                                if (whichVert < profile.numOuterVerts)
+                                { // boxes and prisms have one texture face per side of the prim, so the U values have to be scaled
+                                    // to reflect the entire texture width
+                                    u1 *= sides;
+                                    u2 *= sides;
+                                    u2 -= (int)u1;
+                                    u1 -= (int)u1;
+                                    if (u2 < 0.1f)
+                                        u2 = 1.0f;
+                                }
+                            }
+
+                            if (this.sphereMode)
+                            {
+                                if (whichVert != cut1Vert && whichVert != cut2Vert)
+                                {
+                                    u1 = u1 * 2.0f - 1.0f;
+                                    u2 = u2 * 2.0f - 1.0f;
+
+                                    if (whichVert >= newLayer.numOuterVerts)
+                                    {
+                                        u1 -= hollow;
+                                        u2 -= hollow;
+                                    }
+
+                                }
+                            }
+
+                            newViewerFace1.uv1.U = u1;
+                            newViewerFace1.uv2.U = u1;
+                            newViewerFace1.uv3.U = u2;
+
+                            newViewerFace1.uv1.V = thisV;
+                            newViewerFace1.uv2.V = lastV;
+                            newViewerFace1.uv3.V = thisV;
+
+                            newViewerFace2.uv1.U = u2;
+                            newViewerFace2.uv2.U = u1;
+                            newViewerFace2.uv3.U = u2;
+
+                            newViewerFace2.uv1.V = thisV;
+                            newViewerFace2.uv2.V = lastV;
+                            newViewerFace2.uv3.V = lastV;
+
+                            newViewerFace1.v1 = this.coords[newFace1.v1];
+                            newViewerFace1.v2 = this.coords[newFace1.v2];
+                            newViewerFace1.v3 = this.coords[newFace1.v3];
+
+                            newViewerFace2.v1 = this.coords[newFace2.v1];
+                            newViewerFace2.v2 = this.coords[newFace2.v2];
+                            newViewerFace2.v3 = this.coords[newFace2.v3];
+
+                            newViewerFace1.coordIndex1 = newFace1.v1;
+                            newViewerFace1.coordIndex2 = newFace1.v2;
+                            newViewerFace1.coordIndex3 = newFace1.v3;
+
+                            newViewerFace2.coordIndex1 = newFace2.v1;
+                            newViewerFace2.coordIndex2 = newFace2.v2;
+                            newViewerFace2.coordIndex3 = newFace2.v3;
+
+                            // profile cut faces
+                            if (whichVert == cut1Vert)
+                            {
+                                newViewerFace1.primFaceNumber = cut1FaceNumber;
+                                newViewerFace2.primFaceNumber = cut1FaceNumber;
+                                newViewerFace1.n1 = newLayer.cutNormal1;
+                                newViewerFace1.n2 = newViewerFace1.n3 = lastCutNormal1;
+
+                                newViewerFace2.n1 = newViewerFace2.n3 = newLayer.cutNormal1;
+                                newViewerFace2.n2 = lastCutNormal1;
+                            }
+                            else if (whichVert == cut2Vert)
+                            {
+                                newViewerFace1.primFaceNumber = cut2FaceNumber;
+                                newViewerFace2.primFaceNumber = cut2FaceNumber;
+                                newViewerFace1.n1 = newLayer.cutNormal2;
+                                newViewerFace1.n2 = lastCutNormal2;
+                                newViewerFace1.n3 = lastCutNormal2;
+
+                                newViewerFace2.n1 = newLayer.cutNormal2;
+                                newViewerFace2.n3 = newLayer.cutNormal2;
+                                newViewerFace2.n2 = lastCutNormal2;
+                            }
+
+                            else // outer and hollow faces
+                            {
+                                if ((sides < 5 && whichVert < newLayer.numOuterVerts) || (hollowSides < 5 && whichVert >= newLayer.numOuterVerts))
+                                { // looks terrible when path is twisted... need vertex normals here
+                                    newViewerFace1.CalcSurfaceNormal();
+                                    newViewerFace2.CalcSurfaceNormal();
+                                }
+                                else
+                                {
+                                    newViewerFace1.n1 = this.normals[newFace1.n1];
+                                    newViewerFace1.n2 = this.normals[newFace1.n2];
+                                    newViewerFace1.n3 = this.normals[newFace1.n3];
+
+                                    newViewerFace2.n1 = this.normals[newFace2.n1];
+                                    newViewerFace2.n2 = this.normals[newFace2.n2];
+                                    newViewerFace2.n3 = this.normals[newFace2.n3];
+                                }
+                            }
+
+                            this.viewerFaces.Add(newViewerFace1);
+                            this.viewerFaces.Add(newViewerFace2);
+
+                        }
+                    }
+                }
+
+                lastCutNormal1 = newLayer.cutNormal1;
+                lastCutNormal2 = newLayer.cutNormal2;
+                lastV = thisV;
+
+                if (needEndFaces && nodeIndex == path.pathNodes.Count - 1 && viewerMode)
+                {
+                    // add the top faces to the viewerFaces list here
+                    Coord faceNormal = newLayer.faceNormal;
+                    ViewerFace newViewerFace = new ViewerFace(0);
+                    int numFaces = newLayer.faces.Count;
+                    List<Face> faces = newLayer.faces;
+
+                    for (int i = 0; i < numFaces; i++)
+                    {
+                        Face face = faces[i];
+                        newViewerFace.v1 = newLayer.coords[face.v1 - coordsLen];
+                        newViewerFace.v2 = newLayer.coords[face.v2 - coordsLen];
+                        newViewerFace.v3 = newLayer.coords[face.v3 - coordsLen];
+
+                        newViewerFace.coordIndex1 = face.v1 - coordsLen;
+                        newViewerFace.coordIndex2 = face.v2 - coordsLen;
+                        newViewerFace.coordIndex3 = face.v3 - coordsLen;
+
+                        newViewerFace.n1 = faceNormal;
+                        newViewerFace.n2 = faceNormal;
+                        newViewerFace.n3 = faceNormal;
+
+                        newViewerFace.uv1 = newLayer.faceUVs[face.v1 - coordsLen];
+                        newViewerFace.uv2 = newLayer.faceUVs[face.v2 - coordsLen];
+                        newViewerFace.uv3 = newLayer.faceUVs[face.v3 - coordsLen];
+
+                        if (pathType == PathType.Linear)
+                        {
+                            newViewerFace.uv1.Flip();
+                            newViewerFace.uv2.Flip();
+                            newViewerFace.uv3.Flip();
+                        }
+
+                        this.viewerFaces.Add(newViewerFace);
+                    }
+                }
+
+
+            } // for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++)
+
+        }
+
+
+        /// <summary>
+        /// DEPRICATED - use Extrude(PathType.Linear) instead
+        /// Extrudes a profile along a straight line path. Used for prim types box, cylinder, and prism.
+        /// </summary>
+        /// 
+        public void ExtrudeLinear()
+        {
+            this.Extrude(PathType.Linear);
+        }
+
+
+        /// <summary>
+        /// DEPRICATED - use Extrude(PathType.Circular) instead
+        /// Extrude a profile into a circular path prim mesh. Used for prim types torus, tube, and ring.
+        /// </summary>
+        /// 
+        public void ExtrudeCircular()
+        {
+            this.Extrude(PathType.Circular);
+        }
+
+
+        private Coord SurfaceNormal(Coord c1, Coord c2, Coord c3)
+        {
+            Coord edge1 = new Coord(c2.X - c1.X, c2.Y - c1.Y, c2.Z - c1.Z);
+            Coord edge2 = new Coord(c3.X - c1.X, c3.Y - c1.Y, c3.Z - c1.Z);
+
+            Coord normal = Coord.Cross(edge1, edge2);
+
+            normal.Normalize();
+
+            return normal;
+        }
+
+        private Coord SurfaceNormal(Face face)
+        {
+            return SurfaceNormal(this.coords[face.v1], this.coords[face.v2], this.coords[face.v3]);
+        }
+
+        /// <summary>
+        /// Calculate the surface normal for a face in the list of faces
+        /// </summary>
+        /// <param name="faceIndex"></param>
+        /// <returns></returns>
+        public Coord SurfaceNormal(int faceIndex)
+        {
+            int numFaces = this.faces.Count;
+            if (faceIndex < 0 || faceIndex >= numFaces)
+                throw new Exception("faceIndex out of range");
+
+            return SurfaceNormal(this.faces[faceIndex]);
+        }
+
+        /// <summary>
+        /// Duplicates a PrimMesh object. All object properties are copied by value, including lists.
+        /// </summary>
+        /// <returns></returns>
+        public PrimMesh Copy()
+        {
+            PrimMesh copy = new PrimMesh(this.sides, this.profileStart, this.profileEnd, this.hollow, this.hollowSides);
+            copy.twistBegin = this.twistBegin;
+            copy.twistEnd = this.twistEnd;
+            copy.topShearX = this.topShearX;
+            copy.topShearY = this.topShearY;
+            copy.pathCutBegin = this.pathCutBegin;
+            copy.pathCutEnd = this.pathCutEnd;
+            copy.dimpleBegin = this.dimpleBegin;
+            copy.dimpleEnd = this.dimpleEnd;
+            copy.skew = this.skew;
+            copy.holeSizeX = this.holeSizeX;
+            copy.holeSizeY = this.holeSizeY;
+            copy.taperX = this.taperX;
+            copy.taperY = this.taperY;
+            copy.radius = this.radius;
+            copy.revolutions = this.revolutions;
+            copy.stepsPerRevolution = this.stepsPerRevolution;
+            copy.calcVertexNormals = this.calcVertexNormals;
+            copy.normalsProcessed = this.normalsProcessed;
+            copy.viewerMode = this.viewerMode;
+            copy.numPrimFaces = this.numPrimFaces;
+            copy.errorMessage = this.errorMessage;
+
+            copy.coords = new List<Coord>(this.coords);
+            copy.faces = new List<Face>(this.faces);
+            copy.viewerFaces = new List<ViewerFace>(this.viewerFaces);
+            copy.normals = new List<Coord>(this.normals);
+
+            return copy;
+        }
+
+        /// <summary>
+        /// Calculate surface normals for all of the faces in the list of faces in this mesh
+        /// </summary>
+        public void CalcNormals()
+        {
+            if (normalsProcessed)
+                return;
+
+            normalsProcessed = true;
+
+            int numFaces = faces.Count;
+
+            if (!this.calcVertexNormals)
+                this.normals = new List<Coord>();
+
+            for (int i = 0; i < numFaces; i++)
+            {
+                Face face = faces[i];
+
+                this.normals.Add(SurfaceNormal(i).Normalize());
+
+                int normIndex = normals.Count - 1;
+                face.n1 = normIndex;
+                face.n2 = normIndex;
+                face.n3 = normIndex;
+
+                this.faces[i] = face;
+            }
+        }
+
+        /// <summary>
+        /// Adds a value to each XYZ vertex coordinate in the mesh
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="z"></param>
+        public void AddPos(float x, float y, float z)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+            Coord vert;
+
+            for (i = 0; i < numVerts; i++)
+            {
+                vert = this.coords[i];
+                vert.X += x;
+                vert.Y += y;
+                vert.Z += z;
+                this.coords[i] = vert;
+            }
+
+            if (this.viewerFaces != null)
+            {
+                int numViewerFaces = this.viewerFaces.Count;
+
+                for (i = 0; i < numViewerFaces; i++)
+                {
+                    ViewerFace v = this.viewerFaces[i];
+                    v.AddPos(x, y, z);
+                    this.viewerFaces[i] = v;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Rotates the mesh
+        /// </summary>
+        /// <param name="q"></param>
+        public void AddRot(Quat q)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+
+            for (i = 0; i < numVerts; i++)
+                this.coords[i] *= q;
+
+            if (this.normals != null)
+            {
+                int numNormals = this.normals.Count;
+                for (i = 0; i < numNormals; i++)
+                    this.normals[i] *= q;
+            }
+
+            if (this.viewerFaces != null)
+            {
+                int numViewerFaces = this.viewerFaces.Count;
+
+                for (i = 0; i < numViewerFaces; i++)
+                {
+                    ViewerFace v = this.viewerFaces[i];
+                    v.v1 *= q;
+                    v.v2 *= q;
+                    v.v3 *= q;
+
+                    v.n1 *= q;
+                    v.n2 *= q;
+                    v.n3 *= q;
+                    this.viewerFaces[i] = v;
+                }
+            }
+        }
+
+#if VERTEX_INDEXER
+        public VertexIndexer GetVertexIndexer()
+        {
+            if (this.viewerMode && this.viewerFaces.Count > 0)
+                return new VertexIndexer(this);
+            return null;
+        }
+#endif
+
+        /// <summary>
+        /// Scales the mesh
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="z"></param>
+        public void Scale(float x, float y, float z)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+            //Coord vert;
+
+            Coord m = new Coord(x, y, z);
+            for (i = 0; i < numVerts; i++)
+                this.coords[i] *= m;
+
+            if (this.viewerFaces != null)
+            {
+                int numViewerFaces = this.viewerFaces.Count;
+                for (i = 0; i < numViewerFaces; i++)
+                {
+                    ViewerFace v = this.viewerFaces[i];
+                    v.v1 *= m;
+                    v.v2 *= m;
+                    v.v3 *= m;
+                    this.viewerFaces[i] = v;
+                }
+
+            }
+
+        }
+
+        /// <summary>
+        /// Dumps the mesh to a Blender compatible "Raw" format file
+        /// </summary>
+        /// <param name="path"></param>
+        /// <param name="name"></param>
+        /// <param name="title"></param>
+        public void DumpRaw(String path, String name, String title)
+        {
+            if (path == null)
+                return;
+            String fileName = name + "_" + title + ".raw";
+            String completePath = System.IO.Path.Combine(path, fileName);
+            StreamWriter sw = new StreamWriter(completePath);
+
+            for (int i = 0; i < this.faces.Count; i++)
+            {
+                string s = this.coords[this.faces[i].v1].ToString();
+                s += " " + this.coords[this.faces[i].v2].ToString();
+                s += " " + this.coords[this.faces[i].v3].ToString();
+
+                sw.WriteLine(s);
+            }
+
+            sw.Close();
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/SculptMap.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/SculptMap.cs
new file mode 100644
index 0000000..b3d9cb6
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/SculptMap.cs
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) Contributors
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// to build without references to System.Drawing, comment this out
+#define SYSTEM_DRAWING
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+#if SYSTEM_DRAWING
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace PrimMesher
+{
+    public class SculptMap
+    {
+        public int width;
+        public int height;
+        public byte[] redBytes;
+        public byte[] greenBytes;
+        public byte[] blueBytes;
+
+        public SculptMap()
+        {
+        }
+
+        public SculptMap(Bitmap bm, int lod)
+        {
+            int bmW = bm.Width;
+            int bmH = bm.Height;
+
+            if (bmW == 0 || bmH == 0)
+                throw new Exception("SculptMap: bitmap has no data");
+
+            int numLodPixels = lod * lod;  // (32 * 2)^2  = 64^2 pixels for default sculpt map image
+
+            bool smallMap = bmW * bmH <= numLodPixels;
+            bool needsScaling = false;
+
+            width = bmW;
+            height = bmH;
+            while (width * height > numLodPixels * 4)
+            {
+                width >>= 1;
+                height >>= 1;
+                needsScaling = true;
+            }
+
+            try
+            {
+                if (needsScaling)
+                    bm = ScaleImage(bm, width, height);
+            }
+
+            catch (Exception e)
+            {
+                throw new Exception("Exception in ScaleImage(): e: " + e.ToString());
+            }
+
+            if (width * height > numLodPixels)
+            {
+                width >>= 1;
+                height >>= 1;
+            }
+
+            int numBytes = (width + 1) * (height + 1);
+            redBytes = new byte[numBytes];
+            greenBytes = new byte[numBytes];
+            blueBytes = new byte[numBytes];
+
+            int byteNdx = 0;
+
+            try
+            {
+                for (int y = 0; y <= height; y++)
+                {
+                    for (int x = 0; x <= width; x++)
+                    {
+                        Color c;
+
+                        if (smallMap)
+                            c = bm.GetPixel(x < width ? x : x - 1,
+                                            y < height ? y : y - 1);
+                        else
+                            c = bm.GetPixel(x < width ? x * 2 : x * 2 - 1,
+                                            y < height ? y * 2 : y * 2 - 1);
+
+                        redBytes[byteNdx] = c.R;
+                        greenBytes[byteNdx] = c.G;
+                        blueBytes[byteNdx] = c.B;
+
+                        ++byteNdx;
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                throw new Exception("Caught exception processing byte arrays in SculptMap(): e: " + e.ToString());
+            }
+
+            width++;
+            height++;
+        }
+
+        public List<List<Coord>> ToRows(bool mirror)
+        {
+            int numRows = height;
+            int numCols = width;
+
+            List<List<Coord>> rows = new List<List<Coord>>(numRows);
+
+            float pixScale = 1.0f / 255;
+
+            int rowNdx, colNdx;
+            int smNdx = 0;
+
+
+            for (rowNdx = 0; rowNdx < numRows; rowNdx++)
+            {
+                List<Coord> row = new List<Coord>(numCols);
+                for (colNdx = 0; colNdx < numCols; colNdx++)
+                {
+
+                    if (mirror)
+                        row.Add(new Coord(-((float)redBytes[smNdx] * pixScale - 0.5f), ((float)greenBytes[smNdx] * pixScale - 0.5f), (float)blueBytes[smNdx] * pixScale - 0.5f));
+                    else
+                        row.Add(new Coord((float)redBytes[smNdx] * pixScale - 0.5f, (float)greenBytes[smNdx] * pixScale - 0.5f, (float)blueBytes[smNdx] * pixScale - 0.5f));
+
+                    ++smNdx;
+                }
+                rows.Add(row);
+            }
+            return rows;
+        }
+
+        private Bitmap ScaleImage(Bitmap srcImage, int destWidth, int destHeight)
+        {
+
+            Bitmap scaledImage = new Bitmap(destWidth, destHeight, PixelFormat.Format24bppRgb);
+            
+            Color c;
+            float xscale = srcImage.Width / destWidth;
+            float yscale = srcImage.Height / destHeight;
+            
+            float sy = 0.5f;
+            for (int y = 0; y < destHeight; y++)
+            {
+                float sx = 0.5f;
+                for (int x = 0; x < destWidth; x++)
+                {
+                    try
+                    {
+                        c = srcImage.GetPixel((int)(sx), (int)(sy));
+                        scaledImage.SetPixel(x, y, Color.FromArgb(c.R, c.G, c.B));
+                    }
+                    catch (IndexOutOfRangeException)
+                    {
+                    }
+
+                    sx += xscale;
+                }
+                sy += yscale;
+            }
+            srcImage.Dispose();
+            return scaledImage;
+        }
+
+    }        
+    
+    }
+#endif
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/SculptMesh.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/SculptMesh.cs
new file mode 100644
index 0000000..4a7f3ad
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/SculptMesh.cs
@@ -0,0 +1,646 @@
+/*
+ * Copyright (c) Contributors
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// to build without references to System.Drawing, comment this out
+#define SYSTEM_DRAWING
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+
+#if SYSTEM_DRAWING
+using System.Drawing;
+using System.Drawing.Imaging;
+#endif
+
+namespace PrimMesher
+{
+
+    public class SculptMesh
+    {
+        public List<Coord> coords;
+        public List<Face> faces;
+
+        public List<ViewerFace> viewerFaces;
+        public List<Coord> normals;
+        public List<UVCoord> uvs;
+
+        public enum SculptType { sphere = 1, torus = 2, plane = 3, cylinder = 4 };
+
+#if SYSTEM_DRAWING
+
+        public SculptMesh SculptMeshFromFile(string fileName, SculptType sculptType, int lod, bool viewerMode)
+        {
+            Bitmap bitmap = (Bitmap)Bitmap.FromFile(fileName);
+            SculptMesh sculptMesh = new SculptMesh(bitmap, sculptType, lod, viewerMode);
+            bitmap.Dispose();
+            return sculptMesh;
+        }
+
+
+        public SculptMesh(string fileName, int sculptType, int lod, int viewerMode, int mirror, int invert)
+        {
+            Bitmap bitmap = (Bitmap)Bitmap.FromFile(fileName);
+            _SculptMesh(bitmap, (SculptType)sculptType, lod, viewerMode != 0, mirror != 0, invert != 0);
+            bitmap.Dispose();
+        }
+#endif
+
+        /// <summary>
+        /// ** Experimental ** May disappear from future versions ** not recommeneded for use in applications
+        /// Construct a sculpt mesh from a 2D array of floats
+        /// </summary>
+        /// <param name="zMap"></param>
+        /// <param name="xBegin"></param>
+        /// <param name="xEnd"></param>
+        /// <param name="yBegin"></param>
+        /// <param name="yEnd"></param>
+        /// <param name="viewerMode"></param>
+        public SculptMesh(float[,] zMap, float xBegin, float xEnd, float yBegin, float yEnd, bool viewerMode)
+        {
+            float xStep, yStep;
+            float uStep, vStep;
+
+            int numYElements = zMap.GetLength(0);
+            int numXElements = zMap.GetLength(1);
+
+            try
+            {
+                xStep = (xEnd - xBegin) / (float)(numXElements - 1);
+                yStep = (yEnd - yBegin) / (float)(numYElements - 1);
+
+                uStep = 1.0f / (numXElements - 1);
+                vStep = 1.0f / (numYElements - 1);
+            }
+            catch (DivideByZeroException)
+            {
+                return;
+            }
+
+            coords = new List<Coord>();
+            faces = new List<Face>();
+            normals = new List<Coord>();
+            uvs = new List<UVCoord>();
+
+            viewerFaces = new List<ViewerFace>();
+
+            int p1, p2, p3, p4;
+
+            int x, y;
+            int xStart = 0, yStart = 0;
+
+            for (y = yStart; y < numYElements; y++)
+            {
+                int rowOffset = y * numXElements;
+
+                for (x = xStart; x < numXElements; x++)
+                {
+                    /*
+                    *   p1-----p2
+                    *   | \ f2 |
+                    *   |   \  |
+                    *   | f1  \|
+                    *   p3-----p4
+                    */
+
+                    p4 = rowOffset + x;
+                    p3 = p4 - 1;
+
+                    p2 = p4 - numXElements;
+                    p1 = p3 - numXElements;
+
+                    Coord c = new Coord(xBegin + x * xStep, yBegin + y * yStep, zMap[y, x]);
+                    this.coords.Add(c);
+                    if (viewerMode)
+                    {
+                        this.normals.Add(new Coord());
+                        this.uvs.Add(new UVCoord(uStep * x, 1.0f - vStep * y));
+                    }
+
+                    if (y > 0 && x > 0)
+                    {
+                        Face f1, f2;
+
+                        if (viewerMode)
+                        {
+                            f1 = new Face(p1, p4, p3, p1, p4, p3);
+                            f1.uv1 = p1;
+                            f1.uv2 = p4;
+                            f1.uv3 = p3;
+
+                            f2 = new Face(p1, p2, p4, p1, p2, p4);
+                            f2.uv1 = p1;
+                            f2.uv2 = p2;
+                            f2.uv3 = p4;
+                        }
+                        else
+                        {
+                            f1 = new Face(p1, p4, p3);
+                            f2 = new Face(p1, p2, p4);
+                        }
+
+                        this.faces.Add(f1);
+                        this.faces.Add(f2);
+                    }
+                }
+            }
+
+            if (viewerMode)
+                calcVertexNormals(SculptType.plane, numXElements, numYElements);
+        }
+
+#if SYSTEM_DRAWING
+        public SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool viewerMode)
+        {
+            _SculptMesh(sculptBitmap, sculptType, lod, viewerMode, false, false);
+        }
+
+        public SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool viewerMode, bool mirror, bool invert)
+        {
+            _SculptMesh(sculptBitmap, sculptType, lod, viewerMode, mirror, invert);
+        }
+#endif
+
+        public SculptMesh(List<List<Coord>> rows, SculptType sculptType, bool viewerMode, bool mirror, bool invert)
+        {
+            _SculptMesh(rows, sculptType, viewerMode, mirror, invert);
+        }
+
+#if SYSTEM_DRAWING
+        /// <summary>
+        /// converts a bitmap to a list of lists of coords, while scaling the image.
+        /// the scaling is done in floating point so as to allow for reduced vertex position
+        /// quantization as the position will be averaged between pixel values. this routine will
+        /// likely fail if the bitmap width and height are not powers of 2.
+        /// </summary>
+        /// <param name="bitmap"></param>
+        /// <param name="scale"></param>
+        /// <param name="mirror"></param>
+        /// <returns></returns>
+        private List<List<Coord>> bitmap2Coords(Bitmap bitmap, int scale, bool mirror)
+        {
+            int numRows = bitmap.Height / scale;
+            int numCols = bitmap.Width / scale;
+            List<List<Coord>> rows = new List<List<Coord>>(numRows);
+
+            float pixScale = 1.0f / (scale * scale);
+            pixScale /= 255;
+
+            int imageX, imageY = 0;
+
+            int rowNdx, colNdx;
+
+            for (rowNdx = 0; rowNdx < numRows; rowNdx++)
+            {
+                List<Coord> row = new List<Coord>(numCols);
+                for (colNdx = 0; colNdx < numCols; colNdx++)
+                {
+                    imageX = colNdx * scale;
+                    int imageYStart = rowNdx * scale;
+                    int imageYEnd = imageYStart + scale;
+                    int imageXEnd = imageX + scale;
+                    float rSum = 0.0f;
+                    float gSum = 0.0f;
+                    float bSum = 0.0f;
+                    for (; imageX < imageXEnd; imageX++)
+                    {
+                        for (imageY = imageYStart; imageY < imageYEnd; imageY++)
+                        {
+                            Color c = bitmap.GetPixel(imageX, imageY);
+                            if (c.A != 255)
+                            {
+                                bitmap.SetPixel(imageX, imageY, Color.FromArgb(255, c.R, c.G, c.B));
+                                c = bitmap.GetPixel(imageX, imageY);
+                            }
+                            rSum += c.R;
+                            gSum += c.G;
+                            bSum += c.B;
+                        }
+                    }
+                    if (mirror)
+                        row.Add(new Coord(-(rSum * pixScale - 0.5f), gSum * pixScale - 0.5f, bSum * pixScale - 0.5f));
+                    else
+                        row.Add(new Coord(rSum * pixScale - 0.5f, gSum * pixScale - 0.5f, bSum * pixScale - 0.5f));
+
+                }
+                rows.Add(row);
+            }
+            return rows;
+        }
+
+        private List<List<Coord>> bitmap2CoordsSampled(Bitmap bitmap, int scale, bool mirror)
+        {
+            int numRows = bitmap.Height / scale;
+            int numCols = bitmap.Width / scale;
+            List<List<Coord>> rows = new List<List<Coord>>(numRows);
+
+            float pixScale = 1.0f / 256.0f;
+
+            int imageX, imageY = 0;
+
+            int rowNdx, colNdx;
+
+            for (rowNdx = 0; rowNdx <= numRows; rowNdx++)
+            {
+                List<Coord> row = new List<Coord>(numCols);
+                imageY = rowNdx * scale;
+                if (rowNdx == numRows) imageY--;
+                for (colNdx = 0; colNdx <= numCols; colNdx++)
+                {
+                    imageX = colNdx * scale;
+                    if (colNdx == numCols) imageX--;
+
+                    Color c = bitmap.GetPixel(imageX, imageY);
+                    if (c.A != 255)
+                    {
+                        bitmap.SetPixel(imageX, imageY, Color.FromArgb(255, c.R, c.G, c.B));
+                        c = bitmap.GetPixel(imageX, imageY);
+                    }
+
+                    if (mirror)
+                        row.Add(new Coord(-(c.R * pixScale - 0.5f), c.G * pixScale - 0.5f, c.B * pixScale - 0.5f));
+                    else
+                        row.Add(new Coord(c.R * pixScale - 0.5f, c.G * pixScale - 0.5f, c.B * pixScale - 0.5f));
+
+                }
+                rows.Add(row);
+            }
+            return rows;
+        }
+
+
+        void _SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool viewerMode, bool mirror, bool invert)
+        {
+            _SculptMesh(new SculptMap(sculptBitmap, lod).ToRows(mirror), sculptType, viewerMode, mirror, invert);
+        }
+#endif
+
+        void _SculptMesh(List<List<Coord>> rows, SculptType sculptType, bool viewerMode, bool mirror, bool invert)
+        {
+            coords = new List<Coord>();
+            faces = new List<Face>();
+            normals = new List<Coord>();
+            uvs = new List<UVCoord>();
+
+            sculptType = (SculptType)(((int)sculptType) & 0x07);
+
+            if (mirror)
+                invert = !invert;
+
+            viewerFaces = new List<ViewerFace>();
+
+            int width = rows[0].Count;
+
+            int p1, p2, p3, p4;
+
+            int imageX, imageY;
+
+            if (sculptType != SculptType.plane)
+            {
+                if (rows.Count % 2 == 0)
+                {
+                    for (int rowNdx = 0; rowNdx < rows.Count; rowNdx++)
+                        rows[rowNdx].Add(rows[rowNdx][0]);
+                }
+                else
+                {
+                    int lastIndex = rows[0].Count - 1;
+
+                    for (int i = 0; i < rows.Count; i++)
+                        rows[i][0] = rows[i][lastIndex];
+                }
+            }
+
+            Coord topPole = rows[0][width / 2];
+            Coord bottomPole = rows[rows.Count - 1][width / 2];
+
+            if (sculptType == SculptType.sphere)
+            {
+                if (rows.Count % 2 == 0)
+                {
+                    int count = rows[0].Count;
+                    List<Coord> topPoleRow = new List<Coord>(count);
+                    List<Coord> bottomPoleRow = new List<Coord>(count);
+
+                    for (int i = 0; i < count; i++)
+                    {
+                        topPoleRow.Add(topPole);
+                        bottomPoleRow.Add(bottomPole);
+                    }
+                    rows.Insert(0, topPoleRow);
+                    rows.Add(bottomPoleRow);
+                }
+                else
+                {
+                    int count = rows[0].Count;
+
+                    List<Coord> topPoleRow = rows[0];
+                    List<Coord> bottomPoleRow = rows[rows.Count - 1];
+
+                    for (int i = 0; i < count; i++)
+                    {
+                        topPoleRow[i] = topPole;
+                        bottomPoleRow[i] = bottomPole;
+                    }
+                }
+            }
+
+            if (sculptType == SculptType.torus)
+                rows.Add(rows[0]);
+
+            int coordsDown = rows.Count;
+            int coordsAcross = rows[0].Count;
+//            int lastColumn = coordsAcross - 1;
+
+            float widthUnit = 1.0f / (coordsAcross - 1);
+            float heightUnit = 1.0f / (coordsDown - 1);
+
+            for (imageY = 0; imageY < coordsDown; imageY++)
+            {
+                int rowOffset = imageY * coordsAcross;
+
+                for (imageX = 0; imageX < coordsAcross; imageX++)
+                {
+                    /*
+                    *   p1-----p2
+                    *   | \ f2 |
+                    *   |   \  |
+                    *   | f1  \|
+                    *   p3-----p4
+                    */
+
+                    p4 = rowOffset + imageX;
+                    p3 = p4 - 1;
+
+                    p2 = p4 - coordsAcross;
+                    p1 = p3 - coordsAcross;
+
+                    this.coords.Add(rows[imageY][imageX]);
+                    if (viewerMode)
+                    {
+                        this.normals.Add(new Coord());
+                        this.uvs.Add(new UVCoord(widthUnit * imageX, heightUnit * imageY));
+                    }
+
+                    if (imageY > 0 && imageX > 0)
+                    {
+                        Face f1, f2;
+
+                        if (viewerMode)
+                        {
+                            if (invert)
+                            {
+                                f1 = new Face(p1, p4, p3, p1, p4, p3);
+                                f1.uv1 = p1;
+                                f1.uv2 = p4;
+                                f1.uv3 = p3;
+
+                                f2 = new Face(p1, p2, p4, p1, p2, p4);
+                                f2.uv1 = p1;
+                                f2.uv2 = p2;
+                                f2.uv3 = p4;
+                            }
+                            else
+                            {
+                                f1 = new Face(p1, p3, p4, p1, p3, p4);
+                                f1.uv1 = p1;
+                                f1.uv2 = p3;
+                                f1.uv3 = p4;
+
+                                f2 = new Face(p1, p4, p2, p1, p4, p2);
+                                f2.uv1 = p1;
+                                f2.uv2 = p4;
+                                f2.uv3 = p2;
+                            }
+                        }
+                        else
+                        {
+                            if (invert)
+                            {
+                                f1 = new Face(p1, p4, p3);
+                                f2 = new Face(p1, p2, p4);
+                            }
+                            else
+                            {
+                                f1 = new Face(p1, p3, p4);
+                                f2 = new Face(p1, p4, p2);
+                            }
+                        }
+
+                        this.faces.Add(f1);
+                        this.faces.Add(f2);
+                    }
+                }
+            }
+
+            if (viewerMode)
+                calcVertexNormals(sculptType, coordsAcross, coordsDown);
+        }
+
+        /// <summary>
+        /// Duplicates a SculptMesh object. All object properties are copied by value, including lists.
+        /// </summary>
+        /// <returns></returns>
+        public SculptMesh Copy()
+        {
+            return new SculptMesh(this);
+        }
+
+        public SculptMesh(SculptMesh sm)
+        {
+            coords = new List<Coord>(sm.coords);
+            faces = new List<Face>(sm.faces);
+            viewerFaces = new List<ViewerFace>(sm.viewerFaces);
+            normals = new List<Coord>(sm.normals);
+            uvs = new List<UVCoord>(sm.uvs);
+        }
+
+        private void calcVertexNormals(SculptType sculptType, int xSize, int ySize)
+        {  // compute vertex normals by summing all the surface normals of all the triangles sharing
+            // each vertex and then normalizing
+            int numFaces = this.faces.Count;
+            for (int i = 0; i < numFaces; i++)
+            {
+                Face face = this.faces[i];
+                Coord surfaceNormal = face.SurfaceNormal(this.coords);
+                this.normals[face.n1] += surfaceNormal;
+                this.normals[face.n2] += surfaceNormal;
+                this.normals[face.n3] += surfaceNormal;
+            }
+
+            int numNormals = this.normals.Count;
+            for (int i = 0; i < numNormals; i++)
+                this.normals[i] = this.normals[i].Normalize();
+
+            if (sculptType != SculptType.plane)
+            { // blend the vertex normals at the cylinder seam
+                for (int y = 0; y < ySize; y++)
+                {
+                    int rowOffset = y * xSize;
+
+                    this.normals[rowOffset] = this.normals[rowOffset + xSize - 1] = (this.normals[rowOffset] + this.normals[rowOffset + xSize - 1]).Normalize();
+                }
+            }
+
+            foreach (Face face in this.faces)
+            {
+                ViewerFace vf = new ViewerFace(0);
+                vf.v1 = this.coords[face.v1];
+                vf.v2 = this.coords[face.v2];
+                vf.v3 = this.coords[face.v3];
+
+                vf.coordIndex1 = face.v1;
+                vf.coordIndex2 = face.v2;
+                vf.coordIndex3 = face.v3;
+
+                vf.n1 = this.normals[face.n1];
+                vf.n2 = this.normals[face.n2];
+                vf.n3 = this.normals[face.n3];
+
+                vf.uv1 = this.uvs[face.uv1];
+                vf.uv2 = this.uvs[face.uv2];
+                vf.uv3 = this.uvs[face.uv3];
+
+                this.viewerFaces.Add(vf);
+            }
+        }
+
+        /// <summary>
+        /// Adds a value to each XYZ vertex coordinate in the mesh
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="z"></param>
+        public void AddPos(float x, float y, float z)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+            Coord vert;
+
+            for (i = 0; i < numVerts; i++)
+            {
+                vert = this.coords[i];
+                vert.X += x;
+                vert.Y += y;
+                vert.Z += z;
+                this.coords[i] = vert;
+            }
+
+            if (this.viewerFaces != null)
+            {
+                int numViewerFaces = this.viewerFaces.Count;
+
+                for (i = 0; i < numViewerFaces; i++)
+                {
+                    ViewerFace v = this.viewerFaces[i];
+                    v.AddPos(x, y, z);
+                    this.viewerFaces[i] = v;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Rotates the mesh
+        /// </summary>
+        /// <param name="q"></param>
+        public void AddRot(Quat q)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+
+            for (i = 0; i < numVerts; i++)
+                this.coords[i] *= q;
+
+            int numNormals = this.normals.Count;
+            for (i = 0; i < numNormals; i++)
+                this.normals[i] *= q;
+
+            if (this.viewerFaces != null)
+            {
+                int numViewerFaces = this.viewerFaces.Count;
+
+                for (i = 0; i < numViewerFaces; i++)
+                {
+                    ViewerFace v = this.viewerFaces[i];
+                    v.v1 *= q;
+                    v.v2 *= q;
+                    v.v3 *= q;
+
+                    v.n1 *= q;
+                    v.n2 *= q;
+                    v.n3 *= q;
+
+                    this.viewerFaces[i] = v;
+                }
+            }
+        }
+
+        public void Scale(float x, float y, float z)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+
+            Coord m = new Coord(x, y, z);
+            for (i = 0; i < numVerts; i++)
+                this.coords[i] *= m;
+
+            if (this.viewerFaces != null)
+            {
+                int numViewerFaces = this.viewerFaces.Count;
+                for (i = 0; i < numViewerFaces; i++)
+                {
+                    ViewerFace v = this.viewerFaces[i];
+                    v.v1 *= m;
+                    v.v2 *= m;
+                    v.v3 *= m;
+                    this.viewerFaces[i] = v;
+                }
+            }
+        }
+
+        public void DumpRaw(String path, String name, String title)
+        {
+            if (path == null)
+                return;
+            String fileName = name + "_" + title + ".raw";
+            String completePath = System.IO.Path.Combine(path, fileName);
+            StreamWriter sw = new StreamWriter(completePath);
+
+            for (int i = 0; i < this.faces.Count; i++)
+            {
+                string s = this.coords[this.faces[i].v1].ToString();
+                s += " " + this.coords[this.faces[i].v2].ToString();
+                s += " " + this.coords[this.faces[i].v3].ToString();
+
+                sw.WriteLine(s);
+            }
+
+            sw.Close();
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Properties/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/Meshing/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..d6ac8b2
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Meshing/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using Mono.Addins;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("OpenSim.Region.PhysicsModules.Meshing")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("http://opensimulator.org")]
+[assembly: AssemblyProduct("OpenSim")]
+[assembly: AssemblyCopyright("OpenSimulator developers")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("4b7e35c2-a9dd-4b10-b778-eb417f4f6884")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.8.2.*")]
+
+[assembly: Addin("OpenSim.Region.PhysicsModules.Meshing", OpenSim.VersionInfo.VersionNumber)]
+[assembly: AddinDependency("OpenSim.Region.Framework", OpenSim.VersionInfo.VersionNumber)]
diff --git a/OpenSim/Region/PhysicsModules/Meshing/ZeroMesher.cs b/OpenSim/Region/PhysicsModules/Meshing/ZeroMesher.cs
new file mode 100644
index 0000000..09676c6
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Meshing/ZeroMesher.cs
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Reflection;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenMetaverse;
+using Nini.Config;
+using Mono.Addins;
+using log4net;
+
+/*
+ * This is the zero mesher.
+ * Whatever you want him to mesh, he can't, telling you that by responding with a null pointer.
+ * Effectivly this is for switching off meshing and for testing as each physics machine should deal
+ * with the null pointer situation.
+ * But it's also a convenience thing, as physics machines can rely on having a mesher in any situation, even
+ * if it's a dump one like this.
+ * Note, that this mesher is *not* living in a module but in the manager itself, so
+ * it's always availabe and thus the default in case of configuration errors
+*/
+
+namespace OpenSim.Region.PhysicsModules.Meshing
+{
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "ZeroMesher")]
+    public class ZeroMesher : IMesher, INonSharedRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private bool m_Enabled = false;
+
+        #region INonSharedRegionModule
+        public string Name
+        {
+            get { return "ZeroMesher"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            // TODO: Move this out of Startup
+            IConfig config = source.Configs["Startup"];
+            if (config != null)
+            {
+                // This is the default Mesher
+                string mesher = config.GetString("meshing", Name);
+                if (mesher == Name)
+                    m_Enabled = true;
+            }
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            scene.RegisterModuleInterface<IMesher>(this);
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            scene.UnregisterModuleInterface<IMesher>(this);
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+        }
+        #endregion
+
+        #region IMesher
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod)
+        {
+            return CreateMesh(primName, primShape, size, lod, false);
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool shouldCache, bool convex, bool forOde)
+        {
+            return CreateMesh(primName, primShape, size, lod, false);
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool convex,bool forOde)
+        {
+            return CreateMesh(primName, primShape, size, lod, false);
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical)
+        {
+            // Remove the reference to the encoded JPEG2000 data so it can be GCed
+            primShape.SculptData = OpenMetaverse.Utils.EmptyBytes;
+
+            return null;
+        }
+
+        public IMesh GetMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool convex)
+        {
+            return null;
+        }
+
+        public void ReleaseMesh(IMesh mesh) { }
+        public void ExpireReleaseMeshs() { }
+        public void ExpireFileCache() { }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Ode/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/Ode/AssemblyInfo.cs
new file mode 100644
index 0000000..7869739
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Ode/AssemblyInfo.cs
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+using Mono.Addins;
+
+// Information about this assembly is defined by the following
+// attributes.
+//
+// change them to the information which is associated with the assembly
+// you compile.
+
+[assembly : AssemblyTitle("OdePlugin")]
+[assembly : AssemblyDescription("")]
+[assembly : AssemblyConfiguration("")]
+[assembly : AssemblyCompany("http://opensimulator.org")]
+[assembly : AssemblyProduct("OdePlugin")]
+[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers")]
+[assembly : AssemblyTrademark("")]
+[assembly : AssemblyCulture("")]
+
+// This sets the default COM visibility of types in the assembly to invisible.
+// If you need to expose a type to COM, use [ComVisible(true)] on that type.
+
+[assembly : ComVisible(false)]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all values by your own or you can build default build and revision
+// numbers with the '*' character (the default):
+
+[assembly : AssemblyVersion("0.8.2.*")]
+
+[assembly: Addin("OpenSim.Region.PhysicsModule.ODE", OpenSim.VersionInfo.VersionNumber)]
+[assembly: AddinDependency("OpenSim.Region.Framework", OpenSim.VersionInfo.VersionNumber)]
diff --git a/OpenSim/Region/PhysicsModules/Ode/ODECharacter.cs b/OpenSim/Region/PhysicsModules/Ode/ODECharacter.cs
new file mode 100644
index 0000000..b35c299
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Ode/ODECharacter.cs
@@ -0,0 +1,1409 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenMetaverse;
+using Ode.NET;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using log4net;
+
+namespace OpenSim.Region.PhysicsModule.ODE
+{
+    /// <summary>
+    /// Various properties that ODE uses for AMotors but isn't exposed in ODE.NET so we must define them ourselves.
+    /// </summary>
+    public enum dParam : int
+    {
+        LowStop = 0,
+        HiStop = 1,
+        Vel = 2,
+        FMax = 3,
+        FudgeFactor = 4,
+        Bounce = 5,
+        CFM = 6,
+        StopERP = 7,
+        StopCFM = 8,
+        LoStop2 = 256,
+        HiStop2 = 257,
+        Vel2 = 258,
+        FMax2 = 259,
+        StopERP2 = 7 + 256,
+        StopCFM2 = 8 + 256,
+        LoStop3 = 512,
+        HiStop3 = 513,
+        Vel3 = 514,
+        FMax3 = 515,
+        StopERP3 = 7 + 512,
+        StopCFM3 = 8 + 512
+    }
+
+    public class OdeCharacter : PhysicsActor
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Vector3 _position;
+        private d.Vector3 _zeroPosition;
+        private bool _zeroFlag = false;
+        private bool m_lastUpdateSent = false;
+        private Vector3 _velocity;
+        private Vector3 m_taintTargetVelocity;
+        private Vector3 _target_velocity;
+        private Vector3 _acceleration;
+        private Vector3 m_rotationalVelocity;
+        private float m_mass = 80f;
+        private float m_density = 60f;
+        private bool m_pidControllerActive = true;
+        private float PID_D = 800.0f;
+        private float PID_P = 900.0f;
+        //private static float POSTURE_SERVO = 10000.0f;
+        private float CAPSULE_RADIUS = 0.37f;
+        private float CAPSULE_LENGTH = 2.140599f;
+        private float m_tensor = 3800000f;
+//        private float heightFudgeFactor = 0.52f;
+        private float walkDivisor = 1.3f;
+        private float runDivisor = 0.8f;
+        private bool flying = false;
+        private bool m_iscolliding = false;
+        private bool m_iscollidingGround = false;
+        private bool m_wascolliding = false;
+        private bool m_wascollidingGround = false;
+        private bool m_iscollidingObj = false;
+        private bool m_alwaysRun = false;
+        private bool m_hackSentFall = false;
+        private bool m_hackSentFly = false;
+        private int m_requestedUpdateFrequency = 0;
+        private Vector3 m_taintPosition;
+        internal bool m_avatarplanted = false;
+        /// <summary>
+        /// Hold set forces so we can process them outside physics calculations.  This prevents race conditions if we set force
+        /// while calculatios are going on
+        /// </summary>
+        private Vector3 m_taintForce;
+
+        // taints and their non-tainted counterparts
+        private bool m_isPhysical = false; // the current physical status
+        private bool m_tainted_isPhysical = false; // set when the physical status is tainted (false=not existing in physics engine, true=existing)
+        internal float MinimumGroundFlightOffset = 3f;
+
+        private float m_tainted_CAPSULE_LENGTH; // set when the capsule length changes.
+
+        /// <summary>
+        /// Base movement for calculating tilt.
+        /// </summary>
+        private float m_tiltBaseMovement = (float)Math.Sqrt(2);
+
+        /// <summary>
+        /// Used to introduce a fixed tilt because a straight-up capsule falls through terrain, probably a bug in terrain collider
+        /// </summary>
+        private float m_tiltMagnitudeWhenProjectedOnXYPlane = 0.1131371f;
+
+        private float m_buoyancy = 0f;
+
+        // private CollisionLocker ode;
+        private bool[] m_colliderarr = new bool[11];
+        private bool[] m_colliderGroundarr = new bool[11];
+
+        // Default we're a Character
+        private CollisionCategories m_collisionCategories = (CollisionCategories.Character);
+
+        // Default, Collide with Other Geometries, spaces, bodies and characters.
+        private CollisionCategories m_collisionFlags = (CollisionCategories.Geom
+                                                        | CollisionCategories.Space
+                                                        | CollisionCategories.Body
+                                                        | CollisionCategories.Character
+                                                        | CollisionCategories.Land);
+        /// <summary>
+        /// Body for dynamics simulation
+        /// </summary>
+        internal IntPtr Body { get; private set; }
+
+        private OdeScene _parent_scene;
+
+        /// <summary>
+        /// Collision geometry
+        /// </summary>
+        internal IntPtr Shell { get; private set; }
+        
+        private IntPtr Amotor = IntPtr.Zero;
+        private d.Mass ShellMass;
+
+        private int m_eventsubscription = 0;
+        private CollisionEventUpdate CollisionEventsThisFrame = new CollisionEventUpdate();
+
+        // unique UUID of this character object
+        internal UUID m_uuid { get; private set; }
+        internal bool bad = false;
+
+        /// <summary>
+        /// ODE Avatar.
+        /// </summary>
+        /// <param name="avName"></param>
+        /// <param name="parent_scene"></param>
+        /// <param name="pos"></param>
+        /// <param name="vel"></param>
+        /// <param name="size"></param>
+        /// <param name="pid_d"></param>
+        /// <param name="pid_p"></param>
+        /// <param name="capsule_radius"></param>
+        /// <param name="tensor"></param>
+        /// <param name="density">
+        /// Only used right now to return information to LSL.  Not actually used to set mass in ODE!
+        /// </param>
+        /// <param name="walk_divisor"></param>
+        /// <param name="rundivisor"></param>
+        public OdeCharacter(
+            String avName, OdeScene parent_scene, Vector3 pos, Vector3 vel, Vector3 size, float pid_d, float pid_p,
+            float capsule_radius, float tensor, float density,
+            float walk_divisor, float rundivisor)
+        {
+            m_uuid = UUID.Random();
+
+            if (pos.IsFinite())
+            {
+                if (pos.Z > 9999999f)
+                {
+                    pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
+                }
+                if (pos.Z < -90000f)
+                {
+                    pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
+                }
+
+                _position = pos;
+                m_taintPosition = pos;
+            }
+            else
+            {
+                _position
+                    = new Vector3(
+                        (float)_parent_scene.WorldExtents.X * 0.5f,
+                        (float)_parent_scene.WorldExtents.Y * 0.5f,
+                        parent_scene.GetTerrainHeightAtXY(128f, 128f) + 10f);
+                m_taintPosition = _position;
+
+                m_log.WarnFormat("[ODE CHARACTER]: Got NaN Position on Character Create for {0}", avName);
+            }
+
+            _velocity = vel;
+            m_taintTargetVelocity = vel;
+
+            _parent_scene = parent_scene;
+
+            PID_D = pid_d;
+            PID_P = pid_p;
+            CAPSULE_RADIUS = capsule_radius;
+            m_tensor = tensor;
+            m_density = density;
+//            heightFudgeFactor = height_fudge_factor;
+            walkDivisor = walk_divisor;
+            runDivisor = rundivisor;
+
+            // m_StandUpRotation =
+            //     new d.Matrix3(0.5f, 0.7071068f, 0.5f, -0.7071068f, 0f, 0.7071068f, 0.5f, -0.7071068f,
+            //                   0.5f);
+
+            // We can set taint and actual to be the same here, since the entire character will be set up when the
+            // m_tainted_isPhysical is processed.
+            SetTaintedCapsuleLength(size);
+            CAPSULE_LENGTH = m_tainted_CAPSULE_LENGTH;
+
+            m_isPhysical = false; // current status: no ODE information exists
+            m_tainted_isPhysical = true; // new tainted status: need to create ODE information
+
+            _parent_scene.AddPhysicsActorTaint(this);
+            
+            Name = avName;
+        }
+
+        public override int PhysicsActorType
+        {
+            get { return (int) ActorTypes.Agent; }
+            set { return; }
+        }
+
+        /// <summary>
+        /// If this is set, the avatar will move faster
+        /// </summary>
+        public override bool SetAlwaysRun
+        {
+            get { return m_alwaysRun; }
+            set { m_alwaysRun = value; }
+        }
+
+        public override bool Grabbed
+        {
+            set { return; }
+        }
+
+        public override bool Selected
+        {
+            set { return; }
+        }
+
+        public override float Buoyancy
+        {
+            get { return m_buoyancy; }
+            set { m_buoyancy = value; }
+        }
+
+        public override bool FloatOnWater
+        {
+            set { return; }
+        }
+
+        public override bool IsPhysical
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool ThrottleUpdates
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Flying
+        {
+            get { return flying; }
+            set
+            {
+                flying = value;
+//                m_log.DebugFormat("[ODE CHARACTER]: Set OdeCharacter Flying to {0}", flying);
+            }
+        }
+
+        /// <summary>
+        /// Returns if the avatar is colliding in general.
+        /// This includes the ground and objects and avatar.
+        /// </summary>
+        public override bool IsColliding
+        {
+            get { return m_iscolliding; }
+            set
+            {
+                int i;
+                int truecount = 0;
+                int falsecount = 0;
+
+                if (m_colliderarr.Length >= 10)
+                {
+                    for (i = 0; i < 10; i++)
+                    {
+                        m_colliderarr[i] = m_colliderarr[i + 1];
+                    }
+                }
+                m_colliderarr[10] = value;
+
+                for (i = 0; i < 11; i++)
+                {
+                    if (m_colliderarr[i])
+                    {
+                        truecount++;
+                    }
+                    else
+                    {
+                        falsecount++;
+                    }
+                }
+
+                // Equal truecounts and false counts means we're colliding with something.
+
+                if (falsecount > 1.2*truecount)
+                {
+                    m_iscolliding = false;
+                }
+                else
+                {
+                    m_iscolliding = true;
+                }
+
+                if (m_wascolliding != m_iscolliding)
+                {
+                    //base.SendCollisionUpdate(new CollisionEventUpdate());
+                }
+
+                m_wascolliding = m_iscolliding;
+            }
+        }
+
+        /// <summary>
+        /// Returns if an avatar is colliding with the ground
+        /// </summary>
+        public override bool CollidingGround
+        {
+            get { return m_iscollidingGround; }
+            set
+            {
+                // Collisions against the ground are not really reliable
+                // So, to get a consistant value we have to average the current result over time
+                // Currently we use 1 second = 10 calls to this.
+                int i;
+                int truecount = 0;
+                int falsecount = 0;
+
+                if (m_colliderGroundarr.Length >= 10)
+                {
+                    for (i = 0; i < 10; i++)
+                    {
+                        m_colliderGroundarr[i] = m_colliderGroundarr[i + 1];
+                    }
+                }
+                m_colliderGroundarr[10] = value;
+
+                for (i = 0; i < 11; i++)
+                {
+                    if (m_colliderGroundarr[i])
+                    {
+                        truecount++;
+                    }
+                    else
+                    {
+                        falsecount++;
+                    }
+                }
+
+                // Equal truecounts and false counts means we're colliding with something.
+
+                if (falsecount > 1.2*truecount)
+                {
+                    m_iscollidingGround = false;
+                }
+                else
+                {
+                    m_iscollidingGround = true;
+                }
+                if (m_wascollidingGround != m_iscollidingGround)
+                {
+                    //base.SendCollisionUpdate(new CollisionEventUpdate());
+                }
+                m_wascollidingGround = m_iscollidingGround;
+            }
+        }
+
+        /// <summary>
+        /// Returns if the avatar is colliding with an object
+        /// </summary>
+        public override bool CollidingObj
+        {
+            get { return m_iscollidingObj; }
+            set
+            {
+                m_iscollidingObj = value;
+                if (value && !m_avatarplanted)
+                    m_pidControllerActive = false;
+                else
+                    m_pidControllerActive = true;
+            }
+        }
+
+        /// <summary>
+        /// turn the PID controller on or off.
+        /// The PID Controller will turn on all by itself in many situations
+        /// </summary>
+        /// <param name="status"></param>
+        public void SetPidStatus(bool status)
+        {
+            m_pidControllerActive = status;
+        }
+
+        public override bool Stopped
+        {
+            get { return _zeroFlag; }
+        }
+
+        /// <summary>
+        /// This 'puts' an avatar somewhere in the physics space.
+        /// Not really a good choice unless you 'know' it's a good
+        /// spot otherwise you're likely to orbit the avatar.
+        /// </summary>
+        public override Vector3 Position
+        {
+            get { return _position; }
+            set
+            {
+                if (Body == IntPtr.Zero || Shell == IntPtr.Zero)
+                {
+                    if (value.IsFinite())
+                    {
+                        if (value.Z > 9999999f)
+                        {
+                            value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
+                        }
+                        if (value.Z < -90000f)
+                        {
+                            value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
+                        }
+
+                        m_taintPosition = value;                        
+                        _parent_scene.AddPhysicsActorTaint(this);
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("[ODE CHARACTER]: Got a NaN Position from Scene on character {0}", Name);
+                    }
+                }
+            }
+        }
+
+        public override Vector3 RotationalVelocity
+        {
+            get { return m_rotationalVelocity; }
+            set { m_rotationalVelocity = value; }
+        }
+
+        /// <summary>
+        /// This property sets the height of the avatar only.  We use the height to make sure the avatar stands up straight
+        /// and use it to offset landings properly
+        /// </summary>
+        public override Vector3 Size
+        {
+            get { return new Vector3(CAPSULE_RADIUS * 2, CAPSULE_RADIUS * 2, CAPSULE_LENGTH); }
+            set
+            {
+                SetTaintedCapsuleLength(value);
+
+                    // If we reset velocity here, then an avatar stalls when it crosses a border for the first time
+                    // (as the height of the new root agent is set).
+//                    Velocity = Vector3.Zero;
+
+                _parent_scene.AddPhysicsActorTaint(this);
+            }
+        }
+
+        private void SetTaintedCapsuleLength(Vector3 size)
+        {
+            if (size.IsFinite())
+            {
+                m_pidControllerActive = true;
+
+                m_tainted_CAPSULE_LENGTH = size.Z - CAPSULE_RADIUS * 2.0f;
+
+                // m_log.InfoFormat("[ODE CHARACTER]: Size = {0}, Capsule Length = {1} (Capsule Radius = {2})",
+                //     size, m_tainted_CAPSULE_LENGTH, CAPSULE_RADIUS);
+            }
+            else
+            {
+                m_log.WarnFormat("[ODE CHARACTER]: Got a NaN Size for {0} in {1}", Name, _parent_scene.PhysicsSceneName);
+            }
+        }
+
+        private void AlignAvatarTiltWithCurrentDirectionOfMovement(Vector3 movementVector)
+        {
+            movementVector.Z = 0f;
+            float magnitude = (float)Math.Sqrt((double)(movementVector.X * movementVector.X + movementVector.Y * movementVector.Y));
+            if (magnitude < 0.1f) return;
+
+            // normalize the velocity vector
+            float invMagnitude = 1.0f / magnitude;
+            movementVector.X *= invMagnitude;
+            movementVector.Y *= invMagnitude;
+
+            // if we change the capsule heading too often, the capsule can fall down
+            // therefore we snap movement vector to just 1 of 4 predefined directions (ne, nw, se, sw),
+            // meaning only 4 possible capsule tilt orientations
+            if (movementVector.X > 0)
+            {
+                // east
+                if (movementVector.Y > 0)
+                {
+                    // northeast
+                    movementVector.X = m_tiltBaseMovement;
+                    movementVector.Y = m_tiltBaseMovement;
+                }
+                else
+                {
+                    // southeast
+                    movementVector.X = m_tiltBaseMovement;
+                    movementVector.Y = -m_tiltBaseMovement;
+                }
+            }
+            else
+            {
+                // west
+                if (movementVector.Y > 0)
+                {
+                    // northwest
+                    movementVector.X = -m_tiltBaseMovement;
+                    movementVector.Y = m_tiltBaseMovement;
+                }
+                else
+                {
+                    // southwest
+                    movementVector.X = -m_tiltBaseMovement;
+                    movementVector.Y = -m_tiltBaseMovement;
+                }
+            }
+
+            // movementVector.Z is zero
+
+            // calculate tilt components based on desired amount of tilt and current (snapped) heading.
+            // the "-" sign is to force the tilt to be OPPOSITE the direction of movement.
+            float xTiltComponent = -movementVector.X * m_tiltMagnitudeWhenProjectedOnXYPlane;
+            float yTiltComponent = -movementVector.Y * m_tiltMagnitudeWhenProjectedOnXYPlane;
+
+            //m_log.Debug("[ODE CHARACTER]: changing avatar tilt");
+            d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, xTiltComponent);
+            d.JointSetAMotorParam(Amotor, (int)dParam.HiStop, xTiltComponent); // must be same as lowstop, else a different, spurious tilt is introduced
+            d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, yTiltComponent);
+            d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, yTiltComponent); // same as lowstop
+            d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, 0f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 0f); // same as lowstop
+        }
+
+        /// <summary>
+        /// Uses the capped cyllinder volume formula to calculate the avatar's mass.
+        /// This may be used in calculations in the scene/scenepresence
+        /// </summary>
+        public override float Mass
+        {
+            get
+            {
+                float AVvolume = (float)(Math.PI * Math.Pow(CAPSULE_RADIUS, 2) * CAPSULE_LENGTH);
+                return m_density * AVvolume;
+            }
+        }
+
+        public override void link(PhysicsActor obj) {}
+
+        public override void delink() {}
+
+        public override void LockAngularMotion(Vector3 axis) {}
+
+//      This code is very useful. Written by DanX0r. We're just not using it right now.
+//      Commented out to prevent a warning.
+//
+//         private void standupStraight()
+//         {
+//             // The purpose of this routine here is to quickly stabilize the Body while it's popped up in the air.
+//             // The amotor needs a few seconds to stabilize so without it, the avatar shoots up sky high when you
+//             // change appearance and when you enter the simulator
+//             // After this routine is done, the amotor stabilizes much quicker
+//             d.Vector3 feet;
+//             d.Vector3 head;
+//             d.BodyGetRelPointPos(Body, 0.0f, 0.0f, -1.0f, out feet);
+//             d.BodyGetRelPointPos(Body, 0.0f, 0.0f, 1.0f, out head);
+//             float posture = head.Z - feet.Z;
+
+//             // restoring force proportional to lack of posture:
+//             float servo = (2.5f - posture) * POSTURE_SERVO;
+//             d.BodyAddForceAtRelPos(Body, 0.0f, 0.0f, servo, 0.0f, 0.0f, 1.0f);
+//             d.BodyAddForceAtRelPos(Body, 0.0f, 0.0f, -servo, 0.0f, 0.0f, -1.0f);
+//             //d.Matrix3 bodyrotation = d.BodyGetRotation(Body);
+//             //m_log.Info("[PHYSICSAV]: Rotation: " + bodyrotation.M00 + " : " + bodyFArotation.M01 + " : " + bodyrotation.M02 + " : " + bodyrotation.M10 + " : " + bodyrotation.M11 + " : " + bodyrotation.M12 + " : " + bodyrotation.M20 + " : " + bodyrotation.M21 + " : " + bodyrotation.M22);
+//         }
+
+        public override Vector3 Force
+        {
+            get { return _target_velocity; }
+            set { return; }
+        }
+
+        public override int VehicleType
+        {
+            get { return 0; }
+            set { return; }
+        }
+
+        public override void VehicleFloatParam(int param, float value)
+        {
+        }
+
+        public override void VehicleVectorParam(int param, Vector3 value)
+        {
+        }
+
+        public override void VehicleRotationParam(int param, Quaternion rotation)
+        {
+        }
+
+        public override void VehicleFlags(int param, bool remove)
+        {
+        }
+
+        public override void SetVolumeDetect(int param)
+        {
+        }
+
+        public override Vector3 CenterOfMass
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override Vector3 GeometricCenter
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override PrimitiveBaseShape Shape
+        {
+            set { return; }
+        }
+
+        public override Vector3 TargetVelocity
+        {
+            get
+            {
+                return m_taintTargetVelocity;
+            }
+
+            set
+            {
+                Velocity = value;
+            }
+        }
+
+
+        public override Vector3 Velocity
+        {
+            get
+            {
+                // There's a problem with Vector3.Zero! Don't Use it Here!
+                if (_zeroFlag)
+                    return Vector3.Zero;
+                m_lastUpdateSent = false;
+                return _velocity;
+            }
+
+            set
+            {
+                if (value.IsFinite())
+                {
+                    m_pidControllerActive = true;
+                    m_taintTargetVelocity = value;
+                    _parent_scene.AddPhysicsActorTaint(this);
+                }
+                else
+                {
+                    m_log.WarnFormat("[ODE CHARACTER]: Got a NaN velocity from Scene for {0}", Name);
+                }
+
+//                m_log.DebugFormat("[PHYSICS]: Set target velocity of {0}", m_taintTargetVelocity);
+            }
+        }
+
+        public override Vector3 Torque
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override float CollisionScore
+        {
+            get { return 0f; }
+            set { }
+        }
+
+        public override bool Kinematic
+        {
+            get { return false; }
+            set { }
+        }
+
+        public override Quaternion Orientation
+        {
+            get { return Quaternion.Identity; }
+            set {
+                //Matrix3 or = Orientation.ToRotationMatrix();
+                //d.Matrix3 ord = new d.Matrix3(or.m00, or.m10, or.m20, or.m01, or.m11, or.m21, or.m02, or.m12, or.m22);
+                //d.BodySetRotation(Body, ref ord);
+            }
+        }
+
+        public override Vector3 Acceleration
+        {
+            get { return _acceleration; }
+            set { _acceleration = value; }
+        }
+
+        /// <summary>
+        /// Adds the force supplied to the Target Velocity
+        /// The PID controller takes this target velocity and tries to make it a reality
+        /// </summary>
+        /// <param name="force"></param>
+        public override void AddForce(Vector3 force, bool pushforce)
+        {
+            if (force.IsFinite())
+            {
+                if (pushforce)
+                {
+                    m_pidControllerActive = false;
+                    force *= 100f;
+                    m_taintForce += force;
+                    _parent_scene.AddPhysicsActorTaint(this);
+
+                    // If uncommented, things get pushed off world
+                    //
+                    // m_log.Debug("Push!");
+                    // m_taintTargetVelocity.X += force.X;
+                    // m_taintTargetVelocity.Y += force.Y;
+                    // m_taintTargetVelocity.Z += force.Z;
+                }
+                else
+                {
+                    m_pidControllerActive = true;
+                    m_taintTargetVelocity += force;
+                }
+            }
+            else
+            {
+                m_log.WarnFormat("[ODE CHARACTER]: Got a NaN force applied to {0}", Name);
+            }
+            //m_lastUpdateSent = false;
+        }
+
+        public override void AddAngularForce(Vector3 force, bool pushforce)
+        {
+        }
+
+        public override void SetMomentum(Vector3 momentum)
+        {
+        }
+
+        /// <summary>
+        /// Called from Simulate
+        /// This is the avatar's movement control + PID Controller
+        /// </summary>
+        /// <param name="defects">The character will be added to this list if there is something wrong (non-finite
+        /// position or velocity).
+        /// </param>
+        internal void Move(List<OdeCharacter> defects)
+        {
+            //  no lock; for now it's only called from within Simulate()
+            
+            // If the PID Controller isn't active then we set our force
+            // calculating base velocity to the current position
+
+            if (Body == IntPtr.Zero)
+                return;
+
+            if (m_pidControllerActive == false)
+            {
+                _zeroPosition = d.BodyGetPosition(Body);
+            }
+            //PidStatus = true;
+
+            d.Vector3 localpos = d.BodyGetPosition(Body);
+            Vector3 localPos = new Vector3(localpos.X, localpos.Y, localpos.Z);
+            
+            if (!localPos.IsFinite())
+            {
+                m_log.WarnFormat(
+                    "[ODE CHARACTER]: Avatar position of {0} for {1} is non-finite!  Removing from physics scene.",
+                    localPos, Name);
+
+                defects.Add(this);
+
+                return;
+            }
+
+            Vector3 vec = Vector3.Zero;
+            d.Vector3 vel = d.BodyGetLinearVel(Body);
+
+//            m_log.DebugFormat(
+//                "[ODE CHARACTER]: Current velocity in Move() is <{0},{1},{2}>, target {3} for {4}",
+//                vel.X, vel.Y, vel.Z, _target_velocity, Name);
+
+            float movementdivisor = 1f;
+
+            if (!m_alwaysRun)
+            {
+                movementdivisor = walkDivisor;
+            }
+            else
+            {
+                movementdivisor = runDivisor;
+            }
+
+            //  if velocity is zero, use position control; otherwise, velocity control
+            if (_target_velocity.X == 0.0f && _target_velocity.Y == 0.0f && _target_velocity.Z == 0.0f && m_iscolliding)
+            {
+                //  keep track of where we stopped.  No more slippin' & slidin'
+                if (!_zeroFlag)
+                {
+                    _zeroFlag = true;
+                    _zeroPosition = d.BodyGetPosition(Body);
+                }
+
+                if (m_pidControllerActive)
+                {
+                    // We only want to deactivate the PID Controller if we think we want to have our surrogate
+                    // react to the physics scene by moving it's position.
+                    // Avatar to Avatar collisions
+                    // Prim to avatar collisions
+
+                    d.Vector3 pos = d.BodyGetPosition(Body);
+                    vec.X = (_target_velocity.X - vel.X) * (PID_D) + (_zeroPosition.X - pos.X) * (PID_P * 2);
+                    vec.Y = (_target_velocity.Y - vel.Y) * (PID_D) + (_zeroPosition.Y - pos.Y)* (PID_P * 2);
+                    if (flying)
+                    {
+                        vec.Z = (_target_velocity.Z - vel.Z) * (PID_D) + (_zeroPosition.Z - pos.Z) * PID_P;
+                    }
+                }
+                //PidStatus = true;
+            }
+            else
+            {
+                m_pidControllerActive = true;
+                _zeroFlag = false;
+                if (m_iscolliding && !flying)
+                {
+                    // We're standing on something
+                    vec.X = ((_target_velocity.X / movementdivisor) - vel.X) * (PID_D);
+                    vec.Y = ((_target_velocity.Y / movementdivisor) - vel.Y) * (PID_D);
+                }
+                else if (m_iscolliding && flying)
+                {
+                    // We're flying and colliding with something
+                    vec.X = ((_target_velocity.X / movementdivisor) - vel.X) * (PID_D / 16);
+                    vec.Y = ((_target_velocity.Y / movementdivisor) - vel.Y) * (PID_D / 16);
+                }
+                else if (!m_iscolliding && flying)
+                {
+                    // we're in mid air suspended
+                    vec.X = ((_target_velocity.X / movementdivisor) - vel.X) * (PID_D / 6);
+                    vec.Y = ((_target_velocity.Y / movementdivisor) - vel.Y) * (PID_D / 6);
+
+//                    m_log.DebugFormat(
+//                        "[ODE CHARACTER]: !m_iscolliding && flying, vec {0}, _target_velocity {1}, movementdivisor {2}, vel {3}",
+//                        vec, _target_velocity, movementdivisor, vel);
+                }
+
+                if (flying)
+                {
+                    // This also acts as anti-gravity so that we hover when flying rather than fall.
+                    vec.Z = (_target_velocity.Z - vel.Z) * (PID_D);
+                }
+                else
+                {
+                    if (m_iscolliding && _target_velocity.Z > 0.0f)
+                    {
+                        // We're colliding with something and we're not flying but we're moving
+                        // This means we're walking or running.
+                        d.Vector3 pos = d.BodyGetPosition(Body);
+                        vec.Z = (_target_velocity.Z - vel.Z) * PID_D + (_zeroPosition.Z - pos.Z) * PID_P;
+                        vec.X = ((_target_velocity.X - vel.X) / 1.2f) * PID_D;
+                        vec.Y = ((_target_velocity.Y - vel.Y) / 1.2f) * PID_D;
+                    }
+                    else if (!m_iscolliding)
+                    {
+                        // we're not colliding and we're not flying so that means we're falling!
+                        // m_iscolliding includes collisions with the ground.
+                        vec.X = ((_target_velocity.X - vel.X) / 1.2f) * PID_D;
+                        vec.Y = ((_target_velocity.Y - vel.Y) / 1.2f) * PID_D;
+                    }
+                }
+            }
+
+            if (flying)
+            {
+                // Anti-gravity so that we hover when flying rather than fall.
+                vec.Z += ((-1 * _parent_scene.gravityz) * m_mass);
+
+                //Added for auto fly height. Kitto Flora
+                //d.Vector3 pos = d.BodyGetPosition(Body);
+                float target_altitude = _parent_scene.GetTerrainHeightAtXY(_position.X, _position.Y) + MinimumGroundFlightOffset;
+
+                if (_position.Z < target_altitude)
+                {
+                    vec.Z += (target_altitude - _position.Z) * PID_P * 5.0f;
+                }
+                // end add Kitto Flora
+            }
+
+            if (vec.IsFinite())
+            {
+                // Apply the total force acting on this avatar
+                d.BodyAddForce(Body, vec.X, vec.Y, vec.Z);
+
+                if (!_zeroFlag)
+                    AlignAvatarTiltWithCurrentDirectionOfMovement(vec);
+            }
+            else
+            {
+                m_log.WarnFormat(
+                    "[ODE CHARACTER]: Got a NaN force vector {0} in Move() for {1}.  Removing character from physics scene.",
+                    vec, Name);
+
+                defects.Add(this);
+
+                return;
+            }
+
+            d.Vector3 newVel = d.BodyGetLinearVel(Body);
+            if (newVel.X >= 256 || newVel.X <= 256 || newVel.Y >= 256 || newVel.Y <= 256 || newVel.Z >= 256 || newVel.Z <= 256)
+            {
+//                m_log.DebugFormat(
+//                    "[ODE CHARACTER]: Limiting falling velocity from {0} to {1} for {2}", newVel.Z, -9.8, Name);
+
+                newVel.X = Util.Clamp<float>(newVel.X, -255f, 255f);
+                newVel.Y = Util.Clamp<float>(newVel.Y, -255f, 255f);
+
+                if (!flying)
+                    newVel.Z
+                        = Util.Clamp<float>(
+                            newVel.Z, -_parent_scene.AvatarTerminalVelocity, _parent_scene.AvatarTerminalVelocity);
+                else
+                    newVel.Z = Util.Clamp<float>(newVel.Z, -255f, 255f);
+
+                d.BodySetLinearVel(Body, newVel.X, newVel.Y, newVel.Z);
+            }
+        }
+
+        /// <summary>
+        /// Updates the reported position and velocity.  This essentially sends the data up to ScenePresence.
+        /// </summary>
+        /// <param name="defects">The character will be added to this list if there is something wrong (non-finite
+        /// position or velocity).
+        /// </param>
+        internal void UpdatePositionAndVelocity(List<OdeCharacter> defects)
+        {
+            //  no lock; called from Simulate() -- if you call this from elsewhere, gotta lock or do Monitor.Enter/Exit!
+            d.Vector3 newPos;
+            try
+            {
+                newPos = d.BodyGetPosition(Body);
+            }
+            catch (NullReferenceException)
+            {
+                bad = true;
+                defects.Add(this);
+                newPos = new d.Vector3(_position.X, _position.Y, _position.Z);
+                base.RaiseOutOfBounds(_position); // Tells ScenePresence that there's a problem!
+                m_log.WarnFormat("[ODE CHARACTER]: Avatar Null reference for Avatar {0}, physical actor {1}", Name, m_uuid);
+
+                return;
+            }
+
+            //  kluge to keep things in bounds.  ODE lets dead avatars drift away (they should be removed!)
+            if (newPos.X < 0.0f) newPos.X = 0.0f;
+            if (newPos.Y < 0.0f) newPos.Y = 0.0f;
+            if (newPos.X > (int)_parent_scene.WorldExtents.X - 0.05f) newPos.X = (int)_parent_scene.WorldExtents.X - 0.05f;
+            if (newPos.Y > (int)_parent_scene.WorldExtents.Y - 0.05f) newPos.Y = (int)_parent_scene.WorldExtents.Y - 0.05f;
+
+            _position.X = newPos.X;
+            _position.Y = newPos.Y;
+            _position.Z = newPos.Z;
+
+            // I think we need to update the taintPosition too -- Diva 12/24/10
+            m_taintPosition = _position;
+
+            // Did we move last? = zeroflag
+            // This helps keep us from sliding all over
+
+            if (_zeroFlag)
+            {
+                _velocity = Vector3.Zero;
+
+                // Did we send out the 'stopped' message?
+                if (!m_lastUpdateSent)
+                {
+                    m_lastUpdateSent = true;
+                    //base.RequestPhysicsterseUpdate();
+                }
+            }
+            else
+            {
+                m_lastUpdateSent = false;
+                d.Vector3 newVelocity;
+
+                try
+                {
+                    newVelocity = d.BodyGetLinearVel(Body);
+                }
+                catch (NullReferenceException)
+                {
+                    newVelocity.X = _velocity.X;
+                    newVelocity.Y = _velocity.Y;
+                    newVelocity.Z = _velocity.Z;
+                }
+
+                _velocity.X = newVelocity.X;
+                _velocity.Y = newVelocity.Y;
+                _velocity.Z = newVelocity.Z;
+
+                if (_velocity.Z < -6 && !m_hackSentFall)
+                {
+                    m_hackSentFall = true;
+                    m_pidControllerActive = false;
+                }
+                else if (flying && !m_hackSentFly)
+                {
+                    //m_hackSentFly = true;
+                    //base.SendCollisionUpdate(new CollisionEventUpdate());
+                }
+                else
+                {
+                    m_hackSentFly = false;
+                    m_hackSentFall = false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// This creates the Avatar's physical Surrogate in ODE at the position supplied
+        /// </summary>
+        /// <remarks>
+        /// WARNING: This MUST NOT be called outside of ProcessTaints, else we can have unsynchronized access
+        /// to ODE internals. ProcessTaints is called from within thread-locked Simulate(), so it is the only
+        /// place that is safe to call this routine AvatarGeomAndBodyCreation.
+        /// </remarks>
+        /// <param name="npositionX"></param>
+        /// <param name="npositionY"></param>
+        /// <param name="npositionZ"></param>
+        /// <param name="tensor"></param>
+        private void CreateOdeStructures(float npositionX, float npositionY, float npositionZ, float tensor)
+        {
+            if (!(Shell == IntPtr.Zero && Body == IntPtr.Zero && Amotor == IntPtr.Zero))
+            {
+                m_log.ErrorFormat(
+                    "[ODE CHARACTER]: Creating ODE structures for {0} even though some already exist.  Shell = {1}, Body = {2}, Amotor = {3}",
+                    Name, Shell, Body, Amotor);
+            }
+
+            int dAMotorEuler = 1;
+//            _parent_scene.waitForSpaceUnlock(_parent_scene.space);
+            if (CAPSULE_LENGTH <= 0)
+            {
+                m_log.Warn("[ODE CHARACTER]: The capsule size you specified in opensim.ini is invalid!  Setting it to the smallest possible size!");
+                CAPSULE_LENGTH = 0.01f;
+            }
+
+            if (CAPSULE_RADIUS <= 0)
+            {
+                m_log.Warn("[ODE CHARACTER]: The capsule size you specified in opensim.ini is invalid!  Setting it to the smallest possible size!");
+                CAPSULE_RADIUS = 0.01f;
+            }
+
+//          lock (OdeScene.UniversalColliderSyncObject)
+            Shell = d.CreateCapsule(_parent_scene.space, CAPSULE_RADIUS, CAPSULE_LENGTH);
+
+            d.GeomSetCategoryBits(Shell, (int)m_collisionCategories);
+            d.GeomSetCollideBits(Shell, (int)m_collisionFlags);
+
+            d.MassSetCapsuleTotal(out ShellMass, m_mass, 2, CAPSULE_RADIUS, CAPSULE_LENGTH);
+            Body = d.BodyCreate(_parent_scene.world);
+            d.BodySetPosition(Body, npositionX, npositionY, npositionZ);
+
+            _position.X = npositionX;
+            _position.Y = npositionY;
+            _position.Z = npositionZ;
+
+            m_taintPosition = _position;
+
+            d.BodySetMass(Body, ref ShellMass);
+            d.Matrix3 m_caprot;
+            // 90 Stand up on the cap of the capped cyllinder
+            if (_parent_scene.IsAvCapsuleTilted)
+            {
+                d.RFromAxisAndAngle(out m_caprot, 1, 0, 1, (float)(Math.PI / 2));
+            }
+            else
+            {
+                d.RFromAxisAndAngle(out m_caprot, 0, 0, 1, (float)(Math.PI / 2));
+            }
+
+            d.GeomSetRotation(Shell, ref m_caprot);
+            d.BodySetRotation(Body, ref m_caprot);
+
+            d.GeomSetBody(Shell, Body);
+
+            // The purpose of the AMotor here is to keep the avatar's physical
+            // surrogate from rotating while moving
+            Amotor = d.JointCreateAMotor(_parent_scene.world, IntPtr.Zero);
+            d.JointAttach(Amotor, Body, IntPtr.Zero);
+            d.JointSetAMotorMode(Amotor, dAMotorEuler);
+            d.JointSetAMotorNumAxes(Amotor, 3);
+            d.JointSetAMotorAxis(Amotor, 0, 0, 1, 0, 0);
+            d.JointSetAMotorAxis(Amotor, 1, 0, 0, 1, 0);
+            d.JointSetAMotorAxis(Amotor, 2, 0, 0, 0, 1);
+            d.JointSetAMotorAngle(Amotor, 0, 0);
+            d.JointSetAMotorAngle(Amotor, 1, 0);
+            d.JointSetAMotorAngle(Amotor, 2, 0);
+
+            // These lowstops and high stops are effectively (no wiggle room)
+            if (_parent_scene.IsAvCapsuleTilted)
+            {
+                d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, -0.000000000001f);
+                d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, -0.000000000001f);
+                d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, -0.000000000001f);
+                d.JointSetAMotorParam(Amotor, (int)dParam.HiStop, 0.000000000001f);
+                d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 0.000000000001f);
+                d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, 0.000000000001f);
+            }
+            else
+            {
+                #region Documentation of capsule motor LowStop and HighStop parameters
+                // Intentionally introduce some tilt into the capsule by setting
+                // the motor stops to small epsilon values. This small tilt prevents
+                // the capsule from falling into the terrain; a straight-up capsule
+                // (with -0..0 motor stops) falls into the terrain for reasons yet
+                // to be comprehended in their entirety.
+                #endregion
+                AlignAvatarTiltWithCurrentDirectionOfMovement(Vector3.Zero);
+                d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, 0.08f);
+                d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, -0f);
+                d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, 0.08f);
+                d.JointSetAMotorParam(Amotor, (int)dParam.HiStop,  0.08f); // must be same as lowstop, else a different, spurious tilt is introduced
+                d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 0f); // same as lowstop
+                d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, 0.08f); // same as lowstop
+            }
+
+            // Fudge factor is 1f by default, we're setting it to 0.  We don't want it to Fudge or the
+            // capped cyllinder will fall over
+            d.JointSetAMotorParam(Amotor, (int)dParam.FudgeFactor, 0f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.FMax, tensor);
+
+            //d.Matrix3 bodyrotation = d.BodyGetRotation(Body);
+            //d.QfromR(
+            //d.Matrix3 checkrotation = new d.Matrix3(0.7071068,0.5, -0.7071068,
+            //
+            //m_log.Info("[PHYSICSAV]: Rotation: " + bodyrotation.M00 + " : " + bodyrotation.M01 + " : " + bodyrotation.M02 + " : " + bodyrotation.M10 + " : " + bodyrotation.M11 + " : " + bodyrotation.M12 + " : " + bodyrotation.M20 + " : " + bodyrotation.M21 + " : " + bodyrotation.M22);
+            //standupStraight();
+
+            _parent_scene.geom_name_map[Shell] = Name;
+            _parent_scene.actor_name_map[Shell] = this;
+        }
+
+        /// <summary>
+        /// Cleanup the things we use in the scene.
+        /// </summary>
+        internal void Destroy()
+        {
+            m_tainted_isPhysical = false;
+            _parent_scene.AddPhysicsActorTaint(this);
+        }
+
+        /// <summary>
+        /// Used internally to destroy the ODE structures associated with this character.
+        /// </summary>
+        internal void DestroyOdeStructures()
+        {
+            // Create avatar capsule and related ODE data
+            if (Shell == IntPtr.Zero || Body == IntPtr.Zero || Amotor == IntPtr.Zero)
+            {
+                m_log.ErrorFormat(
+                    "[ODE CHARACTER]: Destroying ODE structures for {0} even though some are already null.  Shell = {1}, Body = {2}, Amotor = {3}",
+                    Name, Shell, Body, Amotor);
+            }
+
+            // destroy avatar capsule and related ODE data
+            if (Amotor != IntPtr.Zero)
+            {
+                // Kill the Amotor
+                d.JointDestroy(Amotor);
+                Amotor = IntPtr.Zero;
+            }
+
+            //kill the Geometry
+//            _parent_scene.waitForSpaceUnlock(_parent_scene.space);
+
+            if (Body != IntPtr.Zero)
+            {
+                //kill the body
+                d.BodyDestroy(Body);
+                Body = IntPtr.Zero;
+            }
+
+            if (Shell != IntPtr.Zero)
+            {
+//              lock (OdeScene.UniversalColliderSyncObject)
+                d.GeomDestroy(Shell);
+
+                _parent_scene.geom_name_map.Remove(Shell);
+                _parent_scene.actor_name_map.Remove(Shell);
+
+                Shell = IntPtr.Zero;
+            }
+        }
+
+        public override void CrossingFailure()
+        {
+        }
+
+        public override Vector3 PIDTarget { set { return; } }
+        public override bool PIDActive 
+        { 
+            get { return false; }
+            set { return; } 
+        }
+        public override float PIDTau { set { return; } }
+
+        public override float PIDHoverHeight { set { return; } }
+        public override bool PIDHoverActive { set { return; } }
+        public override PIDHoverType PIDHoverType { set { return; } }
+        public override float PIDHoverTau { set { return; } }
+        
+        public override Quaternion APIDTarget{ set { return; } }
+
+        public override bool APIDActive{ set { return; } }
+
+        public override float APIDStrength{ set { return; } }
+
+        public override float APIDDamping{ set { return; } }
+
+        public override void SubscribeEvents(int ms)
+        {
+            m_requestedUpdateFrequency = ms;
+            m_eventsubscription = ms;
+
+            // Don't clear collision event reporting here.  This is called directly from scene code and so can lead
+            // to a race condition with the simulate loop
+
+            _parent_scene.AddCollisionEventReporting(this);
+        }
+
+        public override void UnSubscribeEvents()
+        {
+            _parent_scene.RemoveCollisionEventReporting(this);
+
+            // Don't clear collision event reporting here.  This is called directly from scene code and so can lead
+            // to a race condition with the simulate loop
+
+            m_requestedUpdateFrequency = 0;
+            m_eventsubscription = 0;
+        }
+
+        internal void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
+        {
+            if (m_eventsubscription > 0)
+            {
+//                m_log.DebugFormat(
+//                    "[PHYSICS]: Adding collision event for {0}, collidedWith {1}, contact {2}", "", CollidedWith, contact);
+
+                CollisionEventsThisFrame.AddCollider(CollidedWith, contact);
+            }
+        }
+
+        internal void SendCollisions()
+        {
+            if (m_eventsubscription > m_requestedUpdateFrequency)
+            {
+                base.SendCollisionUpdate(CollisionEventsThisFrame);
+
+                CollisionEventsThisFrame.Clear();
+                m_eventsubscription = 0;
+            }
+        }
+
+        public override bool SubscribedEvents()
+        {
+            if (m_eventsubscription > 0)
+                return true;
+            return false;
+        }
+
+        internal void ProcessTaints()
+        {
+            if (m_taintPosition != _position)
+            {
+                if (Body != IntPtr.Zero)
+                {
+                    d.BodySetPosition(Body, m_taintPosition.X, m_taintPosition.Y, m_taintPosition.Z);
+                    _position = m_taintPosition;
+                }
+            }
+
+            if (m_taintForce != Vector3.Zero)
+            {
+                if (Body != IntPtr.Zero)
+                {
+                    // FIXME: This is not a good solution since it's subject to a race condition if a force is another
+                    // thread sets a new force while we're in this loop (since it could be obliterated by
+                    // m_taintForce = Vector3.Zero.  Need to lock ProcessTaints() when we set a new tainted force.
+                    d.BodyAddForce(Body, m_taintForce.X, m_taintForce.Y, m_taintForce.Z);
+                }
+
+                m_taintForce = Vector3.Zero;
+            }
+
+            if (m_taintTargetVelocity != _target_velocity)
+                _target_velocity = m_taintTargetVelocity;
+
+            if (m_tainted_isPhysical != m_isPhysical)
+            {
+                if (m_tainted_isPhysical)
+                {
+                    CreateOdeStructures(_position.X, _position.Y, _position.Z, m_tensor);
+                    _parent_scene.AddCharacter(this);
+                }
+                else
+                {
+                    _parent_scene.RemoveCharacter(this);
+                    DestroyOdeStructures();
+                }
+
+                m_isPhysical = m_tainted_isPhysical;
+            }
+
+            if (m_tainted_CAPSULE_LENGTH != CAPSULE_LENGTH)
+            {
+                if (Shell != IntPtr.Zero && Body != IntPtr.Zero && Amotor != IntPtr.Zero)
+                {
+//                    m_log.DebugFormat(
+//                        "[ODE CHARACTER]: Changing capsule size from {0} to {1} for {2}",
+//                        CAPSULE_LENGTH, m_tainted_CAPSULE_LENGTH, Name);
+                    
+                    m_pidControllerActive = true;
+
+                    // no lock needed on _parent_scene.OdeLock because we are called from within the thread lock in OdePlugin's simulate()
+                    DestroyOdeStructures();
+
+                    float prevCapsule = CAPSULE_LENGTH;
+                    CAPSULE_LENGTH = m_tainted_CAPSULE_LENGTH;
+
+                    CreateOdeStructures(
+                        _position.X,
+                        _position.Y,
+                        _position.Z + (Math.Abs(CAPSULE_LENGTH - prevCapsule) * 2), m_tensor);
+
+                    // As with Size, we reset velocity.  However, this isn't strictly necessary since it doesn't
+                    // appear to stall initial region crossings when done here.  Being done for consistency.
+//                    Velocity = Vector3.Zero;
+                }
+                else
+                {
+                    m_log.Warn("[ODE CHARACTER]: trying to change capsule size for " + Name + ", but the following ODE data is missing - "
+                        + (Shell==IntPtr.Zero ? "Shell ":"")
+                        + (Body==IntPtr.Zero ? "Body ":"")
+                        + (Amotor==IntPtr.Zero ? "Amotor ":""));
+                }
+            }
+        }
+
+        internal void AddCollisionFrameTime(int p)
+        {
+            // protect it from overflow crashing
+            if (m_eventsubscription + p >= int.MaxValue)
+                m_eventsubscription = 0;
+            m_eventsubscription += p;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Ode/ODEDynamics.c_comments b/OpenSim/Region/PhysicsModules/Ode/ODEDynamics.c_comments
new file mode 100644
index 0000000..1060aa6
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Ode/ODEDynamics.c_comments
@@ -0,0 +1,630 @@
+/*
+ * Revised August 26 2009 by Kitto Flora. ODEDynamics.cs replaces
+ * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
+ * ODEPrim.cs contains methods dealing with Prim editing, Prim
+ * characteristics and Kinetic motion.
+ * ODEDynamics.cs contains methods dealing with Prim Physical motion
+ * (dynamics) and the associated settings. Old Linear and angular
+ * motors for dynamic motion have been replace with  MoveLinear()
+ * and MoveAngular(); 'Physical' is used only to switch ODE dynamic 
+ * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
+ * switch between 'VEHICLE' parameter use and general dynamics
+ * settings use.
+ * 
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using log4net;
+using OpenMetaverse;
+using Ode.NET;
+using OpenSim.Framework;
+using OpenSim.Region.Physics.Manager;
+
+namespace OpenSim.Region.Physics.OdePlugin
+{
+    public class ODEDynamics
+    {
+        public Vehicle Type
+        {        
+            get { return m_type; }
+        }
+
+        public IntPtr Body
+        {
+            get { return m_body; }
+        }
+
+        private int frcount = 0;                                                                                // Used to limit dynamics debug output to 
+                                                                                                                                        // every 100th frame
+
+        // private OdeScene m_parentScene = null;
+        private IntPtr m_body = IntPtr.Zero;
+        private IntPtr m_jointGroup = IntPtr.Zero;
+        private IntPtr m_aMotor = IntPtr.Zero;
+ 
+
+        // Vehicle properties
+        private Vehicle m_type = Vehicle.TYPE_NONE;                                             // If a 'VEHICLE', and what kind
+        // private Quaternion m_referenceFrame = Quaternion.Identity;   // Axis modifier
+        private VehicleFlag m_flags = (VehicleFlag) 0;                                  // Boolean settings:
+                                                                                                                                                // HOVER_TERRAIN_ONLY
+                                                                                                                                                // HOVER_GLOBAL_HEIGHT
+                                                                                                                                                // NO_DEFLECTION_UP
+                                                                                                                                                // HOVER_WATER_ONLY
+                                                                                                                                                // HOVER_UP_ONLY
+                                                                                                                                                // LIMIT_MOTOR_UP
+                                                                                                                                                // LIMIT_ROLL_ONLY
+        
+        // Linear properties
+        private Vector3 m_linearMotorDirection = Vector3.Zero;                  // velocity requested by LSL, decayed by time
+        private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero;   // velocity requested by LSL
+        private Vector3 m_dir = Vector3.Zero;                                                   // velocity applied to body
+        private Vector3 m_linearFrictionTimescale = Vector3.Zero;
+        private float m_linearMotorDecayTimescale = 0;
+        private float m_linearMotorTimescale = 0;
+        private Vector3 m_lastLinearVelocityVector = Vector3.Zero;
+                // private bool m_LinearMotorSetLastFrame = false;
+        // private Vector3 m_linearMotorOffset = Vector3.Zero;
+        
+        //Angular properties
+        private Vector3 m_angularMotorDirection = Vector3.Zero;
+        private Vector3 m_angularMotorDirectionLASTSET = Vector3.Zero;
+        private Vector3 m_angularFrictionTimescale = Vector3.Zero;
+        private float m_angularMotorDecayTimescale = 0;
+        private float m_angularMotorTimescale = 0;
+        private Vector3 m_lastAngularVelocityVector = Vector3.Zero;
+
+                //Deflection properties        
+        // private float m_angularDeflectionEfficiency = 0;
+        // private float m_angularDeflectionTimescale = 0;
+        // private float m_linearDeflectionEfficiency = 0;
+        // private float m_linearDeflectionTimescale = 0;
+        
+        //Banking properties
+        // private float m_bankingEfficiency = 0;
+        // private float m_bankingMix = 0;
+        // private float m_bankingTimescale = 0;
+        
+        //Hover and Buoyancy properties
+        private float m_VhoverHeight = 0f;
+        private float m_VhoverEfficiency = 0f;
+        private float m_VhoverTimescale = 0f;
+        private float m_VhoverTargetHeight = -1.0f;     // if <0 then no hover, else its the current target height 
+        private float m_VehicleBuoyancy = 0f;                   //KF: m_VehicleBuoyancy is set by VEHICLE_BUOYANCY for a vehicle.
+                                // Modifies gravity. Slider between -1 (double-gravity) and 1 (full anti-gravity) 
+                                // KF: So far I have found no good method to combine a script-requested .Z velocity and gravity.
+                                // Therefore only m_VehicleBuoyancy=1 (0g) will use the script-requested .Z velocity. 
+                                                                                                        
+                //Attractor properties                                                                                                  
+        private float m_verticalAttractionEfficiency = 0;
+        private float m_verticalAttractionTimescale = 0;
+        
+        
+
+
+
+        internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
+        {
+            switch (pParam)
+            {
+                case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_angularDeflectionEfficiency = pValue;
+                    break;
+                case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_angularDeflectionTimescale = pValue;
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_angularMotorDecayTimescale = pValue;
+                    break;
+                case Vehicle.ANGULAR_MOTOR_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_angularMotorTimescale = pValue;
+                    break;
+                case Vehicle.BANKING_EFFICIENCY:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_bankingEfficiency = pValue;
+                    break;
+                case Vehicle.BANKING_MIX:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_bankingMix = pValue;
+                    break;
+                case Vehicle.BANKING_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_bankingTimescale = pValue;
+                    break;
+                case Vehicle.BUOYANCY:
+                        if (pValue < -1f) pValue = -1f;
+                        if (pValue > 1f) pValue = 1f;
+                    m_VehicleBuoyancy = pValue;
+                    break;
+                case Vehicle.HOVER_EFFICIENCY:
+                        if (pValue < 0f) pValue = 0f;
+                        if (pValue > 1f) pValue = 1f;
+                    m_VhoverEfficiency = pValue;
+                    break;
+                case Vehicle.HOVER_HEIGHT:
+                    m_VhoverHeight = pValue;
+                    break;
+                case Vehicle.HOVER_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_VhoverTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_linearDeflectionEfficiency = pValue;
+                    break;
+                case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_linearDeflectionTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_linearMotorDecayTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_MOTOR_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_linearMotorTimescale = pValue;
+                    break;
+                case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
+                    if (pValue < 0.0f) pValue = 0.0f;
+                    if (pValue > 1.0f) pValue = 1.0f;
+                    m_verticalAttractionEfficiency = pValue;
+                    break;
+                case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_verticalAttractionTimescale = pValue;
+                    break;
+                    
+                // These are vector properties but the engine lets you use a single float value to 
+                // set all of the components to the same value
+                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DIRECTION:
+                    m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
+                    m_angularMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    m_linearMotorDirection = new Vector3(pValue, pValue, pValue);
+                    m_linearMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    // m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
+                    break;
+
+            }
+            
+        }//end ProcessFloatVehicleParam
+
+        internal void ProcessVectorVehicleParam(Vehicle pParam, PhysicsVector pValue)
+        {
+            switch (pParam)
+            {
+                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DIRECTION:
+                    m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    m_angularMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    // m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+            }
+            
+        }//end ProcessVectorVehicleParam
+
+        internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
+        {
+            switch (pParam)
+            {
+                case Vehicle.REFERENCE_FRAME:
+                    // m_referenceFrame = pValue;
+                    break;
+            }
+            
+        }//end ProcessRotationVehicleParam
+
+        internal void ProcessTypeChange(Vehicle pType)
+        {
+Console.WriteLine("ProcessTypeChange to " + pType);
+         
+                        // Set Defaults For Type
+            m_type = pType;
+            switch (pType)
+            {
+                case Vehicle.TYPE_SLED:
+                    m_linearFrictionTimescale = new Vector3(30, 1, 1000);
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 1000;
+                    m_linearMotorDecayTimescale = 120;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 1000;
+                    m_angularMotorDecayTimescale = 120;
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 1;
+                    m_VhoverTimescale = 10;
+                    m_VehicleBuoyancy = 0;
+                    // m_linearDeflectionEfficiency = 1;
+                    // m_linearDeflectionTimescale = 1;
+                    // m_angularDeflectionEfficiency = 1;
+                    // m_angularDeflectionTimescale = 1000;
+                    // m_bankingEfficiency = 0;
+                    // m_bankingMix = 1;
+                    // m_bankingTimescale = 10;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_flags &=
+                        ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
+                          VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
+                    break;
+                case Vehicle.TYPE_CAR:
+                    m_linearFrictionTimescale = new Vector3(100, 2, 1000);
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 1;
+                    m_linearMotorDecayTimescale = 60;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 1;
+                    m_angularMotorDecayTimescale = 0.8f;
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 0;
+                    m_VhoverTimescale = 1000;
+                    m_VehicleBuoyancy = 0;
+                    // // m_linearDeflectionEfficiency = 1;
+                    // // m_linearDeflectionTimescale = 2;
+                    // // m_angularDeflectionEfficiency = 0;
+                    // m_angularDeflectionTimescale = 10;
+                    m_verticalAttractionEfficiency = 1;
+                    m_verticalAttractionTimescale = 10;
+                    // m_bankingEfficiency = -0.2f;
+                    // m_bankingMix = 1;
+                    // m_bankingTimescale = 1;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.HOVER_UP_ONLY |
+                                VehicleFlag.LIMIT_MOTOR_UP);
+                    break;
+                case Vehicle.TYPE_BOAT:
+                    m_linearFrictionTimescale = new Vector3(10, 3, 2);
+                    m_angularFrictionTimescale = new Vector3(10,10,10);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 5;
+                    m_linearMotorDecayTimescale = 60;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 4;
+                    m_angularMotorDecayTimescale = 4;
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 0.5f;
+                    m_VhoverTimescale = 2;
+                    m_VehicleBuoyancy = 1;
+                    // m_linearDeflectionEfficiency = 0.5f;
+                    // m_linearDeflectionTimescale = 3;
+                    // m_angularDeflectionEfficiency = 0.5f;
+                    // m_angularDeflectionTimescale = 5;
+                    m_verticalAttractionEfficiency = 0.5f;
+                    m_verticalAttractionTimescale = 5;
+                    // m_bankingEfficiency = -0.3f;
+                    // m_bankingMix = 0.8f;
+                    // m_bankingTimescale = 1;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.LIMIT_ROLL_ONLY | 
+                                VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.HOVER_WATER_ONLY |
+                                VehicleFlag.LIMIT_MOTOR_UP);
+                    break;
+                case Vehicle.TYPE_AIRPLANE:
+                    m_linearFrictionTimescale = new Vector3(200, 10, 5);
+                    m_angularFrictionTimescale = new Vector3(20, 20, 20);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 2;
+                    m_linearMotorDecayTimescale = 60;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 4;
+                    m_angularMotorDecayTimescale = 4;
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 0.5f;
+                    m_VhoverTimescale = 1000;
+                    m_VehicleBuoyancy = 0;
+                    // m_linearDeflectionEfficiency = 0.5f;
+                    // m_linearDeflectionTimescale = 3;
+                    // m_angularDeflectionEfficiency = 1;
+                    // m_angularDeflectionTimescale = 2;
+                    m_verticalAttractionEfficiency = 0.9f;
+                    m_verticalAttractionTimescale = 2;
+                    // m_bankingEfficiency = 1;
+                    // m_bankingMix = 0.7f;
+                    // m_bankingTimescale = 2;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
+                        VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
+                    m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
+                    break;
+                case Vehicle.TYPE_BALLOON:
+                    m_linearFrictionTimescale = new Vector3(5, 5, 5);
+                    m_angularFrictionTimescale = new Vector3(10, 10, 10);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 5;
+                    m_linearMotorDecayTimescale = 60;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 6;
+                    m_angularMotorDecayTimescale = 10;
+                    m_VhoverHeight = 5;
+                    m_VhoverEfficiency = 0.8f;
+                    m_VhoverTimescale = 10;
+                    m_VehicleBuoyancy = 1;
+                    // m_linearDeflectionEfficiency = 0;
+                    // m_linearDeflectionTimescale = 5;
+                    // m_angularDeflectionEfficiency = 0;
+                    // m_angularDeflectionTimescale = 5;
+                    m_verticalAttractionEfficiency = 1;
+                    m_verticalAttractionTimescale = 1000;
+                    // m_bankingEfficiency = 0;
+                    // m_bankingMix = 0.7f;
+                    // m_bankingTimescale = 5;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
+                        VehicleFlag.HOVER_UP_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
+                    m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    break;
+
+            }
+        }//end SetDefaultsForType
+
+        internal void Enable(IntPtr pBody, OdeScene pParentScene)
+        {
+//Console.WriteLine("Enable  m_type=" + m_type + "   m_VehicleBuoyancy=" + m_VehicleBuoyancy);
+            if (m_type == Vehicle.TYPE_NONE)
+                return;
+
+            m_body = pBody;
+            //KF: This  used to set up the linear and angular joints
+        }
+
+        internal void Step(float pTimestep,  OdeScene pParentScene)
+        {
+            if (m_body == IntPtr.Zero || m_type == Vehicle.TYPE_NONE)
+                return;
+            frcount++;                                  // used to limit debug comment output
+            if (frcount > 100)
+                frcount = 0;
+
+                        MoveLinear(pTimestep, pParentScene);
+            MoveAngular(pTimestep);
+        }// end Step
+
+        private void MoveLinear(float pTimestep, OdeScene _pParentScene)
+        {
+            if (!m_linearMotorDirection.ApproxEquals(Vector3.Zero, 0.01f))              // requested m_linearMotorDirection is significant
+            {
+                 if(!d.BodyIsEnabled (Body))  d.BodyEnable (Body);
+
+                // add drive to body
+                Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale/pTimestep);
+                m_lastLinearVelocityVector += (addAmount*10);                                   // lastLinearVelocityVector is the current body velocity vector?
+        
+                // This will work temporarily, but we really need to compare speed on an axis
+                // KF: Limit body velocity to applied velocity?
+                if (Math.Abs(m_lastLinearVelocityVector.X) > Math.Abs(m_linearMotorDirectionLASTSET.X))
+                    m_lastLinearVelocityVector.X = m_linearMotorDirectionLASTSET.X;
+                if (Math.Abs(m_lastLinearVelocityVector.Y) > Math.Abs(m_linearMotorDirectionLASTSET.Y))
+                    m_lastLinearVelocityVector.Y = m_linearMotorDirectionLASTSET.Y;
+                if (Math.Abs(m_lastLinearVelocityVector.Z) > Math.Abs(m_linearMotorDirectionLASTSET.Z))
+                    m_lastLinearVelocityVector.Z = m_linearMotorDirectionLASTSET.Z;
+                
+                // decay applied velocity
+                Vector3 decayfraction = ((Vector3.One/(m_linearMotorDecayTimescale/pTimestep)));
+                //Console.WriteLine("decay: " + decayfraction);
+                m_linearMotorDirection -= m_linearMotorDirection * decayfraction;
+                //Console.WriteLine("actual: " + m_linearMotorDirection);
+            }
+            else
+            {           // requested is not significant
+                                        // if what remains of applied is small, zero it.
+                                if (m_lastLinearVelocityVector.ApproxEquals(Vector3.Zero, 0.01f))
+                                        m_lastLinearVelocityVector = Vector3.Zero;
+                        }
+                                    
+                        
+                        // convert requested object velocity to world-referenced vector
+            m_dir = m_lastLinearVelocityVector;
+            d.Quaternion rot = d.BodyGetQuaternion(Body);
+                Quaternion rotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W);   // rotq = rotation of object
+                m_dir *= rotq;                                                  // apply obj rotation to velocity vector
+
+                        // add Gravity andBuoyancy
+                        // KF: So far I have found no good method to combine a script-requested
+                        // .Z velocity and gravity. Therefore only 0g will used script-requested
+                        // .Z velocity. >0g (m_VehicleBuoyancy < 1) will used modified gravity only.
+            Vector3 grav = Vector3.Zero;
+                        if(m_VehicleBuoyancy < 1.0f)
+                        {
+                                // There is some gravity, make a gravity force vector
+                                // that is applied after object velocity.     
+                    d.Mass objMass;
+                    d.BodyGetMass(Body, out objMass);
+                    // m_VehicleBuoyancy: -1=2g; 0=1g; 1=0g; 
+                    grav.Z = _pParentScene.gravityz * objMass.mass * (1f - m_VehicleBuoyancy);
+                    // Preserve the current Z velocity
+                                d.Vector3 vel_now = d.BodyGetLinearVel(Body);
+                    m_dir.Z = vel_now.Z;                // Preserve the accumulated falling velocity
+                } // else its 1.0, no gravity.
+                
+                // Check if hovering
+                if( (m_flags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0)
+                {       
+                        // We should hover, get the target height
+                        d.Vector3 pos = d.BodyGetPosition(Body);
+                        if((m_flags & VehicleFlag.HOVER_WATER_ONLY) == VehicleFlag.HOVER_WATER_ONLY)
+                        {
+                                m_VhoverTargetHeight = _pParentScene.GetWaterLevel() + m_VhoverHeight;
+                        }
+                        else if((m_flags & VehicleFlag.HOVER_TERRAIN_ONLY) == VehicleFlag.HOVER_TERRAIN_ONLY)
+                        {
+                                m_VhoverTargetHeight = _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y) + m_VhoverHeight;
+                        }
+                        else if((m_flags & VehicleFlag.HOVER_GLOBAL_HEIGHT) == VehicleFlag.HOVER_GLOBAL_HEIGHT)
+                        {
+                                m_VhoverTargetHeight = m_VhoverHeight;
+                        }
+                        
+                                if((m_flags & VehicleFlag.HOVER_UP_ONLY) == VehicleFlag.HOVER_UP_ONLY)
+                                {
+                                        // If body is aready heigher, use its height as target height
+                                        if(pos.Z > m_VhoverTargetHeight) m_VhoverTargetHeight = pos.Z;
+                                }
+                                
+//                  m_VhoverEfficiency = 0f;    // 0=boucy, 1=Crit.damped
+//                              m_VhoverTimescale = 0f;         // time to acheive height
+//                              pTimestep  is time since last frame,in secs 
+                                float herr0 = pos.Z - m_VhoverTargetHeight;
+//if(frcount == 0) Console.WriteLine("herr0=" + herr0);                 
+                                // Replace Vertical speed with correction figure if significant
+                                if(Math.Abs(herr0) > 0.01f )
+                                {
+                            d.Mass objMass;
+                            d.BodyGetMass(Body, out objMass);
+                                        m_dir.Z = - ( (herr0 * pTimestep * 50.0f) / m_VhoverTimescale);
+                                        // m_VhoverEfficiency is not yet implemented
+                                }
+                                else
+                                {
+                                        m_dir.Z = 0f;
+                                }
+                        }
+                        
+                // Apply velocity
+                d.BodySetLinearVel(Body, m_dir.X, m_dir.Y, m_dir.Z);        
+//if(frcount == 0) Console.WriteLine("Move  " + Body + ":"+ m_dir.X + " " + m_dir.Y + " " + m_dir.Z);
+            // apply gravity force
+                        d.BodyAddForce(Body, grav.X, grav.Y, grav.Z);           
+//if(frcount == 0) Console.WriteLine("Force " + Body + ":" + grav.X + " " + grav.Y + " " + grav.Z);     
+
+
+                        // apply friction
+            Vector3 decayamount = Vector3.One / (m_linearFrictionTimescale / pTimestep);
+            m_lastLinearVelocityVector -= m_lastLinearVelocityVector * decayamount;
+        } // end MoveLinear()
+        
+        private void MoveAngular(float pTimestep)
+        {
+        
+                // m_angularMotorDirection                      is the latest value from the script, and is decayed here
+                // m_angularMotorDirectionLASTSET               is the latest value from the script
+                // m_lastAngularVelocityVector                  is what is being applied to the Body, varied up and down here
+                
+            if (!m_angularMotorDirection.ApproxEquals(Vector3.Zero, 0.01f))
+            {
+                                if(!d.BodyIsEnabled (Body))  d.BodyEnable (Body);
+                                // ramp up to new value
+                Vector3 addAmount = m_angularMotorDirection / (m_angularMotorTimescale / pTimestep);
+                m_lastAngularVelocityVector += (addAmount * 10f);
+//if(frcount == 0) Console.WriteLine("add: " + addAmount);
+
+                                // limit applied value to what was set by script
+                // This will work temporarily, but we really need to compare speed on an axis
+                if (Math.Abs(m_lastAngularVelocityVector.X) > Math.Abs(m_angularMotorDirectionLASTSET.X))
+                    m_lastAngularVelocityVector.X = m_angularMotorDirectionLASTSET.X;
+                if (Math.Abs(m_lastAngularVelocityVector.Y) > Math.Abs(m_angularMotorDirectionLASTSET.Y))
+                    m_lastAngularVelocityVector.Y = m_angularMotorDirectionLASTSET.Y;
+                if (Math.Abs(m_lastAngularVelocityVector.Z) > Math.Abs(m_angularMotorDirectionLASTSET.Z))
+                    m_lastAngularVelocityVector.Z = m_angularMotorDirectionLASTSET.Z;
+
+                                // decay the requested value
+                Vector3 decayfraction = ((Vector3.One / (m_angularMotorDecayTimescale / pTimestep)));
+                //Console.WriteLine("decay: " + decayfraction);
+                m_angularMotorDirection -= m_angularMotorDirection * decayfraction;
+                //Console.WriteLine("actual: " + m_linearMotorDirection);
+            }
+            // KF: m_lastAngularVelocityVector is rotational speed in rad/sec ?
+            
+            // Vertical attractor section
+            
+//            d.Mass objMass;
+//            d.BodyGetMass(Body, out objMass);
+//            float servo = 100f * objMass.mass * m_verticalAttractionEfficiency / (m_verticalAttractionTimescale * pTimestep);
+            float servo = 0.1f * m_verticalAttractionEfficiency / (m_verticalAttractionTimescale * pTimestep);
+            // get present body rotation
+            d.Quaternion rot = d.BodyGetQuaternion(Body);
+            Quaternion rotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W);
+            // make a vector pointing up
+                        Vector3 verterr = Vector3.Zero;
+                        verterr.Z = 1.0f;
+                        // rotate it to Body Angle
+                        verterr = verterr * rotq;
+                        // verterr.X and .Y are the World error ammounts. They are 0 when there is no error (Vehicle Body is 'vertical'), and .Z will be 1.
+                        // As the body leans to its side |.X| will increase to 1 and .Z fall to 0. As body inverts |.X| will fall and .Z will go
+                        // negative. Similar for tilt and |.Y|. .X and .Y must be modulated to prevent a stable inverted body.
+                        if (verterr.Z < 0.0f)
+                        {
+                                verterr.X = 2.0f - verterr.X;
+                                verterr.Y = 2.0f - verterr.Y;
+                        }
+                        // Error is 0 (no error) to +/- 2 (max error)
+                        // scale it by servo
+                        verterr = verterr * servo;
+                        
+                        // rotate to object frame
+        //              verterr = verterr * rotq;
+                        
+                        // As the body rotates around the X axis, then verterr.Y increases; Rotated around Y then .X increases, so 
+                        // Change  Body angular velocity  X based on Y, and Y based on X. Z is not changed.
+                        m_lastAngularVelocityVector.X += verterr.Y;
+                        m_lastAngularVelocityVector.Y -= verterr.X;
+/*
+if(frcount == 0) 
+        {
+//                      Console.WriteLine("AngleMotor " + m_lastAngularVelocityVector);
+                        Console.WriteLine(String.Format("VA Body:{0} servo:{1} err:<{2},{3},{4}>  VAE:{5}", 
+                                        Body, servo, verterr.X, verterr.Y, verterr.Z, m_verticalAttractionEfficiency)); 
+        }
+        */
+                        d.BodySetAngularVel (Body, m_lastAngularVelocityVector.X, m_lastAngularVelocityVector.Y, m_lastAngularVelocityVector.Z);
+                        // apply friction
+            Vector3 decayamount = Vector3.One / (m_angularFrictionTimescale / pTimestep);
+            m_lastAngularVelocityVector -= m_lastAngularVelocityVector * decayamount;
+
+        } //end MoveAngular
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Ode/ODEDynamics.cs b/OpenSim/Region/PhysicsModules/Ode/ODEDynamics.cs
new file mode 100644
index 0000000..8f8e2bd
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Ode/ODEDynamics.cs
@@ -0,0 +1,974 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* Revised Aug, Sept 2009 by Kitto Flora. ODEDynamics.cs replaces
+ * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
+ * ODEPrim.cs contains methods dealing with Prim editing, Prim
+ * characteristics and Kinetic motion.
+ * ODEDynamics.cs contains methods dealing with Prim Physical motion
+ * (dynamics) and the associated settings. Old Linear and angular
+ * motors for dynamic motion have been replace with  MoveLinear()
+ * and MoveAngular(); 'Physical' is used only to switch ODE dynamic
+ * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
+ * switch between 'VEHICLE' parameter use and general dynamics
+ * settings use.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using log4net;
+using OpenMetaverse;
+using Ode.NET;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+namespace OpenSim.Region.PhysicsModule.ODE
+{
+    public class ODEDynamics
+    {
+        public Vehicle Type
+        {
+            get { return m_type; }
+        }
+
+        public IntPtr Body
+        {
+            get { return m_body; }
+        }
+
+        private int frcount = 0;                                        // Used to limit dynamics debug output to
+                                                                        // every 100th frame
+
+        // private OdeScene m_parentScene = null;
+        private IntPtr m_body = IntPtr.Zero;
+//        private IntPtr m_jointGroup = IntPtr.Zero;
+//        private IntPtr m_aMotor = IntPtr.Zero;
+
+
+        // Vehicle properties
+        private Vehicle m_type = Vehicle.TYPE_NONE;                     // If a 'VEHICLE', and what kind
+        // private Quaternion m_referenceFrame = Quaternion.Identity;   // Axis modifier
+        private VehicleFlag m_flags = (VehicleFlag) 0;                  // Boolean settings:
+                                                                        // HOVER_TERRAIN_ONLY
+                                                                        // HOVER_GLOBAL_HEIGHT
+                                                                        // NO_DEFLECTION_UP
+                                                                        // HOVER_WATER_ONLY
+                                                                        // HOVER_UP_ONLY
+                                                                        // LIMIT_MOTOR_UP
+                                                                        // LIMIT_ROLL_ONLY
+        private VehicleFlag m_Hoverflags = (VehicleFlag)0;
+        private Vector3 m_BlockingEndPoint = Vector3.Zero;
+        private Quaternion m_RollreferenceFrame = Quaternion.Identity;
+        // Linear properties
+        private Vector3 m_linearMotorDirection = Vector3.Zero;          // velocity requested by LSL, decayed by time
+        private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero;   // velocity requested by LSL
+        private Vector3 m_dir = Vector3.Zero;                           // velocity applied to body
+        private Vector3 m_linearFrictionTimescale = Vector3.Zero;
+        private float m_linearMotorDecayTimescale = 0;
+        private float m_linearMotorTimescale = 0;
+        private Vector3 m_lastLinearVelocityVector = Vector3.Zero;
+        private d.Vector3 m_lastPositionVector = new d.Vector3();
+        // private bool m_LinearMotorSetLastFrame = false;
+        // private Vector3 m_linearMotorOffset = Vector3.Zero;
+
+        //Angular properties
+        private Vector3 m_angularMotorDirection = Vector3.Zero;         // angular velocity requested by LSL motor
+        private int m_angularMotorApply = 0;                            // application frame counter
+        private Vector3 m_angularMotorVelocity = Vector3.Zero;          // current angular motor velocity
+        private float m_angularMotorTimescale = 0;                      // motor angular velocity ramp up rate
+        private float m_angularMotorDecayTimescale = 0;                 // motor angular velocity decay rate
+        private Vector3 m_angularFrictionTimescale = Vector3.Zero;      // body angular velocity  decay rate
+        private Vector3 m_lastAngularVelocity = Vector3.Zero;           // what was last applied to body
+ //       private Vector3 m_lastVertAttractor = Vector3.Zero;             // what VA was last applied to body
+
+        //Deflection properties
+        // private float m_angularDeflectionEfficiency = 0;
+        // private float m_angularDeflectionTimescale = 0;
+        // private float m_linearDeflectionEfficiency = 0;
+        // private float m_linearDeflectionTimescale = 0;
+
+        //Banking properties
+        // private float m_bankingEfficiency = 0;
+        // private float m_bankingMix = 0;
+        // private float m_bankingTimescale = 0;
+
+        //Hover and Buoyancy properties
+        private float m_VhoverHeight = 0f;
+//        private float m_VhoverEfficiency = 0f;
+        private float m_VhoverTimescale = 0f;
+        private float m_VhoverTargetHeight = -1.0f;     // if <0 then no hover, else its the current target height
+        private float m_VehicleBuoyancy = 0f;           //KF: m_VehicleBuoyancy is set by VEHICLE_BUOYANCY for a vehicle.
+                    // Modifies gravity. Slider between -1 (double-gravity) and 1 (full anti-gravity)
+                    // KF: So far I have found no good method to combine a script-requested .Z velocity and gravity.
+                    // Therefore only m_VehicleBuoyancy=1 (0g) will use the script-requested .Z velocity.
+
+        //Attractor properties
+        private float m_verticalAttractionEfficiency = 1.0f;        // damped
+        private float m_verticalAttractionTimescale = 500f;         // Timescale > 300  means no vert attractor.
+
+        internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
+        {
+            switch (pParam)
+            {
+                case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_angularDeflectionEfficiency = pValue;
+                    break;
+                case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_angularDeflectionTimescale = pValue;
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_angularMotorDecayTimescale = pValue;
+                    break;
+                case Vehicle.ANGULAR_MOTOR_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_angularMotorTimescale = pValue;
+                    break;
+                case Vehicle.BANKING_EFFICIENCY:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_bankingEfficiency = pValue;
+                    break;
+                case Vehicle.BANKING_MIX:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_bankingMix = pValue;
+                    break;
+                case Vehicle.BANKING_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_bankingTimescale = pValue;
+                    break;
+                case Vehicle.BUOYANCY:
+                    if (pValue < -1f) pValue = -1f;
+                    if (pValue > 1f) pValue = 1f;
+                    m_VehicleBuoyancy = pValue;
+                    break;
+//                case Vehicle.HOVER_EFFICIENCY:
+//                    if (pValue < 0f) pValue = 0f;
+//                    if (pValue > 1f) pValue = 1f;
+//                    m_VhoverEfficiency = pValue;
+//                    break;
+                case Vehicle.HOVER_HEIGHT:
+                    m_VhoverHeight = pValue;
+                    break;
+                case Vehicle.HOVER_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_VhoverTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_linearDeflectionEfficiency = pValue;
+                    break;
+                case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_linearDeflectionTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_linearMotorDecayTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_MOTOR_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_linearMotorTimescale = pValue;
+                    break;
+                case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
+                    if (pValue < 0.1f) pValue = 0.1f;    // Less goes unstable
+                    if (pValue > 1.0f) pValue = 1.0f;
+                    m_verticalAttractionEfficiency = pValue;
+                    break;
+                case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_verticalAttractionTimescale = pValue;
+                    break;
+
+                // These are vector properties but the engine lets you use a single float value to
+                // set all of the components to the same value
+                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DIRECTION:
+                    m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
+                    m_angularMotorApply = 10;
+                    break;
+                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    m_linearMotorDirection = new Vector3(pValue, pValue, pValue);
+                    m_linearMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    // m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
+                    break;
+
+            }
+        }//end ProcessFloatVehicleParam
+
+        internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
+        {
+            switch (pParam)
+            {
+                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DIRECTION:
+                    m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    // Limit requested angular speed to 2 rps= 4 pi rads/sec
+                    if (m_angularMotorDirection.X > 12.56f) m_angularMotorDirection.X = 12.56f;
+                    if (m_angularMotorDirection.X < - 12.56f) m_angularMotorDirection.X = - 12.56f;
+                    if (m_angularMotorDirection.Y > 12.56f) m_angularMotorDirection.Y = 12.56f;
+                    if (m_angularMotorDirection.Y < - 12.56f) m_angularMotorDirection.Y = - 12.56f;
+                    if (m_angularMotorDirection.Z > 12.56f) m_angularMotorDirection.Z = 12.56f;
+                    if (m_angularMotorDirection.Z < - 12.56f) m_angularMotorDirection.Z = - 12.56f;
+                    m_angularMotorApply = 10;
+                    break;
+                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    // m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.BLOCK_EXIT:
+                    m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+            }
+        }//end ProcessVectorVehicleParam
+
+        internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
+        {
+            switch (pParam)
+            {
+                case Vehicle.REFERENCE_FRAME:
+                    // m_referenceFrame = pValue;
+                    break;
+                case Vehicle.ROLL_FRAME:
+                    m_RollreferenceFrame = pValue;
+                    break;
+            }
+        }//end ProcessRotationVehicleParam
+
+        internal void ProcessVehicleFlags(int pParam, bool remove)
+        {
+            if (remove)
+            {
+                if (pParam == -1)
+                {
+                    m_flags = (VehicleFlag)0;
+                    m_Hoverflags = (VehicleFlag)0;
+                    return;
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_GLOBAL_HEIGHT) == (int)VehicleFlag.HOVER_GLOBAL_HEIGHT)
+                {
+                    if ((m_Hoverflags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != (VehicleFlag)0)
+                        m_Hoverflags &= ~(VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_TERRAIN_ONLY) == (int)VehicleFlag.HOVER_TERRAIN_ONLY)
+                {
+                    if ((m_Hoverflags & VehicleFlag.HOVER_TERRAIN_ONLY) != (VehicleFlag)0)
+                        m_Hoverflags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_UP_ONLY) == (int)VehicleFlag.HOVER_UP_ONLY)
+                {
+                    if ((m_Hoverflags & VehicleFlag.HOVER_UP_ONLY) != (VehicleFlag)0)
+                        m_Hoverflags &= ~(VehicleFlag.HOVER_UP_ONLY);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_WATER_ONLY) == (int)VehicleFlag.HOVER_WATER_ONLY)
+                {
+                    if ((m_Hoverflags & VehicleFlag.HOVER_WATER_ONLY) != (VehicleFlag)0)
+                        m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY);
+                }
+                if ((pParam & (int)VehicleFlag.LIMIT_MOTOR_UP) == (int)VehicleFlag.LIMIT_MOTOR_UP)
+                {
+                    if ((m_flags & VehicleFlag.LIMIT_MOTOR_UP) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.LIMIT_MOTOR_UP);
+                }
+                if ((pParam & (int)VehicleFlag.LIMIT_ROLL_ONLY) == (int)VehicleFlag.LIMIT_ROLL_ONLY)
+                {
+                    if ((m_flags & VehicleFlag.LIMIT_ROLL_ONLY) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.LIMIT_ROLL_ONLY);
+                }
+                if ((pParam & (int)VehicleFlag.MOUSELOOK_BANK) == (int)VehicleFlag.MOUSELOOK_BANK)
+                {
+                    if ((m_flags & VehicleFlag.MOUSELOOK_BANK) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.MOUSELOOK_BANK);
+                }
+                if ((pParam & (int)VehicleFlag.MOUSELOOK_STEER) == (int)VehicleFlag.MOUSELOOK_STEER)
+                {
+                    if ((m_flags & VehicleFlag.MOUSELOOK_STEER) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.MOUSELOOK_STEER);
+                }
+                if ((pParam & (int)VehicleFlag.NO_DEFLECTION_UP) == (int)VehicleFlag.NO_DEFLECTION_UP)
+                {
+                    if ((m_flags & VehicleFlag.NO_DEFLECTION_UP) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP);
+                }
+                if ((pParam & (int)VehicleFlag.CAMERA_DECOUPLED) == (int)VehicleFlag.CAMERA_DECOUPLED)
+                {
+                    if ((m_flags & VehicleFlag.CAMERA_DECOUPLED) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.CAMERA_DECOUPLED);
+                }
+                if ((pParam & (int)VehicleFlag.NO_X) == (int)VehicleFlag.NO_X)
+                {
+                    if ((m_flags & VehicleFlag.NO_X) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.NO_X);
+                }
+                if ((pParam & (int)VehicleFlag.NO_Y) == (int)VehicleFlag.NO_Y)
+                {
+                    if ((m_flags & VehicleFlag.NO_Y) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.NO_Y);
+                }
+                if ((pParam & (int)VehicleFlag.NO_Z) == (int)VehicleFlag.NO_Z)
+                {
+                    if ((m_flags & VehicleFlag.NO_Z) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.NO_Z);
+                }
+                if ((pParam & (int)VehicleFlag.LOCK_HOVER_HEIGHT) == (int)VehicleFlag.LOCK_HOVER_HEIGHT)
+                {
+                    if ((m_Hoverflags & VehicleFlag.LOCK_HOVER_HEIGHT) != (VehicleFlag)0)
+                        m_Hoverflags &= ~(VehicleFlag.LOCK_HOVER_HEIGHT);
+                }
+                if ((pParam & (int)VehicleFlag.NO_DEFLECTION) == (int)VehicleFlag.NO_DEFLECTION)
+                {
+                    if ((m_flags & VehicleFlag.NO_DEFLECTION) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.NO_DEFLECTION);
+                }
+                if ((pParam & (int)VehicleFlag.LOCK_ROTATION) == (int)VehicleFlag.LOCK_ROTATION)
+                {
+                    if ((m_flags & VehicleFlag.LOCK_ROTATION) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.LOCK_ROTATION);
+                }
+            }
+            else
+            {
+                if ((pParam & (int)VehicleFlag.HOVER_GLOBAL_HEIGHT) == (int)VehicleFlag.HOVER_GLOBAL_HEIGHT)
+                {
+                    m_Hoverflags |= (VehicleFlag.HOVER_GLOBAL_HEIGHT | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_TERRAIN_ONLY) == (int)VehicleFlag.HOVER_TERRAIN_ONLY)
+                {
+                    m_Hoverflags |= (VehicleFlag.HOVER_TERRAIN_ONLY | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_UP_ONLY) == (int)VehicleFlag.HOVER_UP_ONLY)
+                {
+                    m_Hoverflags |= (VehicleFlag.HOVER_UP_ONLY | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_WATER_ONLY) == (int)VehicleFlag.HOVER_WATER_ONLY)
+                {
+                    m_Hoverflags |= (VehicleFlag.HOVER_WATER_ONLY | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.LIMIT_MOTOR_UP) == (int)VehicleFlag.LIMIT_MOTOR_UP)
+                {
+                    m_flags |= (VehicleFlag.LIMIT_MOTOR_UP | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.MOUSELOOK_BANK) == (int)VehicleFlag.MOUSELOOK_BANK)
+                {
+                    m_flags |= (VehicleFlag.MOUSELOOK_BANK | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.MOUSELOOK_STEER) == (int)VehicleFlag.MOUSELOOK_STEER)
+                {
+                    m_flags |= (VehicleFlag.MOUSELOOK_STEER | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.NO_DEFLECTION_UP) == (int)VehicleFlag.NO_DEFLECTION_UP)
+                {
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.CAMERA_DECOUPLED) == (int)VehicleFlag.CAMERA_DECOUPLED)
+                {
+                    m_flags |= (VehicleFlag.CAMERA_DECOUPLED | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.NO_X) == (int)VehicleFlag.NO_X)
+                {
+                    m_flags |= (VehicleFlag.NO_X);
+                }
+                if ((pParam & (int)VehicleFlag.NO_Y) == (int)VehicleFlag.NO_Y)
+                {
+                    m_flags |= (VehicleFlag.NO_Y);
+                }
+                if ((pParam & (int)VehicleFlag.NO_Z) == (int)VehicleFlag.NO_Z)
+                {
+                    m_flags |= (VehicleFlag.NO_Z);
+                }
+                if ((pParam & (int)VehicleFlag.LOCK_HOVER_HEIGHT) == (int)VehicleFlag.LOCK_HOVER_HEIGHT)
+                {
+                    m_Hoverflags |= (VehicleFlag.LOCK_HOVER_HEIGHT);
+                }
+                if ((pParam & (int)VehicleFlag.NO_DEFLECTION) == (int)VehicleFlag.NO_DEFLECTION)
+                {
+                    m_flags |= (VehicleFlag.NO_DEFLECTION);
+                }
+                if ((pParam & (int)VehicleFlag.LOCK_ROTATION) == (int)VehicleFlag.LOCK_ROTATION)
+                {
+                    m_flags |= (VehicleFlag.LOCK_ROTATION);
+                }
+            }
+        }//end ProcessVehicleFlags
+
+        internal void ProcessTypeChange(Vehicle pType)
+        {
+            // Set Defaults For Type
+            m_type = pType;
+            switch (pType)
+            {
+                    case Vehicle.TYPE_NONE:
+                    m_linearFrictionTimescale = new Vector3(0, 0, 0);
+                    m_angularFrictionTimescale = new Vector3(0, 0, 0);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 0;
+                    m_linearMotorDecayTimescale = 0;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 0;
+                    m_angularMotorDecayTimescale = 0;
+                    m_VhoverHeight = 0;
+                    m_VhoverTimescale = 0;
+                    m_VehicleBuoyancy = 0;
+                    m_flags = (VehicleFlag)0;
+                    break;
+
+                case Vehicle.TYPE_SLED:
+                    m_linearFrictionTimescale = new Vector3(30, 1, 1000);
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 1000;
+                    m_linearMotorDecayTimescale = 120;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 1000;
+                    m_angularMotorDecayTimescale = 120;
+                    m_VhoverHeight = 0;
+//                    m_VhoverEfficiency = 1;
+                    m_VhoverTimescale = 10;
+                    m_VehicleBuoyancy = 0;
+                    // m_linearDeflectionEfficiency = 1;
+                    // m_linearDeflectionTimescale = 1;
+                    // m_angularDeflectionEfficiency = 1;
+                    // m_angularDeflectionTimescale = 1000;
+                    // m_bankingEfficiency = 0;
+                    // m_bankingMix = 1;
+                    // m_bankingTimescale = 10;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_Hoverflags &=
+                         ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
+                           VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
+                    break;
+                case Vehicle.TYPE_CAR:
+                    m_linearFrictionTimescale = new Vector3(100, 2, 1000);
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 1;
+                    m_linearMotorDecayTimescale = 60;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 1;
+                    m_angularMotorDecayTimescale = 0.8f;
+                    m_VhoverHeight = 0;
+//                    m_VhoverEfficiency = 0;
+                    m_VhoverTimescale = 1000;
+                    m_VehicleBuoyancy = 0;
+                    // // m_linearDeflectionEfficiency = 1;
+                    // // m_linearDeflectionTimescale = 2;
+                    // // m_angularDeflectionEfficiency = 0;
+                    // m_angularDeflectionTimescale = 10;
+                    m_verticalAttractionEfficiency = 1f;
+                    m_verticalAttractionTimescale = 10f;
+                    // m_bankingEfficiency = -0.2f;
+                    // m_bankingMix = 1;
+                    // m_bankingTimescale = 1;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY |
+                                VehicleFlag.LIMIT_MOTOR_UP);
+                    m_Hoverflags |= (VehicleFlag.HOVER_UP_ONLY);
+                    break;
+                case Vehicle.TYPE_BOAT:
+                    m_linearFrictionTimescale = new Vector3(10, 3, 2);
+                    m_angularFrictionTimescale = new Vector3(10,10,10);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 5;
+                    m_linearMotorDecayTimescale = 60;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 4;
+                    m_angularMotorDecayTimescale = 4;
+                    m_VhoverHeight = 0;
+//                    m_VhoverEfficiency = 0.5f;
+                    m_VhoverTimescale = 2;
+                    m_VehicleBuoyancy = 1;
+                    // m_linearDeflectionEfficiency = 0.5f;
+                    // m_linearDeflectionTimescale = 3;
+                    // m_angularDeflectionEfficiency = 0.5f;
+                    // m_angularDeflectionTimescale = 5;
+                    m_verticalAttractionEfficiency = 0.5f;
+                    m_verticalAttractionTimescale = 5f;
+                    // m_bankingEfficiency = -0.3f;
+                    // m_bankingMix = 0.8f;
+                    // m_bankingTimescale = 1;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_Hoverflags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY |
+                            VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags &= ~(VehicleFlag.LIMIT_ROLL_ONLY);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP |
+                                VehicleFlag.LIMIT_MOTOR_UP);
+                    m_Hoverflags |= (VehicleFlag.HOVER_WATER_ONLY);
+                    break;
+                case Vehicle.TYPE_AIRPLANE:
+                    m_linearFrictionTimescale = new Vector3(200, 10, 5);
+                    m_angularFrictionTimescale = new Vector3(20, 20, 20);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 2;
+                    m_linearMotorDecayTimescale = 60;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 4;
+                    m_angularMotorDecayTimescale = 4;
+                    m_VhoverHeight = 0;
+//                    m_VhoverEfficiency = 0.5f;
+                    m_VhoverTimescale = 1000;
+                    m_VehicleBuoyancy = 0;
+                    // m_linearDeflectionEfficiency = 0.5f;
+                    // m_linearDeflectionTimescale = 3;
+                    // m_angularDeflectionEfficiency = 1;
+                    // m_angularDeflectionTimescale = 2;
+                    m_verticalAttractionEfficiency = 0.9f;
+                    m_verticalAttractionTimescale = 2f;
+                    // m_bankingEfficiency = 1;
+                    // m_bankingMix = 0.7f;
+                    // m_bankingTimescale = 2;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
+                        VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_MOTOR_UP);
+                    m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
+                    break;
+                case Vehicle.TYPE_BALLOON:
+                    m_linearFrictionTimescale = new Vector3(5, 5, 5);
+                    m_angularFrictionTimescale = new Vector3(10, 10, 10);
+                    m_linearMotorDirection = Vector3.Zero;
+                    m_linearMotorTimescale = 5;
+                    m_linearMotorDecayTimescale = 60;
+                    m_angularMotorDirection = Vector3.Zero;
+                    m_angularMotorTimescale = 6;
+                    m_angularMotorDecayTimescale = 10;
+                    m_VhoverHeight = 5;
+//                    m_VhoverEfficiency = 0.8f;
+                    m_VhoverTimescale = 10;
+                    m_VehicleBuoyancy = 1;
+                    // m_linearDeflectionEfficiency = 0;
+                    // m_linearDeflectionTimescale = 5;
+                    // m_angularDeflectionEfficiency = 0;
+                    // m_angularDeflectionTimescale = 5;
+                    m_verticalAttractionEfficiency = 1f;
+                    m_verticalAttractionTimescale = 100f;
+                    // m_bankingEfficiency = 0;
+                    // m_bankingMix = 0.7f;
+                    // m_bankingTimescale = 5;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
+                        VehicleFlag.HOVER_UP_ONLY);
+                    m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_MOTOR_UP);
+                    m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
+                    m_Hoverflags |= (VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    break;
+
+            }
+        }//end SetDefaultsForType
+
+        internal void Enable(IntPtr pBody, OdeScene pParentScene)
+        {
+            if (m_type == Vehicle.TYPE_NONE)
+                return;
+
+            m_body = pBody;
+        }
+
+        internal void Step(float pTimestep,  OdeScene pParentScene)
+        {
+            if (m_body == IntPtr.Zero || m_type == Vehicle.TYPE_NONE)
+                return;
+            frcount++;  // used to limit debug comment output
+            if (frcount > 100)
+                frcount = 0;
+
+            MoveLinear(pTimestep, pParentScene);
+            MoveAngular(pTimestep);
+            LimitRotation(pTimestep);
+        }// end Step
+
+        private void MoveLinear(float pTimestep, OdeScene _pParentScene)
+        {
+            if (!m_linearMotorDirection.ApproxEquals(Vector3.Zero, 0.01f))  // requested m_linearMotorDirection is significant
+            {
+                 if (!d.BodyIsEnabled(Body))
+                     d.BodyEnable(Body);
+
+                // add drive to body
+                Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale/pTimestep);
+                m_lastLinearVelocityVector += (addAmount*10);  // lastLinearVelocityVector is the current body velocity vector?
+
+                // This will work temporarily, but we really need to compare speed on an axis
+                // KF: Limit body velocity to applied velocity?
+                if (Math.Abs(m_lastLinearVelocityVector.X) > Math.Abs(m_linearMotorDirectionLASTSET.X))
+                    m_lastLinearVelocityVector.X = m_linearMotorDirectionLASTSET.X;
+                if (Math.Abs(m_lastLinearVelocityVector.Y) > Math.Abs(m_linearMotorDirectionLASTSET.Y))
+                    m_lastLinearVelocityVector.Y = m_linearMotorDirectionLASTSET.Y;
+                if (Math.Abs(m_lastLinearVelocityVector.Z) > Math.Abs(m_linearMotorDirectionLASTSET.Z))
+                    m_lastLinearVelocityVector.Z = m_linearMotorDirectionLASTSET.Z;
+
+                // decay applied velocity
+                Vector3 decayfraction = ((Vector3.One/(m_linearMotorDecayTimescale/pTimestep)));
+                //Console.WriteLine("decay: " + decayfraction);
+                m_linearMotorDirection -= m_linearMotorDirection * decayfraction * 0.5f;
+                //Console.WriteLine("actual: " + m_linearMotorDirection);
+            }
+            else
+            {        // requested is not significant
+                    // if what remains of applied is small, zero it.
+                if (m_lastLinearVelocityVector.ApproxEquals(Vector3.Zero, 0.01f))
+                    m_lastLinearVelocityVector = Vector3.Zero;
+            }
+
+            // convert requested object velocity to world-referenced vector
+            m_dir = m_lastLinearVelocityVector;
+            d.Quaternion rot = d.BodyGetQuaternion(Body);
+            Quaternion rotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W);    // rotq = rotation of object
+            m_dir *= rotq;                            // apply obj rotation to velocity vector
+
+            // add Gravity andBuoyancy
+            // KF: So far I have found no good method to combine a script-requested
+            // .Z velocity and gravity. Therefore only 0g will used script-requested
+            // .Z velocity. >0g (m_VehicleBuoyancy < 1) will used modified gravity only.
+            Vector3 grav = Vector3.Zero;
+            // There is some gravity, make a gravity force vector
+            // that is applied after object velocity.
+            d.Mass objMass;
+            d.BodyGetMass(Body, out objMass);
+            // m_VehicleBuoyancy: -1=2g; 0=1g; 1=0g;
+            grav.Z = _pParentScene.gravityz * objMass.mass * (1f - m_VehicleBuoyancy);
+            // Preserve the current Z velocity
+            d.Vector3 vel_now = d.BodyGetLinearVel(Body);
+            m_dir.Z = vel_now.Z;        // Preserve the accumulated falling velocity
+
+            d.Vector3 pos = d.BodyGetPosition(Body);
+//            Vector3 accel = new Vector3(-(m_dir.X - m_lastLinearVelocityVector.X / 0.1f), -(m_dir.Y - m_lastLinearVelocityVector.Y / 0.1f), m_dir.Z - m_lastLinearVelocityVector.Z / 0.1f);
+            Vector3 posChange = new Vector3();
+            posChange.X = pos.X - m_lastPositionVector.X;
+            posChange.Y = pos.Y - m_lastPositionVector.Y;
+            posChange.Z = pos.Z - m_lastPositionVector.Z;
+            double Zchange = Math.Abs(posChange.Z);
+            if (m_BlockingEndPoint != Vector3.Zero)
+            {
+                if (pos.X >= (m_BlockingEndPoint.X - (float)1))
+                {
+                    pos.X -= posChange.X + 1;
+                    d.BodySetPosition(Body, pos.X, pos.Y, pos.Z);
+                }
+                if (pos.Y >= (m_BlockingEndPoint.Y - (float)1))
+                {
+                    pos.Y -= posChange.Y + 1;
+                    d.BodySetPosition(Body, pos.X, pos.Y, pos.Z);
+                }
+                if (pos.Z >= (m_BlockingEndPoint.Z - (float)1))
+                {
+                    pos.Z -= posChange.Z + 1;
+                    d.BodySetPosition(Body, pos.X, pos.Y, pos.Z);
+                }
+                if (pos.X <= 0)
+                {
+                    pos.X += posChange.X + 1;
+                    d.BodySetPosition(Body, pos.X, pos.Y, pos.Z);
+                }
+                if (pos.Y <= 0)
+                {
+                    pos.Y += posChange.Y + 1;
+                    d.BodySetPosition(Body, pos.X, pos.Y, pos.Z);
+                }
+            }
+            if (pos.Z < _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y))
+            {
+                pos.Z = _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y) + 2;
+                d.BodySetPosition(Body, pos.X, pos.Y, pos.Z);
+            }
+
+            // Check if hovering
+            if ((m_Hoverflags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0)
+            {
+                // We should hover, get the target height
+                if ((m_Hoverflags & VehicleFlag.HOVER_WATER_ONLY) != 0)
+                {
+                    m_VhoverTargetHeight = _pParentScene.GetWaterLevel() + m_VhoverHeight;
+                }
+                if ((m_Hoverflags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0)
+                {
+                    m_VhoverTargetHeight = _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y) + m_VhoverHeight;
+                }
+                if ((m_Hoverflags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != 0)
+                {
+                    m_VhoverTargetHeight = m_VhoverHeight;
+                }
+
+                if ((m_Hoverflags & VehicleFlag.HOVER_UP_ONLY) != 0)
+                {
+                    // If body is aready heigher, use its height as target height
+                    if (pos.Z > m_VhoverTargetHeight) m_VhoverTargetHeight = pos.Z;
+                }
+                if ((m_Hoverflags & VehicleFlag.LOCK_HOVER_HEIGHT) != 0)
+                {
+                    if ((pos.Z - m_VhoverTargetHeight) > .2 || (pos.Z - m_VhoverTargetHeight) < -.2)
+                    {
+                        d.BodySetPosition(Body, pos.X, pos.Y, m_VhoverTargetHeight);
+                    }
+                }
+                else
+                {
+                    float herr0 = pos.Z - m_VhoverTargetHeight;
+                    // Replace Vertical speed with correction figure if significant
+                    if (Math.Abs(herr0) > 0.01f)
+                    {
+                        m_dir.Z = -((herr0 * pTimestep * 50.0f) / m_VhoverTimescale);
+                        //KF: m_VhoverEfficiency is not yet implemented
+                    }
+                    else
+                    {
+                        m_dir.Z = 0f;
+                    }
+                }
+
+//                m_VhoverEfficiency = 0f;    // 0=boucy, 1=Crit.damped
+//                m_VhoverTimescale = 0f;        // time to acheive height
+//                pTimestep  is time since last frame,in secs
+            }
+
+            if ((m_flags & (VehicleFlag.LIMIT_MOTOR_UP)) != 0)
+            {
+                //Start Experimental Values
+                if (Zchange > .3)
+                {
+                    grav.Z = (float)(grav.Z * 3);
+                }
+                if (Zchange > .15)
+                {
+                    grav.Z = (float)(grav.Z * 2);
+                }
+                if (Zchange > .75)
+                {
+                    grav.Z = (float)(grav.Z * 1.5);
+                }
+                if (Zchange > .05)
+                {
+                    grav.Z = (float)(grav.Z * 1.25);
+                }
+                if (Zchange > .025)
+                {
+                    grav.Z = (float)(grav.Z * 1.125);
+                }
+                float terraintemp = _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y);
+                float postemp = (pos.Z - terraintemp);
+                if (postemp > 2.5f)
+                {
+                    grav.Z = (float)(grav.Z * 1.037125);
+                }
+                //End Experimental Values
+            }
+            if ((m_flags & (VehicleFlag.NO_X)) != 0)
+            {
+                m_dir.X = 0;
+            }
+            if ((m_flags & (VehicleFlag.NO_Y)) != 0)
+            {
+                m_dir.Y = 0;
+            }
+            if ((m_flags & (VehicleFlag.NO_Z)) != 0)
+            {
+                m_dir.Z = 0;
+            }
+
+            m_lastPositionVector = d.BodyGetPosition(Body);
+
+            // Apply velocity
+            d.BodySetLinearVel(Body, m_dir.X, m_dir.Y, m_dir.Z);
+            // apply gravity force
+            d.BodyAddForce(Body, grav.X, grav.Y, grav.Z);
+
+
+            // apply friction
+            Vector3 decayamount = Vector3.One / (m_linearFrictionTimescale / pTimestep);
+            m_lastLinearVelocityVector -= m_lastLinearVelocityVector * decayamount;
+        } // end MoveLinear()
+
+        private void MoveAngular(float pTimestep)
+        {
+            /*
+            private Vector3 m_angularMotorDirection = Vector3.Zero;            // angular velocity requested by LSL motor
+            private int m_angularMotorApply = 0;                            // application frame counter
+             private float m_angularMotorVelocity = 0;                        // current angular motor velocity (ramps up and down)
+            private float m_angularMotorTimescale = 0;                        // motor angular velocity ramp up rate
+            private float m_angularMotorDecayTimescale = 0;                    // motor angular velocity decay rate
+            private Vector3 m_angularFrictionTimescale = Vector3.Zero;        // body angular velocity  decay rate
+            private Vector3 m_lastAngularVelocity = Vector3.Zero;            // what was last applied to body
+            */
+
+            // Get what the body is doing, this includes 'external' influences
+            d.Vector3 angularVelocity = d.BodyGetAngularVel(Body);
+   //         Vector3 angularVelocity = Vector3.Zero;
+
+            if (m_angularMotorApply > 0)
+            {
+                // ramp up to new value
+                //   current velocity  +=                         error                       /    (time to get there / step interval)
+                //                               requested speed            -  last motor speed
+                m_angularMotorVelocity.X += (m_angularMotorDirection.X - m_angularMotorVelocity.X) /  (m_angularMotorTimescale / pTimestep);
+                m_angularMotorVelocity.Y += (m_angularMotorDirection.Y - m_angularMotorVelocity.Y) /  (m_angularMotorTimescale / pTimestep);
+                m_angularMotorVelocity.Z += (m_angularMotorDirection.Z - m_angularMotorVelocity.Z) /  (m_angularMotorTimescale / pTimestep);
+
+                m_angularMotorApply--;        // This is done so that if script request rate is less than phys frame rate the expected
+                                            // velocity may still be acheived.
+            }
+            else
+            {
+                // no motor recently applied, keep the body velocity
+        /*        m_angularMotorVelocity.X = angularVelocity.X;
+                m_angularMotorVelocity.Y = angularVelocity.Y;
+                m_angularMotorVelocity.Z = angularVelocity.Z; */
+
+                // and decay the velocity
+                m_angularMotorVelocity -= m_angularMotorVelocity /  (m_angularMotorDecayTimescale / pTimestep);
+            } // end motor section
+
+            // Vertical attractor section
+            Vector3 vertattr = Vector3.Zero;
+
+            if (m_verticalAttractionTimescale < 300)
+            {
+                float VAservo = 0.2f / (m_verticalAttractionTimescale * pTimestep);
+                // get present body rotation
+                d.Quaternion rot = d.BodyGetQuaternion(Body);
+                Quaternion rotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W);
+                // make a vector pointing up
+                Vector3 verterr = Vector3.Zero;
+                verterr.Z = 1.0f;
+                // rotate it to Body Angle
+                verterr = verterr * rotq;
+                // verterr.X and .Y are the World error ammounts. They are 0 when there is no error (Vehicle Body is 'vertical'), and .Z will be 1.
+                // As the body leans to its side |.X| will increase to 1 and .Z fall to 0. As body inverts |.X| will fall and .Z will go
+                // negative. Similar for tilt and |.Y|. .X and .Y must be modulated to prevent a stable inverted body.
+                if (verterr.Z < 0.0f)
+                {
+                    verterr.X = 2.0f - verterr.X;
+                    verterr.Y = 2.0f - verterr.Y;
+                }
+                // Error is 0 (no error) to +/- 2 (max error)
+                // scale it by VAservo
+                verterr = verterr * VAservo;
+//if (frcount == 0) Console.WriteLine("VAerr=" + verterr);
+
+                // As the body rotates around the X axis, then verterr.Y increases; Rotated around Y then .X increases, so
+                // Change  Body angular velocity  X based on Y, and Y based on X. Z is not changed.
+                vertattr.X =    verterr.Y;
+                vertattr.Y =  - verterr.X;
+                vertattr.Z = 0f;
+
+                // scaling appears better usingsquare-law
+                float bounce = 1.0f - (m_verticalAttractionEfficiency * m_verticalAttractionEfficiency);
+                vertattr.X += bounce * angularVelocity.X;
+                vertattr.Y += bounce * angularVelocity.Y;
+
+            } // else vertical attractor is off
+
+    //        m_lastVertAttractor = vertattr;
+
+            // Bank section tba
+            // Deflection section tba
+
+            // Sum velocities
+            m_lastAngularVelocity = m_angularMotorVelocity + vertattr; // + bank + deflection
+            
+            if ((m_flags & (VehicleFlag.NO_DEFLECTION_UP)) != 0)
+            {
+                m_lastAngularVelocity.X = 0;
+                m_lastAngularVelocity.Y = 0;
+            }
+
+            if (!m_lastAngularVelocity.ApproxEquals(Vector3.Zero, 0.01f))
+            {
+                if (!d.BodyIsEnabled (Body))  d.BodyEnable (Body);
+            }
+            else
+            {
+                m_lastAngularVelocity = Vector3.Zero; // Reduce small value to zero.
+            }
+
+             // apply friction
+            Vector3 decayamount = Vector3.One / (m_angularFrictionTimescale / pTimestep);
+            m_lastAngularVelocity -= m_lastAngularVelocity * decayamount;
+
+            // Apply to the body
+            d.BodySetAngularVel (Body, m_lastAngularVelocity.X, m_lastAngularVelocity.Y, m_lastAngularVelocity.Z);
+
+        } //end MoveAngular
+        internal void LimitRotation(float timestep)
+        {
+            d.Quaternion rot = d.BodyGetQuaternion(Body);
+            Quaternion rotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W);    // rotq = rotation of object
+            d.Quaternion m_rot = new d.Quaternion();
+            bool changed = false;
+            m_rot.X = rotq.X;
+            m_rot.Y = rotq.Y;
+            m_rot.Z = rotq.Z;
+            m_rot.W = rotq.W;
+            if (m_RollreferenceFrame != Quaternion.Identity)
+            {
+                if (rotq.X >= m_RollreferenceFrame.X)
+                {
+                    m_rot.X = rotq.X - (m_RollreferenceFrame.X / 2);
+                }
+                if (rotq.Y >= m_RollreferenceFrame.Y)
+                {
+                    m_rot.Y = rotq.Y - (m_RollreferenceFrame.Y / 2);
+                }
+                if (rotq.X <= -m_RollreferenceFrame.X)
+                {
+                    m_rot.X = rotq.X + (m_RollreferenceFrame.X / 2);
+                }
+                if (rotq.Y <= -m_RollreferenceFrame.Y)
+                {
+                    m_rot.Y = rotq.Y + (m_RollreferenceFrame.Y / 2);
+                }
+                changed = true;
+            }
+            if ((m_flags & VehicleFlag.LOCK_ROTATION) != 0)
+            {
+                m_rot.X = 0;
+                m_rot.Y = 0;
+                changed = true;
+            }
+            if (changed)
+                d.BodySetQuaternion(Body, ref m_rot);
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs b/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs
new file mode 100644
index 0000000..54a2033
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs
@@ -0,0 +1,3435 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Revised August 26 2009 by Kitto Flora. ODEDynamics.cs replaces
+ * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
+ * ODEPrim.cs contains methods dealing with Prim editing, Prim
+ * characteristics and Kinetic motion.
+ * ODEDynamics.cs contains methods dealing with Prim Physical motion
+ * (dynamics) and the associated settings. Old Linear and angular
+ * motors for dynamic motion have been replace with  MoveLinear()
+ * and MoveAngular(); 'Physical' is used only to switch ODE dynamic 
+ * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
+ * switch between 'VEHICLE' parameter use and general dynamics
+ * settings use.
+ */
+
+//#define SPAM
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Threading;
+using log4net;
+using OpenMetaverse;
+using Ode.NET;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+namespace OpenSim.Region.PhysicsModule.ODE
+{
+    /// <summary>
+    /// Various properties that ODE uses for AMotors but isn't exposed in ODE.NET so we must define them ourselves.
+    /// </summary>
+    public class OdePrim : PhysicsActor
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private bool m_isphysical;
+
+        public int ExpectedCollisionContacts { get { return m_expectedCollisionContacts; } }
+        private int m_expectedCollisionContacts = 0;
+
+        /// <summary>
+        /// Gets collide bits so that we can still perform land collisions if a mesh fails to load.
+        /// </summary>
+        private int BadMeshAssetCollideBits
+        {
+            get { return m_isphysical ? (int)CollisionCategories.Land : 0; }
+        }
+
+        /// <summary>
+        /// Is this prim subject to physics?  Even if not, it's still solid for collision purposes.
+        /// </summary>
+        public override bool IsPhysical
+        {
+            get { return m_isphysical; }
+            set
+            {
+                m_isphysical = value;
+                if (!m_isphysical) // Zero the remembered last velocity
+                    m_lastVelocity = Vector3.Zero;
+            }
+        }
+
+        private Vector3 _position;
+        private Vector3 _velocity;
+        private Vector3 _torque;
+        private Vector3 m_lastVelocity;
+        private Vector3 m_lastposition;
+        private Quaternion m_lastorientation = new Quaternion();
+        private Vector3 m_rotationalVelocity;
+        private Vector3 _size;
+        private Vector3 _acceleration;
+        // private d.Vector3 _zeroPosition = new d.Vector3(0.0f, 0.0f, 0.0f);
+        private Quaternion _orientation;
+        private Vector3 m_taintposition;
+        private Vector3 m_taintsize;
+        private Vector3 m_taintVelocity;
+        private Vector3 m_taintTorque;
+        private Quaternion m_taintrot;
+        private Vector3 m_angularlock = Vector3.One;
+        private Vector3 m_taintAngularLock = Vector3.One;
+        private IntPtr Amotor = IntPtr.Zero;
+
+        private bool m_assetFailed = false;
+
+        private Vector3 m_PIDTarget;
+        private float m_PIDTau;
+        private float PID_D = 35f;
+        private float PID_G = 25f;
+
+        // KF: These next 7 params apply to llSetHoverHeight(float height, integer water, float tau),
+        // and are for non-VEHICLES only.
+
+        private float m_PIDHoverHeight;
+        private float m_PIDHoverTau;
+        private bool m_useHoverPID;
+        private PIDHoverType m_PIDHoverType = PIDHoverType.Ground;
+        private float m_targetHoverHeight;
+        private float m_groundHeight;
+        private float m_waterHeight;
+        private float m_buoyancy;                //KF: m_buoyancy should be set by llSetBuoyancy() for non-vehicle. 
+
+        // private float m_tensor = 5f;
+        private int body_autodisable_frames = 20;
+
+
+        private const CollisionCategories m_default_collisionFlags = (CollisionCategories.Geom
+                                                        | CollisionCategories.Space
+                                                        | CollisionCategories.Body
+                                                        | CollisionCategories.Character
+                                                        );
+        private bool m_taintshape;
+        private bool m_taintPhysics;
+        private bool m_collidesLand = true;
+        private bool m_collidesWater;
+
+        // Default we're a Geometry
+        private CollisionCategories m_collisionCategories = (CollisionCategories.Geom);
+
+        // Default, Collide with Other Geometries, spaces and Bodies
+        private CollisionCategories m_collisionFlags = m_default_collisionFlags;
+
+        public bool m_taintremove { get; private set; }
+        public bool m_taintdisable { get; private set; }
+        internal bool m_disabled;
+        public bool m_taintadd { get; private set; }
+        public bool m_taintselected { get; private set; }
+        public bool m_taintCollidesWater { get; private set; }
+
+        private bool m_taintforce = false;
+        private bool m_taintaddangularforce = false;
+        private Vector3 m_force;
+        private List<Vector3> m_forcelist = new List<Vector3>();
+        private List<Vector3> m_angularforcelist = new List<Vector3>();
+
+        private PrimitiveBaseShape _pbs;
+        private OdeScene _parent_scene;
+        
+        /// <summary>
+        /// The physics space which contains prim geometries
+        /// </summary>
+        public IntPtr m_targetSpace = IntPtr.Zero;
+
+        /// <summary>
+        /// The prim geometry, used for collision detection.
+        /// </summary>
+        /// <remarks>
+        /// This is never null except for a brief period when the geometry needs to be replaced (due to resizing or
+        /// mesh change) or when the physical prim is being removed from the scene.
+        /// </remarks>
+        public IntPtr prim_geom { get; private set; }
+
+        public IntPtr _triMeshData { get; private set; }
+
+        private IntPtr _linkJointGroup = IntPtr.Zero;
+        private PhysicsActor _parent;
+        private PhysicsActor m_taintparent;
+
+        private List<OdePrim> childrenPrim = new List<OdePrim>();
+
+        private bool iscolliding;
+        private bool m_isSelected;
+
+        internal bool m_isVolumeDetect; // If true, this prim only detects collisions but doesn't collide actively
+
+        private bool m_throttleUpdates;
+        private int throttleCounter;
+        public int m_interpenetrationcount { get; private set; }
+        internal float m_collisionscore;
+        public int m_roundsUnderMotionThreshold { get; private set; }
+        private int m_crossingfailures;
+
+        public bool outofBounds { get; private set; }
+        private float m_density = 10.000006836f; // Aluminum g/cm3;
+
+        public bool _zeroFlag { get; private set; }
+        private bool m_lastUpdateSent;
+
+        public IntPtr Body = IntPtr.Zero;
+        private Vector3 _target_velocity;
+        private d.Mass pMass;
+
+        private int m_eventsubscription;
+        private CollisionEventUpdate CollisionEventsThisFrame = new CollisionEventUpdate();
+
+        /// <summary>
+        /// Signal whether there were collisions on the previous frame, so we know if we need to send the
+        /// empty CollisionEventsThisFrame to the prim so that it can detect the end of a collision.
+        /// </summary>
+        /// <remarks>
+        /// This is probably a temporary measure, pending storing this information consistently in CollisionEventUpdate itself.
+        /// </remarks>
+        private bool m_collisionsOnPreviousFrame;
+
+        private IntPtr m_linkJoint = IntPtr.Zero;
+
+        internal volatile bool childPrim;
+
+        private ODEDynamics m_vehicle;
+
+        internal int m_material = (int)Material.Wood;
+
+        public OdePrim(
+            String primName, OdeScene parent_scene, Vector3 pos, Vector3 size,
+            Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
+        {
+            Name = primName;
+            m_vehicle = new ODEDynamics();
+            //gc = GCHandle.Alloc(prim_geom, GCHandleType.Pinned);
+
+            if (!pos.IsFinite())
+            {
+                pos = new Vector3(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f),
+                    parent_scene.GetTerrainHeightAtXY(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f)) + 0.5f);
+                m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Position for {0}", Name);
+            }
+            _position = pos;
+            m_taintposition = pos;
+            PID_D = parent_scene.bodyPIDD;
+            PID_G = parent_scene.bodyPIDG;
+            m_density = parent_scene.geomDefaultDensity;
+            // m_tensor = parent_scene.bodyMotorJointMaxforceTensor;
+            body_autodisable_frames = parent_scene.bodyFramesAutoDisable;
+
+            prim_geom = IntPtr.Zero;
+
+            if (!pos.IsFinite())
+            {
+                size = new Vector3(0.5f, 0.5f, 0.5f);
+                m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Size for {0}", Name);
+            }
+
+            if (size.X <= 0) size.X = 0.01f;
+            if (size.Y <= 0) size.Y = 0.01f;
+            if (size.Z <= 0) size.Z = 0.01f;
+
+            _size = size;
+            m_taintsize = _size;
+
+            if (!QuaternionIsFinite(rotation))
+            {
+                rotation = Quaternion.Identity;
+                m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Rotation for {0}", Name);
+            }
+
+            _orientation = rotation;
+            m_taintrot = _orientation;
+            _pbs = pbs;
+
+            _parent_scene = parent_scene;
+            m_targetSpace = (IntPtr)0;
+
+            if (pos.Z < 0)
+            {
+                IsPhysical = false;
+            }
+            else
+            {
+                IsPhysical = pisPhysical;
+                // If we're physical, we need to be in the master space for now.
+                // linksets *should* be in a space together..  but are not currently
+                if (IsPhysical)
+                    m_targetSpace = _parent_scene.space;
+            }
+
+            m_taintadd = true;
+            m_assetFailed = false;
+            _parent_scene.AddPhysicsActorTaint(this);
+        }
+
+        public override int PhysicsActorType
+        {
+            get { return (int) ActorTypes.Prim; }
+            set { return; }
+        }
+
+        public override bool SetAlwaysRun
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Grabbed
+        {
+            set { return; }
+        }
+
+        public override bool Selected
+        {
+            set
+            {
+                // This only makes the object not collidable if the object
+                // is physical or the object is modified somehow *IN THE FUTURE*
+                // without this, if an avatar selects prim, they can walk right
+                // through it while it's selected
+                m_collisionscore = 0;
+
+                if ((IsPhysical && !_zeroFlag) || !value)
+                {
+                    m_taintselected = value;
+                    _parent_scene.AddPhysicsActorTaint(this);
+                }
+                else
+                {
+                    m_taintselected = value;
+                    m_isSelected = value;
+                }
+
+                if (m_isSelected)
+                    disableBodySoft();
+            }
+        }
+
+        /// <summary>
+        /// Set a new geometry for this prim.
+        /// </summary>
+        /// <param name="geom"></param>
+        private void SetGeom(IntPtr geom)
+        {
+            prim_geom = geom;
+//Console.WriteLine("SetGeom to " + prim_geom + " for " + Name);
+
+            if (m_assetFailed)
+            {
+                d.GeomSetCategoryBits(prim_geom, 0);
+                d.GeomSetCollideBits(prim_geom, BadMeshAssetCollideBits);
+            }
+            else
+            {
+                d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
+                d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
+            }
+
+            _parent_scene.geom_name_map[prim_geom] = Name;
+            _parent_scene.actor_name_map[prim_geom] = this;
+
+            if (childPrim)
+            {
+                if (_parent != null && _parent is OdePrim)
+                {
+                    OdePrim parent = (OdePrim)_parent;
+//Console.WriteLine("SetGeom calls ChildSetGeom");
+                    parent.ChildSetGeom(this);
+                }
+            }
+            //m_log.Warn("Setting Geom to: " + prim_geom);
+        }
+
+        private void enableBodySoft()
+        {
+            if (!childPrim)
+            {
+                if (IsPhysical && Body != IntPtr.Zero)
+                {
+                    d.BodyEnable(Body);
+                    if (m_vehicle.Type != Vehicle.TYPE_NONE)
+                        m_vehicle.Enable(Body, _parent_scene);
+                }
+
+                m_disabled = false;
+            }
+        }
+
+        private void disableBodySoft()
+        {
+            m_disabled = true;
+
+            if (IsPhysical && Body != IntPtr.Zero)
+            {
+                d.BodyDisable(Body);
+            }
+        }
+
+        /// <summary>
+        /// Make a prim subject to physics.
+        /// </summary>
+        private void enableBody()
+        {
+            // Don't enable this body if we're a child prim
+            // this should be taken care of in the parent function not here
+            if (!childPrim)
+            {
+                // Sets the geom to a body
+                Body = d.BodyCreate(_parent_scene.world);
+
+                setMass();
+                d.BodySetPosition(Body, _position.X, _position.Y, _position.Z);
+                d.Quaternion myrot = new d.Quaternion();
+                myrot.X = _orientation.X;
+                myrot.Y = _orientation.Y;
+                myrot.Z = _orientation.Z;
+                myrot.W = _orientation.W;
+                d.BodySetQuaternion(Body, ref myrot);
+                d.GeomSetBody(prim_geom, Body);
+
+                if (m_assetFailed)
+                {
+                    d.GeomSetCategoryBits(prim_geom, 0);
+                    d.GeomSetCollideBits(prim_geom, BadMeshAssetCollideBits);
+                }
+                else
+                {
+                    m_collisionCategories |= CollisionCategories.Body;
+                    m_collisionFlags |= (CollisionCategories.Land | CollisionCategories.Wind);
+                }
+
+                d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
+                d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
+
+                d.BodySetAutoDisableFlag(Body, true);
+                d.BodySetAutoDisableSteps(Body, body_autodisable_frames);
+                
+                // disconnect from world gravity so we can apply buoyancy
+                d.BodySetGravityMode (Body, false);
+
+                m_interpenetrationcount = 0;
+                m_collisionscore = 0;
+                m_disabled = false;
+
+                // The body doesn't already have a finite rotation mode set here
+                if ((!m_angularlock.ApproxEquals(Vector3.Zero, 0.0f)) && _parent == null)
+                {
+                    createAMotor(m_angularlock);
+                }
+                if (m_vehicle.Type != Vehicle.TYPE_NONE)
+                {
+                    m_vehicle.Enable(Body, _parent_scene);
+                }
+
+                _parent_scene.ActivatePrim(this);
+            }
+        }
+
+        #region Mass Calculation
+
+        private float CalculateMass()
+        {
+            float volume = _size.X * _size.Y * _size.Z; // default
+            float tmp;
+
+            float returnMass = 0;
+            float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f;
+            float hollowVolume = hollowAmount * hollowAmount; 
+            
+            switch (_pbs.ProfileShape)
+            {
+                case ProfileShape.Square:
+                    // default box
+
+                    if (_pbs.PathCurve == (byte)Extrusion.Straight)
+                        {
+                        if (hollowAmount > 0.0)
+                            {
+                            switch (_pbs.HollowShape)
+                                {
+                                case HollowShape.Square:
+                                case HollowShape.Same:
+                                    break;
+
+                                case HollowShape.Circle:
+
+                                    hollowVolume *= 0.78539816339f;
+                                    break;
+
+                                case HollowShape.Triangle:
+
+                                    hollowVolume *= (0.5f * .5f);
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                                }
+                            volume *= (1.0f - hollowVolume);
+                            }
+                        }
+
+                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                        {
+                        //a tube 
+
+                        volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX);
+                        tmp= 1.0f -2.0e-2f * (float)(200 - _pbs.PathScaleY);
+                        volume -= volume*tmp*tmp;
+                        
+                        if (hollowAmount > 0.0)
+                            {
+                            hollowVolume *= hollowAmount;
+                            
+                            switch (_pbs.HollowShape)
+                                {
+                                case HollowShape.Square:
+                                case HollowShape.Same:
+                                    break;
+
+                                case HollowShape.Circle:
+                                    hollowVolume *= 0.78539816339f;;
+                                    break;
+
+                                case HollowShape.Triangle:
+                                    hollowVolume *= 0.5f * 0.5f;
+                                    break;
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                                }
+                            volume *= (1.0f - hollowVolume);
+                            }
+                        }
+
+                    break;
+
+                case ProfileShape.Circle:
+
+                    if (_pbs.PathCurve == (byte)Extrusion.Straight)
+                        {
+                        volume *= 0.78539816339f; // elipse base
+
+                        if (hollowAmount > 0.0)
+                            {
+                            switch (_pbs.HollowShape)
+                                {
+                                case HollowShape.Same:
+                                case HollowShape.Circle:
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.5f * 2.5984480504799f;
+                                    break;
+
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .5f * 1.27323954473516f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                                }
+                            volume *= (1.0f - hollowVolume);
+                            }
+                        }
+
+                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                        {
+                        volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - _pbs.PathScaleX);
+                        tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
+                        volume *= (1.0f - tmp * tmp);
+                        
+                        if (hollowAmount > 0.0)
+                            {
+
+                            // calculate the hollow volume by it's shape compared to the prim shape
+                            hollowVolume *= hollowAmount;
+
+                            switch (_pbs.HollowShape)
+                                {
+                                case HollowShape.Same:
+                                case HollowShape.Circle:
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.5f * 2.5984480504799f;
+                                    break;
+
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .5f * 1.27323954473516f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                                }
+                            volume *= (1.0f - hollowVolume);
+                            }
+                        }
+                    break;
+
+                case ProfileShape.HalfCircle:
+                    if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                    volume *= 0.52359877559829887307710723054658f;
+                    }
+                    break;
+
+                case ProfileShape.EquilateralTriangle:
+
+                    if (_pbs.PathCurve == (byte)Extrusion.Straight)
+                        {
+                        volume *= 0.32475953f;
+
+                        if (hollowAmount > 0.0)
+                            {
+
+                            // calculate the hollow volume by it's shape compared to the prim shape
+                            switch (_pbs.HollowShape)
+                                {
+                                case HollowShape.Same:
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .25f;
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.499849f * 3.07920140172638f;
+                                    break;
+
+                                case HollowShape.Circle:
+                                    // Hollow shape is a perfect cyllinder in respect to the cube's scale
+                                    // Cyllinder hollow volume calculation
+
+                                    hollowVolume *= 0.1963495f * 3.07920140172638f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                                }
+                            volume *= (1.0f - hollowVolume);
+                            }
+                        }
+                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                        {
+                        volume *= 0.32475953f;
+                        volume *= 0.01f * (float)(200 - _pbs.PathScaleX);
+                        tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
+                        volume *= (1.0f - tmp * tmp);
+
+                        if (hollowAmount > 0.0)
+                            {
+
+                            hollowVolume *= hollowAmount;
+
+                            switch (_pbs.HollowShape)
+                                {
+                                case HollowShape.Same:
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .25f;
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.499849f * 3.07920140172638f;
+                                    break;
+
+                                case HollowShape.Circle:
+
+                                    hollowVolume *= 0.1963495f * 3.07920140172638f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                                }
+                            volume *= (1.0f - hollowVolume);
+                            }
+                        }
+                        break;
+
+                default:
+                    break;
+                }
+
+            float taperX1;
+            float taperY1;
+            float taperX;
+            float taperY;
+            float pathBegin;
+            float pathEnd;
+            float profileBegin;
+            float profileEnd;
+
+            if (_pbs.PathCurve == (byte)Extrusion.Straight || _pbs.PathCurve == (byte)Extrusion.Flexible)
+            {
+                taperX1 = _pbs.PathScaleX * 0.01f;
+                if (taperX1 > 1.0f)
+                    taperX1 = 2.0f - taperX1;
+                taperX = 1.0f - taperX1;
+
+                taperY1 = _pbs.PathScaleY * 0.01f;
+                if (taperY1 > 1.0f)
+                    taperY1 = 2.0f - taperY1;
+                taperY = 1.0f - taperY1;
+            }
+            else
+            {
+                taperX = _pbs.PathTaperX * 0.01f;
+                if (taperX < 0.0f)
+                    taperX = -taperX;
+                taperX1 = 1.0f - taperX;
+
+                taperY = _pbs.PathTaperY * 0.01f;
+                if (taperY < 0.0f)
+                    taperY = -taperY;
+                taperY1 = 1.0f - taperY;
+            }
+
+            volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY);
+
+            pathBegin = (float)_pbs.PathBegin * 2.0e-5f;
+            pathEnd = 1.0f - (float)_pbs.PathEnd * 2.0e-5f;
+            volume *= (pathEnd - pathBegin);
+
+// this is crude aproximation
+            profileBegin = (float)_pbs.ProfileBegin * 2.0e-5f;
+            profileEnd = 1.0f - (float)_pbs.ProfileEnd * 2.0e-5f;
+            volume *= (profileEnd - profileBegin);
+
+            returnMass = m_density * volume;
+
+            if (returnMass <= 0)
+                returnMass = 0.0001f;//ckrinke: Mass must be greater then zero.
+//            else if (returnMass > _parent_scene.maximumMassObject)
+//                returnMass = _parent_scene.maximumMassObject;
+
+            // Recursively calculate mass
+            bool HasChildPrim = false;
+            lock (childrenPrim)
+            {
+                if (childrenPrim.Count > 0)
+                {
+                    HasChildPrim = true;
+                }
+            }
+
+            if (HasChildPrim)
+            {
+                OdePrim[] childPrimArr = new OdePrim[0];
+
+                lock (childrenPrim)
+                    childPrimArr = childrenPrim.ToArray();
+
+                for (int i = 0; i < childPrimArr.Length; i++)
+                {
+                    if (childPrimArr[i] != null && !childPrimArr[i].m_taintremove)
+                        returnMass += childPrimArr[i].CalculateMass();
+                    // failsafe, this shouldn't happen but with OpenSim, you never know :)
+                    if (i > 256)
+                        break;
+                }
+            }
+
+            if (returnMass > _parent_scene.maximumMassObject)
+                returnMass = _parent_scene.maximumMassObject;
+
+            return returnMass;
+        }
+
+        #endregion
+
+        private void setMass()
+        {
+            if (Body != (IntPtr) 0)
+            {
+                float newmass = CalculateMass();
+
+                //m_log.Info("[PHYSICS]: New Mass: " + newmass.ToString());
+
+                d.MassSetBoxTotal(out pMass, newmass, _size.X, _size.Y, _size.Z);
+                d.BodySetMass(Body, ref pMass);
+            }
+        }
+
+        private void setAngularVelocity(float x, float y, float z)
+        {
+            if (Body != (IntPtr)0)
+            {
+                d.BodySetAngularVel(Body, x, y, z);
+            }
+        }
+
+        /// <summary>
+        /// Stop a prim from being subject to physics.
+        /// </summary>
+        internal void disableBody()
+        {
+            //this kills the body so things like 'mesh' can re-create it.
+            lock (this)
+            {
+                if (!childPrim)
+                {
+                    if (Body != IntPtr.Zero)
+                    {
+                        _parent_scene.DeactivatePrim(this);
+                        m_collisionCategories &= ~CollisionCategories.Body;
+                        m_collisionFlags &= ~(CollisionCategories.Wind | CollisionCategories.Land);
+
+                        if (m_assetFailed)
+                        {
+                            d.GeomSetCategoryBits(prim_geom, 0);
+                            d.GeomSetCollideBits(prim_geom, 0);
+                        }
+                        else
+                        {
+                            d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
+                            d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
+                        }
+
+                        d.BodyDestroy(Body);
+                        lock (childrenPrim)
+                        {
+                            if (childrenPrim.Count > 0)
+                            {
+                                foreach (OdePrim prm in childrenPrim)
+                                {
+                                    _parent_scene.DeactivatePrim(prm);
+                                    prm.Body = IntPtr.Zero;
+                                }
+                            }
+                        }
+                        Body = IntPtr.Zero;
+                    }
+                }
+                else
+                {
+                    _parent_scene.DeactivatePrim(this);
+                    
+                    m_collisionCategories &= ~CollisionCategories.Body;
+                    m_collisionFlags &= ~(CollisionCategories.Wind | CollisionCategories.Land);
+
+                    if (m_assetFailed)
+                    {
+                        d.GeomSetCategoryBits(prim_geom, 0);
+                        d.GeomSetCollideBits(prim_geom, 0);
+                    }
+                    else
+                    {
+
+                        d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
+                        d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
+                    }
+
+                    Body = IntPtr.Zero;
+                }
+            }
+
+            m_disabled = true;
+            m_collisionscore = 0;
+        }
+
+        private static Dictionary<IMesh, IntPtr> m_MeshToTriMeshMap = new Dictionary<IMesh, IntPtr>();
+
+        private void setMesh(OdeScene parent_scene, IMesh mesh)
+        {
+//            m_log.DebugFormat("[ODE PRIM]: Setting mesh on {0} to {1}", Name, mesh);
+
+            // This sleeper is there to moderate how long it takes between
+            // setting up the mesh and pre-processing it when we get rapid fire mesh requests on a single object
+
+            //Thread.Sleep(10);
+
+            //Kill Body so that mesh can re-make the geom
+            if (IsPhysical && Body != IntPtr.Zero)
+            {
+                if (childPrim)
+                {
+                    if (_parent != null)
+                    {
+                        OdePrim parent = (OdePrim)_parent;
+                        parent.ChildDelink(this);
+                    }
+                }
+                else
+                {
+                    disableBody();
+                }
+            }
+
+            IntPtr vertices, indices;
+            int vertexCount, indexCount;
+            int vertexStride, triStride;
+            mesh.getVertexListAsPtrToFloatArray(out vertices, out vertexStride, out vertexCount); // Note, that vertices are fixed in unmanaged heap
+            mesh.getIndexListAsPtrToIntArray(out indices, out triStride, out indexCount); // Also fixed, needs release after usage
+            m_expectedCollisionContacts = indexCount;
+            mesh.releaseSourceMeshData(); // free up the original mesh data to save memory
+
+            // We must lock here since m_MeshToTriMeshMap is static and multiple scene threads may call this method at
+            // the same time.
+            lock (m_MeshToTriMeshMap)
+            {
+                if (m_MeshToTriMeshMap.ContainsKey(mesh))
+                {
+                    _triMeshData = m_MeshToTriMeshMap[mesh];
+                }
+                else
+                {
+                    _triMeshData = d.GeomTriMeshDataCreate();
+    
+                    d.GeomTriMeshDataBuildSimple(_triMeshData, vertices, vertexStride, vertexCount, indices, indexCount, triStride);
+                    d.GeomTriMeshDataPreprocess(_triMeshData);
+                    m_MeshToTriMeshMap[mesh] = _triMeshData;
+                }
+            }
+
+//            _parent_scene.waitForSpaceUnlock(m_targetSpace);
+            try
+            {
+                SetGeom(d.CreateTriMesh(m_targetSpace, _triMeshData, parent_scene.triCallback, null, null));
+            }
+            catch (AccessViolationException)
+            {
+                m_log.ErrorFormat("[PHYSICS]: MESH LOCKED FOR {0}", Name);
+                return;
+            }
+
+           // if (IsPhysical && Body == (IntPtr) 0)
+           // {
+                // Recreate the body
+          //     m_interpenetrationcount = 0;
+           //     m_collisionscore = 0;
+
+           //     enableBody();
+           // }
+        }
+
+        internal void ProcessTaints()
+        {
+#if SPAM
+Console.WriteLine("ZProcessTaints for " + Name);
+#endif
+
+            // This must be processed as the very first taint so that later operations have a prim_geom to work with
+            // if this is a new prim.
+            if (m_taintadd)
+                changeadd();
+
+            if (!_position.ApproxEquals(m_taintposition, 0f))
+                 changemove();
+
+            if (m_taintrot != _orientation)
+            {
+                if (childPrim && IsPhysical)    // For physical child prim...
+                {
+                    rotate();
+                    // KF: ODE will also rotate the parent prim!
+                    // so rotate the root back to where it was
+                    OdePrim parent = (OdePrim)_parent;
+                    parent.rotate();
+                }
+                else
+                {
+                    //Just rotate the prim
+                    rotate();
+                }
+            }
+        
+            if (m_taintPhysics != IsPhysical && !(m_taintparent != _parent))
+                changePhysicsStatus();
+
+            if (!_size.ApproxEquals(m_taintsize, 0f))
+                changesize();
+
+            if (m_taintshape)
+                changeshape();
+
+            if (m_taintforce)
+                changeAddForce();
+
+            if (m_taintaddangularforce)
+                changeAddAngularForce();
+
+            if (!m_taintTorque.ApproxEquals(Vector3.Zero, 0.001f))
+                changeSetTorque();
+
+            if (m_taintdisable)
+                changedisable();
+
+            if (m_taintselected != m_isSelected)
+                changeSelectedStatus();
+
+            if (!m_taintVelocity.ApproxEquals(Vector3.Zero, 0.001f))
+                changevelocity();
+
+            if (m_taintparent != _parent)
+                changelink();
+
+            if (m_taintCollidesWater != m_collidesWater)
+                changefloatonwater();
+
+            if (!m_angularlock.ApproxEquals(m_taintAngularLock,0f))
+                changeAngularLock();
+        }
+
+        /// <summary>
+        /// Change prim in response to an angular lock taint.
+        /// </summary>
+        private void changeAngularLock()
+        {
+            // do we have a Physical object?
+            if (Body != IntPtr.Zero)
+            {
+                //Check that we have a Parent
+                //If we have a parent then we're not authorative here
+                if (_parent == null)
+                {
+                    if (!m_taintAngularLock.ApproxEquals(Vector3.One, 0f))
+                    {
+                        //d.BodySetFiniteRotationMode(Body, 0);
+                        //d.BodySetFiniteRotationAxis(Body,m_taintAngularLock.X,m_taintAngularLock.Y,m_taintAngularLock.Z);
+                        createAMotor(m_taintAngularLock);
+                    }
+                    else
+                    {
+                        if (Amotor != IntPtr.Zero)
+                        {
+                            d.JointDestroy(Amotor);
+                            Amotor = IntPtr.Zero;
+                        }
+                    }
+                }
+            }
+
+            // Store this for later in case we get turned into a separate body
+            m_angularlock = m_taintAngularLock;
+        }
+
+        /// <summary>
+        /// Change prim in response to a link taint.
+        /// </summary>
+        private void changelink()
+        {
+            // If the newly set parent is not null
+            // create link
+            if (_parent == null && m_taintparent != null)
+            {
+                if (m_taintparent.PhysicsActorType == (int)ActorTypes.Prim)
+                {
+                    OdePrim obj = (OdePrim)m_taintparent;
+                    //obj.disableBody();
+//Console.WriteLine("changelink calls ParentPrim");
+                    obj.AddChildPrim(this);
+
+                    /*
+                    if (obj.Body != (IntPtr)0 && Body != (IntPtr)0 && obj.Body != Body)
+                    {
+                        _linkJointGroup = d.JointGroupCreate(0);
+                        m_linkJoint = d.JointCreateFixed(_parent_scene.world, _linkJointGroup);
+                        d.JointAttach(m_linkJoint, obj.Body, Body);
+                        d.JointSetFixed(m_linkJoint);
+                    }
+                     */
+                }
+            }
+            // If the newly set parent is null
+            // destroy link
+            else if (_parent != null && m_taintparent == null)
+            {
+//Console.WriteLine("  changelink B");
+            
+                if (_parent is OdePrim)
+                {
+                    OdePrim obj = (OdePrim)_parent;
+                    obj.ChildDelink(this);
+                    childPrim = false;
+                    //_parent = null;
+                }
+                
+                /*
+                    if (Body != (IntPtr)0 && _linkJointGroup != (IntPtr)0)
+                    d.JointGroupDestroy(_linkJointGroup);
+                        
+                    _linkJointGroup = (IntPtr)0;
+                    m_linkJoint = (IntPtr)0;
+                */
+            }
+ 
+            _parent = m_taintparent;
+            m_taintPhysics = IsPhysical;
+        }
+
+        /// <summary>
+        /// Add a child prim to this parent prim.
+        /// </summary>
+        /// <param name="prim">Child prim</param>
+        private void AddChildPrim(OdePrim prim)
+        {
+            if (LocalID == prim.LocalID)
+                return;
+
+            if (Body == IntPtr.Zero)
+            {
+                Body = d.BodyCreate(_parent_scene.world);
+                setMass();
+            }
+
+            lock (childrenPrim)
+            {
+                if (childrenPrim.Contains(prim))
+                    return;
+
+//                m_log.DebugFormat(
+//                    "[ODE PRIM]: Linking prim {0} {1} to {2} {3}", prim.Name, prim.LocalID, Name, LocalID);
+
+                childrenPrim.Add(prim);
+
+                foreach (OdePrim prm in childrenPrim)
+                {
+                    d.Mass m2;
+                    d.MassSetZero(out m2);
+                    d.MassSetBoxTotal(out m2, prim.CalculateMass(), prm._size.X, prm._size.Y, prm._size.Z);
+
+                    d.Quaternion quat = new d.Quaternion();
+                    quat.W = prm._orientation.W;
+                    quat.X = prm._orientation.X;
+                    quat.Y = prm._orientation.Y;
+                    quat.Z = prm._orientation.Z;
+
+                    d.Matrix3 mat = new d.Matrix3();
+                    d.RfromQ(out mat, ref quat);
+                    d.MassRotate(ref m2, ref mat);
+                    d.MassTranslate(ref m2, Position.X - prm.Position.X, Position.Y - prm.Position.Y, Position.Z - prm.Position.Z);
+                    d.MassAdd(ref pMass, ref m2);
+                }
+
+                foreach (OdePrim prm in childrenPrim)
+                {
+                    prm.m_collisionCategories |= CollisionCategories.Body;
+                    prm.m_collisionFlags |= (CollisionCategories.Land | CollisionCategories.Wind);
+
+//Console.WriteLine(" GeomSetCategoryBits 1: " + prm.prim_geom + " - " + (int)prm.m_collisionCategories + " for " + Name);
+                    if (prm.m_assetFailed)
+                    {
+                        d.GeomSetCategoryBits(prm.prim_geom, 0);
+                        d.GeomSetCollideBits(prm.prim_geom, prm.BadMeshAssetCollideBits);
+                    }
+                    else
+                    {
+                        d.GeomSetCategoryBits(prm.prim_geom, (int)prm.m_collisionCategories);
+                        d.GeomSetCollideBits(prm.prim_geom, (int)prm.m_collisionFlags);
+                    }
+
+                    d.Quaternion quat = new d.Quaternion();
+                    quat.W = prm._orientation.W;
+                    quat.X = prm._orientation.X;
+                    quat.Y = prm._orientation.Y;
+                    quat.Z = prm._orientation.Z;
+
+                    d.Matrix3 mat = new d.Matrix3();
+                    d.RfromQ(out mat, ref quat);
+                    if (Body != IntPtr.Zero)
+                    {
+                        d.GeomSetBody(prm.prim_geom, Body);
+                        prm.childPrim = true;
+                        d.GeomSetOffsetWorldPosition(prm.prim_geom, prm.Position.X , prm.Position.Y, prm.Position.Z);
+                        //d.GeomSetOffsetPosition(prim.prim_geom,
+                        //    (Position.X - prm.Position.X) - pMass.c.X,
+                        //    (Position.Y - prm.Position.Y) - pMass.c.Y,
+                        //    (Position.Z - prm.Position.Z) - pMass.c.Z);
+                        d.GeomSetOffsetWorldRotation(prm.prim_geom, ref mat);
+                        //d.GeomSetOffsetRotation(prm.prim_geom, ref mat);
+                        d.MassTranslate(ref pMass, -pMass.c.X, -pMass.c.Y, -pMass.c.Z);
+                        d.BodySetMass(Body, ref pMass);
+                    }
+                    else
+                    {
+                        m_log.DebugFormat("[PHYSICS]: {0} ain't got no boooooooooddy, no body", Name);
+                    }
+
+                    prm.m_interpenetrationcount = 0;
+                    prm.m_collisionscore = 0;
+                    prm.m_disabled = false;
+
+                    // The body doesn't already have a finite rotation mode set here
+                    if ((!m_angularlock.ApproxEquals(Vector3.Zero, 0f)) && _parent == null)
+                    {
+                        prm.createAMotor(m_angularlock);
+                    }
+                    prm.Body = Body;
+                    _parent_scene.ActivatePrim(prm);
+                }
+
+                m_collisionCategories |= CollisionCategories.Body;
+                m_collisionFlags |= (CollisionCategories.Land | CollisionCategories.Wind);
+
+                if (m_assetFailed)
+                {
+                    d.GeomSetCategoryBits(prim_geom, 0);
+                    d.GeomSetCollideBits(prim_geom, BadMeshAssetCollideBits);
+                }
+                else
+                {
+                    //Console.WriteLine("GeomSetCategoryBits 2: " + prim_geom + " - " + (int)m_collisionCategories + " for " + Name);
+                    d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
+                    //Console.WriteLine(" Post GeomSetCategoryBits 2");
+                    d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
+                }
+
+                d.Quaternion quat2 = new d.Quaternion();
+                quat2.W = _orientation.W;
+                quat2.X = _orientation.X;
+                quat2.Y = _orientation.Y;
+                quat2.Z = _orientation.Z;
+
+                d.Matrix3 mat2 = new d.Matrix3();
+                d.RfromQ(out mat2, ref quat2);
+                d.GeomSetBody(prim_geom, Body);
+                d.GeomSetOffsetWorldPosition(prim_geom, Position.X - pMass.c.X, Position.Y - pMass.c.Y, Position.Z - pMass.c.Z);
+                //d.GeomSetOffsetPosition(prim.prim_geom,
+                //    (Position.X - prm.Position.X) - pMass.c.X,
+                //    (Position.Y - prm.Position.Y) - pMass.c.Y,
+                //    (Position.Z - prm.Position.Z) - pMass.c.Z);
+                //d.GeomSetOffsetRotation(prim_geom, ref mat2);
+                d.MassTranslate(ref pMass, -pMass.c.X, -pMass.c.Y, -pMass.c.Z);
+                d.BodySetMass(Body, ref pMass);
+
+                d.BodySetAutoDisableFlag(Body, true);
+                d.BodySetAutoDisableSteps(Body, body_autodisable_frames);
+
+                m_interpenetrationcount = 0;
+                m_collisionscore = 0;
+                m_disabled = false;
+
+                // The body doesn't already have a finite rotation mode set here
+                if ((!m_angularlock.ApproxEquals(Vector3.Zero, 0f)) && _parent == null)
+                {
+                    createAMotor(m_angularlock);
+                }
+
+                d.BodySetPosition(Body, Position.X, Position.Y, Position.Z);
+
+                if (m_vehicle.Type != Vehicle.TYPE_NONE)
+                    m_vehicle.Enable(Body, _parent_scene);
+
+                _parent_scene.ActivatePrim(this);
+            }
+        }
+
+        private void ChildSetGeom(OdePrim odePrim)
+        {
+//            m_log.DebugFormat(
+//                "[ODE PRIM]: ChildSetGeom {0} {1} for {2} {3}", odePrim.Name, odePrim.LocalID, Name, LocalID);
+
+            //if (IsPhysical && Body != IntPtr.Zero)
+            lock (childrenPrim)
+            {
+                foreach (OdePrim prm in childrenPrim)
+                {
+                    //prm.childPrim = true;
+                    prm.disableBody();
+                    //prm.m_taintparent = null;
+                    //prm._parent = null;
+                    //prm.m_taintPhysics = false;
+                    //prm.m_disabled = true;
+                    //prm.childPrim = false;
+                }
+            }
+
+            disableBody();
+
+            // Spurious - Body == IntPtr.Zero after disableBody()
+//            if (Body != IntPtr.Zero)
+//            {
+//                _parent_scene.DeactivatePrim(this);
+//            }
+
+            lock (childrenPrim)
+            {
+                foreach (OdePrim prm in childrenPrim)
+                {
+//Console.WriteLine("ChildSetGeom calls ParentPrim");
+                    AddChildPrim(prm);
+                }
+            }
+        }
+
+        private void ChildDelink(OdePrim odePrim)
+        {
+//            m_log.DebugFormat(
+//                "[ODE PRIM]: Delinking prim {0} {1} from {2} {3}", odePrim.Name, odePrim.LocalID, Name, LocalID);
+
+            // Okay, we have a delinked child..   need to rebuild the body.
+            lock (childrenPrim)
+            {
+                foreach (OdePrim prm in childrenPrim)
+                {
+                    prm.childPrim = true;
+                    prm.disableBody();
+                    //prm.m_taintparent = null;
+                    //prm._parent = null;
+                    //prm.m_taintPhysics = false;
+                    //prm.m_disabled = true;
+                    //prm.childPrim = false;
+                }
+            }
+
+            disableBody();
+
+            lock (childrenPrim)
+            {
+ //Console.WriteLine("childrenPrim.Remove " + odePrim);
+                childrenPrim.Remove(odePrim);
+            }
+
+            // Spurious - Body == IntPtr.Zero after disableBody()
+//            if (Body != IntPtr.Zero)
+//            {
+//                _parent_scene.DeactivatePrim(this);
+//            }
+
+            lock (childrenPrim)
+            {
+                foreach (OdePrim prm in childrenPrim)
+                {
+//Console.WriteLine("ChildDelink calls ParentPrim");
+                    AddChildPrim(prm);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Change prim in response to a selection taint.
+        /// </summary>
+        private void changeSelectedStatus()
+        {
+            if (m_taintselected)
+            {
+                m_collisionCategories = CollisionCategories.Selected;
+                m_collisionFlags = (CollisionCategories.Sensor | CollisionCategories.Space);
+
+                // We do the body disable soft twice because 'in theory' a collision could have happened
+                // in between the disabling and the collision properties setting
+                // which would wake the physical body up from a soft disabling and potentially cause it to fall
+                // through the ground.
+                
+                // NOTE FOR JOINTS: this doesn't always work for jointed assemblies because if you select
+                // just one part of the assembly, the rest of the assembly is non-selected and still simulating,
+                // so that causes the selected part to wake up and continue moving.
+
+                // even if you select all parts of a jointed assembly, it is not guaranteed that the entire
+                // assembly will stop simulating during the selection, because of the lack of atomicity
+                // of select operations (their processing could be interrupted by a thread switch, causing
+                // simulation to continue before all of the selected object notifications trickle down to
+                // the physics engine).
+
+                // e.g. we select 100 prims that are connected by joints. non-atomically, the first 50 are
+                // selected and disabled. then, due to a thread switch, the selection processing is
+                // interrupted and the physics engine continues to simulate, so the last 50 items, whose
+                // selection was not yet processed, continues to simulate. this wakes up ALL of the 
+                // first 50 again. then the last 50 are disabled. then the first 50, which were just woken
+                // up, start simulating again, which in turn wakes up the last 50.
+
+                if (IsPhysical)
+                {
+                    disableBodySoft();
+                }
+
+                if (m_assetFailed)
+                {
+                    d.GeomSetCategoryBits(prim_geom, 0);
+                    d.GeomSetCollideBits(prim_geom, 0);
+                }
+                else
+                {
+                    d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
+                    d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
+                }
+
+                if (IsPhysical)
+                {
+                    disableBodySoft();
+                }
+            }
+            else
+            {
+                m_collisionCategories = CollisionCategories.Geom;
+
+                if (IsPhysical)
+                    m_collisionCategories |= CollisionCategories.Body;
+
+                m_collisionFlags = m_default_collisionFlags;
+
+                if (m_collidesLand)
+                    m_collisionFlags |= CollisionCategories.Land;
+                if (m_collidesWater)
+                    m_collisionFlags |= CollisionCategories.Water;
+
+                if (m_assetFailed)
+                {
+                    d.GeomSetCategoryBits(prim_geom, 0);
+                    d.GeomSetCollideBits(prim_geom, BadMeshAssetCollideBits);
+                }
+                else
+                {
+                    d.GeomSetCategoryBits(prim_geom, (int)m_collisionCategories);
+                    d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
+                }
+
+                if (IsPhysical)
+                {
+                    if (Body != IntPtr.Zero)
+                    {
+                        d.BodySetLinearVel(Body, 0f, 0f, 0f);
+                        d.BodySetForce(Body, 0, 0, 0);
+                        enableBodySoft();
+                    }
+                }
+            }
+
+            resetCollisionAccounting();
+            m_isSelected = m_taintselected;
+        }//end changeSelectedStatus
+
+        internal void ResetTaints()
+        {
+            m_taintposition = _position;
+            m_taintrot = _orientation;
+            m_taintPhysics = IsPhysical;
+            m_taintselected = m_isSelected;
+            m_taintsize = _size;
+            m_taintshape = false;
+            m_taintforce = false;
+            m_taintdisable = false;
+            m_taintVelocity = Vector3.Zero;
+        }
+
+        /// <summary>
+        /// Create a geometry for the given mesh in the given target space.
+        /// </summary>
+        /// <param name="m_targetSpace"></param>
+        /// <param name="mesh">If null, then a mesh is used that is based on the profile shape data.</param>
+        private void CreateGeom(IntPtr m_targetSpace, IMesh mesh)
+        {
+#if SPAM
+Console.WriteLine("CreateGeom:");
+#endif
+            if (mesh != null)
+            {
+                setMesh(_parent_scene, mesh);
+            }
+            else
+            {
+                if (_pbs.ProfileShape == ProfileShape.HalfCircle && _pbs.PathCurve == (byte)Extrusion.Curve1)
+                {
+                    if (_size.X == _size.Y && _size.Y == _size.Z && _size.X == _size.Z)
+                    {
+                        if (((_size.X / 2f) > 0f))
+                        {
+//                            _parent_scene.waitForSpaceUnlock(m_targetSpace);
+                            try
+                            {
+//Console.WriteLine(" CreateGeom 1");
+                                SetGeom(d.CreateSphere(m_targetSpace, _size.X / 2));
+                                m_expectedCollisionContacts = 3;
+                            }
+                            catch (AccessViolationException)
+                            {
+                                m_log.WarnFormat("[PHYSICS]: Unable to create physics proxy for object {0}", Name);
+                                return;
+                            }
+                        }
+                        else
+                        {
+//                            _parent_scene.waitForSpaceUnlock(m_targetSpace);
+                            try
+                            {
+//Console.WriteLine(" CreateGeom 2");
+                                SetGeom(d.CreateBox(m_targetSpace, _size.X, _size.Y, _size.Z));
+                                m_expectedCollisionContacts = 4;
+                            }
+                            catch (AccessViolationException)
+                            {
+                                m_log.WarnFormat("[PHYSICS]: Unable to create physics proxy for object {0}", Name);
+                                return;
+                            }
+                        }
+                    }
+                    else
+                    {
+//                        _parent_scene.waitForSpaceUnlock(m_targetSpace);
+                        try
+                        {
+//Console.WriteLine("  CreateGeom 3");
+                            SetGeom(d.CreateBox(m_targetSpace, _size.X, _size.Y, _size.Z));
+                            m_expectedCollisionContacts = 4;
+                        }
+                        catch (AccessViolationException)
+                        {
+                            m_log.WarnFormat("[PHYSICS]: Unable to create physics proxy for object {0}", Name);
+                            return;
+                        }
+                    }
+                }
+                else
+                {
+//                    _parent_scene.waitForSpaceUnlock(m_targetSpace);
+                    try
+                    {
+//Console.WriteLine("  CreateGeom 4");
+                        SetGeom(d.CreateBox(m_targetSpace, _size.X, _size.Y, _size.Z));
+                        m_expectedCollisionContacts = 4;
+                    }
+                    catch (AccessViolationException)
+                    {
+                        m_log.WarnFormat("[PHYSICS]: Unable to create physics proxy for object {0}", Name);
+                        return;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Remove the existing geom from this prim.
+        /// </summary>
+        /// <param name="m_targetSpace"></param>
+        /// <param name="mesh">If null, then a mesh is used that is based on the profile shape data.</param>
+        /// <returns>true if the geom was successfully removed, false if it was already gone or the remove failed.</returns>
+        internal bool RemoveGeom()
+        {
+            if (prim_geom != IntPtr.Zero)
+            {
+                try
+                {
+                    _parent_scene.geom_name_map.Remove(prim_geom);
+                    _parent_scene.actor_name_map.Remove(prim_geom);
+                    d.GeomDestroy(prim_geom);
+                    m_expectedCollisionContacts = 0;
+                    prim_geom = IntPtr.Zero;
+                }
+                catch (System.AccessViolationException)
+                {
+                    prim_geom = IntPtr.Zero;
+                    m_expectedCollisionContacts = 0;
+                    m_log.ErrorFormat("[PHYSICS]: PrimGeom dead for {0}", Name);
+
+                    return false;
+                }
+
+                return true;
+            }
+            else
+            {
+                m_log.WarnFormat(
+                    "[ODE PRIM]: Called RemoveGeom() on {0} {1} where geometry was already null.", Name, LocalID);
+
+                return false;
+            }
+        }
+        /// <summary>
+        /// Add prim in response to an add taint.
+        /// </summary>
+        private void changeadd()
+        {
+//            m_log.DebugFormat("[ODE PRIM]: Adding prim {0}", Name);
+            
+            int[] iprimspaceArrItem = _parent_scene.calculateSpaceArrayItemFromPos(_position);
+            IntPtr targetspace = _parent_scene.calculateSpaceForGeom(_position);
+
+            if (targetspace == IntPtr.Zero)
+                targetspace = _parent_scene.createprimspace(iprimspaceArrItem[0], iprimspaceArrItem[1]);
+
+            m_targetSpace = targetspace;
+
+            IMesh mesh = null;
+
+            if (_parent_scene.needsMeshing(_pbs))
+            {
+                // Don't need to re-enable body..   it's done in SetMesh
+                mesh = _parent_scene.mesher.CreateMesh(Name, _pbs, _size, _parent_scene.meshSculptLOD, IsPhysical);
+                // createmesh returns null when it's a shape that isn't a cube.
+               // m_log.Debug(m_localID);
+                if (mesh == null)
+                    CheckMeshAsset();
+                else
+                    m_assetFailed = false;
+            }
+
+#if SPAM
+Console.WriteLine("changeadd 1");
+#endif
+            CreateGeom(m_targetSpace, mesh);
+
+            d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
+            d.Quaternion myrot = new d.Quaternion();
+            myrot.X = _orientation.X;
+            myrot.Y = _orientation.Y;
+            myrot.Z = _orientation.Z;
+            myrot.W = _orientation.W;
+            d.GeomSetQuaternion(prim_geom, ref myrot);
+
+            if (IsPhysical && Body == IntPtr.Zero)
+                enableBody();
+
+            changeSelectedStatus();
+
+            m_taintadd = false;
+        }
+
+        /// <summary>
+        /// Move prim in response to a move taint.
+        /// </summary>
+        private void changemove()
+        {
+            if (IsPhysical)
+            {
+                if (!m_disabled && !m_taintremove && !childPrim)
+                {
+                    if (Body == IntPtr.Zero)
+                        enableBody();
+
+                    //Prim auto disable after 20 frames,
+                    //if you move it, re-enable the prim manually.
+                    if (_parent != null)
+                    {
+                        if (m_linkJoint != IntPtr.Zero)
+                        {
+                            d.JointDestroy(m_linkJoint);
+                            m_linkJoint = IntPtr.Zero;
+                        }
+                    }
+
+                    if (Body != IntPtr.Zero)
+                    {
+                        d.BodySetPosition(Body, _position.X, _position.Y, _position.Z);
+
+                        if (_parent != null)
+                        {
+                            OdePrim odParent = (OdePrim)_parent;
+                            if (Body != (IntPtr)0 && odParent.Body != (IntPtr)0 && Body != odParent.Body)
+                            {
+// KF: Fixed Joints were removed? Anyway - this Console.WriteLine does not show up, so routine is not used??
+Console.WriteLine(" JointCreateFixed");
+                                m_linkJoint = d.JointCreateFixed(_parent_scene.world, _linkJointGroup);
+                                d.JointAttach(m_linkJoint, Body, odParent.Body);
+                                d.JointSetFixed(m_linkJoint);
+                            }
+                        }
+                        d.BodyEnable(Body);
+                        if (m_vehicle.Type != Vehicle.TYPE_NONE)
+                        {
+                            m_vehicle.Enable(Body, _parent_scene);
+                        }
+                    }
+                    else
+                    {
+                        m_log.WarnFormat("[PHYSICS]: Body for {0} still null after enableBody().  This is a crash scenario.", Name);
+                    }
+                }
+                //else
+               // {
+                    //m_log.Debug("[BUG]: race!");
+                //}
+            }
+
+            // string primScenAvatarIn = _parent_scene.whichspaceamIin(_position);
+            // int[] arrayitem = _parent_scene.calculateSpaceArrayItemFromPos(_position);
+//          _parent_scene.waitForSpaceUnlock(m_targetSpace);
+
+            IntPtr tempspace = _parent_scene.recalculateSpaceForGeom(prim_geom, _position, m_targetSpace);
+            m_targetSpace = tempspace;
+
+//                _parent_scene.waitForSpaceUnlock(m_targetSpace);
+
+            d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
+
+//                    _parent_scene.waitForSpaceUnlock(m_targetSpace);
+            d.SpaceAdd(m_targetSpace, prim_geom);
+
+            changeSelectedStatus();
+
+            resetCollisionAccounting();
+            m_taintposition = _position;
+        }
+
+        internal void Move(float timestep)
+        {
+            float fx = 0;
+            float fy = 0;
+            float fz = 0;
+
+            if (outofBounds)
+                return;
+
+            if (IsPhysical && (Body != IntPtr.Zero) && !m_isSelected && !childPrim)        // KF: Only move root prims.
+            {
+                if (m_vehicle.Type != Vehicle.TYPE_NONE)
+                {
+                    // 'VEHICLES' are dealt with in ODEDynamics.cs
+                    m_vehicle.Step(timestep, _parent_scene);
+                }
+                else
+                {
+//Console.WriteLine("Move " +  Name);
+                    if (!d.BodyIsEnabled (Body))  d.BodyEnable (Body); // KF add 161009
+                    // NON-'VEHICLES' are dealt with here
+//                    if (d.BodyIsEnabled(Body) && !m_angularlock.ApproxEquals(Vector3.Zero, 0.003f))
+//                    {
+//                        d.Vector3 avel2 = d.BodyGetAngularVel(Body);
+//                        /*
+//                        if (m_angularlock.X == 1)
+//                            avel2.X = 0;
+//                        if (m_angularlock.Y == 1)
+//                            avel2.Y = 0;
+//                        if (m_angularlock.Z == 1)
+//                            avel2.Z = 0;
+//                        d.BodySetAngularVel(Body, avel2.X, avel2.Y, avel2.Z);
+//                         */
+//                    }
+                    //float PID_P = 900.0f;
+
+                    float m_mass = CalculateMass();
+
+//                    fz = 0f;
+                    //m_log.Info(m_collisionFlags.ToString());
+
+                    
+                    //KF: m_buoyancy should be set by llSetBuoyancy() for non-vehicle.
+                    // would come from SceneObjectPart.cs, public void SetBuoyancy(float fvalue) , PhysActor.Buoyancy = fvalue; ??
+                    // m_buoyancy: (unlimited value) <0=Falls fast; 0=1g; 1=0g; >1 = floats up 
+                    // gravityz multiplier = 1 - m_buoyancy
+                    fz = _parent_scene.gravityz * (1.0f - m_buoyancy) * m_mass;
+
+                    if (PIDActive)
+                    {
+//Console.WriteLine("PID " +  Name);
+                        // KF - this is for object move? eg. llSetPos() ?
+                        //if (!d.BodyIsEnabled(Body))
+                        //d.BodySetForce(Body, 0f, 0f, 0f);
+                        // If we're using the PID controller, then we have no gravity
+                        //fz = (-1 * _parent_scene.gravityz) * m_mass;     //KF: ?? Prims have no global gravity,so simply...
+                        fz = 0f;
+
+                        //  no lock; for now it's only called from within Simulate()
+    
+                        // If the PID Controller isn't active then we set our force
+                        // calculating base velocity to the current position
+
+                        if ((m_PIDTau < 1) && (m_PIDTau != 0))
+                        {
+                            //PID_G = PID_G / m_PIDTau;
+                            m_PIDTau = 1;
+                        }
+    
+                        if ((PID_G - m_PIDTau) <= 0)
+                        {
+                            PID_G = m_PIDTau + 1;
+                        }
+                        //PidStatus = true;
+
+                        // PhysicsVector vec = new PhysicsVector();
+                        d.Vector3 vel = d.BodyGetLinearVel(Body);
+
+                        d.Vector3 pos = d.BodyGetPosition(Body);
+                        _target_velocity =
+                            new Vector3(
+                                (m_PIDTarget.X - pos.X) * ((PID_G - m_PIDTau) * timestep),
+                                (m_PIDTarget.Y - pos.Y) * ((PID_G - m_PIDTau) * timestep),
+                                (m_PIDTarget.Z - pos.Z) * ((PID_G - m_PIDTau) * timestep)
+                                );
+
+                        //  if velocity is zero, use position control; otherwise, velocity control
+
+                        if (_target_velocity.ApproxEquals(Vector3.Zero,0.1f))
+                        {
+                            //  keep track of where we stopped.  No more slippin' & slidin'
+    
+                            // We only want to deactivate the PID Controller if we think we want to have our surrogate
+                            // react to the physics scene by moving it's position.
+                            // Avatar to Avatar collisions
+                            // Prim to avatar collisions
+
+                            //fx = (_target_velocity.X - vel.X) * (PID_D) + (_zeroPosition.X - pos.X) * (PID_P * 2);
+                            //fy = (_target_velocity.Y - vel.Y) * (PID_D) + (_zeroPosition.Y - pos.Y) * (PID_P * 2);
+                            //fz = fz + (_target_velocity.Z - vel.Z) * (PID_D) + (_zeroPosition.Z - pos.Z) * PID_P;
+                            d.BodySetPosition(Body, m_PIDTarget.X, m_PIDTarget.Y, m_PIDTarget.Z);
+                            d.BodySetLinearVel(Body, 0, 0, 0);
+                            d.BodyAddForce(Body, 0, 0, fz);
+                            return;
+                        }
+                        else
+                        {
+                            _zeroFlag = false;
+
+                            // We're flying and colliding with something
+                            fx = ((_target_velocity.X) - vel.X) * (PID_D);
+                            fy = ((_target_velocity.Y) - vel.Y) * (PID_D);
+    
+                            // vec.Z = (_target_velocity.Z - vel.Z) * PID_D + (_zeroPosition.Z - pos.Z) * PID_P;
+
+                            fz = fz + ((_target_velocity.Z - vel.Z) * (PID_D) * m_mass);
+                        }
+                    }        // end if (PIDActive)
+
+                    // Hover PID Controller needs to be mutually exlusive to MoveTo PID controller
+                    if (m_useHoverPID && !PIDActive)
+                    {
+//Console.WriteLine("Hover " +  Name);
+                    
+                        // If we're using the PID controller, then we have no gravity
+                        fz = (-1 * _parent_scene.gravityz) * m_mass;
+
+                        //  no lock; for now it's only called from within Simulate()
+
+                        // If the PID Controller isn't active then we set our force
+                        // calculating base velocity to the current position
+
+                        if ((m_PIDTau < 1))
+                        {
+                            PID_G = PID_G / m_PIDTau;
+                        }
+
+                        if ((PID_G - m_PIDTau) <= 0)
+                        {
+                            PID_G = m_PIDTau + 1;
+                        }
+
+                        // Where are we, and where are we headed?
+                        d.Vector3 pos = d.BodyGetPosition(Body);
+                        d.Vector3 vel = d.BodyGetLinearVel(Body);
+
+                        //    Non-Vehicles have a limited set of Hover options.
+                        // determine what our target height really is based on HoverType
+                        switch (m_PIDHoverType)
+                        {
+                            case PIDHoverType.Ground:
+                                m_groundHeight = _parent_scene.GetTerrainHeightAtXY(pos.X, pos.Y);
+                                m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight;
+                                break;
+                            case PIDHoverType.GroundAndWater:
+                                m_groundHeight = _parent_scene.GetTerrainHeightAtXY(pos.X, pos.Y);
+                                m_waterHeight  = _parent_scene.GetWaterLevel();
+                                if (m_groundHeight > m_waterHeight)
+                                {
+                                    m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight;
+                                }
+                                else
+                                {
+                                    m_targetHoverHeight = m_waterHeight + m_PIDHoverHeight;
+                                }
+                                break;
+
+                        }     // end switch (m_PIDHoverType)
+
+
+                        _target_velocity =
+                            new Vector3(0.0f, 0.0f,
+                                (m_targetHoverHeight - pos.Z) * ((PID_G - m_PIDHoverTau) * timestep)
+                                );
+
+                        //  if velocity is zero, use position control; otherwise, velocity control
+
+                        if (_target_velocity.ApproxEquals(Vector3.Zero, 0.1f))
+                        {
+                            //  keep track of where we stopped.  No more slippin' & slidin'
+    
+                            // We only want to deactivate the PID Controller if we think we want to have our surrogate
+                            // react to the physics scene by moving it's position.
+                            // Avatar to Avatar collisions
+                            // Prim to avatar collisions
+
+                            d.BodySetPosition(Body, pos.X, pos.Y, m_targetHoverHeight);
+                            d.BodySetLinearVel(Body, vel.X, vel.Y, 0);
+                            d.BodyAddForce(Body, 0, 0, fz);
+                            return;
+                        }
+                        else
+                        {
+                            _zeroFlag = false;
+
+                            // We're flying and colliding with something
+                            fz = fz + ((_target_velocity.Z - vel.Z) * (PID_D) * m_mass);
+                        }
+                    }
+
+                    fx *= m_mass;
+                    fy *= m_mass;
+                    //fz *= m_mass;
+
+                    fx += m_force.X;
+                    fy += m_force.Y;
+                    fz += m_force.Z;
+
+                    //m_log.Info("[OBJPID]: X:" + fx.ToString() + " Y:" + fy.ToString() + " Z:" + fz.ToString());
+                    if (fx != 0 || fy != 0 || fz != 0)
+                    {
+                        //m_taintdisable = true;
+                        //base.RaiseOutOfBounds(Position);
+                        //d.BodySetLinearVel(Body, fx, fy, 0f);
+                        if (!d.BodyIsEnabled(Body))
+                        {
+                            // A physical body at rest on a surface will auto-disable after a while,
+                            // this appears to re-enable it incase the surface it is upon vanishes,
+                            // and the body should fall again. 
+                            d.BodySetLinearVel(Body, 0f, 0f, 0f);
+                            d.BodySetForce(Body, 0, 0, 0);
+                            enableBodySoft();
+                        }
+
+                        // 35x10 = 350n times the mass per second applied maximum.
+                        float nmax = 35f * m_mass;
+                        float nmin = -35f * m_mass;
+                    
+                        if (fx > nmax)
+                            fx = nmax;
+                        if (fx < nmin)
+                            fx = nmin;
+                        if (fy > nmax)
+                            fy = nmax;
+                        if (fy < nmin)
+                            fy = nmin;
+                        d.BodyAddForce(Body, fx, fy, fz);
+//Console.WriteLine("AddForce " + fx + "," + fy + "," + fz);
+                    }
+                }
+            }
+            else
+            {    // is not physical, or is not a body or is selected
+              //  _zeroPosition = d.BodyGetPosition(Body);
+                return;
+//Console.WriteLine("Nothing " +  Name);
+               
+            }
+        }
+
+        private void rotate()
+        {
+            d.Quaternion myrot = new d.Quaternion();
+            myrot.X = _orientation.X;
+            myrot.Y = _orientation.Y;
+            myrot.Z = _orientation.Z;
+            myrot.W = _orientation.W;
+            if (Body != IntPtr.Zero)
+            {
+                // KF: If this is a root prim do BodySet
+                d.BodySetQuaternion(Body, ref myrot);
+                if (IsPhysical)
+                {
+                    if (!m_angularlock.ApproxEquals(Vector3.One, 0f))
+                        createAMotor(m_angularlock);
+                }
+            }
+            else
+            {
+                // daughter prim, do Geom set
+                d.GeomSetQuaternion(prim_geom, ref myrot);
+            }
+            
+            resetCollisionAccounting();
+            m_taintrot = _orientation;
+        }
+
+        private void resetCollisionAccounting()
+        {
+            m_collisionscore = 0;
+            m_interpenetrationcount = 0;
+            m_disabled = false;
+        }
+
+        /// <summary>
+        /// Change prim in response to a disable taint.
+        /// </summary>
+        private void changedisable()
+        {
+            m_disabled = true;
+            if (Body != IntPtr.Zero)
+            {
+                d.BodyDisable(Body);
+                Body = IntPtr.Zero;
+            }
+
+            m_taintdisable = false;
+        }
+
+        /// <summary>
+        /// Change prim in response to a physics status taint
+        /// </summary>
+        private void changePhysicsStatus()
+        {
+            if (IsPhysical)
+            {
+                if (Body == IntPtr.Zero)
+                {
+                    if (_pbs.SculptEntry && _parent_scene.meshSculptedPrim)
+                    {
+                        changeshape();
+                    }
+                    else
+                    {
+                        enableBody();
+                    }
+                }
+            }
+            else
+            {
+                if (Body != IntPtr.Zero)
+                {
+                    if (_pbs.SculptEntry && _parent_scene.meshSculptedPrim)
+                    {
+                        RemoveGeom();
+
+//Console.WriteLine("changePhysicsStatus for " + Name);
+                        changeadd();
+                    }
+
+                    if (childPrim)
+                    {
+                        if (_parent != null)
+                        {
+                            OdePrim parent = (OdePrim)_parent;
+                            parent.ChildDelink(this);
+                        }
+                    }
+                    else
+                    {
+                        disableBody();
+                    }
+                }
+            }
+
+            changeSelectedStatus();
+
+            resetCollisionAccounting();
+            m_taintPhysics = IsPhysical;
+        }
+
+        /// <summary>
+        /// Change prim in response to a size taint.
+        /// </summary>
+        private void changesize()
+        {
+#if SPAM
+            m_log.DebugFormat("[ODE PRIM]: Called changesize");
+#endif
+
+            if (_size.X <= 0) _size.X = 0.01f;
+            if (_size.Y <= 0) _size.Y = 0.01f;
+            if (_size.Z <= 0) _size.Z = 0.01f;
+
+            //kill body to rebuild
+            if (IsPhysical && Body != IntPtr.Zero)
+            {
+                if (childPrim)
+                {
+                    if (_parent != null)
+                    {
+                        OdePrim parent = (OdePrim)_parent;
+                        parent.ChildDelink(this);
+                    }
+                }
+                else
+                {
+                    disableBody();
+                }
+            }
+
+            if (d.SpaceQuery(m_targetSpace, prim_geom))
+            {
+//                _parent_scene.waitForSpaceUnlock(m_targetSpace);
+                d.SpaceRemove(m_targetSpace, prim_geom);
+            }
+
+            RemoveGeom();
+
+            // we don't need to do space calculation because the client sends a position update also.
+
+            IMesh mesh = null;
+
+            // Construction of new prim
+            if (_parent_scene.needsMeshing(_pbs))
+            {
+                float meshlod = _parent_scene.meshSculptLOD;
+
+                if (IsPhysical)
+                    meshlod = _parent_scene.MeshSculptphysicalLOD;
+                // Don't need to re-enable body..   it's done in SetMesh
+
+                if (_parent_scene.needsMeshing(_pbs))
+                {
+                    mesh = _parent_scene.mesher.CreateMesh(Name, _pbs, _size, meshlod, IsPhysical);
+                    if (mesh == null)
+                        CheckMeshAsset();
+                    else
+                        m_assetFailed = false;
+                }
+                    
+            }
+
+            CreateGeom(m_targetSpace, mesh);
+            d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
+            d.Quaternion myrot = new d.Quaternion();
+            myrot.X = _orientation.X;
+            myrot.Y = _orientation.Y;
+            myrot.Z = _orientation.Z;
+            myrot.W = _orientation.W;
+            d.GeomSetQuaternion(prim_geom, ref myrot);
+
+            //d.GeomBoxSetLengths(prim_geom, _size.X, _size.Y, _size.Z);
+            if (IsPhysical && Body == IntPtr.Zero && !childPrim)
+            {
+                // Re creates body on size.
+                // EnableBody also does setMass()
+                enableBody();
+                d.BodyEnable(Body);
+            }
+
+            changeSelectedStatus();
+
+            if (childPrim)
+            {
+                if (_parent is OdePrim)
+                {
+                    OdePrim parent = (OdePrim)_parent;
+                    parent.ChildSetGeom(this);
+                }
+            }
+            resetCollisionAccounting();
+            m_taintsize = _size;
+        }
+
+        /// <summary>
+        /// Change prim in response to a float on water taint.
+        /// </summary>
+        /// <param name="timestep"></param>
+        private void changefloatonwater()
+        {
+            m_collidesWater = m_taintCollidesWater;
+
+            if (m_collidesWater)
+            {
+                m_collisionFlags |= CollisionCategories.Water;
+            }
+            else
+            {
+                m_collisionFlags &= ~CollisionCategories.Water;
+            }
+
+            if (m_assetFailed)
+                d.GeomSetCollideBits(prim_geom, BadMeshAssetCollideBits);
+            else
+
+                d.GeomSetCollideBits(prim_geom, (int)m_collisionFlags);
+        }
+        /// <summary>
+        /// Change prim in response to a shape taint.
+        /// </summary>
+        private void changeshape()
+        {
+            m_taintshape = false;
+
+            // Cleanup of old prim geometry and Bodies
+            if (IsPhysical && Body != IntPtr.Zero)
+            {
+                if (childPrim)
+                {
+                    if (_parent != null)
+                    {
+                        OdePrim parent = (OdePrim)_parent;
+                        parent.ChildDelink(this);
+                    }
+                }
+                else
+                {
+                    disableBody();
+                }
+            }
+
+            RemoveGeom();
+
+            // we don't need to do space calculation because the client sends a position update also.
+            if (_size.X <= 0) _size.X = 0.01f;
+            if (_size.Y <= 0) _size.Y = 0.01f;
+            if (_size.Z <= 0) _size.Z = 0.01f;
+            // Construction of new prim
+
+            IMesh mesh = null;
+
+
+            if (_parent_scene.needsMeshing(_pbs))
+            {
+                // Don't need to re-enable body..   it's done in CreateMesh
+                float meshlod = _parent_scene.meshSculptLOD;
+
+                if (IsPhysical)
+                    meshlod = _parent_scene.MeshSculptphysicalLOD;
+
+                // createmesh returns null when it doesn't mesh.
+                mesh = _parent_scene.mesher.CreateMesh(Name, _pbs, _size, meshlod, IsPhysical);
+                if (mesh == null)
+                    CheckMeshAsset();
+                else
+                    m_assetFailed = false;
+            }
+
+            CreateGeom(m_targetSpace, mesh);
+            d.GeomSetPosition(prim_geom, _position.X, _position.Y, _position.Z);
+            d.Quaternion myrot = new d.Quaternion();
+            //myrot.W = _orientation.w;
+            myrot.W = _orientation.W;
+            myrot.X = _orientation.X;
+            myrot.Y = _orientation.Y;
+            myrot.Z = _orientation.Z;
+            d.GeomSetQuaternion(prim_geom, ref myrot);
+
+            //d.GeomBoxSetLengths(prim_geom, _size.X, _size.Y, _size.Z);
+            if (IsPhysical && Body == IntPtr.Zero)
+            {
+                // Re creates body on size.
+                // EnableBody also does setMass()
+                enableBody();
+                if (Body != IntPtr.Zero)
+                {
+                    d.BodyEnable(Body);
+                }
+            }
+
+            changeSelectedStatus();
+
+            if (childPrim)
+            {
+                if (_parent is OdePrim)
+                {
+                    OdePrim parent = (OdePrim)_parent;
+                    parent.ChildSetGeom(this);
+                }
+            }
+
+            resetCollisionAccounting();
+//            m_taintshape = false;
+        }
+
+        /// <summary>
+        /// Change prim in response to an add force taint.
+        /// </summary>
+        private void changeAddForce()
+        {
+            if (!m_isSelected)
+            {
+                lock (m_forcelist)
+                {
+                    //m_log.Info("[PHYSICS]: dequeing forcelist");
+                    if (IsPhysical)
+                    {
+                        Vector3 iforce = Vector3.Zero;
+                        int i = 0;
+                        try
+                        {
+                            for (i = 0; i < m_forcelist.Count; i++)
+                            {
+
+                                iforce = iforce + (m_forcelist[i] * 100);
+                            }
+                        }
+                        catch (IndexOutOfRangeException)
+                        {
+                            m_forcelist = new List<Vector3>();
+                            m_collisionscore = 0;
+                            m_interpenetrationcount = 0;
+                            m_taintforce = false;
+                            return;
+                        }
+                        catch (ArgumentOutOfRangeException)
+                        {
+                            m_forcelist = new List<Vector3>();
+                            m_collisionscore = 0;
+                            m_interpenetrationcount = 0;
+                            m_taintforce = false;
+                            return;
+                        }
+                        d.BodyEnable(Body);
+                        d.BodyAddForce(Body, iforce.X, iforce.Y, iforce.Z);
+                    }
+                    m_forcelist.Clear();
+                }
+
+                m_collisionscore = 0;
+                m_interpenetrationcount = 0;
+            }
+
+            m_taintforce = false;
+        }
+
+        /// <summary>
+        /// Change prim in response to a torque taint.
+        /// </summary>
+        private void changeSetTorque()
+        {
+            if (!m_isSelected)
+            {
+                if (IsPhysical && Body != IntPtr.Zero)
+                {
+                    d.BodySetTorque(Body, m_taintTorque.X, m_taintTorque.Y, m_taintTorque.Z);
+                }
+            }
+
+            m_taintTorque = Vector3.Zero;
+        }
+
+        /// <summary>
+        /// Change prim in response to an angular force taint.
+        /// </summary>
+        private void changeAddAngularForce()
+        {
+            if (!m_isSelected)
+            {
+                lock (m_angularforcelist)
+                {
+                    //m_log.Info("[PHYSICS]: dequeing forcelist");
+                    if (IsPhysical)
+                    {
+                        Vector3 iforce = Vector3.Zero;
+                        for (int i = 0; i < m_angularforcelist.Count; i++)
+                        {
+                            iforce = iforce + (m_angularforcelist[i] * 100);
+                        }
+                        d.BodyEnable(Body);
+                        d.BodyAddTorque(Body, iforce.X, iforce.Y, iforce.Z);
+                        
+                    }
+                    m_angularforcelist.Clear();
+                }
+
+                m_collisionscore = 0;
+                m_interpenetrationcount = 0;
+            }
+
+            m_taintaddangularforce = false;
+        }
+
+        /// <summary>
+        /// Change prim in response to a velocity taint.
+        /// </summary>
+        private void changevelocity()
+        {
+            if (!m_isSelected)
+            {
+                // Not sure exactly why this sleep is here, but from experimentation it appears to stop an avatar
+                // walking through a default rez size prim if it keeps kicking it around - justincc.
+                Thread.Sleep(20);
+
+                if (IsPhysical)
+                {
+                    if (Body != IntPtr.Zero)
+                    {
+                        d.BodySetLinearVel(Body, m_taintVelocity.X, m_taintVelocity.Y, m_taintVelocity.Z);
+                    }
+                }
+                
+                //resetCollisionAccounting();
+            }
+
+            m_taintVelocity = Vector3.Zero;
+        }
+
+        internal void setPrimForRemoval()
+        {
+            m_taintremove = true;
+        }
+
+        public override bool Flying
+        {
+            // no flying prims for you
+            get { return false; }
+            set { }
+        }
+
+        public override bool IsColliding
+        {
+            get { return iscolliding; }
+            set { iscolliding = value; }
+        }
+
+        public override bool CollidingGround
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool CollidingObj
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool ThrottleUpdates
+        {
+            get { return m_throttleUpdates; }
+            set { m_throttleUpdates = value; }
+        }
+
+        public override bool Stopped
+        {
+            get { return _zeroFlag; }
+        }
+
+        public override Vector3 Position
+        {
+            get { return _position; }
+
+            set { _position = value;
+                //m_log.Info("[PHYSICS]: " + _position.ToString());
+            }
+        }
+
+        public override Vector3 Size
+        {
+            get { return _size; }
+            set
+            {
+                if (value.IsFinite())
+                {
+                    _size = value;
+//                    m_log.DebugFormat("[PHYSICS]: Set size on {0} to {1}", Name, value);
+                }
+                else
+                {
+                    m_log.WarnFormat("[PHYSICS]: Got NaN Size on object {0}", Name);
+                }
+            }
+        }
+
+        public override float Mass
+        {
+            get { return CalculateMass(); }
+        }
+
+        public override Vector3 Force
+        {
+            //get { return Vector3.Zero; }
+            get { return m_force; }
+            set
+            {
+                if (value.IsFinite())
+                {
+                    m_force = value;
+                }
+                else
+                {
+                    m_log.WarnFormat("[PHYSICS]: NaN in Force Applied to an Object {0}", Name);
+                }
+            }
+        }
+
+        public override int VehicleType
+        {
+            get { return (int)m_vehicle.Type; }
+            set { m_vehicle.ProcessTypeChange((Vehicle)value); }
+        }
+
+        public override void VehicleFloatParam(int param, float value)
+        {
+            m_vehicle.ProcessFloatVehicleParam((Vehicle) param, value);
+        }
+
+        public override void VehicleVectorParam(int param, Vector3 value)
+        {
+            m_vehicle.ProcessVectorVehicleParam((Vehicle) param, value);
+        }
+
+        public override void VehicleRotationParam(int param, Quaternion rotation)
+        {
+            m_vehicle.ProcessRotationVehicleParam((Vehicle) param, rotation);
+        }
+
+        public override void VehicleFlags(int param, bool remove)
+        {
+            m_vehicle.ProcessVehicleFlags(param, remove);
+        }
+
+        public override void SetVolumeDetect(int param)
+        {
+            // We have to lock the scene here so that an entire simulate loop either uses volume detect for all
+            // possible collisions with this prim or for none of them.
+            lock (_parent_scene.OdeLock)
+            {
+                m_isVolumeDetect = (param != 0);
+            }
+        }
+
+        public override Vector3 CenterOfMass
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override Vector3 GeometricCenter
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override PrimitiveBaseShape Shape
+        {
+            set
+            {
+                _pbs = value;
+                m_assetFailed = false;
+                m_taintshape = true;
+            }
+        }
+
+        public override Vector3 Velocity
+        {
+            get
+            {
+                // Average previous velocity with the new one so
+                // client object interpolation works a 'little' better
+                if (_zeroFlag)
+                    return Vector3.Zero;
+
+                Vector3 returnVelocity = Vector3.Zero;
+                returnVelocity.X = (m_lastVelocity.X + _velocity.X) * 0.5f; // 0.5f is mathematically equiv to '/ 2'
+                returnVelocity.Y = (m_lastVelocity.Y + _velocity.Y) * 0.5f;
+                returnVelocity.Z = (m_lastVelocity.Z + _velocity.Z) * 0.5f;
+                return returnVelocity;
+            }
+            set
+            {
+                if (value.IsFinite())
+                {
+                    _velocity = value;
+
+                    m_taintVelocity = value;
+                    _parent_scene.AddPhysicsActorTaint(this);
+                }
+                else
+                {
+                    m_log.WarnFormat("[PHYSICS]: Got NaN Velocity in Object {0}", Name);
+                }
+
+            }
+        }
+
+        public override Vector3 Torque
+        {
+            get
+            {
+                if (!IsPhysical || Body == IntPtr.Zero)
+                    return Vector3.Zero;
+
+                return _torque;
+            }
+
+            set
+            {
+                if (value.IsFinite())
+                {
+                    m_taintTorque = value;
+                    _parent_scene.AddPhysicsActorTaint(this);
+                }
+                else
+                {
+                    m_log.WarnFormat("[PHYSICS]: Got NaN Torque in Object {0}", Name);
+                }
+            }
+        }
+
+        public override float CollisionScore
+        {
+            get { return m_collisionscore; }
+            set { m_collisionscore = value; }
+        }
+
+        public override bool Kinematic
+        {
+            get { return false; }
+            set { }
+        }
+
+        public override Quaternion Orientation
+        {
+            get { return _orientation; }
+            set
+            {
+                if (QuaternionIsFinite(value))
+                    _orientation = value;
+                else
+                    m_log.WarnFormat("[PHYSICS]: Got NaN quaternion Orientation from Scene in Object {0}", Name);
+            }
+        }
+
+        private static bool QuaternionIsFinite(Quaternion q)
+        {
+            if (Single.IsNaN(q.X) || Single.IsInfinity(q.X))
+                return false;
+            if (Single.IsNaN(q.Y) || Single.IsInfinity(q.Y))
+                return false;
+            if (Single.IsNaN(q.Z) || Single.IsInfinity(q.Z))
+                return false;
+            if (Single.IsNaN(q.W) || Single.IsInfinity(q.W))
+                return false;
+            return true;
+        }
+
+        public override Vector3 Acceleration
+        {
+            get { return _acceleration; }
+            set { _acceleration = value; }
+        }
+
+        public override void AddForce(Vector3 force, bool pushforce)
+        {
+            if (force.IsFinite())
+            {
+                lock (m_forcelist)
+                    m_forcelist.Add(force);
+
+                m_taintforce = true;
+            }
+            else
+            {
+                m_log.WarnFormat("[PHYSICS]: Got Invalid linear force vector from Scene in Object {0}", Name);
+            }
+            //m_log.Info("[PHYSICS]: Added Force:" + force.ToString() +  " to prim at " + Position.ToString());
+        }
+
+        public override void AddAngularForce(Vector3 force, bool pushforce)
+        {
+            if (force.IsFinite())
+            {
+                m_angularforcelist.Add(force);
+                m_taintaddangularforce = true;
+            }
+            else
+            {
+                m_log.WarnFormat("[PHYSICS]: Got Invalid Angular force vector from Scene in Object {0}", Name);
+            }
+        }
+
+        public override Vector3 RotationalVelocity
+        {
+            get
+            {
+                Vector3 pv = Vector3.Zero;
+                if (_zeroFlag)
+                    return pv;
+                m_lastUpdateSent = false;
+
+                if (m_rotationalVelocity.ApproxEquals(pv, 0.2f))
+                    return pv;
+
+                return m_rotationalVelocity;
+            }
+            set
+            {
+                if (value.IsFinite())
+                {
+                    m_rotationalVelocity = value;
+                    setAngularVelocity(value.X, value.Y, value.Z);
+                }
+                else
+                {
+                    m_log.WarnFormat("[PHYSICS]: Got NaN RotationalVelocity in Object {0}", Name);
+                }
+            }
+        }
+
+        public override void CrossingFailure()
+        {
+            /*
+                        m_crossingfailures++;
+                        if (m_crossingfailures > _parent_scene.geomCrossingFailuresBeforeOutofbounds)
+                        {
+                            base.RaiseOutOfBounds(_position);
+                            return;
+                        }
+                        else if (m_crossingfailures == _parent_scene.geomCrossingFailuresBeforeOutofbounds)
+                        {
+                            m_log.Warn("[PHYSICS]: Too many crossing failures for: " + Name);
+                        }
+            */
+            _position.X = Util.Clip(_position.X, 0.5f, _parent_scene.WorldExtents.X - 0.5f);
+            _position.Y = Util.Clip(_position.Y, 0.5f, _parent_scene.WorldExtents.Y - 0.5f);
+            _position.Z = Util.Clip(_position.Z + 0.2f, -100f, 50000f);
+
+            m_lastposition = _position;
+            _velocity.X = 0;
+            _velocity.Y = 0;
+            _velocity.Z = 0;
+
+            m_lastVelocity = _velocity;
+
+            if (Body != IntPtr.Zero)
+            {
+                d.BodySetLinearVel(Body, 0, 0, 0); // stop it
+                d.BodySetPosition(Body, _position.X, _position.Y, _position.Z);
+            }
+
+            outofBounds = false;
+            base.RequestPhysicsterseUpdate();
+
+        }
+
+        public override float Buoyancy
+        {
+            get { return m_buoyancy; }
+            set { m_buoyancy = value; }
+        }
+
+        public override void link(PhysicsActor obj)
+        {
+            m_taintparent = obj;
+        }
+
+        public override void delink()
+        {
+            m_taintparent = null;
+        }
+
+        public override void LockAngularMotion(Vector3 axis)
+        {
+            // reverse the zero/non zero values for ODE.
+            if (axis.IsFinite())
+            {
+                axis.X = (axis.X > 0) ? 1f : 0f;
+                axis.Y = (axis.Y > 0) ? 1f : 0f;
+                axis.Z = (axis.Z > 0) ? 1f : 0f;
+                m_log.DebugFormat("[axislock]: <{0},{1},{2}>", axis.X, axis.Y, axis.Z);
+                m_taintAngularLock = axis;
+            }
+            else
+            {
+                m_log.WarnFormat("[PHYSICS]: Got NaN locking axis from Scene on Object {0}", Name);
+            }
+        }
+
+        internal void UpdatePositionAndVelocity()
+        {
+            //  no lock; called from Simulate() -- if you call this from elsewhere, gotta lock or do Monitor.Enter/Exit!
+            if (outofBounds)
+                return;
+            if (_parent == null)
+            {
+                Vector3 pv = Vector3.Zero;
+                bool lastZeroFlag = _zeroFlag;
+                float m_minvelocity = 0;
+                if (Body != (IntPtr)0) // FIXME -> or if it is a joint
+                {
+                    d.Vector3 vec = d.BodyGetPosition(Body);
+                    d.Quaternion ori = d.BodyGetQuaternion(Body);
+                    d.Vector3 vel = d.BodyGetLinearVel(Body);
+                    d.Vector3 rotvel = d.BodyGetAngularVel(Body);
+                    d.Vector3 torque = d.BodyGetTorque(Body);
+                    _torque = new Vector3(torque.X, torque.Y, torque.Z);
+                    Vector3 l_position = Vector3.Zero;
+                    Quaternion l_orientation = Quaternion.Identity;
+
+                    m_lastposition = _position;
+                    m_lastorientation = _orientation;
+
+                    l_position.X = vec.X;
+                    l_position.Y = vec.Y;
+                    l_position.Z = vec.Z;
+                    l_orientation.X = ori.X;
+                    l_orientation.Y = ori.Y;
+                    l_orientation.Z = ori.Z;
+                    l_orientation.W = ori.W;
+
+                    if (l_position.Z < 0)
+                    {
+                        // This is so prim that get lost underground don't fall forever and suck up
+                        //
+                        // Sim resources and memory.
+                        // Disables the prim's movement physics....
+                        // It's a hack and will generate a console message if it fails.
+
+                        //IsPhysical = false;
+
+                        _acceleration.X = 0;
+                        _acceleration.Y = 0;
+                        _acceleration.Z = 0;
+
+                        _velocity.X = 0;
+                        _velocity.Y = 0;
+                        _velocity.Z = 0;
+                        m_rotationalVelocity.X = 0;
+                        m_rotationalVelocity.Y = 0;
+                        m_rotationalVelocity.Z = 0;
+
+                        if (_parent == null)
+                            base.RaiseOutOfBounds(_position);
+
+                        if (_parent == null)
+                            base.RequestPhysicsterseUpdate();
+
+                        m_throttleUpdates = false;
+                        throttleCounter = 0;
+                        _zeroFlag = true;
+                        //outofBounds = true;
+                        return;
+                    }
+
+                    if (l_position.X > ((int)_parent_scene.WorldExtents.X - 0.05f) || l_position.X < 0f || l_position.Y > ((int)_parent_scene.WorldExtents.Y - 0.05f) || l_position.Y < 0f)
+                    {
+                        //base.RaiseOutOfBounds(l_position);
+                        /*
+                                                if (m_crossingfailures < _parent_scene.geomCrossingFailuresBeforeOutofbounds)
+                                                {
+                                                    _position = l_position;
+                                                    //_parent_scene.remActivePrim(this);
+                                                    if (_parent == null)
+                                                        base.RequestPhysicsterseUpdate();
+                                                    return;
+                                                }
+                                                else
+                                                {
+                                                    if (_parent == null)
+                                                        base.RaiseOutOfBounds(l_position);
+                                                    return;
+                                                }
+                        */
+                        outofBounds = true;
+                        // part near the border on outside
+                        if (l_position.X < 0)
+                            Util.Clamp(l_position.X, -0.1f, -2f);
+                        else
+                            Util.Clamp(l_position.X, _parent_scene.WorldExtents.X + 0.1f, _parent_scene.WorldExtents.X + 2f);
+                        if (l_position.Y < 0)
+                            Util.Clamp(l_position.Y, -0.1f, -2f);
+                        else
+                            Util.Clamp(l_position.Y, _parent_scene.WorldExtents.Y + 0.1f, _parent_scene.WorldExtents.Y + 2f);
+
+                        d.BodySetPosition(Body, l_position.X, l_position.Y, l_position.Z);
+
+                        // stop it
+                        d.BodySetAngularVel(Body, 0, 0, 0);
+                        d.BodySetLinearVel(Body, 0, 0, 0);
+                        disableBodySoft();
+
+                        // tell framework to fix it
+                        if (_parent == null)
+                            base.RequestPhysicsterseUpdate();
+                        return;
+                    }
+
+
+                    //float Adiff = 1.0f - Math.Abs(Quaternion.Dot(m_lastorientation, l_orientation));
+                    //Console.WriteLine("Adiff " + Name + " = " + Adiff);
+                    if ((Math.Abs(m_lastposition.X - l_position.X) < 0.02)
+                        && (Math.Abs(m_lastposition.Y - l_position.Y) < 0.02)
+                        && (Math.Abs(m_lastposition.Z - l_position.Z) < 0.02)
+//                        && (1.0 - Math.Abs(Quaternion.Dot(m_lastorientation, l_orientation)) < 0.01))
+                        && (1.0 - Math.Abs(Quaternion.Dot(m_lastorientation, l_orientation)) < 0.0001))  // KF 0.01 is far to large
+                    {
+                        _zeroFlag = true;
+//Console.WriteLine("ZFT 2");
+                        m_throttleUpdates = false;
+                    }
+                    else
+                    {
+                        //m_log.Debug(Math.Abs(m_lastposition.X - l_position.X).ToString());
+                        _zeroFlag = false;
+                        m_lastUpdateSent = false;
+                        //m_throttleUpdates = false;
+                    }
+
+                    if (_zeroFlag)
+                    {
+                        _velocity.X = 0.0f;
+                        _velocity.Y = 0.0f;
+                        _velocity.Z = 0.0f;
+
+                        _acceleration.X = 0;
+                        _acceleration.Y = 0;
+                        _acceleration.Z = 0;
+
+                        //_orientation.w = 0f;
+                        //_orientation.X = 0f;
+                        //_orientation.Y = 0f;
+                        //_orientation.Z = 0f;
+                        m_rotationalVelocity.X = 0;
+                        m_rotationalVelocity.Y = 0;
+                        m_rotationalVelocity.Z = 0;
+                        if (!m_lastUpdateSent)
+                        {
+                            m_throttleUpdates = false;
+                            throttleCounter = 0;
+                            m_rotationalVelocity = pv;
+
+                            if (_parent == null)
+                            {
+                                base.RequestPhysicsterseUpdate();
+                            }
+
+                            m_lastUpdateSent = true;
+                        }
+                    }
+                    else
+                    {
+                        if (lastZeroFlag != _zeroFlag)
+                        {
+                            if (_parent == null)
+                            {
+                                base.RequestPhysicsterseUpdate();
+                            }
+                        }
+
+                        m_lastVelocity = _velocity;
+
+                        _position = l_position;
+
+                        _velocity.X = vel.X;
+                        _velocity.Y = vel.Y;
+                        _velocity.Z = vel.Z;
+
+                        _acceleration = ((_velocity - m_lastVelocity) / 0.1f);
+                        _acceleration = new Vector3(_velocity.X - m_lastVelocity.X / 0.1f, _velocity.Y - m_lastVelocity.Y / 0.1f, _velocity.Z - m_lastVelocity.Z / 0.1f);
+                        //m_log.Info("[PHYSICS]: V1: " + _velocity + " V2: " + m_lastVelocity + " Acceleration: " + _acceleration.ToString());
+                       
+                        // Note here that linearvelocity is affecting angular velocity...  so I'm guessing this is a vehicle specific thing... 
+                        // it does make sense to do this for tiny little instabilities with physical prim, however 0.5m/frame is fairly large. 
+                        // reducing this to 0.02m/frame seems to help the angular rubberbanding quite a bit, however, to make sure it doesn't affect elevators and vehicles
+                        // adding these logical exclusion situations to maintain this where I think it was intended to be.
+                        if (m_throttleUpdates || PIDActive || (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE) || (Amotor != IntPtr.Zero)) 
+                        {
+                            m_minvelocity = 0.5f;
+                        }
+                        else
+                        {
+                            m_minvelocity = 0.02f;
+                        }
+
+                        if (_velocity.ApproxEquals(pv, m_minvelocity))
+                        {
+                            m_rotationalVelocity = pv;
+                        }
+                        else
+                        {
+                            m_rotationalVelocity = new Vector3(rotvel.X, rotvel.Y, rotvel.Z);
+                        }
+
+                        //m_log.Debug("ODE: " + m_rotationalVelocity.ToString());
+                        _orientation.X = ori.X;
+                        _orientation.Y = ori.Y;
+                        _orientation.Z = ori.Z;
+                        _orientation.W = ori.W;
+                        m_lastUpdateSent = false;
+                        if (!m_throttleUpdates || throttleCounter > _parent_scene.geomUpdatesPerThrottledUpdate)
+                        {
+                            if (_parent == null)
+                            {
+                                base.RequestPhysicsterseUpdate();
+                            }
+                        }
+                        else
+                        {
+                            throttleCounter++;
+                        }
+                    }
+                    m_lastposition = l_position;
+                }
+                else
+                {
+                    // Not a body..   so Make sure the client isn't interpolating
+                    _velocity.X = 0;
+                    _velocity.Y = 0;
+                    _velocity.Z = 0;
+
+                    _acceleration.X = 0;
+                    _acceleration.Y = 0;
+                    _acceleration.Z = 0;
+
+                    m_rotationalVelocity.X = 0;
+                    m_rotationalVelocity.Y = 0;
+                    m_rotationalVelocity.Z = 0;
+                    _zeroFlag = true;
+                }
+            }
+        }
+
+        public override bool FloatOnWater
+        {
+            set {
+                m_taintCollidesWater = value;
+                _parent_scene.AddPhysicsActorTaint(this);
+            }
+        }
+
+        public override void SetMomentum(Vector3 momentum)
+        {
+        }
+
+        public override Vector3 PIDTarget 
+        { 
+            set
+            {
+                if (value.IsFinite())
+                {
+                    m_PIDTarget = value;
+                }
+                else
+                    m_log.WarnFormat("[PHYSICS]: Got NaN PIDTarget from Scene on Object {0}", Name);
+            } 
+        }
+
+        public override bool PIDActive { get; set; }
+        public override float PIDTau { set { m_PIDTau = value; } }
+
+        public override float PIDHoverHeight { set { m_PIDHoverHeight = value; ; } }
+        public override bool PIDHoverActive { set { m_useHoverPID = value; } }
+        public override PIDHoverType PIDHoverType { set { m_PIDHoverType = value; } }
+        public override float PIDHoverTau { set { m_PIDHoverTau = value; } }
+        
+        public override Quaternion APIDTarget{ set { return; } }
+
+        public override bool APIDActive{ set { return; } }
+
+        public override float APIDStrength{ set { return; } }
+
+        public override float APIDDamping{ set { return; } }
+
+        private void createAMotor(Vector3 axis)
+        {
+            if (Body == IntPtr.Zero)
+                return;
+
+            if (Amotor != IntPtr.Zero)
+            {
+                d.JointDestroy(Amotor);
+                Amotor = IntPtr.Zero;
+            }
+
+            float axisnum = 3;
+
+            axisnum = (axisnum - (axis.X + axis.Y + axis.Z));
+
+            // PhysicsVector totalSize = new PhysicsVector(_size.X, _size.Y, _size.Z);
+
+            
+            // Inverse Inertia Matrix, set the X, Y, and/r Z inertia to 0 then invert it again.
+            d.Mass objMass;
+            d.MassSetZero(out objMass);
+            DMassCopy(ref pMass, ref objMass);
+
+            //m_log.DebugFormat("1-{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, ", objMass.I.M00, objMass.I.M01, objMass.I.M02, objMass.I.M10, objMass.I.M11, objMass.I.M12, objMass.I.M20, objMass.I.M21, objMass.I.M22);
+
+            Matrix4 dMassMat = FromDMass(objMass);
+
+            Matrix4 mathmat = Inverse(dMassMat);
+
+            /*
+            //m_log.DebugFormat("2-{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, ", mathmat[0, 0], mathmat[0, 1], mathmat[0, 2], mathmat[1, 0], mathmat[1, 1], mathmat[1, 2], mathmat[2, 0], mathmat[2, 1], mathmat[2, 2]);
+
+            mathmat = Inverse(mathmat);
+
+
+            objMass = FromMatrix4(mathmat, ref objMass);
+            //m_log.DebugFormat("3-{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, ", objMass.I.M00, objMass.I.M01, objMass.I.M02, objMass.I.M10, objMass.I.M11, objMass.I.M12, objMass.I.M20, objMass.I.M21, objMass.I.M22);
+
+            mathmat = Inverse(mathmat);
+            */
+            if (axis.X == 0)
+            {
+                mathmat.M33 = 50.0000001f;
+                //objMass.I.M22 = 0;
+            }
+            if (axis.Y == 0)
+            {
+                mathmat.M22 = 50.0000001f;
+                //objMass.I.M11 = 0;
+            }
+            if (axis.Z == 0)
+            {
+                mathmat.M11 = 50.0000001f;
+                //objMass.I.M00 = 0;
+            }
+            
+            
+
+            mathmat = Inverse(mathmat);
+            objMass = FromMatrix4(mathmat, ref objMass);
+            //m_log.DebugFormat("4-{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, ", objMass.I.M00, objMass.I.M01, objMass.I.M02, objMass.I.M10, objMass.I.M11, objMass.I.M12, objMass.I.M20, objMass.I.M21, objMass.I.M22);
+           
+            //return;
+            if (d.MassCheck(ref objMass))
+            {
+                d.BodySetMass(Body, ref objMass);
+            }
+            else
+            {
+                //m_log.Debug("[PHYSICS]: Mass invalid, ignoring");
+            }
+
+            if (axisnum <= 0)
+                return;
+            // int dAMotorEuler = 1;
+
+            Amotor = d.JointCreateAMotor(_parent_scene.world, IntPtr.Zero);
+            d.JointAttach(Amotor, Body, IntPtr.Zero);
+            d.JointSetAMotorMode(Amotor, 0);
+
+            d.JointSetAMotorNumAxes(Amotor,(int)axisnum);
+            int i = 0;
+
+            if (axis.X == 0)
+            {
+                d.JointSetAMotorAxis(Amotor, i, 0, 1, 0, 0);
+                i++;
+            }
+
+            if (axis.Y == 0)
+            {
+                d.JointSetAMotorAxis(Amotor, i, 0, 0, 1, 0);
+                i++;
+            }
+
+            if (axis.Z == 0)
+            {
+                d.JointSetAMotorAxis(Amotor, i, 0, 0, 0, 1);
+                i++;
+            }
+
+            for (int j = 0; j < (int)axisnum; j++)
+            {
+                //d.JointSetAMotorAngle(Amotor, j, 0);
+            }
+
+            //d.JointSetAMotorAngle(Amotor, 1, 0);
+            //d.JointSetAMotorAngle(Amotor, 2, 0);
+
+            // These lowstops and high stops are effectively (no wiggle room)
+            d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, -0f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, -0f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, -0f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.HiStop, 0f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 0f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, 0f);
+            //d.JointSetAMotorParam(Amotor, (int) dParam.Vel, 9000f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.FudgeFactor, 0f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.FMax, Mass * 50f);//
+        }
+
+        private Matrix4 FromDMass(d.Mass pMass)
+        {
+            Matrix4 obj;
+            obj.M11 = pMass.I.M00;
+            obj.M12 = pMass.I.M01;
+            obj.M13 = pMass.I.M02;
+            obj.M14 = 0;
+            obj.M21 = pMass.I.M10;
+            obj.M22 = pMass.I.M11;
+            obj.M23 = pMass.I.M12;
+            obj.M24 = 0;
+            obj.M31 = pMass.I.M20;
+            obj.M32 = pMass.I.M21;
+            obj.M33 = pMass.I.M22;
+            obj.M34 = 0;
+            obj.M41 = 0;
+            obj.M42 = 0;
+            obj.M43 = 0;
+            obj.M44 = 1;
+            return obj;
+        }
+
+        private d.Mass FromMatrix4(Matrix4 pMat, ref d.Mass obj)
+        {
+            obj.I.M00 = pMat[0, 0];
+            obj.I.M01 = pMat[0, 1];
+            obj.I.M02 = pMat[0, 2];
+            obj.I.M10 = pMat[1, 0];
+            obj.I.M11 = pMat[1, 1];
+            obj.I.M12 = pMat[1, 2];
+            obj.I.M20 = pMat[2, 0];
+            obj.I.M21 = pMat[2, 1];
+            obj.I.M22 = pMat[2, 2];
+            return obj;
+        }
+
+        public override void SubscribeEvents(int ms)
+        {
+            m_eventsubscription = ms;
+            _parent_scene.AddCollisionEventReporting(this);
+        }
+
+        public override void UnSubscribeEvents()
+        {
+            _parent_scene.RemoveCollisionEventReporting(this);
+            m_eventsubscription = 0;
+        }
+
+        public void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
+        {
+            CollisionEventsThisFrame.AddCollider(CollidedWith, contact);
+        }
+
+        public void SendCollisions()
+        {
+            if (m_collisionsOnPreviousFrame || CollisionEventsThisFrame.Count > 0)
+            {
+                base.SendCollisionUpdate(CollisionEventsThisFrame);
+
+                if (CollisionEventsThisFrame.Count > 0)
+                {
+                    m_collisionsOnPreviousFrame = true;
+                    CollisionEventsThisFrame.Clear();
+                }
+                else
+                {
+                    m_collisionsOnPreviousFrame = false;
+                }
+            }
+        }
+
+        public override bool SubscribedEvents()
+        {
+            if (m_eventsubscription > 0)
+                return true;
+            return false;
+        }
+
+        public static Matrix4 Inverse(Matrix4 pMat)
+        {
+            if (determinant3x3(pMat) == 0)
+            {
+                return Matrix4.Identity; // should probably throw an error.  singluar matrix inverse not possible
+            }
+
+            return (Adjoint(pMat) / determinant3x3(pMat));
+        }
+
+        public static Matrix4 Adjoint(Matrix4 pMat)
+        {
+            Matrix4 adjointMatrix = new Matrix4();
+            for (int i=0; i<4; i++)
+            {
+                for (int j=0; j<4; j++)
+                {
+                    Matrix4SetValue(ref adjointMatrix, i, j, (float)(Math.Pow(-1, i + j) * (determinant3x3(Minor(pMat, i, j)))));
+                }
+            }
+
+            adjointMatrix = Transpose(adjointMatrix);
+            return adjointMatrix;
+        }
+
+        public static Matrix4 Minor(Matrix4 matrix, int iRow, int iCol)
+        {
+            Matrix4 minor = new Matrix4();
+            int m = 0, n = 0;
+            for (int i = 0; i < 4; i++)
+            {
+                if (i == iRow)
+                    continue;
+                n = 0;
+                for (int j = 0; j < 4; j++)
+                {
+                    if (j == iCol)
+                        continue;
+                    Matrix4SetValue(ref minor, m,n, matrix[i, j]);
+                    n++;
+                }
+                m++;
+            }
+
+            return minor;
+        }
+
+        public static Matrix4 Transpose(Matrix4 pMat)
+        {
+            Matrix4 transposeMatrix = new Matrix4();
+            for (int i = 0; i < 4; i++)
+                for (int j = 0; j < 4; j++)
+                    Matrix4SetValue(ref transposeMatrix, i, j, pMat[j, i]);
+            return transposeMatrix;
+        }
+
+        public static void Matrix4SetValue(ref Matrix4 pMat, int r, int c, float val)
+        {
+            switch (r)
+            {
+                case 0:
+                    switch (c)
+                    {
+                        case 0:
+                            pMat.M11 = val;
+                            break;
+                        case 1:
+                            pMat.M12 = val;
+                            break;
+                        case 2:
+                            pMat.M13 = val;
+                            break;
+                        case 3:
+                            pMat.M14 = val;
+                            break;
+                    }
+
+                    break;
+                case 1:
+                    switch (c)
+                    {
+                        case 0:
+                            pMat.M21 = val;
+                            break;
+                        case 1:
+                            pMat.M22 = val;
+                            break;
+                        case 2:
+                            pMat.M23 = val;
+                            break;
+                        case 3:
+                            pMat.M24 = val;
+                            break;
+                    }
+
+                    break;
+                case 2:
+                    switch (c)
+                    {
+                        case 0:
+                            pMat.M31 = val;
+                            break;
+                        case 1:
+                            pMat.M32 = val;
+                            break;
+                        case 2:
+                            pMat.M33 = val;
+                            break;
+                        case 3:
+                            pMat.M34 = val;
+                            break;
+                    }
+
+                    break;
+                case 3:
+                    switch (c)
+                    {
+                        case 0:
+                            pMat.M41 = val;
+                            break;
+                        case 1:
+                            pMat.M42 = val;
+                            break;
+                        case 2:
+                            pMat.M43 = val;
+                            break;
+                        case 3:
+                            pMat.M44 = val;
+                            break;
+                    }
+
+                    break;
+            }
+        }
+
+        private static float determinant3x3(Matrix4 pMat)
+        {
+            float det = 0;
+            float diag1 = pMat[0, 0]*pMat[1, 1]*pMat[2, 2];
+            float diag2 = pMat[0, 1]*pMat[2, 1]*pMat[2, 0];
+            float diag3 = pMat[0, 2]*pMat[1, 0]*pMat[2, 1];
+            float diag4 = pMat[2, 0]*pMat[1, 1]*pMat[0, 2];
+            float diag5 = pMat[2, 1]*pMat[1, 2]*pMat[0, 0];
+            float diag6 = pMat[2, 2]*pMat[1, 0]*pMat[0, 1];
+
+            det = diag1 + diag2 + diag3 - (diag4 + diag5 + diag6);
+            return det;
+        }
+        
+        private static void DMassCopy(ref d.Mass src, ref d.Mass dst)
+        {
+            dst.c.W = src.c.W;
+            dst.c.X = src.c.X;
+            dst.c.Y = src.c.Y;
+            dst.c.Z = src.c.Z;
+            dst.mass = src.mass;
+            dst.I.M00 = src.I.M00;
+            dst.I.M01 = src.I.M01;
+            dst.I.M02 = src.I.M02;
+            dst.I.M10 = src.I.M10;
+            dst.I.M11 = src.I.M11;
+            dst.I.M12 = src.I.M12;
+            dst.I.M20 = src.I.M20;
+            dst.I.M21 = src.I.M21;
+            dst.I.M22 = src.I.M22;
+        }
+
+        public override void SetMaterial(int pMaterial)
+        {
+            m_material = pMaterial;
+        }
+
+        private void CheckMeshAsset()
+        {
+            if (_pbs.SculptEntry && !m_assetFailed && _pbs.SculptTexture != UUID.Zero)
+            {
+                m_assetFailed = true;
+                Util.FireAndForget(delegate
+                    {
+                        RequestAssetDelegate assetProvider = _parent_scene.RequestAssetMethod;
+                        if (assetProvider != null)
+                            assetProvider(_pbs.SculptTexture, MeshAssetReceived);
+                    }, null, "ODEPrim.CheckMeshAsset");
+            }
+        }
+
+        private void MeshAssetReceived(AssetBase asset)
+        {
+            if (asset != null && asset.Data != null && asset.Data.Length > 0)
+            {
+                if (!_pbs.SculptEntry)
+                    return;
+                if (_pbs.SculptTexture.ToString() != asset.ID)
+                    return;
+
+                _pbs.SculptData = new byte[asset.Data.Length];
+                asset.Data.CopyTo(_pbs.SculptData, 0);
+//                m_assetFailed = false;
+
+//                m_log.DebugFormat(
+//                    "[ODE PRIM]: Received mesh/sculpt data asset {0} with {1} bytes for {2} at {3} in {4}", 
+//                    _pbs.SculptTexture, _pbs.SculptData.Length, Name, _position, _parent_scene.Name);
+
+                m_taintshape = true;
+               _parent_scene.AddPhysicsActorTaint(this);
+            }
+            else
+            {
+                m_log.WarnFormat(
+                    "[ODE PRIM]: Could not get mesh/sculpt asset {0} for {1} at {2} in {3}",
+                    _pbs.SculptTexture, Name, _position, _parent_scene.PhysicsSceneName);
+            }
+        }          
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/PhysicsModules/Ode/ODERayCastRequestManager.cs b/OpenSim/Region/PhysicsModules/Ode/ODERayCastRequestManager.cs
new file mode 100644
index 0000000..80f0fcf
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Ode/ODERayCastRequestManager.cs
@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using OpenMetaverse;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using Ode.NET;
+using log4net;
+
+namespace OpenSim.Region.PhysicsModule.ODE
+{
+    /// <summary>
+    /// Processes raycast requests as ODE is in a state to be able to do them.
+    /// This ensures that it's thread safe and there will be no conflicts.
+    /// Requests get returned by a different thread then they were requested by.
+    /// </summary>
+    public class ODERayCastRequestManager
+    {
+        /// <summary>
+        /// Pending raycast requests
+        /// </summary>
+        protected List<ODERayCastRequest> m_PendingRequests = new List<ODERayCastRequest>();
+
+        /// <summary>
+        /// Pending ray requests
+        /// </summary>
+        protected List<ODERayRequest> m_PendingRayRequests = new List<ODERayRequest>();
+
+        /// <summary>
+        /// Scene that created this object.
+        /// </summary>
+        private OdeScene m_scene;
+
+        /// <summary>
+        /// ODE contact array to be filled by the collision testing
+        /// </summary>
+        d.ContactGeom[] contacts = new d.ContactGeom[5];
+
+        /// <summary>
+        /// ODE near callback delegate
+        /// </summary>
+        private d.NearCallback nearCallback;
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private List<ContactResult> m_contactResults = new List<ContactResult>();
+
+
+        public ODERayCastRequestManager(OdeScene pScene)
+        {
+            m_scene = pScene;
+            nearCallback = near;
+            
+        }
+
+        /// <summary>
+        /// Queues a raycast
+        /// </summary>
+        /// <param name="position">Origin of Ray</param>
+        /// <param name="direction">Ray normal</param>
+        /// <param name="length">Ray length</param>
+        /// <param name="retMethod">Return method to send the results</param>
+        public void QueueRequest(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
+        {
+            lock (m_PendingRequests)
+            {
+                ODERayCastRequest req = new ODERayCastRequest();
+                req.callbackMethod = retMethod;
+                req.length = length;
+                req.Normal = direction;
+                req.Origin = position;
+
+                m_PendingRequests.Add(req);
+            }
+        }
+
+        /// <summary>
+        /// Queues a raycast
+        /// </summary>
+        /// <param name="position">Origin of Ray</param>
+        /// <param name="direction">Ray normal</param>
+        /// <param name="length">Ray length</param>
+        /// <param name="count"></param>
+        /// <param name="retMethod">Return method to send the results</param>
+        public void QueueRequest(Vector3 position, Vector3 direction, float length, int count, RayCallback retMethod)
+        {
+            lock (m_PendingRequests)
+            {
+                ODERayRequest req = new ODERayRequest();
+                req.callbackMethod = retMethod;
+                req.length = length;
+                req.Normal = direction;
+                req.Origin = position;
+                req.Count = count;
+
+                m_PendingRayRequests.Add(req);
+            }
+        }
+
+        /// <summary>
+        /// Process all queued raycast requests
+        /// </summary>
+        /// <returns>Time in MS the raycasts took to process.</returns>
+        public int ProcessQueuedRequests()
+        {
+            int time = System.Environment.TickCount;
+            lock (m_PendingRequests)
+            {
+                if (m_PendingRequests.Count > 0)
+                {
+                    ODERayCastRequest[] reqs = m_PendingRequests.ToArray();
+                    for (int i = 0; i < reqs.Length; i++)
+                    {
+                        if (reqs[i].callbackMethod != null) // quick optimization here, don't raycast 
+                            RayCast(reqs[i]);               // if there isn't anyone to send results
+                    }
+
+                    m_PendingRequests.Clear();
+                }
+            }
+
+            lock (m_PendingRayRequests)
+            {
+                if (m_PendingRayRequests.Count > 0)
+                {
+                    ODERayRequest[] reqs = m_PendingRayRequests.ToArray();
+                    for (int i = 0; i < reqs.Length; i++)
+                    {
+                        if (reqs[i].callbackMethod != null) // quick optimization here, don't raycast 
+                            RayCast(reqs[i]);               // if there isn't anyone to send results
+                    }
+
+                    m_PendingRayRequests.Clear();
+                }
+            }
+
+            lock (m_contactResults)
+                m_contactResults.Clear();
+
+            return System.Environment.TickCount - time;
+        }
+
+        /// <summary>
+        /// Method that actually initiates the raycast
+        /// </summary>
+        /// <param name="req"></param>
+        private void RayCast(ODERayCastRequest req)
+        {
+            // NOTE: limit ray lenght or collisions will take all avaiable stack space
+            // this value may still be too large, depending on machine configuration
+            // of maximum stack
+            float len = req.length;
+            if (len > 250f)
+                len = 250f;
+
+            // Create the ray
+            IntPtr ray = d.CreateRay(m_scene.space, len);
+            d.GeomRaySet(ray, req.Origin.X, req.Origin.Y, req.Origin.Z, req.Normal.X, req.Normal.Y, req.Normal.Z);
+
+            // Collide test
+            d.SpaceCollide2(m_scene.space, ray, IntPtr.Zero, nearCallback);
+
+            // Remove Ray
+            d.GeomDestroy(ray);
+
+            // Define default results
+            bool hitYN = false;
+            uint hitConsumerID = 0;
+            float distance = 999999999999f;
+            Vector3 closestcontact = new Vector3(99999f, 99999f, 99999f);
+            Vector3 snormal = Vector3.Zero;
+
+            // Find closest contact and object.
+            lock (m_contactResults)
+            {
+                foreach (ContactResult cResult in m_contactResults)
+                {
+                    if (Vector3.Distance(req.Origin, cResult.Pos) < Vector3.Distance(req.Origin, closestcontact))
+                    {
+                        closestcontact = cResult.Pos;
+                        hitConsumerID = cResult.ConsumerID;
+                        distance = cResult.Depth;
+                        hitYN = true;
+                        snormal = cResult.Normal;
+                    }
+                }
+
+                m_contactResults.Clear();
+            }
+
+            // Return results
+            if (req.callbackMethod != null)
+                req.callbackMethod(hitYN, closestcontact, hitConsumerID, distance, snormal);
+        }
+
+        /// <summary>
+        /// Method that actually initiates the raycast
+        /// </summary>
+        /// <param name="req"></param>
+        private void RayCast(ODERayRequest req)
+        {
+            // limit ray lenght or collisions will take all avaiable stack space
+            float len = req.length;
+            if (len > 250f)
+                len = 250f;
+
+            // Create the ray
+            IntPtr ray = d.CreateRay(m_scene.space, len);
+            d.GeomRaySet(ray, req.Origin.X, req.Origin.Y, req.Origin.Z, req.Normal.X, req.Normal.Y, req.Normal.Z);
+
+            // Collide test
+            d.SpaceCollide2(m_scene.space, ray, IntPtr.Zero, nearCallback);
+
+            // Remove Ray
+            d.GeomDestroy(ray);
+
+            // Find closest contact and object.
+            lock (m_contactResults)
+            {
+                // Return results
+                if (req.callbackMethod != null)
+                    req.callbackMethod(m_contactResults);
+            }
+        }
+        
+        // This is the standard Near.   Uses space AABBs to speed up detection.
+        private void near(IntPtr space, IntPtr g1, IntPtr g2)
+        {
+
+            //Don't test against heightfield Geom, or you'll be sorry!
+            
+            /*
+             terminate called after throwing an instance of 'std::bad_alloc'
+                  what():  std::bad_alloc
+                Stacktrace:
+                 
+                  at (wrapper managed-to-native) Ode.NET.d.Collide (intptr,intptr,int,Ode.NET.d/ContactGeom[],int) <0x00004>
+                  at (wrapper managed-to-native) Ode.NET.d.Collide (intptr,intptr,int,Ode.NET.d/ContactGeom[],int) <0xffffffff>
+                  at OpenSim.Region.Physics.OdePlugin.ODERayCastRequestManager.near (intptr,intptr,intptr) <0x00280>
+                  at (wrapper native-to-managed) OpenSim.Region.Physics.OdePlugin.ODERayCastRequestManager.near (intptr,intptr,intptr) <0xfff
+                fffff>
+                  at (wrapper managed-to-native) Ode.NET.d.SpaceCollide2 (intptr,intptr,intptr,Ode.NET.d/NearCallback) <0x00004>
+                  at (wrapper managed-to-native) Ode.NET.d.SpaceCollide2 (intptr,intptr,intptr,Ode.NET.d/NearCallback) <0xffffffff>
+                  at OpenSim.Region.Physics.OdePlugin.ODERayCastRequestManager.RayCast (OpenSim.Region.Physics.OdePlugin.ODERayCastRequest) <
+                0x00114>
+                  at OpenSim.Region.Physics.OdePlugin.ODERayCastRequestManager.ProcessQueuedRequests () <0x000eb>
+                  at OpenSim.Region.Physics.OdePlugin.OdeScene.Simulate (single) <0x017e6>
+                  at OpenSim.Region.Framework.Scenes.SceneGraph.UpdatePhysics (double) <0x00042>
+                  at OpenSim.Region.Framework.Scenes.Scene.Update () <0x0039e>
+                  at OpenSim.Region.Framework.Scenes.Scene.Heartbeat (object) <0x00019>
+                  at (wrapper runtime-invoke) object.runtime_invoke_void__this___object (object,intptr,intptr,intptr) <0xffffffff>
+                 
+                Native stacktrace:
+                 
+                        mono [0x80d2a42]
+                        [0xb7f5840c]
+                        /lib/i686/cmov/libc.so.6(abort+0x188) [0xb7d1a018]
+                        /usr/lib/libstdc++.so.6(_ZN9__gnu_cxx27__verbose_terminate_handlerEv+0x158) [0xb45fc988]
+                        /usr/lib/libstdc++.so.6 [0xb45fa865]
+                        /usr/lib/libstdc++.so.6 [0xb45fa8a2]
+                        /usr/lib/libstdc++.so.6 [0xb45fa9da]
+                        /usr/lib/libstdc++.so.6(_Znwj+0x83) [0xb45fb033]
+                        /usr/lib/libstdc++.so.6(_Znaj+0x1d) [0xb45fb11d]
+                        libode.so(_ZN13dxHeightfield23dCollideHeightfieldZoneEiiiiP6dxGeomiiP12dContactGeomi+0xd04) [0xb46678e4]
+                        libode.so(_Z19dCollideHeightfieldP6dxGeomS0_iP12dContactGeomi+0x54b) [0xb466832b]
+                        libode.so(dCollide+0x102) [0xb46571b2]
+                        [0x95cfdec9]
+                        [0x8ea07fe1]
+                        [0xab260146]
+                        libode.so [0xb465a5c4]
+                        libode.so(_ZN11dxHashSpace8collide2EPvP6dxGeomPFvS0_S2_S2_E+0x75) [0xb465bcf5]
+                        libode.so(dSpaceCollide2+0x177) [0xb465ac67]
+                        [0x95cf978e]
+                        [0x8ea07945]
+                        [0x95cf2bbc]
+                        [0xab2787e7]
+                        [0xab419fb3]
+                        [0xab416657]
+                        [0xab415bda]
+                        [0xb609b08e]
+                        mono(mono_runtime_delegate_invoke+0x34) [0x8192534]
+                        mono [0x81a2f0f]
+                        mono [0x81d28b6]
+                        mono [0x81ea2c6]
+                        /lib/i686/cmov/libpthread.so.0 [0xb7e744c0]
+                        /lib/i686/cmov/libc.so.6(clone+0x5e) [0xb7dcd6de]
+             */
+
+            // Exclude heightfield geom
+
+            if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
+                return;
+            if (d.GeomGetClass(g1) == d.GeomClassID.HeightfieldClass || d.GeomGetClass(g2) == d.GeomClassID.HeightfieldClass)
+                return;
+
+            // Raytest against AABBs of spaces first, then dig into the spaces it hits for actual geoms.
+            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);
+                }
+                catch (AccessViolationException)
+                {
+                    m_log.Warn("[PHYSICS]: Unable to collide test a space");
+                    return;
+                }
+                //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;
+            }
+
+            if (g1 == IntPtr.Zero || g2 == IntPtr.Zero)
+                return;
+
+            int count = 0;
+            try
+            {
+                
+                if (g1 == g2)
+                    return; // Can't collide with yourself
+
+                lock (contacts)
+                {
+                    count = d.Collide(g1, g2, contacts.GetLength(0), contacts, d.ContactGeom.SizeOf);
+                }
+            }
+            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.");
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[PHYSICS]: Unable to collide test an object: {0}", e.Message);
+                return;
+            }
+
+            PhysicsActor p1 = null;
+            PhysicsActor p2 = null;
+
+            if (g1 != IntPtr.Zero)
+                m_scene.actor_name_map.TryGetValue(g1, out p1);
+
+            if (g2 != IntPtr.Zero)
+                m_scene.actor_name_map.TryGetValue(g1, out p2);
+
+            // Loop over contacts, build results.
+            for (int i = 0; i < count; i++)
+            {
+                if (p1 != null)
+                {
+                    if (p1 is OdePrim)
+                    {
+                        ContactResult collisionresult = new ContactResult();
+                    
+                        collisionresult.ConsumerID = p1.LocalID;
+                        collisionresult.Pos = new Vector3(contacts[i].pos.X, contacts[i].pos.Y, contacts[i].pos.Z);
+                        collisionresult.Depth = contacts[i].depth;
+                        collisionresult.Normal = new Vector3(contacts[i].normal.X, contacts[i].normal.Y,
+                                                             contacts[i].normal.Z);
+                        lock (m_contactResults)
+                            m_contactResults.Add(collisionresult);
+                    }
+                }
+
+                if (p2 != null)
+                {
+                    if (p2 is OdePrim)
+                    {
+                        ContactResult collisionresult = new ContactResult();
+
+                        collisionresult.ConsumerID = p2.LocalID;
+                        collisionresult.Pos = new Vector3(contacts[i].pos.X, contacts[i].pos.Y, contacts[i].pos.Z);
+                        collisionresult.Depth = contacts[i].depth;
+                        collisionresult.Normal = new Vector3(contacts[i].normal.X, contacts[i].normal.Y,
+                                      contacts[i].normal.Z);
+
+                        lock (m_contactResults)
+                            m_contactResults.Add(collisionresult);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Dereference the creator scene so that it can be garbage collected if needed.
+        /// </summary>
+        internal void Dispose()
+        {
+            m_scene = null;
+        }
+    }
+
+    public struct ODERayCastRequest
+    {
+        public Vector3 Origin;
+        public Vector3 Normal;
+        public float length;
+        public RaycastCallback callbackMethod;
+    }
+
+    public struct ODERayRequest
+    {
+        public Vector3 Origin;
+        public Vector3 Normal;
+        public int Count;
+        public float length;
+        public RayCallback callbackMethod;
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Ode/OdePhysicsJoint.cs b/OpenSim/Region/PhysicsModules/Ode/OdePhysicsJoint.cs
new file mode 100644
index 0000000..2eb7ba6
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Ode/OdePhysicsJoint.cs
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using OpenMetaverse;
+using Ode.NET;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Region.PhysicsModule.ODE;
+
+namespace OpenSim.Region.PhysicsModule.ODE
+{
+    class OdePhysicsJoint : PhysicsJoint
+    {
+        public override bool IsInPhysicsEngine
+        {
+            get
+            {
+                return (jointID != IntPtr.Zero);
+            }
+        }
+        public IntPtr jointID;
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs b/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs
new file mode 100644
index 0000000..b00a5ab
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs
@@ -0,0 +1,4381 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// changes for varsize regions
+// note that raycasts need to have limited range
+// (even in normal regions)
+// or aplication thread stack may just blowup
+// see RayCast(ODERayCastRequest req)
+
+//#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 log4net;
+using Nini.Config;
+using Mono.Addins;
+using Ode.NET;
+using OpenMetaverse;
+#if USE_DRAWSTUFF
+using Drawstuff.NET;
+#endif 
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+
+
+namespace OpenSim.Region.PhysicsModule.ODE
+{
+    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 : int
+    {
+        Disabled = 0,
+        Geom = 0x00000001,
+        Body = 0x00000002,
+        Space = 0x00000004,
+        Character = 0x00000008,
+        Land = 0x00000010,
+        Water = 0x00000020,
+        Wind = 0x00000040,
+        Sensor = 0x00000080,
+        Selected = 0x00000100
+    }
+
+    /// <summary>
+    /// Material type for a primitive
+    /// </summary>
+    public enum Material : int
+    {
+        /// <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
+    }
+
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "ODEPhysicsScene")]
+    public class OdeScene : PhysicsScene, INonSharedRegionModule
+    {
+        private readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType.ToString());
+        private bool m_Enabled = false;
+
+        // private Dictionary<string, sCollisionData> m_storedCollisions = new Dictionary<string, sCollisionData>();
+
+        /// <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();
+
+        /// <summary>
+        /// Is stats collecting enabled for this ODE scene?
+        /// </summary>
+        public bool CollectStats { get; set; }
+
+        /// <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";
+
+        /// <summary>
+        /// Stat name for time spent processing prim taints per frame
+        /// </summary>
+        public const string ODEPrimTaintMsStatName = "ODEPrimTaintFrameMS";
+
+        /// <summary>
+        /// Stat name for time spent calculating avatar forces per frame.
+        /// </summary>
+        public const string ODEAvatarForcesFrameMsStatName = "ODEAvatarForcesFrameMS";
+
+        /// <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;
+
+        private uint m_regionWidth = Constants.RegionSize;
+        private uint m_regionHeight = Constants.RegionSize;
+
+        private float ODE_STEPSIZE = 0.0178f;
+        private float metersInSpace = 29.9f;
+        private float m_timeDilation = 1.0f;
+
+        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 IntPtr contactgroup;
+
+//        internal IntPtr WaterGeom;
+
+        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 = 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 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;
+
+        /// <summary>
+        /// Avatars in the physics scene.
+        /// </summary>
+        private readonly HashSet<OdeCharacter> _characters = new HashSet<OdeCharacter>();
+
+        /// <summary>
+        /// Prims in the physics scene.
+        /// </summary>
+        private readonly HashSet<OdePrim> _prims = new HashSet<OdePrim>();
+
+        /// <summary>
+        /// Prims in the physics scene that are subject to physics, not just collisions.
+        /// </summary>
+        private readonly HashSet<OdePrim> _activeprims = new HashSet<OdePrim>();
+
+        /// <summary>
+        /// Prims that the simulator has created/deleted/updated and so need updating in ODE.
+        /// </summary>
+        private readonly HashSet<OdePrim> _taintedPrims = new HashSet<OdePrim>();
+
+        /// <summary>
+        /// Record a character that has taints to be processed.
+        /// </summary>
+        private readonly HashSet<OdeCharacter> _taintedActors = new HashSet<OdeCharacter>();
+
+        /// <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>();
+
+        /// <summary>
+        /// A dictionary of actors that should receive collision events.
+        /// </summary>
+        private readonly Dictionary<uint, PhysicsActor> m_collisionEventActors = new Dictionary<uint, PhysicsActor>();
+
+        /// <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>();
+
+        /// <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>();
+
+        /// <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>();
+
+        /// <summary>
+        /// can lock for longer. accessed only by OdeScene.
+        /// </summary>
+        private readonly List<PhysicsJoint> pendingJoints = new List<PhysicsJoint>();
+
+        /// <summary>
+        /// can lock for longer. accessed only by OdeScene.
+        /// </summary>
+        private readonly List<PhysicsJoint> activeJoints = new List<PhysicsJoint>();
+
+        /// <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;
+
+        /// <summary>
+        /// Used to lock the entire physics scene.  Locked during the main part of Simulate()
+        /// </summary>
+        internal Object OdeLock = new Object();
+
+        private bool _worldInitialized = false;
+
+        public IMesher mesher;
+
+        private IConfigSource m_config;
+
+        public bool physics_logging = false;
+        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;
+
+        float spacesPerMeterX;
+        float spacesPerMeterY;
+        int spaceGridMaxX;
+        int spaceGridMaxY;
+
+        private ODERayCastRequestManager m_rayCastManager;
+
+
+        #region INonSharedRegionModule
+        public string Name
+        {
+            get { return "OpenDynamicsEngine"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            // TODO: Move this out of Startup
+            IConfig config = source.Configs["Startup"];
+            if (config != null)
+            {
+                string physics = config.GetString("physics", string.Empty);
+                if (physics == Name)
+                {
+                    m_Enabled = true;
+                    m_config = source;
+
+                    // We do this so that OpenSimulator on Windows loads the correct native ODE library depending on whether
+                    // it's running as a 32-bit process or a 64-bit one.  By invoking LoadLibary here, later DLLImports
+                    // will find it already loaded later on.
+                    //
+                    // This isn't necessary for other platforms (e.g. Mac OSX and Linux) since the DLL used can be
+                    // controlled in Ode.NET.dll.config
+                    if (Util.IsWindows())
+                        Util.LoadArchSpecificWindowsDll("ode.dll");
+
+                    // Initializing ODE only when a scene is created allows alternative ODE plugins to co-habit (according to
+                    // http://opensimulator.org/mantis/view.php?id=2750).
+                    d.InitODE();
+
+                }
+            }
+
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            EngineType = Name;
+            PhysicsSceneName = EngineType + "/" + scene.RegionInfo.RegionName;
+
+            scene.RegisterModuleInterface<PhysicsScene>(this);
+            Vector3 extent = new Vector3(scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY, scene.RegionInfo.RegionSizeZ);
+            Initialise(extent);
+            InitialiseFromConfig(m_config);
+
+            // This may not be that good since terrain may not be avaiable at this point
+            base.Initialise(scene.PhysicsRequestAsset, 
+                (scene.Heightmap != null ? scene.Heightmap.GetFloatsSerialised() : new float[(int)(extent.X * extent.Y)]), 
+                (float)scene.RegionInfo.RegionSettings.WaterHeight);
+
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            mesher = scene.RequestModuleInterface<IMesher>();
+            if (mesher == null)
+                m_log.WarnFormat("[ODE SCENE]: No mesher in {0}. Things will not work well.", PhysicsSceneName);
+        }
+        #endregion
+
+        /// <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>
+        private void Initialise(Vector3 regionExtent)
+        {
+                        WorldExtents.X = regionExtent.X;
+            m_regionWidth = (uint)regionExtent.X;
+            WorldExtents.Y = regionExtent.Y;
+            m_regionHeight = (uint)regionExtent.Y;
+                        
+            m_suportCombine = false;
+                        
+            nearCallback = near;
+            triCallback = TriCallback;
+            triArrayCallback = TriArrayCallback;
+            m_rayCastManager = new ODERayCastRequestManager(this);
+
+            // Create the world and the first space
+            world = d.WorldCreate();
+            space = d.HashSpaceCreate(IntPtr.Zero);
+
+            contactgroup = d.JointGroupCreate(0);
+
+            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 void Initialise(IMesher meshmerizer, IConfigSource config, Vector3 regionExtent)
+        {
+            WorldExtents.X = regionExtent.X;
+            m_regionWidth = (uint)regionExtent.X;
+            WorldExtents.Y = regionExtent.Y;
+            m_regionHeight = (uint)regionExtent.Y;
+            m_suportCombine = false;
+            Initialise(meshmerizer, config);
+        }
+
+        // Initialize the mesh plugin
+        public void Initialise(IMesher meshmerizer, IConfigSource config)
+        {
+            InitializeExtraStats();
+
+            m_config = config;
+            // Defaults
+
+            if (Environment.OSVersion.Platform == PlatformID.Unix)
+            {
+                avPIDD = 3200.0f;
+                avPIDP = 1400.0f;
+                avStandupTensor = 2000000f;
+            }
+            else
+            {
+                avPIDD = 2200.0f;
+                avPIDP = 900.0f;
+                avStandupTensor = 550000f;
+            }
+
+            int contactsPerCollision = 80;
+
+            if (m_config != null)
+            {
+                IConfig physicsconfig = m_config.Configs["ODEPhysicsSettings"];
+                if (physicsconfig != null)
+                {
+                    CollectStats = physicsconfig.GetBoolean("collect_stats", false);
+
+                    gravityx = physicsconfig.GetFloat("world_gravityx", 0f);
+                    gravityy = physicsconfig.GetFloat("world_gravityy", 0f);
+                    gravityz = physicsconfig.GetFloat("world_gravityz", -9.8f);
+
+                    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);
+                    }
+
+                    worldHashspaceLow = physicsconfig.GetInt("world_hashspace_size_low", -4);
+                    worldHashspaceHigh = physicsconfig.GetInt("world_hashspace_size_high", 128);
+
+                    metersInSpace = physicsconfig.GetFloat("meters_in_small_space", 29.9f);
+                    smallHashspaceLow = physicsconfig.GetInt("small_hashspace_size_low", -4);
+                    smallHashspaceHigh = physicsconfig.GetInt("small_hashspace_size_high", 66);
+
+                    contactsurfacelayer = physicsconfig.GetFloat("world_contact_surface_layer", 0.001f);
+
+                    nmTerrainContactFriction = physicsconfig.GetFloat("nm_terraincontact_friction", 255.0f);
+                    nmTerrainContactBounce = physicsconfig.GetFloat("nm_terraincontact_bounce", 0.1f);
+                    nmTerrainContactERP = physicsconfig.GetFloat("nm_terraincontact_erp", 0.1025f);
+
+                    mTerrainContactFriction = physicsconfig.GetFloat("m_terraincontact_friction", 75f);
+                    mTerrainContactBounce = physicsconfig.GetFloat("m_terraincontact_bounce", 0.05f);
+                    mTerrainContactERP = physicsconfig.GetFloat("m_terraincontact_erp", 0.05025f);
+
+                    nmAvatarObjectContactFriction = physicsconfig.GetFloat("objectcontact_friction", 250f);
+                    nmAvatarObjectContactBounce = physicsconfig.GetFloat("objectcontact_bounce", 0.2f);
+
+                    mAvatarObjectContactFriction = physicsconfig.GetFloat("m_avatarobjectcontact_friction", 75f);
+                    mAvatarObjectContactBounce = physicsconfig.GetFloat("m_avatarobjectcontact_bounce", 0.1f);
+
+                    ODE_STEPSIZE = physicsconfig.GetFloat("world_stepsize", ODE_STEPSIZE);
+                    m_physicsiterations = physicsconfig.GetInt("world_internal_steps_without_collisions", 10);
+
+                    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);
+
+                    IsAvCapsuleTilted = physicsconfig.GetBoolean("av_capsule_tilted", false);
+
+                    contactsPerCollision = physicsconfig.GetInt("contacts_per_collision", 80);
+
+                    geomContactPointsStartthrottle = physicsconfig.GetInt("geom_contactpoints_start_throttling", 5);
+                    geomUpdatesPerThrottledUpdate = physicsconfig.GetInt("geom_updates_before_throttled_update", 15);
+                    geomCrossingFailuresBeforeOutofbounds = physicsconfig.GetInt("geom_crossing_failures_before_outofbounds", 5);
+
+                    geomDefaultDensity = physicsconfig.GetFloat("geometry_default_density", 10.000006836f);
+                    bodyFramesAutoDisable = physicsconfig.GetInt("body_frames_auto_disable", 20);
+
+                    bodyPIDD = physicsconfig.GetFloat("body_pid_derivative", 35f);
+                    bodyPIDG = physicsconfig.GetFloat("body_pid_gain", 25f);
+
+                    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);
+                    
+                    
+
+                    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);
+                    }
+
+                    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_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 = 1.0f / metersInSpace;
+
+            spaceGridMaxX = (int)(WorldExtents.X * spacesPerMeterX);
+            spaceGridMaxY = (int)(WorldExtents.Y * spacesPerMeterY);
+
+            // note: limit number of spaces
+            if (spaceGridMaxX > 24)
+            {
+                spaceGridMaxX = 24;
+                spacesPerMeterX =  spaceGridMaxX / WorldExtents.X;
+            }
+            if (spaceGridMaxY > 24)
+            {
+                spaceGridMaxY = 24;
+                spacesPerMeterY = spaceGridMaxY / WorldExtents.Y;
+            }
+
+            staticPrimspace = new IntPtr[spaceGridMaxX, spaceGridMaxY]; 
+
+            // make this index limits
+            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;
+
+            /*
+                <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;
+
+            /*
+                private float nmAvatarObjectContactFriction = 250f;
+                private float nmAvatarObjectContactBounce = 0.1f;
+
+                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;
+                }
+            }
+
+            _worldInitialized = true;
+        }
+
+//        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
+
+        /// <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)
+        {
+            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();
+
+                count = d.Collide(geom1, geom2, maxContacts, contactsArray, contactGeomSize);
+            }
+
+            // 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);
+
+            return count;
+        }
+
+        /// <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 (CollectStats)
+            {
+                m_inCollisionTiming = true;
+                m_nativeCollisionStartTick = Util.EnvironmentTickCount();
+            }
+
+            d.SpaceCollide2(space1, space2, data, nearCallback);
+
+            if (CollectStats && m_inCollisionTiming)
+            {
+                m_stats[ODENativeSpaceCollisionFrameMsStatName]
+                    += Util.EnvironmentTickCountSubtract(m_nativeCollisionStartTick);
+                m_inCollisionTiming = false;
+            }
+        }
+
+        /// <summary>
+        /// This is our near callback.  A geometry is near a body
+        /// </summary>
+        /// <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)
+        {
+            if (CollectStats && m_inCollisionTiming)
+            {
+                m_stats[ODENativeSpaceCollisionFrameMsStatName]
+                    += Util.EnvironmentTickCountSubtract(m_nativeCollisionStartTick);
+                m_inCollisionTiming = false;
+            }
+
+//            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 (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
+                {
+                    CollideSpaces(g1, g2, IntPtr.Zero);
+                }
+                catch (AccessViolationException)
+                {
+                    m_log.Error("[ODE SCENE]: Unable to collide test a space");
+                    return;
+                }
+                //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;
+            }
+
+            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
+                // This portion of the function 'was' blatantly ripped off from BoxStack.cs
+
+                if (g1 == g2)
+                    return; // Can't collide with yourself
+
+                if (b1 != IntPtr.Zero && b2 != IntPtr.Zero && d.AreConnectedExcluding(b1, b2, d.JointType.Contact))
+                    return;
+
+                count = CollideGeoms(g1, g2, contacts.Length, contacts, d.ContactGeom.SizeOf);
+
+                // 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(
+                    "[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.ErrorFormat("[ODE SCENE]: Unable to collide test an object: {0}", e.Message);
+                return;
+            }
+
+            PhysicsActor p1;
+            PhysicsActor p2;
+            
+            p1ExpectedPoints = 0;
+            p2ExpectedPoints = 0;
+            
+            if (!actor_name_map.TryGetValue(g1, out p1))
+            {
+                p1 = PANull;
+            }
+
+            if (!actor_name_map.TryGetValue(g2, out p2))
+            {
+                p2 = PANull;
+            }
+
+            ContactPoint maxDepthContact = new ContactPoint();
+            if (p1.CollisionScore + count >= float.MaxValue)
+                p1.CollisionScore = 0;
+            p1.CollisionScore += count;
+
+            if (p2.CollisionScore + count >= float.MaxValue)
+                p2.CollisionScore = 0;
+            p2.CollisionScore += count;
+
+            for (int i = 0; i < count; i++)
+            {
+                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
+                    );
+                }
+
+                //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)
+
+                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;
+
+                        if (p2.Velocity.LengthSquared() > 0.0f)
+                            p2.CollidingObj = true;
+                        break;
+                    case (int)ActorTypes.Unknown:
+                        p2.CollidingGround = true;
+                        break;
+                    default:
+                        p2.CollidingGround = true;
+                        break;
+                }
+
+                // we don't want prim or avatar to explode
+
+                #region InterPenetration Handling - Unintended physics explosions
+# region disabled code1
+
+                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)
+                    {
+                        //m_log.Debug("[PHYSICS]: " + contact.depth.ToString());
+                    }
+
+                    //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))
+                    {
+                        
+                        //contact.depth = contact.depth * 4.15f;
+                        /*
+                        if (p2.PhysicsActorType == (int) ActorTypes.Agent)
+                        {
+                            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));
+
+                        }
+                        else
+                        {
+
+                            //contact.depth = 0.0000000f;
+                        }
+                        if (p1.PhysicsActorType == (int) ActorTypes.Agent)
+                        {
+
+                            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
+                        {
+
+                            //contact.depth = 0.0000000f;
+                        }
+                          
+                        
+                     
+                    }
+*/
+                    // If you interpenetrate a prim with another prim
+                /*
+                    if (p1.PhysicsActorType == (int) ActorTypes.Prim && p2.PhysicsActorType == (int) ActorTypes.Prim)
+                    {
+                        #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 (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);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                #endregion
+
+                // 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;
+
+                if ((p1 is OdePrim) && (((OdePrim)p1).m_isVolumeDetect))
+                    skipThisContact = true;   // No collision on volume detect prims
+
+                if (av_av_collisions_off)
+                    if ((p1 is OdeCharacter) && (p2 is OdeCharacter))
+                        skipThisContact = true;
+
+                if (!skipThisContact && (p2 is OdePrim) && (((OdePrim)p2).m_isVolumeDetect))
+                    skipThisContact = true;   // No collision on volume detect prims
+
+                if (!skipThisContact && curContact.depth < 0f)
+                    skipThisContact = true;
+
+                if (!skipThisContact && checkDupe(curContact, p2.PhysicsActorType))
+                    skipThisContact = true;
+
+                const int maxContactsbeforedeath = 4000;
+                joint = IntPtr.Zero;
+
+                if (!skipThisContact)
+                {
+                    _perloopContact.Add(curContact);
+
+                    if (name1 == "Terrain" || name2 == "Terrain")
+                    {
+                        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)
+                            {
+                                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.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
+                        {
+                        }
+                        */
+                        //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 ((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)
+                        {
+                            //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)
+                            {
+                                joint = d.JointCreateContact(world, contactgroup, ref m_materialContacts[material, 0]);
+                                m_global_contactcount++;
+                            }
+                        }
+                    }
+
+                    if (m_global_contactcount < maxContactsbeforedeath && joint != IntPtr.Zero) // stack collide!
+                    {
+                        d.JointAttach(joint, b1, b2);
+                        m_global_contactcount++;
+                    }
+                }
+
+                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;
+
+            bool result = false;
+
+            ActorTypes at = (ActorTypes)atype;
+
+            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)
+                        {
+                            //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();
+
+                    //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)
+                        {
+                            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));
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        private void collision_accounting_events(PhysicsActor p1, PhysicsActor p2, ContactPoint contact)
+        {
+            // 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;
+
+                    // 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;
+
+                        case ActorTypes.Prim:
+                            if (p1 is OdePrim)
+                            {
+                                cp1 = (OdePrim) p1;
+                                obj2LocalID = cp1.LocalID;
+                                cp1.AddCollisionEvent(cc2.LocalID, contact);
+                            }
+                            //ctype = (int)CollisionCategories.Geom;
+
+                            //if (cp1.CollidingObj)
+                            //cStartStop = (int)StatusIndicators.Generic;
+                            //else
+                            //cStartStop = (int)StatusIndicators.Start;
+
+                            //returncollisions = true;
+                            break;
+
+                        case ActorTypes.Ground:
+                        case ActorTypes.Unknown:
+                            obj2LocalID = 0;
+                            //ctype = (int)CollisionCategories.Land;
+                            //returncollisions = true;
+                            break;
+                    }
+
+                    cc2.AddCollisionEvent(obj2LocalID, contact);
+                    break;
+
+                case ActorTypes.Prim:
+
+                    if (p2 is OdePrim)
+                    {
+                        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 (p1 is OdePrim)
+                                {
+                                    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;
+                                }
+                                break;
+
+                            case ActorTypes.Ground:
+                            case ActorTypes.Unknown:
+                                obj2LocalID = 0;
+                                //ctype = (int)CollisionCategories.Land;
+
+                                //returncollisions = true;
+                                break;
+                        }
+
+                        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))
+                        {
+                            name1 = "null";
+                        }
+                        if (!geom_name_map.TryGetValue(refObject, out name2))
+                        {
+                            name2 = "null";
+                        }
+
+                        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>
+        private void collision_optimized()
+        {
+            _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
+                {
+                    CollideSpaces(space, chr.Shell, IntPtr.Zero);
+                }
+                catch (AccessViolationException)
+                {
+                    m_log.ErrorFormat("[ODE SCENE]: Unable to space collide {0}", PhysicsSceneName);
+                }
+                
+                //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;
+                //}
+            }
+
+            if (CollectStats)
+            {
+                m_tempAvatarCollisionsThisFrame = _perloopContact.Count;
+                m_stats[ODEAvatarContactsStatsName] += m_tempAvatarCollisionsThisFrame;
+            }
+
+            List<OdePrim> removeprims = null;
+            foreach (OdePrim chr in _activeprims)
+            {
+                if (chr.Body != IntPtr.Zero && d.BodyIsEnabled(chr.Body) && (!chr.m_disabled))
+                {
+                    try
+                    {
+                        lock (chr)
+                        {
+                            if (space != IntPtr.Zero && chr.prim_geom != IntPtr.Zero && chr.m_taintremove == false)
+                            {
+                                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.Error("[ODE SCENE]: Unable to space collide");
+                    }
+                }
+            }
+
+            if (CollectStats)
+                m_stats[ODEPrimContactsStatName] += _perloopContact.Count - m_tempAvatarCollisionsThisFrame;
+
+            if (removeprims != null)
+            {
+                foreach (OdePrim chr in removeprims)
+                {
+                    _activeprims.Remove(chr);
+                }
+            }
+        }
+
+        #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)
+            {
+                offsetX = ((int)(x / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
+                offsetY = ((int)(y / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
+            }
+
+            if(RegionTerrain.TryGetValue(new Vector3(offsetX,offsetY,0), out heightFieldGeom))
+            {
+                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;
+                }
+
+            }
+            else
+            {
+                return 0f;
+            }
+        } 
+// End recovered. Kitto Flora
+
+        /// <summary>
+        /// Add actor to the list that should receive collision events in the simulate loop.
+        /// </summary>
+        /// <param name="obj"></param>
+        internal void AddCollisionEventReporting(PhysicsActor 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>
+        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)
+        {
+//            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
+        {
+            get { return m_timeDilation; }
+        }
+
+        public override bool SupportsNINJAJoints
+        {
+            get { return m_NINJA_physics_joints_enabled; }
+        }
+
+        // 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);
+        }
+
+        // internal utility function: must be called within a lock (OdeLock)
+        private void InternalAddPendingJoint(OdePhysicsJoint joint)
+        {
+            pendingJoints.Add(joint);
+            SOPName_to_pendingJoint.Add(joint.ObjectNameInScene, joint);
+        }
+
+        // internal utility function: must be called within a lock (OdeLock)
+        private void InternalRemovePendingJoint(PhysicsJoint joint)
+        {
+            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 override void DumpJointInfo()
+        {
+            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)
+            {
+                m_log.Debug(hdr + " Actor " + actorName + " has the following joints connecting it");
+                foreach (PhysicsJoint j in joints_connecting_actor[actorName])
+                {
+                    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 override void RequestJointDeletion(string ObjectNameInScene)
+        {
+            lock (externalJointRequestsLock)
+            {
+                if (!requestedJointsToBeDeleted.Contains(ObjectNameInScene)) // forbid same deletion request from entering twice to prevent spurious deletions processed asynchronously
+                {
+                    requestedJointsToBeDeleted.Add(ObjectNameInScene);
+                }
+            }
+        }
+
+        private void DeleteRequestedJoints()
+        {
+            List<string> myRequestedJointsToBeDeleted;
+            lock (externalJointRequestsLock)
+            {
+                // make a local copy of the shared list for processing (threading issues)
+                myRequestedJointsToBeDeleted = new List<string>(requestedJointsToBeDeleted);
+            }
+
+            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);
+                                    }
+                                }
+                            }
+
+                            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)
+            {
+                foreach (string jointName in myRequestedJointsToBeDeleted)
+                {
+                    requestedJointsToBeDeleted.Remove(jointName);
+                }
+            }
+        }
+
+        // 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()
+        {
+            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)
+            {
+                foreach (PhysicsJoint joint in myRequestedJointsToBeCreated)
+                {
+                    requestedJointsToBeCreated.Remove(joint);
+                }
+            }
+        }
+
+        /// <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)
+        {
+            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)
+            {
+                if (!requestedJointsToBeCreated.Contains(joint)) // forbid same creation request from entering twice 
+                {
+                    requestedJointsToBeCreated.Add(joint);
+                }
+            }
+
+            return joint;
+        }
+
+        private void RemoveAllJointsConnectedToActor(PhysicsActor actor)
+        {
+            //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 void RemoveAllJointsConnectedToActorThreadLocked(PhysicsActor actor)
+        {
+            //m_log.Debug("RemoveAllJointsConnectedToActorThreadLocked: start");
+            lock (OdeLock)
+            {
+                //m_log.Debug("RemoveAllJointsConnectedToActorThreadLocked: got lock");
+                RemoveAllJointsConnectedToActor(actor);
+            }
+        }
+
+        // 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();
+
+            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);
+        }
+
+        /// <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)
+        {
+            Debug.Assert(joint.IsInPhysicsEngine);
+            d.Vector3 axis = new d.Vector3();
+
+            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:
+                        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)
+        {
+            // As with all ODE physics operations, we don't remove the prim immediately but signal that it should be
+            // removed in the next physics simulate pass.
+            if (prim is OdePrim)
+            {
+                lock (OdeLock)
+                {
+                    OdePrim p = (OdePrim) prim;
+
+                    p.setPrimForRemoval();
+                    AddPhysicsActorTaint(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)
+        {
+//            m_log.DebugFormat("[ODE SCENE]: Removing physical prim {0} {1}", prim.Name, prim.LocalID);
+
+            lock (prim)
+            {
+                RemoveCollisionEventReporting(prim);
+
+                if (prim.prim_geom != IntPtr.Zero)
+                {
+                    prim.ResetTaints();
+
+                    if (prim.IsPhysical)
+                    {
+                        prim.disableBody();
+                        if (prim.childPrim)
+                        {
+                            prim.childPrim = false;
+                            prim.Body = IntPtr.Zero;
+                            prim.m_disabled = true;
+                            prim.IsPhysical = false;
+                        }
+
+
+                    }
+                    // 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);
+                }
+            }
+        }
+
+        #endregion
+
+        #region Space Separation Calculation
+
+        /// <summary>
+        /// 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>
+        internal IntPtr recalculateSpaceForGeom(IntPtr geom, Vector3 pos, IntPtr currentspace)
+        {
+            // Called from setting the Position and Size of an ODEPrim so
+            // it's already in locked space.
+
+            // 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)
+
+            // All physical prim end up in the root space
+            //Thread.Sleep(20);
+            if (currentspace != space)
+            {
+                //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)
+                {
+                    if (d.GeomIsSpace(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(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
+            {
+                // this is a physical object that got disabled. ;.;
+                if (currentspace != IntPtr.Zero && geom != IntPtr.Zero)
+                {
+                    if (d.SpaceQuery(currentspace, geom))
+                    {
+                        if (d.GeomIsSpace(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);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // 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);
+            }
+
+            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>
+        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[] returnint = new int[2];
+
+            returnint[0] = (int) (pos.X * spacesPerMeterX);
+
+            if (returnint[0] > spaceGridMaxX)
+                returnint[0] = spaceGridMaxX;
+            if (returnint[0] < 0)
+                returnint[0] = 0;
+
+            returnint[1] = (int)(pos.Y * spacesPerMeterY);
+            if (returnint[1] > spaceGridMaxY)
+                returnint[1] = spaceGridMaxY;
+            if (returnint[1] < 0)
+                returnint[1] = 0;
+
+            return returnint;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Routine to figure out if we need to mesh this prim with our mesher
+        /// </summary>
+        /// <param name="pbs"></param>
+        /// <returns></returns>
+        internal bool needsMeshing(PrimitiveBaseShape pbs)
+        {
+            // 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...
+
+        //    //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;
+
+            if (pbs.SculptEntry && !meshSculptedPrim)
+            {
+#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))
+                {
+
+                    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++; 
+
+            if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0)
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathScaleX != 100) || (pbs.PathScaleY != 100))
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathShearX != 0) || (pbs.PathShearY != 0))
+                iPropertiesNotSupportedDefault++;
+
+            if (pbs.ProfileShape == ProfileShape.Circle && pbs.PathCurve == (byte)Extrusion.Straight)
+                iPropertiesNotSupportedDefault++;
+
+            if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1 && (pbs.Scale.X != pbs.Scale.Y || pbs.Scale.Y != pbs.Scale.Z || pbs.Scale.Z != pbs.Scale.X))
+                iPropertiesNotSupportedDefault++;
+
+            if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte) Extrusion.Curve1)
+                iPropertiesNotSupportedDefault++;
+
+            // test for torus
+            if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Square)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Curve1)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Straight)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+
+                // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits
+                else if (pbs.PathCurve == (byte)Extrusion.Curve1)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Straight)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+                else if (pbs.PathCurve == (byte)Extrusion.Curve1)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+
+            if (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)
+        /// </remarks>
+        /// <param name="timeStep"></param>
+        /// <returns>The number of frames simulated over that period.</returns>
+        public override float Simulate(float timeStep)
+        {
+            if (!_worldInitialized) return 11f;
+
+            int startFrameTick = CollectStats ? Util.EnvironmentTickCount() : 0;
+            int tempTick = 0, tempTick2 = 0;
+
+            if (framecount >= int.MaxValue)
+                framecount = 0;
+
+            framecount++;
+
+            float fps = 0;
+
+            step_time += timeStep;
+
+            float HalfOdeStep = ODE_STEPSIZE * 0.5f;
+            if (step_time < HalfOdeStep)
+                return 0;
+
+
+            // 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)
+            {
+                foreach (KeyValuePair<uint, PhysicsActor> kvp in m_collisionEventActorsChanges)
+                {
+                    if (kvp.Value == null)
+                        m_collisionEventActors.Remove(kvp.Key);
+                    else
+                        m_collisionEventActors[kvp.Key] = kvp.Value;
+                }
+
+                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
+            }
+
+            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
+                    {
+                        if (CollectStats)
+                            tempTick = Util.EnvironmentTickCount();
+
+                        lock (_taintedActors)
+                        {
+                            foreach (OdeCharacter character in _taintedActors)
+                                character.ProcessTaints();
+
+                            _taintedActors.Clear();
+                        }
+
+                        if (CollectStats)
+                        {
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODEAvatarTaintMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
+                        }
+
+                        lock (_taintedPrims)
+                        {
+                            foreach (OdePrim prim in _taintedPrims)
+                            {
+                                if (prim.m_taintremove)
+                                {
+//                                    Console.WriteLine("Simulate calls RemovePrimThreadLocked for {0}", prim.Name);
+                                    RemovePrimThreadLocked(prim);
+                                }
+                                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
+                        foreach (OdeCharacter actor in _characters)
+                            actor.Move(defects);
+
+                        if (defects.Count != 0)
+                        {
+                            foreach (OdeCharacter actor in defects)
+                            {
+                                m_log.ErrorFormat(
+                                    "[ODE SCENE]: Removing physics character {0} {1} from physics scene {2} due to defect found when moving",
+                                    actor.Name, actor.LocalID, PhysicsSceneName);
+
+                                RemoveCharacter(actor);
+                                actor.DestroyOdeStructures();
+                            }
+
+                            defects.Clear();
+                        }
+
+                        if (CollectStats)
+                        {
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODEAvatarForcesFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
+                        }
+
+                        // Move other active objects
+                        foreach (OdePrim prim in _activeprims)
+                        {
+                            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();
+
+                        if (CollectStats)
+                        {
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODEOtherCollisionFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
+                        }
+
+                        foreach (PhysicsActor obj in m_collisionEventActors.Values)
+                        {
+//                                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(100);
+                                    cobj.SendCollisions();
+                                    break;
+
+                                case ActorTypes.Prim:
+                                    OdePrim pobj = (OdePrim)obj;
+                                    pobj.SendCollisions();
+                                    break;
+                            }
+                        }
+
+//                        if (m_global_contactcount > 0)
+//                            m_log.DebugFormat(
+//                                "[PHYSICS]: Collision contacts to process this frame = {0}", m_global_contactcount);
+
+                        m_global_contactcount = 0;
+
+                        if (CollectStats)
+                        {
+                            tempTick2 = Util.EnvironmentTickCount();
+                            m_stats[ODECollisionNotificationFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                            tempTick = tempTick2;
+                        }
+
+                        d.WorldQuickStep(world, ODE_STEPSIZE);
+
+                        if (CollectStats)
+                            m_stats[ODENativeStepFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick);
+
+                        d.JointGroupEmpty(contactgroup);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("[ODE SCENE]: {0}, {1}, {2}", e.Message, e.TargetSite, e);
+                    }
+
+                    step_time -= ODE_STEPSIZE;
+                    fps += ODE_STEPSIZE;
+                }
+
+                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);
+                }
+
+                if (defects.Count != 0)
+                {
+                    foreach (OdeCharacter actor in defects)
+                    {
+                        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, PhysicsSceneName);
+
+                        RemoveCharacter(actor);
+                        actor.DestroyOdeStructures();
+                    }
+
+                    defects.Clear();
+                }
+
+                if (CollectStats)
+                {
+                    tempTick2 = Util.EnvironmentTickCount();
+                    m_stats[ODEAvatarUpdateFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick2, tempTick);
+                    tempTick = tempTick2;
+                }
+
+                //if (timeStep < 0.2f)
+
+                foreach (OdePrim prim in _activeprims)
+                {
+                    if (prim.IsPhysical && (d.BodyIsEnabled(prim.Body) || !prim._zeroFlag))
+                    {
+                        prim.UpdatePositionAndVelocity();
+
+                        if (SupportsNINJAJoints)
+                            SimulateActorPendingJoints(prim);
+                    }
+                }
+
+                if (CollectStats)
+                    m_stats[ODEPrimUpdateFrameMsStatName] += Util.EnvironmentTickCountSubtract(tempTick);
+
+                //DumpJointInfo();
+
+                // Finished with all sim stepping. If requested, dump world state to file for debugging.
+                // TODO: This call to the export function is already inside lock (OdeLock) - but is an extra lock needed?
+                // TODO: This overwrites all dump files in-place. Should this be a growing logfile, or separate snapshots?
+                if (physics_logging && (physics_logging_interval > 0) && (framecount % physics_logging_interval == 0))
+                {
+                    string fname = "state-" + world.ToString() + ".DIF"; // give each physics world a separate filename
+                    string prefix = "world" + world.ToString(); // prefix for variable names in exported .DIF file
+
+                    if (physics_logging_append_existing_logfile)
+                    {
+                        string header = "-------------- START OF PHYSICS FRAME " + framecount.ToString() + " --------------";
+                        TextWriter fwriter = File.AppendText(fname);
+                        fwriter.WriteLine(header);
+                        fwriter.Close();
+                    }
+
+                    d.WorldExportDIF(world, fname, physics_logging_append_existing_logfile, prefix);
+                }
+
+                latertickcount = Util.EnvironmentTickCountSubtract(tickCountFrameRun);
+
+                // 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.
+
+                if (latertickcount < 100)
+                {
+                    m_timeDilation = 1.0f;
+                }
+                else
+                {
+                    m_timeDilation = 100f / latertickcount;
+                    //m_timeDilation = Math.Min((Math.Max(100 - (Util.EnvironmentTickCount() - tickCountFrameRun), 1) / 100f), 1.0f);
+                }
+
+                tickCountFrameRun = Util.EnvironmentTickCount();
+
+                if (CollectStats)
+                    m_stats[ODETotalFrameMsStatName] += Util.EnvironmentTickCountSubtract(startFrameTick);
+            }
+
+            fps *= 1.0f/timeStep;
+            return fps;
+        }
+
+        /// <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
+
+            // 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")
+                        {
+                            //DoJointErrorMessage(joint, "attaching NULL joint to world");
+                            jointBodies.Add(IntPtr.Zero);
+                        }
+                        else
+                        {
+                            //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;
+                            }
+                        }
+                    }
+
+                    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");
+                    }
+                }
+
+                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");
+                }
+            }
+        }
+
+        /// <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)
+        {
+            // 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)
+            {
+                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);
+                    }
+                }
+            }
+        }
+
+        public override void GetResults()
+        {
+        }
+
+        public override bool IsThreaded
+        {
+            // for now we won't be multithreaded
+            get { return 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];
+
+            // Filling out the array into its multi-dimensional components
+            for (int y = 0; y < WorldExtents.Y; y++)
+            {
+                for (int x = 0; x < WorldExtents.X; x++)
+                {
+                    resultarr[y, x] = heightMap[y * (int)WorldExtents.Y + x];
+                }
+            }
+
+            // 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++)
+            {
+                for (int x = 0; x < WorldExtents.X; x++)
+                {
+                    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];
+                    }
+                }
+            }
+
+            //Flatten out the array
+            int i = 0;
+            for (int y = 0; y < 512; y++)
+            {
+                for (int x = 0; x < 512; x++)
+                {
+                    if (resultarr2[y, x] <= 0)
+                        returnarr[i] = 0.0000001f;
+                    else
+                        returnarr[i] = resultarr2[y, x];
+
+                    i++;
+                }
+            }
+
+            return returnarr;
+        }
+
+        private float[] ResizeTerrain512Interpolation(float[] heightMap)
+        {
+            float[] returnarr = new float[262144];
+            float[,] resultarr = new float[512,512];
+
+            // 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];
+                }
+            }
+
+            // 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++)
+            {
+                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];
+                        }
+                    }
+                }
+            }
+            //Flatten out the array
+            int i = 0;
+            for (int y = 0; y < 512; y++)
+            {
+                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++;
+                }
+            }
+
+            return returnarr;
+        }
+
+        #endregion
+*/
+        public override void SetTerrain(float[] heightMap)
+        {
+            if (m_worldOffset != Vector3.Zero && m_parentScene != null)
+            {
+                if (m_parentScene is OdeScene)
+                {
+                    ((OdeScene)m_parentScene).SetTerrain(heightMap, m_worldOffset);
+                }
+            }
+            else
+            {
+                SetTerrain(heightMap, m_worldOffset);
+            }
+        }
+
+        private void SetTerrain(float[] heightMap, Vector3 pOffset)
+        {
+            int startTime = Util.EnvironmentTickCount();
+            m_log.DebugFormat("[ODE SCENE]: Setting terrain for {0} with offset {1}", PhysicsSceneName, pOffset);
+
+            
+            float[] _heightmap;
+
+            // ok im lasy this are just a aliases
+            uint regionsizeX = m_regionWidth;
+            uint regionsizeY = m_regionHeight;
+
+            // map is rotated
+            uint heightmapWidth = regionsizeY + 2;
+            uint heightmapHeight = regionsizeX + 2;
+
+            uint heightmapWidthSamples = heightmapWidth + 1;
+            uint heightmapHeightSamples = heightmapHeight + 1;
+
+            _heightmap = new float[heightmapWidthSamples * heightmapHeightSamples];
+
+            const float scale = 1.0f;
+            const float offset = 0.0f;
+            const float thickness = 10f;
+            const int wrap = 0;
+
+
+            float hfmin = float.MaxValue;
+            float hfmax = float.MinValue;
+            float val;
+            uint xx;
+            uint yy;
+
+            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;
+            xx = 0;
+
+
+            for (uint x = 0; x < heightmapWidthSamples; x++)
+            {
+                if (x > 1 && xx < maxXX)
+                    xx++;
+                yy = 0;
+                for (uint y = 0; y < heightmapHeightSamples; y++)
+                {
+                    if (y > 1 && y < maxYY)
+                        yy += regionsizeX;
+
+                    val = heightMap[yy + xx];
+                    if (val < 0.0f)
+                        val = 0.0f;
+                    _heightmap[xt + y] = val;
+
+                    if (hfmin > val)
+                        hfmin = val;
+                    if (hfmax < val)
+                        hfmax = val;
+                }
+                xt += heightmapHeightSamples;
+            }
+
+            lock (OdeLock)
+            {
+                IntPtr GroundGeom = IntPtr.Zero;
+                if (RegionTerrain.TryGetValue(pOffset, out GroundGeom))
+                {
+                    RegionTerrain.Remove(pOffset);
+                    if (GroundGeom != IntPtr.Zero)
+                    {
+                        if (TerrainHeightFieldHeights.ContainsKey(GroundGeom))
+                        {
+                            TerrainHeightFieldHeights.Remove(GroundGeom);
+                        }
+                        d.SpaceRemove(space, GroundGeom);
+                        d.GeomDestroy(GroundGeom);
+                    }
+
+                }
+                IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
+                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(space, HeightmapData, 1);
+                if (GroundGeom != IntPtr.Zero)
+                {
+                    d.GeomSetCategoryBits(GroundGeom, (int)(CollisionCategories.Land));
+                    d.GeomSetCollideBits(GroundGeom, (int)(CollisionCategories.Space));
+
+                }
+                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;
+                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 + regionsizeX * 0.5f, pOffset.Y + regionsizeY * 0.5f, 0);
+                IntPtr testGround = IntPtr.Zero;
+                if (RegionTerrain.TryGetValue(pOffset, out testGround))
+                {
+                    RegionTerrain.Remove(pOffset);
+                }
+                RegionTerrain.Add(pOffset, GroundGeom, GroundGeom);
+                TerrainHeightFieldHeights.Add(GroundGeom,_heightmap);
+            }
+
+            m_log.DebugFormat(
+                "[ODE SCENE]: Setting terrain for {0} took {1}ms", PhysicsSceneName, Util.EnvironmentTickCountSubtract(startTime));
+        }
+
+        public override void DeleteTerrain()
+        {
+        }
+
+        internal float GetWaterLevel()
+        {
+            return waterlevel;
+        }
+
+        public override bool SupportsCombining()
+        {
+            return m_suportCombine;
+        }
+
+        public override void SetWaterLevel(float baseheight)
+        {
+            waterlevel = baseheight;
+//            randomizeWater(waterlevel);
+        }
+
+/*
+        private void randomizeWater(float baseheight)
+        {
+            uint heightmapWidth = m_regionWidth + 2;
+            uint heightmapHeight = m_regionHeight + 2;
+            uint heightmapWidthSamples = m_regionWidth + 2;
+            uint heightmapHeightSamples = m_regionHeight + 2;
+            float scale = 1.0f;
+            float offset = 0.0f;
+            float thickness = 2.9f;
+            int wrap = 0;
+
+            for (int i = 0; i < (258 * 258); i++)
+            {
+                _watermap[i] = (baseheight-0.1f) + ((float)fluidRandomizer.Next(1,9) / 10f);
+                // m_log.Info((baseheight - 0.1f) + ((float)fluidRandomizer.Next(1, 9) / 10f));
+            }
+
+            lock (OdeLock)
+            {
+                if (WaterGeom != IntPtr.Zero)
+                {
+                    d.SpaceRemove(space, WaterGeom);
+                }
+                IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
+                d.GeomHeightfieldDataBuildSingle(HeightmapData, _watermap, 0, heightmapWidth, heightmapHeight,
+                                                    (int)heightmapWidthSamples, (int)heightmapHeightSamples, scale,
+                                                    offset, thickness, wrap);
+                d.GeomHeightfieldDataSetBounds(HeightmapData, m_regionWidth, m_regionHeight);
+                WaterGeom = d.CreateHeightfield(space, HeightmapData, 1);
+                if (WaterGeom != IntPtr.Zero)
+                {
+                    d.GeomSetCategoryBits(WaterGeom, (int)(CollisionCategories.Water));
+                    d.GeomSetCollideBits(WaterGeom, (int)(CollisionCategories.Space));
+                }
+
+                geom_name_map[WaterGeom] = "Water";
+
+                d.Matrix3 R = new d.Matrix3();
+
+                Quaternion q1 = Quaternion.CreateFromAxisAngle(new Vector3(1, 0, 0), 1.5707f);
+                Quaternion q2 = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), 1.5707f);
+                //Axiom.Math.Quaternion q3 = Axiom.Math.Quaternion.FromAngleAxis(3.14f, new Axiom.Math.Vector3(0, 0, 1));
+
+                q1 = q1 * q2;
+                //q1 = q1 * q3;
+                Vector3 v3;
+                float angle;
+                q1.GetAxisAngle(out v3, out angle);
+
+                d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
+                d.GeomSetRotation(WaterGeom, ref R);
+                d.GeomSetPosition(WaterGeom, 128, 128, 0);
+            }
+        }
+*/
+        public override void Dispose()
+        {
+            _worldInitialized = false;
+
+            m_rayCastManager.Dispose();
+            m_rayCastManager = null;
+
+            lock (OdeLock)
+            {
+                lock (_prims)
+                {
+                    foreach (OdePrim prm in _prims)
+                    {
+                        RemovePrim(prm);
+                    }
+                }
+
+                //foreach (OdeCharacter act in _characters)
+                //{
+                    //RemoveAvatar(act);
+                //}
+                d.WorldDestroy(world);
+                //d.CloseODE();
+            }
+
+        }
+
+        public override Dictionary<uint, float> GetTopColliders()
+        {
+            Dictionary<uint, float> topColliders;
+
+            lock (_prims)
+            {
+                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 topColliders;
+        }
+
+        public override bool SupportsRayCast()
+        {
+            return true;
+        }
+
+        public override void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
+        {
+            if (retMethod != null)
+            {
+                m_rayCastManager.QueueRequest(position, direction, length, retMethod);
+            }
+        }
+
+        public override void RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayCallback retMethod)
+        {
+            if (retMethod != null)
+            {
+                m_rayCastManager.QueueRequest(position, direction, length, Count, retMethod);
+            }
+        }
+
+        public override List<ContactResult> RaycastWorld(Vector3 position, Vector3 direction, float length, int Count)
+        {
+            ContactResult[] ourResults = null;
+            RayCallback retMethod = delegate(List<ContactResult> results)
+            {
+                ourResults = new ContactResult[results.Count];
+                results.CopyTo(ourResults, 0);
+            };
+            int waitTime = 0;
+            m_rayCastManager.QueueRequest(position, direction, length, Count, retMethod);
+            while (ourResults == null && waitTime < 1000)
+            {
+                Thread.Sleep(1);
+                waitTime++;
+            }
+            if (ourResults == null)
+                return new List<ContactResult> ();
+            return new List<ContactResult>(ourResults);
+        }
+
+#if USE_DRAWSTUFF
+        // Keyboard callback
+        public void command(int cmd)
+        {
+            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);
+
+            
+
+            Char ch = Char.ToLower((Char)cmd);
+            switch ((Char)ch)
+            {
+                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));
+
+                        xyz.X += rotate.X; xyz.Y += rotate.Y; xyz.Z += rotate.Z;
+                        ds.SetViewpoint(ref xyz, ref hpr);
+                    }
+                    catch (ArgumentException)
+                    { hpr.X = 0; }
+                    break;
+
+                case 'a':
+                    hpr.X++;
+                    ds.SetViewpoint(ref xyz, ref hpr);
+                    break;
+
+                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));
+
+                        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;
+            }
+        }
+
+        public void step(int pause)
+        {
+            
+            ds.SetColor(1.0f, 1.0f, 0.0f);
+            ds.SetTexture(ds.Texture.Wood);
+            lock (_prims)
+            {
+                foreach (OdePrim prm in _prims)
+                {
+                    //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);
+
+                        d.Matrix3 R;
+                        d.GeomCopyRotation(prm.prim_geom, out R);
+                        //d.BodyCopyRotation(body, out R);
+
+
+                        d.Vector3 sides = new d.Vector3();
+                        sides.X = prm.Size.X;
+                        sides.Y = prm.Size.Y;
+                        sides.Z = prm.Size.Z;
+
+                        ds.DrawBox(ref pos, ref R, ref sides);
+                    }
+                }
+            }
+            ds.SetColor(1.0f, 0.0f, 0.0f);
+
+            foreach (OdeCharacter chr in _characters)
+            {
+                if (chr.Shell != IntPtr.Zero)
+                {
+                    IntPtr body = d.GeomGetBody(chr.Shell);
+
+                    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);
+
+                    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;
+
+                    ds.DrawBox(ref pos, ref R, ref sides);
+                }
+            }
+        }
+
+        public void start(int unused)
+        {
+            ds.SetViewpoint(ref xyz, ref hpr);
+        }
+#endif
+
+        public override Dictionary<string, float> GetStats()
+        {
+            if (!CollectStats)
+                return null;
+
+            Dictionary<string, float> returnStats;
+
+            lock (OdeLock)
+            {
+                returnStats = new Dictionary<string, float>(m_stats);
+
+                // 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;
+
+                InitializeExtraStats();
+            }
+
+            returnStats[ODEOtherCollisionFrameMsStatName]
+                = returnStats[ODEOtherCollisionFrameMsStatName]
+                    - returnStats[ODENativeSpaceCollisionFrameMsStatName]
+                    - returnStats[ODENativeGeomCollisionFrameMsStatName];
+
+            return returnStats;
+        }
+
+        private void InitializeExtraStats()
+        {
+            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/PhysicsModules/Ode/Tests/ODETestClass.cs b/OpenSim/Region/PhysicsModules/Ode/Tests/ODETestClass.cs
new file mode 100644
index 0000000..6dc22bd
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Ode/Tests/ODETestClass.cs
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using Nini.Config;
+using NUnit.Framework;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Region.PhysicsModule.ODE;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Tests.Common;
+using log4net;
+using System.Reflection;
+
+namespace OpenSim.Region.PhysicsModule.ODE.Tests
+{
+    [TestFixture]
+    public class ODETestClass : OpenSimTestCase
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        //private OpenSim.Region.PhysicsModule.ODE.OdePlugin cbt;
+        private PhysicsScene pScene;
+
+        [SetUp]
+        public void Initialize()
+        {
+            IConfigSource openSimINI = new IniConfigSource();
+            IConfig startupConfig = openSimINI.AddConfig("Startup");
+            startupConfig.Set("physics", "OpenDynamicsEngine");
+            startupConfig.Set("DecodedSculptMapPath", "j2kDecodeCache");
+
+            Vector3 regionExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
+
+            //PhysicsScene pScene = physicsPluginManager.GetPhysicsScene(
+            //                "BulletSim", "Meshmerizer", openSimINI, "BSTestRegion", regionExtent);
+            RegionInfo info = new RegionInfo();
+            info.RegionName = "ODETestRegion";
+            info.RegionSizeX = info.RegionSizeY = info.RegionSizeZ = Constants.RegionSize;
+            OpenSim.Region.Framework.Scenes.Scene scene = new OpenSim.Region.Framework.Scenes.Scene(info);
+
+            //IMesher mesher = new OpenSim.Region.PhysicsModules.Meshing.Meshmerizer();
+            //INonSharedRegionModule mod = mesher as INonSharedRegionModule;
+            //mod.Initialise(openSimINI);
+            //mod.AddRegion(scene);
+            //mod.RegionLoaded(scene);
+
+            pScene = new OdeScene();
+            Console.WriteLine("HERE " + (pScene == null ? "Null" : "Not null"));
+            INonSharedRegionModule mod = (pScene as INonSharedRegionModule);
+            Console.WriteLine("HERE " + (mod == null ? "Null" : "Not null"));
+            mod.Initialise(openSimINI);
+            mod.AddRegion(scene);
+            mod.RegionLoaded(scene);
+
+            // Loading ODEPlugin
+            //cbt = new OdePlugin();
+            // Getting Physics Scene
+            //ps = cbt.GetScene("test");
+            // Initializing Physics Scene.
+            //ps.Initialise(imp.GetMesher(TopConfig), null, Vector3.Zero);
+            float[] _heightmap = new float[(int)Constants.RegionSize * (int)Constants.RegionSize];
+            for (int i = 0; i < ((int)Constants.RegionSize * (int)Constants.RegionSize); i++)
+            {
+                _heightmap[i] = 21f;
+            }
+            pScene.SetTerrain(_heightmap);
+        }
+
+        [TearDown]
+        public void Terminate()
+        {
+            pScene.DeleteTerrain();
+            pScene.Dispose();
+
+        }
+
+        [Test]
+        public void CreateAndDropPhysicalCube()
+        {
+            PrimitiveBaseShape newcube = PrimitiveBaseShape.CreateBox();
+            Vector3 position = new Vector3(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f), 128f);
+            Vector3 size = new Vector3(0.5f, 0.5f, 0.5f);
+            Quaternion rot = Quaternion.Identity;
+            PhysicsActor prim = pScene.AddPrimShape("CoolShape", newcube, position, size, rot, true, 0);
+            OdePrim oprim = (OdePrim)prim;
+            OdeScene pscene = (OdeScene)pScene;
+
+            Assert.That(oprim.m_taintadd);
+
+            prim.LocalID = 5;
+
+            for (int i = 0; i < 58; i++)
+            {
+                pScene.Simulate(0.133f);
+
+                Assert.That(oprim.prim_geom != (IntPtr)0);
+
+                Assert.That(oprim.m_targetSpace != (IntPtr)0);
+
+                //Assert.That(oprim.m_targetSpace == pscene.space);
+                m_log.Info("TargetSpace: " + oprim.m_targetSpace + " - SceneMainSpace: " + pscene.space);
+
+                Assert.That(!oprim.m_taintadd);
+                m_log.Info("Prim Position (" + oprim.LocalID + "): " + prim.Position);
+
+                // Make sure we're above the ground
+                //Assert.That(prim.Position.Z > 20f);
+                //m_log.Info("PrimCollisionScore (" + oprim.m_localID + "): " + oprim.m_collisionscore);
+
+                // Make sure we've got a Body
+                Assert.That(oprim.Body != (IntPtr)0);
+                //m_log.Info(
+            }
+
+            // Make sure we're not somewhere above the ground
+            Assert.That(prim.Position.Z < 21.5f);
+
+            pScene.RemovePrim(prim);
+            Assert.That(oprim.m_taintremove);
+            pScene.Simulate(0.133f);
+            Assert.That(oprim.Body == (IntPtr)0);
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/Ode/drawstuff.cs b/OpenSim/Region/PhysicsModules/Ode/drawstuff.cs
new file mode 100644
index 0000000..87ca446
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/Ode/drawstuff.cs
@@ -0,0 +1,98 @@
+/*
+ * Copyright ODE
+ * Ode.NET - .NET bindings for ODE
+ *  Jason Perkins (starkos@industriousone.com)
+ *  Licensed under the New BSD
+ *  Part of the OpenDynamicsEngine
+Open Dynamics Engine
+Copyright (c) 2001-2007, Russell L. Smith.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+Neither the names of ODE's copyright owner nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * 
+ */
+
+using System;
+using System.Runtime.InteropServices;
+using Ode.NET;
+
+namespace Drawstuff.NET
+{
+#if dDOUBLE
+    using dReal = System.Double;
+#else
+    using dReal = System.Single;
+#endif
+
+    public static class ds
+    {
+        public const int VERSION = 2;
+
+        public enum Texture
+        {
+            None,
+            Wood
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void CallbackFunction(int arg);
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct Functions
+        {
+            public int version;
+            public CallbackFunction start;
+            public CallbackFunction step;
+            public CallbackFunction command;
+            public CallbackFunction stop;
+            public string path_to_textures;
+        }
+
+        [DllImport("drawstuff", EntryPoint = "dsDrawBox")]
+        public static extern void DrawBox(ref d.Vector3 pos, ref d.Matrix3 R, ref d.Vector3 sides);
+
+        [DllImport("drawstuff", EntryPoint = "dsDrawCapsule")]
+        public static extern void DrawCapsule(ref d.Vector3 pos, ref d.Matrix3 R, dReal length, dReal radius);
+
+        [DllImport("drawstuff", EntryPoint = "dsDrawConvex")]
+        public static extern void DrawConvex(ref d.Vector3 pos, ref d.Matrix3 R, dReal[] planes, int planeCount, dReal[] points, int pointCount, int[] polygons);
+
+        [DllImport("drawstuff", EntryPoint = "dsSetColor")]
+        public static extern void SetColor(float red, float green, float blue);
+
+        [DllImport("drawstuff", EntryPoint = "dsSetTexture")]
+        public static extern void SetTexture(Texture texture);
+
+        [DllImport("drawstuff", EntryPoint = "dsSetViewpoint")]
+        public static extern void SetViewpoint(ref d.Vector3 xyz, ref d.Vector3 hpr);
+
+        [DllImport("drawstuff", EntryPoint = "dsSimulationLoop")]
+        public static extern void SimulationLoop(int argc, string[] argv, int window_width, int window_height, ref Functions fn);
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/POS/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/POS/AssemblyInfo.cs
new file mode 100644
index 0000000..e3a3e35
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/POS/AssemblyInfo.cs
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+using Mono.Addins;
+
+// Information about this assembly is defined by the following
+// attributes.
+//
+// change them to the information which is associated with the assembly
+// you compile.
+
+[assembly : AssemblyTitle("POSPlugin")]
+[assembly : AssemblyDescription("")]
+[assembly : AssemblyConfiguration("")]
+[assembly : AssemblyCompany("http://opensimulator.org")]
+[assembly : AssemblyProduct("POSPlugin")]
+[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers")]
+[assembly : AssemblyTrademark("")]
+[assembly : AssemblyCulture("")]
+
+// This sets the default COM visibility of types in the assembly to invisible.
+// If you need to expose a type to COM, use [ComVisible(true)] on that type.
+
+[assembly : ComVisible(false)]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all values by your own or you can build default build and revision
+// numbers with the '*' character (the default):
+
+[assembly : AssemblyVersion("0.8.2.*")]
+
+[assembly: Addin("OpenSim.Region.PhysicsModule.POS", OpenSim.VersionInfo.VersionNumber)]
+[assembly: AddinDependency("OpenSim.Region.Framework", OpenSim.VersionInfo.VersionNumber)]
diff --git a/OpenSim/Region/PhysicsModules/POS/POSCharacter.cs b/OpenSim/Region/PhysicsModules/POS/POSCharacter.cs
new file mode 100644
index 0000000..32469d9
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/POS/POSCharacter.cs
@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+namespace OpenSim.Region.PhysicsModule.POS
+{
+    public class POSCharacter : PhysicsActor
+    {
+        private Vector3 _position;
+        public Vector3 _velocity;
+        public Vector3 _target_velocity = Vector3.Zero;
+        public Vector3 _size = Vector3.Zero;
+        private Vector3 _acceleration;
+        private Vector3 m_rotationalVelocity = Vector3.Zero;
+        private bool flying;
+        private bool isColliding;
+
+        public POSCharacter()
+        {
+        }
+
+        public override int PhysicsActorType
+        {
+            get { return (int) ActorTypes.Agent; }
+            set { return; }
+        }
+
+        public override Vector3 RotationalVelocity
+        {
+            get { return m_rotationalVelocity; }
+            set { m_rotationalVelocity = value; }
+        }
+
+        public override bool SetAlwaysRun
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override uint LocalID
+        {
+            set { return; }
+        }
+
+        public override bool Grabbed
+        {
+            set { return; }
+        }
+
+        public override bool Selected
+        {
+            set { return; }
+        }
+
+        public override float Buoyancy
+        {
+            get { return 0f; }
+            set { return; }
+        }
+
+        public override bool FloatOnWater
+        {
+            set { return; }
+        }
+
+        public override bool IsPhysical
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool ThrottleUpdates
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Flying
+        {
+            get { return flying; }
+            set { flying = value; }
+        }
+
+        public override bool IsColliding
+        {
+            get { return isColliding; }
+            set { isColliding = value; }
+        }
+
+        public override bool CollidingGround
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool CollidingObj
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Stopped
+        {
+            get { return false; }
+        }
+
+        public override Vector3 Position
+        {
+            get { return _position; }
+            set { _position = value; }
+        }
+
+        public override Vector3 Size
+        {
+            get { return _size; }
+            set
+            {
+                _size = value;
+                _size.Z = _size.Z / 2.0f;
+            }
+        }
+
+        public override float Mass
+        {
+            get { return 0f; }
+        }
+
+        public override Vector3 Force
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override int VehicleType
+        {
+            get { return 0; }
+            set { return; }
+        }
+
+        public override void VehicleFloatParam(int param, float value)
+        {
+
+        }
+
+        public override void VehicleVectorParam(int param, Vector3 value)
+        {
+
+        }
+
+        public override void VehicleRotationParam(int param, Quaternion rotation)
+        {
+
+        }
+
+        public override void VehicleFlags(int param, bool remove) { }
+
+        public override void SetVolumeDetect(int param)
+        {
+
+        }
+
+        public override Vector3 CenterOfMass
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override Vector3 GeometricCenter
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override PrimitiveBaseShape Shape
+        {
+            set { return; }
+        }
+
+        public override Vector3 Velocity
+        {
+            get { return _velocity; }
+            set { _target_velocity = value; }
+        }
+
+        public override Vector3 Torque
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override float CollisionScore
+        {
+            get { return 0f; }
+            set { }
+        }
+
+        public override Quaternion Orientation
+        {
+            get { return Quaternion.Identity; }
+            set { }
+        }
+
+        public override Vector3 Acceleration
+        {
+            get { return _acceleration; }
+            set { _acceleration = value; }
+        }
+
+        public override bool Kinematic
+        {
+            get { return true; }
+            set { }
+        }
+
+        public override void link(PhysicsActor obj)
+        {
+        }
+
+        public override void delink()
+        {
+        }
+
+        public override void LockAngularMotion(Vector3 axis)
+        {
+        }
+
+        public override void AddForce(Vector3 force, bool pushforce)
+        {
+        }
+
+        public override void AddAngularForce(Vector3 force, bool pushforce)
+        {
+        }
+
+        public override void SetMomentum(Vector3 momentum)
+        {
+        }
+
+        public override void CrossingFailure()
+        {
+        }
+
+        public override Vector3 PIDTarget
+        {
+            set { return; }
+        }
+
+        public override bool PIDActive 
+        { 
+            get { return false; }
+            set { return; } 
+        }
+
+        public override float PIDTau
+        {
+            set { return; }
+        }
+
+        public override float PIDHoverHeight
+        {
+            set { return; }
+        }
+
+        public override bool PIDHoverActive
+        {
+            set { return; }
+        }
+
+        public override PIDHoverType PIDHoverType
+        {
+            set { return; }
+        }
+
+        public override float PIDHoverTau
+        {
+            set { return; }
+        }
+        
+        public override Quaternion APIDTarget
+        {
+            set { return; }
+        }
+
+        public override bool APIDActive
+        {
+            set { return; }
+        }
+
+        public override float APIDStrength
+        {
+            set { return; }
+        }
+
+        public override float APIDDamping
+        {
+            set { return; }
+        }
+
+
+        public override void SubscribeEvents(int ms)
+        {
+        }
+
+        public override void UnSubscribeEvents()
+        {
+        }
+
+        public override bool SubscribedEvents()
+        {
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/POS/POSPrim.cs b/OpenSim/Region/PhysicsModules/POS/POSPrim.cs
new file mode 100644
index 0000000..c190fab
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/POS/POSPrim.cs
@@ -0,0 +1,336 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using Nini.Config;
+using OpenMetaverse;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+namespace OpenSim.Region.PhysicsModule.POS
+{
+    public class POSPrim : PhysicsActor
+    {
+        private Vector3 _position;
+        private Vector3 _velocity;
+        private Vector3 _acceleration;
+        private Vector3 _size;
+        private Vector3 m_rotationalVelocity = Vector3.Zero;
+        private Quaternion _orientation;
+        private bool iscolliding;
+
+        public POSPrim()
+        {
+        }
+
+        public override int PhysicsActorType
+        {
+            get { return (int) ActorTypes.Prim; }
+            set { return; }
+        }
+
+        public override Vector3 RotationalVelocity
+        {
+            get { return m_rotationalVelocity; }
+            set { m_rotationalVelocity = value; }
+        }
+
+        public override bool IsPhysical
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool ThrottleUpdates
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool IsColliding
+        {
+            get { return iscolliding; }
+            set { iscolliding = value; }
+        }
+
+        public override bool CollidingGround
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool CollidingObj
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Stopped
+        {
+            get { return false; }
+        }
+
+        public override Vector3 Position
+        {
+            get { return _position; }
+            set { _position = value; }
+        }
+
+        public override Vector3 Size
+        {
+            get { return _size; }
+            set { _size = value; }
+        }
+
+        public override float Mass
+        {
+            get { return 0f; }
+        }
+
+        public override Vector3 Force
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override int VehicleType
+        {
+            get { return 0; }
+            set { return; }
+        }
+
+        public override void VehicleFloatParam(int param, float value)
+        {
+
+        }
+
+        public override void VehicleVectorParam(int param, Vector3 value)
+        {
+
+        }
+
+        public override void VehicleRotationParam(int param, Quaternion rotation)
+        {
+
+        }
+
+        public override void VehicleFlags(int param, bool remove) { }
+
+        public override void SetVolumeDetect(int param)
+        {
+
+        }
+
+        public override Vector3 CenterOfMass
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override Vector3 GeometricCenter
+        {
+            get { return Vector3.Zero; }
+        }
+
+        public override PrimitiveBaseShape Shape
+        {
+            set { return; }
+        }
+
+        public override float Buoyancy
+        {
+            get { return 0f; }
+            set { return; }
+        }
+
+        public override bool FloatOnWater
+        {
+            set { return; }
+        }
+
+        public override Vector3 Velocity
+        {
+            get { return _velocity; }
+            set { _velocity = value; }
+        }
+
+        public override float CollisionScore
+        {
+            get { return 0f; }
+            set { }
+        }
+
+        public override Quaternion Orientation
+        {
+            get { return _orientation; }
+            set { _orientation = value; }
+        }
+
+        public override Vector3 Acceleration
+        {
+            get { return _acceleration; }
+            set { _acceleration = value; }
+        }
+
+        public override bool Kinematic
+        {
+            get { return true; }
+            set { }
+        }
+
+        public override void AddForce(Vector3 force, bool pushforce)
+        {
+        }
+
+        public override void AddAngularForce(Vector3 force, bool pushforce)
+        {
+        }
+
+        public override Vector3 Torque
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override void SetMomentum(Vector3 momentum)
+        {
+        }
+
+        public override bool Flying
+        {
+            get { return false; }
+            set { }
+        }
+
+        public override bool SetAlwaysRun
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override uint LocalID
+        {
+            set { return; }
+        }
+
+        public override bool Grabbed
+        {
+            set { return; }
+        }
+
+        public override void link(PhysicsActor obj)
+        {
+        }
+
+        public override void delink()
+        {
+        }
+
+        public override void LockAngularMotion(Vector3 axis)
+        {
+        }
+
+        public override bool Selected
+        {
+            set { return; }
+        }
+
+        public override void CrossingFailure()
+        {
+        }
+
+        public override Vector3 PIDTarget
+        {
+            set { return; }
+        }
+
+        public override bool PIDActive
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override float PIDTau
+        {
+            set { return; }
+        }
+
+        public override float PIDHoverHeight
+        {
+            set { return; }
+        }
+
+        public override bool PIDHoverActive
+        {
+            set { return; }
+        }
+
+        public override PIDHoverType PIDHoverType
+        {
+            set { return; }
+        }
+
+        public override float PIDHoverTau
+        {
+            set { return; }
+        }
+
+        public override Quaternion APIDTarget
+        {
+            set { return; }
+        }
+
+        public override bool APIDActive
+        {
+            set { return; }
+        }
+
+        public override float APIDStrength
+        {
+            set { return; }
+        }
+
+        public override float APIDDamping
+        {
+            set { return; }
+        }
+
+
+        public override void SubscribeEvents(int ms)
+        {
+        }
+
+        public override void UnSubscribeEvents()
+        {
+        }
+
+        public override bool SubscribedEvents()
+        {
+            return false;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/POS/POSScene.cs b/OpenSim/Region/PhysicsModules/POS/POSScene.cs
new file mode 100644
index 0000000..e6bcbf2
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/POS/POSScene.cs
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using Nini.Config;
+using OpenMetaverse;
+using Mono.Addins;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
+
+namespace OpenSim.Region.PhysicsModule.POS
+{
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "POSPhysicsScene")]
+    public class POSScene : PhysicsScene, INonSharedRegionModule
+    {
+        private List<POSCharacter> _characters = new List<POSCharacter>();
+        private List<POSPrim> _prims = new List<POSPrim>();
+        private float[] _heightMap;
+        private const float gravity = -9.8f;
+
+        private bool m_Enabled = false;
+        //protected internal string sceneIdentifier;
+
+        #region INonSharedRegionModule
+        public string Name
+        {
+            get { return "POS"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            // TODO: Move this out of Startup
+            IConfig config = source.Configs["Startup"];
+            if (config != null)
+            {
+                string physics = config.GetString("physics", string.Empty);
+                if (physics == Name)
+                    m_Enabled = true;
+            }
+
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            EngineType = Name;
+            PhysicsSceneName = EngineType + "/" + scene.RegionInfo.RegionName;
+
+            scene.RegisterModuleInterface<PhysicsScene>(this);
+            base.Initialise(scene.PhysicsRequestAsset,
+                (scene.Heightmap != null ? scene.Heightmap.GetFloatsSerialised() : new float[Constants.RegionSize * Constants.RegionSize]),
+                (float)scene.RegionInfo.RegionSettings.WaterHeight);
+
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+        }
+        #endregion
+
+        public override void Dispose()
+        {
+        }
+
+        public override PhysicsActor AddAvatar(
+            string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        {
+            POSCharacter act = new POSCharacter();
+            act.Position = position;
+            act.Flying = isFlying;
+            _characters.Add(act);
+            return act;
+        }
+
+        public override void RemovePrim(PhysicsActor prim)
+        {
+            POSPrim p = (POSPrim) prim;
+            if (_prims.Contains(p))
+            {
+                _prims.Remove(p);
+            }
+        }
+
+        public override void RemoveAvatar(PhysicsActor character)
+        {
+            POSCharacter act = (POSCharacter) character;
+            if (_characters.Contains(act))
+            {
+                _characters.Remove(act);
+            }
+        }
+
+/*
+        public override PhysicsActor AddPrim(Vector3 position, Vector3 size, Quaternion rotation)
+        {
+            return null;
+        }
+*/
+
+        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, uint localid)
+        {
+            POSPrim prim = new POSPrim();
+            prim.Position = position;
+            prim.Orientation = rotation;
+            prim.Size = size;
+            _prims.Add(prim);
+            return prim;
+        }
+
+        private bool isColliding(POSCharacter c, POSPrim p)
+        {
+            Vector3 rotatedPos = new Vector3(c.Position.X - p.Position.X, c.Position.Y - p.Position.Y,
+                                             c.Position.Z - p.Position.Z) * Quaternion.Inverse(p.Orientation);
+            Vector3 avatarSize = new Vector3(c.Size.X, c.Size.Y, c.Size.Z) * Quaternion.Inverse(p.Orientation);
+
+            return (Math.Abs(rotatedPos.X) < (p.Size.X*0.5 + Math.Abs(avatarSize.X)) &&
+                    Math.Abs(rotatedPos.Y) < (p.Size.Y*0.5 + Math.Abs(avatarSize.Y)) &&
+                    Math.Abs(rotatedPos.Z) < (p.Size.Z*0.5 + Math.Abs(avatarSize.Z)));
+        }
+
+        private bool isCollidingWithPrim(POSCharacter c)
+        {
+            foreach (POSPrim p in _prims)
+            {
+                if (isColliding(c, p))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public override void AddPhysicsActorTaint(PhysicsActor prim)
+        {
+        }
+
+        public override float Simulate(float timeStep)
+        {
+            float fps = 0;
+            for (int i = 0; i < _characters.Count; ++i)
+            {
+                fps++;
+                POSCharacter character = _characters[i];
+
+                float oldposX = character.Position.X;
+                float oldposY = character.Position.Y;
+                float oldposZ = character.Position.Z;
+
+                if (!character.Flying)
+                {
+                    character._target_velocity.Z += gravity * timeStep;
+                }
+
+                Vector3 characterPosition = character.Position;
+
+                characterPosition.X += character._target_velocity.X * timeStep;
+                characterPosition.Y += character._target_velocity.Y * timeStep;
+
+                characterPosition.X = Util.Clamp(character.Position.X, 0.01f, Constants.RegionSize - 0.01f);
+                characterPosition.Y = Util.Clamp(character.Position.Y, 0.01f, Constants.RegionSize - 0.01f);
+
+                bool forcedZ = false;
+
+                float terrainheight = _heightMap[(int)character.Position.Y * Constants.RegionSize + (int)character.Position.X];
+                if (character.Position.Z + (character._target_velocity.Z * timeStep) < terrainheight + 2)
+                {
+                    characterPosition.Z = terrainheight + character.Size.Z;
+                    forcedZ = true;
+                }
+                else
+                {
+                    characterPosition.Z += character._target_velocity.Z*timeStep;
+                }
+
+                /// this is it -- the magic you've all been waiting for!  Ladies and gentlemen --
+                /// Completely Bogus Collision Detection!!!
+                /// better known as the CBCD algorithm
+
+                if (isCollidingWithPrim(character))
+                {
+                    characterPosition.Z = oldposZ; //  first try Z axis
+                    if (isCollidingWithPrim(character))
+                    {
+                        characterPosition.Z = oldposZ + character.Size.Z / 4.4f; // try harder
+                        if (isCollidingWithPrim(character))
+                        {
+                            characterPosition.Z = oldposZ + character.Size.Z / 2.2f; // try very hard
+                            if (isCollidingWithPrim(character))
+                            {
+                                characterPosition.X = oldposX;
+                                characterPosition.Y = oldposY;
+                                characterPosition.Z = oldposZ;
+
+                                characterPosition.X += character._target_velocity.X * timeStep;
+                                if (isCollidingWithPrim(character))
+                                {
+                                    characterPosition.X = oldposX;
+                                }
+
+                                characterPosition.Y += character._target_velocity.Y * timeStep;
+                                if (isCollidingWithPrim(character))
+                                {
+                                    characterPosition.Y = oldposY;
+                                }
+                            }
+                            else
+                            {
+                                forcedZ = true;
+                            }
+                        }
+                        else
+                        {
+                            forcedZ = true;
+                        }
+                    }
+                    else
+                    {
+                        forcedZ = true;
+                    }
+                }
+
+                characterPosition.X = Util.Clamp(character.Position.X, 0.01f, Constants.RegionSize - 0.01f);
+                characterPosition.Y = Util.Clamp(character.Position.Y, 0.01f, Constants.RegionSize - 0.01f);
+
+                character.Position = characterPosition;
+
+                character._velocity.X = (character.Position.X - oldposX)/timeStep;
+                character._velocity.Y = (character.Position.Y - oldposY)/timeStep;
+
+                if (forcedZ)
+                {
+                    character._velocity.Z = 0;
+                    character._target_velocity.Z = 0;
+                    ((PhysicsActor)character).IsColliding = true;
+                    character.RequestPhysicsterseUpdate();
+                }
+                else
+                {
+                    ((PhysicsActor)character).IsColliding = false;
+                    character._velocity.Z = (character.Position.Z - oldposZ)/timeStep;
+                }
+            }
+            return 1.0f;
+        }
+
+        public override void GetResults()
+        {
+        }
+
+        public override bool IsThreaded
+        {
+            // for now we won't be multithreaded
+            get { return (false); }
+        }
+
+        public override void SetTerrain(float[] heightMap)
+        {
+            _heightMap = heightMap;
+        }
+
+        public override void DeleteTerrain()
+        {
+        }
+
+        public override void SetWaterLevel(float baseheight)
+        {
+        }
+
+        public override Dictionary<uint, float> GetTopColliders()
+        {
+            Dictionary<uint, float> returncolliders = new Dictionary<uint, float>();
+            return returncolliders;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/SharedBase/AssemblyInfo.cs
new file mode 100644
index 0000000..33f60e4
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/AssemblyInfo.cs
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// Information about this assembly is defined by the following
+// attributes.
+//
+// change them to the information which is associated with the assembly
+// you compile.
+
+[assembly : AssemblyTitle("PhysicsManager")]
+[assembly : AssemblyDescription("")]
+[assembly : AssemblyConfiguration("")]
+[assembly : AssemblyCompany("http://opensimulator.org")]
+[assembly : AssemblyProduct("PhysicsManager")]
+[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers")]
+[assembly : AssemblyTrademark("")]
+[assembly : AssemblyCulture("")]
+
+// This sets the default COM visibility of types in the assembly to invisible.
+// If you need to expose a type to COM, use [ComVisible(true)] on that type.
+
+[assembly : ComVisible(false)]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all values by your own or you can build default build and revision
+// numbers with the '*' character (the default):
+
+[assembly : AssemblyVersion("0.8.2.*")]
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/CollisionLocker.cs b/OpenSim/Region/PhysicsModules/SharedBase/CollisionLocker.cs
new file mode 100644
index 0000000..6e658b5
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/CollisionLocker.cs
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace OpenSim.Region.PhysicsModules.SharedBase
+{
+    public class CollisionLocker
+    {
+        private List<IntPtr> worldlock = new List<IntPtr>();
+
+        public CollisionLocker()
+        {
+
+        }
+
+        public void dlock(IntPtr world)
+        {
+            lock (worldlock)
+            {
+                worldlock.Add(world);
+            }
+
+        }
+
+        public void dunlock(IntPtr world)
+        {
+            lock (worldlock)
+            {
+                worldlock.Remove(world);
+            }
+        }
+
+        public bool lockquery()
+        {
+            return (worldlock.Count > 0);
+        }
+
+        public void drelease(IntPtr world)
+        {
+            lock (worldlock)
+            {
+                if (worldlock.Contains(world))
+                    worldlock.Remove(world);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/IMesher.cs b/OpenSim/Region/PhysicsModules/SharedBase/IMesher.cs
new file mode 100644
index 0000000..88169bb
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/IMesher.cs
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using OpenSim.Framework;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.SharedBase
+{
+    public interface IMesher
+    {
+        IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod);
+        IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical);
+        IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool convex, bool forOde);
+        IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool shouldCache, bool convex, bool forOde);
+        IMesh GetMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool convex);
+        void ReleaseMesh(IMesh mesh);
+        void ExpireReleaseMeshs();
+        void ExpireFileCache();
+    }
+
+    // Values for level of detail to be passed to the mesher.
+    // Values origionally chosen for the LOD of sculpties (the sqrt(width*heigth) of sculpt texture)
+    // Lower level of detail reduces the number of vertices used to represent the meshed shape.
+    public enum LevelOfDetail 
+    {
+        High = 32,
+        Medium = 16,
+        Low = 8,
+        VeryLow = 4
+    }
+
+    public interface IVertex
+    {
+    }
+
+    [Serializable()]
+    [StructLayout(LayoutKind.Explicit)]
+    public struct AMeshKey
+    {
+        [FieldOffset(0)]
+        public UUID uuid;
+        [FieldOffset(0)]
+        public ulong hashA;
+        [FieldOffset(8)]
+        public ulong hashB;
+        [FieldOffset(16)]
+        public ulong hashC;
+
+        public override string ToString()
+        {
+            return uuid.ToString() + "-" + hashC.ToString("x") ;
+        }
+    }
+
+    public interface IMesh
+    {
+        List<Vector3> getVertexList();
+        int[] getIndexListAsInt();
+        int[] getIndexListAsIntLocked();
+        float[] getVertexListAsFloat();
+        float[] getVertexListAsFloatLocked();
+        void getIndexListAsPtrToIntArray(out IntPtr indices, out int triStride, out int indexCount);
+        void getVertexListAsPtrToFloatArray(out IntPtr vertexList, out int vertexStride, out int vertexCount);
+        void releaseSourceMeshData();
+        void releasePinned();
+        void Append(IMesh newMesh);
+        void TransformLinear(float[,] matrix, float[] offset);
+        Vector3 GetCentroid();
+        Vector3 GetOBB();
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/IPhysicsParameters.cs b/OpenSim/Region/PhysicsModules/SharedBase/IPhysicsParameters.cs
new file mode 100755
index 0000000..fb0c9e2
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/IPhysicsParameters.cs
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using OpenSim.Framework;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.SharedBase
+{
+    public struct PhysParameterEntry
+    {
+        // flags to say to apply to all or no instances (I wish one could put consts into interfaces)
+        public const uint APPLY_TO_ALL = 0xfffffff3;
+        public const uint APPLY_TO_NONE = 0xfffffff4;
+
+        // values that denote true and false values
+        public const float NUMERIC_TRUE = 1f;
+        public const float NUMERIC_FALSE = 0f;
+
+        public string name;
+        public string desc;
+
+        public PhysParameterEntry(string n, string d)
+        {
+            name = n;
+            desc = d;
+        }
+    }
+
+    // Interface for a physics scene that implements the runtime setting and getting of physics parameters
+    public interface IPhysicsParameters
+    {
+        // Get the list of parameters this physics engine supports
+        PhysParameterEntry[] GetParameterList();
+
+        // Set parameter on a specific or all instances.
+        // Return 'false' if not able to set the parameter.
+        bool SetPhysicsParameter(string parm, string value, uint localID);
+
+        // Get parameter.
+        // Return 'false' if not able to get the parameter.
+        bool GetPhysicsParameter(string parm, out string value);
+
+        // Get parameter from a particular object
+        // TODO:
+        // bool GetPhysicsParameter(string parm, out string value, uint localID);
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/NullPhysicsScene.cs b/OpenSim/Region/PhysicsModules/SharedBase/NullPhysicsScene.cs
new file mode 100644
index 0000000..432708c
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/NullPhysicsScene.cs
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Collections.Generic;
+using System.Reflection;
+using log4net;
+using Nini.Config;
+using OpenSim.Framework;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.SharedBase
+{
+    class NullPhysicsScene : PhysicsScene
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        
+        private static int m_workIndicator;
+
+        public override PhysicsActor AddAvatar(
+            string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        {
+            m_log.InfoFormat("[PHYSICS]: NullPhysicsScene : AddAvatar({0})", position);
+            return PhysicsActor.Null;
+        }
+
+        public override void RemoveAvatar(PhysicsActor actor)
+        {
+        }
+
+        public override void RemovePrim(PhysicsActor prim)
+        {
+        }
+        public override void SetWaterLevel(float baseheight)
+        {
+
+        }
+
+/*
+        public override PhysicsActor AddPrim(Vector3 position, Vector3 size, Quaternion rotation)
+        {
+            m_log.InfoFormat("NullPhysicsScene : AddPrim({0},{1})", position, size);
+            return PhysicsActor.Null;
+        }
+*/
+
+        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, uint localid)
+        {
+            m_log.InfoFormat("[PHYSICS]: NullPhysicsScene : AddPrim({0},{1})", position, size);
+            return PhysicsActor.Null;
+        }
+
+        public override void AddPhysicsActorTaint(PhysicsActor prim)
+        {
+        }
+
+        public override float Simulate(float timeStep)
+        {
+            m_workIndicator = (m_workIndicator + 1) % 10;
+
+            return 0f;
+        }
+
+        public override void GetResults()
+        {
+            m_log.Info("[PHYSICS]: NullPhysicsScene : GetResults()");
+        }
+
+        public override void SetTerrain(float[] heightMap)
+        {
+            m_log.InfoFormat("[PHYSICS]: NullPhysicsScene : SetTerrain({0} items)", heightMap.Length);
+        }
+
+        public override void DeleteTerrain()
+        {
+        }
+
+        public override bool IsThreaded
+        {
+            get { return false; }
+        }
+
+        public override void Dispose()
+        {
+        }
+
+        public override Dictionary<uint,float> GetTopColliders()
+        {
+            Dictionary<uint, float> returncolliders = new Dictionary<uint, float>();
+            return returncolliders;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs
new file mode 100644
index 0000000..edc41e4
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs
@@ -0,0 +1,639 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using log4net;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenSim.Framework;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.SharedBase
+{
+    public delegate void PositionUpdate(Vector3 position);
+    public delegate void VelocityUpdate(Vector3 velocity);
+    public delegate void OrientationUpdate(Quaternion orientation);
+
+    public enum ActorTypes : int
+    {
+        Unknown = 0,
+        Agent = 1,
+        Prim = 2,
+        Ground = 3,
+        Water = 4
+    }
+
+    public enum PIDHoverType
+    {
+        Ground,
+        GroundAndWater,
+        Water,
+        Absolute
+    }
+
+    public struct ContactPoint
+    {
+        public Vector3 Position;
+        public Vector3 SurfaceNormal;
+        public float PenetrationDepth;
+        public float RelativeSpeed;
+        public bool CharacterFeet;
+
+        public ContactPoint(Vector3 position, Vector3 surfaceNormal, float penetrationDepth)
+        {
+            Position = position;
+            SurfaceNormal = surfaceNormal;
+            PenetrationDepth = penetrationDepth;
+            RelativeSpeed = 0f; // for now let this one be set explicity
+            CharacterFeet = true;  // keep other plugins work as before
+        }
+
+        public ContactPoint(Vector3 position, Vector3 surfaceNormal, float penetrationDepth, bool feet)
+        {
+            Position = position;
+            SurfaceNormal = surfaceNormal;
+            PenetrationDepth = penetrationDepth;
+            RelativeSpeed = 0f; // for now let this one be set explicity
+            CharacterFeet = feet;  // keep other plugins work as before
+        }
+    }
+
+    public struct ContactData
+    {
+        public float mu;
+        public float bounce;
+        public bool softcolide;
+
+        public ContactData(float _mu, float _bounce, bool _softcolide)
+        {
+            mu = _mu;
+            bounce = _bounce;
+            softcolide = _softcolide;
+        }
+    }
+    /// <summary>
+    /// Used to pass collision information to OnCollisionUpdate listeners.
+    /// </summary>
+    public class CollisionEventUpdate : EventArgs
+    {
+        /// <summary>
+        /// Number of collision events in this update.
+        /// </summary>
+        public int Count { get { return m_objCollisionList.Count; } }
+
+        public bool CollisionsOnPreviousFrame { get; private set; }
+
+        public Dictionary<uint, ContactPoint> m_objCollisionList;
+
+        public CollisionEventUpdate(Dictionary<uint, ContactPoint> objCollisionList)
+        {
+            m_objCollisionList = objCollisionList;
+        }
+
+        public CollisionEventUpdate()
+        {
+            m_objCollisionList = new Dictionary<uint, ContactPoint>();
+        }
+
+        public void AddCollider(uint localID, ContactPoint contact)
+        {
+            if (!m_objCollisionList.ContainsKey(localID))
+            {
+                m_objCollisionList.Add(localID, contact);
+            }
+            else
+            {              
+                if (m_objCollisionList[localID].PenetrationDepth < contact.PenetrationDepth)
+                    m_objCollisionList[localID] = contact;
+            }
+        }
+
+        /// <summary>
+        /// Clear added collision events.
+        /// </summary>
+        public void Clear()
+        {
+            m_objCollisionList.Clear();
+        }
+    }
+
+    public abstract class PhysicsActor
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        public delegate void RequestTerseUpdate();
+        public delegate void CollisionUpdate(EventArgs e);
+        public delegate void OutOfBounds(Vector3 pos);
+
+// disable warning: public events
+#pragma warning disable 67
+        public event PositionUpdate OnPositionUpdate;
+        public event VelocityUpdate OnVelocityUpdate;
+        public event OrientationUpdate OnOrientationUpdate;
+        public event RequestTerseUpdate OnRequestTerseUpdate;
+
+        /// <summary>
+        /// Subscribers to this event must synchronously handle the dictionary of collisions received, since the event
+        /// object is reused in subsequent physics frames.
+        /// </summary>
+        public event CollisionUpdate OnCollisionUpdate;
+
+        public virtual void SetVehicle(object vdata) { }
+
+        public event OutOfBounds OnOutOfBounds;
+#pragma warning restore 67
+
+        public static PhysicsActor Null
+        {
+            get { return new NullPhysicsActor(); }
+        }
+   
+        public virtual bool Building { get; set; }
+
+        public virtual void getContactData(ref ContactData cdata)
+        {
+            cdata.mu = 0;
+            cdata.bounce = 0;
+        }
+
+        public abstract bool Stopped { get; }
+
+        public abstract Vector3 Size { get; set; }
+
+        public virtual void setAvatarSize(Vector3 size, float feetOffset)
+        {
+            Size = size;
+        }
+
+        public virtual bool Phantom { get; set; }
+
+        public virtual bool IsVolumeDtc
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public virtual byte PhysicsShapeType { get; set; }
+
+        public abstract PrimitiveBaseShape Shape { set; }
+
+        uint m_baseLocalID;
+        public virtual uint LocalID
+        {
+            set { m_baseLocalID = value; }
+            get { return m_baseLocalID; }
+        }
+
+        public abstract bool Grabbed { set; }
+
+        public abstract bool Selected { set; }
+
+        /// <summary>
+        /// Name of this actor.
+        /// </summary>
+        /// <remarks>
+        /// XXX: Bizarrely, this cannot be "Terrain" or "Water" right now unless it really is simulating terrain or
+        /// water.  This is not a problem due to the formatting of names given by prims and avatars.
+        /// </remarks>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// This is being used by ODE joint code.
+        /// </summary>
+        public string SOPName;
+
+        public abstract void CrossingFailure();
+
+        public abstract void link(PhysicsActor obj);
+
+        public abstract void delink();
+
+        public abstract void LockAngularMotion(Vector3 axis);
+
+        public virtual void RequestPhysicsterseUpdate()
+        {
+            // Make a temporary copy of the event to avoid possibility of
+            // a race condition if the last subscriber unsubscribes
+            // immediately after the null check and before the event is raised.
+            RequestTerseUpdate handler = OnRequestTerseUpdate;
+
+            if (handler != null)
+            {
+                handler();
+            }
+        }
+
+        public virtual void RaiseOutOfBounds(Vector3 pos)
+        {
+            // Make a temporary copy of the event to avoid possibility of
+            // a race condition if the last subscriber unsubscribes
+            // immediately after the null check and before the event is raised.
+            OutOfBounds handler = OnOutOfBounds;
+
+            if (handler != null)
+            {
+                handler(pos);
+            }
+        }
+
+        public virtual void SendCollisionUpdate(EventArgs e)
+        {
+            CollisionUpdate handler = OnCollisionUpdate;
+
+//            m_log.DebugFormat("[PHYSICS ACTOR]: Sending collision for {0}", LocalID);
+
+            if (handler != null)
+                handler(e);
+        }
+
+        public virtual void SetMaterial (int material) { }
+        public virtual float Density { get; set; }
+        public virtual float GravModifier { get; set; }
+        public virtual float Friction { get; set; }
+        public virtual float Restitution { get; set; }
+
+        /// <summary>
+        /// Position of this actor.
+        /// </summary>
+        /// <remarks>
+        /// Setting this directly moves the actor to a given position.
+        /// Getting this retrieves the position calculated by physics scene updates, using factors such as velocity and
+        /// collisions.
+        /// </remarks>
+        public abstract Vector3 Position { get; set; }
+
+        public abstract float Mass { get; }
+        public abstract Vector3 Force { get; set; }
+
+        public abstract int VehicleType { get; set; }
+        public abstract void VehicleFloatParam(int param, float value);
+        public abstract void VehicleVectorParam(int param, Vector3 value);
+        public abstract void VehicleRotationParam(int param, Quaternion rotation);
+        public abstract void VehicleFlags(int param, bool remove);
+
+        /// <summary>
+        /// Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more
+        /// </summary>
+        public abstract void SetVolumeDetect(int param);
+
+        public abstract Vector3 GeometricCenter { get; }
+        public abstract Vector3 CenterOfMass { get; }
+
+        public virtual Vector3 OOBsize
+        {
+            get
+                {
+                Vector3 s=Size;
+                s.X *=0.5f;
+                s.Y *=0.5f;
+                s.Z *=0.5f;
+                return s;
+                } 
+        }
+
+        public virtual Vector3 OOBoffset
+        {
+            get
+            {
+                return Vector3.Zero;
+            }
+        }
+
+        public virtual float OOBRadiusSQ
+        {
+            get
+            {
+                return Size.LengthSquared() * 0.25f; // ((0.5^2)
+            }
+        }
+
+
+        public virtual float PhysicsCost
+        {
+            get
+            {
+                return 0.1f;
+            }
+        }
+
+        public virtual float StreamCost
+        {
+            get
+            {
+                return 1.0f;
+            }
+        }
+
+        /// <summary>
+        /// The desired velocity of this actor.
+        /// </summary>
+        /// <remarks>
+        /// Setting this provides a target velocity for physics scene updates.
+        /// Getting this returns the last set target. Fetch Velocity to get the current velocity.
+        /// </remarks>
+        protected Vector3 m_targetVelocity;
+        public virtual Vector3 TargetVelocity
+        {
+            get { return m_targetVelocity; }
+            set {
+                m_targetVelocity = value;
+                Velocity = m_targetVelocity;
+            }
+        }
+
+        public abstract Vector3 Velocity { get; set; }
+
+        public abstract Vector3 Torque { get; set; }
+        public abstract float CollisionScore { get; set;}
+        public abstract Vector3 Acceleration { get; set; }
+        public abstract Quaternion Orientation { get; set; }
+        public abstract int PhysicsActorType { get; set; }
+        public abstract bool IsPhysical { get; set; }
+        public abstract bool Flying { get; set; }
+        public abstract bool SetAlwaysRun { get; set; }
+        public abstract bool ThrottleUpdates { get; set; }
+        public abstract bool IsColliding { get; set; }
+        public abstract bool CollidingGround { get; set; }
+        public abstract bool CollidingObj { get; set; }
+        public abstract bool FloatOnWater { set; }
+        public abstract Vector3 RotationalVelocity { get; set; }
+        public abstract bool Kinematic { get; set; }
+        public abstract float Buoyancy { get; set; }
+
+        // Used for MoveTo
+        public abstract Vector3 PIDTarget { set; }
+        public abstract bool PIDActive { get; set; }
+        public abstract float PIDTau { set; }
+
+        // Used for llSetHoverHeight and maybe vehicle height
+        // Hover Height will override MoveTo target's Z
+        public abstract bool PIDHoverActive { set;}
+        public abstract float PIDHoverHeight { set;}
+        public abstract PIDHoverType PIDHoverType { set;}
+        public abstract float PIDHoverTau { set;}
+
+        // For RotLookAt
+        public abstract Quaternion APIDTarget { set;}
+        public abstract bool APIDActive { set;}
+        public abstract float APIDStrength { set;}
+        public abstract float APIDDamping { set;}
+        
+        public abstract void AddForce(Vector3 force, bool pushforce);
+        public abstract void AddAngularForce(Vector3 force, bool pushforce);
+        public abstract void SetMomentum(Vector3 momentum);
+        public abstract void SubscribeEvents(int ms);
+        public abstract void UnSubscribeEvents();
+        public abstract bool SubscribedEvents();
+
+        public virtual void AddCollisionEvent(uint CollidedWith, ContactPoint contact) { }
+
+        // Warning in a parent part it returns itself, not null
+        public virtual PhysicsActor ParentActor { get { return this; } }
+        
+
+        // Extendable interface for new, physics engine specific operations
+        public virtual object Extension(string pFunct, params object[] pParams)
+        {
+            // A NOP of the physics engine does not implement this feature
+            return null;
+        }
+    }
+
+    public class NullPhysicsActor : PhysicsActor
+    {
+        private ActorTypes m_actorType = ActorTypes.Unknown;
+
+        public override bool Stopped
+        {
+            get{ return true; }
+        }
+
+        public override Vector3 Position
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override bool SetAlwaysRun
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override uint LocalID
+        {
+            get { return 0; }
+            set { return; }
+        }
+
+        public override bool Grabbed
+        {
+            set { return; }
+        }
+
+        public override bool Selected
+        {
+            set { return; }
+        }
+
+        public override float Buoyancy
+        {
+            get { return 0f; }
+            set { return; }
+        }
+
+        public override bool  FloatOnWater
+        {
+            set { return; }
+        }
+
+        public override bool CollidingGround
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool CollidingObj
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override Vector3 Size
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override float Mass
+        {
+            get { return 0f; }
+        }
+
+        public override Vector3 Force
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override int VehicleType
+        {
+            get { return 0; }
+            set { return; }
+        }
+
+        public override void VehicleFloatParam(int param, float value) {}
+        public override void VehicleVectorParam(int param, Vector3 value) { }
+        public override void VehicleRotationParam(int param, Quaternion rotation) { }
+        public override void VehicleFlags(int param, bool remove) { }
+        public override void SetVolumeDetect(int param) {}
+        public override void SetMaterial(int material) {}
+        public override Vector3 CenterOfMass { get { return Vector3.Zero; }}
+
+        public override Vector3 GeometricCenter { get { return Vector3.Zero; }}
+
+        public override PrimitiveBaseShape Shape { set { return; }}
+
+        public override Vector3 Velocity
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override Vector3 Torque
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override float CollisionScore
+        {
+            get { return 0f; }
+            set { }
+        }
+
+        public override void CrossingFailure() {}
+
+        public override Quaternion Orientation
+        {
+            get { return Quaternion.Identity; }
+            set { }
+        }
+
+        public override Vector3 Acceleration
+        {
+            get { return Vector3.Zero; }
+            set { }
+        }
+
+        public override bool IsPhysical
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Flying
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool ThrottleUpdates
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool IsColliding
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override int PhysicsActorType
+        {
+            get { return (int)m_actorType; }
+            set {               
+                ActorTypes type = (ActorTypes)value;
+                switch (type)
+                {
+                    case ActorTypes.Ground:
+                    case ActorTypes.Water:
+                        m_actorType = type;
+                        break;
+                    default:
+                        m_actorType = ActorTypes.Unknown;
+                        break;
+                }
+            }
+        }
+
+        public override bool Kinematic
+        {
+            get { return true; }
+            set { return; }
+        }
+
+        public override void link(PhysicsActor obj) { }
+        public override void delink() { }
+        public override void LockAngularMotion(Vector3 axis) { }
+        public override void AddForce(Vector3 force, bool pushforce) { }
+        public override void AddAngularForce(Vector3 force, bool pushforce) { }
+
+        public override Vector3 RotationalVelocity
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override Vector3 PIDTarget { set { return; } }
+
+        public override bool PIDActive 
+        {
+            get { return false; }
+            set { return; } 
+        }
+
+        public override float PIDTau { set { return; } }
+
+        public override float PIDHoverHeight { set { return; } }
+        public override bool PIDHoverActive { set { return; } }
+        public override PIDHoverType PIDHoverType { set { return; } }
+        public override float PIDHoverTau { set { return; } }
+        
+        public override Quaternion APIDTarget { set { return; } }
+        public override bool APIDActive { set { return; } }
+        public override float APIDStrength { set { return; } }
+        public override float APIDDamping { set { return; } }
+        
+        public override void SetMomentum(Vector3 momentum) { }
+
+        public override void SubscribeEvents(int ms) { }
+        public override void UnSubscribeEvents() { }
+        public override bool SubscribedEvents() { return false; }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsJoint.cs b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsJoint.cs
new file mode 100644
index 0000000..ce2bf05
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsJoint.cs
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using OpenSim.Framework;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.SharedBase
+{
+    public enum PhysicsJointType : int
+    {
+        Ball = 0,
+        Hinge = 1
+    }
+
+    public class PhysicsJoint
+    {
+        public virtual bool IsInPhysicsEngine { get { return false; } } // set internally to indicate if this joint has already been passed to the physics engine or is still pending
+        public PhysicsJointType Type;
+        public string RawParams;
+        public List<string> BodyNames = new List<string>();
+        public Vector3 Position; // global coords
+        public Quaternion Rotation; // global coords
+        public string ObjectNameInScene; // proxy object in scene that represents the joint position/orientation
+        public string TrackedBodyName; // body name that this joint is attached to (ObjectNameInScene will follow TrackedBodyName)
+        public Quaternion LocalRotation; // joint orientation relative to one of the involved bodies, the tracked body
+        public int ErrorMessageCount; // total # of error messages printed for this joint since its creation. if too many, further error messages are suppressed to prevent flooding.
+        public const int maxErrorMessages = 100; // no more than this # of error messages will be printed for each joint
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsScene.cs b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsScene.cs
new file mode 100644
index 0000000..1c0ad20
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsScene.cs
@@ -0,0 +1,420 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+using log4net;
+using Nini.Config;
+
+using OpenSim.Framework;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.SharedBase
+{
+    public delegate void physicsCrash();
+
+    public delegate void RaycastCallback(bool hitYN, Vector3 collisionPoint, uint localid, float distance, Vector3 normal);
+    public delegate void RayCallback(List<ContactResult> list);
+    public delegate void ProbeBoxCallback(List<ContactResult> list);
+    public delegate void ProbeSphereCallback(List<ContactResult> list);
+    public delegate void ProbePlaneCallback(List<ContactResult> list);
+    public delegate void SitAvatarCallback(int status, uint partID, Vector3 offset, Quaternion Orientation);
+
+    public delegate void JointMoved(PhysicsJoint joint);
+    public delegate void JointDeactivated(PhysicsJoint joint);
+    public delegate void JointErrorMessage(PhysicsJoint joint, string message); // this refers to an "error message due to a problem", not "amount of joint constraint violation"
+
+    public enum RayFilterFlags : ushort
+    {
+        // the flags
+        water = 0x01,
+        land = 0x02,
+        agent = 0x04,
+        nonphysical = 0x08,
+        physical = 0x10,
+        phantom = 0x20,
+        volumedtc = 0x40,
+
+        // ray cast colision control (may only work for meshs)
+        ContactsUnImportant = 0x2000,
+        BackFaceCull = 0x4000,
+        ClosestHit = 0x8000,
+
+        // some combinations
+        LSLPhantom = phantom | volumedtc,
+        PrimsNonPhantom = nonphysical | physical,
+        PrimsNonPhantomAgents = nonphysical | physical | agent,
+
+        AllPrims = nonphysical | phantom | volumedtc | physical,
+        AllButLand = agent | nonphysical | physical | phantom | volumedtc,
+
+        ClosestAndBackCull = ClosestHit | BackFaceCull,
+
+        All = 0x3f
+    }
+
+    public delegate void RequestAssetDelegate(UUID assetID, AssetReceivedDelegate callback);
+    public delegate void AssetReceivedDelegate(AssetBase asset);
+
+    /// <summary>
+    /// Contact result from a raycast.
+    /// </summary>
+    public struct ContactResult
+    {
+        public Vector3 Pos;
+        public float Depth;
+        public uint ConsumerID;
+        public Vector3 Normal;
+    }
+
+
+
+    public abstract class PhysicsScene
+    {
+//        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// A unique identifying string for this instance of the physics engine.
+        /// Useful in debug messages to distinguish one OdeScene instance from another.
+        /// Usually set to include the region name that the physics engine is acting for.
+        /// </summary>
+        public string PhysicsSceneName { get; protected set; }
+
+        /// <summary>
+        /// A string identifying the family of this physics engine. Most common values returned
+        /// are "OpenDynamicsEngine" and "BulletSim" but others are possible.
+        /// </summary>
+        public string EngineType { get; protected set; }
+
+        // The only thing that should register for this event is the SceneGraph
+        // Anything else could cause problems.
+        public event physicsCrash OnPhysicsCrash;
+
+        public static PhysicsScene Null
+        {
+            get { return new NullPhysicsScene(); }
+        }
+
+        public RequestAssetDelegate RequestAssetMethod { get; set; }
+
+        protected void Initialise(RequestAssetDelegate m, float[] terrain, float waterHeight)
+        {
+            RequestAssetMethod = m;
+            SetTerrain(terrain);
+            SetWaterLevel(waterHeight);
+
+        }
+
+        public virtual void TriggerPhysicsBasedRestart()
+        {
+            physicsCrash handler = OnPhysicsCrash;
+            if (handler != null)
+            {
+                OnPhysicsCrash();
+            }
+        }
+
+        /// <summary>
+        /// Add an avatar
+        /// </summary>
+        /// <param name="avName"></param>
+        /// <param name="position"></param>
+        /// <param name="velocity"></param>
+        /// <param name="size"></param>
+        /// <param name="isFlying"></param>
+        /// <returns></returns>
+
+        public abstract PhysicsActor AddAvatar(
+            string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying);
+
+        /// <summary>
+        /// Add an avatar
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <param name="avName"></param>
+        /// <param name="position"></param>
+        /// <param name="velocity"></param>
+        /// <param name="size"></param>
+        /// <param name="isFlying"></param>
+        /// <returns></returns>
+        public virtual PhysicsActor AddAvatar(
+            uint localID, string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        {
+            PhysicsActor ret = AddAvatar(avName, position, velocity, size, isFlying);
+
+            if (ret != null)
+                ret.LocalID = localID;
+
+            return ret;
+        }
+
+        public virtual PhysicsActor AddAvatar(
+            uint localID, string avName, Vector3 position, Vector3 size, bool isFlying)
+        {
+            PhysicsActor ret = AddAvatar(localID, avName, position, Vector3.Zero, size, isFlying);             
+            return ret;
+        }
+
+        public virtual PhysicsActor AddAvatar(
+            uint localID, string avName, Vector3 position, Vector3 size, float feetOffset, bool isFlying)
+        {
+            PhysicsActor ret = AddAvatar(localID, avName, position, Vector3.Zero, size, isFlying);
+            return ret;
+        }
+
+        /// <summary>
+        /// Remove an avatar.
+        /// </summary>
+        /// <param name="actor"></param>
+        public abstract void RemoveAvatar(PhysicsActor actor);
+
+        /// <summary>
+        /// Remove a prim.
+        /// </summary>
+        /// <param name="prim"></param>
+        public abstract void RemovePrim(PhysicsActor prim);
+
+        public abstract PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, uint localid);
+
+        public virtual PhysicsActor AddPrimShape(string primName, PhysicsActor parent, PrimitiveBaseShape pbs, Vector3 position,
+                                                  uint localid, byte[] sdata)
+        {
+            return null;
+        }
+
+        public virtual PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, uint localid)
+        {
+            return AddPrimShape(primName, pbs, position, size, rotation, isPhysical, localid);
+        }
+
+                           
+        public virtual PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, byte shapetype, uint localid)
+        {
+            return AddPrimShape(primName, pbs, position, size, rotation, isPhysical, localid);
+        }
+
+        public virtual float TimeDilation
+        {
+            get { return 1.0f; }
+        }
+
+        public virtual bool SupportsNINJAJoints
+        {
+            get { return false; }
+        }
+
+        public virtual PhysicsJoint RequestJointCreation(string objectNameInScene, PhysicsJointType jointType, Vector3 position,
+                                            Quaternion rotation, string parms, List<string> bodyNames, string trackedBodyName, Quaternion localRotation)
+        { return null; }
+
+        public virtual void RequestJointDeletion(string objectNameInScene)
+        { return; }
+
+        public virtual void RemoveAllJointsConnectedToActorThreadLocked(PhysicsActor actor)
+        { return; }
+
+        public virtual void DumpJointInfo()
+        { return; }
+
+        public event JointMoved OnJointMoved;
+
+        protected virtual void DoJointMoved(PhysicsJoint joint)
+        {
+            // We need this to allow subclasses (but not other classes) to invoke the event; C# does
+            // not allow subclasses to invoke the parent class event.
+            if (OnJointMoved != null)
+            {
+                OnJointMoved(joint);
+            }
+        }
+
+        public event JointDeactivated OnJointDeactivated;
+
+        protected virtual void DoJointDeactivated(PhysicsJoint joint)
+        {
+            // We need this to allow subclasses (but not other classes) to invoke the event; C# does
+            // not allow subclasses to invoke the parent class event.
+            if (OnJointDeactivated != null)
+            {
+                OnJointDeactivated(joint);
+            }
+        }
+
+        public event JointErrorMessage OnJointErrorMessage;
+
+        protected virtual void DoJointErrorMessage(PhysicsJoint joint, string message)
+        {
+            // We need this to allow subclasses (but not other classes) to invoke the event; C# does
+            // not allow subclasses to invoke the parent class event.
+            if (OnJointErrorMessage != null)
+            {
+                OnJointErrorMessage(joint, message);
+            }
+        }
+
+        public virtual Vector3 GetJointAnchor(PhysicsJoint joint)
+        { return Vector3.Zero; }
+
+        public virtual Vector3 GetJointAxis(PhysicsJoint joint)
+        { return Vector3.Zero; }
+
+        public abstract void AddPhysicsActorTaint(PhysicsActor prim);
+
+
+        public virtual void PrepareSimulation() { }
+
+        /// <summary>
+        /// Perform a simulation of the current physics scene over the given timestep.
+        /// </summary>
+        /// <param name="timeStep"></param>
+        /// <returns>The number of frames simulated over that period.</returns>
+        public abstract float Simulate(float timeStep);
+
+        /// <summary>
+        /// Get statistics about this scene.
+        /// </summary>
+        /// <remarks>This facility is currently experimental and subject to change.</remarks>
+        /// <returns>
+        /// A dictionary where the key is the statistic name.  If no statistics are supplied then returns null.
+        /// </returns>
+        public virtual Dictionary<string, float> GetStats() { return null; }
+
+        public abstract void GetResults();
+
+        public abstract void SetTerrain(float[] heightMap);
+
+        public abstract void SetWaterLevel(float baseheight);
+
+        public abstract void DeleteTerrain();
+
+        public abstract void Dispose();
+
+        public abstract Dictionary<uint, float> GetTopColliders();
+
+        public abstract bool IsThreaded { get; }
+
+        /// <summary>
+        /// True if the physics plugin supports raycasting against the physics scene
+        /// </summary>
+        public virtual bool SupportsRayCast()
+        {
+            return false;
+        }
+
+        public virtual bool SupportsCombining()
+        {
+            return false;
+        }
+
+        public virtual void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents) {}
+        public virtual void CombineTerrain(float[] heightMap, Vector3 pOffset) {}
+        public virtual void UnCombine(PhysicsScene pScene) {}
+
+        /// <summary>
+        /// Queue a raycast against the physics scene.
+        /// The provided callback method will be called when the raycast is complete
+        /// 
+        /// Many physics engines don't support collision testing at the same time as 
+        /// manipulating the physics scene, so we queue the request up and callback 
+        /// a custom method when the raycast is complete.
+        /// This allows physics engines that give an immediate result to callback immediately
+        /// and ones that don't, to callback when it gets a result back.
+        /// 
+        /// ODE for example will not allow you to change the scene while collision testing or
+        /// it asserts, 'opteration not valid for locked space'.  This includes adding a ray to the scene.
+        /// 
+        /// This is named RayCastWorld to not conflict with modrex's Raycast method.
+        /// </summary>
+        /// <param name="position">Origin of the ray</param>
+        /// <param name="direction">Direction of the ray</param>
+        /// <param name="length">Length of ray in meters</param>
+        /// <param name="retMethod">Method to call when the raycast is complete</param>
+        public virtual void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
+        {
+            if (retMethod != null)
+                retMethod(false, Vector3.Zero, 0, 999999999999f, Vector3.Zero);
+        }
+
+        public virtual void RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayCallback retMethod)
+        {
+            if (retMethod != null)
+                retMethod(new List<ContactResult>());
+        }
+
+        public virtual List<ContactResult> RaycastWorld(Vector3 position, Vector3 direction, float length, int Count)
+        {
+            return new List<ContactResult>();
+        }
+
+        public virtual object RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags filter)
+        {
+            return null;
+        }
+
+        public virtual bool SupportsRaycastWorldFiltered()
+        {
+            return false;
+        }
+
+        public virtual List<ContactResult> RaycastActor(PhysicsActor actor, Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags flags)
+        {
+            return new List<ContactResult>();
+        }
+
+        public virtual List<ContactResult> BoxProbe(Vector3 position, Vector3 size, Quaternion orientation, int Count, RayFilterFlags flags)
+        {
+            return new List<ContactResult>();
+        }
+
+        public virtual List<ContactResult> SphereProbe(Vector3 position, float radius, int Count, RayFilterFlags flags)
+        {
+            return new List<ContactResult>();
+        }
+
+        public virtual List<ContactResult> PlaneProbe(PhysicsActor actor, Vector4 plane, int Count, RayFilterFlags flags)
+        {
+            return new List<ContactResult>();
+        }
+
+        public virtual int SitAvatar(PhysicsActor actor, Vector3 AbsolutePosition, Vector3 CameraPosition, Vector3 offset, Vector3 AvatarSize, SitAvatarCallback PhysicsSitResponse)
+        {
+            return 0;
+        }
+
+        // Extendable interface for new, physics engine specific operations
+        public virtual object Extension(string pFunct, params object[] pParams)
+        {
+            // A NOP if the extension thing is not implemented by the physics engine
+            return null;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsSensor.cs b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsSensor.cs
new file mode 100644
index 0000000..da9c96c
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsSensor.cs
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Timers;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.SharedBase
+{
+    [Flags]
+    public enum SenseType : uint
+    {
+        NONE = 0,
+        AGENT = 1,
+        ACTIVE = 2,
+        PASSIVE = 3,
+        SCRIPTED = 4
+    }
+
+    public abstract class PhysicsSensor
+    {
+        public static PhysicsSensor Null
+        {
+            get { return new NullPhysicsSensor(); }
+        }
+        public abstract Vector3 Position { get; set; }
+        public abstract void TimerCallback (object obj, ElapsedEventArgs eea);
+        public abstract float radianarc {get; set;}
+        public abstract string targetname {get; set;}
+        public abstract Guid targetKey{get;set;}
+        public abstract SenseType sensetype { get;set;}
+        public abstract float range { get;set;}
+        public abstract float rateSeconds { get;set;}
+    }
+
+    public class NullPhysicsSensor : PhysicsSensor
+    {
+        public override Vector3 Position
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+        public override void TimerCallback(object obj, ElapsedEventArgs eea)
+        {
+            // don't do squat
+        }
+        public override float radianarc { get { return 0f; } set { } }
+        public override string targetname { get { return ""; } set { } }
+        public override Guid targetKey { get { return Guid.Empty; } set { } }
+        public override SenseType sensetype { get { return SenseType.NONE; } set { } }
+        public override float range { get { return 0; } set { } }
+        public override float rateSeconds { get { return 0; } set { } }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsVector.cs b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsVector.cs
new file mode 100644
index 0000000..76a82fa
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsVector.cs
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+
+namespace OpenSim.Region.PhysicsModules.SharedBase
+{
+    /*public class PhysicsVector
+    {
+        public float X;
+        public float Y;
+        public float Z;
+
+        public Vector3()
+        {
+        }
+
+        public Vector3(float x, float y, float z)
+        {
+            X = x;
+            Y = y;
+            Z = z;
+        }
+
+        public Vector3(Vector3 pv) : this(pv.X, pv.Y, pv.Z)
+        {
+        }
+        
+        public void setValues(float x, float y, float z)
+        {
+            X = x;
+            Y = y;
+            Z = z;
+        }
+
+        public static readonly PhysicsVector Zero = new PhysicsVector(0f, 0f, 0f);
+
+        public override string ToString()
+        {
+            return "<" + X + "," + Y + "," + Z + ">";
+        }
+
+        /// <summary>
+        /// These routines are the easiest way to store XYZ values in an Vector3 without requiring 3 calls.
+        /// </summary>
+        /// <returns></returns>
+        public byte[] GetBytes()
+        {
+            byte[] byteArray = new byte[12];
+
+            Buffer.BlockCopy(BitConverter.GetBytes(X), 0, byteArray, 0, 4);
+            Buffer.BlockCopy(BitConverter.GetBytes(Y), 0, byteArray, 4, 4);
+            Buffer.BlockCopy(BitConverter.GetBytes(Z), 0, byteArray, 8, 4);
+
+            if (!BitConverter.IsLittleEndian)
+            {
+                Array.Reverse(byteArray, 0, 4);
+                Array.Reverse(byteArray, 4, 4);
+                Array.Reverse(byteArray, 8, 4);
+            }
+
+            return byteArray;
+        }
+
+        public void FromBytes(byte[] byteArray, int pos)
+        {
+            byte[] conversionBuffer = null;
+            if (!BitConverter.IsLittleEndian)
+            {
+                // Big endian architecture
+                if (conversionBuffer == null)
+                    conversionBuffer = new byte[12];
+
+                Buffer.BlockCopy(byteArray, pos, conversionBuffer, 0, 12);
+
+                Array.Reverse(conversionBuffer, 0, 4);
+                Array.Reverse(conversionBuffer, 4, 4);
+                Array.Reverse(conversionBuffer, 8, 4);
+
+                X = BitConverter.ToSingle(conversionBuffer, 0);
+                Y = BitConverter.ToSingle(conversionBuffer, 4);
+                Z = BitConverter.ToSingle(conversionBuffer, 8);
+            }
+            else
+            {
+                // Little endian architecture
+                X = BitConverter.ToSingle(byteArray, pos);
+                Y = BitConverter.ToSingle(byteArray, pos + 4);
+                Z = BitConverter.ToSingle(byteArray, pos + 8);
+            }
+        }
+
+        // Operations
+        public static PhysicsVector operator +(Vector3 a, Vector3 b)
+        {
+            return new PhysicsVector(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
+        }
+
+        public static PhysicsVector operator -(Vector3 a, Vector3 b)
+        {
+            return new PhysicsVector(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
+        }
+
+        public static PhysicsVector cross(Vector3 a, Vector3 b)
+        {
+            return new PhysicsVector(a.Y*b.Z - a.Z*b.Y, a.Z*b.X - a.X*b.Z, a.X*b.Y - a.Y*b.X);
+        }
+
+        public float length()
+        {
+            return (float) Math.Sqrt(X*X + Y*Y + Z*Z);
+        }
+
+        public static float GetDistanceTo(Vector3 a, Vector3 b)
+        {
+            float dx = a.X - b.X;
+            float dy = a.Y - b.Y;
+            float dz = a.Z - b.Z;
+            return (float) Math.Sqrt(dx * dx + dy * dy + dz * dz);
+        }
+
+        public static PhysicsVector operator /(Vector3 v, float f)
+        {
+            return new PhysicsVector(v.X/f, v.Y/f, v.Z/f);
+        }
+
+        public static PhysicsVector operator *(Vector3 v, float f)
+        {
+            return new PhysicsVector(v.X*f, v.Y*f, v.Z*f);
+        }
+
+        public static PhysicsVector operator *(float f, Vector3 v)
+        {
+            return v*f;
+        }
+
+        public static bool isFinite(Vector3 v)
+        {
+            if (v == null)
+                return false;
+            if (Single.IsInfinity(v.X) || Single.IsNaN(v.X))
+                return false;
+            if (Single.IsInfinity(v.Y) || Single.IsNaN(v.Y))
+                return false;
+            if (Single.IsInfinity(v.Z) || Single.IsNaN(v.Z))
+                return false;
+
+            return true;
+        }
+
+        public virtual bool IsIdentical(Vector3 v, float tolerance)
+        {
+            PhysicsVector diff = this - v;
+            float d = diff.length();
+            if (d <= tolerance)
+                return true;
+
+            return false;
+        }
+
+    }*/
+}
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/VehicleConstants.cs b/OpenSim/Region/PhysicsModules/SharedBase/VehicleConstants.cs
new file mode 100644
index 0000000..e850b11
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/SharedBase/VehicleConstants.cs
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.SharedBase
+{
+    public enum Vehicle : int
+    {
+        /// <summary>
+        /// Turns off Vehicle Support
+        /// </summary>
+        TYPE_NONE = 0,
+
+        /// <summary>
+        /// No Angular motor, High Left right friction, No Hover, Linear Deflection 1, no angular deflection 
+        /// no vertical attractor, No banking, Identity rotation frame
+        /// </summary>
+        TYPE_SLED = 1,
+
+        /// <summary>
+        /// Needs Motors to be driven by timer or control events  High left/right friction, No angular friction
+        /// Linear Motor wins in a second, decays in 60 seconds.  Angular motor wins in a second, decays in 8/10ths of a second
+        /// linear deflection 2 seconds
+        /// Vertical Attractor locked UP
+        /// </summary>
+        TYPE_CAR = 2,
+        TYPE_BOAT = 3,
+        TYPE_AIRPLANE = 4,
+        TYPE_BALLOON = 5,
+        LINEAR_FRICTION_TIMESCALE = 16,
+        /// <summary>
+        /// vector of timescales for exponential decay of angular velocity about three axis
+        /// </summary>
+        ANGULAR_FRICTION_TIMESCALE = 17,
+        /// <summary>
+        /// linear velocity vehicle will try for
+        /// </summary>
+        LINEAR_MOTOR_DIRECTION = 18,
+
+        /// <summary>
+        /// Offset from center of mass where linear motor forces are added
+        /// </summary>
+        LINEAR_MOTOR_OFFSET = 20,
+        /// <summary>
+        /// angular velocity that vehicle will try for
+        /// </summary>
+        ANGULAR_MOTOR_DIRECTION = 19,
+        HOVER_HEIGHT = 24,
+        HOVER_EFFICIENCY = 25,
+        HOVER_TIMESCALE = 26,
+        BUOYANCY = 27,
+        LINEAR_DEFLECTION_EFFICIENCY = 28,
+        LINEAR_DEFLECTION_TIMESCALE = 29,
+        LINEAR_MOTOR_TIMESCALE = 30,
+        LINEAR_MOTOR_DECAY_TIMESCALE = 31,
+
+        /// <summary>
+        /// slide between 0 and 1
+        /// </summary>
+        ANGULAR_DEFLECTION_EFFICIENCY = 32,
+        ANGULAR_DEFLECTION_TIMESCALE = 33,
+        ANGULAR_MOTOR_TIMESCALE = 34,
+        ANGULAR_MOTOR_DECAY_TIMESCALE = 35,
+        VERTICAL_ATTRACTION_EFFICIENCY = 36,
+        VERTICAL_ATTRACTION_TIMESCALE = 37,
+        BANKING_EFFICIENCY = 38,
+        BANKING_MIX = 39,
+        BANKING_TIMESCALE = 40,
+        REFERENCE_FRAME = 44,
+        BLOCK_EXIT = 45,
+        ROLL_FRAME = 46
+
+    }
+
+    [Flags]
+    public enum VehicleFlag
+    {
+        NO_DEFLECTION_UP = 1,
+        LIMIT_ROLL_ONLY = 2,
+        HOVER_WATER_ONLY = 4,
+        HOVER_TERRAIN_ONLY = 8,
+        HOVER_GLOBAL_HEIGHT = 16,
+        HOVER_UP_ONLY = 32,
+        LIMIT_MOTOR_UP = 64,
+        MOUSELOOK_STEER = 128,
+        MOUSELOOK_BANK = 256,
+        CAMERA_DECOUPLED = 512,
+        NO_X = 1024,
+        NO_Y = 2048,
+        NO_Z = 4096,
+        LOCK_HOVER_HEIGHT = 8192,
+        NO_DEFLECTION = 16392,
+        LOCK_ROTATION = 32784
+    }
+
+    public struct VehicleData
+    {
+        public Vehicle m_type;
+        public VehicleFlag m_flags;
+
+        // Linear properties
+        public Vector3 m_linearMotorDirection;
+        public Vector3 m_linearFrictionTimescale;
+        public float m_linearMotorDecayTimescale;
+        public float m_linearMotorTimescale;
+        public Vector3 m_linearMotorOffset;
+
+        //Angular properties
+        public Vector3 m_angularMotorDirection;
+        public float m_angularMotorTimescale;
+        public float m_angularMotorDecayTimescale;
+        public Vector3 m_angularFrictionTimescale;
+
+        //Deflection properties
+        public float m_angularDeflectionEfficiency;
+        public float m_angularDeflectionTimescale;
+        public float m_linearDeflectionEfficiency;
+        public float m_linearDeflectionTimescale;
+
+        //Banking properties
+        public float m_bankingEfficiency;
+        public float m_bankingMix;
+        public float m_bankingTimescale;
+
+        //Hover and Buoyancy properties
+        public float m_VhoverHeight;
+        public float m_VhoverEfficiency;
+        public float m_VhoverTimescale;
+        public float m_VehicleBuoyancy;
+
+        //Attractor properties
+        public float m_verticalAttractionEfficiency;
+        public float m_verticalAttractionTimescale;
+
+        // Axis
+        public Quaternion m_referenceFrame;
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitMeshing/HelperTypes.cs b/OpenSim/Region/PhysicsModules/UbitMeshing/HelperTypes.cs
new file mode 100644
index 0000000..5dc1e78
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitMeshing/HelperTypes.cs
@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using OpenMetaverse;
+using OpenSim.Region.Physics.Manager;
+using OpenSim.Region.Physics.Meshing;
+
+public class Vertex : IComparable<Vertex>
+{
+    Vector3 vector;
+
+    public float X
+    {
+        get { return vector.X; }
+        set { vector.X = value; }
+    }
+
+    public float Y
+    {
+        get { return vector.Y; }
+        set { vector.Y = value; }
+    }
+
+    public float Z
+    {
+        get { return vector.Z; }
+        set { vector.Z = value; }
+    }
+
+    public Vertex(float x, float y, float z)
+    {
+        vector.X = x;
+        vector.Y = y;
+        vector.Z = z;
+    }
+
+    public Vertex normalize()
+    {
+        float tlength = vector.Length();
+        if (tlength != 0f)
+        {
+            float mul = 1.0f / tlength;
+            return new Vertex(vector.X * mul, vector.Y * mul, vector.Z * mul);
+        }
+        else
+        {
+            return new Vertex(0f, 0f, 0f);
+        }
+    }
+
+    public Vertex cross(Vertex v)
+    {
+        return new Vertex(vector.Y * v.Z - vector.Z * v.Y, vector.Z * v.X - vector.X * v.Z, vector.X * v.Y - vector.Y * v.X);
+    }
+
+    // disable warning: mono compiler moans about overloading
+    // operators hiding base operator but should not according to C#
+    // language spec
+#pragma warning disable 0108
+    public static Vertex operator *(Vertex v, Quaternion q)
+    {
+        // From http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/
+
+        Vertex v2 = new Vertex(0f, 0f, 0f);
+
+        v2.X =   q.W * q.W * v.X +
+            2f * q.Y * q.W * v.Z -
+            2f * q.Z * q.W * v.Y +
+                 q.X * q.X * v.X +
+            2f * q.Y * q.X * v.Y +
+            2f * q.Z * q.X * v.Z -
+                 q.Z * q.Z * v.X -
+                 q.Y * q.Y * v.X;
+
+        v2.Y =
+            2f * q.X * q.Y * v.X +
+                 q.Y * q.Y * v.Y +
+            2f * q.Z * q.Y * v.Z +
+            2f * q.W * q.Z * v.X -
+                 q.Z * q.Z * v.Y +
+                 q.W * q.W * v.Y -
+            2f * q.X * q.W * v.Z -
+                 q.X * q.X * v.Y;
+
+        v2.Z =
+            2f * q.X * q.Z * v.X +
+            2f * q.Y * q.Z * v.Y +
+                 q.Z * q.Z * v.Z -
+            2f * q.W * q.Y * v.X -
+                 q.Y * q.Y * v.Z +
+            2f * q.W * q.X * v.Y -
+                 q.X * q.X * v.Z +
+                 q.W * q.W * v.Z;
+
+        return v2;
+    }
+
+    public static Vertex operator +(Vertex v1, Vertex v2)
+    {
+        return new Vertex(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z);
+    }
+
+    public static Vertex operator -(Vertex v1, Vertex v2)
+    {
+        return new Vertex(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z);
+    }
+
+    public static Vertex operator *(Vertex v1, Vertex v2)
+    {
+        return new Vertex(v1.X * v2.X, v1.Y * v2.Y, v1.Z * v2.Z);
+    }
+
+    public static Vertex operator +(Vertex v1, float am)
+    {
+        v1.X += am;
+        v1.Y += am;
+        v1.Z += am;
+        return v1;
+    }
+
+    public static Vertex operator -(Vertex v1, float am)
+    {
+        v1.X -= am;
+        v1.Y -= am;
+        v1.Z -= am;
+        return v1;
+    }
+
+    public static Vertex operator *(Vertex v1, float am)
+    {
+        v1.X *= am;
+        v1.Y *= am;
+        v1.Z *= am;
+        return v1;
+    }
+
+    public static Vertex operator /(Vertex v1, float am)
+    {
+        if (am == 0f)
+        {
+            return new Vertex(0f,0f,0f);
+        }
+        float mul = 1.0f / am;
+        v1.X *= mul;
+        v1.Y *= mul;
+        v1.Z *= mul;
+        return v1;
+    }
+#pragma warning restore 0108
+
+
+    public float dot(Vertex v)
+    {
+        return X * v.X + Y * v.Y + Z * v.Z;
+    }
+
+    public Vertex(Vector3 v)
+    {
+        vector = v;
+    }
+
+    public Vertex Clone()
+    {
+        return new Vertex(X, Y, Z);
+    }
+
+    public static Vertex FromAngle(double angle)
+    {
+        return new Vertex((float) Math.Cos(angle), (float) Math.Sin(angle), 0.0f);
+    }
+
+    public float Length()
+    {
+        return vector.Length();
+    }
+
+    public virtual bool Equals(Vertex v, float tolerance)
+    {
+        Vertex diff = this - v;
+        float d = diff.Length();
+        if (d < tolerance)
+            return true;
+
+        return false;
+    }
+
+
+    public int CompareTo(Vertex other)
+    {
+        if (X < other.X)
+            return -1;
+
+        if (X > other.X)
+            return 1;
+
+        if (Y < other.Y)
+            return -1;
+
+        if (Y > other.Y)
+            return 1;
+
+        if (Z < other.Z)
+            return -1;
+
+        if (Z > other.Z)
+            return 1;
+
+        return 0;
+    }
+
+    public static bool operator >(Vertex me, Vertex other)
+    {
+        return me.CompareTo(other) > 0;
+    }
+
+    public static bool operator <(Vertex me, Vertex other)
+    {
+        return me.CompareTo(other) < 0;
+    }
+
+    public String ToRaw()
+    {
+        // Why this stuff with the number formatter?
+        // Well, the raw format uses the english/US notation of numbers
+        // where the "," separates groups of 1000 while the "." marks the border between 1 and 10E-1.
+        // The german notation uses these characters exactly vice versa!
+        // The Float.ToString() routine is a localized one, giving different results depending on the country
+        // settings your machine works with. Unusable for a machine readable file format :-(
+        NumberFormatInfo nfi = new NumberFormatInfo();
+        nfi.NumberDecimalSeparator = ".";
+        nfi.NumberDecimalDigits = 6;
+
+        String s1 = X.ToString(nfi) + " " + Y.ToString(nfi) + " " + Z.ToString(nfi);
+
+        return s1;
+    }
+}
+
+public class Triangle
+{
+    public Vertex v1;
+    public Vertex v2;
+    public Vertex v3;
+
+    public Triangle(Vertex _v1, Vertex _v2, Vertex _v3)
+    {
+        v1 = _v1;
+        v2 = _v2;
+        v3 = _v3;
+    }
+
+    public Triangle(float _v1x,float _v1y,float _v1z,
+                    float _v2x,float _v2y,float _v2z,
+                    float _v3x,float _v3y,float _v3z)
+    {
+        v1 = new Vertex(_v1x, _v1y, _v1z);
+        v2 = new Vertex(_v2x, _v2y, _v2z);
+        v3 = new Vertex(_v3x, _v3y, _v3z);
+    }
+
+    public override String ToString()
+    {
+        NumberFormatInfo nfi = new NumberFormatInfo();
+        nfi.CurrencyDecimalDigits = 2;
+        nfi.CurrencyDecimalSeparator = ".";
+
+        String s1 = "<" + v1.X.ToString(nfi) + "," + v1.Y.ToString(nfi) + "," + v1.Z.ToString(nfi) + ">";
+        String s2 = "<" + v2.X.ToString(nfi) + "," + v2.Y.ToString(nfi) + "," + v2.Z.ToString(nfi) + ">";
+        String s3 = "<" + v3.X.ToString(nfi) + "," + v3.Y.ToString(nfi) + "," + v3.Z.ToString(nfi) + ">";
+
+        return s1 + ";" + s2 + ";" + s3;
+    }
+
+    public Vector3 getNormal()
+    {
+        // Vertices
+
+        // Vectors for edges
+        Vector3 e1;
+        Vector3 e2;
+
+        e1 = new Vector3(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z);
+        e2 = new Vector3(v1.X - v3.X, v1.Y - v3.Y, v1.Z - v3.Z);
+
+        // Cross product for normal
+        Vector3 n = Vector3.Cross(e1, e2);
+
+        // Length
+        float l = n.Length();
+
+        // Normalized "normal"
+        n = n/l;
+
+        return n;
+    }
+
+    public void invertNormal()
+    {
+        Vertex vt;
+        vt = v1;
+        v1 = v2;
+        v2 = vt;
+    }
+
+    // Dumps a triangle in the "raw faces" format, blender can import. This is for visualisation and
+    // debugging purposes
+    public String ToStringRaw()
+    {
+        String output = v1.ToRaw() + " " + v2.ToRaw() + " " + v3.ToRaw();
+        return output;
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitMeshing/Mesh.cs b/OpenSim/Region/PhysicsModules/UbitMeshing/Mesh.cs
new file mode 100644
index 0000000..0418893
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitMeshing/Mesh.cs
@@ -0,0 +1,601 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using OpenSim.Region.Physics.Manager;
+using PrimMesher;
+using OpenMetaverse;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters.Binary;
+
+namespace OpenSim.Region.Physics.Meshing
+{
+    public class MeshBuildingData
+    {
+        public Dictionary<Vertex, int> m_vertices;
+        public List<Triangle> m_triangles;
+        public float m_obbXmin;
+        public float m_obbXmax;
+        public float m_obbYmin;
+        public float m_obbYmax;
+        public float m_obbZmin;
+        public float m_obbZmax;
+        public Vector3 m_centroid;
+        public int m_centroidDiv;
+    }
+
+    [Serializable()]
+    public class Mesh : IMesh
+    {
+        float[] vertices;
+        int[] indexes;
+        Vector3 m_obb;
+        Vector3 m_obboffset;
+        [NonSerialized()]
+        MeshBuildingData m_bdata;
+        [NonSerialized()]
+        GCHandle vhandler;
+        [NonSerialized()]
+        GCHandle ihandler;
+        [NonSerialized()]
+        IntPtr m_verticesPtr = IntPtr.Zero;
+        [NonSerialized()]
+        IntPtr m_indicesPtr = IntPtr.Zero;
+        [NonSerialized()]
+        int m_vertexCount = 0;
+        [NonSerialized()]
+        int m_indexCount = 0;
+
+        public int RefCount { get; set; }
+        public AMeshKey Key { get; set; }
+
+        private class vertexcomp : IEqualityComparer<Vertex>
+        {
+            public bool Equals(Vertex v1, Vertex v2)
+            {
+                if (v1.X == v2.X && v1.Y == v2.Y && v1.Z == v2.Z)
+                    return true;
+                else
+                    return false;
+            }
+            public int GetHashCode(Vertex v)
+            {
+                int a = v.X.GetHashCode();
+                int b = v.Y.GetHashCode();
+                int c = v.Z.GetHashCode();
+                return (a << 16) ^ (b << 8) ^ c;
+            }
+        }
+
+        public Mesh()
+        {
+            vertexcomp vcomp = new vertexcomp();
+
+            m_bdata = new MeshBuildingData();
+            m_bdata.m_vertices = new Dictionary<Vertex, int>(vcomp);
+            m_bdata.m_triangles = new List<Triangle>();
+            m_bdata.m_centroid = Vector3.Zero;
+            m_bdata.m_centroidDiv = 0;
+            m_bdata.m_obbXmin = float.MaxValue;
+            m_bdata.m_obbXmax = float.MinValue;
+            m_bdata.m_obbYmin = float.MaxValue;
+            m_bdata.m_obbYmax = float.MinValue;
+            m_bdata.m_obbZmin = float.MaxValue;
+            m_bdata.m_obbZmax = float.MinValue;
+            m_obb = new Vector3(0.5f, 0.5f, 0.5f);
+            m_obboffset = Vector3.Zero;
+        }
+
+
+        public Mesh Scale(Vector3 scale)
+        {
+            if (m_verticesPtr == null || m_indicesPtr == null)
+                return null;
+
+            Mesh result = new Mesh();
+
+            float x = scale.X;
+            float y = scale.Y;
+            float z = scale.Z;
+
+            result.m_obb.X = m_obb.X * x;
+            result.m_obb.Y = m_obb.Y * y;
+            result.m_obb.Z = m_obb.Z * z;
+            result.m_obboffset.X = m_obboffset.X * x;
+            result.m_obboffset.Y = m_obboffset.Y * y;
+            result.m_obboffset.Z = m_obboffset.Z * z;
+
+            result.vertices = new float[vertices.Length];
+            int j = 0;
+            for (int i = 0; i < m_vertexCount; i++)
+            {
+                result.vertices[j] = vertices[j] * x;
+                j++;
+                result.vertices[j] = vertices[j] * y;
+                j++;
+                result.vertices[j] = vertices[j] * z;
+                j++;
+            }
+
+            result.indexes = new int[indexes.Length];
+            indexes.CopyTo(result.indexes,0);
+
+            result.pinMemory();
+
+            return result;
+        }
+
+        public Mesh Clone()
+        {
+            Mesh result = new Mesh();
+
+            if (m_bdata != null)
+            {
+                result.m_bdata = new MeshBuildingData();
+                foreach (Triangle t in m_bdata.m_triangles)
+                {
+                    result.Add(new Triangle(t.v1.Clone(), t.v2.Clone(), t.v3.Clone()));
+                }
+                result.m_bdata.m_centroid = m_bdata.m_centroid;
+                result.m_bdata.m_centroidDiv = m_bdata.m_centroidDiv;
+                result.m_bdata.m_obbXmin = m_bdata.m_obbXmin;
+                result.m_bdata.m_obbXmax = m_bdata.m_obbXmax;
+                result.m_bdata.m_obbYmin = m_bdata.m_obbYmin;
+                result.m_bdata.m_obbYmax = m_bdata.m_obbYmax;
+                result.m_bdata.m_obbZmin = m_bdata.m_obbZmin;
+                result.m_bdata.m_obbZmax = m_bdata.m_obbZmax;
+            }
+            result.m_obb = m_obb;
+            result.m_obboffset = m_obboffset;
+            return result;
+        }
+
+        public void addVertexLStats(Vertex v)
+        {
+            float x = v.X;
+            float y = v.Y;
+            float z = v.Z;
+
+            m_bdata.m_centroid.X += x;
+            m_bdata.m_centroid.Y += y;
+            m_bdata.m_centroid.Z += z;
+            m_bdata.m_centroidDiv++;
+
+            if (x > m_bdata.m_obbXmax)
+                m_bdata.m_obbXmax = x;
+            else if (x < m_bdata.m_obbXmin)
+                m_bdata.m_obbXmin = x;
+
+            if (y > m_bdata.m_obbYmax)
+                m_bdata.m_obbYmax = y;
+            else if (y < m_bdata.m_obbYmin)
+                m_bdata.m_obbYmin = y;
+
+            if (z > m_bdata.m_obbZmax)
+                m_bdata.m_obbZmax = z;
+            else if (z < m_bdata.m_obbZmin)
+                m_bdata.m_obbZmin = z;
+
+        }
+
+        public void Add(Triangle triangle)
+        {
+            if (m_indicesPtr != IntPtr.Zero || m_verticesPtr != IntPtr.Zero)
+                throw new NotSupportedException("Attempt to Add to a pinned Mesh");
+
+
+            triangle.v1.X = (float)Math.Round(triangle.v1.X, 6);
+            triangle.v1.Y = (float)Math.Round(triangle.v1.Y, 6);
+            triangle.v1.Z = (float)Math.Round(triangle.v1.Z, 6);
+            triangle.v2.X = (float)Math.Round(triangle.v2.X, 6);
+            triangle.v2.Y = (float)Math.Round(triangle.v2.Y, 6);
+            triangle.v2.Z = (float)Math.Round(triangle.v2.Z, 6);
+            triangle.v3.X = (float)Math.Round(triangle.v3.X, 6);
+            triangle.v3.Y = (float)Math.Round(triangle.v3.Y, 6);
+            triangle.v3.Z = (float)Math.Round(triangle.v3.Z, 6);
+
+            if ((triangle.v1.X == triangle.v2.X && triangle.v1.Y == triangle.v2.Y && triangle.v1.Z == triangle.v2.Z)
+                || (triangle.v1.X == triangle.v3.X && triangle.v1.Y == triangle.v3.Y && triangle.v1.Z == triangle.v3.Z)
+                || (triangle.v2.X == triangle.v3.X && triangle.v2.Y == triangle.v3.Y && triangle.v2.Z == triangle.v3.Z)
+                )               
+            {               
+                return;
+            }
+
+            if (m_bdata.m_vertices.Count == 0)
+            {
+                m_bdata.m_centroidDiv = 0;
+                m_bdata.m_centroid = Vector3.Zero;
+            }
+
+            if (!m_bdata.m_vertices.ContainsKey(triangle.v1))
+            {
+                m_bdata.m_vertices[triangle.v1] = m_bdata.m_vertices.Count;
+                addVertexLStats(triangle.v1);
+            }
+            if (!m_bdata.m_vertices.ContainsKey(triangle.v2))
+            {
+                m_bdata.m_vertices[triangle.v2] = m_bdata.m_vertices.Count;
+                addVertexLStats(triangle.v2);
+            }
+            if (!m_bdata.m_vertices.ContainsKey(triangle.v3))
+            {
+                m_bdata.m_vertices[triangle.v3] = m_bdata.m_vertices.Count;
+                addVertexLStats(triangle.v3);
+            }
+            m_bdata.m_triangles.Add(triangle);
+        }
+
+        public Vector3 GetCentroid()
+        {
+            return m_obboffset;
+
+        }
+
+        public Vector3 GetOBB()
+        {
+            return m_obb;
+            float x, y, z;
+            if (m_bdata.m_centroidDiv > 0)
+            {
+                x = (m_bdata.m_obbXmax - m_bdata.m_obbXmin) * 0.5f;
+                y = (m_bdata.m_obbYmax - m_bdata.m_obbYmin) * 0.5f;
+                z = (m_bdata.m_obbZmax - m_bdata.m_obbZmin) * 0.5f;
+            }
+            else // ??
+            {
+                x = 0.5f;
+                y = 0.5f;
+                z = 0.5f;
+            }
+            return new Vector3(x, y, z);
+        }
+
+        public List<Vector3> getVertexList()
+        {
+            List<Vector3> result = new List<Vector3>();
+            foreach (Vertex v in m_bdata.m_vertices.Keys)
+            {
+                result.Add(new Vector3(v.X, v.Y, v.Z));
+            }
+            return result;
+        }
+
+        public float[] getVertexListAsFloat()
+        {
+            if (m_bdata.m_vertices == null)
+                throw new NotSupportedException();
+            float[] result = new float[m_bdata.m_vertices.Count * 3];
+            foreach (KeyValuePair<Vertex, int> kvp in m_bdata.m_vertices)
+            {
+                Vertex v = kvp.Key;
+                int i = kvp.Value;
+                result[3 * i + 0] = v.X;
+                result[3 * i + 1] = v.Y;
+                result[3 * i + 2] = v.Z;
+            }
+            return result;
+        }
+
+        public float[] getVertexListAsFloatLocked()
+        {
+            return null;
+        }
+
+        public void getVertexListAsPtrToFloatArray(out IntPtr _vertices, out int vertexStride, out int vertexCount)
+        {
+            // A vertex is 3 floats
+            vertexStride = 3 * sizeof(float);
+
+            // If there isn't an unmanaged array allocated yet, do it now
+            if (m_verticesPtr == IntPtr.Zero && m_bdata != null)
+            {
+                vertices = getVertexListAsFloat();
+                // Each vertex is 3 elements (floats)
+                m_vertexCount = vertices.Length / 3;
+                vhandler = GCHandle.Alloc(vertices, GCHandleType.Pinned);
+                m_verticesPtr = vhandler.AddrOfPinnedObject();
+                GC.AddMemoryPressure(Buffer.ByteLength(vertices));
+            }
+            _vertices = m_verticesPtr;
+            vertexCount = m_vertexCount;
+        }
+
+        public int[] getIndexListAsInt()
+        {
+            if (m_bdata.m_triangles == null)
+                throw new NotSupportedException();
+            int[] result = new int[m_bdata.m_triangles.Count * 3];
+            for (int i = 0; i < m_bdata.m_triangles.Count; i++)
+            {
+                Triangle t = m_bdata.m_triangles[i];
+                result[3 * i + 0] = m_bdata.m_vertices[t.v1];
+                result[3 * i + 1] = m_bdata.m_vertices[t.v2];
+                result[3 * i + 2] = m_bdata.m_vertices[t.v3];
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// creates a list of index values that defines triangle faces. THIS METHOD FREES ALL NON-PINNED MESH DATA
+        /// </summary>
+        /// <returns></returns>
+        public int[] getIndexListAsIntLocked()
+        {
+            return null;
+        }
+
+        public void getIndexListAsPtrToIntArray(out IntPtr indices, out int triStride, out int indexCount)
+        {
+            // If there isn't an unmanaged array allocated yet, do it now
+            if (m_indicesPtr == IntPtr.Zero && m_bdata != null)
+            {
+                indexes = getIndexListAsInt();
+                m_indexCount = indexes.Length;
+                ihandler = GCHandle.Alloc(indexes, GCHandleType.Pinned);
+                m_indicesPtr = ihandler.AddrOfPinnedObject();
+                GC.AddMemoryPressure(Buffer.ByteLength(indexes));
+            }
+            // A triangle is 3 ints (indices)
+            triStride = 3 * sizeof(int);
+            indices = m_indicesPtr;
+            indexCount = m_indexCount;
+        }
+
+        public void releasePinned()
+        {
+            if (m_verticesPtr != IntPtr.Zero)
+            {
+                vhandler.Free();
+                vertices = null;
+                m_verticesPtr = IntPtr.Zero;
+            }
+            if (m_indicesPtr != IntPtr.Zero)
+            {
+                ihandler.Free();
+                indexes = null;
+                m_indicesPtr = IntPtr.Zero;
+            }
+        }
+
+        /// <summary>
+        /// frees up the source mesh data to minimize memory - call this method after calling get*Locked() functions
+        /// </summary>
+        public void releaseSourceMeshData()
+        {
+            if (m_bdata != null)
+            {
+                m_bdata.m_triangles = null;
+                m_bdata.m_vertices = null;
+            }
+        }
+
+        public void releaseBuildingMeshData()
+        {
+            if (m_bdata != null)
+            {
+                m_bdata.m_triangles = null;
+                m_bdata.m_vertices = null;
+                m_bdata = null;
+            }
+        }
+
+        public void Append(IMesh newMesh)
+        {
+            if (m_indicesPtr != IntPtr.Zero || m_verticesPtr != IntPtr.Zero)
+                throw new NotSupportedException("Attempt to Append to a pinned Mesh");
+        
+            if (!(newMesh is Mesh))
+                return;
+
+            foreach (Triangle t in ((Mesh)newMesh).m_bdata.m_triangles)
+                Add(t);
+        }
+
+        // Do a linear transformation of  mesh.
+        public void TransformLinear(float[,] matrix, float[] offset)
+        {
+            if (m_indicesPtr != IntPtr.Zero || m_verticesPtr != IntPtr.Zero)
+                throw new NotSupportedException("Attempt to TransformLinear a pinned Mesh");
+
+            foreach (Vertex v in m_bdata.m_vertices.Keys)
+            {
+                if (v == null)
+                    continue;
+                float x, y, z;
+                x = v.X*matrix[0, 0] + v.Y*matrix[1, 0] + v.Z*matrix[2, 0];
+                y = v.X*matrix[0, 1] + v.Y*matrix[1, 1] + v.Z*matrix[2, 1];
+                z = v.X*matrix[0, 2] + v.Y*matrix[1, 2] + v.Z*matrix[2, 2];
+                v.X = x + offset[0];
+                v.Y = y + offset[1];
+                v.Z = z + offset[2];
+            }
+        }
+
+        public void DumpRaw(String path, String name, String title)
+        {
+            if (path == null)
+                return;
+            if (m_bdata == null)
+                return;
+            String fileName = name + "_" + title + ".raw";
+            String completePath = System.IO.Path.Combine(path, fileName);
+            StreamWriter sw = new StreamWriter(completePath);
+            foreach (Triangle t in m_bdata.m_triangles)
+            {
+                String s = t.ToStringRaw();
+                sw.WriteLine(s);
+            }
+            sw.Close();
+        }
+
+        public void TrimExcess()
+        {
+            m_bdata.m_triangles.TrimExcess();
+        }
+
+        public void pinMemory()
+        {
+            m_vertexCount = vertices.Length / 3;
+            vhandler = GCHandle.Alloc(vertices, GCHandleType.Pinned);
+            m_verticesPtr = vhandler.AddrOfPinnedObject();
+            GC.AddMemoryPressure(Buffer.ByteLength(vertices));
+
+            m_indexCount = indexes.Length;
+            ihandler = GCHandle.Alloc(indexes, GCHandleType.Pinned);
+            m_indicesPtr = ihandler.AddrOfPinnedObject();
+            GC.AddMemoryPressure(Buffer.ByteLength(indexes));
+        }
+
+        public void PrepForOde()
+        {
+            // If there isn't an unmanaged array allocated yet, do it now
+            if (m_verticesPtr == IntPtr.Zero)
+                vertices = getVertexListAsFloat();
+
+            // If there isn't an unmanaged array allocated yet, do it now
+            if (m_indicesPtr == IntPtr.Zero)
+                indexes = getIndexListAsInt();
+
+            pinMemory();
+
+            float x, y, z;
+
+            if (m_bdata.m_centroidDiv > 0)
+            {
+                m_obboffset = new Vector3(m_bdata.m_centroid.X / m_bdata.m_centroidDiv, m_bdata.m_centroid.Y / m_bdata.m_centroidDiv, m_bdata.m_centroid.Z / m_bdata.m_centroidDiv);
+                x = (m_bdata.m_obbXmax - m_bdata.m_obbXmin) * 0.5f;
+                y = (m_bdata.m_obbYmax - m_bdata.m_obbYmin) * 0.5f;
+                z = (m_bdata.m_obbZmax - m_bdata.m_obbZmin) * 0.5f;
+            }
+
+            else
+            {
+                m_obboffset = Vector3.Zero;
+                x = 0.5f;
+                y = 0.5f;
+                z = 0.5f;
+            }
+            m_obb = new Vector3(x, y, z);
+
+            releaseBuildingMeshData();
+        }
+        public bool ToStream(Stream st)
+        {
+            if (m_indicesPtr == IntPtr.Zero || m_verticesPtr == IntPtr.Zero)
+                return false;
+
+            BinaryWriter bw = new BinaryWriter(st);
+            bool ok = true;
+
+            try
+            {
+
+                bw.Write(m_vertexCount);
+                bw.Write(m_indexCount);
+
+                for (int i = 0; i < 3 * m_vertexCount; i++)
+                    bw.Write(vertices[i]);
+                for (int i = 0; i < m_indexCount; i++)
+                    bw.Write(indexes[i]);
+                bw.Write(m_obb.X);
+                bw.Write(m_obb.Y);
+                bw.Write(m_obb.Z);
+                bw.Write(m_obboffset.X);
+                bw.Write(m_obboffset.Y);
+                bw.Write(m_obboffset.Z);
+            }
+            catch
+            {
+                ok = false;
+            }
+
+            if (bw != null)
+            {
+                bw.Flush();
+                bw.Close();
+            }
+
+            return ok;
+        }
+
+        public static Mesh FromStream(Stream st, AMeshKey key)
+        {
+            Mesh mesh = new Mesh();
+            mesh.releaseBuildingMeshData();
+
+            BinaryReader br = new BinaryReader(st);
+
+            bool ok = true;
+            try
+            {
+                mesh.m_vertexCount = br.ReadInt32();
+                mesh.m_indexCount = br.ReadInt32();
+
+                int n = 3 * mesh.m_vertexCount;
+                mesh.vertices = new float[n];
+                for (int i = 0; i < n; i++)
+                    mesh.vertices[i] = br.ReadSingle();
+
+                mesh.indexes = new int[mesh.m_indexCount];
+                for (int i = 0; i < mesh.m_indexCount; i++)
+                    mesh.indexes[i] = br.ReadInt32();
+
+                mesh.m_obb.X = br.ReadSingle();
+                mesh.m_obb.Y = br.ReadSingle();
+                mesh.m_obb.Z = br.ReadSingle();
+
+                mesh.m_obboffset.X = br.ReadSingle();
+                mesh.m_obboffset.Y = br.ReadSingle();
+                mesh.m_obboffset.Z = br.ReadSingle();
+            }
+            catch
+            {
+                ok = false;
+            }
+
+            br.Close();
+
+            if (ok)
+            {
+                mesh.pinMemory();
+
+                mesh.Key = key;
+                mesh.RefCount = 1;
+
+                return mesh;
+            }
+
+            mesh.vertices = null;
+            mesh.indexes = null;
+            return null;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitMeshing/Meshmerizer.cs b/OpenSim/Region/PhysicsModules/UbitMeshing/Meshmerizer.cs
new file mode 100644
index 0000000..c131c6f
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitMeshing/Meshmerizer.cs
@@ -0,0 +1,1424 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+//#define SPAM
+
+using System;
+using System.Collections.Generic;
+using OpenSim.Framework;
+using OpenSim.Region.Physics.Manager;
+using OpenMetaverse;
+using OpenMetaverse.StructuredData;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO.Compression;
+using PrimMesher;
+using log4net;
+using Nini.Config;
+using System.Reflection;
+using System.IO;
+using ComponentAce.Compression.Libs.zlib;
+using OpenSim.Region.Physics.ConvexDecompositionDotNet;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters.Binary;
+
+namespace OpenSim.Region.Physics.Meshing
+{
+    public class MeshmerizerPlugin : IMeshingPlugin
+    {
+        public MeshmerizerPlugin()
+        {
+        }
+
+        public string GetName()
+        {
+            return "UbitMeshmerizer";
+        }
+
+        public IMesher GetMesher(IConfigSource config)
+        {
+            return new Meshmerizer(config);
+        }
+    }
+
+    public class Meshmerizer : IMesher
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        // Setting baseDir to a path will enable the dumping of raw files
+        // raw files can be imported by blender so a visual inspection of the results can be done
+
+        public object diskLock = new object();
+
+        public bool doMeshFileCache = true;
+
+        public string cachePath = "MeshCache";
+        public TimeSpan CacheExpire;
+        public bool doCacheExpire = true;
+
+//        const string baseDir = "rawFiles";
+        private const string baseDir = null; //"rawFiles";
+
+        private bool useMeshiesPhysicsMesh = false;
+
+        private float minSizeForComplexMesh = 0.2f; // prims with all dimensions smaller than this will have a bounding box mesh
+
+        private Dictionary<AMeshKey, Mesh> m_uniqueMeshes = new Dictionary<AMeshKey, Mesh>();
+        private Dictionary<AMeshKey, Mesh> m_uniqueReleasedMeshes = new Dictionary<AMeshKey, Mesh>();
+
+        public Meshmerizer(IConfigSource config)
+        {
+            IConfig start_config = config.Configs["Startup"];
+            IConfig mesh_config = config.Configs["Mesh"];
+
+
+            float fcache = 48.0f;
+//            float fcache = 0.02f;
+
+            if(mesh_config != null)
+            {
+                useMeshiesPhysicsMesh = mesh_config.GetBoolean("UseMeshiesPhysicsMesh", useMeshiesPhysicsMesh);
+                if (useMeshiesPhysicsMesh)
+                {
+                    doMeshFileCache = mesh_config.GetBoolean("MeshFileCache", doMeshFileCache);
+                    cachePath = mesh_config.GetString("MeshFileCachePath", cachePath);
+                    fcache = mesh_config.GetFloat("MeshFileCacheExpireHours", fcache);
+                    doCacheExpire = mesh_config.GetBoolean("MeshFileCacheDoExpire", doCacheExpire);
+                }
+                else
+                {
+                    doMeshFileCache = false;
+                    doCacheExpire = false;
+                }
+            }
+
+            CacheExpire = TimeSpan.FromHours(fcache);
+
+        }
+
+        /// <summary>
+        /// creates a simple box mesh of the specified size. This mesh is of very low vertex count and may
+        /// be useful as a backup proxy when level of detail is not needed or when more complex meshes fail
+        /// for some reason
+        /// </summary>
+        /// <param name="minX"></param>
+        /// <param name="maxX"></param>
+        /// <param name="minY"></param>
+        /// <param name="maxY"></param>
+        /// <param name="minZ"></param>
+        /// <param name="maxZ"></param>
+        /// <returns></returns>
+        private static Mesh CreateSimpleBoxMesh(float minX, float maxX, float minY, float maxY, float minZ, float maxZ)
+        {
+            Mesh box = new Mesh();
+            List<Vertex> vertices = new List<Vertex>();
+            // bottom
+
+            vertices.Add(new Vertex(minX, maxY, minZ));
+            vertices.Add(new Vertex(maxX, maxY, minZ));
+            vertices.Add(new Vertex(maxX, minY, minZ));
+            vertices.Add(new Vertex(minX, minY, minZ));
+
+            box.Add(new Triangle(vertices[0], vertices[1], vertices[2]));
+            box.Add(new Triangle(vertices[0], vertices[2], vertices[3]));
+
+            // top
+
+            vertices.Add(new Vertex(maxX, maxY, maxZ));
+            vertices.Add(new Vertex(minX, maxY, maxZ));
+            vertices.Add(new Vertex(minX, minY, maxZ));
+            vertices.Add(new Vertex(maxX, minY, maxZ));
+
+            box.Add(new Triangle(vertices[4], vertices[5], vertices[6]));
+            box.Add(new Triangle(vertices[4], vertices[6], vertices[7]));
+
+            // sides
+
+            box.Add(new Triangle(vertices[5], vertices[0], vertices[3]));
+            box.Add(new Triangle(vertices[5], vertices[3], vertices[6]));
+
+            box.Add(new Triangle(vertices[1], vertices[0], vertices[5]));
+            box.Add(new Triangle(vertices[1], vertices[5], vertices[4]));
+
+            box.Add(new Triangle(vertices[7], vertices[1], vertices[4]));
+            box.Add(new Triangle(vertices[7], vertices[2], vertices[1]));
+
+            box.Add(new Triangle(vertices[3], vertices[2], vertices[7]));
+            box.Add(new Triangle(vertices[3], vertices[7], vertices[6]));
+
+            return box;
+        }
+
+        /// <summary>
+        /// Creates a simple bounding box mesh for a complex input mesh
+        /// </summary>
+        /// <param name="meshIn"></param>
+        /// <returns></returns>
+        private static Mesh CreateBoundingBoxMesh(Mesh meshIn)
+        {
+            float minX = float.MaxValue;
+            float maxX = float.MinValue;
+            float minY = float.MaxValue;
+            float maxY = float.MinValue;
+            float minZ = float.MaxValue;
+            float maxZ = float.MinValue;
+
+            foreach (Vector3 v in meshIn.getVertexList())
+            {
+                if (v.X < minX) minX = v.X;
+                if (v.Y < minY) minY = v.Y;
+                if (v.Z < minZ) minZ = v.Z;
+
+                if (v.X > maxX) maxX = v.X;
+                if (v.Y > maxY) maxY = v.Y;
+                if (v.Z > maxZ) maxZ = v.Z;
+            }
+
+            return CreateSimpleBoxMesh(minX, maxX, minY, maxY, minZ, maxZ);
+        }
+
+        private void ReportPrimError(string message, string primName, PrimMesh primMesh)
+        {
+            m_log.Error(message);
+            m_log.Error("\nPrim Name: " + primName);
+            m_log.Error("****** PrimMesh Parameters ******\n" + primMesh.ParamsToDisplayString());
+        }
+
+        /// <summary>
+        /// Add a submesh to an existing list of coords and faces.
+        /// </summary>
+        /// <param name="subMeshData"></param>
+        /// <param name="size">Size of entire object</param>
+        /// <param name="coords"></param>
+        /// <param name="faces"></param>
+        private void AddSubMesh(OSDMap subMeshData, List<Coord> coords, List<Face> faces)
+        {
+    //                                    Console.WriteLine("subMeshMap for {0} - {1}", primName, Util.GetFormattedXml((OSD)subMeshMap));
+    
+            // As per http://wiki.secondlife.com/wiki/Mesh/Mesh_Asset_Format, some Mesh Level
+            // of Detail Blocks (maps) contain just a NoGeometry key to signal there is no
+            // geometry for this submesh.
+            if (subMeshData.ContainsKey("NoGeometry") && ((OSDBoolean)subMeshData["NoGeometry"]))
+                return;
+
+            OpenMetaverse.Vector3 posMax;
+            OpenMetaverse.Vector3 posMin;
+            if (subMeshData.ContainsKey("PositionDomain"))
+            {
+                posMax = ((OSDMap)subMeshData["PositionDomain"])["Max"].AsVector3();
+                posMin = ((OSDMap)subMeshData["PositionDomain"])["Min"].AsVector3();
+            }
+            else
+            {
+                posMax = new Vector3(0.5f, 0.5f, 0.5f);
+                posMin = new Vector3(-0.5f, -0.5f, -0.5f);
+            }
+
+            ushort faceIndexOffset = (ushort)coords.Count;
+
+            byte[] posBytes = subMeshData["Position"].AsBinary();
+            for (int i = 0; i < posBytes.Length; i += 6)
+            {
+                ushort uX = Utils.BytesToUInt16(posBytes, i);
+                ushort uY = Utils.BytesToUInt16(posBytes, i + 2);
+                ushort uZ = Utils.BytesToUInt16(posBytes, i + 4);
+    
+                Coord c = new Coord(
+                Utils.UInt16ToFloat(uX, posMin.X, posMax.X),
+                Utils.UInt16ToFloat(uY, posMin.Y, posMax.Y),
+                Utils.UInt16ToFloat(uZ, posMin.Z, posMax.Z));
+    
+                coords.Add(c);
+            }
+    
+            byte[] triangleBytes = subMeshData["TriangleList"].AsBinary();
+            for (int i = 0; i < triangleBytes.Length; i += 6)
+            {
+                ushort v1 = (ushort)(Utils.BytesToUInt16(triangleBytes, i) + faceIndexOffset);
+                ushort v2 = (ushort)(Utils.BytesToUInt16(triangleBytes, i + 2) + faceIndexOffset);
+                ushort v3 = (ushort)(Utils.BytesToUInt16(triangleBytes, i + 4) + faceIndexOffset);
+                Face f = new Face(v1, v2, v3);
+                faces.Add(f);
+            }
+        }
+
+        /// <summary>
+        /// Create a physics mesh from data that comes with the prim.  The actual data used depends on the prim type.
+        /// </summary>
+        /// <param name="primName"></param>
+        /// <param name="primShape"></param>
+        /// <param name="size"></param>
+        /// <param name="lod"></param>
+        /// <returns></returns>
+        private Mesh CreateMeshFromPrimMesher(string primName, PrimitiveBaseShape primShape, float lod, bool convex)
+        {
+//            m_log.DebugFormat(
+//                "[MESH]: Creating physics proxy for {0}, shape {1}",
+//                primName, (OpenMetaverse.SculptType)primShape.SculptType);
+
+            List<Coord> coords;
+            List<Face> faces;
+
+            if (primShape.SculptEntry)
+            {
+                if (((OpenMetaverse.SculptType)primShape.SculptType) == SculptType.Mesh)
+                {
+                    if (!useMeshiesPhysicsMesh)
+                        return null;
+
+                    if (!GenerateCoordsAndFacesFromPrimMeshData(primName, primShape, out coords, out faces, convex))
+                        return null;
+                }
+                else
+                {
+                    if (!GenerateCoordsAndFacesFromPrimSculptData(primName, primShape, lod, out coords, out faces))
+                        return null;
+                }
+            }
+            else
+            {
+                if (!GenerateCoordsAndFacesFromPrimShapeData(primName, primShape, lod, out coords, out faces))
+                    return null;
+            }
+
+            primShape.SculptData = Utils.EmptyBytes;
+
+            int numCoords = coords.Count;
+            int numFaces = faces.Count;
+
+            Mesh mesh = new Mesh();
+            // Add the corresponding triangles to the mesh
+            for (int i = 0; i < numFaces; i++)
+            {
+                Face f = faces[i];
+                mesh.Add(new Triangle(coords[f.v1].X, coords[f.v1].Y, coords[f.v1].Z,
+                                        coords[f.v2].X, coords[f.v2].Y, coords[f.v2].Z,
+                                        coords[f.v3].X, coords[f.v3].Y, coords[f.v3].Z));
+            }
+
+            coords.Clear();
+            faces.Clear();
+
+            return mesh;
+        }
+
+        /// <summary>
+        /// Generate the co-ords and faces necessary to construct a mesh from the mesh data the accompanies a prim.
+        /// </summary>
+        /// <param name="primName"></param>
+        /// <param name="primShape"></param>
+        /// <param name="size"></param>
+        /// <param name="coords">Coords are added to this list by the method.</param>
+        /// <param name="faces">Faces are added to this list by the method.</param>
+        /// <returns>true if coords and faces were successfully generated, false if not</returns>
+        private bool GenerateCoordsAndFacesFromPrimMeshData(
+            string primName, PrimitiveBaseShape primShape, out List<Coord> coords, out List<Face> faces, bool convex)
+        {
+//            m_log.DebugFormat("[MESH]: experimental mesh proxy generation for {0}", primName);
+
+            bool usemesh = false;
+
+            coords = new List<Coord>();
+            faces = new List<Face>();
+            OSD meshOsd = null;
+
+            if (primShape.SculptData.Length <= 0)
+            {
+//                m_log.InfoFormat("[MESH]: asset data for {0} is zero length", primName);
+                return false;
+            }
+
+            long start = 0;
+            using (MemoryStream data = new MemoryStream(primShape.SculptData))
+            {
+                try
+                {
+                    OSD osd = OSDParser.DeserializeLLSDBinary(data);
+                    if (osd is OSDMap)
+                        meshOsd = (OSDMap)osd;
+                    else
+                    {
+                        m_log.Warn("[Mesh}: unable to cast mesh asset to OSDMap");
+                        return false;
+                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.Error("[MESH]: Exception deserializing mesh asset header:" + e.ToString());
+                }
+
+                start = data.Position;
+            }
+
+            if (meshOsd is OSDMap)
+            {
+                OSDMap physicsParms = null;
+                OSDMap map = (OSDMap)meshOsd;
+
+                if (!convex)
+                {
+                    if (map.ContainsKey("physics_shape"))
+                        physicsParms = (OSDMap)map["physics_shape"]; // old asset format
+                    else if (map.ContainsKey("physics_mesh"))
+                        physicsParms = (OSDMap)map["physics_mesh"]; // new asset format
+
+                    if (physicsParms != null)
+                        usemesh = true;
+                }
+                
+                if(!usemesh && (map.ContainsKey("physics_convex")))
+                        physicsParms = (OSDMap)map["physics_convex"];
+              
+
+                if (physicsParms == null)
+                {
+                    m_log.Warn("[MESH]: unknown mesh type");
+                    return false;
+                }
+
+                int physOffset = physicsParms["offset"].AsInteger() + (int)start;
+                int physSize = physicsParms["size"].AsInteger();
+
+                if (physOffset < 0 || physSize == 0)
+                    return false; // no mesh data in asset
+
+                OSD decodedMeshOsd = new OSD();
+                byte[] meshBytes = new byte[physSize];
+                System.Buffer.BlockCopy(primShape.SculptData, physOffset, meshBytes, 0, physSize);
+
+                try
+                {
+                    using (MemoryStream inMs = new MemoryStream(meshBytes))
+                    {
+                        using (MemoryStream outMs = new MemoryStream())
+                        {
+                            using (ZOutputStream zOut = new ZOutputStream(outMs))
+                            {
+                                byte[] readBuffer = new byte[2048];
+                                int readLen = 0;
+                                while ((readLen = inMs.Read(readBuffer, 0, readBuffer.Length)) > 0)
+                                {
+                                    zOut.Write(readBuffer, 0, readLen);
+                                }
+                                zOut.Flush();
+                                outMs.Seek(0, SeekOrigin.Begin);
+
+                                byte[] decompressedBuf = outMs.GetBuffer();
+
+                                decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
+                            }
+                        }
+                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.Error("[MESH]: exception decoding physical mesh: " + e.ToString());
+                    return false;
+                }
+
+                if (usemesh)
+                {
+                    OSDArray decodedMeshOsdArray = null;
+
+                    // physics_shape is an array of OSDMaps, one for each submesh
+                    if (decodedMeshOsd is OSDArray)
+                    {
+//                      Console.WriteLine("decodedMeshOsd for {0} - {1}", primName, Util.GetFormattedXml(decodedMeshOsd));
+
+                        decodedMeshOsdArray = (OSDArray)decodedMeshOsd;
+                        foreach (OSD subMeshOsd in decodedMeshOsdArray)
+                        {
+                            if (subMeshOsd is OSDMap)
+                                AddSubMesh(subMeshOsd as OSDMap, coords, faces);
+                        }
+                    }
+                }
+                else
+                {
+                    OSDMap cmap = (OSDMap)decodedMeshOsd;
+                    if (cmap == null)
+                        return false;
+
+                    byte[] data;
+
+                    List<float3> vs = new List<float3>();
+                    PHullResult hullr = new PHullResult();
+                    float3 f3;
+                    Coord c;
+                    Face f;
+                    Vector3 range;
+                    Vector3 min;
+
+                    const float invMaxU16 = 1.0f / 65535f;
+                    int t1;
+                    int t2;
+                    int t3;
+                    int i;
+                    int nverts;
+                    int nindexs;
+
+                    if (cmap.ContainsKey("Max"))
+                        range = cmap["Max"].AsVector3();
+                    else
+                        range = new Vector3(0.5f, 0.5f, 0.5f);
+
+                    if (cmap.ContainsKey("Min"))
+                        min = cmap["Min"].AsVector3();
+                    else
+                        min = new Vector3(-0.5f, -0.5f, -0.5f);
+
+                    range = range - min;
+                    range *= invMaxU16;
+
+                    if (!convex && cmap.ContainsKey("HullList") && cmap.ContainsKey("Positions"))
+                    {
+                        List<int> hsizes = new List<int>();
+                        int totalpoints = 0;
+                        data = cmap["HullList"].AsBinary();
+                        for (i = 0; i < data.Length; i++)
+                        {
+                            t1 = data[i];
+                            if (t1 == 0)
+                                t1 = 256;
+                            totalpoints += t1;
+                            hsizes.Add(t1);
+                        }
+
+                        data = cmap["Positions"].AsBinary();
+                        int ptr = 0;
+                        int vertsoffset = 0;
+
+                        if (totalpoints == data.Length / 6) // 2 bytes per coord, 3 coords per point
+                        {
+                            foreach (int hullsize in hsizes)
+                            {
+                                for (i = 0; i < hullsize; i++ )
+                                {
+                                    t1 = data[ptr++];
+                                    t1 += data[ptr++] << 8;
+                                    t2 = data[ptr++];
+                                    t2 += data[ptr++] << 8;
+                                    t3 = data[ptr++];
+                                    t3 += data[ptr++] << 8;
+
+                                    f3 = new float3((t1 * range.X + min.X),
+                                              (t2 * range.Y + min.Y),
+                                              (t3 * range.Z + min.Z));
+                                    vs.Add(f3);
+                                }
+
+                                if(hullsize <3)
+                                {
+                                    vs.Clear();
+                                    continue;
+                                }
+
+                                if (hullsize <5)
+                                {
+                                    foreach (float3 point in vs)
+                                    {
+                                        c.X = point.x;
+                                        c.Y = point.y;
+                                        c.Z = point.z;
+                                        coords.Add(c);
+                                    }
+                                    f = new Face(vertsoffset, vertsoffset + 1, vertsoffset + 2);
+                                    faces.Add(f);
+
+                                    if (hullsize == 4)
+                                    {
+                                        // not sure about orientation..
+                                        f = new Face(vertsoffset, vertsoffset + 2, vertsoffset + 3);
+                                        faces.Add(f);
+                                        f = new Face(vertsoffset, vertsoffset + 3, vertsoffset + 1);
+                                        faces.Add(f);
+                                        f = new Face(vertsoffset + 3, vertsoffset + 2, vertsoffset + 1);
+                                        faces.Add(f);
+                                    }
+                                    vertsoffset += vs.Count;
+                                    vs.Clear(); 
+                                    continue;
+                                }
+
+                                if (!HullUtils.ComputeHull(vs, ref hullr, 0, 0.0f))
+                                {
+                                    vs.Clear();
+                                    continue;
+                                }
+
+                                nverts = hullr.Vertices.Count;
+                                nindexs = hullr.Indices.Count;
+
+                                if (nindexs % 3 != 0)
+                                {
+                                    vs.Clear();
+                                    continue;
+                                }
+
+                                for (i = 0; i < nverts; i++)
+                                {
+                                    c.X = hullr.Vertices[i].x;
+                                    c.Y = hullr.Vertices[i].y;
+                                    c.Z = hullr.Vertices[i].z;
+                                    coords.Add(c);
+                                }
+                               
+                                for (i = 0; i < nindexs; i += 3)
+                                {
+                                    t1 = hullr.Indices[i];
+                                    if (t1 > nverts)
+                                        break;
+                                    t2 = hullr.Indices[i + 1];
+                                    if (t2 > nverts)
+                                        break;
+                                    t3 = hullr.Indices[i + 2];
+                                    if (t3 > nverts)
+                                        break;
+                                    f = new Face(vertsoffset + t1, vertsoffset + t2, vertsoffset + t3);
+                                    faces.Add(f);
+                                }
+                                vertsoffset += nverts;
+                                vs.Clear();
+                            }
+                        }
+                        if (coords.Count > 0 && faces.Count > 0)
+                            return true;                      
+                    }
+
+                    vs.Clear();
+
+                    if (cmap.ContainsKey("BoundingVerts"))
+                    {
+                        data = cmap["BoundingVerts"].AsBinary();
+
+                        for (i = 0; i < data.Length; )
+                        {
+                            t1 = data[i++];
+                            t1 += data[i++] << 8;
+                            t2 = data[i++];
+                            t2 += data[i++] << 8;
+                            t3 = data[i++];
+                            t3 += data[i++] << 8;
+
+                            f3 = new float3((t1 * range.X + min.X),
+                                      (t2 * range.Y + min.Y),
+                                      (t3 * range.Z + min.Z));
+                            vs.Add(f3);
+                        }
+
+                        if (vs.Count < 3)
+                        {
+                            vs.Clear();
+                            return false;
+                        }
+
+                        if (vs.Count < 5)
+                        {
+                            foreach (float3 point in vs)
+                            {
+                                c.X = point.x;
+                                c.Y = point.y;
+                                c.Z = point.z;
+                                coords.Add(c);
+                            }
+                            f = new Face(0, 1, 2);
+                            faces.Add(f);
+
+                            if (vs.Count == 4)
+                            {
+                                f = new Face(0, 2, 3);
+                                faces.Add(f);
+                                f = new Face(0, 3, 1);
+                                faces.Add(f);
+                                f = new Face( 3, 2, 1);
+                                faces.Add(f);
+                            }
+                            vs.Clear();
+                            return true;
+                        }
+
+                        if (!HullUtils.ComputeHull(vs, ref hullr, 0, 0.0f))
+                            return false;
+
+                        nverts = hullr.Vertices.Count;
+                        nindexs = hullr.Indices.Count;
+
+                        if (nindexs % 3 != 0)
+                            return false;
+
+                        for (i = 0; i < nverts; i++)
+                        {
+                            c.X = hullr.Vertices[i].x;
+                            c.Y = hullr.Vertices[i].y;
+                            c.Z = hullr.Vertices[i].z;
+                            coords.Add(c);
+                        }
+                        for (i = 0; i < nindexs; i += 3)
+                        {
+                            t1 = hullr.Indices[i];
+                            if (t1 > nverts)
+                                break;
+                            t2 = hullr.Indices[i + 1];
+                            if (t2 > nverts)
+                                break;
+                            t3 = hullr.Indices[i + 2];
+                            if (t3 > nverts)
+                                break;
+                            f = new Face(t1, t2, t3);
+                            faces.Add(f);
+                        }
+
+                        if (coords.Count > 0 && faces.Count > 0)
+                            return true;
+                    }
+                    else
+                        return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Generate the co-ords and faces necessary to construct a mesh from the sculpt data the accompanies a prim.
+        /// </summary>
+        /// <param name="primName"></param>
+        /// <param name="primShape"></param>
+        /// <param name="size"></param>
+        /// <param name="lod"></param>
+        /// <param name="coords">Coords are added to this list by the method.</param>
+        /// <param name="faces">Faces are added to this list by the method.</param>
+        /// <returns>true if coords and faces were successfully generated, false if not</returns>
+        private bool GenerateCoordsAndFacesFromPrimSculptData(
+            string primName, PrimitiveBaseShape primShape, float lod, out List<Coord> coords, out List<Face> faces)
+        {
+            coords = new List<Coord>();
+            faces = new List<Face>();
+            PrimMesher.SculptMesh sculptMesh;
+            Image idata = null;
+
+                if (primShape.SculptData == null || primShape.SculptData.Length == 0)
+                    return false;
+
+                try
+                {
+                    OpenMetaverse.Imaging.ManagedImage unusedData;
+                    OpenMetaverse.Imaging.OpenJPEG.DecodeToImage(primShape.SculptData, out unusedData, out idata);
+
+                    unusedData = null;
+
+                    if (idata == null)
+                    {
+                        // In some cases it seems that the decode can return a null bitmap without throwing
+                        // an exception
+                        m_log.WarnFormat("[PHYSICS]: OpenJPEG decoded sculpt data for {0} to a null bitmap.  Ignoring.", primName);
+                        return false;
+                    }
+                }
+                catch (DllNotFoundException)
+                {
+                    m_log.Error("[PHYSICS]: OpenJpeg is not installed correctly on this system. Physics Proxy generation failed.  Often times this is because of an old version of GLIBC.  You must have version 2.4 or above!");
+                    return false;
+                }
+                catch (IndexOutOfRangeException)
+                {
+                    m_log.Error("[PHYSICS]: OpenJpeg was unable to decode this. Physics Proxy generation failed");
+                    return false;
+                }
+                catch (Exception ex)
+                {
+                    m_log.Error("[PHYSICS]: Unable to generate a Sculpty physics proxy. Sculpty texture decode failed: " + ex.Message);
+                    return false;
+                }
+
+            PrimMesher.SculptMesh.SculptType sculptType;
+            // remove mirror and invert bits
+            OpenMetaverse.SculptType pbsSculptType = ((OpenMetaverse.SculptType)(primShape.SculptType & 0x3f));
+            switch (pbsSculptType)
+            {
+                case OpenMetaverse.SculptType.Cylinder:
+                    sculptType = PrimMesher.SculptMesh.SculptType.cylinder;
+                    break;
+                case OpenMetaverse.SculptType.Plane:
+                    sculptType = PrimMesher.SculptMesh.SculptType.plane;
+                    break;
+                case OpenMetaverse.SculptType.Torus:
+                    sculptType = PrimMesher.SculptMesh.SculptType.torus;
+                    break;
+                case OpenMetaverse.SculptType.Sphere:
+                    sculptType = PrimMesher.SculptMesh.SculptType.sphere;
+                    break;
+                default:
+                    sculptType = PrimMesher.SculptMesh.SculptType.plane;
+                    break;
+            }
+
+            bool mirror = ((primShape.SculptType & 128) != 0);
+            bool invert = ((primShape.SculptType & 64) != 0);
+
+            sculptMesh = new PrimMesher.SculptMesh((Bitmap)idata, sculptType, (int)lod, mirror, invert);
+
+            idata.Dispose();
+
+//            sculptMesh.DumpRaw(baseDir, primName, "primMesh");
+
+            coords = sculptMesh.coords;
+            faces = sculptMesh.faces;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Generate the co-ords and faces necessary to construct a mesh from the shape data the accompanies a prim.
+        /// </summary>
+        /// <param name="primName"></param>
+        /// <param name="primShape"></param>
+        /// <param name="size"></param>
+        /// <param name="coords">Coords are added to this list by the method.</param>
+        /// <param name="faces">Faces are added to this list by the method.</param>
+        /// <returns>true if coords and faces were successfully generated, false if not</returns>
+        private bool GenerateCoordsAndFacesFromPrimShapeData(
+            string primName, PrimitiveBaseShape primShape, float lod, out List<Coord> coords, out List<Face> faces)
+        {
+            PrimMesh primMesh;
+            coords = new List<Coord>();
+            faces = new List<Face>();            
+
+            float pathShearX = primShape.PathShearX < 128 ? (float)primShape.PathShearX * 0.01f : (float)(primShape.PathShearX - 256) * 0.01f;
+            float pathShearY = primShape.PathShearY < 128 ? (float)primShape.PathShearY * 0.01f : (float)(primShape.PathShearY - 256) * 0.01f;
+            float pathBegin = (float)primShape.PathBegin * 2.0e-5f;
+            float pathEnd = 1.0f - (float)primShape.PathEnd * 2.0e-5f;
+            float pathScaleX = (float)(primShape.PathScaleX - 100) * 0.01f;
+            float pathScaleY = (float)(primShape.PathScaleY - 100) * 0.01f;
+
+            float profileBegin = (float)primShape.ProfileBegin * 2.0e-5f;
+            float profileEnd = 1.0f - (float)primShape.ProfileEnd * 2.0e-5f;
+
+            if (profileBegin < 0.0f)
+                profileBegin = 0.0f;
+
+            if (profileEnd < 0.02f)
+                profileEnd = 0.02f;
+            else if (profileEnd > 1.0f)
+                profileEnd = 1.0f;
+
+            if (profileBegin >= profileEnd)
+                profileBegin = profileEnd - 0.02f;
+
+            float profileHollow = (float)primShape.ProfileHollow * 2.0e-5f;
+            if (profileHollow > 0.95f)
+                profileHollow = 0.95f;
+          
+            int sides = 4;
+            LevelOfDetail iLOD = (LevelOfDetail)lod;
+            byte profshape = (byte)(primShape.ProfileCurve & 0x07);
+
+            if (profshape == (byte)ProfileShape.EquilateralTriangle
+                || profshape == (byte)ProfileShape.IsometricTriangle
+                || profshape == (byte)ProfileShape.RightTriangle)
+                sides = 3;
+            else if (profshape == (byte)ProfileShape.Circle)
+            {
+                switch (iLOD)
+                {
+                    case LevelOfDetail.High:    sides = 24;     break;
+                    case LevelOfDetail.Medium:  sides = 12;     break;
+                    case LevelOfDetail.Low:     sides = 6;      break;
+                    case LevelOfDetail.VeryLow: sides = 3;      break;
+                    default:                    sides = 24;     break;
+                }
+            }
+            else if (profshape == (byte)ProfileShape.HalfCircle)
+            { // half circle, prim is a sphere
+                switch (iLOD)
+                {
+                    case LevelOfDetail.High:    sides = 24;     break;
+                    case LevelOfDetail.Medium:  sides = 12;     break;
+                    case LevelOfDetail.Low:     sides = 6;      break;
+                    case LevelOfDetail.VeryLow: sides = 3;      break;
+                    default:                    sides = 24;     break;
+                }
+
+                profileBegin = 0.5f * profileBegin + 0.5f;
+                profileEnd = 0.5f * profileEnd + 0.5f;
+            }
+
+            int hollowSides = sides;
+            if (primShape.HollowShape == HollowShape.Circle)
+            {
+                switch (iLOD)
+                {
+                    case LevelOfDetail.High:    hollowSides = 24;     break;
+                    case LevelOfDetail.Medium:  hollowSides = 12;     break;
+                    case LevelOfDetail.Low:     hollowSides = 6;      break;
+                    case LevelOfDetail.VeryLow: hollowSides = 3;      break;
+                    default:                    hollowSides = 24;     break;
+                }
+            }
+            else if (primShape.HollowShape == HollowShape.Square)
+                hollowSides = 4;
+            else if (primShape.HollowShape == HollowShape.Triangle)
+            {
+                if (profshape == (byte)ProfileShape.HalfCircle)
+                    hollowSides = 6;
+                else
+                    hollowSides = 3;
+            }
+
+            primMesh = new PrimMesh(sides, profileBegin, profileEnd, profileHollow, hollowSides);
+            
+            if (primMesh.errorMessage != null)
+                if (primMesh.errorMessage.Length > 0)
+                    m_log.Error("[ERROR] " + primMesh.errorMessage);
+
+            primMesh.topShearX = pathShearX;
+            primMesh.topShearY = pathShearY;
+            primMesh.pathCutBegin = pathBegin;
+            primMesh.pathCutEnd = pathEnd;
+
+            if (primShape.PathCurve == (byte)Extrusion.Straight || primShape.PathCurve == (byte) Extrusion.Flexible)
+            {
+                primMesh.twistBegin = (primShape.PathTwistBegin * 18) / 10;
+                primMesh.twistEnd = (primShape.PathTwist * 18) / 10;
+                primMesh.taperX = pathScaleX;
+                primMesh.taperY = pathScaleY;
+
+#if SPAM
+            m_log.Debug("****** PrimMesh Parameters (Linear) ******\n" + primMesh.ParamsToDisplayString());
+#endif
+                try
+                {
+                    primMesh.ExtrudeLinear();
+                }
+                catch (Exception ex)
+                {
+                    ReportPrimError("Extrusion failure: exception: " + ex.ToString(), primName, primMesh);
+                    return false;
+                }
+            }
+            else
+            {
+                primMesh.holeSizeX = (200 - primShape.PathScaleX) * 0.01f;
+                primMesh.holeSizeY = (200 - primShape.PathScaleY) * 0.01f;
+                primMesh.radius = 0.01f * primShape.PathRadiusOffset;
+                primMesh.revolutions = 1.0f + 0.015f * primShape.PathRevolutions;
+                primMesh.skew = 0.01f * primShape.PathSkew;
+                primMesh.twistBegin = (primShape.PathTwistBegin * 36) / 10;
+                primMesh.twistEnd = (primShape.PathTwist * 36) / 10;
+                primMesh.taperX = primShape.PathTaperX * 0.01f;
+                primMesh.taperY = primShape.PathTaperY * 0.01f;
+
+#if SPAM
+            m_log.Debug("****** PrimMesh Parameters (Circular) ******\n" + primMesh.ParamsToDisplayString());
+#endif
+                try
+                {
+                    primMesh.ExtrudeCircular();
+                }
+                catch (Exception ex)
+                {
+                    ReportPrimError("Extrusion failure: exception: " + ex.ToString(), primName, primMesh);
+                    return false;
+                }
+            }
+
+//            primMesh.DumpRaw(baseDir, primName, "primMesh");
+
+            coords = primMesh.coords;
+            faces = primMesh.faces;
+
+            return true;
+        }
+
+        public AMeshKey GetMeshUniqueKey(PrimitiveBaseShape primShape, Vector3 size, byte lod, bool convex)
+        {
+            AMeshKey key = new AMeshKey();
+            Byte[] someBytes;
+
+            key.hashB = 5181;
+            key.hashC = 5181;
+            ulong hash = 5381;
+
+            if (primShape.SculptEntry)
+            {
+                key.uuid = primShape.SculptTexture;
+                key.hashC = mdjb2(key.hashC, primShape.SculptType);
+                key.hashC = mdjb2(key.hashC, primShape.PCode);
+            }
+            else
+            {
+                hash = mdjb2(hash, primShape.PathCurve);
+                hash = mdjb2(hash, (byte)primShape.HollowShape);
+                hash = mdjb2(hash, (byte)primShape.ProfileShape);
+                hash = mdjb2(hash, primShape.PathBegin);
+                hash = mdjb2(hash, primShape.PathEnd);
+                hash = mdjb2(hash, primShape.PathScaleX);
+                hash = mdjb2(hash, primShape.PathScaleY);
+                hash = mdjb2(hash, primShape.PathShearX);
+                key.hashA = hash;
+                hash = key.hashB;
+                hash = mdjb2(hash, primShape.PathShearY);
+                hash = mdjb2(hash, (byte)primShape.PathTwist);
+                hash = mdjb2(hash, (byte)primShape.PathTwistBegin);
+                hash = mdjb2(hash, (byte)primShape.PathRadiusOffset);
+                hash = mdjb2(hash, (byte)primShape.PathTaperX);
+                hash = mdjb2(hash, (byte)primShape.PathTaperY);
+                hash = mdjb2(hash, primShape.PathRevolutions);
+                hash = mdjb2(hash, (byte)primShape.PathSkew);
+                hash = mdjb2(hash, primShape.ProfileBegin);
+                hash = mdjb2(hash, primShape.ProfileEnd);
+                hash = mdjb2(hash, primShape.ProfileHollow);
+                hash = mdjb2(hash, primShape.PCode);
+                key.hashB = hash;
+            }
+
+            hash = key.hashC;
+
+            hash = mdjb2(hash, lod);
+
+            if (size == m_MeshUnitSize)
+            {
+                hash = hash << 8;
+                hash |= 8;
+            }
+            else
+            {
+                someBytes = size.GetBytes();
+                for (int i = 0; i < someBytes.Length; i++)
+                    hash = mdjb2(hash, someBytes[i]);
+                hash = hash << 8;
+            }          
+
+            if (convex)
+                hash |= 4;
+
+            if (primShape.SculptEntry)
+            {
+                hash |= 1;
+                if (primShape.SculptType == (byte)SculptType.Mesh)
+                    hash |= 2;
+            }
+
+            key.hashC = hash;
+
+            return key;
+        }
+
+        private ulong mdjb2(ulong hash, byte c)
+        {
+            return ((hash << 5) + hash) + (ulong)c;
+        }
+
+        private ulong mdjb2(ulong hash, ushort c)
+        {
+            hash = ((hash << 5) + hash) + (ulong)((byte)c);
+            return ((hash << 5) + hash) + (ulong)(c >> 8);
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod)
+        {
+            return CreateMesh(primName, primShape, size, lod, false,false,false);
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical)
+        {
+            return CreateMesh(primName, primShape, size, lod, false,false,false);
+        }
+
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool shouldCache, bool convex, bool forOde)
+        {
+            return CreateMesh(primName, primShape, size, lod, false, false, false);
+        }
+        
+        public IMesh GetMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool convex)
+        {
+            Mesh mesh = null;
+
+            if (size.X < 0.01f) size.X = 0.01f;
+            if (size.Y < 0.01f) size.Y = 0.01f;
+            if (size.Z < 0.01f) size.Z = 0.01f;
+
+            AMeshKey key = GetMeshUniqueKey(primShape, size, (byte)lod, convex);
+            lock (m_uniqueMeshes)
+            {
+                m_uniqueMeshes.TryGetValue(key, out mesh);
+
+                if (mesh != null)
+                {
+                    mesh.RefCount++;
+                    return mesh;
+                }
+
+                // try to find a identical mesh on meshs recently released
+                lock (m_uniqueReleasedMeshes)
+                {
+                    m_uniqueReleasedMeshes.TryGetValue(key, out mesh);
+                    if (mesh != null)
+                    {
+                        m_uniqueReleasedMeshes.Remove(key);
+                        try
+                        {
+                            m_uniqueMeshes.Add(key, mesh);
+                        }
+                        catch { }
+                        mesh.RefCount = 1;
+                        return mesh;
+                    }
+                }
+            }
+            return null;
+        }
+
+        private static Vector3 m_MeshUnitSize = new Vector3(1.0f, 1.0f, 1.0f);
+        
+        public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod, bool isPhysical, bool convex, bool forOde)
+        {
+#if SPAM
+            m_log.DebugFormat("[MESH]: Creating mesh for {0}", primName);
+#endif
+
+            Mesh mesh = null;
+
+            if (size.X < 0.01f) size.X = 0.01f;
+            if (size.Y < 0.01f) size.Y = 0.01f;
+            if (size.Z < 0.01f) size.Z = 0.01f;
+
+            // try to find a identical mesh on meshs in use
+
+            AMeshKey key = GetMeshUniqueKey(primShape,size,(byte)lod, convex);
+
+            lock (m_uniqueMeshes)
+            {
+                m_uniqueMeshes.TryGetValue(key, out mesh);
+
+                if (mesh != null)
+                {
+                    mesh.RefCount++;
+                    return mesh;
+                }
+
+                // try to find a identical mesh on meshs recently released
+                lock (m_uniqueReleasedMeshes)
+                {
+                    m_uniqueReleasedMeshes.TryGetValue(key, out mesh);
+                    if (mesh != null)
+                    {
+                        m_uniqueReleasedMeshes.Remove(key);
+                        try
+                        {
+                            m_uniqueMeshes.Add(key, mesh);
+                        }
+                        catch { }
+                        mesh.RefCount = 1;
+                        return mesh;
+                    }
+                }
+            }
+
+            Mesh UnitMesh = null;
+            AMeshKey unitKey = GetMeshUniqueKey(primShape, m_MeshUnitSize, (byte)lod, convex);
+
+            lock (m_uniqueReleasedMeshes)
+            {
+                m_uniqueReleasedMeshes.TryGetValue(unitKey, out UnitMesh);
+                if (UnitMesh != null)
+                {
+                    UnitMesh.RefCount = 1;
+                }
+            }
+
+            if (UnitMesh == null && primShape.SculptEntry && doMeshFileCache)
+                UnitMesh = GetFromFileCache(unitKey);
+
+            if (UnitMesh == null)
+            {
+                UnitMesh = CreateMeshFromPrimMesher(primName, primShape, lod, convex);
+
+                if (UnitMesh == null)
+                    return null;
+
+                UnitMesh.DumpRaw(baseDir, unitKey.ToString(), "Z");
+
+                if (forOde)
+                {
+                    // force pinned mem allocation
+                    UnitMesh.PrepForOde();
+                }
+                else
+                    UnitMesh.TrimExcess();
+
+                UnitMesh.Key = unitKey;
+                UnitMesh.RefCount = 1;
+
+                if (doMeshFileCache && primShape.SculptEntry)
+                    StoreToFileCache(unitKey, UnitMesh);
+
+                lock (m_uniqueReleasedMeshes)
+                {
+                    try
+                    {
+                        m_uniqueReleasedMeshes.Add(unitKey, UnitMesh);
+                    }
+                    catch { }
+                }
+            }
+
+            mesh = UnitMesh.Scale(size);
+            mesh.Key = key;
+            mesh.RefCount = 1;
+            lock (m_uniqueMeshes)
+            {
+                try
+                {
+                    m_uniqueMeshes.Add(key, mesh);
+                }
+                catch { }
+            }           
+
+            return mesh;
+        }
+
+        public void ReleaseMesh(IMesh imesh)
+        {
+            if (imesh == null)
+                return;
+
+            Mesh mesh = (Mesh)imesh;
+
+            lock (m_uniqueMeshes)
+            {
+                int curRefCount = mesh.RefCount;
+                curRefCount--;
+
+                if (curRefCount > 0)
+                {
+                    mesh.RefCount = curRefCount;
+                    return;
+                }
+
+                mesh.RefCount = 0;
+                m_uniqueMeshes.Remove(mesh.Key);
+                lock (m_uniqueReleasedMeshes)
+                {
+                    try
+                    {
+                        m_uniqueReleasedMeshes.Add(mesh.Key, mesh);
+                    }
+                    catch { }
+                }           
+            }
+        }
+
+        public void ExpireReleaseMeshs()
+        {
+            if (m_uniqueReleasedMeshes.Count == 0)
+                return;
+
+            List<Mesh> meshstodelete = new List<Mesh>();
+            int refcntr;
+
+            lock (m_uniqueReleasedMeshes)
+            {
+                foreach (Mesh m in m_uniqueReleasedMeshes.Values)
+                {
+                    refcntr = m.RefCount;
+                    refcntr--;
+                    if (refcntr > -6)
+                        m.RefCount = refcntr;
+                    else
+                        meshstodelete.Add(m);
+                }
+
+                foreach (Mesh m in meshstodelete)
+                {
+                    m_uniqueReleasedMeshes.Remove(m.Key);
+                    m.releaseBuildingMeshData();
+                    m.releasePinned();
+                }
+            }
+        }
+
+        public void FileNames(AMeshKey key, out string dir,out string fullFileName)
+        {
+            string id = key.ToString();
+            string init = id.Substring(0, 1);
+            dir = System.IO.Path.Combine(cachePath, init);
+            fullFileName = System.IO.Path.Combine(dir, id);
+        }
+
+        public string FullFileName(AMeshKey key)
+        {
+            string id = key.ToString();
+            string init = id.Substring(0,1);
+            id = System.IO.Path.Combine(init, id);
+            id = System.IO.Path.Combine(cachePath, id);
+            return id;
+        }
+
+        private Mesh GetFromFileCache(AMeshKey key)
+        {
+            Mesh mesh = null;
+            string filename = FullFileName(key);
+            bool ok = true;
+
+            lock (diskLock)
+            {
+                if (File.Exists(filename))
+                {
+                    FileStream stream = null;
+                    try
+                    {
+                        stream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
+                        BinaryFormatter bformatter = new BinaryFormatter();
+
+                        mesh = Mesh.FromStream(stream, key);
+                        
+                    }
+                    catch (Exception e)
+                    {
+                        ok = false;
+                        m_log.ErrorFormat(
+                            "[MESH CACHE]: Failed to get file {0}.  Exception {1} {2}",
+                            filename, e.Message, e.StackTrace);
+                    }
+
+                    if (stream != null)
+                        stream.Close();
+
+                    if (mesh == null || !ok)
+                        File.Delete(filename);
+                    else
+                        File.SetLastAccessTimeUtc(filename, DateTime.UtcNow);
+                }
+            }
+
+            return mesh;
+        }
+
+        private void StoreToFileCache(AMeshKey key, Mesh mesh)
+        {
+            Stream stream = null;
+            bool ok = false;
+
+            // Make sure the target cache directory exists
+            string dir = String.Empty;
+            string filename = String.Empty;
+
+            FileNames(key, out dir, out filename);
+
+            lock (diskLock)
+            {
+                try
+                {
+                    if (!Directory.Exists(dir))
+                    {
+                        Directory.CreateDirectory(dir);
+                    }
+
+                    stream = File.Open(filename, FileMode.Create);
+                    ok = mesh.ToStream(stream);
+                }
+                catch (IOException e)
+                {
+                    m_log.ErrorFormat(
+                        "[MESH CACHE]: Failed to write file {0}.  Exception {1} {2}.",
+                        filename, e.Message, e.StackTrace);
+                    ok = false;
+                }
+
+                if (stream != null)
+                    stream.Close();
+
+                if (File.Exists(filename))
+                {
+                    if (ok)
+                        File.SetLastAccessTimeUtc(filename, DateTime.UtcNow);
+                    else
+                        File.Delete(filename);
+                }
+            }
+        }
+        
+        public void ExpireFileCache()
+        {
+            if (!doCacheExpire)
+                return;
+
+            string controlfile = System.IO.Path.Combine(cachePath, "cntr");
+
+            lock (diskLock)
+            {
+                try
+                {
+                    if (File.Exists(controlfile))
+                    {
+                        int ndeleted = 0;
+                        int totalfiles = 0;
+                        int ndirs = 0;
+                        DateTime OlderTime = File.GetLastAccessTimeUtc(controlfile) - CacheExpire;
+                        File.SetLastAccessTimeUtc(controlfile, DateTime.UtcNow);
+                        
+                        foreach (string dir in Directory.GetDirectories(cachePath))                       
+                        {
+                            try
+                            {
+                                foreach (string file in Directory.GetFiles(dir))
+                                {
+                                    try
+                                    {
+                                        if (File.GetLastAccessTimeUtc(file) < OlderTime)
+                                        {
+                                            File.Delete(file);
+                                            ndeleted++;
+                                        }
+                                    }
+                                    catch { }
+                                    totalfiles++;
+                                }
+                            }
+                            catch { }
+                            ndirs++;
+                        }
+
+                        if (ndeleted == 0)
+                            m_log.InfoFormat("[MESH CACHE]: {0} Files in {1} cache folders, no expires",
+                                totalfiles,ndirs);
+                        else
+                            m_log.InfoFormat("[MESH CACHE]: {0} Files in {1} cache folders, expired {2} files accessed before {3}",
+                                totalfiles,ndirs, ndeleted, OlderTime.ToString());
+                    }
+                    else
+                    {
+                        m_log.Info("[MESH CACHE]: Expire delayed to next startup");
+                        FileStream fs = File.Create(controlfile,4096,FileOptions.WriteThrough);
+                        fs.Close();
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitMeshing/PrimMesher.cs b/OpenSim/Region/PhysicsModules/UbitMeshing/PrimMesher.cs
new file mode 100644
index 0000000..8eb136b
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitMeshing/PrimMesher.cs
@@ -0,0 +1,1708 @@
+/*
+ * Copyright (c) Contributors
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+
+namespace PrimMesher
+{
+    public struct Quat
+    {
+        /// <summary>X value</summary>
+        public float X;
+        /// <summary>Y value</summary>
+        public float Y;
+        /// <summary>Z value</summary>
+        public float Z;
+        /// <summary>W value</summary>
+        public float W;
+
+        public Quat(float x, float y, float z, float w)
+        {
+            X = x;
+            Y = y;
+            Z = z;
+            W = w;
+        }
+
+        public Quat(Coord axis, float angle)
+        {
+            axis = axis.Normalize();
+
+            angle *= 0.5f;
+            float c = (float)Math.Cos(angle);
+            float s = (float)Math.Sin(angle);
+
+            X = axis.X * s;
+            Y = axis.Y * s;
+            Z = axis.Z * s;
+            W = c;
+
+            Normalize();
+        }
+
+        public float Length()
+        {
+            return (float)Math.Sqrt(X * X + Y * Y + Z * Z + W * W);
+        }
+
+        public Quat Normalize()
+        {
+            const float MAG_THRESHOLD = 0.0000001f;
+            float mag = Length();
+
+            // Catch very small rounding errors when normalizing
+            if (mag > MAG_THRESHOLD)
+            {
+                float oomag = 1f / mag;
+                X *= oomag;
+                Y *= oomag;
+                Z *= oomag;
+                W *= oomag;
+            }
+            else
+            {
+                X = 0f;
+                Y = 0f;
+                Z = 0f;
+                W = 1f;
+            }
+
+            return this;
+        }
+
+        public static Quat operator *(Quat q1, Quat q2)
+        {
+            float x = q1.W * q2.X + q1.X * q2.W + q1.Y * q2.Z - q1.Z * q2.Y;
+            float y = q1.W * q2.Y - q1.X * q2.Z + q1.Y * q2.W + q1.Z * q2.X;
+            float z = q1.W * q2.Z + q1.X * q2.Y - q1.Y * q2.X + q1.Z * q2.W;
+            float w = q1.W * q2.W - q1.X * q2.X - q1.Y * q2.Y - q1.Z * q2.Z;
+            return new Quat(x, y, z, w);
+        }
+
+        public override string ToString()
+        {
+            return "< X: " + this.X.ToString() + ", Y: " + this.Y.ToString() + ", Z: " + this.Z.ToString() + ", W: " + this.W.ToString() + ">";
+        }
+    }
+
+    public struct Coord
+    {
+        public float X;
+        public float Y;
+        public float Z;
+
+        public Coord(float x, float y, float z)
+        {
+            this.X = x;
+            this.Y = y;
+            this.Z = z;
+        }
+
+        public float Length()
+        {
+            return (float)Math.Sqrt(this.X * this.X + this.Y * this.Y + this.Z * this.Z);
+        }
+
+        public Coord Invert()
+        {
+            this.X = -this.X;
+            this.Y = -this.Y;
+            this.Z = -this.Z;
+
+            return this;
+        }
+
+        public Coord Normalize()
+        {
+            const float MAG_THRESHOLD = 0.0000001f;
+            float mag = Length();
+
+            // Catch very small rounding errors when normalizing
+            if (mag > MAG_THRESHOLD)
+            {
+                float oomag = 1.0f / mag;
+                this.X *= oomag;
+                this.Y *= oomag;
+                this.Z *= oomag;
+            }
+            else
+            {
+                this.X = 0.0f;
+                this.Y = 0.0f;
+                this.Z = 0.0f;
+            }
+
+            return this;
+        }
+
+        public override string ToString()
+        {
+            return this.X.ToString() + " " + this.Y.ToString() + " " + this.Z.ToString();
+        }
+
+        public static Coord Cross(Coord c1, Coord c2)
+        {
+            return new Coord(
+                c1.Y * c2.Z - c2.Y * c1.Z,
+                c1.Z * c2.X - c2.Z * c1.X,
+                c1.X * c2.Y - c2.X * c1.Y
+                );
+        }
+
+        public static Coord operator +(Coord v, Coord a)
+        {
+            return new Coord(v.X + a.X, v.Y + a.Y, v.Z + a.Z);
+        }
+
+        public static Coord operator *(Coord v, Coord m)
+        {
+            return new Coord(v.X * m.X, v.Y * m.Y, v.Z * m.Z);
+        }
+
+        public static Coord operator *(Coord v, Quat q)
+        {
+            // From http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/
+
+            Coord c2 = new Coord(0.0f, 0.0f, 0.0f);
+
+            c2.X = q.W * q.W * v.X +
+                2f * q.Y * q.W * v.Z -
+                2f * q.Z * q.W * v.Y +
+                     q.X * q.X * v.X +
+                2f * q.Y * q.X * v.Y +
+                2f * q.Z * q.X * v.Z -
+                     q.Z * q.Z * v.X -
+                     q.Y * q.Y * v.X;
+
+            c2.Y =
+                2f * q.X * q.Y * v.X +
+                     q.Y * q.Y * v.Y +
+                2f * q.Z * q.Y * v.Z +
+                2f * q.W * q.Z * v.X -
+                     q.Z * q.Z * v.Y +
+                     q.W * q.W * v.Y -
+                2f * q.X * q.W * v.Z -
+                     q.X * q.X * v.Y;
+
+            c2.Z =
+                2f * q.X * q.Z * v.X +
+                2f * q.Y * q.Z * v.Y +
+                     q.Z * q.Z * v.Z -
+                2f * q.W * q.Y * v.X -
+                     q.Y * q.Y * v.Z +
+                2f * q.W * q.X * v.Y -
+                     q.X * q.X * v.Z +
+                     q.W * q.W * v.Z;
+
+            return c2;
+        }
+    }
+
+    public struct Face
+    {
+        public int primFace;
+
+        // vertices
+        public int v1;
+        public int v2;
+        public int v3;
+
+        public Face(int v1, int v2, int v3)
+        {
+            primFace = 0;
+
+            this.v1 = v1;
+            this.v2 = v2;
+            this.v3 = v3;
+
+        }
+
+        public Coord SurfaceNormal(List<Coord> coordList)
+        {
+            Coord c1 = coordList[this.v1];
+            Coord c2 = coordList[this.v2];
+            Coord c3 = coordList[this.v3];
+
+            Coord edge1 = new Coord(c2.X - c1.X, c2.Y - c1.Y, c2.Z - c1.Z);
+            Coord edge2 = new Coord(c3.X - c1.X, c3.Y - c1.Y, c3.Z - c1.Z);
+
+            return Coord.Cross(edge1, edge2).Normalize();
+        }
+    }
+
+    internal struct Angle
+    {
+        internal float angle;
+        internal float X;
+        internal float Y;
+
+        internal Angle(float angle, float x, float y)
+        {
+            this.angle = angle;
+            this.X = x;
+            this.Y = y;
+        }
+    }
+
+    internal class AngleList
+    {
+        private float iX, iY; // intersection point
+
+        private static Angle[] angles3 =
+        {
+            new Angle(0.0f, 1.0f, 0.0f),
+            new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f),
+            new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f),
+            new Angle(1.0f, 1.0f, 0.0f)
+        };
+
+        private static Angle[] angles4 =
+        {
+            new Angle(0.0f, 1.0f, 0.0f),
+            new Angle(0.25f, 0.0f, 1.0f),
+            new Angle(0.5f, -1.0f, 0.0f),
+            new Angle(0.75f, 0.0f, -1.0f),
+            new Angle(1.0f, 1.0f, 0.0f)
+        };
+
+        private static Angle[] angles6 =
+        {
+            new Angle(0.0f, 1.0f, 0.0f),
+            new Angle(0.16666666666666667f, 0.5f, 0.8660254037844386f),
+            new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f),
+            new Angle(0.5f, -1.0f, 0.0f),
+            new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f),
+            new Angle(0.83333333333333326f, 0.5f, -0.86602540378443904f),
+            new Angle(1.0f, 1.0f, 0.0f)
+        };
+
+        private static Angle[] angles12 =
+        {
+            new Angle(0.0f, 1.0f, 0.0f),
+            new Angle(0.083333333333333329f, 0.86602540378443871f, 0.5f),
+            new Angle(0.16666666666666667f, 0.5f, 0.8660254037844386f),
+            new Angle(0.25f, 0.0f, 1.0f),
+            new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f),
+            new Angle(0.41666666666666663f, -0.86602540378443849f, 0.5f),
+            new Angle(0.5f, -1.0f, 0.0f),
+            new Angle(0.58333333333333326f, -0.86602540378443882f, -0.5f),
+            new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f),
+            new Angle(0.75f, 0.0f, -1.0f),
+            new Angle(0.83333333333333326f, 0.5f, -0.86602540378443904f),
+            new Angle(0.91666666666666663f, 0.86602540378443837f, -0.5f),
+            new Angle(1.0f, 1.0f, 0.0f)
+        };
+
+        private static Angle[] angles24 =
+        {
+            new Angle(0.0f, 1.0f, 0.0f),
+            new Angle(0.041666666666666664f, 0.96592582628906831f, 0.25881904510252074f),
+            new Angle(0.083333333333333329f, 0.86602540378443871f, 0.5f),
+            new Angle(0.125f, 0.70710678118654757f, 0.70710678118654746f),
+            new Angle(0.16666666666666667f, 0.5f, 0.8660254037844386f),
+            new Angle(0.20833333333333331f, 0.25881904510252096f, 0.9659258262890682f),
+            new Angle(0.25f, 0.0f, 1.0f),
+            new Angle(0.29166666666666663f, -0.25881904510252063f, 0.96592582628906831f),
+            new Angle(0.33333333333333333f, -0.5f, 0.86602540378443871f),
+            new Angle(0.375f, -0.70710678118654746f, 0.70710678118654757f),
+            new Angle(0.41666666666666663f, -0.86602540378443849f, 0.5f),
+            new Angle(0.45833333333333331f, -0.9659258262890682f, 0.25881904510252102f),
+            new Angle(0.5f, -1.0f, 0.0f),
+            new Angle(0.54166666666666663f, -0.96592582628906842f, -0.25881904510252035f),
+            new Angle(0.58333333333333326f, -0.86602540378443882f, -0.5f),
+            new Angle(0.62499999999999989f, -0.70710678118654791f, -0.70710678118654713f),
+            new Angle(0.66666666666666667f, -0.5f, -0.86602540378443837f),
+            new Angle(0.70833333333333326f, -0.25881904510252152f, -0.96592582628906809f),
+            new Angle(0.75f, 0.0f, -1.0f),
+            new Angle(0.79166666666666663f, 0.2588190451025203f, -0.96592582628906842f),
+            new Angle(0.83333333333333326f, 0.5f, -0.86602540378443904f),
+            new Angle(0.875f, 0.70710678118654735f, -0.70710678118654768f),
+            new Angle(0.91666666666666663f, 0.86602540378443837f, -0.5f),
+            new Angle(0.95833333333333326f, 0.96592582628906809f, -0.25881904510252157f),
+            new Angle(1.0f, 1.0f, 0.0f)
+        };
+
+        private Angle interpolatePoints(float newPoint, Angle p1, Angle p2)
+        {
+            float m = (newPoint - p1.angle) / (p2.angle - p1.angle);
+            return new Angle(newPoint, p1.X + m * (p2.X - p1.X), p1.Y + m * (p2.Y - p1.Y));
+        }
+
+        private void intersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
+        { // ref: http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
+            double denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+            double uaNumerator = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
+
+            if (denom != 0.0)
+            {
+                double ua = uaNumerator / denom;
+                iX = (float)(x1 + ua * (x2 - x1));
+                iY = (float)(y1 + ua * (y2 - y1));
+            }
+        }
+
+        internal List<Angle> angles;
+
+        internal void makeAngles(int sides, float startAngle, float stopAngle, bool hasCut)
+        {
+            angles = new List<Angle>();
+
+            const double twoPi = System.Math.PI * 2.0;
+            const float twoPiInv = (float)(1.0d / twoPi);
+
+            if (sides < 1)
+                throw new Exception("number of sides not greater than zero");
+            if (stopAngle <= startAngle)
+                throw new Exception("stopAngle not greater than startAngle");
+
+            if ((sides == 3 || sides == 4 || sides == 6 || sides == 12 || sides == 24))
+            {
+                startAngle *= twoPiInv;
+                stopAngle *= twoPiInv;
+
+                Angle[] sourceAngles;
+                switch (sides)
+                {
+                    case 3:
+                        sourceAngles = angles3;
+                        break;
+                    case 4:
+                        sourceAngles = angles4;
+                        break;
+                    case 6:
+                        sourceAngles = angles6;
+                        break;
+                    case 12:
+                        sourceAngles = angles12;
+                        break;
+                    default:
+                        sourceAngles = angles24;
+                        break;
+                }
+
+                int startAngleIndex = (int)(startAngle * sides);
+                int endAngleIndex = sourceAngles.Length - 1;
+
+                if (hasCut)
+                {
+                    if (stopAngle < 1.0f)
+                        endAngleIndex = (int)(stopAngle * sides) + 1;
+                    if (endAngleIndex == startAngleIndex)
+                        endAngleIndex++;
+
+                    for (int angleIndex = startAngleIndex; angleIndex < endAngleIndex + 1; angleIndex++)
+                    {
+                        angles.Add(sourceAngles[angleIndex]);
+                    }
+
+                    if (startAngle > 0.0f)
+                        angles[0] = interpolatePoints(startAngle, angles[0], angles[1]);
+
+                    if (stopAngle < 1.0f)
+                    {
+                        int lastAngleIndex = angles.Count - 1;
+                        angles[lastAngleIndex] = interpolatePoints(stopAngle, angles[lastAngleIndex - 1], angles[lastAngleIndex]);
+                    }
+                }
+                else
+                {
+                    for (int angleIndex = startAngleIndex; angleIndex < endAngleIndex; angleIndex++)
+                        angles.Add(sourceAngles[angleIndex]);
+                }
+            }
+            else
+            {
+                double stepSize = twoPi / sides;
+
+                int startStep = (int)(startAngle / stepSize);
+                double angle = stepSize * startStep;
+                int step = startStep;
+                double stopAngleTest = stopAngle;
+                if (stopAngle < twoPi)
+                {
+                    stopAngleTest = stepSize * ((int)(stopAngle / stepSize) + 1);
+                    if (stopAngleTest < stopAngle)
+                        stopAngleTest += stepSize;
+                    if (stopAngleTest > twoPi)
+                        stopAngleTest = twoPi;
+                }
+
+                while (angle <= stopAngleTest)
+                {
+                    Angle newAngle;
+                    newAngle.angle = (float)angle;
+                    newAngle.X = (float)System.Math.Cos(angle);
+                    newAngle.Y = (float)System.Math.Sin(angle);
+                    angles.Add(newAngle);
+                    step += 1;
+                    angle = stepSize * step;
+                }
+
+                if (startAngle > angles[0].angle)
+                {
+                    Angle newAngle;
+                    intersection(angles[0].X, angles[0].Y, angles[1].X, angles[1].Y, 0.0f, 0.0f, (float)Math.Cos(startAngle), (float)Math.Sin(startAngle));
+                    newAngle.angle = startAngle;
+                    newAngle.X = iX;
+                    newAngle.Y = iY;
+                    angles[0] = newAngle;
+                }
+
+                int index = angles.Count - 1;
+                if (stopAngle < angles[index].angle)
+                {
+                    Angle newAngle;
+                    intersection(angles[index - 1].X, angles[index - 1].Y, angles[index].X, angles[index].Y, 0.0f, 0.0f, (float)Math.Cos(stopAngle), (float)Math.Sin(stopAngle));
+                    newAngle.angle = stopAngle;
+                    newAngle.X = iX;
+                    newAngle.Y = iY;
+                    angles[index] = newAngle;
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// generates a profile for extrusion
+    /// </summary>
+    public class Profile
+    {
+        private const float twoPi = 2.0f * (float)Math.PI;
+
+        public string errorMessage = null;
+
+        public List<Coord> coords;
+        public List<Face> faces;
+
+        // use these for making individual meshes for each prim face
+        public List<int> outerCoordIndices = null;
+        public List<int> hollowCoordIndices = null;
+
+        public int numOuterVerts = 0;
+        public int numHollowVerts = 0;
+
+        public int outerFaceNumber = -1;
+        public int hollowFaceNumber = -1;
+
+        public int bottomFaceNumber = 0;
+        public int numPrimFaces = 0;
+
+        public Profile()
+        {
+            this.coords = new List<Coord>();
+            this.faces = new List<Face>();
+        }
+
+        public Profile(int sides, float profileStart, float profileEnd, float hollow, int hollowSides, bool hasProfileCut, bool createFaces)
+        {
+            const float halfSqr2 = 0.7071067811866f;
+            
+            this.coords = new List<Coord>();
+            this.faces = new List<Face>();
+
+            List<Coord> hollowCoords = new List<Coord>();
+
+            bool hasHollow = (hollow > 0.0f);
+
+            AngleList angles = new AngleList();
+            AngleList hollowAngles = new AngleList();
+
+            float xScale = 0.5f;
+            float yScale = 0.5f;
+            if (sides == 4)  // corners of a square are sqrt(2) from center
+            {
+                xScale = halfSqr2;
+                yScale = halfSqr2;
+            }
+
+            float startAngle = profileStart * twoPi;
+            float stopAngle = profileEnd * twoPi;
+
+            try { angles.makeAngles(sides, startAngle, stopAngle,hasProfileCut); }
+            catch (Exception ex)
+            {
+
+                errorMessage = "makeAngles failed: Exception: " + ex.ToString()
+                + "\nsides: " + sides.ToString() + " startAngle: " + startAngle.ToString() + " stopAngle: " + stopAngle.ToString();
+
+                return;
+            }
+
+            this.numOuterVerts = angles.angles.Count;
+
+            Angle angle;
+            Coord newVert = new Coord();
+
+            // flag to create as few triangles as possible for 3 or 4 side profile
+            bool simpleFace = (sides < 5 && !hasHollow && !hasProfileCut);
+
+            if (hasHollow)
+            {
+                if (sides == hollowSides)
+                    hollowAngles = angles;
+                else
+                {
+                    try { hollowAngles.makeAngles(hollowSides, startAngle, stopAngle, hasProfileCut); }
+                    catch (Exception ex)
+                    {
+                        errorMessage = "makeAngles failed: Exception: " + ex.ToString()
+                        + "\nsides: " + sides.ToString() + " startAngle: " + startAngle.ToString() + " stopAngle: " + stopAngle.ToString();
+
+                        return;
+                    }
+
+                    int numHollowAngles = hollowAngles.angles.Count;
+                    for (int i = 0; i < numHollowAngles; i++)
+                    {
+                        angle = hollowAngles.angles[i];
+                        newVert.X = hollow * xScale * angle.X;
+                        newVert.Y = hollow * yScale * angle.Y;
+                        newVert.Z = 0.0f;
+
+                        hollowCoords.Add(newVert);
+                    }
+                }
+                this.numHollowVerts = hollowAngles.angles.Count;
+            }
+            else if (!simpleFace)
+            {
+                Coord center = new Coord(0.0f, 0.0f, 0.0f);
+                this.coords.Add(center);
+            }
+
+            int numAngles = angles.angles.Count;
+            bool hollowsame = (hasHollow && hollowSides == sides);
+
+            for (int i = 0; i < numAngles; i++)
+            {
+                angle = angles.angles[i];
+                newVert.X = angle.X * xScale;
+                newVert.Y = angle.Y * yScale;
+                newVert.Z = 0.0f;
+                this.coords.Add(newVert);
+                if (hollowsame)
+                {
+                    newVert.X *= hollow;
+                    newVert.Y *= hollow;
+                    hollowCoords.Add(newVert);
+                }
+            }
+
+            if (hasHollow)
+            {
+                hollowCoords.Reverse();
+                this.coords.AddRange(hollowCoords);
+
+                if (createFaces)
+                {
+                    int numTotalVerts = this.numOuterVerts + this.numHollowVerts;
+
+                    if (this.numOuterVerts == this.numHollowVerts)
+                    {
+                        Face newFace = new Face();
+
+                        for (int coordIndex = 0; coordIndex < this.numOuterVerts - 1; coordIndex++)
+                        {
+                            newFace.v1 = coordIndex;
+                            newFace.v2 = coordIndex + 1;
+                            newFace.v3 = numTotalVerts - coordIndex - 1;
+                            this.faces.Add(newFace);
+
+                            newFace.v1 = coordIndex + 1;
+                            newFace.v2 = numTotalVerts - coordIndex - 2;
+                            newFace.v3 = numTotalVerts - coordIndex - 1;
+                            this.faces.Add(newFace);
+                        }
+                        if (!hasProfileCut)
+                        {
+                            newFace.v1 = this.numOuterVerts - 1;
+                            newFace.v2 = 0;
+                            newFace.v3 = this.numOuterVerts;
+                            this.faces.Add(newFace);
+
+                            newFace.v1 = 0;
+                            newFace.v2 = numTotalVerts - 1;
+                            newFace.v3 = this.numOuterVerts;
+                            this.faces.Add(newFace);
+                        }
+                    }
+                    else if (this.numOuterVerts < this.numHollowVerts)
+                    {
+                        Face newFace = new Face();
+                        int j = 0; // j is the index for outer vertices
+                        int i;
+                        int maxJ = this.numOuterVerts - 1;
+                        float curHollowAngle = 0;
+                        for (i = 0; i < this.numHollowVerts; i++) // i is the index for inner vertices
+                        {
+                            curHollowAngle = hollowAngles.angles[i].angle;
+                            if (j < maxJ)
+                            {
+                                if (angles.angles[j + 1].angle - curHollowAngle < curHollowAngle - angles.angles[j].angle + 0.000001f)
+                                {
+                                    newFace.v1 = numTotalVerts - i - 1;
+                                    newFace.v2 = j;
+                                    newFace.v3 = j + 1;
+                                    this.faces.Add(newFace);
+                                    j++;
+                                }
+                            }
+                            else
+                            {
+                                if (1.0f - curHollowAngle < curHollowAngle - angles.angles[j].angle + 0.000001f)
+                                    break;
+                            }
+
+                            newFace.v1 = j;
+                            newFace.v2 = numTotalVerts - i - 2;
+                            newFace.v3 = numTotalVerts - i - 1;
+
+                            this.faces.Add(newFace);
+                        }
+
+                        if (!hasProfileCut)
+                        {
+                            if (i == this.numHollowVerts)
+                            {
+                                newFace.v1 = numTotalVerts - this.numHollowVerts;
+                                newFace.v2 = maxJ;
+                                newFace.v3 = 0;
+
+                                this.faces.Add(newFace);
+                            }
+                            else
+                            {
+                                if (1.0f - curHollowAngle < curHollowAngle - angles.angles[maxJ].angle + 0.000001f)
+                                {
+                                    newFace.v1 = numTotalVerts - i - 1;
+                                    newFace.v2 = maxJ;
+                                    newFace.v3 = 0;
+
+                                    this.faces.Add(newFace);
+                                }
+
+                                for (; i < this.numHollowVerts - 1; i++)
+                                {
+                                    newFace.v1 = 0;
+                                    newFace.v2 = numTotalVerts - i - 2;
+                                    newFace.v3 = numTotalVerts - i - 1;
+
+                                    this.faces.Add(newFace);
+                                }
+                            }
+
+                            newFace.v1 = 0;
+                            newFace.v2 = numTotalVerts - this.numHollowVerts;
+                            newFace.v3 = numTotalVerts - 1;
+                            this.faces.Add(newFace);
+                        }
+                    }
+                    else // numHollowVerts < numOuterVerts
+                    {
+                        Face newFace = new Face();
+                        int j = 0; // j is the index for inner vertices
+                        int maxJ = this.numHollowVerts - 1;
+                        for (int i = 0; i < this.numOuterVerts; i++)
+                        {
+                            if (j < maxJ)
+                                if (hollowAngles.angles[j + 1].angle - angles.angles[i].angle < angles.angles[i].angle - hollowAngles.angles[j].angle + 0.000001f)
+                                {
+                                    newFace.v1 = i;
+                                    newFace.v2 = numTotalVerts - j - 2;
+                                    newFace.v3 = numTotalVerts - j - 1;
+
+                                    this.faces.Add(newFace);
+                                    j += 1;
+                                }
+
+                            newFace.v1 = numTotalVerts - j - 1;
+                            newFace.v2 = i;
+                            newFace.v3 = i + 1;
+
+                            this.faces.Add(newFace);
+                        }
+
+                        if (!hasProfileCut)
+                        {
+                            int i = this.numOuterVerts - 1;
+
+                            if (hollowAngles.angles[0].angle - angles.angles[i].angle < angles.angles[i].angle - hollowAngles.angles[maxJ].angle + 0.000001f)
+                            {
+                                newFace.v1 = 0;
+                                newFace.v2 = numTotalVerts - maxJ - 1;
+                                newFace.v3 = numTotalVerts - 1;
+
+                                this.faces.Add(newFace);
+                            }
+
+                            newFace.v1 = numTotalVerts - maxJ - 1;
+                            newFace.v2 = i;
+                            newFace.v3 = 0;
+
+                            this.faces.Add(newFace);
+                        }
+                    }
+                }
+                
+            }
+
+            else if (createFaces)
+            {
+                if (simpleFace)
+                {
+                    if (sides == 3)
+                        this.faces.Add(new Face(0, 1, 2));
+                    else if (sides == 4)
+                    {
+                        this.faces.Add(new Face(0, 1, 2));
+                        this.faces.Add(new Face(0, 2, 3));
+                    }
+                }
+                else
+                {
+                    for (int i = 1; i < numAngles ; i++)
+                    {
+                        Face newFace = new Face();
+                        newFace.v1 = 0;
+                        newFace.v2 = i;
+                        newFace.v3 = i + 1;
+                        this.faces.Add(newFace);
+                    }
+                    if (!hasProfileCut)
+                    {
+                        Face newFace = new Face();
+                        newFace.v1 = 0;
+                        newFace.v2 = numAngles;
+                        newFace.v3 = 1;
+                        this.faces.Add(newFace);
+                    }
+                }
+            }
+
+
+            hollowCoords = null;
+        }
+
+
+        public Profile Copy()
+        {
+            return this.Copy(true);
+        }
+
+        public Profile Copy(bool needFaces)
+        {
+            Profile copy = new Profile();
+
+            copy.coords.AddRange(this.coords);
+
+            if (needFaces)
+                copy.faces.AddRange(this.faces);
+
+            copy.numOuterVerts = this.numOuterVerts;
+            copy.numHollowVerts = this.numHollowVerts;
+
+            return copy;
+        }
+
+        public void AddPos(Coord v)
+        {
+            this.AddPos(v.X, v.Y, v.Z);
+        }
+
+        public void AddPos(float x, float y, float z)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+            Coord vert;
+
+            for (i = 0; i < numVerts; i++)
+            {
+                vert = this.coords[i];
+                vert.X += x;
+                vert.Y += y;
+                vert.Z += z;
+                this.coords[i] = vert;
+            }
+        }
+
+        public void AddRot(Quat q)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+
+            for (i = 0; i < numVerts; i++)
+                this.coords[i] *= q;
+        }
+
+        public void Scale(float x, float y)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+            Coord vert;
+
+            for (i = 0; i < numVerts; i++)
+            {
+                vert = this.coords[i];
+                vert.X *= x;
+                vert.Y *= y;
+                this.coords[i] = vert;
+            }
+        }
+
+        /// <summary>
+        /// Changes order of the vertex indices and negates the center vertex normal. Does not alter vertex normals of radial vertices
+        /// </summary>
+        public void FlipNormals()
+        {
+            int i;
+            int numFaces = this.faces.Count;
+            Face tmpFace;
+            int tmp;
+
+            for (i = 0; i < numFaces; i++)
+            {
+                tmpFace = this.faces[i];
+                tmp = tmpFace.v3;
+                tmpFace.v3 = tmpFace.v1;
+                tmpFace.v1 = tmp;
+                this.faces[i] = tmpFace;
+            }
+        }
+
+        public void AddValue2FaceVertexIndices(int num)
+        {
+            int numFaces = this.faces.Count;
+            Face tmpFace;
+            for (int i = 0; i < numFaces; i++)
+            {
+                tmpFace = this.faces[i];
+                tmpFace.v1 += num;
+                tmpFace.v2 += num;
+                tmpFace.v3 += num;
+
+                this.faces[i] = tmpFace;
+            }
+        }
+
+         public void DumpRaw(String path, String name, String title)
+        {
+            if (path == null)
+                return;
+            String fileName = name + "_" + title + ".raw";
+            String completePath = System.IO.Path.Combine(path, fileName);
+            StreamWriter sw = new StreamWriter(completePath);
+
+            for (int i = 0; i < this.faces.Count; i++)
+            {
+                string s = this.coords[this.faces[i].v1].ToString();
+                s += " " + this.coords[this.faces[i].v2].ToString();
+                s += " " + this.coords[this.faces[i].v3].ToString();
+
+                sw.WriteLine(s);
+            }
+
+            sw.Close();
+        }
+    }
+
+    public struct PathNode
+    {
+        public Coord position;
+        public Quat rotation;
+        public float xScale;
+        public float yScale;
+        public float percentOfPath;
+    }
+
+    public enum PathType { Linear = 0, Circular = 1, Flexible = 2 }
+
+    public class Path
+    {
+        public List<PathNode> pathNodes = new List<PathNode>();
+
+        public float twistBegin = 0.0f;
+        public float twistEnd = 0.0f;
+        public float topShearX = 0.0f;
+        public float topShearY = 0.0f;
+        public float pathCutBegin = 0.0f;
+        public float pathCutEnd = 1.0f;
+        public float dimpleBegin = 0.0f;
+        public float dimpleEnd = 1.0f;
+        public float skew = 0.0f;
+        public float holeSizeX = 1.0f; // called pathScaleX in pbs
+        public float holeSizeY = 0.25f;
+        public float taperX = 0.0f;
+        public float taperY = 0.0f;
+        public float radius = 0.0f;
+        public float revolutions = 1.0f;
+        public int stepsPerRevolution = 24;
+
+        private const float twoPi = 2.0f * (float)Math.PI;
+
+        public void Create(PathType pathType, int steps)
+        {
+            if (this.taperX > 0.999f)
+                this.taperX = 0.999f;
+            if (this.taperX < -0.999f)
+                this.taperX = -0.999f;
+            if (this.taperY > 0.999f)
+                this.taperY = 0.999f;
+            if (this.taperY < -0.999f)
+                this.taperY = -0.999f;
+
+            if (pathType == PathType.Linear || pathType == PathType.Flexible)
+            {
+                int step = 0;
+
+                float length = this.pathCutEnd - this.pathCutBegin;
+                float twistTotal = twistEnd - twistBegin;
+                float twistTotalAbs = Math.Abs(twistTotal);
+                if (twistTotalAbs > 0.01f)
+                    steps += (int)(twistTotalAbs * 3.66); //  dahlia's magic number
+
+                float start = -0.5f;
+                float stepSize = length / (float)steps;
+                float percentOfPathMultiplier = stepSize * 0.999999f;
+                float xOffset = this.topShearX * this.pathCutBegin;
+                float yOffset = this.topShearY * this.pathCutBegin;
+                float zOffset = start;
+                float xOffsetStepIncrement = this.topShearX * length / steps;
+                float yOffsetStepIncrement = this.topShearY * length / steps;
+
+                float percentOfPath = this.pathCutBegin;
+                zOffset += percentOfPath;
+
+                // sanity checks
+
+                bool done = false;
+
+                while (!done)
+                {
+                    PathNode newNode = new PathNode();
+
+                    newNode.xScale = 1.0f;
+                    if (this.taperX == 0.0f)
+                        newNode.xScale = 1.0f;
+                    else if (this.taperX > 0.0f)
+                        newNode.xScale = 1.0f - percentOfPath * this.taperX;
+                    else newNode.xScale = 1.0f + (1.0f - percentOfPath) * this.taperX;
+
+                    newNode.yScale = 1.0f;
+                    if (this.taperY == 0.0f)
+                        newNode.yScale = 1.0f;
+                    else if (this.taperY > 0.0f)
+                        newNode.yScale = 1.0f - percentOfPath * this.taperY;
+                    else newNode.yScale = 1.0f + (1.0f - percentOfPath) * this.taperY;
+
+                    float twist = twistBegin + twistTotal * percentOfPath;
+
+                    newNode.rotation = new Quat(new Coord(0.0f, 0.0f, 1.0f), twist);
+                    newNode.position = new Coord(xOffset, yOffset, zOffset);
+                    newNode.percentOfPath = percentOfPath;
+
+                    pathNodes.Add(newNode);
+
+                    if (step < steps)
+                    {
+                        step += 1;
+                        percentOfPath += percentOfPathMultiplier;
+                        xOffset += xOffsetStepIncrement;
+                        yOffset += yOffsetStepIncrement;
+                        zOffset += stepSize;
+                        if (percentOfPath > this.pathCutEnd)
+                            done = true;
+                    }
+                    else done = true;
+                }
+            } // end of linear path code
+
+            else // pathType == Circular
+            {
+                float twistTotal = twistEnd - twistBegin;
+
+                // if the profile has a lot of twist, add more layers otherwise the layers may overlap
+                // and the resulting mesh may be quite inaccurate. This method is arbitrary and doesn't
+                // accurately match the viewer
+                float twistTotalAbs = Math.Abs(twistTotal);
+                if (twistTotalAbs > 0.01f)
+                {
+                    if (twistTotalAbs > Math.PI * 1.5f)
+                        steps *= 2;
+                    if (twistTotalAbs > Math.PI * 3.0f)
+                        steps *= 2;
+                }
+
+                float yPathScale = this.holeSizeY * 0.5f;
+                float pathLength = this.pathCutEnd - this.pathCutBegin;
+                float totalSkew = this.skew * 2.0f * pathLength;
+                float skewStart = this.pathCutBegin * 2.0f * this.skew - this.skew;
+                float xOffsetTopShearXFactor = this.topShearX * (0.25f + 0.5f * (0.5f - this.holeSizeY));
+                float yShearCompensation = 1.0f + Math.Abs(this.topShearY) * 0.25f;
+
+                // It's not quite clear what pushY (Y top shear) does, but subtracting it from the start and end
+                // angles appears to approximate it's effects on path cut. Likewise, adding it to the angle used
+                // to calculate the sine for generating the path radius appears to approximate it's effects there
+                // too, but there are some subtle differences in the radius which are noticeable as the prim size
+                // increases and it may affect megaprims quite a bit. The effect of the Y top shear parameter on
+                // the meshes generated with this technique appear nearly identical in shape to the same prims when
+                // displayed by the viewer.
+
+                float startAngle = (twoPi * this.pathCutBegin * this.revolutions) - this.topShearY * 0.9f;
+                float endAngle = (twoPi * this.pathCutEnd * this.revolutions) - this.topShearY * 0.9f;
+                float stepSize = twoPi / this.stepsPerRevolution;
+
+                int step = (int)(startAngle / stepSize);
+                float angle = startAngle;
+
+                bool done = false;
+                while (!done) // loop through the length of the path and add the layers
+                {
+                    PathNode newNode = new PathNode();
+
+                    float xProfileScale = (1.0f - Math.Abs(this.skew)) * this.holeSizeX;
+                    float yProfileScale = this.holeSizeY;
+
+                    float percentOfPath = angle / (twoPi * this.revolutions);
+                    float percentOfAngles = (angle - startAngle) / (endAngle - startAngle);
+
+                    if (this.taperX > 0.01f)
+                        xProfileScale *= 1.0f - percentOfPath * this.taperX;
+                    else if (this.taperX < -0.01f)
+                        xProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperX;
+
+                    if (this.taperY > 0.01f)
+                        yProfileScale *= 1.0f - percentOfPath * this.taperY;
+                    else if (this.taperY < -0.01f)
+                        yProfileScale *= 1.0f + (1.0f - percentOfPath) * this.taperY;
+
+                    newNode.xScale = xProfileScale;
+                    newNode.yScale = yProfileScale;
+
+                    float radiusScale = 1.0f;
+                    if (this.radius > 0.001f)
+                        radiusScale = 1.0f - this.radius * percentOfPath;
+                    else if (this.radius < 0.001f)
+                        radiusScale = 1.0f + this.radius * (1.0f - percentOfPath);
+
+                    float twist = twistBegin + twistTotal * percentOfPath;
+
+                    float xOffset = 0.5f * (skewStart + totalSkew * percentOfAngles);
+                    xOffset += (float)Math.Sin(angle) * xOffsetTopShearXFactor;
+
+                    float yOffset = yShearCompensation * (float)Math.Cos(angle) * (0.5f - yPathScale) * radiusScale;
+
+                    float zOffset = (float)Math.Sin(angle + this.topShearY) * (0.5f - yPathScale) * radiusScale;
+
+                    newNode.position = new Coord(xOffset, yOffset, zOffset);
+
+                    // now orient the rotation of the profile layer relative to it's position on the path
+                    // adding taperY to the angle used to generate the quat appears to approximate the viewer
+
+                    newNode.rotation = new Quat(new Coord(1.0f, 0.0f, 0.0f), angle + this.topShearY);
+
+                    // next apply twist rotation to the profile layer
+                    if (twistTotal != 0.0f || twistBegin != 0.0f)
+                        newNode.rotation *= new Quat(new Coord(0.0f, 0.0f, 1.0f), twist);
+
+                    newNode.percentOfPath = percentOfPath;
+
+                    pathNodes.Add(newNode);
+
+                    // calculate terms for next iteration
+                    // calculate the angle for the next iteration of the loop
+
+                    if (angle >= endAngle - 0.01)
+                        done = true;
+                    else
+                    {
+                        step += 1;
+                        angle = stepSize * step;
+                        if (angle > endAngle)
+                            angle = endAngle;
+                    }
+                }
+            }
+        }
+    }
+
+    public class PrimMesh
+    {
+        public string errorMessage = "";
+        private const float twoPi = 2.0f * (float)Math.PI;
+
+        public List<Coord> coords;
+//        public List<Coord> normals;
+        public List<Face> faces;
+
+        private int sides = 4;
+        private int hollowSides = 4;
+        private float profileStart = 0.0f;
+        private float profileEnd = 1.0f;
+        private float hollow = 0.0f;
+        public int twistBegin = 0;
+        public int twistEnd = 0;
+        public float topShearX = 0.0f;
+        public float topShearY = 0.0f;
+        public float pathCutBegin = 0.0f;
+        public float pathCutEnd = 1.0f;
+        public float dimpleBegin = 0.0f;
+        public float dimpleEnd = 1.0f;
+        public float skew = 0.0f;
+        public float holeSizeX = 1.0f; // called pathScaleX in pbs
+        public float holeSizeY = 0.25f;
+        public float taperX = 0.0f;
+        public float taperY = 0.0f;
+        public float radius = 0.0f;
+        public float revolutions = 1.0f;
+        public int stepsPerRevolution = 24;
+
+        private bool hasProfileCut = false;
+        private bool hasHollow = false;
+
+        public int numPrimFaces = 0;
+
+        /// <summary>
+        /// Human readable string representation of the parameters used to create a mesh.
+        /// </summary>
+        /// <returns></returns>
+        public string ParamsToDisplayString()
+        {
+            string s = "";
+            s += "sides..................: " + this.sides.ToString();
+            s += "\nhollowSides..........: " + this.hollowSides.ToString();
+            s += "\nprofileStart.........: " + this.profileStart.ToString();
+            s += "\nprofileEnd...........: " + this.profileEnd.ToString();
+            s += "\nhollow...............: " + this.hollow.ToString();
+            s += "\ntwistBegin...........: " + this.twistBegin.ToString();
+            s += "\ntwistEnd.............: " + this.twistEnd.ToString();
+            s += "\ntopShearX............: " + this.topShearX.ToString();
+            s += "\ntopShearY............: " + this.topShearY.ToString();
+            s += "\npathCutBegin.........: " + this.pathCutBegin.ToString();
+            s += "\npathCutEnd...........: " + this.pathCutEnd.ToString();
+            s += "\ndimpleBegin..........: " + this.dimpleBegin.ToString();
+            s += "\ndimpleEnd............: " + this.dimpleEnd.ToString();
+            s += "\nskew.................: " + this.skew.ToString();
+            s += "\nholeSizeX............: " + this.holeSizeX.ToString();
+            s += "\nholeSizeY............: " + this.holeSizeY.ToString();
+            s += "\ntaperX...............: " + this.taperX.ToString();
+            s += "\ntaperY...............: " + this.taperY.ToString();
+            s += "\nradius...............: " + this.radius.ToString();
+            s += "\nrevolutions..........: " + this.revolutions.ToString();
+            s += "\nstepsPerRevolution...: " + this.stepsPerRevolution.ToString();
+            s += "\nhasProfileCut........: " + this.hasProfileCut.ToString();
+            s += "\nhasHollow............: " + this.hasHollow.ToString();          
+
+            return s;
+        }
+
+        public bool HasProfileCut
+        {
+            get { return hasProfileCut; }
+            set { hasProfileCut = value; }
+        }
+
+        public bool HasHollow
+        {
+            get { return hasHollow; }
+        }
+
+
+        /// <summary>
+        /// Constructs a PrimMesh object and creates the profile for extrusion.
+        /// </summary>
+        /// <param name="sides"></param>
+        /// <param name="profileStart"></param>
+        /// <param name="profileEnd"></param>
+        /// <param name="hollow"></param>
+        /// <param name="hollowSides"></param>
+        /// <param name="sphereMode"></param>
+        public PrimMesh(int sides, float profileStart, float profileEnd, float hollow, int hollowSides)
+        {
+            this.coords = new List<Coord>();
+            this.faces = new List<Face>();
+
+            this.sides = sides;
+            this.profileStart = profileStart;
+            this.profileEnd = profileEnd;
+            this.hollow = hollow;
+            this.hollowSides = hollowSides;
+
+            if (sides < 3)
+                this.sides = 3;
+            if (hollowSides < 3)
+                this.hollowSides = 3;
+            if (profileStart < 0.0f)
+                this.profileStart = 0.0f;
+            if (profileEnd > 1.0f)
+                this.profileEnd = 1.0f;
+            if (profileEnd < 0.02f)
+                this.profileEnd = 0.02f;
+            if (profileStart >= profileEnd)
+                this.profileStart = profileEnd - 0.02f;
+            if (hollow > 0.99f)
+                this.hollow = 0.99f;
+            if (hollow < 0.0f)
+                this.hollow = 0.0f;
+        }
+
+        /// <summary>
+        /// Extrudes a profile along a path.
+        /// </summary>
+        public void Extrude(PathType pathType)
+        {
+            bool needEndFaces = false;
+
+            this.coords = new List<Coord>();
+            this.faces = new List<Face>();
+
+            int steps = 1;
+
+            float length = this.pathCutEnd - this.pathCutBegin;
+
+            this.hasProfileCut = this.profileEnd - this.profileStart < 0.9999f;
+
+            this.hasHollow = (this.hollow > 0.001f);
+
+            float twistBegin = this.twistBegin / 360.0f * twoPi;
+            float twistEnd = this.twistEnd / 360.0f * twoPi;
+            float twistTotal = twistEnd - twistBegin;
+            float twistTotalAbs = Math.Abs(twistTotal);
+            if (twistTotalAbs > 0.01f)
+                steps += (int)(twistTotalAbs * 3.66); //  dahlia's magic number
+
+            float hollow = this.hollow;
+
+            if (pathType == PathType.Circular)
+            {
+                needEndFaces = false;
+                if (this.pathCutBegin != 0.0f || this.pathCutEnd != 1.0f)
+                    needEndFaces = true;
+                else if (this.taperX != 0.0f || this.taperY != 0.0f)
+                    needEndFaces = true;
+                else if (this.skew != 0.0f)
+                    needEndFaces = true;
+                else if (twistTotal != 0.0f)
+                    needEndFaces = true;
+                else if (this.radius != 0.0f)
+                    needEndFaces = true;
+            }
+            else needEndFaces = true;
+
+            // sanity checks
+            float initialProfileRot = 0.0f;
+            if (pathType == PathType.Circular)
+            {
+                if (this.sides == 3)
+                {
+                    initialProfileRot = (float)Math.PI;
+                    if (this.hollowSides == 4)
+                    {
+                        if (hollow > 0.7f)
+                            hollow = 0.7f;
+                        hollow *= 0.707f;
+                    }
+                    else hollow *= 0.5f;
+                }
+                else if (this.sides == 4)
+                {
+                    initialProfileRot = 0.25f * (float)Math.PI;
+                    if (this.hollowSides != 4)
+                        hollow *= 0.707f;
+                }
+                else if (this.sides > 4)
+                {
+                    initialProfileRot = (float)Math.PI;
+                    if (this.hollowSides == 4)
+                    {
+                        if (hollow > 0.7f)
+                            hollow = 0.7f;
+                        hollow /= 0.7f;
+                    }
+                }
+            }
+            else
+            {
+                if (this.sides == 3)
+                {
+                    if (this.hollowSides == 4)
+                    {
+                        if (hollow > 0.7f)
+                            hollow = 0.7f;
+                        hollow *= 0.707f;
+                    }
+                    else hollow *= 0.5f;
+                }
+                else if (this.sides == 4)
+                {
+                    initialProfileRot = 1.25f * (float)Math.PI;
+                    if (this.hollowSides != 4)
+                        hollow *= 0.707f;
+                }
+                else if (this.sides == 24 && this.hollowSides == 4)
+                    hollow *= 1.414f;
+            }
+
+            Profile profile = new Profile(this.sides, this.profileStart, this.profileEnd, hollow, this.hollowSides, this.hasProfileCut,true);
+            this.errorMessage = profile.errorMessage;
+
+            this.numPrimFaces = profile.numPrimFaces;
+
+            if (initialProfileRot != 0.0f)
+            {
+                profile.AddRot(new Quat(new Coord(0.0f, 0.0f, 1.0f), initialProfileRot));
+            }
+
+            float thisV = 0.0f;
+            float lastV = 0.0f;
+
+            Path path = new Path();
+            path.twistBegin = twistBegin;
+            path.twistEnd = twistEnd;
+            path.topShearX = topShearX;
+            path.topShearY = topShearY;
+            path.pathCutBegin = pathCutBegin;
+            path.pathCutEnd = pathCutEnd;
+            path.dimpleBegin = dimpleBegin;
+            path.dimpleEnd = dimpleEnd;
+            path.skew = skew;
+            path.holeSizeX = holeSizeX;
+            path.holeSizeY = holeSizeY;
+            path.taperX = taperX;
+            path.taperY = taperY;
+            path.radius = radius;
+            path.revolutions = revolutions;
+            path.stepsPerRevolution = stepsPerRevolution;
+
+            path.Create(pathType, steps);
+            
+            int lastNode = path.pathNodes.Count -1;
+
+            for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++)
+            {
+                PathNode node = path.pathNodes[nodeIndex];
+                Profile newLayer = profile.Copy();
+
+                newLayer.Scale(node.xScale, node.yScale);
+                newLayer.AddRot(node.rotation);
+                newLayer.AddPos(node.position);
+
+                if (needEndFaces && nodeIndex == 0)
+                {
+                    newLayer.FlipNormals();
+                } // if (nodeIndex == 0)
+
+                // append this layer
+
+                int coordsLen = this.coords.Count;
+                newLayer.AddValue2FaceVertexIndices(coordsLen);
+
+                this.coords.AddRange(newLayer.coords);
+
+                if (needEndFaces)
+                {
+                    if (nodeIndex == 0)
+                        this.faces.AddRange(newLayer.faces);
+                    else if (nodeIndex == lastNode)
+                    {
+                        if (node.xScale > 1e-6 && node.yScale > 1e-6)
+                            this.faces.AddRange(newLayer.faces);
+                    }
+                }
+
+                // fill faces between layers
+
+                int numVerts = newLayer.coords.Count;
+                Face newFace1 = new Face();
+                Face newFace2 = new Face();
+
+                thisV = 1.0f - node.percentOfPath;
+
+                if (nodeIndex > 0)
+                {
+                    int startVert = coordsLen;
+                    int endVert = this.coords.Count;
+                    if (!this.hasProfileCut)
+                    {
+                        int i = startVert;
+                        for (int l = 0; l < profile.numOuterVerts - 1; l++)
+                        {
+                            newFace1.v1 = i;
+                            newFace1.v2 = i - numVerts;
+                            newFace1.v3 = i + 1;
+                            this.faces.Add(newFace1);
+
+                            newFace2.v1 = i + 1;
+                            newFace2.v2 = i - numVerts;
+                            newFace2.v3 = i + 1 - numVerts;
+                            this.faces.Add(newFace2);
+                            i++;
+                        }
+
+                        newFace1.v1 = i;
+                        newFace1.v2 = i - numVerts;
+                        newFace1.v3 = startVert;
+                        this.faces.Add(newFace1);
+
+                        newFace2.v1 = startVert;
+                        newFace2.v2 = i - numVerts;
+                        newFace2.v3 = startVert - numVerts;
+                        this.faces.Add(newFace2);
+
+                        if (this.hasHollow)
+                        {
+                            startVert = ++i;
+                            for (int l = 0; l < profile.numHollowVerts - 1; l++)
+                            {
+                                newFace1.v1 = i;
+                                newFace1.v2 = i - numVerts;
+                                newFace1.v3 = i + 1;
+                                this.faces.Add(newFace1);
+
+                                newFace2.v1 = i + 1;
+                                newFace2.v2 = i - numVerts;
+                                newFace2.v3 = i + 1 - numVerts;
+                                this.faces.Add(newFace2);
+                                i++;
+                            }
+
+                            newFace1.v1 = i;
+                            newFace1.v2 = i - numVerts;
+                            newFace1.v3 = startVert;
+                            this.faces.Add(newFace1);
+
+                            newFace2.v1 = startVert;
+                            newFace2.v2 = i - numVerts;
+                            newFace2.v3 = startVert - numVerts;
+                            this.faces.Add(newFace2);
+                        }
+
+
+                    }
+                    else
+                    {
+                        for (int i = startVert; i < endVert; i++)
+                        {
+                            int iNext = i + 1;
+                            if (i == endVert - 1)
+                                iNext = startVert;
+
+                            newFace1.v1 = i;
+                            newFace1.v2 = i - numVerts;
+                            newFace1.v3 = iNext;
+                            this.faces.Add(newFace1);
+
+                            newFace2.v1 = iNext;
+                            newFace2.v2 = i - numVerts;
+                            newFace2.v3 = iNext - numVerts;
+                            this.faces.Add(newFace2);
+
+                        }
+                    }
+                }
+
+                lastV = thisV;
+
+            } // for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++)
+
+        }
+
+
+        /// <summary>
+        /// DEPRICATED - use Extrude(PathType.Linear) instead
+        /// Extrudes a profile along a straight line path. Used for prim types box, cylinder, and prism.
+        /// </summary>
+        /// 
+        public void ExtrudeLinear()
+        {
+            this.Extrude(PathType.Linear);
+        }
+
+
+        /// <summary>
+        /// DEPRICATED - use Extrude(PathType.Circular) instead
+        /// Extrude a profile into a circular path prim mesh. Used for prim types torus, tube, and ring.
+        /// </summary>
+        /// 
+        public void ExtrudeCircular()
+        {
+            this.Extrude(PathType.Circular);
+        }
+
+
+        private Coord SurfaceNormal(Coord c1, Coord c2, Coord c3)
+        {
+            Coord edge1 = new Coord(c2.X - c1.X, c2.Y - c1.Y, c2.Z - c1.Z);
+            Coord edge2 = new Coord(c3.X - c1.X, c3.Y - c1.Y, c3.Z - c1.Z);
+
+            Coord normal = Coord.Cross(edge1, edge2);
+
+            normal.Normalize();
+
+            return normal;
+        }
+
+        private Coord SurfaceNormal(Face face)
+        {
+            return SurfaceNormal(this.coords[face.v1], this.coords[face.v2], this.coords[face.v3]);
+        }
+
+        /// <summary>
+        /// Calculate the surface normal for a face in the list of faces
+        /// </summary>
+        /// <param name="faceIndex"></param>
+        /// <returns></returns>
+        public Coord SurfaceNormal(int faceIndex)
+        {
+            int numFaces = this.faces.Count;
+            if (faceIndex < 0 || faceIndex >= numFaces)
+                throw new Exception("faceIndex out of range");
+
+            return SurfaceNormal(this.faces[faceIndex]);
+        }
+
+        /// <summary>
+        /// Duplicates a PrimMesh object. All object properties are copied by value, including lists.
+        /// </summary>
+        /// <returns></returns>
+        public PrimMesh Copy()
+        {
+            PrimMesh copy = new PrimMesh(this.sides, this.profileStart, this.profileEnd, this.hollow, this.hollowSides);
+            copy.twistBegin = this.twistBegin;
+            copy.twistEnd = this.twistEnd;
+            copy.topShearX = this.topShearX;
+            copy.topShearY = this.topShearY;
+            copy.pathCutBegin = this.pathCutBegin;
+            copy.pathCutEnd = this.pathCutEnd;
+            copy.dimpleBegin = this.dimpleBegin;
+            copy.dimpleEnd = this.dimpleEnd;
+            copy.skew = this.skew;
+            copy.holeSizeX = this.holeSizeX;
+            copy.holeSizeY = this.holeSizeY;
+            copy.taperX = this.taperX;
+            copy.taperY = this.taperY;
+            copy.radius = this.radius;
+            copy.revolutions = this.revolutions;
+            copy.stepsPerRevolution = this.stepsPerRevolution;
+
+            copy.numPrimFaces = this.numPrimFaces;
+            copy.errorMessage = this.errorMessage;
+
+            copy.coords = new List<Coord>(this.coords);
+            copy.faces = new List<Face>(this.faces);
+
+            return copy;
+        }
+
+        /// <summary>
+        /// Adds a value to each XYZ vertex coordinate in the mesh
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="z"></param>
+        public void AddPos(float x, float y, float z)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+            Coord vert;
+
+            for (i = 0; i < numVerts; i++)
+            {
+                vert = this.coords[i];
+                vert.X += x;
+                vert.Y += y;
+                vert.Z += z;
+                this.coords[i] = vert;
+            }
+        }
+
+        /// <summary>
+        /// Rotates the mesh
+        /// </summary>
+        /// <param name="q"></param>
+        public void AddRot(Quat q)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+
+            for (i = 0; i < numVerts; i++)
+                this.coords[i] *= q;
+        }
+
+#if VERTEX_INDEXER
+        public VertexIndexer GetVertexIndexer()
+        {
+            return null;
+        }
+#endif
+
+        /// <summary>
+        /// Scales the mesh
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="z"></param>
+        public void Scale(float x, float y, float z)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+            //Coord vert;
+
+            Coord m = new Coord(x, y, z);
+            for (i = 0; i < numVerts; i++)
+                this.coords[i] *= m;
+        }
+
+        /// <summary>
+        /// Dumps the mesh to a Blender compatible "Raw" format file
+        /// </summary>
+        /// <param name="path"></param>
+        /// <param name="name"></param>
+        /// <param name="title"></param>
+        public void DumpRaw(String path, String name, String title)
+        {
+            if (path == null)
+                return;
+            String fileName = name + "_" + title + ".raw";
+            String completePath = System.IO.Path.Combine(path, fileName);
+            StreamWriter sw = new StreamWriter(completePath);
+
+            for (int i = 0; i < this.faces.Count; i++)
+            {
+                string s = this.coords[this.faces[i].v1].ToString();
+                s += " " + this.coords[this.faces[i].v2].ToString();
+                s += " " + this.coords[this.faces[i].v3].ToString();
+
+                sw.WriteLine(s);
+            }
+
+            sw.Close();
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitMeshing/SculptMap.cs b/OpenSim/Region/PhysicsModules/UbitMeshing/SculptMap.cs
new file mode 100644
index 0000000..1c75db6
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitMeshing/SculptMap.cs
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) Contributors
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace PrimMesher
+{
+    public class SculptMap
+    {
+        public int width;
+        public int height;
+        public byte[] redBytes;
+        public byte[] greenBytes;
+        public byte[] blueBytes;
+
+        public SculptMap()
+        {
+        }
+
+        public SculptMap(Bitmap bm, int lod)
+        {
+            int bmW = bm.Width;
+            int bmH = bm.Height;
+
+            if (bmW == 0 || bmH == 0)
+                throw new Exception("SculptMap: bitmap has no data");
+
+            int numLodPixels = lod * lod;  // (32 * 2)^2  = 64^2 pixels for default sculpt map image
+
+            bool needsScaling = false;
+            bool smallMap = false;
+
+            width = bmW;
+            height = bmH;
+
+            while (width * height > numLodPixels * 4)
+            {
+                width >>= 1;
+                height >>= 1;
+                needsScaling = true;
+            }
+
+            try
+            {
+                if (needsScaling)
+                    bm = ScaleImage(bm, width, height);
+            }
+
+            catch (Exception e)
+            {
+                throw new Exception("Exception in ScaleImage(): e: " + e.ToString());
+            }
+
+            if (width * height > numLodPixels)
+            {
+                smallMap = false;
+                width >>= 1;
+                height >>= 1;
+            }
+            else
+                smallMap = true;
+
+            int numBytes = (width + 1) * (height + 1);
+            redBytes = new byte[numBytes];
+            greenBytes = new byte[numBytes];
+            blueBytes = new byte[numBytes];
+
+            int byteNdx = 0;
+            Color c;
+
+            try
+            {
+                for (int y = 0; y <= height; y++)
+                {
+                    for (int x = 0; x < width; x++)
+                    {
+                        if (smallMap)
+                            c = bm.GetPixel(x,  y < height ? y : y - 1);
+                        else
+                            c = bm.GetPixel(x * 2, y < height ? y * 2 : y * 2 - 1);
+
+                        redBytes[byteNdx] = c.R;
+                        greenBytes[byteNdx] = c.G;
+                        blueBytes[byteNdx] = c.B;
+
+                        ++byteNdx;
+                    }
+
+                    if (smallMap)
+                        c = bm.GetPixel(width - 1, y < height ? y : y - 1);
+                    else
+                        c = bm.GetPixel(width * 2 - 1, y < height ? y * 2 : y * 2 - 1);
+
+                    redBytes[byteNdx] = c.R;
+                    greenBytes[byteNdx] = c.G;
+                    blueBytes[byteNdx] = c.B;
+
+                    ++byteNdx;
+                }
+            }
+            catch (Exception e)
+            {
+                throw new Exception("Caught exception processing byte arrays in SculptMap(): e: " + e.ToString());
+            }
+
+            width++;
+            height++;
+        }
+
+        public List<List<Coord>> ToRows(bool mirror)
+        {
+            int numRows = height;
+            int numCols = width;
+
+            List<List<Coord>> rows = new List<List<Coord>>(numRows);
+
+            float pixScale = 1.0f / 255;
+
+            int rowNdx, colNdx;
+            int smNdx = 0;
+
+            for (rowNdx = 0; rowNdx < numRows; rowNdx++)
+            {
+                List<Coord> row = new List<Coord>(numCols);
+                for (colNdx = 0; colNdx < numCols; colNdx++)
+                {
+
+                    if (mirror)
+                        row.Add(new Coord(-((float)redBytes[smNdx] * pixScale - 0.5f), ((float)greenBytes[smNdx] * pixScale - 0.5f), (float)blueBytes[smNdx] * pixScale - 0.5f));
+                    else
+                        row.Add(new Coord((float)redBytes[smNdx] * pixScale - 0.5f, (float)greenBytes[smNdx] * pixScale - 0.5f, (float)blueBytes[smNdx] * pixScale - 0.5f));
+
+                    ++smNdx;
+                }
+                rows.Add(row);
+            }
+            return rows;
+        }
+
+        private Bitmap ScaleImage(Bitmap srcImage, int destWidth, int destHeight)
+        {
+
+            Bitmap scaledImage = new Bitmap(destWidth, destHeight, PixelFormat.Format24bppRgb);
+
+            Color c;
+            
+
+            // will let last step to be eventually diferent, as seems to be in sl
+
+            float xscale = (float)srcImage.Width / (float)destWidth;
+            float yscale = (float)srcImage.Height / (float)destHeight;
+
+            int lastsx = srcImage.Width - 1;
+            int lastsy = srcImage.Height - 1;
+            int lastdx = destWidth - 1;
+            int lastdy = destHeight - 1;
+
+            float sy = 0.5f;
+            float sx;
+
+            for (int y = 0; y < lastdy; y++)
+            {
+                sx = 0.5f;
+                for (int x = 0; x < lastdx; x++)
+                {
+                    try
+                    {
+                        c = srcImage.GetPixel((int)(sx), (int)(sy));
+                        scaledImage.SetPixel(x, y, Color.FromArgb(c.R, c.G, c.B));
+                    }
+                    catch (IndexOutOfRangeException)
+                    {
+                    }
+                    sx += xscale;
+                }
+                try
+                {
+                    c = srcImage.GetPixel(lastsx, (int)(sy));
+                    scaledImage.SetPixel(lastdx, y, Color.FromArgb(c.R, c.G, c.B));
+                }
+                catch (IndexOutOfRangeException)
+                {
+                }
+
+                sy += yscale;
+            }
+
+            sx = 0.5f;
+            for (int x = 0; x < lastdx; x++)
+            {
+                try
+                {
+                    c = srcImage.GetPixel((int)(sx), lastsy);
+                    scaledImage.SetPixel(x, lastdy, Color.FromArgb(c.R, c.G, c.B));
+                }
+                catch (IndexOutOfRangeException)
+                {
+                }
+
+                sx += xscale;
+            }
+            try
+            {
+                c = srcImage.GetPixel(lastsx, lastsy);
+                scaledImage.SetPixel(lastdx, lastdy, Color.FromArgb(c.R, c.G, c.B));
+            }
+            catch (IndexOutOfRangeException)
+            {
+            }
+
+            srcImage.Dispose();
+            return scaledImage;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/PhysicsModules/UbitMeshing/SculptMesh.cs b/OpenSim/Region/PhysicsModules/UbitMeshing/SculptMesh.cs
new file mode 100644
index 0000000..bc1375b
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitMeshing/SculptMesh.cs
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) Contributors
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+
+using System.Drawing;
+using System.Drawing.Imaging;
+
+namespace PrimMesher
+{
+
+    public class SculptMesh
+    {
+        public List<Coord> coords;
+        public List<Face> faces;
+
+        public enum SculptType { sphere = 1, torus = 2, plane = 3, cylinder = 4 };
+
+
+        public SculptMesh(Bitmap sculptBitmap, SculptType sculptType, int lod, bool mirror, bool invert)
+        {
+            if (mirror)
+                invert = !invert;
+
+            SculptMap smap = new SculptMap(sculptBitmap, lod);
+
+            List<List<Coord>> rows = smap.ToRows(mirror);
+
+            _SculptMesh(rows, sculptType, invert);
+        }
+
+        private void _SculptMesh(List<List<Coord>> rows, SculptType sculptType, bool invert)
+        {
+            coords = new List<Coord>();
+            faces = new List<Face>();
+
+            sculptType = (SculptType)(((int)sculptType) & 0x07);
+
+            int width = rows[0].Count;
+
+            int p1, p2, p3, p4;
+
+            int imageX, imageY;
+
+            if (sculptType != SculptType.plane)
+            {
+                if (rows.Count % 2 == 0)
+                {
+                    for (int rowNdx = 0; rowNdx < rows.Count; rowNdx++)
+                        rows[rowNdx].Add(rows[rowNdx][0]);
+                }
+                else
+                {
+                    int lastIndex = rows[0].Count - 1;
+
+                    for (int i = 0; i < rows.Count; i++)
+                        rows[i][0] = rows[i][lastIndex];
+                }
+            }
+
+            Coord topPole = rows[0][width / 2];
+            Coord bottomPole = rows[rows.Count - 1][width / 2];
+
+            if (sculptType == SculptType.sphere)
+            {
+                if (rows.Count % 2 == 0)
+                {
+                    int count = rows[0].Count;
+                    List<Coord> topPoleRow = new List<Coord>(count);
+                    List<Coord> bottomPoleRow = new List<Coord>(count);
+
+                    for (int i = 0; i < count; i++)
+                    {
+                        topPoleRow.Add(topPole);
+                        bottomPoleRow.Add(bottomPole);
+                    }
+                    rows.Insert(0, topPoleRow);
+                    rows.Add(bottomPoleRow);
+                }
+                else
+                {
+                    int count = rows[0].Count;
+
+                    List<Coord> topPoleRow = rows[0];
+                    List<Coord> bottomPoleRow = rows[rows.Count - 1];
+
+                    for (int i = 0; i < count; i++)
+                    {
+                        topPoleRow[i] = topPole;
+                        bottomPoleRow[i] = bottomPole;
+                    }
+                }
+            }
+
+            if (sculptType == SculptType.torus)
+                rows.Add(rows[0]);
+
+            int coordsDown = rows.Count;
+            int coordsAcross = rows[0].Count;
+
+            float widthUnit = 1.0f / (coordsAcross - 1);
+            float heightUnit = 1.0f / (coordsDown - 1);
+
+            for (imageY = 0; imageY < coordsDown; imageY++)
+            {
+                int rowOffset = imageY * coordsAcross;
+
+                for (imageX = 0; imageX < coordsAcross; imageX++)
+                {
+                    /*
+                    *   p1-----p2
+                    *   | \ f2 |
+                    *   |   \  |
+                    *   | f1  \|
+                    *   p3-----p4
+                    */
+
+                    p4 = rowOffset + imageX;
+                    p3 = p4 - 1;
+
+                    p2 = p4 - coordsAcross;
+                    p1 = p3 - coordsAcross;
+
+                    this.coords.Add(rows[imageY][imageX]);
+
+                    if (imageY > 0 && imageX > 0)
+                    {
+                        Face f1, f2;
+
+                            if (invert)
+                            {
+                                f1 = new Face(p1, p4, p3);
+                                f2 = new Face(p1, p2, p4);
+                            }
+                            else
+                            {
+                                f1 = new Face(p1, p3, p4);
+                                f2 = new Face(p1, p4, p2);
+                            }
+
+                        this.faces.Add(f1);
+                        this.faces.Add(f2);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Duplicates a SculptMesh object. All object properties are copied by value, including lists.
+        /// </summary>
+        /// <returns></returns>
+        public SculptMesh Copy()
+        {
+            return new SculptMesh(this);
+        }
+
+        public SculptMesh(SculptMesh sm)
+        {
+            coords = new List<Coord>(sm.coords);
+            faces = new List<Face>(sm.faces);
+        }
+
+        public void Scale(float x, float y, float z)
+        {
+            int i;
+            int numVerts = this.coords.Count;
+
+            Coord m = new Coord(x, y, z);
+            for (i = 0; i < numVerts; i++)
+                this.coords[i] *= m;
+        }
+
+        public void DumpRaw(String path, String name, String title)
+        {
+            if (path == null)
+                return;
+            String fileName = name + "_" + title + ".raw";
+            String completePath = System.IO.Path.Combine(path, fileName);
+            StreamWriter sw = new StreamWriter(completePath);
+
+            for (int i = 0; i < this.faces.Count; i++)
+            {
+                string s = this.coords[this.faces[i].v1].ToString();
+                s += " " + this.coords[this.faces[i].v2].ToString();
+                s += " " + this.coords[this.faces[i].v3].ToString();
+
+                sw.WriteLine(s);
+            }
+
+            sw.Close();
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitOdePlugin/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/UbitOdePlugin/AssemblyInfo.cs
new file mode 100644
index 0000000..d46341b
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitOdePlugin/AssemblyInfo.cs
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// Information about this assembly is defined by the following
+// attributes.
+//
+// change them to the information which is associated with the assembly
+// you compile.
+
+[assembly : AssemblyTitle("OdePlugin")]
+[assembly : AssemblyDescription("Ubit Variation")]
+[assembly : AssemblyConfiguration("")]
+[assembly : AssemblyCompany("http://opensimulator.org")]
+[assembly : AssemblyProduct("OdePlugin")]
+[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2009")]
+[assembly : AssemblyTrademark("")]
+[assembly : AssemblyCulture("")]
+
+// This sets the default COM visibility of types in the assembly to invisible.
+// If you need to expose a type to COM, use [ComVisible(true)] on that type.
+
+[assembly : ComVisible(false)]
+
+// The assembly version has following format :
+//
+// Major.Minor.Build.Revision
+//
+// You can specify all values by your own or you can build default build and revision
+// numbers with the '*' character (the default):
+
+[assembly : AssemblyVersion("0.6.5.*")]
diff --git a/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODECharacter.cs b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODECharacter.cs
new file mode 100644
index 0000000..ba38136
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODECharacter.cs
@@ -0,0 +1,1847 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+// Revision by Ubit 2011/12
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenMetaverse;
+using OdeAPI;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using log4net;
+
+namespace OpenSim.Region.PhysicsModules.OdePlugin
+{
+    /// <summary>
+    /// Various properties that ODE uses for AMotors but isn't exposed in ODE.NET so we must define them ourselves.
+    /// </summary>
+
+    public enum dParam : int
+    {
+        LowStop = 0,
+        HiStop = 1,
+        Vel = 2,
+        FMax = 3,
+        FudgeFactor = 4,
+        Bounce = 5,
+        CFM = 6,
+        StopERP = 7,
+        StopCFM = 8,
+        LoStop2 = 256,
+        HiStop2 = 257,
+        Vel2 = 258,
+        FMax2 = 259,
+        StopERP2 = 7 + 256,
+        StopCFM2 = 8 + 256,
+        LoStop3 = 512,
+        HiStop3 = 513,
+        Vel3 = 514,
+        FMax3 = 515,
+        StopERP3 = 7 + 512,
+        StopCFM3 = 8 + 512
+    }
+ 
+    public class OdeCharacter : PhysicsActor
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        private Vector3 _position;
+        private Vector3 _zeroPosition;
+        private Vector3 _velocity;
+        private Vector3 _target_velocity;
+        private Vector3 _acceleration;
+        private Vector3 m_rotationalVelocity;
+        private Vector3 m_size;
+        private Vector3 m_collideNormal;
+        private Quaternion m_orientation;
+        private Quaternion m_orientation2D;
+        private float m_mass = 80f;
+        public float m_density = 60f;
+        private bool m_pidControllerActive = true;
+
+        const float basePID_D = 0.55f; // scaled for unit mass unit time (2200 /(50*80))
+        const float basePID_P = 0.225f; // scaled for unit mass unit time (900 /(50*80))
+        public float PID_D;
+        public float PID_P;
+
+        private float timeStep;
+        private float invtimeStep;
+
+        private float m_feetOffset = 0;
+        private float feetOff = 0;
+        private float boneOff = 0;
+        private float AvaAvaSizeXsq = 0.3f;
+        private float AvaAvaSizeYsq = 0.2f;
+
+        public float walkDivisor = 1.3f;
+        public float runDivisor = 0.8f;
+        private bool flying = false;
+        private bool m_iscolliding = false;
+        private bool m_iscollidingGround = false;
+        private bool m_iscollidingObj = false;
+        private bool m_alwaysRun = false;
+
+        private bool _zeroFlag = false;
+
+
+        private uint m_localID = 0;
+        public bool m_returnCollisions = false;
+        // taints and their non-tainted counterparts
+        public bool m_isPhysical = false; // the current physical status
+        public float MinimumGroundFlightOffset = 3f;
+
+        private float m_buoyancy = 0f;
+
+        private bool m_freemove = false;
+        // private CollisionLocker ode;
+
+//        private string m_name = String.Empty;
+        // other filter control
+        int m_colliderfilter = 0;
+        int m_colliderGroundfilter = 0;
+        int m_colliderObjectfilter = 0;
+
+        // Default we're a Character
+        private CollisionCategories m_collisionCategories = (CollisionCategories.Character);
+
+        // Default, Collide with Other Geometries, spaces, bodies and characters.
+        private CollisionCategories m_collisionFlags = (CollisionCategories.Character
+                                                        | CollisionCategories.Geom
+                                                        | CollisionCategories.VolumeDtc
+                                                        );
+        // we do land collisions not ode                | CollisionCategories.Land);
+        public IntPtr Body = IntPtr.Zero;
+        private OdeScene _parent_scene;
+        private IntPtr capsule = IntPtr.Zero;
+        public IntPtr collider = IntPtr.Zero;
+
+        public IntPtr Amotor = IntPtr.Zero;
+
+        public d.Mass ShellMass;
+
+        public int m_eventsubscription = 0;
+        private int m_cureventsubscription = 0;
+        private CollisionEventUpdate CollisionEventsThisFrame = null;
+        private bool SentEmptyCollisionsEvent;
+
+        // unique UUID of this character object
+        public UUID m_uuid;
+        public bool bad = false;
+
+        float mu;       
+
+        public OdeCharacter(uint localID, String avName, OdeScene parent_scene, Vector3 pos, Vector3 pSize, float pfeetOffset, float density, float walk_divisor, float rundivisor)
+        {
+            m_uuid = UUID.Random();
+            m_localID = localID;
+
+            timeStep = parent_scene.ODE_STEPSIZE;
+            invtimeStep = 1 / timeStep;
+
+            if (pos.IsFinite())
+            {
+                if (pos.Z > 99999f)
+                {
+                    pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
+                }
+                if (pos.Z < -100f) // shouldn't this be 0 ?
+                {
+                    pos.Z = parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
+                }
+                _position = pos;
+            }
+            else
+            {
+                _position = new Vector3(((float)_parent_scene.WorldExtents.X * 0.5f), ((float)_parent_scene.WorldExtents.Y * 0.5f), parent_scene.GetTerrainHeightAtXY(128f, 128f) + 10f);
+                m_log.Warn("[PHYSICS]: Got NaN Position on Character Create");
+            }
+
+            _parent_scene = parent_scene;
+
+
+            m_size.X = pSize.X;
+            m_size.Y = pSize.Y;
+            m_size.Z = pSize.Z;
+
+            if(m_size.X <0.01f)
+                m_size.X = 0.01f;
+            if(m_size.Y <0.01f)
+                m_size.Y = 0.01f;
+            if(m_size.Z <0.01f)
+                m_size.Z = 0.01f;
+
+            m_feetOffset = pfeetOffset;
+            m_orientation = Quaternion.Identity;
+            m_orientation2D = Quaternion.Identity;
+            m_density = density;
+
+            // force lower density for testing
+            m_density = 3.0f;
+
+            mu = parent_scene.AvatarFriction;
+
+            walkDivisor = walk_divisor;
+            runDivisor = rundivisor;
+
+            m_mass = m_density * m_size.X * m_size.Y * m_size.Z; ; // sure we have a default           
+
+            PID_D = basePID_D * m_mass * invtimeStep;
+            PID_P = basePID_P * m_mass * invtimeStep;
+
+            m_isPhysical = false; // current status: no ODE information exists
+
+            Name = avName;
+
+            AddChange(changes.Add, null);
+        }
+
+        public override int PhysicsActorType
+        {
+            get { return (int)ActorTypes.Agent; }
+            set { return; }
+        }
+
+        public override void getContactData(ref ContactData cdata)
+        {
+            cdata.mu = mu;
+            cdata.bounce = 0;
+            cdata.softcolide = false;
+        }
+
+        public override bool Building { get; set; }
+
+        /// <summary>
+        /// If this is set, the avatar will move faster
+        /// </summary>
+        public override bool SetAlwaysRun
+        {
+            get { return m_alwaysRun; }
+            set { m_alwaysRun = value; }
+        }
+
+        public override uint LocalID
+        {
+            get { return m_localID; }     
+            set { m_localID = value; }
+        }
+
+        public override PhysicsActor ParentActor
+        {
+            get { return (PhysicsActor)this; }
+        }
+
+        public override bool Grabbed
+        {
+            set { return; }
+        }
+
+        public override bool Selected
+        {
+            set { return; }
+        }
+
+        public override float Buoyancy
+        {
+            get { return m_buoyancy; }
+            set { m_buoyancy = value; }
+        }
+
+        public override bool FloatOnWater
+        {
+            set { return; }
+        }
+
+        public override bool IsPhysical
+        {
+            get { return m_isPhysical; }
+            set { return; }
+        }
+
+        public override bool ThrottleUpdates
+        {
+            get { return false; }
+            set { return; }
+        }
+
+        public override bool Flying
+        {
+            get { return flying; }
+            set
+            {
+                flying = value;
+//                m_log.DebugFormat("[PHYSICS]: Set OdeCharacter Flying to {0}", flying);
+            }
+        }
+
+        /// <summary>
+        /// Returns if the avatar is colliding in general.
+        /// This includes the ground and objects and avatar.
+        /// </summary>
+        public override bool IsColliding
+        {
+            get { return (m_iscolliding || m_iscollidingGround); }
+            set
+            {
+                if (value)
+                {
+                    m_colliderfilter += 3;
+                    if (m_colliderfilter > 3)
+                        m_colliderfilter = 3;
+                }
+                else
+                {
+                    m_colliderfilter--;
+                    if (m_colliderfilter < 0)
+                        m_colliderfilter = 0;
+                }
+
+                if (m_colliderfilter == 0)
+                    m_iscolliding = false;
+                else
+                {
+                    m_pidControllerActive = true;
+                    m_iscolliding = true;
+                    m_freemove = false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns if an avatar is colliding with the ground
+        /// </summary>
+        public override bool CollidingGround
+        {
+            get { return m_iscollidingGround; }
+            set
+            {
+/*  we now control this
+                if (value)
+                    {
+                    m_colliderGroundfilter += 2;
+                    if (m_colliderGroundfilter > 2)
+                        m_colliderGroundfilter = 2;
+                    }
+                else
+                    {
+                    m_colliderGroundfilter--;
+                    if (m_colliderGroundfilter < 0)
+                        m_colliderGroundfilter = 0;
+                    }
+
+                if (m_colliderGroundfilter == 0)
+                    m_iscollidingGround = false;
+                else
+                    m_iscollidingGround = true;
+ */
+            }
+
+        }
+
+        /// <summary>
+        /// Returns if the avatar is colliding with an object
+        /// </summary>
+        public override bool CollidingObj
+        {
+            get { return m_iscollidingObj; }
+            set
+            {
+                // Ubit filter this also
+                if (value)
+                {
+                    m_colliderObjectfilter += 2;
+                    if (m_colliderObjectfilter > 2)
+                        m_colliderObjectfilter = 2;
+                }
+                else
+                {
+                    m_colliderObjectfilter--;
+                    if (m_colliderObjectfilter < 0)
+                        m_colliderObjectfilter = 0;
+                }
+
+                if (m_colliderObjectfilter == 0)
+                    m_iscollidingObj = false;
+                else
+                    m_iscollidingObj = true;
+
+//            m_iscollidingObj = value;
+
+                if (m_iscollidingObj)
+                    m_pidControllerActive = false;
+                else
+                    m_pidControllerActive = true;
+            }
+        }
+
+        /// <summary>
+        /// turn the PID controller on or off.
+        /// The PID Controller will turn on all by itself in many situations
+        /// </summary>
+        /// <param name="status"></param>
+        public void SetPidStatus(bool status)
+        {
+            m_pidControllerActive = status;
+        }
+
+        public override bool Stopped
+        {
+            get { return _zeroFlag; }
+        }
+
+        /// <summary>
+        /// This 'puts' an avatar somewhere in the physics space.
+        /// Not really a good choice unless you 'know' it's a good
+        /// spot otherwise you're likely to orbit the avatar.
+        /// </summary>
+        public override Vector3 Position
+        {
+            get { return _position; }
+            set
+            {
+                if (value.IsFinite())
+                {
+                    if (value.Z > 9999999f)
+                    {
+                        value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
+                    }
+                    if (value.Z < -100f)
+                    {
+                        value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
+                    }
+                    AddChange(changes.Position, value);
+                }
+                else
+                {
+                    m_log.Warn("[PHYSICS]: Got a NaN Position from Scene on a Character");
+                }
+            }
+        }
+
+        public override Vector3 RotationalVelocity
+        {
+            get { return m_rotationalVelocity; }
+            set { m_rotationalVelocity = value; }
+        }
+
+        /// <summary>
+        /// This property sets the height of the avatar only.  We use the height to make sure the avatar stands up straight
+        /// and use it to offset landings properly
+        /// </summary>
+        public override Vector3 Size
+        {
+            get
+            {
+                return m_size;
+            }
+            set
+            {
+                if (value.IsFinite())
+                {
+                    if(value.X <0.01f)
+                        value.X = 0.01f;
+                    if(value.Y <0.01f)
+                        value.Y = 0.01f;
+                    if(value.Z <0.01f)
+                        value.Z = 0.01f;
+
+                    AddChange(changes.Size, value);
+                }
+                else
+                {
+                    m_log.Warn("[PHYSICS]: Got a NaN Size from Scene on a Character");
+                }
+            }
+        }
+
+        public override void setAvatarSize(Vector3 size, float feetOffset)
+        {
+            if (size.IsFinite())
+            {
+                if (size.X < 0.01f)
+                    size.X = 0.01f;
+                if (size.Y < 0.01f)
+                    size.Y = 0.01f;
+                if (size.Z < 0.01f)
+                    size.Z = 0.01f;
+
+                strAvatarSize st = new strAvatarSize();
+                st.size = size;
+                st.offset = feetOffset;
+                AddChange(changes.AvatarSize, st);
+            }
+            else
+            {
+                m_log.Warn("[PHYSICS]: Got a NaN AvatarSize from Scene on a Character");
+            }
+            
+        }
+        /// <summary>
+        /// This creates the Avatar's physical Surrogate at the position supplied
+        /// </summary>
+        /// <param name="npositionX"></param>
+        /// <param name="npositionY"></param>
+        /// <param name="npositionZ"></param>
+
+        //
+        /// <summary>
+        /// Uses the capped cyllinder volume formula to calculate the avatar's mass.
+        /// This may be used in calculations in the scene/scenepresence
+        /// </summary>
+        public override float Mass
+        {
+            get
+            {
+                return m_mass;
+            }
+        }
+        public override void link(PhysicsActor obj)
+        {
+
+        }
+
+        public override void delink()
+        {
+
+        }
+
+        public override void LockAngularMotion(Vector3 axis)
+        {
+
+        }
+
+
+        public override Vector3 Force
+        {
+            get { return _target_velocity; }
+            set { return; }
+        }
+
+        public override int VehicleType
+        {
+            get { return 0; }
+            set { return; }
+        }
+
+        public override void VehicleFloatParam(int param, float value)
+        {
+
+        }
+
+        public override void VehicleVectorParam(int param, Vector3 value)
+        {
+
+        }
+
+        public override void VehicleRotationParam(int param, Quaternion rotation)
+        {
+
+        }
+
+        public override void VehicleFlags(int param, bool remove)
+        {
+
+        }
+
+        public override void SetVolumeDetect(int param)
+        {
+
+        }
+
+        public override Vector3 CenterOfMass
+        {
+            get
+            {
+                Vector3 pos = _position;
+                return pos;
+            }
+        }
+
+        public override Vector3 GeometricCenter
+        {
+            get
+            {
+                Vector3 pos = _position;
+                return pos;
+            }
+        }
+
+        public override PrimitiveBaseShape Shape
+        {
+            set { return; }
+        }
+
+        public override Vector3 Velocity
+        {
+            get
+            {
+                return _velocity;
+            }
+            set
+            {
+                if (value.IsFinite())
+                {
+                    AddChange(changes.Velocity, value);
+                }
+                else
+                {
+                    m_log.Warn("[PHYSICS]: Got a NaN velocity from Scene in a Character");
+                }
+            }
+        }
+
+        public override Vector3 Torque
+        {
+            get { return Vector3.Zero; }
+            set { return; }
+        }
+
+        public override float CollisionScore
+        {
+            get { return 0f; }
+            set { }
+        }
+
+        public override bool Kinematic
+        {
+            get { return false; }
+            set { }
+        }
+
+        public override Quaternion Orientation
+        {
+            get { return m_orientation; }
+            set
+            {
+//                fakeori = value;
+//                givefakeori++;
+                value.Normalize();
+                AddChange(changes.Orientation, value);
+            }
+        }
+
+        public override Vector3 Acceleration
+        {
+            get { return _acceleration; }
+            set { }
+        }
+
+        public void SetAcceleration(Vector3 accel)
+        {
+            m_pidControllerActive = true;
+            _acceleration = accel;
+        }
+
+        /// <summary>
+        /// Adds the force supplied to the Target Velocity
+        /// The PID controller takes this target velocity and tries to make it a reality
+        /// </summary>
+        /// <param name="force"></param>
+        public override void AddForce(Vector3 force, bool pushforce)
+        {
+            if (force.IsFinite())
+            {
+                if (pushforce)
+                {
+                    AddChange(changes.Force, force * m_density / (_parent_scene.ODE_STEPSIZE * 28f));
+                }
+                else
+                {
+                    AddChange(changes.Velocity, force);
+                }
+            }
+            else
+            {
+                m_log.Warn("[PHYSICS]: Got a NaN force applied to a Character");
+            }
+            //m_lastUpdateSent = false;
+        }
+
+        public override void AddAngularForce(Vector3 force, bool pushforce)
+        {
+
+        }
+
+        public override void SetMomentum(Vector3 momentum)
+        {
+            if (momentum.IsFinite())
+                AddChange(changes.Momentum, momentum);
+        }
+
+
+        private void AvatarGeomAndBodyCreation(float npositionX, float npositionY, float npositionZ)
+        {
+            // sizes  one day should came from visual parameters
+            float sx = m_size.X;
+            float sy = m_size.Y;
+            float sz = m_size.Z;
+
+            float bot = -sz * 0.5f + m_feetOffset;
+            boneOff = bot + 0.3f;
+
+            float feetsz = sz * 0.45f;
+            if (feetsz > 0.6f)
+                feetsz = 0.6f;
+
+            feetOff = bot + feetsz;
+
+            AvaAvaSizeXsq = 0.4f * sx;
+            AvaAvaSizeXsq *= AvaAvaSizeXsq;
+            AvaAvaSizeYsq = 0.5f * sy;
+            AvaAvaSizeYsq *= AvaAvaSizeYsq;
+
+            _parent_scene.waitForSpaceUnlock(_parent_scene.CharsSpace);
+
+            collider = d.HashSpaceCreate(_parent_scene.CharsSpace);
+            d.HashSpaceSetLevels(collider, -4, 3);
+            d.SpaceSetSublevel(collider, 3);
+            d.SpaceSetCleanup(collider, false);
+            d.GeomSetCategoryBits(collider, (uint)m_collisionCategories);
+            d.GeomSetCollideBits(collider, (uint)m_collisionFlags);
+
+            float r = m_size.X;
+            if (m_size.Y > r)
+                r = m_size.Y;
+            float l = m_size.Z - r;
+            r *= 0.5f;
+
+            capsule = d.CreateCapsule(collider, r, l);
+
+            m_mass = m_density * m_size.X * m_size.Y * m_size.Z;  // update mass
+
+            d.MassSetBoxTotal(out ShellMass, m_mass, m_size.X, m_size.Y, m_size.Z);
+
+            PID_D = basePID_D * m_mass / _parent_scene.ODE_STEPSIZE;
+            PID_P = basePID_P * m_mass / _parent_scene.ODE_STEPSIZE;
+            
+            Body = d.BodyCreate(_parent_scene.world);
+
+            _zeroFlag = false;
+            m_pidControllerActive = true;
+            m_freemove = false;
+
+            _velocity = Vector3.Zero;
+
+            d.BodySetAutoDisableFlag(Body, false);
+            d.BodySetPosition(Body, npositionX, npositionY, npositionZ);
+
+            _position.X = npositionX;
+            _position.Y = npositionY;
+            _position.Z = npositionZ;
+
+            d.BodySetMass(Body, ref ShellMass);
+            d.GeomSetBody(capsule, Body);
+
+            // The purpose of the AMotor here is to keep the avatar's physical
+            // surrogate from rotating while moving
+            Amotor = d.JointCreateAMotor(_parent_scene.world, IntPtr.Zero);
+            d.JointAttach(Amotor, Body, IntPtr.Zero);
+
+            d.JointSetAMotorMode(Amotor, 0);
+            d.JointSetAMotorNumAxes(Amotor, 3);
+            d.JointSetAMotorAxis(Amotor, 0, 0, 1, 0, 0);
+            d.JointSetAMotorAxis(Amotor, 1, 0, 0, 1, 0);
+            d.JointSetAMotorAxis(Amotor, 2, 0, 0, 0, 1);
+
+            d.JointSetAMotorAngle(Amotor, 0, 0);
+            d.JointSetAMotorAngle(Amotor, 1, 0);
+            d.JointSetAMotorAngle(Amotor, 2, 0);
+
+            d.JointSetAMotorParam(Amotor, (int)dParam.StopCFM, 0f); // make it HARD
+            d.JointSetAMotorParam(Amotor, (int)dParam.StopCFM2, 0f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.StopCFM3, 0f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.StopERP, 0.8f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.StopERP2, 0.8f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.StopERP3, 0.8f);
+
+            // These lowstops and high stops are effectively (no wiggle room)
+            d.JointSetAMotorParam(Amotor, (int)dParam.LowStop, -1e-5f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.HiStop, 1e-5f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.LoStop2, -1e-5f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.HiStop2, 1e-5f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.LoStop3, -1e-5f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.HiStop3, 1e-5f);
+
+            d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel, 0);
+            d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel2, 0);
+            d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel3, 0);
+
+            d.JointSetAMotorParam(Amotor, (int)dParam.FMax, 5e8f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.FMax2, 5e8f);
+            d.JointSetAMotorParam(Amotor, (int)dParam.FMax3, 5e8f);
+        }
+
+        /// <summary>
+        /// Destroys the avatar body and geom
+
+        private void AvatarGeomAndBodyDestroy()
+        {
+            // Kill the Amotor
+            if (Amotor != IntPtr.Zero)
+            {
+                d.JointDestroy(Amotor);
+                Amotor = IntPtr.Zero;
+            }
+
+            if (Body != IntPtr.Zero)
+            {
+                //kill the body
+                d.BodyDestroy(Body);
+                Body = IntPtr.Zero;
+            }
+
+            //kill the Geoms
+            if (capsule != IntPtr.Zero)
+            {
+                _parent_scene.actor_name_map.Remove(capsule);
+                _parent_scene.waitForSpaceUnlock(collider);
+                d.GeomDestroy(capsule);
+                capsule = IntPtr.Zero;
+            }
+
+            if (collider != IntPtr.Zero)
+            {
+                d.SpaceDestroy(collider);
+                collider = IntPtr.Zero;
+            }
+
+        }
+
+        //in place 2D rotation around Z assuming rot is normalised and is a rotation around Z
+        public void RotateXYonZ(ref float x, ref float y, ref Quaternion rot)
+        {
+            float sin = 2.0f * rot.Z * rot.W;
+            float cos = rot.W * rot.W - rot.Z * rot.Z;
+            float tx = x;
+
+            x = tx * cos - y * sin;
+            y = tx * sin + y * cos;
+        }
+        public void RotateXYonZ(ref float x, ref float y, ref float sin, ref float cos)
+        {
+            float tx = x;
+            x = tx * cos - y * sin;
+            y = tx * sin + y * cos;
+        }
+        public void invRotateXYonZ(ref float x, ref float y, ref float sin, ref float cos)
+        {
+            float tx = x;
+            x = tx * cos + y * sin;
+            y = -tx * sin + y * cos;
+        }
+
+        public void invRotateXYonZ(ref float x, ref float y, ref Quaternion rot)
+        {
+            float sin = - 2.0f * rot.Z * rot.W;
+            float cos = rot.W * rot.W - rot.Z * rot.Z;
+            float tx = x;
+
+            x = tx * cos - y * sin;
+            y = tx * sin + y * cos;
+        }
+      
+        public bool Collide(IntPtr me, IntPtr other, bool reverse, ref d.ContactGeom contact,
+                ref d.ContactGeom altContact , ref bool useAltcontact, ref bool feetcollision)
+        {
+            feetcollision = false;
+            useAltcontact = false;
+
+            if (me == capsule)
+            {
+                Vector3 offset;
+
+                float h = contact.pos.Z - _position.Z;
+                offset.Z = h - feetOff;
+
+                offset.X = contact.pos.X - _position.X;
+                offset.Y = contact.pos.Y - _position.Y;
+
+                d.GeomClassID gtype = d.GeomGetClass(other);
+                if (gtype == d.GeomClassID.CapsuleClass)
+                {
+                    Vector3 roff = offset * Quaternion.Inverse(m_orientation2D);
+                    float r = roff.X *roff.X / AvaAvaSizeXsq;
+                    r += (roff.Y * roff.Y) / AvaAvaSizeYsq;
+                    if (r > 1.0f)
+                        return false;
+
+                    float dp = 1.0f -(float)Math.Sqrt((double)r);
+                    if (dp > 0.05f)
+                        dp = 0.05f;
+
+                    contact.depth = dp;
+
+                    if (offset.Z < 0)
+                    {
+                        feetcollision = true;
+                        if (h < boneOff)
+                        {
+                            m_collideNormal.X = contact.normal.X;
+                            m_collideNormal.Y = contact.normal.Y;
+                            m_collideNormal.Z = contact.normal.Z;
+                            IsColliding = true;
+                        }
+                    }
+                    return true;
+                }               
+/*
+                d.AABB aabb;
+                d.GeomGetAABB(other,out aabb);
+                float othertop = aabb.MaxZ - _position.Z;
+*/
+//                if (offset.Z > 0 || othertop > -feetOff || contact.normal.Z > 0.35f)
+                if (offset.Z > 0 || contact.normal.Z > 0.35f)
+                {
+                    if (offset.Z <= 0)
+                    {
+                        feetcollision = true;
+                        if (h < boneOff)
+                        {
+                            m_collideNormal.X = contact.normal.X;
+                            m_collideNormal.Y = contact.normal.Y;
+                            m_collideNormal.Z = contact.normal.Z;
+                            IsColliding = true;
+                        }
+                    }
+                    return true;
+                }
+
+                altContact = contact;
+                useAltcontact = true;
+
+                offset.Z -= 0.2f;
+
+                offset.Normalize();
+
+                if (contact.depth > 0.1f)
+                    contact.depth = 0.1f;
+
+                if (reverse)
+                {
+                    altContact.normal.X = offset.X;
+                    altContact.normal.Y = offset.Y;
+                    altContact.normal.Z = offset.Z;
+                }
+                else
+                {
+                    altContact.normal.X = -offset.X;
+                    altContact.normal.Y = -offset.Y;
+                    altContact.normal.Z = -offset.Z;
+                }
+
+                feetcollision = true;
+                if (h < boneOff)
+                {
+                    m_collideNormal.X = contact.normal.X;
+                    m_collideNormal.Y = contact.normal.Y;
+                    m_collideNormal.Z = contact.normal.Z;
+                    IsColliding = true;
+                }
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Called from Simulate
+        /// This is the avatar's movement control + PID Controller
+        /// </summary>
+        /// <param name="timeStep"></param>
+        public void Move(List<OdeCharacter> defects)
+        {
+            if (Body == IntPtr.Zero)
+                return;
+
+            d.Vector3 dtmp = d.BodyGetPosition(Body);
+            Vector3 localpos = new Vector3(dtmp.X, dtmp.Y, dtmp.Z);
+
+            // the Amotor still lets avatar rotation to drift during colisions
+            // so force it back to identity
+
+            d.Quaternion qtmp;
+            qtmp.W = m_orientation2D.W;
+            qtmp.X = m_orientation2D.X;
+            qtmp.Y = m_orientation2D.Y;
+            qtmp.Z = m_orientation2D.Z;
+            d.BodySetQuaternion(Body, ref qtmp);
+
+            if (m_pidControllerActive == false)
+            {
+                _zeroPosition = localpos;
+            }
+
+            if (!localpos.IsFinite())
+            {
+                m_log.Warn("[PHYSICS]: Avatar Position is non-finite!");
+                defects.Add(this);
+                // _parent_scene.RemoveCharacter(this);
+
+                // destroy avatar capsule and related ODE data
+                AvatarGeomAndBodyDestroy();
+                return;
+            }
+
+            // check outbounds forcing to be in world
+            bool fixbody = false;
+            if (localpos.X < 0.0f)
+            {
+                fixbody = true;
+                localpos.X = 0.1f;
+            }
+            else if (localpos.X > _parent_scene.WorldExtents.X - 0.1f)
+            {
+                fixbody = true;
+                localpos.X = _parent_scene.WorldExtents.X - 0.1f;
+            }
+            if (localpos.Y < 0.0f)
+            {
+                fixbody = true;
+                localpos.Y = 0.1f;
+            }
+            else if (localpos.Y > _parent_scene.WorldExtents.Y - 0.1)
+            {
+                fixbody = true;
+                localpos.Y = _parent_scene.WorldExtents.Y - 0.1f;
+            }
+            if (fixbody)
+            {
+                m_freemove = false;
+                d.BodySetPosition(Body, localpos.X, localpos.Y, localpos.Z);
+            }
+
+            float breakfactor;
+
+            Vector3 vec = Vector3.Zero;
+            dtmp = d.BodyGetLinearVel(Body);
+            Vector3 vel = new Vector3(dtmp.X, dtmp.Y, dtmp.Z);
+            float velLengthSquared = vel.LengthSquared();
+
+
+            Vector3 ctz = _target_velocity;
+
+            float movementdivisor = 1f;
+            //Ubit change divisions into multiplications below
+            if (!m_alwaysRun)
+                movementdivisor = 1 / walkDivisor;
+            else
+                movementdivisor = 1 / runDivisor;
+
+            ctz.X *= movementdivisor;
+            ctz.Y *= movementdivisor;
+
+            //******************************************
+            // colide with land
+
+            d.AABB aabb;
+//            d.GeomGetAABB(feetbox, out aabb);
+            d.GeomGetAABB(capsule, out aabb);
+            float chrminZ = aabb.MinZ; // move up a bit
+            Vector3 posch = localpos;
+
+            float ftmp;
+
+            if (flying)
+            {
+                ftmp = timeStep;
+                posch.X += vel.X * ftmp;
+                posch.Y += vel.Y * ftmp;
+            }
+
+            float terrainheight = _parent_scene.GetTerrainHeightAtXY(posch.X, posch.Y);
+            if (chrminZ < terrainheight)
+            {
+                if (ctz.Z < 0)
+                    ctz.Z = 0;
+
+                Vector3 n = _parent_scene.GetTerrainNormalAtXY(posch.X, posch.Y);
+                float depth = terrainheight - chrminZ;
+
+                vec.Z = depth * PID_P * 50;
+
+                if (!flying)
+                    vec.Z += -vel.Z * PID_D;
+
+                if (depth < 0.2f)
+                {
+                    m_colliderGroundfilter++;
+                    if (m_colliderGroundfilter > 2)
+                    {
+                        m_iscolliding = true;
+                        m_colliderfilter = 2;
+
+                        if (m_colliderGroundfilter > 10)
+                        {
+                            m_colliderGroundfilter = 10;
+                            m_freemove = false;
+                        }
+
+                        m_collideNormal.X = n.X;
+                        m_collideNormal.Y = n.Y;
+                        m_collideNormal.Z = n.Z;
+
+                        m_iscollidingGround = true;
+
+
+                        ContactPoint contact = new ContactPoint();
+                        contact.PenetrationDepth = depth;
+                        contact.Position.X = localpos.X;
+                        contact.Position.Y = localpos.Y;
+                        contact.Position.Z = terrainheight;
+                        contact.SurfaceNormal.X = -n.X;
+                        contact.SurfaceNormal.Y = -n.Y;
+                        contact.SurfaceNormal.Z = -n.Z;
+                        contact.RelativeSpeed = -vel.Z;
+                        contact.CharacterFeet = true;
+                        AddCollisionEvent(0, contact);
+
+//                        vec.Z *= 0.5f;
+                    }
+                }
+
+                else
+                {
+                    m_colliderGroundfilter -= 5;
+                    if (m_colliderGroundfilter <= 0)
+                    {
+                        m_colliderGroundfilter = 0;
+                        m_iscollidingGround = false;
+                    }
+                }
+            }
+            else
+            {
+                m_colliderGroundfilter -= 5;
+                if (m_colliderGroundfilter <= 0)
+                {
+                    m_colliderGroundfilter = 0;
+                    m_iscollidingGround = false;
+                }
+            }
+
+            
+            //******************************************
+            if (!m_iscolliding)
+                m_collideNormal.Z = 0;
+
+            bool tviszero = (ctz.X == 0.0f && ctz.Y == 0.0f && ctz.Z == 0.0f);
+
+
+
+            if (!tviszero)
+            {
+                m_freemove = false;
+
+                // movement relative to surface if moving on it
+                // dont disturbe vertical movement, ie jumps
+                if (m_iscolliding && !flying && ctz.Z == 0 && m_collideNormal.Z > 0.2f && m_collideNormal.Z < 0.94f)
+                {
+                    float p = ctz.X * m_collideNormal.X + ctz.Y * m_collideNormal.Y;
+                    ctz.X *= (float)Math.Sqrt(1 - m_collideNormal.X * m_collideNormal.X);
+                    ctz.Y *= (float)Math.Sqrt(1 - m_collideNormal.Y * m_collideNormal.Y);
+                    ctz.Z -= p;
+                    if (ctz.Z < 0)
+                        ctz.Z *= 2;
+
+                }
+
+            }
+
+
+            if (!m_freemove)
+            {
+
+                //  if velocity is zero, use position control; otherwise, velocity control
+                if (tviszero && m_iscolliding && !flying)
+                {
+                    //  keep track of where we stopped.  No more slippin' & slidin'
+                    if (!_zeroFlag)
+                    {
+                        _zeroFlag = true;
+                        _zeroPosition = localpos;
+                    }
+                    if (m_pidControllerActive)
+                    {
+                        // We only want to deactivate the PID Controller if we think we want to have our surrogate
+                        // react to the physics scene by moving it's position.
+                        // Avatar to Avatar collisions
+                        // Prim to avatar collisions
+
+                        vec.X = -vel.X * PID_D * 2f + (_zeroPosition.X - localpos.X) * (PID_P * 5);
+                        vec.Y = -vel.Y * PID_D * 2f + (_zeroPosition.Y - localpos.Y) * (PID_P * 5);
+                        if(vel.Z > 0)
+                            vec.Z += -vel.Z * PID_D + (_zeroPosition.Z - localpos.Z) * PID_P;
+                        else
+                            vec.Z += (-vel.Z * PID_D + (_zeroPosition.Z - localpos.Z) * PID_P) * 0.2f;
+/*
+                        if (flying)
+                        {
+                            vec.Z += -vel.Z * PID_D + (_zeroPosition.Z - localpos.Z) * PID_P;
+                        }
+*/
+                    }
+                    //PidStatus = true;
+                }
+                else
+                {
+                    m_pidControllerActive = true;
+                    _zeroFlag = false;
+
+                    if (m_iscolliding)
+                    {
+                        if (!flying)
+                        {
+                            // we are on a surface
+                            if (ctz.Z > 0f)
+                            {
+                                // moving up or JUMPING
+                                vec.Z += (ctz.Z - vel.Z) * PID_D * 2f;
+                                vec.X += (ctz.X - vel.X) * (PID_D);
+                                vec.Y += (ctz.Y - vel.Y) * (PID_D);
+                            }
+                            else
+                            {
+                                // we are moving down on a surface
+                                if (ctz.Z == 0)
+                                {
+                                    if (vel.Z > 0)
+                                        vec.Z -= vel.Z * PID_D * 2f;
+                                    vec.X += (ctz.X - vel.X) * (PID_D);
+                                    vec.Y += (ctz.Y - vel.Y) * (PID_D);
+                                }
+                                // intencionally going down
+                                else
+                                {
+                                    if (ctz.Z < vel.Z)
+                                        vec.Z += (ctz.Z - vel.Z) * PID_D;
+                                    else
+                                    {
+                                    }
+
+                                    if (Math.Abs(ctz.X) > Math.Abs(vel.X))
+                                        vec.X += (ctz.X - vel.X) * (PID_D);
+                                    if (Math.Abs(ctz.Y) > Math.Abs(vel.Y))
+                                        vec.Y += (ctz.Y - vel.Y) * (PID_D);
+                                }
+                            }
+
+                            // We're standing on something
+                        }
+                        else
+                        {
+                            // We're flying and colliding with something
+                            vec.X += (ctz.X - vel.X) * (PID_D * 0.0625f);
+                            vec.Y += (ctz.Y - vel.Y) * (PID_D * 0.0625f);
+                            vec.Z += (ctz.Z - vel.Z) * (PID_D * 0.0625f);
+                        }
+                    }
+                    else // ie not colliding
+                    {
+                        if (flying) //(!m_iscolliding && flying)
+                        {
+                            // we're in mid air suspended
+                            vec.X += (ctz.X - vel.X) * (PID_D);
+                            vec.Y += (ctz.Y - vel.Y) * (PID_D);
+                            vec.Z += (ctz.Z - vel.Z) * (PID_D);
+                        }
+
+                        else
+                        {
+                            // we're not colliding and we're not flying so that means we're falling!
+                            // m_iscolliding includes collisions with the ground.
+
+                            // d.Vector3 pos = d.BodyGetPosition(Body);
+                            vec.X += (ctz.X - vel.X) * PID_D * 0.833f;
+                            vec.Y += (ctz.Y - vel.Y) * PID_D * 0.833f;
+                            // hack for  breaking on fall
+                            if (ctz.Z == -9999f)
+                                vec.Z += -vel.Z * PID_D - _parent_scene.gravityz * m_mass;
+                        }
+                    }
+                }
+
+                if (velLengthSquared > 2500.0f) // 50m/s apply breaks
+                {
+                    breakfactor = 0.16f * m_mass;
+                    vec.X -= breakfactor * vel.X;
+                    vec.Y -= breakfactor * vel.Y;
+                    vec.Z -= breakfactor * vel.Z;
+                }
+            }
+            else
+            {
+                breakfactor = m_mass;
+                vec.X -= breakfactor * vel.X;
+                vec.Y -= breakfactor * vel.Y;
+                if (flying)
+                    vec.Z -= 0.5f * breakfactor * vel.Z;
+                else
+                    vec.Z -= .16f* m_mass * vel.Z;
+            }
+
+            if (flying)
+            {
+                vec.Z -= _parent_scene.gravityz * m_mass;
+
+                //Added for auto fly height. Kitto Flora
+                float target_altitude = _parent_scene.GetTerrainHeightAtXY(localpos.X, localpos.Y) + MinimumGroundFlightOffset;
+
+                if (localpos.Z < target_altitude)
+                {
+                    vec.Z += (target_altitude - localpos.Z) * PID_P * 5.0f;
+                }
+                // end add Kitto Flora
+            }
+
+            if (vec.IsFinite())
+            {
+                if (vec.X != 0 || vec.Y !=0 || vec.Z !=0)
+                    d.BodyAddForce(Body, vec.X, vec.Y, vec.Z);
+            }
+            else
+            {
+                m_log.Warn("[PHYSICS]: Got a NaN force vector in Move()");
+                m_log.Warn("[PHYSICS]: Avatar Position is non-finite!");
+                defects.Add(this);
+                // _parent_scene.RemoveCharacter(this);
+                // destroy avatar capsule and related ODE data
+                AvatarGeomAndBodyDestroy();
+                return;
+            }
+
+            // update our local ideia of position velocity and aceleration
+            //            _position = localpos;
+            _position = localpos;
+
+            if (_zeroFlag)
+            {
+                _velocity = Vector3.Zero;
+                _acceleration = Vector3.Zero;
+                m_rotationalVelocity = Vector3.Zero;
+            }
+            else
+            {
+                Vector3 a =_velocity; // previus velocity
+                SetSmooth(ref _velocity, ref vel, 2);
+                a = (_velocity - a) * invtimeStep;
+                SetSmooth(ref _acceleration, ref a, 2);
+
+                dtmp = d.BodyGetAngularVel(Body);
+                m_rotationalVelocity.X = 0f;
+                m_rotationalVelocity.Y = 0f;
+                m_rotationalVelocity.Z = dtmp.Z;
+                Math.Round(m_rotationalVelocity.Z,3);
+            }
+        }
+
+        public void round(ref Vector3 v, int digits)
+        {
+            v.X = (float)Math.Round(v.X, digits);
+            v.Y = (float)Math.Round(v.Y, digits);
+            v.Z = (float)Math.Round(v.Z, digits);
+         }
+
+        public void SetSmooth(ref Vector3 dst, ref Vector3 value)
+        {
+            dst.X = 0.1f * dst.X + 0.9f * value.X;
+            dst.Y = 0.1f * dst.Y + 0.9f * value.Y;
+            dst.Z = 0.1f * dst.Z + 0.9f * value.Z;
+        }
+
+        public void SetSmooth(ref Vector3 dst, ref Vector3 value, int rounddigits)
+        {
+            dst.X = 0.4f * dst.X + 0.6f * value.X;
+            dst.X = (float)Math.Round(dst.X, rounddigits);
+
+            dst.Y = 0.4f * dst.Y + 0.6f * value.Y;
+            dst.Y = (float)Math.Round(dst.Y, rounddigits);
+
+            dst.Z = 0.4f * dst.Z + 0.6f * value.Z;
+            dst.Z = (float)Math.Round(dst.Z, rounddigits);
+        }
+
+
+        /// <summary>
+        /// Updates the reported position and velocity.
+        /// Used to copy variables from unmanaged space at heartbeat rate and also trigger scene updates acording
+        /// also outbounds checking
+        /// copy and outbounds now done in move(..) at ode rate
+        /// 
+        /// </summary>
+        public void UpdatePositionAndVelocity()
+        {
+            return;
+
+//            if (Body == IntPtr.Zero)
+//                return;
+
+        }
+
+        /// <summary>
+        /// Cleanup the things we use in the scene.
+        /// </summary>
+        public void Destroy()
+        {
+            AddChange(changes.Remove, null);
+        }
+
+        public override void CrossingFailure()
+        {
+        }
+
+        public override Vector3 PIDTarget { set { return; } }
+        public override bool PIDActive {get {return m_pidControllerActive;} set { return; } }
+        public override float PIDTau { set { return; } }
+
+        public override float PIDHoverHeight { set { return; } }
+        public override bool PIDHoverActive { set { return; } }
+        public override PIDHoverType PIDHoverType { set { return; } }
+        public override float PIDHoverTau { set { return; } }
+
+        public override Quaternion APIDTarget { set { return; } }
+
+        public override bool APIDActive { set { return; } }
+
+        public override float APIDStrength { set { return; } }
+
+        public override float APIDDamping { set { return; } }
+
+
+        public override void SubscribeEvents(int ms)
+        {
+            m_eventsubscription = ms;
+            m_cureventsubscription = 0;
+            if (CollisionEventsThisFrame == null)
+                CollisionEventsThisFrame = new CollisionEventUpdate();
+            SentEmptyCollisionsEvent = false;
+        }
+
+        public override void UnSubscribeEvents()
+        {
+            if (CollisionEventsThisFrame != null)
+            {
+                lock (CollisionEventsThisFrame)
+                {
+                    CollisionEventsThisFrame.Clear();
+                    CollisionEventsThisFrame = null;
+                }
+            }
+            m_eventsubscription = 0;
+        }
+
+        public override void AddCollisionEvent(uint CollidedWith, ContactPoint contact)
+        {
+            if (CollisionEventsThisFrame == null)
+                CollisionEventsThisFrame = new CollisionEventUpdate();
+            lock (CollisionEventsThisFrame)
+            {
+                CollisionEventsThisFrame.AddCollider(CollidedWith, contact);
+                _parent_scene.AddCollisionEventReporting(this);
+            }
+        }
+
+        public void SendCollisions()
+        {
+            if (CollisionEventsThisFrame == null)
+                return;
+
+            lock (CollisionEventsThisFrame)
+            {
+                if (m_cureventsubscription < m_eventsubscription)
+                    return;
+
+                m_cureventsubscription = 0;
+
+                int ncolisions = CollisionEventsThisFrame.m_objCollisionList.Count;
+
+                if (!SentEmptyCollisionsEvent || ncolisions > 0)
+                {
+                    base.SendCollisionUpdate(CollisionEventsThisFrame);
+
+                    if (ncolisions == 0)
+                    {
+                        SentEmptyCollisionsEvent = true;
+                        _parent_scene.RemoveCollisionEventReporting(this);
+                    }
+                    else
+                    {
+                        SentEmptyCollisionsEvent = false;
+                        CollisionEventsThisFrame.Clear();
+                    }
+                }
+            }           
+        }
+
+        internal void AddCollisionFrameTime(int t)
+        {
+            // protect it from overflow crashing
+            if (m_cureventsubscription < 50000)
+                m_cureventsubscription += t;
+        }
+
+        public override bool SubscribedEvents()
+        {
+            if (m_eventsubscription > 0)
+                return true;
+            return false;
+        }
+
+        private void changePhysicsStatus(bool NewStatus)
+        {
+            if (NewStatus != m_isPhysical)
+            {
+                if (NewStatus)
+                {
+                    AvatarGeomAndBodyDestroy();
+
+                    AvatarGeomAndBodyCreation(_position.X, _position.Y, _position.Z);
+
+                    _parent_scene.actor_name_map[collider] = (PhysicsActor)this;
+                    _parent_scene.actor_name_map[capsule] = (PhysicsActor)this;
+                    _parent_scene.AddCharacter(this);
+                }
+                else
+                {
+                    _parent_scene.RemoveCollisionEventReporting(this);
+                    _parent_scene.RemoveCharacter(this);
+                    // destroy avatar capsule and related ODE data
+                    AvatarGeomAndBodyDestroy();
+                }
+                m_freemove = false;
+                m_isPhysical = NewStatus;
+            }
+        }
+
+        private void changeAdd()
+        {
+            changePhysicsStatus(true);
+        }
+
+        private void changeRemove()
+        {
+            changePhysicsStatus(false);
+        }
+
+        private void changeShape(PrimitiveBaseShape arg)
+        {
+        }
+
+        private void changeAvatarSize(strAvatarSize st)
+        {
+            m_feetOffset = st.offset;
+            changeSize(st.size);
+        }
+
+        private void changeSize(Vector3 pSize)
+        {
+            if (pSize.IsFinite())
+            {
+                // for now only look to Z changes since viewers also don't change X and Y
+                if (pSize.Z != m_size.Z)
+                {
+                    AvatarGeomAndBodyDestroy();
+
+
+                    float oldsz = m_size.Z;
+                    m_size = pSize;
+
+
+                    AvatarGeomAndBodyCreation(_position.X, _position.Y,
+                                      _position.Z + (m_size.Z - oldsz) * 0.5f);
+
+                    Velocity = Vector3.Zero;
+                    
+
+                    _parent_scene.actor_name_map[collider] = (PhysicsActor)this;
+                    _parent_scene.actor_name_map[capsule] = (PhysicsActor)this;
+                }
+                m_freemove = false;
+                m_pidControllerActive = true;
+            }
+            else
+            {
+                m_log.Warn("[PHYSICS]: Got a NaN Size from Scene on a Character");
+            }
+        }
+
+        private void changePosition( Vector3 newPos)
+            {
+                if (Body != IntPtr.Zero)
+                    d.BodySetPosition(Body, newPos.X, newPos.Y, newPos.Z);
+                _position = newPos;
+                m_freemove = false;
+                m_pidControllerActive = true;               
+            }
+
+        private void changeOrientation(Quaternion newOri)
+        {
+            if (m_orientation != newOri)
+            {
+                m_orientation = newOri; // keep a copy for core use
+                // but only use rotations around Z
+
+                m_orientation2D.W = newOri.W;
+                m_orientation2D.Z = newOri.Z;
+
+                float t = m_orientation2D.W * m_orientation2D.W + m_orientation2D.Z * m_orientation2D.Z;
+                if (t > 0)
+                {
+                    t = 1.0f / (float)Math.Sqrt(t);
+                    m_orientation2D.W *= t;
+                    m_orientation2D.Z *= t;
+                }
+                else
+                {
+                    m_orientation2D.W = 1.0f;
+                    m_orientation2D.Z = 0f;
+                }
+                m_orientation2D.Y = 0f;
+                m_orientation2D.X = 0f;
+
+                d.Quaternion myrot = new d.Quaternion();
+                myrot.X = m_orientation2D.X;
+                myrot.Y = m_orientation2D.Y;
+                myrot.Z = m_orientation2D.Z;
+                myrot.W = m_orientation2D.W;
+                d.BodySetQuaternion(Body, ref myrot);
+            }
+        }
+
+        private void changeVelocity(Vector3 newVel)
+        {
+            m_pidControllerActive = true;
+            m_freemove = false;
+            _target_velocity = newVel;
+        }
+
+        private void changeSetTorque(Vector3 newTorque)
+        {
+        }                                 
+
+        private void changeAddForce(Vector3 newForce)
+        {
+        }                                 
+
+        private void changeAddAngularForce(Vector3 arg)
+        {
+        }                                 
+
+        private void changeAngularLock(Vector3 arg)
+        {
+        }                                 
+
+        private void changeFloatOnWater(bool arg)
+        {
+        }                                 
+
+        private void changeVolumedetetion(bool arg)
+        {
+        }                                 
+
+        private void changeSelectedStatus(bool arg)
+        {
+        }                                 
+
+        private void changeDisable(bool arg)
+        {
+        }                                 
+
+        private void changeBuilding(bool arg)
+        {
+        }
+
+        private void setFreeMove()
+        {
+            m_pidControllerActive = true;
+            _zeroFlag = false;
+            _target_velocity = Vector3.Zero;
+            m_freemove = true;
+            m_colliderfilter = -1;
+            m_colliderObjectfilter = -1;
+            m_colliderGroundfilter = -1;
+
+            m_iscolliding = false;
+            m_iscollidingGround = false;
+            m_iscollidingObj = false;
+
+            CollisionEventsThisFrame.Clear();
+        }
+
+        private void changeForce(Vector3 newForce)
+        {
+            setFreeMove();
+
+            if (Body != IntPtr.Zero)
+            {
+                if (newForce.X != 0f || newForce.Y != 0f || newForce.Z != 0)
+                    d.BodyAddForce(Body, newForce.X, newForce.Y, newForce.Z);
+            }
+        }
+
+        // for now momentum is actually velocity
+        private void changeMomentum(Vector3 newmomentum)
+        {
+            _velocity = newmomentum;
+            setFreeMove();
+
+            if (Body != IntPtr.Zero)
+                d.BodySetLinearVel(Body, newmomentum.X, newmomentum.Y, newmomentum.Z);
+        }
+
+        private void donullchange()
+        {
+        }
+
+        public bool DoAChange(changes what, object arg)
+        {
+            if (collider == IntPtr.Zero && what != changes.Add && what != changes.Remove)
+            {
+                return false;
+            }
+
+            // nasty switch
+            switch (what)
+            {
+                case changes.Add:
+                    changeAdd();
+                    break;
+                case changes.Remove:
+                    changeRemove();
+                    break;
+
+                case changes.Position:
+                    changePosition((Vector3)arg);
+                    break;
+
+                case changes.Orientation:
+                    changeOrientation((Quaternion)arg);
+                    break;
+
+                case changes.PosOffset:
+                    donullchange();
+                    break;
+
+                case changes.OriOffset:
+                    donullchange();
+                    break;
+
+                case changes.Velocity:
+                    changeVelocity((Vector3)arg);
+                    break;
+
+                //                case changes.Acceleration:
+                //                    changeacceleration((Vector3)arg);
+                //                    break;
+                //                case changes.AngVelocity:
+                //                    changeangvelocity((Vector3)arg);
+                //                    break;
+
+                case changes.Force:
+                    changeForce((Vector3)arg);
+                    break;
+
+                case changes.Torque:
+                    changeSetTorque((Vector3)arg);
+                    break;
+
+                case changes.AddForce:
+                    changeAddForce((Vector3)arg);
+                    break;
+
+                case changes.AddAngForce:
+                    changeAddAngularForce((Vector3)arg);
+                    break;
+
+                case changes.AngLock:
+                    changeAngularLock((Vector3)arg);
+                    break;
+
+                case changes.Size:
+                    changeSize((Vector3)arg);
+                    break;
+
+                case changes.AvatarSize:
+                    changeAvatarSize((strAvatarSize)arg);
+                    break;
+
+                case changes.Momentum:
+                    changeMomentum((Vector3)arg);
+                    break;
+/* not in use for now
+                case changes.Shape:
+                    changeShape((PrimitiveBaseShape)arg);
+                    break;
+
+                case changes.CollidesWater:
+                    changeFloatOnWater((bool)arg);
+                    break;
+
+                case changes.VolumeDtc:
+                    changeVolumedetetion((bool)arg);
+                    break;
+
+                case changes.Physical:
+                    changePhysicsStatus((bool)arg);
+                    break;
+
+                case changes.Selected:
+                    changeSelectedStatus((bool)arg);
+                    break;
+
+                case changes.disabled:
+                    changeDisable((bool)arg);
+                    break;
+
+                case changes.building:
+                    changeBuilding((bool)arg);
+                    break;
+*/
+                case changes.Null:
+                    donullchange();
+                    break;
+
+                default:
+                    donullchange();
+                    break;
+            }
+            return false;
+        }
+
+        public void AddChange(changes what, object arg)
+        {
+            _parent_scene.AddChange((PhysicsActor)this, what, arg);
+        }
+
+        private struct strAvatarSize
+        {
+            public Vector3 size;
+            public float offset;
+        }
+
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODEDynamics.cs b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODEDynamics.cs
new file mode 100644
index 0000000..36bb1e9
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODEDynamics.cs
@@ -0,0 +1,1096 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* Revised Aug, Sept 2009 by Kitto Flora. ODEDynamics.cs replaces
+ * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:
+ * ODEPrim.cs contains methods dealing with Prim editing, Prim
+ * characteristics and Kinetic motion.
+ * ODEDynamics.cs contains methods dealing with Prim Physical motion
+ * (dynamics) and the associated settings. Old Linear and angular
+ * motors for dynamic motion have been replace with  MoveLinear()
+ * and MoveAngular(); 'Physical' is used only to switch ODE dynamic
+ * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to
+ * switch between 'VEHICLE' parameter use and general dynamics
+ * settings use.
+ */
+
+// Extensive change Ubit 2012
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using log4net;
+using OpenMetaverse;
+using OdeAPI;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+
+namespace OpenSim.Region.PhysicsModules.OdePlugin
+{
+    public class ODEDynamics
+    {
+        public Vehicle Type
+        {
+            get { return m_type; }
+        }
+
+        private OdePrim rootPrim;
+        private OdeScene _pParentScene;
+
+        // Vehicle properties
+        // WARNING this are working copies for internel use
+        // their values may not be the corresponding parameter
+
+        private Quaternion m_referenceFrame = Quaternion.Identity;      // Axis modifier
+        private Quaternion m_RollreferenceFrame = Quaternion.Identity;  // what hell is this ?
+
+        private Vehicle m_type = Vehicle.TYPE_NONE;                     // If a 'VEHICLE', and what kind
+
+        private VehicleFlag m_flags = (VehicleFlag) 0;                  // Boolean settings:
+                                                                        // HOVER_TERRAIN_ONLY
+                                                                        // HOVER_GLOBAL_HEIGHT
+                                                                        // NO_DEFLECTION_UP
+                                                                        // HOVER_WATER_ONLY
+                                                                        // HOVER_UP_ONLY
+                                                                        // LIMIT_MOTOR_UP
+                                                                        // LIMIT_ROLL_ONLY
+        private Vector3 m_BlockingEndPoint = Vector3.Zero;              // not sl
+
+        // Linear properties
+        private Vector3 m_linearMotorDirection = Vector3.Zero;          // velocity requested by LSL, decayed by time
+        private Vector3 m_linearFrictionTimescale = new Vector3(1000, 1000, 1000);
+        private float m_linearMotorDecayTimescale = 120;
+        private float m_linearMotorTimescale = 1000;
+        private Vector3 m_linearMotorOffset = Vector3.Zero;
+
+        //Angular properties
+        private Vector3 m_angularMotorDirection = Vector3.Zero;         // angular velocity requested by LSL motor
+        private float m_angularMotorTimescale = 1000;                      // motor angular velocity ramp up rate
+        private float m_angularMotorDecayTimescale = 120;                 // motor angular velocity decay rate
+        private Vector3 m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);      // body angular velocity  decay rate
+
+        //Deflection properties
+        private float m_angularDeflectionEfficiency = 0;
+        private float m_angularDeflectionTimescale = 1000;
+        private float m_linearDeflectionEfficiency = 0;
+        private float m_linearDeflectionTimescale = 1000;
+
+        //Banking properties
+        private float m_bankingEfficiency = 0;
+        private float m_bankingMix = 0;
+        private float m_bankingTimescale = 1000;
+
+        //Hover and Buoyancy properties
+        private float m_VhoverHeight = 0f;
+        private float m_VhoverEfficiency = 0f;
+        private float m_VhoverTimescale = 1000f;
+        private float m_VehicleBuoyancy = 0f;           //KF: m_VehicleBuoyancy is set by VEHICLE_BUOYANCY for a vehicle.
+                    // Modifies gravity. Slider between -1 (double-gravity) and 1 (full anti-gravity)
+                    // KF: So far I have found no good method to combine a script-requested .Z velocity and gravity.
+                    // Therefore only m_VehicleBuoyancy=1 (0g) will use the script-requested .Z velocity.
+
+        //Attractor properties
+        private float m_verticalAttractionEfficiency = 1.0f;        // damped
+        private float m_verticalAttractionTimescale = 1000f;        // Timescale > 300  means no vert attractor.
+
+
+        // auxiliar
+        private float m_lmEfect = 0f;                                            // current linear motor eficiency
+        private float m_lmDecay = 0f;                                            // current linear decay
+
+        private float m_amEfect = 0;                                            // current angular motor eficiency
+        private float m_amDecay = 0f;                                            // current linear decay
+
+        private float m_ffactor = 1.0f;
+
+        private float m_timestep = 0.02f;
+        private float m_invtimestep = 50;
+
+
+        float m_ampwr;
+        float m_amdampX;
+        float m_amdampY;
+        float m_amdampZ;
+
+        float m_gravmod;
+
+        public float FrictionFactor
+        {
+            get
+            {
+                return m_ffactor;
+            }
+        }
+
+        public float GravMod
+        {
+            set
+            {
+                m_gravmod = value;
+            }
+        }
+
+
+        public ODEDynamics(OdePrim rootp)
+        {
+            rootPrim = rootp;
+            _pParentScene = rootPrim._parent_scene;
+            m_timestep = _pParentScene.ODE_STEPSIZE;
+            m_invtimestep = 1.0f / m_timestep;
+            m_gravmod = rootPrim.GravModifier;
+        }
+
+        public void DoSetVehicle(VehicleData vd)
+        {
+            m_type = vd.m_type;
+            m_flags = vd.m_flags;
+
+            
+            // Linear properties
+            m_linearMotorDirection = vd.m_linearMotorDirection;
+
+            m_linearFrictionTimescale = vd.m_linearFrictionTimescale;
+            if (m_linearFrictionTimescale.X < m_timestep) m_linearFrictionTimescale.X = m_timestep;
+            if (m_linearFrictionTimescale.Y < m_timestep) m_linearFrictionTimescale.Y = m_timestep;
+            if (m_linearFrictionTimescale.Z < m_timestep) m_linearFrictionTimescale.Z = m_timestep;
+
+            m_linearMotorDecayTimescale = vd.m_linearMotorDecayTimescale;
+            if (m_linearMotorDecayTimescale < m_timestep) m_linearMotorDecayTimescale = m_timestep;
+            m_linearMotorDecayTimescale += 0.2f;
+            m_linearMotorDecayTimescale *= m_invtimestep;
+
+            m_linearMotorTimescale = vd.m_linearMotorTimescale;
+            if (m_linearMotorTimescale < m_timestep) m_linearMotorTimescale = m_timestep;
+
+            m_linearMotorOffset = vd.m_linearMotorOffset;
+
+            //Angular properties
+            m_angularMotorDirection = vd.m_angularMotorDirection;
+            m_angularMotorTimescale = vd.m_angularMotorTimescale;
+            if (m_angularMotorTimescale < m_timestep) m_angularMotorTimescale = m_timestep;
+
+            m_angularMotorDecayTimescale = vd.m_angularMotorDecayTimescale;
+            if (m_angularMotorDecayTimescale < m_timestep) m_angularMotorDecayTimescale = m_timestep;
+            m_angularMotorDecayTimescale *= m_invtimestep;
+
+            m_angularFrictionTimescale = vd.m_angularFrictionTimescale;
+            if (m_angularFrictionTimescale.X < m_timestep) m_angularFrictionTimescale.X = m_timestep;
+            if (m_angularFrictionTimescale.Y < m_timestep) m_angularFrictionTimescale.Y = m_timestep;
+            if (m_angularFrictionTimescale.Z < m_timestep) m_angularFrictionTimescale.Z = m_timestep;
+
+            //Deflection properties
+            m_angularDeflectionEfficiency = vd.m_angularDeflectionEfficiency;
+            m_angularDeflectionTimescale = vd.m_angularDeflectionTimescale;
+            if (m_angularDeflectionTimescale < m_timestep) m_angularDeflectionTimescale = m_timestep;
+
+            m_linearDeflectionEfficiency = vd.m_linearDeflectionEfficiency;
+            m_linearDeflectionTimescale = vd.m_linearDeflectionTimescale;
+            if (m_linearDeflectionTimescale < m_timestep) m_linearDeflectionTimescale = m_timestep;
+
+            //Banking properties
+            m_bankingEfficiency = vd.m_bankingEfficiency;
+            m_bankingMix = vd.m_bankingMix;
+            m_bankingTimescale = vd.m_bankingTimescale;
+            if (m_bankingTimescale < m_timestep) m_bankingTimescale = m_timestep;
+
+            //Hover and Buoyancy properties
+            m_VhoverHeight = vd.m_VhoverHeight;
+            m_VhoverEfficiency = vd.m_VhoverEfficiency;
+            m_VhoverTimescale = vd.m_VhoverTimescale;
+            if (m_VhoverTimescale < m_timestep) m_VhoverTimescale = m_timestep;
+
+            m_VehicleBuoyancy = vd.m_VehicleBuoyancy;
+
+            //Attractor properties
+            m_verticalAttractionEfficiency = vd.m_verticalAttractionEfficiency;
+            m_verticalAttractionTimescale = vd.m_verticalAttractionTimescale;
+            if (m_verticalAttractionTimescale < m_timestep) m_verticalAttractionTimescale = m_timestep;
+
+            // Axis
+            m_referenceFrame = vd.m_referenceFrame;
+
+            m_lmEfect = 0;
+            m_lmDecay = (1.0f - 1.0f / m_linearMotorDecayTimescale);
+            m_amEfect = 0;
+            m_ffactor = 1.0f;
+        }
+
+        internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
+        {
+            float len;
+
+            switch (pParam)
+            {
+                case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
+                    if (pValue < 0f) pValue = 0f;
+                    if (pValue > 1f) pValue = 1f;
+                    m_angularDeflectionEfficiency = pValue;
+                    break;
+                case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    m_angularDeflectionTimescale = pValue;
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    else if (pValue > 120) pValue = 120;
+                    m_angularMotorDecayTimescale = pValue * m_invtimestep;
+                    m_amDecay = 1.0f - 1.0f / m_angularMotorDecayTimescale;
+                    break;
+                case Vehicle.ANGULAR_MOTOR_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    m_angularMotorTimescale = pValue;
+                    break;
+                case Vehicle.BANKING_EFFICIENCY:
+                    if (pValue < -1f) pValue = -1f;
+                    if (pValue > 1f) pValue = 1f;
+                    m_bankingEfficiency = pValue;
+                    break;
+                case Vehicle.BANKING_MIX:
+                    if (pValue < 0f) pValue = 0f;
+                    if (pValue > 1f) pValue = 1f;
+                    m_bankingMix = pValue;
+                    break;
+                case Vehicle.BANKING_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    m_bankingTimescale = pValue;
+                    break;
+                case Vehicle.BUOYANCY:
+                    if (pValue < -1f) pValue = -1f;
+                    if (pValue > 1f) pValue = 1f;
+                    m_VehicleBuoyancy = pValue;
+                    break;
+                case Vehicle.HOVER_EFFICIENCY:
+                    if (pValue < 0f) pValue = 0f;
+                    if (pValue > 1f) pValue = 1f;
+                    m_VhoverEfficiency = pValue;
+                    break;
+                case Vehicle.HOVER_HEIGHT:
+                    m_VhoverHeight = pValue;
+                    break;
+                case Vehicle.HOVER_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    m_VhoverTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
+                    if (pValue < 0f) pValue = 0f;
+                    if (pValue > 1f) pValue = 1f;
+                    m_linearDeflectionEfficiency = pValue;
+                    break;
+                case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    m_linearDeflectionTimescale = pValue;
+                    break;
+                case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    else if (pValue > 120) pValue = 120;
+                    m_linearMotorDecayTimescale = (0.2f +pValue) * m_invtimestep;
+                    m_lmDecay = (1.0f - 1.0f / m_linearMotorDecayTimescale);
+                    break;
+                case Vehicle.LINEAR_MOTOR_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    m_linearMotorTimescale = pValue;
+                    break;
+                case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
+                    if (pValue < 0f) pValue = 0f;
+                    if (pValue > 1f) pValue = 1f;
+                    m_verticalAttractionEfficiency = pValue;
+                    break;
+                case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    m_verticalAttractionTimescale = pValue;
+                    break;
+
+                // These are vector properties but the engine lets you use a single float value to
+                // set all of the components to the same value
+                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DIRECTION:
+                    m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
+                    len = m_angularMotorDirection.Length();
+                    if (len > 12.566f)
+                        m_angularMotorDirection *= (12.566f / len);
+
+                    m_amEfect = 1.0f ; // turn it on
+                    m_amDecay = 1.0f - 1.0f / m_angularMotorDecayTimescale;
+
+                    if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
+                            && !rootPrim.m_isSelected && !rootPrim.m_disabled)
+                        d.BodyEnable(rootPrim.Body);
+                    break;
+                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    if (pValue < m_timestep) pValue = m_timestep;
+                    m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    m_linearMotorDirection = new Vector3(pValue, pValue, pValue);
+                    len = m_linearMotorDirection.Length();
+                    if (len > 100.0f)
+                        m_linearMotorDirection *= (100.0f / len);
+
+                    m_lmDecay = 1.0f - 1.0f / m_linearMotorDecayTimescale;
+                    m_lmEfect = 1.0f; // turn it on
+
+                    m_ffactor = 0.0f;
+                    if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
+                            && !rootPrim.m_isSelected && !rootPrim.m_disabled)
+                        d.BodyEnable(rootPrim.Body);
+                    break;
+                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
+                    len = m_linearMotorOffset.Length();
+                    if (len > 100.0f)
+                        m_linearMotorOffset *= (100.0f / len);
+                    break;
+            }
+        }//end ProcessFloatVehicleParam
+
+        internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
+        {
+            float len;
+
+            switch (pParam)
+            {
+                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    if (pValue.X < m_timestep) pValue.X = m_timestep;
+                    if (pValue.Y < m_timestep) pValue.Y = m_timestep;
+                    if (pValue.Z < m_timestep) pValue.Z = m_timestep;
+
+                    m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.ANGULAR_MOTOR_DIRECTION:
+                    m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    // Limit requested angular speed to 2 rps= 4 pi rads/sec
+                    len = m_angularMotorDirection.Length();
+                    if (len > 12.566f)
+                        m_angularMotorDirection *= (12.566f / len);
+
+                    m_amEfect = 1.0f; // turn it on
+                    m_amDecay = 1.0f - 1.0f / m_angularMotorDecayTimescale;
+
+                    if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
+                            && !rootPrim.m_isSelected && !rootPrim.m_disabled)
+                        d.BodyEnable(rootPrim.Body);
+                    break;
+                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    if (pValue.X < m_timestep) pValue.X = m_timestep;
+                    if (pValue.Y < m_timestep) pValue.Y = m_timestep;
+                    if (pValue.Z < m_timestep) pValue.Z = m_timestep;
+                    m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    len = m_linearMotorDirection.Length();
+                    if (len > 100.0f)
+                        m_linearMotorDirection *= (100.0f / len);
+
+                    m_lmEfect = 1.0f; // turn it on
+                    m_lmDecay = 1.0f - 1.0f / m_linearMotorDecayTimescale;
+
+                    m_ffactor = 0.0f;
+                    if (rootPrim.Body != IntPtr.Zero && !d.BodyIsEnabled(rootPrim.Body)
+                            && !rootPrim.m_isSelected && !rootPrim.m_disabled)
+                        d.BodyEnable(rootPrim.Body);
+                    break;
+                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    len = m_linearMotorOffset.Length();
+                    if (len > 100.0f)
+                        m_linearMotorOffset *= (100.0f / len);
+                    break;
+                case Vehicle.BLOCK_EXIT:
+                    m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    break;
+            }
+        }//end ProcessVectorVehicleParam
+
+        internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
+        {
+            switch (pParam)
+            {
+                case Vehicle.REFERENCE_FRAME:
+                    //                    m_referenceFrame = Quaternion.Inverse(pValue);
+                    m_referenceFrame = pValue;
+                    break;
+                case Vehicle.ROLL_FRAME:
+                    m_RollreferenceFrame = pValue;
+                    break;
+            }
+        }//end ProcessRotationVehicleParam
+
+        internal void ProcessVehicleFlags(int pParam, bool remove)
+        {
+            if (remove)
+            {
+                m_flags &= ~((VehicleFlag)pParam);
+            }
+            else
+            {
+                m_flags |= (VehicleFlag)pParam;
+            }
+        }//end ProcessVehicleFlags
+
+        internal void ProcessTypeChange(Vehicle pType)
+        {
+            m_lmEfect = 0;
+
+            m_amEfect = 0;
+            m_ffactor = 1f;
+
+            m_linearMotorDirection = Vector3.Zero;
+            m_angularMotorDirection = Vector3.Zero;
+
+            m_BlockingEndPoint = Vector3.Zero;
+            m_RollreferenceFrame = Quaternion.Identity;
+            m_linearMotorOffset = Vector3.Zero;
+
+            m_referenceFrame = Quaternion.Identity;
+
+            // Set Defaults For Type
+            m_type = pType;
+            switch (pType)
+            {
+                case Vehicle.TYPE_NONE:
+                    m_linearFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    m_linearMotorTimescale = 1000;
+                    m_linearMotorDecayTimescale = 120 * m_invtimestep;
+                    m_angularMotorTimescale = 1000;
+                    m_angularMotorDecayTimescale = 1000  * m_invtimestep;
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 1;
+                    m_VhoverTimescale = 1000;
+                    m_VehicleBuoyancy = 0;
+                    m_linearDeflectionEfficiency = 0;
+                    m_linearDeflectionTimescale = 1000;
+                    m_angularDeflectionEfficiency = 0;
+                    m_angularDeflectionTimescale = 1000;
+                    m_bankingEfficiency = 0;
+                    m_bankingMix = 1;
+                    m_bankingTimescale = 1000;
+                    m_verticalAttractionEfficiency = 0;
+                    m_verticalAttractionTimescale = 1000;
+
+                    m_flags = (VehicleFlag)0;
+                    break;
+
+                case Vehicle.TYPE_SLED:
+                    m_linearFrictionTimescale = new Vector3(30, 1, 1000);
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    m_linearMotorTimescale = 1000;
+                    m_linearMotorDecayTimescale = 120 * m_invtimestep;
+                    m_angularMotorTimescale = 1000;
+                    m_angularMotorDecayTimescale = 120 * m_invtimestep;
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 1;
+                    m_VhoverTimescale = 10;
+                    m_VehicleBuoyancy = 0;
+                    m_linearDeflectionEfficiency = 1;
+                    m_linearDeflectionTimescale = 1;
+                    m_angularDeflectionEfficiency = 0;
+                    m_angularDeflectionTimescale = 10;
+                    m_verticalAttractionEfficiency = 1;
+                    m_verticalAttractionTimescale = 1000;
+                    m_bankingEfficiency = 0;
+                    m_bankingMix = 1;
+                    m_bankingTimescale = 10;
+                    m_flags &=
+                         ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
+                           VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP |
+                        VehicleFlag.LIMIT_ROLL_ONLY |
+                        VehicleFlag.LIMIT_MOTOR_UP);
+                    break;
+
+                case Vehicle.TYPE_CAR:
+                    m_linearFrictionTimescale = new Vector3(100, 2, 1000);
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
+                    m_linearMotorTimescale = 1;
+                    m_linearMotorDecayTimescale = 60 * m_invtimestep;
+                    m_angularMotorTimescale = 1;
+                    m_angularMotorDecayTimescale = 0.8f * m_invtimestep;
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 0;
+                    m_VhoverTimescale = 1000;
+                    m_VehicleBuoyancy = 0;
+                    m_linearDeflectionEfficiency = 1;
+                    m_linearDeflectionTimescale = 2;
+                    m_angularDeflectionEfficiency = 0;
+                    m_angularDeflectionTimescale = 10;
+                    m_verticalAttractionEfficiency = 1f;
+                    m_verticalAttractionTimescale = 10f;
+                    m_bankingEfficiency = -0.2f;
+                    m_bankingMix = 1;
+                    m_bankingTimescale = 1;
+                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
+                                VehicleFlag.HOVER_TERRAIN_ONLY |
+                                VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP |
+                                VehicleFlag.LIMIT_ROLL_ONLY |
+                                VehicleFlag.LIMIT_MOTOR_UP |
+                                VehicleFlag.HOVER_UP_ONLY);
+                    break;
+                case Vehicle.TYPE_BOAT:
+                    m_linearFrictionTimescale = new Vector3(10, 3, 2);
+                    m_angularFrictionTimescale = new Vector3(10, 10, 10);
+                    m_linearMotorTimescale = 5;
+                    m_linearMotorDecayTimescale = 60 * m_invtimestep;
+                    m_angularMotorTimescale = 4;
+                    m_angularMotorDecayTimescale = 4 * m_invtimestep;
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 0.5f;
+                    m_VhoverTimescale = 2;
+                    m_VehicleBuoyancy = 1;
+                    m_linearDeflectionEfficiency = 0.5f;
+                    m_linearDeflectionTimescale = 3;
+                    m_angularDeflectionEfficiency = 0.5f;
+                    m_angularDeflectionTimescale = 5;
+                    m_verticalAttractionEfficiency = 0.5f;
+                    m_verticalAttractionTimescale = 5f;
+                    m_bankingEfficiency = -0.3f;
+                    m_bankingMix = 0.8f;
+                    m_bankingTimescale = 1;
+                    m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY |
+                            VehicleFlag.HOVER_GLOBAL_HEIGHT |
+                            VehicleFlag.HOVER_UP_ONLY); // |
+//                            VehicleFlag.LIMIT_ROLL_ONLY);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP |
+                                VehicleFlag.LIMIT_MOTOR_UP |
+                                VehicleFlag.HOVER_UP_ONLY |  // new sl
+                                VehicleFlag.HOVER_WATER_ONLY);
+                    break;
+
+                case Vehicle.TYPE_AIRPLANE:
+                    m_linearFrictionTimescale = new Vector3(200, 10, 5);
+                    m_angularFrictionTimescale = new Vector3(20, 20, 20);
+                    m_linearMotorTimescale = 2;
+                    m_linearMotorDecayTimescale = 60 * m_invtimestep;
+                    m_angularMotorTimescale = 4;
+                    m_angularMotorDecayTimescale = 8 * m_invtimestep;
+                    m_VhoverHeight = 0;
+                    m_VhoverEfficiency = 0.5f;
+                    m_VhoverTimescale = 1000;
+                    m_VehicleBuoyancy = 0;
+                    m_linearDeflectionEfficiency = 0.5f;
+                    m_linearDeflectionTimescale = 0.5f;
+                    m_angularDeflectionEfficiency = 1;
+                    m_angularDeflectionTimescale = 2;
+                    m_verticalAttractionEfficiency = 0.9f;
+                    m_verticalAttractionTimescale = 2f;
+                    m_bankingEfficiency = 1;
+                    m_bankingMix = 0.7f;
+                    m_bankingTimescale = 2;
+                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
+                        VehicleFlag.HOVER_TERRAIN_ONLY |
+                        VehicleFlag.HOVER_GLOBAL_HEIGHT |
+                        VehicleFlag.HOVER_UP_ONLY |
+                        VehicleFlag.NO_DEFLECTION_UP |
+                        VehicleFlag.LIMIT_MOTOR_UP);
+                    m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
+                    break;
+
+                case Vehicle.TYPE_BALLOON:
+                    m_linearFrictionTimescale = new Vector3(5, 5, 5);
+                    m_angularFrictionTimescale = new Vector3(10, 10, 10);
+                    m_linearMotorTimescale = 5;
+                    m_linearMotorDecayTimescale = 60 * m_invtimestep;
+                    m_angularMotorTimescale = 6;
+                    m_angularMotorDecayTimescale = 10 * m_invtimestep;
+                    m_VhoverHeight = 5;
+                    m_VhoverEfficiency = 0.8f;
+                    m_VhoverTimescale = 10;
+                    m_VehicleBuoyancy = 1;
+                    m_linearDeflectionEfficiency = 0;
+                    m_linearDeflectionTimescale = 5 * m_invtimestep;
+                    m_angularDeflectionEfficiency = 0;
+                    m_angularDeflectionTimescale = 5;
+                    m_verticalAttractionEfficiency = 1f;
+                    m_verticalAttractionTimescale = 1000f;
+                    m_bankingEfficiency = 0;
+                    m_bankingMix = 0.7f;
+                    m_bankingTimescale = 5;
+                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY |
+                        VehicleFlag.HOVER_TERRAIN_ONLY |
+                        VehicleFlag.HOVER_UP_ONLY |
+                        VehicleFlag.NO_DEFLECTION_UP |
+                        VehicleFlag.LIMIT_MOTOR_UP  | //);
+                        VehicleFlag.LIMIT_ROLL_ONLY | // new sl
+                        VehicleFlag.HOVER_GLOBAL_HEIGHT); // new sl
+
+//                    m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY |
+//                        VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    break;
+
+            }
+
+            m_lmDecay = (1.0f - 1.0f / m_linearMotorDecayTimescale);
+            m_amDecay = 1.0f - 1.0f / m_angularMotorDecayTimescale;
+
+        }//end SetDefaultsForType
+
+        internal void Stop()
+        {
+            m_lmEfect = 0;
+            m_lmDecay = 0f;
+            m_amEfect = 0;
+            m_amDecay = 0;
+            m_ffactor = 1f;
+        }
+
+        public static Vector3 Xrot(Quaternion rot)
+        {
+            Vector3 vec;
+            rot.Normalize(); // just in case
+            vec.X = 2 * (rot.X * rot.X + rot.W * rot.W) - 1;
+            vec.Y = 2 * (rot.X * rot.Y + rot.Z * rot.W);
+            vec.Z = 2 * (rot.X * rot.Z - rot.Y * rot.W);
+            return vec;
+        }
+
+        public static Vector3 Zrot(Quaternion rot)
+        {
+            Vector3 vec;
+            rot.Normalize(); // just in case
+            vec.X = 2 * (rot.X * rot.Z + rot.Y * rot.W);
+            vec.Y = 2 * (rot.Y * rot.Z - rot.X * rot.W);
+            vec.Z = 2 * (rot.Z * rot.Z + rot.W * rot.W) - 1;
+
+            return vec;
+        }
+
+        private const float pi = (float)Math.PI;
+        private const float halfpi = 0.5f * (float)Math.PI;
+        private const float twopi = 2.0f * pi;
+
+        public static Vector3 ubitRot2Euler(Quaternion rot)
+        {
+            // returns roll in X
+            //         pitch in Y
+            //         yaw in Z
+            Vector3 vec;
+
+            // assuming rot is normalised
+            // rot.Normalize();
+
+            float zX = rot.X * rot.Z + rot.Y * rot.W;
+
+            if (zX < -0.49999f)
+            {
+                vec.X = 0;
+                vec.Y = -halfpi;
+                vec.Z = (float)(-2d * Math.Atan(rot.X / rot.W));
+            }
+            else if (zX > 0.49999f)
+            {
+                vec.X = 0;
+                vec.Y = halfpi;
+                vec.Z = (float)(2d * Math.Atan(rot.X / rot.W));
+            }
+            else
+            {
+                vec.Y = (float)Math.Asin(2 * zX);
+
+                float sqw = rot.W * rot.W;
+
+                float minuszY = rot.X * rot.W - rot.Y * rot.Z;
+                float zZ = rot.Z * rot.Z + sqw - 0.5f;
+
+                vec.X = (float)Math.Atan2(minuszY, zZ);
+
+                float yX = rot.Z * rot.W - rot.X * rot.Y; //( have negative ?)
+                float yY = rot.X * rot.X + sqw - 0.5f;
+                vec.Z = (float)Math.Atan2(yX, yY);
+            }
+            return vec;
+        }
+
+        public static void GetRollPitch(Quaternion rot, out float roll, out float pitch)
+        {
+            // assuming rot is normalised
+            // rot.Normalize();
+
+            float zX = rot.X * rot.Z + rot.Y * rot.W;
+
+            if (zX < -0.49999f)
+            {
+                roll = 0;
+                pitch = -halfpi;
+            }
+            else if (zX > 0.49999f)
+            {
+                roll = 0;
+                pitch = halfpi;
+            }
+            else
+            {
+                pitch = (float)Math.Asin(2 * zX);
+
+                float minuszY = rot.X * rot.W - rot.Y * rot.Z;
+                float zZ = rot.Z * rot.Z + rot.W * rot.W - 0.5f;
+
+                roll = (float)Math.Atan2(minuszY, zZ);
+            }
+            return ;
+        }        
+        
+        internal void Step()
+        {
+            IntPtr Body = rootPrim.Body;
+
+            d.Mass dmass;
+            d.BodyGetMass(Body, out dmass);
+
+            d.Quaternion rot = d.BodyGetQuaternion(Body);
+            Quaternion objrotq = new Quaternion(rot.X, rot.Y, rot.Z, rot.W);    // rotq = rotation of object
+            Quaternion rotq = objrotq;    // rotq = rotation of object
+            rotq *= m_referenceFrame; // rotq is now rotation in vehicle reference frame
+            Quaternion irotq = Quaternion.Inverse(rotq);
+
+            d.Vector3 dvtmp;
+            Vector3 tmpV;
+            Vector3 curVel; // velocity in world
+            Vector3 curAngVel; // angular velocity in world
+            Vector3 force = Vector3.Zero; // actually linear aceleration until mult by mass in world frame
+            Vector3 torque = Vector3.Zero;// actually angular aceleration until mult by Inertia in vehicle frame
+            d.Vector3 dtorque = new d.Vector3();
+
+            dvtmp = d.BodyGetLinearVel(Body);
+            curVel.X = dvtmp.X;
+            curVel.Y = dvtmp.Y;
+            curVel.Z = dvtmp.Z;
+            Vector3 curLocalVel = curVel * irotq; // current velocity in  local
+
+            dvtmp = d.BodyGetAngularVel(Body);
+            curAngVel.X = dvtmp.X;
+            curAngVel.Y = dvtmp.Y;
+            curAngVel.Z = dvtmp.Z;
+            Vector3 curLocalAngVel = curAngVel * irotq; // current angular velocity in  local
+
+            float ldampZ = 0;
+            
+            // linear motor
+            if (m_lmEfect > 0.01 && m_linearMotorTimescale < 1000)
+            {
+                tmpV = m_linearMotorDirection - curLocalVel; // velocity error
+                tmpV *= m_lmEfect / m_linearMotorTimescale; // error to correct in this timestep
+                tmpV *= rotq; // to world
+
+                if ((m_flags & VehicleFlag.LIMIT_MOTOR_UP) != 0)
+                    tmpV.Z = 0;
+
+                if (m_linearMotorOffset.X != 0 || m_linearMotorOffset.Y != 0 || m_linearMotorOffset.Z != 0)
+                {
+                    // have offset, do it now
+                    tmpV *= dmass.mass;
+                    d.BodyAddForceAtRelPos(Body, tmpV.X, tmpV.Y, tmpV.Z, m_linearMotorOffset.X, m_linearMotorOffset.Y, m_linearMotorOffset.Z);
+                }
+                else
+                {
+                    force.X += tmpV.X;
+                    force.Y += tmpV.Y;
+                    force.Z += tmpV.Z;
+                }
+
+                m_lmEfect *= m_lmDecay;
+//                m_ffactor = 0.01f + 1e-4f * curVel.LengthSquared();
+                m_ffactor = 0.0f;
+            }
+            else
+            {
+                m_lmEfect = 0;
+                m_ffactor = 1f;
+            }
+           
+            // hover
+            if (m_VhoverTimescale < 300 && rootPrim.prim_geom != IntPtr.Zero)
+            {
+                //                d.Vector3 pos = d.BodyGetPosition(Body);
+                d.Vector3 pos = d.GeomGetPosition(rootPrim.prim_geom);
+                pos.Z -= 0.21f; // minor offset that seems to be always there in sl
+
+                float t = _pParentScene.GetTerrainHeightAtXY(pos.X, pos.Y);
+                float perr;
+
+                // default to global but don't go underground
+                perr = m_VhoverHeight - pos.Z;
+
+                if ((m_flags & VehicleFlag.HOVER_GLOBAL_HEIGHT) == 0)
+                {
+                    if ((m_flags & VehicleFlag.HOVER_WATER_ONLY) != 0)
+                    {
+                        perr += _pParentScene.GetWaterLevel();
+                    }
+                    else if ((m_flags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0)
+                    {
+                        perr += t;
+                    }
+                    else
+                    {
+                        float w = _pParentScene.GetWaterLevel();
+                        if (t > w)
+                            perr += t;
+                        else
+                            perr += w;
+                    }
+                }
+                else if (t > m_VhoverHeight)
+                        perr = t - pos.Z; ;
+
+                if ((m_flags & VehicleFlag.HOVER_UP_ONLY) == 0 || perr > -0.1)
+                {
+                    ldampZ = m_VhoverEfficiency * m_invtimestep;
+
+                    perr *= (1.0f + ldampZ) / m_VhoverTimescale;
+
+                    //                    force.Z += perr - curVel.Z * tmp;
+                    force.Z += perr;
+                    ldampZ *= -curVel.Z;
+
+                    force.Z += _pParentScene.gravityz * m_gravmod * (1f - m_VehicleBuoyancy);
+                }
+                else // no buoyancy
+                    force.Z += _pParentScene.gravityz;
+            }
+            else
+            {
+                // default gravity and Buoyancy
+                force.Z += _pParentScene.gravityz * m_gravmod * (1f - m_VehicleBuoyancy);
+            }
+
+            // linear deflection
+            if (m_linearDeflectionEfficiency > 0)
+            {
+                float len = curVel.Length();
+                if (len > 0.01) // if moving
+                {
+                    Vector3 atAxis;
+                    atAxis = Xrot(rotq); // where are we pointing to
+                    atAxis *= len; // make it same size as world velocity vector
+
+                    tmpV = -atAxis; // oposite direction
+                    atAxis -= curVel; // error to one direction
+                    len = atAxis.LengthSquared();
+
+                    tmpV -= curVel; // error to oposite
+                    float lens = tmpV.LengthSquared();
+
+                    if (len > 0.01 || lens > 0.01) // do nothing if close enougth
+                    {
+                        if (len < lens)
+                            tmpV = atAxis;
+
+                        tmpV *= (m_linearDeflectionEfficiency / m_linearDeflectionTimescale); // error to correct in this timestep
+                        force.X += tmpV.X;
+                        force.Y += tmpV.Y;
+                        if ((m_flags & VehicleFlag.NO_DEFLECTION_UP) == 0)
+                            force.Z += tmpV.Z;
+                    }
+                }
+            }
+
+            // linear friction/damping
+            if (curLocalVel.X != 0 || curLocalVel.Y != 0 || curLocalVel.Z != 0)
+            {
+                tmpV.X = -curLocalVel.X / m_linearFrictionTimescale.X;
+                tmpV.Y = -curLocalVel.Y / m_linearFrictionTimescale.Y;
+                tmpV.Z = -curLocalVel.Z / m_linearFrictionTimescale.Z;
+                tmpV *= rotq; // to world
+
+                if(ldampZ != 0 && Math.Abs(ldampZ) > Math.Abs(tmpV.Z))
+                    tmpV.Z = ldampZ;
+                force.X += tmpV.X;
+                force.Y += tmpV.Y;
+                force.Z += tmpV.Z;
+            }
+
+            // vertical atractor
+            if (m_verticalAttractionTimescale < 300)
+            {
+                float roll;
+                float pitch;
+
+
+
+                float ftmp = m_invtimestep / m_verticalAttractionTimescale / m_verticalAttractionTimescale;
+
+                float ftmp2;
+                ftmp2 = 0.5f * m_verticalAttractionEfficiency * m_invtimestep;
+                m_amdampX = ftmp2;
+
+                m_ampwr = 1.0f - 0.8f * m_verticalAttractionEfficiency;
+
+                GetRollPitch(irotq, out roll, out pitch);
+
+                if (roll > halfpi)
+                    roll = pi - roll;
+                else if (roll < -halfpi)
+                    roll = -pi - roll;
+
+                float effroll = pitch / halfpi;
+                effroll *= effroll;
+                effroll = 1 - effroll;
+                effroll *= roll;
+
+
+                torque.X += effroll * ftmp;
+
+                if ((m_flags & VehicleFlag.LIMIT_ROLL_ONLY) == 0)
+                {
+                    float effpitch = roll / halfpi;
+                    effpitch *= effpitch;
+                    effpitch = 1 - effpitch;
+                    effpitch *= pitch;
+
+                    torque.Y += effpitch * ftmp;
+                }
+
+                if (m_bankingEfficiency != 0 && Math.Abs(effroll) > 0.01)
+                {
+
+                    float broll = effroll;
+                    /*
+                                        if (broll > halfpi)
+                                            broll = pi - broll;
+                                        else if (broll < -halfpi)
+                                            broll = -pi - broll;                           
+                    */
+                    broll *= m_bankingEfficiency;
+                    if (m_bankingMix != 0)
+                    {
+                        float vfact = Math.Abs(curLocalVel.X) / 10.0f;
+                        if (vfact > 1.0f) vfact = 1.0f;
+
+                        if (curLocalVel.X >= 0)
+                            broll *= (1 + (vfact - 1) * m_bankingMix);
+                        else
+                            broll *= -(1 + (vfact - 1) * m_bankingMix);
+                    }
+                    // make z rot be in world Z not local as seems to be in sl
+
+                    broll = broll / m_bankingTimescale;
+
+
+                    tmpV = Zrot(irotq);
+                    tmpV *= broll;
+
+                    torque.X += tmpV.X;
+                    torque.Y += tmpV.Y;
+                    torque.Z += tmpV.Z;
+
+                    m_amdampZ = Math.Abs(m_bankingEfficiency) / m_bankingTimescale;
+                    m_amdampY = m_amdampZ;
+
+                }
+                else
+                {
+                    m_amdampZ = 1 / m_angularFrictionTimescale.Z;
+                    m_amdampY = m_amdampX;
+                }
+            }
+            else
+            {
+                m_ampwr = 1.0f;
+                m_amdampX = 1 / m_angularFrictionTimescale.X;
+                m_amdampY = 1 / m_angularFrictionTimescale.Y;
+                m_amdampZ = 1 / m_angularFrictionTimescale.Z;
+            }
+
+            // angular motor
+            if (m_amEfect > 0.01 && m_angularMotorTimescale < 1000)
+            {
+                tmpV = m_angularMotorDirection - curLocalAngVel; // velocity error
+                tmpV *= m_amEfect / m_angularMotorTimescale; // error to correct in this timestep
+                torque.X += tmpV.X * m_ampwr;
+                torque.Y += tmpV.Y * m_ampwr;
+                torque.Z += tmpV.Z;
+
+                m_amEfect *= m_amDecay;
+            }
+            else
+                m_amEfect = 0;
+
+            // angular deflection
+            if (m_angularDeflectionEfficiency > 0)
+            {
+                Vector3 dirv;
+                
+                if (curLocalVel.X > 0.01f)
+                    dirv = curLocalVel;
+                else if (curLocalVel.X < -0.01f)
+                    // use oposite 
+                    dirv = -curLocalVel;
+                else
+                {
+                    // make it fall into small positive x case
+                    dirv.X = 0.01f;
+                    dirv.Y = curLocalVel.Y;
+                    dirv.Z = curLocalVel.Z;
+                }
+
+                float ftmp = m_angularDeflectionEfficiency / m_angularDeflectionTimescale;
+
+                if (Math.Abs(dirv.Z) > 0.01)
+                {
+                    torque.Y += - (float)Math.Atan2(dirv.Z, dirv.X) * ftmp;
+                }
+
+                if (Math.Abs(dirv.Y) > 0.01)
+                {
+                    torque.Z += (float)Math.Atan2(dirv.Y, dirv.X) * ftmp;
+                }
+            }
+
+            // angular friction
+            if (curLocalAngVel.X != 0 || curLocalAngVel.Y != 0 || curLocalAngVel.Z != 0)
+            {
+                torque.X -= curLocalAngVel.X * m_amdampX;
+                torque.Y -= curLocalAngVel.Y * m_amdampY;
+                torque.Z -= curLocalAngVel.Z * m_amdampZ;
+            }
+          
+
+            if (force.X != 0 || force.Y != 0 || force.Z != 0)
+            {
+                force *= dmass.mass;
+                d.BodyAddForce(Body, force.X, force.Y, force.Z);
+            }
+
+            if (torque.X != 0 || torque.Y != 0 || torque.Z != 0)
+            {
+                torque *= m_referenceFrame; // to object frame
+                dtorque.X = torque.X ;
+                dtorque.Y = torque.Y;
+                dtorque.Z = torque.Z;
+
+                d.MultiplyM3V3(out dvtmp, ref dmass.I, ref dtorque);
+                d.BodyAddRelTorque(Body, dvtmp.X, dvtmp.Y, dvtmp.Z); // add torque in object frame
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODEMeshWorker.cs b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODEMeshWorker.cs
new file mode 100644
index 0000000..918c9db
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODEMeshWorker.cs
@@ -0,0 +1,933 @@
+/*
+ * AJLDuarte 2012
+ */
+
+using System;
+using System.Threading;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OdeAPI;
+using log4net;
+using Nini.Config;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.OdePlugin
+{
+    public enum MeshState : byte
+    {
+        noNeed = 0,
+
+        loadingAsset = 1,
+
+        AssetOK = 0x0f,     // 00001111
+
+        NeedMask = 0x30,    // 00110000
+        needMesh = 0x10,    // 00010000 
+        needAsset = 0x20,   // 00100000
+
+        FailMask = 0xC0,    // 11000000
+        AssetFailed = 0x40, // 01000000
+        MeshFailed = 0x80,   // 10000000
+
+        MeshNoColide = FailMask | needAsset
+    }
+
+    public enum meshWorkerCmnds : byte
+    {
+        nop = 0,
+        addnew,
+        changefull,
+        changesize,
+        changeshapetype,
+        getmesh,
+    }
+
+    public class ODEPhysRepData
+    {
+        public PhysicsActor actor;
+        public PrimitiveBaseShape pbs;
+        public IMesh mesh;
+
+        public Vector3 size;
+        public Vector3 OBB;
+        public Vector3 OBBOffset;
+
+        public float volume;
+
+        public byte shapetype;
+        public bool hasOBB;
+        public bool hasMeshVolume;
+        public MeshState meshState;
+        public UUID? assetID;
+        public meshWorkerCmnds comand;
+    }
+
+    public class ODEMeshWorker
+    {
+
+        private ILog m_log;
+        private OdeScene m_scene;
+        private IMesher m_mesher;
+
+        public bool meshSculptedPrim = true;
+        public bool forceSimplePrimMeshing = false;
+        public float meshSculptLOD = 32;
+        public float MeshSculptphysicalLOD = 32;
+
+
+        private OpenSim.Framework.BlockingQueue<ODEPhysRepData> createqueue = new OpenSim.Framework.BlockingQueue<ODEPhysRepData>();
+        private bool m_running;
+
+        private Thread m_thread;
+
+        public ODEMeshWorker(OdeScene pScene, ILog pLog, IMesher pMesher, IConfig pConfig)
+        {
+            m_scene = pScene;
+            m_log = pLog;
+            m_mesher = pMesher;
+
+            if (pConfig != null)
+            {
+                forceSimplePrimMeshing = pConfig.GetBoolean("force_simple_prim_meshing", forceSimplePrimMeshing);
+                meshSculptedPrim = pConfig.GetBoolean("mesh_sculpted_prim", meshSculptedPrim);
+                meshSculptLOD = pConfig.GetFloat("mesh_lod", meshSculptLOD);
+                MeshSculptphysicalLOD = pConfig.GetFloat("mesh_physical_lod", MeshSculptphysicalLOD);
+            }
+            m_running = true;
+            m_thread = new Thread(DoWork);
+            m_thread.Name = "OdeMeshWorker";
+            m_thread.Start();
+        }
+
+        private void DoWork()
+        {
+            m_mesher.ExpireFileCache();
+
+            while(m_running)
+            {
+                 ODEPhysRepData nextRep = createqueue.Dequeue();
+                if(!m_running)
+                    return;
+                if (nextRep == null)
+                    continue;
+                if (m_scene.haveActor(nextRep.actor))
+                {
+                    switch (nextRep.comand)
+                    {
+                        case meshWorkerCmnds.changefull:
+                        case meshWorkerCmnds.changeshapetype:
+                        case meshWorkerCmnds.changesize:
+                            GetMesh(nextRep);
+                            if (CreateActorPhysRep(nextRep) && m_scene.haveActor(nextRep.actor))
+                                m_scene.AddChange(nextRep.actor, changes.PhysRepData, nextRep);
+                            break;
+                        case meshWorkerCmnds.getmesh:
+                            DoRepDataGetMesh(nextRep);
+                            break;
+                    }
+                }
+            }
+        }
+
+        public void Stop()
+        {
+            try
+            {
+                m_thread.Abort();
+                createqueue.Clear();
+            }
+            catch
+            {
+            }
+        }
+
+        public void ChangeActorPhysRep(PhysicsActor actor, PrimitiveBaseShape pbs,
+                                        Vector3 size, byte shapetype)
+        {
+            ODEPhysRepData repData = new ODEPhysRepData();
+            repData.actor = actor;
+            repData.pbs = pbs;
+            repData.size = size;
+            repData.shapetype = shapetype;
+
+            CheckMesh(repData);
+            CalcVolumeData(repData);
+            m_scene.AddChange(actor, changes.PhysRepData, repData);
+            return;
+        }
+
+        public ODEPhysRepData NewActorPhysRep(PhysicsActor actor, PrimitiveBaseShape pbs,
+                                        Vector3 size, byte shapetype)
+        {
+            ODEPhysRepData repData = new ODEPhysRepData();
+            repData.actor = actor;
+            repData.pbs = pbs;
+            repData.size = size;
+            repData.shapetype = shapetype;
+
+            CheckMesh(repData);
+            CalcVolumeData(repData);
+            m_scene.AddChange(actor, changes.AddPhysRep, repData);
+            return repData;
+        }
+
+        public void RequestMesh(ODEPhysRepData repData)
+        {
+            repData.mesh = null;
+
+            if (repData.meshState == MeshState.needAsset)
+            {
+                PrimitiveBaseShape pbs = repData.pbs;
+
+                // check if we got outdated
+
+                if (!pbs.SculptEntry || pbs.SculptTexture == UUID.Zero)
+                {
+                    repData.meshState = MeshState.noNeed;
+                    return;
+                }
+
+                repData.assetID = pbs.SculptTexture;
+                repData.meshState = MeshState.loadingAsset;
+
+                repData.comand = meshWorkerCmnds.getmesh;
+                createqueue.Enqueue(repData);
+            }
+        }
+
+        // creates and prepares a mesh to use and calls parameters estimation
+        public bool CreateActorPhysRep(ODEPhysRepData repData)
+        {
+            IMesh mesh = repData.mesh;
+
+            if (mesh != null)
+            {
+                IntPtr vertices, indices;
+                int vertexCount, indexCount;
+                int vertexStride, triStride;
+
+                mesh.getVertexListAsPtrToFloatArray(out vertices, out vertexStride, out vertexCount);
+                mesh.getIndexListAsPtrToIntArray(out indices, out triStride, out indexCount);
+
+                if (vertexCount == 0 || indexCount == 0)
+                {
+                    m_log.WarnFormat("[PHYSICS]: Invalid mesh data on prim {0} mesh UUID {1}",
+                        repData.actor.Name, repData.pbs.SculptTexture.ToString());
+                    repData.meshState = MeshState.MeshFailed;
+                    repData.hasOBB = false;
+                    repData.mesh = null;
+                    m_scene.mesher.ReleaseMesh(mesh);
+                }
+                else
+                {
+                    repData.OBBOffset = mesh.GetCentroid();
+                    repData.OBB = mesh.GetOBB();
+                    repData.hasOBB = true;
+                    mesh.releaseSourceMeshData();
+                }
+            }
+            CalcVolumeData(repData);
+            return true;
+        }
+
+        public void AssetLoaded(ODEPhysRepData repData)
+        {
+            if (m_scene.haveActor(repData.actor))
+            {
+                if (needsMeshing(repData.pbs)) // no need for pbs now?
+                {
+                    repData.comand = meshWorkerCmnds.changefull;
+                    createqueue.Enqueue(repData);
+                }
+            }
+            else
+                repData.pbs.SculptData = Utils.EmptyBytes;
+        }
+
+        public void DoRepDataGetMesh(ODEPhysRepData repData)
+        {
+            if (!repData.pbs.SculptEntry)
+                return;
+
+            if (repData.meshState != MeshState.loadingAsset)
+                return;
+
+            if (repData.assetID == null || repData.assetID == UUID.Zero)
+                return;
+
+            if (repData.assetID != repData.pbs.SculptTexture)
+                return;
+
+            // check if it is in cache
+            GetMesh(repData);
+            if (repData.meshState != MeshState.needAsset)
+            {
+                CreateActorPhysRep(repData);
+                m_scene.AddChange(repData.actor, changes.PhysRepData, repData);
+                return;
+            }
+
+            RequestAssetDelegate assetProvider = m_scene.RequestAssetMethod;
+            if (assetProvider == null)
+                return;
+            ODEAssetRequest asr = new ODEAssetRequest(this, assetProvider, repData, m_log);
+        }
+
+
+        /// <summary>
+        /// Routine to figure out if we need to mesh this prim with our mesher
+        /// </summary>
+        /// <param name="pbs"></param>
+        /// <returns></returns>
+        public bool needsMeshing(PrimitiveBaseShape pbs)
+        {
+            // check sculpts or meshs 
+            if (pbs.SculptEntry)
+            {
+                if (meshSculptedPrim)
+                    return true;
+
+                if (pbs.SculptType == (byte)SculptType.Mesh) // always do meshs
+                    return true;
+
+                return false;
+            }
+
+            if (forceSimplePrimMeshing)
+                return true;
+
+            // if it's a standard box or sphere with no cuts, hollows, twist or top shear, return false since ODE can use an internal representation for the prim
+
+            if ((pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight)
+                    || (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1
+                    && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z))
+            {
+
+                if (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0
+                    && pbs.ProfileHollow == 0
+                    && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0
+                    && pbs.PathBegin == 0 && pbs.PathEnd == 0
+                    && pbs.PathTaperX == 0 && pbs.PathTaperY == 0
+                    && pbs.PathScaleX == 100 && pbs.PathScaleY == 100
+                    && pbs.PathShearX == 0 && pbs.PathShearY == 0)
+                {
+                    return false;
+                }
+            }
+
+            //  following code doesn't give meshs to boxes and spheres ever
+            // and it's odd..  so for now just return true if asked to force meshs
+            // hopefully mesher will fail if doesn't suport so things still get basic boxes
+
+            int iPropertiesNotSupportedDefault = 0;
+
+            if (pbs.ProfileHollow != 0)
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathBegin != 0) || pbs.PathEnd != 0)
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0))
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0)
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathScaleX != 100) || (pbs.PathScaleY != 100))
+                iPropertiesNotSupportedDefault++;
+
+            if ((pbs.PathShearX != 0) || (pbs.PathShearY != 0))
+                iPropertiesNotSupportedDefault++;
+
+            if (pbs.ProfileShape == ProfileShape.Circle && pbs.PathCurve == (byte)Extrusion.Straight)
+                iPropertiesNotSupportedDefault++;
+
+            if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1 && (pbs.Scale.X != pbs.Scale.Y || pbs.Scale.Y != pbs.Scale.Z || pbs.Scale.Z != pbs.Scale.X))
+                iPropertiesNotSupportedDefault++;
+
+            if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1)
+                iPropertiesNotSupportedDefault++;
+
+            // test for torus
+            if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Square)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Curve1)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Straight)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+
+                // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits
+                else if (pbs.PathCurve == (byte)Extrusion.Curve1)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+            else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle)
+            {
+                if (pbs.PathCurve == (byte)Extrusion.Straight)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+                else if (pbs.PathCurve == (byte)Extrusion.Curve1)
+                {
+                    iPropertiesNotSupportedDefault++;
+                }
+            }
+
+            if (iPropertiesNotSupportedDefault == 0)
+            {
+                return false;
+            }
+            return true;
+        }
+
+        // see if we need a mesh and if so if we have a cached one
+        // called with a new repData
+        public void CheckMesh(ODEPhysRepData repData)
+        {
+            PhysicsActor actor = repData.actor;
+            PrimitiveBaseShape pbs = repData.pbs;
+
+            if (!needsMeshing(pbs))
+            {
+                repData.meshState = MeshState.noNeed;
+                return;
+            }
+
+            IMesh mesh = null;
+
+            Vector3 size = repData.size;
+            byte shapetype = repData.shapetype;
+
+            bool convex;
+
+            int clod = (int)LevelOfDetail.High;
+            if (shapetype == 0)
+                convex = false;
+            else
+            {
+                convex = true;
+                if (pbs.SculptType != (byte)SculptType.Mesh)
+                    clod = (int)LevelOfDetail.Low;
+            }
+
+            mesh = m_mesher.GetMesh(actor.Name, pbs, size, clod, true, convex);
+
+            if (mesh == null)
+            {
+                if (pbs.SculptEntry)
+                {
+                    if (pbs.SculptTexture != null && pbs.SculptTexture != UUID.Zero)
+                    {
+                        repData.assetID = pbs.SculptTexture;
+                        repData.meshState = MeshState.needAsset;
+                    }
+                    else
+                        repData.meshState = MeshState.MeshFailed;
+
+                    return;
+                }
+                else
+                {
+                    repData.meshState = MeshState.needMesh;
+                    mesh = m_mesher.CreateMesh(actor.Name, pbs, size, clod, true, convex, true);
+                    if (mesh == null)
+                    {
+                        repData.meshState = MeshState.MeshFailed;
+                        return;
+                    }
+                }               
+            }
+
+            repData.meshState = MeshState.AssetOK;
+            repData.mesh = mesh;
+
+            if (pbs.SculptEntry)
+            {
+                repData.assetID = pbs.SculptTexture;
+            }
+
+            pbs.SculptData = Utils.EmptyBytes;
+            return ;
+        }
+
+        public void GetMesh(ODEPhysRepData repData)
+        {
+            PhysicsActor actor = repData.actor;
+
+            PrimitiveBaseShape pbs = repData.pbs;
+
+            repData.mesh = null;
+            repData.hasOBB = false;
+
+            if (!needsMeshing(pbs))
+            {
+                repData.meshState = MeshState.noNeed;
+                return;
+            }
+
+            if (repData.meshState == MeshState.MeshFailed)
+                return;
+
+            if (pbs.SculptEntry)
+            {
+                if (repData.meshState == MeshState.AssetFailed)
+                {
+                    if (pbs.SculptTexture == repData.assetID)
+                        return;
+                }
+            }
+
+            repData.meshState = MeshState.noNeed;
+
+            IMesh mesh = null;
+            Vector3 size = repData.size;
+            byte shapetype = repData.shapetype;
+
+            bool convex;
+            int clod = (int)LevelOfDetail.High;
+            if (shapetype == 0)
+                convex = false;
+            else
+            {
+                convex = true;
+                if (pbs.SculptType != (byte)SculptType.Mesh)
+                    clod = (int)LevelOfDetail.Low;
+            }
+
+            mesh = m_mesher.CreateMesh(actor.Name, pbs, size, clod, true, convex, true);
+   
+            if (mesh == null)
+            {
+                if (pbs.SculptEntry)
+                {
+                    if (pbs.SculptTexture == UUID.Zero)
+                        return;
+
+                    repData.assetID = pbs.SculptTexture;
+
+                    if (pbs.SculptData == null || pbs.SculptData.Length == 0)
+                    {
+                        repData.meshState = MeshState.needAsset;
+                        return;
+                    }
+                }
+            }
+
+            repData.mesh = mesh;
+            repData.pbs.SculptData = Utils.EmptyBytes;
+
+            if (mesh == null)
+            {
+                if (pbs.SculptEntry)
+                    repData.meshState = MeshState.AssetFailed;
+                else
+                    repData.meshState = MeshState.MeshFailed;
+
+                return;
+            }
+
+            repData.meshState = MeshState.AssetOK;
+
+            return;
+        }
+
+        private void CalculateBasicPrimVolume(ODEPhysRepData repData)
+        {
+            PrimitiveBaseShape _pbs = repData.pbs;
+            Vector3 _size = repData.size;
+
+            float volume = _size.X * _size.Y * _size.Z; // default
+            float tmp;
+
+            float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f;
+            float hollowVolume = hollowAmount * hollowAmount;
+
+            switch (_pbs.ProfileShape)
+            {
+                case ProfileShape.Square:
+                    // default box
+
+                    if (_pbs.PathCurve == (byte)Extrusion.Straight)
+                    {
+                        if (hollowAmount > 0.0)
+                        {
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Square:
+                                case HollowShape.Same:
+                                    break;
+
+                                case HollowShape.Circle:
+
+                                    hollowVolume *= 0.78539816339f;
+                                    break;
+
+                                case HollowShape.Triangle:
+
+                                    hollowVolume *= (0.5f * .5f);
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+
+                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                        //a tube 
+
+                        volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX);
+                        tmp = 1.0f - 2.0e-2f * (float)(200 - _pbs.PathScaleY);
+                        volume -= volume * tmp * tmp;
+
+                        if (hollowAmount > 0.0)
+                        {
+                            hollowVolume *= hollowAmount;
+
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Square:
+                                case HollowShape.Same:
+                                    break;
+
+                                case HollowShape.Circle:
+                                    hollowVolume *= 0.78539816339f;
+                                    break;
+
+                                case HollowShape.Triangle:
+                                    hollowVolume *= 0.5f * 0.5f;
+                                    break;
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+
+                    break;
+
+                case ProfileShape.Circle:
+
+                    if (_pbs.PathCurve == (byte)Extrusion.Straight)
+                    {
+                        volume *= 0.78539816339f; // elipse base
+
+                        if (hollowAmount > 0.0)
+                        {
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Same:
+                                case HollowShape.Circle:
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.5f * 2.5984480504799f;
+                                    break;
+
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .5f * 1.27323954473516f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+
+                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                        volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - _pbs.PathScaleX);
+                        tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
+                        volume *= (1.0f - tmp * tmp);
+
+                        if (hollowAmount > 0.0)
+                        {
+
+                            // calculate the hollow volume by it's shape compared to the prim shape
+                            hollowVolume *= hollowAmount;
+
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Same:
+                                case HollowShape.Circle:
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.5f * 2.5984480504799f;
+                                    break;
+
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .5f * 1.27323954473516f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+                    break;
+
+                case ProfileShape.HalfCircle:
+                    if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                        volume *= 0.5236f;
+
+                        if (hollowAmount > 0.0)
+                        {
+                            hollowVolume *= hollowAmount;
+
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Circle:
+                                case HollowShape.Triangle:  // diference in sl is minor and odd
+                                case HollowShape.Same:
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.909f;
+                                    break;
+
+                                //                                case HollowShape.Triangle:
+                                //                                    hollowVolume *= .827f;
+                                //                                    break;
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+
+                    }
+                    break;
+
+                case ProfileShape.EquilateralTriangle:
+
+                    if (_pbs.PathCurve == (byte)Extrusion.Straight)
+                    {
+                        volume *= 0.32475953f;
+
+                        if (hollowAmount > 0.0)
+                        {
+
+                            // calculate the hollow volume by it's shape compared to the prim shape
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Same:
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .25f;
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.499849f * 3.07920140172638f;
+                                    break;
+
+                                case HollowShape.Circle:
+                                    // Hollow shape is a perfect cyllinder in respect to the cube's scale
+                                    // Cyllinder hollow volume calculation
+
+                                    hollowVolume *= 0.1963495f * 3.07920140172638f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+                    else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
+                    {
+                        volume *= 0.32475953f;
+                        volume *= 0.01f * (float)(200 - _pbs.PathScaleX);
+                        tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
+                        volume *= (1.0f - tmp * tmp);
+
+                        if (hollowAmount > 0.0)
+                        {
+
+                            hollowVolume *= hollowAmount;
+
+                            switch (_pbs.HollowShape)
+                            {
+                                case HollowShape.Same:
+                                case HollowShape.Triangle:
+                                    hollowVolume *= .25f;
+                                    break;
+
+                                case HollowShape.Square:
+                                    hollowVolume *= 0.499849f * 3.07920140172638f;
+                                    break;
+
+                                case HollowShape.Circle:
+
+                                    hollowVolume *= 0.1963495f * 3.07920140172638f;
+                                    break;
+
+                                default:
+                                    hollowVolume = 0;
+                                    break;
+                            }
+                            volume *= (1.0f - hollowVolume);
+                        }
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+
+            float taperX1;
+            float taperY1;
+            float taperX;
+            float taperY;
+            float pathBegin;
+            float pathEnd;
+            float profileBegin;
+            float profileEnd;
+
+            if (_pbs.PathCurve == (byte)Extrusion.Straight || _pbs.PathCurve == (byte)Extrusion.Flexible)
+            {
+                taperX1 = _pbs.PathScaleX * 0.01f;
+                if (taperX1 > 1.0f)
+                    taperX1 = 2.0f - taperX1;
+                taperX = 1.0f - taperX1;
+
+                taperY1 = _pbs.PathScaleY * 0.01f;
+                if (taperY1 > 1.0f)
+                    taperY1 = 2.0f - taperY1;
+                taperY = 1.0f - taperY1;
+            }
+            else
+            {
+                taperX = _pbs.PathTaperX * 0.01f;
+                if (taperX < 0.0f)
+                    taperX = -taperX;
+                taperX1 = 1.0f - taperX;
+
+                taperY = _pbs.PathTaperY * 0.01f;
+                if (taperY < 0.0f)
+                    taperY = -taperY;
+                taperY1 = 1.0f - taperY;
+            }
+
+            volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY);
+
+            pathBegin = (float)_pbs.PathBegin * 2.0e-5f;
+            pathEnd = 1.0f - (float)_pbs.PathEnd * 2.0e-5f;
+            volume *= (pathEnd - pathBegin);
+
+            // this is crude aproximation
+            profileBegin = (float)_pbs.ProfileBegin * 2.0e-5f;
+            profileEnd = 1.0f - (float)_pbs.ProfileEnd * 2.0e-5f;
+            volume *= (profileEnd - profileBegin);           
+
+            repData.volume = volume;
+        }
+
+        private void CalcVolumeData(ODEPhysRepData repData)
+        {
+            if (repData.hasOBB)
+            {
+                Vector3 OBB = repData.OBB;
+            }
+            else
+            {
+                Vector3 OBB = repData.size;
+                OBB.X *= 0.5f;
+                OBB.Y *= 0.5f;
+                OBB.Z *= 0.5f;
+
+                repData.OBB = OBB;
+                repData.OBBOffset = Vector3.Zero;
+            }
+
+            CalculateBasicPrimVolume(repData);
+        }
+    }
+
+    public class ODEAssetRequest
+    {
+        ODEMeshWorker m_worker;
+        private ILog m_log;
+        ODEPhysRepData repData;
+
+        public ODEAssetRequest(ODEMeshWorker pWorker, RequestAssetDelegate provider,
+            ODEPhysRepData pRepData, ILog plog)
+        {
+            m_worker = pWorker;
+            m_log = plog;
+            repData = pRepData;
+
+            repData.meshState = MeshState.AssetFailed;
+            if (provider == null)
+                return;
+
+            if (repData.assetID == null)
+                return;
+
+            UUID assetID = (UUID) repData.assetID;
+            if (assetID == UUID.Zero)
+                return;
+
+            repData.meshState = MeshState.loadingAsset;
+            provider(assetID, ODEassetReceived);
+        }
+
+        void ODEassetReceived(AssetBase asset)
+        {
+            repData.meshState = MeshState.AssetFailed;
+            if (asset != null)
+            {
+                if (asset.Data != null && asset.Data.Length > 0)
+                {
+                    repData.meshState = MeshState.noNeed;
+
+                    if (!repData.pbs.SculptEntry)
+                        return;
+                    if (repData.pbs.SculptTexture != repData.assetID)
+                        return;
+
+//                    repData.pbs.SculptData = new byte[asset.Data.Length];
+//                    asset.Data.CopyTo(repData.pbs.SculptData,0);
+                    repData.pbs.SculptData = asset.Data;
+                    repData.meshState = MeshState.AssetOK;
+                    m_worker.AssetLoaded(repData);
+                }
+                else
+                    m_log.WarnFormat("[PHYSICS]: asset provider returned invalid mesh data for prim {0} asset UUID {1}.",
+                        repData.actor.Name, asset.ID.ToString());
+            }
+            else
+                m_log.WarnFormat("[PHYSICS]: asset provider returned null asset fo mesh of prim {0}.",
+                    repData.actor.Name);
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODEPrim.cs b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODEPrim.cs
new file mode 100644
index 0000000..b52a242
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODEPrim.cs
@@ -0,0 +1,3901 @@
+/*

+ * Copyright (c) Contributors, http://opensimulator.org/

+ * See CONTRIBUTORS.TXT for a full list of copyright holders.

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions are met:

+ *     * Redistributions of source code must retain the above copyright

+ *       notice, this list of conditions and the following disclaimer.

+ *     * Redistributions in binary form must reproduce the above copyright

+ *       notice, this list of conditions and the following disclaimer in the

+ *       documentation and/or other materials provided with the distribution.

+ *     * Neither the name of the OpenSimulator Project nor the

+ *       names of its contributors may be used to endorse or promote products

+ *       derived from this software without specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY

+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY

+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+

+/* Revision 2011/12/13 by Ubit Umarov

+ *

+ * 

+ */

+

+/*

+ * Revised August 26 2009 by Kitto Flora. ODEDynamics.cs replaces

+ * ODEVehicleSettings.cs. It and ODEPrim.cs are re-organised:

+ * ODEPrim.cs contains methods dealing with Prim editing, Prim

+ * characteristics and Kinetic motion.

+ * ODEDynamics.cs contains methods dealing with Prim Physical motion

+ * (dynamics) and the associated settings. Old Linear and angular

+ * motors for dynamic motion have been replace with  MoveLinear()

+ * and MoveAngular(); 'Physical' is used only to switch ODE dynamic 

+ * simualtion on/off; VEHICAL_TYPE_NONE/VEHICAL_TYPE_<other> is to

+ * switch between 'VEHICLE' parameter use and general dynamics

+ * settings use.

+ */

+

+//#define SPAM

+

+using System;

+using System.Collections.Generic;

+using System.Reflection;

+using System.Runtime.InteropServices;

+using System.Threading;

+using log4net;

+using OpenMetaverse;

+using OdeAPI;

+using OpenSim.Framework;

+using OpenSim.Region.PhysicsModules.SharedBase;

+

+namespace OpenSim.Region.PhysicsModules.OdePlugin

+{

+    public class OdePrim : PhysicsActor

+    {

+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

+

+        private bool m_isphysical;

+        private bool m_fakeisphysical;

+        private bool m_isphantom;

+        private bool m_fakeisphantom;

+        internal bool m_isVolumeDetect; // If true, this prim only detects collisions but doesn't collide actively

+        private bool m_fakeisVolumeDetect; // If true, this prim only detects collisions but doesn't collide actively

+

+        protected bool m_building;

+        protected bool m_forcePosOrRotation;

+        private bool m_iscolliding;

+

+        internal bool m_isSelected;

+        private bool m_delaySelect;

+        private bool m_lastdoneSelected;

+        internal bool m_outbounds;

+

+        private Quaternion m_lastorientation;

+        private Quaternion _orientation;

+

+        private Vector3 _position;

+        private Vector3 _velocity;

+        private Vector3 m_torque;

+        private Vector3 m_lastVelocity;

+        private Vector3 m_lastposition;

+        private Vector3 m_rotationalVelocity;

+        private Vector3 _size;

+        private Vector3 _acceleration;

+        private Vector3 m_angularlock = Vector3.One;

+        private IntPtr Amotor;

+

+        private Vector3 m_force;

+        private Vector3 m_forceacc;

+        private Vector3 m_angularForceacc;

+

+        private float m_invTimeStep;

+        private float m_timeStep;

+

+        private Vector3 m_PIDTarget;

+        private float m_PIDTau;

+        private bool m_usePID;

+

+        private float m_PIDHoverHeight;

+        private float m_PIDHoverTau;

+        private bool m_useHoverPID;

+        private PIDHoverType m_PIDHoverType;

+        private float m_targetHoverHeight;

+        private float m_groundHeight;

+        private float m_waterHeight;

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

+

+        private int body_autodisable_frames;

+        public int bodydisablecontrol;

+        private float m_gravmod = 1.0f;

+

+        // Default we're a Geometry

+        private CollisionCategories m_collisionCategories = (CollisionCategories.Geom);

+        // Default colide nonphysical don't try to colide with anything

+        private const CollisionCategories m_default_collisionFlagsNotPhysical = 0;

+

+        private const CollisionCategories m_default_collisionFlagsPhysical = (CollisionCategories.Geom |

+                                        CollisionCategories.Character |

+                                        CollisionCategories.Land |

+                                        CollisionCategories.VolumeDtc);

+

+//        private bool m_collidesLand = true;

+        private bool m_collidesWater;

+//        public bool m_returnCollisions;

+

+        private bool m_NoColide;  // for now only for internal use for bad meshs

+

+

+        // Default, Collide with Other Geometries, spaces and Bodies

+        private CollisionCategories m_collisionFlags = m_default_collisionFlagsNotPhysical;

+

+        public bool m_disabled;

+

+        private uint m_localID;

+

+        private IMesh m_mesh;

+        private object m_meshlock = new object();

+        private PrimitiveBaseShape _pbs;

+

+        private UUID? m_assetID;

+        private MeshState m_meshState;

+        

+        public OdeScene _parent_scene;

+

+        /// <summary>

+        /// The physics space which contains prim geometry

+        /// </summary>

+        public IntPtr m_targetSpace;

+

+        public IntPtr prim_geom;

+        public IntPtr _triMeshData;

+

+        private PhysicsActor _parent;

+

+        private List<OdePrim> childrenPrim = new List<OdePrim>();

+

+        public float m_collisionscore;

+        private int m_colliderfilter = 0;

+

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

+

+        private float m_density;

+        private byte m_shapetype;

+        public bool _zeroFlag;

+        private bool m_lastUpdateSent;

+

+        public IntPtr Body;

+

+        private Vector3 _target_velocity;

+

+        public Vector3 m_OBBOffset;

+        public Vector3 m_OBB;

+        public float primOOBradiusSQ;

+

+        private bool m_hasOBB = true;

+

+        private float m_physCost;

+        private float m_streamCost;

+

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

+        float primMass; // prim own mass

+        float primVolume; // prim own volume;

+        float _mass; // object mass acording to case

+

+        public int givefakepos;

+        private Vector3 fakepos;

+        public int givefakeori;

+        private Quaternion fakeori;

+

+        private int m_eventsubscription;

+        private int m_cureventsubscription;

+        private CollisionEventUpdate CollisionEventsThisFrame = null;

+        private bool SentEmptyCollisionsEvent;

+

+        public volatile bool childPrim;

+

+        public ODEDynamics m_vehicle;

+

+        internal int m_material = (int)Material.Wood;

+        private float mu;

+        private float bounce;

+

+        /// <summary>

+        /// Is this prim subject to physics?  Even if not, it's still solid for collision purposes.

+        /// </summary>

+        public override bool IsPhysical  // this is not reliable for internal use

+        {

+            get { return m_fakeisphysical; }

+            set

+            {

+                m_fakeisphysical = value; // we show imediatly to outside that we changed physical

+                // and also to stop imediatly some updates

+                // but real change will only happen in taintprocessing

+

+                if (!value) // Zero the remembered last velocity

+                    m_lastVelocity = Vector3.Zero;

+                AddChange(changes.Physical, value);

+            }

+        }

+

+        public override bool IsVolumeDtc

+        {

+            get { return m_fakeisVolumeDetect; }

+            set

+            {

+                m_fakeisVolumeDetect = value;

+                AddChange(changes.VolumeDtc, value);

+            }

+        }

+

+        public override bool Phantom  // this is not reliable for internal use

+        {

+            get { return m_fakeisphantom; }

+            set

+            {

+                m_fakeisphantom = value;

+                AddChange(changes.Phantom, value);

+            }

+        }

+

+        public override bool Building  // this is not reliable for internal use

+        {

+            get { return m_building; }

+            set

+            {

+//                if (value)

+//                    m_building = true;

+                AddChange(changes.building, value);

+            }

+        }

+

+        public override void getContactData(ref ContactData cdata)

+        {

+            cdata.mu = mu;

+            cdata.bounce = bounce;

+

+            //            cdata.softcolide = m_softcolide;

+            cdata.softcolide = false;

+

+            if (m_isphysical)

+            {

+                ODEDynamics veh;

+                if (_parent != null)

+                    veh = ((OdePrim)_parent).m_vehicle;

+                else

+                    veh = m_vehicle;

+

+                if (veh != null && veh.Type != Vehicle.TYPE_NONE)

+                    cdata.mu *= veh.FrictionFactor;

+//                    cdata.mu *= 0;

+            }

+        }

+

+        public override float PhysicsCost

+        {

+            get

+            {

+                return m_physCost;

+            }

+        }

+

+        public override float StreamCost

+        {

+            get

+            {

+                return m_streamCost;

+            }

+        }

+

+        public override int PhysicsActorType

+        {

+            get { return (int)ActorTypes.Prim; }

+            set { return; }

+        }

+

+        public override bool SetAlwaysRun

+        {

+            get { return false; }

+            set { return; }

+        }

+

+        public override uint LocalID

+        {

+            get { return m_localID; }

+            set { m_localID = value; }

+        }

+

+        public override PhysicsActor ParentActor

+        {

+            get

+            {

+                if (childPrim)

+                    return _parent;

+                else

+                    return (PhysicsActor)this;

+            }

+        }

+

+        public override bool Grabbed

+        {

+            set { return; }

+        }

+

+        public override bool Selected

+        {

+            set

+            {

+                if (value)

+                    m_isSelected = value; // if true set imediatly to stop moves etc

+                AddChange(changes.Selected, value);

+            }

+        }

+

+        public override bool Flying

+        {

+            // no flying prims for you

+            get { return false; }

+            set { }

+        }

+

+        public override bool IsColliding

+        {

+            get { return m_iscolliding; }

+            set

+            {

+                if (value)

+                {

+                    m_colliderfilter += 2;

+                    if (m_colliderfilter > 2)

+                        m_colliderfilter = 2;

+                }

+                else

+                {

+                    m_colliderfilter--;

+                    if (m_colliderfilter < 0)

+                        m_colliderfilter = 0;

+                }

+

+                if (m_colliderfilter == 0)

+                    m_iscolliding = false;

+                else

+                    m_iscolliding = true;

+            }

+        }

+

+        public override bool CollidingGround

+        {

+            get { return false; }

+            set { return; }

+        }

+

+        public override bool CollidingObj

+        {

+            get { return false; }

+            set { return; }

+        }

+

+

+        public override bool ThrottleUpdates {get;set;}

+

+        public override bool Stopped

+        {

+            get { return _zeroFlag; }

+        }

+

+        public override Vector3 Position

+        {

+            get

+            {

+                if (givefakepos > 0)

+                    return fakepos;

+                else

+                    return _position;

+            }

+

+            set

+            {

+                fakepos = value;

+                givefakepos++;

+                AddChange(changes.Position, value);

+            }

+        }

+

+        public override Vector3 Size

+        {

+            get { return _size; }

+            set

+            {

+                if (value.IsFinite())

+                {

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

+                }

+                else

+                {

+                    m_log.WarnFormat("[PHYSICS]: Got NaN Size on object {0}", Name);

+                }

+            }

+        }

+

+        public override float Mass

+        {

+            get { return primMass; }

+        }

+

+        public override Vector3 Force

+        {

+            get { return m_force; }

+            set

+            {

+                if (value.IsFinite())

+                {

+                    AddChange(changes.Force, value);

+                }

+                else

+                {

+                    m_log.WarnFormat("[PHYSICS]: NaN in Force Applied to an Object {0}", Name);

+                }

+            }

+        }

+

+        public override void SetVolumeDetect(int param)

+        {

+            m_fakeisVolumeDetect = (param != 0);

+            AddChange(changes.VolumeDtc, m_fakeisVolumeDetect);

+        }

+

+        public override Vector3 GeometricCenter

+        {

+            // this is not real geometric center but a average of positions relative to root prim acording to

+            // http://wiki.secondlife.com/wiki/llGetGeometricCenter

+            // ignoring tortured prims details since sl also seems to ignore

+            // so no real use in doing it on physics

+            get

+            {

+                return Vector3.Zero;

+            }

+        }

+

+        public override Vector3 CenterOfMass

+        {

+            get

+            {

+                lock (_parent_scene.OdeLock)

+                {

+                    d.Vector3 dtmp;

+                    if (!childPrim && Body != IntPtr.Zero)

+                    {

+                        dtmp = d.BodyGetPosition(Body);

+                        return new Vector3(dtmp.X, dtmp.Y, dtmp.Z);

+                    }

+                    else if (prim_geom != IntPtr.Zero)

+                    {

+                        d.Quaternion dq;

+                        d.GeomCopyQuaternion(prim_geom, out dq);

+                        Quaternion q;

+                        q.X = dq.X;

+                        q.Y = dq.Y;

+                        q.Z = dq.Z;

+                        q.W = dq.W;

+

+                        Vector3 Ptot = m_OBBOffset * q;

+                        dtmp = d.GeomGetPosition(prim_geom);

+                        Ptot.X += dtmp.X;

+                        Ptot.Y += dtmp.Y;

+                        Ptot.Z += dtmp.Z;

+

+                        //                    if(childPrim)  we only know about physical linksets

+                        return Ptot;

+/*

+                        float tmass = _mass;

+                        Ptot *= tmass;

+

+                        float m;

+

+                        foreach (OdePrim prm in childrenPrim)

+                        {

+                            m = prm._mass;

+                            Ptot += prm.CenterOfMass * m;

+                            tmass += m;

+                        }

+

+                        if (tmass == 0)

+                            tmass = 0;

+                        else

+                            tmass = 1.0f / tmass;

+

+                        Ptot *= tmass;

+                        return Ptot;

+*/

+                    }

+                    else

+                        return _position;

+                }

+            }

+        }

+

+        public override Vector3 OOBsize

+            {

+            get

+                {

+                return m_OBB;

+                }

+            }

+

+        public override Vector3 OOBoffset

+            {

+            get

+                {

+                return m_OBBOffset;

+                }

+            }

+

+        public override float OOBRadiusSQ

+            {

+            get

+                {

+                return primOOBradiusSQ;

+                }

+            }

+

+        public override PrimitiveBaseShape Shape

+        {

+            set

+            {

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

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

+            }

+        }

+

+        public override byte PhysicsShapeType

+        {

+            get

+            {

+                return m_shapetype;

+            }

+            set

+            {

+                m_shapetype = value;

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

+            }

+        }

+

+        public override Vector3 Velocity

+        {

+            get

+            {

+                if (_zeroFlag)

+                    return Vector3.Zero;

+                return _velocity;

+            }

+            set

+            {

+                if (value.IsFinite())

+                {

+                    AddChange(changes.Velocity, value);

+                }

+                else

+                {

+                    m_log.WarnFormat("[PHYSICS]: Got NaN Velocity in Object {0}", Name);

+                }

+

+            }

+        }

+

+        public override Vector3 Torque

+        {

+            get

+            {

+                if (!IsPhysical || Body == IntPtr.Zero)

+                    return Vector3.Zero;

+

+                return m_torque;

+            }

+

+            set

+            {

+                if (value.IsFinite())

+                {

+                    AddChange(changes.Torque, value);

+                }

+                else

+                {

+                    m_log.WarnFormat("[PHYSICS]: Got NaN Torque in Object {0}", Name);

+                }

+            }

+        }

+

+        public override float CollisionScore

+        {

+            get { return m_collisionscore; }

+            set { m_collisionscore = value; }

+        }

+

+        public override bool Kinematic

+        {

+            get { return false; }

+            set { }

+        }

+

+        public override Quaternion Orientation

+        {

+            get

+            {

+                if (givefakeori > 0)

+                    return fakeori;

+                else

+

+                    return _orientation;

+            }

+            set

+            {

+                if (QuaternionIsFinite(value))

+                {

+                    fakeori = value;

+                    givefakeori++;

+

+                    value.Normalize();

+

+                    AddChange(changes.Orientation, value);

+                }

+                else

+                    m_log.WarnFormat("[PHYSICS]: Got NaN quaternion Orientation from Scene in Object {0}", Name);

+

+            }

+        }

+

+        public override Vector3 Acceleration

+        {

+            get { return _acceleration; }

+            set { }

+        }

+

+        public override Vector3 RotationalVelocity

+        {

+            get

+            {

+                Vector3 pv = Vector3.Zero;

+                if (_zeroFlag)

+                    return pv;

+

+                if (m_rotationalVelocity.ApproxEquals(pv, 0.0001f))

+                    return pv;

+

+                return m_rotationalVelocity;

+            }

+            set

+            {

+                if (value.IsFinite())

+                {

+                    AddChange(changes.AngVelocity, value);

+                }

+                else

+                {

+                    m_log.WarnFormat("[PHYSICS]: Got NaN RotationalVelocity in Object {0}", Name);

+                }

+            }

+        }

+

+        public override float Buoyancy

+        {

+            get { return m_buoyancy; }

+            set

+            {

+                 AddChange(changes.Buoyancy,value);

+            }

+        }

+

+        public override bool FloatOnWater

+        {

+            set

+            {

+                AddChange(changes.CollidesWater, value);

+            }

+        }

+

+        public override Vector3 PIDTarget

+        {

+            set

+            {

+                if (value.IsFinite())

+                {

+                    AddChange(changes.PIDTarget,value);

+                }

+                else

+                    m_log.WarnFormat("[PHYSICS]: Got NaN PIDTarget from Scene on Object {0}", Name);

+            }

+        }

+

+        public override bool PIDActive

+        {

+            get

+            {

+                return m_usePID;

+            }

+            set

+            {

+                AddChange(changes.PIDActive,value);

+            }

+        }

+

+        public override float PIDTau

+        {

+            set

+            {

+                float tmp = 0;

+                if (value > 0)

+                {

+                    float mint = (0.05f > m_timeStep ? 0.05f : m_timeStep);

+                    if (value < mint)

+                        tmp = mint;

+                    else

+                        tmp = value;

+                }

+                AddChange(changes.PIDTau,tmp);

+            }

+        }

+

+        public override float PIDHoverHeight

+        {

+            set

+            {

+                AddChange(changes.PIDHoverHeight,value);

+            }

+        }

+        public override bool PIDHoverActive

+        {

+            set

+            {

+                AddChange(changes.PIDHoverActive, value);

+            }

+        }

+

+        public override PIDHoverType PIDHoverType

+        {

+            set

+            {

+                AddChange(changes.PIDHoverType,value);

+            }

+        }

+

+        public override float PIDHoverTau

+        {

+            set

+            {

+                float tmp =0;

+                if (value > 0)

+                {

+                    float mint = (0.05f > m_timeStep ? 0.05f : m_timeStep);

+                    if (value < mint)

+                        tmp = mint;

+                    else

+                        tmp = value;

+                }

+                AddChange(changes.PIDHoverTau, tmp);

+            }

+        }

+

+        public override Quaternion APIDTarget { set { return; } }

+

+        public override bool APIDActive { set { return; } }

+

+        public override float APIDStrength { set { return; } }

+

+        public override float APIDDamping { set { return; } }

+

+        public override int VehicleType

+        {

+            // we may need to put a fake on this

+            get

+            {

+                if (m_vehicle == null)

+                    return (int)Vehicle.TYPE_NONE;

+                else

+                    return (int)m_vehicle.Type;

+            }

+            set

+            {

+                AddChange(changes.VehicleType, value);

+            }

+        }

+

+        public override void VehicleFloatParam(int param, float value)

+        {

+            strVehicleFloatParam fp = new strVehicleFloatParam();

+            fp.param = param;

+            fp.value = value;

+            AddChange(changes.VehicleFloatParam, fp);

+        }

+

+        public override void VehicleVectorParam(int param, Vector3 value)

+        {

+            strVehicleVectorParam fp = new strVehicleVectorParam();

+            fp.param = param;

+            fp.value = value;

+            AddChange(changes.VehicleVectorParam, fp);

+        }

+

+        public override void VehicleRotationParam(int param, Quaternion value)

+        {

+            strVehicleQuatParam fp = new strVehicleQuatParam();

+            fp.param = param;

+            fp.value = value;

+            AddChange(changes.VehicleRotationParam, fp);

+        }

+

+        public override void VehicleFlags(int param, bool value)

+        {

+            strVehicleBoolParam bp = new strVehicleBoolParam();

+            bp.param = param;

+            bp.value = value;

+            AddChange(changes.VehicleFlags, bp);

+        }

+

+        public override void SetVehicle(object vdata)

+        {

+            AddChange(changes.SetVehicle, vdata);

+        }

+        public void SetAcceleration(Vector3 accel)

+        {

+            _acceleration = accel;

+        }

+

+        public override void AddForce(Vector3 force, bool pushforce)

+        {

+            if (force.IsFinite())

+            {

+                if(pushforce)

+                    AddChange(changes.AddForce, force);

+                else // a impulse

+                    AddChange(changes.AddForce, force * m_invTimeStep);

+            }

+            else

+            {

+                m_log.WarnFormat("[PHYSICS]: Got Invalid linear force vector from Scene in Object {0}", Name);

+            }

+            //m_log.Info("[PHYSICS]: Added Force:" + force.ToString() +  " to prim at " + Position.ToString());

+        }

+

+        public override void AddAngularForce(Vector3 force, bool pushforce)

+        {

+            if (force.IsFinite())

+            {

+//                if(pushforce)  for now applyrotationimpulse seems more happy applied as a force

+                    AddChange(changes.AddAngForce, force);

+//                else // a impulse

+//                    AddChange(changes.AddAngForce, force * m_invTimeStep);

+            }

+            else

+            {

+                m_log.WarnFormat("[PHYSICS]: Got Invalid Angular force vector from Scene in Object {0}", Name);

+            }

+        }

+

+        public override void CrossingFailure()

+        {

+            if (m_outbounds)

+            {

+                _position.X = Util.Clip(_position.X, 0.5f, _parent_scene.WorldExtents.X - 0.5f);

+                _position.Y = Util.Clip(_position.Y, 0.5f, _parent_scene.WorldExtents.Y - 0.5f);

+                _position.Z = Util.Clip(_position.Z + 0.2f, -100f, 50000f);

+

+                m_lastposition = _position;

+                _velocity.X = 0;

+                _velocity.Y = 0;

+                _velocity.Z = 0;

+

+                m_lastVelocity = _velocity;

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

+                    m_vehicle.Stop();

+

+                if(Body != IntPtr.Zero)

+                    d.BodySetLinearVel(Body, 0, 0, 0); // stop it

+                if (prim_geom != IntPtr.Zero)

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

+

+                m_outbounds = false;

+                changeDisable(false);

+                base.RequestPhysicsterseUpdate();

+            }

+        }

+

+        public override void SetMomentum(Vector3 momentum)

+        {

+        }

+

+        public override void SetMaterial(int pMaterial)

+        {

+            m_material = pMaterial;

+            mu = _parent_scene.m_materialContactsData[pMaterial].mu;

+            bounce = _parent_scene.m_materialContactsData[pMaterial].bounce;

+        }

+

+        public override float Density

+        {

+            get

+            {

+                return m_density * 100f;

+            }

+            set

+            {

+                m_density = value / 100f;

+                // for not prim mass is not updated since this implies full rebuild of body inertia TODO

+            }

+        }

+        public override float GravModifier

+        {

+            get

+            {

+                return m_gravmod;

+            }

+            set

+            {

+                m_gravmod = value;

+                if (m_vehicle != null)

+                    m_vehicle.GravMod = m_gravmod;

+            }

+        }

+        public override float Friction

+        {

+            get

+            {

+                return mu;

+            }

+            set

+            {

+                mu = value;

+            }

+        }

+

+        public override float Restitution

+        {

+            get

+            {

+                return bounce;

+            }

+            set

+            {

+                bounce = value;

+            }

+        }

+

+        public void setPrimForRemoval()

+        {

+            AddChange(changes.Remove, null);

+        }

+

+        public override void link(PhysicsActor obj)

+        {

+            AddChange(changes.Link, obj);

+        }

+

+        public override void delink()

+        {

+            AddChange(changes.DeLink, null);

+        }

+

+        public override void LockAngularMotion(Vector3 axis)

+        {

+            // reverse the zero/non zero values for ODE.

+            if (axis.IsFinite())

+            {

+                axis.X = (axis.X > 0) ? 1f : 0f;

+                axis.Y = (axis.Y > 0) ? 1f : 0f;

+                axis.Z = (axis.Z > 0) ? 1f : 0f;

+//                m_log.DebugFormat("[axislock]: <{0},{1},{2}>", axis.X, axis.Y, axis.Z);

+                AddChange(changes.AngLock, axis);

+            }

+            else

+            {

+                m_log.WarnFormat("[PHYSICS]: Got NaN locking axis from Scene on Object {0}", Name);

+            }

+        }

+

+        public override void SubscribeEvents(int ms)

+        {

+            m_eventsubscription = ms;

+            m_cureventsubscription = 0;

+            if (CollisionEventsThisFrame == null)

+                CollisionEventsThisFrame = new CollisionEventUpdate();

+            SentEmptyCollisionsEvent = false;

+        }

+

+        public override void UnSubscribeEvents()

+        {

+            if (CollisionEventsThisFrame != null)

+            {

+                CollisionEventsThisFrame.Clear();

+                CollisionEventsThisFrame = null;

+            }

+            m_eventsubscription = 0;

+           _parent_scene.RemoveCollisionEventReporting(this);

+        }

+

+        public override void AddCollisionEvent(uint CollidedWith, ContactPoint contact)

+        {

+            if (CollisionEventsThisFrame == null)

+                CollisionEventsThisFrame = new CollisionEventUpdate();

+//            if(CollisionEventsThisFrame.Count < 32)

+                CollisionEventsThisFrame.AddCollider(CollidedWith, contact);

+        }

+

+        public void SendCollisions()

+        {

+            if (CollisionEventsThisFrame == null)

+                return;

+

+            if (m_cureventsubscription < m_eventsubscription)

+                return;

+

+            m_cureventsubscription = 0;

+

+            int ncolisions = CollisionEventsThisFrame.m_objCollisionList.Count;

+

+            if (!SentEmptyCollisionsEvent || ncolisions > 0)

+            {

+                base.SendCollisionUpdate(CollisionEventsThisFrame);

+

+                if (ncolisions == 0)

+                {

+                    SentEmptyCollisionsEvent = true;

+                    _parent_scene.RemoveCollisionEventReporting(this);

+                }

+                else

+                {

+                    SentEmptyCollisionsEvent = false;

+                    CollisionEventsThisFrame.Clear();

+                }

+            }           

+        }

+

+        internal void AddCollisionFrameTime(int t)

+        {

+            if (m_cureventsubscription < 50000)

+                m_cureventsubscription += t;

+        }

+

+        public override bool SubscribedEvents()

+        {

+            if (m_eventsubscription > 0)

+                return true;

+            return false;

+        }

+

+        public OdePrim(String primName, OdeScene parent_scene, Vector3 pos, Vector3 size,

+                       Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical,bool pisPhantom,byte _shapeType,uint plocalID)

+        {

+            Name = primName;

+            LocalID = plocalID;

+

+            m_vehicle = null;

+

+            if (!pos.IsFinite())

+            {

+                pos = new Vector3(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f),

+                    parent_scene.GetTerrainHeightAtXY(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f)) + 0.5f);

+                m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Position for {0}", Name);

+            }

+            _position = pos;

+            givefakepos = 0;

+

+            m_timeStep = parent_scene.ODE_STEPSIZE;

+            m_invTimeStep = 1f / m_timeStep;

+

+            m_density = parent_scene.geomDefaultDensity;

+            body_autodisable_frames = parent_scene.bodyFramesAutoDisable;

+

+            prim_geom = IntPtr.Zero;

+            collide_geom = IntPtr.Zero;

+            Body = IntPtr.Zero;

+

+            if (!size.IsFinite())

+            {

+                size = new Vector3(0.5f, 0.5f, 0.5f);

+                m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Size for {0}", Name);

+            }

+

+            if (size.X <= 0) size.X = 0.01f;

+            if (size.Y <= 0) size.Y = 0.01f;

+            if (size.Z <= 0) size.Z = 0.01f;

+

+            _size = size;

+

+            if (!QuaternionIsFinite(rotation))

+            {

+                rotation = Quaternion.Identity;

+                m_log.WarnFormat("[PHYSICS]: Got nonFinite Object create Rotation for {0}", Name);

+            }

+

+            _orientation = rotation;

+            givefakeori = 0;

+

+            _pbs = pbs;

+

+            _parent_scene = parent_scene;

+            m_targetSpace = IntPtr.Zero;

+

+            if (pos.Z < 0)

+            {

+                m_isphysical = false;

+            }

+            else

+            {

+                m_isphysical = pisPhysical;

+            }

+            m_fakeisphysical = m_isphysical;

+

+            m_isVolumeDetect = false;

+            m_fakeisVolumeDetect = false;

+

+            m_force = Vector3.Zero;

+

+            m_iscolliding = false;

+            m_colliderfilter = 0;

+            m_NoColide = false;

+

+            _triMeshData = IntPtr.Zero;

+

+            m_shapetype = _shapeType;

+

+            m_lastdoneSelected = false;

+            m_isSelected = false;

+            m_delaySelect = false;

+

+            m_isphantom = pisPhantom;

+            m_fakeisphantom = pisPhantom;

+

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

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

+

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

+

+            // get basic mass parameters

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

+

+            primVolume = repData.volume;

+            m_OBB = repData.OBB;

+            m_OBBOffset = repData.OBBOffset;

+

+            UpdatePrimBodyData();

+        }

+

+        private void resetCollisionAccounting()

+        {

+            m_collisionscore = 0;

+        }

+

+        private void UpdateCollisionCatFlags()

+        {

+            if(m_isphysical && m_disabled)

+            {

+                m_collisionCategories = 0;

+                m_collisionFlags = 0;

+            }

+

+            else if (m_isSelected)

+            {

+                m_collisionCategories = CollisionCategories.Selected;

+                m_collisionFlags = 0;

+            }

+

+            else if (m_isVolumeDetect)

+            {

+                m_collisionCategories = CollisionCategories.VolumeDtc;

+                if (m_isphysical)

+                    m_collisionFlags = CollisionCategories.Geom | CollisionCategories.Character;

+                else

+                    m_collisionFlags = 0;

+            }

+            else if (m_isphantom)

+            {

+                m_collisionCategories = CollisionCategories.Phantom;

+                if (m_isphysical)

+                    m_collisionFlags = CollisionCategories.Land;

+                else

+                    m_collisionFlags = 0;

+            }

+            else

+            {

+                m_collisionCategories = CollisionCategories.Geom;

+                if (m_isphysical)

+                    m_collisionFlags = m_default_collisionFlagsPhysical;

+                else

+                    m_collisionFlags = m_default_collisionFlagsNotPhysical;

+            }

+        }

+

+        private void ApplyCollisionCatFlags()

+        {

+            if (prim_geom != IntPtr.Zero)

+            {

+                if (!childPrim && childrenPrim.Count > 0)

+                {

+                    foreach (OdePrim prm in childrenPrim)

+                    {

+                        if (m_isphysical && m_disabled)

+                        {

+                            prm.m_collisionCategories = 0;

+                            prm.m_collisionFlags = 0;

+                        }

+                        else

+                        {

+                            // preserve some

+                            if (prm.m_isSelected)

+                            {

+                                prm.m_collisionCategories = CollisionCategories.Selected;

+                                prm.m_collisionFlags = 0;

+                            }

+                            else if (prm.m_isVolumeDetect)

+                            {

+                                prm.m_collisionCategories = CollisionCategories.VolumeDtc;

+                                if (m_isphysical)

+                                    prm.m_collisionFlags = CollisionCategories.Geom | CollisionCategories.Character;

+                                else

+                                    prm.m_collisionFlags = 0;

+                            }

+                            else if (prm.m_isphantom)

+                            {

+                                prm.m_collisionCategories = CollisionCategories.Phantom;

+                                if (m_isphysical)

+                                    prm.m_collisionFlags = CollisionCategories.Land;

+                                else

+                                    prm.m_collisionFlags = 0;

+                            }

+                            else

+                            {

+                                prm.m_collisionCategories = m_collisionCategories;

+                                prm.m_collisionFlags = m_collisionFlags;

+                            }

+                        }

+

+                        if (prm.prim_geom != IntPtr.Zero)

+                        {

+                            if (prm.m_NoColide)

+                            {

+                                d.GeomSetCategoryBits(prm.prim_geom, 0);

+                                if (m_isphysical)

+                                    d.GeomSetCollideBits(prm.prim_geom, (int)CollisionCategories.Land);

+                                else

+                                    d.GeomSetCollideBits(prm.prim_geom, 0);

+                            }

+                            else

+                            {

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

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

+                            }

+                        }

+                    }

+                }

+

+                if (m_NoColide)

+                {

+                    d.GeomSetCategoryBits(prim_geom, 0);

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

+                    if (collide_geom != prim_geom && collide_geom != IntPtr.Zero)

+                    {

+                        d.GeomSetCategoryBits(collide_geom, 0);

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

+                    }

+                }

+                else

+                {

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

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

+                    if (collide_geom != prim_geom && collide_geom != IntPtr.Zero)

+                    {

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

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

+                    }

+                }

+            }

+        }

+

+        private void createAMotor(Vector3 axis)

+        {

+            if (Body == IntPtr.Zero)

+                return;

+

+            if (Amotor != IntPtr.Zero)

+            {

+                d.JointDestroy(Amotor);

+                Amotor = IntPtr.Zero;

+            }

+

+            int axisnum = 3 - (int)(axis.X + axis.Y + axis.Z);

+

+            if (axisnum <= 0)

+                return;

+

+            // stop it

+            d.BodySetTorque(Body, 0, 0, 0);

+            d.BodySetAngularVel(Body, 0, 0, 0);

+

+            Amotor = d.JointCreateAMotor(_parent_scene.world, IntPtr.Zero);

+            d.JointAttach(Amotor, Body, IntPtr.Zero);

+

+            d.JointSetAMotorMode(Amotor, 0);

+

+            d.JointSetAMotorNumAxes(Amotor, axisnum);

+

+            // get current orientation to lock

+

+            d.Quaternion dcur = d.BodyGetQuaternion(Body);

+            Quaternion curr; // crap convertion between identical things

+            curr.X = dcur.X;

+            curr.Y = dcur.Y;

+            curr.Z = dcur.Z;

+            curr.W = dcur.W;

+            Vector3 ax;

+

+            int i = 0;

+            int j = 0;

+            if (axis.X == 0)

+            {

+                ax = (new Vector3(1, 0, 0)) * curr; // rotate world X to current local X

+                // ODE should do this  with axis relative to body 1 but seems to fail

+                d.JointSetAMotorAxis(Amotor, 0, 0, ax.X, ax.Y, ax.Z);

+                d.JointSetAMotorAngle(Amotor, 0, 0);

+                d.JointSetAMotorParam(Amotor, (int)d.JointParam.LoStop, 0f);

+                d.JointSetAMotorParam(Amotor, (int)d.JointParam.HiStop, 0f);

+                d.JointSetAMotorParam(Amotor, (int)d.JointParam.Vel, 0);

+                d.JointSetAMotorParam(Amotor, (int)d.JointParam.FudgeFactor, 0.0001f);

+                d.JointSetAMotorParam(Amotor, (int)d.JointParam.Bounce, 0f);

+                d.JointSetAMotorParam(Amotor, (int)d.JointParam.FMax, 5e8f);

+                d.JointSetAMotorParam(Amotor, (int)d.JointParam.StopCFM, 0f);

+                d.JointSetAMotorParam(Amotor, (int)d.JointParam.StopERP, 0.8f);

+                i++;

+                j = 256; // move to next axis set

+            }

+

+            if (axis.Y == 0)

+            {

+                ax = (new Vector3(0, 1, 0)) * curr;

+                d.JointSetAMotorAxis(Amotor, i, 0, ax.X, ax.Y, ax.Z);

+                d.JointSetAMotorAngle(Amotor, i, 0);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.LoStop, 0f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.HiStop, 0f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Vel, 0);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FudgeFactor, 0.0001f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Bounce, 0f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FMax, 5e8f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopCFM, 0f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopERP, 0.8f);

+                i++;

+                j += 256;

+            }

+

+            if (axis.Z == 0)

+            {

+                ax = (new Vector3(0, 0, 1)) * curr;

+                d.JointSetAMotorAxis(Amotor, i, 0, ax.X, ax.Y, ax.Z);

+                d.JointSetAMotorAngle(Amotor, i, 0);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.LoStop, 0f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.HiStop, 0f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Vel, 0);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FudgeFactor, 0.0001f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.Bounce, 0f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.FMax, 5e8f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopCFM, 0f);

+                d.JointSetAMotorParam(Amotor, j + (int)d.JointParam.StopERP, 0.8f);

+            }

+        }

+

+

+        private void SetGeom(IntPtr geom)

+        {

+            prim_geom = geom;

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

+            if (prim_geom != IntPtr.Zero)

+            {

+

+                if (m_NoColide)

+                {

+                    d.GeomSetCategoryBits(prim_geom, 0);

+                    if (m_isphysical)

+                    {

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

+                    }

+                    else

+                    {

+                        d.GeomSetCollideBits(prim_geom, 0);

+                        d.GeomDisable(prim_geom);

+                    }

+                }

+                else

+                {

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

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

+                }

+

+                UpdatePrimBodyData();

+                _parent_scene.actor_name_map[prim_geom] = this;

+

+/*

+// debug

+                d.AABB aabb;

+                d.GeomGetAABB(prim_geom, out aabb);

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

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

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

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

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

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

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

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

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

+

+//

+*/

+

+            }

+            else

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

+        }

+

+        private bool GetMeshGeom()

+        {

+            IntPtr vertices, indices;

+            int vertexCount, indexCount;

+            int vertexStride, triStride;

+            

+            IMesh mesh = m_mesh;

+

+            if (mesh == null)

+                return false;

+

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

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

+

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

+            {

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

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

+

+                m_hasOBB = false;

+                m_OBBOffset = Vector3.Zero;

+                m_OBB = _size * 0.5f;

+

+                m_physCost = 0.1f;

+                m_streamCost = 1.0f;

+

+                _parent_scene.mesher.ReleaseMesh(mesh);

+                m_meshState = MeshState.MeshFailed;

+                m_mesh = null;

+                return false;

+            }

+

+            IntPtr geo = IntPtr.Zero;

+

+            try

+            {

+                _triMeshData = d.GeomTriMeshDataCreate();

+

+                d.GeomTriMeshDataBuildSimple(_triMeshData, vertices, vertexStride, vertexCount, indices, indexCount, triStride);

+                d.GeomTriMeshDataPreprocess(_triMeshData);

+

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

+            }

+

+            catch (Exception e)

+            {

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

+                if (_triMeshData != IntPtr.Zero)

+                {

+                    try

+                    {

+                        d.GeomTriMeshDataDestroy(_triMeshData);

+                    }

+                    catch

+                    {

+                    }

+                }

+                _triMeshData = IntPtr.Zero;

+

+                m_hasOBB = false;

+                m_OBBOffset = Vector3.Zero;

+                m_OBB = _size * 0.5f;

+                m_physCost = 0.1f;

+                m_streamCost = 1.0f;

+              

+                _parent_scene.mesher.ReleaseMesh(mesh);

+                m_meshState = MeshState.MeshFailed;

+                m_mesh = null;

+                return false;

+            }

+

+            m_physCost = 0.0013f * (float)indexCount;

+            // todo

+            m_streamCost = 1.0f;

+

+            SetGeom(geo);

+

+            return true;

+        }

+

+        private void CreateGeom()

+        {

+            bool hasMesh = false;

+

+            m_NoColide = false;

+

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

+                m_NoColide = true;

+

+            else if(m_mesh != null)

+            {

+                if (GetMeshGeom())

+                    hasMesh = true;

+                else

+                    m_NoColide = true;

+            }

+

+

+            if (!hasMesh)

+            {

+                IntPtr geo = IntPtr.Zero;

+

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

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

+                { // it's a sphere

+                    try

+                    {

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

+                    }

+                    catch (Exception e)

+                    {

+                        m_log.WarnFormat("[PHYSICS]: Create sphere failed: {0}", e);

+                        return;

+                    }

+                }

+                else

+                {// do it as a box

+                    try

+                    {

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

+                    }

+                    catch (Exception e)

+                    {

+                        m_log.Warn("[PHYSICS]: Create box failed: {0}", e);

+                        return;

+                    }

+                }

+                m_physCost = 0.1f;

+                m_streamCost = 1.0f;

+                SetGeom(geo);

+            }

+        }

+

+        private void RemoveGeom()

+        {

+            if (prim_geom != IntPtr.Zero)

+            {

+                _parent_scene.actor_name_map.Remove(prim_geom);

+

+                try

+                {

+                    d.GeomDestroy(prim_geom);

+                    if (_triMeshData != IntPtr.Zero)

+                    {

+                        d.GeomTriMeshDataDestroy(_triMeshData);

+                        _triMeshData = IntPtr.Zero;

+                    }

+                }

+                catch (Exception e)

+                {

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

+                }

+

+                prim_geom = IntPtr.Zero;

+                collide_geom = IntPtr.Zero;

+                m_targetSpace = IntPtr.Zero;

+            }

+            else

+            {

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

+            }

+

+            lock (m_meshlock)

+            {

+                if (m_mesh != null)

+                {

+                    _parent_scene.mesher.ReleaseMesh(m_mesh);

+                    m_mesh = null;

+                }

+            }

+

+            Body = IntPtr.Zero;

+            m_hasOBB = false;

+        }

+

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

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

+        private void SetInStaticSpace(OdePrim prim)

+        {

+            IntPtr targetSpace = _parent_scene.MoveGeomToStaticSpace(prim.prim_geom, prim._position, prim.m_targetSpace);

+            prim.m_targetSpace = targetSpace;

+            collide_geom = IntPtr.Zero;

+        }

+

+        public void enableBodySoft()

+        {

+            m_disabled = false;

+            if (!childPrim && !m_isSelected)

+            {

+                if (m_isphysical && Body != IntPtr.Zero)

+                {

+                    UpdateCollisionCatFlags();

+                    ApplyCollisionCatFlags();

+

+                    d.BodyEnable(Body);

+                }

+            }

+            resetCollisionAccounting();

+        }

+

+        private void disableBodySoft()

+        {

+            m_disabled = true;

+            if (!childPrim)

+            {

+                if (m_isphysical && Body != IntPtr.Zero)

+                {

+                    if (m_isSelected)

+                        m_collisionFlags = CollisionCategories.Selected;

+                    else

+                        m_collisionCategories = 0;

+                    m_collisionFlags = 0;

+                    ApplyCollisionCatFlags();

+                    d.BodyDisable(Body);

+                }

+            }

+        }

+

+        private void MakeBody()

+        {

+            if (!m_isphysical) // only physical get bodies

+                return;

+

+            if (childPrim)  // child prims don't get bodies;

+                return;

+

+            if (m_building)

+                return;

+

+            if (prim_geom == IntPtr.Zero)

+            {

+                m_log.Warn("[PHYSICS]: Unable to link the linkset.  Root has no geom yet");

+                return;

+            }

+

+            if (Body != IntPtr.Zero)

+            {

+                DestroyBody();

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

+            }

+

+            if (d.GeomGetBody(prim_geom) != IntPtr.Zero)

+            {

+                d.GeomSetBody(prim_geom, IntPtr.Zero);

+                m_log.Warn("[PHYSICS]: MakeBody root geom already had a body");

+            }

+

+            d.Matrix3 mymat = new d.Matrix3();

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

+            d.Mass objdmass = new d.Mass { };

+

+            Body = d.BodyCreate(_parent_scene.world);

+

+            objdmass = primdMass;

+

+            // rotate inertia

+            myrot.X = _orientation.X;

+            myrot.Y = _orientation.Y;

+            myrot.Z = _orientation.Z;

+            myrot.W = _orientation.W;

+

+            d.RfromQ(out mymat, ref myrot);

+            d.MassRotate(ref objdmass, ref mymat);

+

+            // set the body rotation

+            d.BodySetRotation(Body, ref mymat);

+

+            // recompute full object inertia if needed

+            if (childrenPrim.Count > 0)

+            {

+                d.Matrix3 mat = new d.Matrix3();

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

+                d.Mass tmpdmass = new d.Mass { };

+                Vector3 rcm;

+

+                rcm.X = _position.X;

+                rcm.Y = _position.Y;

+                rcm.Z = _position.Z;

+

+                lock (childrenPrim)

+                {

+                    foreach (OdePrim prm in childrenPrim)

+                    {

+                        if (prm.prim_geom == IntPtr.Zero)

+                        {

+                            m_log.Warn("[PHYSICS]: Unable to link one of the linkset elements, skipping it.  No geom yet");

+                            continue;

+                        }

+

+                        tmpdmass = prm.primdMass;

+

+                        // apply prim current rotation to inertia

+                        quat.X = prm._orientation.X;

+                        quat.Y = prm._orientation.Y;

+                        quat.Z = prm._orientation.Z;

+                        quat.W = prm._orientation.W;

+                        d.RfromQ(out mat, ref quat);

+                        d.MassRotate(ref tmpdmass, ref mat);

+

+                        Vector3 ppos = prm._position;

+                        ppos.X -= rcm.X;

+                        ppos.Y -= rcm.Y;

+                        ppos.Z -= rcm.Z;

+                        // refer inertia to root prim center of mass position

+                        d.MassTranslate(ref tmpdmass,

+                            ppos.X,

+                            ppos.Y,

+                            ppos.Z);

+

+                        d.MassAdd(ref objdmass, ref tmpdmass); // add to total object inertia

+                        // fix prim colision cats

+

+                        if (d.GeomGetBody(prm.prim_geom) != IntPtr.Zero)

+                        {

+                            d.GeomSetBody(prm.prim_geom, IntPtr.Zero);

+                            m_log.Warn("[PHYSICS]: MakeBody child geom already had a body");

+                        }

+

+                        d.GeomClearOffset(prm.prim_geom);

+                        d.GeomSetBody(prm.prim_geom, Body);

+                        prm.Body = Body;

+                        d.GeomSetOffsetWorldRotation(prm.prim_geom, ref mat); // set relative rotation

+                    }

+                }

+            }

+

+            d.GeomClearOffset(prim_geom); // make sure we don't have a hidden offset

+            // associate root geom with body

+            d.GeomSetBody(prim_geom, Body);

+

+            d.BodySetPosition(Body, _position.X + objdmass.c.X, _position.Y + objdmass.c.Y, _position.Z + objdmass.c.Z);

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

+

+            d.MassTranslate(ref objdmass, -objdmass.c.X, -objdmass.c.Y, -objdmass.c.Z); // ode wants inertia at center of body

+            myrot.X = -myrot.X;

+            myrot.Y = -myrot.Y;

+            myrot.Z = -myrot.Z;

+

+            d.RfromQ(out mymat, ref myrot);

+            d.MassRotate(ref objdmass, ref mymat);

+

+            d.BodySetMass(Body, ref objdmass);

+            _mass = objdmass.mass;

+

+            // disconnect from world gravity so we can apply buoyancy

+            d.BodySetGravityMode(Body, false);

+

+            d.BodySetAutoDisableFlag(Body, true);

+            d.BodySetAutoDisableSteps(Body, body_autodisable_frames);

+            d.BodySetAutoDisableAngularThreshold(Body, 0.01f);

+            d.BodySetAutoDisableLinearThreshold(Body, 0.01f);

+            d.BodySetDamping(Body, .005f, .001f);

+

+            if (m_targetSpace != IntPtr.Zero)

+            {

+                _parent_scene.waitForSpaceUnlock(m_targetSpace);

+                if (d.SpaceQuery(m_targetSpace, prim_geom))

+                    d.SpaceRemove(m_targetSpace, prim_geom);

+            }

+

+            if (childrenPrim.Count == 0)

+            {

+                collide_geom = prim_geom;

+                m_targetSpace = _parent_scene.ActiveSpace;               

+            }

+            else

+            {

+                m_targetSpace = d.HashSpaceCreate(_parent_scene.ActiveSpace);

+                d.HashSpaceSetLevels(m_targetSpace, -2, 8);

+                d.SpaceSetSublevel(m_targetSpace, 3);

+                d.SpaceSetCleanup(m_targetSpace, false);

+

+                d.GeomSetCategoryBits(m_targetSpace, (uint)(CollisionCategories.Space |

+                                                            CollisionCategories.Geom |

+                                                            CollisionCategories.Phantom |

+                                                            CollisionCategories.VolumeDtc

+                                                            ));

+                d.GeomSetCollideBits(m_targetSpace, 0);

+                collide_geom = m_targetSpace;

+            }

+

+            d.SpaceAdd(m_targetSpace, prim_geom);

+

+            if (m_delaySelect)

+            {

+                m_isSelected = true;

+                m_delaySelect = false;

+            }

+

+            m_collisionscore = 0;

+

+            UpdateCollisionCatFlags();

+            ApplyCollisionCatFlags();

+

+            _parent_scene.addActivePrim(this);

+

+            lock (childrenPrim)

+            {

+                foreach (OdePrim prm in childrenPrim)

+                {

+                    if (prm.prim_geom == IntPtr.Zero)

+                        continue;

+

+                    Vector3 ppos = prm._position;

+                    d.GeomSetOffsetWorldPosition(prm.prim_geom, ppos.X, ppos.Y, ppos.Z); // set relative position

+

+                    if (prm.m_targetSpace != m_targetSpace)

+                    {

+                        if (prm.m_targetSpace != IntPtr.Zero)

+                        {

+                            _parent_scene.waitForSpaceUnlock(prm.m_targetSpace);

+                            if (d.SpaceQuery(prm.m_targetSpace, prm.prim_geom))

+                                d.SpaceRemove(prm.m_targetSpace, prm.prim_geom);

+                        }

+                        prm.m_targetSpace = m_targetSpace;

+                        d.SpaceAdd(m_targetSpace, prm.prim_geom);

+                    }

+

+                    prm.m_collisionscore = 0;

+

+                    if(!m_disabled)

+                        prm.m_disabled = false;

+

+                    _parent_scene.addActivePrim(prm);

+                }

+            }

+

+            // The body doesn't already have a finite rotation mode set here

+            if ((!m_angularlock.ApproxEquals(Vector3.One, 0.0f)) && _parent == null)

+            {

+                createAMotor(m_angularlock);

+            }

+

+

+            if (m_isSelected || m_disabled)

+            {

+                d.BodyDisable(Body);

+            }

+            else

+            {

+                d.BodySetAngularVel(Body, m_rotationalVelocity.X, m_rotationalVelocity.Y, m_rotationalVelocity.Z);

+                d.BodySetLinearVel(Body, _velocity.X, _velocity.Y, _velocity.Z);

+            }               

+            _parent_scene.addActiveGroups(this);

+        }

+

+        private void DestroyBody()

+        {

+            if (Body != IntPtr.Zero)

+            {

+                _parent_scene.remActivePrim(this);

+

+                collide_geom = IntPtr.Zero;

+

+                if (m_disabled)

+                    m_collisionCategories = 0;

+                else if (m_isSelected)

+                    m_collisionCategories = CollisionCategories.Selected;

+                else if (m_isVolumeDetect)

+                    m_collisionCategories = CollisionCategories.VolumeDtc;

+                else if (m_isphantom)

+                    m_collisionCategories = CollisionCategories.Phantom;

+                else

+                    m_collisionCategories = CollisionCategories.Geom;

+

+                m_collisionFlags = 0;

+

+                if (prim_geom != IntPtr.Zero)

+                {

+                    if (m_NoColide)

+                    {

+                        d.GeomSetCategoryBits(prim_geom, 0);

+                        d.GeomSetCollideBits(prim_geom, 0);

+                    }

+                    else

+                    {

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

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

+                    }

+                    UpdateDataFromGeom();

+                    d.GeomSetBody(prim_geom, IntPtr.Zero);

+                    SetInStaticSpace(this);

+                }

+

+                if (!childPrim)

+                {

+                    lock (childrenPrim)

+                    {

+                        foreach (OdePrim prm in childrenPrim)

+                        {

+                            _parent_scene.remActivePrim(prm);

+

+                            if (prm.m_isSelected)

+                                prm.m_collisionCategories = CollisionCategories.Selected;

+                            else if (prm.m_isVolumeDetect)

+                                prm.m_collisionCategories = CollisionCategories.VolumeDtc;

+                            else if (prm.m_isphantom)

+                                prm.m_collisionCategories = CollisionCategories.Phantom;

+                            else

+                                prm.m_collisionCategories = CollisionCategories.Geom;

+

+                            prm.m_collisionFlags = 0;

+

+                            if (prm.prim_geom != IntPtr.Zero)

+                            {

+                                if (prm.m_NoColide)

+                                {

+                                    d.GeomSetCategoryBits(prm.prim_geom, 0);

+                                    d.GeomSetCollideBits(prm.prim_geom, 0);

+                                }

+                                else

+                                {

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

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

+                                }

+                                prm.UpdateDataFromGeom();

+                                SetInStaticSpace(prm);

+                            }

+                            prm.Body = IntPtr.Zero;

+                            prm._mass = prm.primMass;

+                            prm.m_collisionscore = 0;

+                        }

+                    }

+                    if (Amotor != IntPtr.Zero)

+                    {

+                        d.JointDestroy(Amotor);

+                        Amotor = IntPtr.Zero;

+                    }

+                    _parent_scene.remActiveGroup(this);

+                    d.BodyDestroy(Body);

+                }

+                Body = IntPtr.Zero;

+            }

+            _mass = primMass;

+            m_collisionscore = 0;

+        }

+

+        private void FixInertia(Vector3 NewPos,Quaternion newrot)

+        {

+            d.Matrix3 mat = new d.Matrix3();

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

+

+            d.Mass tmpdmass = new d.Mass { };         

+            d.Mass objdmass = new d.Mass { };

+

+            d.BodyGetMass(Body, out tmpdmass);

+            objdmass = tmpdmass;

+

+            d.Vector3 dobjpos;

+            d.Vector3 thispos;

+

+            // get current object position and rotation

+            dobjpos = d.BodyGetPosition(Body);

+

+            // get prim own inertia in its local frame

+            tmpdmass = primdMass;

+

+            // transform to object frame

+            mat = d.GeomGetOffsetRotation(prim_geom);

+            d.MassRotate(ref tmpdmass, ref mat);

+

+            thispos = d.GeomGetOffsetPosition(prim_geom);

+            d.MassTranslate(ref tmpdmass,

+                            thispos.X,

+                            thispos.Y,

+                            thispos.Z);

+

+            // subtract current prim inertia from object

+            DMassSubPartFromObj(ref tmpdmass, ref objdmass);

+

+            // back prim own inertia 

+            tmpdmass = primdMass;

+

+            // update to new position and orientation

+            _position = NewPos;

+            d.GeomSetOffsetWorldPosition(prim_geom, NewPos.X, NewPos.Y, NewPos.Z);

+            _orientation = newrot;

+            quat.X = newrot.X;

+            quat.Y = newrot.Y;

+            quat.Z = newrot.Z;

+            quat.W = newrot.W;

+            d.GeomSetOffsetWorldQuaternion(prim_geom, ref quat);

+

+            mat = d.GeomGetOffsetRotation(prim_geom);

+            d.MassRotate(ref tmpdmass, ref mat);

+

+            thispos = d.GeomGetOffsetPosition(prim_geom);

+            d.MassTranslate(ref tmpdmass,

+                            thispos.X,

+                            thispos.Y,

+                            thispos.Z);

+

+            d.MassAdd(ref objdmass, ref tmpdmass);

+

+            // fix all positions

+            IntPtr g = d.BodyGetFirstGeom(Body);

+            while (g != IntPtr.Zero)

+            {

+                thispos = d.GeomGetOffsetPosition(g);

+                thispos.X -= objdmass.c.X;

+                thispos.Y -= objdmass.c.Y;

+                thispos.Z -= objdmass.c.Z;

+                d.GeomSetOffsetPosition(g, thispos.X, thispos.Y, thispos.Z);

+                g = d.dBodyGetNextGeom(g);

+            }

+            d.BodyVectorToWorld(Body,objdmass.c.X, objdmass.c.Y, objdmass.c.Z,out thispos);

+

+            d.BodySetPosition(Body, dobjpos.X + thispos.X, dobjpos.Y + thispos.Y, dobjpos.Z + thispos.Z);

+            d.MassTranslate(ref objdmass, -objdmass.c.X, -objdmass.c.Y, -objdmass.c.Z); // ode wants inertia at center of body

+            d.BodySetMass(Body, ref objdmass);

+            _mass = objdmass.mass;

+        }

+

+

+

+        private void FixInertia(Vector3 NewPos)

+        {

+            d.Matrix3 primmat = new d.Matrix3();

+            d.Mass tmpdmass = new d.Mass { };

+            d.Mass objdmass = new d.Mass { };

+            d.Mass primmass = new d.Mass { };

+

+            d.Vector3 dobjpos;

+            d.Vector3 thispos;

+

+            d.BodyGetMass(Body, out objdmass);

+

+            // get prim own inertia in its local frame

+            primmass = primdMass;

+            // transform to object frame

+            primmat = d.GeomGetOffsetRotation(prim_geom);

+            d.MassRotate(ref primmass, ref primmat);

+

+            tmpdmass = primmass;

+

+            thispos = d.GeomGetOffsetPosition(prim_geom);

+            d.MassTranslate(ref tmpdmass,

+                            thispos.X,

+                            thispos.Y,

+                            thispos.Z);

+

+            // subtract current prim inertia from object

+            DMassSubPartFromObj(ref tmpdmass, ref objdmass);

+

+            // update to new position

+            _position = NewPos;

+            d.GeomSetOffsetWorldPosition(prim_geom, NewPos.X, NewPos.Y, NewPos.Z);

+

+            thispos = d.GeomGetOffsetPosition(prim_geom);

+            d.MassTranslate(ref primmass,

+                            thispos.X,

+                            thispos.Y,

+                            thispos.Z);

+

+            d.MassAdd(ref objdmass, ref primmass);

+

+            // fix all positions

+            IntPtr g = d.BodyGetFirstGeom(Body);

+            while (g != IntPtr.Zero)

+            {

+                thispos = d.GeomGetOffsetPosition(g);

+                thispos.X -= objdmass.c.X;

+                thispos.Y -= objdmass.c.Y;

+                thispos.Z -= objdmass.c.Z;

+                d.GeomSetOffsetPosition(g, thispos.X, thispos.Y, thispos.Z);

+                g = d.dBodyGetNextGeom(g);

+            }

+

+            d.BodyVectorToWorld(Body, objdmass.c.X, objdmass.c.Y, objdmass.c.Z, out thispos);

+

+            // get current object position and rotation

+            dobjpos = d.BodyGetPosition(Body);

+

+            d.BodySetPosition(Body, dobjpos.X + thispos.X, dobjpos.Y + thispos.Y, dobjpos.Z + thispos.Z);

+            d.MassTranslate(ref objdmass, -objdmass.c.X, -objdmass.c.Y, -objdmass.c.Z); // ode wants inertia at center of body

+            d.BodySetMass(Body, ref objdmass);

+            _mass = objdmass.mass;

+        }

+

+        private void FixInertia(Quaternion newrot)

+        {

+            d.Matrix3 mat = new d.Matrix3();

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

+

+            d.Mass tmpdmass = new d.Mass { };

+            d.Mass objdmass = new d.Mass { };

+            d.Vector3 dobjpos;

+            d.Vector3 thispos;

+

+            d.BodyGetMass(Body, out objdmass);

+

+            // get prim own inertia in its local frame

+            tmpdmass = primdMass;

+            mat = d.GeomGetOffsetRotation(prim_geom);

+            d.MassRotate(ref tmpdmass, ref mat);

+            // transform to object frame

+            thispos = d.GeomGetOffsetPosition(prim_geom);

+            d.MassTranslate(ref tmpdmass,

+                            thispos.X,

+                            thispos.Y,

+                            thispos.Z);

+

+            // subtract current prim inertia from object

+            DMassSubPartFromObj(ref tmpdmass, ref objdmass);

+

+            // update to new orientation

+            _orientation = newrot;

+            quat.X = newrot.X;

+            quat.Y = newrot.Y;

+            quat.Z = newrot.Z;

+            quat.W = newrot.W;

+            d.GeomSetOffsetWorldQuaternion(prim_geom, ref quat);

+

+            tmpdmass = primdMass;

+            mat = d.GeomGetOffsetRotation(prim_geom);

+            d.MassRotate(ref tmpdmass, ref mat);

+            d.MassTranslate(ref tmpdmass,

+                            thispos.X,

+                            thispos.Y,

+                            thispos.Z);

+

+            d.MassAdd(ref objdmass, ref tmpdmass);

+

+            // fix all positions

+            IntPtr g = d.BodyGetFirstGeom(Body);

+            while (g != IntPtr.Zero)

+            {

+                thispos = d.GeomGetOffsetPosition(g);

+                thispos.X -= objdmass.c.X;

+                thispos.Y -= objdmass.c.Y;

+                thispos.Z -= objdmass.c.Z;

+                d.GeomSetOffsetPosition(g, thispos.X, thispos.Y, thispos.Z);

+                g = d.dBodyGetNextGeom(g);

+            }

+

+            d.BodyVectorToWorld(Body, objdmass.c.X, objdmass.c.Y, objdmass.c.Z, out thispos);

+            // get current object position and rotation

+            dobjpos = d.BodyGetPosition(Body);

+

+            d.BodySetPosition(Body, dobjpos.X + thispos.X, dobjpos.Y + thispos.Y, dobjpos.Z + thispos.Z);

+            d.MassTranslate(ref objdmass, -objdmass.c.X, -objdmass.c.Y, -objdmass.c.Z); // ode wants inertia at center of body

+            d.BodySetMass(Body, ref objdmass);

+            _mass = objdmass.mass;

+        }

+

+

+        #region Mass Calculation

+

+        private void UpdatePrimBodyData()

+        {

+            primMass = m_density * primVolume;

+

+            if (primMass <= 0)

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

+            if (primMass > _parent_scene.maximumMassObject)

+                primMass = _parent_scene.maximumMassObject;

+

+            _mass = primMass; // just in case

+

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

+

+            d.MassTranslate(ref primdMass,

+                                m_OBBOffset.X,

+                                m_OBBOffset.Y,

+                                m_OBBOffset.Z);

+

+            primOOBradiusSQ = m_OBB.LengthSquared();

+

+            if (_triMeshData != IntPtr.Zero)

+            {

+                float pc = m_physCost;

+                float psf = primOOBradiusSQ;

+                psf *= 1.33f * .2f;

+                pc *= psf;

+                if (pc < 0.1f)

+                    pc = 0.1f;

+

+                m_physCost = pc;

+            }

+            else

+                m_physCost = 0.1f;

+

+            m_streamCost = 1.0f;

+        }

+

+        #endregion

+

+

+        /// <summary>

+        /// Add a child prim to this parent prim.

+        /// </summary>

+        /// <param name="prim">Child prim</param>

+        // I'm the parent

+        // prim is the child

+        public void ParentPrim(OdePrim prim)

+        {

+            //Console.WriteLine("ParentPrim  " + m_primName);

+            if (this.m_localID != prim.m_localID)

+            {

+                DestroyBody();  // for now we need to rebuil entire object on link change

+

+                lock (childrenPrim)

+                {

+                    // adopt the prim

+                    if (!childrenPrim.Contains(prim))

+                        childrenPrim.Add(prim);

+

+                    // see if this prim has kids and adopt them also

+                    // should not happen for now

+                    foreach (OdePrim prm in prim.childrenPrim)

+                    {

+                        if (!childrenPrim.Contains(prm))

+                        {

+                            if (prm.Body != IntPtr.Zero)

+                            {

+                                if (prm.prim_geom != IntPtr.Zero)

+                                    d.GeomSetBody(prm.prim_geom, IntPtr.Zero);

+                                if (prm.Body != prim.Body)

+                                    prm.DestroyBody(); // don't loose bodies around

+                                prm.Body = IntPtr.Zero;

+                            }

+

+                            childrenPrim.Add(prm);

+                            prm._parent = this;

+                        }

+                    }

+                }

+                //Remove old children from the prim

+                prim.childrenPrim.Clear();

+

+                if (prim.Body != IntPtr.Zero)

+                {

+                    if (prim.prim_geom != IntPtr.Zero)

+                        d.GeomSetBody(prim.prim_geom, IntPtr.Zero);

+                    prim.DestroyBody(); // don't loose bodies around

+                    prim.Body = IntPtr.Zero;

+                }

+

+                prim.childPrim = true;

+                prim._parent = this;

+

+                MakeBody(); // full nasty reconstruction

+            }

+        }

+

+        private void UpdateChildsfromgeom()

+        {

+            if (childrenPrim.Count > 0)

+            {

+                foreach (OdePrim prm in childrenPrim)

+                    prm.UpdateDataFromGeom();

+            }

+        }

+

+        private void UpdateDataFromGeom()

+        {

+            if (prim_geom != IntPtr.Zero)

+            {

+                d.Quaternion qtmp;

+                d.GeomCopyQuaternion(prim_geom, out qtmp);

+                _orientation.X = qtmp.X;

+                _orientation.Y = qtmp.Y;

+                _orientation.Z = qtmp.Z;

+                _orientation.W = qtmp.W;

+/*

+// Debug

+                float qlen = _orientation.Length();

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

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

+//

+*/

+                _orientation.Normalize();

+

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

+                _position.X = lpos.X;

+                _position.Y = lpos.Y;

+                _position.Z = lpos.Z;

+            }

+        }

+

+        private void ChildDelink(OdePrim odePrim, bool remakebodies)

+        {

+            // Okay, we have a delinked child.. destroy all body and remake

+            if (odePrim != this && !childrenPrim.Contains(odePrim))

+                return;

+

+            DestroyBody();

+

+            if (odePrim == this) // delinking the root prim

+            {

+                OdePrim newroot = null;

+                lock (childrenPrim)

+                {

+                    if (childrenPrim.Count > 0)

+                    {

+                        newroot = childrenPrim[0];

+                        childrenPrim.RemoveAt(0);

+                        foreach (OdePrim prm in childrenPrim)

+                        {

+                            newroot.childrenPrim.Add(prm);

+                        }

+                        childrenPrim.Clear();

+                    }

+                    if (newroot != null)

+                    {

+                        newroot.childPrim = false;

+                        newroot._parent = null;

+                        if (remakebodies)

+                            newroot.MakeBody();

+                    }

+                }

+            }

+

+            else

+            {

+                lock (childrenPrim)

+                {

+                    childrenPrim.Remove(odePrim);

+                    odePrim.childPrim = false;

+                    odePrim._parent = null;

+                    //                    odePrim.UpdateDataFromGeom();

+                    if (remakebodies)

+                        odePrim.MakeBody();

+                }

+            }

+            if (remakebodies)

+                MakeBody();

+        }

+

+        protected void ChildRemove(OdePrim odePrim, bool reMakeBody)

+        {

+            // Okay, we have a delinked child.. destroy all body and remake

+            if (odePrim != this && !childrenPrim.Contains(odePrim))

+                return;

+

+            DestroyBody();

+

+            if (odePrim == this)

+            {

+                OdePrim newroot = null;

+                lock (childrenPrim)

+                {

+                    if (childrenPrim.Count > 0)

+                    {

+                        newroot = childrenPrim[0];

+                        childrenPrim.RemoveAt(0);

+                        foreach (OdePrim prm in childrenPrim)

+                        {

+                            newroot.childrenPrim.Add(prm);

+                        }

+                        childrenPrim.Clear();

+                    }

+                    if (newroot != null)

+                    {

+                        newroot.childPrim = false;

+                        newroot._parent = null;

+                        newroot.MakeBody();

+                    }

+                }

+                if (reMakeBody)

+                    MakeBody();

+                return;

+            }

+            else

+            {

+                lock (childrenPrim)

+                {

+                    childrenPrim.Remove(odePrim);

+                    odePrim.childPrim = false;

+                    odePrim._parent = null;

+                    if (reMakeBody)

+                        odePrim.MakeBody();

+                }

+            }

+            MakeBody();

+        }

+

+ 

+        #region changes

+

+        private void changeadd()

+        {

+        }

+

+        private void changeAngularLock(Vector3 newLock)

+        {

+            // do we have a Physical object?

+            if (Body != IntPtr.Zero)

+            {

+                //Check that we have a Parent

+                //If we have a parent then we're not authorative here

+                if (_parent == null)

+                {

+                    if (!newLock.ApproxEquals(Vector3.One, 0f))

+                    {

+                        createAMotor(newLock);

+                    }

+                    else

+                    {

+                        if (Amotor != IntPtr.Zero)

+                        {

+                            d.JointDestroy(Amotor);

+                            Amotor = IntPtr.Zero;

+                        }

+                    }

+                }

+            }

+            // Store this for later in case we get turned into a separate body

+            m_angularlock = newLock;

+        }

+

+        private void changeLink(OdePrim NewParent)

+        {

+            if (_parent == null && NewParent != null)

+            {

+                NewParent.ParentPrim(this);

+            }

+            else if (_parent != null)

+            {

+                if (_parent is OdePrim)

+                {

+                    if (NewParent != _parent)

+                    {

+                        (_parent as OdePrim).ChildDelink(this, false); // for now...

+                        childPrim = false;

+

+                        if (NewParent != null)

+                        {

+                            NewParent.ParentPrim(this);

+                        }

+                    }

+                }

+            }

+            _parent = NewParent;

+        }

+

+

+        private void Stop()

+        {

+            if (!childPrim)

+            {

+//                m_force = Vector3.Zero;

+                m_forceacc = Vector3.Zero;

+                m_angularForceacc = Vector3.Zero;

+//                m_torque = Vector3.Zero;

+                _velocity = Vector3.Zero;

+                _acceleration = Vector3.Zero;

+                m_rotationalVelocity = Vector3.Zero;

+                _target_velocity = Vector3.Zero;

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

+                    m_vehicle.Stop();

+

+                _zeroFlag = false;

+                base.RequestPhysicsterseUpdate();

+            }

+

+            if (Body != IntPtr.Zero)

+            {

+                d.BodySetForce(Body, 0f, 0f, 0f);

+                d.BodySetTorque(Body, 0f, 0f, 0f);

+                d.BodySetLinearVel(Body, 0f, 0f, 0f);

+                d.BodySetAngularVel(Body, 0f, 0f, 0f);

+            }

+        }

+

+        private void changePhantomStatus(bool newval)

+        {

+            m_isphantom = newval;

+

+            UpdateCollisionCatFlags();

+            ApplyCollisionCatFlags();

+        }

+

+/* not in use

+        internal void ChildSelectedChange(bool childSelect)

+        {

+            if(childPrim)

+                return;

+

+            if (childSelect == m_isSelected)

+                return;

+

+            if (childSelect)

+            {

+                DoSelectedStatus(true);

+            }

+

+            else

+            {

+                foreach (OdePrim prm in childrenPrim)

+                {

+                    if (prm.m_isSelected)

+                        return;

+                }

+                DoSelectedStatus(false);

+            }

+        }

+*/

+        private void changeSelectedStatus(bool newval)

+        {

+            if (m_lastdoneSelected == newval)

+                return;

+

+            m_lastdoneSelected = newval;

+            DoSelectedStatus(newval);

+        }

+

+        private void CheckDelaySelect()

+        {

+            if (m_delaySelect)

+            {

+                DoSelectedStatus(m_isSelected);

+            }

+        }

+

+        private void DoSelectedStatus(bool newval)

+        {

+            m_isSelected = newval;

+            Stop();

+

+            if (newval)

+            {

+                if (!childPrim && Body != IntPtr.Zero)

+                    d.BodyDisable(Body);

+

+                if (m_delaySelect || m_isphysical)

+                {

+                    m_collisionCategories = CollisionCategories.Selected;

+                    m_collisionFlags = 0;

+

+                    if (!childPrim)

+                    {

+                        foreach (OdePrim prm in childrenPrim)

+                        {

+                            prm.m_collisionCategories = m_collisionCategories;

+                            prm.m_collisionFlags = m_collisionFlags;

+

+                            if (prm.prim_geom != IntPtr.Zero)

+                            {

+

+                                if (prm.m_NoColide)

+                                {

+                                    d.GeomSetCategoryBits(prm.prim_geom, 0);

+                                    d.GeomSetCollideBits(prm.prim_geom, 0);

+                                }

+                                else

+                                {

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

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

+                                }

+                            }

+                            prm.m_delaySelect = false;

+                        }

+                    }

+//                    else if (_parent != null)

+//                        ((OdePrim)_parent).ChildSelectedChange(true);

+

+

+                    if (prim_geom != IntPtr.Zero)

+                    {

+                        if (m_NoColide)

+                        {

+                            d.GeomSetCategoryBits(prim_geom, 0);

+                            d.GeomSetCollideBits(prim_geom, 0);

+                            if (collide_geom != prim_geom && collide_geom != IntPtr.Zero)

+                            {

+                                d.GeomSetCategoryBits(collide_geom, 0);

+                                d.GeomSetCollideBits(collide_geom, 0);

+                            }

+

+                        }

+                        else

+                        {

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

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

+                            if (collide_geom != prim_geom && collide_geom != IntPtr.Zero)

+                            {

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

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

+                            }

+                        }

+                    }

+

+                    m_delaySelect = false;

+                }

+                else if(!m_isphysical)

+                {

+                    m_delaySelect = true;

+                }

+            }

+            else

+            {

+                if (!childPrim)

+                {

+                    if (Body != IntPtr.Zero && !m_disabled)

+                        d.BodyEnable(Body);

+                }

+//                else if (_parent != null)

+//                    ((OdePrim)_parent).ChildSelectedChange(false);

+

+                UpdateCollisionCatFlags();

+                ApplyCollisionCatFlags();

+

+                m_delaySelect = false;

+            }

+

+            resetCollisionAccounting();

+        }

+

+        private void changePosition(Vector3 newPos)

+        {

+            CheckDelaySelect();

+            if (m_isphysical)

+            {

+                if (childPrim)  // inertia is messed, must rebuild

+                {

+                    if (m_building)

+                    {

+                        _position = newPos;

+                    }

+

+                    else if (m_forcePosOrRotation && _position != newPos && Body != IntPtr.Zero)

+                    {

+                        FixInertia(newPos);

+                        if (!d.BodyIsEnabled(Body))

+                            d.BodyEnable(Body);

+                    }

+                }

+                else

+                {

+                    if (_position != newPos)

+                    {

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

+                        _position = newPos;

+                    }

+                    if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))

+                        d.BodyEnable(Body);

+                }

+            }

+            else

+            {

+                if (prim_geom != IntPtr.Zero)

+                {

+                    if (newPos != _position)

+                    {

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

+                        _position = newPos;

+

+                        m_targetSpace = _parent_scene.MoveGeomToStaticSpace(prim_geom, _position, m_targetSpace);

+                    }

+                }

+            }

+            givefakepos--;

+            if (givefakepos < 0)

+                givefakepos = 0;

+//            changeSelectedStatus();

+            resetCollisionAccounting();

+        }

+

+        private void changeOrientation(Quaternion newOri)

+        {

+            CheckDelaySelect();

+            if (m_isphysical)

+            {

+                if (childPrim)  // inertia is messed, must rebuild

+                {

+                    if (m_building)

+                    {

+                        _orientation = newOri;

+                    }

+/*

+                    else if (m_forcePosOrRotation && _orientation != newOri && Body != IntPtr.Zero)

+                    {

+                        FixInertia(_position, newOri);

+                        if (!d.BodyIsEnabled(Body))

+                            d.BodyEnable(Body);

+                    }

+*/

+                }

+                else

+                {

+                    if (newOri != _orientation)

+                    {

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

+                        myrot.X = newOri.X;

+                        myrot.Y = newOri.Y;

+                        myrot.Z = newOri.Z;

+                        myrot.W = newOri.W;

+                        d.GeomSetQuaternion(prim_geom, ref myrot);

+                        _orientation = newOri;

+                        if (Body != IntPtr.Zero && !m_angularlock.ApproxEquals(Vector3.One, 0f))

+                            createAMotor(m_angularlock);

+                    }

+                    if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))

+                        d.BodyEnable(Body);

+                }

+            }

+            else

+            {

+                if (prim_geom != IntPtr.Zero)

+                {

+                    if (newOri != _orientation)

+                    {

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

+                        myrot.X = newOri.X;

+                        myrot.Y = newOri.Y;

+                        myrot.Z = newOri.Z;

+                        myrot.W = newOri.W;

+                        d.GeomSetQuaternion(prim_geom, ref myrot);

+                        _orientation = newOri;

+                    }

+                }

+            }

+            givefakeori--;

+            if (givefakeori < 0)

+                givefakeori = 0;

+            resetCollisionAccounting();

+        }

+

+        private void changePositionAndOrientation(Vector3 newPos, Quaternion newOri)

+        {

+            CheckDelaySelect();

+            if (m_isphysical)

+            {

+                if (childPrim && m_building)  // inertia is messed, must rebuild

+                {

+                    _position = newPos;

+                    _orientation = newOri;

+                }

+                else

+                {

+                    if (newOri != _orientation)

+                    {

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

+                        myrot.X = newOri.X;

+                        myrot.Y = newOri.Y;

+                        myrot.Z = newOri.Z;

+                        myrot.W = newOri.W;

+                        d.GeomSetQuaternion(prim_geom, ref myrot);

+                        _orientation = newOri;

+                        if (Body != IntPtr.Zero && !m_angularlock.ApproxEquals(Vector3.One, 0f))

+                            createAMotor(m_angularlock);

+                    }

+                    if (_position != newPos)

+                    {

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

+                        _position = newPos;

+                    }

+                    if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))

+                        d.BodyEnable(Body);

+                }

+            }

+            else

+            {

+                // string primScenAvatarIn = _parent_scene.whichspaceamIin(_position);

+                // int[] arrayitem = _parent_scene.calculateSpaceArrayItemFromPos(_position);

+

+                if (prim_geom != IntPtr.Zero)

+                {

+                    if (newOri != _orientation)

+                    {

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

+                        myrot.X = newOri.X;

+                        myrot.Y = newOri.Y;

+                        myrot.Z = newOri.Z;

+                        myrot.W = newOri.W;

+                        d.GeomSetQuaternion(prim_geom, ref myrot);

+                        _orientation = newOri;

+                    }

+

+                    if (newPos != _position)

+                    {

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

+                        _position = newPos;

+

+                        m_targetSpace = _parent_scene.MoveGeomToStaticSpace(prim_geom, _position, m_targetSpace);

+                    }

+                }

+            }

+            givefakepos--;

+            if (givefakepos < 0)

+                givefakepos = 0;

+            givefakeori--;

+            if (givefakeori < 0)

+                givefakeori = 0;

+            resetCollisionAccounting();

+        }

+

+        private void changeDisable(bool disable)

+        {

+            if (disable)

+            {

+                if (!m_disabled)

+                    disableBodySoft();

+            }

+            else

+            {

+                if (m_disabled)

+                    enableBodySoft();

+            }

+        }

+

+        private void changePhysicsStatus(bool NewStatus)

+        {

+            CheckDelaySelect();

+

+            m_isphysical = NewStatus;

+

+            if (!childPrim)

+            {

+                if (NewStatus)

+                {

+                    if (Body == IntPtr.Zero)

+                        MakeBody();

+                }

+                else

+                {

+                    if (Body != IntPtr.Zero)

+                    {

+                        DestroyBody();

+                    }

+                    Stop();

+                }

+            }

+

+            resetCollisionAccounting();

+        }

+

+        private void changeSize(Vector3 newSize)

+        {

+        }

+

+        private void changeShape(PrimitiveBaseShape newShape)

+        {

+        }

+

+        private void changeAddPhysRep(ODEPhysRepData repData)

+        {

+            _size = repData.size; //??

+            _pbs = repData.pbs;

+            m_shapetype = repData.shapetype;

+

+            m_mesh = repData.mesh;

+

+            m_assetID = repData.assetID;

+            m_meshState = repData.meshState;

+

+            m_hasOBB = repData.hasOBB;

+            m_OBBOffset = repData.OBBOffset;

+            m_OBB = repData.OBB;

+

+            primVolume = repData.volume;

+

+            CreateGeom();

+

+            if (prim_geom != IntPtr.Zero)

+            {

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

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

+                myrot.X = _orientation.X;

+                myrot.Y = _orientation.Y;

+                myrot.Z = _orientation.Z;

+                myrot.W = _orientation.W;

+                d.GeomSetQuaternion(prim_geom, ref myrot);

+            }

+

+            if (!m_isphysical)

+            {

+                SetInStaticSpace(this);

+                UpdateCollisionCatFlags();

+                ApplyCollisionCatFlags();

+            }

+            else

+                MakeBody();

+

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

+            {

+                repData.size = _size;

+                repData.pbs = _pbs;

+                repData.shapetype = m_shapetype;

+                _parent_scene.m_meshWorker.RequestMesh(repData);

+            }

+        }

+

+        private void changePhysRepData(ODEPhysRepData repData)

+        {

+            CheckDelaySelect();

+

+            OdePrim parent = (OdePrim)_parent;

+

+            bool chp = childPrim;

+

+            if (chp)

+            {

+                if (parent != null)

+                {

+                    parent.DestroyBody();

+                }

+            }

+            else

+            {

+                DestroyBody();

+            }

+

+            RemoveGeom();

+

+            _size = repData.size;

+            _pbs = repData.pbs;

+            m_shapetype = repData.shapetype;

+

+            m_mesh = repData.mesh;

+

+            m_assetID = repData.assetID;

+            m_meshState = repData.meshState;

+

+            m_hasOBB = repData.hasOBB;

+            m_OBBOffset = repData.OBBOffset;

+            m_OBB = repData.OBB;

+

+            primVolume = repData.volume;

+

+            CreateGeom();          

+

+            if (prim_geom != IntPtr.Zero)

+            {

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

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

+                myrot.X = _orientation.X;

+                myrot.Y = _orientation.Y;

+                myrot.Z = _orientation.Z;

+                myrot.W = _orientation.W;

+                d.GeomSetQuaternion(prim_geom, ref myrot);

+            }

+

+            if (m_isphysical)

+            {

+                if (chp)

+                {

+                    if (parent != null)

+                    {

+                        parent.MakeBody();

+                    }

+                }

+                else

+                    MakeBody();

+            }

+            else

+            {

+                SetInStaticSpace(this);

+                UpdateCollisionCatFlags();

+                ApplyCollisionCatFlags();

+            }

+

+            resetCollisionAccounting();

+

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

+            {

+                repData.size = _size;

+                repData.pbs = _pbs;

+                repData.shapetype = m_shapetype;

+                _parent_scene.m_meshWorker.RequestMesh(repData);

+            }

+        }

+

+        private void changeFloatOnWater(bool newval)

+        {

+            m_collidesWater = newval;

+

+            UpdateCollisionCatFlags();

+            ApplyCollisionCatFlags();

+        }

+

+        private void changeSetTorque(Vector3 newtorque)

+        {

+            if (!m_isSelected)

+            {

+                if (m_isphysical && Body != IntPtr.Zero)

+                {

+                    if (m_disabled)

+                        enableBodySoft();

+                    else if (!d.BodyIsEnabled(Body))

+                        d.BodyEnable(Body);

+

+                }

+                m_torque = newtorque;

+            }

+        }

+

+        private void changeForce(Vector3 force)

+        {

+            m_force = force;

+            if (Body != IntPtr.Zero && !d.BodyIsEnabled(Body))

+                d.BodyEnable(Body);

+        }

+

+        private void changeAddForce(Vector3 theforce)

+        {

+            m_forceacc += theforce;

+            if (!m_isSelected)

+            {

+                lock (this)

+                {

+                    //m_log.Info("[PHYSICS]: dequeing forcelist");

+                    if (m_isphysical && Body != IntPtr.Zero)

+                    {

+                        if (m_disabled)

+                            enableBodySoft();

+                        else if (!d.BodyIsEnabled(Body))

+                            d.BodyEnable(Body);

+                    }

+                }

+                m_collisionscore = 0;

+            }

+        }

+

+        // actually angular impulse

+        private void changeAddAngularImpulse(Vector3 aimpulse)

+        {

+            m_angularForceacc += aimpulse * m_invTimeStep;

+            if (!m_isSelected)

+            {

+                lock (this)

+                {

+                    if (m_isphysical && Body != IntPtr.Zero)

+                    {

+                        if (m_disabled)

+                            enableBodySoft();

+                        else if (!d.BodyIsEnabled(Body))

+                            d.BodyEnable(Body);

+                    }

+                }

+                m_collisionscore = 0;

+            }

+        }

+

+        private void changevelocity(Vector3 newVel)

+        {

+            float len = newVel.LengthSquared();

+            if (len > 100000.0f) // limit to 100m/s

+            {

+                len = 100.0f / (float)Math.Sqrt(len);

+                newVel *= len;

+            }

+

+            if (!m_isSelected)

+            {

+                if (Body != IntPtr.Zero)

+                {

+                    if (m_disabled)

+                        enableBodySoft();

+                    else if (!d.BodyIsEnabled(Body))

+                        d.BodyEnable(Body);

+

+                    d.BodySetLinearVel(Body, newVel.X, newVel.Y, newVel.Z);

+                }

+                //resetCollisionAccounting();           

+            }

+            _velocity = newVel;

+        }

+

+        private void changeangvelocity(Vector3 newAngVel)

+        {

+            float len = newAngVel.LengthSquared();

+            if (len > 144.0f) // limit to 12rad/s

+            {

+                len = 12.0f / (float)Math.Sqrt(len);

+                newAngVel *= len;

+            }

+

+            if (!m_isSelected)

+            {

+                if (Body != IntPtr.Zero)

+                {

+                    if (m_disabled)

+                        enableBodySoft();

+                    else if (!d.BodyIsEnabled(Body))

+                        d.BodyEnable(Body);

+

+

+                    d.BodySetAngularVel(Body, newAngVel.X, newAngVel.Y, newAngVel.Z);

+                }

+                //resetCollisionAccounting();           

+            }

+            m_rotationalVelocity = newAngVel;

+        }

+

+        private void changeVolumedetetion(bool newVolDtc)

+        {

+            m_isVolumeDetect = newVolDtc;

+            m_fakeisVolumeDetect = newVolDtc;

+            UpdateCollisionCatFlags();

+            ApplyCollisionCatFlags();

+        }

+

+        protected void changeBuilding(bool newbuilding)

+        {

+            // Check if we need to do anything

+            if (newbuilding == m_building)

+                return;

+

+            if ((bool)newbuilding)

+            {

+                m_building = true;

+                if (!childPrim)

+                    DestroyBody();

+            }

+            else

+            {

+                m_building = false;

+                CheckDelaySelect();

+                if (!childPrim)

+                    MakeBody();

+            }

+            if (!childPrim && childrenPrim.Count > 0)

+            {

+                foreach (OdePrim prm in childrenPrim)

+                    prm.changeBuilding(m_building); // call directly

+            }

+        }

+

+       public void changeSetVehicle(VehicleData vdata)

+        {

+            if (m_vehicle == null)

+                m_vehicle = new ODEDynamics(this);

+            m_vehicle.DoSetVehicle(vdata);

+        }

+

+        private void changeVehicleType(int value)

+        {

+            if (value == (int)Vehicle.TYPE_NONE)

+            {

+                if (m_vehicle != null)

+                    m_vehicle = null;

+            }

+            else

+            {

+                if (m_vehicle == null)

+                    m_vehicle = new ODEDynamics(this);

+

+                m_vehicle.ProcessTypeChange((Vehicle)value);

+            }

+        }

+

+        private void changeVehicleFloatParam(strVehicleFloatParam fp)

+        {

+            if (m_vehicle == null)

+                return;

+

+            m_vehicle.ProcessFloatVehicleParam((Vehicle)fp.param, fp.value);

+        }

+

+        private void changeVehicleVectorParam(strVehicleVectorParam vp)

+        {

+            if (m_vehicle == null)

+                return;

+            m_vehicle.ProcessVectorVehicleParam((Vehicle)vp.param, vp.value);

+        }

+

+        private void changeVehicleRotationParam(strVehicleQuatParam qp)

+        {

+            if (m_vehicle == null)

+                return;

+            m_vehicle.ProcessRotationVehicleParam((Vehicle)qp.param, qp.value);

+        }

+

+        private void changeVehicleFlags(strVehicleBoolParam bp)

+        {

+            if (m_vehicle == null)

+                return;

+            m_vehicle.ProcessVehicleFlags(bp.param, bp.value);

+        }

+

+        private void changeBuoyancy(float b)

+        {

+            m_buoyancy = b;

+        }

+

+        private void changePIDTarget(Vector3 trg)

+        {

+            m_PIDTarget = trg;

+        }

+

+        private void changePIDTau(float tau)

+        {

+            m_PIDTau = tau;

+        }

+

+        private void changePIDActive(bool val)

+        {

+            m_usePID = val;

+        }

+

+        private void changePIDHoverHeight(float val)

+        {

+          m_PIDHoverHeight = val;

+          if (val == 0)

+            m_useHoverPID = false;

+        }

+

+        private void changePIDHoverType(PIDHoverType type)

+        {

+            m_PIDHoverType = type;

+        }

+

+        private void changePIDHoverTau(float tau)

+        {

+            m_PIDHoverTau = tau;

+        }

+

+        private void changePIDHoverActive(bool active)

+        {

+            m_useHoverPID = active;

+        }

+

+        #endregion

+

+        public void Move()

+        {

+            if (!childPrim && m_isphysical && Body != IntPtr.Zero &&

+                !m_disabled && !m_isSelected && !m_building && !m_outbounds)

+            {

+                if (!d.BodyIsEnabled(Body))

+                {

+                    // let vehicles sleep

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

+                        return;

+

+                    if (++bodydisablecontrol < 20)

+                        return;

+                    

+                    d.BodyEnable(Body);

+                }

+

+                bodydisablecontrol = 0;

+

+                d.Vector3 lpos = d.GeomGetPosition(prim_geom); // root position that is seem by rest of simulator

+

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

+                {

+                    // 'VEHICLES' are dealt with in ODEDynamics.cs

+                    m_vehicle.Step();

+                    return;

+                }

+

+                float fx = 0;

+                float fy = 0;

+                float fz = 0;

+

+                float m_mass = _mass;

+

+                if (m_usePID && m_PIDTau > 0)

+                {

+                    // for now position error

+                    _target_velocity =

+                        new Vector3(

+                            (m_PIDTarget.X - lpos.X),

+                            (m_PIDTarget.Y - lpos.Y),

+                            (m_PIDTarget.Z - lpos.Z)

+                            );

+

+                    if (_target_velocity.ApproxEquals(Vector3.Zero, 0.02f))

+                    {

+                        d.BodySetPosition(Body, m_PIDTarget.X, m_PIDTarget.Y, m_PIDTarget.Z);

+                        d.BodySetLinearVel(Body, 0, 0, 0);

+                        return;

+                    }

+                    else

+                    {

+                        _zeroFlag = false;

+

+                        float tmp = 1 / m_PIDTau;

+                        _target_velocity *= tmp;

+

+                        // apply limits

+                        tmp = _target_velocity.Length();

+                        if (tmp > 50.0f)

+                        {

+                            tmp = 50 / tmp;

+                            _target_velocity *= tmp;

+                        }

+                        else if (tmp < 0.05f)

+                        {

+                            tmp = 0.05f / tmp;

+                            _target_velocity *= tmp;

+                        }

+

+                        d.Vector3 vel = d.BodyGetLinearVel(Body);

+                        fx = (_target_velocity.X - vel.X) * m_invTimeStep;

+                        fy = (_target_velocity.Y - vel.Y) * m_invTimeStep;

+                        fz = (_target_velocity.Z - vel.Z) * m_invTimeStep;

+//                        d.BodySetLinearVel(Body, _target_velocity.X, _target_velocity.Y, _target_velocity.Z);

+                    }

+                }        // end if (m_usePID)

+

+                // Hover PID Controller needs to be mutually exlusive to MoveTo PID controller

+                else if (m_useHoverPID && m_PIDHoverTau != 0 && m_PIDHoverHeight != 0)

+                {

+

+                    //    Non-Vehicles have a limited set of Hover options.

+                    // determine what our target height really is based on HoverType

+

+                    m_groundHeight = _parent_scene.GetTerrainHeightAtXY(lpos.X, lpos.Y);

+

+                    switch (m_PIDHoverType)

+                    {

+                        case PIDHoverType.Ground:

+                            m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight;

+                            break;

+

+                        case PIDHoverType.GroundAndWater:

+                            m_waterHeight = _parent_scene.GetWaterLevel();

+                            if (m_groundHeight > m_waterHeight)

+                                m_targetHoverHeight = m_groundHeight + m_PIDHoverHeight;

+                            else

+                                m_targetHoverHeight = m_waterHeight + m_PIDHoverHeight;

+                            break;

+                    }     // end switch (m_PIDHoverType)

+

+                    // don't go underground unless volumedetector 

+

+                    if (m_targetHoverHeight > m_groundHeight || m_isVolumeDetect)

+                    {

+                        d.Vector3 vel = d.BodyGetLinearVel(Body);

+

+                        fz = (m_targetHoverHeight - lpos.Z);

+

+                        //  if error is zero, use position control; otherwise, velocity control

+                        if (Math.Abs(fz) < 0.01f)

+                        {

+                            d.BodySetPosition(Body, lpos.X, lpos.Y, m_targetHoverHeight);

+                            d.BodySetLinearVel(Body, vel.X, vel.Y, 0);

+                        }

+                        else

+                        {

+                            _zeroFlag = false;

+                            fz /= m_PIDHoverTau;

+

+                            float tmp = Math.Abs(fz);

+                            if (tmp > 50)

+                                fz = 50 * Math.Sign(fz);

+                            else if (tmp < 0.1)

+                                fz = 0.1f * Math.Sign(fz);

+

+                            fz = ((fz - vel.Z) * m_invTimeStep);

+                        }

+                    }

+                }

+                else

+                {

+                    float b = (1.0f - m_buoyancy) * m_gravmod;

+                    fx = _parent_scene.gravityx * b;

+                    fy = _parent_scene.gravityy * b;

+                    fz = _parent_scene.gravityz * b;

+                }

+

+                fx *= m_mass;

+                fy *= m_mass;

+                fz *= m_mass;

+

+                // constant force

+                fx += m_force.X;

+                fy += m_force.Y;

+                fz += m_force.Z;

+

+                fx += m_forceacc.X;

+                fy += m_forceacc.Y;

+                fz += m_forceacc.Z;

+

+                m_forceacc = Vector3.Zero;

+

+                //m_log.Info("[OBJPID]: X:" + fx.ToString() + " Y:" + fy.ToString() + " Z:" + fz.ToString());

+                if (fx != 0 || fy != 0 || fz != 0)

+                {

+                    d.BodyAddForce(Body, fx, fy, fz);

+                    //Console.WriteLine("AddForce " + fx + "," + fy + "," + fz);

+                }

+

+                Vector3 trq;

+

+                trq = m_torque;

+                trq += m_angularForceacc;

+                m_angularForceacc = Vector3.Zero;

+                if (trq.X != 0 || trq.Y != 0 || trq.Z != 0)

+                {

+                    d.BodyAddTorque(Body, trq.X, trq.Y, trq.Z);

+                }

+            }

+            else

+            {    // is not physical, or is not a body or is selected

+                //  _zeroPosition = d.BodyGetPosition(Body);

+                return;

+                //Console.WriteLine("Nothing " +  Name);

+

+            }

+        }

+

+        public void UpdatePositionAndVelocity(int frame)

+        {

+            if (_parent == null && !m_disabled && !m_building && !m_outbounds && Body != IntPtr.Zero)

+            {

+                bool bodyenabled = d.BodyIsEnabled(Body);

+                if (bodyenabled || !_zeroFlag)

+                {

+                    bool lastZeroFlag = _zeroFlag;

+

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

+

+                    // check outside region

+                    if (lpos.Z < -100 || lpos.Z > 100000f)

+                    {

+                        m_outbounds = true;

+

+                        lpos.Z = Util.Clip(lpos.Z, -100f, 100000f);

+                        _acceleration.X = 0;

+                        _acceleration.Y = 0;

+                        _acceleration.Z = 0;

+

+                        _velocity.X = 0;

+                        _velocity.Y = 0;

+                        _velocity.Z = 0;

+                        m_rotationalVelocity.X = 0;

+                        m_rotationalVelocity.Y = 0;

+                        m_rotationalVelocity.Z = 0;

+

+                        d.BodySetLinearVel(Body, 0, 0, 0); // stop it

+                        d.BodySetAngularVel(Body, 0, 0, 0); // stop it

+                        d.BodySetPosition(Body, lpos.X, lpos.Y, lpos.Z); // put it somewhere 

+                        m_lastposition = _position;

+                        m_lastorientation = _orientation;

+

+                        base.RequestPhysicsterseUpdate();

+

+//                        throttleCounter = 0;

+                        _zeroFlag = true;

+

+                        disableBodySoft(); // disable it and colisions

+                        base.RaiseOutOfBounds(_position);

+                        return;

+                    }

+

+                    if (lpos.X < 0f)

+                    {

+                        _position.X = Util.Clip(lpos.X, -2f, -0.1f);

+                        m_outbounds = true;

+                    }

+                    else if (lpos.X > _parent_scene.WorldExtents.X)

+                    {

+                        _position.X = Util.Clip(lpos.X, _parent_scene.WorldExtents.X + 0.1f, _parent_scene.WorldExtents.X + 2f);

+                        m_outbounds = true;

+                    }

+                    if (lpos.Y < 0f)

+                    {

+                        _position.Y = Util.Clip(lpos.Y, -2f, -0.1f);

+                        m_outbounds = true;

+                    }

+                    else if (lpos.Y > _parent_scene.WorldExtents.Y)

+                    {

+                        _position.Y = Util.Clip(lpos.Y, _parent_scene.WorldExtents.Y + 0.1f, _parent_scene.WorldExtents.Y + 2f);

+                        m_outbounds = true;

+                    }

+

+                    if (m_outbounds)

+                    {

+                        m_lastposition = _position;

+                        m_lastorientation = _orientation;

+

+                        d.Vector3 dtmp = d.BodyGetAngularVel(Body);

+                        m_rotationalVelocity.X = dtmp.X;

+                        m_rotationalVelocity.Y = dtmp.Y;

+                        m_rotationalVelocity.Z = dtmp.Z;

+

+                        dtmp = d.BodyGetLinearVel(Body);

+                        _velocity.X = dtmp.X;

+                        _velocity.Y = dtmp.Y;

+                        _velocity.Z = dtmp.Z;

+

+                        d.BodySetLinearVel(Body, 0, 0, 0); // stop it

+                        d.BodySetAngularVel(Body, 0, 0, 0);

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

+                        disableBodySoft(); // stop collisions

+                        UnSubscribeEvents();

+

+                        base.RequestPhysicsterseUpdate();

+                        return;

+                    }

+

+                    d.Quaternion ori;

+                    d.GeomCopyQuaternion(prim_geom, out ori);

+

+                    // decide if moving

+                    // use positions since this are integrated quantities

+                    // tolerance values depende a lot on simulation noise...

+                    // use simple math.abs since we dont need to be exact

+

+                    if (!bodyenabled ||

+                        (Math.Abs(_position.X - lpos.X) < 0.005f)

+                        && (Math.Abs(_position.Y - lpos.Y) < 0.005f)

+                        && (Math.Abs(_position.Z - lpos.Z) < 0.005f)

+                        && (Math.Abs(_orientation.X - ori.X) < 0.0005f)

+                        && (Math.Abs(_orientation.Y - ori.Y) < 0.0005f)

+                        && (Math.Abs(_orientation.Z - ori.Z) < 0.0005f)  // ignore W

+                        )

+                    {

+                        _zeroFlag = true;

+                    }

+                    else

+                        _zeroFlag = false;

+

+                    // update velocities and aceleration

+                    if (!(_zeroFlag && lastZeroFlag))

+                    {

+                        d.Vector3 vel = d.BodyGetLinearVel(Body);

+

+                        _acceleration = _velocity;

+

+                        if ((Math.Abs(vel.X) < 0.005f) &&

+                            (Math.Abs(vel.Y) < 0.005f) &&

+                            (Math.Abs(vel.Z) < 0.005f))

+                        {

+                            _velocity = Vector3.Zero;

+                            float t = -m_invTimeStep;

+                            _acceleration = _acceleration * t;

+                        }

+                        else

+                        {

+                            _velocity.X = vel.X;

+                            _velocity.Y = vel.Y;

+                            _velocity.Z = vel.Z;

+                            _acceleration = (_velocity - _acceleration) * m_invTimeStep;

+                        }

+

+                        if ((Math.Abs(_acceleration.X) < 0.01f) &&

+                            (Math.Abs(_acceleration.Y) < 0.01f) &&

+                            (Math.Abs(_acceleration.Z) < 0.01f))

+                        {

+                            _acceleration = Vector3.Zero;

+                        }

+

+                        if ((Math.Abs(_orientation.X - ori.X) < 0.0001) &&

+                           (Math.Abs(_orientation.Y - ori.Y) < 0.0001) &&

+                           (Math.Abs(_orientation.Z - ori.Z) < 0.0001)

+                           )

+                        {

+                            m_rotationalVelocity = Vector3.Zero;

+                        }

+                        else

+                        {

+                            vel = d.BodyGetAngularVel(Body);

+                            m_rotationalVelocity.X = vel.X;

+                            m_rotationalVelocity.Y = vel.Y;

+                            m_rotationalVelocity.Z = vel.Z;

+                        }

+                        //                    }

+

+                        _position.X = lpos.X;

+                        _position.Y = lpos.Y;

+                        _position.Z = lpos.Z;

+

+                        _orientation.X = ori.X;

+                        _orientation.Y = ori.Y;

+                        _orientation.Z = ori.Z;

+                        _orientation.W = ori.W;

+                    }

+                    if (_zeroFlag)

+                    {

+                        if (lastZeroFlag)

+                        {

+                            _velocity = Vector3.Zero;

+                            _acceleration = Vector3.Zero;

+                            m_rotationalVelocity = Vector3.Zero;

+                        }

+

+                        if (!m_lastUpdateSent)

+                        {

+                            base.RequestPhysicsterseUpdate();

+                            if (lastZeroFlag)

+                                m_lastUpdateSent = true;

+                        }

+                        return;

+                    }

+

+                    base.RequestPhysicsterseUpdate();

+                    m_lastUpdateSent = false;

+                }

+            }

+        }

+

+        internal static bool QuaternionIsFinite(Quaternion q)

+        {

+            if (Single.IsNaN(q.X) || Single.IsInfinity(q.X))

+                return false;

+            if (Single.IsNaN(q.Y) || Single.IsInfinity(q.Y))

+                return false;

+            if (Single.IsNaN(q.Z) || Single.IsInfinity(q.Z))

+                return false;

+            if (Single.IsNaN(q.W) || Single.IsInfinity(q.W))

+                return false;

+            return true;

+        }

+

+        internal static void DMassSubPartFromObj(ref d.Mass part, ref d.Mass theobj)

+        {

+            // assumes object center of mass is zero

+            float smass = part.mass;

+            theobj.mass -= smass;

+

+            smass *= 1.0f / (theobj.mass); ;

+

+            theobj.c.X -= part.c.X * smass;

+            theobj.c.Y -= part.c.Y * smass;

+            theobj.c.Z -= part.c.Z * smass;

+

+            theobj.I.M00 -= part.I.M00;

+            theobj.I.M01 -= part.I.M01;

+            theobj.I.M02 -= part.I.M02;

+            theobj.I.M10 -= part.I.M10;

+            theobj.I.M11 -= part.I.M11;

+            theobj.I.M12 -= part.I.M12;

+            theobj.I.M20 -= part.I.M20;

+            theobj.I.M21 -= part.I.M21;

+            theobj.I.M22 -= part.I.M22;

+        }

+

+        private void donullchange()

+        {

+        }

+

+        public bool DoAChange(changes what, object arg)

+        {

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

+            {

+                return false;

+            }

+

+            // nasty switch

+            switch (what)

+            {

+                case changes.Add:

+                    changeadd();

+                    break;

+

+                case changes.AddPhysRep:

+                    changeAddPhysRep((ODEPhysRepData)arg);

+                    break;

+

+                case changes.Remove:

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

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

+                    if (_parent != null)

+                    {

+                        OdePrim parent = (OdePrim)_parent;

+                        parent.ChildRemove(this, false);

+                    }

+                    else

+                        ChildRemove(this, false);

+

+                    m_vehicle = null;

+                    RemoveGeom();

+                    m_targetSpace = IntPtr.Zero;

+                    UnSubscribeEvents();

+                    return true;

+

+                case changes.Link:

+                    OdePrim tmp = (OdePrim)arg;

+                    changeLink(tmp);

+                    break;

+

+                case changes.DeLink:

+                    changeLink(null);

+                    break;

+

+                case changes.Position:

+                    changePosition((Vector3)arg);

+                    break;

+

+                case changes.Orientation:

+                    changeOrientation((Quaternion)arg);

+                    break;

+

+                case changes.PosOffset:

+                    donullchange();

+                    break;

+

+                case changes.OriOffset:

+                    donullchange();

+                    break;

+

+                case changes.Velocity:

+                    changevelocity((Vector3)arg);

+                    break;

+

+//                case changes.Acceleration:

+//                    changeacceleration((Vector3)arg);

+//                    break;

+

+                case changes.AngVelocity:

+                    changeangvelocity((Vector3)arg);

+                    break;

+

+                case changes.Force:

+                    changeForce((Vector3)arg);

+                    break;

+

+                case changes.Torque:

+                    changeSetTorque((Vector3)arg);

+                    break;

+

+                case changes.AddForce:

+                    changeAddForce((Vector3)arg);

+                    break;

+

+                case changes.AddAngForce:

+                    changeAddAngularImpulse((Vector3)arg);

+                    break;

+

+                case changes.AngLock:

+                    changeAngularLock((Vector3)arg);

+                    break;

+

+                case changes.Size:

+                    changeSize((Vector3)arg);

+                    break;

+

+                case changes.Shape:

+                    changeShape((PrimitiveBaseShape)arg);

+                    break;

+

+                case changes.PhysRepData:

+                    changePhysRepData((ODEPhysRepData) arg);

+                    break;

+

+                case changes.CollidesWater:

+                    changeFloatOnWater((bool)arg);

+                    break;

+

+                case changes.VolumeDtc:

+                    changeVolumedetetion((bool)arg);

+                    break;

+

+                case changes.Phantom:

+                    changePhantomStatus((bool)arg);

+                    break;

+

+                case changes.Physical:

+                    changePhysicsStatus((bool)arg);

+                    break;

+

+                case changes.Selected:

+                    changeSelectedStatus((bool)arg);

+                    break;

+

+                case changes.disabled:

+                    changeDisable((bool)arg);

+                    break;

+

+                case changes.building:

+                    changeBuilding((bool)arg);

+                    break;

+

+                case changes.VehicleType:

+                    changeVehicleType((int)arg);

+                    break;

+

+                case changes.VehicleFlags:

+                    changeVehicleFlags((strVehicleBoolParam) arg);

+                    break;

+

+                case changes.VehicleFloatParam:

+                    changeVehicleFloatParam((strVehicleFloatParam) arg);

+                    break;

+

+                case changes.VehicleVectorParam:

+                    changeVehicleVectorParam((strVehicleVectorParam) arg);

+                    break;

+

+                case changes.VehicleRotationParam:

+                    changeVehicleRotationParam((strVehicleQuatParam) arg);

+                    break;

+

+                case changes.SetVehicle:

+                    changeSetVehicle((VehicleData) arg);

+                    break;

+

+                case changes.Buoyancy:

+                    changeBuoyancy((float)arg);

+                    break;

+

+                case changes.PIDTarget:

+                    changePIDTarget((Vector3)arg);

+                    break;

+

+                case changes.PIDTau:

+                    changePIDTau((float)arg);

+                    break;

+

+                case changes.PIDActive:

+                    changePIDActive((bool)arg);

+                    break;

+

+                case changes.PIDHoverHeight:

+                    changePIDHoverHeight((float)arg);

+                    break;

+

+                case changes.PIDHoverType:

+                    changePIDHoverType((PIDHoverType)arg);

+                    break;

+

+                case changes.PIDHoverTau:

+                    changePIDHoverTau((float)arg);

+                    break;

+

+                case changes.PIDHoverActive:

+                    changePIDHoverActive((bool)arg);

+                    break;

+

+                case changes.Null:

+                    donullchange();

+                    break;

+

+

+

+                default:

+                    donullchange();

+                    break;

+            }

+            return false;

+        }

+

+        public void AddChange(changes what, object arg)

+        {

+            _parent_scene.AddChange((PhysicsActor) this, what, arg);

+        }

+

+

+        private struct strVehicleBoolParam

+        {

+            public int param;

+            public bool value;

+        }

+

+        private struct strVehicleFloatParam

+        {

+            public int param;

+            public float value;

+        }

+

+        private struct strVehicleQuatParam

+        {

+            public int param;

+            public Quaternion value;

+        }

+

+        private struct strVehicleVectorParam

+        {

+            public int param;

+            public Vector3 value;

+        }

+    }

+}

diff --git a/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODERayCastRequestManager.cs b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODERayCastRequestManager.cs
new file mode 100644
index 0000000..3ad9a47
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODERayCastRequestManager.cs
@@ -0,0 +1,683 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OdeAPI;
+using log4net;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.OdePlugin
+{
+    /// <summary>
+    /// Processes raycast requests as ODE is in a state to be able to do them.
+    /// This ensures that it's thread safe and there will be no conflicts.
+    /// Requests get returned by a different thread then they were requested by.
+    /// </summary>
+    public class ODERayCastRequestManager
+    {
+        /// <summary>
+        /// Pending ray requests
+        /// </summary>
+        protected OpenSim.Framework.LocklessQueue<ODERayRequest> m_PendingRequests = new OpenSim.Framework.LocklessQueue<ODERayRequest>();
+
+        /// <summary>
+        /// Scene that created this object.
+        /// </summary>
+        private OdeScene m_scene;
+
+        IntPtr ray; // the ray. we only need one for our lifetime
+        IntPtr Sphere;
+        IntPtr Box;
+        IntPtr Plane;
+
+        private int CollisionContactGeomsPerTest = 25;
+        private const int DefaultMaxCount = 25;
+        private const int MaxTimePerCallMS = 30;
+
+        /// <summary>
+        /// ODE near callback delegate
+        /// </summary>
+        private d.NearCallback nearCallback;
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private List<ContactResult> m_contactResults = new List<ContactResult>();
+        private RayFilterFlags CurrentRayFilter;
+        private int CurrentMaxCount;
+
+        public ODERayCastRequestManager(OdeScene pScene)
+        {
+            m_scene = pScene;
+            nearCallback = near;
+            ray = d.CreateRay(IntPtr.Zero, 1.0f);
+            d.GeomSetCategoryBits(ray, 0);
+            Box = d.CreateBox(IntPtr.Zero, 1.0f, 1.0f, 1.0f);
+            d.GeomSetCategoryBits(Box, 0);
+            Sphere = d.CreateSphere(IntPtr.Zero,1.0f);
+            d.GeomSetCategoryBits(Sphere, 0);
+            Plane = d.CreatePlane(IntPtr.Zero, 0f,0f,1f,1f);
+            d.GeomSetCategoryBits(Sphere, 0);
+        }
+
+        public void QueueRequest(ODERayRequest req)
+        {
+            if (req.Count == 0)
+                req.Count = DefaultMaxCount;
+
+            m_PendingRequests.Enqueue(req);
+        }
+
+        /// <summary>
+        /// Process all queued raycast requests
+        /// </summary>
+        /// <returns>Time in MS the raycasts took to process.</returns>
+        public int ProcessQueuedRequests()
+        {
+
+            if (m_PendingRequests.Count <= 0)
+                return 0;
+
+            if (m_scene.ContactgeomsArray == IntPtr.Zero || ray == IntPtr.Zero)
+                // oops something got wrong or scene isn't ready still
+            {
+                m_PendingRequests.Clear();
+                return 0;
+            }
+
+            int time = Util.EnvironmentTickCount();
+
+            ODERayRequest req;
+            int closestHit;
+            int backfacecull;
+            CollisionCategories catflags;
+
+            while (m_PendingRequests.Dequeue(out req))
+            {
+                if (req.callbackMethod != null)
+                {
+                    IntPtr geom = IntPtr.Zero;
+                    if (req.actor != null)
+                    {
+                        if (m_scene.haveActor(req.actor))
+                        {
+                            if (req.actor is OdePrim)
+                                geom = ((OdePrim)req.actor).prim_geom;
+                            else if (req.actor is OdeCharacter)
+                                geom = ((OdePrim)req.actor).prim_geom;
+                        }
+                        if (geom == IntPtr.Zero)
+                        {
+                            NoContacts(req);
+                            continue;
+                        }
+                    }
+                      
+
+                    CurrentRayFilter = req.filter;
+                    CurrentMaxCount = req.Count;
+
+                    CollisionContactGeomsPerTest = req.Count & 0xffff;
+
+                    closestHit = ((CurrentRayFilter & RayFilterFlags.ClosestHit) == 0 ? 0 : 1);
+                    backfacecull = ((CurrentRayFilter & RayFilterFlags.BackFaceCull) == 0 ? 0 : 1);
+
+                    if (req.callbackMethod is ProbeBoxCallback)
+                    {
+                        if (CollisionContactGeomsPerTest > 80)
+                            CollisionContactGeomsPerTest = 80;
+                        d.GeomBoxSetLengths(Box, req.Normal.X, req.Normal.Y, req.Normal.Z);
+                        d.GeomSetPosition(Box, req.Origin.X, req.Origin.Y, req.Origin.Z);
+                        d.Quaternion qtmp;
+                        qtmp.X = req.orientation.X;
+                        qtmp.Y = req.orientation.Y;
+                        qtmp.Z = req.orientation.Z;
+                        qtmp.W = req.orientation.W;
+                        d.GeomSetQuaternion(Box, ref qtmp);
+                    }
+                    else if (req.callbackMethod is ProbeSphereCallback)
+                    {
+                        if (CollisionContactGeomsPerTest > 80)
+                            CollisionContactGeomsPerTest = 80;
+
+                        d.GeomSphereSetRadius(Sphere, req.length);
+                        d.GeomSetPosition(Sphere, req.Origin.X, req.Origin.Y, req.Origin.Z);
+                    }
+                    else if (req.callbackMethod is ProbePlaneCallback)
+                    {
+                        if (CollisionContactGeomsPerTest > 80)
+                            CollisionContactGeomsPerTest = 80;
+
+                        d.GeomPlaneSetParams(Plane, req.Normal.X, req.Normal.Y, req.Normal.Z, req.length);
+                    }
+
+                    else
+                    {
+                        if (CollisionContactGeomsPerTest > 25)
+                            CollisionContactGeomsPerTest = 25;
+
+                        d.GeomRaySetLength(ray, req.length);
+                        d.GeomRaySet(ray, req.Origin.X, req.Origin.Y, req.Origin.Z, req.Normal.X, req.Normal.Y, req.Normal.Z);
+                        d.GeomRaySetParams(ray, 0, backfacecull);
+                        d.GeomRaySetClosestHit(ray, closestHit);
+
+                        if (req.callbackMethod is RaycastCallback)
+                        {
+                            // if we only want one get only one per Collision pair saving memory
+                            CurrentRayFilter |= RayFilterFlags.ClosestHit;
+                            d.GeomRaySetClosestHit(ray, 1);
+                        }
+                        else
+                            d.GeomRaySetClosestHit(ray, closestHit);
+                    }
+
+                    if ((CurrentRayFilter & RayFilterFlags.ContactsUnImportant) != 0)
+                        unchecked
+                        {
+                            CollisionContactGeomsPerTest |= (int)d.CONTACTS_UNIMPORTANT;
+                        }
+
+                    if (geom == IntPtr.Zero)
+                    {
+                        // translate ray filter to Collision flags
+                        catflags = 0;
+                        if ((CurrentRayFilter & RayFilterFlags.volumedtc) != 0)
+                            catflags |= CollisionCategories.VolumeDtc;
+                        if ((CurrentRayFilter & RayFilterFlags.phantom) != 0)
+                            catflags |= CollisionCategories.Phantom;
+                        if ((CurrentRayFilter & RayFilterFlags.agent) != 0)
+                            catflags |= CollisionCategories.Character;
+                        if ((CurrentRayFilter & RayFilterFlags.PrimsNonPhantom) != 0)
+                            catflags |= CollisionCategories.Geom;
+                        if ((CurrentRayFilter & RayFilterFlags.land) != 0)
+                            catflags |= CollisionCategories.Land;
+                        if ((CurrentRayFilter & RayFilterFlags.water) != 0)
+                            catflags |= CollisionCategories.Water;
+
+                        if (catflags != 0)
+                        {
+                            if (req.callbackMethod is ProbeBoxCallback)
+                            {
+                                catflags |= CollisionCategories.Space;
+                                d.GeomSetCollideBits(Box, (uint)catflags);
+                                d.GeomSetCategoryBits(Box, (uint)catflags);
+                                doProbe(req, Box);
+                            }
+                            else if (req.callbackMethod is ProbeSphereCallback)
+                            {
+                                catflags |= CollisionCategories.Space;
+                                d.GeomSetCollideBits(Sphere, (uint)catflags);
+                                d.GeomSetCategoryBits(Sphere, (uint)catflags);
+                                doProbe(req, Sphere);
+                            }
+                            else if (req.callbackMethod is ProbePlaneCallback)
+                            {
+                                catflags |= CollisionCategories.Space;
+                                d.GeomSetCollideBits(Plane, (uint)catflags);
+                                d.GeomSetCategoryBits(Plane, (uint)catflags);
+                                doPlane(req,IntPtr.Zero);
+                            }
+                            else
+                            {
+                                d.GeomSetCollideBits(ray, (uint)catflags);
+                                doSpaceRay(req);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // if we select a geom don't use filters
+
+                        if (req.callbackMethod is ProbePlaneCallback)
+                        {
+                            d.GeomSetCollideBits(Plane, (uint)CollisionCategories.All);
+                            doPlane(req,geom);
+                        }
+                        else
+                        {
+                            d.GeomSetCollideBits(ray, (uint)CollisionCategories.All);
+                            doGeomRay(req,geom);
+                        }
+                    }
+                }
+
+                if (Util.EnvironmentTickCountSubtract(time) > MaxTimePerCallMS)
+                    break;
+            }
+
+            lock (m_contactResults)
+                m_contactResults.Clear();
+
+            return Util.EnvironmentTickCountSubtract(time);
+        }
+        /// <summary>
+        /// Method that actually initiates the raycast with spaces
+        /// </summary>
+        /// <param name="req"></param>
+        /// 
+
+        private void NoContacts(ODERayRequest req)
+        {
+            if (req.callbackMethod is RaycastCallback)
+            {
+                ((RaycastCallback)req.callbackMethod)(false, Vector3.Zero, 0, 0, Vector3.Zero);
+                return;
+            }
+            List<ContactResult> cresult = new List<ContactResult>();
+
+            if (req.callbackMethod is RayCallback)
+                ((RayCallback)req.callbackMethod)(cresult);
+            else if (req.callbackMethod is ProbeBoxCallback)
+                ((ProbeBoxCallback)req.callbackMethod)(cresult);
+            else if (req.callbackMethod is ProbeSphereCallback)
+                ((ProbeSphereCallback)req.callbackMethod)(cresult);
+        }
+
+        private const RayFilterFlags FilterActiveSpace = RayFilterFlags.agent | RayFilterFlags.physical | RayFilterFlags.LSLPhantom;
+//        private const RayFilterFlags FilterStaticSpace = RayFilterFlags.water | RayFilterFlags.land | RayFilterFlags.nonphysical | RayFilterFlags.LSLPhanton;
+        private const RayFilterFlags FilterStaticSpace = RayFilterFlags.water | RayFilterFlags.nonphysical | RayFilterFlags.LSLPhantom;
+
+        private void doSpaceRay(ODERayRequest req)
+        {
+            // Collide tests
+            if ((CurrentRayFilter & FilterActiveSpace) != 0)
+            {
+                d.SpaceCollide2(ray, m_scene.ActiveSpace, IntPtr.Zero, nearCallback);
+                d.SpaceCollide2(ray, m_scene.CharsSpace, IntPtr.Zero, nearCallback);
+            }
+            if ((CurrentRayFilter & FilterStaticSpace) != 0 && (m_contactResults.Count < CurrentMaxCount))
+                d.SpaceCollide2(ray, m_scene.StaticSpace, IntPtr.Zero, nearCallback);
+            if ((CurrentRayFilter & RayFilterFlags.land) != 0 && (m_contactResults.Count < CurrentMaxCount))
+            {
+                // current ode land to ray collisions is very bad
+                // so for now limit its range badly
+
+                if (req.length > 30.0f)
+                    d.GeomRaySetLength(ray, 30.0f);
+
+                d.SpaceCollide2(ray, m_scene.GroundSpace, IntPtr.Zero, nearCallback);
+            }
+
+            if (req.callbackMethod is RaycastCallback)
+            {
+                // Define default results
+                bool hitYN = false;
+                uint hitConsumerID = 0;
+                float distance = float.MaxValue;
+                Vector3 closestcontact = Vector3.Zero;
+                Vector3 snormal = Vector3.Zero;
+
+                // Find closest contact and object.
+                lock (m_contactResults)
+                {
+                    foreach (ContactResult cResult in m_contactResults)
+                    {
+                        if(cResult.Depth < distance)
+                        {
+                            closestcontact = cResult.Pos;
+                            hitConsumerID = cResult.ConsumerID;
+                            distance = cResult.Depth;
+                            snormal = cResult.Normal;
+                        }
+                    }
+                    m_contactResults.Clear();
+                }
+
+                if (distance > 0 && distance < float.MaxValue)
+                    hitYN = true;
+                ((RaycastCallback)req.callbackMethod)(hitYN, closestcontact, hitConsumerID, distance, snormal);
+            }
+            else
+            {
+                List<ContactResult> cresult = new List<ContactResult>(m_contactResults.Count);
+                lock (m_PendingRequests)
+                {
+                    cresult.AddRange(m_contactResults);
+                    m_contactResults.Clear();
+                }
+                ((RayCallback)req.callbackMethod)(cresult);
+            }
+        }
+
+        private void doProbe(ODERayRequest req, IntPtr probe)
+        {
+            // Collide tests
+            if ((CurrentRayFilter & FilterActiveSpace) != 0)
+            {
+                d.SpaceCollide2(probe, m_scene.ActiveSpace, IntPtr.Zero, nearCallback);
+                d.SpaceCollide2(probe, m_scene.CharsSpace, IntPtr.Zero, nearCallback);
+            }
+            if ((CurrentRayFilter & FilterStaticSpace) != 0 && (m_contactResults.Count < CurrentMaxCount))
+                d.SpaceCollide2(probe, m_scene.StaticSpace, IntPtr.Zero, nearCallback);
+            if ((CurrentRayFilter & RayFilterFlags.land) != 0 && (m_contactResults.Count < CurrentMaxCount))
+                d.SpaceCollide2(probe, m_scene.GroundSpace, IntPtr.Zero, nearCallback);
+
+            List<ContactResult> cresult = new List<ContactResult>(m_contactResults.Count);
+            lock (m_PendingRequests)
+            {
+                cresult.AddRange(m_contactResults);
+                m_contactResults.Clear();
+            }
+            if (req.callbackMethod is ProbeBoxCallback)
+                ((ProbeBoxCallback)req.callbackMethod)(cresult);
+            else if (req.callbackMethod is ProbeSphereCallback)
+                ((ProbeSphereCallback)req.callbackMethod)(cresult);
+        }
+
+        private void doPlane(ODERayRequest req,IntPtr geom)
+        {
+            // Collide tests
+            if (geom == IntPtr.Zero)
+            {
+                if ((CurrentRayFilter & FilterActiveSpace) != 0)
+                {
+                    d.SpaceCollide2(Plane, m_scene.ActiveSpace, IntPtr.Zero, nearCallback);
+                    d.SpaceCollide2(Plane, m_scene.CharsSpace, IntPtr.Zero, nearCallback);
+                }
+                if ((CurrentRayFilter & FilterStaticSpace) != 0 && (m_contactResults.Count < CurrentMaxCount))
+                    d.SpaceCollide2(Plane, m_scene.StaticSpace, IntPtr.Zero, nearCallback);
+                if ((CurrentRayFilter & RayFilterFlags.land) != 0 && (m_contactResults.Count < CurrentMaxCount))
+                    d.SpaceCollide2(Plane, m_scene.GroundSpace, IntPtr.Zero, nearCallback);
+            }
+            else
+            {
+                d.SpaceCollide2(Plane, geom, IntPtr.Zero, nearCallback);
+            }
+
+            List<ContactResult> cresult = new List<ContactResult>(m_contactResults.Count);
+            lock (m_PendingRequests)
+            {
+                cresult.AddRange(m_contactResults);
+                m_contactResults.Clear();
+            }
+
+            ((ProbePlaneCallback)req.callbackMethod)(cresult);
+        }
+
+        /// <summary>
+        /// Method that actually initiates the raycast with a geom
+        /// </summary>
+        /// <param name="req"></param>
+        private void doGeomRay(ODERayRequest req, IntPtr geom)
+        {
+            // Collide test
+            d.SpaceCollide2(ray, geom, IntPtr.Zero, nearCallback); // still do this to have full AABB pre test
+
+            if (req.callbackMethod is RaycastCallback)
+            {
+                // Define default results
+                bool hitYN = false;
+                uint hitConsumerID = 0;
+                float distance = float.MaxValue;
+                Vector3 closestcontact = Vector3.Zero;
+                Vector3 snormal = Vector3.Zero;
+
+                // Find closest contact and object.
+                lock (m_contactResults)
+                {
+                    foreach (ContactResult cResult in m_contactResults)
+                    {
+                        if(cResult.Depth < distance )
+                        {
+                            closestcontact = cResult.Pos;
+                            hitConsumerID = cResult.ConsumerID;
+                            distance = cResult.Depth;
+                            snormal = cResult.Normal;
+                        }
+                    }
+                    m_contactResults.Clear();
+                }
+
+                if (distance > 0 && distance < float.MaxValue)
+                    hitYN = true;
+
+                ((RaycastCallback)req.callbackMethod)(hitYN, closestcontact, hitConsumerID, distance, snormal);
+            }
+            else
+            {
+                List<ContactResult> cresult = new List<ContactResult>(m_contactResults.Count);
+                lock (m_PendingRequests)
+                {
+                    cresult.AddRange(m_contactResults);
+                    m_contactResults.Clear();
+                }
+                ((RayCallback)req.callbackMethod)(cresult);
+            }
+        }
+
+        private bool GetCurContactGeom(int index, ref d.ContactGeom newcontactgeom)
+        {
+            IntPtr ContactgeomsArray = m_scene.ContactgeomsArray;
+            if (ContactgeomsArray == IntPtr.Zero || index >= CollisionContactGeomsPerTest)
+                return false;
+
+            IntPtr contactptr = new IntPtr(ContactgeomsArray.ToInt64() + (Int64)(index * d.ContactGeom.unmanagedSizeOf));
+            newcontactgeom = (d.ContactGeom)Marshal.PtrToStructure(contactptr, typeof(d.ContactGeom));
+            return true;
+        }
+        
+        // This is the standard Near. g1 is the ray
+        private void near(IntPtr space, IntPtr g1, IntPtr g2)
+        {
+             if (g2 == IntPtr.Zero || g1 == g2)
+                return;
+
+             if (m_contactResults.Count >= CurrentMaxCount)
+                return;
+
+            if (d.GeomIsSpace(g2))
+            {
+                try
+                {
+                    d.SpaceCollide2(g1, g2, IntPtr.Zero, nearCallback);
+                }
+                catch (Exception e)
+                {
+                    m_log.WarnFormat("[PHYSICS Ray]: Unable to Space collide test an object: {0}", e.Message);
+                }
+                return;
+            }
+
+            int count = 0;
+            try
+            {
+                count = d.CollidePtr(g1, g2, CollisionContactGeomsPerTest, m_scene.ContactgeomsArray, d.ContactGeom.unmanagedSizeOf);
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[PHYSICS Ray]: Unable to collide test an object: {0}", e.Message);
+                return;
+            }
+
+            if (count == 0)
+                return;
+/*
+            uint cat1 = d.GeomGetCategoryBits(g1);
+            uint cat2 = d.GeomGetCategoryBits(g2);
+            uint col1 = d.GeomGetCollideBits(g1);
+            uint col2 = d.GeomGetCollideBits(g2);
+*/
+            
+            uint ID = 0;
+            PhysicsActor p2 = null;
+
+            m_scene.actor_name_map.TryGetValue(g2, out p2);
+
+            if (p2 == null)
+                return;
+
+            switch (p2.PhysicsActorType)
+            {
+                case (int)ActorTypes.Prim:
+
+                    RayFilterFlags thisFlags;
+
+                    if (p2.IsPhysical)
+                        thisFlags = RayFilterFlags.physical;
+                    else
+                        thisFlags = RayFilterFlags.nonphysical;
+
+                    if (p2.Phantom)
+                        thisFlags |= RayFilterFlags.phantom;
+
+                    if (p2.IsVolumeDtc)
+                        thisFlags |= RayFilterFlags.volumedtc;
+
+                    if ((thisFlags & CurrentRayFilter) == 0)
+                        return;
+
+                    ID = ((OdePrim)p2).LocalID;
+                    break;
+
+                case (int)ActorTypes.Agent:
+
+                    if ((CurrentRayFilter & RayFilterFlags.agent) == 0)
+                        return;
+                    else
+                        ID = ((OdeCharacter)p2).LocalID;
+                    break;
+
+                case (int)ActorTypes.Ground:
+
+                    if ((CurrentRayFilter & RayFilterFlags.land) == 0)
+                        return;
+                    break;
+
+                case (int)ActorTypes.Water:
+
+                    if ((CurrentRayFilter & RayFilterFlags.water) == 0)
+                        return;
+                    break;
+
+                default:
+                    break;
+            }
+
+            d.ContactGeom curcontact = new d.ContactGeom();
+
+            // closestHit for now only works for meshs, so must do it for others
+            if ((CurrentRayFilter & RayFilterFlags.ClosestHit) == 0)
+            {
+                // Loop all contacts, build results.
+                for (int i = 0; i < count; i++)
+                {
+                    if (!GetCurContactGeom(i, ref curcontact))
+                        break;
+
+                    ContactResult collisionresult = new ContactResult();
+                    collisionresult.ConsumerID = ID;
+                    collisionresult.Pos.X = curcontact.pos.X;
+                    collisionresult.Pos.Y = curcontact.pos.Y;
+                    collisionresult.Pos.Z = curcontact.pos.Z;
+                    collisionresult.Depth = curcontact.depth;
+                    collisionresult.Normal.X = curcontact.normal.X;
+                    collisionresult.Normal.Y = curcontact.normal.Y;
+                    collisionresult.Normal.Z = curcontact.normal.Z;
+                    lock (m_contactResults)
+                    {
+                        m_contactResults.Add(collisionresult);
+                        if (m_contactResults.Count >= CurrentMaxCount)
+                            return;
+                    }
+                }
+            }
+            else
+            {
+                // keep only closest contact
+                ContactResult collisionresult = new ContactResult();
+                collisionresult.ConsumerID = ID;
+                collisionresult.Depth = float.MaxValue;
+
+                for (int i = 0; i < count; i++)
+                {
+                    if (!GetCurContactGeom(i, ref curcontact))
+                        break;
+
+                    if (curcontact.depth < collisionresult.Depth)
+                    {
+                        collisionresult.Pos.X = curcontact.pos.X;
+                        collisionresult.Pos.Y = curcontact.pos.Y;
+                        collisionresult.Pos.Z = curcontact.pos.Z;
+                        collisionresult.Depth = curcontact.depth;
+                        collisionresult.Normal.X = curcontact.normal.X;
+                        collisionresult.Normal.Y = curcontact.normal.Y;
+                        collisionresult.Normal.Z = curcontact.normal.Z;
+                    }
+                }
+
+                if (collisionresult.Depth != float.MaxValue)
+                {
+                    lock (m_contactResults)
+                        m_contactResults.Add(collisionresult);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Dereference the creator scene so that it can be garbage collected if needed.
+        /// </summary>
+        internal void Dispose()
+        {
+            m_scene = null;
+            if (ray != IntPtr.Zero)
+            {
+                d.GeomDestroy(ray);
+                ray = IntPtr.Zero;
+            }
+            if (Box != IntPtr.Zero)
+            {
+                d.GeomDestroy(Box);
+                Box = IntPtr.Zero;
+            }
+            if (Sphere != IntPtr.Zero)
+            {
+                d.GeomDestroy(Sphere);
+                Sphere = IntPtr.Zero;
+            }
+            if (Plane != IntPtr.Zero)
+            {
+                d.GeomDestroy(Plane);
+                Plane = IntPtr.Zero;
+            }           
+        }
+    }
+
+    public struct ODERayRequest
+    {
+        public PhysicsActor actor;
+        public Vector3 Origin;
+        public Vector3 Normal;
+        public int Count;
+        public float length;
+        public object callbackMethod;
+        public RayFilterFlags filter;
+        public Quaternion orientation;
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODESitAvatar.cs b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODESitAvatar.cs
new file mode 100644
index 0000000..d934d3e
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitOdePlugin/ODESitAvatar.cs
@@ -0,0 +1,356 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+// Ubit 2012
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OdeAPI;
+using log4net;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.OdePlugin
+{
+    /// <summary>
+    /// </summary>
+    public class ODESitAvatar
+    {
+        private OdeScene m_scene;
+        private ODERayCastRequestManager m_raymanager;
+
+        public ODESitAvatar(OdeScene pScene, ODERayCastRequestManager raymanager)
+        {
+            m_scene = pScene;
+            m_raymanager = raymanager;
+        }
+
+        private static Vector3 SitAjust = new Vector3(0, 0, 0.4f);
+        private const RayFilterFlags RaySitFlags = RayFilterFlags.AllPrims | RayFilterFlags.ClosestHit;
+
+        private void RotAroundZ(float x, float y, ref Quaternion ori)
+        {
+            double ang = Math.Atan2(y, x);
+            ang *= 0.5d;
+            float s = (float)Math.Sin(ang);
+            float c = (float)Math.Cos(ang);
+
+            ori.X = 0;
+            ori.Y = 0;
+            ori.Z = s;
+            ori.W = c;
+        }
+
+
+        public void Sit(PhysicsActor actor, Vector3 avPos, Vector3 avCameraPosition, Vector3 offset, Vector3 avOffset, SitAvatarCallback PhysicsSitResponse)
+        {
+            if (!m_scene.haveActor(actor) || !(actor is OdePrim) || ((OdePrim)actor).prim_geom == IntPtr.Zero)
+            {
+                PhysicsSitResponse(-1, actor.LocalID, offset, Quaternion.Identity);
+                return;
+            }
+
+            IntPtr geom = ((OdePrim)actor).prim_geom;
+
+            Vector3 geopos = d.GeomGetPositionOMV(geom);
+            Quaternion geomOri = d.GeomGetQuaternionOMV(geom);
+
+//            Vector3 geopos = actor.Position;
+//            Quaternion geomOri = actor.Orientation;
+
+            Quaternion geomInvOri = Quaternion.Conjugate(geomOri);
+
+            Quaternion ori = Quaternion.Identity;
+
+            Vector3 rayDir = geopos + offset - avCameraPosition;
+
+            float raylen = rayDir.Length();
+            if (raylen < 0.001f)
+            {
+                PhysicsSitResponse(-1, actor.LocalID, offset, Quaternion.Identity);
+                return;
+            }
+            float t = 1 / raylen;
+            rayDir.X *= t;
+            rayDir.Y *= t;
+            rayDir.Z *= t;
+
+            raylen += 30f; // focal point may be far
+            List<ContactResult> rayResults;
+
+            rayResults = m_scene.RaycastActor(actor, avCameraPosition, rayDir, raylen, 1, RaySitFlags);
+            if (rayResults.Count == 0)
+            {
+/* if this fundamental ray failed, then just fail so user can try another spot and not be sitted far on a big prim
+                d.AABB aabb;
+                d.GeomGetAABB(geom, out aabb);
+                offset = new Vector3(avOffset.X, 0, aabb.MaxZ + avOffset.Z - geopos.Z);
+                ori = geomInvOri;
+                offset *= geomInvOri;
+                PhysicsSitResponse(1, actor.LocalID, offset, ori);
+*/
+                PhysicsSitResponse(0, actor.LocalID, offset, ori);
+                return;
+            }
+
+            int status = 1;
+
+            offset = rayResults[0].Pos - geopos;
+
+            d.GeomClassID geoclass = d.GeomGetClass(geom);
+
+            if (geoclass == d.GeomClassID.SphereClass)
+            {
+                float r = d.GeomSphereGetRadius(geom);
+
+                offset.Normalize();
+                offset *= r;
+
+                RotAroundZ(offset.X, offset.Y, ref ori);
+
+                if (r < 0.4f)
+                {
+                    offset = new Vector3(0, 0, r);
+                }
+                else
+                {
+                    if (offset.Z < 0.4f)
+                    {
+                        t = offset.Z;
+                        float rsq = r * r;
+
+                        t = 1.0f / (rsq - t * t);
+                        offset.X *= t;
+                        offset.Y *= t;
+                        offset.Z = 0.4f;
+                        t = rsq - 0.16f;
+                        offset.X *= t;
+                        offset.Y *= t;
+                    }
+                    else if (r > 0.8f && offset.Z > 0.8f * r)
+                    {
+                        status = 3;
+                        avOffset.X = -avOffset.X;
+                        avOffset.Z *= 1.6f;
+                    }
+                }
+
+                offset += avOffset * ori;
+
+                ori = geomInvOri * ori;
+                offset *= geomInvOri;
+
+                PhysicsSitResponse(status, actor.LocalID, offset, ori);
+                return;
+            }
+
+            Vector3 norm = rayResults[0].Normal;
+
+            if (norm.Z < -0.4f)
+            {
+                PhysicsSitResponse(0, actor.LocalID, offset, Quaternion.Identity);
+                return;
+            }
+
+
+            float SitNormX = -rayDir.X;
+            float SitNormY = -rayDir.Y;
+
+            Vector3 pivot = geopos + offset;
+
+            float edgeNormalX = norm.X;
+            float edgeNormalY = norm.Y;
+            float edgeDirX = -rayDir.X;
+            float edgeDirY = -rayDir.Y;
+            Vector3 edgePos = rayResults[0].Pos;
+            float edgeDist = float.MaxValue;
+
+            bool foundEdge = false;
+
+            if (norm.Z < 0.5f)
+            {
+                float rayDist = 4.0f;
+
+                for (int i = 0; i < 6; i++)
+                {
+                    pivot.X -= 0.01f * norm.X;
+                    pivot.Y -= 0.01f * norm.Y;
+                    pivot.Z -= 0.01f * norm.Z;
+
+                    rayDir.X = -norm.X * norm.Z;
+                    rayDir.Y = -norm.Y * norm.Z;
+                    rayDir.Z = 1.0f - norm.Z * norm.Z;
+                    rayDir.Normalize();
+
+                    rayResults = m_scene.RaycastActor(actor, pivot, rayDir, rayDist, 1, RayFilterFlags.AllPrims);
+                    if (rayResults.Count == 0)
+                        break;
+
+                    if (Math.Abs(rayResults[0].Normal.Z) < 0.7f)
+                    {
+                        rayDist -= rayResults[0].Depth;
+                        if (rayDist < 0f)
+                            break;
+
+                        pivot = rayResults[0].Pos;
+                        norm = rayResults[0].Normal;
+                        edgeNormalX = norm.X;
+                        edgeNormalY = norm.Y;
+                        edgeDirX = -rayDir.X;
+                        edgeDirY = -rayDir.Y;
+                    }
+                    else
+                    {
+                        foundEdge = true;
+                        edgePos = rayResults[0].Pos;
+                        break;
+                    }
+                }
+
+                if (!foundEdge)
+                {
+                    PhysicsSitResponse(0, actor.LocalID, offset, ori);
+                    return;
+                }
+                avOffset.X *= 0.5f;
+            }
+
+            else if (norm.Z > 0.866f)
+            {
+                float toCamBaseX = avCameraPosition.X - pivot.X;
+                float toCamBaseY = avCameraPosition.Y - pivot.Y;
+                float toCamX = toCamBaseX;
+                float toCamY = toCamBaseY;
+
+                for (int j = 0; j < 4; j++)
+                {
+                    float rayDist = 1.0f;
+                    float curEdgeDist = 0.0f;
+
+                    for (int i = 0; i < 3; i++)
+                    {
+                        pivot.Z -= 0.01f;
+                        rayDir.X = toCamX;
+                        rayDir.Y = toCamY;
+                        rayDir.Z = (-toCamX * norm.X - toCamY * norm.Y) / norm.Z;
+                        rayDir.Normalize();
+
+                        rayResults = m_scene.RaycastActor(actor, pivot, rayDir, rayDist, 1, RayFilterFlags.AllPrims);
+                        if (rayResults.Count == 0)
+                            break;
+
+                        curEdgeDist += rayResults[0].Depth;
+
+                        if (rayResults[0].Normal.Z > 0.5f)
+                        {
+                            rayDist -= rayResults[0].Depth;
+                            if (rayDist < 0f)
+                                break;
+
+                            pivot = rayResults[0].Pos;
+                            norm = rayResults[0].Normal;
+                        }
+                        else
+                        {
+                            foundEdge = true;
+                            if (curEdgeDist < edgeDist)
+                            {
+                                edgeDist = curEdgeDist;
+                                edgeNormalX = rayResults[0].Normal.X;
+                                edgeNormalY = rayResults[0].Normal.Y;
+                                edgeDirX = rayDir.X;
+                                edgeDirY = rayDir.Y;
+                                edgePos = rayResults[0].Pos;
+                            }
+                            break;
+                        }
+                    }
+                    if (foundEdge && edgeDist < 0.2f)
+                        break;
+
+                    pivot = geopos + offset;
+
+                    switch (j)
+                    {
+                        case 0:
+                            toCamX = -toCamBaseY;
+                            toCamY = toCamBaseX;
+                            break;
+                        case 1:
+                            toCamX = toCamBaseY;
+                            toCamY = -toCamBaseX;
+                            break;
+                        case 2:
+                            toCamX = -toCamBaseX;
+                            toCamY = -toCamBaseY;
+                            break;
+                        default:
+                            break;
+                    }
+                }
+
+                if (!foundEdge)
+                {
+                    avOffset.X = -avOffset.X;
+                    avOffset.Z *= 1.6f;
+
+                    RotAroundZ(SitNormX, SitNormY, ref ori);
+
+                    offset += avOffset * ori;
+
+                    ori = geomInvOri * ori;
+                    offset *= geomInvOri;
+
+                    PhysicsSitResponse(3, actor.LocalID, offset, ori);
+                    return;
+                }
+                avOffset.X *= 0.5f;
+            }
+
+            SitNormX = edgeNormalX;
+            SitNormY = edgeNormalY;
+            if (edgeDirX * SitNormX + edgeDirY * SitNormY < 0)
+            {
+                SitNormX = -SitNormX;
+                SitNormY = -SitNormY;
+            }
+
+            RotAroundZ(SitNormX, SitNormY, ref ori);
+
+            offset = edgePos + avOffset * ori;
+            offset -= geopos;
+
+            ori = geomInvOri * ori;
+            offset *= geomInvOri;
+
+            PhysicsSitResponse(1, actor.LocalID, offset, ori);
+            return;
+        }
+    }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitOdePlugin/OdeApi.cs b/OpenSim/Region/PhysicsModules/UbitOdePlugin/OdeApi.cs
new file mode 100644
index 0000000..10d7d50
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitOdePlugin/OdeApi.cs
@@ -0,0 +1,2025 @@
+/*
+ * based on:
+ * Ode.NET - .NET bindings for ODE
+ * Jason Perkins (starkos@industriousone.com)
+  *  Licensed under the New BSD
+ *  Part of the OpenDynamicsEngine
+Open Dynamics Engine
+Copyright (c) 2001-2007, Russell L. Smith.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+Neither the names of ODE's copyright owner nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * changes by opensim team; 
+ * changes by Aurora team http://www.aurora-sim.org/
+  
+ * Revision/fixs by Ubit Umarov
+ */
+
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+using OMV = OpenMetaverse;
+namespace OdeAPI
+{
+//#if dDOUBLE
+// don't see much use in double precision with time steps of 20ms and 10 iterations used on opensim
+// at least we save same memory and memory access time, FPU performance on intel usually is similar
+//      using dReal = System.Double;
+//#else
+        using dReal = System.Single;
+//#endif
+
+        public static class d
+        {
+                public static dReal Infinity = dReal.MaxValue;
+        public static int NTotalBodies = 0;
+        public static int NTotalGeoms = 0;
+
+        public const uint CONTACTS_UNIMPORTANT = 0x80000000;
+
+                #region Flags and Enumerations
+
+        [Flags]
+        public enum AllocateODEDataFlags : uint
+        {
+            BasicData = 0,
+            CollisionData = 0x00000001,
+            All = ~0u
+        }
+
+        [Flags]
+        public enum IniteODEFlags : uint
+        {
+            dInitFlagManualThreadCleanup = 0x00000001
+        }
+
+                [Flags]
+                public enum ContactFlags : int
+                {
+                        Mu2 = 0x001,
+                        FDir1 = 0x002,
+                        Bounce = 0x004,
+                        SoftERP = 0x008,
+                        SoftCFM = 0x010,
+                        Motion1 = 0x020,
+                        Motion2 = 0x040,
+            MotionN = 0x080,
+                        Slip1 = 0x100,
+                        Slip2 = 0x200,
+                        Approx0 = 0x0000,
+                        Approx1_1 = 0x1000,
+                        Approx1_2 = 0x2000,
+                        Approx1 = 0x3000
+                }
+
+                public enum GeomClassID : int
+                {
+                        SphereClass,
+                        BoxClass,
+                        CapsuleClass,
+                        CylinderClass,
+                        PlaneClass,
+                        RayClass,
+                        ConvexClass,
+                        GeomTransformClass,
+                        TriMeshClass,
+            HeightfieldClass,
+                        FirstSpaceClass,
+                        SimpleSpaceClass = FirstSpaceClass,
+                        HashSpaceClass,
+                        QuadTreeSpaceClass,
+                        LastSpaceClass = QuadTreeSpaceClass,
+            UbitTerrainClass,
+                        FirstUserClass,
+                        LastUserClass = FirstUserClass + MaxUserClasses - 1,
+                        NumClasses,
+                        MaxUserClasses = 5
+                }
+
+                public enum JointType : int
+                {
+                        None,
+                        Ball,
+                        Hinge,
+                        Slider,
+                        Contact,
+                        Universal,
+                        Hinge2,
+                        Fixed,
+                        Null,
+                        AMotor,
+                        LMotor,
+                        Plane2D
+                }
+
+                public enum JointParam : int
+                {
+                        LoStop,
+                        HiStop,
+                        Vel,
+                        FMax,
+                        FudgeFactor,
+                        Bounce,
+                        CFM,
+                        StopERP,
+                        StopCFM,
+                        SuspensionERP,
+                        SuspensionCFM,
+                        LoStop2 = 256,
+                        HiStop2,
+                        Vel2,
+                        FMax2,
+                        FudgeFactor2,
+                        Bounce2,
+                        CFM2,
+                        StopERP2,
+                        StopCFM2,
+                        SuspensionERP2,
+                        SuspensionCFM2,
+                        LoStop3 = 512,
+                        HiStop3,
+                        Vel3,
+                        FMax3,
+                        FudgeFactor3,
+                        Bounce3,
+                        CFM3,
+                        StopERP3,
+                        StopCFM3,
+                        SuspensionERP3,
+                        SuspensionCFM3
+                }
+
+        public enum dSweepAndPruneAxis : int
+        {
+            XYZ = ((0)|(1<<2)|(2<<4)),
+            XZY = ((0)|(2<<2)|(1<<4)),
+            YXZ = ((1)|(0<<2)|(2<<4)),
+            YZX = ((1)|(2<<2)|(0<<4)),
+            ZXY = ((2)|(0<<2)|(1<<4)),
+            ZYX = ((2)|(1<<2)|(0<<4))
+        }
+
+                #endregion
+
+                #region Callbacks
+
+                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+                public delegate int AABBTestFn(IntPtr o1, IntPtr o2, ref AABB aabb);
+
+                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+                public delegate int ColliderFn(IntPtr o1, IntPtr o2, int flags, out ContactGeom contact, int skip);
+
+                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+                public delegate void GetAABBFn(IntPtr geom, out AABB aabb);
+
+                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+                public delegate ColliderFn GetColliderFnFn(int num);
+
+                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+                public delegate void GeomDtorFn(IntPtr o);
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate dReal HeightfieldGetHeight(IntPtr p_user_data, int x, int z);
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate dReal UbitTerrainGetHeight(IntPtr p_user_data, int x, int z);
+
+                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+                public delegate void NearCallback(IntPtr data, IntPtr geom1, IntPtr geom2);
+
+                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+                public delegate int TriCallback(IntPtr trimesh, IntPtr refObject, int triangleIndex);
+
+                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+                public delegate int TriArrayCallback(IntPtr trimesh, IntPtr refObject, int[] triangleIndex, int triCount);
+
+                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+                public delegate int TriRayCallback(IntPtr trimesh, IntPtr ray, int triangleIndex, dReal u, dReal v);
+
+                #endregion
+
+                #region Structs
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct AABB
+                {
+                        public dReal MinX, MaxX;
+                        public dReal MinY, MaxY;
+                        public dReal MinZ, MaxZ;
+                }
+
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct Contact
+                {
+                        public SurfaceParameters surface;
+                        public ContactGeom geom;
+                        public Vector3 fdir1;
+            public static readonly int unmanagedSizeOf = Marshal.SizeOf(typeof(Contact));
+                }
+
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct ContactGeom
+                {
+
+                        public Vector3 pos;
+                        public Vector3 normal;
+                        public dReal depth;
+                        public IntPtr g1;
+                        public IntPtr g2;
+                        public int side1;
+                        public int side2;
+            public static readonly int unmanagedSizeOf = Marshal.SizeOf(typeof(ContactGeom));
+        }
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct GeomClass
+                {
+                        public int bytes;
+                        public GetColliderFnFn collider;
+                        public GetAABBFn aabb;
+                        public AABBTestFn aabb_test;
+                        public GeomDtorFn dtor;
+                }
+
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct JointFeedback 
+                {
+                        public Vector3 f1;
+                        public Vector3 t1;
+                        public Vector3 f2;
+                        public Vector3 t2;
+                }
+
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct Mass
+                {
+                        public dReal mass;
+                        public Vector4 c;
+                        public Matrix3 I;
+                }
+
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct Matrix3
+                {
+                        public Matrix3(dReal m00, dReal m10, dReal m20, dReal m01, dReal m11, dReal m21, dReal m02, dReal m12, dReal m22)
+                        {
+                                M00 = m00;  M10 = m10;  M20 = m20;  _m30 = 0.0f;
+                                M01 = m01;  M11 = m11;  M21 = m21;  _m31 = 0.0f;
+                                M02 = m02;  M12 = m12;  M22 = m22;  _m32 = 0.0f;
+                        }
+                        public dReal M00, M10, M20;
+                        private dReal _m30;
+                        public dReal M01, M11, M21;
+                        private dReal _m31;
+                        public dReal M02, M12, M22;
+                        private dReal _m32;
+                }
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct Matrix4
+                {
+                        public Matrix4(dReal m00, dReal m10, dReal m20, dReal m30,
+                                dReal m01, dReal m11, dReal m21, dReal m31,
+                                dReal m02, dReal m12, dReal m22, dReal m32,
+                                dReal m03, dReal m13, dReal m23, dReal m33)
+                        {
+                                M00 = m00; M10 = m10; M20 = m20; M30 = m30;
+                                M01 = m01; M11 = m11; M21 = m21; M31 = m31;
+                                M02 = m02; M12 = m12; M22 = m22; M32 = m32;
+                                M03 = m03; M13 = m13; M23 = m23; M33 = m33;
+                        }
+                        public dReal M00, M10, M20, M30;
+                        public dReal M01, M11, M21, M31;
+                        public dReal M02, M12, M22, M32;
+                        public dReal M03, M13, M23, M33;
+                }
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct Quaternion
+                {
+                        public dReal W, X, Y, Z;
+                }
+
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct SurfaceParameters
+                {
+                        public ContactFlags mode;
+                        public dReal mu;
+                        public dReal mu2;
+                        public dReal bounce;
+                        public dReal bounce_vel;
+                        public dReal soft_erp;
+                        public dReal soft_cfm;
+                        public dReal motion1;
+                        public dReal motion2;
+            public dReal motionN;
+                        public dReal slip1;
+                        public dReal slip2;
+                }
+
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct Vector3
+                {
+                        public Vector3(dReal x, dReal y, dReal z)
+                        {
+                                X = x;  Y = y;  Z = z;  _w = 0.0f;
+                        }
+                        public dReal X, Y, Z;
+                        private dReal _w;
+                }
+
+
+                [StructLayout(LayoutKind.Sequential)]
+                public struct Vector4
+                {
+                        public Vector4(dReal x, dReal y, dReal z, dReal w)
+                        {
+                                X = x;  Y = y;  Z = z;  W = w;
+                        }
+                        public dReal X, Y, Z, W;
+                }
+
+                #endregion
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dAllocateODEDataForThread"), SuppressUnmanagedCodeSecurity]
+        public static extern int AllocateODEDataForThread(uint ODEInitFlags);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dAreConnected"), SuppressUnmanagedCodeSecurity]
+                public static extern bool AreConnected(IntPtr b1, IntPtr b2);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dAreConnectedExcluding"), SuppressUnmanagedCodeSecurity]
+                public static extern bool AreConnectedExcluding(IntPtr b1, IntPtr b2, JointType joint_type);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddForce"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyAddForce(IntPtr body, dReal fx, dReal fy, dReal fz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddForceAtPos"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyAddForceAtPos(IntPtr body, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddForceAtRelPos"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyAddForceAtRelPos(IntPtr body, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddRelForce"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyAddRelForce(IntPtr body, dReal fx, dReal fy, dReal fz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddRelForceAtPos"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyAddRelForceAtPos(IntPtr body, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddRelForceAtRelPos"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyAddRelForceAtRelPos(IntPtr body, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddRelTorque"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyAddRelTorque(IntPtr body, dReal fx, dReal fy, dReal fz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyAddTorque"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyAddTorque(IntPtr body, dReal fx, dReal fy, dReal fz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyCopyPosition(IntPtr body, out Vector3 pos);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyCopyPosition(IntPtr body, out dReal X);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyCopyQuaternion(IntPtr body, out Quaternion quat);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyCopyQuaternion(IntPtr body, out dReal X);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyCopyRotation(IntPtr body, out Matrix3 R);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCopyRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyCopyRotation(IntPtr body, out dReal M00);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyCreate"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr BodyiCreate(IntPtr world);
+        public static IntPtr BodyCreate(IntPtr world)
+        {
+            NTotalBodies++;
+            return BodyiCreate(world);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyDestroy"), SuppressUnmanagedCodeSecurity]
+        public static extern void BodyiDestroy(IntPtr body);
+        public static void BodyDestroy(IntPtr body)
+        {
+            NTotalBodies--;
+            BodyiDestroy(body);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyDisable"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyDisable(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyEnable"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyEnable(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableAngularThreshold"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal BodyGetAutoDisableAngularThreshold(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableFlag"), SuppressUnmanagedCodeSecurity]
+                public static extern bool BodyGetAutoDisableFlag(IntPtr body);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableDefaults"), SuppressUnmanagedCodeSecurity]
+        public static extern void BodyGetAutoDisableDefaults(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableLinearThreshold"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal BodyGetAutoDisableLinearThreshold(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableSteps"), SuppressUnmanagedCodeSecurity]
+                public static extern int BodyGetAutoDisableSteps(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAutoDisableTime"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal BodyGetAutoDisableTime(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAngularVel"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Vector3* BodyGetAngularVelUnsafe(IntPtr body);
+                public static Vector3 BodyGetAngularVel(IntPtr body)
+                {
+                        unsafe { return *(BodyGetAngularVelUnsafe(body)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetData"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr BodyGetData(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetFiniteRotationMode"), SuppressUnmanagedCodeSecurity]
+                public static extern int BodyGetFiniteRotationMode(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetFiniteRotationAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyGetFiniteRotationAxis(IntPtr body, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetForce"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Vector3* BodyGetForceUnsafe(IntPtr body);
+                public static Vector3 BodyGetForce(IntPtr body)
+                {
+                        unsafe { return *(BodyGetForceUnsafe(body)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetGravityMode"), SuppressUnmanagedCodeSecurity]
+                public static extern bool BodyGetGravityMode(IntPtr body);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetGyroscopicMode"), SuppressUnmanagedCodeSecurity]
+        public static extern int BodyGetGyroscopicMode(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetJoint"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr BodyGetJoint(IntPtr body, int index);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetLinearVel"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Vector3* BodyGetLinearVelUnsafe(IntPtr body);
+                public static Vector3 BodyGetLinearVel(IntPtr body)
+                {
+                        unsafe { return *(BodyGetLinearVelUnsafe(body)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetMass"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyGetMass(IntPtr body, out Mass mass);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetNumJoints"), SuppressUnmanagedCodeSecurity]
+                public static extern int BodyGetNumJoints(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetPointVel"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyGetPointVel(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetPosition"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Vector3* BodyGetPositionUnsafe(IntPtr body);
+                public static Vector3 BodyGetPosition(IntPtr body)
+                {
+                        unsafe { return *(BodyGetPositionUnsafe(body)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetPosRelPoint"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyGetPosRelPoint(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetQuaternion"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Quaternion* BodyGetQuaternionUnsafe(IntPtr body);
+                public static Quaternion BodyGetQuaternion(IntPtr body)
+                {
+                        unsafe { return *(BodyGetQuaternionUnsafe(body)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetRelPointPos"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyGetRelPointPos(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetRelPointVel"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyGetRelPointVel(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetRotation"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Matrix3* BodyGetRotationUnsafe(IntPtr body);
+                public static Matrix3 BodyGetRotation(IntPtr body)
+                {
+                        unsafe { return *(BodyGetRotationUnsafe(body)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetTorque"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Vector3* BodyGetTorqueUnsafe(IntPtr body);
+                public static Vector3 BodyGetTorque(IntPtr body)
+                {
+                        unsafe { return *(BodyGetTorqueUnsafe(body)); }
+                }
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetWorld"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr BodyGetWorld(IntPtr body);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetFirstGeom"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr BodyGetFirstGeom(IntPtr body);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetNextGeom"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr dBodyGetNextGeom(IntPtr Geom);
+
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyIsEnabled"), SuppressUnmanagedCodeSecurity]
+                public static extern bool BodyIsEnabled(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAngularVel"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetAngularVel(IntPtr body, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableAngularThreshold"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetAutoDisableAngularThreshold(IntPtr body, dReal angular_threshold);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableDefaults"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetAutoDisableDefaults(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableFlag"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetAutoDisableFlag(IntPtr body, bool do_auto_disable);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableLinearThreshold"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetAutoDisableLinearThreshold(IntPtr body, dReal linear_threshold);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableSteps"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetAutoDisableSteps(IntPtr body, int steps);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAutoDisableTime"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetAutoDisableTime(IntPtr body, dReal time);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetData"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetData(IntPtr body, IntPtr data);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetFiniteRotationMode"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetFiniteRotationMode(IntPtr body, int mode);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetFiniteRotationAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetFiniteRotationAxis(IntPtr body, dReal x, dReal y, dReal z);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetLinearDamping"), SuppressUnmanagedCodeSecurity]
+        public static extern void BodySetLinearDamping(IntPtr body, dReal scale);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAngularDamping"), SuppressUnmanagedCodeSecurity]
+        public static extern void BodySetAngularDamping(IntPtr body, dReal scale);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetLinearDamping"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal BodyGetLinearDamping(IntPtr body);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAngularDamping"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal BodyGetAngularDamping(IntPtr body);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAngularDamping"), SuppressUnmanagedCodeSecurity]
+        public static extern void BodySetDamping(IntPtr body, dReal linear_scale, dReal angular_scale);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetAngularDampingThreshold"), SuppressUnmanagedCodeSecurity]
+        public static extern void BodySetAngularDampingThreshold(IntPtr body, dReal threshold);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetLinearDampingThreshold"), SuppressUnmanagedCodeSecurity]
+        public static extern void BodySetLinearDampingThreshold(IntPtr body, dReal threshold);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetLinearDampingThreshold"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal BodyGetLinearDampingThreshold(IntPtr body);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyGetAngularDampingThreshold"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal BodyGetAngularDampingThreshold(IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetForce"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetForce(IntPtr body, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetGravityMode"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetGravityMode(IntPtr body, bool mode);
+
+        /// <summary>
+        /// Sets the Gyroscopic term status on the body specified.
+        /// </summary>
+        /// <param name="body">Pointer to body</param>
+        /// <param name="enabled">NonZero enabled, Zero disabled</param>
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetGyroscopicMode"), SuppressUnmanagedCodeSecurity]
+        public static extern void dBodySetGyroscopicMode(IntPtr body, int enabled);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetLinearVel"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetLinearVel(IntPtr body, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetMass"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetMass(IntPtr body, ref Mass mass);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetPosition(IntPtr body, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetQuaternion(IntPtr body, ref Quaternion q);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetQuaternion(IntPtr body, ref dReal w);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetRotation(IntPtr body, ref Matrix3 R);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetRotation(IntPtr body, ref dReal M00);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodySetTorque"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodySetTorque(IntPtr body, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyVectorFromWorld"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyVectorFromWorld(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyVectorToWorld"), SuppressUnmanagedCodeSecurity]
+                public static extern void BodyVectorToWorld(IntPtr body, dReal px, dReal py, dReal pz, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBoxBox"), SuppressUnmanagedCodeSecurity]
+                public static extern void BoxBox(ref Vector3 p1, ref Matrix3 R1,
+                        ref Vector3 side1, ref Vector3 p2,
+                        ref Matrix3 R2, ref Vector3 side2,
+                        ref Vector3 normal, out dReal depth, out int return_code,
+                        int maxc, out ContactGeom contact, int skip);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBoxTouchesBox"), SuppressUnmanagedCodeSecurity]
+                public static extern void BoxTouchesBox(ref Vector3 _p1, ref Matrix3 R1,
+                        ref Vector3 side1, ref Vector3 _p2,
+                        ref Matrix3 R2, ref Vector3 side2);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCleanupODEAllDataForThread"), SuppressUnmanagedCodeSecurity]
+                public static extern void CleanupODEAllDataForThread();
+        
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dClosestLineSegmentPoints"), SuppressUnmanagedCodeSecurity]
+                public static extern void ClosestLineSegmentPoints(ref Vector3 a1, ref Vector3 a2, 
+                        ref Vector3 b1, ref Vector3 b2, 
+                        ref Vector3 cp1, ref Vector3 cp2);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCloseODE"), SuppressUnmanagedCodeSecurity]
+                public static extern void CloseODE();
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCollide"), SuppressUnmanagedCodeSecurity]
+        public static extern int Collide(IntPtr o1, IntPtr o2, int flags, [In, Out] ContactGeom[] contact, int skip);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCollide"), SuppressUnmanagedCodeSecurity]
+        public static extern int CollidePtr(IntPtr o1, IntPtr o2, int flags, IntPtr contactgeomarray, int skip);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dConnectingJoint"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr ConnectingJoint(IntPtr j1, IntPtr j2);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateBox"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr CreateiBox(IntPtr space, dReal lx, dReal ly, dReal lz);
+                public static IntPtr CreateBox(IntPtr space, dReal lx, dReal ly, dReal lz)
+        {
+            NTotalGeoms++;
+            return CreateiBox(space, lx, ly, lz);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateCapsule"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr CreateiCapsule(IntPtr space, dReal radius, dReal length);
+        public static IntPtr CreateCapsule(IntPtr space, dReal radius, dReal length)
+        {
+            NTotalGeoms++;
+            return CreateiCapsule(space, radius, length);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateConvex"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr CreateiConvex(IntPtr space, dReal[] planes, int planeCount, dReal[] points, int pointCount, int[] polygons);
+        public static IntPtr CreateConvex(IntPtr space, dReal[] planes, int planeCount, dReal[] points, int pointCount, int[] polygons)
+        {
+            NTotalGeoms++;
+            return CreateiConvex(space, planes, planeCount, points, pointCount, polygons);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateCylinder"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr CreateiCylinder(IntPtr space, dReal radius, dReal length);
+        public static IntPtr CreateCylinder(IntPtr space, dReal radius, dReal length)
+        {
+            NTotalGeoms++;
+            return CreateiCylinder(space, radius, length);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateHeightfield"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr CreateiHeightfield(IntPtr space, IntPtr data, int bPlaceable);
+        public static IntPtr CreateHeightfield(IntPtr space, IntPtr data, int bPlaceable)
+        {
+            NTotalGeoms++;
+            return CreateiHeightfield(space, data, bPlaceable);
+        }
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateUbitTerrain"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr CreateiUbitTerrain(IntPtr space, IntPtr data, int bPlaceable);
+        public static IntPtr CreateUbitTerrain(IntPtr space, IntPtr data, int bPlaceable)
+        {
+            NTotalGeoms++;
+            return CreateiUbitTerrain(space, data, bPlaceable);
+        }
+
+
+
+        
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateGeom"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr CreateiGeom(int classnum);
+        public static IntPtr CreateGeom(int classnum)
+        {
+            NTotalGeoms++;
+            return CreateiGeom(classnum);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateGeomClass"), SuppressUnmanagedCodeSecurity]
+                public static extern int CreateGeomClass(ref GeomClass classptr);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateGeomTransform"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr CreateGeomTransform(IntPtr space);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreatePlane"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr CreateiPlane(IntPtr space, dReal a, dReal b, dReal c, dReal d);
+        public static IntPtr CreatePlane(IntPtr space, dReal a, dReal b, dReal c, dReal d)
+        {
+            NTotalGeoms++;
+            return CreateiPlane(space, a, b, c, d);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateRay"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr CreateiRay(IntPtr space, dReal length);
+        public static IntPtr CreateRay(IntPtr space, dReal length)
+        {
+            NTotalGeoms++;
+            return CreateiRay(space, length);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateSphere"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr CreateiSphere(IntPtr space, dReal radius);
+        public static IntPtr CreateSphere(IntPtr space, dReal radius)
+        {
+            NTotalGeoms++;
+            return CreateiSphere(space, radius);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateTriMesh"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr CreateiTriMesh(IntPtr space, IntPtr data, 
+                        TriCallback callback, TriArrayCallback arrayCallback, TriRayCallback rayCallback);
+        public static IntPtr CreateTriMesh(IntPtr space, IntPtr data,
+            TriCallback callback, TriArrayCallback arrayCallback, TriRayCallback rayCallback)
+        {
+            NTotalGeoms++;
+            return CreateiTriMesh(space, data, callback, arrayCallback, rayCallback);
+        }
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dDot"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal Dot(ref dReal X0, ref dReal X1, int n);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dDQfromW"), SuppressUnmanagedCodeSecurity]
+                public static extern void DQfromW(dReal[] dq, ref Vector3 w, ref Quaternion q);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dFactorCholesky"), SuppressUnmanagedCodeSecurity]
+                public static extern int FactorCholesky(ref dReal A00, int n);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dFactorLDLT"), SuppressUnmanagedCodeSecurity]
+                public static extern void FactorLDLT(ref dReal A, out dReal d, int n, int nskip);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomBoxGetLengths"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomBoxGetLengths(IntPtr geom, out Vector3 len);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomBoxGetLengths"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomBoxGetLengths(IntPtr geom, out dReal x);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomBoxPointDepth"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal GeomBoxPointDepth(IntPtr geom, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomBoxSetLengths"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomBoxSetLengths(IntPtr geom, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCapsuleGetParams"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCapsuleGetParams(IntPtr geom, out dReal radius, out dReal length);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCapsulePointDepth"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal GeomCapsulePointDepth(IntPtr geom, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCapsuleSetParams"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCapsuleSetParams(IntPtr geom, dReal radius, dReal length);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomClearOffset"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomClearOffset(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyOffsetPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomCopyOffsetPosition(IntPtr geom, ref Vector3 pos);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyOffsetPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomCopyOffsetPosition(IntPtr geom, ref dReal X);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetOffsetQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCopyOffsetQuaternion(IntPtr geom, ref Quaternion Q);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetOffsetQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCopyOffsetQuaternion(IntPtr geom, ref dReal X);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyOffsetRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomCopyOffsetRotation(IntPtr geom, ref Matrix3 R);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyOffsetRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomCopyOffsetRotation(IntPtr geom, ref dReal M00);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCopyPosition(IntPtr geom, out Vector3 pos);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCopyPosition(IntPtr geom, out dReal X);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCopyRotation(IntPtr geom, out Matrix3 R);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCopyRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCopyRotation(IntPtr geom, out dReal M00);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCylinderGetParams"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCylinderGetParams(IntPtr geom, out dReal radius, out dReal length);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomCylinderSetParams"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCylinderSetParams(IntPtr geom, dReal radius, dReal length);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomDestroy"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomiDestroy(IntPtr geom);
+        public static void GeomDestroy(IntPtr geom)
+        {
+            NTotalGeoms--;
+            GeomiDestroy(geom);
+        }
+
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomDisable"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomDisable(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomEnable"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomEnable(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetAABB"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomGetAABB(IntPtr geom, out AABB aabb);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetAABB"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomGetAABB(IntPtr geom, out dReal minX);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetBody"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomGetBody(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetCategoryBits"), SuppressUnmanagedCodeSecurity]
+                public static extern uint GeomGetCategoryBits(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetClassData"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomGetClassData(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetCollideBits"), SuppressUnmanagedCodeSecurity]
+                public static extern uint GeomGetCollideBits(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetClass"), SuppressUnmanagedCodeSecurity]
+                public static extern GeomClassID GeomGetClass(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetData"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr GeomGetData(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetOffsetPosition"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Vector3* GeomGetOffsetPositionUnsafe(IntPtr geom);
+                public static Vector3 GeomGetOffsetPosition(IntPtr geom)
+                {
+                        unsafe { return *(GeomGetOffsetPositionUnsafe(geom)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetOffsetRotation"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Matrix3* GeomGetOffsetRotationUnsafe(IntPtr geom);
+                public static Matrix3 GeomGetOffsetRotation(IntPtr geom)
+                {
+                        unsafe { return *(GeomGetOffsetRotationUnsafe(geom)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetPosition"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Vector3* GeomGetPositionUnsafe(IntPtr geom);
+                public static Vector3 GeomGetPosition(IntPtr geom)
+                {
+                        unsafe { return *(GeomGetPositionUnsafe(geom)); }
+                }
+                public static OMV.Vector3 GeomGetPositionOMV(IntPtr geom)
+                {
+            Vector3 vtmp = GeomGetPosition(geom);
+            return new OMV.Vector3(vtmp.X, vtmp.Y, vtmp.Z);
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetQuaternion"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomCopyQuaternion(IntPtr geom, out Quaternion q);
+        public static OMV.Quaternion GeomGetQuaternionOMV(IntPtr geom)
+        {
+            Quaternion qtmp;
+            GeomCopyQuaternion(geom, out qtmp);
+            return new OMV.Quaternion(qtmp.X, qtmp.Y, qtmp.Z, qtmp.W);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomCopyQuaternion(IntPtr geom, out dReal X);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetRotation"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Matrix3* GeomGetRotationUnsafe(IntPtr geom);
+                public static Matrix3 GeomGetRotation(IntPtr geom)
+                {
+                        unsafe { return *(GeomGetRotationUnsafe(geom)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetSpace"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomGetSpace(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildByte"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataBuildByte(IntPtr d, byte[] pHeightData, int bCopyHeightData,
+                                dReal width, dReal depth, int widthSamples, int depthSamples,
+                                dReal scale, dReal offset, dReal thickness, int bWrap);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildByte"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataBuildByte(IntPtr d, IntPtr pHeightData, int bCopyHeightData,
+                                dReal width, dReal depth, int widthSamples, int depthSamples,
+                                dReal scale, dReal offset, dReal thickness,     int bWrap);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildCallback"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataBuildCallback(IntPtr d, IntPtr pUserData, HeightfieldGetHeight pCallback,
+                                dReal width, dReal depth, int widthSamples, int depthSamples,
+                                dReal scale, dReal offset, dReal thickness, int bWrap);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildShort"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataBuildShort(IntPtr d, ushort[] pHeightData, int bCopyHeightData,
+                                dReal width, dReal depth, int widthSamples, int depthSamples,
+                                dReal scale, dReal offset, dReal thickness, int bWrap);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildShort"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataBuildShort(IntPtr d, short[] pHeightData, int bCopyHeightData,
+                                dReal width, dReal depth, int widthSamples, int depthSamples,
+                                dReal scale, dReal offset, dReal thickness, int bWrap);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildShort"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataBuildShort(IntPtr d, IntPtr pHeightData, int bCopyHeightData,
+                                dReal width, dReal depth, int widthSamples, int depthSamples,
+                                dReal scale, dReal offset, dReal thickness, int bWrap);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildSingle"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataBuildSingle(IntPtr d, float[] pHeightData, int bCopyHeightData,
+                                dReal width, dReal depth, int widthSamples, int depthSamples,
+                                dReal scale, dReal offset, dReal thickness, int bWrap);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildSingle"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataBuildSingle(IntPtr d, IntPtr pHeightData, int bCopyHeightData,
+                                dReal width, dReal depth, int widthSamples, int depthSamples,
+                                dReal scale, dReal offset, dReal thickness, int bWrap);
+
+
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildDouble"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataBuildDouble(IntPtr d, double[] pHeightData, int bCopyHeightData,
+                                dReal width, dReal depth, int widthSamples, int depthSamples,
+                                dReal scale, dReal offset, dReal thickness, int bWrap);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataBuildDouble"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataBuildDouble(IntPtr d, IntPtr pHeightData, int bCopyHeightData,
+                                dReal width, dReal depth, int widthSamples, int depthSamples,
+                                dReal scale, dReal offset, dReal thickness, int bWrap);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataCreate"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomHeightfieldDataCreate();
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataDestroy"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataDestroy(IntPtr d);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldDataSetBounds"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldDataSetBounds(IntPtr d, dReal minHeight, dReal maxHeight);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldGetHeightfieldData"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomHeightfieldGetHeightfieldData(IntPtr g);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomHeightfieldSetHeightfieldData"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomHeightfieldSetHeightfieldData(IntPtr g, IntPtr d);
+
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataBuild"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomUbitTerrainDataBuild(IntPtr d, float[] pHeightData, int bCopyHeightData,
+                dReal sampleSize, int widthSamples, int depthSamples,
+                dReal offset, dReal thickness, int bWrap);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataBuild"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomUbitTerrainDataBuild(IntPtr d, IntPtr pHeightData, int bCopyHeightData,
+                dReal sampleSize, int widthSamples, int depthSamples,
+                dReal thickness, int bWrap);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataCreate"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr GeomUbitTerrainDataCreate();
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataDestroy"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomUbitTerrainDataDestroy(IntPtr d);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataSetBounds"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomUbitTerrainDataSetBounds(IntPtr d, dReal minHeight, dReal maxHeight);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainGetHeightfieldData"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr GeomUbitTerrainGetHeightfieldData(IntPtr g);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainSetHeightfieldData"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomUbitTerrainSetHeightfieldData(IntPtr g, IntPtr d);
+
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomIsEnabled"), SuppressUnmanagedCodeSecurity]
+                public static extern bool GeomIsEnabled(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomIsOffset"), SuppressUnmanagedCodeSecurity]
+                public static extern bool GeomIsOffset(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomIsSpace"), SuppressUnmanagedCodeSecurity]
+                public static extern bool GeomIsSpace(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomPlaneGetParams"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomPlaneGetParams(IntPtr geom, ref Vector4 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomPlaneGetParams"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomPlaneGetParams(IntPtr geom, ref dReal A);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomPlanePointDepth"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal GeomPlanePointDepth(IntPtr geom, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomPlaneSetParams"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomPlaneSetParams(IntPtr plane, dReal a, dReal b, dReal c, dReal d);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRayGet"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomRayGet(IntPtr ray, ref Vector3 start, ref Vector3 dir);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRayGet"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomRayGet(IntPtr ray, ref dReal startX, ref dReal dirX);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRayGetClosestHit"), SuppressUnmanagedCodeSecurity]
+                public static extern int GeomRayGetClosestHit(IntPtr ray);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRayGetLength"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal GeomRayGetLength(IntPtr ray);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRayGetParams"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal GeomRayGetParams(IntPtr g, out int firstContact, out int backfaceCull);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRaySet"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomRaySet(IntPtr ray, dReal px, dReal py, dReal pz, dReal dx, dReal dy, dReal dz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRaySetClosestHit"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomRaySetClosestHit(IntPtr ray, int closestHit);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRaySetLength"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomRaySetLength(IntPtr ray, dReal length);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomRaySetParams"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomRaySetParams(IntPtr ray, int firstContact, int backfaceCull);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetBody"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetBody(IntPtr geom, IntPtr body);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetCategoryBits"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetCategoryBits(IntPtr geom, uint bits);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetCollideBits"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetCollideBits(IntPtr geom, uint bits);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetConvex"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomSetConvex(IntPtr geom, dReal[] planes, int planeCount, dReal[] points, int pointCount, int[] polygons);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetData"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetData(IntPtr geom, IntPtr data);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetOffsetPosition(IntPtr geom, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetOffsetQuaternion(IntPtr geom, ref Quaternion Q);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetOffsetQuaternion(IntPtr geom, ref dReal X);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetOffsetRotation(IntPtr geom, ref Matrix3 R);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetOffsetRotation(IntPtr geom, ref dReal M00);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetOffsetWorldPosition(IntPtr geom, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetOffsetWorldQuaternion(IntPtr geom, ref Quaternion Q);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetOffsetWorldQuaternion(IntPtr geom, ref dReal X);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetOffsetWorldRotation(IntPtr geom, ref Matrix3 R);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetOffsetWorldRotation(IntPtr geom, ref dReal M00);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetPosition(IntPtr geom, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetQuaternion(IntPtr geom, ref Quaternion quat);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetQuaternion(IntPtr geom, ref dReal w);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetRotation(IntPtr geom, ref Matrix3 R);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSetRotation(IntPtr geom, ref dReal M00);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSphereGetRadius"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal GeomSphereGetRadius(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSpherePointDepth"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal GeomSpherePointDepth(IntPtr geom, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSphereSetRadius"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomSphereSetRadius(IntPtr geom, dReal radius);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetCleanup"), SuppressUnmanagedCodeSecurity]
+                public static extern int GeomTransformGetCleanup(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetGeom"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomTransformGetGeom(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetInfo"), SuppressUnmanagedCodeSecurity]
+                public static extern int GeomTransformGetInfo(IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformSetCleanup"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTransformSetCleanup(IntPtr geom, int mode);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformSetGeom"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTransformSetGeom(IntPtr geom, IntPtr obj);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformSetInfo"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTransformSetInfo(IntPtr geom, int info);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildDouble"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildDouble(IntPtr d,
+                        double[] vertices, int vertexStride, int vertexCount,
+                        int[] indices, int indexCount, int triStride);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildDouble"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildDouble(IntPtr d,
+                        IntPtr vertices, int vertexStride, int vertexCount,
+                        IntPtr indices, int indexCount, int triStride);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildDouble1"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildDouble1(IntPtr d,
+                        double[] vertices, int vertexStride, int vertexCount,
+                        int[] indices, int indexCount, int triStride,
+                        double[] normals);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildDouble1"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildDouble(IntPtr d,
+                        IntPtr vertices, int vertexStride, int vertexCount,
+                        IntPtr indices, int indexCount, int triStride,
+                        IntPtr normals);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSimple"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildSingle(IntPtr d,
+                        dReal[] vertices, int vertexStride, int vertexCount,
+                        int[] indices, int indexCount, int triStride);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSimple"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildSingle(IntPtr d,
+                        IntPtr vertices, int vertexStride, int vertexCount,
+                        IntPtr indices, int indexCount, int triStride);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSimple1"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildSingle1(IntPtr d,
+                        dReal[] vertices, int vertexStride, int vertexCount,
+                        int[] indices, int indexCount, int triStride,
+                        dReal[] normals);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSimple1"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildSingle1(IntPtr d,
+                        IntPtr vertices, int vertexStride, int vertexCount,
+                        IntPtr indices, int indexCount, int triStride,
+                        IntPtr normals);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSingle"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildSimple(IntPtr d, 
+                        float[] vertices, int vertexStride, int vertexCount,
+                        int[] indices, int indexCount, int triStride);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSingle"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildSimple(IntPtr d,
+                        IntPtr vertices, int vertexStride, int vertexCount,
+                        IntPtr indices, int indexCount, int triStride);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSingle1"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildSimple1(IntPtr d, 
+                        float[] vertices, int vertexStride, int vertexCount,
+                        int[] indices, int indexCount, int triStride,
+                        float[] normals);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataBuildSingle1"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataBuildSimple1(IntPtr d,
+                        IntPtr vertices, int vertexStride, int vertexCount,
+                        IntPtr indices, int indexCount, int triStride,
+                        IntPtr normals);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshClearTCCache"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshClearTCCache(IntPtr g);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataCreate"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomTriMeshDataCreate();
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataDestroy"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataDestroy(IntPtr d);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataGet"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomTriMeshDataGet(IntPtr d, int data_id);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataPreprocess"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataPreprocess(IntPtr d);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataSet"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataSet(IntPtr d, int data_id, IntPtr in_data);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataUpdate"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshDataUpdate(IntPtr d);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshEnableTC"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshEnableTC(IntPtr g, int geomClass, bool enable);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetArrayCallback"), SuppressUnmanagedCodeSecurity]
+                public static extern TriArrayCallback GeomTriMeshGetArrayCallback(IntPtr g);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetCallback"), SuppressUnmanagedCodeSecurity]
+                public static extern TriCallback GeomTriMeshGetCallback(IntPtr g);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetData"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomTriMeshGetData(IntPtr g);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetLastTransform"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static Matrix4* GeomTriMeshGetLastTransformUnsafe(IntPtr geom);
+                public static Matrix4 GeomTriMeshGetLastTransform(IntPtr geom)
+                {
+                        unsafe { return *(GeomTriMeshGetLastTransformUnsafe(geom)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetPoint"), SuppressUnmanagedCodeSecurity]
+                public extern static void GeomTriMeshGetPoint(IntPtr g, int index, dReal u, dReal v, ref Vector3 outVec);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetRayCallback"), SuppressUnmanagedCodeSecurity]
+                public static extern TriRayCallback GeomTriMeshGetRayCallback(IntPtr g);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetTriangle"), SuppressUnmanagedCodeSecurity]
+                public extern static void GeomTriMeshGetTriangle(IntPtr g, int index, ref Vector3 v0, ref Vector3 v1, ref Vector3 v2);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetTriangleCount"), SuppressUnmanagedCodeSecurity]
+                public extern static int GeomTriMeshGetTriangleCount(IntPtr g);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetTriMeshDataID"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr GeomTriMeshGetTriMeshDataID(IntPtr g);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshIsTCEnabled"), SuppressUnmanagedCodeSecurity]
+                public static extern bool GeomTriMeshIsTCEnabled(IntPtr g, int geomClass);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetArrayCallback"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshSetArrayCallback(IntPtr g, TriArrayCallback arrayCallback);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetCallback"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshSetCallback(IntPtr g, TriCallback callback);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetData"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshSetData(IntPtr g, IntPtr data);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetLastTransform"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshSetLastTransform(IntPtr g, ref Matrix4 last_trans);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetLastTransform"), SuppressUnmanagedCodeSecurity]
+                public static extern void GeomTriMeshSetLastTransform(IntPtr g, ref dReal M00);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshSetRayCallback"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTriMeshSetRayCallback(IntPtr g, TriRayCallback callback);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGetConfiguration"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr iGetConfiguration();
+
+        public static string GetConfiguration()
+        {
+            IntPtr ptr = iGetConfiguration();
+            string s = Marshal.PtrToStringAnsi(ptr);
+            return s;
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dHashSpaceCreate"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr HashSpaceCreate(IntPtr space);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dHashSpaceGetLevels"), SuppressUnmanagedCodeSecurity]
+                public static extern void HashSpaceGetLevels(IntPtr space, out int minlevel, out int maxlevel);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dHashSpaceSetLevels"), SuppressUnmanagedCodeSecurity]
+                public static extern void HashSpaceSetLevels(IntPtr space, int minlevel, int maxlevel);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dInfiniteAABB"), SuppressUnmanagedCodeSecurity]
+                public static extern void InfiniteAABB(IntPtr geom, out AABB aabb);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dInitODE"), SuppressUnmanagedCodeSecurity]
+                public static extern void InitODE();
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dInitODE2"), SuppressUnmanagedCodeSecurity]
+        public static extern int InitODE2(uint ODEInitFlags);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dIsPositiveDefinite"), SuppressUnmanagedCodeSecurity]
+                public static extern int IsPositiveDefinite(ref dReal A, int n);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dInvertPDMatrix"), SuppressUnmanagedCodeSecurity]
+                public static extern int InvertPDMatrix(ref dReal A, out dReal Ainv, int n);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddAMotorTorques"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointAddAMotorTorques(IntPtr joint, dReal torque1, dReal torque2, dReal torque3);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddHingeTorque"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointAddHingeTorque(IntPtr joint, dReal torque);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddHinge2Torque"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointAddHinge2Torques(IntPtr joint, dReal torque1, dReal torque2);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddPRTorque"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointAddPRTorque(IntPtr joint, dReal torque);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddUniversalTorque"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointAddUniversalTorques(IntPtr joint, dReal torque1, dReal torque2);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAddSliderForce"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointAddSliderForce(IntPtr joint, dReal force);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointAttach"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointAttach(IntPtr joint, IntPtr body1, IntPtr body2);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateAMotor"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreateAMotor(IntPtr world, IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateBall"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreateBall(IntPtr world, IntPtr group);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateContact"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr JointCreateContact(IntPtr world, IntPtr group, ref Contact contact);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateContact"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr JointCreateContactPtr(IntPtr world, IntPtr group, IntPtr contact);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateFixed"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreateFixed(IntPtr world, IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateHinge"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreateHinge(IntPtr world, IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateHinge2"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreateHinge2(IntPtr world, IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateLMotor"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreateLMotor(IntPtr world, IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateNull"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreateNull(IntPtr world, IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreatePR"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreatePR(IntPtr world, IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreatePlane2D"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreatePlane2D(IntPtr world, IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateSlider"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreateSlider(IntPtr world, IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointCreateUniversal"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointCreateUniversal(IntPtr world, IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointDestroy"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointDestroy(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorAngle"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetAMotorAngle(IntPtr j, int anum);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorAngleRate"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetAMotorAngleRate(IntPtr j, int anum);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetAMotorAxis(IntPtr j, int anum, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorAxisRel"), SuppressUnmanagedCodeSecurity]
+                public static extern int JointGetAMotorAxisRel(IntPtr j, int anum);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorMode"), SuppressUnmanagedCodeSecurity]
+                public static extern int JointGetAMotorMode(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorNumAxes"), SuppressUnmanagedCodeSecurity]
+                public static extern int JointGetAMotorNumAxes(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetAMotorParam"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetAMotorParam(IntPtr j, int parameter);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetBallAnchor"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetBallAnchor(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetBallAnchor2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetBallAnchor2(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetBody"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointGetBody(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetData"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointGetData(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetFeedback"), SuppressUnmanagedCodeSecurity]
+                public extern unsafe static JointFeedback* JointGetFeedbackUnsafe(IntPtr j);
+                public static JointFeedback JointGetFeedback(IntPtr j)
+                {
+                        unsafe { return *(JointGetFeedbackUnsafe(j)); }
+                }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeAnchor"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetHingeAnchor(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeAngle"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetHingeAngle(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeAngleRate"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetHingeAngleRate(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetHingeAxis(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeParam"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetHingeParam(IntPtr j, int parameter);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Angle1"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetHinge2Angle1(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Angle1Rate"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetHinge2Angle1Rate(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Angle2Rate"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetHinge2Angle2Rate(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHingeAnchor2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetHingeAnchor2(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Anchor"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetHinge2Anchor(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Anchor2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetHinge2Anchor2(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Axis1"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetHinge2Axis1(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Axis2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetHinge2Axis2(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetHinge2Param"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetHinge2Param(IntPtr j, int parameter);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetLMotorAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetLMotorAxis(IntPtr j, int anum, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetLMotorNumAxes"), SuppressUnmanagedCodeSecurity]
+                public static extern int JointGetLMotorNumAxes(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetLMotorParam"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetLMotorParam(IntPtr j, int parameter);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRAnchor"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetPRAnchor(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRAxis1"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetPRAxis1(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRAxis2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetPRAxis2(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRParam"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetPRParam(IntPtr j, int parameter);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetPRPosition(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetPRPositionRate"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetPRPositionRate(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetSliderAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetSliderAxis(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetSliderParam"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetSliderParam(IntPtr j, int parameter);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetSliderPosition"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetSliderPosition(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetSliderPositionRate"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetSliderPositionRate(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetType"), SuppressUnmanagedCodeSecurity]
+                public static extern JointType JointGetType(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAnchor"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetUniversalAnchor(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAnchor2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetUniversalAnchor2(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAngle1"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetUniversalAngle1(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAngle1Rate"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetUniversalAngle1Rate(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAngle2"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetUniversalAngle2(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAngle2Rate"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetUniversalAngle2Rate(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAngles"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetUniversalAngles(IntPtr j, out dReal angle1, out dReal angle2);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAxis1"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetUniversalAxis1(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalAxis2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGetUniversalAxis2(IntPtr j, out Vector3 result);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGetUniversalParam"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal JointGetUniversalParam(IntPtr j, int parameter);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGroupCreate"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr JointGroupCreate(int max_size);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGroupDestroy"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGroupDestroy(IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointGroupEmpty"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointGroupEmpty(IntPtr group);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetAMotorAngle"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetAMotorAngle(IntPtr j, int anum, dReal angle);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetAMotorAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetAMotorAxis(IntPtr j, int anum, int rel, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetAMotorMode"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetAMotorMode(IntPtr j, int mode);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetAMotorNumAxes"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetAMotorNumAxes(IntPtr group, int num);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetAMotorParam"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetAMotorParam(IntPtr group, int parameter, dReal value);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetBallAnchor"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetBallAnchor(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetBallAnchor2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetBallAnchor2(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetData"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetData(IntPtr j, IntPtr data);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetFeedback"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetFeedback(IntPtr j, out JointFeedback feedback);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetFixed"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetFixed(IntPtr j);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHingeAnchor"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetHingeAnchor(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHingeAnchorDelta"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetHingeAnchorDelta(IntPtr j, dReal x, dReal y, dReal z, dReal ax, dReal ay, dReal az);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHingeAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetHingeAxis(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHingeParam"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetHingeParam(IntPtr j, int parameter, dReal value);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHinge2Anchor"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetHinge2Anchor(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHinge2Axis1"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetHinge2Axis1(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHinge2Axis2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetHinge2Axis2(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetHinge2Param"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetHinge2Param(IntPtr j, int parameter, dReal value);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetLMotorAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetLMotorAxis(IntPtr j, int anum, int rel, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetLMotorNumAxes"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetLMotorNumAxes(IntPtr j, int num);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetLMotorParam"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetLMotorParam(IntPtr j, int parameter, dReal value);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPlane2DAngleParam"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetPlane2DAngleParam(IntPtr j, int parameter, dReal value);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPlane2DXParam"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetPlane2DXParam(IntPtr j, int parameter, dReal value);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPlane2DYParam"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetPlane2DYParam(IntPtr j, int parameter, dReal value);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPRAnchor"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetPRAnchor(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPRAxis1"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetPRAxis1(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPRAxis2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetPRAxis2(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetPRParam"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetPRParam(IntPtr j, int parameter, dReal value);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetSliderAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetSliderAxis(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetSliderAxisDelta"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetSliderAxisDelta(IntPtr j, dReal x, dReal y, dReal z, dReal ax, dReal ay, dReal az);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetSliderParam"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetSliderParam(IntPtr j, int parameter, dReal value);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetUniversalAnchor"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetUniversalAnchor(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetUniversalAxis1"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetUniversalAxis1(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetUniversalAxis2"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetUniversalAxis2(IntPtr j, dReal x, dReal y, dReal z);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dJointSetUniversalParam"), SuppressUnmanagedCodeSecurity]
+                public static extern void JointSetUniversalParam(IntPtr j, int parameter, dReal value);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dLDLTAddTL"), SuppressUnmanagedCodeSecurity]
+                public static extern void LDLTAddTL(ref dReal L, ref dReal d, ref dReal a, int n, int nskip);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassAdd"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassAdd(ref Mass a, ref Mass b);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassAdjust"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassAdjust(ref Mass m, dReal newmass);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassCheck"), SuppressUnmanagedCodeSecurity]
+                public static extern bool MassCheck(ref Mass m);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassRotate"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassRotate(ref Mass mass, ref Matrix3 R);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassRotate"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassRotate(ref Mass mass, ref dReal M00);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetBox"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassSetBox(out Mass mass, dReal density, dReal lx, dReal ly, dReal lz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetBoxTotal"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassSetBoxTotal(out Mass mass, dReal total_mass, dReal lx, dReal ly, dReal lz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetCapsule"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassSetCapsule(out Mass mass, dReal density, int direction, dReal radius, dReal length);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetCapsuleTotal"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassSetCapsuleTotal(out Mass mass, dReal total_mass, int direction, dReal radius, dReal length);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetCylinder"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassSetCylinder(out Mass mass, dReal density, int direction, dReal radius, dReal length);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetCylinderTotal"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassSetCylinderTotal(out Mass mass, dReal total_mass, int direction, dReal radius, dReal length);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetParameters"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassSetParameters(out Mass mass, dReal themass,
+                         dReal cgx, dReal cgy, dReal cgz,
+                         dReal i11, dReal i22, dReal i33,
+                         dReal i12, dReal i13, dReal i23);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetSphere"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassSetSphere(out Mass mass, dReal density, dReal radius);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetSphereTotal"), SuppressUnmanagedCodeSecurity]
+                public static extern void dMassSetSphereTotal(out Mass mass, dReal total_mass, dReal radius);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetTrimesh"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassSetTrimesh(out Mass mass, dReal density, IntPtr g);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassSetZero"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassSetZero(out Mass mass);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMassTranslate"), SuppressUnmanagedCodeSecurity]
+                public static extern void MassTranslate(ref Mass mass, dReal x, dReal y, dReal z);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMultiply0"), SuppressUnmanagedCodeSecurity]
+        public static extern void Multiply0(out dReal A00, ref dReal B00, ref dReal C00, int p, int q, int r);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMultiply0"), SuppressUnmanagedCodeSecurity]
+        private static extern void MultiplyiM3V3(out Vector3 vout, ref Matrix3 matrix, ref Vector3 vect,int p, int q, int r);
+        public static void MultiplyM3V3(out Vector3 outvector, ref Matrix3 matrix, ref Vector3 invector)
+        {
+            MultiplyiM3V3(out outvector, ref matrix, ref invector, 3, 3, 1);
+        }
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMultiply1"), SuppressUnmanagedCodeSecurity]
+                public static extern void Multiply1(out dReal A00, ref dReal B00, ref dReal C00, int p, int q, int r);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dMultiply2"), SuppressUnmanagedCodeSecurity]
+                public static extern void Multiply2(out dReal A00, ref dReal B00, ref dReal C00, int p, int q, int r);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQFromAxisAndAngle"), SuppressUnmanagedCodeSecurity]
+                public static extern void QFromAxisAndAngle(out Quaternion q, dReal ax, dReal ay, dReal az, dReal angle);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQfromR"), SuppressUnmanagedCodeSecurity]
+                public static extern void QfromR(out Quaternion q, ref Matrix3 R);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQMultiply0"), SuppressUnmanagedCodeSecurity]
+                public static extern void QMultiply0(out Quaternion qa, ref Quaternion qb, ref Quaternion qc);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQMultiply1"), SuppressUnmanagedCodeSecurity]
+                public static extern void QMultiply1(out Quaternion qa, ref Quaternion qb, ref Quaternion qc);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQMultiply2"), SuppressUnmanagedCodeSecurity]
+                public static extern void QMultiply2(out Quaternion qa, ref Quaternion qb, ref Quaternion qc);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQMultiply3"), SuppressUnmanagedCodeSecurity]
+                public static extern void QMultiply3(out Quaternion qa, ref Quaternion qb, ref Quaternion qc);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQSetIdentity"), SuppressUnmanagedCodeSecurity]
+                public static extern void QSetIdentity(out Quaternion q);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQuadTreeSpaceCreate"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr QuadTreeSpaceCreate(IntPtr space, ref Vector3 center, ref Vector3 extents, int depth);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dQuadTreeSpaceCreate"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr QuadTreeSpaceCreate(IntPtr space, ref dReal centerX, ref dReal extentsX, int depth);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRandReal"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal RandReal();
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRFrom2Axes"), SuppressUnmanagedCodeSecurity]
+                public static extern void RFrom2Axes(out Matrix3 R, dReal ax, dReal ay, dReal az, dReal bx, dReal by, dReal bz);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRFromAxisAndAngle"), SuppressUnmanagedCodeSecurity]
+                public static extern void RFromAxisAndAngle(out Matrix3 R, dReal x, dReal y, dReal z, dReal angle);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRFromEulerAngles"), SuppressUnmanagedCodeSecurity]
+                public static extern void RFromEulerAngles(out Matrix3 R, dReal phi, dReal theta, dReal psi);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRfromQ"), SuppressUnmanagedCodeSecurity]
+                public static extern void RfromQ(out Matrix3 R, ref Quaternion q);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRFromZAxis"), SuppressUnmanagedCodeSecurity]
+                public static extern void RFromZAxis(out Matrix3 R, dReal ax, dReal ay, dReal az);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dRSetIdentity"), SuppressUnmanagedCodeSecurity]
+                public static extern void RSetIdentity(out Matrix3 R);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSetValue"), SuppressUnmanagedCodeSecurity]
+                public static extern void SetValue(out dReal a, int n);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSetZero"), SuppressUnmanagedCodeSecurity]
+                public static extern void SetZero(out dReal a, int n);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSimpleSpaceCreate"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr SimpleSpaceCreate(IntPtr space);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSolveCholesky"), SuppressUnmanagedCodeSecurity]
+                public static extern void SolveCholesky(ref dReal L, out dReal b, int n);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSolveL1"), SuppressUnmanagedCodeSecurity]
+                public static extern void SolveL1(ref dReal L, out dReal b, int n, int nskip);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSolveL1T"), SuppressUnmanagedCodeSecurity]
+                public static extern void SolveL1T(ref dReal L, out dReal b, int n, int nskip);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSolveLDLT"), SuppressUnmanagedCodeSecurity]
+                public static extern void SolveLDLT(ref dReal L, ref dReal d, out dReal b, int n, int nskip);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceAdd"), SuppressUnmanagedCodeSecurity]
+                public static extern void SpaceAdd(IntPtr space, IntPtr geom);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceLockQuery"), SuppressUnmanagedCodeSecurity]
+        public static extern bool SpaceLockQuery(IntPtr space);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceClean"), SuppressUnmanagedCodeSecurity]
+                public static extern void SpaceClean(IntPtr space);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceCollide"), SuppressUnmanagedCodeSecurity]
+                public static extern void SpaceCollide(IntPtr space, IntPtr data, NearCallback callback);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceCollide2"), SuppressUnmanagedCodeSecurity]
+                public static extern void SpaceCollide2(IntPtr space1, IntPtr space2, IntPtr data, NearCallback callback);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceDestroy"), SuppressUnmanagedCodeSecurity]
+                public static extern void SpaceDestroy(IntPtr space);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceGetCleanup"), SuppressUnmanagedCodeSecurity]
+                public static extern bool SpaceGetCleanup(IntPtr space);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceGetNumGeoms"), SuppressUnmanagedCodeSecurity]
+                public static extern int SpaceGetNumGeoms(IntPtr space);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceGetGeom"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr SpaceGetGeom(IntPtr space, int i);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceGetSublevel"), SuppressUnmanagedCodeSecurity]
+        public static extern int SpaceGetSublevel(IntPtr space);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceQuery"), SuppressUnmanagedCodeSecurity]
+                public static extern bool SpaceQuery(IntPtr space, IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceRemove"), SuppressUnmanagedCodeSecurity]
+                public static extern void SpaceRemove(IntPtr space, IntPtr geom);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceSetCleanup"), SuppressUnmanagedCodeSecurity]
+                public static extern void SpaceSetCleanup(IntPtr space, bool mode);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSpaceSetSublevel"), SuppressUnmanagedCodeSecurity]
+        public static extern void SpaceSetSublevel(IntPtr space, int sublevel);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dSweepAndPruneSpaceCreate"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr SweepAndPruneSpaceCreate(IntPtr space, int AxisOrder);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dVectorScale"), SuppressUnmanagedCodeSecurity]
+                public static extern void VectorScale(out dReal a, ref dReal d, int n);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldCreate"), SuppressUnmanagedCodeSecurity]
+                public static extern IntPtr WorldCreate();
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldDestroy"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldDestroy(IntPtr world);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableAverageSamplesCount"), SuppressUnmanagedCodeSecurity]
+        public static extern int WorldGetAutoDisableAverageSamplesCount(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableAngularThreshold"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal WorldGetAutoDisableAngularThreshold(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableFlag"), SuppressUnmanagedCodeSecurity]
+                public static extern bool WorldGetAutoDisableFlag(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableLinearThreshold"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal WorldGetAutoDisableLinearThreshold(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableSteps"), SuppressUnmanagedCodeSecurity]
+                public static extern int WorldGetAutoDisableSteps(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoDisableTime"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal WorldGetAutoDisableTime(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAutoEnableDepthSF1"), SuppressUnmanagedCodeSecurity]
+                public static extern int WorldGetAutoEnableDepthSF1(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetCFM"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal WorldGetCFM(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetERP"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal WorldGetERP(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetGravity"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldGetGravity(IntPtr world, out Vector3 gravity);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetGravity"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldGetGravity(IntPtr world, out dReal X);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetContactMaxCorrectingVel"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal WorldGetContactMaxCorrectingVel(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetContactSurfaceLayer"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal WorldGetContactSurfaceLayer(IntPtr world);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAngularDamping"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal WorldGetAngularDamping(IntPtr world);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAngularDampingThreshold"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal WorldGetAngularDampingThreshold(IntPtr world);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetLinearDamping"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal WorldGetLinearDamping(IntPtr world);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetLinearDampingThreshold"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal WorldGetLinearDampingThreshold(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetQuickStepNumIterations"), SuppressUnmanagedCodeSecurity]
+                public static extern int WorldGetQuickStepNumIterations(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetQuickStepW"), SuppressUnmanagedCodeSecurity]
+                public static extern dReal WorldGetQuickStepW(IntPtr world);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetMaxAngularSpeed"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal WorldGetMaxAngularSpeed(IntPtr world);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldImpulseToForce"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldImpulseToForce(IntPtr world, dReal stepsize, dReal ix, dReal iy, dReal iz, out Vector3 force);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldImpulseToForce"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldImpulseToForce(IntPtr world, dReal stepsize, dReal ix, dReal iy, dReal iz, out dReal forceX);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldQuickStep"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldQuickStep(IntPtr world, dReal stepsize);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAngularDamping"), SuppressUnmanagedCodeSecurity]
+        public static extern void WorldSetAngularDamping(IntPtr world, dReal scale);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAngularDampingThreshold"), SuppressUnmanagedCodeSecurity]
+        public static extern void WorldSetAngularDampingThreshold(IntPtr world, dReal threshold);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableAngularThreshold"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetAutoDisableAngularThreshold(IntPtr world, dReal angular_threshold);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableAverageSamplesCount"), SuppressUnmanagedCodeSecurity]
+        public static extern void WorldSetAutoDisableAverageSamplesCount(IntPtr world, int average_samples_count);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableFlag"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetAutoDisableFlag(IntPtr world, bool do_auto_disable);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableLinearThreshold"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetAutoDisableLinearThreshold(IntPtr world, dReal linear_threshold);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableSteps"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetAutoDisableSteps(IntPtr world, int steps);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoDisableTime"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetAutoDisableTime(IntPtr world, dReal time);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetAutoEnableDepthSF1"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetAutoEnableDepthSF1(IntPtr world, int autoEnableDepth);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetCFM"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetCFM(IntPtr world, dReal cfm);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetContactMaxCorrectingVel"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetContactMaxCorrectingVel(IntPtr world, dReal vel);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetContactSurfaceLayer"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetContactSurfaceLayer(IntPtr world, dReal depth);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetDamping"), SuppressUnmanagedCodeSecurity]
+        public static extern void WorldSetDamping(IntPtr world, dReal linear_scale, dReal angular_scale);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetERP"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetERP(IntPtr world, dReal erp);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetGravity"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetGravity(IntPtr world, dReal x, dReal y, dReal z);
+        
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetLinearDamping"), SuppressUnmanagedCodeSecurity]
+        public static extern void WorldSetLinearDamping(IntPtr world, dReal scale);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetLinearDampingThreshold"), SuppressUnmanagedCodeSecurity]
+        public static extern void WorldSetLinearDampingThreshold(IntPtr world, dReal threshold);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetQuickStepNumIterations"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetQuickStepNumIterations(IntPtr world, int num);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetQuickStepW"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldSetQuickStepW(IntPtr world, dReal over_relaxation);
+
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldSetMaxAngularSpeed"), SuppressUnmanagedCodeSecurity]
+        public static extern void WorldSetMaxAngularSpeed(IntPtr world, dReal max_speed);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldStep"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldStep(IntPtr world, dReal stepsize);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldStepFast1"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldStepFast1(IntPtr world, dReal stepsize, int maxiterations);
+
+                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldExportDIF"), SuppressUnmanagedCodeSecurity]
+                public static extern void WorldExportDIF(IntPtr world, string filename, bool append, string prefix);
+        }
+}
diff --git a/OpenSim/Region/PhysicsModules/UbitOdePlugin/OdeScene.cs b/OpenSim/Region/PhysicsModules/UbitOdePlugin/OdeScene.cs
new file mode 100644
index 0000000..9373d2b
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/UbitOdePlugin/OdeScene.cs
@@ -0,0 +1,2930 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Revision 2011/12/13 by Ubit Umarov
+//#define SPAM
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.IO;
+using System.Diagnostics;
+using log4net;
+using Nini.Config;
+using OdeAPI;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModules.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
+
+    [Flags]
+    public enum CollisionCategories : uint
+    {
+        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
+    }
+
+    /// <summary>
+    /// Material type for a primitive
+    /// </summary>
+    public enum Material : int
+    {
+        /// <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,
+
+        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;
+    }
+
+    
+
+    public class OdeScene : PhysicsScene, INonSharedRegionModule
+    {
+        private readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType.ToString() + "." + sceneIdentifier);
+        // private Dictionary<string, sCollisionData> m_storedCollisions = new Dictionary<string, sCollisionData>();
+
+        public bool OdeUbitLib = false;
+        public bool m_suportCombine = false; // mega suport not tested
+
+//        private int threadid = 0;
+//        private Random fluidRandomizer = new Random(Environment.TickCount);
+
+//        const d.ContactFlags comumContactFlags = d.ContactFlags.SoftERP | d.ContactFlags.SoftCFM |d.ContactFlags.Approx1 | d.ContactFlags.Bounce;
+
+        const d.ContactFlags comumContactFlags = d.ContactFlags.Bounce | d.ContactFlags.Approx1 | d.ContactFlags.Slip1 | d.ContactFlags.Slip2;
+        const float comumContactERP = 0.7f;
+        const float comumContactCFM = 0.0001f;
+        const float comumContactSLIP = 0f;
+        
+        float frictionMovementMult = 0.8f;
+
+        float TerrainBounce = 0.1f;
+        float TerrainFriction = 0.3f;
+
+        public float AvatarFriction = 0;// 0.9f * 0.5f;
+
+        // 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 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;
+
+        private float waterlevel = 0f;
+        private int framecount = 0;
+
+//        private int m_meshExpireCntr;
+
+        private float avDensity = 3f;
+        private float avMovementDivisorWalk = 1.3f;
+        private float avMovementDivisorRun = 0.8f;
+        private float minimumGroundFlightOffset = 3f;
+        public float maximumMassObject = 10000.01f;
+
+
+        public float geomDefaultDensity = 10.000006836f;
+
+        public float bodyPIDD = 35f;
+        public float bodyPIDG = 25;
+
+        public int bodyFramesAutoDisable = 5;
+
+        private d.NearCallback nearCallback;
+
+        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>();
+
+        public OpenSim.Framework.LocklessQueue<ODEchangeitem> ChangesQueue = new OpenSim.Framework.LocklessQueue<ODEchangeitem>();
+
+        /// <summary>
+        /// A list of actors that should receive collision events.
+        /// </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 float contactsurfacelayer = 0.001f;
+
+        private int contactsPerCollision = 80;
+        internal IntPtr ContactgeomsArray = IntPtr.Zero;
+        private IntPtr GlobalContactsArray = IntPtr.Zero;
+        private d.Contact SharedTmpcontact = new d.Contact();
+
+        const int maxContactsbeforedeath = 4000;
+        private volatile int m_global_contactcount = 0;
+
+        private IntPtr contactgroup;
+
+        public ContactData[] m_materialContactsData = new ContactData[8];
+
+        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;
+
+        public IntPtr world;
+
+
+        // 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
+
+        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
+
+        // some speedup variables
+        private int spaceGridMaxX;
+        private int spaceGridMaxY;
+        private float spacesPerMeterX;
+        private float spacesPerMeterY;
+
+        // split static geometry collision into a grid as before
+        private IntPtr[,] staticPrimspace;
+        private IntPtr[] staticPrimspaceOffRegion;
+
+        public Object OdeLock;
+        public static Object SimulationLock;
+
+        public IMesher mesher;
+
+        private IConfigSource m_config;
+
+        public bool physics_logging = false;
+        public int physics_logging_interval = 0;
+        public bool physics_logging_append_existing_logfile = false;
+
+        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;
+
+/* maybe needed if ode uses tls
+        private void checkThread()
+        {
+
+            int th = Thread.CurrentThread.ManagedThreadId;
+            if(th != threadid)
+            {
+                threadid = th;
+                d.AllocateODEDataForThread(~0U);
+            }
+        }
+ */
+        #region INonSharedRegionModule
+        public string Name
+        {
+            get { return "UbitODE"; }
+        }
+
+        public Type ReplaceableInterface
+        {
+            get { return null; }
+        }
+
+        public void Initialise(IConfigSource source)
+        {
+            // TODO: Move this out of Startup
+            IConfig config = source.Configs["Startup"];
+            if (config != null)
+            {
+                string physics = config.GetString("physics", string.Empty);
+                if (physics == Name)
+                {
+                    m_Enabled = true;
+                    m_Config = source;
+                }
+            }
+
+        }
+
+        public void Close()
+        {
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            EngineType = Name;
+            RegionName = scene.RegionInfo.RegionName;
+            PhysicsSceneName = EngineType + "/" + RegionName;
+
+            scene.RegisterModuleInterface<PhysicsScene>(this);
+            Vector3 extent = new Vector3(scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY, scene.RegionInfo.RegionSizeZ);
+            RawInitialization();
+            Initialise(m_Config, extent);
+
+            base.Initialise(scene.PhysicsRequestAsset,
+                (scene.Heightmap != null ? scene.Heightmap.GetFloatsSerialised() : new float[scene.RegionInfo.RegionSizeX * scene.RegionInfo.RegionSizeY]),
+                (float)scene.RegionInfo.RegionSettings.WaterHeight);
+
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            if (!m_Enabled)
+                return;
+
+            mesher = scene.RequestModuleInterface<IMesher>();
+            if (mesher == null)
+                m_log.WarnFormat("{0} No mesher. Things will not work well.", LogHeader);
+
+            scene.PhysicsEnabled = true;
+        }
+        #endregion
+
+        /// <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>
+        private void RawInitialization()
+            {
+
+//            checkThread();
+
+            OdeLock = new Object();
+            SimulationLock = new Object();
+
+            nearCallback = near;
+
+            m_rayCastManager = new ODERayCastRequestManager(this);         
+
+            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!
+                    }
+
+                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);
+            }
+        }
+
+        public void Initialise(IConfigSource config, Vector3 regionExtent)
+        {
+            WorldExtents.X =  regionExtent.X;
+            m_regionWidth = (uint)regionExtent.X;
+            WorldExtents.Y =  regionExtent.Y;
+            m_regionHeight = (uint)regionExtent.Y;
+
+            m_suportCombine = false;
+//            checkThread();
+            m_config = config;
+
+            string ode_config = d.GetConfiguration();
+            if (ode_config != null && ode_config != "")
+            {
+                m_log.WarnFormat("ODE configuration: {0}", ode_config);
+
+                if (ode_config.Contains("ODE_Ubit"))
+                {
+                    OdeUbitLib = true;
+                }
+            }
+
+            // Defaults
+
+            int contactsPerCollision = 80;
+
+            IConfig physicsconfig = null;
+
+            if (m_config != null)
+            {
+                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);
+
+//                    contactsurfacelayer = physicsconfig.GetFloat("world_contact_surface_layer", contactsurfacelayer);
+
+                    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);
+
+            d.WorldSetGravity(world, gravityx, gravityy, gravityz);
+
+            d.WorldSetLinearDamping(world, 0.002f);
+            d.WorldSetAngularDamping(world, 0.002f);
+            d.WorldSetAngularDampingThreshold(world, 0f);
+            d.WorldSetLinearDampingThreshold(world, 0f);
+            d.WorldSetMaxAngularSpeed(world, 100f);
+
+            d.WorldSetQuickStepNumIterations(world, m_physicsiterations);
+
+            d.WorldSetContactSurfaceLayer(world, contactsurfacelayer);
+            d.WorldSetContactMaxCorrectingVel(world, 60.0f);
+
+            m_meshWorker = new ODEMeshWorker(this, m_log, meshmerizer, physicsconfig);
+
+            HalfOdeStep = ODE_STEPSIZE * 0.5f;
+            odetimestepMS = (int)(1000.0f * ODE_STEPSIZE +0.5f);
+
+            ContactgeomsArray = Marshal.AllocHGlobal(contactsPerCollision * d.ContactGeom.unmanagedSizeOf);
+            GlobalContactsArray = Marshal.AllocHGlobal(maxContactsbeforedeath * d.Contact.unmanagedSizeOf);
+
+            SharedTmpcontact.geom.g1 = IntPtr.Zero;
+            SharedTmpcontact.geom.g2 = IntPtr.Zero;
+
+            SharedTmpcontact.geom.side1 = -1;
+            SharedTmpcontact.geom.side2 = -1;
+
+            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;
+
+            m_materialContactsData[(int)Material.Stone].mu = 0.8f;
+            m_materialContactsData[(int)Material.Stone].bounce = 0.4f;
+
+            m_materialContactsData[(int)Material.Metal].mu = 0.3f;
+            m_materialContactsData[(int)Material.Metal].bounce = 0.4f;
+
+            m_materialContactsData[(int)Material.Glass].mu = 0.2f;
+            m_materialContactsData[(int)Material.Glass].bounce = 0.7f;
+
+            m_materialContactsData[(int)Material.Wood].mu = 0.6f;
+            m_materialContactsData[(int)Material.Wood].bounce = 0.5f;
+
+            m_materialContactsData[(int)Material.Flesh].mu = 0.9f;
+            m_materialContactsData[(int)Material.Flesh].bounce = 0.3f;
+
+            m_materialContactsData[(int)Material.Plastic].mu = 0.4f;
+            m_materialContactsData[(int)Material.Plastic].bounce = 0.7f;
+
+            m_materialContactsData[(int)Material.Rubber].mu = 0.9f;
+            m_materialContactsData[(int)Material.Rubber].bounce = 0.95f;
+
+            m_materialContactsData[(int)Material.light].mu = 0.0f;
+            m_materialContactsData[(int)Material.light].bounce = 0.0f;
+
+
+            spacesPerMeterX = 1.0f / metersInSpace;
+            spacesPerMeterY = spacesPerMeterX;
+            spaceGridMaxX = (int)(WorldExtents.X * spacesPerMeterX);
+            spaceGridMaxY = (int)(WorldExtents.Y * spacesPerMeterY);
+
+            if (spaceGridMaxX > 24)
+            {
+                spaceGridMaxX = 24;
+                spacesPerMeterX = spaceGridMaxX / WorldExtents.X ;
+            }
+
+            if (spaceGridMaxY > 24)
+            {
+                spaceGridMaxY = 24;
+                spacesPerMeterY = spaceGridMaxY / WorldExtents.Y ;
+            }
+
+            staticPrimspace = new IntPtr[spaceGridMaxX, spaceGridMaxY];
+
+            // create all spaces now
+            int i, j;
+            IntPtr newspace;
+
+            for (i = 0; i < spaceGridMaxX; i++)
+                for (j = 0; j < spaceGridMaxY; j++)
+                {
+                    newspace = d.HashSpaceCreate(StaticSpace);
+                    d.GeomSetCategoryBits(newspace, (int)CollisionCategories.Space);
+                    waitForSpaceUnlock(newspace);
+                    d.SpaceSetSublevel(newspace, 2);
+                    d.HashSpaceSetLevels(newspace, -2, 8);
+                    d.GeomSetCategoryBits(newspace, (uint)(CollisionCategories.Space |
+                                        CollisionCategories.Geom |
+                                        CollisionCategories.Land |
+                                        CollisionCategories.Water |
+                                        CollisionCategories.Phantom |
+                                        CollisionCategories.VolumeDtc
+                                        ));
+                    d.GeomSetCollideBits(newspace, 0);
+
+                    staticPrimspace[i, j] = newspace;
+                }
+
+            // let this now be index limit
+            spaceGridMaxX--;
+            spaceGridMaxY--;
+
+            // create 4 off world spaces (x<0,x>max,y<0,y>max)
+            staticPrimspaceOffRegion = new IntPtr[4];
+
+            for (i = 0; i < 4; i++)
+                {
+                    newspace = d.HashSpaceCreate(StaticSpace);
+                    d.GeomSetCategoryBits(newspace, (int)CollisionCategories.Space);
+                    waitForSpaceUnlock(newspace);
+                    d.SpaceSetSublevel(newspace, 2);
+                    d.HashSpaceSetLevels(newspace, -2, 8);
+                    d.GeomSetCategoryBits(newspace, (uint)(CollisionCategories.Space |
+                                        CollisionCategories.Geom |
+                                        CollisionCategories.Land |
+                                        CollisionCategories.Water |
+                                        CollisionCategories.Phantom |
+                                        CollisionCategories.VolumeDtc
+                                        ));
+                    d.GeomSetCollideBits(newspace, 0);
+
+                    staticPrimspaceOffRegion[i] = newspace;
+                }
+
+            m_lastframe = DateTime.UtcNow;
+            m_lastMeshExpire = m_lastframe;
+        }
+
+        internal void waitForSpaceUnlock(IntPtr space)
+        {
+            //if (space != IntPtr.Zero)
+                //while (d.SpaceLockQuery(space)) { } // Wait and do nothing
+        }
+
+        #region Collision Detection
+
+        // sets a global contact for a joint for contactgeom , and base contact description)
+
+        
+
+        private IntPtr CreateContacJoint(ref d.ContactGeom contactGeom)
+        {
+            if (m_global_contactcount >= maxContactsbeforedeath)
+                return IntPtr.Zero;
+
+            m_global_contactcount++;
+
+            SharedTmpcontact.geom.depth = contactGeom.depth;
+            SharedTmpcontact.geom.pos = contactGeom.pos;
+            SharedTmpcontact.geom.normal = contactGeom.normal;
+
+            IntPtr contact = new IntPtr(GlobalContactsArray.ToInt64() + (Int64)(m_global_contactcount * d.Contact.unmanagedSizeOf));
+            Marshal.StructureToPtr(SharedTmpcontact, contact, true);
+            return d.JointCreateContactPtr(world, contactgroup, contact);
+        }
+
+        private bool GetCurContactGeom(int index, ref d.ContactGeom newcontactgeom)
+        {
+            if (ContactgeomsArray == IntPtr.Zero || index >= contactsPerCollision)
+                return false;
+
+            IntPtr contactptr = new IntPtr(ContactgeomsArray.ToInt64() + (Int64)(index * d.ContactGeom.unmanagedSizeOf));
+            newcontactgeom = (d.ContactGeom)Marshal.PtrToStructure(contactptr, typeof(d.ContactGeom));
+            return true;
+        }
+
+        /// <summary>
+        /// This is our near callback.  A geometry is near a body
+        /// </summary>
+        /// <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 (m_global_contactcount >= maxContactsbeforedeath)
+                return;
+
+            // 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))
+            {
+                // 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);
+                }
+                catch (AccessViolationException)
+                {
+                    m_log.Warn("[PHYSICS]: 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
+                return;
+            }
+
+            // get geom bodies to check if we already a joint contact
+            // guess this shouldn't happen now
+            IntPtr b1 = d.GeomGetBody(g1);
+            IntPtr b2 = d.GeomGetBody(g2);
+
+            // d.GeomClassID id = d.GeomGetClass(g1);
+
+            // Figure out how many contact points we have
+            int count = 0;
+            try
+            {
+                // Colliding Geom To Geom
+                // This portion of the function 'was' blatantly ripped off from BoxStack.cs
+
+                if (g1 == g2)
+                    return; // Can't collide with yourself
+
+                if (b1 != IntPtr.Zero && b2 != IntPtr.Zero && d.AreConnectedExcluding(b1, b2, d.JointType.Contact))
+                    return;
+                /*
+                // debug
+                                PhysicsActor dp2;
+                                if (d.GeomGetClass(g1) == d.GeomClassID.HeightfieldClass)
+                                {
+                                    d.AABB aabb;
+                                    d.GeomGetAABB(g2, out aabb);
+                                    float x = aabb.MaxX - aabb.MinX;
+                                    float y = aabb.MaxY - aabb.MinY;
+                                    float z = aabb.MaxZ - aabb.MinZ;
+                                    if (x > 60.0f || y > 60.0f || z > 60.0f)
+                                    {
+                                        if (!actor_name_map.TryGetValue(g2, out dp2))
+                                            m_log.WarnFormat("[PHYSICS]: failed actor mapping for geom 2");
+                                        else
+                                            m_log.WarnFormat("[PHYSICS]: land versus large prim geo {0},size {1}, AABBsize <{2},{3},{4}>, at {5} ori {6},({7})",
+                                                dp2.Name, dp2.Size, x, y, z,
+                                                dp2.Position.ToString(),
+                                                dp2.Orientation.ToString(),
+                                                dp2.Orientation.Length());
+                                        return;
+                                    }
+                                }
+                //
+                */
+
+
+                if (d.GeomGetCategoryBits(g1) == (uint)CollisionCategories.VolumeDtc ||
+                    d.GeomGetCategoryBits(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);
+            }
+            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);
+                base.TriggerPhysicsBasedRestart();
+            }
+            catch (Exception e)
+            {
+                m_log.WarnFormat("[PHYSICS]: Unable to collide test an object: {0}", e.Message);
+                return;
+            }
+
+            // contacts done
+            if (count == 0)
+                return;
+
+            // try get physical actors 
+            PhysicsActor p1;
+            PhysicsActor p2;
+
+            if (!actor_name_map.TryGetValue(g1, out p1))
+            {
+                m_log.WarnFormat("[PHYSICS]: failed actor mapping for geom 1");
+                return;
+            }
+
+            if (!actor_name_map.TryGetValue(g2, out p2))
+            {
+                m_log.WarnFormat("[PHYSICS]: failed actor mapping for geom 2");
+                return;
+            }
+
+            // update actors collision score
+            if (p1.CollisionScore >= float.MaxValue - count)
+                p1.CollisionScore = 0;
+            p1.CollisionScore += count;
+
+            if (p2.CollisionScore >= float.MaxValue - count)
+                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))
+            {
+                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
+                    );
+
+                collision_accounting_events(p1, p2, maxDepthContact);
+                return;
+            }
+
+            // big messy collision analises
+
+            float mu = 0;
+            float bounce = 0;
+//            bool IgnoreNegSides = false;
+
+            ContactData contactdata1 = new ContactData(0, 0, false);
+            ContactData contactdata2 = new ContactData(0, 0, false);
+
+            bool dop1ava = false;
+            bool dop2ava = false;
+            bool ignore = false;
+
+            switch (p1.PhysicsActorType)
+            {
+                case (int)ActorTypes.Agent:
+                    {
+                        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;
+                    }
+
+                case (int)ActorTypes.Prim:
+                    {
+                        switch (p2.PhysicsActorType)
+                        {
+                            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);
+
+                                if (relVlenSQ > 0.01f)
+                                    mu *= frictionMovementMult;
+
+                                break;
+
+                            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;
+
+                            case (int)ActorTypes.Water:
+                            default:
+                                ignore = true;
+                                break;
+                        }
+                    }
+                    break;
+
+                case (int)ActorTypes.Ground:
+                    if (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;
+
+                        if (Math.Abs(p2.Velocity.X) > 0.1f || Math.Abs(p2.Velocity.Y) > 0.1f)
+                            mu *= frictionMovementMult;
+                    }
+                    else
+                        ignore = true;
+                    break;
+
+                case (int)ActorTypes.Water:
+                default:
+                    break;
+            }
+
+            if (ignore)
+                return;
+
+            IntPtr Joint;
+            bool FeetCollision = false;
+            int ncontacts = 0;
+
+            int i = 0;
+
+            maxDepthContact = new ContactPoint();
+            maxDepthContact.PenetrationDepth = float.MinValue;
+            ContactPoint minDepthContact = new ContactPoint();
+            minDepthContact.PenetrationDepth = float.MaxValue;
+
+            SharedTmpcontact.geom.depth = 0;
+            SharedTmpcontact.surface.mu = mu;
+            SharedTmpcontact.surface.bounce = bounce;
+
+            d.ContactGeom altContact = new d.ContactGeom();
+            bool useAltcontact = false;
+            bool noskip = true;
+
+            while (true)
+            {
+//                if (!(IgnoreNegSides && curContact.side1 < 0))
+                {
+                    noskip = true;
+                    useAltcontact = false;
+
+                    if (dop1ava)
+                    {
+                        if ((((OdeCharacter)p1).Collide(g1, g2, false, ref curContact, ref altContact , ref useAltcontact, ref FeetCollision)))
+                        {
+                            if (p2.PhysicsActorType == (int)ActorTypes.Agent)
+                            {
+                                p1.CollidingObj = true;
+                                p2.CollidingObj = true;
+                            }
+                            else if (p2.Velocity.LengthSquared() > 0.0f)
+                                    p2.CollidingObj = true;
+                        }
+                        else
+                            noskip = false;
+                    }
+                    else if (dop2ava)
+                    {
+                        if ((((OdeCharacter)p2).Collide(g2, g1, true, ref curContact, ref altContact , ref useAltcontact, ref FeetCollision)))
+                        {
+                            if (p1.PhysicsActorType == (int)ActorTypes.Agent)
+                            {
+                                p1.CollidingObj = true;
+                                p2.CollidingObj = true;
+                            }
+                            else if (p2.Velocity.LengthSquared() > 0.0f)
+                                p1.CollidingObj = true;
+                        }
+                        else
+                            noskip = false;
+                    }
+
+                    if (noskip)
+                    {
+                        if(useAltcontact)
+                            Joint = CreateContacJoint(ref altContact);
+                        else
+                            Joint = CreateContacJoint(ref curContact);
+
+                        if (Joint == IntPtr.Zero)
+                            break;
+
+                        d.JointAttach(Joint, b1, b2);
+
+                        ncontacts++;
+
+                        if (curContact.depth > maxDepthContact.PenetrationDepth)
+                        {
+                            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;
+                        }
+
+                        if (curContact.depth < minDepthContact.PenetrationDepth)
+                        {
+                            minDepthContact.PenetrationDepth = curContact.depth;
+                            minDepthContact.SurfaceNormal.X = curContact.normal.X;
+                            minDepthContact.SurfaceNormal.Y = curContact.normal.Y;
+                            minDepthContact.SurfaceNormal.Z = curContact.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);
+            }
+        }
+
+        private void collision_accounting_events(PhysicsActor p1, PhysicsActor p2, ContactPoint contact)
+        {
+            uint obj2LocalID = 0;
+
+            bool p1events = p1.SubscribedEvents();
+            bool p2events = p2.SubscribedEvents();
+
+            if (p1.IsVolumeDtc)
+                p2events = false;
+            if (p2.IsVolumeDtc)
+                p1events = false;
+
+            if (!p2events && !p1events)
+                return;
+
+            Vector3 vel = Vector3.Zero;
+            if (p2 != null && p2.IsPhysical)
+                vel = p2.Velocity;
+
+            if (p1 != null && p1.IsPhysical)
+                vel -= p1.Velocity;
+
+            contact.RelativeSpeed = Vector3.Dot(vel, contact.SurfaceNormal);
+
+            switch ((ActorTypes)p1.PhysicsActorType)
+            {
+                case ActorTypes.Agent:
+                case ActorTypes.Prim:
+                    {
+                        switch ((ActorTypes)p2.PhysicsActorType)
+                        {
+                            case ActorTypes.Agent:
+                            case ActorTypes.Prim:
+                                if (p2events)
+                                {
+                                    AddCollisionEventReporting(p2);
+                                    p2.AddCollisionEvent(p1.ParentActor.LocalID, contact);
+                                }
+                                obj2LocalID = p2.ParentActor.LocalID;
+                                break;
+
+                            case ActorTypes.Ground:
+                            case ActorTypes.Unknown:
+                            default:
+                                obj2LocalID = 0;
+                                break;
+                        }
+                        if (p1events)
+                        {
+                            contact.SurfaceNormal = -contact.SurfaceNormal;
+                            AddCollisionEventReporting(p1);
+                            p1.AddCollisionEvent(obj2LocalID, contact);
+                        }
+                        break;
+                    }
+                case ActorTypes.Ground:
+                case ActorTypes.Unknown:
+                default:
+                    {
+                        if (p2events && !p2.IsVolumeDtc)
+                        {
+                            AddCollisionEventReporting(p2);
+                            p2.AddCollisionEvent(0, contact);
+                        }
+                        break;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// This is our collision testing routine in ODE
+        /// </summary>
+        /// <param name="timeStep"></param>
+        private void collision_optimized()
+        {
+            lock (_characters)
+                {
+                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);
+
+                }
+                catch (AccessViolationException)
+                {
+                    m_log.Warn("[PHYSICS]: Unable to collide Character to static space");
+                }
+
+            }
+
+            lock (_activeprims)
+            {
+                foreach (OdePrim aprim in _activeprims)
+                {
+                    aprim.CollisionScore = 0;
+                    aprim.IsColliding = false;
+                }
+            }
+
+            // collide active prims with static enviroment
+            lock (_activegroups)
+            {
+                try
+                {
+                    foreach (OdePrim prm in _activegroups)
+                    {
+                        if (!prm.m_outbounds)
+                        {
+                            if (d.BodyIsEnabled(prm.Body))
+                            {
+                                d.SpaceCollide2(StaticSpace, prm.collide_geom, IntPtr.Zero, nearCallback);
+                                d.SpaceCollide2(GroundSpace, prm.collide_geom, IntPtr.Zero, nearCallback);
+                            }
+                        }
+                    }
+                }
+                catch (AccessViolationException)
+                {
+                    m_log.Warn("[PHYSICS]: Unable to collide Active prim to static space");
+                }
+            }
+            // colide active amoung them
+            try
+            {
+                d.SpaceCollide(ActiveSpace, IntPtr.Zero, nearCallback);
+            }
+            catch (AccessViolationException)
+            {
+                m_log.Warn("[PHYSICS]: Unable to collide Active with Characters space");
+            }
+            // and with chars
+            try
+            {
+                d.SpaceCollide2(CharsSpace,ActiveSpace, IntPtr.Zero, nearCallback);
+            }
+            catch (AccessViolationException)
+            {
+                m_log.Warn("[PHYSICS]: Unable to collide in Active space");
+            }
+            //            _perloopContact.Clear();
+        }
+
+        #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)
+        {
+            if (!_collisionEventPrim.Contains(obj))
+                _collisionEventPrim.Add(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)
+        {
+            if (_collisionEventPrim.Contains(obj) && !_collisionEventPrimRemove.Contains(obj))
+                _collisionEventPrimRemove.Add(obj);
+        }
+
+        public override float TimeDilation
+        {
+            get { return m_timeDilation; }
+        }
+
+        public override bool SupportsNINJAJoints
+        {
+            get { return false; }
+        }
+
+        #region Add/Remove Entities
+
+        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        {
+            return null;
+        }
+
+        public override PhysicsActor AddAvatar(uint localID, string avName, Vector3 position, Vector3 size, float feetOffset, bool isFlying)
+        {
+             OdeCharacter newAv = new OdeCharacter(localID, avName, this, position,
+                size, feetOffset, avDensity, avMovementDivisorWalk, avMovementDivisorRun);
+            newAv.Flying = isFlying;
+            newAv.MinimumGroundFlightOffset = minimumGroundFlightOffset;
+            
+            return newAv;
+        }
+
+        public void AddCharacter(OdeCharacter chr)
+        {
+            lock (_characters)
+            {
+                if (!_characters.Contains(chr))
+                {
+                    _characters.Add(chr);
+                    if (chr.bad)
+                        m_log.DebugFormat("[PHYSICS] Added BAD actor {0} to characters list", chr.m_uuid);
+                }
+            }
+        }
+
+        public void RemoveCharacter(OdeCharacter chr)
+        {
+            lock (_characters)
+            {
+                if (_characters.Contains(chr))
+                {
+                    _characters.Remove(chr);
+                }
+            }
+        }
+
+        public void BadCharacter(OdeCharacter chr)
+        {
+            lock (_badCharacter)
+            {
+                if (!_badCharacter.Contains(chr))
+                    _badCharacter.Add(chr);
+            }
+        }
+
+        public override void RemoveAvatar(PhysicsActor actor)
+        {
+            //m_log.Debug("[PHYSICS]:ODELOCK");
+            ((OdeCharacter) actor).Destroy();
+        }
+
+
+        public void addActivePrim(OdePrim activatePrim)
+        {
+            // adds active prim..   
+            lock (_activeprims)
+            {
+                if (!_activeprims.Contains(activatePrim))
+                    _activeprims.Add(activatePrim);
+            }
+        }
+
+        public void addActiveGroups(OdePrim activatePrim)
+        {
+            lock (_activegroups)
+            {
+                if (!_activegroups.Contains(activatePrim))
+                    _activegroups.Add(activatePrim);
+            }
+        }
+
+        private PhysicsActor AddPrim(String name, Vector3 position, Vector3 size, Quaternion rotation,
+                                     PrimitiveBaseShape pbs, bool isphysical, bool isPhantom, byte shapeType, uint localID)
+        {
+            OdePrim newPrim;
+            lock (OdeLock)
+            {
+                newPrim = new OdePrim(name, this, position, size, rotation, pbs, isphysical, isPhantom, shapeType, localID);
+                lock (_prims)
+                    _prims.Add(newPrim);
+            }
+            return newPrim;
+        }
+
+        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, uint localid)
+        {
+            return AddPrim(primName, position, size, rotation, pbs, isPhysical, isPhantom, 0 , localid);
+        }
+
+
+        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, uint localid)
+        {
+            return AddPrim(primName, position, size, rotation, pbs, isPhysical,false, 0, localid);
+        }
+
+        public override PhysicsActor AddPrimShape(string primName, PrimitiveBaseShape pbs, Vector3 position,
+                                                  Vector3 size, Quaternion rotation, bool isPhysical, bool isPhantom, byte shapeType, uint localid)
+        {
+
+            return AddPrim(primName, position, size, rotation, pbs, isPhysical,isPhantom, shapeType, localid);
+        }
+
+        public void remActivePrim(OdePrim deactivatePrim)
+        {
+            lock (_activeprims)
+            {
+                _activeprims.Remove(deactivatePrim);
+            }
+        }
+        public void remActiveGroup(OdePrim deactivatePrim)
+        {
+            lock (_activegroups)
+            {
+                _activegroups.Remove(deactivatePrim);
+            }
+        }
+
+        public override void RemovePrim(PhysicsActor prim)
+        {
+            // As with all ODE physics operations, we don't remove the prim immediately but signal that it should be
+            // removed in the next physics simulate pass.
+            if (prim is OdePrim)
+            {
+//                lock (OdeLock)
+                {
+                    
+                    OdePrim p = (OdePrim)prim;
+                    p.setPrimForRemoval();
+                }
+            }
+        }
+
+        public void RemovePrimThreadLocked(OdePrim prim)
+        {
+            //Console.WriteLine("RemovePrimThreadLocked " +  prim.m_primName);
+            lock (prim)
+            {
+//                RemoveCollisionEventReporting(prim);
+                lock (_prims)
+                    _prims.Remove(prim);
+            }
+
+        }
+
+        public bool havePrim(OdePrim prm)
+        {
+            lock (_prims)
+                return _prims.Contains(prm);
+        }
+
+        public bool haveActor(PhysicsActor actor)
+        {
+            if (actor is OdePrim)
+            {
+                lock (_prims)
+                    return _prims.Contains((OdePrim)actor);
+            }
+            else if (actor is OdeCharacter)
+            {
+                lock (_characters)
+                    return _characters.Contains((OdeCharacter)actor);
+            }
+            return false;
+        }
+
+        #endregion
+
+        #region Space Separation Calculation
+
+        /// <summary>
+        /// Called when a static prim moves or becomes static
+        /// Places the prim in a space one the static sub-spaces grid
+        /// </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)
+        {
+            // moves a prim into another static sub-space or from another space into a static sub-space
+
+            // Called ODEPrim so
+            // it's already in locked space.
+
+            if (geom == IntPtr.Zero) // shouldn't happen
+                return IntPtr.Zero;
+
+            // get the static sub-space for current position
+            IntPtr newspace = calculateSpaceForGeom(pos);
+
+            if (newspace == currentspace) // if we are there all done
+                return newspace;
+
+            // else remove it from its current space
+            if (currentspace != IntPtr.Zero && d.SpaceQuery(currentspace, geom))
+            {
+                if (d.GeomIsSpace(currentspace))
+                {
+                    waitForSpaceUnlock(currentspace);
+                    d.SpaceRemove(currentspace, geom);
+
+                    if (d.SpaceGetSublevel(currentspace) > 2 && d.SpaceGetNumGeoms(currentspace) == 0)
+                    {
+                        d.SpaceDestroy(currentspace);
+                    }
+                }
+                else
+                {
+                    m_log.Info("[Physics]: Invalid or empty Space passed to 'MoveGeomToStaticSpace':" + currentspace +
+                                   " Geom:" + geom);
+                }
+            }
+            else // odd currentspace is null or doesn't contain the geom? lets try the geom ideia of current space
+            {
+                currentspace = d.GeomGetSpace(geom);
+                if (currentspace != IntPtr.Zero)
+                {
+                    if (d.GeomIsSpace(currentspace))
+                    {
+                        waitForSpaceUnlock(currentspace);
+                        d.SpaceRemove(currentspace, geom);
+
+                        if (d.SpaceGetSublevel(currentspace) > 2 && d.SpaceGetNumGeoms(currentspace) == 0)
+                        {
+                            d.SpaceDestroy(currentspace);
+                        }
+
+                    }
+                }
+            }
+
+            // put the geom in the newspace
+            waitForSpaceUnlock(newspace);
+            d.SpaceAdd(newspace, geom);
+
+            // let caller know this newspace
+            return newspace;
+        }
+
+        /// <summary>
+        /// Calculates the space the prim should be in by its position
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <returns>a pointer to the space. This could be a new space or reused space.</returns>
+        public IntPtr calculateSpaceForGeom(Vector3 pos)
+        {
+            int x, y;
+
+            if (pos.X < 0)
+                return staticPrimspaceOffRegion[0];
+
+            if (pos.Y < 0)
+                return staticPrimspaceOffRegion[2];
+
+            x = (int)(pos.X * spacesPerMeterX);
+            if (x > spaceGridMaxX)
+                return staticPrimspaceOffRegion[1];
+            
+            y = (int)(pos.Y * spacesPerMeterY);
+            if (y > spaceGridMaxY)
+                return staticPrimspaceOffRegion[3];
+
+            return staticPrimspace[x, y];
+        }
+ 
+        #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
+        /// </summary>
+
+        public void AddChange(PhysicsActor actor, changes what, Object arg)
+        {
+            ODEchangeitem item = new ODEchangeitem();
+            item.actor = actor;
+            item.what = what;
+            item.arg = arg;
+            ChangesQueue.Enqueue(item);
+        }
+
+        /// <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)
+        {
+        }
+
+        // does all pending changes generated during region load process
+        public override void PrepareSimulation()
+        {
+            lock (OdeLock)
+            {
+                if (world == IntPtr.Zero)
+                {
+                    ChangesQueue.Clear();
+                    return;
+                }
+
+                ODEchangeitem item;
+
+                int donechanges = 0;
+                if (ChangesQueue.Count > 0)
+                {
+                    m_log.InfoFormat("[ODE] start processing pending actor operations");
+                    int tstart = Util.EnvironmentTickCount();
+
+                    while (ChangesQueue.Dequeue(out item))
+                    {
+                        if (item.actor != null)
+                        {
+                            try
+                            {
+                                if (item.actor is OdeCharacter)
+                                    ((OdeCharacter)item.actor).DoAChange(item.what, item.arg);
+                                else if (((OdePrim)item.actor).DoAChange(item.what, item.arg))
+                                    RemovePrimThreadLocked((OdePrim)item.actor);
+                            }
+                            catch
+                            {
+                                m_log.WarnFormat("[PHYSICS]: Operation failed for a actor {0} {1}",
+                                    item.actor.Name, item.what.ToString());
+                            }
+                        }
+                        donechanges++;
+                    }
+                    int time = Util.EnvironmentTickCountSubtract(tstart);
+                    m_log.InfoFormat("[ODE] finished {0} operations in {1}ms", donechanges, time);
+                }
+            }
+        }
+
+        /// <summary>
+        /// This is our main simulate loop
+        /// 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>
+        /// <param name="timeStep"></param>
+        /// <returns></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 (step_time < HalfOdeStep)
+                return 0;
+
+            if (framecount < 0)
+                framecount = 0;
+
+            framecount++;
+
+//            int curphysiteractions;
+
+            // if in trouble reduce step resolution
+//            if (step_time >= m_SkipFramesAtms)
+//                curphysiteractions = m_physicsiterations / 2;
+//            else
+//                curphysiteractions = m_physicsiterations;
+
+//            checkThread();
+            int nodeframes = 0;
+
+            lock (SimulationLock)
+                lock(OdeLock)
+            {
+                if (world == IntPtr.Zero)
+                {
+                    ChangesQueue.Clear();
+                    return 0;
+                }
+
+                ODEchangeitem item;
+                
+//                d.WorldSetQuickStepNumIterations(world, curphysiteractions);
+
+                int loopstartMS = Util.EnvironmentTickCount();
+                int looptimeMS = 0;
+             
+
+                while (step_time > HalfOdeStep)
+                {
+                    try
+                    {
+                        // clear pointer/counter to contacts to pass into joints
+                        m_global_contactcount = 0;
+
+                        if (ChangesQueue.Count > 0)
+                        {
+                            int changestartMS = Util.EnvironmentTickCount();
+                            int ttmp;
+                            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]: doChange failed for a actor {0} {1}",
+                                            item.actor.Name, item.what.ToString());
+                                    }
+                                }
+                                ttmp = Util.EnvironmentTickCountSubtract(changestartMS);
+                                if (ttmp > 20)
+                                    break;
+                            }
+                        }
+
+                        // Move characters
+                        lock (_characters)
+                        {
+                            List<OdeCharacter> defects = new List<OdeCharacter>();
+                            foreach (OdeCharacter actor in _characters)
+                            {
+                                if (actor != null)
+                                    actor.Move(defects);
+                            }
+                            if (defects.Count != 0)
+                            {
+                                foreach (OdeCharacter defect in defects)
+                                {
+                                    RemoveCharacter(defect);
+                                }
+                                defects.Clear();
+                            }
+                        }
+
+                        // Move other active objects
+                        lock (_activegroups)
+                        {
+                            foreach (OdePrim aprim in _activegroups)
+                            {
+                                aprim.Move();
+                            }
+                        }
+ 
+                        m_rayCastManager.ProcessQueuedRequests();
+
+                        collision_optimized();
+
+                        foreach (PhysicsActor obj in _collisionEventPrim)
+                        {
+                            if (obj == null)
+                                continue;
+
+                            switch ((ActorTypes)obj.PhysicsActorType)
+                            {
+                                case ActorTypes.Agent:
+                                    OdeCharacter cobj = (OdeCharacter)obj;
+                                    cobj.AddCollisionFrameTime((int)(odetimestepMS));
+                                    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();
+                                    }
+                                    break;
+                            }
+                        }
+
+                        foreach (PhysicsActor obj in _collisionEventPrimRemove)
+                            _collisionEventPrim.Remove(obj);
+
+                        _collisionEventPrimRemove.Clear();
+
+                        // do a ode simulation step
+                        d.WorldQuickStep(world, ODE_STEPSIZE);
+//                        d.WorldStep(world, ODE_STEPSIZE);
+                        d.JointGroupEmpty(contactgroup);
+
+                        // update managed ideia of physical data and do updates to core
+        /*
+                        lock (_characters)
+                        {
+                            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();
+                                }
+                            }
+                        }
+        */
+
+                        lock (_activegroups)
+                        {
+                            {
+                                foreach (OdePrim actor in _activegroups)
+                                {
+                                    if (actor.IsPhysical)
+                                    {
+                                        actor.UpdatePositionAndVelocity(framecount);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("[PHYSICS]: {0}, {1}, {2}", e.Message, e.TargetSite, e);
+//                        ode.dunlock(world);
+                    }
+
+                    step_time -= ODE_STEPSIZE;
+                    nodeframes++;
+
+                    looptimeMS = Util.EnvironmentTickCountSubtract(loopstartMS);
+                    if (looptimeMS > 100)
+                        break;
+                }
+
+                lock (_badCharacter)
+                {
+                    if (_badCharacter.Count > 0)
+                    {
+                        foreach (OdeCharacter chr in _badCharacter)
+                        {
+                            RemoveCharacter(chr);
+                        }
+
+                        _badCharacter.Clear();
+                    }
+                }
+
+                timedif = now - m_lastMeshExpire;
+
+                if (timedif.Seconds > 10)
+                {
+                    mesher.ExpireReleaseMeshs();
+                    m_lastMeshExpire = now;
+                }
+
+// 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;
+
+                for (int i = 0; i < ntopactivegeoms; i++)
+                {
+                    sp = d.SpaceGetGeom(ActiveSpace, i);
+                    if (d.GeomIsSpace(sp))
+                    {
+                        nactivespaces++;
+                        nactivegeoms += d.SpaceGetNumGeoms(sp);
+                    }
+                    else
+                        nactivegeoms++;
+                }
+
+                for (int i = 0; i < ntopstaticgeoms; i++)
+                {
+                    sp = d.SpaceGetGeom(StaticSpace, i);
+                    if (d.GeomIsSpace(sp))
+                    {
+                        nstaticspaces++;
+                        nstaticgeoms += d.SpaceGetNumGeoms(sp);
+                    }
+                    else
+                        nstaticgeoms++;
+                }
+
+                int ntopgeoms = d.SpaceGetNumGeoms(TopSpace);
+
+                int totgeoms = nstaticgeoms + nactivegeoms + ngroundgeoms + 1; // one ray
+                int nbodies = d.NTotalBodies;
+                int ngeoms = d.NTotalGeoms;
+*/
+                // Finished with all sim stepping. If requested, dump world state to file for debugging.
+                // TODO: This call to the export function is already inside lock (OdeLock) - but is an extra lock needed?
+                // TODO: This overwrites all dump files in-place. Should this be a growing logfile, or separate snapshots?
+                if (physics_logging && (physics_logging_interval > 0) && (framecount % physics_logging_interval == 0))
+                {
+                    string fname = "state-" + world.ToString() + ".DIF"; // give each physics world a separate filename
+                    string prefix = "world" + world.ToString(); // prefix for variable names in exported .DIF file
+
+                    if (physics_logging_append_existing_logfile)
+                    {
+                        string header = "-------------- START OF PHYSICS FRAME " + framecount.ToString() + " --------------";
+                        TextWriter fwriter = File.AppendText(fname);
+                        fwriter.WriteLine(header);
+                        fwriter.Close();
+                    }
+
+                    d.WorldExportDIF(world, fname, physics_logging_append_existing_logfile, prefix);
+                }
+                
+                // 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 (float)nodeframes * ODE_STEPSIZE / timeStep;
+        }
+
+        /// <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;
+
+            // 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;
+
+            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)
+                {
+                    iy = (int)y;
+                    dy = y - (float)iy;
+                }
+                else
+                {
+                    iy = regsizeY - 2;
+                    dy = 0;
+                }
+            }
+            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;
+
+                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;
+                }
+            }
+
+            float h0;
+            float h1;
+            float h2;
+
+            iy *= regsize;
+            iy += ix; // all indexes have iy + ix
+
+            float[] heights = TerrainHeightFieldHeights[heightFieldGeom];
+            /*
+                        if ((dx + dy) <= 1.0f)
+                        {
+                            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
+                        }
+                        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
+                        }
+            */
+            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
+            }
+
+            return h0 + h1 + h2;
+        }
+
+        public Vector3 GetTerrainNormalAtXY(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;
+            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;
+
+            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;
+
+            int xstep = 1;
+            int ystep = regsizeX;
+            bool firstTri = false;
+
+            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)
+                {
+                    iy = (int)y;
+                    dy = y - (float)iy;
+                }
+                else
+                {
+                    iy = regsizeY - 2;
+                    dy = 0;
+                }
+                firstTri = dy > dx;
+            }
+
+            else
+            {
+                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)
+                {
+                    ix = (int)y;
+                    dx = y - (float)ix;
+                }
+                else
+                {
+                    ix = regsizeY - 2;
+                    dx = 0;
+                }
+                firstTri = dx > dy;
+            }
+
+            float h0;
+            float h1;
+            float h2;
+
+            iy *= regsize;
+            iy += ix; // all indexes have iy + ix
+
+            float[] heights = TerrainHeightFieldHeights[heightFieldGeom];
+
+            if (firstTri)
+            {
+                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;              
+            }
+            else
+            {
+                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;
+            }
+            norm.Z = 1;
+            norm.Normalize();
+            return norm;
+        }
+
+        public override void SetTerrain(float[] heightMap)
+        {
+            if (m_worldOffset != Vector3.Zero && m_parentScene != null)
+            {
+                if (m_parentScene is OdeScene)
+                {
+                    ((OdeScene)m_parentScene).SetTerrain(heightMap, m_worldOffset);
+                }
+            }
+            else
+            {
+                SetTerrain(heightMap, m_worldOffset);
+            }
+        }
+
+        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)
+        {
+            // 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;
+
+            // map is rotated
+            uint heightmapWidth = regionsizeY + 2;
+            uint heightmapHeight = regionsizeX + 2;
+
+            uint heightmapWidthSamples = heightmapWidth + 1;
+            uint heightmapHeightSamples = heightmapHeight + 1;
+
+            _heightmap = new float[heightmapWidthSamples * heightmapHeightSamples];
+
+            const float scale = 1.0f;
+            const float offset = 0.0f;
+            const float thickness = 10f;
+            const int wrap = 0;
+
+ 
+            float hfmin = float.MaxValue;
+            float hfmax = float.MinValue;
+            float val;
+            uint xx;
+            uint yy;
+
+            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;
+            xx = 0;
+
+            for (uint x = 0; x < heightmapWidthSamples; x++)
+            {
+                if (x > 1 && xx < maxXX)
+                    xx++;
+                yy = 0;
+                for (uint y = 0; y < heightmapHeightSamples; y++)
+                {
+                    if (y > 1 && y < maxYY)
+                        yy += regionsizeX;
+
+                    val = heightMap[yy + xx];
+                    if (val < 0.0f)
+                        val = 0.0f; // no neg terrain as in chode
+                    _heightmap[xt + y] = val;
+
+                    if (hfmin > val)
+                        hfmin = val;
+                    if (hfmax < val)
+                        hfmax = val;
+                }
+                xt += heightmapHeightSamples;
+            }
+
+            lock (OdeLock)
+            {
+                IntPtr GroundGeom = IntPtr.Zero;
+                if (RegionTerrain.TryGetValue(pOffset, out GroundGeom))
+                {
+                    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);
+                            }
+                    }
+                }
+                IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
+
+                GCHandle _heightmaphandler = GCHandle.Alloc(_heightmap, GCHandleType.Pinned);
+
+                d.GeomHeightfieldDataBuildSingle(HeightmapData, _heightmaphandler.AddrOfPinnedObject(), 0, heightmapWidth , heightmapHeight,
+                                                 (int)heightmapWidthSamples, (int)heightmapHeightSamples, scale,
+                                                 offset, thickness, wrap);
+
+                d.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
+
+                GroundGeom = d.CreateHeightfield(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.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;
+
+                    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;
+
+
+            uint maxXX = regionsizeX - 1;
+            uint maxYY = regionsizeY - 1;
+            // adding one margin all around so things don't fall in edges
+
+            uint xx;
+            uint yy = 0;
+            uint yt = 0;
+
+            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))
+                {
+                    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);
+                }
+            }
+        }
+
+
+        public override void DeleteTerrain()
+        {
+        }
+
+        public float GetWaterLevel()
+        {
+            return waterlevel;
+        }
+
+        public override bool SupportsCombining()
+        {
+            return m_suportCombine;
+        }
+/*
+        public override void UnCombine(PhysicsScene pScene)
+        {
+            IntPtr localGround = IntPtr.Zero;
+//            float[] localHeightfield;
+            bool proceed = false;
+            List<IntPtr> geomDestroyList = new List<IntPtr>();
+
+            lock (OdeLock)
+            {
+                if (RegionTerrain.TryGetValue(Vector3.Zero, out localGround))
+                {
+                    foreach (IntPtr geom in TerrainHeightFieldHeights.Keys)
+                    {
+                        if (geom == localGround)
+                        {
+//                            localHeightfield = TerrainHeightFieldHeights[geom];
+                            proceed = true;
+                        }
+                        else
+                        {
+                            geomDestroyList.Add(geom);
+                        }
+                    }
+
+                    if (proceed)
+                    {
+                        m_worldOffset = Vector3.Zero;
+                        WorldExtents = new Vector2((int)Constants.RegionSize, (int)Constants.RegionSize);
+                        m_parentScene = null;
+
+                        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);
+
+                                if (RegionTerrain.ContainsKey(g))
+                                {
+                                    RegionTerrain.Remove(g);
+                                }
+
+                                d.GeomDestroy(g);
+                                //removingHeightField = new float[0];
+                            }
+                        }
+
+                    }
+                    else
+                    {
+                        m_log.Warn("[PHYSICS]: Couldn't proceed with UnCombine.  Region has inconsistant data.");
+                    }
+                }
+            }
+        }
+*/
+        public override void SetWaterLevel(float baseheight)
+        {
+            waterlevel = baseheight;
+        }
+
+        public override void Dispose()
+        {
+            if (m_meshWorker != null)
+                m_meshWorker.Stop();
+
+            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();
+                    }
+                }
+
+                TerrainHeightFieldHeightsHandlers.Clear();
+                TerrainHeightFieldHeights.Clear();
+
+                if (ContactgeomsArray != IntPtr.Zero)
+                    Marshal.FreeHGlobal(ContactgeomsArray);
+                if (GlobalContactsArray != IntPtr.Zero)
+                    Marshal.FreeHGlobal(GlobalContactsArray);
+
+
+                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;
+            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;
+                        }
+                    }
+                }
+            }
+            return returncolliders;
+        }
+
+        public override bool SupportsRayCast()
+        {
+            return true;
+        }
+
+        public override void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
+        {
+            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);
+            }
+        }
+
+        public override void RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayCallback retMethod)
+        {
+            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);
+            }
+        }
+
+       
+        public override List<ContactResult> RaycastWorld(Vector3 position, Vector3 direction, float length, int Count)
+        {
+            List<ContactResult> ourresults = new List<ContactResult>();
+            object SyncObject = new object();
+
+            RayCallback retMethod = delegate(List<ContactResult> results)
+            {
+                lock (SyncObject)
+                {
+                    ourresults = results;
+                    Monitor.PulseAll(SyncObject);
+                }
+            };
+
+            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)
+            {
+                m_rayCastManager.QueueRequest(req);
+                if (!Monitor.Wait(SyncObject, 500))
+                    return null;
+                else
+                    return ourresults;
+            }
+        }
+
+        public override bool SupportsRaycastWorldFiltered()
+        {
+            return true;
+        }
+
+        public override object RaycastWorld(Vector3 position, Vector3 direction, float length, int Count, RayFilterFlags filter)
+        {
+            object SyncObject = new object();
+            List<ContactResult> ourresults = new List<ContactResult>();
+
+            RayCallback retMethod = delegate(List<ContactResult> results)
+            {
+                lock (SyncObject)
+                {
+                    ourresults = results;
+                    Monitor.PulseAll(SyncObject);
+                }
+            };
+
+            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)
+            {
+                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>();
+
+            List<ContactResult> ourResults = null;
+            object SyncObject = new object();
+
+            RayCallback retMethod = delegate(List<ContactResult> results)
+            {
+                lock (SyncObject)
+                {
+                    ourResults = results;
+                    Monitor.PulseAll(SyncObject);
+                }
+            };
+
+            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;
+
+            lock (SyncObject)
+            {
+                m_rayCastManager.QueueRequest(req);
+                if (!Monitor.Wait(SyncObject, 500))
+                    return new List<ContactResult>();
+            }
+
+            if (ourResults == null)
+                return new List<ContactResult>();
+            return ourResults;
+        }
+
+        public override List<ContactResult> BoxProbe(Vector3 position, Vector3 size, Quaternion orientation, int Count, RayFilterFlags flags)
+        {
+            List<ContactResult> ourResults = null;
+            object SyncObject = new object();
+
+            ProbeBoxCallback retMethod = delegate(List<ContactResult> results)
+            {
+                lock (SyncObject)
+                {
+                    ourResults = results;
+                    Monitor.PulseAll(SyncObject);
+                }
+            };
+
+            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;
+
+            lock (SyncObject)
+            {
+                m_rayCastManager.QueueRequest(req);
+                if (!Monitor.Wait(SyncObject, 500))
+                    return new List<ContactResult>();
+            }
+
+            if (ourResults == null)
+                return new List<ContactResult>();
+            return ourResults;
+        }
+
+        public override List<ContactResult> SphereProbe(Vector3 position, float radius, int Count, RayFilterFlags flags)
+        {
+            List<ContactResult> ourResults = null;
+            object SyncObject = new object();
+
+            ProbeSphereCallback retMethod = delegate(List<ContactResult> results)
+            {
+                ourResults = results;
+                Monitor.PulseAll(SyncObject);
+            };
+
+            ODERayRequest req = new ODERayRequest();
+            req.actor = null;
+            req.callbackMethod = retMethod;
+            req.length = radius;
+            req.Origin = position;
+            req.Count = Count;
+            req.filter = flags;
+
+
+            lock (SyncObject)
+            {
+                m_rayCastManager.QueueRequest(req);
+                if (!Monitor.Wait(SyncObject, 500))
+                    return new List<ContactResult>();
+            }
+
+            if (ourResults == null)
+                return new List<ContactResult>();
+            return ourResults;
+        }
+
+        public override List<ContactResult> PlaneProbe(PhysicsActor actor, Vector4 plane, int Count, RayFilterFlags flags)
+        {
+            IntPtr geom = IntPtr.Zero;;
+
+            if (actor != null)
+            {
+                if (actor is OdePrim)
+                    geom = ((OdePrim)actor).prim_geom;
+                else if (actor is OdeCharacter)
+                    geom = ((OdePrim)actor).prim_geom;
+            }
+
+            List<ContactResult> ourResults = null;
+            object SyncObject = new object();
+
+            ProbePlaneCallback retMethod = delegate(List<ContactResult> results)
+            {
+                ourResults = results;
+                Monitor.PulseAll(SyncObject);
+            };
+
+            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;
+
+            lock (SyncObject)
+            {
+                m_rayCastManager.QueueRequest(req);
+                if (!Monitor.Wait(SyncObject, 500))
+                    return new List<ContactResult>();
+            }
+
+            if (ourResults == null)
+                return new List<ContactResult>();
+            return ourResults;
+        }
+
+        public override int SitAvatar(PhysicsActor actor, Vector3 AbsolutePosition, Vector3 CameraPosition, Vector3 offset, Vector3 AvatarSize, SitAvatarCallback PhysicsSitResponse)
+        {
+            Util.FireAndForget( delegate
+            {
+                ODESitAvatar sitAvatar = new ODESitAvatar(this, m_rayCastManager);
+                if(sitAvatar != null)
+                    sitAvatar.Sit(actor, AbsolutePosition, CameraPosition, offset, AvatarSize, PhysicsSitResponse);
+            });
+            return 1;
+        }
+
+    }
+}