public void ConstructorTakesOverAxisCount()
{
var axes = new float[24];
var sliders = new float[8];
var buttons = new bool[128];
var povs = new int[4];
for (int count = 0; count < 24; ++count)
{
int axisBits = 0;
for (int axisIndex = 0; axisIndex < count; ++axisIndex)
{
axisBits |= (1 << axisIndex);
}
ExtendedGamePadState state = new ExtendedGamePadState(
(ExtendedAxes)axisBits, axes,
0, sliders,
0, buttons,
0, povs
);
// Only the provided axes should be reported as available by the state
Assert.AreEqual(state.AvailableAxes, (ExtendedAxes)axisBits);
Assert.AreEqual(count, state.AxisCount);
}
}
public void InvalidPovIndexCausesException(int povIndex)
{
var state = new ExtendedGamePadState();
Assert.Throws <ArgumentOutOfRangeException>(
delegate() { state.GetPov(povIndex); }
);
}
public void TestExtendedGamePadStateConversion()
{
requireAttachedJoystick();
var converter = new DirectInputConverter(this.joystick);
JoystickState joystickState = this.joystick.GetCurrentState();
var gamePadState = new ExtendedGamePadState(converter, ref joystickState);
}
public void AccessingInvalidAxisCausesException()
{
var state = new ExtendedGamePadState();
Assert.Throws <ArgumentOutOfRangeException>(
delegate() {
state.GetAxis(ExtendedAxes.X | ExtendedAxes.Y);
}
);
}
public void AccessingInvalidSliderCausesException()
{
var state = new ExtendedGamePadState();
Assert.Throws <ArgumentOutOfRangeException>(
delegate() {
state.GetSlider(ExtendedSliders.Slider1 | ExtendedSliders.Slider2);
}
);
}
public void AccessingInvalidButtonsCausesException(int buttonIndex)
{
var state = new ExtendedGamePadState();
Assert.Throws <ArgumentOutOfRangeException>(
delegate() { state.IsButtonDown(buttonIndex); }
);
Assert.Throws <ArgumentOutOfRangeException>(
delegate() { state.IsButtonUp(buttonIndex); }
);
}
public void CanConvertBetweeenDirectionalPadAndPov(
int pov, bool up, bool down, bool left, bool right
)
{
GamePadDPad dpad = new GamePadDPad(
up ? ButtonState.Pressed : ButtonState.Released,
down ? ButtonState.Pressed : ButtonState.Released,
left ? ButtonState.Pressed : ButtonState.Released,
right ? ButtonState.Pressed : ButtonState.Released
);
Assert.AreEqual(pov, ExtendedGamePadState.PovFromDpad(dpad));
Assert.AreEqual(dpad, ExtendedGamePadState.DpadFromPov(pov));
}
public void ExtendedGamePadStateCanBeConstructedFromGamePadState(Buttons button)
{
var state = new GamePadState(
new Vector2(0.12f, 0.34f),
new Vector2(0.56f, 0.78f),
0.1234f, 0.5678f,
button
);
var extendedState = new ExtendedGamePadState(ref state);
Assert.AreEqual(0.12f, extendedState.GetAxis(ExtendedAxes.X));
Assert.AreEqual(0.34f, extendedState.GetAxis(ExtendedAxes.Y));
Assert.AreEqual(0.56f, extendedState.GetAxis(ExtendedAxes.RotationX));
Assert.AreEqual(0.78f, extendedState.GetAxis(ExtendedAxes.RotationY));
Assert.AreEqual(0.1234f, extendedState.GetSlider(ExtendedSliders.Slider1));
Assert.AreEqual(0.5678f, extendedState.GetSlider(ExtendedSliders.Slider2));
switch (button)
{
case Buttons.DPadUp: {
Assert.AreEqual(0, extendedState.GetPov(0));
break;
}
case Buttons.DPadRight: {
Assert.AreEqual(9000, extendedState.GetPov(0));
break;
}
case Buttons.DPadDown: {
Assert.AreEqual(18000, extendedState.GetPov(0));
break;
}
case Buttons.DPadLeft: {
Assert.AreEqual(27000, extendedState.GetPov(0));
break;
}
default: {
Assert.IsTrue(
extendedState.IsButtonDown(
Array.IndexOf(ExtendedGamePadState.ButtonOrder, button)
)
);
break;
}
}
}
/// <summary>Updates the state of the input device</summary>
/// <remarks>
/// <para>
/// If this method is called with no snapshots in the queue, it will take
/// an immediate snapshot and make it the current state. This way, you
/// can use the input devices without caring for the snapshot system if
/// you wish.
/// </para>
/// <para>
/// If this method is called while one or more snapshots are waiting in
/// the queue, this method takes the next snapshot from the queue and makes
/// it the current state.
/// </para>
/// </remarks>
public override void Update()
{
ExtendedGamePadState previous = this.current;
if (this.states.Count == 0)
{
this.current = buildState();
}
else
{
this.current = this.states.Dequeue();
}
generateEvents(ref previous, ref this.current);
}
/// <summary>Retrieves the current state of the game pad</summary>
/// <returns>The current state of the game pad</returns>
public override GamePadState GetState()
{
ulong buttons1, buttons2;
this.current.InternalGetButtons(out buttons1, out buttons2);
return(new GamePadState(
new GamePadThumbSticks(
new Vector2(this.current.X, this.current.Y),
new Vector2(this.current.RotationX, this.current.RotationY)
),
new GamePadTriggers(this.current.Slider1, this.current.Slider2),
new GamePadButtons(ExtendedGamePadState.ButtonsFromExtendedButtons(buttons1)),
ExtendedGamePadState.DpadFromPov(this.current.Pov1)
));
}
/// <summary>Generates events for any changes to the button states</summary>
/// <param name="previous">Previous state of the game pad to compare against</param>
/// <param name="current">Current state of the game pad</param>
private void generateEvents(
ref ExtendedGamePadState previous, ref ExtendedGamePadState current
)
{
ulong previous1, previous2;
previous.InternalGetButtons(out previous1, out previous2);
ulong current1, current2;
current.InternalGetButtons(out current1, out current2);
// Determine which buttons have changed state since the last update
ulong changeMask1 = previous1 ^ current1;
ulong changeMask2 = previous2 ^ current2;
// Report any buttons that have been pressed
ulong pressed1 = current1 & changeMask1;
ulong pressed2 = current2 & changeMask2;
if ((pressed1 != 0) || (pressed2 != 0))
{
Buttons pressed = ExtendedGamePadState.ButtonsFromExtendedButtons(pressed1);
if (pressed != 0)
{
OnButtonPressed(pressed);
}
OnExtendedButtonPressed(pressed1, pressed2);
}
// Report any buttons that have been released
ulong released1 = ~current1 & changeMask1;
ulong released2 = ~current2 & changeMask2;
if ((released1 != 0) || (released2 != 0))
{
Buttons released = ExtendedGamePadState.ButtonsFromExtendedButtons(released1);
if (released != 0)
{
OnButtonReleased(released);
}
OnExtendedButtonReleased(released1, released2);
}
}
public void ConstructorTakesOverAxisStates()
{
var axes = new float[24];
var sliders = new float[8];
var buttons = new bool[128];
var povs = new int[4];
int axisIndex = 0;
foreach (ExtendedAxes axis in Enum.GetValues(typeof(ExtendedAxes)))
{
Array.Clear(axes, 0, 24);
axes[axisIndex] = 12.34f;
ExtendedGamePadState state = new ExtendedGamePadState(
axis, axes,
0, sliders,
0, buttons,
0, povs
);
// Only the provided axis should be reported as available by the state
Assert.AreEqual(state.AvailableAxes, axis);
// Ensure only the provided axis has the value assigned
foreach (ExtendedAxes axis2 in Enum.GetValues(typeof(ExtendedAxes)))
{
if (axis2 == axis)
{
Assert.AreEqual(12.34f, state.GetAxis(axis2));
}
else
{
Assert.AreEqual(0.0f, state.GetAxis(axis2));
}
}
++axisIndex;
}
}
public void ConstructorTakesOverSliderStates()
{
var axes = new float[24];
var sliders = new float[8];
var buttons = new bool[128];
var povs = new int[4];
int sliderIndex = 0;
foreach (ExtendedSliders slider in Enum.GetValues(typeof(ExtendedSliders)))
{
Array.Clear(sliders, 0, 8);
sliders[sliderIndex] = 12.34f;
ExtendedGamePadState state = new ExtendedGamePadState(
0, axes,
slider, sliders,
0, buttons,
0, povs
);
// Only the provided slider should be reported as available by the state
Assert.AreEqual(state.AvailableSliders, slider);
// Ensure only the provided slider has the value assigned
foreach (ExtendedSliders slider2 in Enum.GetValues(typeof(ExtendedSliders)))
{
if (slider2 == slider)
{
Assert.AreEqual(12.34f, state.GetSlider(slider2));
}
else
{
Assert.AreEqual(0.0f, state.GetSlider(slider2));
}
}
++sliderIndex;
}
}
public void ConstuctorTakesOverButtonStates()
{
var axes = new float[24];
var sliders = new float[8];
var buttons = new bool[128];
var povs = new int[4];
for (int buttonIndex = 0; buttonIndex < 128; ++buttonIndex)
{
Array.Clear(buttons, 0, 128);
buttons[buttonIndex] = true;
ExtendedGamePadState state = new ExtendedGamePadState(
0, axes,
0, sliders,
buttonIndex + 1, buttons,
0, povs
);
// The specified number of buttons should be available
Assert.AreEqual(state.ButtonCount, buttonIndex + 1);
// Ensure only the provided button is reported as pressed
for (int buttonIndex2 = 0; buttonIndex2 < 128; ++buttonIndex2)
{
if (buttonIndex2 == buttonIndex)
{
Assert.AreEqual(ButtonState.Pressed, state.GetButton(buttonIndex2));
Assert.IsTrue(state.IsButtonDown(buttonIndex2));
Assert.IsFalse(state.IsButtonUp(buttonIndex2));
}
else
{
Assert.AreEqual(ButtonState.Released, state.GetButton(buttonIndex2));
Assert.IsFalse(state.IsButtonDown(buttonIndex2));
Assert.IsTrue(state.IsButtonUp(buttonIndex2));
}
} // for
} // for
}
public void TestExtendedButtons()
{
var gamePad = new MockedGamePad();
gamePad.ButtonCount = 128;
for (int index = 0; index < 128; ++index)
{
ExtendedGamePadState state = gamePad.GetExtendedState();
Assert.IsFalse(state.IsButtonDown(index));
gamePad.Press(index);
gamePad.Update();
state = gamePad.GetExtendedState();
Assert.IsTrue(state.IsButtonDown(index));
gamePad.Release(index);
gamePad.Update();
state = gamePad.GetExtendedState();
Assert.IsFalse(state.IsButtonDown(index));
}
}
public void ConstructorTakesOverPovControllerStates()
{
var axes = new float[24];
var sliders = new float[8];
var buttons = new bool[128];
var povs = new int[4];
for (int povIndex = 0; povIndex < 4; ++povIndex)
{
Array.Clear(povs, 0, 4);
povs[povIndex] = 12345;
var state = new ExtendedGamePadState(
0, axes,
0, sliders,
0, buttons,
povIndex + 1, povs
);
// The specified number of PoV controllers should be available
Assert.AreEqual(state.PovCount, povIndex + 1);
// Ensure only the provided pov has the value assigned
for (int povIndex2 = 0; povIndex2 < 4; ++povIndex2)
{
if (povIndex2 == povIndex)
{
Assert.AreEqual(12345, state.GetPov(povIndex2));
}
else
{
Assert.AreEqual(0, state.GetPov(povIndex2));
}
} // for
} // for
}
/// <summary>
/// Initializes a new extended game pad state from a standard game pad state
/// </summary>
/// <param name="gamePadState">
/// Standard game pad state the extended game pad state is initialized from
/// </param>
public ExtendedGamePadState(ref GamePadState gamePadState)
{
// Axes
{
this.AvailableAxes =
ExtendedAxes.X |
ExtendedAxes.Y |
ExtendedAxes.RotationX |
ExtendedAxes.RotationY;
this.X = gamePadState.ThumbSticks.Left.X;
this.Y = gamePadState.ThumbSticks.Left.Y;
this.Z = 0.0f;
this.VelocityX = this.VelocityY = this.VelocityZ = 0.0f;
this.AccelerationX = this.AccelerationY = this.AccelerationZ = 0.0f;
this.ForceX = this.ForceY = this.ForceZ = 0.0f;
this.RotationX = gamePadState.ThumbSticks.Right.X;
this.RotationY = gamePadState.ThumbSticks.Right.Y;
this.RotationZ = 0.0f;
this.AngularVelocityX = this.AngularVelocityY = this.AngularVelocityZ = 0.0f;
this.AngularAccelerationX = 0.0f;
this.AngularAccelerationY = 0.0f;
this.AngularAccelerationZ = 0.0f;
this.TorqueX = this.TorqueY = this.TorqueZ = 0.0f;
}
// Buttons
{
this.ButtonCount = 11;
this.buttonState1 =
(gamePadState.IsButtonDown(Buttons.A) ? 1UL : 0UL) |
(gamePadState.IsButtonDown(Buttons.B) ? 2UL : 0UL) |
(gamePadState.IsButtonDown(Buttons.X) ? 4UL : 0UL) |
(gamePadState.IsButtonDown(Buttons.Y) ? 8UL : 0UL) |
(gamePadState.IsButtonDown(Buttons.LeftShoulder) ? 16UL : 0UL) |
(gamePadState.IsButtonDown(Buttons.RightShoulder) ? 32UL : 0UL) |
(gamePadState.IsButtonDown(Buttons.Back) ? 64UL : 0UL) |
(gamePadState.IsButtonDown(Buttons.Start) ? 128UL : 0UL) |
(gamePadState.IsButtonDown(Buttons.LeftStick) ? 256UL : 0UL) |
(gamePadState.IsButtonDown(Buttons.RightStick) ? 512UL : 0UL) |
(gamePadState.IsButtonDown(Buttons.BigButton) ? 1024UL : 0UL);
this.buttonState2 = 0;
}
// Sliders
{
this.AvailableSliders =
ExtendedSliders.Slider1 |
ExtendedSliders.Slider2;
this.Slider1 = gamePadState.Triggers.Left;
this.Slider2 = gamePadState.Triggers.Right;
this.VelocitySlider1 = this.VelocitySlider2 = 0.0f;
this.AccelerationSlider1 = this.AccelerationSlider2 = 0.0f;
this.ForceSlider1 = this.ForceSlider2 = 0.0f;
}
// PoVs
{
this.PovCount = 1;
this.Pov1 = ExtendedGamePadState.PovFromDpad(gamePadState.DPad);
this.Pov2 = -1;
this.Pov3 = -1;
this.Pov4 = -1;
}
}
/// <summary>Generates events for all 128 possible buttons</summary>
/// <param name="previousButtons">Previous state of all buttons</param>
/// <param name="currentButtons">Current state of all buttons</param>
private void generateAllEvents(bool[] previousButtons, bool[] currentButtons)
{
// Collect changes to the first 64 buttons
ulong pressed1 = 0, released1 = 0;
{
int count = Math.Min(this.converter.ButtonCount, 64);
for (int index = 0; index < count; ++index)
{
bool currentState = currentButtons[index];
if (previousButtons[index] != currentState)
{
if (currentState)
{
pressed1 |= 1UL << index;
}
else
{
released1 |= 1UL << index;
}
}
}
}
// Collect changes to the second 64 buttons
ulong pressed2 = 0, released2 = 0;
{
int count = Math.Min(this.converter.ButtonCount, 128);
for (int index = 64; index < count; ++index)
{
bool currentState = currentButtons[index];
if (previousButtons[index] != currentState)
{
if (currentState)
{
pressed2 |= 1UL << (index - 64);
}
else
{
released2 |= 1UL << (index - 64);
}
}
}
}
// If there are subscribers to the standard events, notify them
if (HaveEventSubscribers)
{
Buttons released = ExtendedGamePadState.ButtonsFromExtendedButtons(released1);
Buttons pressed = ExtendedGamePadState.ButtonsFromExtendedButtons(pressed1);
// If any buttons have been pressed or released, fire the corresponding events
if (released != 0)
{
OnButtonReleased(released);
}
if (pressed != 0)
{
OnButtonPressed(pressed);
}
}
// If any changes were detected, fire the corresponding events
if ((released1 != 0) || (released2 != 0))
{
OnExtendedButtonReleased(released1, released2);
}
if ((pressed1 != 0) || (pressed2 != 0))
{
OnExtendedButtonPressed(pressed1, pressed2);
}
}
/// <summary>Converts a joystick state into an XNA game pad state</summary>
/// <param name="joystickState">Joystick state that will be converted</param>
/// <returns>The equivalent XNA game pad state</returns>
internal GamePadState Convert(ref JoystickState joystickState)
{
// Read the current states of both thumb sticks
Vector2 leftThumbstick, rightThumbstick;
{
if (this.axisReaders[0] != null)
{
leftThumbstick.X = this.axisReaders[0].GetValue(ref joystickState);
}
else
{
leftThumbstick.X = 0.0f;
}
if (this.axisReaders[1] != null)
{
leftThumbstick.Y = -this.axisReaders[1].GetValue(ref joystickState);
}
else
{
leftThumbstick.Y = 0.0f;
}
if (this.axisReaders[12] != null)
{
rightThumbstick.X = this.axisReaders[12].GetValue(ref joystickState);
}
else
{
rightThumbstick.X = 0.0f;
}
if (this.axisReaders[13] != null)
{
rightThumbstick.Y = -this.axisReaders[13].GetValue(ref joystickState);
}
else
{
rightThumbstick.Y = 0.0f;
}
}
// Read the current states of the triggers
float leftTrigger, rightTrigger;
{
if (this.sliderReaders[0] != null)
{
leftTrigger = this.sliderReaders[0].GetValue(ref joystickState);
}
else
{
leftTrigger = 0.0f;
}
if (this.sliderReaders[1] != null)
{
rightTrigger = this.sliderReaders[1].GetValue(ref joystickState);
}
else
{
rightTrigger = 0.0f;
}
}
// Convert the button states
Buttons buttons = 0;
{
Buttons[] buttonOrder = ExtendedGamePadState.ButtonOrder;
bool[] buttonPressed = joystickState.GetButtons();
int count = Math.Min(buttonOrder.Length, this.buttonCount);
for (int index = 0; index < count; ++index)
{
if (buttonPressed[index])
{
buttons |= buttonOrder[index];
}
}
}
// Convert the first PoV controller into a directional pad
GamePadDPad dpad;
{
if (this.povCount > 0)
{
int[] povs = joystickState.GetPointOfViewControllers();
dpad = ExtendedGamePadState.DpadFromPov(povs[0]);
}
else
{
dpad = new GamePadDPad();
}
}
// All informations gathered, construct the game pad state
return(new GamePadState(
new GamePadThumbSticks(leftThumbstick, rightThumbstick),
new GamePadTriggers(leftTrigger, rightTrigger),
new XnaGamePadButtons(buttons),
dpad
));
}
/// <summary>Updates the state of all buttons in the mask</summary>
/// <param name="buttonMask">Mask of buttons that will be updated</param>
/// <param name="state">New state the buttons will assume</param>
private void updateButtonStates(Buttons buttonMask, bool state)
{
if ((buttonMask & Buttons.A) == Buttons.A)
{
enforceButtonCountAtLeast(1);
this.buttonStates[0] = state;
}
if ((buttonMask & Buttons.B) == Buttons.B)
{
enforceButtonCountAtLeast(2);
this.buttonStates[1] = state;
}
if ((buttonMask & Buttons.X) == Buttons.X)
{
enforceButtonCountAtLeast(3);
this.buttonStates[2] = state;
}
if ((buttonMask & Buttons.Y) == Buttons.Y)
{
enforceButtonCountAtLeast(4);
this.buttonStates[3] = state;
}
if ((buttonMask & Buttons.LeftShoulder) == Buttons.LeftShoulder)
{
enforceButtonCountAtLeast(5);
this.buttonStates[4] = state;
}
if ((buttonMask & Buttons.RightShoulder) == Buttons.RightShoulder)
{
enforceButtonCountAtLeast(6);
this.buttonStates[5] = state;
}
if ((buttonMask & Buttons.Back) == Buttons.Back)
{
enforceButtonCountAtLeast(7);
this.buttonStates[6] = state;
}
if ((buttonMask & Buttons.Start) == Buttons.Start)
{
enforceButtonCountAtLeast(8);
this.buttonStates[7] = state;
}
if ((buttonMask & Buttons.LeftStick) == Buttons.LeftStick)
{
enforceButtonCountAtLeast(9);
this.buttonStates[8] = state;
}
if ((buttonMask & Buttons.RightStick) == Buttons.RightStick)
{
enforceButtonCountAtLeast(10);
this.buttonStates[9] = state;
}
if ((buttonMask & Buttons.BigButton) == Buttons.BigButton)
{
enforceButtonCountAtLeast(11);
this.buttonStates[10] = state;
}
if ((buttonMask & Buttons.DPadUp) == Buttons.DPadUp)
{
GamePadDPad dpad = ExtendedGamePadState.DpadFromPov(this.povStates[0]);
this.povStates[0] = ExtendedGamePadState.PovFromDpad(
new GamePadDPad(ButtonState.Pressed, dpad.Down, dpad.Left, dpad.Right)
);
}
if ((buttonMask & Buttons.DPadDown) == Buttons.DPadDown)
{
GamePadDPad dpad = ExtendedGamePadState.DpadFromPov(this.povStates[0]);
this.povStates[0] = ExtendedGamePadState.PovFromDpad(
new GamePadDPad(dpad.Up, ButtonState.Pressed, dpad.Left, dpad.Right)
);
}
if ((buttonMask & Buttons.DPadLeft) == Buttons.DPadLeft)
{
GamePadDPad dpad = ExtendedGamePadState.DpadFromPov(this.povStates[0]);
this.povStates[0] = ExtendedGamePadState.PovFromDpad(
new GamePadDPad(dpad.Up, dpad.Down, ButtonState.Pressed, dpad.Right)
);
}
if ((buttonMask & Buttons.DPadRight) == Buttons.DPadRight)
{
GamePadDPad dpad = ExtendedGamePadState.DpadFromPov(this.povStates[0]);
this.povStates[0] = ExtendedGamePadState.PovFromDpad(
new GamePadDPad(dpad.Up, dpad.Down, dpad.Left, ButtonState.Pressed)
);
}
}
public void DefaultConstructorCanBeUsed()
{
var state = new ExtendedGamePadState();
Assert.IsNotNull(state); // nonsense, avoids compiler warning
}
