CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plInputCore/plInputManager.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 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 received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "hsConfig.h"
#include "hsWindows.h"

// plInputManager.cpp
#define DIRECTINPUT_VERSION 0x0800
#include <dinput.h>

#include "hsTypes.h"
#include "plInputManager.h"
#include "plPipeline.h"
#include "plInputDevice.h"
#include "plDInputDevice.h"
#include "../plMessage/plInputEventMsg.h"
#include "plInputInterfaceMgr.h"
#include "hsStream.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnKeyedObject/plFixedKey.h"
#include "hsResMgr.h"
#include "hsTimer.h"
#include "plgDispatch.h"
#include "../pnMessage/plTimeMsg.h"
#include "../pnMessage/plCmdIfaceModMsg.h"
#include "../pnMessage/plPlayerPageMsg.h"

hsBool	plInputManager::fUseDInput = false;
UInt8	plInputManager::bRecenterMouse = 0;
HWND	plInputManager::fhWnd = nil;
#define NUM_ACTIONS		17

struct plDIDevice
{
	plDIDevice() : fDevice(nil), fCaps(nil) {;}
	plDIDevice(IDirectInputDevice8* _device) : fCaps(nil) { fDevice = _device;}
	IDirectInputDevice8*	fDevice;
	DIDEVCAPS*				fCaps;
};

struct plDInput
{
	plDInput() :
	fDInput(nil),
	fActionFormat(nil)
	{;}
	IDirectInput8*			fDInput; 
	hsTArray<plDIDevice*>	fSticks;
	DIACTIONFORMAT*			fActionFormat;
};

class plDInputMgr 
{
public:
	plDInputMgr();
	~plDInputMgr();

	void Init(HINSTANCE hInst, HWND hWnd);
	void Update();
	void AddDevice(IDirectInputDevice8* device);
	void ConfigureDevice();
	virtual hsBool MsgReceive(plMessage* msg);
	
	// dinput callback functions
	static int __stdcall EnumGamepadCallback(const DIDEVICEINSTANCE* device, void* pRef);
// I should be using these but they don't work...
//	static int __stdcall SetAxisRange(const DIDEVICEOBJECTINSTANCE* obj, void* pRef);
//	static int __stdcall EnumSuitableDevices(const struct DIDEVICEINSTANCEA* devInst, struct IDirectInputDevice8* dev, unsigned long why, unsigned long devRemaining, void* pRef);

protected:
	plDInput*					fDI;
	hsTArray<plDInputDevice*>	fInputDevice;
	static DIACTION				fActionMap[];
	HWND						fhWnd;
};
// function pointers to dinput callbacks
typedef int (__stdcall * Pfunc1) (const DIDEVICEINSTANCE* device, void* pRef);
// I should need these...
//typedef int (__stdcall * Pfunc2) (const DIDEVICEOBJECTINSTANCE* device, void* pRef);
//typedef int (__stdcall * Pfunc3) (const struct DIDEVICEINSTANCEA* devInst, struct IDirectInputDevice8* dev, unsigned long why, unsigned long devRemaining, void* pRef); 


plInputManager* plInputManager::fInstance = nil;

plInputManager::plInputManager( HWND hWnd ) :
fDInputMgr(nil),
fInterfaceMgr(nil)
{
	fhWnd = hWnd;
	fInstance = this;
	fActive = false;
	fFirstActivated = false;
	fMouseScale = 1.f;
}

plInputManager::plInputManager() :
fDInputMgr(nil),
fInterfaceMgr(nil)
{
	fInstance = this;
	fActive = false;
	fFirstActivated = false;
	fMouseScale = 1.f;
}

plInputManager::~plInputManager() 
{
	fInterfaceMgr->Shutdown();
	fInterfaceMgr = nil;

	for (int i = 0; i < fInputDevices.Count(); i++)
	{
		fInputDevices[i]->Shutdown();
		delete(fInputDevices[i]);
	}
	if (fDInputMgr)
		delete fDInputMgr;
}

//static
void plInputManager::SetRecenterMouse(hsBool b)
{ 
	if (b)
		bRecenterMouse++;
	else if (bRecenterMouse > 0)
		bRecenterMouse--;
}


void plInputManager::RecenterCursor()
{
	RECT rect;
	GetClientRect(fhWnd, &rect);
	POINT pt;
//	pt.y = ( (rect.bottom - rect.top) / 2 ) / fInstance->fMouseScale;
//	pt.x = ( (rect.right - rect.left) / 2 ) / fInstance->fMouseScale;
	ClientToScreen(fhWnd, &pt);
	SetCursorPos( pt.x, pt.y );
}
void plInputManager::CreateInterfaceMod(plPipeline* p)
{
	fInterfaceMgr = TRACKED_NEW plInputInterfaceMgr();
	fInterfaceMgr->Init();
}

void plInputManager::InitDInput(HINSTANCE hInst, HWND hWnd)
{
	if (fUseDInput)
	{
		fDInputMgr = TRACKED_NEW plDInputMgr;
		fDInputMgr->Init(hInst, hWnd);
	}
}

hsBool plInputManager::MsgReceive(plMessage* msg)
{
	for (int i=0; i<fInputDevices.Count(); i++)
		if (fInputDevices[i]->MsgReceive(msg))
			return true;

	if (fDInputMgr)
		return fDInputMgr->MsgReceive(msg);

	return hsKeyedObject::MsgReceive(msg);
}

void plInputManager::Update()
{
	if (fDInputMgr)
		fDInputMgr->Update();
}

void plInputManager::SetMouseScale( hsScalar s )
{
/*	RECT	rect;
	POINT	currPos;


	// Gotta make sure to move the mouse to the correct new position for the scale
	GetClientRect( fhWnd, &rect );
	GetCursorPos( &currPos );
	ScreenToClient( fhWnd, &currPos );

	float x = (float)currPos.x / rect.right;
	float y = (float)currPos.y / rect.bottom;

	x *= fMouseScale; y *= fMouseScale;

	fMouseScale = s;

	// Refreshes all of the input devices so that they can reset mouse limits, etc
	RECT rect2 = rect;
	rect2.right /= fMouseScale;
	rect2.bottom /= fMouseScale;
	::MapWindowPoints( fhWnd, NULL, (POINT *)&rect2, 2 );
	BOOL ret = ::ClipCursor( &rect );

	// Now move the cursor to the right spot

	currPos.x = ( x / fMouseScale ) * rect.right;
	currPos.y = ( y / fMouseScale ) * rect.bottom;

	ClientToScreen( fhWnd, &currPos );
	SetCursorPos( currPos.x, currPos.y );
*/
}

// Sometimes the keyboard driver "helps" us translating a key involved in a key
// combo. For example pressing shif-numpad8 will actually generate a KEY_UP event,
// the same as the up arrow. This function undoes that translation.
plKeyDef plInputManager::UntranslateKey(plKeyDef key, hsBool extended)
{
	if (!extended)
	{
		if (key == KEY_UP)
			return KEY_NUMPAD8;
		if (key == KEY_DOWN)
			return KEY_NUMPAD2;
		if (key == KEY_LEFT)
			return KEY_NUMPAD4;
		if (key == KEY_RIGHT)
			return KEY_NUMPAD6;
	}

	return key;
}
		
void plInputManager::HandleWin32ControlEvent(UINT message, WPARAM Wparam, LPARAM Lparam, HWND hWnd)
{
	if( !fhWnd )
		fhWnd = hWnd;

	hsBool bExtended;

	switch (message)
	{
	case SYSKEYDOWN:
	case KEYDOWN:
		{
			bExtended = Lparam >> 24 & 1;
			hsBool bRepeat = ((Lparam >> 29) & 0xf) != 0;
			for (int i=0; i<fInputDevices.Count(); i++)
				fInputDevices[i]->HandleKeyEvent( KEYDOWN, UntranslateKey((plKeyDef)Wparam, bExtended), true, bRepeat ); 
		}
		break;
	case SYSKEYUP:
	case KEYUP:
		{
			bExtended = Lparam >> 24 & 1;
			for (int i=0; i<fInputDevices.Count(); i++)
				fInputDevices[i]->HandleKeyEvent( KEYUP, UntranslateKey((plKeyDef)Wparam, bExtended), false, false ); 
		}
		break;
	case MOUSEWHEEL:
		{
			plMouseEventMsg* pMsg = TRACKED_NEW plMouseEventMsg;
			int zDelta = GET_WHEEL_DELTA_WPARAM(Wparam);
			pMsg->SetWheelDelta((float)zDelta);
			if (zDelta < 0)
				pMsg->SetButton(kWheelNeg);
			else
				pMsg->SetButton(kWheelPos);

			RECT rect;
			GetClientRect(hWnd, &rect);
			pMsg->SetXPos(LOWORD(Lparam) / (float)rect.right);
			pMsg->SetYPos(HIWORD(Lparam) / (float)rect.bottom);

			pMsg->Send();
		}
		break;
	case MOUSEMOVE:
	case L_BUTTONDN:
	case L_BUTTONUP:
	case R_BUTTONDN:
	case R_BUTTONUP:
	case L_BUTTONDBLCLK:
	case R_BUTTONDBLCLK:
	case M_BUTTONDN:
	case M_BUTTONUP:
		{
			
			RECT rect;
			GetClientRect(hWnd, &rect);
		 
			plIMouseXEventMsg* pXMsg = TRACKED_NEW plIMouseXEventMsg;
			plIMouseYEventMsg* pYMsg = TRACKED_NEW plIMouseYEventMsg;
			plIMouseBEventMsg* pBMsg = TRACKED_NEW plIMouseBEventMsg;

			pXMsg->fWx = LOWORD(Lparam);
			pXMsg->fX = (float)LOWORD(Lparam) / (float)rect.right;
			pYMsg->fWy = HIWORD(Lparam);
			pYMsg->fY = (float)HIWORD(Lparam) / (float)rect.bottom;

			// Apply mouse scale
//			pXMsg->fX *= fMouseScale;
//			pYMsg->fY *= fMouseScale;
			
			if (Wparam & MK_LBUTTON && message != L_BUTTONUP)
			{
				pBMsg->fButton |= kLeftButtonDown;
			}
			else
			{
				pBMsg->fButton |= kLeftButtonUp;
			}
						
			if (Wparam & MK_RBUTTON && message != R_BUTTONUP)
			{
				pBMsg->fButton |= kRightButtonDown;
			}
			else
			{
				pBMsg->fButton |= kRightButtonUp;
			}
			
			if (Wparam & MK_MBUTTON && message != M_BUTTONUP)
			{
				pBMsg->fButton |= kMiddleButtonDown;
			}
			else
			{
				pBMsg->fButton |= kMiddleButtonUp;
			}
			
			if( message == L_BUTTONDBLCLK )
				pBMsg->fButton |= kLeftButtonDblClk;		// We send the double clicks separately
			if( message == R_BUTTONDBLCLK )
				pBMsg->fButton |= kRightButtonDblClk;

			for (int i=0; i<fInputDevices.Count(); i++)
			{
				fInputDevices[i]->MsgReceive(pXMsg);
				fInputDevices[i]->MsgReceive(pYMsg);
				fInputDevices[i]->MsgReceive(pBMsg);
			}
			POINT pt;
			
			if (RecenterMouse() && (pXMsg->fX <= 0.1 || pXMsg->fX >= 0.9) )
			{		
				pt.x = (rect.right - rect.left) / 2;
				pt.y = HIWORD(Lparam);
				ClientToScreen(hWnd, &pt);
				SetCursorPos( pt.x, pt.y );
			}
			else
			if (RecenterMouse() && (pYMsg->fY <= 0.1 || pYMsg->fY >= 0.9) )
			{		
				pt.y = (rect.bottom - rect.top) / 2;
				pt.x = LOWORD(Lparam);
				ClientToScreen(hWnd, &pt);
				SetCursorPos( pt.x, pt.y );
			}
			if (RecenterMouse() && Lparam == 0)
			{
				pt.y = (rect.bottom - rect.top) / 2;
				pt.x = (rect.right - rect.left) / 2;
				ClientToScreen(hWnd, &pt);
				SetCursorPos( pt.x, pt.y );
			}
			delete(pXMsg);
			delete(pYMsg);
			delete(pBMsg);

			

		}
		break;
	case WM_ACTIVATE:
		{
			bool activated = ( LOWORD( Wparam ) == WA_INACTIVE ) ? false : true;
			Activate( activated );
		}
		break;
	}

}

//// Activate ////////////////////////////////////////////////////////////////
//	Handles what happens when the app (window) activates/deactivates

void	plInputManager::Activate( bool activating )
{
	int		i;


	for( i = 0; i < fInputDevices.GetCount(); i++ )
		fInputDevices[ i ]->HandleWindowActivate( activating, fhWnd );

	fActive = activating;
	fFirstActivated = true;
}

//// AddInputDevice //////////////////////////////////////////////////////////

void	plInputManager::AddInputDevice( plInputDevice *pDev )
{
	fInputDevices.Append( pDev ); 
	if( fFirstActivated )
		pDev->HandleWindowActivate( fActive, fhWnd );
}

//
//
// dinput manager
//
//


plDInputMgr::plDInputMgr() :
fDI(nil)
{
	fDI = TRACKED_NEW plDInput;
}

plDInputMgr::~plDInputMgr()
{
	if (fDI)
	{
		for (int i = 0; i < fDI->fSticks.Count(); i++)
		{	
			plDIDevice* pD = fDI->fSticks[i];
			pD->fDevice->Release();
			delete(pD->fCaps);
			delete(pD);
		}
		fDI->fSticks.SetCountAndZero(0);
		delete(fDI->fActionFormat);
		fDI->fDInput->Release();
		for(int j = 0; j < fInputDevice.Count(); j++)
			delete(fInputDevice[j]);
		fInputDevice.SetCountAndZero(0);
		delete fDI;
	}
}


void plDInputMgr::Init(HINSTANCE hInst, HWND hWnd)
{
	
	HRESULT         hr; 
	hr = DirectInput8Create(hInst, DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&fDI->fDInput, NULL); 
	hsAssert(!hr, "failed to initialize directInput!"); 
	// enumerate game controllers
	Pfunc1 fPtr = &plDInputMgr::EnumGamepadCallback;
	int i = 0;
	

	// set up the action mapping
	fDI->fActionFormat = TRACKED_NEW DIACTIONFORMAT;
	fDI->fActionFormat->dwSize        = sizeof(DIACTIONFORMAT);
	fDI->fActionFormat->dwActionSize  = sizeof(DIACTION);
	fDI->fActionFormat->dwDataSize    = NUM_ACTIONS * sizeof(DWORD);
	fDI->fActionFormat->dwNumActions  = NUM_ACTIONS;
	fDI->fActionFormat->guidActionMap = PL_ACTION_GUID;
	fDI->fActionFormat->dwGenre       = DIVIRTUAL_FIGHTING_THIRDPERSON;
	fDI->fActionFormat->rgoAction     = fActionMap;
	fDI->fActionFormat->dwBufferSize  = 16;
	fDI->fActionFormat->lAxisMin      = -1000;
	fDI->fActionFormat->lAxisMax      = 1000;
	sprintf( fDI->fActionFormat->tszActionMap, "Plasma 2.0 Game Actions" );

	// this call should not work:
	fDI->fDInput->EnumDevices(DI8DEVCLASS_GAMECTRL, fPtr, fDI, DIEDFL_ATTACHEDONLY); 
	
	// apply the mapping to the game controller	
	// this is the correct <but broken> way to apply the action map:
//	Pfunc3 fPtr3 = &plDInputMgr::EnumSuitableDevices;
//	hr = fDI->fDInput->EnumDevicesBySemantics(NULL, fDI->fActionFormat, EnumSuitableDevices, fDI, NULL);

	
	for (i = 0; i < fDI->fSticks.Count(); i++)
	{
		fDI->fSticks[i]->fCaps = TRACKED_NEW DIDEVCAPS; 
		fDI->fSticks[i]->fCaps->dwSize = sizeof(DIDEVCAPS);
		hr = fDI->fSticks[i]->fDevice->GetCapabilities(fDI->fSticks[i]->fCaps);
		hsAssert(!hr, "Unable to acquire devcaps in DInput Device!"); 
		hr = fDI->fSticks[i]->fDevice->Acquire();
		hsAssert(!hr, "Unable to acquire DInput Device!"); 
	}

	fhWnd = hWnd;
	
	for (i = 0; i < fDI->fSticks.Count(); i++)
		fInputDevice.Append( TRACKED_NEW plDInputDevice );
}

void plDInputMgr::Update()
{
	HRESULT     hr;
 
    if (!fDI->fSticks.Count()) 
        return;

    // Poll the devices to read the current state
    for (int i = 0; i < fDI->fSticks.Count(); i++)
	{
 		hr = fDI->fSticks[i]->fDevice->Poll(); 
		if (FAILED(hr))  
		{
			// Attempt to reacquire joystick
			while(hr == DIERR_INPUTLOST) 
			{	
				hr = fDI->fSticks[i]->fDevice->Acquire();
				char str[256];
				sprintf(str, "DInput Device # %d connection lost - press Ignore to attempt to reacquire!", i);
				hsAssert(!hr, str); 
			}
		}
		
		DIDEVICEOBJECTDATA data; 
		ULONG size = 1;
		hr = fDI->fSticks[i]->fDevice->GetDeviceData(sizeof(DIDEVICEOBJECTDATA),&data,&size,0); 

		fInputDevice[i]->Update(&data);
	}
}

void plDInputMgr::AddDevice(IDirectInputDevice8* device)
{
	HRESULT hr = device->BuildActionMap(fDI->fActionFormat, NULL, NULL);
	if (!FAILED(hr))
		device->SetActionMap( fDI->fActionFormat, NULL, NULL );
}

void plDInputMgr::ConfigureDevice()
{
	::ClipCursor(nil);
	::ShowCursor( TRUE );
	ReleaseCapture();
		

	DICOLORSET dics;
    ZeroMemory(&dics, sizeof(DICOLORSET));
    dics.dwSize = sizeof(DICOLORSET);

    DICONFIGUREDEVICESPARAMS dicdp;
    ZeroMemory(&dicdp, sizeof(dicdp));
    dicdp.dwSize = sizeof(dicdp);
    dicdp.dwcUsers       = 1;
    dicdp.lptszUserNames = NULL;
    
    dicdp.dwcFormats     = 1;
    dicdp.lprgFormats    = fDI->fActionFormat;
    dicdp.hwnd           = fhWnd;
    dicdp.lpUnkDDSTarget = NULL;

	fDI->fDInput->ConfigureDevices(NULL, &dicdp, DICD_EDIT, NULL);
	for (int i = 0; i < fDI->fSticks.Count(); i++)
		fDI->fSticks[i]->fDevice->SetActionMap( fDI->fActionFormat, NULL, DIDSAM_FORCESAVE );

	RECT rect;
	::GetClientRect(fhWnd,&rect);
	::ClientToScreen(fhWnd,(LPPOINT)&rect);
	::ClipCursor(&rect);
	::ShowCursor( FALSE );
	SetCapture(fhWnd);

}

hsBool plDInputMgr::MsgReceive(plMessage* msg)
{
	plInputEventMsg* pMsg = plInputEventMsg::ConvertNoRef(msg);
	if (pMsg && pMsg->fEvent == plInputEventMsg::kConfigure)
	{
		ConfigureDevice();
	}
	return false;
}

// dinput required callback functions:

// enumerate the dinput devices 
int __stdcall plDInputMgr::EnumGamepadCallback(const DIDEVICEINSTANCE* device, void* pRef)
{
	HRESULT hr;
	
	plDInput* pDI = (plDInput*)pRef;
	IDirectInputDevice8* fStick = nil;
    hr = pDI->fDInput->CreateDevice(device->guidInstance, &fStick, NULL);
	
	if(!FAILED(hr)) 
	{
        pDI->fSticks.Append(TRACKED_NEW plDIDevice(fStick));
		
		// the following code pertaining to the action map shouldn't be here.
		// in fact this shouldn't work at all according to MS, but this is 
		// currently the only way this works.  Whatever - the correct
		// code is here and commented out in case this ever gets fixed by MS
		// in a future release of dinput.
		HRESULT hr = fStick->BuildActionMap(pDI->fActionFormat, NULL, NULL);
		if (!FAILED(hr))
		{
			hr = fStick->SetActionMap( pDI->fActionFormat, NULL, NULL );

			DIPROPDWORD dipW; 
			dipW.diph.dwSize		= sizeof(DIPROPDWORD); 
			dipW.diph.dwHeaderSize	= sizeof(DIPROPHEADER); 
			dipW.diph.dwHow			= DIPH_DEVICE; 
			dipW.diph.dwObj			= 0;
			dipW.dwData				= 500; // 5% of axis range for deadzone

			hr = fStick->SetProperty(DIPROP_DEADZONE , &dipW.diph);
		}
		return DIENUM_CONTINUE;
	}
    return DIENUM_STOP;
}

// look for axes on the controller and set the output range to +-100
// apparently not needed with action mapping:
/*
int __stdcall plDInputMgr::SetAxisRange(const DIDEVICEOBJECTINSTANCE* obj, void* pRef)
{
	HRESULT hr;
	DIPROPRANGE diprg; 

	diprg.diph.dwSize       = sizeof(DIPROPRANGE); 
	diprg.diph.dwHeaderSize = sizeof(DIPROPHEADER); 
	diprg.diph.dwHow        = DIPH_BYID; 
	diprg.diph.dwObj        = obj->dwType; 
	diprg.lMin              = -100; 
	diprg.lMax              = +100; 

	plDInput* pDI = (plDInput*)pRef;
	for (int i = 0; i < pDI->fSticks.Count(); i++)
		hr = pDI->fSticks[i]->fDevice->SetProperty(DIPROP_RANGE, &diprg.diph);

	if(!FAILED(hr)) 
        return DIENUM_CONTINUE;
	
    return DIENUM_STOP;

}
*/

// apply mapping to controller
// not used.  why? no one really knows.
// leave this here in case dinput ever gets fixed...
/*
int __stdcall plDInputMgr::EnumSuitableDevices(const struct DIDEVICEINSTANCEA* devInst, struct IDirectInputDevice8* dev, unsigned long why, unsigned long devRemaining, void* pRef)
{
	plDInput* pDI = (plDInput*)pRef;
	HRESULT hr = dev->BuildActionMap(pDI->fActionFormat, NULL, NULL);
	if (!FAILED(hr))
	{
		hr = dev->SetActionMap( pDI->fActionFormat, NULL, NULL );
	}
	return DIENUM_STOP;
}
*/
DIACTION plDInputMgr::fActionMap[NUM_ACTIONS] =
{
	{A_CONTROL_MOVE,			DIAXIS_TPS_MOVE,		0,	"Walk Forward-Backward"	,},
	{A_CONTROL_TURN,			DIAXIS_TPS_TURN,		0,	"Turn Left-Right"		,},
	{A_CONTROL_MOUSE_X,			DIAXIS_ANY_1,			0,	"Move Camera Left-Right",},
	{A_CONTROL_MOUSE_Y,			DIAXIS_ANY_2,			0,	"Move Camera Up-Down"	,},
	{B_CONTROL_ACTION,			DIBUTTON_TPS_ACTION,	0,	"Action"				,},
	{B_CONTROL_JUMP,			DIBUTTON_TPS_JUMP,		0,	"Jump"					,},
	{B_CONTROL_STRAFE_LEFT,		DIBUTTON_TPS_STEPLEFT,	0,	"Strafe Left"			,},
	{B_CONTROL_STRAFE_RIGHT,	DIBUTTON_TPS_STEPRIGHT,	0,	"Strafe Right"			,},
	{B_CONTROL_MODIFIER_FAST,	DIBUTTON_TPS_RUN,		0,	"Run"					,},
	{B_CONTROL_EQUIP,			DIBUTTON_TPS_SELECT,	0,	"Equip Item"			,},
	{B_CONTROL_DROP,			DIBUTTON_TPS_USE,		0,	"Drop Item"				,},
	{B_CONTROL_MOVE_FORWARD,	DIBUTTON_ANY(0),		0,	"Walk Forward"			,},
	{B_CONTROL_MOVE_BACKWARD,	DIBUTTON_ANY(1),		0,	"Walk Backward"			,},
	{B_CONTROL_ROTATE_LEFT,		DIBUTTON_ANY(2),		0,	"Turn Left"				,},
	{B_CONTROL_ROTATE_RIGHT,	DIBUTTON_ANY(3),		0,	"Turn Right"			,},
	{B_CONTROL_TURN_TO,			DIBUTTON_ANY(4),		0,	"Pick Item"				,},
	{B_CAMERA_RECENTER,			DIBUTTON_ANY(5),		0,	"Recenter Camera"		,},
};