/// <summary>
/// Handles <see cref="GamePad.AxisDownEvent"/> when the drop down is open.
/// </summary>
private void OnGamePadAxisDown_DropDownOpen(GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, ref RoutedEventData data)
{
if (GamePad.UseAxisForDirectionalNavigation)
{
if (GamePad.DirectionalNavigationAxisX == axis || GamePad.DirectionalNavigationAxisY == axis)
{
var direction = device.GetJoystickDirectionFromAxis(axis);
switch (direction)
{
case GamePadJoystickDirection.Up:
MoveItemFocus(-1);
break;
case GamePadJoystickDirection.Down:
MoveItemFocus(1);
break;
case GamePadJoystickDirection.Left:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Left, ModifierKeys.None, ref data);
}
break;
case GamePadJoystickDirection.Right:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Right, ModifierKeys.None, ref data);
}
break;
}
data.Handled = true;
}
}
}
/// <summary>
/// Attempts to perform navigation as a result of the specified game pad button press.
/// </summary>
/// <param name="view">The view for which to perform navigation.</param>
/// <param name="device">The game pad device that raised the button press event.</param>
/// <param name="button">The button that was pressed.</param>
/// <returns><c>true</c> if navigation was performed; otherwise, <c>false</c>.</returns>
public static Boolean PerformNavigation(PresentationFoundationView view, GamePadDevice device, GamePadButton button)
{
Contract.Require(view, "view");
var element = (view.ElementWithFocus ?? view.LayoutRoot) as UIElement;
if (element == null)
return false;
if (GamePad.TabButton == button)
return PerformNavigation(view, element, FocusNavigationDirection.Next, false);
if (GamePad.ShiftTabButton == button)
return PerformNavigation(view, element, FocusNavigationDirection.Previous, false);
if (!GamePad.UseAxisForDirectionalNavigation)
{
switch (button)
{
case GamePadButton.DPadUp:
return PerformNavigation(view, element, FocusNavigationDirection.Up, false);
case GamePadButton.DPadDown:
return PerformNavigation(view, element, FocusNavigationDirection.Down, false);
case GamePadButton.DPadLeft:
return PerformNavigation(view, element, FocusNavigationDirection.Left, false);
case GamePadButton.DPadRight:
return PerformNavigation(view, element, FocusNavigationDirection.Right, false);
}
}
return false;
}
/// <summary>
/// Handles <see cref="GamePad.ButtonDownEvent"/> when the drop down is closed.
/// </summary>
private void OnGamePadButtonDown_DropDownClosed(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
IsDropDownOpen = true;
data.Handled = true;
}
else
{
switch (button)
{
case GamePadButton.LeftStickUp:
case GamePadButton.LeftStickLeft:
MoveItemSelection(-1);
data.Handled = true;
break;
case GamePadButton.LeftStickDown:
case GamePadButton.LeftStickRight:
MoveItemSelection(1);
data.Handled = true;
break;
}
}
}
/// <summary>
/// Handles <see cref="GamePad.ButtonDownEvent"/> when the drop down is closed.
/// </summary>
private void OnGamePadButtonDown_DropDownClosed(GamePadDevice device, GamePadButton button, Boolean repeat, ref RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
IsDropDownOpen = true;
data.Handled = true;
}
else
{
if (!GamePad.UseAxisForDirectionalNavigation)
{
switch (button)
{
case GamePadButton.DPadUp:
case GamePadButton.DPadLeft:
MoveItemSelection(-1);
break;
case GamePadButton.DPadDown:
case GamePadButton.DPadRight:
MoveItemSelection(1);
break;
}
data.Handled = true;
}
}
}
/// <inheritdoc/>
public override Boolean MatchesGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (PlayerIndex == AnyPlayerIndex || PlayerIndex == device.PlayerIndex)
{
return(Button == button);
}
return(base.MatchesGamePadButtonDown(device, button, repeat, data));
}
/// <summary>
/// Raises the <see cref="GamePadDisconnected"/> event.
/// </summary>
/// <param name="device">The device that was disconnected.</param>
/// <param name="playerIndex">The player index associated with the game pad.</param>
private void OnGamePadDisconnected(GamePadDevice device, Int32 playerIndex)
{
if (primaryGamePad == device)
{
primaryGamePad = null;
}
GamePadDisconnected?.Invoke(device, playerIndex);
}
/// <inheritdoc/>
protected override void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (GamePad.ConfirmButton == button && !repeat)
{
HandlePressed();
data.Handled = true;
}
base.OnGamePadButtonDown(device, button, repeat, data);
}
/// <inheritdoc/>
protected override void OnGamePadButtonUp(GamePadDevice device, GamePadButton button, RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
HandleReleased(false);
data.Handled = true;
}
base.OnGamePadButtonUp(device, button, data);
}
/// <summary>
/// Handles <see cref="GamePad.ButtonDownEvent"/> when the drop down is open.
/// </summary>
private void OnGamePadButtonDown_DropDownOpen(GamePadDevice device, GamePadButton button, Boolean repeat, ref RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
SelectFocusedItem();
IsDropDownOpen = false;
data.Handled = true;
}
else if (GamePad.CancelButton == button)
{
IsDropDownOpen = false;
data.Handled = true;
}
else if (GamePad.TabButton == button)
{
PerformTabNavigation(Key.Tab, ModifierKeys.None);
data.Handled = true;
}
else if (GamePad.ShiftTabButton == button)
{
PerformTabNavigation(Key.Tab, ModifierKeys.Shift);
data.Handled = true;
}
else
{
if (!GamePad.UseAxisForDirectionalNavigation)
{
switch (button)
{
case GamePadButton.DPadUp:
MoveItemSelection(-1);
break;
case GamePadButton.DPadDown:
MoveItemSelection(1);
break;
case GamePadButton.DPadLeft:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Left, ModifierKeys.None, ref data);
}
break;
case GamePadButton.DPadRight:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Right, ModifierKeys.None, ref data);
}
break;
}
data.Handled = true;
}
}
}
/// <inheritdoc/>
protected override void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, ref RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
var listBoxItem = ItemsControlUtil.FindContainer <ListBoxItem>(this, data.OriginalSource);
if (listBoxItem != null)
{
HandleItemClicked(listBoxItem);
data.Handled = true;
}
}
else
{
if (!GamePad.UseAxisForDirectionalNavigation)
{
switch (button)
{
case GamePadButton.DPadLeft:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Left, ModifierKeys.None, ref data);
}
data.Handled = true;
break;
case GamePadButton.DPadRight:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Right, ModifierKeys.None, ref data);
}
data.Handled = true;
break;
case GamePadButton.DPadUp:
if (SelectionMode == SelectionMode.Single)
{
MoveSelectedItem(FocusNavigationDirection.Up);
}
data.Handled = true;
break;
case GamePadButton.DPadDown:
if (SelectionMode == SelectionMode.Single)
{
MoveSelectedItem(FocusNavigationDirection.Down);
}
data.Handled = true;
break;
}
}
}
base.OnGamePadButtonDown(device, button, repeat, ref data);
}
/// <inheritdoc/>
protected override void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (IsDropDownOpen)
{
OnGamePadButtonDown_DropDownOpen(device, button, repeat, data);
}
else
{
OnGamePadButtonDown_DropDownClosed(device, button, repeat, data);
}
base.OnGamePadButtonDown(device, button, repeat, data);
}
/// <inheritdoc/>
protected override void OnGamePadAxisDown(GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, ref RoutedEventData data)
{
if (IsDropDownOpen)
{
OnGamePadAxisDown_DropDownOpen(device, axis, value, repeat, ref data);
}
else
{
OnGamePadAxisDown_DropDownClosed(device, axis, value, repeat, ref data);
}
base.OnGamePadAxisDown(device, axis, value, repeat, ref data);
}
/// <summary>
/// Handles <see cref="GamePad.ButtonDownEvent"/> when the drop down is open.
/// </summary>
private void OnGamePadButtonDown_DropDownOpen(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
SelectFocusedItem();
IsDropDownOpen = false;
data.Handled = true;
}
else if (GamePad.CancelButton == button)
{
IsDropDownOpen = false;
data.Handled = true;
}
else if (GamePad.TabButton == button)
{
PerformTabNavigation(Key.Tab, ModifierKeys.None);
data.Handled = true;
}
else if (GamePad.ShiftTabButton == button)
{
PerformTabNavigation(Key.Tab, ModifierKeys.Shift);
data.Handled = true;
}
else
{
switch (button)
{
case GamePadButton.LeftStickUp:
MoveItemFocus(-1);
data.Handled = true;
break;
case GamePadButton.LeftStickDown:
MoveItemFocus(1);
data.Handled = true;
break;
case GamePadButton.LeftStickLeft:
PART_ScrollViewer?.LineLeft();
data.Handled = true;
break;
case GamePadButton.LeftStickRight:
PART_ScrollViewer?.LineRight();
data.Handled = true;
break;
}
}
}
/// <inheritdoc/>
protected override void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
switch (button)
{
case GamePadButton.LeftStickUp:
Value += SmallChange;
data.Handled = true;
break;
case GamePadButton.LeftStickDown:
Value -= SmallChange;
data.Handled = true;
break;
}
base.OnGamePadButtonDown(device, button, repeat, data);
}
/// <inheritdoc/>
protected override void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
var listBoxItem = ItemsControlUtil.FindContainer <ListBoxItem>(this, data.OriginalSource);
if (listBoxItem != null)
{
HandleItemClicked(listBoxItem);
data.Handled = true;
}
}
else
{
switch (button)
{
case GamePadButton.LeftStickLeft:
PART_ScrollViewer?.LineLeft();
data.Handled = true;
break;
case GamePadButton.LeftStickRight:
PART_ScrollViewer?.LineRight();
data.Handled = true;
break;
case GamePadButton.LeftStickUp:
if (SelectionMode == SelectionMode.Single)
{
MoveSelectedItem(FocusNavigationDirection.Up);
}
data.Handled = true;
break;
case GamePadButton.LeftStickDown:
if (SelectionMode == SelectionMode.Single)
{
MoveSelectedItem(FocusNavigationDirection.Down);
}
data.Handled = true;
break;
}
}
base.OnGamePadButtonDown(device, button, repeat, data);
}
/// <inheritdoc/>
protected override void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (!GamePad.UseAxisForDirectionalNavigation)
{
switch (button)
{
case GamePadButton.DPadUp:
DecreaseSmall();
data.Handled = true;
break;
case GamePadButton.DPadDown:
IncreaseSmall();
data.Handled = true;
break;
}
}
base.OnGamePadButtonDown(device, button, repeat, data);
}
/// <inheritdoc/>
protected override void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, ref RoutedEventData data)
{
if (!GamePad.UseAxisForDirectionalNavigation)
{
switch (button)
{
case GamePadButton.DPadLeft:
DecreaseSmall();
data.Handled = true;
break;
case GamePadButton.DPadRight:
IncreaseSmall();
data.Handled = true;
break;
}
}
base.OnGamePadButtonDown(device, button, repeat, ref data);
}
/// <inheritdoc/>
protected override void OnGamePadAxisDown(GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, ref RoutedEventData data)
{
if (GamePad.UseAxisForDirectionalNavigation)
{
var direction = device.GetJoystickDirectionFromAxis(axis);
switch (direction)
{
case GamePadJoystickDirection.Left:
DecreaseSmall();
data.Handled = true;
break;
case GamePadJoystickDirection.Right:
IncreaseSmall();
data.Handled = true;
break;
}
}
base.OnGamePadAxisDown(device, axis, value, repeat, ref data);
}
/// <inheritdoc/>
protected override void OnGamePadAxisDown(GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, RoutedEventData data)
{
if (GamePad.UseAxisForDirectionalNavigation)
{
var direction = device.GetJoystickDirectionFromAxis(axis);
switch (direction)
{
case GamePadJoystickDirection.Up:
DecreaseSmall();
data.Handled = true;
break;
case GamePadJoystickDirection.Down:
IncreaseSmall();
data.Handled = true;
break;
}
}
base.OnGamePadAxisDown(device, axis, value, repeat, data);
}
/// <inheritdoc/>
protected override void OnGamePadAxisDown(GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, ref RoutedEventData data)
{
if (GamePad.UseAxisForDirectionalNavigation && (axis == GamePad.DirectionalNavigationAxisX || axis == GamePad.DirectionalNavigationAxisY))
{
var direction = device.GetJoystickDirectionFromAxis(axis);
switch (direction)
{
case GamePadJoystickDirection.Left:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Left, ModifierKeys.None, ref data);
}
break;
case GamePadJoystickDirection.Right:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Right, ModifierKeys.None, ref data);
}
break;
case GamePadJoystickDirection.Up:
if (SelectionMode == SelectionMode.Single)
{
MoveSelectedItem(FocusNavigationDirection.Up);
}
break;
case GamePadJoystickDirection.Down:
if (SelectionMode == SelectionMode.Single)
{
MoveSelectedItem(FocusNavigationDirection.Down);
}
break;
}
data.Handled = true;
}
base.OnGamePadAxisDown(device, axis, value, repeat, ref data);
}
/// <summary>
/// Handles <see cref="GamePad.AxisDownEvent"/> when the drop down is closed.
/// </summary>
private void OnGamePadAxisDown_DropDownClosed(GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, ref RoutedEventData data)
{
if (GamePad.UseAxisForDirectionalNavigation)
{
if (GamePad.DirectionalNavigationAxisX == axis || GamePad.DirectionalNavigationAxisY == axis)
{
var direction = device.GetJoystickDirectionFromAxis(axis);
switch (direction)
{
case GamePadJoystickDirection.Up:
case GamePadJoystickDirection.Left:
MoveItemSelection(-1);
break;
case GamePadJoystickDirection.Down:
case GamePadJoystickDirection.Right:
MoveItemSelection(1);
break;
}
data.Handled = true;
}
}
}
/// <summary> /// When overriden in a derived class, determines whether the gesture matches the specified game pad button down input event. /// </summary> /// <param name="device">The game pad device.</param> /// <param name="button">The game pad button that was pressed.</param> /// <param name="repeat">A value indicating whether this is a repeated button press.</param> /// <param name="data">The routed event metadata for this event invocation.</param> /// <returns><see langword="true"/> if the gesture matches the event; otherwise, <see langword="false"/>.</returns> public virtual Boolean MatchesGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data) => false;
/// <inheritdoc/> public override Boolean MatchesGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data) => IsValid(data.Source) ? WrappedGesture.MatchesGamePadButtonDown(device, button, repeat, data) : false;
/// <summary>
/// Raises the <see cref="E:Ultraviolet.Presentation.Input.GamePad.ButtonUp"/> attached event for the specified element.
/// </summary>
internal static void RaiseButtonUp(DependencyObject element, GamePadDevice device, GamePadButton button, RoutedEventData data)
{
var evt = EventManager.GetInvocationDelegate <UpfGamePadButtonUpEventHandler>(ButtonUpEvent);
evt?.Invoke(element, device, button, data);
}
/// <summary>
/// Raises the <see cref="E:Ultraviolet.Presentation.Input.GamePad.AxisDown"/> attached event for the specified element.
/// </summary>
internal static void RaiseAxisDown(DependencyObject element, GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, RoutedEventData data)
{
var evt = EventManager.GetInvocationDelegate <UpfGamePadAxisDownEventHandler>(AxisDownEvent);
evt?.Invoke(element, device, axis, value, repeat, data);
}
/// <summary>
/// Handles <see cref="GamePad.AxisDownEvent"/> when the drop down is closed.
/// </summary>
private void OnGamePadAxisDown_DropDownClosed(GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, RoutedEventData data)
{
if (GamePad.UseAxisForDirectionalNavigation)
{
if (GamePad.DirectionalNavigationAxisX == axis || GamePad.DirectionalNavigationAxisY == axis)
{
var direction = device.GetJoystickDirectionFromAxis(axis);
switch (direction)
{
case GamePadJoystickDirection.Up:
case GamePadJoystickDirection.Left:
MoveItemSelection(-1);
break;
case GamePadJoystickDirection.Down:
case GamePadJoystickDirection.Right:
MoveItemSelection(1);
break;
}
data.Handled = true;
}
}
}
/// <inheritdoc/>
protected override void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, ref RoutedEventData data)
{
var templatedParent = TemplatedParent as Control;
if (templatedParent == null || !templatedParent.HandlesScrolling)
{
if (!GamePad.UseAxisForDirectionalNavigation)
{
switch (button)
{
case GamePadButton.DPadUp:
HandleKeyScrolling(Key.Up, ModifierKeys.None, ref data);
break;
case GamePadButton.DPadDown:
HandleKeyScrolling(Key.Down, ModifierKeys.None, ref data);
break;
case GamePadButton.DPadLeft:
HandleKeyScrolling(Key.Left, ModifierKeys.None, ref data);
break;
case GamePadButton.DPadRight:
HandleKeyScrolling(Key.Right, ModifierKeys.None, ref data);
break;
}
data.Handled = true;
}
}
base.OnGamePadButtonDown(device, button, repeat, ref data);
}
/// <summary>
/// Raises the <see cref="E:TwistedLogik.Ultraviolet.UI.Presentation.Input.GamePad.PreviewAxisDown"/> attached event for the specified element.
/// </summary>
internal static void RaisePreviewAxisDown(DependencyObject element, GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, RoutedEventData data)
{
var evt = EventManager.GetInvocationDelegate<UpfGamePadAxisDownEventHandler>(PreviewAxisDownEvent);
evt?.Invoke(element, device, axis, value, repeat, data);
}
/// <summary>
/// Raises the AxisDown attached event for the specified element.
/// </summary>
internal static void RaiseAxisDown(DependencyObject element, GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, ref RoutedEventData data)
{
var temp = EventManager.GetInvocationDelegate<UpfGamePadAxisDownEventHandler>(AxisDownEvent);
if (temp != null)
{
temp(element, device, axis, value, repeat, ref data);
}
}
/// <summary> /// Raises the <see cref="GamePadDisconnected"/> event. /// </summary> /// <param name="device">The device that was disconnected.</param> /// <param name="playerIndex">The player index associated with the game pad.</param> private void OnGamePadDisconnected(GamePadDevice device, Int32 playerIndex) => GamePadDisconnected?.Invoke(device, playerIndex);
public GamepadHandler(int a_padID)
{
_bindings = InputManager.Instance.GamePadDefaults();
PadId = a_padID;
device = new GamePadDevice(_bindings, PadId);
}
/// <summary>
/// Handles <see cref="GamePad.ButtonDownEvent"/> when the drop down is closed.
/// </summary>
private void OnGamePadButtonDown_DropDownClosed(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
IsDropDownOpen = true;
data.Handled = true;
}
else
{
if (!GamePad.UseAxisForDirectionalNavigation)
{
switch (button)
{
case GamePadButton.DPadUp:
case GamePadButton.DPadLeft:
MoveItemSelection(-1);
break;
case GamePadButton.DPadDown:
case GamePadButton.DPadRight:
MoveItemSelection(1);
break;
}
data.Handled = true;
}
}
}
/// <summary>
/// Attempts to perform navigation as a result of the specified game pad axis press.
/// </summary>
/// <param name="view">The view for which to perform navigation.</param>
/// <param name="device">The game pad device that raised the button press event.</param>
/// <param name="axis">The axis that was pressed.</param>
/// <returns><c>true</c> if navigation was performed; otherwise, <c>false</c>.</returns>
public static Boolean PerformNavigation(PresentationFoundationView view, GamePadDevice device, GamePadAxis axis)
{
Contract.Require(view, "view");
if (GamePad.UseAxisForDirectionalNavigation)
{
var element = (view.ElementWithFocus ?? view.LayoutRoot) as UIElement;
if (element == null)
return false;
if (GamePad.DirectionalNavigationAxisX == axis || GamePad.DirectionalNavigationAxisY == axis)
{
var direction = device.GetJoystickDirectionFromAxis(axis);
var succeeded = false;
if ((direction & GamePadJoystickDirection.Up) == GamePadJoystickDirection.Up)
succeeded = succeeded || PerformNavigation(view, element, FocusNavigationDirection.Up, false);
if ((direction & GamePadJoystickDirection.Down) == GamePadJoystickDirection.Down)
succeeded = succeeded || PerformNavigation(view, element, FocusNavigationDirection.Down, false);
if ((direction & GamePadJoystickDirection.Left) == GamePadJoystickDirection.Left)
succeeded = succeeded || PerformNavigation(view, element, FocusNavigationDirection.Left, false);
if ((direction & GamePadJoystickDirection.Right) == GamePadJoystickDirection.Right)
succeeded = succeeded || PerformNavigation(view, element, FocusNavigationDirection.Right, false);
}
}
return false;
}
// Init is called on startup.
public override void Init()
{
_initCanvasWidth = Width / 100f;
_initCanvasHeight = Height / 100f;
_canvasHeight = _initCanvasHeight;
_canvasWidth = _initCanvasWidth;
// Initial "Zoom" value (it's rather the distance in view direction, not the camera's focal distance/opening angle)
_zoom = 400;
_angleRoll = 0;
_angleRollInit = 0;
_twoTouchRepeated = false;
_offset = float2.Zero;
_offsetInit = float2.Zero;
// Set the clear color for the back buffer to white (100% intensity in all color channels R, G, B, A).
RC.ClearColor = new float4(1, 1, 1, 1);
// Load the standard model
_scene = AssetStorage.Get <SceneContainer>(ModelFile);
_gui = CreateGui();
// Create the interaction handler
_sih = new SceneInteractionHandler(_gui);
// Register the input devices that are not already given.
_gamePad = GetDevice <GamePadDevice>(0);
AABBCalculator aabbc = new AABBCalculator(_scene);
var bbox = aabbc.GetBox();
if (bbox != null)
{
// If the model origin is more than one third away from its bounding box,
// recenter it to the bounding box. Do this check individually per dimension.
// This way, small deviations will keep the model's original center, while big deviations
// will make the model rotate around its geometric center.
float3 bbCenter = bbox.Value.Center;
float3 bbSize = bbox.Value.Size;
float3 center = float3.Zero;
if (System.Math.Abs(bbCenter.x) > bbSize.x * 0.3)
{
center.x = bbCenter.x;
}
if (System.Math.Abs(bbCenter.y) > bbSize.y * 0.3)
{
center.y = bbCenter.y;
}
if (System.Math.Abs(bbCenter.z) > bbSize.z * 0.3)
{
center.z = bbCenter.z;
}
_sceneCenter = float4x4.CreateTranslation(-center);
// Adjust the model size
float maxScale = System.Math.Max(bbSize.x, System.Math.Max(bbSize.y, bbSize.z));
if (maxScale != 0)
{
_sceneScale = float4x4.CreateScale(200.0f / maxScale);
}
else
{
_sceneScale = float4x4.Identity;
}
}
// Wrap a SceneRenderer around the model.
_sceneRenderer = new SceneRendererForward(_scene);
_guiRenderer = new SceneRendererForward(_gui);
}
/// <summary>
/// Raises the <see cref="E:TwistedLogik.Ultraviolet.UI.Presentation.Input.GamePad.PreviewButtonUp"/> attached event for the specified element.
/// </summary>
internal static void RaisePreviewButtonUp(DependencyObject element, GamePadDevice device, GamePadButton button, RoutedEventData data)
{
var evt = EventManager.GetInvocationDelegate<UpfGamePadButtonUpEventHandler>(PreviewButtonUpEvent);
evt?.Invoke(element, device, button, data);
}
/// <summary>
/// Invokes the <see cref="OnGamePadAxisChanged"/> method.
/// </summary>
private static void OnGamePadAxisChangedProxy(DependencyObject element, GamePadDevice device, GamePadAxis axis, Single value, RoutedEventData data)
{
((UIElement)element).OnGamePadAxisChanged(device, axis, value, data);
}
/// <summary>
/// Raises the <see cref="E:TwistedLogik.Ultraviolet.UI.Presentation.Input.GamePad.ButtonDown"/> attached event for the specified element.
/// </summary>
internal static void RaiseButtonDown(DependencyObject element, GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
var evt = EventManager.GetInvocationDelegate<UpfGamePadButtonDownEventHandler>(ButtonDownEvent);
evt?.Invoke(element, device, button, repeat, data);
}
/// <inheritdoc/>
protected override void OnGamePadAxisDown(GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, ref RoutedEventData data)
{
var templatedParent = TemplatedParent as Control;
if (templatedParent == null || !templatedParent.HandlesScrolling)
{
if (GamePad.UseAxisForDirectionalNavigation)
{
var direction = device.GetJoystickDirectionFromAxis(axis);
switch (direction)
{
case GamePadJoystickDirection.Up:
HandleKeyScrolling(Key.Up, ModifierKeys.None, ref data);
break;
case GamePadJoystickDirection.Down:
HandleKeyScrolling(Key.Down, ModifierKeys.None, ref data);
break;
case GamePadJoystickDirection.Left:
HandleKeyScrolling(Key.Left, ModifierKeys.None, ref data);
break;
case GamePadJoystickDirection.Right:
HandleKeyScrolling(Key.Right, ModifierKeys.None, ref data);
break;
}
data.Handled = true;
}
}
base.OnGamePadAxisDown(device, axis, value, repeat, ref data);
}
/// <inheritdoc/>
protected override void OnGamePadButtonUp(GamePadDevice device, GamePadButton button, RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
HandleReleased(false);
data.Handled = true;
}
base.OnGamePadButtonUp(device, button, data);
}
public GamepadHandler(int a_padID, GamePadBindings a_bindings)
{
_bindings = a_bindings;
PadId = a_padID;
device = new GamePadDevice(_bindings, PadId);
}
/// <summary>
/// Handles <see cref="GamePad.ButtonDownEvent"/> when the drop down is open.
/// </summary>
private void OnGamePadButtonDown_DropDownOpen(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
SelectFocusedItem();
IsDropDownOpen = false;
data.Handled = true;
}
else if (GamePad.CancelButton == button)
{
IsDropDownOpen = false;
data.Handled = true;
}
else if (GamePad.TabButton == button)
{
PerformTabNavigation(Key.Tab, ModifierKeys.None);
data.Handled = true;
}
else if (GamePad.ShiftTabButton == button)
{
PerformTabNavigation(Key.Tab, ModifierKeys.Shift);
data.Handled = true;
}
else
{
if (!GamePad.UseAxisForDirectionalNavigation)
{
switch (button)
{
case GamePadButton.DPadUp:
MoveItemSelection(-1);
break;
case GamePadButton.DPadDown:
MoveItemSelection(1);
break;
case GamePadButton.DPadLeft:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Left, ModifierKeys.None, data);
}
break;
case GamePadButton.DPadRight:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Right, ModifierKeys.None, data);
}
break;
}
data.Handled = true;
}
}
}
/// <summary>
/// Invokes the <see cref="OnGamePadAxisUp"/> method.
/// </summary>
private static void OnGamePadAxisUpProxy(DependencyObject element, GamePadDevice device, GamePadAxis axis, RoutedEventData data)
{
((UIElement)element).OnGamePadAxisUp(device, axis, data);
}
/// <inheritdoc/>
protected override void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (GamePad.ConfirmButton == button && !repeat)
{
HandlePressed();
data.Handled = true;
}
base.OnGamePadButtonDown(device, button, repeat, data);
}
/// <summary>
/// Invokes the <see cref="OnGamePadButtonUp"/> method.
/// </summary>
private static void OnGamePadButtonUpProxy(DependencyObject element, GamePadDevice device, GamePadButton button, RoutedEventData data)
{
((UIElement)element).OnGamePadButtonUp(device, button, data);
}
/// <summary>
/// Raises the PreviewAxisUp attached event for the specified element.
/// </summary>
internal static void RaisePreviewAxisUp(DependencyObject element, GamePadDevice device, GamePadAxis axis, ref RoutedEventData data)
{
var temp = EventManager.GetInvocationDelegate<UpfGamePadAxisUpEventHandler>(PreviewAxisUpEvent);
if (temp != null)
{
temp(element, device, axis, ref data);
}
}
/// <summary>
/// Invokes by the <see cref="GamePad.AxisDownEvent"/> attached routed event.
/// </summary>
/// <param name="device">The game pad device.</param>
/// <param name="axis">The axis that was pressed.</param>
/// <param name="value">The axis' value when it was pressed.</param>
/// <param name="repeat">A value indicating whether this is a repeated axis press.</param>
/// <param name="data">The routed event metadata for this event invocation.</param>
protected virtual void OnGamePadAxisDown(GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, RoutedEventData data)
{
}
/// <summary>
/// Raises the ButtonUp attached event for the specified element.
/// </summary>
internal static void RaiseButtonUp(DependencyObject element, GamePadDevice device, GamePadButton button, ref RoutedEventData data)
{
var temp = EventManager.GetInvocationDelegate<UpfGamePadButtonUpEventHandler>(ButtonUpEvent);
if (temp != null)
{
temp(element, device, button, ref data);
}
}
/// <summary>
/// Invokes by the <see cref="GamePad.ButtonDownEvent"/> attached routed event.
/// </summary>
/// <param name="device">The game pad device.</param>
/// <param name="button">The button that was pressed.</param>
/// <param name="repeat">A value indicating whether this is a repeated button press.</param>
/// <param name="data">The routed event metadata for this event invocation.</param>
protected virtual void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
}
/// <summary>
/// Invokes the <see cref="OnGamePadAxisDown"/> method.
/// </summary>
private static void OnGamePadAxisDownProxy(DependencyObject element, GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, RoutedEventData data)
{
((UIElement)element).OnGamePadAxisDown(device, axis, value, repeat, data);
}
/// <summary>
/// Raises the <see cref="E:TwistedLogik.Ultraviolet.UI.Presentation.Input.GamePad.AxisUp"/> attached event for the specified element.
/// </summary>
internal static void RaiseAxisUp(DependencyObject element, GamePadDevice device, GamePadAxis axis, RoutedEventData data)
{
var evt = EventManager.GetInvocationDelegate<UpfGamePadAxisUpEventHandler>(AxisUpEvent);
evt?.Invoke(element, device, axis, data);
}
/// <summary>
/// Invokes the <see cref="OnGamePadButtonDown"/> method.
/// </summary>
private static void OnGamePadButtonDownProxy(DependencyObject element, GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
((UIElement)element).OnGamePadButtonDown(device, button, repeat, data);
}
/// <inheritdoc/>
protected override void OnGamePadAxisDown(GamePadDevice device, GamePadAxis axis, Single value, Boolean repeat, RoutedEventData data)
{
if (GamePad.UseAxisForDirectionalNavigation && (axis == GamePad.DirectionalNavigationAxisX || axis == GamePad.DirectionalNavigationAxisY))
{
var direction = device.GetJoystickDirectionFromAxis(axis);
switch (direction)
{
case GamePadJoystickDirection.Left:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Left, ModifierKeys.None, data);
}
break;
case GamePadJoystickDirection.Right:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Right, ModifierKeys.None, data);
}
break;
case GamePadJoystickDirection.Up:
if (SelectionMode == SelectionMode.Single)
{
MoveSelectedItem(FocusNavigationDirection.Up);
}
break;
case GamePadJoystickDirection.Down:
if (SelectionMode == SelectionMode.Single)
{
MoveSelectedItem(FocusNavigationDirection.Down);
}
break;
}
data.Handled = true;
}
base.OnGamePadAxisDown(device, axis, value, repeat, data);
}
/// <summary>
/// Invokes by the <see cref="GamePad.AxisChangedEvent"/> attached routed event.
/// </summary>
/// <param name="device">The game pad device.</param>
/// <param name="axis">The axis that was changed.</param>
/// <param name="value">The value to which the axis was changed.</param>
/// <param name="data">The routed event metadata for this event invocation.</param>
protected virtual void OnGamePadAxisChanged(GamePadDevice device, GamePadAxis axis, Single value, RoutedEventData data)
{
}
/// <inheritdoc/>
protected override void OnGamePadButtonDown(GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
if (GamePad.ConfirmButton == button)
{
var listBoxItem = ItemsControlUtil.FindContainer<ListBoxItem>(this, data.OriginalSource);
if (listBoxItem != null)
{
HandleItemClicked(listBoxItem);
data.Handled = true;
}
}
else
{
if (!GamePad.UseAxisForDirectionalNavigation)
{
switch (button)
{
case GamePadButton.DPadLeft:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Left, ModifierKeys.None, data);
}
data.Handled = true;
break;
case GamePadButton.DPadRight:
if (PART_ScrollViewer != null)
{
PART_ScrollViewer.HandleKeyScrolling(Key.Right, ModifierKeys.None, data);
}
data.Handled = true;
break;
case GamePadButton.DPadUp:
if (SelectionMode == SelectionMode.Single)
{
MoveSelectedItem(FocusNavigationDirection.Up);
}
data.Handled = true;
break;
case GamePadButton.DPadDown:
if (SelectionMode == SelectionMode.Single)
{
MoveSelectedItem(FocusNavigationDirection.Down);
}
data.Handled = true;
break;
}
}
}
base.OnGamePadButtonDown(device, button, repeat, data);
}
/// <summary>
/// Invokes by the <see cref="GamePad.AxisUpEvent"/> attached routed event.
/// </summary>
/// <param name="device">The game pad device.</param>
/// <param name="axis">The axis that was released.</param>
/// <param name="data">The routed event metadata for this event invocation.</param>
protected virtual void OnGamePadAxisUp(GamePadDevice device, GamePadAxis axis, RoutedEventData data)
{
}
/// <summary>
/// Raises the <see cref="E:Ultraviolet.Presentation.Input.GamePad.PreviewAxisUp"/> attached event for the specified element.
/// </summary>
internal static void RaisePreviewAxisUp(DependencyObject element, GamePadDevice device, GamePadAxis axis, RoutedEventData data)
{
var evt = EventManager.GetInvocationDelegate <UpfGamePadAxisUpEventHandler>(PreviewAxisUpEvent);
evt?.Invoke(element, device, axis, data);
}
/// <summary>
/// Invokes by the <see cref="GamePad.ButtonUpEvent"/> attached routed event.
/// </summary>
/// <param name="device">The game pad device.</param>
/// <param name="button">The button that was released.</param>
/// <param name="data">The routed event metadata for this event invocation.</param>
protected virtual void OnGamePadButtonUp(GamePadDevice device, GamePadButton button, RoutedEventData data)
{
}
/// <summary>
/// Raises the <see cref="E:Ultraviolet.Presentation.Input.GamePad.PreviewAxisDown"/> attached event for the specified element.
/// </summary>
internal static void RaisePreviewButtonDown(DependencyObject element, GamePadDevice device, GamePadButton button, Boolean repeat, RoutedEventData data)
{
var evt = EventManager.GetInvocationDelegate <UpfGamePadButtonDownEventHandler>(PreviewButtonDownEvent);
evt?.Invoke(element, device, button, repeat, data);
}
