Merge branch 'master' into careminster

Conflicts:
	CONTRIBUTORS.txt
	OpenSim/Region/CoreModules/Avatar/Attachments/AttachmentsModule.cs
	OpenSim/Region/CoreModules/Avatar/Attachments/Tests/AttachmentsModuleTests.cs

1 files changed, 153 insertions, 8 deletions

diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
index 3fe71e1..d9b738b 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -39,26 +39,171 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 // unless the difference is significant.
 public abstract class BSPhysObject : PhysicsActor
 {
-    public abstract BSLinkset Linkset { get; set; }
+    protected void BaseInitialize(BSScene parentScene, uint localID, string name, string typeName)
+    {
+        PhysicsScene = parentScene;
+        LocalID = localID;
+        PhysObjectName = name;
+        TypeName = typeName;
 
-    public abstract bool Collide(uint collidingWith, BSPhysObject collidee,
-            OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth);
-    public abstract void SendCollisions();
+        Linkset = new BSLinkset(PhysicsScene, this);
 
-    // Return the object mass without calculating it or side effects
+        CollisionCollection = new CollisionEventUpdate();
+        SubscribedEventsMs = 0;
+        CollidingStep = 0;
+        CollidingGroundStep = 0;
+    }
+
+    public BSScene PhysicsScene { get; protected set; }
+    // public override uint LocalID { get; set; } // Use the LocalID definition in PhysicsActor
+    public string PhysObjectName { get; protected set; }
+    public string TypeName { get; protected set; }
+
+    public BSLinkset Linkset { get; set; }
+
+    // Return the object mass without calculating it or having side effects
     public abstract float MassRaw { get; }
 
     // Reference to the physical body (btCollisionObject) of this object
-    public abstract BulletBody BSBody { get; set; }
+    public BulletBody BSBody;
     // Reference to the physical shape (btCollisionShape) of this object
-    public abstract BulletShape BSShape { get; set; }
+    public BulletShape BSShape;
 
+    // Stop all physical motion.
     public abstract void ZeroMotion();
 
+    // Step the vehicle simulation for this object. A NOOP if the vehicle was not configured.
     public virtual void StepVehicle(float timeStep) { }
 
+    // Update the physical location and motion of the object. Called with data from Bullet.
     public abstract void UpdateProperties(EntityProperties entprop);
 
+    // Tell the object to clean up.
     public abstract void Destroy();
+
+    #region Collisions
+
+    // Requested number of milliseconds between collision events. Zero means disabled.
+    protected int SubscribedEventsMs { get; set; }
+    // Given subscription, the time that a collision may be passed up
+    protected int NextCollisionOkTime { get; set; }
+    // The simulation step that last had a collision
+    protected long CollidingStep { get; set; }
+    // The simulation step that last had a collision with the ground
+    protected long CollidingGroundStep { get; set; }
+    // The collision flags we think are set in Bullet
+    protected CollisionFlags CurrentCollisionFlags { get; set; }
+
+    // The collisions that have been collected this tick
+    protected CollisionEventUpdate CollisionCollection;
+
+    // The simulation step is telling this object about a collision.
+    // Return 'true' if a collision was processed and should be sent up.
+    // Called at taint time from within the Step() function
+    public virtual bool Collide(uint collidingWith, BSPhysObject collidee,
+                    OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
+    {
+        bool ret = false;
+
+        // The following lines make IsColliding() and IsCollidingGround() work
+        CollidingStep = PhysicsScene.SimulationStep;
+        if (collidingWith <= PhysicsScene.TerrainManager.HighestTerrainID)
+        {
+            CollidingGroundStep = PhysicsScene.SimulationStep;
+        }
+
+        // prims in the same linkset cannot collide with each other
+        if (collidee != null && (this.Linkset.LinksetID == collidee.Linkset.LinksetID))
+        {
+            return ret;
+        }
+
+        // if someone has subscribed for collision events....
+        if (SubscribedEvents()) {
+            CollisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+            // DetailLog("{0},{1}.Collison.AddCollider,call,with={2},point={3},normal={4},depth={5}",
+            //                 LocalID, TypeName, collidingWith, contactPoint, contactNormal, pentrationDepth);
+
+            ret = true;
+        }
+        return ret;
+    }
+
+    // Routine to send the collected collisions into the simulator.
+    // Also handles removal of this from the collection of objects with collisions if
+    //      there are no collisions from this object. Mechanism is create one last
+    //      collision event to make collision_end work.
+    // Called at taint time from within the Step() function thus no locking problems
+    //      with CollisionCollection and ObjectsWithNoMoreCollisions.
+    // Return 'true' if there were some actual collisions passed up
+    public virtual bool SendCollisions()
+    {
+        bool ret = true;
+
+        // throttle the collisions to the number of milliseconds specified in the subscription
+        int nowTime = PhysicsScene.SimulationNowTime;
+        if (nowTime >= NextCollisionOkTime)
+        {
+            NextCollisionOkTime = nowTime + SubscribedEventsMs;
+
+            // We are called if we previously had collisions. If there are no collisions
+            //   this time, send up one last empty event so OpenSim can sense collision end.
+            if (CollisionCollection.Count == 0)
+            {
+                // If I have no collisions this time, remove me from the list of objects with collisions.
+                ret = false;
+            }
+
+            // DetailLog("{0},{1}.SendCollisionUpdate,call,numCollisions={2}", LocalID, TypeName, CollisionCollection.Count);
+            base.SendCollisionUpdate(CollisionCollection);
+
+            // The collisionCollection structure is passed around in the simulator.
+            // Make sure we don't have a handle to that one and that a new one is used for next time.
+            CollisionCollection = new CollisionEventUpdate();
+        }
+        return ret;
+    }
+
+    // Subscribe for collision events.
+    // Parameter is the millisecond rate the caller wishes collision events to occur.
+    public override void SubscribeEvents(int ms) {
+        // DetailLog("{0},{1}.SubscribeEvents,subscribing,ms={2}", LocalID, TypeName, ms);
+        SubscribedEventsMs = ms;
+        if (ms > 0)
+        {
+            // make sure first collision happens
+            NextCollisionOkTime = Util.EnvironmentTickCountSubtract(SubscribedEventsMs);
+
+            PhysicsScene.TaintedObject(TypeName+".SubscribeEvents", delegate()
+            {
+                CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(BSBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+            });
+        }
+        else
+        {
+            // Subscribing for zero or less is the same as unsubscribing
+            UnSubscribeEvents();
+        }
+    }
+    public override void UnSubscribeEvents() { 
+        // DetailLog("{0},{1}.UnSubscribeEvents,unsubscribing", LocalID, TypeName);
+        SubscribedEventsMs = 0;
+        PhysicsScene.TaintedObject(TypeName+".UnSubscribeEvents", delegate()
+        {
+            CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(BSBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+        });
+    }
+    // Return 'true' if the simulator wants collision events
+    public override bool SubscribedEvents() { 
+        return (SubscribedEventsMs > 0);
+    }
+
+    #endregion // Collisions
+
+    // High performance detailed logging routine used by the physical objects.
+    protected void DetailLog(string msg, params Object[] args)
+    {
+        PhysicsScene.PhysicsLogging.Write(msg, args);
+    }
 }
 }