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 }