コード例 #1
0
ファイル: x360ce.cpp プロジェクト: mmelnic/x360ce
extern "C" DWORD WINAPI XInputGetState(DWORD dwUserIndex, XINPUT_STATE* pState)
{
    //PrintLog("XInputGetState");
    if(g_bDisable) return ERROR_DEVICE_NOT_CONNECTED;

    if((dwUserIndex+1 > g_Devices.size() || g_Devices[dwUserIndex].passthrough) && XInputInitialize())
		return xinput.XInputGetState(dwUserIndex, pState);

    DInputDevice& device = g_Devices[dwUserIndex];
    if (!pState || !(dwUserIndex < XUSER_MAX_COUNT)) return ERROR_BAD_ARGUMENTS;

    HRESULT hr = E_FAIL;

    if(hMsgWnd == NULL) CreateMsgWnd();

    if(device.device == NULL && device.dwUserIndex == dwUserIndex)
        DeviceInitialize(device);
    if(!device.device) return ERROR_DEVICE_NOT_CONNECTED;

    //Update device state if enabled or we not use enable
    if(XInputIsEnabled.bEnabled || !XInputIsEnabled.bUseEnabled)
        hr = UpdateState(device);

#if defined(DEBUG) | defined(_DEBUG)
    PrintLog("UpdateState %d %d",dwUserIndex,hr);
#endif

    if(FAILED(hr)) return ERROR_DEVICE_NOT_CONNECTED;

    Mapping& mapping = g_Mappings[dwUserIndex];
    XINPUT_STATE& xstate = *pState;

    xstate.Gamepad.wButtons = 0;
    xstate.Gamepad.bLeftTrigger = 0;
    xstate.Gamepad.bRightTrigger = 0;
    xstate.Gamepad.sThumbLX = 0;
    xstate.Gamepad.sThumbLY = 0;
    xstate.Gamepad.sThumbRX = 0;
    xstate.Gamepad.sThumbRY = 0;

    if(!XInputIsEnabled.bEnabled && XInputIsEnabled.bUseEnabled) return ERROR_SUCCESS;

    // timestamp packet
    xstate.dwPacketNumber=GetTickCount();

    // --- Map buttons ---
    for (int i = 0; i < 10; ++i)
    {
        if (((int)mapping.Button[i] >= 0) && ButtonPressed(mapping.Button[i],device))
            xstate.Gamepad.wButtons |= buttonIDs[i];
    }

    // --- Map POV to the D-pad ---
    if (mapping.DpadPOV > 0 && mapping.PovIsButton == false)
    {
        //INT pov = POVState(mapping.DpadPOV,dwUserIndex,Gamepad[dwUserIndex].povrotation);

        int povdeg = device.state.rgdwPOV[mapping.DpadPOV-1];
        if(povdeg >= 0)
        {
            // Up-left, up, up-right, up (at 360 degrees)
            if (IN_RANGE2(povdeg,mapping.pov[GAMEPAD_DPAD_LEFT]+1,mapping.pov[GAMEPAD_DPAD_UP]) || IN_RANGE2(povdeg,0,mapping.pov[GAMEPAD_DPAD_RIGHT]-1))
                xstate.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP;

            // Up-right, right, down-right
            if (IN_RANGE(povdeg,0,mapping.pov[GAMEPAD_DPAD_DOWN]))
                xstate.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT;

            // Down-right, down, down-left
            if (IN_RANGE(povdeg,mapping.pov[GAMEPAD_DPAD_RIGHT],mapping.pov[GAMEPAD_DPAD_LEFT]))
                xstate.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN;

            // Down-left, left, up-left
            if (IN_RANGE(povdeg,mapping.pov[GAMEPAD_DPAD_DOWN],mapping.pov[GAMEPAD_DPAD_UP]))
                xstate.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT;
        }
    }
    else if(mapping.PovIsButton == true)
    {
        for (int i = 0; i < 4; ++i)
        {
            if (((int)mapping.pov[i] >= 0) && ButtonPressed(mapping.pov[i],device))
            {
                xstate.Gamepad.wButtons |= povIDs[i];
            }
        }
    }

    // Created so we can refer to each axis with an ID
    LONG axis[] =
    {
        device.state.lX,
        device.state.lY,
        device.state.lZ,
        device.state.lRx,
        device.state.lRy,
        device.state.lRz,
        0
    };
    LONG slider[] =
    {
        device.state.rglSlider[0],
        device.state.rglSlider[1]
    };

    // --- Map triggers ---
    BYTE *targetTrigger[] =
    {
        & xstate.Gamepad.bLeftTrigger,
        & xstate.Gamepad.bRightTrigger
    };

    for (size_t i = 0; i < 2; ++i)
    {
        MappingType triggerType = mapping.Trigger[i].type;

        if (triggerType == DIGITAL)
        {
            if(ButtonPressed(mapping.Trigger[i].id,device))*(targetTrigger[i]) = 255;
        }
        else
        {
            LONG *values;

            switch (triggerType)
            {
            case AXIS:
            case HAXIS:
            case CBUT:
                values = axis;
                break;

            case SLIDER:
            case HSLIDER:
                values = slider;
                break;

            default:
                values = axis;
                break;
            }

            LONG v = 0;

            if(mapping.Trigger[i].id > 0) v = values[mapping.Trigger[i].id -1];
            else v = -values[-mapping.Trigger[i].id -1] - 1;

            /* FIXME: axis negative max should be -32768
            --- v is the full range (-32767 .. +32767) that should be projected to 0...255

            --- Full ranges
            AXIS:	(	0 to 255 from -32767 to 32767) using axis
            SLIDER:	(	0 to 255 from -32767 to 32767) using slider
            ------------------------------------------------------------------------------
            --- Half ranges
            HAXIS:	(	0 to 255 from 0 to 32767) using axis
            HSLIDER:	(	0 to 255 from 0 to 32767) using slider
            */

            LONG v2=0;
            LONG offset=0;
            LONG scaling=1;

            switch (triggerType)
            {
                // Full range
            case AXIS:
            case SLIDER:
                scaling = 255;
                offset = 32767;
                break;

                // Half range
            case HAXIS:
            case HSLIDER:
            case CBUT: // add /////////////////////////////////////////////////////////
                scaling = 127;
                offset = 0;
                break;

            default:
                scaling = 1;
                offset = 0;
                break;
            }

            //v2 = (v + offset) / scaling;
            // Add deadzones
            //*(targetTrigger[i]) = (BYTE) deadzone(v2, 0, 255, device.triggerdz, 255);

            /////////////////////////////////////////////////////////////////////////////////////////
            if (triggerType == CBUT)
            {

                if (ButtonPressed(mapping.Trigger[0].but,device)
                        && ButtonPressed(mapping.Trigger[1].but,device))
                {
                    *(targetTrigger[0]) = 255;
                    *(targetTrigger[1]) = 255;
                }

                if (ButtonPressed(mapping.Trigger[0].but,device)
                        && !ButtonPressed(mapping.Trigger[1].but,device))
                {
                    v2 = (offset-v) / scaling;
                    *(targetTrigger[0]) = 255;
                    *(targetTrigger[1]) = 255 - (BYTE) deadzone(v2, 0, 255, device.triggerdz[1], 255);
                }

                if (!ButtonPressed(mapping.Trigger[0].but,device)
                        && ButtonPressed(mapping.Trigger[1].but,device))
                {
                    v2 = (offset+v) / scaling;
                    *(targetTrigger[0]) = 255 - (BYTE) deadzone(v2, 0, 255, device.triggerdz[0], 255);
                    *(targetTrigger[1]) = 255;
                }

                if (!ButtonPressed(mapping.Trigger[0].but,device)
                        && !ButtonPressed(mapping.Trigger[1].but,device))
                {
                    v2 = (offset+v) / scaling;
                    *(targetTrigger[i]) = (BYTE) deadzone(v2, 0, 255, device.triggerdz[i], 255);
                }

            }
            else
            {
                v2 = (offset+v) / scaling;
                *(targetTrigger[i]) = (BYTE) deadzone(v2, 0, 255, device.triggerdz[i], 255);
            }

            /////////////////////////////////////////////////////////////////////////////////////////
        }
    }

    // --- Map thumbsticks ---

    // Created so we can refer to each axis with an ID
    SHORT *targetAxis[4] =
    {
        & xstate.Gamepad.sThumbLX,
        & xstate.Gamepad.sThumbLY,
        & xstate.Gamepad.sThumbRX,
        & xstate.Gamepad.sThumbRY
    };

    // NOTE: Could add symbolic constants as indexers, such as
    // THUMB_LX_AXIS, THUMB_LX_POSITIVE, THUMB_LX_NEGATIVE
    if(device.axistodpad==0)
    {


        for (INT i = 0; i < 4; ++i)
        {
            LONG *values = axis;

            // Analog input
            if (mapping.Axis[i].analogType == AXIS) values = axis;

            if (mapping.Axis[i].analogType == SLIDER) values = slider;

            if (mapping.Axis[i].analogType != NONE)
            {

                if(mapping.Axis[i].id > 0 )
                {
                    SHORT val = (SHORT) values[mapping.Axis[i].id - 1];
                    *(targetAxis[i])= (SHORT) clamp(val,-32767,32767);
                }
                else if(mapping.Axis[i].id < 0 )
                {
                    SHORT val = (SHORT) -values[-mapping.Axis[i].id - 1];
                    *(targetAxis[i]) = (SHORT) clamp(val,-32767,32767);
                }
            }

            // Digital input, positive direction
            if (mapping.Axis[i].hasDigital && mapping.Axis[i].positiveButtonID >= 0)
            {

                if (ButtonPressed(mapping.Axis[i].positiveButtonID,device))
                    *(targetAxis[i]) = 32767;
            }

            // Digital input, negative direction
            if (mapping.Axis[i].hasDigital && mapping.Axis[i].negativeButtonID >= 0)
            {

                if (ButtonPressed(mapping.Axis[i].negativeButtonID,device))
                    *(targetAxis[i]) = -32767;
            }
        }
    }

    //WILDS - Axis to D-Pad
    if(device.axistodpad==1)
    {
        //PrintLog("x: %d, y: %d, z: %d",Gamepad[dwUserIndex].state.lX,Gamepad[dwUserIndex].state.lY,Gamepad[dwUserIndex].state.lZ);

        if(device.state.lX - device.a2doffset > device.a2ddeadzone)
            xstate.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT;

        if(device.state.lX - device.a2doffset < -device.a2ddeadzone)
            xstate.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT;

        if(device.state.lY - device.a2doffset < -device.a2ddeadzone)
            xstate.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP;

        if(device.state.lY - device.a2doffset > device.a2ddeadzone)
            xstate.Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN;
    }

    //WILDS END

    for (int i = 0; i < 4; ++i)
    {

        if (device.antideadzone[i])
        {
            SHORT antidz = device.antideadzone[i];
            LONG val = *(targetAxis[i]);
            SHORT direction = val > 0 ? 1 : -1;
            val = (LONG)(abs(val) / (32767 / (32767 - antidz * 1.0)) + antidz);
            val = min(val, 32767);

            if(val == device.antideadzone[i] || val == -device.antideadzone[i]) val = 0;

            *(targetAxis[i]) = (SHORT) (direction * val);
        }

        if (device.axisdeadzone[i])
        {
            SHORT dz = device.axisdeadzone[i];
            LONG val = *(targetAxis[i]);

            if((val <= dz) && (val >= -dz) ) val = 0;

            *(targetAxis[i]) = (SHORT) clamp(val,-32767,32767);
        }

        // --- Do Linears ---

        if (device.axislinear[i])
        {

            SHORT absval = (SHORT)((abs(*(targetAxis[i])) + (((32767.0 / 2.0) - (((abs((abs(*(targetAxis[i]))) - (32767.0 / 2.0)))))) * (device.axislinear[i] * 0.01))));
            *(targetAxis[i]) = *(targetAxis[i]) > 0 ? absval : -absval;
        }
    }

    return ERROR_SUCCESS;
}
コード例 #2
0
ファイル: Controller.cpp プロジェクト: samir233/x360ce
DWORD Controller::GetState(XINPUT_STATE* pState)
{
	// Passthrough?
	if (m_passthrough)
		return XInputModuleManager::Get().XInputGetState(m_passthroughindex, pState);

	if (!ControllerManager::Get().XInputEnabled())
	{
		// Clear state
		if (pState) ZeroMemory(pState, sizeof(XINPUT_STATE));
		return ERROR_SUCCESS;
	}

	HRESULT hr = UpdateState();
#if 0
	PrintLog("UpdateState %u %u", dwUserIndex, hr);
#endif

	if (FAILED(hr)) return
		ERROR_DEVICE_NOT_CONNECTED;

	pState->Gamepad.wButtons = 0;
	pState->Gamepad.bLeftTrigger = 0;
	pState->Gamepad.bRightTrigger = 0;
	pState->Gamepad.sThumbLX = 0;
	pState->Gamepad.sThumbLY = 0;
	pState->Gamepad.sThumbRX = 0;
	pState->Gamepad.sThumbRY = 0;

	// timestamp packet
	pState->dwPacketNumber = GetTickCount();


	// --- Map POV to the D-pad ---
	if (m_mapping.DpadPOV > 0 && m_mapping.PovIsButton == false)
	{
		//INT pov = POVState(m_mapping.DpadPOV,dwUserIndex,Gamepad[dwUserIndex].povrotation);

		int povdeg = m_state.rgdwPOV[m_mapping.DpadPOV - 1];
		if (povdeg >= 0)
		{
			// Up-left, up, up-right, up (at 360 degrees)
			if (IN_RANGE2(povdeg, m_mapping.pov[Config::DPAD_LEFT] + 1, m_mapping.pov[Config::DPAD_UP]) || IN_RANGE2(povdeg, 0, m_mapping.pov[Config::DPAD_RIGHT] - 1))
				pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP;

			// Up-right, right, down-right
			if (IN_RANGE(povdeg, 0, m_mapping.pov[Config::DPAD_DOWN]))
				pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT;

			// Down-right, down, down-left
			if (IN_RANGE(povdeg, m_mapping.pov[Config::DPAD_RIGHT], m_mapping.pov[Config::DPAD_LEFT]))
				pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN;

			// Down-left, left, up-left
			if (IN_RANGE(povdeg, m_mapping.pov[Config::DPAD_DOWN], m_mapping.pov[Config::DPAD_UP]))
				pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT;
		}
	}
	else if (m_mapping.PovIsButton == true)
	{
		for (int i = 0; i < _countof(m_mapping.pov); ++i)
		{
			if (ButtonPressed(m_mapping.pov[i]))
			{
				pState->Gamepad.wButtons |= Config::povIDs[i];
			}
		}
	}

	// Created so we can refer to each axis with an ID
	s32 axis[] =
	{
		m_state.lX,
		m_state.lY,
		m_state.lZ,
		m_state.lRx,
		m_state.lRy,
		m_state.lRz
	};

	s32 slider[] =
	{
		m_state.rglSlider[0],
		m_state.rglSlider[1]
	};









	// --- Map buttons ---
	if (ButtonPressed(m_mapping.guide))
		pState->Gamepad.wButtons |= 0x400;

	for (u32 i = 0; i < _countof(m_mapping.Button); ++i)
	{
		// Skip invalid mappings
		if (m_mapping.Button[i].id == 0)
			continue;

		Config::MappingType buttonType = m_mapping.Button[i].type;

		if (buttonType == Config::DIGITAL)
		{
			if (ButtonPressed(m_mapping.Button[i].id -1))
				pState->Gamepad.wButtons |= Config::buttonIDs[i];
		}
		else
		{
			s32 *values;

			switch (buttonType)
			{
			case Config::AXIS:
			case Config::HAXIS:
			case Config::CBUT:
				values = axis;
				break;

			case Config::SLIDER:
			case Config::HSLIDER:
				values = slider;
				break;

			default:
				values = axis;
				break;
			}

			s32 v = 0;

			if (m_mapping.Button[i].id > 0)
			{
				v = values[m_mapping.Button[i].id - 1];
			}
			else if (m_mapping.Button[i].id < 0)
			{
				v = -values[-m_mapping.Button[i].id - 1] - 1;
			}

			s32 v2 = 0;
			s32 offset = 0;
			s32 scaling = 1;

			switch (buttonType)
			{
				// Full range
			case Config::AXIS:
			case Config::SLIDER:
				scaling = 255;
				offset = 32767;
				break;

				// Half range
			case Config::HAXIS:
			case Config::HSLIDER:
			case Config::CBUT:
				scaling = 127;
				offset = 0;
				break;

			default:
				scaling = 1;
				offset = 0;
				break;
			}

			v2 = (offset + v) / scaling;
			if (deadzone(v2, 0, 1, m_mapping.Button[i].buttondz, 1) > 0)
			{
				pState->Gamepad.wButtons |= Config::buttonIDs[i];
			}
		}
	}

	// --- Map triggers ---
	u8 *targetTrigger[] =
	{
		&pState->Gamepad.bLeftTrigger,
		&pState->Gamepad.bRightTrigger
	};

	for (u32 i = 0; i < _countof(m_mapping.Trigger); ++i)
	{
		// Skip invalid mappings
		if (m_mapping.Trigger[i].id == 0)
			continue;

		Config::MappingType triggerType = m_mapping.Trigger[i].type;

		if (triggerType == Config::DIGITAL)
		{
			if (ButtonPressed(m_mapping.Trigger[i].id - 1))*(targetTrigger[i]) = 255;
		}
		else
		{
			s32 *values;

			switch (triggerType)
			{
			case Config::AXIS:
			case Config::HAXIS:
			case Config::CBUT:
				values = axis;
				break;

			case Config::SLIDER:
			case Config::HSLIDER:
				values = slider;
				break;

			default:
				values = axis;
				break;
			}

			s32 v = 0;

			if (m_mapping.Trigger[i].id > 0)
			{
				v = values[m_mapping.Trigger[i].id - 1];
			}
			else if (m_mapping.Trigger[i].id < 0)
			{
				v = -values[-m_mapping.Trigger[i].id - 1] - 1;
			}

			/* FIXME: axis negative max should be -32768
			--- v is the full range (-32768 .. +32767) that should be projected to 0...255

			--- Full ranges
			AXIS:	(	0 to 255 from -32768 to 32767) using axis
			SLIDER:	(	0 to 255 from -32768 to 32767) using slider
			------------------------------------------------------------------------------
			--- Half ranges
			HAXIS:	(	0 to 255 from 0 to 32767) using axis
			HSLIDER:	(	0 to 255 from 0 to 32767) using slider
			*/

			s32 v2 = 0;
			s32 offset = 0;
			s32 scaling = 1;

			switch (triggerType)
			{
				// Full range
			case Config::AXIS:
			case Config::SLIDER:
				scaling = 255;
				offset = 32767;
				break;

				// Half range
			case Config::HAXIS:
			case Config::HSLIDER:
			case Config::CBUT: // add /////////////////////////////////////////////////////////
				scaling = 127;
				offset = 0;
				break;

			default:
				scaling = 1;
				offset = 0;
				break;
			}

			//v2 = (v + offset) / scaling;
			// Add deadzones
			//*(targetTrigger[i]) = (BYTE) deadzone(v2, 0, 255, pController->triggerdz, 255);

			/////////////////////////////////////////////////////////////////////////////////////////
			if (triggerType == Config::CBUT)
			{

				if (ButtonPressed(m_mapping.Trigger[0].but)
					&& ButtonPressed(m_mapping.Trigger[1].but))
				{
					*(targetTrigger[0]) = 255;
					*(targetTrigger[1]) = 255;
				}

				if (ButtonPressed(m_mapping.Trigger[0].but)
					&& !ButtonPressed(m_mapping.Trigger[1].but))
				{
					v2 = (offset - v) / scaling;
					*(targetTrigger[0]) = 255;
					*(targetTrigger[1]) = 255 - (u8)deadzone(v2, 0, 255, m_mapping.Trigger[1].triggerdz, 255);
				}

				if (!ButtonPressed(m_mapping.Trigger[0].but)
					&& ButtonPressed(m_mapping.Trigger[1].but))
				{
					v2 = (offset + v) / scaling;
					*(targetTrigger[0]) = 255 - (u8)deadzone(v2, 0, 255, m_mapping.Trigger[0].triggerdz, 255);
					*(targetTrigger[1]) = 255;
				}

				if (!ButtonPressed(m_mapping.Trigger[0].but)
					&& !ButtonPressed(m_mapping.Trigger[1].but))
				{
					v2 = (offset + v) / scaling;
					*(targetTrigger[i]) = (u8)deadzone(v2, 0, 255, m_mapping.Trigger[i].triggerdz, 255);
				}

			}
			else
			{
				v2 = (offset + v) / scaling;
				*(targetTrigger[i]) = (u8)deadzone(v2, 0, 255, m_mapping.Trigger[i].triggerdz, 255);
			}

			/////////////////////////////////////////////////////////////////////////////////////////
		}
	}

	// --- Map thumbsticks ---

	// Created so we can refer to each axis with an ID
	SHORT *targetAxis[4] =
	{
		&pState->Gamepad.sThumbLX,
		&pState->Gamepad.sThumbLY,
		&pState->Gamepad.sThumbRX,
		&pState->Gamepad.sThumbRY
	};

	for (u32 i = 0; i < _countof(m_mapping.Axis); ++i)
	{

		if (m_mapping.Axis[i].axistodpad == 0)
		{
			// Skip invalid mappings
			if (m_mapping.Axis[i].id != 0)
			{
				u32 index = std::abs(m_mapping.Axis[i].id) - 1;
				s32 value = axis[index];

				// Analog input
				if (m_mapping.Axis[i].analogType == Config::AXIS) value = axis[index];
				if (m_mapping.Axis[i].analogType == Config::SLIDER) value = slider[index];

				if (m_mapping.Axis[i].analogType != Config::NONE)
				{
					//        [ 32768 steps | 32768 steps ]
					// DInput [ 0     32767 | 32768 65535 ] 
					// XInput [ 32768    -1 | 0     32767 ]
					//
					//int xInput = dInputValue;
					s32 xInput = value;
					s32 deadZone = (s32)m_mapping.Axis[i].axisdeadzone;
					s32 antiDeadZone = (s32)m_mapping.Axis[i].antideadzone;
					s32 linear = (s32)m_mapping.Axis[i].axislinear;
					s32 min = -32768;
					s32 max = 32767;

					bool invert = m_mapping.Axis[i].id < 0;

					// If axis should be inverted, convert [-32768;32767] -> [32767;-32768]
					if (invert) xInput = -1 - xInput;

					// The following sections expect xInput values in range [0;32767]
					// So, convert to positive: [-32768;-1] -> [32767;0]
					bool negative = xInput < 0;
					if (negative) xInput = -1 - xInput;

					// If deadzone value is set then...
					if (deadZone > 0)
					{
						if (xInput > deadZone)
						{
							// [deadZone;32767] => [0;32767];
							xInput = (s32)((float)(xInput - deadZone) / (float)(max - deadZone) * (float)max);
						}
						else
						{
							xInput = 0;
						}
					}
					// If anti-deadzone value is set then...
					if (antiDeadZone > 0)
					{
						if (xInput > 0)
						{
							// [0;32767] => [antiDeadZone;32767];
							xInput = (s32)((float)(xInput) / (float)max * (float)(max - antiDeadZone) + antiDeadZone);
						}
					}
					// If linear value is set then...
					if (linear != 0 && xInput > 0)
					{
						// [antiDeadZone;32767] => [0;32767];
						float xInputF = (float)(xInput - antiDeadZone) / (float)(max - antiDeadZone) * (float)max;
						float linearF = (float)linear / 100.f;
						xInputF = ConvertToFloat((short)xInputF);
						float x = -xInputF;
						if (linearF < 0.f) x = 1.f + x;
						float v = ((float)sqrt(1.f - x * x));
						if (linearF < 0.f) v = 1.f - v;
						xInputF = xInputF + (2.f - v - xInputF - 1.f) * abs(linearF);
						xInput = ConvertToShort(xInputF);
						// [0;32767] => [antiDeadZone;32767];
						xInput = (s32)((float)(xInput) / (float)max * (float)(max - antiDeadZone) + antiDeadZone);
					}

					// If originally negative, convert back: [32767;0] -> [-32768;-1]
					if (negative) xInput = -1 - xInput;

					*(targetAxis[i]) = (s16)clamp(xInput, min, max);
					//return (short)xInput;
				}
			}

			// Map axis to Button: Digital input, positive direction
			if (m_mapping.Axis[i].hasDigital && m_mapping.Axis[i].positiveButtonID >= 0)
			{
				if (ButtonPressed(m_mapping.Axis[i].positiveButtonID))
					*(targetAxis[i]) = 32767;
			}

			// Map axis to Button: Digital input, negative direction
			if (m_mapping.Axis[i].hasDigital && m_mapping.Axis[i].negativeButtonID >= 0)
			{
				if (ButtonPressed(m_mapping.Axis[i].negativeButtonID))
					*(targetAxis[i]) = -32768;
			}
		}
		else
		{
			//PrintLog("x: %d, y: %d, z: %d",Gamepad[dwUserIndex].state.lX,Gamepad[dwUserIndex].state.lY,Gamepad[dwUserIndex].state.lZ);

			if (m_state.lX - m_mapping.Axis[i].a2doffset > m_mapping.Axis[i].a2ddeadzone)
				pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT;

			if (m_state.lX - m_mapping.Axis[i].a2doffset < -m_mapping.Axis[i].a2ddeadzone)
				pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT;

			if (m_state.lY - m_mapping.Axis[i].a2doffset < -m_mapping.Axis[i].a2ddeadzone)
				pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP;

			if (m_state.lY - m_mapping.Axis[i].a2doffset > m_mapping.Axis[i].a2ddeadzone)
				pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN;
		}
	}

	return ERROR_SUCCESS;
}