/// <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);
        }
Beispiel #2
0
        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);
            }
        }
Beispiel #3
0
 public AxisToButton(XboxController controllerId, XboxAxis axis, ReadAxis readAxis, float deadZone)
 {
     m_ControllerId = controllerId;
     m_Axis         = axis;
     m_Readaxis     = readAxis;
     m_DeadZone     = deadZone;
 }
Beispiel #4
0
        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);
        }
Beispiel #7
0
 /// <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]);
 }
Beispiel #8
0
 public InputAxis(string name, string mouseAxis, XboxAxis xboxAxis)
 {
     setName(name);
     this.mouseAxis = mouseAxis;
     this.xboxAxis  = xboxAxis;
     isKey          = false;
     inputAxis      = this;
 }
Beispiel #9
0
 /// <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);
 }
Beispiel #10
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);
 }
Beispiel #11
0
    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));
        }
Beispiel #13
0
    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;
        }
Beispiel #16
0
    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;
        }
Beispiel #19
0
        private bool IsAxisHighlighted(XboxAxis axis, XboxAxisPosition position)
        {
            var axisImage = this.GetAxisImage(axis, position);

            if (axisImage != null)
            {
                return(axisImage.Visibility == Visibility.Visible);
            }

            return(false);
        }
Beispiel #20
0
            public PresetAxisVersionOne(XboxAxis axis, XboxAxisPosition position, string key)
            {
                if (key == null)
                {
                    throw new ArgumentNullException("key");
                }

                this.Axis        = axis;
                this.Position    = position;
                this.KeyboardKey = key;
            }
Beispiel #21
0
 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);
        }
Beispiel #23
0
    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");
    }
Beispiel #24
0
 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);
 }
Beispiel #25
0
    // 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);
            }
        }
    }
Beispiel #26
0
 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)));
    }
Beispiel #28
0
        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
        }
Beispiel #29
0
 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;
             }
         }
     }
 }
Beispiel #30
0
 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;
		}