70 files changed, 3353 insertions, 3353 deletions

diff --git a/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsActor.cs b/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsActor.cs
index 3944047..67d9207 100644
--- a/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsActor.cs
+++ b/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsActor.cs
@@ -268,23 +268,23 @@ namespace OpenSim.Region.PhysicsModule.BasicPhysics
             set { return; }
         }
 
-        public override Quaternion APIDTarget 
-        { 
+        public override Quaternion APIDTarget
+        {
             set { return; }
         }
-        
+
         public override bool APIDActive
-        { 
+        {
             set { return; }
         }
-        
+
         public override float APIDStrength
-        { 
+        {
             set { return; }
         }
-        
+
         public override float APIDDamping
-        { 
+        {
             set { return; }
         }
 
diff --git a/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsPrim.cs b/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsPrim.cs
index d2cd028..58c2581 100644
--- a/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsPrim.cs
+++ b/OpenSim/Region/PhysicsModules/BasicPhysics/BasicPhysicsPrim.cs
@@ -281,23 +281,23 @@ namespace OpenSim.Region.PhysicsModule.BasicPhysics
             set { return; }
         }
 
-        public override Quaternion APIDTarget 
-        { 
+        public override Quaternion APIDTarget
+        {
             set { return; }
         }
-        
+
         public override bool APIDActive
-        { 
+        {
             set { return; }
         }
-        
+
         public override float APIDStrength
-        { 
+        {
             set { return; }
         }
-        
+
         public override float APIDDamping
-        { 
+        {
             set { return; }
         }
 
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs b/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs
index c4a923c..42db7fe 100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs
@@ -155,8 +155,8 @@ public BSAPIUnman(string paramName, BSScene physScene)
 
 // Initialization and simulation
 public override BulletWorld Initialize(Vector3 maxPosition, ConfigurationParameters parms,
-                                                                                        int maxCollisions,  ref CollisionDesc[] collisionArray,
-                                                                                        int maxUpdates, ref EntityProperties[] updateArray
+                                            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
@@ -1472,8 +1472,8 @@ 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,
+                                            int maxCollisions,  IntPtr collisionArray,
+                                            int maxUpdates, IntPtr updateArray,
                                             DebugLogCallback logRoutine);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs b/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs
index 887311d..37017b0 100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs
@@ -815,161 +815,161 @@ private sealed class BulletConstraintXNA : BulletConstraint
     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;
-                }
+        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;
-                }
+        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;
-                }
+        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;
-                }
+        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;
     }
 
@@ -1197,20 +1197,20 @@ private sealed class BulletConstraintXNA : BulletConstraint
                                                          };
         /*
             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_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);
@@ -2172,7 +2172,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     }
 
     public override BulletShape CreateTerrainShape(uint id, Vector3 size, float minHeight, float maxHeight, float[] heightMap,
-                                                                float scaleFactor, float collisionMargin)
+                                float scaleFactor, float collisionMargin)
     {
         const int upAxis = 2;
         HeightfieldTerrainShape terrainShape = new HeightfieldTerrainShape((int)size.X, (int)size.Y,
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs
index 87cf972..f2019ae 100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs
@@ -205,7 +205,7 @@ public class BSActorMoveToTarget : BSActor
             addedForce = correctionVector / timeStep;
             // Remove the existing velocity (only the moveToTarget force counts)
             addedForce -= m_controllingPrim.RawVelocity;
-            // Overcome gravity. 
+            // Overcome gravity.
             addedForce -= m_controllingPrim.Gravity;
 
             // Add enough force to overcome the mass of the object
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs b/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs
index 7756b10..816189f 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs
@@ -36,16 +36,16 @@ 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
+    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
 }
@@ -54,25 +54,25 @@ public enum ConstraintType : int
 [StructLayout(LayoutKind.Sequential)]
 public struct ConvexHull
 {
-        Vector3 Offset;
-        int VertexCount;
-        Vector3[] Vertices;
+    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,
+    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_GROUNDPLANE  = 20,
+    SHAPE_TERRAIN   = 21,
+    SHAPE_COMPOUND  = 22,
+    SHAPE_HEIGHTMAP = 23,
     SHAPE_AVATAR    = 24,
     SHAPE_CONVEXHULL= 25,
     SHAPE_GIMPACT   = 26,
@@ -180,16 +180,16 @@ public struct ConfigurationParameters
     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 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 globalContactBreakingThreshold;
 
     public float physicsLoggingFrames;
 
@@ -202,30 +202,30 @@ public struct ConfigurationParameters
 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
+    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
+    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
@@ -322,8 +322,8 @@ 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
+                                            int maxCollisions,  ref CollisionDesc[] collisionArray,
+                                            int maxUpdates, ref EntityProperties[] updateArray
                                             );
 
 public abstract int PhysicsStep(BulletWorld world, float timeStep, int maxSubSteps, float fixedTimeStep,
@@ -398,7 +398,7 @@ 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);
+                                float scaleFactor, float collisionMargin);
 
 // =====================================================================================
 // Constraint creation and helper routines
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs b/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs
index 6322695..57f03fb 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs
@@ -64,9 +64,9 @@ public sealed class BSCharacter : BSPhysObject
     private OMV.Vector3 _PIDTarget;
     private float _PIDTau;
 
-//        public override OMV.Vector3 RawVelocity 
-//        { get { return base.RawVelocity; } 
-//            set { 
+//        public override OMV.Vector3 RawVelocity
+//        { get { return base.RawVelocity; }
+//            set {
 //                if (value != base.RawVelocity)
 //                    Util.PrintCallStack();
 //                Console.WriteLine("Set rawvel to {0}", value);
@@ -82,7 +82,7 @@ public sealed class BSCharacter : BSPhysObject
             : base(parent_scene, localID, avName, "BSCharacter")
     {
         _physicsActorType = (int)ActorTypes.Agent;
-        RawPosition = pos;        
+        RawPosition = pos;
 
         _flying = isFlying;
         RawOrientation = OMV.Quaternion.Identity;
@@ -819,7 +819,7 @@ public sealed class BSCharacter : BSPhysObject
         //    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 
+        // 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
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs b/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs
index 313c961..c4ccdbe 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs
@@ -125,8 +125,8 @@ namespace OpenSim.Region.PhysicsModule.BulletS
 
         // 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 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
@@ -1595,7 +1595,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
         //     in that direction.
         // TODO: implement reference frame.
         public void ComputeAngularDeflection()
-        {   
+        {
 
             if (BSParam.VehicleEnableAngularDeflection && m_angularDeflectionEfficiency != 0 && VehicleForwardSpeed > 0.2)
             {
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs b/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs
index e73f0e8..13c1361 100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs
@@ -319,7 +319,7 @@ public abstract class BSLinkset
     public virtual bool AllPartsComplete
     {
         get {
-            bool ret = true; 
+            bool ret = true;
             this.ForEachMember((member) =>
             {
                 if ((!member.IsInitialized) || member.IsIncomplete || member.PrimAssetState == BSPhysObject.PrimAssetCondition.Waiting)
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs
index 28df2d9..352c03e 100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs
@@ -90,8 +90,8 @@ public static class BSParam
     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 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
@@ -119,14 +119,14 @@ public static class BSParam
     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 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; }
@@ -149,19 +149,19 @@ public static class BSParam
     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 AvatarContactProcessingThreshold { get; private set; }
     public static float AvatarAddForcePushFactor { get; private set; }
     public static float AvatarStopZeroThreshold { get; private set; }
     public static float AvatarStopZeroThresholdSquared { 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; }
+    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; }
@@ -193,31 +193,31 @@ public static class BSParam
     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
+    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
+    // 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; }
@@ -579,7 +579,7 @@ public static class BSParam
             (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)",
+        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 ),
@@ -631,31 +631,31 @@ public static class BSParam
             2.0f ),
         new ParameterDefn<float>("AvatarTerminalVelocity", "Terminal Velocity of falling avatar",
             -54.0f ),
-            new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions",
+        new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions",
             0.1f ),
-            new ParameterDefn<float>("AvatarAddForcePushFactor", "BSCharacter.AddForce is multiplied by this and mass to be like other physics engines",
+        new ParameterDefn<float>("AvatarAddForcePushFactor", "BSCharacter.AddForce is multiplied by this and mass to be like other physics engines",
             0.315f ),
-            new ParameterDefn<float>("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped",
+        new ParameterDefn<float>("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped",
             0.45f,
             (s) => { return (float)AvatarStopZeroThreshold; },
             (s,v) => { AvatarStopZeroThreshold = v; AvatarStopZeroThresholdSquared = v * v; } ),
-            new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground",
+        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.",
+        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",
+        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",
+        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",
+        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)",
+        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",
+        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",
+        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",
+        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",
@@ -699,131 +699,131 @@ public static class BSParam
         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)",
+        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)",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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)",
+        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.",
+        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))",
+        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",
+        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",
+        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",
+        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)",
+        new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)",
             5f ),
-            new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)",
+        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.",
+        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.",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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",
+        new ParameterDefn<float>("VHACDresolution", "max number of voxels generated during voxelization stage",
             100000f ),
-            new ParameterDefn<float>("VHACDdepth", "max number of clipping stages",
+        new ParameterDefn<float>("VHACDdepth", "max number of clipping stages",
             20f ),
-            new ParameterDefn<float>("VHACDconcavity", "maximum concavity",
+        new ParameterDefn<float>("VHACDconcavity", "maximum concavity",
             0.0025f ),
-            new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane",
+        new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane",
             4f ),
-            new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process",
+        new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process",
             4f ),
-            new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes",
+        new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes",
             0.05f ),
-            new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis",
+        new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis",
             0.05f ),
-            new ParameterDefn<float>("VHACDgamma", "max concavity when merging",
+        new ParameterDefn<float>("VHACDgamma", "max concavity when merging",
             0.00125f ),
-            new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp",
+        new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp",
             0f ),
-            new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based",
+        new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based",
             0f ),
-            new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull",
+        new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull",
             64f ),
-            new ParameterDefn<float>("VHACDminVolumePerCH",     "sampling of generated convex hulls",
+        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)",
+        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",
+        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.",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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)",
+        new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)",
             40 ),
 
-            new ParameterDefn<float>("DebugNumber", "A console setable number sometimes used for debugging",
+        new ParameterDefn<float>("DebugNumber", "A console setable number sometimes used for debugging",
             1.0f ),
 
         new ParameterDefn<int>("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)",
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
index a846869..6aa24d5 100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
@@ -317,10 +317,10 @@ public abstract class BSPhysObject : PhysicsActor
 
     public virtual bool ForceBodyShapeRebuild(bool inTaintTime) { return false; }
 
-    public override bool PIDActive 
+    public override bool PIDActive
     {
         get { return MoveToTargetActive; }
-        set { MoveToTargetActive = value; } 
+        set { MoveToTargetActive = value; }
     }
 
     public override OMV.Vector3 PIDTarget { set { MoveToTargetTarget = value; } }
@@ -572,7 +572,7 @@ public abstract class BSPhysObject : PhysicsActor
             newContact.RelativeSpeed = -OMV.Vector3.Dot(relvel, contactNormal);
             // DetailLog("{0},{1}.Collision.AddCollider,vel={2},contee.vel={3},relvel={4},relspeed={5}",
             //         LocalID, TypeName, RawVelocity, (collidee == null ? OMV.Vector3.Zero : collidee.RawVelocity), relvel, newContact.RelativeSpeed);
-                    
+
             lock (PhysScene.CollisionLock)
             {
                 CollisionCollection.AddCollider(collideeLocalID, newContact);
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs
index db2b9db..b153761 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs
@@ -1144,14 +1144,14 @@ public class BSPrim : BSPhysObject
         }
     }
 
-    public override bool PIDActive 
+    public override bool PIDActive
     {
         get
         {
             return MoveToTargetActive;
         }
 
-        set 
+        set
         {
             MoveToTargetActive = value;
 
@@ -1179,13 +1179,13 @@ public class BSPrim : BSPhysObject
                 // 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 {
-        get 
+        get
         {
         return base.HoverActive;
         }
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs b/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs
index ee57f0c..7ff0a07 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs
@@ -351,12 +351,12 @@ namespace OpenSim.Region.PhysicsModule.BulletS
             if (BSParam.UseSeparatePhysicsThread)
             {
                 // The physics simulation should happen independently of the heartbeat loop
-                m_physicsThread 
+                m_physicsThread
                     = WorkManager.StartThread(
-                        BulletSPluginPhysicsThread, 
-                        string.Format("{0} ({1})", BulletEngineName, RegionName), 
-                        ThreadPriority.Normal, 
-                        true, 
+                        BulletSPluginPhysicsThread,
+                        string.Format("{0} ({1})", BulletEngineName, RegionName),
+                        ThreadPriority.Normal,
+                        true,
                         true);
             }
         }
diff --git a/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs b/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs
index 2ba3c5a..ab5d4849 100755
--- a/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs
@@ -136,7 +136,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
 
                 return;
             }
- 
+
             // Register as LSL functions all the [ScriptInvocation] marked methods.
             Comms.RegisterScriptInvocations(this);
             Comms.RegisterConstants(this);
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs
index 6ed7af1..91ce468 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs
@@ -3,7 +3,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Mono.Addins;
 
-// General Information about an assembly is controlled through the following 
+// 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")]
@@ -15,8 +15,8 @@ using Mono.Addins;
 [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 
+// 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)]
 
@@ -26,7 +26,7 @@ using Mono.Addins;
 // Version information for an assembly consists of the following four values:
 //
 //      Major Version
-//      Minor Version 
+//      Minor Version
 //      Build Number
 //      Revision
 //
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs
index 109e19c..3e8c1cd 100755
--- a/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs
@@ -80,7 +80,7 @@ public static class BulletSimTestsUtil
         }
 
         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;
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs
index c0cf19a..c2be568 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs
@@ -146,7 +146,7 @@ public class HullCreation : OpenSimTestCase
         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();
 
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/CTri.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/CTri.cs
index 3d81439..bd1f75e 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/CTri.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/CTri.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
@@ -246,13 +246,13 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
         }
 
         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;
-            }
+        {
+            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)
         {
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Concavity.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Concavity.cs
index 6a98535..0d22d71 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Concavity.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Concavity.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexBuilder.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexBuilder.cs
index 4480036..810e95d 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexBuilder.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexBuilder.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexDecomposition.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexDecomposition.cs
index e6dc98a..a382f9d 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexDecomposition.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexDecomposition.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexResult.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexResult.cs
index 09129ed..300fed3 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexResult.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/ConvexResult.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullClasses.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullClasses.cs
index 7d342d1..73fb252 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullClasses.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullClasses.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullTriangle.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullTriangle.cs
index 66457ac..6e73fd5 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullTriangle.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullTriangle.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullUtils.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullUtils.cs
index 72f2d6d..cf7161a 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullUtils.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/HullUtils.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
@@ -763,7 +763,7 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
                     }
                     else if ((vertflag[edge0.v].planetest | vertflag[edge1.v].planetest) == (0))
                     {
-                        // both endpoints coplanar 
+                        // 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)
@@ -792,7 +792,7 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
                     }
                     else if (vertflag[edge0.v].planetest == (1) && vertflag[edge1.v].planetest == (2))
                     {
-                        // first is under 2nd is over 
+                        // first is under 2nd is over
 
                         edgeflag[e0].undermap = (short)under_edge_count;
                         tmpunderedges[under_edge_count].v = vertflag[edge0.v].undermap;
@@ -815,7 +815,7 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
                             vout = vertcountunder++;
                         }
                         under_edge_count++;
-                        /// hmmm something to think about: i might be able to output this edge regarless of 
+                        /// 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;
@@ -834,7 +834,7 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
                     }
                     else if (vertflag[edge0.v].planetest == (0) && vertflag[edge1.v].planetest == (2))
                     {
-                        // first is coplanar 2nd is over 
+                        // first is coplanar 2nd is over
 
                         edgeflag[e0].undermap = -1;
                         vout = vertflag[edge0.v].undermap;
@@ -858,7 +858,7 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
                     }
                     else if (vertflag[edge0.v].planetest == (2) && vertflag[edge1.v].planetest == (1))
                     {
-                        // first is over next is under 
+                        // first is over next is under
                         // new vertex!!!
                         Debug.Assert(vin == -1);
                         if (e0 < edge0.ea)
@@ -901,7 +901,7 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
                     }
                     else if (vertflag[edge0.v].planetest == (2) && vertflag[edge1.v].planetest == (0))
                     {
-                        // first is over next is coplanar 
+                        // first is over next is coplanar
 
                         edgeflag[e0].undermap = -1;
                         vin = vertflag[edge1.v].undermap;
@@ -1543,7 +1543,7 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
         public static bool ComputeHull(List<float3> vertices, out List<int> indices)
         {
             List<HullTriangle> tris = new List<HullTriangle>();
-            
+
             bool ret = calchull(vertices, out indices, 0, tris);
             if (ret == false)
             {
@@ -1636,7 +1636,7 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
                 addPoint(ref vcount, vertices, x2, y2, z2);
                 addPoint(ref vcount, vertices, x1, y2, z2);
 
-                return true; // return cube     
+                return true; // return cube
             }
             else
             {
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Plane.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Plane.cs
index f58cad6..0f10e5f 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Plane.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Plane.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/PlaneTri.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/PlaneTri.cs
index 8f08ddf..5915c29 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/PlaneTri.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/PlaneTri.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
index e9ff26e..9b418d6 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
@@ -2,7 +2,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-// General Information about an assembly is controlled through the following 
+// 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")]
@@ -14,8 +14,8 @@ using System.Runtime.InteropServices;
 [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 
+// 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)]
 
@@ -25,11 +25,11 @@ using System.Runtime.InteropServices;
 // Version information for an assembly consists of the following four values:
 //
 //      Major Version
-//      Minor Version 
+//      Minor Version
 //      Build Number
 //      Revision
 //
-// You can specify all the values or you can default the Build and Revision Numbers 
+// 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(OpenSim.VersionInfo.AssemblyVersionNumber)]
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Quaternion.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Quaternion.cs
index 2d72117..571677d 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Quaternion.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/Quaternion.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
@@ -126,9 +126,9 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
         }
 
         public static Quaternion operator *(Quaternion a, float b)
-            {
-                    return new Quaternion(a.x *b, a.y *b, a.z *b, a.w *b);
-            }
+        {
+            return new Quaternion(a.x *b, a.y *b, a.z *b, a.w *b);
+        }
 
         public static Quaternion normalize(Quaternion a)
         {
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/SplitPlane.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/SplitPlane.cs
index cc5f99c..d8c10c7 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/SplitPlane.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/SplitPlane.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/VertexLookup.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/VertexLookup.cs
index da2255e..915bec6 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/VertexLookup.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/VertexLookup.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float2.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float2.cs
index 2a58ec4..c2c8940 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float2.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float2.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3.cs
index 64a9ef8..1ea003b 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3x3.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3x3.cs
index 266ed0b..4b6cd5d 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3x3.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float3x3.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4.cs
index 058934d..1f2ab02 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4x4.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4x4.cs
index 58f4f58..85a8cf1 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4x4.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/float4x4.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
@@ -127,88 +127,88 @@ namespace OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet
         }
 
         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
+        {
+            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;
+            // calculate matrix inverse
+            det = 1/det;
             for (int j = 0; j < 4; j++)
                 d[j] *= det;
-                    return d;
-            }
+            return d;
+        }
 
         public static float4x4 MatrixRigidInverse(float4x4 m)
         {
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int3.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int3.cs
index b3d4ecb..e7bb6e7 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int3.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int3.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int4.cs b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int4.cs
index 41e0912..9950be2 100644
--- a/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int4.cs
+++ b/OpenSim/Region/PhysicsModules/ConvexDecompositionDotNet/int4.cs
@@ -1,21 +1,21 @@
 /* The MIT License
- * 
+ *
  * Copyright (c) 2010 Intel Corporation.
  * All rights reserved.
  *
- * Based on the convexdecomposition library from 
+ * 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
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Mesh.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Mesh.cs
index e63ad01..42ba37e 100644
--- a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Mesh.cs
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Mesh.cs
@@ -102,8 +102,8 @@ namespace OpenSim.Region.PhysicsModule.Meshing
             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;
             }
 
@@ -259,7 +259,7 @@ namespace OpenSim.Region.PhysicsModule.Meshing
         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
@@ -299,7 +299,7 @@ namespace OpenSim.Region.PhysicsModule.Meshing
         {
             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
@@ -357,7 +357,7 @@ namespace OpenSim.Region.PhysicsModule.Meshing
         {
             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;
 
@@ -370,7 +370,7 @@ namespace OpenSim.Region.PhysicsModule.Meshing
         {
             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)
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs
index 0d22e96..4f95554 100644
--- a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/Meshmerizer.cs
@@ -247,13 +247,13 @@ namespace OpenSim.Region.PhysicsModule.Meshing
         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;
@@ -264,15 +264,15 @@ namespace OpenSim.Region.PhysicsModule.Meshing
                 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)
             {
@@ -436,9 +436,9 @@ namespace OpenSim.Region.PhysicsModule.Meshing
                             int convexSize = convexBlock["size"].AsInteger();
 
                             byte[] convexBytes = new byte[convexSize];
-                            
+
                             System.Buffer.BlockCopy(primShape.SculptData, convexOffset, convexBytes, 0, convexSize);
-                            
+
                             try
                             {
                                 convexBlockOsd = DecompressOsd(convexBytes);
@@ -449,7 +449,7 @@ namespace OpenSim.Region.PhysicsModule.Meshing
                                 //return false;
                             }
                         }
-                        
+
                         if (convexBlockOsd != null && convexBlockOsd is OSDMap)
                         {
                             convexBlock = convexBlockOsd as OSDMap;
@@ -762,7 +762,7 @@ namespace OpenSim.Region.PhysicsModule.Meshing
         {
             PrimMesh primMesh;
             coords = new List<Coord>();
-            faces = new List<Face>();            
+            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;
@@ -994,7 +994,7 @@ namespace OpenSim.Region.PhysicsModule.Meshing
                 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 " + 
+                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);
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/PrimMesher.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/PrimMesher.cs
index 4049ee1..fd2b1ea 100644
--- a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/PrimMesher.cs
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/PrimMesher.cs
@@ -445,7 +445,7 @@ namespace PrimMesher
             new Angle(1.0f, 1.0f, 0.0f)
         };
 
-        private static Coord[] normals4 = 
+        private static Coord[] normals4 =
         {
             new Coord(0.5f, 0.5f, 0.0f).Normalize(),
             new Coord(-0.5f, 0.5f, 0.0f).Normalize(),
@@ -2066,7 +2066,7 @@ namespace PrimMesher
         /// 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);
@@ -2077,7 +2077,7 @@ namespace PrimMesher
         /// 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);
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/SculptMap.cs b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/SculptMap.cs
index b3d9cb6..01d11f4 100644
--- a/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/SculptMap.cs
+++ b/OpenSim/Region/PhysicsModules/Meshing/Meshmerizer/SculptMap.cs
@@ -163,11 +163,11 @@ namespace PrimMesher
         {
 
             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++)
             {
@@ -191,7 +191,7 @@ namespace PrimMesher
             return scaledImage;
         }
 
-    }        
-    
+    }
+
     }
 #endif
diff --git a/OpenSim/Region/PhysicsModules/Meshing/Properties/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/Meshing/Properties/AssemblyInfo.cs
index 8a842d4..5c257e6 100644
--- a/OpenSim/Region/PhysicsModules/Meshing/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/PhysicsModules/Meshing/Properties/AssemblyInfo.cs
@@ -3,7 +3,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Mono.Addins;
 
-// General Information about an assembly is controlled through the following 
+// 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.PhysicsModule.Meshing")]
@@ -15,8 +15,8 @@ using Mono.Addins;
 [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 
+// 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)]
 
@@ -26,7 +26,7 @@ using Mono.Addins;
 // Version information for an assembly consists of the following four values:
 //
 //      Major Version
-//      Minor Version 
+//      Minor Version
 //      Build Number
 //      Revision
 //
diff --git a/OpenSim/Region/PhysicsModules/Ode/ODEApi.cs b/OpenSim/Region/PhysicsModules/Ode/ODEApi.cs
index 12086c8..c851b12 100644
--- a/OpenSim/Region/PhysicsModules/Ode/ODEApi.cs
+++ b/OpenSim/Region/PhysicsModules/Ode/ODEApi.cs
@@ -34,8 +34,8 @@ 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 opensim team;
  * changes by Aurora team http://www.aurora-sim.org/
  * changes by Ubit Umarov
  */
@@ -52,18 +52,18 @@ namespace OpenSim.Region.PhysicsModule.ODE
 // 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;
+    using dReal = System.Single;
 //#endif
 
-        public static class d
-        {
-                public static dReal Infinity = dReal.MaxValue;
+    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
+        #region Flags and Enumerations
 
         [Flags]
         public enum AllocateODEDataFlags : uint
@@ -79,101 +79,101 @@ namespace OpenSim.Region.PhysicsModule.ODE
             dInitFlagManualThreadCleanup = 0x00000001
         }
 
-                [Flags]
-                public enum ContactFlags : int
-                {
-                        Mu2 = 0x001,
-                        FDir1 = 0x002,
-                        Bounce = 0x004,
-                        SoftERP = 0x008,
-                        SoftCFM = 0x010,
-                        Motion1 = 0x020,
-                        Motion2 = 0x040,
+        [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,
+            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,
+            FirstSpaceClass,
+            SimpleSpaceClass = FirstSpaceClass,
+            HashSpaceClass,
+            QuadTreeSpaceClass,
+            LastSpaceClass = QuadTreeSpaceClass,
             ubtTerrainClass,
-                        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
-                }
+            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
         {
@@ -185,24 +185,24 @@ namespace OpenSim.Region.PhysicsModule.ODE
             ZYX = ((2)|(1<<2)|(0<<4))
         }
 
-                #endregion
+        #endregion
 
-                #region Callbacks
+        #region Callbacks
 
-                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-                public delegate int AABBTestFn(IntPtr o1, IntPtr o2, ref AABB aabb);
+        [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 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 void GetAABBFn(IntPtr geom, out AABB aabb);
 
-                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-                public delegate ColliderFn GetColliderFnFn(int num);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate ColliderFn GetColliderFnFn(int num);
 
-                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-                public delegate void GeomDtorFn(IntPtr o);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void GeomDtorFn(IntPtr o);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate dReal HeightfieldGetHeight(IntPtr p_user_data, int x, int z);
@@ -210,230 +210,230 @@ namespace OpenSim.Region.PhysicsModule.ODE
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate dReal OSTerrainGetHeight(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 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 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 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);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int TriRayCallback(IntPtr trimesh, IntPtr ray, int triangleIndex, dReal u, dReal v);
 
-                #endregion
+        #endregion
 
-                #region Structs
+        #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 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;
+        [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
-                {
+        [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 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;
+        [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
+            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);
+        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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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 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 = "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 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 = "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);
+        [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]
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyDestroy"), SuppressUnmanagedCodeSecurity]
         public static extern void BodyiDestroy(IntPtr body);
         public static void BodyDestroy(IntPtr body)
         {
@@ -441,114 +441,114 @@ namespace OpenSim.Region.PhysicsModule.ODE
             BodyiDestroy(body);
         }
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyDisable"), SuppressUnmanagedCodeSecurity]
-                public static extern void BodyDisable(IntPtr 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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);
@@ -560,38 +560,38 @@ namespace OpenSim.Region.PhysicsModule.ODE
         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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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);
@@ -620,11 +620,11 @@ namespace OpenSim.Region.PhysicsModule.ODE
         [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 = "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);
+        [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.
@@ -634,76 +634,76 @@ namespace OpenSim.Region.PhysicsModule.ODE
         [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 = "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 = "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 = "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 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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "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);
+        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 = "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 = "dConnectingJoint"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr ConnectingJoint(IntPtr j1, IntPtr j2);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateBox"), SuppressUnmanagedCodeSecurity]
+        [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)
+        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]
+        [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)
         {
@@ -711,23 +711,23 @@ namespace OpenSim.Region.PhysicsModule.ODE
             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);
+        [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);
+        [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]
+        [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)
         {
@@ -745,23 +745,23 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
 
 
-        
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateGeom"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr CreateiGeom(int classnum);
+
+        [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 = "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 = "dCreateGeomTransform"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr CreateGeomTransform(IntPtr space);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreatePlane"), SuppressUnmanagedCodeSecurity]
+        [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)
         {
@@ -769,25 +769,25 @@ namespace OpenSim.Region.PhysicsModule.ODE
             return CreateiPlane(space, a, b, c, d);
         }
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateRay"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr CreateiRay(IntPtr space, dReal length);
+        [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);
+        [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);
+        [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)
         {
@@ -795,79 +795,79 @@ namespace OpenSim.Region.PhysicsModule.ODE
             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);
+        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 = "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 = "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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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 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 = "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 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 = "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 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 = "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 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 = "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 = "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 = "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);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomDestroy"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomiDestroy(IntPtr geom);
         public static void GeomDestroy(IntPtr geom)
         {
             NTotalGeoms--;
@@ -875,63 +875,63 @@ namespace OpenSim.Region.PhysicsModule.ODE
         }
 
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomDisable"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomDisable(IntPtr 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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "dGeomGetClass"), SuppressUnmanagedCodeSecurity]
+        public static extern GeomClassID GeomGetClass(IntPtr geom);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetData"), SuppressUnmanagedCodeSecurity]
+        [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)
-                {
+        [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]
+        [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)
         {
@@ -940,85 +940,85 @@ namespace OpenSim.Region.PhysicsModule.ODE
             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 = "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 = "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 = "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, 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 = "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 = "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, 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, 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 = "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, 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 = "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, 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 = "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 = "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 = "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 = "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 = "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 = "dGeomHeightfieldSetHeightfieldData"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomHeightfieldSetHeightfieldData(IntPtr g, IntPtr d);
 
 
         [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataBuild"), SuppressUnmanagedCodeSecurity]
@@ -1047,279 +1047,279 @@ namespace OpenSim.Region.PhysicsModule.ODE
         public static extern void GeomOSTerrainSetHeightfieldData(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 = "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 = "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 = "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 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 = "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 = "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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "dGeomSetOffsetPosition"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetOffsetPosition(IntPtr geom, dReal x, dReal y, dReal z);
 
-                [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 = "dGeomSetOffsetQuaternion"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetOffsetQuaternion(IntPtr geom, ref Quaternion Q);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldQuaternion"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetOffsetWorldQuaternion(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 = "dGeomSetOffsetWorldQuaternion"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetOffsetWorldQuaternion(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 = "dGeomSetOffsetWorldRotation"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetOffsetWorldRotation(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 = "dGeomSetOffsetWorldRotation"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetOffsetWorldRotation(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 = "dGeomSetPosition"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetPosition(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 = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetQuaternion(IntPtr geom, ref Quaternion quat);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldQuaternion"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetOffsetWorldQuaternion(IntPtr geom, ref dReal X);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetQuaternion(IntPtr geom, ref dReal w);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldRotation"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetOffsetWorldRotation(IntPtr geom, ref Matrix3 R);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetRotation(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 = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetRotation(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 = "dGeomSphereGetRadius"), SuppressUnmanagedCodeSecurity]
-                public static extern dReal GeomSphereGetRadius(IntPtr geom);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetQuaternion(IntPtr geom, ref Quaternion quat);
 
-                [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 = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetQuaternion(IntPtr geom, ref dReal w);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSphereSetRadius"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSphereSetRadius(IntPtr geom, dReal radius);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetRotation(IntPtr geom, ref Matrix3 R);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetCleanup"), SuppressUnmanagedCodeSecurity]
-                public static extern int GeomTransformGetCleanup(IntPtr geom);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetRotation(IntPtr geom, ref dReal M00);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetGeom"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr GeomTransformGetGeom(IntPtr geom);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSphereGetRadius"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal GeomSphereGetRadius(IntPtr geom);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetInfo"), SuppressUnmanagedCodeSecurity]
-                public static extern int GeomTransformGetInfo(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 = "dGeomTransformSetCleanup"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTransformSetCleanup(IntPtr geom, int mode);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSphereSetRadius"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSphereSetRadius(IntPtr geom, dReal radius);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformSetGeom"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTransformSetGeom(IntPtr geom, IntPtr obj);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetCleanup"), SuppressUnmanagedCodeSecurity]
+        public static extern int GeomTransformGetCleanup(IntPtr geom);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformSetInfo"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTransformSetInfo(IntPtr geom, int info);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetGeom"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr GeomTransformGetGeom(IntPtr geom);
 
-                [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 = "dGeomTransformGetInfo"), SuppressUnmanagedCodeSecurity]
+        public static extern int GeomTransformGetInfo(IntPtr geom);
 
-                [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 = "dGeomTransformSetCleanup"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTransformSetCleanup(IntPtr geom, int mode);
 
-                [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 = "dGeomTransformSetGeom"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTransformSetGeom(IntPtr geom, IntPtr obj);
 
-                [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 = "dGeomTransformSetInfo"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTransformSetInfo(IntPtr geom, int info);
 
-                [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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "dGeomTriMeshClearTCCache"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTriMeshClearTCCache(IntPtr g);
+        [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 = "dGeomTriMeshDataCreate"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr GeomTriMeshDataCreate();
+        [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 = "dGeomTriMeshDataDestroy"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTriMeshDataDestroy(IntPtr d);
+        [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 = "dGeomTriMeshDataGet"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr GeomTriMeshDataGet(IntPtr d, int data_id);
+        [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 = "dGeomTriMeshDataPreprocess"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTriMeshDataPreprocess(IntPtr d);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshClearTCCache"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTriMeshClearTCCache(IntPtr g);
 
-                [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 = "dGeomTriMeshDataCreate"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr GeomTriMeshDataCreate();
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataUpdate"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTriMeshDataUpdate(IntPtr d);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataDestroy"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTriMeshDataDestroy(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 = "dGeomTriMeshDataGet"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr GeomTriMeshDataGet(IntPtr d, int data_id);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetArrayCallback"), SuppressUnmanagedCodeSecurity]
-                public static extern TriArrayCallback GeomTriMeshGetArrayCallback(IntPtr g);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataPreprocess"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTriMeshDataPreprocess(IntPtr d);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetCallback"), SuppressUnmanagedCodeSecurity]
-                public static extern TriCallback GeomTriMeshGetCallback(IntPtr g);
+        [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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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);
@@ -1334,416 +1334,416 @@ namespace OpenSim.Region.PhysicsModule.ODE
             return s;
         }
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dHashSpaceCreate"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr HashSpaceCreate(IntPtr space);
+        [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 = "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 = "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 = "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 = "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);
+        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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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);
@@ -1755,119 +1755,119 @@ namespace OpenSim.Region.PhysicsModule.ODE
             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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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);
@@ -1875,53 +1875,53 @@ namespace OpenSim.Region.PhysicsModule.ODE
         [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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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 = "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 = "dWorldGetContactSurfaceLayer"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal WorldGetContactSurfaceLayer(IntPtr world);
 
         [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAngularDamping"), SuppressUnmanagedCodeSecurity]
         public static extern dReal WorldGetAngularDamping(IntPtr world);
@@ -1935,23 +1935,23 @@ namespace OpenSim.Region.PhysicsModule.ODE
         [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 = "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 = "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 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 = "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 = "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);
@@ -1959,67 +1959,67 @@ namespace OpenSim.Region.PhysicsModule.ODE
         [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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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);
-        }
+        [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/Ode/ODECharacter.cs b/OpenSim/Region/PhysicsModules/Ode/ODECharacter.cs
index aaf90f2..98bfd1c 100644
--- a/OpenSim/Region/PhysicsModules/Ode/ODECharacter.cs
+++ b/OpenSim/Region/PhysicsModules/Ode/ODECharacter.cs
@@ -149,7 +149,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
         /// Collision geometry
         /// </summary>
         internal IntPtr Shell { get; private set; }
-        
+
         private IntPtr Amotor = IntPtr.Zero;
         private d.Mass ShellMass;
 
@@ -237,7 +237,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
             m_tainted_isPhysical = true; // new tainted status: need to create ODE information
 
             _parent_scene.AddPhysicsActorTaint(this);
-            
+
             Name = avName;
         }
 
@@ -461,7 +461,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                             value.Z = _parent_scene.GetTerrainHeightAtXY(127, 127) + 5;
                         }
 
-                        m_taintPosition = value;                        
+                        m_taintPosition = value;
                         _parent_scene.AddPhysicsActorTaint(this);
                     }
                     else
@@ -796,7 +796,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
         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
 
@@ -811,7 +811,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
             d.Vector3 localpos = d.BodyGetPosition(Body);
             Vector3 localPos = new Vector3(localpos.X, localpos.Y, localpos.Z);
-            
+
             if (!localPos.IsFinite())
             {
                 m_log.WarnFormat(
@@ -1248,10 +1248,10 @@ namespace OpenSim.Region.PhysicsModule.ODE
         }
 
         public override Vector3 PIDTarget { set { return; } }
-        public override bool PIDActive 
-        { 
+        public override bool PIDActive
+        {
             get { return false; }
-            set { return; } 
+            set { return; }
         }
         public override float PIDTau { set { return; } }
 
@@ -1259,7 +1259,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
         public override bool PIDHoverActive {get {return false;} 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; } }
@@ -1369,7 +1369,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 //                    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()
diff --git a/OpenSim/Region/PhysicsModules/Ode/ODEDynamics.cs b/OpenSim/Region/PhysicsModules/Ode/ODEDynamics.cs
index ff19384..7e95d7f 100644
--- a/OpenSim/Region/PhysicsModules/Ode/ODEDynamics.cs
+++ b/OpenSim/Region/PhysicsModules/Ode/ODEDynamics.cs
@@ -914,7 +914,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
             // Sum velocities
             m_lastAngularVelocity = m_angularMotorVelocity + vertattr; // + bank + deflection
-            
+
             if ((m_flags & (VehicleFlag.NO_DEFLECTION_UP)) != 0)
             {
                 m_lastAngularVelocity.X = 0;
diff --git a/OpenSim/Region/PhysicsModules/Ode/ODEModule.cs b/OpenSim/Region/PhysicsModules/Ode/ODEModule.cs
index d61ee61..22fc84d 100644
--- a/OpenSim/Region/PhysicsModules/Ode/ODEModule.cs
+++ b/OpenSim/Region/PhysicsModules/Ode/ODEModule.cs
@@ -9,14 +9,14 @@ using OpenSim.Region.Framework.Interfaces;
 
 namespace OpenSim.Region.PhysicsModule.ODE
 {
-        [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "ODEPhysicsScene")]
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "ODEPhysicsScene")]
     public class OdeModule : INonSharedRegionModule
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private bool m_Enabled = false;
-                private IConfigSource m_config;
-                private OdeScene  m_scene;
+        private IConfigSource m_config;
+        private OdeScene  m_scene;
 
        #region INonSharedRegionModule
 
@@ -84,6 +84,6 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
             m_scene.RegionLoaded();
         }
-        #endregion                      
+        #endregion
     }
 }
diff --git a/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs b/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs
index 36546aa..8934330 100644
--- a/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs
+++ b/OpenSim/Region/PhysicsModules/Ode/ODEPrim.cs
@@ -33,7 +33,7 @@
  * 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 
+ * 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.
@@ -133,7 +133,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
         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_buoyancy;                //KF: m_buoyancy should be set by llSetBuoyancy() for non-vehicle.
 
         // private float m_tensor = 5f;
         private int body_autodisable_frames = 20;
@@ -170,7 +170,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
         private PrimitiveBaseShape _pbs;
         private OdeScene _parent_scene;
-        
+
         /// <summary>
         /// The physics space which contains prim geometries
         /// </summary>
@@ -443,7 +443,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
                 d.BodySetAutoDisableFlag(Body, true);
                 d.BodySetAutoDisableSteps(Body, body_autodisable_frames);
-                
+
                 // disconnect from world gravity so we can apply buoyancy
                 d.BodySetGravityMode (Body, false);
 
@@ -474,8 +474,8 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
             float returnMass = 0;
             float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f;
-            float hollowVolume = hollowAmount * hollowAmount; 
-            
+            float hollowVolume = hollowAmount * hollowAmount;
+
             switch (_pbs.ProfileShape)
             {
                 case ProfileShape.Square:
@@ -511,16 +511,16 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
                     else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
                         {
-                        //a tube 
+                        //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:
@@ -579,7 +579,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                         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)
                             {
 
@@ -845,7 +845,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 else
                 {
                     _parent_scene.DeactivatePrim(this);
-                    
+
                     m_collisionCategories &= ~CollisionCategories.Body;
                     m_collisionFlags &= ~(CollisionCategories.Wind | CollisionCategories.Land);
 
@@ -916,7 +916,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 else
                 {
                     _triMeshData = d.GeomTriMeshDataCreate();
-    
+
                     d.GeomTriMeshDataBuildSimple(_triMeshData, vertices, vertexStride, vertexCount, indices, indexCount, triStride);
                     d.GeomTriMeshDataPreprocess(_triMeshData);
                     m_MeshToTriMeshMap[mesh] = _triMeshData;
@@ -974,7 +974,7 @@ Console.WriteLine("ZProcessTaints for " + Name);
                     rotate();
                 }
             }
-        
+
             if (m_taintPhysics != IsPhysical && !(m_taintparent != _parent))
                 changePhysicsStatus();
 
@@ -1074,7 +1074,7 @@ Console.WriteLine("ZProcessTaints for " + Name);
             else if (_parent != null && m_taintparent == null)
             {
 //Console.WriteLine("  changelink B");
-            
+
                 if (_parent is OdePrim)
                 {
                     OdePrim obj = (OdePrim)_parent;
@@ -1082,16 +1082,16 @@ Console.WriteLine("ZProcessTaints for " + Name);
                     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;
         }
@@ -1345,7 +1345,7 @@ Console.WriteLine("ZProcessTaints for " + Name);
                 // 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.
@@ -1359,7 +1359,7 @@ Console.WriteLine("ZProcessTaints for " + Name);
                 // 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 
+                // 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.
 
@@ -1565,7 +1565,7 @@ Console.WriteLine("CreateGeom:");
         private void changeadd()
         {
 //            m_log.DebugFormat("[ODE PRIM]: Adding prim {0}", Name);
-            
+
             int[] iprimspaceArrItem = _parent_scene.calculateSpaceArrayItemFromPos(_position);
             IntPtr targetspace = _parent_scene.calculateSpaceForGeom(_position);
 
@@ -1711,10 +1711,10 @@ Console.WriteLine(" JointCreateFixed");
 //                    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 
+                    // 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;
 
@@ -1729,7 +1729,7 @@ Console.WriteLine(" JointCreateFixed");
                         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
 
@@ -1738,7 +1738,7 @@ Console.WriteLine(" JointCreateFixed");
                             //PID_G = PID_G / m_PIDTau;
                             m_PIDTau = 1;
                         }
-    
+
                         if ((PID_G - m_PIDTau) <= 0)
                         {
                             PID_G = m_PIDTau + 1;
@@ -1761,7 +1761,7 @@ Console.WriteLine(" JointCreateFixed");
                         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
@@ -1782,7 +1782,7 @@ Console.WriteLine(" JointCreateFixed");
                             // 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);
@@ -1793,7 +1793,7 @@ Console.WriteLine(" JointCreateFixed");
                     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;
 
@@ -1850,7 +1850,7 @@ Console.WriteLine(" JointCreateFixed");
                         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
@@ -1888,7 +1888,7 @@ Console.WriteLine(" JointCreateFixed");
                         {
                             // 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. 
+                            // and the body should fall again.
                             d.BodySetLinearVel(Body, 0f, 0f, 0f);
                             d.BodySetForce(Body, 0, 0, 0);
                             enableBodySoft();
@@ -1897,7 +1897,7 @@ Console.WriteLine(" JointCreateFixed");
                         // 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)
@@ -1916,7 +1916,7 @@ Console.WriteLine(" JointCreateFixed");
               //  _zeroPosition = d.BodyGetPosition(Body);
                 return;
 //Console.WriteLine("Nothing " +  Name);
-               
+
             }
         }
 
@@ -1942,7 +1942,7 @@ Console.WriteLine(" JointCreateFixed");
                 // daughter prim, do Geom set
                 d.GeomSetQuaternion(prim_geom, ref myrot);
             }
-            
+
             resetCollisionAccounting();
             m_taintrot = _orientation;
         }
@@ -2080,7 +2080,7 @@ Console.WriteLine(" JointCreateFixed");
                     else
                         m_assetFailed = false;
                 }
-                    
+
             }
 
             CreateGeom(m_targetSpace, mesh);
@@ -2312,7 +2312,7 @@ Console.WriteLine(" JointCreateFixed");
                         }
                         d.BodyEnable(Body);
                         d.BodyAddTorque(Body, iforce.X, iforce.Y, iforce.Z);
-                        
+
                     }
                     m_angularforcelist.Clear();
                 }
@@ -2342,7 +2342,7 @@ Console.WriteLine(" JointCreateFixed");
                         d.BodySetLinearVel(Body, m_taintVelocity.X, m_taintVelocity.Y, m_taintVelocity.Z);
                     }
                 }
-                
+
                 //resetCollisionAccounting();
             }
 
@@ -2686,7 +2686,7 @@ Console.WriteLine(" JointCreateFixed");
 
             if(m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)
                 m_vehicle.Stop(); // this also updates vehicle last position from the body position
-            
+
             enableBodySoft();
 
             outofBounds = false;
@@ -2899,12 +2899,12 @@ Console.WriteLine(" JointCreateFixed");
                         _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. 
+
+                        // 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)) 
+                        if (m_throttleUpdates || PIDActive || (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE) || (Amotor != IntPtr.Zero))
                         {
                             m_minvelocity = 0.5f;
                         }
@@ -2973,8 +2973,8 @@ Console.WriteLine(" JointCreateFixed");
         {
         }
 
-        public override Vector3 PIDTarget 
-        { 
+        public override Vector3 PIDTarget
+        {
             set
             {
                 if (value.IsFinite())
@@ -2983,7 +2983,7 @@ Console.WriteLine(" JointCreateFixed");
                 }
                 else
                     m_log.WarnFormat("[PHYSICS]: Got NaN PIDTarget from Scene on Object {0}", Name);
-            } 
+            }
         }
 
         public override bool PIDActive { get; set; }
@@ -2993,7 +2993,7 @@ Console.WriteLine(" JointCreateFixed");
         public override bool PIDHoverActive { get { return m_useHoverPID;} 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; } }
@@ -3189,7 +3189,7 @@ Console.WriteLine(" JointCreateFixed");
 //                m_assetFailed = false;
 
 //                m_log.DebugFormat(
-//                    "[ODE PRIM]: Received mesh/sculpt data asset {0} with {1} bytes for {2} at {3} in {4}", 
+//                    "[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;
@@ -3201,6 +3201,6 @@ Console.WriteLine(" JointCreateFixed");
                     "[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
index a21ec2b..78dd7de 100644
--- a/OpenSim/Region/PhysicsModules/Ode/ODERayCastRequestManager.cs
+++ b/OpenSim/Region/PhysicsModules/Ode/ODERayCastRequestManager.cs
@@ -75,7 +75,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
         {
             m_scene = pScene;
             nearCallback = near;
-            
+
         }
 
         /// <summary>
@@ -136,7 +136,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                     ODERayCastRequest[] reqs = m_PendingRequests.ToArray();
                     for (int i = 0; i < reqs.Length; i++)
                     {
-                        if (reqs[i].callbackMethod != null) // quick optimization here, don't raycast 
+                        if (reqs[i].callbackMethod != null) // quick optimization here, don't raycast
                             RayCast(reqs[i]);               // if there isn't anyone to send results
                     }
 
@@ -151,7 +151,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                     ODERayRequest[] reqs = m_PendingRayRequests.ToArray();
                     for (int i = 0; i < reqs.Length; i++)
                     {
-                        if (reqs[i].callbackMethod != null) // quick optimization here, don't raycast 
+                        if (reqs[i].callbackMethod != null) // quick optimization here, don't raycast
                             RayCast(reqs[i]);               // if there isn't anyone to send results
                     }
 
@@ -247,7 +247,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                     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)
         {
@@ -262,7 +262,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
             {
                 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
@@ -290,7 +290,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
             int count = 0;
             try
             {
-                
+
                 if (g1 == g2)
                     return; // Can't collide with yourself
 
@@ -326,7 +326,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                     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;
diff --git a/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs b/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs
index ed2aad4..d15568e 100644
--- a/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs
+++ b/OpenSim/Region/PhysicsModules/Ode/OdeScene.cs
@@ -126,7 +126,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
         /// </remarks>
         internal static Object UniversalColliderSyncObject = new Object();
         internal static Object SimulationLock = new Object();
-        
+
         /// <summary>
         /// Is stats collecting enabled for this ODE scene?
         /// </summary>
@@ -495,14 +495,14 @@ namespace OpenSim.Region.PhysicsModule.ODE
         int spaceGridMaxY;
 
         private ODERayCastRequestManager m_rayCastManager;
-        
-                public Scene m_frameWorkScene = null;
+
+        public Scene m_frameWorkScene = null;
 
         public OdeScene(Scene pscene, IConfigSource psourceconfig, string pname, string pversion)
-                {
-                        m_config = psourceconfig;
-                        m_frameWorkScene = pscene;
-                        
+        {
+            m_config = psourceconfig;
+            m_frameWorkScene = pscene;
+
             EngineType = pname;
             PhysicsSceneName = EngineType + "/" + pscene.RegionInfo.RegionName;
             EngineName = pname + " " + pversion;
@@ -513,8 +513,8 @@ namespace OpenSim.Region.PhysicsModule.ODE
             InitialiseFromConfig(m_config);
 
             // This may not be that good since terrain may not be avaiable at this point
-            base.Initialise(pscene.PhysicsRequestAsset, 
-                (pscene.Heightmap != null ? pscene.Heightmap.GetFloatsSerialised() : new float[(int)(extent.X * extent.Y)]), 
+            base.Initialise(pscene.PhysicsRequestAsset,
+                (pscene.Heightmap != null ? pscene.Heightmap.GetFloatsSerialised() : new float[(int)(extent.X * extent.Y)]),
                 (float)pscene.RegionInfo.RegionSettings.WaterHeight);
 
         }
@@ -524,8 +524,8 @@ namespace OpenSim.Region.PhysicsModule.ODE
             mesher = m_frameWorkScene.RequestModuleInterface<IMesher>();
             if (mesher == null)
                 m_log.WarnFormat("[ODE SCENE]: No mesher in {0}. Things will not work well.", PhysicsSceneName);
-                                
-                        m_frameWorkScene.PhysicsEnabled = true;                         
+
+            m_frameWorkScene.PhysicsEnabled = true;
         }
 
         /// <summary>
@@ -535,11 +535,11 @@ namespace OpenSim.Region.PhysicsModule.ODE
         /// </summary>
         private void Initialise(Vector3 regionExtent)
         {
-                        WorldExtents.X = regionExtent.X;
+            WorldExtents.X = regionExtent.X;
             m_regionWidth = (uint)regionExtent.X;
             WorldExtents.Y = regionExtent.Y;
             m_regionHeight = (uint)regionExtent.Y;
-                        
+
             nearCallback = near;
             m_rayCastManager = new ODERayCastRequestManager(this);
 
@@ -671,7 +671,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 spacesPerMeterY = spaceGridMaxY / WorldExtents.Y;
             }
 
-            staticPrimspace = new IntPtr[spaceGridMaxX, spaceGridMaxY]; 
+            staticPrimspace = new IntPtr[spaceGridMaxX, spaceGridMaxY];
 
             // make this index limits
             spaceGridMaxX--;
@@ -948,7 +948,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
             {
                 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
@@ -1027,10 +1027,10 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
             PhysicsActor p1;
             PhysicsActor p2;
-            
+
             p1ExpectedPoints = 0;
             p2ExpectedPoints = 0;
-            
+
             if (!actor_name_map.TryGetValue(g1, out p1))
             {
                 p1 = PANull;
@@ -1067,7 +1067,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 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)
                 {
@@ -1081,7 +1081,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 {
                     p2.IsColliding = true;
                 }
-                
+
                 //if ((framecount % m_returncollisions) == 0)
 
                 switch (p1.PhysicsActorType)
@@ -1160,7 +1160,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
                 // Logic for collision handling
                 // Note, that if *all* contacts are skipped (VolumeDetect)
-                // The prim still detects (and forwards) collision events but 
+                // The prim still detects (and forwards) collision events but
                 // appears to be phantom for the world
                 Boolean skipThisContact = false;
 
@@ -1235,10 +1235,10 @@ namespace OpenSim.Region.PhysicsModule.ODE
                                         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);
@@ -1350,7 +1350,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                                 material = ((OdePrim)p2).m_material;
                                 p2ExpectedPoints = ((OdePrim)p2).ExpectedCollisionContacts;
                             }
-                            
+
                             //m_log.DebugFormat("Material: {0}", material);
                             m_materialContacts[material, 0].geom = curContact;
 
@@ -1370,7 +1370,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 }
 
                 collision_accounting_events(p1, p2, maxDepthContact);
-                
+
                 if (count > ((p1ExpectedPoints + p2ExpectedPoints) * 0.25) + (geomContactPointsStartthrottle))
                 {
                     // If there are more then 3 contact points, it's likely
@@ -1410,7 +1410,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                              break;
                         }
                     }
-                } 
+                }
                 else if (at == ActorTypes.Prim)
                 {
                     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)))
@@ -1544,11 +1544,11 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 // 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
@@ -1562,7 +1562,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 {
                     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)
                 //{
@@ -1655,7 +1655,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                             //m_log.DebugFormat("x{0} y{1} = {2}", x, y, (float)TerrainHeightFieldHeights[heightFieldGeom][index]);
                             return (float)TerrainHeightFieldHeights[heightFieldGeom][index];
                         }
-                            
+
                         else
                             return 0f;
                     }
@@ -1675,7 +1675,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
             {
                 return 0f;
             }
-        } 
+        }
 // End recovered. Kitto Flora
 
         /// <summary>
@@ -1685,7 +1685,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
         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;
         }
@@ -2071,7 +2071,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 
             lock (externalJointRequestsLock)
             {
-                if (!requestedJointsToBeCreated.Contains(joint)) // forbid same creation request from entering twice 
+                if (!requestedJointsToBeCreated.Contains(joint)) // forbid same creation request from entering twice
                 {
                     requestedJointsToBeCreated.Add(joint);
                 }
@@ -2417,7 +2417,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 //            waitForSpaceUnlock(space);
             d.SpaceSetSublevel(space, 1);
             d.SpaceAdd(space, staticPrimspace[iprimspaceArrItemX, iprimspaceArrItemY]);
-            
+
             return staticPrimspace[iprimspaceArrItemX, iprimspaceArrItemY];
         }
 
@@ -2514,7 +2514,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 iPropertiesNotSupportedDefault++;
 
             if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0))
-                iPropertiesNotSupportedDefault++; 
+                iPropertiesNotSupportedDefault++;
 
             if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0)
                 iPropertiesNotSupportedDefault++;
@@ -2587,7 +2587,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
 #if SPAM
             m_log.Debug("Mesh");
 #endif
-            return true; 
+            return true;
         }
 
         /// <summary>
@@ -2652,7 +2652,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                         }
                         _taintedPrims.Clear();
                     }
-                   
+
                     int time = Util.EnvironmentTickCountSubtract(tstart);
                     m_log.InfoFormat("[Ode] finished {0} operations in {1}ms", donechanges, time);
                 }
@@ -2716,7 +2716,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                 CreateRequestedJoints(); // this must be outside of the lock (OdeLock) to avoid deadlocks
             }
 
-            
+
             lock (OdeLock)
             {
                 d.AllocateODEDataForThread(~0U);
@@ -3109,7 +3109,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
                                         // 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.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
@@ -3237,7 +3237,7 @@ namespace OpenSim.Region.PhysicsModule.ODE
             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
diff --git a/OpenSim/Region/PhysicsModules/POS/POSCharacter.cs b/OpenSim/Region/PhysicsModules/POS/POSCharacter.cs
index 28d2b53..341530e 100644
--- a/OpenSim/Region/PhysicsModules/POS/POSCharacter.cs
+++ b/OpenSim/Region/PhysicsModules/POS/POSCharacter.cs
@@ -273,10 +273,10 @@ namespace OpenSim.Region.PhysicsModule.POS
             set { return; }
         }
 
-        public override bool PIDActive 
-        { 
+        public override bool PIDActive
+        {
             get { return false; }
-            set { return; } 
+            set { return; }
         }
 
         public override float PIDTau
@@ -304,7 +304,7 @@ namespace OpenSim.Region.PhysicsModule.POS
         {
             set { return; }
         }
-        
+
         public override Quaternion APIDTarget
         {
             set { return; }
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/IMesher.cs b/OpenSim/Region/PhysicsModules/SharedBase/IMesher.cs
index 88169bb..1a8409e 100644
--- a/OpenSim/Region/PhysicsModules/SharedBase/IMesher.cs
+++ b/OpenSim/Region/PhysicsModules/SharedBase/IMesher.cs
@@ -48,7 +48,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
     // 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 
+    public enum LevelOfDetail
     {
         High = 32,
         Medium = 16,
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/NullPhysicsScene.cs b/OpenSim/Region/PhysicsModules/SharedBase/NullPhysicsScene.cs
index 432708c..8079e79 100644
--- a/OpenSim/Region/PhysicsModules/SharedBase/NullPhysicsScene.cs
+++ b/OpenSim/Region/PhysicsModules/SharedBase/NullPhysicsScene.cs
@@ -37,7 +37,7 @@ 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(
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs
index 250b155..33f0337 100644
--- a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs
+++ b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsActor.cs
@@ -134,8 +134,8 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
                 m_objCollisionList.Add(localID, contact);
             }
             else
-            {   
-                float lastVel = m_objCollisionList[localID].RelativeSpeed;        
+            {
+                float lastVel = m_objCollisionList[localID].RelativeSpeed;
                 if (m_objCollisionList[localID].PenetrationDepth < contact.PenetrationDepth)
                 {
                     if(Math.Abs(lastVel) > Math.Abs(contact.RelativeSpeed))
@@ -201,7 +201,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
         {
             get { return new NullPhysicsActor(); }
         }
-   
+
         public virtual bool Building { get; set; }
 
         public virtual void getContactData(ref ContactData cdata)
@@ -263,7 +263,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
         public abstract void delink();
 
         public abstract void LockAngularMotion(byte axislocks);
- 
+
         public virtual void RequestPhysicsterseUpdate()
         {
             // Make a temporary copy of the event to avoid possibility of
@@ -326,7 +326,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
         public abstract void VehicleFlags(int param, bool remove);
 
         // This is an overridable version of SetVehicle() that works for all physics engines.
-        // This is VERY inefficient. It behoves any physics engine to override this and 
+        // This is VERY inefficient. It behoves any physics engine to override this and
         //     implement a more efficient setting of all the vehicle parameters.
         public virtual void SetVehicle(object pvdata)
         {
@@ -453,7 +453,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
         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);
@@ -465,7 +465,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
 
         // 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)
@@ -629,7 +629,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
         public override int PhysicsActorType
         {
             get { return (int)m_actorType; }
-            set {               
+            set {
                 ActorTypes type = (ActorTypes)value;
                 switch (type)
                 {
@@ -664,10 +664,10 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
 
         public override Vector3 PIDTarget { set { return; } }
 
-        public override bool PIDActive 
+        public override bool PIDActive
         {
             get { return false; }
-            set { return; } 
+            set { return; }
         }
 
         public override float PIDTau { set { return; } }
@@ -676,12 +676,12 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
         public override bool PIDHoverActive {get {return false;} 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) { }
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsScene.cs b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsScene.cs
index aa51c4e..e8d6334 100644
--- a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsScene.cs
+++ b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsScene.cs
@@ -179,7 +179,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
         public virtual PhysicsActor AddAvatar(
             uint localID, string avName, Vector3 position, Vector3 size, bool isFlying)
         {
-            PhysicsActor ret = AddAvatar(localID, avName, position, Vector3.Zero, size, isFlying);             
+            PhysicsActor ret = AddAvatar(localID, avName, position, Vector3.Zero, size, isFlying);
             return ret;
         }
 
@@ -217,7 +217,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
             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)
         {
@@ -335,16 +335,16 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
         /// <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 
+        ///
+        /// 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>
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsVector.cs b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsVector.cs
index 76a82fa..5aae42f 100644
--- a/OpenSim/Region/PhysicsModules/SharedBase/PhysicsVector.cs
+++ b/OpenSim/Region/PhysicsModules/SharedBase/PhysicsVector.cs
@@ -49,7 +49,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
         public Vector3(Vector3 pv) : this(pv.X, pv.Y, pv.Z)
         {
         }
-        
+
         public void setValues(float x, float y, float z)
         {
             X = x;
diff --git a/OpenSim/Region/PhysicsModules/SharedBase/VehicleConstants.cs b/OpenSim/Region/PhysicsModules/SharedBase/VehicleConstants.cs
index e850b11..0b4c8c6 100644
--- a/OpenSim/Region/PhysicsModules/SharedBase/VehicleConstants.cs
+++ b/OpenSim/Region/PhysicsModules/SharedBase/VehicleConstants.cs
@@ -38,7 +38,7 @@ namespace OpenSim.Region.PhysicsModules.SharedBase
         TYPE_NONE = 0,
 
         /// <summary>
-        /// No Angular motor, High Left right friction, No Hover, Linear Deflection 1, no angular deflection 
+        /// 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,
diff --git a/OpenSim/Region/PhysicsModules/ubOde/ODEApi.cs b/OpenSim/Region/PhysicsModules/ubOde/ODEApi.cs
index daf3af1..35adf11 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODEApi.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODEApi.cs
@@ -34,8 +34,8 @@ 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 opensim team;
  * changes by Aurora team http://www.aurora-sim.org/
  * changes by Ubit Umarov
  */
@@ -51,18 +51,18 @@ namespace OdeAPI
 // 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;
+    using dReal = System.Single;
 //#endif
 
-        public static class d
-        {
-                public static dReal Infinity = dReal.MaxValue;
+    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
+        #region Flags and Enumerations
 
         [Flags]
         public enum AllocateODEDataFlags : uint
@@ -78,101 +78,101 @@ namespace OdeAPI
             dInitFlagManualThreadCleanup = 0x00000001
         }
 
-                [Flags]
-                public enum ContactFlags : int
-                {
-                        Mu2 = 0x001,
-                        FDir1 = 0x002,
-                        Bounce = 0x004,
-                        SoftERP = 0x008,
-                        SoftCFM = 0x010,
-                        Motion1 = 0x020,
-                        Motion2 = 0x040,
+        [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,
+            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,
+            FirstSpaceClass,
+            SimpleSpaceClass = FirstSpaceClass,
+            HashSpaceClass,
+            QuadTreeSpaceClass,
+            LastSpaceClass = QuadTreeSpaceClass,
             ubtTerrainClass,
-                        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
-                }
+            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
         {
@@ -184,24 +184,24 @@ namespace OdeAPI
             ZYX = ((2)|(1<<2)|(0<<4))
         }
 
-                #endregion
+        #endregion
 
-                #region Callbacks
+        #region Callbacks
 
-                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-                public delegate int AABBTestFn(IntPtr o1, IntPtr o2, ref AABB aabb);
+        [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 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 void GetAABBFn(IntPtr geom, out AABB aabb);
 
-                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-                public delegate ColliderFn GetColliderFnFn(int num);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate ColliderFn GetColliderFnFn(int num);
 
-                [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-                public delegate void GeomDtorFn(IntPtr o);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void GeomDtorFn(IntPtr o);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate dReal HeightfieldGetHeight(IntPtr p_user_data, int x, int z);
@@ -209,230 +209,230 @@ namespace OdeAPI
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate dReal OSTerrainGetHeight(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 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 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 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);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int TriRayCallback(IntPtr trimesh, IntPtr ray, int triangleIndex, dReal u, dReal v);
 
-                #endregion
+        #endregion
 
-                #region Structs
+        #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 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;
+        [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
-                {
+        [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 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;
+        [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
+            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);
+        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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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 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 = "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 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 = "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);
+        [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]
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyDestroy"), SuppressUnmanagedCodeSecurity]
         public static extern void BodyiDestroy(IntPtr body);
         public static void BodyDestroy(IntPtr body)
         {
@@ -440,114 +440,114 @@ namespace OdeAPI
             BodyiDestroy(body);
         }
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dBodyDisable"), SuppressUnmanagedCodeSecurity]
-                public static extern void BodyDisable(IntPtr 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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);
@@ -559,38 +559,38 @@ namespace OdeAPI
         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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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);
@@ -619,11 +619,11 @@ namespace OdeAPI
         [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 = "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);
+        [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.
@@ -633,76 +633,76 @@ namespace OdeAPI
         [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 = "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 = "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 = "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 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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "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);
+        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 = "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 = "dConnectingJoint"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr ConnectingJoint(IntPtr j1, IntPtr j2);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateBox"), SuppressUnmanagedCodeSecurity]
+        [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)
+        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]
+        [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)
         {
@@ -710,23 +710,23 @@ namespace OdeAPI
             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);
+        [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);
+        [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]
+        [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)
         {
@@ -744,23 +744,23 @@ namespace OdeAPI
 
 
 
-        
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateGeom"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr CreateiGeom(int classnum);
+
+        [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 = "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 = "dCreateGeomTransform"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr CreateGeomTransform(IntPtr space);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreatePlane"), SuppressUnmanagedCodeSecurity]
+        [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)
         {
@@ -768,25 +768,25 @@ namespace OdeAPI
             return CreateiPlane(space, a, b, c, d);
         }
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dCreateRay"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr CreateiRay(IntPtr space, dReal length);
+        [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);
+        [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);
+        [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)
         {
@@ -794,79 +794,79 @@ namespace OdeAPI
             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);
+        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 = "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 = "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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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 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 = "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 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 = "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 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 = "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 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 = "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 = "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 = "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);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomDestroy"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomiDestroy(IntPtr geom);
         public static void GeomDestroy(IntPtr geom)
         {
             NTotalGeoms--;
@@ -874,63 +874,63 @@ namespace OdeAPI
         }
 
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomDisable"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomDisable(IntPtr 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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "dGeomGetClass"), SuppressUnmanagedCodeSecurity]
+        public static extern GeomClassID GeomGetClass(IntPtr geom);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomGetData"), SuppressUnmanagedCodeSecurity]
+        [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)
-                {
+        [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]
+        [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)
         {
@@ -939,85 +939,85 @@ namespace OdeAPI
             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 = "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 = "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 = "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, 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 = "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 = "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, 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, 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 = "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, 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 = "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, 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 = "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 = "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 = "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 = "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 = "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 = "dGeomHeightfieldSetHeightfieldData"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomHeightfieldSetHeightfieldData(IntPtr g, IntPtr d);
 
 
         [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomUbitTerrainDataBuild"), SuppressUnmanagedCodeSecurity]
@@ -1046,279 +1046,279 @@ namespace OdeAPI
         public static extern void GeomOSTerrainSetHeightfieldData(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 = "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 = "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 = "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 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 = "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 = "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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "dGeomSetOffsetPosition"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetOffsetPosition(IntPtr geom, dReal x, dReal y, dReal z);
 
-                [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 = "dGeomSetOffsetQuaternion"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetOffsetQuaternion(IntPtr geom, ref Quaternion Q);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldQuaternion"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetOffsetWorldQuaternion(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 = "dGeomSetOffsetWorldQuaternion"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetOffsetWorldQuaternion(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 = "dGeomSetOffsetWorldRotation"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetOffsetWorldRotation(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 = "dGeomSetOffsetWorldRotation"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetOffsetWorldRotation(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 = "dGeomSetPosition"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetPosition(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 = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetQuaternion(IntPtr geom, ref Quaternion quat);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldQuaternion"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetOffsetWorldQuaternion(IntPtr geom, ref dReal X);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetQuaternion(IntPtr geom, ref dReal w);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetOffsetWorldRotation"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetOffsetWorldRotation(IntPtr geom, ref Matrix3 R);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetRotation(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 = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSetRotation(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 = "dGeomSphereGetRadius"), SuppressUnmanagedCodeSecurity]
-                public static extern dReal GeomSphereGetRadius(IntPtr geom);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetQuaternion(IntPtr geom, ref Quaternion quat);
 
-                [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 = "dGeomSetQuaternion"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetQuaternion(IntPtr geom, ref dReal w);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSphereSetRadius"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomSphereSetRadius(IntPtr geom, dReal radius);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetRotation(IntPtr geom, ref Matrix3 R);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetCleanup"), SuppressUnmanagedCodeSecurity]
-                public static extern int GeomTransformGetCleanup(IntPtr geom);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSetRotation"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSetRotation(IntPtr geom, ref dReal M00);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetGeom"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr GeomTransformGetGeom(IntPtr geom);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSphereGetRadius"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal GeomSphereGetRadius(IntPtr geom);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetInfo"), SuppressUnmanagedCodeSecurity]
-                public static extern int GeomTransformGetInfo(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 = "dGeomTransformSetCleanup"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTransformSetCleanup(IntPtr geom, int mode);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomSphereSetRadius"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomSphereSetRadius(IntPtr geom, dReal radius);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformSetGeom"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTransformSetGeom(IntPtr geom, IntPtr obj);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetCleanup"), SuppressUnmanagedCodeSecurity]
+        public static extern int GeomTransformGetCleanup(IntPtr geom);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformSetInfo"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTransformSetInfo(IntPtr geom, int info);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTransformGetGeom"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr GeomTransformGetGeom(IntPtr geom);
 
-                [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 = "dGeomTransformGetInfo"), SuppressUnmanagedCodeSecurity]
+        public static extern int GeomTransformGetInfo(IntPtr geom);
 
-                [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 = "dGeomTransformSetCleanup"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTransformSetCleanup(IntPtr geom, int mode);
 
-                [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 = "dGeomTransformSetGeom"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTransformSetGeom(IntPtr geom, IntPtr obj);
 
-                [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 = "dGeomTransformSetInfo"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTransformSetInfo(IntPtr geom, int info);
 
-                [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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "dGeomTriMeshClearTCCache"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTriMeshClearTCCache(IntPtr g);
+        [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 = "dGeomTriMeshDataCreate"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr GeomTriMeshDataCreate();
+        [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 = "dGeomTriMeshDataDestroy"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTriMeshDataDestroy(IntPtr d);
+        [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 = "dGeomTriMeshDataGet"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr GeomTriMeshDataGet(IntPtr d, int data_id);
+        [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 = "dGeomTriMeshDataPreprocess"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTriMeshDataPreprocess(IntPtr d);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshClearTCCache"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTriMeshClearTCCache(IntPtr g);
 
-                [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 = "dGeomTriMeshDataCreate"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr GeomTriMeshDataCreate();
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataUpdate"), SuppressUnmanagedCodeSecurity]
-                public static extern void GeomTriMeshDataUpdate(IntPtr d);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataDestroy"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTriMeshDataDestroy(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 = "dGeomTriMeshDataGet"), SuppressUnmanagedCodeSecurity]
+        public static extern IntPtr GeomTriMeshDataGet(IntPtr d, int data_id);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetArrayCallback"), SuppressUnmanagedCodeSecurity]
-                public static extern TriArrayCallback GeomTriMeshGetArrayCallback(IntPtr g);
+        [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshDataPreprocess"), SuppressUnmanagedCodeSecurity]
+        public static extern void GeomTriMeshDataPreprocess(IntPtr d);
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dGeomTriMeshGetCallback"), SuppressUnmanagedCodeSecurity]
-                public static extern TriCallback GeomTriMeshGetCallback(IntPtr g);
+        [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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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);
@@ -1333,416 +1333,416 @@ namespace OdeAPI
             return s;
         }
 
-                [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dHashSpaceCreate"), SuppressUnmanagedCodeSecurity]
-                public static extern IntPtr HashSpaceCreate(IntPtr space);
+        [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 = "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 = "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 = "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 = "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);
+        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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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);
@@ -1754,119 +1754,119 @@ namespace OdeAPI
             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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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);
@@ -1874,53 +1874,53 @@ namespace OdeAPI
         [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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 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 = "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 = "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 = "dWorldGetContactSurfaceLayer"), SuppressUnmanagedCodeSecurity]
+        public static extern dReal WorldGetContactSurfaceLayer(IntPtr world);
 
         [DllImport("ode", CallingConvention = CallingConvention.Cdecl, EntryPoint = "dWorldGetAngularDamping"), SuppressUnmanagedCodeSecurity]
         public static extern dReal WorldGetAngularDamping(IntPtr world);
@@ -1934,23 +1934,23 @@ namespace OdeAPI
         [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 = "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 = "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 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 = "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 = "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);
@@ -1958,67 +1958,67 @@ namespace OdeAPI
         [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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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);
-        }
+        [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/ubOde/ODECharacter.cs b/OpenSim/Region/PhysicsModules/ubOde/ODECharacter.cs
index f7e1044..9cef3d5 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODECharacter.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODECharacter.cs
@@ -67,7 +67,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         StopERP3 = 7 + 512,
         StopCFM3 = 8 + 512
     }
- 
+
     public class OdeCharacter : PhysicsActor
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
@@ -121,7 +121,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         private float m_buoyancy = 0f;
 
         private bool m_freemove = false;
- 
+
 //        private string m_name = String.Empty;
         // other filter control
         int m_colliderfilter = 0;
@@ -155,7 +155,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         public UUID m_uuid;
         public bool bad = false;
 
-        float mu;       
+        float mu;
 
         // HoverHeight control
         private float m_PIDHoverHeight;
@@ -218,7 +218,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             walkDivisor = walk_divisor;
             runDivisor = rundivisor;
 
-            m_mass = m_density * m_size.X * m_size.Y * m_size.Z; ; // sure we have a default           
+            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;
@@ -256,7 +256,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
         public override uint LocalID
         {
-            get { return m_localID; }     
+            get { return m_localID; }
             set { m_localID = value; }
         }
 
@@ -508,7 +508,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             {
                 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
@@ -636,7 +636,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         {
             get
             {
-                return m_targetVelocity; 
+                return m_targetVelocity;
             }
             set
             {
@@ -774,7 +774,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
             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;
@@ -900,7 +900,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             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)
         {
@@ -944,7 +944,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                         }
                     }
                     return true;
-                }               
+                }
 /*
                 d.AABB aabb;
                 d.GeomGetAABB(other,out aabb);
@@ -1141,7 +1141,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                             n.Y = 0f;
                             n.Z = 1.0f;
                          }
-                    }               
+                    }
                 }
 
                 if (depth < 0.2f)
@@ -1223,7 +1223,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                         break;
                 }     // end switch (m_PIDHoverType)
 
-                    // don't go underground 
+                    // don't go underground
                 if (m_targetHoverHeight > terrainheight + 0.5f * (aabb.MaxZ - aabb.MinZ))
                 {
                     float fz = (m_targetHoverHeight - localpos.Z);
@@ -1248,7 +1248,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     }
                 }
             }
-            
+
             //******************************************
             if (!m_iscolliding)
                 m_collideNormal.Z = 0;
@@ -1495,7 +1495,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         /// 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()
         {
@@ -1625,7 +1625,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                         CollisionEventsThisFrame.Clear();
                     }
                 }
-            }           
+            }
         }
 
         public override bool SubscribedEvents()
@@ -1697,7 +1697,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                       _position.Z + (m_size.Z - oldsz) * 0.5f);
 
 //                    Velocity = Vector3.Zero;
-                    m_targetVelocity = Vector3.Zero;                  
+                    m_targetVelocity = Vector3.Zero;
 
                     _parent_scene.actor_name_map[collider] = (PhysicsActor)this;
                     _parent_scene.actor_name_map[capsule] = (PhysicsActor)this;
@@ -1717,7 +1717,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     d.BodySetPosition(Body, newPos.X, newPos.Y, newPos.Z);
                 _position = newPos;
                 m_freemove = false;
-                m_pidControllerActive = true;               
+                m_pidControllerActive = true;
             }
 
         private void changeOrientation(Quaternion newOri)
@@ -1772,35 +1772,35 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
         private void changeSetTorque(Vector3 newTorque)
         {
-        }                                 
+        }
 
         private void changeAddForce(Vector3 newForce)
         {
-        }                                 
+        }
 
         private void changeAddAngularForce(Vector3 arg)
         {
-        }                                 
+        }
 
         private void changeAngularLock(byte 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)
         {
diff --git a/OpenSim/Region/PhysicsModules/ubOde/ODEDynamics.cs b/OpenSim/Region/PhysicsModules/ubOde/ODEDynamics.cs
index fa32441..63bef7c 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODEDynamics.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODEDynamics.cs
@@ -170,7 +170,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             m_type = vd.m_type;
             m_flags = vd.m_flags;
 
-            
+
             // Linear properties
             m_linearMotorDirection = vd.m_linearMotorDirection;
 
@@ -761,8 +761,8 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 roll = (float)Math.Atan2(minuszY, zZ);
             }
             return ;
-        }        
-        
+        }
+
         internal void Step()
         {
             IntPtr Body = rootPrim.Body;
@@ -797,7 +797,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             Vector3 curLocalAngVel = curAngVel * irotq; // current angular velocity in  local
 
             float ldampZ = 0;
-            
+
             bool mousemode = false;
             bool mousemodebank = false;
 
@@ -852,7 +852,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 m_lmEfect = 0;
                 m_ffactor = 1f;
             }
-           
+
             // hover
             if (m_VhoverTimescale < 300 && rootPrim.prim_geom != IntPtr.Zero)
             {
@@ -1001,7 +1001,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                         if (broll > halfpi)
                                             broll = pi - broll;
                                         else if (broll < -halfpi)
-                                            broll = -pi - broll;                           
+                                            broll = -pi - broll;
                     */
                     broll *= m_bankingEfficiency;
                     if (m_bankingMix != 0)
@@ -1054,7 +1054,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     float invamts = 1.0f/m_angularMotorTimescale;
                     float tmp;
 
-                    // get out of x == 0 plane 
+                    // get out of x == 0 plane
                     if(Math.Abs(dirv.X) < 0.001f)
                         dirv.X = 0.001f;
 
@@ -1068,7 +1068,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                         torque.Y += (tmp - curLocalAngVel.Y) * invamts;
                         torque.Y -= curLocalAngVel.Y * m_amdampY;
                     }
-                    else 
+                    else
                         torque.Y -= curLocalAngVel.Y * m_invtimestep;
 
                     if (Math.Abs(dirv.Y) > 0.01)
@@ -1099,7 +1099,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     {
                         if(mousemodebank)
                             torque.X -= curLocalAngVel.X * m_invtimestep;
-                        else 
+                        else
                             torque.Z -= curLocalAngVel.Z * m_invtimestep;
                     }
                 }
@@ -1133,11 +1133,11 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 if (m_angularDeflectionEfficiency > 0)
                 {
                     Vector3 dirv;
-                
+
                     if (curLocalVel.X > 0.01f)
                         dirv = curLocalVel;
                     else if (curLocalVel.X < -0.01f)
-                        // use oposite 
+                        // use oposite
                         dirv = -curLocalVel;
                     else
                     {
@@ -1167,7 +1167,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     torque.Z -= curLocalAngVel.Z * m_amdampZ;
                 }
             }
-          
+
             force *= dmass.mass;
 
             force += rootPrim.m_force;
diff --git a/OpenSim/Region/PhysicsModules/ubOde/ODEMeshWorker.cs b/OpenSim/Region/PhysicsModules/ubOde/ODEMeshWorker.cs
index bb661e5..923e2ff 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODEMeshWorker.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODEMeshWorker.cs
@@ -27,7 +27,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         AssetOK = 0x0f,     // 00001111
 
         NeedMask = 0x30,    // 00110000
-        needMesh = 0x10,    // 00010000 
+        needMesh = 0x10,    // 00010000
         needAsset = 0x20,   // 00100000
 
         FailMask = 0xC0,    // 11000000
@@ -287,7 +287,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         public bool needsMeshing(ODEPhysRepData repData)
         {
             PrimitiveBaseShape pbs = repData.pbs;
-            // check sculpts or meshs 
+            // check sculpts or meshs
             if (pbs.SculptEntry)
             {
                 if (meshSculptedPrim)
@@ -462,7 +462,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                         repData.meshState = MeshState.MeshFailed;
                         return;
                     }
-                }               
+                }
             }
 
             repData.meshState = MeshState.AssetOK;
@@ -525,7 +525,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             }
 
             mesh = m_mesher.CreateMesh(actor.Name, pbs, size, clod, true, convex, true);
-   
+
             if (mesh == null)
             {
                 if (pbs.SculptEntry)
@@ -607,7 +607,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
                     else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
                     {
-                        //a tube 
+                        //a tube
 
                         volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX);
                         tmp = 1.0f - 2.0e-2f * (float)(200 - _pbs.PathScaleY);
@@ -857,7 +857,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             // this is crude aproximation
             profileBegin = (float)_pbs.ProfileBegin * 2.0e-5f;
             profileEnd = 1.0f - (float)_pbs.ProfileEnd * 2.0e-5f;
-            volume *= (profileEnd - profileBegin);           
+            volume *= (profileEnd - profileBegin);
 
             repData.volume = volume;
         }
diff --git a/OpenSim/Region/PhysicsModules/ubOde/ODEModule.cs b/OpenSim/Region/PhysicsModules/ubOde/ODEModule.cs
index 51b8e4e..4cb1736 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODEModule.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODEModule.cs
@@ -11,16 +11,16 @@ using OpenSim.Region.Framework.Interfaces;
 
 namespace OpenSim.Region.PhysicsModule.ubOde
 {
-        [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "ubODEPhysicsScene")]
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "ubODEPhysicsScene")]
     class ubOdeModule : INonSharedRegionModule
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private static Dictionary<Scene, ODEScene> m_scenes = new Dictionary<Scene, ODEScene>();
         private bool m_Enabled = false;
-                private IConfigSource m_config;
+        private IConfigSource m_config;
         private bool OSOdeLib;
-        
+
 
        #region INonSharedRegionModule
 
@@ -80,7 +80,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
             if(m_scenes.ContainsKey(scene)) // ???
                 return;
-                    ODEScene newodescene = new ODEScene(scene, m_config, Name, Version, OSOdeLib);
+            ODEScene newodescene = new ODEScene(scene, m_config, Name, Version, OSOdeLib);
             m_scenes[scene] = newodescene;
         }
 
@@ -100,13 +100,13 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         {
             if (!m_Enabled)
                 return;
-            
+
             if(m_scenes.ContainsKey(scene))
             {
                 m_scenes[scene].RegionLoaded();
             }
 
         }
-        #endregion                      
+        #endregion
     }
 }
diff --git a/OpenSim/Region/PhysicsModules/ubOde/ODEPrim.cs b/OpenSim/Region/PhysicsModules/ubOde/ODEPrim.cs
index a50905b..a2fbf41 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODEPrim.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODEPrim.cs
@@ -33,7 +33,7 @@
  * 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 
+ * 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.
@@ -107,7 +107,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         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_buoyancy;                //KF: m_buoyancy should be set by llSetBuoyancy() for non-vehicle.
 
         private int body_autodisable_frames;
         public int bodydisablecontrol = 0;
@@ -143,7 +143,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
         private UUID? m_assetID;
         private MeshState m_meshState;
-        
+
         public ODEScene _parent_scene;
 
         /// <summary>
@@ -888,7 +888,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
                 m_lastVelocity = _velocity;
                 if (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)
-                    m_vehicle.Stop();              
+                    m_vehicle.Stop();
 
                 if(Body != IntPtr.Zero)
                     d.BodySetLinearVel(Body, 0, 0, 0); // stop it
@@ -980,7 +980,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         {
 //                m_log.DebugFormat("[axislock]: <{0},{1},{2}>", axis.X, axis.Y, axis.Z);
             AddChange(changes.AngLock, axislock);
-         
+
         }
 
         public override void SubscribeEvents(int ms)
@@ -1464,7 +1464,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             IntPtr vertices, indices;
             int vertexCount, indexCount;
             int vertexStride, triStride;
-            
+
             IMesh mesh = m_mesh;
 
             if (mesh == null)
@@ -1529,7 +1529,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 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;
@@ -1830,7 +1830,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             if (childrenPrim.Count == 0)
             {
                 collide_geom = prim_geom;
-                m_targetSpace = _parent_scene.ActiveSpace;               
+                m_targetSpace = _parent_scene.ActiveSpace;
             }
             else
             {
@@ -1911,7 +1911,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 d.BodySetLinearVel(Body, _velocity.X, _velocity.Y, _velocity.Z);
                 _zeroFlag = false;
                 bodydisablecontrol = 0;
-            }               
+            }
             _parent_scene.addActiveGroups(this);
         }
 
@@ -2011,7 +2011,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             d.Matrix3 mat = new d.Matrix3();
             d.Quaternion quat = new d.Quaternion();
 
-            d.Mass tmpdmass = new d.Mass { };         
+            d.Mass tmpdmass = new d.Mass { };
             d.Mass objdmass = new d.Mass { };
 
             d.BodyGetMass(Body, out tmpdmass);
@@ -2039,7 +2039,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             // subtract current prim inertia from object
             DMassSubPartFromObj(ref tmpdmass, ref objdmass);
 
-            // back prim own inertia 
+            // back prim own inertia
             tmpdmass = primdMass;
 
             // update to new position and orientation
@@ -2444,7 +2444,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             MakeBody();
         }
 
- 
+
         #region changes
 
         private void changeadd()
@@ -3011,7 +3011,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
             primVolume = repData.volume;
 
-            CreateGeom();          
+            CreateGeom();
 
             if (prim_geom != IntPtr.Zero)
             {
@@ -3145,7 +3145,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
                     d.BodySetLinearVel(Body, newVel.X, newVel.Y, newVel.Z);
                 }
-                //resetCollisionAccounting();           
+                //resetCollisionAccounting();
             }
             _velocity = newVel;
         }
@@ -3171,7 +3171,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
                     d.BodySetAngularVel(Body, newAngVel.X, newAngVel.Y, newAngVel.Z);
                 }
-                //resetCollisionAccounting();           
+                //resetCollisionAccounting();
             }
             m_rotationalVelocity = newAngVel;
         }
@@ -3316,7 +3316,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     // let vehicles sleep
                     if (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE)
                         return;
-                    
+
                     if (++bodydisablecontrol < 50)
                         return;
 
@@ -3414,7 +3414,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                             break;
                     }     // end switch (m_PIDHoverType)
 
-                    // don't go underground unless volumedetector 
+                    // don't go underground unless volumedetector
 
                     if (m_targetHoverHeight > m_groundHeight || m_isVolumeDetect)
                     {
@@ -3526,7 +3526,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
                         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 
+                        d.BodySetPosition(Body, lpos.X, lpos.Y, lpos.Z); // put it somewhere
                         m_lastposition = _position;
                         m_lastorientation = _orientation;
 
@@ -3635,7 +3635,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                         _orientation.X = ori.X;
                         _orientation.Y = ori.Y;
                         _orientation.Z = ori.Z;
-                        _orientation.W = ori.W;                   
+                        _orientation.W = ori.W;
                     }
 
                     // update velocities and aceleration
diff --git a/OpenSim/Region/PhysicsModules/ubOde/ODERayCastRequestManager.cs b/OpenSim/Region/PhysicsModules/ubOde/ODERayCastRequestManager.cs
index adefd5e..f671722 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODERayCastRequestManager.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODERayCastRequestManager.cs
@@ -139,7 +139,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                             continue;
                         }
                     }
-                   
+
                     CurrentRayFilter = req.filter;
                     CurrentMaxCount = req.Count;
 
@@ -279,7 +279,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         /// Method that actually initiates the raycast with spaces
         /// </summary>
         /// <param name="req"></param>
-        /// 
+        ///
 
         private void NoContacts(ODERayRequest req)
         {
@@ -488,7 +488,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             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)
         {
@@ -530,7 +530,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             uint col1 = d.GeomGetCollideBits(g1);
             uint col2 = d.GeomGetCollideBits(g2);
 */
-            
+
             uint ID = 0;
             PhysicsActor p2 = null;
 
@@ -671,7 +671,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             {
                 d.GeomDestroy(Plane);
                 Plane = IntPtr.Zero;
-            }           
+            }
         }
     }
 
diff --git a/OpenSim/Region/PhysicsModules/ubOde/ODEScene.cs b/OpenSim/Region/PhysicsModules/ubOde/ODEScene.cs
index 410463c..bed66cc 100644
--- a/OpenSim/Region/PhysicsModules/ubOde/ODEScene.cs
+++ b/OpenSim/Region/PhysicsModules/ubOde/ODEScene.cs
@@ -97,7 +97,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
         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 ?)
@@ -182,7 +182,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         const float comumContactERP = 0.75f;
         const float comumContactCFM = 0.0001f;
         const float comumContactSLIP = 0f;
-        
+
         float frictionMovementMult = 0.8f;
 
         float TerrainBounce = 0.1f;
@@ -241,7 +241,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         /// </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, PhysicsActor> actor_name_map = new Dictionary<IntPtr, PhysicsActor>();
 
@@ -262,7 +262,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         private IntPtr TerrainGeom;
         private float[] TerrainHeightFieldHeight;
         private GCHandle TerrainHeightFieldHeightsHandler = new 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();
@@ -330,7 +330,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             EngineType = pname;
             PhysicsSceneName = EngineType + "/" + pscene.RegionInfo.RegionName;
             EngineName = pname + " " + pversion;
-                        m_config = psourceconfig;
+            m_config = psourceconfig;
             m_OSOdeLib = pOSOdeLib;
 
 //            m_OSOdeLib = false; //debug
@@ -343,7 +343,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
             base.Initialise(m_frameWorkScene.PhysicsRequestAsset,
                 (m_frameWorkScene.Heightmap != null ? m_frameWorkScene.Heightmap.GetFloatsSerialised() : new float[m_frameWorkScene.RegionInfo.RegionSizeX * m_frameWorkScene.RegionInfo.RegionSizeY]),
-                (float)m_frameWorkScene.RegionInfo.RegionSettings.WaterHeight);           
+                (float)m_frameWorkScene.RegionInfo.RegionSettings.WaterHeight);
         }
 
         public void RegionLoaded()
@@ -354,7 +354,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 m_log.ErrorFormat("[ubOde] No mesher. module disabled");
                 return;
             }
-            
+
             m_meshWorker = new ODEMeshWorker(this, m_log, mesher, physicsconfig);
             m_frameWorkScene.PhysicsEnabled = true;
         }
@@ -394,7 +394,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 }
                 catch
                 {
-                    // i must RtC#FM 
+                    // i must RtC#FM
                     // i did!
                 }
 
@@ -674,7 +674,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
         /// <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)
         {
@@ -784,7 +784,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             if (count == 0)
                 return;
 
-            // try get physical actors 
+            // try get physical actors
             PhysicsActor p1;
             PhysicsActor p2;
 
@@ -1135,10 +1135,10 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                         chr.IsColliding = false;
                         // chr.CollidingGround = false; not done here
                         chr.CollidingObj = false;
-                        
+
                         if(chr.Body == IntPtr.Zero || chr.collider == IntPtr.Zero )
                             continue;
-                    
+
                         // do colisions with static space
                         d.SpaceCollide2(chr.collider, StaticSpace, IntPtr.Zero, nearCallback);
 
@@ -1160,7 +1160,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 foreach (OdePrim aprim in _activeprims)
                 {
                     aprim.CollisionScore = 0;
-                    aprim.IsColliding = false;                   
+                    aprim.IsColliding = false;
                 }
             }
             lock (_activegroups)
@@ -1170,7 +1170,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                     foreach (OdePrim aprim in _activegroups)
                     {
                         if(!aprim.m_outbounds && d.BodyIsEnabled(aprim.Body) &&
-                                aprim.collide_geom != IntPtr.Zero)    
+                                aprim.collide_geom != IntPtr.Zero)
                         {
                             d.SpaceCollide2(StaticSpace, aprim.collide_geom, IntPtr.Zero, nearCallback);
                             d.SpaceCollide2(GroundSpace, aprim.collide_geom, IntPtr.Zero, nearCallback);
@@ -1251,7 +1251,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 size, feetOffset, avDensity, avMovementDivisorWalk, avMovementDivisorRun);
             newAv.Flying = isFlying;
             newAv.MinimumGroundFlightOffset = minimumGroundFlightOffset;
-            
+
             return newAv;
         }
 
@@ -1301,7 +1301,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
         public void addActivePrim(OdePrim activatePrim)
         {
-            // adds active prim..   
+            // adds active prim..
             lock (_activeprims)
             {
                 if (!_activeprims.Contains(activatePrim))
@@ -1324,7 +1324,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             OdePrim newPrim;
             lock (OdeLock)
             {
-              
+
                 newPrim = new OdePrim(name, this, position, size, rotation, pbs, isphysical, isPhantom, shapeType, localID);
             }
             return newPrim;
@@ -1372,7 +1372,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             {
 //                lock (OdeLock)
                 {
-                    
+
                     OdePrim p = (OdePrim)prim;
                     p.setPrimForRemoval();
                 }
@@ -1423,7 +1423,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 _prims[prim.LocalID] = prim;
             }
         }
-        
+
         public bool haveActor(PhysicsActor actor)
         {
             if (actor is OdePrim)
@@ -1531,14 +1531,14 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             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
 
 
@@ -1628,7 +1628,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             TimeSpan timedif = now - m_lastframe;
             float timeStep = (float)timedif.TotalSeconds;
             m_lastframe = now;
-            
+
             // acumulate time so we can reduce error
             step_time += timeStep;
 
@@ -1654,7 +1654,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 }
 
                 ODEchangeitem item;
-                
+
 //                d.WorldSetQuickStepNumIterations(world, curphysiteractions);
 
                 int loopstartMS = Util.EnvironmentTickCount();
@@ -1662,9 +1662,9 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 int changestimeMS = 0;
                 int maxChangestime = (int)(reqTimeStep * 500f); // half the time
                 int maxLoopTime = (int)(reqTimeStep * 1200f); // 1.2 the time
- 
+
                 d.AllocateODEDataForThread(~0U);
-               
+
                 if (ChangesQueue.Count > 0)
                 {
                     while (ChangesQueue.Dequeue(out item))
@@ -1726,7 +1726,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                 aprim.Move();
                             }
                         }
- 
+
                         m_rayCastManager.ProcessQueuedRequests();
 
                         collision_optimized();
@@ -1750,7 +1750,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                                     {
                                         pobj.SendCollisions((int)(odetimestepMS));
                                         if(pobj.Body != IntPtr.Zero && !pobj.m_isSelected &&
-                                            !pobj.m_disabled && !pobj.m_building && 
+                                            !pobj.m_disabled && !pobj.m_building &&
                                             !d.BodyIsEnabled(pobj.Body))
                                         sleepers.Add(pobj);
                                     }
@@ -1900,7 +1900,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
                     d.WorldExportDIF(world, fname, physics_logging_append_existing_logfile, prefix);
                 }
-                
+
                 fps = (float)nodeframes * ODE_STEPSIZE / reqTimeStep;
 
                 if(step_time < HalfOdeStep)
@@ -2166,7 +2166,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
                 h0 = (float)heights[iy]; // 0,1
                 h2 = (float)heights[iy+xstep]; // 1,1 vertice
                 norm.X = h0 - h2;
-                norm.Y = h1 - h0;              
+                norm.Y = h1 - h0;
             }
             else
             {
@@ -2214,7 +2214,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             const float thickness = 10f;
             const int wrap = 0;
 
- 
+
             float hfmin = float.MaxValue;
             float hfmax = float.MinValue;
             float val;
@@ -2503,7 +2503,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
 
             orderedPrims.Sort(compareByCollisionsDesc);
             topColliders = orderedPrims.Take(25).ToDictionary(p => p.LocalID, p => p.CollisionScore);
-           
+
             return topColliders;
         }
 
@@ -2546,7 +2546,7 @@ namespace OpenSim.Region.PhysicsModule.ubOde
             }
         }
 
-       
+
         public override List<ContactResult> RaycastWorld(Vector3 position, Vector3 direction, float length, int Count)
         {
             List<ContactResult> ourresults = new List<ContactResult>();
diff --git a/OpenSim/Region/PhysicsModules/ubOdeMeshing/Mesh.cs b/OpenSim/Region/PhysicsModules/ubOdeMeshing/Mesh.cs
index 0cdaa60..5d2b1f7 100644
--- a/OpenSim/Region/PhysicsModules/ubOdeMeshing/Mesh.cs
+++ b/OpenSim/Region/PhysicsModules/ubOdeMeshing/Mesh.cs
@@ -243,8 +243,8 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                     triangle.v3.Z)
                 || (triangle.v2.X == triangle.v3.X && triangle.v2.Y == triangle.v3.Y && triangle.v2.Z ==
                     triangle.v3.Z)
-                )               
-            {               
+                )
+            {
                 return;
             }
 
@@ -444,7 +444,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
         {
             if (m_indicesPtr != IntPtr.Zero || m_verticesPtr != IntPtr.Zero)
                 throw new NotSupportedException("Attempt to Append to a pinned Mesh");
-        
+
             if (!(newMesh is Mesh))
                 return;
 
diff --git a/OpenSim/Region/PhysicsModules/ubOdeMeshing/Meshmerizer.cs b/OpenSim/Region/PhysicsModules/ubOdeMeshing/Meshmerizer.cs
index 7f0713a..163f439 100644
--- a/OpenSim/Region/PhysicsModules/ubOdeMeshing/Meshmerizer.cs
+++ b/OpenSim/Region/PhysicsModules/ubOdeMeshing/Meshmerizer.cs
@@ -58,8 +58,8 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
         // 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
 
-                private bool m_Enabled = false;
-                
+        private bool m_Enabled = false;
+
         public static object diskLock = new object();
 
         public bool doMeshFileCache = true;
@@ -120,7 +120,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                 }
 
                 CacheExpire = TimeSpan.FromHours(fcache);
-                
+
                 lock (diskLock)
                 {
                     if(doMeshFileCache && cachePath != "")
@@ -165,9 +165,9 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
             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
@@ -266,7 +266,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
         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.
@@ -294,15 +294,15 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                 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)
             {
@@ -448,7 +448,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                     if (physicsParms != null)
                         usemesh = true;
                 }
-                
+
                 if(!usemesh && (map.ContainsKey("physics_convex")))
                         physicsParms = (OSDMap)map["physics_convex"];
 
@@ -488,9 +488,9 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
 
                                 byte[] decompressedBuf = outMs.GetBuffer();
 
-                                decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);  
+                                decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
                             }
-                        }          
+                        }
                     }
                 }
                 catch (Exception e)
@@ -622,7 +622,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                                             faces.Add(f);
                                         }
                                         vertsoffset += vs.Count;
-                                        vs.Clear(); 
+                                        vs.Clear();
                                         continue;
                                     }
     /*
@@ -648,7 +648,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                                         c.Z = hullr.Vertices[i].z;
                                         coords.Add(c);
                                     }
-                               
+
                                     for (i = 0; i < nindexs; i += 3)
                                     {
                                         t1 = hullr.Indices[i];
@@ -687,7 +687,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                                         c.Z = vs[i].z;
                                         coords.Add(c);
                                     }
-                               
+
                                     for (i = 0; i < nindexs; i += 3)
                                     {
                                         t1 = indices[i];
@@ -707,12 +707,12 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                                 }
                             }
                             if (coords.Count > 0 && faces.Count > 0)
-                                return true;                      
+                                return true;
                         }
                         else
                         {
                             // if neither mesh or decomposition present, warn and use convex
-                            m_log.WarnFormat("[MESH]: Data for PRIM shape type ( mesh or decomposition) not found for prim {0}",primName);                     
+                            m_log.WarnFormat("[MESH]: Data for PRIM shape type ( mesh or decomposition) not found for prim {0}",primName);
                         }
                     }
                     vs.Clear();
@@ -947,7 +947,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
         {
             PrimMesh primMesh;
             coords = new List<Coord>();
-            faces = new List<Face>();            
+            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;
@@ -975,7 +975,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                 profileHollow = 0.0f;
             else if (profileHollow > 0.95f)
                 profileHollow = 0.95f;
-          
+
             int sides = 4;
             LevelOfDetail iLOD = (LevelOfDetail)lod;
             byte profshape = (byte)(primShape.ProfileCurve & 0x07);
@@ -1033,7 +1033,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
             }
 
             primMesh = new PrimMesh(sides, profileBegin, profileEnd, profileHollow, hollowSides);
-            
+
             if (primMesh.errorMessage != null)
                 if (primMesh.errorMessage.Length > 0)
                     m_log.Error("[ERROR] " + primMesh.errorMessage);
@@ -1162,7 +1162,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                 for (int i = 0; i < someBytes.Length; i++)
                     hash = mdjb2(hash, someBytes[i]);
                 hash = hash << 8;
-            }          
+            }
 
             if (convex)
                 hash |= 4;
@@ -1204,7 +1204,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
         {
             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;
@@ -1245,7 +1245,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
         }
 
         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
@@ -1348,7 +1348,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                     m_uniqueMeshes.Add(key, mesh);
                 }
                 catch { }
-            }           
+            }
 
             return mesh;
         }
@@ -1380,7 +1380,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                         m_uniqueReleasedMeshes.Add(mesh.Key, mesh);
                     }
                     catch { }
-                }           
+                }
             }
         }
 
@@ -1447,7 +1447,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
 //                            BinaryFormatter bformatter = new BinaryFormatter();
                             mesh = Mesh.FromStream(stream,key);
                         }
-                        
+
                     }
                     catch (Exception e)
                     {
@@ -1524,7 +1524,7 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                 }
             }
         }
-        
+
         public void ExpireFileCache()
         {
             if (!doCacheExpire)
@@ -1543,8 +1543,8 @@ namespace OpenSim.Region.PhysicsModule.ubODEMeshing
                         int ndirs = 0;
                         DateTime OlderTime = File.GetLastAccessTimeUtc(controlfile) - CacheExpire;
                         File.SetLastAccessTimeUtc(controlfile, DateTime.UtcNow);
-                        
-                        foreach (string dir in Directory.GetDirectories(cachePath))                       
+
+                        foreach (string dir in Directory.GetDirectories(cachePath))
                         {
                             try
                             {
diff --git a/OpenSim/Region/PhysicsModules/ubOdeMeshing/PrimMesher.cs b/OpenSim/Region/PhysicsModules/ubOdeMeshing/PrimMesher.cs
index 51d067a..10facf2 100644
--- a/OpenSim/Region/PhysicsModules/ubOdeMeshing/PrimMesher.cs
+++ b/OpenSim/Region/PhysicsModules/ubOdeMeshing/PrimMesher.cs
@@ -522,7 +522,7 @@ namespace PrimMesher
         public Profile(int sides, float profileStart, float profileEnd, float hollow, int hollowSides, bool hasProfileCut, bool createFaces)
         {
             const float halfSqr2 = 0.7071067811866f;
-            
+
             coords = new List<Coord>();
             faces = new List<Face>();
 
@@ -769,7 +769,7 @@ namespace PrimMesher
                         }
                     }
                 }
-                
+
             }
 
             else if (createFaces)
@@ -865,7 +865,7 @@ namespace PrimMesher
             int i;
             int numVerts = coords.Count;
             Coord vert;
-                     
+
             for (i = 0; i < numVerts; i++)
             {
                 vert = coords[i];
@@ -1226,7 +1226,7 @@ namespace PrimMesher
             s += "\nrevolutions..........: " + this.revolutions.ToString();
             s += "\nstepsPerRevolution...: " + this.stepsPerRevolution.ToString();
             s += "\nhasProfileCut........: " + this.hasProfileCut.ToString();
-            s += "\nhasHollow............: " + this.hasHollow.ToString();          
+            s += "\nhasHollow............: " + this.hasHollow.ToString();
 
             return s;
         }
@@ -1324,7 +1324,7 @@ namespace PrimMesher
                     needEndFaces = true;
             }
             else needEndFaces = true;
-            
+
             if (pathType == PathType.Circular)
             {
                 if (sides == 3)
@@ -1377,7 +1377,7 @@ namespace PrimMesher
                     hollow *= 1.414f;
             }
 
-            Profile profile = new Profile(sides, profileStart, profileEnd, hollow, hollowSides, 
+            Profile profile = new Profile(sides, profileStart, profileEnd, hollow, hollowSides,
                                 HasProfileCut,true);
             errorMessage = profile.errorMessage;
 
@@ -1407,7 +1407,7 @@ namespace PrimMesher
             path.stepsPerRevolution = stepsPerRevolution;
 
             path.Create(pathType, steps);
-            
+
             int lastNode = path.pathNodes.Count - 1;
 
             for (int nodeIndex = 0; nodeIndex < path.pathNodes.Count; nodeIndex++)
@@ -1537,7 +1537,7 @@ namespace PrimMesher
         /// 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()
         {
             Extrude(PathType.Linear);
@@ -1548,7 +1548,7 @@ namespace PrimMesher
         /// 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()
         {
             Extrude(PathType.Circular);
diff --git a/OpenSim/Region/PhysicsModules/ubOdeMeshing/Properties/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/ubOdeMeshing/Properties/AssemblyInfo.cs
index adb1f2e..6503e35 100644
--- a/OpenSim/Region/PhysicsModules/ubOdeMeshing/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/PhysicsModules/ubOdeMeshing/Properties/AssemblyInfo.cs
@@ -3,7 +3,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Mono.Addins;
 
-// General Information about an assembly is controlled through the following 
+// 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.PhysicsModule.ubODEMeshing")]
@@ -15,8 +15,8 @@ using Mono.Addins;
 [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 
+// 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)]
 
@@ -26,7 +26,7 @@ using Mono.Addins;
 // Version information for an assembly consists of the following four values:
 //
 //      Major Version
-//      Minor Version 
+//      Minor Version
 //      Build Number
 //      Revision
 //
diff --git a/OpenSim/Region/PhysicsModules/ubOdeMeshing/SculptMap.cs b/OpenSim/Region/PhysicsModules/ubOdeMeshing/SculptMap.cs
index 2ca2af7..ebe2523 100644
--- a/OpenSim/Region/PhysicsModules/ubOdeMeshing/SculptMap.cs
+++ b/OpenSim/Region/PhysicsModules/ubOdeMeshing/SculptMap.cs
@@ -57,7 +57,7 @@ namespace PrimMesher
             int numLodPixels = lod * lod;  // (32 * 2)^2  = 64^2 pixels for default sculpt map image
 
             bool needsScaling = false;
-            bool smallMap = false;          
+            bool smallMap = false;
 
             width = bmW;
             height = bmH;