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

BulletSim: add VEHICLE_ more parameter value limit checking. 

This only bounds passed parameters as there is no good way of refusing
the parameter setting. This mostly means that passing NaN's won't
crash the simulator.
0.8.1-post-fixes
Robert Adams 2015-03-07 17:47:40 -08:00 committed by Justin Clark-Casey (justincc)
parent 60889f139a
commit d8642ff210
2 changed files with 57 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
OpenSim/Region/Framework/Scenes/Scene.cs
View File

@ -5216,6 +5216,10 @@ namespace OpenSim.Region.Framework.Scenes
return null; return null;
} }
// Get terrain height at the specified <x,y> location.
// Presumes the underlying implementation is a heightmap which is a 1m grid.
// Finds heightmap grid points before and after the point and
// does a linear approximation of the height at this intermediate point.
public float GetGroundHeight(float x, float y) public float GetGroundHeight(float x, float y)
{ {
if (x < 0) if (x < 0)

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

@ -76,8 +76,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
private Vector3 m_linearMotorOffset = Vector3.Zero; // the point of force can be offset from the center private Vector3 m_linearMotorOffset = Vector3.Zero; // the point of force can be offset from the center
private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero; // velocity requested by LSL private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero; // velocity requested by LSL
private Vector3 m_linearFrictionTimescale = Vector3.Zero; private Vector3 m_linearFrictionTimescale = Vector3.Zero;
private float m_linearMotorDecayTimescale = 0; private float m_linearMotorDecayTimescale = 1;
private float m_linearMotorTimescale = 0; private float m_linearMotorTimescale = 1;
private Vector3 m_lastLinearVelocityVector = Vector3.Zero; private Vector3 m_lastLinearVelocityVector = Vector3.Zero;
private Vector3 m_lastPositionVector = Vector3.Zero; private Vector3 m_lastPositionVector = Vector3.Zero;
// private bool m_LinearMotorSetLastFrame = false; // private bool m_LinearMotorSetLastFrame = false;
@ -88,8 +88,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
private Vector3 m_angularMotorDirection = Vector3.Zero; // angular velocity requested by LSL motor private Vector3 m_angularMotorDirection = Vector3.Zero; // angular velocity requested by LSL motor
// private int m_angularMotorApply = 0; // application frame counter // private int m_angularMotorApply = 0; // application frame counter
private Vector3 m_angularMotorVelocity = Vector3.Zero; // current angular motor velocity private Vector3 m_angularMotorVelocity = Vector3.Zero; // current angular motor velocity
private float m_angularMotorTimescale = 0; // motor angular velocity ramp up rate private float m_angularMotorTimescale = 1; // motor angular velocity ramp up rate
private float m_angularMotorDecayTimescale = 0; // motor angular velocity decay rate private float m_angularMotorDecayTimescale = 1; // motor angular velocity decay rate
private Vector3 m_angularFrictionTimescale = Vector3.Zero; // body angular velocity decay rate private Vector3 m_angularFrictionTimescale = Vector3.Zero; // body angular velocity decay rate
private Vector3 m_lastAngularVelocity = Vector3.Zero; private Vector3 m_lastAngularVelocity = Vector3.Zero;
private Vector3 m_lastVertAttractor = Vector3.Zero; // what VA was last applied to body private Vector3 m_lastVertAttractor = Vector3.Zero; // what VA was last applied to body
@ -103,7 +103,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
//Banking properties //Banking properties
private float m_bankingEfficiency = 0; private float m_bankingEfficiency = 0;
private float m_bankingMix = 0; private float m_bankingMix = 1;
private float m_bankingTimescale = 0; private float m_bankingTimescale = 0;
//Hover and Buoyancy properties //Hover and Buoyancy properties
@ -124,8 +124,10 @@ namespace OpenSim.Region.Physics.BulletSPlugin
private float m_verticalAttractionTimescale = 510f; private float m_verticalAttractionTimescale = 510f;
// Just some recomputed constants: // Just some recomputed constants:
static readonly float PIOverFour = ((float)Math.PI) / 4f;
#pragma warning disable 414 #pragma warning disable 414
static readonly float TwoPI = ((float)Math.PI) * 2f;
static readonly float FourPI = ((float)Math.PI) * 4f;
static readonly float PIOverFour = ((float)Math.PI) / 4f;
static readonly float PIOverTwo = ((float)Math.PI) / 2f; static readonly float PIOverTwo = ((float)Math.PI) / 2f;
#pragma warning restore 414 #pragma warning restore 414
@ -159,56 +161,58 @@ namespace OpenSim.Region.Physics.BulletSPlugin
public void ProcessFloatVehicleParam(Vehicle pParam, float pValue) public void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
{ {
VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue); VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
float clampTemp;
switch (pParam) switch (pParam)
{ {
case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY: case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
m_angularDeflectionEfficiency = ClampInRange(0f, pValue, 1f); m_angularDeflectionEfficiency = ClampInRange(0f, pValue, 1f);
break; break;
case Vehicle.ANGULAR_DEFLECTION_TIMESCALE: case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
m_angularDeflectionTimescale = Math.Max(pValue, 0.01f); m_angularDeflectionTimescale = ClampInRange(0.25f, pValue, 120);
break; break;
case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE: case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
m_angularMotorDecayTimescale = ClampInRange(0.01f, pValue, 120); m_angularMotorDecayTimescale = ClampInRange(0.25f, pValue, 120);
m_angularMotor.TargetValueDecayTimeScale = m_angularMotorDecayTimescale; m_angularMotor.TargetValueDecayTimeScale = m_angularMotorDecayTimescale;
break; break;
case Vehicle.ANGULAR_MOTOR_TIMESCALE: case Vehicle.ANGULAR_MOTOR_TIMESCALE:
m_angularMotorTimescale = Math.Max(pValue, 0.01f); m_angularMotorTimescale = ClampInRange(0.25f, pValue, 120);
m_angularMotor.TimeScale = m_angularMotorTimescale; m_angularMotor.TimeScale = m_angularMotorTimescale;
break; break;
case Vehicle.BANKING_EFFICIENCY: case Vehicle.BANKING_EFFICIENCY:
m_bankingEfficiency = ClampInRange(-1f, pValue, 1f); m_bankingEfficiency = ClampInRange(-1f, pValue, 1f);
break; break;
case Vehicle.BANKING_MIX: case Vehicle.BANKING_MIX:
m_bankingMix = Math.Max(pValue, 0.01f); m_bankingMix = ClampInRange(0.01f, pValue, 1);
break; break;
case Vehicle.BANKING_TIMESCALE: case Vehicle.BANKING_TIMESCALE:
m_bankingTimescale = Math.Max(pValue, 0.01f); m_bankingTimescale = ClampInRange(0.25f, pValue, 120);
break; break;
case Vehicle.BUOYANCY: case Vehicle.BUOYANCY:
m_VehicleBuoyancy = ClampInRange(-1f, pValue, 1f); m_VehicleBuoyancy = ClampInRange(-1f, pValue, 1f);
m_VehicleGravity = ControllingPrim.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(0.01f, pValue, 1f);
break; break;
case Vehicle.HOVER_HEIGHT: case Vehicle.HOVER_HEIGHT:
m_VhoverHeight = pValue; m_VhoverHeight = ClampInRange(0f, pValue, 1000000f);
break; break;
case Vehicle.HOVER_TIMESCALE: case Vehicle.HOVER_TIMESCALE:
m_VhoverTimescale = Math.Max(pValue, 0.01f); m_VhoverTimescale = ClampInRange(0.01f, pValue, 120);
break; break;
case Vehicle.LINEAR_DEFLECTION_EFFICIENCY: case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
m_linearDeflectionEfficiency = ClampInRange(0f, pValue, 1f); m_linearDeflectionEfficiency = ClampInRange(0f, pValue, 1f);
break; break;
case Vehicle.LINEAR_DEFLECTION_TIMESCALE: case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
m_linearDeflectionTimescale = Math.Max(pValue, 0.01f); m_linearDeflectionTimescale = ClampInRange(0.01f, pValue, 120);
break; break;
case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE: case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
m_linearMotorDecayTimescale = ClampInRange(0.01f, pValue, 120); m_linearMotorDecayTimescale = ClampInRange(0.01f, pValue, 120);
m_linearMotor.TargetValueDecayTimeScale = m_linearMotorDecayTimescale; m_linearMotor.TargetValueDecayTimeScale = m_linearMotorDecayTimescale;
break; break;
case Vehicle.LINEAR_MOTOR_TIMESCALE: case Vehicle.LINEAR_MOTOR_TIMESCALE:
m_linearMotorTimescale = Math.Max(pValue, 0.01f); m_linearMotorTimescale = ClampInRange(0.01f, pValue, 120);
m_linearMotor.TimeScale = m_linearMotorTimescale; m_linearMotor.TimeScale = m_linearMotorTimescale;
break; break;
case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY: case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
@ -216,30 +220,35 @@ namespace OpenSim.Region.Physics.BulletSPlugin
m_verticalAttractionMotor.Efficiency = m_verticalAttractionEfficiency; m_verticalAttractionMotor.Efficiency = m_verticalAttractionEfficiency;
break; break;
case Vehicle.VERTICAL_ATTRACTION_TIMESCALE: case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
m_verticalAttractionTimescale = Math.Max(pValue, 0.01f); m_verticalAttractionTimescale = ClampInRange(0.01f, pValue, 120);
m_verticalAttractionMotor.TimeScale = m_verticalAttractionTimescale; m_verticalAttractionMotor.TimeScale = m_verticalAttractionTimescale;
break; break;
// These are vector properties but the engine lets you use a single float value to // These are vector properties but the engine lets you use a single float value to
// set all of the components to the same value // set all of the components to the same value
case Vehicle.ANGULAR_FRICTION_TIMESCALE: case Vehicle.ANGULAR_FRICTION_TIMESCALE:
m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue); clampTemp = ClampInRange(0.01f, pValue, 120);
m_angularFrictionTimescale = new Vector3(clampTemp, clampTemp, clampTemp);
break; break;
case Vehicle.ANGULAR_MOTOR_DIRECTION: case Vehicle.ANGULAR_MOTOR_DIRECTION:
m_angularMotorDirection = new Vector3(pValue, pValue, pValue); clampTemp = ClampInRange(-TwoPI, pValue, TwoPI);
m_angularMotorDirection = new Vector3(clampTemp, clampTemp, clampTemp);
m_angularMotor.Zero(); m_angularMotor.Zero();
m_angularMotor.SetTarget(m_angularMotorDirection); m_angularMotor.SetTarget(m_angularMotorDirection);
break; break;
case Vehicle.LINEAR_FRICTION_TIMESCALE: case Vehicle.LINEAR_FRICTION_TIMESCALE:
m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue); clampTemp = ClampInRange(0.01f, pValue, 120);
m_linearFrictionTimescale = new Vector3(clampTemp, clampTemp, clampTemp);
break; break;
case Vehicle.LINEAR_MOTOR_DIRECTION: case Vehicle.LINEAR_MOTOR_DIRECTION:
m_linearMotorDirection = new Vector3(pValue, pValue, pValue); clampTemp = ClampInRange(-BSParam.MaxLinearVelocity, pValue, BSParam.MaxLinearVelocity);
m_linearMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue); m_linearMotorDirection = new Vector3(clampTemp, clampTemp, clampTemp);
m_linearMotorDirectionLASTSET = new Vector3(clampTemp, clampTemp, clampTemp);
m_linearMotor.SetTarget(m_linearMotorDirection); m_linearMotor.SetTarget(m_linearMotorDirection);
break; break;
case Vehicle.LINEAR_MOTOR_OFFSET: case Vehicle.LINEAR_MOTOR_OFFSET:
m_linearMotorOffset = new Vector3(pValue, pValue, pValue); clampTemp = ClampInRange(-1000, pValue, 1000);
m_linearMotorOffset = new Vector3(clampTemp, clampTemp, clampTemp);
break; break;
} }
@ -251,29 +260,46 @@ namespace OpenSim.Region.Physics.BulletSPlugin
switch (pParam) switch (pParam)
{ {
case Vehicle.ANGULAR_FRICTION_TIMESCALE: case Vehicle.ANGULAR_FRICTION_TIMESCALE:
pValue.X = ClampInRange(0.25f, pValue.X, 120);
pValue.Y = ClampInRange(0.25f, pValue.Y, 120);
pValue.Z = ClampInRange(0.25f, pValue.Z, 120);
m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z); m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
break; break;
case Vehicle.ANGULAR_MOTOR_DIRECTION: case Vehicle.ANGULAR_MOTOR_DIRECTION:
// Limit requested angular speed to 2 rps= 4 pi rads/sec // Limit requested angular speed to 2 rps= 4 pi rads/sec
pValue.X = ClampInRange(-12.56f, pValue.X, 12.56f); pValue.X = ClampInRange(-FourPI, pValue.X, FourPI);
pValue.Y = ClampInRange(-12.56f, pValue.Y, 12.56f); pValue.Y = ClampInRange(-FourPI, pValue.Y, FourPI);
pValue.Z = ClampInRange(-12.56f, pValue.Z, 12.56f); pValue.Z = ClampInRange(-FourPI, pValue.Z, FourPI);
m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z); m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
m_angularMotor.Zero(); m_angularMotor.Zero();
m_angularMotor.SetTarget(m_angularMotorDirection); m_angularMotor.SetTarget(m_angularMotorDirection);
break; break;
case Vehicle.LINEAR_FRICTION_TIMESCALE: case Vehicle.LINEAR_FRICTION_TIMESCALE:
pValue.X = ClampInRange(0.25f, pValue.X, 120);
pValue.Y = ClampInRange(0.25f, pValue.Y, 120);
pValue.Z = ClampInRange(0.25f, pValue.Z, 120);
m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z); m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
break; break;
case Vehicle.LINEAR_MOTOR_DIRECTION: case Vehicle.LINEAR_MOTOR_DIRECTION:
pValue.X = ClampInRange(-BSParam.MaxLinearVelocity, pValue.X, BSParam.MaxLinearVelocity);
pValue.Y = ClampInRange(-BSParam.MaxLinearVelocity, pValue.Y, BSParam.MaxLinearVelocity);
pValue.Z = ClampInRange(-BSParam.MaxLinearVelocity, pValue.Z, BSParam.MaxLinearVelocity);
m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z); m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z); m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z);
m_linearMotor.SetTarget(m_linearMotorDirection); m_linearMotor.SetTarget(m_linearMotorDirection);
break; break;
case Vehicle.LINEAR_MOTOR_OFFSET: case Vehicle.LINEAR_MOTOR_OFFSET:
// Not sure the correct range to limit this variable
pValue.X = ClampInRange(-1000, pValue.X, 1000);
pValue.Y = ClampInRange(-1000, pValue.Y, 1000);
pValue.Z = ClampInRange(-1000, pValue.Z, 1000);
m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z); m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
break; break;
case Vehicle.BLOCK_EXIT: case Vehicle.BLOCK_EXIT:
// Not sure the correct range to limit this variable
pValue.X = ClampInRange(-10000, pValue.X, 10000);
pValue.Y = ClampInRange(-10000, pValue.Y, 10000);
pValue.Z = ClampInRange(-10000, pValue.Z, 10000);
m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z); m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z);
break; break;
} }
@ -1601,7 +1627,6 @@ namespace OpenSim.Region.Physics.BulletSPlugin
deflectContributionV = (-deflectionError) * ClampInRange(0, m_angularDeflectionEfficiency/m_angularDeflectionTimescale,1f); deflectContributionV = (-deflectionError) * ClampInRange(0, m_angularDeflectionEfficiency/m_angularDeflectionTimescale,1f);
//deflectContributionV /= m_angularDeflectionTimescale; //deflectContributionV /= m_angularDeflectionTimescale;
// VehicleRotationalVelocity += deflectContributionV * VehicleOrientation;
VehicleRotationalVelocity += deflectContributionV; VehicleRotationalVelocity += deflectContributionV;
VDetailLog("{0}, MoveAngular,Deflection,movingDir={1},pointingDir={2},deflectError={3},ret={4}", VDetailLog("{0}, MoveAngular,Deflection,movingDir={1},pointingDir={2},deflectError={3},ret={4}",
ControllingPrim.LocalID, movingDirection, pointingDirection, deflectionError, deflectContributionV); ControllingPrim.LocalID, movingDirection, pointingDirection, deflectionError, deflectContributionV);
@ -1659,7 +1684,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// TODO: the banking effect should not go to infinity but what to limit it to? // TODO: the banking effect should not go to infinity but what to limit it to?
// And what should happen when this is being added to a user defined yaw that is already PI*4? // And what should happen when this is being added to a user defined yaw that is already PI*4?
mixedYawAngle = ClampInRange(-12, mixedYawAngle, 12); mixedYawAngle = ClampInRange(-FourPI, mixedYawAngle, FourPI);
// Build the force vector to change rotation from what it is to what it should be // Build the force vector to change rotation from what it is to what it should be
bankingContributionV.Z = -mixedYawAngle; bankingContributionV.Z = -mixedYawAngle;
@ -1667,7 +1692,6 @@ namespace OpenSim.Region.Physics.BulletSPlugin
// Don't do it all at once. Fudge because 1 second is too fast with most user defined roll as PI*4. // Don't do it all at once. Fudge because 1 second is too fast with most user defined roll as PI*4.
bankingContributionV /= m_bankingTimescale * BSParam.VehicleAngularBankingTimescaleFudge; bankingContributionV /= m_bankingTimescale * BSParam.VehicleAngularBankingTimescaleFudge;
//VehicleRotationalVelocity += bankingContributionV * VehicleOrientation;
VehicleRotationalVelocity += bankingContributionV; VehicleRotationalVelocity += bankingContributionV;