Merge branch 'master' into careminster

Conflicts:
	OpenSim/Region/Framework/Scenes/Scene.cs

BUILDING.md

@@ -1,6 +1,4 @@
-==== Building OpenSim ====
+# Building on Windows
-
-=== Building on Windows ===
 
 Steps:
  * runprebuild.bat
@@ -9,16 +7,15 @@ Steps:
  * copy OpenSim.ini.example to OpenSim.ini and other appropriate files in bin/config-include
  * run OpenSim.exe
 
-=== Building on Linux ===
+# Building on Linux
 
 Prereqs:
- * Mono >= 2.4.3
+*	Mono >= 2.4.3
- * Nant >= 0.85
+*	Nant >= 0.85
- * On some Linux distributions you may need to install additional packages.  
+*	On some Linux distributions you may need to install additional packages.
-    See http://opensimulator.org/wiki/Dependencies for more information.
+	See http://opensimulator.org/wiki/Dependencies for more information.
-
+*	May also use xbuild (included in mono distributions)
- * May also use xbuild (included in mono distributions)
+*	May use Monodevelop, a cross-platform IDE
- * May use Monodevelop, a cross-platform IDE 
 
 From the distribution type:
  * ./runprebuild.sh
@@ -27,13 +24,13 @@ From the distribution type:
  * copy OpenSim.ini.example to OpenSim.ini and other appropriate files in bin/config-include
  * run mono OpenSim.exe
 
-=== Using Monodevelop ===
+# Using Monodevelop
 
 From the distribution type:
  * ./runprebuild.sh
  * type monodevelop OpenSim.sln
 
-=== References ===
+# References
  
 Helpful resources:
 * http://opensimulator.org/wiki/Build_Instructions

OpenSim/Framework/Constants.cs

@@ -31,6 +31,7 @@ namespace OpenSim.Framework
     public class Constants
     {
         public const uint RegionSize = 256;
+        public const uint RegionHeight = 4096;
         public const byte TerrainPatchSize = 16;
         public const string DefaultTexture = "89556747-24cb-43ed-920b-47caed15465f";
 

OpenSim/Framework/RegionInfo.cs

@@ -128,6 +128,7 @@ namespace OpenSim.Framework
         private int m_physPrimMax = 0;
         private bool m_clampPrimSize = false;
         private int m_objectCapacity = 0;
+        private int m_linksetCapacity = 0;
         private int m_agentCapacity = 0;
         private string m_regionType = String.Empty;
         private RegionLightShareData m_windlight = new RegionLightShareData();
@@ -319,6 +320,11 @@ namespace OpenSim.Framework
             get { return m_objectCapacity; }
         }
 
+        public int LinksetCapacity
+        {
+            get { return m_linksetCapacity; }
+        }
+
         public int AgentCapacity
         {
             get { return m_agentCapacity; }
@@ -657,6 +663,9 @@ namespace OpenSim.Framework
             m_objectCapacity = config.GetInt("MaxPrims", 15000);
             allKeys.Remove("MaxPrims");
 
+            m_linksetCapacity = config.GetInt("LinksetPrims", 0);
+            allKeys.Remove("LinksetPrims");
+            
             #endregion
 
             m_agentCapacity = config.GetInt("MaxAgents", 100);
@@ -714,6 +723,9 @@ namespace OpenSim.Framework
             if (m_objectCapacity != 0)
                 config.Set("MaxPrims", m_objectCapacity);
 
+            if (m_linksetCapacity != 0)
+                config.Set("LinksetPrims", m_linksetCapacity);
+
             if (m_agentCapacity != 0)
                 config.Set("MaxAgents", m_agentCapacity);
 
@@ -809,6 +821,9 @@ namespace OpenSim.Framework
             configMember.addConfigurationOption("object_capacity", ConfigurationOption.ConfigurationTypes.TYPE_INT32,
                                                 "Max objects this sim will hold", m_objectCapacity.ToString(), true);
 
+            configMember.addConfigurationOption("linkset_capacity", ConfigurationOption.ConfigurationTypes.TYPE_INT32,
+                                                "Max prims an object will hold", m_linksetCapacity.ToString(), true);
+
             configMember.addConfigurationOption("agent_capacity", ConfigurationOption.ConfigurationTypes.TYPE_INT32,
                                                 "Max avatars this sim will hold", m_agentCapacity.ToString(), true);
 
@@ -930,6 +945,9 @@ namespace OpenSim.Framework
                 case "object_capacity":
                     m_objectCapacity = (int)configuration_result;
                     break;
+                case "linkset_capacity":
+                    m_linksetCapacity = (int)configuration_result;
+                    break;
                 case "agent_capacity":
                     m_agentCapacity = (int)configuration_result;
                     break;

OpenSim/Region/Framework/Scenes/Scene.cs

@@ -123,6 +123,11 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public float m_maxPhys = 10;
 
+        /// <summary>
+        /// Max prims an object will hold
+        /// </summary>
+        public int m_linksetCapacity = 0;
+
         public bool m_clampPrimSize;
         public bool m_trustBinaries;
         public bool m_allowScriptCrossings;
@@ -789,6 +794,12 @@ namespace OpenSim.Region.Framework.Scenes
                         m_maxPhys = RegionInfo.PhysPrimMax;
                     }
 
+                    m_linksetCapacity = startupConfig.GetInt("LinksetPrims", m_linksetCapacity);
+                    if (RegionInfo.LinksetCapacity > 0)
+                    {
+                        m_linksetCapacity = RegionInfo.LinksetCapacity;
+                    }
+
                     SpawnPointRouting = startupConfig.GetString("SpawnPointRouting", "closest");
                     TelehubAllowLandmarks = startupConfig.GetBoolean("TelehubAllowLandmark", false);
 
@@ -4563,6 +4574,16 @@ namespace OpenSim.Region.Framework.Scenes
             return LandChannel.GetLandObject(x, y).LandData;
         }
 
+        /// <summary>
+        /// Get LandData by position.
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <returns></returns>
+        public LandData GetLandData(Vector3 pos)
+        {
+            return GetLandData(pos.X, pos.Y);
+        }
+
         public LandData GetLandData(uint x, uint y)
         {
             m_log.DebugFormat("[SCENE]: returning land for {0},{1}", x, y);

OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs

@@ -2738,6 +2738,24 @@ namespace OpenSim.Region.Framework.Scenes
             if (objectGroup == this)
                 return;
 
+            // If the configured linkset capacity is greater than zero,
+            // and the new linkset would have a prim count higher than this
+            // value, do not link it.
+            if (m_scene.m_linksetCapacity > 0 &&
+                    (PrimCount + objectGroup.PrimCount) >
+                    m_scene.m_linksetCapacity)
+            {
+                m_log.DebugFormat(
+                        "[SCENE OBJECT GROUP]: Cannot link group with root" +
+                        " part {0}, {1} ({2} prims) to group with root part" +
+                        " {3}, {4} ({5} prims) because the new linkset" +
+                        " would exceed the configured maximum of {6}",
+                        objectGroup.RootPart.Name, objectGroup.RootPart.UUID,
+                        objectGroup.PrimCount, RootPart.Name, RootPart.UUID,
+                        PrimCount, m_scene.m_linksetCapacity);
+                return;
+            }
+
             // 'linkPart' == the root of the group being linked into this group
             SceneObjectPart linkPart = objectGroup.m_rootPart;
 

OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs

@@ -447,7 +447,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.Voice.FreeSwitchVoice
                 // settings allow voice, then whether parcel allows
                 // voice, if all do retrieve or obtain the parcel
                 // voice channel
-                LandData land = scene.GetLandData(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
+                LandData land = scene.GetLandData(avatar.AbsolutePosition);
 
                 //m_log.DebugFormat("[FreeSwitchVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": request: {4}, path: {5}, param: {6}",
                 //                  scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName, request, path, param);

OpenSim/Region/OptionalModules/Avatar/Voice/VivoxVoice/VivoxVoiceModule.cs

@@ -623,7 +623,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.Voice.VivoxVoice
                 // settings allow voice, then whether parcel allows
                 // voice, if all do retrieve or obtain the parcel
                 // voice channel
-                LandData land = scene.GetLandData(avatar.AbsolutePosition.X, avatar.AbsolutePosition.Y);
+                LandData land = scene.GetLandData(avatar.AbsolutePosition);
 
 //                    m_log.DebugFormat("[VivoxVoice][PARCELVOICE]: region \"{0}\": Parcel \"{1}\" ({2}): avatar \"{3}\": request: {4}, path: {5}, param: {6}",
 //                                      scene.RegionInfo.RegionName, land.Name, land.LocalID, avatarName, request, path, param);

OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs

@@ -73,7 +73,8 @@ public class BSCharacter : BSPhysObject
     private bool _kinematic;
     private float _buoyancy;
 
-    public override BulletBody Body { get; set; }
+    public override BulletBody BSBody { get; set; }
+    public override BulletShape BSShape { get; set; }
     public override BSLinkset Linkset { get; set; }
 
     private int _subscribedEventsMs = 0;
@@ -92,6 +93,7 @@ public class BSCharacter : BSPhysObject
         _localID = localID;
         _avName = avName;
         Scene = parent_scene;
+        _physicsActorType = (int)ActorTypes.Agent;
         _position = pos;
         _size = size;
         _flying = isFlying;
@@ -128,9 +130,9 @@ public class BSCharacter : BSPhysObject
             // Set the buoyancy for flying. This will be refactored when all the settings happen in C#
             BulletSimAPI.SetObjectBuoyancy(Scene.WorldID, LocalID, _buoyancy);
 
-            Body = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(Scene.World.Ptr, LocalID));
+            BSBody = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(Scene.World.Ptr, LocalID));
             // avatars get all collisions no matter what (makes walking on ground and such work)
-            BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+            BulletSimAPI.AddToCollisionFlags2(BSBody.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
         });
             
         return;
@@ -440,7 +442,7 @@ public class BSCharacter : BSPhysObject
             Scene.TaintedObject("BSCharacter.AddForce", delegate()
             {
                 DetailLog("{0},BSCharacter.setAddForce,taint,addedForce={1}", LocalID, _force);
-                BulletSimAPI.AddObjectForce2(Body.Ptr, _force);
+                BulletSimAPI.SetObjectForce2(BSBody.Ptr, _force);
             });
         }
         else
@@ -465,7 +467,7 @@ public class BSCharacter : BSPhysObject
 
             Scene.TaintedObject("BSCharacter.SubscribeEvents", delegate()
             {
-                BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                BulletSimAPI.AddToCollisionFlags2(BSBody.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
             });
         }
     }

OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs

@@ -98,6 +98,10 @@ public abstract class BSConstraint : IDisposable
             {
                 // m_world.scene.PhysicsLogging.Write("{0},BSConstraint.RecomputeConstraintVariables,taint,enabling,A={1},B={2}",
                 //                 BSScene.DetailLogZero, Body1.ID, Body2.ID);
+
+                // Setting an object's mass to zero (making it static like when it's selected)
+                //     automatically disables the constraints.
+                // If enabled, be sure to set the constraint itself to enabled.
                 BulletSimAPI.SetConstraintEnable2(m_constraint.Ptr, m_world.scene.NumericBool(true));
             }
             else

OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs

@@ -233,7 +233,7 @@ public class BSLinkset
             foreach (BSPhysObject child in m_children)
             {
                 BSConstraint constrain;
-                if (m_physicsScene.Constraints.TryGetConstraint(LinksetRoot.Body, child.Body, out constrain))
+                if (m_physicsScene.Constraints.TryGetConstraint(LinksetRoot.BSBody, child.BSBody, out constrain))
                 {
                     // DetailLog("{0},BSLinkset.RecomputeLinksetConstraintVariables,taint,child={1},mass={2},A={3},B={4}", 
                     //         LinksetRoot.LocalID, child.LocalID, linksetMass, constrain.Body1.ID, constrain.Body2.ID);
@@ -245,8 +245,8 @@ public class BSLinkset
                     //    their constraints have not been created yet.
                     // Caused by the fact that m_children is built at run time but building constraints
                     //    happens at taint time.
-                    // m_physicsScene.Logger.ErrorFormat("[BULLETSIM LINKSET] RecomputeLinksetConstraintVariables: constraint not found for root={0}, child={1}",
+                    // m_physicsScene.Logger.ErrorFormat("{0} RecomputeLinksetConstraintVariables: constraint not found for root={1}, child={2}",
-                    //                                 m_linksetRoot.Body.ID, child.Body.ID);
+                    //                                 LogHeader, m_linksetRoot.Body.ID, child.Body.ID);
                 }
             }
         }
@@ -327,7 +327,7 @@ public class BSLinkset
         DetailLog("{0},PhysicallyLinkAChildToRoot,taint,root={1},child={2},rLoc={3},cLoc={4},midLoc={5}", 
             rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID, rootPrim.Position, childPrim.Position, midPoint);
         BS6DofConstraint constrain = new BS6DofConstraint(
-                        m_physicsScene.World, rootPrim.Body, childPrim.Body,
+                        m_physicsScene.World, rootPrim.BSBody, childPrim.BSBody,
                         midPoint,
                         true,
                         true
@@ -388,10 +388,10 @@ public class BSLinkset
         DetailLog("{0},PhysicallyUnlinkAChildFromRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID);
 
         // Find the constraint for this link and get rid of it from the overall collection and from my list
-        m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.Body, childPrim.Body);
+        m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.BSBody, childPrim.BSBody);
 
         // Make the child refresh its location
-        BulletSimAPI.PushUpdate2(childPrim.Body.Ptr);
+        BulletSimAPI.PushUpdate2(childPrim.BSBody.Ptr);
     }
 
     // Remove linkage between myself and any possible children I might have
@@ -400,7 +400,7 @@ public class BSLinkset
     {
         DetailLog("{0},PhysicallyUnlinkAllChildren,taint", rootPrim.LocalID);
 
-        m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.Body);
+        m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.BSBody);
     }
 
     // Invoke the detailed logger and output something if it's enabled.

OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs

@@ -48,7 +48,11 @@ public abstract class BSPhysObject : PhysicsActor
     // Return the object mass without calculating it or side effects
     public abstract float MassRaw { get; }
 
-    public abstract BulletBody Body { get; set; }
+    // Reference to the physical body (btCollisionObject) of this object
+    public abstract BulletBody BSBody { get; set; }
+    // Reference to the physical shape (btCollisionShape) of this object
+    public abstract BulletShape BSShape { get; set; }
+
     public abstract void ZeroMotion();
 
     public virtual void StepVehicle(float timeStep) { }

OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs

@@ -94,8 +94,10 @@ public sealed class BSPrim : BSPhysObject
     private int _nextCollisionOkTime = 0;
     long _collidingStep;
     long _collidingGroundStep;
+    CollisionFlags m_currentCollisionFlags = 0;
 
-    public override BulletBody Body { get; set; }
+    public override BulletBody BSBody { get; set; }
+    public override BulletShape BSShape { get; set; }
 
     private BSDynamics _vehicle;
 
@@ -113,6 +115,7 @@ public sealed class BSPrim : BSPhysObject
         // m_log.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID);
         _localID = localID;
         _avName = primName;
+        _physicsActorType = (int)ActorTypes.Prim;
         _scene = parent_scene;
         _position = pos;
         _size = size;
@@ -142,7 +145,9 @@ public sealed class BSPrim : BSPhysObject
             // Get the pointer to the physical body for this object.
             // At the moment, we're still letting BulletSim manage the creation and destruction
             //    of the object. Someday we'll move that into the C# code.
-            Body = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID));
+            BSBody = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID));
+            BSShape = new BulletShape(BulletSimAPI.GetCollisionShape2(BSBody.Ptr));
+            m_currentCollisionFlags = BulletSimAPI.GetCollisionFlags2(BSBody.Ptr);
         });
     }
 
@@ -258,10 +263,10 @@ public sealed class BSPrim : BSPhysObject
         _rotationalVelocity = OMV.Vector3.Zero;
 
         // Zero some other properties directly into the physics engine
-        BulletSimAPI.SetVelocity2(Body.Ptr, OMV.Vector3.Zero);
+        BulletSimAPI.SetLinearVelocity2(BSBody.Ptr, OMV.Vector3.Zero);
-        BulletSimAPI.SetAngularVelocity2(Body.Ptr, OMV.Vector3.Zero);
+        BulletSimAPI.SetAngularVelocity2(BSBody.Ptr, OMV.Vector3.Zero);
-        BulletSimAPI.SetInterpolation2(Body.Ptr, OMV.Vector3.Zero, OMV.Vector3.Zero);
+        BulletSimAPI.SetInterpolationVelocity2(BSBody.Ptr, OMV.Vector3.Zero, OMV.Vector3.Zero);
-        BulletSimAPI.ClearForces2(Body.Ptr);
+        BulletSimAPI.ClearForces2(BSBody.Ptr);
     }
 
     public override void LockAngularMotion(OMV.Vector3 axis)
@@ -324,7 +329,7 @@ public sealed class BSPrim : BSPhysObject
             {
                 DetailLog("{0},BSPrim.setForce,taint,force={1}", LocalID, _force);
                 // BulletSimAPI.SetObjectForce(_scene.WorldID, _localID, _force);
-                BulletSimAPI.SetObjectForce2(Body.Ptr, _force);
+                BulletSimAPI.SetObjectForce2(BSBody.Ptr, _force);
             });
         } 
     }
@@ -442,8 +447,7 @@ public sealed class BSPrim : BSPhysObject
     }
     public override int PhysicsActorType { 
         get { return _physicsActorType; } 
-        set { _physicsActorType = value; 
+        set { _physicsActorType = value; } 
-        } 
     }
     public override bool IsPhysical { 
         get { return _isPhysical; } 
@@ -470,6 +474,11 @@ public sealed class BSPrim : BSPhysObject
 
     // Make gravity work if the object is physical and not selected
     // No locking here because only called when it is safe
+    // There are four flags we're interested in:
+    //     IsStatic: Object does not move, otherwise the object has mass and moves
+    //     isSolid: other objects bounce off of this object
+    //     isVolumeDetect: other objects pass through but can generate collisions
+    //     collisionEvents: whether this object returns collision events
     private void SetObjectDynamic()
     {
         // If it's becoming dynamic, it will need hullness
@@ -479,12 +488,66 @@ public sealed class BSPrim : BSPhysObject
         float mass = IsStatic ? 0f : _mass;
 
         BulletSimAPI.SetObjectProperties(_scene.WorldID, LocalID, IsStatic, IsSolid, SubscribedEvents(), mass);
+        /*
+        BulletSimAPI.RemoveObjectFromWorld2(Scene.World.Ptr, BSBody.Ptr);
 
-        // recompute any linkset parameters
+        // Set up the object physicalness (static or dynamic)
+        MakeDynamic();
+
+        // Make solid or not and arrange for collisions, etc
+        MakeSolid();
+
+        m_currentCollisionFlags = BulletSimAPI.GetCollisionFlags2(BSBody.Ptr);
+
+        BulletSimAPI.AddObjectToWorld2(Scene.World.Ptr, BSBody.Ptr);
+         */
+
+        // Recompute any linkset parameters.
+        // When going from non-physical to physical, this re-enables the constraints that
+        //     had been automatically disabled when the mass was set to zero.
         Linkset.Refresh(this);
 
-        CollisionFlags cf = BulletSimAPI.GetCollisionFlags2(Body.Ptr);
+        DetailLog("{0},BSPrim.SetObjectDynamic,taint,static={1},solid={2},mass={3}, cf={4}", LocalID, IsStatic, IsSolid, mass, m_currentCollisionFlags);
-        DetailLog("{0},BSPrim.SetObjectDynamic,taint,static={1},solid={2},mass={3}, cf={4}", LocalID, IsStatic, IsSolid, mass, cf);
+    }
+
+    // "Making dynamic" means changing to and from static.
+    // When static, gravity does not effect the object and it is fixed in space.
+    // When dynamic, the object can fall and be pushed by others.
+    // This is independent of its 'solidness' which controls what passes through
+    //    this object and what interacts with it.
+    private void MakeDynamic()
+    {
+        if (IsStatic)
+        {
+            // Become a Bullet 'static' object type
+            BulletSimAPI.AddToCollisionFlags2(BSBody.Ptr, CollisionFlags.CF_STATIC_OBJECT);
+            // Stop all movement
+            BulletSimAPI.ClearAllForces2(BSBody.Ptr);
+            // Mass is zero which disables a bunch of physics stuff in Bullet
+            BulletSimAPI.SetMassProps2(BSBody.Ptr, 0f, OMV.Vector3.Zero);
+            // There is no inertia in a static object
+            BulletSimAPI.UpdateInertiaTensor2(BSBody.Ptr);
+            // The activation state is 'sleeping' so Bullet will not try to act on it
+            BulletSimAPI.ForceActivationState2(BSBody.Ptr, ActivationState.ISLAND_SLEEPING);
+        }
+        else
+        {
+            // Not a Bullet static object
+            BulletSimAPI.RemoveFromCollisionFlags2(BSBody.Ptr, CollisionFlags.CF_STATIC_OBJECT);
+            // A dynamic object has mass
+            BulletSimAPI.SetMassProps2(BSBody.Ptr, _mass, OMV.Vector3.Zero);
+            // The shape is interesting and has mass and a center of gravity
+            IntPtr collisionShapePtr = BulletSimAPI.GetCollisionShape2(BSBody.Ptr);
+            BulletSimAPI.CalculateLocalInertia2(collisionShapePtr, _mass, OMV.Vector3.Zero);
+            // Inertia is based on our new mass
+            BulletSimAPI.UpdateInertiaTensor2(BSBody.Ptr);
+            // Force activation of the object so Bullet will act on it.
+            BulletSimAPI.Activate2(BSBody.Ptr, true);
+        }
+    }
+
+    private void MakeSolid()
+    {
     }
 
     // prims don't fly
@@ -609,7 +672,7 @@ public sealed class BSPrim : BSPhysObject
         }
         else
         {
-            m_log.WarnFormat("{0}: Got a NaN force applied to a Character", LogHeader);
+            m_log.WarnFormat("{0}: Got a NaN force applied to a prim. LocalID={1}", LogHeader, LocalID);
             return;
         }
         _scene.TaintedObject("BSPrim.AddForce", delegate()
@@ -624,7 +687,8 @@ public sealed class BSPrim : BSPhysObject
                 m_accumulatedForces.Clear();
             }
             DetailLog("{0},BSPrim.AddObjectForce,taint,force={1}", LocalID, _force);
-            BulletSimAPI.AddObjectForce2(Body.Ptr, fSum);
+            // For unknown reason, "ApplyCentralForce" is really additive.
+            BulletSimAPI.ApplyCentralForce2(BSBody.Ptr, fSum);
         });
     }
 
@@ -644,7 +708,7 @@ public sealed class BSPrim : BSPhysObject
 
             Scene.TaintedObject("BSPrim.SubscribeEvents", delegate()
             {
-                BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                m_currentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(BSBody.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
             });
         }
     }
@@ -652,7 +716,7 @@ public sealed class BSPrim : BSPhysObject
         _subscribedEventsMs = 0;
         Scene.TaintedObject("BSPrim.UnSubscribeEvents", delegate()
         {
-            BulletSimAPI.RemoveFromCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+            m_currentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(BSBody.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
         });
     }
     public override bool SubscribedEvents() { 
@@ -1237,7 +1301,7 @@ public sealed class BSPrim : BSPhysObject
         bool ret = BulletSimAPI.CreateObject(_scene.WorldID, shape);
 
         // the CreateObject() may have recreated the rigid body. Make sure we have the latest.
-        Body = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID));
+        BSBody = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID));
 
         return ret;
     }

OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs

@@ -403,13 +403,13 @@ public class BSTerrainManager
         {
             float regionX = tX - offsetX;
             float regionY = tY - offsetY;
-            if (regionX > mapInfo.sizeX) regionX = 0;
+            if (regionX >= mapInfo.sizeX || regionX < 0f) regionX = 0;
-            if (regionY > mapInfo.sizeY) regionY = 0;
+            if (regionY >= mapInfo.sizeY || regionY < 0f) regionY = 0;
             int mapIndex = (int)regionY * (int)mapInfo.sizeY + (int)regionX;
             ret = mapInfo.heightMap[mapIndex];
             m_terrainModified = false;
-            DetailLog("{0},BSTerrainManager.GetTerrainHeightAtXY,bX={1},baseY={2},szX={3},szY={4},regX={5},regY={6},index={7},ht={8}",
+            // DetailLog("{0},BSTerrainManager.GetTerrainHeightAtXY,bX={1},baseY={2},szX={3},szY={4},regX={5},regY={6},index={7},ht={8}",
-                    BSScene.DetailLogZero, offsetX, offsetY, mapInfo.sizeX, mapInfo.sizeY, regionX, regionY, mapIndex, ret);
+            //         BSScene.DetailLogZero, offsetX, offsetY, mapInfo.sizeX, mapInfo.sizeY, regionX, regionY, mapIndex, ret);
         }
         else
         {

OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs

@@ -218,7 +218,20 @@ public struct ConfigurationParameters
     public const float numericFalse = 0f;
 }
 
-// Values used by Bullet and BulletSim to control collisions
+
+// The states a bullet collision object can have
+public enum ActivationState : uint
+{
+    ACTIVE_TAG = 1,
+    ISLAND_SLEEPING,
+    WANTS_DEACTIVATION,
+    DISABLE_DEACTIVATION,
+    DISABLE_SIMULATION
+}
+
+// Values used by Bullet and BulletSim to control object properties.
+// Bullet's "CollisionFlags" has more to do with operations on the
+//    object (if collisions happen, if gravity effects it, ...).
 public enum CollisionFlags : uint
 {
     CF_STATIC_OBJECT                 = 1 << 0,
@@ -233,8 +246,75 @@ public enum CollisionFlags : uint
     BS_VOLUME_DETECT_OBJECT          = 1 << 11,
     BS_PHANTOM_OBJECT                = 1 << 12,
     BS_PHYSICAL_OBJECT               = 1 << 13,
+    BS_TERRAIN_OBJECT                = 1 << 14,
+    BS_NONE                          = 0,
+    BS_ALL                           = 0xFFFFFFFF
 };
 
+// Values for collisions groups and masks
+public enum CollisionFilterGroups : uint
+{
+    NoneFilter              = 0,
+    DefaultFilter           = 1 << 0,
+    StaticFilter            = 1 << 1,
+    KinematicFilter         = 1 << 2,
+    DebrisFilter            = 1 << 3,
+    SensorTrigger           = 1 << 4,
+    CharacterFilter         = 1 << 5,
+    AllFilter               = 0xFFFFFFFF,
+    // Filter groups defined by BulletSim
+    GroundPlaneFilter       = 1 << 10,
+    TerrainFilter           = 1 << 11,
+    RaycastFilter           = 1 << 12,
+    SolidFilter             = 1 << 13,
+};
+
+    // For each type, we first clear and then set the collision flags
+public enum ClearCollisionFlag : uint
+{
+    Terrain = CollisionFlags.BS_ALL,
+    Phantom = CollisionFlags.BS_ALL,
+    VolumeDetect = CollisionFlags.BS_ALL,
+    PhysicalObject = CollisionFlags.BS_ALL,
+    StaticObject = CollisionFlags.BS_ALL
+}
+
+public enum SetCollisionFlag : uint
+{
+    Terrain = CollisionFlags.CF_STATIC_OBJECT
+        | CollisionFlags.BS_TERRAIN_OBJECT,
+    Phantom = CollisionFlags.CF_STATIC_OBJECT
+        | CollisionFlags.BS_PHANTOM_OBJECT
+        | CollisionFlags.CF_NO_CONTACT_RESPONSE,
+    VolumeDetect = CollisionFlags.CF_STATIC_OBJECT
+        | CollisionFlags.BS_VOLUME_DETECT_OBJECT
+        | CollisionFlags.CF_NO_CONTACT_RESPONSE,
+    PhysicalObject = CollisionFlags.BS_PHYSICAL_OBJECT,
+    StaticObject = CollisionFlags.CF_STATIC_OBJECT,
+}
+
+// Collision filters used for different types of objects
+public enum SetCollisionFilter : uint
+{
+    Terrain = CollisionFilterGroups.AllFilter,
+    Phantom = CollisionFilterGroups.GroundPlaneFilter
+        | CollisionFilterGroups.TerrainFilter,
+    VolumeDetect = CollisionFilterGroups.AllFilter,
+    PhysicalObject = CollisionFilterGroups.AllFilter,
+    StaticObject = CollisionFilterGroups.AllFilter,
+}
+
+// Collision masks used for different types of objects
+public enum SetCollisionMask : uint
+{
+    Terrain = CollisionFilterGroups.AllFilter,
+    Phantom = CollisionFilterGroups.GroundPlaneFilter
+        | CollisionFilterGroups.TerrainFilter,
+    VolumeDetect = CollisionFilterGroups.AllFilter,
+    PhysicalObject = CollisionFilterGroups.AllFilter,
+    StaticObject = CollisionFilterGroups.AllFilter
+}
+
 // CFM controls the 'hardness' of the constraint. 0=fixed, 0..1=violatable. Default=0
 // ERP controls amount of correction per tick. Usable range=0.1..0.8. Default=0.2.
 public enum ConstraintParams : int
@@ -347,6 +427,7 @@ public static extern bool SetObjectVelocity(uint worldID, uint id, Vector3 veloc
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool SetObjectAngularVelocity(uint worldID, uint id, Vector3 angularVelocity);
 
+// Set the current force acting on the object
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool SetObjectForce(uint worldID, uint id, Vector3 force);
 
@@ -403,6 +484,7 @@ public static extern void SetDebugLogCallback(DebugLogCallback callback);
 // The names have a "2" tacked on. This will be removed as the C# code gets rebuilt
 //    and the old code is removed.
 
+// Functions use while converting from API1 to API2. Can be removed when totally converted.
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr GetSimHandle2(uint worldID);
 
@@ -413,6 +495,7 @@ public static extern IntPtr GetBodyHandleWorldID2(uint worldID, uint id);
 public static extern IntPtr GetBodyHandle2(IntPtr world, uint id);
 
 // ===============================================================================
+// Initialization and simulation
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms,
 											int maxCollisions,  IntPtr collisionArray,
@@ -438,6 +521,7 @@ public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSt
 public static extern bool PushUpdate2(IntPtr obj);
 
 // =====================================================================================
+// Mesh, hull, shape and body creation helper routines
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr CreateMeshShape2(IntPtr world, 
                 int indicesCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices, 
@@ -460,12 +544,26 @@ public static extern bool DeleteCollisionShape2(IntPtr world, IntPtr shape);
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr CreateBodyFromShape2(IntPtr sim, IntPtr shape, Vector3 pos, Quaternion rot);
 
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateBodyFromShapeAndInfo2(IntPtr sim, IntPtr shape, IntPtr constructionInfo);
+
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr CreateBodyWithDefaultMotionState2(IntPtr shape, Vector3 pos, Quaternion rot);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetBodyShape2(IntPtr sim, IntPtr obj, IntPtr shape);
+public static extern IntPtr AllocateBodyInfo2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ReleaseBodyInfo2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void DestroyObject2(IntPtr sim, IntPtr obj);
+
 // =====================================================================================
+// Terrain creation and helper routines
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void DumpMapInfo(IntPtr sim, IntPtr manInfo);
+
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr CreateHeightMapInfo2(IntPtr sim, uint id, Vector3 minCoords, Vector3 maxCoords, 
         [MarshalAs(UnmanagedType.LPArray)] float[] heightMap, float collisionMargin);
@@ -484,6 +582,7 @@ public static extern IntPtr CreateGroundPlaneShape2(uint id, float height, float
 public static extern IntPtr CreateTerrainShape2(IntPtr mapInfo);
 
 // =====================================================================================
+// Constraint creation and helper routines
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr Create6DofConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2,
                     Vector3 frame1loc, Quaternion frame1rot,
@@ -536,16 +635,108 @@ public static extern bool SetConstraintParam2(IntPtr constrain, ConstraintParams
 public static extern bool DestroyConstraint2(IntPtr world, IntPtr constrain);
 
 // =====================================================================================
+// btCollisionWorld entries
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void UpdateSingleAabb2(IntPtr world, IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void UpdateAabbs2(IntPtr world);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool GetForceUpdateAllAabbs2(IntPtr world);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetForceUpdateAllAabbs2(IntPtr world, bool force);
+
+// =====================================================================================
+// btDynamicsWorld entries
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool AddObjectToWorld2(IntPtr world, IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool RemoveObjectFromWorld2(IntPtr world, IntPtr obj);
 
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool AddConstraintToWorld2(IntPtr world, IntPtr constrain, bool disableCollisionsBetweenLinkedObjects);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool RemoveConstraintFromWorld2(IntPtr world, IntPtr constrain);
 // =====================================================================================
+// btCollisionObject entries
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetAnisotripicFriction2(IntPtr constrain);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 SetAnisotripicFriction2(IntPtr constrain, Vector3 frict);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool HasAnisotripicFriction2(IntPtr constrain);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetContactProcessingThreshold2(IntPtr obj, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetContactProcessingThreshold2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsStaticObject2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsKinematicObject2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsStaticOrKinematicObject2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool HasContactResponse2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetCollisionShape2(IntPtr sim, IntPtr obj, IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr GetCollisionShape2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern int GetActivationState2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetActivationState2(IntPtr obj, int state);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetDeactivationTime2(IntPtr obj, float dtime);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetDeactivationTime2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ForceActivationState2(IntPtr obj, ActivationState state);
+
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern void Activate2(IntPtr obj, bool forceActivation);
 
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsActive2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetRestitution2(IntPtr obj, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetRestitution2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetFriction2(IntPtr obj, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetFriction2(IntPtr obj);
+
+    /* Haven't defined the type 'Transform'
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Transform GetWorldTransform2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void setWorldTransform2(IntPtr obj, Transform trans);
+     */
+
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern Vector3 GetPosition2(IntPtr obj);
 
@@ -553,89 +744,288 @@ public static extern Vector3 GetPosition2(IntPtr obj);
 public static extern Quaternion GetOrientation2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetTranslation2(IntPtr obj, Vector3 position, Quaternion rotation);
+public static extern void SetTranslation2(IntPtr obj, Vector3 position, Quaternion rotation);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetVelocity2(IntPtr obj, Vector3 velocity);
+public static extern IntPtr GetBroadphaseHandle2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetAngularVelocity2(IntPtr obj, Vector3 angularVelocity);
+public static extern void SetBroadphaseHandle2(IntPtr obj, IntPtr handle);
+
+    /*
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Transform GetInterpolationWorldTransform2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetObjectForce2(IntPtr obj, Vector3 force);
+public static extern void SetInterpolationWorldTransform2(IntPtr obj, Transform trans);
+     */
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool AddObjectForce2(IntPtr obj, Vector3 force);
+public static extern void SetInterpolationLinearVelocity2(IntPtr obj, Vector3 vel);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetCcdMotionThreshold2(IntPtr obj, float val);
+public static extern void SetInterpolationAngularVelocity2(IntPtr obj, Vector3 vel);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetCcdSweepSphereRadius2(IntPtr obj, float val);
+public static extern void SetInterpolationVelocity2(IntPtr obj, Vector3 linearVel, Vector3 angularVel);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetDamping2(IntPtr obj, float lin_damping, float ang_damping);
+public static extern float GetHitFraction2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetDeactivationTime2(IntPtr obj, float val);
+public static extern void SetHitFraction2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetSleepingThresholds2(IntPtr obj, float lin_threshold, float ang_threshold);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetContactProcessingThreshold2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetFriction2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetHitFraction2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetRestitution2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetLinearVelocity2(IntPtr obj, Vector3 val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetInterpolation2(IntPtr obj, Vector3 lin, Vector3 ang);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern CollisionFlags GetCollisionFlags2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr SetCollisionFlags2(IntPtr obj, CollisionFlags flags);
+public static extern CollisionFlags SetCollisionFlags2(IntPtr obj, CollisionFlags flags);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr AddToCollisionFlags2(IntPtr obj, CollisionFlags flags);
+public static extern CollisionFlags AddToCollisionFlags2(IntPtr obj, CollisionFlags flags);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr RemoveFromCollisionFlags2(IntPtr obj, CollisionFlags flags);
+public static extern CollisionFlags RemoveFromCollisionFlags2(IntPtr obj, CollisionFlags flags);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetMassProps2(IntPtr obj, float mass, Vector3 inertia);
+public static extern float GetCcdMotionThreshold2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool UpdateInertiaTensor2(IntPtr obj);
+public static extern void SetCcdMotionThreshold2(IntPtr obj, float val);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetGravity2(IntPtr obj, Vector3 val);
+public static extern float GetCcdSweepSphereRadius2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr ClearForces2(IntPtr obj);
+public static extern void SetCcdSweepSphereRadius2(IntPtr obj, float val);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr ClearAllForces2(IntPtr obj);
+public static extern IntPtr GetUserPointer2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetMargin2(IntPtr obj, float val);
+public static extern void SetUserPointer2(IntPtr obj, IntPtr val);
+
+// =====================================================================================
+// btRigidBody entries
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyGravity2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool UpdateSingleAabb2(IntPtr world, IntPtr obj);
+public static extern void SetGravity2(IntPtr obj, Vector3 val);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool DestroyObject2(IntPtr world, IntPtr obj);
+public static extern Vector3 GetGravity2(IntPtr obj);
 
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetDamping2(IntPtr obj, float lin_damping, float ang_damping);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetLinearDamping2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetAngularDamping2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetLinearSleepingThreshold2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetAngularSleepingThreshold2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyDamping2(IntPtr obj, float timeStep);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetMassProps2(IntPtr obj, float mass, Vector3 inertia);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetLinearFactor2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetLinearFactor2(IntPtr obj, Vector3 factor);
+
+    /*
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetCenterOfMassTransform2(IntPtr obj, Transform trans);
+     */
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetCenterOfMassByPosRot2(IntPtr obj, Vector3 pos, Quaternion rot);
+
+// Add a force to the object as if its mass is one.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyCentralForce2(IntPtr obj, Vector3 force);
+
+// Set the force being applied to the object as if its mass is one.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetObjectForce2(IntPtr obj, Vector3 force);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetTotalForce2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetTotalTorque2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetInvInertiaDiagLocal2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetInvInertiaDiagLocal2(IntPtr obj, Vector3 inert);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetSleepingThresholds2(IntPtr obj, float lin_threshold, float ang_threshold);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyTorque2(IntPtr obj, Vector3 torque);
+
+// Apply force at the given point. Will add torque to the object.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyForce2(IntPtr obj, Vector3 force, Vector3 pos);
+
+// Apply impulse to the object. Same as "ApplycentralForce" but force scaled by object's mass.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyCentralImpulse2(IntPtr obj, Vector3 imp);
+
+// Apply impulse to the object's torque. Force is scaled by object's mass.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyTorqueImpulse2(IntPtr obj, Vector3 imp);
+
+// Apply impulse at the point given. For is scaled by object's mass and effects both linear and angular forces.
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ApplyImpulse2(IntPtr obj, Vector3 imp, Vector3 pos);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ClearForces2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void ClearAllForces2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void UpdateInertiaTensor2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetCenterOfMassPosition2(IntPtr obj);
+
+    /*
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Transform GetCenterOfMassTransform2(IntPtr obj);
+     */
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetLinearVelocity2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetAngularVelocity2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetLinearVelocity2(IntPtr obj, Vector3 val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetAngularVelocity2(IntPtr obj, Vector3 angularVelocity);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetVelocityInLocalPoint2(IntPtr obj, Vector3 pos);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void Translate2(IntPtr obj, Vector3 trans);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void UpdateDeactivation2(IntPtr obj, float timeStep);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool WantsSleeping2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetAngularFactor2(IntPtr obj, float factor);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetAngularFactorV2(IntPtr obj, Vector3 factor);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetAngularFactor2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsInWorld2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void AddConstraintRef2(IntPtr obj, IntPtr constrain);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void RemoveConstraintRef2(IntPtr obj, IntPtr constrain);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr GetConstraintRef2(IntPtr obj, int index);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern int GetNumConstraintRefs2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetDeltaLinearVelocity2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetDeltaAngularVelocity2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetPushVelocity2(IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetTurnVelocity2(IntPtr obj);
+
+// =====================================================================================
+// btCollisionShape entries
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetAngularMotionDisc2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetContactBreakingThreshold2(IntPtr shape, float defaultFactor);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsPolyhedral2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsConvex2d2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsConvex2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsNonMoving2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsConcave2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsCompound2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsSoftBody2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool IsInfinite2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetLocalScaling2(IntPtr shape, Vector3 scale);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern Vector3 GetLocalScaling2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void CalculateLocalInertia2(IntPtr shape, float mass, Vector3 inertia);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern int GetShapeType2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetMargin2(IntPtr shape, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern float GetMargin2(IntPtr shape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void SetCollisionFilterMask(IntPtr shape, uint filter, uint mask);
+
+// =====================================================================================
+// Debugging
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern void DumpPhysicsStatistics2(IntPtr sim);
 

OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs

@@ -2182,7 +2182,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                     pos.x > (Constants.RegionSize + 10) || // return FALSE if more than 10 meters into a east-adjacent region.
                     pos.y < -10.0 || // return FALSE if more than 10 meters into a south-adjacent region.
                     pos.y > (Constants.RegionSize + 10) || // return FALSE if more than 10 meters into a north-adjacent region.
-                    pos.z > 4096 // return FALSE if altitude than 4096m
+                    pos.z > Constants.RegionHeight // return FALSE if altitude than 4096m
                 )
             )
             {
@@ -2193,8 +2193,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             // this could possibly be done in the above else-if block, but we're doing the check here to keep the code easier to read.
 
             Vector3 objectPos = m_host.ParentGroup.RootPart.AbsolutePosition;
-            LandData here = World.GetLandData((float)objectPos.X, (float)objectPos.Y);
+            LandData here = World.GetLandData(objectPos);
-            LandData there = World.GetLandData((float)pos.x, (float)pos.y);
+            LandData there = World.GetLandData(pos);
 
             // we're only checking prim limits if it's moving to a different parcel under the assumption that if the object got onto the parcel without exceeding the prim limits.
 
@@ -10525,20 +10525,20 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                     switch ((ParcelMediaCommandEnum) Convert.ToInt32(aList.Data[i].ToString()))
                     {
                         case ParcelMediaCommandEnum.Url:
-                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).MediaURL));
+                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition).MediaURL));
                             break;
                         case ParcelMediaCommandEnum.Desc:
-                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).Description));
+                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition).Description));
                             break;
                         case ParcelMediaCommandEnum.Texture:
-                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).MediaID.ToString()));
+                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition).MediaID.ToString()));
                             break;
                         case ParcelMediaCommandEnum.Type:
-                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).MediaType));
+                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition).MediaType));
                             break;
                         case ParcelMediaCommandEnum.Size:
-                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).MediaWidth));
+                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition).MediaWidth));
-                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition.X, m_host.AbsolutePosition.Y).MediaHeight));
+                            list.Add(new LSL_String(World.GetLandData(m_host.AbsolutePosition).MediaHeight));
                             break;
                         default:
                             ParcelMediaCommandEnum mediaCommandEnum = ParcelMediaCommandEnum.Url;
@@ -11275,7 +11275,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
         public LSL_List llGetParcelDetails(LSL_Vector pos, LSL_List param)
         {
             m_host.AddScriptLPS(1);
-            LandData land = World.GetLandData((float)pos.x, (float)pos.y);
+            LandData land = World.GetLandData(pos);
             if (land == null)
             {
                 return new LSL_List(0);

OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs

@@ -2989,7 +2989,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             ScenePresence presence = World.GetScenePresence(avatarId); 
             if (presence != null)
             {
-                LandData land = World.GetLandData((float)pos.X, (float)pos.Y);
+                LandData land = World.GetLandData(pos);
                 if ((land.Flags & (uint)ParcelFlags.AllowDamage) == (uint)ParcelFlags.AllowDamage)
                 {
                     float health = presence.Health;

OpenSim/Services/Connectors/SimianGrid/SimianGridServiceConnector.cs

@@ -112,7 +112,7 @@ namespace OpenSim.Services.Connectors.SimianGrid
 //                m_log.Warn("Registering region " + regionInfo.RegionName + " (" + regionInfo.RegionID + ") that we are not tracking");
 
             Vector3d minPosition = new Vector3d(regionInfo.RegionLocX, regionInfo.RegionLocY, 0.0);
-            Vector3d maxPosition = minPosition + new Vector3d(Constants.RegionSize, Constants.RegionSize, 4096.0);
+            Vector3d maxPosition = minPosition + new Vector3d(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
 
             OSDMap extraData = new OSDMap
             {
@@ -297,7 +297,7 @@ namespace OpenSim.Services.Connectors.SimianGrid
             List<GridRegion> foundRegions = new List<GridRegion>();
 
             Vector3d minPosition = new Vector3d(xmin, ymin, 0.0);
-            Vector3d maxPosition = new Vector3d(xmax, ymax, 4096.0);
+            Vector3d maxPosition = new Vector3d(xmax, ymax, Constants.RegionHeight);
 
             NameValueCollection requestArgs = new NameValueCollection
             {

README.md

@@ -1,8 +1,6 @@
 Welcome to OpenSim!
 
-==================
+# Overview
-==== OVERVIEW ====
-==================
 
 OpenSim is a BSD Licensed Open Source project to develop a functioning
 virtual worlds server platform capable of supporting multiple clients
@@ -12,16 +10,12 @@ C#, and can run under Mono or the Microsoft .NET runtimes.
 This is considered an alpha release.  Some stuff works, a lot doesn't.
 If it breaks, you get to keep *both* pieces.
 
-=========================
+# Compiling OpenSim
-=== Compiling OpenSim ===
-=========================
 
-Please see BUILDING.txt if you downloaded a source distribution and 
+Please see BUILDING.md if you downloaded a source distribution and 
 need to build OpenSim before running it.
 
-==================================
+# Running OpenSim on Windows
-=== Running OpenSim on Windows ===
-==================================
 
 We recommend that you run OpenSim from a command prompt on Windows in order
 to capture any errors.
@@ -33,9 +27,7 @@ To run OpenSim from a command prompt
 
 Now see the "Configuring OpenSim" section
 
-================================
+# Running OpenSim on Linux
-=== Running OpenSim on Linux ===
-================================
 
 You will need Mono >= 2.4.3 to run OpenSim.  On some Linux distributions you
 may need to install additional packages.  See http://opensimulator.org/wiki/Dependencies
@@ -48,14 +40,12 @@ To run OpenSim, from the unpacked distribution type:
 
 Now see the "Configuring OpenSim" section
 
-===========================
+# Configuring OpenSim
-=== Configuring OpenSim ===
-===========================
 
 When OpenSim starts for the first time, you will be prompted with a
 series of questions that look something like:
 
-[09-17 03:54:40] DEFAULT REGION CONFIG: Simulator Name [OpenSim Test]:
+	[09-17 03:54:40] DEFAULT REGION CONFIG: Simulator Name [OpenSim Test]:
 
 For all the options except simulator name, you can safely hit enter to accept
 the default if you want to connect using a client on the same machine or over
@@ -72,7 +62,7 @@ in-world.  You can also use these details to perform your first login.
 
 Once you are presented with a prompt that looks like:
 
-  Region (My region name) #
+	Region (My region name) #
 
 You have successfully started OpenSim.
 
@@ -83,9 +73,7 @@ Helpful resources:
  * http://opensimulator.org/wiki/Configuration
  * http://opensimulator.org/wiki/Configuring_Regions
 
-==================================
+# Connecting to your OpenSim
-=== Connecting to your OpenSim ===
-==================================
 
 By default your sim will be available for login on port 9000.  You can login by
 adding -loginuri http://127.0.0.1:9000 to the command that starts Second Life
@@ -96,15 +84,11 @@ http://192.168.1.2:9000)
 To login, use the avatar details that you gave for your estate ownership or the
 one you set up using the "create user" command.
 
-===================
+# Bug reports
-=== Bug reports ===
-===================
 
 In the very likely event of bugs biting you (err, your OpenSim) we
 encourage you to see whether the problem has already been reported on
-the OpenSim mantis system. You can find the OpenSim mantis system at
+the [OpenSim mantis system](http://opensimulator.org/mantis/main_page.php).
-
-    http://opensimulator.org/mantis/main_page.php
 
 If your bug has already been reported, you might want to add to the
 bug description and supply additional information.
@@ -119,9 +103,7 @@ mantis"). Useful information to include:
 
        mono --debug OpenSim.exe
 
-===================================
+# More Information on OpenSim
-=== More Information on OpenSim ===
-===================================
 
 More extensive information on building, running, and configuring
 OpenSim, as well as how to report bugs, and participate in the OpenSim

bin/OpenSim.ini.example

@@ -108,6 +108,11 @@
     ;; This can be overriden in the region config file.
     ; ClampPrimSize = false
 	
+	;# {LinksetPrims} {} {Max prims an object will hold?} {} 0
+	;; Maximum number of prims allowable in a linkset. Affects creating new linksets. Ignored if less than or equal to zero.
+	;; This can be overriden in the region config file.
+	; LinksetPrims = 0
+
     ;# {AllowScriptCrossing} {} {Allow scripts to cross into this region} {true false} true
     ;; Allow scripts to keep running when they cross region boundaries, rather than being restarted.  State is reloaded on the destination region.
     ;; This only applies when crossing to a region running in a different simulator.  

bin/OpenSimDefaults.ini

@@ -95,6 +95,10 @@
     ; This can be overriden in the region config file.
     ClampPrimSize = false
 	
+	; Maximum number of prims allowable in a linkset. Affects creating new linksets. Ignored if less than or equal to zero.
+	; This can be overriden in the region config file.
+	LinksetPrims = 0
+
     ; Allow scripts to keep running when they cross region boundaries, rather than being restarted.  State is reloaded on the destination region.
     ; This only applies when crossing to a region running in a different simulator.  
     ; For crossings where the regions are on the same simulator the script is always kept running.