private void ControlBiped(InputManager input, float dTimeMs)
{
// If input is in line with avatar orientation, you get all movement, otherwise, some of the movement is dulled to get reorientation
Vector3 moveInput = Vector3.Zero;
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.MoveLeftRightRate))
{
moveInput.X += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.MoveLeftRightRate],
InputIndex);
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.MoveDownUpRate))
{
moveInput.Z -= input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.MoveDownUpRate],
InputIndex);
}
float moveAmount = moveInput.Length();
if (moveAmount > 0.0f)
{
// Transform (rotation only) the input from view space into world space
Matrix cameraRotation = mReferenceCam.Transform;
cameraRotation.Translation = Vector3.Zero;
moveInput = Vector3.Transform(moveInput, cameraRotation);
if (moveInput.X != 0.0f || moveInput.Z != 0.0f)
{
moveInput.Y = 0.0f;
Quaternion directionDiff = SpaceUtils.GetSweptQuaternion(BepuConverter.Convert(mBipedControl.Controller.HorizontalViewDirection), moveInput);
mBipedControl.OrientationChange = directionDiff;
}
}
mBipedControl.HorizontalMovement = Vector2.UnitY * moveAmount;
// Crouching:
if (input.CheckForBinaryInput(ActiveInputMap, BinaryControlActions.Crouch, InputIndex))
{
mBipedControl.DesiredMovementActions |= BipedControllerComponent.MovementActions.Crouching;
}
else
{
mBipedControl.DesiredMovementActions &= ~BipedControllerComponent.MovementActions.Crouching;
}
// Jumping:
if (input.CheckForNewBinaryInput(ActiveInputMap, BinaryControlActions.Jump, InputIndex))
{
mBipedControl.DesiredMovementActions |= BipedControllerComponent.MovementActions.Jumping;
}
else
{
mBipedControl.DesiredMovementActions &= ~BipedControllerComponent.MovementActions.Jumping;
}
}
private void ControlBiped(InputManager input, float dTimeMs)
{
// If input is in line with avatar orientation, you get all movement, otherwise, some of the movement is dulled to get reorientation
Vector3 moveInput = Vector3.Zero;
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.MoveLeftRightRate))
{
moveInput.X += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.MoveLeftRightRate],
InputIndex);
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.MoveDownUpRate))
{
moveInput.Z -= input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.MoveDownUpRate],
InputIndex);
}
float moveAmount = moveInput.Length();
if (moveAmount > 0.0f)
{
// Transform (rotation only) the input from view space into world space
Matrix cameraRotation = mReferenceCam.Transform;
cameraRotation.Translation = Vector3.Zero;
moveInput = Vector3.Transform(moveInput, cameraRotation);
if (moveInput.X != 0.0f || moveInput.Z != 0.0f)
{
moveInput.Y = 0.0f;
Quaternion directionDiff = SpaceUtils.GetSweptQuaternion(BepuConverter.Convert(mBipedControl.Controller.HorizontalViewDirection), moveInput);
mBipedControl.OrientationChange = directionDiff;
}
}
mBipedControl.HorizontalMovement = Vector2.UnitY * moveAmount;
// Crouching:
if (input.CheckForBinaryInput(ActiveInputMap, BinaryControlActions.Crouch, InputIndex))
{
mBipedControl.DesiredMovementActions |= BipedControllerComponent.MovementActions.Crouching;
}
else
{
mBipedControl.DesiredMovementActions &= ~BipedControllerComponent.MovementActions.Crouching;
}
// Jumping:
if (input.CheckForNewBinaryInput(ActiveInputMap, BinaryControlActions.Jump, InputIndex))
{
mBipedControl.DesiredMovementActions |= BipedControllerComponent.MovementActions.Jumping;
}
else
{
mBipedControl.DesiredMovementActions &= ~BipedControllerComponent.MovementActions.Jumping;
}
}
private void ControlBiped(InputManager input, float dTimeMs)
{
// Player orientation
Quaternion orientationChange = Quaternion.Identity;
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
orientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
orientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, -INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.TurnLeftRightRate))
{
orientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up,
-input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.TurnLeftRightRate],
InputIndex) * INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
float fullAxisTurnAmount = 0.0f;
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.TurnLeftRightDelta))
{
fullAxisTurnAmount += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.TurnLeftRightDelta],
InputIndex);
}
orientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, -fullAxisTurnAmount * INPUT_MOUSE_LOOK_FACTOR);
// We are collecting the pad movement before we're totally done with orientation to check for special case...
Vector2 padMovement = Vector2.Zero;
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.StrafeLeftRightRate))
{
padMovement.X += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.StrafeLeftRightRate], InputIndex);
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.MoveForwardBackwardRate))
{
padMovement.Y += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.MoveForwardBackwardRate], InputIndex);
}
// Special case for reorientation upon full axis (mouse) turn or pad movement:
if (fullAxisTurnAmount != 0.0f || padMovement.LengthSquared() > 0.0f)
{
// Bake the camera yaw into the orientation:
orientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, mCameraDesc.Yaw);
mCameraDesc.Yaw = 0.0f;
}
// It's good practice to make sure floating point errors don't accumulate and change the length of our unit quaternion:
orientationChange = Quaternion.Normalize(orientationChange);
mBipedControl.OrientationChange = orientationChange;
// Character movement:
Vector2 rawMovement = Vector2.Zero;
// Character movement (binary):
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveForward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveForward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(0.0f, 1.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveBackward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveBackward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(0.0f, -1.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(-1.0f, 0.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(1.0f, 0.0f);
break;
}
}
}
// Character movement (interval i.e. pad):
rawMovement += padMovement;
// Character movement (full axis i.e. mouse):
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.StrafeLeftRightDelta))
{
rawMovement.X += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.StrafeLeftRightDelta],
InputIndex);
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.MoveForwardBackwardDelta))
{
rawMovement.Y += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.MoveForwardBackwardDelta],
InputIndex) * INPUT_MOUSE_MOVE_FACTOR;
}
mBipedControl.HorizontalMovement = rawMovement;
bool pressConfirmed = false;
// Crouching:
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.Crouch))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.Crouch])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
pressConfirmed = true;
break;
}
}
}
if (pressConfirmed)
{
mBipedControl.DesiredMovementActions |= BipedControllerComponent.MovementActions.Crouching;
}
else
{
mBipedControl.DesiredMovementActions &= ~BipedControllerComponent.MovementActions.Crouching;
}
// Jumping:
pressConfirmed = false;
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.Jump))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.Jump])
{
if (input.IsNewBinaryControlPress(control, InputIndex))
{
pressConfirmed = true;
break;
}
}
}
if (pressConfirmed)
{
mBipedControl.DesiredMovementActions |= BipedControllerComponent.MovementActions.Jumping;
}
else
{
mBipedControl.DesiredMovementActions &= ~BipedControllerComponent.MovementActions.Jumping;
}
}
public override void HandleInput(GameTime gameTime, InputManager input)
{
float dTimeMs = (float)(gameTime.ElapsedGameTime.TotalMilliseconds);
// Camera yaw
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraYawDecrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraYawDecrease])
{
mCameraDesc.Yaw += (input.IsBinaryControlDown(control, InputIndex) ? -INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraYawIncrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraYawIncrease])
{
mCameraDesc.Yaw += (input.IsBinaryControlDown(control, InputIndex) ? INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.CameraYawRate))
{
mCameraDesc.Yaw += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.CameraYawRate],
InputIndex) * INPUT_PAD_LOOK_FACTOR * dTimeMs;
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.CameraYawDelta))
{
mCameraDesc.Yaw += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.CameraYawDelta],
InputIndex) * INPUT_MOUSE_LOOK_FACTOR;
}
mCameraDesc.Yaw = mCameraDesc.Yaw % MathHelper.TwoPi;
// Camera pitch
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraPitchDecrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraPitchDecrease])
{
mCameraDesc.Pitch += (input.IsBinaryControlDown(control, InputIndex) ? -INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraPitchIncrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraPitchIncrease])
{
mCameraDesc.Pitch += (input.IsBinaryControlDown(control, InputIndex) ? INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.CameraPitchRate))
{
mCameraDesc.Pitch += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.CameraPitchRate],
InputIndex) * INPUT_PAD_LOOK_FACTOR * dTimeMs;
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.CameraPitchDelta))
{
mCameraDesc.Pitch += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.CameraPitchDelta],
InputIndex) * INPUT_MOUSE_LOOK_FACTOR;
}
mCameraDesc.Pitch = MathHelper.Clamp(mCameraDesc.Pitch, -2.0f * MathHelper.Pi / 5.0f, 2.0f * MathHelper.Pi / 5.0f);
if (mBipedControl != null)
{
ControlBiped(input, dTimeMs);
}
}
private void ControlBiped(InputManager input, float dTimeMs)
{
// Aim pitch
float aimPitch = (float)(Math.Asin(mBipedControl.Controller.ViewDirection.Y));
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraPitchDecrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraPitchDecrease])
{
aimPitch += (input.IsBinaryControlDown(control, InputIndex) ? -INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraPitchIncrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraPitchIncrease])
{
aimPitch += (input.IsBinaryControlDown(control, InputIndex) ? INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.CameraPitchRate))
{
aimPitch += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.CameraPitchRate],
InputIndex) * INPUT_PAD_LOOK_FACTOR * dTimeMs;
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.CameraPitchDelta))
{
aimPitch += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.CameraPitchDelta],
InputIndex) * INPUT_MOUSE_LOOK_FACTOR;
}
aimPitch = MathHelper.Clamp(aimPitch, -2.0f * MathHelper.Pi / 5.0f, 2.0f * MathHelper.Pi / 5.0f);
// Aim yaw
Quaternion yawOrientationChange = Quaternion.Identity;
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
yawOrientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
yawOrientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, -INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.TurnLeftRightRate))
{
yawOrientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up,
-input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.TurnLeftRightRate],
InputIndex) * INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.TurnLeftRightDelta))
{
float fullAxisYawAmount = input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.TurnLeftRightDelta],
InputIndex);
yawOrientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, -fullAxisYawAmount * INPUT_MOUSE_LOOK_FACTOR);
}
// It's good practice to make sure floating point errors don't accumulate and change the length of our unit quaternion:
yawOrientationChange = Quaternion.Normalize(yawOrientationChange);
mBipedControl.OrientationChange = yawOrientationChange;
mBipedControl.Controller.ViewDirection = mBipedControl.Controller.HorizontalViewDirection + BEPUutilities.Vector3.Up * (float)(Math.Sin(aimPitch));
// Character movement:
Vector2 rawMovement = Vector2.Zero;
// Character movement (binary):
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveForward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveForward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(0.0f, 1.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveBackward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveBackward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(0.0f, -1.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(-1.0f, 0.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(1.0f, 0.0f);
break;
}
}
}
// Character movement (interval i.e. pad):
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.StrafeLeftRightRate))
{
rawMovement.X += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.StrafeLeftRightRate],
InputIndex);
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.MoveForwardBackwardRate))
{
rawMovement.Y += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.MoveForwardBackwardRate],
InputIndex);
}
// Character movement (full axis i.e. mouse):
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.StrafeLeftRightDelta))
{
rawMovement.X += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.StrafeLeftRightDelta],
InputIndex) * INPUT_MOUSE_MOVE_FACTOR;
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.MoveForwardBackwardDelta))
{
rawMovement.Y += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.MoveForwardBackwardDelta],
InputIndex) * INPUT_MOUSE_MOVE_FACTOR;
}
mBipedControl.HorizontalMovement = rawMovement;
// Jumping:
if (input.CheckForNewBinaryInput(ActiveInputMap, BinaryControlActions.Jump, InputIndex))
{
mBipedControl.DesiredMovementActions |= BipedControllerComponent.MovementActions.Jumping;
}
else
{
mBipedControl.DesiredMovementActions &= ~BipedControllerComponent.MovementActions.Jumping;
}
}
private void ControlFlyer(InputManager input, float dTimeMs)
{
// Rotation force
Vector3 rotationForce = Vector3.Zero;
// X (pitch)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.VehiclePitchUp))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.VehiclePitchUp])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.X += 1.0f;
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.VehiclePitchDown))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.VehiclePitchDown])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.X -= 1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.VehiclePitchRate))
{
rotationForce.X += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.VehiclePitchRate], InputIndex);
}
// Y (yaw)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.Y += 1.0f;
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.Y += -1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.TurnLeftRightRate))
{
rotationForce.Y += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.TurnLeftRightRate], InputIndex);
}
// Z (roll)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.VehicleRollLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.VehicleRollLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.Z += 1.0f;
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.VehicleRollRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.VehicleRollRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.Z += -1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.VehicleRollRate))
{
rotationForce.Z += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.VehicleRollRate], InputIndex);
}
mFlyerControl.SetRotationForce(rotationForce);
// Direct rotation
Quaternion rotation = Quaternion.Identity;
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.VehiclePitchDelta))
{
float inputAmount = input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.VehiclePitchDelta], InputIndex);
rotation *= Quaternion.CreateFromAxisAngle(Vector3.Right, inputAmount * INPUT_MOUSE_LOOK_FACTOR);
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.TurnLeftRightDelta))
{
float inputAmount = input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.TurnLeftRightDelta], InputIndex);
rotation *= Quaternion.CreateFromAxisAngle(Vector3.Up, -inputAmount * INPUT_MOUSE_LOOK_FACTOR); // Negate because we want positive axis mouse movement (usually to the right) to rotate a negative amount of radians around the up direction (turn right).
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.VehicleRollDelta))
{
float inputAmount = input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.VehicleRollDelta], InputIndex);
rotation *= Quaternion.CreateFromAxisAngle(Vector3.Forward, inputAmount * INPUT_MOUSE_LOOK_FACTOR);
}
mFlyerControl.SetDirectRotation(rotation);
// Movement force
Vector3 force = Vector3.Zero;
// Z (forward/backward)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveForward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveForward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.Z -= 1.0f; // Forward is -Z
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveBackward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveBackward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.Z += 1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.MoveForwardBackwardRate))
{
force.Z -= input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.MoveForwardBackwardRate], InputIndex); // Forward is -Z
}
// X (left/right)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.X -= 1.0f;
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.X += 1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.StrafeLeftRightRate))
{
force.X += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.StrafeLeftRightRate], InputIndex);
}
// Y (up/down)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.LevitateUp))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.LevitateUp])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.Y += 1.0f;
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.LevitateDown))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.LevitateDown])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.Y -= 1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.LevitateUpDownRate))
{
force.Y += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.LevitateUpDownRate], InputIndex);
}
mFlyerControl.SetForce(force);
}
private void ControlFlyer(InputManager input, float dTimeMs)
{
// Rotation force
Vector3 rotationForce = Vector3.Zero;
// X (pitch)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.VehiclePitchUp))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.VehiclePitchUp])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.X += 1.0f;
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.VehiclePitchDown))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.VehiclePitchDown])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.X -= 1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.VehiclePitchRate))
{
rotationForce.X += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.VehiclePitchRate], InputIndex);
}
// Y (yaw)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.Y += 1.0f;
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.Y += -1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.TurnLeftRightRate))
{
rotationForce.Y += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.TurnLeftRightRate], InputIndex);
}
// Z (roll)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.VehicleRollLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.VehicleRollLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.Z += 1.0f;
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.VehicleRollRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.VehicleRollRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rotationForce.Z += -1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.VehicleRollRate))
{
rotationForce.Z += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.VehicleRollRate], InputIndex);
}
mFlyerControl.SetRotationForce(rotationForce);
// Direct rotation
Quaternion rotation = Quaternion.Identity;
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.VehiclePitchDelta))
{
float inputAmount = input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.VehiclePitchDelta], InputIndex);
rotation *= Quaternion.CreateFromAxisAngle(Vector3.Right, inputAmount * INPUT_MOUSE_LOOK_FACTOR);
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.TurnLeftRightDelta))
{
float inputAmount = input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.TurnLeftRightDelta], InputIndex);
rotation *= Quaternion.CreateFromAxisAngle(Vector3.Up, -inputAmount * INPUT_MOUSE_LOOK_FACTOR); // Negate because we want positive axis mouse movement (usually to the right) to rotate a negative amount of radians around the up direction (turn right).
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.VehicleRollDelta))
{
float inputAmount = input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.VehicleRollDelta], InputIndex);
rotation *= Quaternion.CreateFromAxisAngle(Vector3.Forward, inputAmount * INPUT_MOUSE_LOOK_FACTOR);
}
mFlyerControl.SetDirectRotation(rotation);
// Movement force
Vector3 force = Vector3.Zero;
// Z (forward/backward)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveForward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveForward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.Z -= 1.0f; // Forward is -Z
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveBackward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveBackward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.Z += 1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.MoveForwardBackwardRate))
{
force.Z -= input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.MoveForwardBackwardRate], InputIndex); // Forward is -Z
}
// X (left/right)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.X -= 1.0f;
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.X += 1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.StrafeLeftRightRate))
{
force.X += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.StrafeLeftRightRate], InputIndex);
}
// Y (up/down)
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.LevitateUp))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.LevitateUp])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.Y += 1.0f;
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.LevitateDown))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.LevitateDown])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
force.Y -= 1.0f;
break;
}
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.LevitateUpDownRate))
{
force.Y += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.LevitateUpDownRate], InputIndex);
}
mFlyerControl.SetForce(force);
}
public override void HandleInput(GameTime gameTime, InputManager input)
{
float dTimeMs = (float)(gameTime.ElapsedGameTime.TotalMilliseconds);
// Camera yaw
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraYawDecrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraYawDecrease])
{
mCameraDesc.Yaw += (input.IsBinaryControlDown(control, InputIndex) ? -INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraYawIncrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraYawIncrease])
{
mCameraDesc.Yaw += (input.IsBinaryControlDown(control, InputIndex) ? INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.CameraYawRate))
{
mCameraDesc.Yaw -= input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.CameraYawRate],
InputIndex) * INPUT_PAD_LOOK_FACTOR * dTimeMs;
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.CameraYawDelta))
{
mCameraDesc.Yaw += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.CameraYawDelta],
InputIndex) * INPUT_MOUSE_LOOK_FACTOR;
}
mCameraDesc.Yaw = mCameraDesc.Yaw % MathHelper.TwoPi;
// Camera pitch
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraPitchDecrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraPitchDecrease])
{
mCameraDesc.Pitch += (input.IsBinaryControlDown(control, InputIndex) ? -INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraPitchIncrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraPitchIncrease])
{
mCameraDesc.Pitch += (input.IsBinaryControlDown(control, InputIndex) ? INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.CameraPitchRate))
{
mCameraDesc.Pitch += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.CameraPitchRate],
InputIndex) * INPUT_PAD_LOOK_FACTOR * dTimeMs;
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.CameraPitchDelta))
{
mCameraDesc.Pitch += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.CameraPitchDelta],
InputIndex) * INPUT_MOUSE_LOOK_FACTOR;
}
mCameraDesc.Pitch = MathHelper.Clamp(mCameraDesc.Pitch, -2.0f * MathHelper.Pi / 5.0f, 2.0f * MathHelper.Pi / 5.0f);
}
private void ControlBiped(InputManager input, float dTimeMs)
{
// Player orientation
Quaternion orientationChange = Quaternion.Identity;
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
orientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
orientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, -INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.TurnLeftRightRate))
{
orientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up,
-input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.TurnLeftRightRate],
InputIndex) * INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
float fullAxisTurnAmount = 0.0f;
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.TurnLeftRightDelta))
{
fullAxisTurnAmount += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.TurnLeftRightDelta],
InputIndex);
}
orientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, -fullAxisTurnAmount * INPUT_MOUSE_LOOK_FACTOR);
// We are collecting the pad movement before we're totally done with orientation to check for special case...
Vector2 padMovement = Vector2.Zero;
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.StrafeLeftRightRate))
{
padMovement.X += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.StrafeLeftRightRate], InputIndex);
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.MoveForwardBackwardRate))
{
padMovement.Y += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.MoveForwardBackwardRate], InputIndex);
}
// Special case for reorientation upon full axis (mouse) turn or pad movement:
if (fullAxisTurnAmount != 0.0f || padMovement.LengthSquared() > 0.0f)
{
// Bake the camera yaw into the orientation:
orientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, mCameraDesc.Yaw);
mCameraDesc.Yaw = 0.0f;
}
// It's good practice to make sure floating point errors don't accumulate and change the length of our unit quaternion:
orientationChange = Quaternion.Normalize(orientationChange);
mBipedControl.OrientationChange = orientationChange;
// Character movement:
Vector2 rawMovement = Vector2.Zero;
// Character movement (binary):
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveForward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveForward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(0.0f, 1.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveBackward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveBackward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(0.0f, -1.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(-1.0f, 0.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(1.0f, 0.0f);
break;
}
}
}
// Character movement (interval i.e. pad):
rawMovement += padMovement;
// Character movement (full axis i.e. mouse):
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.StrafeLeftRightDelta))
{
rawMovement.X += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.StrafeLeftRightDelta],
InputIndex);
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.MoveForwardBackwardDelta))
{
rawMovement.Y += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.MoveForwardBackwardDelta],
InputIndex) * INPUT_MOUSE_MOVE_FACTOR;
}
mBipedControl.HorizontalMovement = rawMovement;
bool pressConfirmed = false;
// Crouching:
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.Crouch))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.Crouch])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
pressConfirmed = true;
break;
}
}
}
if (pressConfirmed)
{
mBipedControl.DesiredMovementActions |= BipedControllerComponent.MovementActions.Crouching;
}
else
{
mBipedControl.DesiredMovementActions &= ~BipedControllerComponent.MovementActions.Crouching;
}
// Jumping:
pressConfirmed = false;
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.Jump))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.Jump])
{
if (input.IsNewBinaryControlPress(control, InputIndex))
{
pressConfirmed = true;
break;
}
}
}
if (pressConfirmed)
{
mBipedControl.DesiredMovementActions |= BipedControllerComponent.MovementActions.Jumping;
}
else
{
mBipedControl.DesiredMovementActions &= ~BipedControllerComponent.MovementActions.Jumping;
}
}
private void ControlBiped(InputManager input, float dTimeMs)
{
// Aim pitch
float aimPitch = (float)(Math.Asin(mBipedControl.Controller.ViewDirection.Y));
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraPitchDecrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraPitchDecrease])
{
aimPitch += (input.IsBinaryControlDown(control, InputIndex) ? -INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.CameraPitchIncrease))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.CameraPitchIncrease])
{
aimPitch += (input.IsBinaryControlDown(control, InputIndex) ? INPUT_PAD_LOOK_FACTOR * dTimeMs : 0.0f);
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.CameraPitchRate))
{
aimPitch += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.CameraPitchRate],
InputIndex) * INPUT_PAD_LOOK_FACTOR * dTimeMs;
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.CameraPitchDelta))
{
aimPitch += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.CameraPitchDelta],
InputIndex) * INPUT_MOUSE_LOOK_FACTOR;
}
aimPitch = MathHelper.Clamp(aimPitch, -2.0f * MathHelper.Pi / 5.0f, 2.0f * MathHelper.Pi / 5.0f);
// Aim yaw
Quaternion yawOrientationChange = Quaternion.Identity;
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
yawOrientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.TurnRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.TurnRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
yawOrientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, -INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.TurnLeftRightRate))
{
yawOrientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up,
-input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.TurnLeftRightRate],
InputIndex) * INPUT_PAD_LOOK_FACTOR * dTimeMs);
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.TurnLeftRightDelta))
{
float fullAxisYawAmount = input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.TurnLeftRightDelta],
InputIndex);
yawOrientationChange *= Quaternion.CreateFromAxisAngle(Vector3.Up, -fullAxisYawAmount * INPUT_MOUSE_LOOK_FACTOR);
}
// It's good practice to make sure floating point errors don't accumulate and change the length of our unit quaternion:
yawOrientationChange = Quaternion.Normalize(yawOrientationChange);
mBipedControl.OrientationChange = yawOrientationChange;
mBipedControl.Controller.ViewDirection = mBipedControl.Controller.HorizontalViewDirection + BEPUutilities.Vector3.Up * (float)(Math.Sin(aimPitch));
// Character movement:
Vector2 rawMovement = Vector2.Zero;
// Character movement (binary):
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveForward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveForward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(0.0f, 1.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.MoveBackward))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.MoveBackward])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(0.0f, -1.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeLeft))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeLeft])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(-1.0f, 0.0f);
break;
}
}
}
if (ActiveInputMap.BinaryMap.ContainsKey(BinaryControlActions.StrafeRight))
{
foreach (BinaryControls control in ActiveInputMap.BinaryMap[BinaryControlActions.StrafeRight])
{
if (input.IsBinaryControlDown(control, InputIndex))
{
rawMovement += new Vector2(1.0f, 0.0f);
break;
}
}
}
// Character movement (interval i.e. pad):
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.StrafeLeftRightRate))
{
rawMovement.X += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.StrafeLeftRightRate],
InputIndex);
}
if (ActiveInputMap.FullIntervalMap.ContainsKey(FullIntervalControlActions.MoveForwardBackwardRate))
{
rawMovement.Y += input.GetFullIntervalControlValue(ActiveInputMap.FullIntervalMap[FullIntervalControlActions.MoveForwardBackwardRate],
InputIndex);
}
// Character movement (full axis i.e. mouse):
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.StrafeLeftRightDelta))
{
rawMovement.X += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.StrafeLeftRightDelta],
InputIndex) * INPUT_MOUSE_MOVE_FACTOR;
}
if (ActiveInputMap.FullAxisMap.ContainsKey(FullAxisControlActions.MoveForwardBackwardDelta))
{
rawMovement.Y += input.GetFullAxisControlValue(ActiveInputMap.FullAxisMap[FullAxisControlActions.MoveForwardBackwardDelta],
InputIndex) * INPUT_MOUSE_MOVE_FACTOR;
}
mBipedControl.HorizontalMovement = rawMovement;
// Jumping:
if (input.CheckForNewBinaryInput(ActiveInputMap, BinaryControlActions.Jump, InputIndex))
{
mBipedControl.DesiredMovementActions |= BipedControllerComponent.MovementActions.Jumping;
}
else
{
mBipedControl.DesiredMovementActions &= ~BipedControllerComponent.MovementActions.Jumping;
}
}
