566 lines
20 KiB
C++
566 lines
20 KiB
C++
|
// ******************************************************************
|
||
|
|
// *
|
||
|
|
// * .,-::::: .,:: .::::::::. .,:: .:
|
||
|
|
// * ,;;;'````' `;;;, .,;; ;;;'';;' `;;;, .,;;
|
||
|
|
// * [[[ '[[,,[[' [[[__[[\. '[[,,[['
|
||
|
|
// * $$$ Y$$$P $$""""Y$$ Y$$$P
|
||
|
|
// * `88bo,__,o, oP"``"Yo, _88o,,od8P oP"``"Yo,
|
||
|
|
// * "YUMMMMMP",m" "Mm,""YUMMMP" ,m" "Mm,
|
||
|
|
// *
|
||
|
|
// * Cxbx->Win32->XBController.cpp
|
||
|
|
// *
|
||
|
|
// * This file is part of the Cxbx project.
|
||
|
|
// *
|
||
|
|
// * Cxbx and Cxbe are free software; you can redistribute them
|
||
|
|
// * and/or modify them under the terms of the GNU General Public
|
||
|
|
// * License as published by the Free Software Foundation; either
|
||
|
|
// * version 2 of the license, or (at your option) any later version.
|
||
|
|
// *
|
||
|
|
// * This program is distributed in the hope that it will be useful,
|
||
|
|
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
// * GNU General Public License for more details.
|
||
|
|
// *
|
||
|
|
// * You should have recieved a copy of the GNU General Public License
|
||
|
|
// * along with this program; see the file COPYING.
|
||
|
|
// * If not, write to the Free Software Foundation, Inc.,
|
||
|
|
// * 59 Temple Place - Suite 330, Bostom, MA 02111-1307, USA.
|
||
|
|
// *
|
||
|
|
// * (c) 2002-2003 Aaron Robinson <caustik@caustik.com>
|
||
|
|
// *
|
||
|
|
// * All rights reserved
|
||
|
|
// *
|
||
|
|
// ******************************************************************
|
||
|
|
#include "XBController.h"
|
||
|
|
|
||
|
|
#include <stdio.h>
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: XBController::XBController
|
||
|
|
// ******************************************************************
|
||
|
|
XBController::XBController()
|
||
|
|
{
|
||
|
|
int v=0;
|
||
|
|
|
||
|
|
for(v=0;v<XBCTRL_MAX_DEVICES;v++)
|
||
|
|
m_DeviceName[v][0] = '\0';
|
||
|
|
|
||
|
|
for(v=0;v<XBCTRL_OBJECT_COUNT;v++)
|
||
|
|
{
|
||
|
|
m_ObjectConfig[v].dwDevice = -1;
|
||
|
|
m_ObjectConfig[v].dwInfo = -1;
|
||
|
|
m_ObjectConfig[v].dwFlags = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: XBController::Load
|
||
|
|
// ******************************************************************
|
||
|
|
void XBController::Load(const char *szRegistryKey)
|
||
|
|
{
|
||
|
|
Lock();
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Load Configuration from Registry
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
DWORD dwDisposition, dwType, dwSize;
|
||
|
|
HKEY hKey;
|
||
|
|
|
||
|
|
if(RegCreateKeyEx(HKEY_CURRENT_USER, szRegistryKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_QUERY_VALUE, NULL, &hKey, &dwDisposition) == ERROR_SUCCESS)
|
||
|
|
{
|
||
|
|
int v=0;
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Load Device Names
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
char szValueName[64];
|
||
|
|
|
||
|
|
for(v=0;v<XBCTRL_MAX_DEVICES;v++)
|
||
|
|
{
|
||
|
|
// default is a null string
|
||
|
|
m_DeviceName[v][0] = '\0';
|
||
|
|
|
||
|
|
sprintf(szValueName, "DeviceName 0x%.02X", v);
|
||
|
|
|
||
|
|
dwType = REG_SZ; dwSize = 260;
|
||
|
|
RegQueryValueEx(hKey, szValueName, NULL, &dwType, (PBYTE)m_DeviceName[v], &dwSize);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Load Object Configuration
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
char szValueName[64];
|
||
|
|
|
||
|
|
for(v=0;v<XBCTRL_OBJECT_COUNT;v++)
|
||
|
|
{
|
||
|
|
// default object configuration
|
||
|
|
m_ObjectConfig[v].dwDevice = -1;
|
||
|
|
m_ObjectConfig[v].dwInfo = -1;
|
||
|
|
m_ObjectConfig[v].dwFlags = 0;
|
||
|
|
|
||
|
|
sprintf(szValueName, "Object : \"%s\"", m_DeviceNameLookup[v]);
|
||
|
|
|
||
|
|
dwType = REG_BINARY; dwSize = sizeof(XBCtrlObjectCfg);
|
||
|
|
RegQueryValueEx(hKey, szValueName, NULL, &dwType, (PBYTE)&m_ObjectConfig[v], &dwSize);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
RegCloseKey(hKey);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Unlock();
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: XBController::Save
|
||
|
|
// ******************************************************************
|
||
|
|
void XBController::Save(const char *szRegistryKey)
|
||
|
|
{
|
||
|
|
Lock();
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Save Configuration to Registry
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
DWORD dwDisposition, dwType, dwSize;
|
||
|
|
HKEY hKey;
|
||
|
|
|
||
|
|
if(RegCreateKeyEx(HKEY_CURRENT_USER, szRegistryKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &hKey, &dwDisposition) == ERROR_SUCCESS)
|
||
|
|
{
|
||
|
|
int v=0;
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Save Device Names
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
char szValueName[64];
|
||
|
|
|
||
|
|
for(v=0;v<XBCTRL_MAX_DEVICES;v++)
|
||
|
|
{
|
||
|
|
sprintf(szValueName, "DeviceName 0x%.02X", v);
|
||
|
|
|
||
|
|
dwType = REG_SZ; dwSize = 260;
|
||
|
|
|
||
|
|
if(m_DeviceName[v][0] != '\0')
|
||
|
|
RegSetValueEx(hKey, szValueName, NULL, dwType, (PBYTE)m_DeviceName[v], dwSize);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Save Object Configuration
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
char szValueName[64];
|
||
|
|
|
||
|
|
for(v=0;v<XBCTRL_OBJECT_COUNT;v++)
|
||
|
|
{
|
||
|
|
sprintf(szValueName, "Object : \"%s\"", m_DeviceNameLookup[v]);
|
||
|
|
|
||
|
|
dwType = REG_BINARY; dwSize = sizeof(XBCtrlObjectCfg);
|
||
|
|
|
||
|
|
if(m_ObjectConfig[v].dwDevice != -1)
|
||
|
|
RegSetValueEx(hKey, szValueName, NULL, dwType, (PBYTE)&m_ObjectConfig[v], dwSize);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
RegCloseKey(hKey);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Unlock();
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: XBController::ConfigBegin
|
||
|
|
// ******************************************************************
|
||
|
|
void XBController::ConfigBegin(HWND hwnd, XBCtrlObject object)
|
||
|
|
{
|
||
|
|
// ******************************************************************
|
||
|
|
// * Create DirectInput Object
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
HRESULT hRet = DirectInput8Create
|
||
|
|
(
|
||
|
|
GetModuleHandle(NULL),
|
||
|
|
DIRECTINPUT_VERSION,
|
||
|
|
IID_IDirectInput8,
|
||
|
|
(void**)&m_pDirectInput8,
|
||
|
|
NULL
|
||
|
|
);
|
||
|
|
|
||
|
|
if(FAILED(hRet))
|
||
|
|
{
|
||
|
|
SetError("Could not initialized DirectInput8", true);
|
||
|
|
goto cleanup;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Create all the devices available (well...most of them)
|
||
|
|
// ******************************************************************
|
||
|
|
if(m_pDirectInput8 != 0)
|
||
|
|
{
|
||
|
|
HRESULT hRet = m_pDirectInput8->EnumDevices
|
||
|
|
(
|
||
|
|
DI8DEVCLASS_GAMECTRL,
|
||
|
|
WrapEnumGameCtrlCallback,
|
||
|
|
this,
|
||
|
|
DIEDFL_ATTACHEDONLY
|
||
|
|
);
|
||
|
|
|
||
|
|
hRet = m_pDirectInput8->CreateDevice(GUID_SysKeyboard, &m_InputDevice[m_dwInputDeviceCount].m_Device, NULL);
|
||
|
|
|
||
|
|
if(!FAILED(hRet))
|
||
|
|
{
|
||
|
|
m_InputDevice[m_dwInputDeviceCount].m_Flags = DEVICE_FLAG_KEYBOARD;
|
||
|
|
|
||
|
|
m_InputDevice[m_dwInputDeviceCount++].m_Device->SetDataFormat(&c_dfDIKeyboard);
|
||
|
|
}
|
||
|
|
|
||
|
|
hRet = m_pDirectInput8->CreateDevice(GUID_SysMouse, &m_InputDevice[m_dwInputDeviceCount].m_Device, NULL);
|
||
|
|
|
||
|
|
if(!FAILED(hRet))
|
||
|
|
{
|
||
|
|
m_InputDevice[m_dwInputDeviceCount].m_Flags = DEVICE_FLAG_MOUSE;
|
||
|
|
|
||
|
|
m_InputDevice[m_dwInputDeviceCount++].m_Device->SetDataFormat(&c_dfDIMouse2);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Set cooperative level and acquire
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
for(int v=m_dwInputDeviceCount-1;v>=0;v--)
|
||
|
|
{
|
||
|
|
m_InputDevice[v].m_Device->SetCooperativeLevel(hwnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
|
||
|
|
m_InputDevice[v].m_Device->Acquire();
|
||
|
|
|
||
|
|
HRESULT hRet = m_InputDevice[v].m_Device->Poll();
|
||
|
|
|
||
|
|
if(FAILED(hRet))
|
||
|
|
{
|
||
|
|
hRet = m_InputDevice[v].m_Device->Acquire();
|
||
|
|
|
||
|
|
while(hRet == DIERR_INPUTLOST)
|
||
|
|
hRet = m_InputDevice[v].m_Device->Acquire();
|
||
|
|
|
||
|
|
if(hRet != DIERR_INPUTLOST)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Enumerate Controller objects
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
for(m_dwCurObject=0;m_dwCurObject<m_dwInputDeviceCount;m_dwCurObject++)
|
||
|
|
m_InputDevice[m_dwCurObject].m_Device->EnumObjects(WrapEnumObjectsCallback, this, DIDFT_ALL);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Last Mouse Input for Delta Calculations
|
||
|
|
// ******************************************************************
|
||
|
|
LastMouse_lX = -1;
|
||
|
|
LastMouse_lY = -1;
|
||
|
|
LastMouse_lZ = -1;
|
||
|
|
|
||
|
|
CurConfigObject = object;
|
||
|
|
|
||
|
|
cleanup:
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: XBController::ConfigPoll
|
||
|
|
// ******************************************************************
|
||
|
|
bool XBController::ConfigPoll(char *szStatus)
|
||
|
|
{
|
||
|
|
DIDEVICEINSTANCE DeviceInstance;
|
||
|
|
DIDEVICEOBJECTINSTANCE ObjectInstance;
|
||
|
|
|
||
|
|
DeviceInstance.dwSize = sizeof(DIDEVICEINSTANCE);
|
||
|
|
ObjectInstance.dwSize = sizeof(DIDEVICEOBJECTINSTANCE);
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Monitor for significant device state changes
|
||
|
|
// ******************************************************************
|
||
|
|
for(int v=m_dwInputDeviceCount-1;v>=0;v--)
|
||
|
|
{
|
||
|
|
// ******************************************************************
|
||
|
|
// * Poll the current device
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
HRESULT hRet = m_InputDevice[v].m_Device->Poll();
|
||
|
|
|
||
|
|
if(FAILED(hRet))
|
||
|
|
{
|
||
|
|
hRet = m_InputDevice[v].m_Device->Acquire();
|
||
|
|
|
||
|
|
while(hRet == DIERR_INPUTLOST)
|
||
|
|
hRet = m_InputDevice[v].m_Device->Acquire();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
DWORD dwHow = -1, dwFlags = m_InputDevice[v].m_Flags;
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Detect Joystick Input
|
||
|
|
// ******************************************************************
|
||
|
|
if(m_InputDevice[v].m_Flags & DEVICE_FLAG_JOYSTICK)
|
||
|
|
{
|
||
|
|
DIJOYSTATE JoyState;
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Get Joystick State
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
HRESULT hRet = m_InputDevice[v].m_Device->GetDeviceState(sizeof(DIJOYSTATE), &JoyState);
|
||
|
|
|
||
|
|
if(FAILED(hRet))
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
dwFlags = DEVICE_FLAG_JOYSTICK;
|
||
|
|
|
||
|
|
if(abs(JoyState.lX) > DETECT_SENSITIVITY_JOYSTICK)
|
||
|
|
{
|
||
|
|
dwHow = FIELD_OFFSET(DIJOYSTATE, lX);
|
||
|
|
dwFlags |= (JoyState.lX > 0) ? (DEVICE_FLAG_AXIS | DEVICE_FLAG_POSITIVE) : (DEVICE_FLAG_AXIS | DEVICE_FLAG_NEGATIVE);
|
||
|
|
}
|
||
|
|
else if(abs(JoyState.lY) > DETECT_SENSITIVITY_JOYSTICK)
|
||
|
|
{
|
||
|
|
dwHow = FIELD_OFFSET(DIJOYSTATE, lY);
|
||
|
|
dwFlags |= (JoyState.lY > 0) ? (DEVICE_FLAG_AXIS | DEVICE_FLAG_POSITIVE) : (DEVICE_FLAG_AXIS | DEVICE_FLAG_NEGATIVE);
|
||
|
|
}
|
||
|
|
else if(abs(JoyState.lZ) > DETECT_SENSITIVITY_JOYSTICK)
|
||
|
|
{
|
||
|
|
dwHow = FIELD_OFFSET(DIJOYSTATE, lZ);
|
||
|
|
dwFlags |= (JoyState.lZ > 0) ? (DEVICE_FLAG_AXIS | DEVICE_FLAG_POSITIVE) : (DEVICE_FLAG_AXIS | DEVICE_FLAG_NEGATIVE);
|
||
|
|
}
|
||
|
|
else if(abs(JoyState.lRx) > DETECT_SENSITIVITY_JOYSTICK)
|
||
|
|
{
|
||
|
|
dwHow = FIELD_OFFSET(DIJOYSTATE, lRx);
|
||
|
|
dwFlags |= (JoyState.lRx > 0) ? (DEVICE_FLAG_AXIS | DEVICE_FLAG_POSITIVE) : (DEVICE_FLAG_AXIS | DEVICE_FLAG_NEGATIVE);
|
||
|
|
}
|
||
|
|
else if(abs(JoyState.lRy) > DETECT_SENSITIVITY_JOYSTICK)
|
||
|
|
{
|
||
|
|
dwHow = FIELD_OFFSET(DIJOYSTATE, lRy);
|
||
|
|
dwFlags |= (JoyState.lRy > 0) ? (DEVICE_FLAG_AXIS | DEVICE_FLAG_POSITIVE) : (DEVICE_FLAG_AXIS | DEVICE_FLAG_NEGATIVE);
|
||
|
|
}
|
||
|
|
else if(abs(JoyState.lRz) > DETECT_SENSITIVITY_JOYSTICK)
|
||
|
|
{
|
||
|
|
dwHow = FIELD_OFFSET(DIJOYSTATE, lRz);
|
||
|
|
dwFlags |= (JoyState.lRz > 0) ? (DEVICE_FLAG_AXIS | DEVICE_FLAG_POSITIVE) : (DEVICE_FLAG_AXIS | DEVICE_FLAG_NEGATIVE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
for(int b=0;b<2;b++)
|
||
|
|
if(abs(JoyState.rglSlider[b]) > DETECT_SENSITIVITY_JOYSTICK)
|
||
|
|
dwHow = FIELD_OFFSET(DIJOYSTATE, rglSlider[b]);
|
||
|
|
else
|
||
|
|
for(int b=0;b<4;b++)
|
||
|
|
if(abs(JoyState.rgdwPOV[b]) > DETECT_SENSITIVITY_POV)
|
||
|
|
dwHow = FIELD_OFFSET(DIJOYSTATE, rgdwPOV[b]);
|
||
|
|
else
|
||
|
|
for(int b=0;b<32;b++)
|
||
|
|
if(JoyState.rgbButtons[b] > DETECT_SENSITIVITY_BUTTON)
|
||
|
|
dwHow = FIELD_OFFSET(DIJOYSTATE, rgbButtons[b]);
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Retrieve Object Info
|
||
|
|
// ******************************************************************
|
||
|
|
if(dwHow != -1)
|
||
|
|
{
|
||
|
|
char *szDirection = (dwFlags & DEVICE_FLAG_AXIS) ? (dwFlags & DEVICE_FLAG_POSITIVE) ? "Positive " : "Negative " : "";
|
||
|
|
|
||
|
|
m_InputDevice[v].m_Device->GetDeviceInfo(&DeviceInstance);
|
||
|
|
|
||
|
|
m_InputDevice[v].m_Device->GetObjectInfo(&ObjectInstance, dwHow, DIPH_BYOFFSET);
|
||
|
|
|
||
|
|
Map(CurConfigObject, DeviceInstance.tszInstanceName, dwHow, dwFlags);
|
||
|
|
|
||
|
|
printf("Cxbx: Detected %s %s on %s\n", szDirection, ObjectInstance.tszName, DeviceInstance.tszInstanceName, ObjectInstance.dwType);
|
||
|
|
|
||
|
|
sprintf(szStatus, "Success: %s Mapped to '%s%s' on '%s'!", m_DeviceNameLookup[CurConfigObject], szDirection, ObjectInstance.tszName, DeviceInstance.tszInstanceName);
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: XBController::ConfigEnd
|
||
|
|
// ******************************************************************
|
||
|
|
void XBController::ConfigEnd()
|
||
|
|
{
|
||
|
|
// ******************************************************************
|
||
|
|
// * Cleanup DirectInput
|
||
|
|
// ******************************************************************
|
||
|
|
{
|
||
|
|
for(int v=m_dwInputDeviceCount-1;v>=0;v--)
|
||
|
|
{
|
||
|
|
m_InputDevice[v].m_Device->Unacquire();
|
||
|
|
m_InputDevice[v].m_Device->Release();
|
||
|
|
m_InputDevice[v].m_Device = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_dwInputDeviceCount = 0;
|
||
|
|
|
||
|
|
if(m_pDirectInput8 != 0)
|
||
|
|
{
|
||
|
|
m_pDirectInput8->Release();
|
||
|
|
m_pDirectInput8 = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: XBController::Map
|
||
|
|
// ******************************************************************
|
||
|
|
void XBController::Map(XBCtrlObject object, const char *szDeviceName, int dwInfo, int dwFlags)
|
||
|
|
{
|
||
|
|
// Initialize InputMapping instance
|
||
|
|
m_ObjectConfig[object].dwDevice = Insert(szDeviceName);
|
||
|
|
m_ObjectConfig[object].dwInfo = dwInfo;
|
||
|
|
m_ObjectConfig[object].dwFlags = dwFlags;
|
||
|
|
|
||
|
|
// Purse unused device slots
|
||
|
|
for(int v=0;v<XBCTRL_MAX_DEVICES;v++)
|
||
|
|
{
|
||
|
|
bool inuse = false;
|
||
|
|
|
||
|
|
for(int r=0;r<XBCTRL_OBJECT_COUNT;r++)
|
||
|
|
if(m_ObjectConfig[r].dwDevice == v)
|
||
|
|
inuse=true;
|
||
|
|
|
||
|
|
if(!inuse)
|
||
|
|
m_DeviceName[v][0] = '\0';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: XBController::Insert
|
||
|
|
// ******************************************************************
|
||
|
|
int XBController::Insert(const char *szDeviceName)
|
||
|
|
{
|
||
|
|
int v=0;
|
||
|
|
|
||
|
|
for(v=0;v<XBCTRL_MAX_DEVICES;v++)
|
||
|
|
if(strcmp(m_DeviceName[v], szDeviceName) == 0)
|
||
|
|
return v;
|
||
|
|
|
||
|
|
for(v=0;v<XBCTRL_MAX_DEVICES;v++)
|
||
|
|
{
|
||
|
|
if(m_DeviceName[v][0] == '\0')
|
||
|
|
{
|
||
|
|
strncpy(m_DeviceName[v], szDeviceName, 255);
|
||
|
|
|
||
|
|
return v;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageBox(NULL, "Unexpected Circumstance (Too Many Controller Devices)! Please contact caustik!", "Cxbx", MB_OK | MB_ICONEXCLAMATION);
|
||
|
|
|
||
|
|
ExitProcess(1);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: XBController::EnumGameCtrlCallback
|
||
|
|
// ******************************************************************
|
||
|
|
BOOL XBController::EnumGameCtrlCallback(LPCDIDEVICEINSTANCE lpddi)
|
||
|
|
{
|
||
|
|
HRESULT hRet = m_pDirectInput8->CreateDevice(lpddi->guidInstance, &m_InputDevice[m_dwInputDeviceCount].m_Device, NULL);
|
||
|
|
|
||
|
|
if(!FAILED(hRet))
|
||
|
|
{
|
||
|
|
m_InputDevice[m_dwInputDeviceCount].m_Flags = DEVICE_FLAG_JOYSTICK;
|
||
|
|
|
||
|
|
m_InputDevice[m_dwInputDeviceCount++].m_Device->SetDataFormat(&c_dfDIJoystick);
|
||
|
|
}
|
||
|
|
|
||
|
|
return DIENUM_CONTINUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: XBController::EnumObjectsCallback
|
||
|
|
// ******************************************************************
|
||
|
|
BOOL XBController::EnumObjectsCallback(LPCDIDEVICEOBJECTINSTANCE lpddoi)
|
||
|
|
{
|
||
|
|
if(lpddoi->dwType & DIDFT_AXIS)
|
||
|
|
{
|
||
|
|
DIPROPRANGE diprg;
|
||
|
|
|
||
|
|
diprg.diph.dwSize = sizeof(DIPROPRANGE);
|
||
|
|
diprg.diph.dwHeaderSize = sizeof(DIPROPHEADER);
|
||
|
|
diprg.diph.dwHow = DIPH_BYID;
|
||
|
|
diprg.diph.dwObj = lpddoi->dwType;
|
||
|
|
diprg.lMin = 0 - 32768;
|
||
|
|
diprg.lMax = 0 + 32767;
|
||
|
|
|
||
|
|
HRESULT hRet = m_InputDevice[m_dwCurObject].m_Device->SetProperty(DIPROP_RANGE, &diprg.diph);
|
||
|
|
|
||
|
|
if(FAILED(hRet))
|
||
|
|
return DIENUM_STOP;
|
||
|
|
}
|
||
|
|
|
||
|
|
return DIENUM_CONTINUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: WrapEnumGameCtrlCallback
|
||
|
|
// ******************************************************************
|
||
|
|
BOOL CALLBACK WrapEnumGameCtrlCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef)
|
||
|
|
{
|
||
|
|
XBController *context = (XBController*)pvRef;
|
||
|
|
|
||
|
|
return context->EnumGameCtrlCallback(lpddi);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * func: WrapEnumObjectsCallback
|
||
|
|
// ******************************************************************
|
||
|
|
BOOL CALLBACK WrapEnumObjectsCallback(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef)
|
||
|
|
{
|
||
|
|
XBController *context = (XBController*)pvRef;
|
||
|
|
|
||
|
|
return context->EnumObjectsCallback(lpddoi);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Input Device Name Lookup Table
|
||
|
|
// ******************************************************************
|
||
|
|
const char *XBController::m_DeviceNameLookup[XBCTRL_OBJECT_COUNT] =
|
||
|
|
{
|
||
|
|
// ******************************************************************
|
||
|
|
// * Analog Axis
|
||
|
|
// ******************************************************************
|
||
|
|
"LThumbPosX", "LThumbNegX", "LThumbPosY", "LThumbNegY",
|
||
|
|
"RThumbPosX", "RThumbNegX", "RThumbPosY", "RThumbNegY",
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Analog Buttons
|
||
|
|
// ******************************************************************
|
||
|
|
"X", "Y", "A", "B", "White", "Black", "LTrigger", "RTrigger",
|
||
|
|
|
||
|
|
// ******************************************************************
|
||
|
|
// * Digital Buttons
|
||
|
|
// ******************************************************************
|
||
|
|
"DPadUp", "DPadDown", "DPadLeft", "DPadRight",
|
||
|
|
"Back", "Start", "LThumb", "RThumb",
|
||
|
|
};
|