protected override float ImpGetAxis(AxisCode axis)
{
InputControl tmp = GetInputControlAxis(_inputDevice, axis);
float aValue = 0;
float dZone = 0;
if (tmp != null)
{
AxisControl aControl = null;
if (axis == AxisCode.LeftStick_Horizontal || axis == AxisCode.RightStick_Horizontal)
{
aControl = ((Vector2Control)tmp).x;
dZone = _deadZoneThumbStick;
}
else if (axis == AxisCode.LeftStick_Vertical || axis == AxisCode.RightStick_Vertical)
{
aControl = ((Vector2Control)tmp).y;
dZone = _deadZoneThumbStick;
}
else
{
aControl = (AxisControl)tmp;
dZone = _deadZoneIndexTrigger;
}
aValue = aControl.ReadValue();
}
return(Mathf.Abs(aValue) > dZone ? aValue : 0);
}
/// <summary>
/// Class is used as help for <code>PlayerInput</code> class to better organisation with passing<br>
/// arguments to user by AxisCodeerface methods such as <code>TriggerInput</code>.
/// Use it only, if you know what it should do.</br>
/// </summary>
/// <param name="unityInputX">Name of input project settings, make sure that string exists</param>
/// <param name="code">code of axis, for single axis codes it can be only: LEFT_TRIGGER and RIGHT_TRIGGER that this class contains, so pass them to avoid exception</param>
/// <param name="deadZoneX">Deadzone of X axis</param>
public JoystickAxis(PInput input, string unityInputX, AxisCode code, float deadZoneX)
{
this.input = input;
SetCode(code);
this.unityInputX = unityInputX;
this.deadZoneX = deadZoneX;
}
public static float GetAxis(AxisCode axis)
{
XRController controller = GetXRController(axis);
if (controller != null)
{
InputControl tmp = GetInputControlAxis(controller, axis);
AxisControl aControl = null;
if (axis == AxisCode.LeftStick_Horizontal || axis == AxisCode.RightStick_Horizontal)
{
aControl = ((Vector2Control)tmp).x;
}
else if (axis == AxisCode.LeftStick_Vertical || axis == AxisCode.RightStick_Vertical)
{
aControl = ((Vector2Control)tmp).y;
}
else
{
aControl = (AxisControl)tmp;
}
return(aControl.ReadValue());
}
return(0);
}
public float GetAxis(AxisCode axis)
{
if ((int)axis < 450)
{
//TODO: Feels bad man
return(GetButton((ActionKeyCode)((int)axis)) ? 1 : 0);
}
switch (axis)
{
case AxisCode.GamepadAxisRightX:
return(CurrentState.ThumbSticks.Right.X);
case AxisCode.GamepadAxisRightY:
return(CurrentState.ThumbSticks.Right.Y);
case AxisCode.GamepadAxisLeftX:
return(CurrentState.ThumbSticks.Left.X);
case AxisCode.GamepadAxisLeftY:
return(CurrentState.ThumbSticks.Left.Y);
case AxisCode.GamepadAxisRightTrigger:
return(CurrentState.Triggers.Right);
case AxisCode.GamepadAxisLeftTrigger:
return(CurrentState.Triggers.Left);
default:
Debug.LogError("Not a Gamepad Axis");
break;
}
return(0.0f);
}
public float GetKeyY(AxisCode code)
{
// In each case, we checks if button on up or down is pressed, if user holds
// two buttons in the same time, it results zero
float result = 0;
switch (code)
{
case AxisCode.LeftStick:
result += (Input.GetKey(LeftStick_DY) ? -1 : 0) + (Input.GetKey(LeftStick_UY) ? 1 : 0);
break;
case AxisCode.RightStick:
result += (Input.GetKey(RightStick_DY) ? -1 : 0) + (Input.GetKey(RightStick_UY) ? 1 : 0);
break;
case AxisCode.Arrows:
result += (Input.GetKey(Arrows_DY) ? -1 : 0) + (Input.GetKey(Arrows_UY) ? 1 : 0);
break;
default:
throw new System.Exception("Wrong AxisCode - KeyboardSettings::GetKeyY");
}
return(result);
}
/// <summary>
/// Constructs a new <see cref="ControllerAxis"/> using the given code.
/// </summary>
/// <param name="controller">The controller's device ID.</param>
/// <param name="code">The code for the axis represented by this <see cref="ControllerAxis"/>.</param>
public ControllerAxis(int controller, AxisCode code)
{
Assert.Index(controller, Core.Input.ControllersMax);
this.controller = controller;
this.code = code;
}
public static bool Up(AxisCode input, bool firstFixedOnly = true)
{
if (checkInput || !firstFixedOnly)
{
return((axisStates[(int)input - firstAxisCodeValue] & AxisState.Up) == AxisState.Up);
}
return(false);
}
public override float GetAxis(AxisCode ac)
{
if (!_axisMapping.ContainsKey(ac))
{
return(0.0f);
}
return(Input.GetAxis(_axisMapping[ac]));
}
public void SetKey(string uniqueKeyName, AxisCode joystickAxis, TargetController targetController = TargetController.All)
{
int i = GetUniqueIndex(uniqueKeyName);
inputs[i].Type = KeyType.ControllerAxis;
inputs[i].Axis = joystickAxis;
inputs[i].targetController = targetController;
hUtility.SaveBinings(inputs);
}
void AddAxisInAxisInput(TCT_AxisInput _action, AxisCode _key)
{
if (_action.AllAxisCode.Any(n => n == AxisCode.None))
{
Debug.LogWarning("A axis is not assign. Please assign it to get an other key");
return;
}
_action.AddKey(_key);
}
private static InputControl GetInputControlAxis(XRController controller, AxisCode axis)
{
InputControl result = null;
string[] values = _toAxisControl[axis];
for (int i = 0; result == null && i < values.Length; i++)
{
result = controller.TryGetChildControl(values[i]);
}
return(result);
}
float GetRawAxis(AxisCode axis)
{
if ((int)axis < 400)
{
return(Input.GetKeyUp((KeyCode)((int)axis)) ? 1f : 0f);
}
else if ((int)axis > 500)
{
Input.GetAxisRaw(AxisLookup(axis));
}
return(0f);
}
public override float GetAxis(AxisCode ac)
{
if(!_axisMapping.ContainsKey(ac))
return 0.0f;
if(trackedObj.index == SteamVR_TrackedObject.EIndex.None)
return 0.0f;
var device = SteamVR_Controller.Input((int)trackedObj.index);
// todo: use a struct for us to define if we want to map x or y from the device.GetAxis method
return device.GetAxis(_axisMapping[ac]).x;
}
public KeyCode GetKey(AxisCode code)
{
switch (code)
{
case AxisCode.LeftTrigger:
return(LeftTrigger);
case AxisCode.RightTrigger:
return(RightTrigger);
default:
throw new System.Exception("Wrong AxisCode - KeyboardSettings::GetKey");
}
}
protected override void SetCode(AxisCode code)
{
this.code = code;
switch (code)
{
case AxisCode.LeftStick:
case AxisCode.RightStick:
case AxisCode.Arrows:
break;
default:
throw new System.Exception("JoystickDoubleAxis::SetCode::(Wrong type parameter, you should use " +
"LeftStick, RightStick or Arrows to initialize double axis)");
}
}
private string AxisLookup(AxisCode axis)
{
switch (axis)
{
case AxisCode.MouseX:
return("Mouse X");
case AxisCode.MouseY:
return("Mouse y");
default:
Debug.LogError("Not a mouse axis");
return("");
}
}
protected override float ImpGetAxis(AxisCode axis)
{
float result = 0;
if (axis == AxisCode.HorizontalDelta)
{
result = _inputDevice.delta.x.ReadValue() * _mouseSensitivity;
}
else if (axis == AxisCode.VerticalDelta)
{
result = _inputDevice.delta.y.ReadValue() * _mouseSensitivity;
}
return(result);
}
protected virtual void SetCode(AxisCode code)
{
// When user pass wrong argument then it throws excpetion
this.code = code;
switch (code)
{
case AxisCode.LeftTrigger:
case AxisCode.RightTrigger:
break;
default:
throw new System.Exception("JoystickAxis::SetCode::(Wrong code parameter, you should use " +
"LeftTrigger or RightTrigger to initialize single axis)");
}
}
public static float Axis(AxisCode input, bool firstFixedOnly = false)
{
if (!firstFixedOnly || checkInput)
{
if (settings.trackAxisStates)
{
return(axisValues[(int)input - firstAxisCodeValue]);
}
else
{
return(Input.GetAxis(((AxisCode)input).ToString()));
}
}
return(0);
}
public static bool Pressed(AxisCode input, bool firstFixedOnly = false)
{
if (!firstFixedOnly || checkInput)
{
if (settings.trackAxisStates)
{
return((axisStates[(int)input - firstAxisCodeValue] & AxisState.Pressed) == AxisState.Pressed);
}
else
{
return(Input.GetAxisRaw(((AxisCode)input).ToString()) != 0);
}
}
return(false);
}
public static float GetAxis(AxisCode _axisCode, float _sensibility = 1, float _deadZone = 0)
{
switch (_axisCode)
{
case AxisCode.MouseX:
return(MouseX(_sensibility, _deadZone));
case AxisCode.MouseY:
return(MouseY(_sensibility, _deadZone));
default:
break;
}
return(0);
}
public override float GetAxis(AxisCode ac)
{
if (!_axisMapping.ContainsKey(ac))
{
return(0.0f);
}
if (trackedObj.index == SteamVR_TrackedObject.EIndex.None)
{
return(0.0f);
}
var device = SteamVR_Controller.Input((int)trackedObj.index);
// todo: use a struct for us to define if we want to map x or y from the device.GetAxis method
return(device.GetAxis(_axisMapping[ac]).x);
}
float GetSmoothedAxis(AxisCode axis)
{
if ((int)axis < 400)
{
return(Input.GetKeyUp((KeyCode)((int)axis)) ? 1f : 0f);
}
else if ((int)axis > 500)
{
if (!LockCursor)
{
return(Input.GetAxisRaw(AxisLookup(axis)));
}
else
{
}
}
return(0f);
}
protected override float ImpGetAxis(AxisCode axis)
{
float result = 0;
//Left Stick
if (axis == AxisCode.LeftStick_Horizontal)
{
float f = _inputDevice.leftStick.right.ReadValue();
result = f > 0 ? f : -1 * _inputDevice.leftStick.left.ReadValue();
}
else if (axis == AxisCode.LeftStick_Vertical)
{
float f = _inputDevice.leftStick.up.ReadValue();
result = f > 0 ? f : -1 * _inputDevice.leftStick.down.ReadValue();
}
//Right Stick
else if (axis == AxisCode.RightStick_Horizontal)
{
float f = _inputDevice.rightStick.right.ReadValue();
result = f > 0 ? f : -1 * _inputDevice.rightStick.left.ReadValue();
}
else if (axis == AxisCode.RightStick_Vertical)
{
float f = _inputDevice.rightStick.up.ReadValue();
result = f > 0 ? f : -1 * _inputDevice.rightStick.down.ReadValue();
}
//Left Trigger
else if (axis == AxisCode.LeftTrigger)
{
result = _inputDevice.leftTrigger.ReadValue();
}
//Right Trigger
else if (axis == AxisCode.RightTrigger)
{
result = _inputDevice.rightTrigger.ReadValue();
}
return(Mathf.Abs(result) > _deadZone ? result : 0);
}
/// <summary>
/// Checks if axis is in dead zone
/// </summary>
/// <param name="code">Code of axis</param>
/// <returns>TRUE if is in dead zone, otherwise returns FALSE</returns>
public bool IsInDeadZone(AxisCode code)
{
switch (code)
{
case AxisCode.LeftStick:
return(IsInDead(leftStick.X, leftStick.DeadZoneX) && IsInDead(leftStick.Y, leftStick.DeadZoneY));
case AxisCode.RightStick:
return(IsInDead(rightStick.X, rightStick.DeadZoneX) && IsInDead(rightStick.Y, rightStick.DeadZoneY));
case AxisCode.Arrows:
return(IsInDead(arrows.X, arrows.DeadZoneX) && IsInDead(arrows.Y, arrows.DeadZoneY));
case AxisCode.LeftTrigger:
return(IsBelowDead(leftTrigger.X, leftTrigger.DeadZoneX));
case AxisCode.RightTrigger:
return(IsBelowDead(rightTrigger.X, rightTrigger.DeadZoneX));
}
return(false);
}
public override float GetAxis(AxisCode ac)
{
throw new NotImplementedException();
}
private static XRController GetXRController(AxisCode axis)
{
return(axis <= AxisCode.LeftGrip ? XRController.leftHand : XRController.rightHand);
}
public static void SetKey(string uniqueKeyName, AxisCode joystickAxis, TargetController targetController = TargetController.All)
{
hManager.Active().SetKey(uniqueKeyName, joystickAxis, targetController);
}
/// <summary>
/// Reads the current value of a controller axis.
/// </summary>
/// <param name="id">The device ID of the controller to read.</param>
/// <param name="axis">The <see cref="AxisCode"/> representing the axis to read.</param>
/// <returns>The current position value of the axis.</returns>
public short GetAxisValue(int id, AxisCode axis)
{
Assert.Index(id, Core.Input.ControllersMax);
return(coreState.Controllers[id].Axes[(int)(axis)]);
}
void RemoveAxisCode(TCT_AxisInput _axis, AxisCode _code)
{
_axis.RemoveKey(_code);
}
public JoystickDoubleAxis(PInput input, string unityInputX, string unityInputY, AxisCode code, float deadZoneX, float deadZoneY) : base(input, unityInputX, code, deadZoneX)
{
this.unityInputY = unityInputY;
this.deadZoneY = deadZoneY;
}
// get value of this axis public abstract float GetAxis(AxisCode ac);
// get value of this axis public abstract float GetAxis(AxisCode ac);
