public PhysicsState(ALVector2D position)
{
this.Position = position;
this.Velocity = ALVector2D.Zero;
this.Acceleration = ALVector2D.Zero;
this.ForceAccumulator = ALVector2D.Zero;
}
public void UpdatePosition(TimeStep step, ref ALVector2D extraVelocity)
{
state.Position.Linear.X += (state.Velocity.Linear.X + extraVelocity.Linear.X) * step.Dt;
state.Position.Linear.Y += (state.Velocity.Linear.Y + extraVelocity.Linear.Y) * step.Dt;
state.Position.Angular += (state.Velocity.Angular + extraVelocity.Angular) * step.Dt;
ApplyPosition();
}
void UpdateAcceleration(ref ALVector2D acceleration, ref ALVector2D forceAccumulator)
{
Scalar proxDamping = 1.0f / (proxies.Count + 1);
acceleration.Linear.X = acceleration.Linear.X * proxDamping + forceAccumulator.Linear.X * massInfo.MassInv;
acceleration.Linear.Y = acceleration.Linear.Y * proxDamping + forceAccumulator.Linear.Y * massInfo.MassInv;
acceleration.Angular += forceAccumulator.Angular * massInfo.MomentOfInertiaInv;
}
public static void SubtractImpulse(
ref ALVector2D velocity, ref Vector2D impulse, ref Vector2D point,
ref Scalar massInv, ref Scalar inertiaInv)
{
velocity.Linear.X -= impulse.X * massInv;
velocity.Linear.Y -= impulse.Y * massInv;
velocity.Angular -= (inertiaInv * (point.X * impulse.Y - point.Y * impulse.X));
}
public static Vector2D GetRelativeVelocity(
ALVector2D velocity1, ALVector2D velocity2,
Vector2D point1, Vector2D point2)
{
Vector2D result;
GetRelativeVelocity(ref velocity1, ref velocity2, ref point1, ref point2, out result);
return(result);
}
internal void OnPositionChanged()
{
if (PositionChanged != null &&
!ALVector2D.Equals(ref lastPosition, ref state.Position))
{
PositionChanged(this, EventArgs.Empty);
lastPosition = state.Position;
}
}
public PhysicsState(PhysicsState state)
{
if (state == null)
{
throw new ArgumentNullException("state");
}
this.Position = state.Position;
this.Velocity = state.Velocity;
this.Acceleration = state.Acceleration;
this.ForceAccumulator = state.ForceAccumulator;
}
internal void OnPositionChanged()
{
if (PositionChanged != null &&
(transformChanged ||
!ALVector2D.Equals(ref lastPosition, ref state.Position)))
{
PositionChanged(this, EventArgs.Empty);
lastPosition = state.Position;
transformChanged = false;
}
}
public static void GetRelativeVelocity(
ref ALVector2D velocity1, ref ALVector2D velocity2,
ref Vector2D point1, ref Vector2D point2,
out Vector2D result)
{
result.X =
(velocity2.Linear.X - velocity2.Angular * point2.Y) -
(velocity1.Linear.X - velocity1.Angular * point1.Y);
result.Y =
(velocity2.Linear.Y + velocity2.Angular * point2.X) -
(velocity1.Linear.Y + velocity1.Angular * point1.X);
}
/// <summary>
/// Updates all the values caluclated from the State.Position.
/// Re-calculates the Matrices property the re-calculates the Rectangle property
/// from that.
/// </summary>
public void ApplyPosition()
{
MathHelper.ClampAngle(ref state.Position.Angular);
Matrix2x3 matrix;
ALVector2D.ToMatrix2x3(ref state.Position, out matrix);
Matrix2x3.Multiply(ref matrix, ref transformation, out matrix);
matrices.SetToWorld(ref matrix);
shape.CalcBoundingRectangle(ref matrix, out rectangle);
if (engine == null || !engine.inUpdate)
{
OnPositionChanged();
}
}
void UpdateVelocity(ref ALVector2D velocity, ref ALVector2D acceleration, Scalar dt)
{
velocity.Linear.X = velocity.Linear.X * linearDamping + acceleration.Linear.X * dt;
velocity.Linear.Y = velocity.Linear.Y * linearDamping + acceleration.Linear.Y * dt;
velocity.Angular = velocity.Angular * angularDamping + acceleration.Angular * dt;
}
public void UpdatePosition(TimeStep step, ALVector2D extraVelocity)
{
UpdatePosition(step, ref extraVelocity);
}
