/// <summary> Returns the float number of the specified axis from a specified controller without Unity's smoothing filter. </summary> /// <param name='axis'> An identifier for the specified Xbox axis to be tested. </param> /// <param name='controllerNumber'> An identifier for the specific controller on which to test the axis. An int between 1 and 4. </param> public static float GetAxisRaw(XboxAxis axis, int controllerNumber) { float r = 0.0f; if (OnWindowsNative()) { if (!XInputStillInCurrFrame()) { XInputUpdateAllStates(); //XInputUpdatePaticularStateRaw(controllerNumber); } GamePadState ctrlrState = XInputGetPaticularState(controllerNumber); if (axis == XboxAxis.LeftTrigger || axis == XboxAxis.RightTrigger) { r = XInputGetAxisState(ctrlrState.Triggers, axis); } else { r = XInputGetAxisState(ctrlrState.ThumbSticks, axis); } } else { string axisCode = DetermineAxisCode(axis, controllerNumber); r = Input.GetAxisRaw(axisCode); r = AdjustAxisValues(r, axis); } return(r); }
public static float convertAxisState(XboxAxis axis) { switch (axis) { case XboxAxis.LeftStickX: return(currentInput.currentState.ThumbSticks.Left.X); case XboxAxis.LeftStickY: return(currentInput.currentState.ThumbSticks.Left.Y); case XboxAxis.RightTrigger: return(currentInput.currentState.Triggers.Right); case XboxAxis.LeftTrigger: return(currentInput.currentState.Triggers.Left); case XboxAxis.RightStickX: return(currentInput.currentState.ThumbSticks.Right.X); case XboxAxis.RightStickY: return(currentInput.currentState.ThumbSticks.Right.Y); default: Debug.Log("convertAxisState(): could not find axis"); return(0); } }
public AxisToButton(XboxController controllerId, XboxAxis axis, ReadAxis readAxis, float deadZone) { m_ControllerId = controllerId; m_Axis = axis; m_Readaxis = readAxis; m_DeadZone = deadZone; }
private void HighlightAxis(XboxAxis axis) { Image minImage = this.GetAxisImage(axis, XboxAxisPosition.Min); Image maxImage = this.GetAxisImage(axis, XboxAxisPosition.Max); this.SetImageVisibility(minImage, false); this.SetImageVisibility(maxImage, false); bool isLeftStick = axis == XboxAxis.X || axis == XboxAxis.Y; int deadzone = isLeftStick ? XboxTestSlot.LeftStickDeadZone : XboxTestSlot.RightStickDeadZone; short value = this.XinputController.GetAxisState((XinputAxis)(uint)axis); if (Math.Abs((int)value) < deadzone) { return; } if (value < 0) { this.SetImageVisibility(minImage, true); } else if (value > 0) { this.SetImageVisibility(maxImage, true); } }
// >>> For Axis <<< // /// <summary> Returns the analog number of the specified axis from any controller. </summary> /// <param name='axis'> An identifier for the specified Xbox axis to be tested. </param> public static float GetAxis(XboxAxis axis) { float r = 0.0f; if(OnWindowsNative()) { if(!XInputStillInCurrFrame()) { XInputUpdateAllStates(); //XInputUpdateSingleState(); } GamePadState ctrlrState = XInputGetSingleState(); if(axis == XboxAxis.LeftTrigger || axis == XboxAxis.RightTrigger) { r = XInputGetAxisState(ctrlrState.Triggers, axis); } else { r = XInputGetAxisState(ctrlrState.ThumbSticks, axis); } } else { string axisCode = DetermineAxisCode(axis, 0); r = Input.GetAxis(axisCode); r = AdjustAxisValues(r, axis); } return r; }
private static float AdjustAxisValues(float axisValue, XboxAxis axis) { float newAxisValue = axisValue; if (OnMac()) { if (axis == XboxAxis.LeftTrigger) { newAxisValue = -newAxisValue; newAxisValue = RefactorRange(newAxisValue); } else if (axis == XboxAxis.RightTrigger) { newAxisValue = RefactorRange(newAxisValue); } else if (axis == XboxAxis.RightStickY) { newAxisValue = -newAxisValue; } } else if (OnLinux()) { if (axis == XboxAxis.RightTrigger) { newAxisValue = RefactorRange(newAxisValue); } else if (axis == XboxAxis.LeftTrigger) { newAxisValue = RefactorRange(newAxisValue); } } return(newAxisValue); }
/// <summary> /// Returns the current axis value of the controller /// </summary> /// <param name="axis">The axis on the controller to check</param> public float GetAxis(XboxAxis axis) { if (!IsConnected) { return(0.0f); } return(axis == XboxAxis.None ? 0.0f : currentAxisDict[axis]); }
public InputAxis(string name, string mouseAxis, XboxAxis xboxAxis) { setName(name); this.mouseAxis = mouseAxis; this.xboxAxis = xboxAxis; isKey = false; inputAxis = this; }
/// <summary> /// Returns the axis value on the first frame where the axis reaches its maximum absolute value /// </summary> /// <param name="axis"></param> public float GetAxisDown(XboxAxis axis) { if (!IsConnected) { return(0.0f); } return(Math.Abs(currentAxisDict[axis]) == 1 && Math.Abs(previousAxisDict[axis]) != 1 ? currentAxisDict[axis] : 0); }
/// <summary> /// Returns the current raw axis value of the controller /// </summary> /// <param name="axis">The axis on the controller to check</param> public float GetAxisRaw(XboxAxis axis) { if (!IsConnected) { return(0.0f); } return(axis == XboxAxis.None ? 0.0f : currentAxisDict[axis] != 0 ? Math.Sign(currentAxisDict[axis]) : 0.0f); }
public static AxisKey XboxAxis(XboxAxis axis) { AxisKey ak = new AxisKey(); ak.Type = ControlKeyType.Xbox; ak.xboxAxisType = XboxAxisType.axis; ak.keys.Add(axis.ToString()); return ak; }
public static bool SetAxis(uint userIndex, XboxAxis axis, XboxAxisPosition position) { if (!VirtualXboxController.IsOwned(userIndex)) { return(false); } return(VirtualXboxController.SetAxis(userIndex, axis, (short)position)); }
private Vector2 XYStick(XboxAxis xAsis, XboxController xboxController) { Vector2 output = new Vector2() { x = XCI.GetAxis(xAsis, xboxController), y = XCI.GetAxis(xAsis + 1, xboxController), }; return(output); }
/// <summary> Returns the float number of the specified axis from a specified controller without Unity's smoothing filter. </summary> /// <param name='axis'> An identifier for the specified Xbox axis to be tested. </param> /// <param name='controllerNumber'> An identifier for the specific controller on which to test the axis. </param> public static float GetAxisRaw(XboxAxis axis, int controllerNumber) { float r = 0.0f; string axisCode = DetermineAxisCode(axis, controllerNumber); r = Input.GetAxisRaw(axisCode); r = AdjustAxisValues(r, axis); return(r); }
/// <summary> Returns the float number of the specified axis from a specified controller. </summary> /// <param name='axis'> An identifier for the specified Xbox axis to be tested. </param> /// <param name='controllerNumber'> An identifier for the specific controller on which to test the axis. </param> public static float GetAxis(XboxAxis axis, int controllerNumber) { float r = 0.0f; string axisCode = DetermineAxisCode(axis, controllerNumber); r = Input.GetAxis(axisCode); r = AdjustAxisValues(r, axis); return r; }
public static AxisKey XboxAxis(XboxAxis axis) { AxisKey ak = new AxisKey(); ak.Type = ControlKeyType.Xbox; ak.xboxAxisType = XboxAxisType.axis; ak.keys.Add(axis.ToString()); return(ak); }
// >>> For Axis <<< // /// <summary> Returns the analog number of the specified axis from any controller. </summary> /// <param name='axis'> An identifier for the specified Xbox axis to be tested. </param> public static float GetAxis(XboxAxis axis) { float r = 0.0f; string axisCode = DetermineAxisCode(axis, 0); r = Input.GetAxis(axisCode); r = AdjustAxisValues(r, axis); return(r); }
// >>> For Axis <<< // /// <summary> Returns the analog number of the specified axis from any controller. </summary> /// <param name='axis'> An identifier for the specified Xbox axis to be tested. </param> public static float GetAxis(XboxAxis axis) { float r = 0.0f; string axisCode = DetermineAxisCode(axis, 0); r = Input.GetAxis(axisCode); r = AdjustAxisValues(r, axis); return r; }
private bool IsAxisHighlighted(XboxAxis axis, XboxAxisPosition position) { var axisImage = this.GetAxisImage(axis, position); if (axisImage != null) { return(axisImage.Visibility == Visibility.Visible); } return(false); }
public PresetAxisVersionOne(XboxAxis axis, XboxAxisPosition position, string key) { if (key == null) { throw new ArgumentNullException("key"); } this.Axis = axis; this.Position = position; this.KeyboardKey = key; }
public override float GetAxis(XboxAxis axis) { foreach (var source in sources) { var d = source.GetAxis(axis); if (d != 0f) { return(d); } } return(0f); }
private static float XInputGetAxisState(GamePadTriggers xiTriggers, XboxAxis xciAxis) { float stateToReturn = 0.0f; switch (xciAxis) { case XboxAxis.LeftTrigger: stateToReturn = xiTriggers.Left; break; case XboxAxis.RightTrigger: stateToReturn = xiTriggers.Right; break; default: stateToReturn = 0.0f; break; } return(stateToReturn); }
public static void AddTrigger(XboxAxis axis, string weaponName, float refreshTime, int ammo, GameObject gameObj) { //Set btnData and add it to the list UITrigger btnData; btnData.axis = axis; btnData.Gamebutton = gameObj; btnData.ammo = ammo; btnData.isAble = true; btnData.fullAmmo = ammo; buttonList.Add(btnData); gameObj.GetComponent <buttonDetails>().updateInfo(weaponName, refreshTime, ammo, false); gameObj.GetComponent <buttonDetails>().updateAxis(axis); Debug.Log("Added Trigger"); }
public static int getAmmo(XboxAxis axis) { for (int i = 0; i < buttonList.Count; i++) { if (buttonList[i] is UITrigger) { UITrigger tmp = (UITrigger)buttonList[i]; if (tmp.axis == axis) { return(tmp.ammo); } } } return(-1); }
// Update is called once per frame void Update() { if (m_playerNumber != -1) { XboxController controller = XboxController.All; XboxAxis stick = XboxAxis.LeftStickX; XboxButton activate = XboxButton.LeftBumper; switch (m_playerNumber) { case 1: controller = XboxController.First; stick = XboxAxis.LeftStickX; activate = XboxButton.LeftBumper; break; case 2: controller = XboxController.First; stick = XboxAxis.RightStickX; activate = XboxButton.RightBumper; break; case 3: controller = XboxController.Second; stick = XboxAxis.LeftStickX; activate = XboxButton.LeftBumper; break; case 4: controller = XboxController.Second; stick = XboxAxis.RightStickX; activate = XboxButton.RightBumper; break; } m_rotationVelocity += XCI.GetAxisRaw(stick, controller) * m_rotationSpeed * Time.deltaTime; Quaternion rotation = Quaternion.Euler(0, m_rotationVelocity, 0); transform.rotation *= rotation; m_rotationVelocity -= m_rotationDrag * m_rotationVelocity * Time.deltaTime; if (XCI.GetButton(activate, controller)) { m_rigidbody.AddForce(transform.forward * m_speed); } } }
public static bool getAble(XboxAxis axis) { for (int i = 0; i < buttonList.Count; i++) { if (buttonList[i] is UITrigger) { UITrigger tmp = (UITrigger)buttonList[i]; if (tmp.axis == axis) { return(tmp.isAble); } } } Debug.Log("Couldn't find, returning false"); return(false); }
private static float getAxis(string playerTag, string kbAxis, XboxAxis ctrlrAxis) { Player player = playerFromTag(playerTag); // if the player is the keyboard player (and they're using the keyboard), // have that take precedence. if (player == KB_PLAYER) { float kbAxisVal = Input.GetAxis(kbAxis); if (kbAxisVal != 0.0f) { return(kbAxisVal); } } // otherwise return the controller output return(XCI.GetAxis(ctrlrAxis, ctrlrFromPlayer(player))); }
public static float GetAxis(XboxAxis axis, XboxController controller) { #if UNITY_EDITOR int controllerNum = Ctrl2Num(controller); if (XCI.GetNumPluggedCtrlrs() >= controllerNum) { return(XCI.GetAxis(axis, controller)); } else { return(Input.GetAxis("P" + controllerNum + axis)); } #else return(XCI.GetAxis(axis, controller)); #endif }
public static void callReload(XboxAxis axis) { Debug.Log("Reloading!"); for (int i = 0; i < buttonList.Count; i++) { if (buttonList[i] is UITrigger) { UITrigger tmp = (UITrigger)buttonList[i]; if (tmp.axis == axis) { buttonDetails dets = tmp.Gamebutton.GetComponent <buttonDetails>(); dets.reload(); break; } } } }
public static int setAmmo(XboxAxis axis, int ammo) { for (int i = 0; i < buttonList.Count; i++) { if (buttonList[i] is UITrigger) { UITrigger tmp = (UITrigger)buttonList[i]; if (tmp.axis == axis) { tmp.ammo = ammo; buttonList[i] = tmp; callUpdateAmmoAmount(i, ammo); return(tmp.ammo); } } } return(-1); }
void AxisControlsXInput(int i) { XboxAxis val = myXCIAxis[i].GetXAxisValue(); float axisVal = XCI.GetAxis(val, xboxController); if (axisVal != 0) { if (s_GameManager.ShowDebug() || ShowDebug) { Debug.Log(val.ToString() + " is value of " + axisVal); } myXCIAxis[i].Execute(axisVal); } else { myXCIAxis[i].Execute0(axisVal); } }
private static float XInputGetAxisState(GamePadThumbSticks xiThumbSticks, XboxAxis xciAxis) { float stateToReturn = 0.0f; switch (xciAxis) { case XboxAxis.LeftStickX: stateToReturn = xiThumbSticks.Left.X; break; case XboxAxis.LeftStickY: stateToReturn = xiThumbSticks.Left.Y; break; case XboxAxis.RightStickX: stateToReturn = xiThumbSticks.Right.X; break; case XboxAxis.RightStickY: stateToReturn = xiThumbSticks.Right.Y; break; default: stateToReturn = 0.0f; break; } return(stateToReturn); }
public static short GetAxisValue(uint userIndex, XboxAxis axis) { switch (axis) { case XboxAxis.X: return(states[(int)userIndex - 1].AxisXValue); case XboxAxis.Y: return(states[(int)userIndex - 1].AxisYValue); case XboxAxis.Rx: return(states[(int)userIndex - 1].AxisRxValue); case XboxAxis.Ry: return(states[(int)userIndex - 1].AxisRyValue); default: throw new NotImplementedException( "Not implemented xbox axis: " + axis); } }
public static bool SetAxis(uint userIndex, XboxAxis axis, short value) { if (!VirtualXboxController.IsOwned(userIndex)) { return(false); } if (!NativeMethods.SetAxis(userIndex, (uint)axis, value)) { return(false); } switch (axis) { case XboxAxis.X: states[(int)userIndex - 1].AxisXValue = value; break; case XboxAxis.Y: states[(int)userIndex - 1].AxisYValue = value; break; case XboxAxis.Rx: states[(int)userIndex - 1].AxisRxValue = value; break; case XboxAxis.Ry: states[(int)userIndex - 1].AxisRyValue = value; break; default: throw new NotImplementedException( "Not implemented xbox axis: " + axis); } return(true); }
private static float XInputApplyDeadzone(float rawAxisValue, XboxAxis axis, XboxController controller) { float finalValue = rawAxisValue; float deadzone = 0.0f; // Find the deadzone switch(axis) { case XboxAxis.LeftStickX: deadzone = XciHandler.Instance.Deadzones.LeftStickX[(int) controller]; break; case XboxAxis.LeftStickY: deadzone = XciHandler.Instance.Deadzones.LeftStickY[(int) controller]; break; case XboxAxis.RightStickX: deadzone = XciHandler.Instance.Deadzones.RightStickX[(int) controller]; break; case XboxAxis.RightStickY: deadzone = XciHandler.Instance.Deadzones.RightStickY[(int) controller]; break; case XboxAxis.LeftTrigger: deadzone = XciHandler.Instance.Deadzones.LeftTrigger[(int) controller]; break; case XboxAxis.RightTrigger: deadzone = XciHandler.Instance.Deadzones.RightTrigger[(int) controller]; break; } // Clear axis value if less than the deadzone if(Mathf.Abs(rawAxisValue) < deadzone) { finalValue = 0.0f; } // Remap the axis value from interval [0,1] to [deadzone,1] else { finalValue = (Mathf.Abs(rawAxisValue) * (1 - deadzone)) + deadzone; finalValue = finalValue * Mathf.Sign(rawAxisValue); } return finalValue; }
private static float RefactorRange(float oldRangeValue, int ctrlrNum, XboxAxis axis) { // HACK: On OS X, Left and right trigger under OSX return 0.5 until touched // Issue #16 on Github: https://github.com/JISyed/Unity-XboxCtrlrInput/issues/16 if(XCI.OnMac()) { if(axis == XboxAxis.LeftTrigger) { switch(ctrlrNum) { case 0: { if(!XCI.XciHandler.Instance.u3dTrigger0LeftIsTouched) { if(oldRangeValue != 0.0f) { XCI.XciHandler.Instance.u3dTrigger0LeftIsTouched = true; } else { return 0.0f; } } break; } case 1: { if(!XCI.XciHandler.Instance.u3dTrigger1LeftIsTouched) { if(oldRangeValue != 0.0f) { XCI.XciHandler.Instance.u3dTrigger1LeftIsTouched = true; } else { return 0.0f; } } break; } case 2: { if(!XCI.XciHandler.Instance.u3dTrigger2LeftIsTouched) { if(oldRangeValue != 0.0f) { XCI.XciHandler.Instance.u3dTrigger2LeftIsTouched = true; } else { return 0.0f; } } break; } case 3: { if(!XCI.XciHandler.Instance.u3dTrigger3LeftIsTouched) { if(oldRangeValue != 0.0f) { XCI.XciHandler.Instance.u3dTrigger3LeftIsTouched = true; } else { return 0.0f; } } break; } case 4: { if(!XCI.XciHandler.Instance.u3dTrigger4LeftIsTouched) { if(oldRangeValue != 0.0f) { XCI.XciHandler.Instance.u3dTrigger4LeftIsTouched = true; } else { return 0.0f; } } break; } default: break; } } else if(axis == XboxAxis.RightTrigger) { switch(ctrlrNum) { case 0: { if(!XCI.XciHandler.Instance.u3dTrigger0RightIsTouched) { if(oldRangeValue != 0.0f) { XCI.XciHandler.Instance.u3dTrigger0RightIsTouched = true; } else { return 0.0f; } } break; } case 1: { if(!XCI.XciHandler.Instance.u3dTrigger1RightIsTouched) { if(oldRangeValue != 0.0f) { XCI.XciHandler.Instance.u3dTrigger1RightIsTouched = true; } else { return 0.0f; } } break; } case 2: { if(!XCI.XciHandler.Instance.u3dTrigger2RightIsTouched) { if(oldRangeValue != 0.0f) { XCI.XciHandler.Instance.u3dTrigger2RightIsTouched = true; } else { return 0.0f; } } break; } case 3: { if(!XCI.XciHandler.Instance.u3dTrigger3RightIsTouched) { if(oldRangeValue != 0.0f) { XCI.XciHandler.Instance.u3dTrigger3RightIsTouched = true; } else { return 0.0f; } } break; } case 4: { if(!XCI.XciHandler.Instance.u3dTrigger4RightIsTouched) { if(oldRangeValue != 0.0f) { XCI.XciHandler.Instance.u3dTrigger4RightIsTouched = true; } else { return 0.0f; } } break; } default: break; } } } // Assumes you want to take a number from -1 to 1 range // And turn it into a number from a 0 to 1 range return ((oldRangeValue + 1.0f) / 2.0f ); }
private static float XInputGetAxisState(GamePadTriggers xiTriggers, XboxAxis xciAxis) { float stateToReturn = 0.0f; switch(xciAxis) { case XboxAxis.LeftTrigger: stateToReturn = xiTriggers.Left; break; case XboxAxis.RightTrigger: stateToReturn = xiTriggers.Right; break; default: stateToReturn = 0.0f; break; } return stateToReturn; }
private static string DetermineAxisCode(XboxAxis axs, int ctrlrNum) { string r = ""; string sJoyCode = ctrlrNum.ToString(); string sAxisCode = ""; bool invalidCode = false; if(OnMac()) { switch(axs) { case XboxAxis.LeftStickX: sAxisCode = "X"; break; case XboxAxis.LeftStickY: sAxisCode = "Y"; break; case XboxAxis.RightStickX: sAxisCode = "3"; break; case XboxAxis.RightStickY: sAxisCode = "4"; break; case XboxAxis.LeftTrigger: sAxisCode = "5"; break; case XboxAxis.RightTrigger: sAxisCode = "6"; break; default: invalidCode = true; break; } } else if(OnLinux()) { switch(axs) { case XboxAxis.LeftStickX: sAxisCode = "X"; break; case XboxAxis.LeftStickY: sAxisCode = "Y"; break; case XboxAxis.RightStickX: sAxisCode = "4"; break; case XboxAxis.RightStickY: sAxisCode = "5"; break; case XboxAxis.LeftTrigger: sAxisCode = "3"; break; case XboxAxis.RightTrigger: sAxisCode = "6"; break; default: invalidCode = true; break; } } else { switch(axs) { case XboxAxis.LeftStickX: sAxisCode = "X"; break; case XboxAxis.LeftStickY: sAxisCode = "Y"; break; case XboxAxis.RightStickX: sAxisCode = "4"; break; case XboxAxis.RightStickY: sAxisCode = "5"; break; case XboxAxis.LeftTrigger: sAxisCode = "9"; break; case XboxAxis.RightTrigger: sAxisCode = "10"; break; default: invalidCode = true; break; } } r = "XboxAxis" + sAxisCode + "Joy" + sJoyCode; if(invalidCode) { r = ""; } return r; }
private static float AdjustAxisValues(float axisValue, XboxAxis axis) { float newAxisValue = axisValue; if(OnMac()) { if(axis == XboxAxis.LeftTrigger) { newAxisValue = -newAxisValue; newAxisValue = RefactorRange(newAxisValue); } else if(axis == XboxAxis.RightTrigger) { newAxisValue = RefactorRange(newAxisValue); } else if(axis == XboxAxis.RightStickY) { newAxisValue = -newAxisValue; } } else if(OnLinux()) { if(axis == XboxAxis.RightTrigger) { newAxisValue = RefactorRange(newAxisValue); } else if(axis == XboxAxis.LeftTrigger) { newAxisValue = RefactorRange(newAxisValue); } } return newAxisValue; }
/// <summary> /// Returns the float number of the specified axis from a specified controller without Unity's smoothing filter. /// </summary> /// <param name='axis'> /// An identifier for the specified Xbox axis to be tested. /// </param> /// <param name='controller'> /// An identifier for the specific controller on which to test the axis. /// </param> public static float GetAxisRaw(XboxAxis axis, XboxController controller) { if (controller == XboxController.All) return GetAxisRaw(axis); int controllerNumber = (int)controller; float r = 0.0f; if(OnWindowsNative()) { if(!XInputStillInCurrFrame()) { XInputUpdateAllStates(); } GamePadState ctrlrState = XInputGetPaticularState(controllerNumber); if(axis == XboxAxis.LeftTrigger || axis == XboxAxis.RightTrigger) { r = XInputGetAxisState(ctrlrState.Triggers, axis); } else { r = XInputGetAxisState(ctrlrState.ThumbSticks, axis); } } else { string axisCode = DetermineAxisCode(axis, controllerNumber); r = Input.GetAxisRaw(axisCode); r = AdjustAxisValues(r, axis, controllerNumber); } return r; }
private static float XInputGetAxisState(GamePadThumbSticks xiThumbSticks, XboxAxis xciAxis) { float stateToReturn = 0.0f; switch(xciAxis) { case XboxAxis.LeftStickX: stateToReturn = xiThumbSticks.Left.X; break; case XboxAxis.LeftStickY: stateToReturn = xiThumbSticks.Left.Y; break; case XboxAxis.RightStickX: stateToReturn = xiThumbSticks.Right.X; break; case XboxAxis.RightStickY: stateToReturn = xiThumbSticks.Right.Y; break; default: stateToReturn = 0.0f; break; } return stateToReturn; }