summaryrefslogtreecommitdiffstats
path: root/src/osd/winui/dijoystick.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/osd/winui/dijoystick.cpp')
-rw-r--r--src/osd/winui/dijoystick.cpp758
1 files changed, 758 insertions, 0 deletions
diff --git a/src/osd/winui/dijoystick.cpp b/src/osd/winui/dijoystick.cpp
new file mode 100644
index 00000000000..3350ea2f5d4
--- /dev/null
+++ b/src/osd/winui/dijoystick.cpp
@@ -0,0 +1,758 @@
+// For licensing and usage information, read docs/winui_license.txt
+// MASTER
+//****************************************************************************
+
+/***************************************************************************
+
+ dijoystick.cpp
+
+ ***************************************************************************/
+
+// standard windows headers
+#include <windows.h>
+
+// standard C headers
+#include <tchar.h>
+
+// MAMEUI headers
+#include "winui.h"
+#include "directinput.h"
+#include "dijoystick.h"
+#include "mui_util.h" // For ErrorMsg
+
+/***************************************************************************
+ function prototypes
+ ***************************************************************************/
+
+static int DIJoystick_init(void);
+static void DIJoystick_exit(void);
+static void DIJoystick_poll_joysticks(void);
+static int DIJoystick_is_joy_pressed(int joycode);
+static BOOL DIJoystick_Available(void);
+
+static BOOL CALLBACK DIJoystick_EnumDeviceProc(LPDIDEVICEINSTANCE pdidi, LPVOID pv);
+
+/***************************************************************************
+ External variables
+ ***************************************************************************/
+
+const struct OSDJoystick DIJoystick =
+{
+ DIJoystick_init, /* init */
+ DIJoystick_exit, /* exit */
+ DIJoystick_is_joy_pressed, /* joy_pressed */
+ DIJoystick_poll_joysticks, /* poll_joysticks */
+ DIJoystick_Available, /* Available */
+};
+
+/***************************************************************************
+ Internal structures
+ ***************************************************************************/
+
+#define MAX_PHYSICAL_JOYSTICKS 20
+#define MAX_AXES 20
+
+typedef struct
+{
+ GUID guid;
+ TCHAR *name;
+
+ int offset; /* offset in dijoystate */
+} axis_type;
+
+typedef struct
+{
+ BOOL use_joystick;
+
+ GUID guidDevice;
+ TCHAR *name;
+
+ BOOL is_light_gun;
+
+ LPDIRECTINPUTDEVICE2 did;
+
+ DWORD num_axes;
+ axis_type axes[MAX_AXES];
+
+ DWORD num_pov;
+ DWORD num_buttons;
+
+ DIJOYSTATE dijs;
+
+} joystick_type;
+
+struct tDIJoystick_private
+{
+ int use_count; /* the gui and game can both init/exit us, so keep track */
+ BOOL m_bCoinSlot;
+
+ DWORD num_joysticks;
+ joystick_type joysticks[MAX_PHYSICAL_JOYSTICKS]; /* actual joystick data! */
+};
+
+/* internal functions needing our declarations */
+static BOOL CALLBACK DIJoystick_EnumAxisObjectsProc(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef);
+static BOOL CALLBACK DIJoystick_EnumPOVObjectsProc(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef);
+static BOOL CALLBACK DIJoystick_EnumButtonObjectsProc(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef);
+static void ClearJoyState(DIJOYSTATE *pdijs);
+static void InitJoystick(joystick_type *joystick);
+static void ExitJoystick(joystick_type *joystick);
+const char * DirectXDecodeError(HRESULT errorval);
+
+/***************************************************************************
+ Internal variables
+ ***************************************************************************/
+
+static struct tDIJoystick_private This;
+
+static const GUID guidNULL = {0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}};
+
+/***************************************************************************
+ External OSD functions
+ ***************************************************************************/
+/*
+ put here anything you need to do when the program is started. Return 0 if
+ initialization was successful, nonzero otherwise.
+*/
+static int DIJoystick_init(void)
+{
+ This.use_count++;
+ This.num_joysticks = 0;
+
+ LPDIRECTINPUT di = GetDirectInput();
+ if (di == NULL)
+ {
+ ErrorMsg("DirectInput not initialized");
+ return 1;
+ }
+
+ /* enumerate for joystick devices */
+ HRESULT hr = IDirectInput_EnumDevices(di, DIDEVTYPE_JOYSTICK, (LPDIENUMDEVICESCALLBACK)DIJoystick_EnumDeviceProc, NULL, DIEDFL_ATTACHEDONLY );
+ if (FAILED(hr))
+ {
+ ErrorMsg("DirectInput EnumDevices() failed: %s", DirectXDecodeError(hr));
+ return 0;
+ }
+
+ /* create each joystick device, enumerate each joystick for axes, etc */
+ for (DWORD i = 0; i < This.num_joysticks; i++)
+ InitJoystick(&This.joysticks[i]);
+
+ /* Are there any joysticks attached? */
+ if (This.num_joysticks < 1)
+ /*ErrorMsg("DirectInput EnumDevices didn't find any joysticks");*/
+ return 1;
+
+ return 0;
+}
+
+/*
+ put here cleanup routines to be executed when the program is terminated.
+*/
+static void DIJoystick_exit(void)
+{
+ This.use_count--;
+ if (This.use_count > 0)
+ return;
+
+ for (DWORD i = 0; i < This.num_joysticks; i++)
+ ExitJoystick(&This.joysticks[i]);
+
+ This.num_joysticks = 0;
+}
+
+static void DIJoystick_poll_joysticks(void)
+{
+ HRESULT hr;
+ This.m_bCoinSlot = 0;
+
+ for (DWORD i = 0; i < This.num_joysticks; i++)
+ {
+ /* start by clearing the structure, then fill it in if possible */
+
+ ClearJoyState(&This.joysticks[i].dijs);
+
+ if (This.joysticks[i].did == NULL)
+ continue;
+
+ if (This.joysticks[i].use_joystick == FALSE)
+ continue;
+
+ hr = IDirectInputDevice2_Poll(This.joysticks[i].did);
+
+ hr = IDirectInputDevice2_GetDeviceState(This.joysticks[i].did,sizeof(DIJOYSTATE), &This.joysticks[i].dijs);
+ if (FAILED(hr))
+ {
+ if (hr == DIERR_INPUTLOST || hr == DIERR_NOTACQUIRED)
+ hr = IDirectInputDevice2_Acquire(This.joysticks[i].did);
+
+ continue;
+ }
+ }
+}
+
+/*
+ check if the DIJoystick is moved in the specified direction, defined in
+ osdepend.h. Return 0 if it is not pressed, nonzero otherwise.
+*/
+
+static int DIJoystick_is_joy_pressed(int joycode)
+{
+ int axis = 0;
+ int dir = 0;
+ int value = 0;
+ int dz = 60;
+ int joy_num = GET_JOYCODE_JOY(joycode);
+
+ /* do we have as many sticks? */
+ if (joy_num == 0 || This.num_joysticks < joy_num)
+ return 0;
+ joy_num--;
+
+ if (This.joysticks[joy_num].use_joystick == FALSE)
+ return 0;
+
+ DIJOYSTATE dijs = This.joysticks[joy_num].dijs;
+
+ int stick = GET_JOYCODE_STICK(joycode);
+
+ if (stick == JOYCODE_STICK_BTN)
+ {
+ /* buttons */
+ int button;
+
+ button = GET_JOYCODE_BUTTON(joycode);
+ button--;
+
+ if (button >= This.joysticks[joy_num].num_buttons
+ || GET_JOYCODE_DIR(joycode) != JOYCODE_DIR_BTN)
+ return 0;
+
+ return dijs.rgbButtons[button] != 0;
+ }
+
+ if (stick == JOYCODE_STICK_POV)
+ {
+ /* POV */
+ int pov_value = 0;
+ int angle = 0;
+ int axis_value = 0;
+
+ int num_pov = GET_JOYCODE_BUTTON(joycode) / 4;
+ int code = GET_JOYCODE_BUTTON(joycode) % 4;
+ axis = code / 2;
+ dir = code % 2;
+
+ if (num_pov >= This.joysticks[joy_num].num_pov)
+ return 0;
+
+ pov_value = dijs.rgdwPOV[num_pov];
+ if (LOWORD(pov_value) == 0xffff)
+ return 0;
+
+ angle = (pov_value + 27000) % 36000;
+ angle = (36000 - angle) % 36000;
+ angle /= 100;
+
+ /* angle is now in degrees counterclockwise from x axis*/
+ if (axis == 1)
+ axis_value = 128 + (int)(127 * cos(2 * M_PI * angle / 360.0)); /* x */
+ else
+ axis_value = 128 + (int)(127 * sin(2 * M_PI * angle / 360.0)); /* y */
+
+ if (dir == 1)
+ return axis_value <= (128 - 128 * dz / 100);
+ else
+ return axis_value >= (128 + 128 * dz / 100);
+ }
+
+ /* sticks */
+
+ axis = GET_JOYCODE_AXIS(joycode);
+ dir = GET_JOYCODE_DIR(joycode);
+
+ if (axis == 0 || This.joysticks[joy_num].num_axes < axis)
+ return 0;
+ axis--;
+
+ value = *(int *)(((byte *)&dijs) + This.joysticks[joy_num].axes[axis].offset);
+
+ if (dir == JOYCODE_DIR_NEG)
+ return value <= (128 - 128 * dz / 100);
+ else
+ return value >= (128 + 128 * dz / 100);
+}
+
+static BOOL DIJoystick_Available(void)
+{
+ static BOOL bBeenHere = false;
+ static BOOL bAvailable = false;
+ LPDIRECTINPUT di = GetDirectInput();
+
+ if (di == NULL)
+ return false;
+
+ if (bBeenHere == false)
+ bBeenHere = true;
+ else
+ return bAvailable;
+
+ /* enumerate for joystick devices */
+ GUID guidDevice = guidNULL;
+ HRESULT hr = IDirectInput_EnumDevices(di, DIDEVTYPE_JOYSTICK, inputEnumDeviceProc, &guidDevice, DIEDFL_ATTACHEDONLY );
+ if (FAILED(hr))
+ {
+ return false;
+ }
+
+ /* Are there any joysticks attached? */
+ if (IsEqualGUID(guidDevice, guidNULL))
+ return false;
+
+ LPDIRECTINPUTDEVICE didTemp;
+ hr = IDirectInput_CreateDevice(di, guidDevice, &didTemp, NULL);
+ if (FAILED(hr))
+ return false;
+
+ /* Determine if DX5 is available by a QI for a DX5 interface. */
+ LPDIRECTINPUTDEVICE didJoystick;
+ hr = IDirectInputDevice_QueryInterface(didTemp, IID_IDirectInputDevice2, (void**)&didJoystick);
+ if (FAILED(hr))
+ bAvailable = false;
+ else
+ {
+ bAvailable = true;
+ IDirectInputDevice_Release(didJoystick);
+ }
+
+ /* dispose of the temp interface */
+ IDirectInputDevice_Release(didTemp);
+
+ return bAvailable;
+}
+
+int DIJoystick_GetNumPhysicalJoysticks()
+{
+ return This.num_joysticks;
+}
+
+TCHAR* DIJoystick_GetPhysicalJoystickName(int num_joystick)
+{
+ return This.joysticks[num_joystick].name;
+}
+
+int DIJoystick_GetNumPhysicalJoystickAxes(int num_joystick)
+{
+ return This.joysticks[num_joystick].num_axes;
+}
+
+TCHAR* DIJoystick_GetPhysicalJoystickAxisName(int num_joystick, int num_axis)
+{
+ return This.joysticks[num_joystick].axes[num_axis].name;
+}
+
+/***************************************************************************
+ Internal functions
+ ***************************************************************************/
+
+BOOL CALLBACK DIJoystick_EnumDeviceProc(LPDIDEVICEINSTANCE pdidi, LPVOID pv)
+{
+ TCHAR buffer[5000];
+
+ This.joysticks[This.num_joysticks].guidDevice = pdidi->guidInstance;
+
+ _stprintf(buffer, TEXT("%s (%s)"), pdidi->tszProductName, pdidi->tszInstanceName);
+ This.joysticks[This.num_joysticks].name = (TCHAR *)malloc((_tcslen(buffer) + 1) * sizeof(TCHAR));
+ _tcscpy(This.joysticks[This.num_joysticks].name, buffer);
+
+ This.num_joysticks++;
+
+ return DIENUM_CONTINUE;
+}
+
+static BOOL CALLBACK DIJoystick_EnumAxisObjectsProc(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef)
+{
+ joystick_type* joystick = (joystick_type*)pvRef;
+ joystick->axes[joystick->num_axes].guid = lpddoi->guidType;
+ joystick->axes[joystick->num_axes].name = (TCHAR *)malloc((_tcslen(lpddoi->tszName) + 1) * sizeof(TCHAR));
+ _tcscpy(joystick->axes[joystick->num_axes].name, lpddoi->tszName);
+ joystick->axes[joystick->num_axes].offset = lpddoi->dwOfs;
+
+ /*ErrorMsg("got axis %s, offset %i",lpddoi->tszName, lpddoi->dwOfs);*/
+
+ DIPROPRANGE diprg;
+ diprg.diph.dwSize = sizeof(diprg);
+ diprg.diph.dwHeaderSize = sizeof(diprg.diph);
+ diprg.diph.dwObj = lpddoi->dwOfs;
+ diprg.diph.dwHow = DIPH_BYOFFSET;
+ diprg.lMin = 0;
+ diprg.lMax = 255;
+
+ HRESULT hr = IDirectInputDevice2_SetProperty(joystick->did, DIPROP_RANGE, &diprg.diph);
+ if (FAILED(hr)) /* if this fails, don't use this axis */
+ {
+ free(joystick->axes[joystick->num_axes].name);
+ joystick->axes[joystick->num_axes].name = NULL;
+ return DIENUM_CONTINUE;
+ }
+
+#ifdef JOY_DEBUG
+ if (FAILED(hr))
+ ErrorMsg("DirectInput SetProperty() joystick axis %s failed - %s\n", joystick->axes[joystick->num_axes].name, DirectXDecodeError(hr));
+#endif
+
+ /* Set axis dead zone to 0; we need accurate #'s for analog joystick reading. */
+
+ hr = SetDIDwordProperty(joystick->did, DIPROP_DEADZONE, lpddoi->dwOfs, DIPH_BYOFFSET, 0);
+
+#ifdef JOY_DEBUG
+ if (FAILED(hr))
+ ErrorMsg("DirectInput SetProperty() joystick axis %s dead zone failed - %s\n", joystick->axes[joystick->num_axes].name, DirectXDecodeError(hr));
+#endif
+
+ joystick->num_axes++;
+
+ return DIENUM_CONTINUE;
+}
+
+static BOOL CALLBACK DIJoystick_EnumPOVObjectsProc(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef)
+{
+ joystick_type* joystick = (joystick_type*)pvRef;
+ joystick->num_pov++;
+
+ return DIENUM_CONTINUE;
+}
+
+static BOOL CALLBACK DIJoystick_EnumButtonObjectsProc(LPCDIDEVICEOBJECTINSTANCE lpddoi, LPVOID pvRef)
+{
+ joystick_type* joystick = (joystick_type*)pvRef;
+ joystick->num_buttons++;
+
+ return DIENUM_CONTINUE;
+}
+
+static void ClearJoyState(DIJOYSTATE *pdijs)
+{
+ memset(pdijs, 0, sizeof(DIJOYSTATE));
+ pdijs->lX = 128;
+ pdijs->lY = 128;
+ pdijs->lZ = 128;
+ pdijs->lRx = 128;
+ pdijs->lRy = 128;
+ pdijs->lRz = 128;
+ pdijs->rglSlider[0] = 128;
+ pdijs->rglSlider[1] = 128;
+ pdijs->rgdwPOV[0] = -1;
+ pdijs->rgdwPOV[1] = -1;
+ pdijs->rgdwPOV[2] = -1;
+ pdijs->rgdwPOV[3] = -1;
+}
+
+static void InitJoystick(joystick_type *joystick)
+{
+ joystick->use_joystick = false;
+ joystick->did = NULL;
+ joystick->num_axes = 0;
+ joystick->is_light_gun = (_tcscmp(joystick->name, TEXT("ACT LABS GS (ACT LABS GS)")) == 0);
+
+ /* get a did1 interface first... */
+ LPDIRECTINPUT di = GetDirectInput();
+ LPDIRECTINPUTDEVICE didTemp;
+ HRESULT hr = IDirectInput_CreateDevice(di, joystick->guidDevice, &didTemp, NULL);
+ if (FAILED(hr))
+ {
+ ErrorMsg("DirectInput CreateDevice() joystick failed: %s\n", DirectXDecodeError(hr));
+ return;
+ }
+
+ /* get a did2 interface to work with polling (most) joysticks */
+ hr = IDirectInputDevice_QueryInterface(didTemp, IID_IDirectInputDevice2, (void**)&joystick->did);
+
+ /* dispose of the temp interface */
+ IDirectInputDevice_Release(didTemp);
+
+ /* check result of getting the did2 */
+ if (FAILED(hr))
+ {
+ /* no error message because this happens in dx3 */
+ /* ErrorMsg("DirectInput QueryInterface joystick failed\n"); */
+ joystick->did = NULL;
+ return;
+ }
+
+
+ hr = IDirectInputDevice2_SetCooperativeLevel(joystick->did, GetMainWindow(), DISCL_NONEXCLUSIVE | DISCL_BACKGROUND);
+ if (FAILED(hr))
+ {
+ ErrorMsg("DirectInput SetCooperativeLevel() joystick failed: %s\n", DirectXDecodeError(hr));
+ return;
+ }
+
+
+ hr = IDirectInputDevice2_SetDataFormat(joystick->did, &c_dfDIJoystick);
+ if (FAILED(hr))
+ {
+ ErrorMsg("DirectInput SetDataFormat() joystick failed: %s\n", DirectXDecodeError(hr));
+ return;
+ }
+
+ if (joystick->is_light_gun)
+ {
+ /* setup light gun to report raw screen pixel data */
+
+ DIPROPDWORD diprop;
+ memset(&diprop, 0, sizeof(diprop));
+ diprop.diph.dwSize = sizeof(DIPROPDWORD);
+ diprop.diph.dwHeaderSize = sizeof(DIPROPHEADER);
+ diprop.diph.dwObj = 0;
+ diprop.diph.dwHow = DIPH_DEVICE;
+ diprop.dwData = DIPROPCALIBRATIONMODE_RAW;
+
+ IDirectInputDevice2_SetProperty(joystick->did, DIPROP_CALIBRATIONMODE, &diprop.diph);
+ }
+ else
+ {
+ /* enumerate our axes */
+ hr = IDirectInputDevice_EnumObjects(joystick->did, DIJoystick_EnumAxisObjectsProc, joystick, DIDFT_AXIS);
+ if (FAILED(hr))
+ {
+ ErrorMsg("DirectInput EnumObjects() Axes failed: %s\n", DirectXDecodeError(hr));
+ return;
+ }
+
+ /* enumerate our POV hats */
+ joystick->num_pov = 0;
+ hr = IDirectInputDevice_EnumObjects(joystick->did, DIJoystick_EnumPOVObjectsProc, joystick, DIDFT_POV);
+ if (FAILED(hr))
+ {
+ ErrorMsg("DirectInput EnumObjects() POVs failed: %s\n", DirectXDecodeError(hr));
+ return;
+ }
+ }
+
+ /* enumerate our buttons */
+
+ joystick->num_buttons = 0;
+ hr = IDirectInputDevice_EnumObjects(joystick->did, DIJoystick_EnumButtonObjectsProc, joystick, DIDFT_BUTTON);
+ if (FAILED(hr))
+ {
+ ErrorMsg("DirectInput EnumObjects() Buttons failed: %s\n", DirectXDecodeError(hr));
+ return;
+ }
+
+ hr = IDirectInputDevice2_Acquire(joystick->did);
+ if (FAILED(hr))
+ {
+ ErrorMsg("DirectInputDevice Acquire joystick failed!\n");
+ return;
+ }
+
+ /* start by clearing the structures */
+
+ ClearJoyState(&joystick->dijs);
+
+ joystick->use_joystick = TRUE;
+}
+
+static void ExitJoystick(joystick_type *joystick)
+{
+ if (joystick->did)
+ {
+ IDirectInputDevice_Unacquire(joystick->did);
+ IDirectInputDevice_Release(joystick->did);
+ joystick->did = NULL;
+ }
+
+ for (DWORD i = 0; i < joystick->num_axes; i++)
+ {
+ if (joystick->axes[i].name)
+ free(joystick->axes[i].name);
+ joystick->axes[i].name = NULL;
+ }
+
+ if (joystick->name)
+ {
+ free(joystick->name);
+ joystick->name = NULL;
+ }
+}
+
+/***************************************************************************
+ DXdecode stuff
+ ***************************************************************************/
+
+typedef struct tagERRORCODE
+{
+ HRESULT hr;
+ const char *szError;
+} ERRORCODE, * LPERRORCODE;
+
+#include <ddraw.h>
+static const ERRORCODE g_ErrorCode[] =
+{
+ { DDERR_ALREADYINITIALIZED, "DDERR_ALREADYINITIALIZED"},
+ { DDERR_CANNOTATTACHSURFACE, "DDERR_CANNOTATTACHSURFACE"},
+ { DDERR_CANNOTDETACHSURFACE, "DDERR_CANNOTDETACHSURFACE"},
+ { DDERR_CURRENTLYNOTAVAIL, "DDERR_CURRENTLYNOTAVAIL"},
+ { DDERR_EXCEPTION, "DDERR_EXCEPTION"},
+ { DDERR_GENERIC, "DDERR_GENERIC"},
+ { DDERR_HEIGHTALIGN, "DDERR_HEIGHTALIGN"},
+ { DDERR_INCOMPATIBLEPRIMARY, "DDERR_INCOMPATIBLEPRIMARY"},
+ { DDERR_INVALIDCAPS, "DDERR_INVALIDCAPS"},
+ { DDERR_INVALIDCLIPLIST, "DDERR_INVALIDCLIPLIST"},
+ { DDERR_INVALIDMODE, "DDERR_INVALIDMODE"},
+ { DDERR_INVALIDOBJECT, "DDERR_INVALIDOBJECT"},
+ { DDERR_INVALIDPARAMS, "DDERR_INVALIDPARAMS"},
+ { DDERR_INVALIDPIXELFORMAT, "DDERR_INVALIDPIXELFORMAT"},
+ { DDERR_INVALIDRECT, "DDERR_INVALIDRECT"},
+ { DDERR_LOCKEDSURFACES, "DDERR_LOCKEDSURFACES"},
+ { DDERR_NO3D, "DDERR_NO3D"},
+ { DDERR_NOALPHAHW, "DDERR_NOALPHAHW"},
+ { DDERR_NOCLIPLIST, "DDERR_NOCLIPLIST"},
+ { DDERR_NOCOLORCONVHW, "DDERR_NOCOLORCONVHW"},
+ { DDERR_NOCOOPERATIVELEVELSET, "DDERR_NOCOOPERATIVELEVELSET"},
+ { DDERR_NOCOLORKEY, "DDERR_NOCOLORKEY"},
+ { DDERR_NOCOLORKEYHW, "DDERR_NOCOLORKEYHW"},
+ { DDERR_NODIRECTDRAWSUPPORT, "DDERR_NODIRECTDRAWSUPPORT"},
+ { DDERR_NOEXCLUSIVEMODE, "DDERR_NOEXCLUSIVEMODE"},
+ { DDERR_NOFLIPHW, "DDERR_NOFLIPHW"},
+ { DDERR_NOGDI, "DDERR_NOGDI"},
+ { DDERR_NOMIRRORHW, "DDERR_NOMIRRORHW"},
+ { DDERR_NOTFOUND, "DDERR_NOTFOUND"},
+ { DDERR_NOOVERLAYHW, "DDERR_NOOVERLAYHW"},
+ { DDERR_NORASTEROPHW, "DDERR_NORASTEROPHW"},
+ { DDERR_NOROTATIONHW, "DDERR_NOROTATIONHW"},
+ { DDERR_NOSTRETCHHW, "DDERR_NOSTRETCHHW"},
+ { DDERR_NOT4BITCOLOR, "DDERR_NOT4BITCOLOR"},
+ { DDERR_NOT4BITCOLORINDEX, "DDERR_NOT4BITCOLORINDEX"},
+ { DDERR_NOT8BITCOLOR, "DDERR_NOT8BITCOLOR"},
+ { DDERR_NOTEXTUREHW, "DDERR_NOTEXTUREHW"},
+ { DDERR_NOVSYNCHW, "DDERR_NOVSYNCHW"},
+ { DDERR_NOZBUFFERHW, "DDERR_NOZBUFFERHW"},
+ { DDERR_NOZOVERLAYHW, "DDERR_NOZOVERLAYHW"},
+ { DDERR_OUTOFCAPS, "DDERR_OUTOFCAPS"},
+ { DDERR_OUTOFMEMORY, "DDERR_OUTOFMEMORY"},
+ { DDERR_OUTOFVIDEOMEMORY, "DDERR_OUTOFVIDEOMEMORY"},
+ { DDERR_OVERLAYCANTCLIP, "DDERR_OVERLAYCANTCLIP"},
+ { DDERR_OVERLAYCOLORKEYONLYONEACTIVE, "DDERR_OVERLAYCOLORKEYONLYONEACTIVE"},
+ { DDERR_PALETTEBUSY, "DDERR_PALETTEBUSY"},
+ { DDERR_COLORKEYNOTSET, "DDERR_COLORKEYNOTSET"},
+ { DDERR_SURFACEALREADYATTACHED, "DDERR_SURFACEALREADYATTACHED"},
+ { DDERR_SURFACEALREADYDEPENDENT, "DDERR_SURFACEALREADYDEPENDENT"},
+ { DDERR_SURFACEBUSY, "DDERR_SURFACEBUSY"},
+ { DDERR_CANTLOCKSURFACE, "DDERR_CANTLOCKSURFACE"},
+ { DDERR_SURFACEISOBSCURED, "DDERR_SURFACEISOBSCURED"},
+ { DDERR_SURFACELOST, "DDERR_SURFACELOST"},
+ { DDERR_SURFACENOTATTACHED, "DDERR_SURFACENOTATTACHED"},
+ { DDERR_TOOBIGHEIGHT, "DDERR_TOOBIGHEIGHT"},
+ { DDERR_TOOBIGSIZE, "DDERR_TOOBIGSIZE"},
+ { DDERR_TOOBIGWIDTH, "DDERR_TOOBIGWIDTH"},
+ { DDERR_UNSUPPORTED, "DDERR_UNSUPPORTED"},
+ { DDERR_UNSUPPORTEDFORMAT, "DDERR_UNSUPPORTEDFORMAT"},
+ { DDERR_UNSUPPORTEDMASK, "DDERR_UNSUPPORTEDMASK"},
+ { DDERR_VERTICALBLANKINPROGRESS, "DDERR_VERTICALBLANKINPROGRESS"},
+ { DDERR_WASSTILLDRAWING, "DDERR_WASSTILLDRAWING"},
+ { DDERR_XALIGN, "DDERR_XALIGN"},
+ { DDERR_INVALIDDIRECTDRAWGUID, "DDERR_INVALIDDIRECTDRAWGUID"},
+ { DDERR_DIRECTDRAWALREADYCREATED, "DDERR_DIRECTDRAWALREADYCREATED"},
+ { DDERR_NODIRECTDRAWHW, "DDERR_NODIRECTDRAWHW"},
+ { DDERR_PRIMARYSURFACEALREADYEXISTS, "DDERR_PRIMARYSURFACEALREADYEXISTS"},
+ { DDERR_NOEMULATION, "DDERR_NOEMULATION"},
+ { DDERR_REGIONTOOSMALL, "DDERR_REGIONTOOSMALL"},
+ { DDERR_CLIPPERISUSINGHWND, "DDERR_CLIPPERISUSINGHWND"},
+ { DDERR_NOCLIPPERATTACHED, "DDERR_NOCLIPPERATTACHED"},
+ { DDERR_NOHWND, "DDERR_NOHWND"},
+ { DDERR_HWNDSUBCLASSED, "DDERR_HWNDSUBCLASSED"},
+ { DDERR_HWNDALREADYSET, "DDERR_HWNDALREADYSET"},
+ { DDERR_NOPALETTEATTACHED, "DDERR_NOPALETTEATTACHED"},
+ { DDERR_NOPALETTEHW, "DDERR_NOPALETTEHW"},
+ { DDERR_BLTFASTCANTCLIP, "DDERR_BLTFASTCANTCLIP"},
+ { DDERR_NOBLTHW, "DDERR_NOBLTHW"},
+ { DDERR_NODDROPSHW, "DDERR_NODDROPSHW"},
+ { DDERR_OVERLAYNOTVISIBLE, "DDERR_OVERLAYNOTVISIBLE"},
+ { DDERR_NOOVERLAYDEST, "DDERR_NOOVERLAYDEST"},
+ { DDERR_INVALIDPOSITION, "DDERR_INVALIDPOSITION"},
+ { DDERR_NOTAOVERLAYSURFACE, "DDERR_NOTAOVERLAYSURFACE"},
+ { DDERR_EXCLUSIVEMODEALREADYSET, "DDERR_EXCLUSIVEMODEALREADYSET"},
+ { DDERR_NOTFLIPPABLE, "DDERR_NOTFLIPPABLE"},
+ { DDERR_CANTDUPLICATE, "DDERR_CANTDUPLICATE"},
+ { DDERR_NOTLOCKED, "DDERR_NOTLOCKED"},
+ { DDERR_CANTCREATEDC, "DDERR_CANTCREATEDC"},
+ { DDERR_NODC, "DDERR_NODC"},
+ { DDERR_WRONGMODE, "DDERR_WRONGMODE"},
+ { DDERR_IMPLICITLYCREATED, "DDERR_IMPLICITLYCREATED"},
+ { DDERR_NOTPALETTIZED, "DDERR_NOTPALETTIZED"},
+ { DDERR_UNSUPPORTEDMODE, "DDERR_UNSUPPORTEDMODE"},
+ { DDERR_NOMIPMAPHW, "DDERR_NOMIPMAPHW"},
+ { DDERR_INVALIDSURFACETYPE, "DDERR_INVALIDSURFACETYPE"},
+
+ { DDERR_NOOPTIMIZEHW, "DDERR_NOOPTIMIZEHW"},
+ { DDERR_NOTLOADED, "DDERR_NOTLOADED"},
+
+ { DDERR_DCALREADYCREATED, "DDERR_DCALREADYCREATED"},
+
+ { DDERR_NONONLOCALVIDMEM, "DDERR_NONONLOCALVIDMEM"},
+ { DDERR_CANTPAGELOCK, "DDERR_CANTPAGELOCK"},
+ { DDERR_CANTPAGEUNLOCK, "DDERR_CANTPAGEUNLOCK"},
+ { DDERR_NOTPAGELOCKED, "DDERR_NOTPAGELOCKED"},
+
+ { DDERR_MOREDATA, "DDERR_MOREDATA"},
+ { DDERR_VIDEONOTACTIVE, "DDERR_VIDEONOTACTIVE"},
+ { DDERR_DEVICEDOESNTOWNSURFACE, "DDERR_DEVICEDOESNTOWNSURFACE"},
+ { DDERR_NOTINITIALIZED, "DDERR_NOTINITIALIZED"},
+
+ { DIERR_OLDDIRECTINPUTVERSION, "DIERR_OLDDIRECTINPUTVERSION" },
+ { DIERR_BETADIRECTINPUTVERSION, "DIERR_BETADIRECTINPUTVERSION" },
+ { DIERR_BADDRIVERVER, "DIERR_BADDRIVERVER" },
+ { DIERR_DEVICENOTREG, "DIERR_DEVICENOTREG" },
+ { DIERR_NOTFOUND, "DIERR_NOTFOUND" },
+ { DIERR_OBJECTNOTFOUND, "DIERR_OBJECTNOTFOUND" },
+ { DIERR_INVALIDPARAM, "DIERR_INVALIDPARAM" },
+ { DIERR_NOINTERFACE, "DIERR_NOINTERFACE" },
+ { DIERR_GENERIC, "DIERR_GENERIC" },
+ { DIERR_OUTOFMEMORY, "DIERR_OUTOFMEMORY" },
+ { DIERR_UNSUPPORTED, "DIERR_UNSUPPORTED" },
+ { DIERR_NOTINITIALIZED, "DIERR_NOTINITIALIZED" },
+ { DIERR_ALREADYINITIALIZED, "DIERR_ALREADYINITIALIZED" },
+ { DIERR_NOAGGREGATION, "DIERR_NOAGGREGATION" },
+ { DIERR_OTHERAPPHASPRIO, "DIERR_OTHERAPPHASPRIO" },
+ { DIERR_INPUTLOST, "DIERR_INPUTLOST" },
+ { DIERR_ACQUIRED, "DIERR_ACQUIRED" },
+ { DIERR_NOTACQUIRED, "DIERR_NOTACQUIRED" },
+ { DIERR_READONLY, "DIERR_READONLY" },
+ { DIERR_HANDLEEXISTS, "DIERR_HANDLEEXISTS" },
+ { E_PENDING, "E_PENDING" },
+ { (HRESULT)DIERR_INSUFFICIENTPRIVS, "DIERR_INSUFFICIENTPRIVS" },
+ { (HRESULT)DIERR_DEVICEFULL, "DIERR_DEVICEFULL" },
+ { (HRESULT)DIERR_MOREDATA, "DIERR_MOREDATA" },
+ { (HRESULT)DIERR_NOTDOWNLOADED, "DIERR_NOTDOWNLOADED" },
+ { (HRESULT)DIERR_HASEFFECTS, "DIERR_HASEFFECTS" },
+ { (HRESULT)DIERR_NOTEXCLUSIVEACQUIRED,"DIERR_NOTEXCLUSIVEACQUIRED" },
+ { (HRESULT)DIERR_INCOMPLETEEFFECT, "DIERR_INCOMPLETEEFFECT" },
+ { (HRESULT)DIERR_NOTBUFFERED, "DIERR_NOTBUFFERED" },
+ { (HRESULT)DIERR_EFFECTPLAYING, "DIERR_EFFECTPLAYING" },
+ //{ (HRESULT)DIERR_UNPLUGGED, "DIERR_UNPLUGGED" },
+
+ { E_NOINTERFACE, "E_NOINTERFACE" }
+
+};
+
+
+/****************************************************************************
+ DirectXDecodeError: Return a string description of the given DirectX
+ error code.
+*****************************************************************************/
+const char * DirectXDecodeError(HRESULT errorval)
+{
+ for (int i = 0; i < (sizeof(g_ErrorCode) / sizeof(g_ErrorCode[0])); i++)
+ {
+ if (g_ErrorCode[i].hr == errorval)
+ {
+ return g_ErrorCode[i].szError;
+ }
+ }
+ static char tmp[64];
+ sprintf(tmp, "UNKNOWN: 0x%x", (unsigned int)errorval);
+ return tmp;
+}
+