private bool IsButtonPressed(uint index, ButtonPressTypes type, OVRInput.Touch button)
{
if (index >= uint.MaxValue)
{
return(false);
}
var device = GetTrackedObject(GetControllerByIndex(index));
if (device)
{
var controller = touchControllers[index];
switch (type)
{
case ButtonPressTypes.Touch:
return(OVRInput.Get(button, controller));
case ButtonPressTypes.TouchDown:
return(OVRInput.GetDown(button, controller));
case ButtonPressTypes.TouchUp:
return(OVRInput.GetUp(button, controller));
}
}
return(false);
}
/// <summary>
/// checks if the given button (KeyCode) is currently in a specific pressed state (ButtonPressTypes) on the keyboard
/// also asserts that button presses are only handled for the currently active controller by comparing the controller indices
/// </summary>
/// <param name="index">unique index of the controller for which the button press is to be checked</param>
/// <param name="type">the type of press (up, down, hold)</param>
/// <param name="button">the button on the keyboard</param>
/// <returns>Returns true if the button is being pressed.</returns>
protected virtual bool IsButtonPressed(uint index, ButtonPressTypes type, KeyCode button)
{
SetupPlayer();
if (index >= uint.MaxValue)
{
return(false);
}
if (index == 1)
{
if (gazeController == null || !gazeController.selected)
{
return(false);
}
}
else
{
return(false);
}
switch (type)
{
case ButtonPressTypes.Press:
return(Input.GetKey(button));
case ButtonPressTypes.PressDown:
return(Input.GetKeyDown(button));
case ButtonPressTypes.PressUp:
return(Input.GetKeyUp(button));
}
return(false);
}
private bool IsButtonPressed(uint index, ButtonPressTypes type, ulong button)
{
if (index >= OpenVR.k_unTrackedDeviceIndexInvalid)
{
return(false);
}
var device = SteamVR_Controller.Input((int)index);
switch (type)
{
case ButtonPressTypes.Press:
return(device.GetPress(button));
case ButtonPressTypes.PressDown:
return(device.GetPressDown(button));
case ButtonPressTypes.PressUp:
return(device.GetPressUp(button));
case ButtonPressTypes.Touch:
return(device.GetTouch(button));
case ButtonPressTypes.TouchDown:
return(device.GetTouchDown(button));
case ButtonPressTypes.TouchUp:
return(device.GetTouchUp(button));
}
return(false);
}
/// <summary>
/// The GetControllerButtonState method is used to determine if the given controller button for the given press type on the given controller reference is currently taking place.
/// </summary>
/// <param name="buttonType">The type of button to check for the state of.</param>
/// <param name="pressType">The button state to check for.</param>
/// <param name="controllerReference">The reference to the controller to check the button state on.</param>
/// <returns>Returns true if the given button is in the state of the given press type on the given controller reference.</returns>
public override bool GetControllerButtonState(ButtonTypes buttonType, ButtonPressTypes pressType, VRTK_ControllerReference controllerReference)
{
uint index = VRTK_ControllerReference.GetRealIndex(controllerReference);
switch (buttonType)
{
case ButtonTypes.Trigger:
case ButtonTypes.TriggerHairline:
return(GetControllerButtonState(index, "Trigger", pressType));
case ButtonTypes.Grip:
case ButtonTypes.GripHairline:
return(GetControllerButtonState(index, "Grip", pressType));
case ButtonTypes.Touchpad:
return(GetControllerButtonState(index, "TouchpadPress", pressType));
case ButtonTypes.ButtonOne:
return(GetControllerButtonState(index, "ButtonOne", pressType));
case ButtonTypes.ButtonTwo:
return(GetControllerButtonState(index, "ButtonTwo", pressType));
case ButtonTypes.StartMenu:
return(GetControllerButtonState(index, "StartMenu", pressType));
}
return(false);
}
private static bool IsButtonPressed(uint index, ButtonPressTypes type, ulong button)
{
if (index >= uint.MaxValue)
{
return(false);
}
var device = SteamVR_Controller.Input((int)index);
switch (type)
{
case ButtonPressTypes.Press:
return(device.GetPress(button));
case ButtonPressTypes.PressDown:
return(device.GetPressDown(button));
case ButtonPressTypes.PressUp:
return(device.GetPressUp(button));
case ButtonPressTypes.Touch:
return(device.GetTouch(button));
case ButtonPressTypes.TouchDown:
return(device.GetTouchDown(button));
case ButtonPressTypes.TouchUp:
return(device.GetTouchUp(button));
}
return(false);
}
protected virtual bool MousePressType(ButtonPressTypes pressType, int buttonIndex)
{
switch (pressType)
{
case ButtonPressTypes.Press:
return(Input.GetMouseButton(buttonIndex));
case ButtonPressTypes.PressDown:
return(Input.GetMouseButtonDown(buttonIndex));
case ButtonPressTypes.PressUp:
return(Input.GetMouseButtonUp(buttonIndex));
}
return(false);
}
/// <summary>
/// The GetControllerButtonState method is used to determine if the given controller button for the given press type on the given controller reference is currently taking place.
/// </summary>
/// <param name="buttonType">The type of button to check for the state of.</param>
/// <param name="pressType">The button state to check for.</param>
/// <param name="controllerReference">The reference to the controller to check the button state on.</param>
/// <returns>Returns true if the given button is in the state of the given press type on the given controller reference.</returns>
public override bool GetControllerButtonState(ButtonTypes buttonType, ButtonPressTypes pressType, VRTK_ControllerReference controllerReference)
{
if (!VRTK_ControllerReference.IsValid(controllerReference))
{
return(false);
}
bool isRightController = (controllerReference.hand == ControllerHand.Right);
KeyCode?touchButton = VRTK_SharedMethods.GetDictionaryValue((isRightController ? rightControllerTouchKeyCodes : leftControllerTouchKeyCodes), buttonType);
KeyCode?pressButton = VRTK_SharedMethods.GetDictionaryValue((isRightController ? rightControllerPressKeyCodes : leftControllerPressKeyCodes), buttonType);
switch (buttonType)
{
case ButtonTypes.Trigger:
switch (pressType)
{
case ButtonPressTypes.Touch:
case ButtonPressTypes.TouchDown:
case ButtonPressTypes.TouchUp:
return(IsButtonPressed(pressType, touchButton, pressButton));
case ButtonPressTypes.Press:
case ButtonPressTypes.PressDown:
case ButtonPressTypes.PressUp:
return(IsMouseAliasPress(isRightController, buttonType, pressType) || IsAxisButtonPress(controllerReference, buttonType, pressType));
}
break;
case ButtonTypes.Grip:
return(IsMouseAliasPress(isRightController, buttonType, pressType) || IsAxisButtonPress(controllerReference, buttonType, pressType));
case ButtonTypes.Touchpad:
return(IsButtonPressed(pressType, touchButton, pressButton));
case ButtonTypes.ButtonOne:
return(IsButtonPressed(pressType, touchButton, pressButton));
case ButtonTypes.ButtonTwo:
return(IsButtonPressed(pressType, touchButton, pressButton));
case ButtonTypes.StartMenu:
return(IsButtonPressed(pressType, touchButton, pressButton));
}
return(false);
}
/// <summary>
/// checks if the given button (KeyCode) is currently in a specific pressed state (ButtonPressTypes) on the keyboard
/// also asserts that button presses are only handled for the currently active controller by comparing the controller indices
/// </summary>
/// <param name="index">unique index of the controller for which the button press is to be checked</param>
/// <param name="type">the type of press (up, down, hold)</param>
/// <param name="button">the button on the keyboard</param>
/// <returns></returns>
private bool IsButtonPressed(uint index, ButtonPressTypes type, KeyCode button)
{
if (index >= uint.MaxValue)
{
return(false);
}
if (index == 1)
{
if (!controllers.rightController.Selected)
{
return(false);
}
}
else if (index == 2)
{
if (!controllers.leftController.Selected)
{
return(false);
}
}
else
{
return(false);
}
switch (type)
{
case ButtonPressTypes.Press:
return(Input.GetKey(button));
case ButtonPressTypes.PressDown:
return(Input.GetKeyDown(button));
case ButtonPressTypes.PressUp:
return(Input.GetKeyUp(button));
}
return(false);
}
private bool IsButtonPressed(uint index, ButtonPressTypes type, ControllerRawButton button)
{
if (index < 0)
{
return(false);
}
var device = GetControllerInputByIndex(index);
if (device == null)
{
return(false);
}
switch (type)
{
case ButtonPressTypes.Press:
return(device.GetButton(button));
case ButtonPressTypes.PressDown:
return(device.GetButtonDown(button));
case ButtonPressTypes.PressUp:
return(device.GetButtonUp(button));
case ButtonPressTypes.Touch:
return(device.GetButton(button));
case ButtonPressTypes.TouchDown:
return(device.GetButtonDown(button));
case ButtonPressTypes.TouchUp:
return(device.GetButtonUp(button));
}
return(false);
}
protected virtual bool IsButtonPressed(ButtonPressTypes pressType, KeyCode?touchKey, KeyCode?pressKey)
{
switch (pressType)
{
case ButtonPressTypes.Touch:
return(touchKey != null && Input.GetKey((KeyCode)touchKey));
case ButtonPressTypes.TouchDown:
return(touchKey != null && Input.GetKeyDown((KeyCode)touchKey));
case ButtonPressTypes.TouchUp:
return(touchKey != null && Input.GetKeyUp((KeyCode)touchKey));
case ButtonPressTypes.Press:
return(pressKey != null && Input.GetKey((KeyCode)pressKey));
case ButtonPressTypes.PressDown:
return(pressKey != null && Input.GetKeyDown((KeyCode)pressKey));
case ButtonPressTypes.PressUp:
return(pressKey != null && Input.GetKeyUp((KeyCode)pressKey));
}
return(false);
}
/// <summary>
/// The GetControllerButtonState method is used to determine if the given controller button for the given press type on the given controller reference is currently taking place.
/// </summary>
/// <param name="buttonType">The type of button to check for the state of.</param>
/// <param name="pressType">The button state to check for.</param>
/// <param name="controllerReference">The reference to the controller to check the button state on.</param>
/// <returns>Returns true if the given button is in the state of the given press type on the given controller reference.</returns>
public override bool GetControllerButtonState(ButtonTypes buttonType, ButtonPressTypes pressType, VRTK_ControllerReference controllerReference)
{
return(false);
}
/// <summary>
/// Gets the state of the given button key mapping for the press type on the controller index.
/// </summary>
/// <param name="index">The index of the controller.</param>
/// <param name="keyMapping">The key mapping key to check.</param>
/// <param name="pressType">The type of button press to check.</param>
/// <returns>Returns true if the button state matches the given data.</returns>
protected virtual bool GetControllerButtonState(uint index, string keyMapping, ButtonPressTypes pressType)
{
KeyCode buttonCode = VRTK_SharedMethods.GetDictionaryValue(keyMappings, keyMapping, KeyCode.None);
if (pressType == ButtonPressTypes.Touch)
{
return(IsButtonPressed(index, ButtonPressTypes.Press, buttonCode));
}
else if (pressType == ButtonPressTypes.TouchDown)
{
return(IsButtonPressed(index, ButtonPressTypes.PressDown, buttonCode));
}
else if (pressType == ButtonPressTypes.TouchUp)
{
return(IsButtonPressed(index, ButtonPressTypes.PressUp, buttonCode));
}
else if (pressType == ButtonPressTypes.Press)
{
return(!IsButtonPressIgnored() && IsButtonPressed(index, ButtonPressTypes.Press, buttonCode));
}
else if (pressType == ButtonPressTypes.PressDown)
{
return(!IsButtonPressIgnored() && IsButtonPressed(index, ButtonPressTypes.PressDown, buttonCode));
}
else if (pressType == ButtonPressTypes.PressUp)
{
return(!IsButtonPressIgnored() && IsButtonPressed(index, ButtonPressTypes.PressUp, buttonCode));
}
return(false);
}
/// <summary>
/// Gets the state of the given button key mapping for the press type on the controller index.
/// </summary>
/// <param name="index">The index of the controller.</param>
/// <param name="keyMapping">The key mapping key to check.</param>
/// <param name="pressType">The type of button press to check.</param>
/// <returns>Returns true if the button state matches the given data.</returns>
protected virtual bool GetControllerButtonState(uint index, string keyMapping, ButtonPressTypes pressType)
{
if (pressType == ButtonPressTypes.Touch)
{
return(IsButtonPressed(index, ButtonPressTypes.Press, keyMappings[keyMapping]));
}
else if (pressType == ButtonPressTypes.TouchDown)
{
return(IsButtonPressed(index, ButtonPressTypes.PressDown, keyMappings[keyMapping]));
}
else if (pressType == ButtonPressTypes.TouchUp)
{
return(IsButtonPressed(index, ButtonPressTypes.PressUp, keyMappings[keyMapping]));
}
else if (pressType == ButtonPressTypes.Press)
{
return(!IsButtonPressIgnored() && IsButtonPressed(index, ButtonPressTypes.Press, keyMappings[keyMapping]));
}
else if (pressType == ButtonPressTypes.PressDown)
{
return(!IsButtonPressIgnored() && IsButtonPressed(index, ButtonPressTypes.PressDown, keyMappings[keyMapping]));
}
else if (pressType == ButtonPressTypes.PressUp)
{
return(!IsButtonPressIgnored() && IsButtonPressed(index, ButtonPressTypes.PressUp, keyMappings[keyMapping]));
}
return(false);
}
/// <summary> /// The GetControllerButtonState method is used to determine if the given controller button for the given press type on the given controller reference is currently taking place. /// </summary> /// <param name="buttonType">The type of button to check for the state of.</param> /// <param name="pressType">The button state to check for.</param> /// <param name="controllerReference">The reference to the controller to check the button state on.</param> /// <returns>Returns true if the given button is in the state of the given press type on the given controller reference.</returns> public abstract bool GetControllerButtonState(ButtonTypes buttonType, ButtonPressTypes pressType, VRTK_ControllerReference controllerReference);
protected virtual bool IsAxisButtonPress(VRTK_ControllerReference controllerReference, ButtonTypes buttonType, ButtonPressTypes pressType)
{
bool isRightController = (controllerReference.hand == ControllerHand.Right);
Vector2 axisValue = GetButtonAxis(buttonType, controllerReference);
return(IsAxisOnHandButtonPress((isRightController ? rightAxisButtonPressState : leftAxisButtonPressState), buttonType, pressType, axisValue));
}
protected virtual bool IsAxisOnHandButtonPress(Dictionary <ButtonTypes, bool> axisHandState, ButtonTypes buttonType, ButtonPressTypes pressType, Vector2 axisValue)
{
bool previousAxisState = VRTK_SharedMethods.GetDictionaryValue(axisHandState, buttonType);
if (pressType == ButtonPressTypes.PressDown && !previousAxisState)
{
bool currentAxisState = GetAxisPressState(previousAxisState, axisValue.x);
VRTK_SharedMethods.AddDictionaryValue(axisHandState, buttonType, currentAxisState, true);
return(currentAxisState);
}
if (pressType == ButtonPressTypes.PressUp && previousAxisState)
{
bool currentAxisState = GetAxisPressState(previousAxisState, axisValue.x);
VRTK_SharedMethods.AddDictionaryValue(axisHandState, buttonType, currentAxisState, true);
return(!currentAxisState);
}
return(false);
}
protected virtual bool IsMouseAliasPress(bool validController, ButtonTypes buttonType, ButtonPressTypes pressType)
{
if (validController)
{
switch (buttonType)
{
case ButtonTypes.Trigger:
return(MousePressType(pressType, 0));
case ButtonTypes.Grip:
return(MousePressType(pressType, 1));
}
}
return(false);
}
private static bool IsButtonPressed(uint index, ButtonPressTypes type, ulong button)
{
if (index >= uint.MaxValue)
{
return false;
}
var device = SteamVR_Controller.Input((int)index);
switch (type)
{
case ButtonPressTypes.Press:
return device.GetPress(button);
case ButtonPressTypes.PressDown:
return device.GetPressDown(button);
case ButtonPressTypes.PressUp:
return device.GetPressUp(button);
case ButtonPressTypes.Touch:
return device.GetTouch(button);
case ButtonPressTypes.TouchDown:
return device.GetTouchDown(button);
case ButtonPressTypes.TouchUp:
return device.GetTouchUp(button);
}
return false;
}
