Dump OpenSim 0.9.0.1 into it's own branch.

1 files changed, 106 insertions, 17 deletions

diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
index da3fc18..6aa24d5 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
@@ -230,34 +230,97 @@ 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);
 
+    // The position value as known by BulletSim. Does not effect the physics engine.
     public virtual OMV.Vector3 RawPosition { get; set; }
+    // Set position in BulletSim and the physics engined to a value immediately. Must be called at taint time.
     public abstract OMV.Vector3 ForcePosition { get; set; }
 
+    // The orientation value as known by BulletSim. Does not effect the physics engine.
     public virtual OMV.Quaternion RawOrientation { get; set; }
+    // Set orientation in BulletSim and the physics engine to a value immediately. Must be called at taint time.
     public abstract OMV.Quaternion ForceOrientation { get; set; }
 
+    // The velocity value as known by BulletSim. Does not effect the physics engine.
     public virtual OMV.Vector3 RawVelocity { get; set; }
+    // Set velocity in BulletSim and the physics engined to a value immediately. Must be called at taint time.
     public abstract OMV.Vector3 ForceVelocity { get; set; }
 
+    // The rotational velocity value as known by BulletSim. Does not effect the physics engine.
+    public OMV.Vector3 RawRotationalVelocity { get; set; }
+
+    // RawForce is a constant force applied to object (see Force { set; } )
     public OMV.Vector3 RawForce { get; set; }
     public OMV.Vector3 RawTorque { get; set; }
+
     public override void AddAngularForce(OMV.Vector3 force, bool pushforce)
     {
-        AddAngularForce(force, pushforce, false);
+        AddAngularForce(false, force);
     }
-    public abstract void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime);
-    public abstract void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime);
+    public abstract void AddAngularForce(bool inTaintTime, OMV.Vector3 force);
+    public abstract void AddForce(bool inTaintTime, OMV.Vector3 force);
 
-    public abstract OMV.Vector3 ForceRotationalVelocity { get; set; }
+    // PhysicsActor.Velocity
+    public override OMV.Vector3 Velocity
+    {
+        get { return RawVelocity;  }
+        set
+        {
+            // This sets the velocity now. BSCharacter will override to clear target velocity
+            //    before calling this.
+            RawVelocity = value;
+            PhysScene.TaintedObject(LocalID, TypeName + ".SetVelocity", delegate () {
+                // DetailLog("{0},BSPhysObject.Velocity.set,vel={1}", LocalID, RawVelocity);
+                ForceVelocity = RawVelocity;
+            });
+        }
+    }
+
+    // PhysicsActor.SetMomentum
+    // All the physics engines use this as a way of forcing the velocity to something.
+    // BSCharacter overrides this so it can set the target velocity to zero before calling this.
+    public override void SetMomentum(OMV.Vector3 momentum)
+    {
+        this.Velocity = momentum;
+    }
+
+    public override OMV.Vector3 RotationalVelocity {
+        get {
+            return RawRotationalVelocity;
+        }
+        set {
+            RawRotationalVelocity = value;
+            Util.ClampV(RawRotationalVelocity, BSParam.MaxAngularVelocity);
+            // m_log.DebugFormat("{0}: RotationalVelocity={1}", LogHeader, _rotationalVelocity);
+            PhysScene.TaintedObject(LocalID, TypeName + ".setRotationalVelocity", delegate()
+            {
+                ForceRotationalVelocity = RawRotationalVelocity;
+            });
+        }
+    }
+    public OMV.Vector3 ForceRotationalVelocity {
+        get {
+            return RawRotationalVelocity;
+        }
+        set {
+            RawRotationalVelocity = Util.ClampV(value, BSParam.MaxAngularVelocity);
+            if (PhysBody.HasPhysicalBody)
+            {
+                DetailLog("{0},{1}.ForceRotationalVel,taint,rotvel={2}", LocalID, TypeName, RawRotationalVelocity);
+                PhysScene.PE.SetAngularVelocity(PhysBody, RawRotationalVelocity);
+                // PhysicsScene.PE.SetInterpolationAngularVelocity(PhysBody, _rotationalVelocity);
+                ActivateIfPhysical(false);
+            }
+        }
+    }
 
     public abstract float ForceBuoyancy { get; set; }
 
     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; } }
@@ -268,7 +331,7 @@ public abstract class BSPhysObject : PhysicsActor
     public float MoveToTargetTau { get; set; }
 
     // Used for llSetHoverHeight and maybe vehicle height. Hover Height will override MoveTo target's Z
-    public override bool PIDHoverActive { set { HoverActive = value; } }
+    public override bool PIDHoverActive {get {return HoverActive;}  set { HoverActive = value; } }
     public override float PIDHoverHeight { set { HoverHeight = value; } }
     public override PIDHoverType PIDHoverType { set { HoverType = value; } }
     public override float PIDHoverTau { set { HoverTau = value; } }
@@ -452,18 +515,24 @@ public abstract class BSPhysObject : PhysicsActor
     private long CollisionsLastTickStep = -1;
 
     // The simulation step is telling this object about a collision.
+    // I'm the 'collider', the thing I'm colliding with is the 'collidee'.
     // Return 'true' if a collision was processed and should be sent up.
     // Return 'false' if this object is not enabled/subscribed/appropriate for or has already seen this collision.
     // Called at taint time from within the Step() function
-    public delegate bool CollideCall(uint collidingWith, BSPhysObject collidee, OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth);
-    public virtual bool Collide(uint collidingWith, BSPhysObject collidee,
-                    OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
+    public virtual bool Collide(BSPhysObject collidee, OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
     {
         bool ret = false;
 
+        // if 'collidee' is null, that means it is terrain
+        uint collideeLocalID = (collidee == null) ? BSScene.TERRAIN_ID : collidee.LocalID;
+        // All terrain goes by the TERRAIN_ID id when passed up as a collision
+        if (collideeLocalID <= PhysScene.TerrainManager.HighestTerrainID) {
+            collideeLocalID = BSScene.TERRAIN_ID;
+        }
+
         // The following lines make IsColliding(), CollidingGround() and CollidingObj work
         CollidingStep = PhysScene.SimulationStep;
-        if (collidingWith <= PhysScene.TerrainManager.HighestTerrainID)
+        if (collideeLocalID == BSScene.TERRAIN_ID)
         {
             CollidingGroundStep = PhysScene.SimulationStep;
         }
@@ -474,10 +543,13 @@ public abstract class BSPhysObject : PhysicsActor
 
         CollisionAccumulation++;
 
-        // For movement tests, remember if we are colliding with an object that is moving.
-        ColliderIsMoving = collidee != null ? (collidee.RawVelocity != OMV.Vector3.Zero) : false;
+        // For movement tests, if the collider is me, remember if we are colliding with an object that is moving.
+        // Here the 'collider'/'collidee' thing gets messed up. In the larger context, when something is checking
+        //     if the thing it is colliding with is moving, for instance, it asks if the its collider is moving.
+        ColliderIsMoving = collidee != null ? (collidee.RawVelocity != OMV.Vector3.Zero || collidee.RotationalVelocity != OMV.Vector3.Zero) : false;
         ColliderIsVolumeDetect = collidee != null ? (collidee.IsVolumeDetect) : false;
 
+
         // Make a collection of the collisions that happened the last simulation tick.
         // This is different than the collection created for sending up to the simulator as it is cleared every tick.
         if (CollisionsLastTickStep != PhysScene.SimulationStep)
@@ -485,16 +557,29 @@ public abstract class BSPhysObject : PhysicsActor
             CollisionsLastTick = new CollisionEventUpdate();
             CollisionsLastTickStep = PhysScene.SimulationStep;
         }
-        CollisionsLastTick.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+        CollisionsLastTick.AddCollider(collideeLocalID, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
 
         // If someone has subscribed for collision events log the collision so it will be reported up
         if (SubscribedEvents()) {
+            ContactPoint newContact = new ContactPoint(contactPoint, contactNormal, pentrationDepth);
+
+            // Collision sound requires a velocity to know it should happen. This is a lot of computation for a little used feature.
+            OMV.Vector3 relvel = OMV.Vector3.Zero;
+            if (IsPhysical)
+                relvel = RawVelocity;
+            if (collidee != null && collidee.IsPhysical)
+                relvel -= collidee.RawVelocity;
+            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(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+                CollisionCollection.AddCollider(collideeLocalID, newContact);
             }
-            DetailLog("{0},{1}.Collision.AddCollider,call,with={2},point={3},normal={4},depth={5},colliderMoving={6}",
-                            LocalID, TypeName, collidingWith, contactPoint, contactNormal, pentrationDepth, ColliderIsMoving);
+            DetailLog("{0},{1}.Collision.AddCollider,call,with={2},point={3},normal={4},depth={5},speed={6},colliderMoving={7}",
+                            LocalID, TypeName, collideeLocalID, contactPoint, contactNormal, pentrationDepth,
+                            newContact.RelativeSpeed, ColliderIsMoving);
 
             ret = true;
         }
@@ -555,7 +640,11 @@ public abstract class BSPhysObject : PhysicsActor
             PhysScene.TaintedObject(LocalID, TypeName+".SubscribeEvents", delegate()
             {
                 if (PhysBody.HasPhysicalBody)
+                {
                     CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                    DetailLog("{0},{1}.SubscribeEvents,setting collision. ms={2}, collisionFlags={3:x}",
+                            LocalID, TypeName, SubscribedEventsMs, CurrentCollisionFlags);
+                }
             });
         }
         else