239 lines
7.0 KiB
C++
239 lines
7.0 KiB
C++
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions
|
|
// are met:
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above copyright
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
// documentation and/or other materials provided with the distribution.
|
|
// * Neither the name of NVIDIA CORPORATION nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// Copyright (c) 2018 NVIDIA Corporation. All rights reserved.
|
|
|
|
#include "SampleViewerGamepad.h"
|
|
#include "SampleViewerScene.h"
|
|
|
|
#include <stdio.h>
|
|
#include <direct.h>
|
|
|
|
#include "PsString.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
static bool gTimeInit = false;
|
|
static const unsigned int MAX_GAMEPADS = 4;
|
|
static const unsigned int MAX_GAMEPAD_AXES = 4;
|
|
static XINPUT_STATE m_lastInputState[MAX_GAMEPADS];
|
|
static int m_lastAxisData[MAX_GAMEPADS][MAX_GAMEPAD_AXES];
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
SampleViewerGamepad::SampleViewerGamepad()
|
|
: mGamePadConnected(false), mConnectedPad(0), mXInputLibrary(), mpXInputGetState(0), mpXInputGetCapabilities(0)
|
|
{
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
SampleViewerGamepad::~SampleViewerGamepad()
|
|
{
|
|
release();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void SampleViewerGamepad::init()
|
|
{
|
|
static const unsigned int xInputLibCount = 4;
|
|
static const char* xInputLibs[xInputLibCount] = { "xinput1_4.dll",
|
|
"xinput1_3.dll",
|
|
"xinput1_2.dll",
|
|
"xinput1_1.dll" };
|
|
for (unsigned int i = 0; i < xInputLibCount; ++i)
|
|
{
|
|
mXInputLibrary = LoadLibraryA(xInputLibs[i]);
|
|
if (mXInputLibrary)
|
|
break;
|
|
}
|
|
|
|
if(!mXInputLibrary)
|
|
{
|
|
physx::shdfnd::printString("Could not load XInput library.");
|
|
}
|
|
|
|
if (mXInputLibrary)
|
|
{
|
|
mpXInputGetState = (LPXINPUTGETSTATE)GetProcAddress(mXInputLibrary, "XInputGetState");
|
|
mpXInputGetCapabilities = (LPXINPUTGETCAPABILITIES)GetProcAddress(mXInputLibrary, "XInputGetCapabilities");
|
|
if(!mpXInputGetState)
|
|
{
|
|
physx::shdfnd::printString("Error loading XInputGetState function.");
|
|
}
|
|
|
|
if(!mpXInputGetCapabilities)
|
|
{
|
|
physx::shdfnd::printString("Error loading XInputGetCapabilities function.");
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void SampleViewerGamepad::release()
|
|
{
|
|
if (mXInputLibrary)
|
|
{
|
|
FreeLibrary(mXInputLibrary);
|
|
mXInputLibrary = 0;
|
|
}
|
|
|
|
mpXInputGetState = 0;
|
|
mpXInputGetCapabilities = 0;
|
|
mGamePadConnected = false;
|
|
mConnectedPad = 0;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
void SampleViewerGamepad::processGamepads(SampleViewerScene& viewerScene)
|
|
{
|
|
if (!gTimeInit)
|
|
{
|
|
gTimeInit = true;
|
|
|
|
for (unsigned int p = 0; p < MAX_GAMEPADS; p++)
|
|
{
|
|
memset(&m_lastInputState[p], 0, sizeof(XINPUT_STATE));
|
|
for (unsigned int i = 0; i < MAX_GAMEPAD_AXES; i++)
|
|
{
|
|
m_lastAxisData[p][i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int32_t disConnected[4] = { 1, 2, 3, 4 };
|
|
|
|
if (!hasXInput())
|
|
return;
|
|
|
|
for (uint32_t p = 0; p < MAX_GAMEPADS; p++)
|
|
{
|
|
if ((--disConnected[p]) == 0)
|
|
{
|
|
XINPUT_STATE inputState;
|
|
DWORD state = mpXInputGetState(p, &inputState);
|
|
if (state == ERROR_DEVICE_NOT_CONNECTED)
|
|
{
|
|
disConnected[p] = 4;
|
|
if (mGamePadConnected && (mConnectedPad == p))
|
|
{
|
|
mGamePadConnected = false;
|
|
mConnectedPad = 0;
|
|
for (uint32_t k = 0; k < MAX_GAMEPADS; k++)
|
|
{
|
|
XINPUT_STATE inputStateDisc;
|
|
DWORD stateDisc = mpXInputGetState(k, &inputStateDisc);
|
|
if (stateDisc == ERROR_SUCCESS)
|
|
{
|
|
mConnectedPad = k;
|
|
mGamePadConnected = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (state == ERROR_SUCCESS)
|
|
{
|
|
if (!mGamePadConnected)
|
|
{
|
|
mGamePadConnected = true;
|
|
mConnectedPad = p;
|
|
}
|
|
|
|
disConnected[p] = 1; //force to test next time
|
|
XINPUT_CAPABILITIES caps;
|
|
mpXInputGetCapabilities(p, XINPUT_FLAG_GAMEPAD, &caps);
|
|
|
|
//gamepad
|
|
{
|
|
// Process buttons
|
|
const WORD lastWButtons = m_lastInputState[p].Gamepad.wButtons;
|
|
const WORD currWButtons = inputState.Gamepad.wButtons;
|
|
|
|
const WORD buttonsDown = currWButtons & ~lastWButtons;
|
|
const WORD buttonsUp = ~currWButtons & lastWButtons;
|
|
// const WORD buttonsHeld = currWButtons & lastWButtons;
|
|
|
|
for (int i = 0; i < 14; i++)
|
|
{
|
|
// order has to match struct GamepadControls
|
|
static const WORD buttonMasks[] = {
|
|
XINPUT_GAMEPAD_DPAD_UP,
|
|
XINPUT_GAMEPAD_DPAD_DOWN,
|
|
XINPUT_GAMEPAD_DPAD_LEFT,
|
|
XINPUT_GAMEPAD_DPAD_RIGHT,
|
|
XINPUT_GAMEPAD_START,
|
|
XINPUT_GAMEPAD_BACK,
|
|
XINPUT_GAMEPAD_LEFT_THUMB,
|
|
XINPUT_GAMEPAD_RIGHT_THUMB,
|
|
XINPUT_GAMEPAD_Y,
|
|
XINPUT_GAMEPAD_A,
|
|
XINPUT_GAMEPAD_X,
|
|
XINPUT_GAMEPAD_B,
|
|
XINPUT_GAMEPAD_LEFT_SHOULDER,
|
|
XINPUT_GAMEPAD_RIGHT_SHOULDER,
|
|
};
|
|
|
|
if (buttonsDown & buttonMasks[i])
|
|
viewerScene.handleGamepadButton(i, true);
|
|
else if (buttonsUp & buttonMasks[i])
|
|
viewerScene.handleGamepadButton(i, false);
|
|
}
|
|
|
|
{
|
|
const BYTE newTriggerVal = inputState.Gamepad.bRightTrigger;
|
|
viewerScene.handleGamepadTrigger(GamepadTrigger::GAMEPAD_RIGHT_SHOULDER_TRIGGER, ((float)newTriggerVal) / 255);
|
|
}
|
|
{
|
|
const BYTE newTriggerVal = inputState.Gamepad.bLeftTrigger;
|
|
viewerScene.handleGamepadTrigger(GamepadTrigger::GAMEPAD_LEFT_SHOULDER_TRIGGER, ((float)newTriggerVal) / 255);
|
|
}
|
|
}
|
|
|
|
// Gamepad
|
|
const int axisData[] = { inputState.Gamepad.sThumbRX, inputState.Gamepad.sThumbRY, inputState.Gamepad.sThumbLX, inputState.Gamepad.sThumbLY };
|
|
for (uint32_t i = 0; i < MAX_GAMEPAD_AXES; i++)
|
|
{
|
|
if (axisData[i] != m_lastAxisData[p][i])
|
|
{
|
|
int data = axisData[i];
|
|
if (abs(data) < XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE)
|
|
{
|
|
data = 0;
|
|
}
|
|
viewerScene.handleGamepadAxis(i, ((float)data) / SHRT_MAX);
|
|
}
|
|
m_lastAxisData[p][i] = axisData[i];
|
|
}
|
|
m_lastInputState[p] = inputState;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|