OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

BulletSim: convert BSDynamic to a BSActor and change BSPrim to set 

up the vehicle actor.
user_profiles
Robert Adams 2013-03-31 17:36:15 -07:00
parent 2c581cae2a
commit 747ece59d2
5 changed files with 149 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
View File

@ -40,13 +40,14 @@ using OpenSim.Region.Physics.Manager;
namespace OpenSim.Region.Physics.BulletSPlugin namespace OpenSim.Region.Physics.BulletSPlugin
{ {
public sealed class BSDynamics public sealed class BSDynamics : BSActor
{ {
private static string LogHeader = "[BULLETSIM VEHICLE]"; private static string LogHeader = "[BULLETSIM VEHICLE]";
private BSScene PhysicsScene { get; set; }
// the prim this dynamic controller belongs to // the prim this dynamic controller belongs to
private BSPrim Prim { get; set; } private BSPrim ControllingPrim { get; set; }
private bool m_haveRegisteredForSceneEvents;
// mass of the vehicle fetched each time we're calles // mass of the vehicle fetched each time we're calles
private float m_vehicleMass; private float m_vehicleMass;
@ -129,11 +130,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
public bool enableAngularDeflection; public bool enableAngularDeflection;
public bool enableAngularBanking; public bool enableAngularBanking;
public BSDynamics(BSScene myScene, BSPrim myPrim) public BSDynamics(BSScene myScene, BSPrim myPrim, string actorName)
: base(myScene, myPrim, actorName)
{ {
PhysicsScene = myScene; ControllingPrim = myPrim;
Prim = myPrim;
Type = Vehicle.TYPE_NONE; Type = Vehicle.TYPE_NONE;
m_haveRegisteredForSceneEvents = false;
SetupVehicleDebugging(); SetupVehicleDebugging();
} }
@ -155,7 +157,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// Return 'true' if this vehicle is doing vehicle things // Return 'true' if this vehicle is doing vehicle things
public bool IsActive public bool IsActive
{ {
get { return (Type != Vehicle.TYPE_NONE && Prim.IsPhysicallyActive); } get { return (Type != Vehicle.TYPE_NONE && ControllingPrim.IsPhysicallyActive); }
} }
// Return 'true' if this a vehicle that should be sitting on the ground // Return 'true' if this a vehicle that should be sitting on the ground
@ -167,7 +169,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
#region Vehicle parameter setting #region Vehicle parameter setting
public void ProcessFloatVehicleParam(Vehicle pParam, float pValue) public void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
{ {
VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue); VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
switch (pParam) switch (pParam)
{ {
case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY: case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
@ -195,7 +197,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
break; break;
case Vehicle.BUOYANCY: case Vehicle.BUOYANCY:
m_VehicleBuoyancy = ClampInRange(-1f, pValue, 1f); m_VehicleBuoyancy = ClampInRange(-1f, pValue, 1f);
m_VehicleGravity = Prim.ComputeGravity(m_VehicleBuoyancy); m_VehicleGravity = ControllingPrim.ComputeGravity(m_VehicleBuoyancy);
break; break;
case Vehicle.HOVER_EFFICIENCY: case Vehicle.HOVER_EFFICIENCY:
m_VhoverEfficiency = ClampInRange(0f, pValue, 1f); m_VhoverEfficiency = ClampInRange(0f, pValue, 1f);
@ -258,7 +260,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue) internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
{ {
VDetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue); VDetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
switch (pParam) switch (pParam)
{ {
case Vehicle.ANGULAR_FRICTION_TIMESCALE: case Vehicle.ANGULAR_FRICTION_TIMESCALE:
@ -294,7 +296,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue) internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
{ {
VDetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue); VDetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
switch (pParam) switch (pParam)
{ {
case Vehicle.REFERENCE_FRAME: case Vehicle.REFERENCE_FRAME:
@ -308,7 +310,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
internal void ProcessVehicleFlags(int pParam, bool remove) internal void ProcessVehicleFlags(int pParam, bool remove)
{ {
VDetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", Prim.LocalID, pParam, remove); VDetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", ControllingPrim.LocalID, pParam, remove);
VehicleFlag parm = (VehicleFlag)pParam; VehicleFlag parm = (VehicleFlag)pParam;
if (pParam == -1) if (pParam == -1)
m_flags = (VehicleFlag)0; m_flags = (VehicleFlag)0;
@ -323,7 +325,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
public void ProcessTypeChange(Vehicle pType) public void ProcessTypeChange(Vehicle pType)
{ {
VDetailLog("{0},ProcessTypeChange,type={1}", Prim.LocalID, pType); VDetailLog("{0},ProcessTypeChange,type={1}", ControllingPrim.LocalID, pType);
// Set Defaults For Type // Set Defaults For Type
Type = pType; Type = pType;
switch (pType) switch (pType)
@ -578,13 +580,23 @@ namespace OpenSim.Region.Physics.BulletSPlugin
m_verticalAttractionMotor.FrictionTimescale = new Vector3(BSMotor.Infinite, BSMotor.Infinite, 0.1f); m_verticalAttractionMotor.FrictionTimescale = new Vector3(BSMotor.Infinite, BSMotor.Infinite, 0.1f);
m_verticalAttractionMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG DEBUG (enables detail logging) m_verticalAttractionMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG DEBUG (enables detail logging)
*/ */
if (this.Type == Vehicle.TYPE_NONE)
{
UnregisterForSceneEvents();
}
else
{
RegisterForSceneEvents();
}
} }
#endregion // Vehicle parameter setting #endregion // Vehicle parameter setting
public void Refresh() // BSActor.Refresh()
public override void Refresh()
{ {
// If asking for a refresh, reset the physical parameters before the next simulation step. // If asking for a refresh, reset the physical parameters before the next simulation step.
PhysicsScene.PostTaintObject("BSDynamics.Refresh", Prim.LocalID, delegate() PhysicsScene.PostTaintObject("BSDynamics.Refresh", ControllingPrim.LocalID, delegate()
{ {
SetPhysicalParameters(); SetPhysicalParameters();
}); });
@ -597,49 +609,90 @@ namespace OpenSim.Region.Physics.BulletSPlugin
if (IsActive) if (IsActive)
{ {
// Remember the mass so we don't have to fetch it every step // Remember the mass so we don't have to fetch it every step
m_vehicleMass = Prim.TotalMass; m_vehicleMass = ControllingPrim.TotalMass;
// Friction affects are handled by this vehicle code // Friction affects are handled by this vehicle code
PhysicsScene.PE.SetFriction(Prim.PhysBody, BSParam.VehicleFriction); PhysicsScene.PE.SetFriction(ControllingPrim.PhysBody, BSParam.VehicleFriction);
PhysicsScene.PE.SetRestitution(Prim.PhysBody, BSParam.VehicleRestitution); PhysicsScene.PE.SetRestitution(ControllingPrim.PhysBody, BSParam.VehicleRestitution);
// Moderate angular movement introduced by Bullet. // Moderate angular movement introduced by Bullet.
// TODO: possibly set AngularFactor and LinearFactor for the type of vehicle. // TODO: possibly set AngularFactor and LinearFactor for the type of vehicle.
// Maybe compute linear and angular factor and damping from params. // Maybe compute linear and angular factor and damping from params.
PhysicsScene.PE.SetAngularDamping(Prim.PhysBody, BSParam.VehicleAngularDamping); PhysicsScene.PE.SetAngularDamping(ControllingPrim.PhysBody, BSParam.VehicleAngularDamping);
PhysicsScene.PE.SetLinearFactor(Prim.PhysBody, BSParam.VehicleLinearFactor); PhysicsScene.PE.SetLinearFactor(ControllingPrim.PhysBody, BSParam.VehicleLinearFactor);
PhysicsScene.PE.SetAngularFactorV(Prim.PhysBody, BSParam.VehicleAngularFactor); PhysicsScene.PE.SetAngularFactorV(ControllingPrim.PhysBody, BSParam.VehicleAngularFactor);
// Vehicles report collision events so we know when it's on the ground // Vehicles report collision events so we know when it's on the ground
PhysicsScene.PE.AddToCollisionFlags(Prim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS); PhysicsScene.PE.AddToCollisionFlags(ControllingPrim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
Prim.Inertia = PhysicsScene.PE.CalculateLocalInertia(Prim.PhysShape, m_vehicleMass); ControllingPrim.Inertia = PhysicsScene.PE.CalculateLocalInertia(ControllingPrim.PhysShape, m_vehicleMass);
PhysicsScene.PE.SetMassProps(Prim.PhysBody, m_vehicleMass, Prim.Inertia); PhysicsScene.PE.SetMassProps(ControllingPrim.PhysBody, m_vehicleMass, ControllingPrim.Inertia);
PhysicsScene.PE.UpdateInertiaTensor(Prim.PhysBody); PhysicsScene.PE.UpdateInertiaTensor(ControllingPrim.PhysBody);
// Set the gravity for the vehicle depending on the buoyancy // Set the gravity for the vehicle depending on the buoyancy
// TODO: what should be done if prim and vehicle buoyancy differ? // TODO: what should be done if prim and vehicle buoyancy differ?
m_VehicleGravity = Prim.ComputeGravity(m_VehicleBuoyancy); m_VehicleGravity = ControllingPrim.ComputeGravity(m_VehicleBuoyancy);
// The actual vehicle gravity is set to zero in Bullet so we can do all the application of same. // The actual vehicle gravity is set to zero in Bullet so we can do all the application of same.
PhysicsScene.PE.SetGravity(Prim.PhysBody, Vector3.Zero); PhysicsScene.PE.SetGravity(ControllingPrim.PhysBody, Vector3.Zero);
VDetailLog("{0},BSDynamics.SetPhysicalParameters,mass={1},inert={2},vehGrav={3},aDamp={4},frict={5},rest={6},lFact={7},aFact={8}", VDetailLog("{0},BSDynamics.SetPhysicalParameters,mass={1},inert={2},vehGrav={3},aDamp={4},frict={5},rest={6},lFact={7},aFact={8}",
Prim.LocalID, m_vehicleMass, Prim.Inertia, m_VehicleGravity, ControllingPrim.LocalID, m_vehicleMass, ControllingPrim.Inertia, m_VehicleGravity,
BSParam.VehicleAngularDamping, BSParam.VehicleFriction, BSParam.VehicleRestitution, BSParam.VehicleAngularDamping, BSParam.VehicleFriction, BSParam.VehicleRestitution,
BSParam.VehicleLinearFactor, BSParam.VehicleAngularFactor BSParam.VehicleLinearFactor, BSParam.VehicleAngularFactor
); );
} }
else else
{ {
if (Prim.PhysBody.HasPhysicalBody) if (ControllingPrim.PhysBody.HasPhysicalBody)
PhysicsScene.PE.RemoveFromCollisionFlags(Prim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS); PhysicsScene.PE.RemoveFromCollisionFlags(ControllingPrim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
} }
} }
public bool RemoveBodyDependencies(BSPhysObject prim) // BSActor.RemoveBodyDependencies
public override void RemoveBodyDependencies()
{ {
Refresh(); Refresh();
return IsActive; }
// BSActor.Release()
public override void Dispose()
{
UnregisterForSceneEvents();
Type = Vehicle.TYPE_NONE;
Enabled = false;
return;
}
private void RegisterForSceneEvents()
{
if (!m_haveRegisteredForSceneEvents)
{
PhysicsScene.BeforeStep += this.Step;
PhysicsScene.AfterStep += this.PostStep;
ControllingPrim.OnPreUpdateProperty += this.PreUpdateProperty;
m_haveRegisteredForSceneEvents = true;
}
}
private void UnregisterForSceneEvents()
{
if (m_haveRegisteredForSceneEvents)
{
PhysicsScene.BeforeStep -= this.Step;
PhysicsScene.AfterStep -= this.PostStep;
ControllingPrim.OnPreUpdateProperty -= this.PreUpdateProperty;
m_haveRegisteredForSceneEvents = false;
}
}
private void PreUpdateProperty(ref EntityProperties entprop)
{
// A temporary kludge to suppress the rotational effects introduced on vehicles by Bullet
// TODO: handle physics introduced by Bullet with computed vehicle physics.
if (IsActive)
{
entprop.RotationalVelocity = Vector3.Zero;
}
} }
#region Known vehicle value functions #region Known vehicle value functions
@ -686,14 +739,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin
if (m_knownChanged != 0) if (m_knownChanged != 0)
{ {
if ((m_knownChanged & m_knownChangedPosition) != 0) if ((m_knownChanged & m_knownChangedPosition) != 0)
Prim.ForcePosition = m_knownPosition; ControllingPrim.ForcePosition = m_knownPosition;
if ((m_knownChanged & m_knownChangedOrientation) != 0) if ((m_knownChanged & m_knownChangedOrientation) != 0)
Prim.ForceOrientation = m_knownOrientation; ControllingPrim.ForceOrientation = m_knownOrientation;
if ((m_knownChanged & m_knownChangedVelocity) != 0) if ((m_knownChanged & m_knownChangedVelocity) != 0)
{ {
Prim.ForceVelocity = m_knownVelocity; ControllingPrim.ForceVelocity = m_knownVelocity;
// Fake out Bullet by making it think the velocity is the same as last time. // Fake out Bullet by making it think the velocity is the same as last time.
// Bullet does a bunch of smoothing for changing parameters. // Bullet does a bunch of smoothing for changing parameters.
// Since the vehicle is demanding this setting, we override Bullet's smoothing // Since the vehicle is demanding this setting, we override Bullet's smoothing
@ -702,28 +755,28 @@ namespace OpenSim.Region.Physics.BulletSPlugin
} }
if ((m_knownChanged & m_knownChangedForce) != 0) if ((m_knownChanged & m_knownChangedForce) != 0)
Prim.AddForce((Vector3)m_knownForce, false /*pushForce*/, true /*inTaintTime*/); ControllingPrim.AddForce((Vector3)m_knownForce, false /*pushForce*/, true /*inTaintTime*/);
if ((m_knownChanged & m_knownChangedForceImpulse) != 0) if ((m_knownChanged & m_knownChangedForceImpulse) != 0)
Prim.AddForceImpulse((Vector3)m_knownForceImpulse, false /*pushforce*/, true /*inTaintTime*/); ControllingPrim.AddForceImpulse((Vector3)m_knownForceImpulse, false /*pushforce*/, true /*inTaintTime*/);
if ((m_knownChanged & m_knownChangedRotationalVelocity) != 0) if ((m_knownChanged & m_knownChangedRotationalVelocity) != 0)
{ {
Prim.ForceRotationalVelocity = m_knownRotationalVelocity; ControllingPrim.ForceRotationalVelocity = m_knownRotationalVelocity;
// PhysicsScene.PE.SetInterpolationAngularVelocity(Prim.PhysBody, m_knownRotationalVelocity); // PhysicsScene.PE.SetInterpolationAngularVelocity(Prim.PhysBody, m_knownRotationalVelocity);
} }
if ((m_knownChanged & m_knownChangedRotationalImpulse) != 0) if ((m_knownChanged & m_knownChangedRotationalImpulse) != 0)
Prim.ApplyTorqueImpulse((Vector3)m_knownRotationalImpulse, true /*inTaintTime*/); ControllingPrim.ApplyTorqueImpulse((Vector3)m_knownRotationalImpulse, true /*inTaintTime*/);
if ((m_knownChanged & m_knownChangedRotationalForce) != 0) if ((m_knownChanged & m_knownChangedRotationalForce) != 0)
{ {
Prim.AddAngularForce((Vector3)m_knownRotationalForce, false /*pushForce*/, true /*inTaintTime*/); ControllingPrim.AddAngularForce((Vector3)m_knownRotationalForce, false /*pushForce*/, true /*inTaintTime*/);
} }
// If we set one of the values (ie, the physics engine didn't do it) we must force // If we set one of the values (ie, the physics engine didn't do it) we must force
// an UpdateProperties event to send the changes up to the simulator. // an UpdateProperties event to send the changes up to the simulator.
PhysicsScene.PE.PushUpdate(Prim.PhysBody); PhysicsScene.PE.PushUpdate(ControllingPrim.PhysBody);
} }
m_knownChanged = 0; m_knownChanged = 0;
} }
@ -736,7 +789,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
if ((m_knownHas & m_knownChangedTerrainHeight) == 0 || pos != lastRememberedHeightPos) if ((m_knownHas & m_knownChangedTerrainHeight) == 0 || pos != lastRememberedHeightPos)
{ {
lastRememberedHeightPos = pos; lastRememberedHeightPos = pos;
m_knownTerrainHeight = Prim.PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos); m_knownTerrainHeight = ControllingPrim.PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos);
m_knownHas |= m_knownChangedTerrainHeight; m_knownHas |= m_knownChangedTerrainHeight;
} }
return m_knownTerrainHeight; return m_knownTerrainHeight;
@ -748,7 +801,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{ {
if ((m_knownHas & m_knownChangedWaterLevel) == 0) if ((m_knownHas & m_knownChangedWaterLevel) == 0)
{ {
m_knownWaterLevel = Prim.PhysicsScene.TerrainManager.GetWaterLevelAtXYZ(pos); m_knownWaterLevel = ControllingPrim.PhysicsScene.TerrainManager.GetWaterLevelAtXYZ(pos);
m_knownHas |= m_knownChangedWaterLevel; m_knownHas |= m_knownChangedWaterLevel;
} }
return (float)m_knownWaterLevel; return (float)m_knownWaterLevel;
@ -760,7 +813,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{ {
if ((m_knownHas & m_knownChangedPosition) == 0) if ((m_knownHas & m_knownChangedPosition) == 0)
{ {
m_knownPosition = Prim.ForcePosition; m_knownPosition = ControllingPrim.ForcePosition;
m_knownHas |= m_knownChangedPosition; m_knownHas |= m_knownChangedPosition;
} }
return m_knownPosition; return m_knownPosition;
@ -779,7 +832,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{ {
if ((m_knownHas & m_knownChangedOrientation) == 0) if ((m_knownHas & m_knownChangedOrientation) == 0)
{ {
m_knownOrientation = Prim.ForceOrientation; m_knownOrientation = ControllingPrim.ForceOrientation;
m_knownHas |= m_knownChangedOrientation; m_knownHas |= m_knownChangedOrientation;
} }
return m_knownOrientation; return m_knownOrientation;
@ -798,7 +851,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{ {
if ((m_knownHas & m_knownChangedVelocity) == 0) if ((m_knownHas & m_knownChangedVelocity) == 0)
{ {
m_knownVelocity = Prim.ForceVelocity; m_knownVelocity = ControllingPrim.ForceVelocity;
m_knownHas |= m_knownChangedVelocity; m_knownHas |= m_knownChangedVelocity;
} }
return m_knownVelocity; return m_knownVelocity;
@ -839,7 +892,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{ {
if ((m_knownHas & m_knownChangedRotationalVelocity) == 0) if ((m_knownHas & m_knownChangedRotationalVelocity) == 0)
{ {
m_knownRotationalVelocity = Prim.ForceRotationalVelocity; m_knownRotationalVelocity = ControllingPrim.ForceRotationalVelocity;
m_knownHas |= m_knownChangedRotationalVelocity; m_knownHas |= m_knownChangedRotationalVelocity;
} }
return (Vector3)m_knownRotationalVelocity; return (Vector3)m_knownRotationalVelocity;
@ -915,10 +968,10 @@ namespace OpenSim.Region.Physics.BulletSPlugin
PushKnownChanged(); PushKnownChanged();
if (PhysicsScene.VehiclePhysicalLoggingEnabled) if (PhysicsScene.VehiclePhysicalLoggingEnabled)
PhysicsScene.PE.DumpRigidBody(PhysicsScene.World, Prim.PhysBody); PhysicsScene.PE.DumpRigidBody(PhysicsScene.World, ControllingPrim.PhysBody);
VDetailLog("{0},BSDynamics.Step,done,pos={1}, force={2},velocity={3},angvel={4}", VDetailLog("{0},BSDynamics.Step,done,pos={1}, force={2},velocity={3},angvel={4}",
Prim.LocalID, VehiclePosition, m_knownForce, VehicleVelocity, VehicleRotationalVelocity); ControllingPrim.LocalID, VehiclePosition, m_knownForce, VehicleVelocity, VehicleRotationalVelocity);
} }
// Called after the simulation step // Called after the simulation step
@ -927,7 +980,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
if (!IsActive) return; if (!IsActive) return;
if (PhysicsScene.VehiclePhysicalLoggingEnabled) if (PhysicsScene.VehiclePhysicalLoggingEnabled)
PhysicsScene.PE.DumpRigidBody(PhysicsScene.World, Prim.PhysBody); PhysicsScene.PE.DumpRigidBody(PhysicsScene.World, ControllingPrim.PhysBody);
} }
// Apply the effect of the linear motor and other linear motions (like hover and float). // Apply the effect of the linear motor and other linear motions (like hover and float).
@ -967,12 +1020,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
VehicleVelocity /= VehicleVelocity.Length(); VehicleVelocity /= VehicleVelocity.Length();
VehicleVelocity *= BSParam.VehicleMaxLinearVelocity; VehicleVelocity *= BSParam.VehicleMaxLinearVelocity;
VDetailLog("{0}, MoveLinear,clampMax,origVelW={1},lenSq={2},maxVelSq={3},,newVelW={4}", VDetailLog("{0}, MoveLinear,clampMax,origVelW={1},lenSq={2},maxVelSq={3},,newVelW={4}",
Prim.LocalID, origVelW, newVelocityLengthSq, BSParam.VehicleMaxLinearVelocitySquared, VehicleVelocity); ControllingPrim.LocalID, origVelW, newVelocityLengthSq, BSParam.VehicleMaxLinearVelocitySquared, VehicleVelocity);
} }
else if (newVelocityLengthSq < 0.001f) else if (newVelocityLengthSq < 0.001f)
VehicleVelocity = Vector3.Zero; VehicleVelocity = Vector3.Zero;
VDetailLog("{0}, MoveLinear,done,isColl={1},newVel={2}", Prim.LocalID, Prim.IsColliding, VehicleVelocity ); VDetailLog("{0}, MoveLinear,done,isColl={1},newVel={2}", ControllingPrim.LocalID, ControllingPrim.IsColliding, VehicleVelocity );
} // end MoveLinear() } // end MoveLinear()
@ -997,7 +1050,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
VehicleVelocity += linearMotorVelocityW; VehicleVelocity += linearMotorVelocityW;
VDetailLog("{0}, MoveLinear,velocity,origVelW={1},velV={2},correctV={3},correctW={4},newVelW={5}", VDetailLog("{0}, MoveLinear,velocity,origVelW={1},velV={2},correctV={3},correctW={4},newVelW={5}",
Prim.LocalID, origVelW, currentVelV, linearMotorCorrectionV, linearMotorVelocityW, VehicleVelocity); ControllingPrim.LocalID, origVelW, currentVelV, linearMotorCorrectionV, linearMotorVelocityW, VehicleVelocity);
} }
public void ComputeLinearTerrainHeightCorrection(float pTimestep) public void ComputeLinearTerrainHeightCorrection(float pTimestep)
@ -1011,7 +1064,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
newPosition.Z = GetTerrainHeight(VehiclePosition) + 1f; newPosition.Z = GetTerrainHeight(VehiclePosition) + 1f;
VehiclePosition = newPosition; VehiclePosition = newPosition;
VDetailLog("{0}, MoveLinear,terrainHeight,terrainHeight={1},pos={2}", VDetailLog("{0}, MoveLinear,terrainHeight,terrainHeight={1},pos={2}",
Prim.LocalID, GetTerrainHeight(VehiclePosition), VehiclePosition); ControllingPrim.LocalID, GetTerrainHeight(VehiclePosition), VehiclePosition);
} }
} }
@ -1050,7 +1103,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
pos.Z = m_VhoverTargetHeight; pos.Z = m_VhoverTargetHeight;
VehiclePosition = pos; VehiclePosition = pos;
VDetailLog("{0}, MoveLinear,hover,pos={1},lockHoverHeight", Prim.LocalID, pos); VDetailLog("{0}, MoveLinear,hover,pos={1},lockHoverHeight", ControllingPrim.LocalID, pos);
} }
} }
else else
@ -1079,7 +1132,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
*/ */
VDetailLog("{0}, MoveLinear,hover,pos={1},eff={2},hoverTS={3},height={4},target={5},err={6},corr={7}", VDetailLog("{0}, MoveLinear,hover,pos={1},eff={2},hoverTS={3},height={4},target={5},err={6},corr={7}",
Prim.LocalID, VehiclePosition, m_VhoverEfficiency, ControllingPrim.LocalID, VehiclePosition, m_VhoverEfficiency,
m_VhoverTimescale, m_VhoverHeight, m_VhoverTargetHeight, m_VhoverTimescale, m_VhoverHeight, m_VhoverTargetHeight,
verticalError, verticalCorrection); verticalError, verticalCorrection);
} }
@ -1124,7 +1177,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{ {
VehiclePosition = pos; VehiclePosition = pos;
VDetailLog("{0}, MoveLinear,blockingEndPoint,block={1},origPos={2},pos={3}", VDetailLog("{0}, MoveLinear,blockingEndPoint,block={1},origPos={2},pos={3}",
Prim.LocalID, m_BlockingEndPoint, posChange, pos); ControllingPrim.LocalID, m_BlockingEndPoint, posChange, pos);
} }
} }
return changed; return changed;
@ -1164,7 +1217,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// Another approach is to measure if we're going up. If going up and not colliding, // Another approach is to measure if we're going up. If going up and not colliding,
// the vehicle is in the air. Fix that by pushing down. // the vehicle is in the air. Fix that by pushing down.
if (!Prim.IsColliding && VehicleVelocity.Z > 0.1) if (!ControllingPrim.IsColliding && VehicleVelocity.Z > 0.1)
{ {
// Get rid of any of the velocity vector that is pushing us up. // Get rid of any of the velocity vector that is pushing us up.
float upVelocity = VehicleVelocity.Z; float upVelocity = VehicleVelocity.Z;
@ -1186,7 +1239,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
} }
*/ */
VDetailLog("{0}, MoveLinear,limitMotorUp,collide={1},upVel={2},newVel={3}", VDetailLog("{0}, MoveLinear,limitMotorUp,collide={1},upVel={2},newVel={3}",
Prim.LocalID, Prim.IsColliding, upVelocity, VehicleVelocity); ControllingPrim.LocalID, ControllingPrim.IsColliding, upVelocity, VehicleVelocity);
} }
} }
} }
@ -1196,14 +1249,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin
Vector3 appliedGravity = m_VehicleGravity * m_vehicleMass; Vector3 appliedGravity = m_VehicleGravity * m_vehicleMass;
// Hack to reduce downward force if the vehicle is probably sitting on the ground // Hack to reduce downward force if the vehicle is probably sitting on the ground
if (Prim.IsColliding && IsGroundVehicle) if (ControllingPrim.IsColliding && IsGroundVehicle)
appliedGravity *= BSParam.VehicleGroundGravityFudge; appliedGravity *= BSParam.VehicleGroundGravityFudge;
VehicleAddForce(appliedGravity); VehicleAddForce(appliedGravity);
VDetailLog("{0}, MoveLinear,applyGravity,vehGrav={1},collid={2},fudge={3},mass={4},appliedForce={3}", VDetailLog("{0}, MoveLinear,applyGravity,vehGrav={1},collid={2},fudge={3},mass={4},appliedForce={3}",
Prim.LocalID, m_VehicleGravity, ControllingPrim.LocalID, m_VehicleGravity,
Prim.IsColliding, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity); ControllingPrim.IsColliding, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity);
} }
// ======================================================================= // =======================================================================
@ -1227,11 +1280,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin
{ {
// The vehicle is not adding anything angular wise. // The vehicle is not adding anything angular wise.
VehicleRotationalVelocity = Vector3.Zero; VehicleRotationalVelocity = Vector3.Zero;
VDetailLog("{0}, MoveAngular,done,zero", Prim.LocalID); VDetailLog("{0}, MoveAngular,done,zero", ControllingPrim.LocalID);
} }
else else
{ {
VDetailLog("{0}, MoveAngular,done,nonZero,angVel={1}", Prim.LocalID, VehicleRotationalVelocity); VDetailLog("{0}, MoveAngular,done,nonZero,angVel={1}", ControllingPrim.LocalID, VehicleRotationalVelocity);
} }
// ================================================================== // ==================================================================
@ -1262,7 +1315,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
torqueFromOffset.Z = 0; torqueFromOffset.Z = 0;
VehicleAddAngularForce(torqueFromOffset * m_vehicleMass); VehicleAddAngularForce(torqueFromOffset * m_vehicleMass);
VDetailLog("{0}, BSDynamic.MoveAngular,motorOffset,applyTorqueImpulse={1}", Prim.LocalID, torqueFromOffset); VDetailLog("{0}, BSDynamic.MoveAngular,motorOffset,applyTorqueImpulse={1}", ControllingPrim.LocalID, torqueFromOffset);
} }
} }
@ -1288,7 +1341,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// } // }
VehicleRotationalVelocity += angularMotorContributionV * VehicleOrientation; VehicleRotationalVelocity += angularMotorContributionV * VehicleOrientation;
VDetailLog("{0}, MoveAngular,angularTurning,angularMotorContrib={1}", Prim.LocalID, angularMotorContributionV); VDetailLog("{0}, MoveAngular,angularTurning,angularMotorContrib={1}", ControllingPrim.LocalID, angularMotorContributionV);
} }
// From http://wiki.secondlife.com/wiki/Linden_Vehicle_Tutorial: // From http://wiki.secondlife.com/wiki/Linden_Vehicle_Tutorial:
@ -1334,7 +1387,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
VehicleRotationalVelocity += vertContributionV; VehicleRotationalVelocity += vertContributionV;
VDetailLog("{0}, MoveAngular,verticalAttraction,diffAxis={1},diffAng={2},corrRot={3},contrib={4}", VDetailLog("{0}, MoveAngular,verticalAttraction,diffAxis={1},diffAng={2},corrRot={3},contrib={4}",
Prim.LocalID, ControllingPrim.LocalID,
differenceAxis, differenceAxis,
differenceAngle, differenceAngle,
correctionRotation, correctionRotation,
@ -1433,9 +1486,9 @@ namespace OpenSim.Region.Physics.BulletSPlugin
VehicleRotationalVelocity += deflectContributionV * VehicleOrientation; VehicleRotationalVelocity += deflectContributionV * VehicleOrientation;
VDetailLog("{0}, MoveAngular,Deflection,movingDir={1},pointingDir={2},deflectError={3},ret={4}", VDetailLog("{0}, MoveAngular,Deflection,movingDir={1},pointingDir={2},deflectError={3},ret={4}",
Prim.LocalID, movingDirection, pointingDirection, deflectionError, deflectContributionV); ControllingPrim.LocalID, movingDirection, pointingDirection, deflectionError, deflectContributionV);
VDetailLog("{0}, MoveAngular,Deflection,fwdSpd={1},defEff={2},defTS={3}", VDetailLog("{0}, MoveAngular,Deflection,fwdSpd={1},defEff={2},defTS={3}",
Prim.LocalID, VehicleForwardSpeed, m_angularDeflectionEfficiency, m_angularDeflectionTimescale); ControllingPrim.LocalID, VehicleForwardSpeed, m_angularDeflectionEfficiency, m_angularDeflectionTimescale);
} }
} }
@ -1501,7 +1554,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
VDetailLog("{0}, MoveAngular,Banking,rollComp={1},speed={2},rollComp={3},yAng={4},mYAng={5},ret={6}", VDetailLog("{0}, MoveAngular,Banking,rollComp={1},speed={2},rollComp={3},yAng={4},mYAng={5},ret={6}",
Prim.LocalID, rollComponents, VehicleForwardSpeed, rollComponents, yawAngle, mixedYawAngle, bankingContributionV); ControllingPrim.LocalID, rollComponents, VehicleForwardSpeed, rollComponents, yawAngle, mixedYawAngle, bankingContributionV);
} }
} }
@ -1540,7 +1593,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
if (rotq != m_rot) if (rotq != m_rot)
{ {
VehicleOrientation = m_rot; VehicleOrientation = m_rot;
VDetailLog("{0}, LimitRotation,done,orig={1},new={2}", Prim.LocalID, rotq, m_rot); VDetailLog("{0}, LimitRotation,done,orig={1},new={2}", ControllingPrim.LocalID, rotq, m_rot);
} }
} }
@ -1554,8 +1607,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// Invoke the detailed logger and output something if it's enabled. // Invoke the detailed logger and output something if it's enabled.
private void VDetailLog(string msg, params Object[] args) private void VDetailLog(string msg, params Object[] args)
{ {
if (Prim.PhysicsScene.VehicleLoggingEnabled) if (ControllingPrim.PhysicsScene.VehicleLoggingEnabled)
Prim.PhysicsScene.DetailLog(msg, args); ControllingPrim.PhysicsScene.DetailLog(msg, args);
} }
} }
} }

2
OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
View File

@ -187,7 +187,7 @@ public abstract class BSPhysObject : PhysicsActor
Friction = matAttrib.friction; Friction = matAttrib.friction;
Restitution = matAttrib.restitution; Restitution = matAttrib.restitution;
Density = matAttrib.density / BSParam.DensityScaleFactor; Density = matAttrib.density / BSParam.DensityScaleFactor;
DetailLog("{0},{1}.SetMaterial,Mat={2},frict={3},rest={4},den={5}", LocalID, TypeName, Material, Friction, Restitution, Density); // DetailLog("{0},{1}.SetMaterial,Mat={2},frict={3},rest={4},den={5}", LocalID, TypeName, Material, Friction, Restitution, Density);
} }
// Stop all physical motion. // Stop all physical motion.

46
OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
View File

@ -72,7 +72,8 @@ public class BSPrim : BSPhysObject
private int CrossingFailures { get; set; } private int CrossingFailures { get; set; }
public BSDynamics VehicleController { get; private set; } public BSDynamics VehicleActor;
public string VehicleActorName = "BasicVehicle";
private BSVMotor _targetMotor; private BSVMotor _targetMotor;
private OMV.Vector3 _PIDTarget; private OMV.Vector3 _PIDTarget;
@ -100,11 +101,12 @@ public class BSPrim : BSPhysObject
_isPhysical = pisPhysical; _isPhysical = pisPhysical;
_isVolumeDetect = false; _isVolumeDetect = false;
VehicleController = new BSDynamics(PhysicsScene, this); // add vehicleness VehicleActor = new BSDynamics(PhysicsScene, this, VehicleActorName);
PhysicalActors.Add(VehicleActorName, VehicleActor);
_mass = CalculateMass(); _mass = CalculateMass();
DetailLog("{0},BSPrim.constructor,call", LocalID); // DetailLog("{0},BSPrim.constructor,call", LocalID);
// do the actual object creation at taint time // do the actual object creation at taint time
PhysicsScene.TaintedObject("BSPrim.create", delegate() PhysicsScene.TaintedObject("BSPrim.create", delegate()
{ {
@ -272,6 +274,7 @@ public class BSPrim : BSPhysObject
{ {
PhysicsScene.TaintedObject("BSPrim.LockAngularMotion", delegate() PhysicsScene.TaintedObject("BSPrim.LockAngularMotion", delegate()
{ {
DetailLog("{0},BSPrim.LockAngularMotion,taint,registeringLockAxisActor", LocalID);
// If there is not already an axis locker, make one // If there is not already an axis locker, make one
if (!PhysicalActors.HasActor(LockedAxisActorName)) if (!PhysicalActors.HasActor(LockedAxisActorName))
{ {
@ -537,7 +540,7 @@ public class BSPrim : BSPhysObject
public override int VehicleType { public override int VehicleType {
get { get {
return (int)VehicleController.Type; // if we are a vehicle, return that type return (int)VehicleActor.Type; // if we are a vehicle, return that type
} }
set { set {
Vehicle type = (Vehicle)value; Vehicle type = (Vehicle)value;
@ -546,20 +549,8 @@ public class BSPrim : BSPhysObject
{ {
// Done at taint time so we're sure the physics engine is not using the variables // Done at taint time so we're sure the physics engine is not using the variables
// Vehicle code changes the parameters for this vehicle type. // Vehicle code changes the parameters for this vehicle type.
VehicleController.ProcessTypeChange(type); VehicleActor.ProcessTypeChange(type);
ActivateIfPhysical(false); ActivateIfPhysical(false);
// If an active vehicle, register the vehicle code to be called before each step
if (VehicleController.Type == Vehicle.TYPE_NONE)
{
UnRegisterPreStepAction("BSPrim.Vehicle", LocalID);
UnRegisterPostStepAction("BSPrim.Vehicle", LocalID);
}
else
{
RegisterPreStepAction("BSPrim.Vehicle", LocalID, VehicleController.Step);
RegisterPostStepAction("BSPrim.Vehicle", LocalID, VehicleController.PostStep);
}
}); });
} }
} }
@ -567,7 +558,7 @@ public class BSPrim : BSPhysObject
{ {
PhysicsScene.TaintedObject("BSPrim.VehicleFloatParam", delegate() PhysicsScene.TaintedObject("BSPrim.VehicleFloatParam", delegate()
{ {
VehicleController.ProcessFloatVehicleParam((Vehicle)param, value); VehicleActor.ProcessFloatVehicleParam((Vehicle)param, value);
ActivateIfPhysical(false); ActivateIfPhysical(false);
}); });
} }
@ -575,7 +566,7 @@ public class BSPrim : BSPhysObject
{ {
PhysicsScene.TaintedObject("BSPrim.VehicleVectorParam", delegate() PhysicsScene.TaintedObject("BSPrim.VehicleVectorParam", delegate()
{ {
VehicleController.ProcessVectorVehicleParam((Vehicle)param, value); VehicleActor.ProcessVectorVehicleParam((Vehicle)param, value);
ActivateIfPhysical(false); ActivateIfPhysical(false);
}); });
} }
@ -583,7 +574,7 @@ public class BSPrim : BSPhysObject
{ {
PhysicsScene.TaintedObject("BSPrim.VehicleRotationParam", delegate() PhysicsScene.TaintedObject("BSPrim.VehicleRotationParam", delegate()
{ {
VehicleController.ProcessRotationVehicleParam((Vehicle)param, rotation); VehicleActor.ProcessRotationVehicleParam((Vehicle)param, rotation);
ActivateIfPhysical(false); ActivateIfPhysical(false);
}); });
} }
@ -591,7 +582,7 @@ public class BSPrim : BSPhysObject
{ {
PhysicsScene.TaintedObject("BSPrim.VehicleFlags", delegate() PhysicsScene.TaintedObject("BSPrim.VehicleFlags", delegate()
{ {
VehicleController.ProcessVehicleFlags(param, remove); VehicleActor.ProcessVehicleFlags(param, remove);
}); });
} }
@ -848,7 +839,7 @@ public class BSPrim : BSPhysObject
MakeDynamic(IsStatic); MakeDynamic(IsStatic);
// Update vehicle specific parameters (after MakeDynamic() so can change physical parameters) // Update vehicle specific parameters (after MakeDynamic() so can change physical parameters)
VehicleController.Refresh(); VehicleActor.Refresh();
PhysicalActors.Refresh(); PhysicalActors.Refresh();
// Arrange for collision events if the simulator wants them // Arrange for collision events if the simulator wants them
@ -1655,9 +1646,9 @@ public class BSPrim : BSPhysObject
volume *= (profileEnd - profileBegin); volume *= (profileEnd - profileBegin);
returnMass = Density * BSParam.DensityScaleFactor * volume; returnMass = Density * BSParam.DensityScaleFactor * volume;
DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3}", LocalID, Density, volume, returnMass);
returnMass = Util.Clamp(returnMass, BSParam.MinimumObjectMass, BSParam.MaximumObjectMass); returnMass = Util.Clamp(returnMass, BSParam.MinimumObjectMass, BSParam.MaximumObjectMass);
// DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3}", LocalID, Density, volume, returnMass);
return returnMass; return returnMass;
}// end CalculateMass }// end CalculateMass
@ -1686,7 +1677,7 @@ public class BSPrim : BSPhysObject
protected virtual void RemoveBodyDependencies() protected virtual void RemoveBodyDependencies()
{ {
VehicleController.RemoveBodyDependencies(this); VehicleActor.RemoveBodyDependencies();
PhysicalActors.RemoveBodyDependencies(); PhysicalActors.RemoveBodyDependencies();
} }
@ -1696,13 +1687,6 @@ public class BSPrim : BSPhysObject
{ {
TriggerPreUpdatePropertyAction(ref entprop); TriggerPreUpdatePropertyAction(ref entprop);
// A temporary kludge to suppress the rotational effects introduced on vehicles by Bullet
// TODO: handle physics introduced by Bullet with computed vehicle physics.
if (VehicleController.IsActive)
{
entprop.RotationalVelocity = OMV.Vector3.Zero;
}
// DetailLog("{0},BSPrim.UpdateProperties,entry,entprop={1}", LocalID, entprop); // DEBUG DEBUG // DetailLog("{0},BSPrim.UpdateProperties,entry,entprop={1}", LocalID, entprop); // DEBUG DEBUG
// Assign directly to the local variables so the normal set actions do not happen // Assign directly to the local variables so the normal set actions do not happen

2
OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
View File

@ -463,7 +463,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
if (!m_initialized) return null; if (!m_initialized) return null;
DetailLog("{0},BSScene.AddPrimShape,call", localID); // DetailLog("{0},BSScene.AddPrimShape,call", localID);
BSPhysObject prim = new BSPrimLinkable(localID, primName, this, position, size, rotation, pbs, isPhysical); BSPhysObject prim = new BSPrimLinkable(localID, primName, this, position, size, rotation, pbs, isPhysical);
lock (PhysObjects) PhysObjects.Add(localID, prim); lock (PhysObjects) PhysObjects.Add(localID, prim);

12
OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs
View File

@ -114,9 +114,9 @@ public class BasicVehicles : OpenSimTestCase
// Instead the appropriate values are set and calls are made just the parts of the // Instead the appropriate values are set and calls are made just the parts of the
// controller we want to exercise. Stepping the physics engine then applies // controller we want to exercise. Stepping the physics engine then applies
// the actions of that one feature. // the actions of that one feature.
TestVehicle.VehicleController.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, efficiency); TestVehicle.VehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, efficiency);
TestVehicle.VehicleController.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, timeScale); TestVehicle.VehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, timeScale);
TestVehicle.VehicleController.enableAngularVerticalAttraction = true; TestVehicle.VehicleActor.enableAngularVerticalAttraction = true;
TestVehicle.IsPhysical = true; TestVehicle.IsPhysical = true;
PhysicsScene.ProcessTaints(); PhysicsScene.ProcessTaints();
@ -124,9 +124,9 @@ public class BasicVehicles : OpenSimTestCase
// Step the simulator a bunch of times and vertical attraction should orient the vehicle up // Step the simulator a bunch of times and vertical attraction should orient the vehicle up
for (int ii = 0; ii < simSteps; ii++) for (int ii = 0; ii < simSteps; ii++)
{ {
TestVehicle.VehicleController.ForgetKnownVehicleProperties(); TestVehicle.VehicleActor.ForgetKnownVehicleProperties();
TestVehicle.VehicleController.ComputeAngularVerticalAttraction(); TestVehicle.VehicleActor.ComputeAngularVerticalAttraction();
TestVehicle.VehicleController.PushKnownChanged(); TestVehicle.VehicleActor.PushKnownChanged();
PhysicsScene.Simulate(simulationTimeStep); PhysicsScene.Simulate(simulationTimeStep);
} }