1 files changed, 137 insertions, 10 deletions

diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
index f6a890e..534f929 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
@@ -45,6 +45,16 @@ namespace OpenSim.Region.Physics.BulletSPlugin
  *      ForceVariableName: direct reference (store and fetch) to the value in the physics engine.
  *  The last two (and certainly the last one) should be referenced only in taint-time.
  */
+
+/*
+ * As of 20121221, the following are the call sequences (going down) for different script physical functions:
+ * llApplyImpulse       llApplyRotImpulse           llSetTorque             llSetForce
+ * SOP.ApplyImpulse     SOP.ApplyAngularImpulse     SOP.SetAngularImpulse   SOP.SetForce
+ * SOG.ApplyImpulse     SOG.ApplyAngularImpulse     SOG.SetAngularImpulse
+ * PA.AddForce          PA.AddAngularForce          PA.Torque = v           PA.Force = v
+ * BS.ApplyCentralForce BS.ApplyTorque              
+ */
+
 public abstract class BSPhysObject : PhysicsActor
 {
     protected BSPhysObject()
@@ -57,26 +67,42 @@ public abstract class BSPhysObject : PhysicsActor
         PhysObjectName = name;
         TypeName = typeName;
 
+        // We don't have any physical representation yet.
+        PhysBody = new BulletBody(localID);
+        PhysShape = new BulletShape();
+
+        // A linkset of just me
         Linkset = BSLinkset.Factory(PhysicsScene, this);
         LastAssetBuildFailed = false;
 
+        // Default material type
+        Material = MaterialAttributes.Material.Wood;
+
         CollisionCollection = new CollisionEventUpdate();
         SubscribedEventsMs = 0;
         CollidingStep = 0;
         CollidingGroundStep = 0;
     }
 
+    // Tell the object to clean up.
+    public virtual void Destroy()
+    {
+        UnRegisterAllPreStepActions();
+    }
+
     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; }
+    public BSLinksetInfo LinksetInfo { get; set; }
 
     // Return the object mass without calculating it or having side effects
     public abstract float RawMass { get; }
     // Set the raw mass but also update physical mass properties (inertia, ...)
-    public abstract void UpdatePhysicalMassProperties(float mass);
+    // 'inWorld' true if the object has already been added to the dynamic world.
+    public abstract void UpdatePhysicalMassProperties(float mass, bool inWorld);
 
     // The last value calculated for the prim's inertia
     public OMV.Vector3 Inertia { get; set; }
@@ -105,10 +131,17 @@ public abstract class BSPhysObject : PhysicsActor
     public EntityProperties CurrentEntityProperties { get; set; }
     public EntityProperties LastEntityProperties { get; set; }
 
-    public abstract OMV.Vector3 Scale { get; set; }
+    public virtual OMV.Vector3 Scale { get; set; }
     public abstract bool IsSolid { get; }
     public abstract bool IsStatic { get; }
 
+    // Materialness
+    public MaterialAttributes.Material Material { get; private set; }
+    public override void SetMaterial(int material)
+    {
+        Material = (MaterialAttributes.Material)material;
+    }
+
     // Stop all physical motion.
     public abstract void ZeroMotion(bool inTaintTime);
     public abstract void ZeroAngularMotion(bool inTaintTime);
@@ -119,15 +152,23 @@ public abstract class BSPhysObject : PhysicsActor
     // 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();
-
     public abstract OMV.Vector3 RawPosition { get; set; }
     public abstract OMV.Vector3 ForcePosition { get; set; }
 
     public abstract OMV.Quaternion RawOrientation { get; set; }
     public abstract OMV.Quaternion ForceOrientation { get; set; }
 
+    // The system is telling us the velocity it wants to move at.
+    // protected OMV.Vector3 m_targetVelocity;  // use the definition in PhysicsActor
+    public override OMV.Vector3 TargetVelocity
+    {
+        get { return m_targetVelocity; }
+        set
+        {
+            m_targetVelocity = value;
+            Velocity = value;
+        }
+    }
     public abstract OMV.Vector3 ForceVelocity { get; set; }
 
     public abstract OMV.Vector3 ForceRotationalVelocity { get; set; }
@@ -146,9 +187,40 @@ public abstract class BSPhysObject : PhysicsActor
     protected long CollidingStep { get; set; }
     // The simulation step that last had a collision with the ground
     protected long CollidingGroundStep { get; set; }
+    // The simulation step that last collided with an object
+    protected long CollidingObjectStep { get; set; }
     // The collision flags we think are set in Bullet
     protected CollisionFlags CurrentCollisionFlags { get; set; }
 
+    public override bool IsColliding {
+        get { return (CollidingStep == PhysicsScene.SimulationStep); }
+        set {
+            if (value)
+                CollidingStep = PhysicsScene.SimulationStep;
+            else
+                CollidingStep = 0;
+            }
+    }
+    public override bool CollidingGround {
+        get { return (CollidingGroundStep == PhysicsScene.SimulationStep); }
+        set
+        {
+            if (value)
+                CollidingGroundStep = PhysicsScene.SimulationStep;
+            else
+                CollidingGroundStep = 0;
+        }
+    }
+    public override bool CollidingObj {
+        get { return (CollidingObjectStep == PhysicsScene.SimulationStep); }
+        set { 
+            if (value)
+                CollidingObjectStep = PhysicsScene.SimulationStep;
+            else
+                CollidingObjectStep = 0;
+        }
+    }
+
     // The collisions that have been collected this tick
     protected CollisionEventUpdate CollisionCollection;
 
@@ -160,12 +232,16 @@ public abstract class BSPhysObject : PhysicsActor
     {
         bool ret = false;
 
-        // The following lines make IsColliding() and IsCollidingGround() work
+        // The following lines make IsColliding(), CollidingGround() and CollidingObj work
         CollidingStep = PhysicsScene.SimulationStep;
         if (collidingWith <= PhysicsScene.TerrainManager.HighestTerrainID)
         {
             CollidingGroundStep = PhysicsScene.SimulationStep;
         }
+        else
+        {
+            CollidingObjectStep = PhysicsScene.SimulationStep;
+        }
 
         // prims in the same linkset cannot collide with each other
         if (collidee != null && (this.Linkset.LinksetID == collidee.Linkset.LinksetID))
@@ -192,7 +268,7 @@ public abstract class BSPhysObject : PhysicsActor
     {
         bool ret = true;
         // If the 'no collision' call, force it to happen right now so quick collision_end
-        bool force = CollisionCollection.Count == 0;
+        bool force = (CollisionCollection.Count == 0);
 
         // throttle the collisions to the number of milliseconds specified in the subscription
         if (force || (PhysicsScene.SimulationNowTime >= NextCollisionOkTime))
@@ -210,8 +286,10 @@ public abstract class BSPhysObject : PhysicsActor
             // DetailLog("{0},{1}.SendCollisionUpdate,call,numCollisions={2}", LocalID, TypeName, CollisionCollection.Count);
             base.SendCollisionUpdate(CollisionCollection);
 
-            // The collisionCollection structure is passed around in the simulator.
+            // The CollisionCollection instance is passed around in the simulator.
             // Make sure we don't have a handle to that one and that a new one is used for next time.
+            //    This fixes an interesting 'gotcha'. If we call CollisionCollection.Clear() here, 
+            //    a race condition is created for the other users of this instance.
             CollisionCollection = new CollisionEventUpdate();
         }
         return ret;
@@ -229,7 +307,8 @@ public abstract class BSPhysObject : PhysicsActor
 
             PhysicsScene.TaintedObject(TypeName+".SubscribeEvents", delegate()
             {
-                CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                if (PhysBody.HasPhysicalBody)
+                    CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
             });
         }
         else
@@ -243,7 +322,9 @@ public abstract class BSPhysObject : PhysicsActor
         SubscribedEventsMs = 0;
         PhysicsScene.TaintedObject(TypeName+".UnSubscribeEvents", delegate()
         {
-            CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+            // Make sure there is a body there because sometimes destruction happens in an un-ideal order.
+            if (PhysBody.HasPhysicalBody)
+                CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
         });
     }
     // Return 'true' if the simulator wants collision events
@@ -253,11 +334,57 @@ public abstract class BSPhysObject : PhysicsActor
 
     #endregion // Collisions
 
+    #region Per Simulation Step actions
+    // There are some actions that must be performed for a physical object before each simulation step.
+    // These actions are optional so, rather than scanning all the physical objects and asking them
+    //     if they have anything to do, a physical object registers for an event call before the step is performed.
+    // This bookkeeping makes it easy to add, remove and clean up after all these registrations.
+    private Dictionary<string, BSScene.PreStepAction> RegisteredActions = new Dictionary<string, BSScene.PreStepAction>();
+    protected void RegisterPreStepAction(string op, uint id, BSScene.PreStepAction actn)
+    {
+        string identifier = op + "-" + id.ToString();
+
+        // Clean out any existing action
+        UnRegisterPreStepAction(op, id);
+
+        RegisteredActions[identifier] = actn;
+        PhysicsScene.BeforeStep += actn;
+        DetailLog("{0},BSPhysObject.RegisterPreStepAction,id={1}", LocalID, identifier);
+    }
+
+    // Unregister a pre step action. Safe to call if the action has not been registered.
+    protected void UnRegisterPreStepAction(string op, uint id)
+    {
+        string identifier = op + "-" + id.ToString();
+        bool removed = false;
+        if (RegisteredActions.ContainsKey(identifier))
+        {
+            PhysicsScene.BeforeStep -= RegisteredActions[identifier];
+            RegisteredActions.Remove(identifier);
+            removed = true;
+        }
+        DetailLog("{0},BSPhysObject.UnRegisterPreStepAction,id={1},removed={2}", LocalID, identifier, removed);
+    }
+
+    protected void UnRegisterAllPreStepActions()
+    {
+        foreach (KeyValuePair<string, BSScene.PreStepAction> kvp in RegisteredActions)
+        {
+            PhysicsScene.BeforeStep -= kvp.Value;
+        }
+        RegisteredActions.Clear();
+        DetailLog("{0},BSPhysObject.UnRegisterAllPreStepActions,", LocalID);
+    }
+
+    
+    #endregion // Per Simulation Step actions
+
     // High performance detailed logging routine used by the physical objects.
     protected void DetailLog(string msg, params Object[] args)
     {
         if (PhysicsScene.PhysicsLogging.Enabled)
             PhysicsScene.DetailLog(msg, args);
     }
+
 }
 }