int refresh_gamepads(HWND hwnd)
{
int test=FALSE;
int i;
LPDIRECTINPUT8 dinp;
SendMessage(hwnd,CB_RESETCONTENT,0,0);
if(test){
DIDEVICEINSTANCE di;
sprintf(di.tszInstanceName,"adaptoid");
for(i=0;i<4;i++){
di.guidInstance.Data1=rand();
enum_gamepads(&di,hwnd);
}
printf("press key\n");
// getkey();
}
else
if(DirectInput8Create(GetModuleHandle(0),DIRECTINPUT_VERSION,&IID_IDirectInput8,(void *)&dinp,0)==DI_OK){
IDirectInput8_EnumDevices(dinp, DI8DEVCLASS_GAMECTRL, enum_gamepads,
hwnd, DIEDFL_ATTACHEDONLY);
}
SendMessage(hwnd,CB_SETCURSEL,0,0);
return TRUE;
}
static void test_GetDeviceStatus(void)
{
IDirectInput8A *pDI;
HRESULT hr;
hr = DirectInput8Create(hInstance, DIRECTINPUT_VERSION, &IID_IDirectInput8A, (void **)&pDI, NULL);
if (FAILED(hr))
{
win_skip("Failed to instantiate a IDirectInputA instance: 0x%08x\n", hr);
return;
}
hr = IDirectInput8_GetDeviceStatus(pDI, NULL);
ok(hr == E_POINTER, "IDirectInput8_GetDeviceStatus returned 0x%08x\n", hr);
hr = IDirectInput8_GetDeviceStatus(pDI, &GUID_Unknown);
todo_wine
ok(hr == DIERR_DEVICENOTREG, "IDirectInput8_GetDeviceStatus returned 0x%08x\n", hr);
hr = IDirectInput8_GetDeviceStatus(pDI, &GUID_SysMouse);
ok(hr == DI_OK, "IDirectInput8_GetDeviceStatus returned 0x%08x\n", hr);
IDirectInput8_Release(pDI);
}
InputLayer::InputLayer(
HINSTANCE hInst,
HWND hWnd,
bool bExclusive,
bool bUseKeyboard,
bool bUseMouse )
{
m_pKeyboard = NULL;
m_pMouse = NULL;
if( m_pGlobalILayer )
{
assert(false);
}
m_pGlobalILayer = this;
HRESULT hr;
/**
* ´´½¨DI8 ¶ÔÏó
*/
HR(DirectInput8Create( hInst, DIRECTINPUT_VERSION,
IID_IDirectInput8, (void**)&m_pDI, NULL ));
if( bUseKeyboard )
{
m_pKeyboard = new Keyboard( hWnd );
}
if( bUseMouse )
{
m_pMouse = new Mouse( hWnd, bExclusive );
}
}
bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight)
{
HRESULT result;
// Initialize the location of the mouse on the screen.
m_mouseX = 0;
m_mouseY = 0;
// Store the screen size which will be used for positioning the mouse cursor.
m_screenWidth = screenWidth;
m_screenHeight = screenHeight;
// Initialize the main direct input interface.
result = DirectInput8Create(hinstance, DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&m_directInput, NULL);
if(FAILED(result))
{
return false;
}
// Initialize the direct input interface for the keyboard.
result = m_directInput->CreateDevice(GUID_SysKeyboard, &m_keyboard, NULL);
if(FAILED(result))
{
return false;
}
// Set the data format. In this case since it is a keyboard we can use the predefined data format.
result = m_keyboard->SetDataFormat(&c_dfDIKeyboard);
if(FAILED(result))
{
return false;
}
// Set the cooperative level of the keyboard to not share with other programs.
result = m_keyboard->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_EXCLUSIVE);
if(FAILED(result))
{
return false;
}
// Now acquire the keyboard.
result = m_keyboard->Acquire();
if(FAILED(result))
{
return false;
}
// Initialize the direct input interface for the mouse.
result = m_directInput->CreateDevice(GUID_SysMouse, &m_mouse, NULL);
if(FAILED(result))
{
return false;
}
// Set the data format for the mouse using the pre-defined mouse data format.
result = m_mouse->SetDataFormat(&c_dfDIMouse);
if(FAILED(result))
{
return false;
}
// Set the cooperative level of the mouse to share with other programs.
result = m_mouse->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
if(FAILED(result))
{
return false;
}
// Acquire the mouse.
result = m_mouse->Acquire();
if(FAILED(result))
{
return false;
}
return true;
}
// Initialise runtime
bool CRuntime::Initialise(CRuntimeSetup* crSetup)
{
// Start by getting and saving the CPU capabilities.
DWORD cpuFeatures = GetCPUCaps();
supportMMX = cpuFeatures & CPU_FEATURE_MMX;
supportSSE = cpuFeatures & CPU_FEATURE_SSE;
supportSSE2 = cpuFeatures & CPU_FEATURE_SSE2;
// Construct requires MMX for collisions
#ifndef APPRUNTIME
if (!supportMMX)
throw runtime_error("Your CPU does not support MMX technology (it must be pretty old!). Please buy a newer PC then try again!");
#endif
// Save hInstance
hInstance = crSetup->hInstance;
CapReader.pRuntime = this;
CreateTempDirectory();
// Get app properties
BYTE* pData;
int dataSize;
HGLOBAL hData = OpenResourceBinary(997, "APPBLOCK", pData, dataSize);
CapReader.ReadAppProperties(pData, dataSize, props);
FreeResource(hData);
// Cannot use both multisampling and motion blur
#ifndef APPRUNTIME
if (multisamples > 0 && motionBlur)
throw runtime_error("Cannot enable both multisamples and motion blur. Please change one of these settings.");
#endif
#ifdef PYTHON
// Get python
hData = OpenResourceBinary(992, "PYTHONLIBS", pData, dataSize);
CapReader.ReadPythonResources(pData, dataSize);
FreeResource(hData);
if(!SearchPath(NULL, "python26.dll", NULL, 0, NULL, NULL))
throw runtime_error("Python26.dll was not found and is required to run this application or feature. Reinstalling the application "
"may fix this problem.");
Py_Initialize();
#endif
// Get menu resources
hData = OpenResourceBinary(993, "MENUBLOCK", pData, dataSize);
CapReader.ReadMenuResources(pData, dataSize, menus);
FreeResource(hData);
crSetup->winWidth = props.winWidth;
crSetup->winHeight = props.winHeight;
crSetup->eyeDistance = props.eyeDistance;
crSetup->screensaver = props.screensaver;
fpsMode = props.fpsMode;
userFps = props.fps;
//if (disableWindowsKey)
// g_hKeyboardHook = SetWindowsHookEx( WH_KEYBOARD_LL, DisableWinKeyKeyboardProc, hInstance, 0);
#ifdef CONSTRUCT_DIRECTX9
crSetup->display_params.fps_mode = props.fpsMode;
crSetup->display_params.fullscreen = fullscreen = props.fullscreen;
crSetup->display_params.backbuffer_width = props.winWidth;
crSetup->display_params.backbuffer_height = props.winHeight;
switch (multisamples) {
case 0: // Off
crSetup->display_params.multisamples = 0;
break;
case 1: // 2x
crSetup->display_params.multisamples = 2;
break;
case 2: // 4x
crSetup->display_params.multisamples = 4;
break;
case 3: // 8x
crSetup->display_params.multisamples = 8;
break;
default:
crSetup->display_params.multisamples = 0;
break;
}
// PreInit gets the D3D caps and allows MakeWindows to create the correct number of windows to pass to Init()
//Display.SetMultiMonitorMode(MMM_CLONE);
//Display.PreInit();
renderer.LoadD3D();
#endif
#ifndef CONSTRUCT_SDL
// Create a window for the runtime
if (!MakeWindows(crSetup))
throw runtime_error("Cannot create window");
#else
if (SDL_Init(SDL_INIT_VIDEO) < 0)
exit(1);
// Register SDL_Quit to be called at exit; makes sure things are cleaned up when we quit.
atexit(SDL_Quit);
// Attempt to create window with 32bit pixels in hardware
Display.screen = SDL_SetVideoMode(props.winWidth, props.winHeight, 32, SDL_HWSURFACE);
SDL_SetAlpha(Display.screen, SDL_SRCALPHA, 255); // Set alpha to normal
#endif
InitCommonControls();
// The preview runtimes show the runtime in the title bar.
#ifdef CONSTRUCT_PREVIEW
#ifdef CONSTRUCT_DIRECTX9
props.appTitle += " (DX9 runtime)";
#endif
#ifdef APPRUNTIME
props.appTitle += " (App runtime)";
#endif
#ifdef CONSTRUCT_SDL
props.appTitle += " (SDL runtime)";
#endif
#endif
#ifndef CONSTRUCT_SDL
SetWindowText(hWnds.front(), props.appTitle);
#else
SDL_WM_SetCaption(props.appTitle, NULL);
#endif
// Restore mouse cursor from hourglass
if (!props.screensaver)
SetCursor(LoadCursor(NULL, IDC_ARROW));
// Load a menu
if (props.UseMenu)
if (menus.size() != 0)
SetMenu(hWnds.front(), menus[0]);
#ifndef APPRUNTIME
#ifndef CONSTRUCT_SDL
// Direct-X setup
crSetup->display_params.hWnds = hWnds;
crSetup->display_params.hFocusWnd = hWnds.front();
winWidthOffset = 0;
winHeightOffset = 0;
// Retrieve all display modes: can't set an invalid display mode size
if (crSetup->display_params.fullscreen) {
BOOL bRetVal;
DEVMODE devMode;
int iMode = 0;
int wantedWidth = crSetup->display_params.backbuffer_width;
int wantedHeight = crSetup->display_params.backbuffer_height;
int bestWidth = 100000;
int bestHeight = 100000;
bool found = false;
do
{
bRetVal = ::EnumDisplaySettings(NULL, iMode, &devMode);
iMode++;
if (bRetVal)
{
int curWidth = devMode.dmPelsWidth;
int curHeight = devMode.dmPelsHeight;
// Display mode found!
if (curWidth == wantedWidth && curHeight == wantedHeight)
found = true;
// This display mode is big enough to fit the display in, but is smaller than the last best size
if ((curWidth >= wantedWidth && curHeight >= wantedHeight)
&& (curWidth < bestWidth && curHeight < bestHeight)) {
bestWidth = curWidth;
bestHeight = curHeight;
}
}
}
while (bRetVal);
// Identical display mode not found: use next best that can fit it all on
if (!found) {
// Still 100000x100000: no resolution found that supports this
if (bestWidth == 100000 || bestHeight == 100000)
throw runtime_error("The display resolution required by this application is not supported.");
#ifdef CONSTRUCT_PREVIEW
CString msg;
msg.Format("Switching to Fullscreen mode: Display mode %d x %d not supported, switching to next best %d x %d.\n\n"
"The 'Window Width' and 'Window Height' values in Application Properties define the fullscreen resolution.",
crSetup->display_params.backbuffer_width, crSetup->display_params.backbuffer_height, bestWidth, bestHeight);
MessageBox(NULL, msg, "Fullscreen preview", MB_OK | MB_ICONEXCLAMATION);
#endif
crSetup->display_params.backbuffer_width = wantedWidth = bestWidth;
crSetup->display_params.backbuffer_height = wantedHeight = bestHeight;
}
}
// Set the eye distance before we initialize
eyeDistance = crSetup->eyeDistance;
renderer.SetEyeDistance(eyeDistance);
// Start up the display engine
//Display.Init(&(crSetup->d3dDisplaySetup));
renderer.CreateDevice(crSetup->display_params);
/*
// No identical match for display mode
if (crSetup->d3dDisplaySetup.resWidth != actualDisplayWidth || crSetup->d3dDisplaySetup.resHeight != actualDisplayHeight)
if (tempDisplayTarget == unallocated_texture)
tempDisplayTarget = CreateDisplayTargetTexture();
winWidthOffset = (actualDisplayWidth - crSetup->d3dDisplaySetup.resWidth) / 2;
winHeightOffset = (actualDisplayHeight - crSetup->d3dDisplaySetup.resHeight) / 2;
}
*/
GetSwapChains();
// Multi-monitor settings require the temp display target
if (renderer.GetMultiMonitorMode() != cr::multimonitor_singlescreen) {
if (tempDisplayTarget == unallocated_texture)
tempDisplayTarget = CreateDisplayTargetTexture();
}
// Linear resizers
if (props.sampler == 0) {
renderer.SetSamplerState(cr::ss_magfilter, cr::ssv_point);
renderer.SetSamplerState(cr::ss_minfilter, cr::ssv_point);
}
if (props.sampler == 1) {
renderer.SetSamplerState(cr::ss_magfilter, cr::ssv_linear);
renderer.SetSamplerState(cr::ss_minfilter, cr::ssv_linear);
}
// Premultiplied alpha mode
renderer.SetAlphaBlending();
// Runtime uses clamp-sampling
renderer.SetSamplerState(cr::ss_addressu, cr::ssv_clamp);
renderer.SetSamplerState(cr::ss_addressv, cr::ssv_clamp);
// Create the multisampling target if one required
//if (multisamples > 0) // 0 is off
// multisampleTargets[0] = renderer.CreateRenderTargetTexture(crSetup->winWidth, crSetup->winHeight, cr::texture_format_a8r8g8b8, true);
#if defined(CONSTRUCT_DIRECTX9) && defined(CONSTRUCT_PREVIEW)
// Handle shader simulation
if (simShader != SS_NOSIM) {
UINT ps_major = D3DSHADER_VERSION_MAJOR(renderer.GetCaps().PixelShaderVersion);
UINT ps_minor = D3DSHADER_VERSION_MINOR(renderer.GetCaps().PixelShaderVersion);
CString hardwarePS;
hardwarePS.Format("%d.%d", ps_major, ps_minor);
CString simulatedPS;
switch (simShader) {
case SS_PS14:
simulatedPS = "1.4";
break;
case SS_PS11:
simulatedPS = "1.1";
break;
case SS_PS00:
simulatedPS = "0.0";
break;
}
float ps_version = atof(hardwarePS);
float sim_version = atof(simulatedPS);
// If fullscreen MessageBox()'s won't work
if (!fullscreen) {
if (sim_version > ps_version) {
CString msg;
msg.Format("You have chosen to simulate a pixel shader version (PS %s) higher than your hardware supports (PS %s). "
"You can only simulate lower hardware capabilities. The application will continue to use PS %s.",
simulatedPS, hardwarePS, simulatedPS);
MessageBox(NULL, msg, "Simulate shader", MB_OK | MB_ICONEXCLAMATION);
}
else if (sim_version == ps_version) {
CString msg;
msg.Format("You have chosen to simulate the same pixel shader version as your hardware supports (PS %s). "
"The application will continue normally.", hardwarePS);
MessageBox(NULL, msg, "Simulate shader", MB_OK | MB_ICONINFORMATION);
}
else {
CString msg;
msg.Format("You are simulating pixel shader %s capabilites. Your hardware supports pixel shader %s.",
simulatedPS, hardwarePS);
MessageBox(NULL, msg, "Simulate shader", MB_OK | MB_ICONEXCLAMATION);
}
}
}
#endif // shader sims
#endif
// Load the PNG image list
hData = OpenResourceBinary(995, "IMAGEBLOCK", pData, dataSize);
CapReader.ReadImageData(pData, dataSize, imagehandle_to_address);
FreeResource(hData);
#ifdef CONSTRUCT_DIRECTX9
// Initialise DirectInput
if (FAILED(DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
IID_IDirectInput8, (void**)&dinput, NULL)))
throw runtime_error("Failed to initialise DirectInput. Please ensure you have DirectX 8 or above installed!");
// Initialize the keyboard
if (FAILED(dinput->CreateDevice(GUID_SysKeyboard, &d_keyboard, NULL)))
throw runtime_error("Failed to initialise DirectInput.");
if (FAILED(d_keyboard->SetDataFormat(&c_dfDIKeyboard)))
throw runtime_error("Failed to initialise DirectInput.");
if (FAILED(d_keyboard->SetCooperativeLevel(hWnds.front(), DISCL_BACKGROUND |
DISCL_NONEXCLUSIVE)))
throw runtime_error("Failed to initialise DirectInput.");
if (FAILED(d_keyboard->Acquire()))
throw runtime_error("Failed to initialise DirectInput.");
// initialize the mouse
if (FAILED(dinput->CreateDevice(GUID_SysMouse, &d_mouse, NULL)))
throw runtime_error("Failed to initialise DirectInput.");
if (FAILED(d_mouse->SetCooperativeLevel(hWnds.front(), DISCL_BACKGROUND |
DISCL_NONEXCLUSIVE)))
throw runtime_error("Failed to initialise DirectInput.");
if (FAILED(d_mouse->SetDataFormat(&c_dfDIMouse)))
throw runtime_error("Failed to initialise DirectInput.");
if (FAILED(d_mouse->Acquire()))
throw runtime_error("Failed to initialise DirectInput.");
inputState.isDirectInput = true;
#endif
#endif //#ifndef APPRUNTIME
// Save window dimensions
winWidth = crSetup->winWidth;
winHeight = crSetup->winHeight;
RECT clientSize;
GetClientRect(hWnds.front(), &clientSize);
realWinWidth = clientSize.right - clientSize.left;
realWinHeight = clientSize.bottom - clientSize.top;
// Unpack dependencies before loading plugins
UnpackDependencies();
// Unpack the resource plugins to the temp dir and load them
UnpackPlugins(1000);
// Read the frame data
hData = OpenResourceBinary(998, "LEVELBLOCK", pData, dataSize);
CapReader.ReadFrameData(pData, dataSize);
FreeResource(hData);
// Map object type names to their pointers
for (vector<CRunObjType*>::iterator i = objects.begin(); i != objects.end(); i++)
{
CString lowername = (*i)->Name;
lowername.MakeLower();
name_to_object[lowername] = *i;
}
#ifdef CONSTRUCT_DEBUGGER
// Create debugger once object types are known but before parsing event block (which may send logs)
// Create invisible initially
pDebug->Create();
pDebug->ShowWindow(SW_HIDE);
#endif
// Read the CAP event tree
hData = OpenResourceBinary(999, "EVENTBLOCK", pData, dataSize);
CapReader.ReadEventList(pData, dataSize);
FreeResource(hData);
// Iterate all events determining their modifiers
vector<CRunLayout*>::iterator f = Frames.begin();
const vector<CRunLayout*>::const_iterator Frames_end = Frames.end();
for ( ; f != Frames_end; f++) {
EventIterator e = (*f)->Events.begin();
EventConstIterator Events_end = (*f)->Events.end();
for ( ; e != Events_end; ++e) {
// Recurse down tree finding SOL modifiers
(*e)->GetSolModifiers(*f);
// If this event line is a group, it can be marked as top level for optimisation
if ((*e)->GetType() == EVENT_GROUP)
((CEventGroup*)*e)->isTopLevel = true;
}
}
// Initialise effects
#ifdef CONSTRUCT_DIRECTX9
hData = OpenResourceBinary(994, "HLSL", pData, dataSize);
CapReader.ReadHLSLData(pData, dataSize);
FreeResource(hData);
// If motionblur is required, set up the textures
if (motionBlur) {
InitMotionBlur();
}
#endif //APPRUNTIME
// Clock offset (timers relative to Run())
clockOffset = clock();
curFrame = 0;
// Mark objects which are not to serialize
CRunObjType* pNoSerialize = GetTypeFromName("No serialize");
if (pNoSerialize) {
if (!pNoSerialize->teams.empty()) {
ObjTypeIterator t = pNoSerialize->teams.begin();
ObjTypeIterator end = pNoSerialize->teams.end();
for ( ; t != end; t++)
(*t)->noSerialize = true;
}
}
// Set current frame
CRunLayout* pFirstFrame = Frames.front();
runningFrames.push_back(pFirstFrame);
system.pLayout = pFirstFrame;
pFirstFrame->systemDrawn = true;
pFirstFrame->Load();
// Load any other layouts which want their textures loaded on startup
vector<CRunLayout*>::iterator ly = Frames.begin();
ly++; // already loaded 1st layout
for ( ; ly != Frames.end(); ++ly) {
if ((*ly)->texture_loading == CRunLayout::tl_load_on_app_start)
(*ly)->LoadLayoutTextures();
else if ((*ly)->texture_loading == CRunLayout::tl_use_app_setting && texture_loading == tl_load_on_app_start)
(*ly)->LoadLayoutTextures();
}
// Directories exist etc. by now.
completedInitialisation = true;
// Initial frame mouse coord
POINT mouse;
GetCursorPos(&mouse);
if (!fullscreen)
ScreenToClient(hWnds.front(), &mouse);
pFirstFrame->mouseX = mouse.x;
pFirstFrame->mouseY = mouse.y;
// Create initial frame objects (generatevent works)
pFirstFrame->CreateInitialObjects();
FlushDelayedObjects();
system.changeResWidth = winWidth;
system.changeResHeight = winHeight;
// Start of Layout triggered only if not previewing another layout
if (previewLayout <= 0)
GenerateEvent(-1, SYSTEM_STARTOFFRAME, NULL);
#ifdef CONSTRUCT_DEBUGGER
pDebug->ShowWindow(SW_SHOW);
pDebug->SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
pDebug->ModifyStyleEx(0, WS_EX_TOPMOST);
#endif
// Previewing single layout?
if (previewLayout > 0) // if == 0, no need to jump anywhere, already on layout 1
system.DoFrameChange(previewLayout, "none", 0);
return true;
}
bool Input::init(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight)
{
HRESULT result;
//store the screen width and height
m_screenWidth = screenWidth;
m_screenHeight = screenHeight;
//init the mouse location
m_mouseX = 0;
m_mouseY = 0;
//init the main direct input interface
result = DirectInput8Create(hinstance, DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&m_directInput, NULL);
if (FAILED(result))
{
return false;
}
//init the direct input interface for the keyboard
result = m_directInput->CreateDevice(GUID_SysKeyboard, &m_keyboard, NULL);
if (FAILED(result))
{
return false;
}
//set the data format, since it is a keyboard use the defualt keyboard format
result = m_keyboard->SetDataFormat(&c_dfDIKeyboard);
if (FAILED(result))
{
return false;
}
//Set the cooperative level of the keyboard to not share with other programs
result = m_keyboard->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_EXCLUSIVE);
if (FAILED(result))
{
return false;
}
//now aquire the keyboard
result = m_keyboard->Acquire();
if (FAILED(result))
{
return false;
}
//init the direct input interface for the mouse
result = m_directInput->CreateDevice(GUID_SysMouse, &m_mouse, NULL);
if (FAILED(result))
{
return false;
}
//set the data format for th mouse to use
result = m_mouse->SetDataFormat(&c_dfDIMouse);
if (FAILED(result))
{
return false;
}
//Aquire the mouse
result = m_mouse->Acquire();
if (FAILED(result))
{
return false;
}
return true;
}
C_RESULT open_dx_gamepad(void)
{
HRESULT hr;
HWND hDlg = GetConsoleHwnd();
// Register with the DirectInput subsystem and get a pointer
// to a IDirectInput interface we can use.
// Create a DInput object
if (g_pDI==NULL)
if( VP_FAILED( hr = DirectInput8Create( GetModuleHandle( NULL ), DIRECTINPUT_VERSION,
IID_IDirectInput8, ( VOID** )&g_pDI, NULL ) ) )
return hr;
if( g_bFilterOutXinputDevices )
SetupForIsXInputDevice();
DIJOYCONFIG PreferredJoyCfg = {0};
DI_ENUM_CONTEXT enumContext;
enumContext.pPreferredJoyCfg = &PreferredJoyCfg;
enumContext.bPreferredJoyCfgValid = false;
IDirectInputJoyConfig8* pJoyConfig = NULL;
if( VP_FAILED( hr = g_pDI->QueryInterface( IID_IDirectInputJoyConfig8, ( void** )&pJoyConfig ) ) )
return hr;
PreferredJoyCfg.dwSize = sizeof( PreferredJoyCfg );
if( SUCCEEDED( pJoyConfig->GetConfig( 0, &PreferredJoyCfg, DIJC_GUIDINSTANCE ) ) ) // This function is expected to fail if no g_pJoystick is attached
enumContext.bPreferredJoyCfgValid = true;
SAFE_RELEASE( pJoyConfig );
// Look for a simple g_pJoystick we can use for this sample program.
if( VP_FAILED( hr = g_pDI->EnumDevices( DI8DEVCLASS_GAMECTRL,
Enumg_pJoysticksCallback,
&enumContext, DIEDFL_ATTACHEDONLY ) ) )
return hr;
if( g_bFilterOutXinputDevices )
CleanupForIsXInputDevice();
// Make sure we got a g_pJoystick
if( g_pJoystick == NULL )
{
//MessageBox( NULL, TEXT( "Joystick not found." ),
// TEXT( "A.R. Drone"),
// MB_ICONERROR | MB_OK );
// EndDialog( hDlg, 0 );
return C_FAIL;
}
// Set the data format to "simple g_pJoystick" - a predefined data format
//
// A data format specifies which controls on a device we are interested in,
// and how they should be reported. This tells DInput that we will be
// passing a DIJOYSTATE2 structure to IDirectInputDevice::GetDeviceState().
if( VP_FAILED( hr = g_pJoystick->SetDataFormat( &c_dfDIJoystick2 ) ) )
return C_FAIL;
// Set the cooperative level to let DInput know how this device should
// interact with the system and with other DInput applications.
if( VP_FAILED( hr = g_pJoystick->SetCooperativeLevel( hDlg , DISCL_EXCLUSIVE |
DISCL_FOREGROUND ) ) )
return C_FAIL;
// Enumerate the g_pJoystick objects. The callback function enabled user
// interface elements for objects that are found, and sets the min/max
// values property for discovered axes.
if( VP_FAILED( hr = g_pJoystick->EnumObjects( EnumObjectsCallback,
( VOID* )hDlg, DIDFT_ALL ) ) )
return C_FAIL;
return C_OK;
}
void CDirectXFramework::Init(HWND& hWnd, HINSTANCE& hInst, bool bWindowed)
{
m_hWnd = hWnd;
//////////////////////////////////////////////////////////////////////////
// Direct3D Foundations - D3D Object, Present Parameters, and D3D Device
//////////////////////////////////////////////////////////////////////////
// Create the D3D Object
m_pD3DObject = Direct3DCreate9(D3D_SDK_VERSION);
// create the direct input object
DirectInput8Create(hInst,
DIRECTINPUT_VERSION,
IID_IDirectInput8,
(void**)&m_pDInputObject, NULL);
//RECT
// Find the width and height of window using hWnd and GetWindowRect()
RECT rect;
GetWindowRect(hWnd, &rect);
int screenWidth = rect.right - rect.left;
int screenHeight = rect.bottom - rect.top;
// Set D3D Device presentation parameters before creating the device
D3DPRESENT_PARAMETERS D3Dpp;
ZeroMemory(&D3Dpp, sizeof(D3Dpp)); // NULL the structure's memory
D3Dpp.hDeviceWindow = hWnd; // Handle to the focus window
D3Dpp.Windowed = bWindowed; // Windowed or Full-screen boolean
D3Dpp.AutoDepthStencilFormat = D3DFMT_D24S8; // Format of depth/stencil buffer, 24 bit depth, 8 bit stencil
D3Dpp.EnableAutoDepthStencil = TRUE; // Enables Z-Buffer (Depth Buffer)
D3Dpp.BackBufferCount = 1; // Change if need of > 1 is required at a later date
D3Dpp.BackBufferFormat = D3DFMT_X8R8G8B8; // Back-buffer format, 8 bits for each pixel
D3Dpp.BackBufferHeight = screenHeight + 424; // Make sure resolution is supported, use adapter modes
D3Dpp.BackBufferWidth = screenWidth + 224; // (Same as above)
D3Dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; // Discard back-buffer, must stay discard to support multi-sample
D3Dpp.PresentationInterval = m_bVsync ? D3DPRESENT_INTERVAL_DEFAULT : D3DPRESENT_INTERVAL_IMMEDIATE; // Present back-buffer immediately, unless V-Sync is on
D3Dpp.Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL; // This flag should improve performance, if not set to NULL.
D3Dpp.FullScreen_RefreshRateInHz = bWindowed ? 0 : D3DPRESENT_RATE_DEFAULT; // Full-screen refresh rate, use adapter modes or default
D3Dpp.MultiSampleQuality = 0; // MSAA currently off, check documentation for support.
D3Dpp.MultiSampleType = D3DMULTISAMPLE_NONE; // MSAA currently off, check documentation for support.
// Check device capabilities
DWORD deviceBehaviorFlags = 0;
m_pD3DObject->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &m_D3DCaps);
// Determine vertex processing mode
if(m_D3DCaps.DevCaps & D3DCREATE_HARDWARE_VERTEXPROCESSING)
{
// Hardware vertex processing supported? (Video Card)
deviceBehaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
}
else
{
// If not, use software (CPU)
deviceBehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
// If hardware vertex processing is on, check pure device support
if(m_D3DCaps.DevCaps & D3DDEVCAPS_PUREDEVICE && deviceBehaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING)
{
deviceBehaviorFlags |= D3DCREATE_PUREDEVICE;
}
// Create the D3D Device with the present parameters and device flags above
m_pD3DObject->CreateDevice(
D3DADAPTER_DEFAULT, // which adapter to use, set to primary
D3DDEVTYPE_HAL, // device type to use, set to hardware rasterization
hWnd, // handle to the focus window
deviceBehaviorFlags, // behavior flags
&D3Dpp, // presentation parameters
&m_pD3DDevice); // returned device pointer
/*************************************
create the direct input devices here!!
***************************************/
m_pDInputObject->CreateDevice(GUID_SysKeyboard, &m_pDIKeyboard, NULL);
m_pDInputObject->CreateDevice(GUID_SysMouse, &m_pDIMouse, NULL);
//setting data format
m_pDIKeyboard->SetDataFormat(&c_dfDIKeyboard);
m_pDIMouse->SetDataFormat(&c_dfDIMouse2);
//setting cooperative level
m_pDIKeyboard->SetCooperativeLevel(m_hWnd,
DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
m_pDIMouse->SetCooperativeLevel(m_hWnd,
DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
// end of direct input****************************************************
// create the SPRITE object
D3DXCreateSprite(m_pD3DDevice, &m_pD3DSprite);
// create a TEXTURE object
D3DXCreateTextureFromFileEx(m_pD3DDevice, L"space.jpg", 0,0,0,0,
D3DFMT_UNKNOWN,D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255),
&m_imageInfo, 0, &mainMenuTexture);
D3DXCreateTextureFromFileEx(m_pD3DDevice, L"you win.jpg", 0,0,0,0,
D3DFMT_UNKNOWN,D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255),
&m_imageInfo, 0, &winScreenTexture);
// create a FONT object
AddFontResourceEx(L"Delicious-Roman.otf", FR_PRIVATE, 0);
D3DXCreateFont(m_pD3DDevice, 30, 0, FW_BOLD, 0, false,
DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY,
DEFAULT_PITCH | FF_DONTCARE, TEXT("Delicious-Roman"),
&m_pD3DFont);
/****************************************************************************
Projectiles sprites
****************************************************************************/
//////////////////////////////////////////////////////////////////////
//add a if check for game state to render player only during game play
//////////////////////////////////////////////////////////////////////
player.projectile.LoadProjectile(m_pD3DDevice);
/**************************************************************************
character sprites
****************************************************************************/
///////////////////////////////////////////////////////////////////////
//add a if check for game state to render player only during game play
//////////////////////////////////////////////////////////////////////
playerWon = false;
player.LoadPlayer(m_pD3DDevice);
enemy.Loadenemy(m_pD3DDevice);
enemy2.Loadenemy(m_pD3DDevice);
explosion.LoadExplosion(m_pD3DDevice);
explosion.LoadExplosionRect();
explosion2.LoadExplosion(m_pD3DDevice);
explosion2.LoadExplosionRect();
/**************************************************************************
Music and Sound Files
****************************************************************************/
// Load bgm
MenuMusic = new SoundEffect();
MenuMusic = SoundLoader::GetInstance()->LoadBGM("avenger BGM.mp3");
AudioManager::GetInstance()->PlayBGM(*MenuMusic);
enemy.KillCounter = 0;
// random seed for random positions
srand(time(NULL));
//
};
HRESULT InitDirectInput2( HWND hDlg )
{
HRESULT hr;
DIPROPDWORD dipdw;
// Setup the g_EffectsList circular linked list
ZeroMemory( &g_EffectsList, sizeof( EFFECTS_NODE ) );
g_EffectsList.pNext = &g_EffectsList;
// Create a DInput object
if( FAILED( hr = DirectInput8Create( GetModuleHandle(NULL), DIRECTINPUT_VERSION, IID_IDirectInput8, (VOID**)&g_pDI, NULL ) ) )
{
ctx->OutputToConsole("PlayFFE :: DirectInput8Create");
return hr;
}
// Get the first enumerated force feedback device
if( FAILED( hr = g_pDI->EnumDevices( DI8DEVCLASS_GAMECTRL, EnumFFDevicesCallback2, 0,
DIEDFL_ATTACHEDONLY |
DIEDFL_FORCEFEEDBACK ) ) )
{
ctx->OutputToConsole("PlayFFE :: EnumDevices failed");
return hr;
}
if( g_pFFDevice == NULL )
{
ctx->OutputToConsole("PlayFFE :: No force feedback device found.");
return -1;
}
// Set the data format
if( FAILED( hr = g_pFFDevice->SetDataFormat( &c_dfDIJoystick ) ) )
return hr;
// Set the coop level
//hr = g_pFFDevice->SetCooperativeLevel( hDlg , DISCL_EXCLUSIVE | DISCL_FOREGROUND) ;
hr = g_pFFDevice->SetCooperativeLevel( hDlg , DISCL_EXCLUSIVE | DISCL_BACKGROUND) ;
//DISCL_NONEXCLUSIVE
// Since we will be playing force feedback effects, we should disable the
// auto-centering spring.
dipdw.diph.dwSize = sizeof( DIPROPDWORD );
dipdw.diph.dwHeaderSize = sizeof( DIPROPHEADER );
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = FALSE;
if( FAILED( hr = g_pFFDevice->SetProperty( DIPROP_AUTOCENTER, &dipdw.diph ) ) )
return hr;
// Enumerate and count the axes of the joystick
if( FAILED( hr = g_pFFDevice->EnumObjects( EnumAxesCallback,
( VOID* )&g_dwNumForceFeedbackAxis, DIDFT_AXIS ) ) )
return hr;
// This simple sample only supports one or two axis joysticks
if( g_dwNumForceFeedbackAxis > 2 )
g_dwNumForceFeedbackAxis = 2;
// This application needs only one effect: Applying raw forces.
DWORD rgdwAxes[2] = { DIJOFS_X, DIJOFS_Y };
LONG rglDirection[2] = { 0,0 };
DICONSTANTFORCE cf = { 0 };
cf.lMagnitude = 0;
DIEFFECT eff;
ZeroMemory( &eff, sizeof( eff ) );
eff.dwSize = sizeof( DIEFFECT );
eff.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
eff.dwDuration = INFINITE;
eff.dwSamplePeriod = 0;
eff.dwGain = DI_FFNOMINALMAX;
eff.dwTriggerButton = DIEB_NOTRIGGER;
eff.dwTriggerRepeatInterval = 0;
eff.cAxes = g_dwNumForceFeedbackAxis;
eff.rgdwAxes = rgdwAxes;
eff.rglDirection = rglDirection;
eff.lpEnvelope = 0;
eff.cbTypeSpecificParams = sizeof( DICONSTANTFORCE );
eff.lpvTypeSpecificParams = &cf;
eff.dwStartDelay = 0;
// Create the prepared effect
if( FAILED( hr = g_pFFDevice->CreateEffect( GUID_ConstantForce,
&eff, &g_pEffect, NULL ) ) )
{
return hr;
}
if( NULL == g_pEffect )
return E_FAIL;
return S_OK;
}
void CDirectXFramework::Init(HWND& hWnd, HINSTANCE& hInst, bool bWindowed)
{
m_hWnd = hWnd;
CoInitialize(NULL);
CoCreateInstance( CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
IID_IGraphBuilder, (void**)&m_pGraphBuilder);
m_pGraphBuilder->QueryInterface(IID_IMediaControl,
(void**)&m_pMediaControl);
m_pGraphBuilder->QueryInterface(IID_IMediaEvent,
(void**)&m_pMediaEvent);
m_pGraphBuilder->RenderFile(L"intro.wmv", NULL);
m_pMediaControl->QueryInterface(IID_IVideoWindow,
(void**)&m_pVideoWindow);
// Setup the window
m_pVideoWindow->put_Owner((OAHWND)m_hWnd);
// Set the style
m_pVideoWindow->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE);
// Obtain the size of the window
RECT WinRect;
GetClientRect(m_hWnd, &WinRect);
// Set the video size to the size of the window
WinRect.top = 0;
WinRect.bottom = 600;
WinRect.left = 0;
WinRect.right = 800;
m_pVideoWindow->SetWindowPosition(WinRect.left, WinRect.top,
WinRect.right, WinRect.bottom);
//////////////////////////////////////////////////////////////////////////
// Direct3D Foundations - D3D Object, Present Parameters, and D3D Device
//////////////////////////////////////////////////////////////////////////
// Create the D3D Object
m_pD3DObject = Direct3DCreate9(D3D_SDK_VERSION);
// Find the width and height of window using hWnd and GetWindowRect()
RECT rect;
GetWindowRect(hWnd, &rect);
int width = rect.right - rect.left;
int height = rect.bottom - rect.top;
// Set D3D Device presentation parameters before creating the device
D3DPRESENT_PARAMETERS D3Dpp;
ZeroMemory(&D3Dpp, sizeof(D3Dpp)); // NULL the structure's memory
D3Dpp.hDeviceWindow = hWnd; // Handle to the focus window
D3Dpp.Windowed = bWindowed; // Windowed or Full-screen boolean
D3Dpp.AutoDepthStencilFormat = D3DFMT_D24S8; // Format of depth/stencil buffer, 24 bit depth, 8 bit stencil
D3Dpp.EnableAutoDepthStencil = TRUE; // Enables Z-Buffer (Depth Buffer)
D3Dpp.BackBufferCount = 1; // Change if need of > 1 is required at a later date
D3Dpp.BackBufferFormat = D3DFMT_X8R8G8B8; // Back-buffer format, 8 bits for each pixel
D3Dpp.BackBufferHeight = height; // Make sure resolution is supported, use adapter modes
D3Dpp.BackBufferWidth = width; // (Same as above)
D3Dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; // Discard back-buffer, must stay discard to support multi-sample
D3Dpp.PresentationInterval = m_bVsync ? D3DPRESENT_INTERVAL_DEFAULT : D3DPRESENT_INTERVAL_IMMEDIATE; // Present back-buffer immediately, unless V-Sync is on
D3Dpp.Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL; // This flag should improve performance, if not set to NULL.
D3Dpp.FullScreen_RefreshRateInHz = bWindowed ? 0 : D3DPRESENT_RATE_DEFAULT; // Full-screen refresh rate, use adapter modes or default
D3Dpp.MultiSampleQuality = 0; // MSAA currently off, check documentation for support.
D3Dpp.MultiSampleType = D3DMULTISAMPLE_NONE; // MSAA currently off, check documentation for support.
// Check device capabilities
DWORD deviceBehaviorFlags = 0;
m_pD3DObject->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &m_D3DCaps);
// Determine vertex processing mode
if(m_D3DCaps.DevCaps & D3DCREATE_HARDWARE_VERTEXPROCESSING)
{
// Hardware vertex processing supported? (Video Card)
deviceBehaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
}
else
{
// If not, use software (CPU)
deviceBehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
// If hardware vertex processing is on, check pure device support
if(m_D3DCaps.DevCaps & D3DDEVCAPS_PUREDEVICE && deviceBehaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING)
{
deviceBehaviorFlags |= D3DCREATE_PUREDEVICE;
}
// Create the D3D Device with the present parameters and device flags above
m_pD3DObject->CreateDevice(
D3DADAPTER_DEFAULT, // which adapter to use, set to primary
D3DDEVTYPE_HAL, // device type to use, set to hardware rasterization
hWnd, // handle to the focus window
deviceBehaviorFlags, // behavior flags
&D3Dpp, // presentation parameters
&m_pD3DDevice); // returned device pointer
//*************************************************************************
//////////////////////////////////////////////////////////////////////////
// Create a Font Object
//////////////////////////////////////////////////////////////////////////
// Load a font for private use for this process
// Load D3DXFont, each font style you want to support will need an ID3DXFont
D3DXCreateFont(m_pD3DDevice, 30, 0, FW_BOLD, 0, false,
DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY,
DEFAULT_PITCH | FF_DONTCARE, TEXT("Times New Roman"),
&m_pD3DFont);
//////////////////////////////////////////////////////////////////////////
// Create Sprite Object and Textures
//////////////////////////////////////////////////////////////////////////
// Create a sprite object, note you will only need one for all 2D sprites
D3DXCreateSprite(m_pD3DDevice, &m_pD3DSprite);
D3DXCreateSprite(m_pD3DDevice, &m_Ball);
D3DXCreateSprite(m_pD3DDevice, &m_Wall);
// Create a texture, each different 2D sprite to display to the screen
// will need a new texture object. If drawing the same sprite texture
D3DXCreateTextureFromFileEx(m_pD3DDevice, L"Paddle.tga", 0, 0, 0, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255),
&m_imageInfo, 0, &m_pTexture);
D3DXCreateTextureFromFileEx(m_pD3DDevice, L"Ball.tga", 0, 0, 0, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255),
&m_ballImage, 0, &m_ballTexture);
D3DXCreateTextureFromFileEx(m_pD3DDevice, L"wall.tga", 0, 0, 0, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255),
&m_wallImage, 0, &m_wallTexture);
D3DXCreateTextureFromFileEx(m_pD3DDevice, L"START.tga", 0, 0, 0, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255),
&m_StartImage, 0, &m_StartText);
D3DXCreateTextureFromFileEx(m_pD3DDevice, L"CREDITS.tga", 0, 0, 0, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255),
&m_CreditImage, 0, &m_CreditText);
D3DXCreateTextureFromFileEx(m_pD3DDevice, L"CREDIT2.tga", 0, 0, 0, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255),
&m_Credit2Image, 0, &m_Credit2Text);
D3DXCreateTextureFromFileEx(m_pD3DDevice, L"EXIT.tga", 0, 0, 0, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, D3DCOLOR_XRGB(255, 0, 255),
&m_ExitImage, 0, &m_ExitText);
// multiple times, just call that sprite's Draw() with different
// transformation values.
//Paddle 1
Paddle[0].xp = -12;
Paddle[0].yp = 300;
//Paddle 2
Paddle[1].xp = 800;
Paddle[1].yp = 300;
//Ball
Ball.xp = 400;
Ball.yp = 300;
// Wall / Background
Wall.xp = 400;
Wall.yp = 300;
// Menu
Menu.xp = 200;
Menu.yp = 200;
//Initial Direction
Ball.DIR_UP_RIGHT = true;
//MENU
Menu.onGAME = false;
Menu.onSTART = true;
//*************************************************************************
// create direct input object
DirectInput8Create(hInst, DIRECTINPUT_VERSION, IID_IDirectInput8,(void **)&m_pDIObject, NULL);
// Create Keyboard
m_pDIObject->CreateDevice(GUID_SysKeyboard, &m_pDIKeyboard, NULL);
//Set Keyboard data format
m_pDIKeyboard->SetDataFormat(&c_dfDIKeyboard);
//Set Keyboard coop level
m_pDIKeyboard->SetCooperativeLevel(hWnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
// Create Mouse
m_pDIObject->CreateDevice(GUID_SysMouse, &m_pDIMouse, NULL);
// Set Mouse Data Format
m_pDIMouse->SetDataFormat(&c_dfDIMouse2);
// Set Mouse Coop Level
m_pDIMouse->SetCooperativeLevel(hWnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
//SOUND INITIALIZATION
channel = 0;
result = FMOD::System_Create(&system);
result = system->init(100, FMOD_INIT_NORMAL, 0); // initialize fmod
result = system->createSound("beep1.ogg", FMOD_DEFAULT, 0, &mySound1);
result = system->createSound("beep2.ogg", FMOD_DEFAULT, 0, &mySound2);
result = system->createSound("pongMusic.wav", FMOD_LOOP_NORMAL | FMOD_2D, 0, &myStream);
//BACKGROUND MUSIC---------------------------------------------
result = system->playSound(myStream, 0, true, &channel);
result = channel->setVolume(0.5f);
result = channel->setPaused(false);
//-------------------------------------------------------------
}
bool InputWrapper::Init(HINSTANCE hinstance, HWND hwnd)
{
if (myIsInitialized == false)
{
myIsInitialized = true;
HRESULT result;
// Initialize the main direct input interface.
result = DirectInput8Create(hinstance, DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&myDirectInputInterface, NULL);
if (FAILED(result) == true)
{
return false;
}
// Initialize the direct input interface for the keyboard.
result = myDirectInputInterface->CreateDevice(GUID_SysKeyboard, &myKeyboard, NULL);
if (FAILED(result) == true)
{
return false;
}
// Set the data format. In this case since it is a keyboard we can use the predefined data format.
result = myKeyboard->SetDataFormat(&c_dfDIKeyboard);
if (FAILED(result) == true)
{
return false;
}
// Set the cooperative level of the keyboard to not share with other programs.
result = myKeyboard->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_EXCLUSIVE);
if (FAILED(result) == true)
{
return false;
}
// Now acquire the keyboard.
result = myKeyboard->Acquire();
if (FAILED(result) == true)
{
return false;
}
// Initialize the direct input interface for the mouse.
result = myDirectInputInterface->CreateDevice(GUID_SysMouse, &myMouse, NULL);
if (FAILED(result) == true)
{
return false;
}
// Set the data format for the mouse using the pre-defined mouse data format.
result = myMouse->SetDataFormat(&c_dfDIMouse);
if (FAILED(result) == true)
{
return false;
}
// Set the cooperative level of the mouse to share with other programs.
result = myMouse->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
if (FAILED(result) == true)
{
return false;
}
// Acquire the mouse.
result = myMouse->Acquire();
if (FAILED(result) == true)
{
return false;
}
}
return true;
}
//********************************************************************************************************************************************
// 初期化
//********************************************************************************************************************************************
bool InputManager::Initialize( void )
{
HRESULT hResult = S_OK;
// DirectInputインターフェイスを取得
hResult = DirectInput8Create( GetModuleHandle( NULL ), DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&m_pInput, NULL );
// マウスデバイスの初期化
if( SUCCEEDED( hResult ) ){
// デバイスを作成
hResult = m_pInput->CreateDevice( GUID_SysMouse, &m_pMouse, NULL );
// データ形式を設定
if( SUCCEEDED( hResult ) ){
hResult = m_pMouse->SetDataFormat( &c_dfDIMouse2 );
}
// 強調レベルの設定
if( SUCCEEDED( hResult ) ){
// 非排他
hResult = m_pMouse->SetCooperativeLevel( iexSystem::Window, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND );
// 排他
//hResult = m_pMouse->SetCooperativeLevel( iexSystem::Window, DISCL_EXCLUSIVE | DISCL_FOREGROUND );
}
// バッファサイズの設定
if( SUCCEEDED( hResult ) ){
DIPROPDWORD dipdw;
// ヘッダー
dipdw.diph.dwSize = sizeof( DIPROPDWORD );
dipdw.diph.dwHeaderSize = sizeof( DIPROPHEADER );
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
// データ
dipdw.dwData = sizeof( DIMOUSESTATE2 );
// セット
hResult = m_pMouse->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph );
}
}
// キーボードデバイスの初期化
if( SUCCEEDED( hResult ) ){
// デバイスを作成
hResult = m_pInput->CreateDevice( GUID_SysKeyboard, &m_pKeyBoard, NULL );
// データ形式を設定
if( SUCCEEDED( hResult ) ){
hResult = m_pKeyBoard->SetDataFormat( &c_dfDIKeyboard );
}
// 強調レベルの設定
if( SUCCEEDED( hResult ) ){
hResult = m_pKeyBoard->SetCooperativeLevel( iexSystem::Window, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND );
}
}
// 結果を返す
if( SUCCEEDED( hResult ) ) return true;
else return false;
}
void PsychHIDInitializeHIDStandardInterfaces(void)
{
int i;
HRESULT rc;
HINSTANCE modulehandle = NULL;
dinput = NULL;
ndevices = 0;
// Init x_dev array:
for (i = 0; i < PSYCH_HID_MAX_DEVICES; i++) x_dev[i] = NULL;
// Init keyboard queue arrays:
memset(&psychHIDKbQueueFirstPress[0], 0, sizeof(psychHIDKbQueueFirstPress));
memset(&psychHIDKbQueueFirstRelease[0], 0, sizeof(psychHIDKbQueueFirstRelease));
memset(&psychHIDKbQueueLastPress[0], 0, sizeof(psychHIDKbQueueLastPress));
memset(&psychHIDKbQueueLastRelease[0], 0, sizeof(psychHIDKbQueueLastRelease));
memset(&psychHIDKbQueueActive[0], 0, sizeof(psychHIDKbQueueActive));
memset(&psychHIDKbQueueScanKeys[0], 0, sizeof(psychHIDKbQueueScanKeys));
// We need the module instance handle of ourselves, ie., the PsychHID mex file to
// open a DirectInput-8 interface, so the OS can apply backwards compatibility fixes
// specific to the way our mex file DLL was built. For this we need the name of the
// mex file, which is dependent on Octave vs. Matlab and 32-Bit vs. 64-Bit:
#ifndef PTBOCTAVE3MEX
// Matlab: 64-Bit or 32-Bit mex file?
#if defined(__LP64__) || defined(_M_IA64) || defined(_WIN64)
// 64-Bit:
modulehandle = GetModuleHandle("PsychHID.mexw64");
#else
// 32-Bit:
modulehandle = GetModuleHandle("PsychHID.mexw32");
#endif
#else
// Octave: Same mex file file-extension for 32/64-Bit:
modulehandle = GetModuleHandle("PsychHID.mex");
#endif
// If this doesn't work, try with application module handle as fallback. This works usually on
// Windows XP/Vista/7, but may fail catastrophically on Windows-8 and later:
if (NULL == modulehandle) {
printf("PsychHID-WARNING: Could not get module handle to PsychHID mex file. Did you rename it? Please don't do that!\n");
printf("PsychHID-WARNING: Will try application module handle as fallback. This may end badly, e.g., with a crash. Cross your fingers!\n");
modulehandle = GetModuleHandle(NULL);
}
if (NULL == modulehandle) PsychErrorExitMsg(PsychError_system, "PsychHID: FATAL ERROR: Couldn't get module handle to create interface to Microsoft DirectInput-8! Game over!");
// Open a DirectInput-8 interface:
rc = DirectInput8Create(modulehandle, DIRECTINPUT_VERSION, IID_IDirectInput8, (LPVOID*)&dinput, NULL);
if (DI_OK != rc) {
printf("PsychHID-ERROR: Error return from DirectInput8Create: %x\n", (int) rc);
if (rc == DIERR_OLDDIRECTINPUTVERSION) printf("PsychHID-ERROR: You need to install a more recent version of DirectX -- at least DirectX-8.\n");
PsychErrorExitMsg(PsychError_system, "PsychHID: FATAL ERROR: Couldn't create interface to Microsoft DirectInput-8! Game over!");
}
// Enumerate all DirectInput keyboard(-like) devices:
rc = dinput->EnumDevices(DI8DEVCLASS_KEYBOARD, (LPDIENUMDEVICESCALLBACK) keyboardEnumCallback, NULL, DIEDFL_ATTACHEDONLY | DIEDFL_INCLUDEHIDDEN);
if (DI_OK != rc) {
printf("PsychHID-ERROR: Error return from DirectInput8 EnumDevices(): %x! Game over!\n", (int) rc);
goto out;
}
// Enumerate all DirectInput mouse(-like) devices:
rc = dinput->EnumDevices(DI8DEVCLASS_POINTER, (LPDIENUMDEVICESCALLBACK) keyboardEnumCallback, NULL, DIEDFL_ATTACHEDONLY | DIEDFL_INCLUDEHIDDEN);
if (DI_OK != rc) {
printf("PsychHID-ERROR: Error return from DirectInput8 EnumDevices(): %x! Game over!\n", (int) rc);
goto out;
}
// Enumerate all DirectInput joystick/gamepad(-like) devices:
rc = dinput->EnumDevices(DI8DEVCLASS_GAMECTRL, (LPDIENUMDEVICESCALLBACK) keyboardEnumCallback, NULL, DIEDFL_ATTACHEDONLY | DIEDFL_INCLUDEHIDDEN);
if (DI_OK != rc) {
printf("PsychHID-ERROR: Error return from DirectInput8 EnumDevices(): %x! Game over!\n", (int) rc);
goto out;
}
// Create keyboard queue mutex for later use:
KbQueueThreadTerminate = FALSE;
PsychInitMutex(&KbQueueMutex);
PsychInitCondition(&KbQueueCondition, NULL);
// Create event object for signalling device state changes:
hEvent = CreateEvent( NULL, // default security attributes
FALSE, // auto-reset event: This would need to be set TRUE for PsychBroadcastCondition() to work on Windows!
FALSE, // initial state is nonsignaled
NULL // no object name
);
// Ready.
return;
out:
ndevices = 0;
// Close our dedicated x-display connection and we are done:
if (dinput) dinput->Release();
dinput = NULL;
PsychErrorExitMsg(PsychError_system, "PsychHID: FATAL ERROR: X Input extension version 2.0 or later not available! Game over!");
}
qboolean IN_InitDInput(void)
{
HRESULT hResult;
DIPROPDWORD dipdw = {
{
sizeof(DIPROPDWORD), // diph.dwSize
sizeof(DIPROPHEADER), // diph.dwHeaderSize
0, // diph.dwObj
DIPH_DEVICE, // diph.dwHow
}
,
DINPUT_BUFFERSIZE, // dwData
};
#ifdef __GNUC__
hResult = DirectInputCreate(g_wv.hInstance, DIRECTINPUT_VERSION, &g_pdi, NULL);
#else
hResult = DirectInput8Create(g_wv.hInstance, DIRECTINPUT_VERSION, &IID_IDirectInput8A, &g_pdi, NULL);
#endif
if(FAILED(hResult))
{
#ifdef __GNUC__
Com_Printf("DirectInput8Create failed\n");
#else
Com_Printf("DirectInput8Create failed\n");
#endif
return qfalse;
}
// obtain an interface to the system mouse device.
hResult = IDirectInput_CreateDevice(g_pdi, &GUID_SysMouse, &g_pMouse, NULL);
if(FAILED(hResult))
{
Com_Printf("Couldn't open DI mouse device\n");
return qfalse;
}
// set the data format to "mouse format".
hResult = IDirectInputDevice_SetDataFormat(g_pMouse, &df);
if(FAILED(hResult))
{
Com_Printf("Couldn't set DI mouse format\n");
return qfalse;
}
// set the DirectInput cooperativity level.
hResult = IDirectInputDevice_SetCooperativeLevel(g_pMouse, g_wv.hWnd, DISCL_EXCLUSIVE | DISCL_FOREGROUND);
if(FAILED(hResult))
{
Com_Printf("Couldn't set DI coop level\n");
return qfalse;
}
// set the buffer size to DINPUT_BUFFERSIZE elements.
// the buffer size is a DWORD property associated with the device
hResult = IDirectInputDevice_SetProperty(g_pMouse, DIPROP_BUFFERSIZE, &dipdw.diph);
if(FAILED(hResult))
{
Com_Printf("Couldn't set DI buffersize\n");
return qfalse;
}
return qtrue;
}
int Game_Init(void *parms, int num_parms)
{
// this function is where you do all the initialization
// for your game
int index; // looping var
char filename[80]; // used to build up files names
// initialize directdraw
DDraw_Init(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP);
#if 0 // directinput7 method
// first create the direct input object
if (DirectInputCreateEx(main_instance,DIRECTINPUT_VERSION,IID_IDirectInput7, (void **)&lpdi,NULL)!=DI_OK)
return(0);
// create a keyboard device //////////////////////////////////
if (lpdi->CreateDeviceEx(GUID_SysKeyboard, IID_IDirectInputDevice7, (void **)&lpdikey, NULL)!=DI_OK)
return(0);
#endif
// first create the direct input object
if (DirectInput8Create(main_instance,DIRECTINPUT_VERSION,IID_IDirectInput8, (void **)&lpdi,NULL)!=DI_OK)
return(0);
// create a keyboard device //////////////////////////////////
if (lpdi->CreateDevice(GUID_SysKeyboard, &lpdikey, NULL)!=DI_OK)
return(0);
// set cooperation level
if (lpdikey->SetCooperativeLevel(main_window_handle,
DISCL_NONEXCLUSIVE | DISCL_BACKGROUND)!=DI_OK)
return(0);
// set data format
if (lpdikey->SetDataFormat(&c_dfDIKeyboard)!=DI_OK)
return(0);
// acquire the keyboard
if (lpdikey->Acquire()!=DI_OK)
return(0);
///////////////////////////////////////////////////////////
// load the background
Load_Bitmap_File(&bitmap8bit, "REACTOR.BMP");
// set the palette to background image palette
Set_Palette(bitmap8bit.palette);
// create and load the reactor bitmap image
Create_Bitmap(&reactor, 0,0, 640, 480);
Load_Image_Bitmap(&reactor,&bitmap8bit,0,0,BITMAP_EXTRACT_MODE_ABS);
Unload_Bitmap_File(&bitmap8bit);
// now let's load in all the frames for the skelaton!!!
// create skelaton bob
if (!Create_BOB(&skelaton,0,0,56,72,32,
BOB_ATTR_VISIBLE | BOB_ATTR_MULTI_ANIM,DDSCAPS_SYSTEMMEMORY))
return(0);
// load the frames in 8 directions, 4 frames each
// each set of frames has a walk and a fire, frame sets
// are loaded in counter clockwise order looking down
// from a birds eys view or the x-z plane
for (int direction = 0; direction < 8; direction++)
{
// build up file name
sprintf(filename,"SKELSP%d.BMP",direction);
// load in new bitmap file
Load_Bitmap_File(&bitmap8bit,filename);
Load_Frame_BOB(&skelaton,&bitmap8bit,0+direction*4,0,0,BITMAP_EXTRACT_MODE_CELL);
Load_Frame_BOB(&skelaton,&bitmap8bit,1+direction*4,1,0,BITMAP_EXTRACT_MODE_CELL);
Load_Frame_BOB(&skelaton,&bitmap8bit,2+direction*4,2,0,BITMAP_EXTRACT_MODE_CELL);
Load_Frame_BOB(&skelaton,&bitmap8bit,3+direction*4,0,1,BITMAP_EXTRACT_MODE_CELL);
// unload the bitmap file
Unload_Bitmap_File(&bitmap8bit);
// set the animation sequences for skelaton
Load_Animation_BOB(&skelaton,direction,4,skelaton_anims[direction]);
} // end for direction
// set up stating state of skelaton
Set_Animation_BOB(&skelaton, 0);
Set_Anim_Speed_BOB(&skelaton, 4);
Set_Vel_BOB(&skelaton, 0,0);
Set_Pos_BOB(&skelaton, 0, 128);
// set clipping rectangle to screen extents so mouse cursor
// doens't mess up at edges
RECT screen_rect = {0,0,screen_width,screen_height};
lpddclipper = DDraw_Attach_Clipper(lpddsback,1,&screen_rect);
// hide the mouse
ShowCursor(FALSE);
// return success
return(1);
} // end Game_Init
bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight)
{
HRESULT result;
//Store the screen size which will be used for positioning the mouse cursor
m_screenHeight = screenWidth;
m_screenHeight = screenHeight;
//initialize the mouse
m_mouseX = 0;
m_mouseY = 0;
//initialize the directInput
result = DirectInput8Create(hinstance, DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&m_directInput, NULL);
if (FAILED(result))
{
return false;
}
//first initialize the keyboard
result = m_directInput->CreateDevice(GUID_SysKeyboard, &m_keyboard, NULL);
if (FAILED(result))
{
return false;
}
//Set the data format using the predifined format
result = m_keyboard->SetDataFormat(&c_dfDIKeyboard);
if (FAILED(result))
{
return false;
}
//set the keyboard to non-exclusive
result = m_keyboard->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
if (FAILED(result))
{
return false;
}
//Aquire the keyboard
result = m_keyboard->Acquire();
if (FAILED(result))
{
return false;
}
//Init the mouse input
result = m_directInput->CreateDevice(GUID_SysMouse, &m_mouse, NULL);
if (FAILED(result))
{
return false;
}
//set the data format for the mouse
result = m_mouse->SetDataFormat(&c_dfDIMouse);
if (FAILED(result))
{
return false;
}
//set the cooperative level of the mouse
result = m_mouse->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
if (FAILED(result))
{
return false;
}
//Acquire the mouse
result = m_mouse->Acquire();
if (FAILED(result))
{
return false;
}
return true;
}
void FTNoIR_Tracker::StartTracker(QFrame* frame)
{
QMutexLocker foo(&mtx);
this->frame = frame;
iter = 0;
auto hr = CoInitialize( nullptr );
if( FAILED( hr = DirectInput8Create( GetModuleHandle( NULL ), DIRECTINPUT_VERSION,
IID_IDirectInput8, ( VOID** )&g_pDI, NULL ) ) )
{
qDebug() << "create";
goto fail;
}
if( FAILED( hr = g_pDI->EnumDevices( DI8DEVCLASS_GAMECTRL,
EnumJoysticksCallback,
this,
DIEDFL_ATTACHEDONLY)))
{
qDebug() << "enum2";
goto fail;
}
if (!g_pJoystick)
{
qDebug() << "ENODEV";
goto fail;
}
if (FAILED(g_pJoystick->SetDataFormat(&c_dfDIJoystick)))
{
qDebug() << "format";
goto fail;
}
if (FAILED(g_pJoystick->SetCooperativeLevel((HWND) frame->window()->winId(), DISCL_NONEXCLUSIVE | DISCL_BACKGROUND)))
{
qDebug() << "coop";
goto fail;
}
iter = 0;
if( FAILED( hr = g_pJoystick->EnumObjects( EnumObjectsCallback,
( VOID* )this, DIDFT_ALL )))
{
qDebug() << "enum axes";
goto fail;
}
qDebug() << "joy init success";
return;
fail:
if (g_pJoystick)
g_pJoystick->Release();
if (g_pDI)
g_pDI->Release();
g_pJoystick = nullptr;
g_pDI = nullptr;
qDebug() << "joy init failure";
}
HRESULT InitDirectInput(unsigned int joystick_index)
{
HRESULT hr;
state.is_initialized = false;
// Register with the DirectInput subsystem and get a pointer
// to a IDirectInput interface we can use.
// Create a DInput object
if (FAILED(hr = DirectInput8Create(GetModuleHandle(nullptr), DIRECTINPUT_VERSION,
IID_IDirectInput8, (VOID**)&g_pDI, nullptr)))
return hr;
if (g_bFilterOutXinputDevices)
SetupForIsXInputDevice();
enumContext.pPreferredJoyCfg = &PreferredJoyCfg;
enumContext.bPreferredJoyCfgValid = false;
IDirectInputJoyConfig8* pJoyConfig = nullptr;
if (FAILED(hr = g_pDI->QueryInterface(IID_IDirectInputJoyConfig8, (void**)&pJoyConfig))) {
state.message = "QueryInterface on IID_IDirectInputJoyConfig8 failed";
return hr;
}
PreferredJoyCfg.dwSize = sizeof(PreferredJoyCfg);
if (SUCCEEDED(pJoyConfig->GetConfig(joystick_index, &PreferredJoyCfg, DIJC_GUIDINSTANCE))) { // This function is expected to fail if no joystick is attached
enumContext.bPreferredJoyCfgValid = true;
joystick_info.is_valid = true;
joystick_info.instance_guide = toDIGUID(PreferredJoyCfg.guidInstance);
joystick_info.pid_vid = toString(PreferredJoyCfg.wszType);
}
DIJT_SAFE_RELEASE(pJoyConfig);
// Look for a simple joystick we can use for this sample program.
if (FAILED(hr = g_pDI->EnumDevices(DI8DEVCLASS_GAMECTRL,
DirectInputJoyStick::impl::EnumJoysticksCallback,
this, DIEDFL_ATTACHEDONLY))) {
state.message = "EnumDevices failed";
return hr;
}
if (g_bFilterOutXinputDevices)
CleanupForIsXInputDevice();
// Make sure we got a joystick
if (!g_pJoystick)
{
state.message = "Joystick at index " + std::to_string(joystick_index) + " is not available";
return S_FALSE;
}
// Set the data format to "simple joystick" - a predefined data format
//
// A data format specifies which controls on a device we are interested in,
// and how they should be reported. This tells DInput that we will be
// passing a DIJOYSTATE2 structure to IDirectInputDevice::GetDeviceState().
if (FAILED(hr = g_pJoystick->SetDataFormat(&c_dfDIJoystick2)))
{
state.message = "Device does not support DIJOYSTATE2";
return hr;
}
// Set the cooperative level to let DInput know how this device should
// interact with the system and with other DInput applications.
if (FAILED(hr = g_pJoystick->SetCooperativeLevel(NULL, DISCL_NONEXCLUSIVE | DISCL_BACKGROUND))) {
state.message = "SetCooperativeLevel failed";
return hr;
}
// Enumerate the joystick objects. The callback function enabled user
// interface elements for objects that are found, and sets the min/max
// values property for discovered axes.
if (FAILED(hr = g_pJoystick->EnumObjects(DirectInputJoyStick::impl::EnumObjectsCallback,
(VOID*) this, DIDFT_ALL))) {
state.message = "EnumObjects failed";
return hr;
}
InitForceFeedback();
state.is_initialized = true;
return S_OK;
}
void AppState::initInputDevices() {
//创建DirectInput8对象
IDirectInput8A* direct_input;
dx::throwIfFailed(
DirectInput8Create(
hInstance_,
DIRECTINPUT_VERSION,
IID_IDirectInput8,
(void **) &direct_input,
nullptr)
);
direct_input_.reset(direct_input);
//创建DirectInput8设备（键盘）
IDirectInputDevice8A* keyboard_device;
dx::throwIfFailed(
direct_input_->CreateDevice(GUID_SysKeyboard, &keyboard_device, nullptr)
);
keyboard_device_.reset(keyboard_device);
//为键盘设置格式
dx::throwIfFailed(
keyboard_device_->SetDataFormat(&c_dfDIKeyboard)
);
//为键盘设置行为
dx::throwIfFailed(
keyboard_device_->SetCooperativeLevel(windowHwnd, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)
);
//为键盘设置缓冲方式
DIPROPDWORD dipdw;
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = kKeyInputBufferSize; // Arbitary buffer size
dx::throwIfFailed(
keyboard_device_->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph)
);
//创建事件，为自动型（使用完自动置为无信号状态），初始化为无信号状态
HANDLE handle = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!handle) {
throw std::runtime_error("CreateEvent keyboard error!");
}
//为键盘安装事件通知关联，并准备获取采集
keyboard_device_->SetEventNotification(handle);
keyboard_device_->Acquire();
//添加等待对象,以及触发事件
addEventHandle(handle, std::bind(&AppState::updateKeyInputState, this));
//创建DirectInput8设备（鼠标）
IDirectInputDevice8A* mouse_device;
dx::throwIfFailed(
direct_input_->CreateDevice(GUID_SysMouse, &mouse_device, NULL)
);
mouse_device_.reset(mouse_device);
//为鼠标设置格式(8按键鼠标)
dx::throwIfFailed(
mouse_device_->SetDataFormat(&c_dfDIMouse2)
);
//为鼠标设置行为
dx::throwIfFailed(
mouse_device_->SetCooperativeLevel(windowHwnd, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)
);
//鼠标设置缓冲方式
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = kMouseInputBufferSize;
dx::throwIfFailed(
mouse_device_->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph)
);
handle = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!handle) {
throw std::runtime_error("CreateEvent mouse error!");
}
mouse_device_->SetEventNotification(handle);
mouse_device_->Acquire();
addEventHandle(handle, std::bind(&AppState::updateMouseInputState, this));
/*
_pD3D = Direct3DCreate9(D3D_SDK_VERSION);
if(_pD3D == nullptr)
{
BOOST_THROW_EXCEPTION(std::runtime_error("Direct3DCreate9 error!"));
}
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof( d3dpp ) );
d3dpp.Windowed = TRUE; //不是全屏
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
hr = _pD3D->CreateDevice(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
WindowHwnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp,
&_pd3dDevice);
if (FAILED(hr)) {
BOOST_THROW_EXCEPTION(std::runtime_error("CreateDevice IDirect3DDevice9 error!"));
}
IDirect3DSurface8* lpDSCursor;
hr = _pd3dDevice->CreateImageSurface(32, 32, D3DFMT_A8R8G8B8,&lpDSCursor);
*/
}
void DXInput::Initialize(HWND hWindow)
{
// Check if we have already initialized the system
if (mInitialized)
{
// Write to log
Log::Get()->Write(LogType::Warning, "[Input] System already initialized.");
return;
}
// Write to log
Log::Get()->Write(LogType::Message, "[Input] Initializing...");
// Obtain an interface to DirectInput
if (FAILED(DirectInput8Create(GetModuleHandle(nullptr), DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&mpDI, nullptr)))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to create DirectInput object.");
return;
}
//----------------------------------------------------------------------------------------------------
// Create keyboard device
if (FAILED(mpDI->CreateDevice(GUID_SysKeyboard, &mpKeyboard, nullptr)))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to create keyboard device.");
return;
}
// Set the keyboard data format
if (FAILED(mpKeyboard->SetDataFormat(&c_dfDIKeyboard)))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to set keyboard data format.");
return;
}
// Set the keyboard cooperative level
if (FAILED(mpKeyboard->SetCooperativeLevel(hWindow, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE | DISCL_NOWINKEY)))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to set keyboard cooperative level.");
return;
}
// Acquire the keyboard device
if (FAILED(mpKeyboard->Acquire()))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to acquire keyboard device.");
}
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
// Create mouse device
if (FAILED(mpDI->CreateDevice(GUID_SysMouse, &mpMouse, nullptr)))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to create mouse device.");
return;
}
// Set the mouse data format
if (FAILED(mpMouse->SetDataFormat(&c_dfDIMouse)))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to set mouse data format.");
return;
}
// Set the mouse cooperative level
if (FAILED(mpMouse->SetCooperativeLevel(hWindow, DISCL_FOREGROUND | DISCL_EXCLUSIVE)))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to set mouse cooperative level.");
return;
}
// Acquire the mouse device
if (FAILED(mpMouse->Acquire()))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to acquire mouse device.");
}
// Calculate starting mouse position
RECT clientRect;
GetClientRect(hWindow, &clientRect);
GetWindowRect(hWindow, &clientRect);
mScreenWidth = clientRect.right - clientRect.left;
mScreenHeight = clientRect.bottom - clientRect.top;
mMouseX = mScreenWidth>> 1;
mMouseY = mScreenHeight>> 1;
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
// Enumerate for game pad device
if (FAILED(mpDI->EnumDevices(DI8DEVCLASS_GAMECTRL, EnumGamePadCallback, nullptr, DIEDFL_ATTACHEDONLY)))
{
// Write to log
Log::Get()->Write(LogType::Warning, "[Input] Failed to enumerate for game pad devices.");
}
// Check if we have a game pad detected
if (nullptr != mpGamePad)
{
// Set the game pad data format
if (FAILED(mpGamePad->SetDataFormat(&c_dfDIJoystick)))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to set game pad data format.");
return;
}
// Set the game pad cooperative level
if (FAILED(mpGamePad->SetCooperativeLevel(hWindow, DISCL_FOREGROUND | DISCL_EXCLUSIVE)))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to set game pad cooperative level.");
return;
}
// Acquire the game pad device
if (FAILED(mpGamePad->Acquire()))
{
// Write to log
Log::Get()->Write(LogType::Error, "[Input] Failed to acquire game pad device.");
}
}
else
{
// Write to log
Log::Get()->Write(LogType::Warning, "[Input] No game pad attached.");
}
// Set flag
mInitialized = true;
// Write to log
Log::Get()->Write(LogType::Message, "[Input] System initialized.");
}
//************************************************
//*主程序
//************************************************
int APIENTRY t1::_tWinMain(HINSTANCE &hInstance,
HINSTANCE &hPrevInstance,
LPTSTR &lpCmdLine,
int &nCmdShow, HWND &_hWnd,
std::string winClassName, std::string winName)
{
// 初始化句柄和状态
bool bUnClosedLastWin = true;
hWnd = _hWnd;
gHinstance = hInstance;
ShowCursor(FALSE);
//g_nThreadExitCount = 0;
//获得传递的命令行参数，得到被试着名字和任务编号
char *pdest;
int result;
int pos1;
pdest = strrchr(lpCmdLine, ' ');
pos1 = pdest - lpCmdLine;
if (pos1>0)
{
strncpy(m_TaskNumStr, lpCmdLine, pos1);
}
else
{
strcpy(m_TaskNumStr, "");
}
pdest = strrchr(lpCmdLine, '-');
result = pdest - lpCmdLine;
if (result>0)
{
strncpy(m_TesterName, lpCmdLine + pos1 + 1, result - pos1 - 1);
}
else
{
strcpy(m_TesterName, "");
}
if (pos1>0)
{
strcpy(m_DataName, lpCmdLine + pos1 + 1);
}
else
{
strcpy(m_DataName, "");
}
//读取任务设置
if (!ReadSetting())
{
MessageBox(hWnd, "任务设置文件格式错误！", "测试任务", MB_OK);
return 0;
}
//注册窗口类
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS, MsgProc, 0L, 0L,
hInstance, NULL, NULL, NULL, NULL,
std::to_string(nCmdShow).c_str(), NULL };
RegisterClassEx(&wc);
x_resolution = GetSystemMetrics(SM_CXSCREEN);
y_resolution = GetSystemMetrics(SM_CYSCREEN);
rec_x_begin = (x_resolution - 1024) / 2;
rec_y_begin = (y_resolution - 768) / 2;
rec_x_end = (x_resolution + 1024) / 2;
rec_y_end = (y_resolution + 768) / 2;
_hWnd = hWnd = CreateWindow(std::to_string(nCmdShow).c_str(), std::to_string(nCmdShow).c_str(),
WS_VISIBLE | WS_POPUP, 0, 0, x_resolution, y_resolution,
NULL, NULL, hInstance, NULL);
//显示主窗口
SetFocus(hWnd);
//创建DirectX设备
if (FAILED(DirectInput8Create(hInstance, DIRECTINPUT_VERSION,
IID_IDirectInput8,
(void**)&m_lpkDInput, NULL)))
{
return 0;
}
float m_JoySpeedMax;
if (m_HardSetting.m_JoySpeedMax > 0)
{
m_JoySpeedMax = m_HardSetting.m_JoySpeedMax;
}
else
{
m_JoySpeedMax = 200;
}
//关闭输入法
HKL hkl;
hkl = LoadKeyboardLayout("00000804", KLF_ACTIVATE);
if (hkl != NULL)
{
ActivateKeyboardLayout(hkl, KLF_SETFORPROCESS);
}
//ShowCursor(FALSE);
//设置操纵杆变化范围
if (JoystickInit(hWnd, -m_JoySpeedMax, m_JoySpeedMax, 1))
{
JoystickUpdate();
}
else
{
MessageBox(hWnd, "请检查操纵杆连接是否正确！", "测试任务", MB_OK);
return 0;
}
// declare a variable of our data structure to pass to the ThreadProcedure
MYDATA MyThreadData;
MyThreadData.nTime = 7509843;
MyThreadData.nNumber = 39;
//创建操纵杆输入线程
// declare a DWORD to hold our thread's new generated ID
HANDLE h = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)InputThreadProcedure,
(LPVOID)&MyThreadData, NULL, &dwInputThreadID);
// SetPriorityClass(h,NORMAL_PRIORITY_CLASS);
// SetThreadPriority(h,THREAD_PRIORITY_ABOVE_NORMAL);
// actually create and start the thread now!
// the thread will run until we send it our own WM_THREADSTOP message
srand((unsigned)time(NULL)); //初始化随机种子
//初始化Direct3D
bool b_InitD3d = SUCCEEDED(InitD3D(hWnd));
if (b_InitD3d)
{
//进入消息循环
MSG msg;
ZeroMemory(&msg, sizeof(msg));
while (msg.message != WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
//处理外部消息
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
//执行测试过程
UpdateState();
if (m_bDisplayReady)
{
//渲染图形
Render();
hideLastWindow(bUnClosedLastWin, winClassName, winName, hInstance);
}
}
Sleep(1);
// 当按下“下一个任务”或“退出”时，终止消息循环
if (m_TestState == STATE_NEXT
|| m_TestState == STATE_EXIT)
{
break;
}
}
}
ShowCursor(TRUE);
CloseHandle(h);
return rtn;
}
CInputManagerImplementation::CInputManagerImplementation(HWND hWnd)
: m_MovementX(0)
, m_MovementY(0)
, m_MovementZ(0)
, m_ButtonLeft(false)
, m_ButtonMiddle(false)
, m_ButtonRight(false)
, m_PreviousButtonLeft(false)
, m_PreviousButtonMiddle(false)
, m_PreviousButtonRight(false)
, m_MouseSpeed(1)
,m_FileName("")
{
m_Alt = false;
m_Ctrl = false;
for (int i = 0; i < 256; ++i)
{
m_KeysPrevious[i] = m_KeysCurrent[i] = false;
}
for (int i = 0; i < 4; ++i)
{
m_PadButtensPrevious[i] = 0;
}
// mouse input
HRESULT l_HR;
DWORD l_CoopFlags = 0;
/*l_CoopFlags= DISCL_EXCLUSIVE | DISCL_FOREGROUND;*/
if (FAILED(l_HR = DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION, IID_IDirectInput8, (VOID**)&m_DI, NULL)))
return;
if (FAILED(l_HR = m_DI->CreateDevice(GUID_SysMouse, &m_Mouse, NULL)))
return;
if (FAILED(l_HR = m_Mouse->SetDataFormat(&c_dfDIMouse2)))
return;
//if (FAILED(l_HR = m_Mouse->SetCooperativeLevel(hWnd, l_CoopFlags)))
// return;
HMODULE XInputLibrary = LoadLibraryA("xinput1_4.dll");
if (!XInputLibrary)
{
XInputLibrary = LoadLibraryA("xinput9_1_0.dll");
}
if (!XInputLibrary)
{
XInputLibrary = LoadLibraryA("xinput1_3.dll");
}
if (XInputLibrary)
{
s_XInputGetState = (TF_XInputGetState *)GetProcAddress(XInputLibrary, "XInputGetState");
if (!s_XInputGetState) { s_XInputGetState = FakeXInputGetState; }
}
if (m_Mouse != NULL)
m_Mouse->Acquire();
else
MessageBox(hWnd, "Problem with de mouse input!", "Mouse", MB_ICONERROR | MB_OK);
}
bool Direct3DInit(HWND hwnd, HINSTANCE hInstance)
{
LPDIRECT3D9 pD3D9;
pD3D9 = Direct3DCreate9(D3D_SDK_VERSION);
if (pD3D9 == nullptr)
{
return false;
}
D3DCAPS9 caps;
if (FAILED(pD3D9->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps)))
{
return false;
}
int vp = 0;
if (caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
{
vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
}
else
{
vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.BackBufferWidth = WINDOW_WIDTH;
d3dpp.BackBufferHeight = WINDOW_HEIGHT;
d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
d3dpp.BackBufferCount = 2;
d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp.MultiSampleQuality = 0;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow = hwnd;
d3dpp.Windowed = true;
d3dpp.EnableAutoDepthStencil = true;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
d3dpp.Flags = 0;
d3dpp.FullScreen_RefreshRateInHz = 0;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
if (FAILED(pD3D9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, vp, &d3dpp, &gPD3DDevice)))
{
return false;
}
D3DADAPTER_IDENTIFIER9 ident;
pD3D9->GetAdapterIdentifier(0, 0, &ident);
int len = MultiByteToWideChar(CP_ACP, 0, ident.Description, -1, 0, 0);
MultiByteToWideChar(CP_ACP, 0, ident.Description, -1, gStrAdapterDesc, len);
DirectInput8Create(hInstance, 0x0800, IID_IDirectInput8, (void**)&gPDirectInput, nullptr);
gPDirectInput->CreateDevice(GUID_SysMouse, &gPMouseInput, nullptr);
gPMouseInput->SetDataFormat(&c_dfDIMouse);
gPMouseInput->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
gPMouseInput->Acquire();
gPDirectInput->CreateDevice(GUID_SysKeyboard, &gPKeyboardInput, nullptr);
gPKeyboardInput->SetDataFormat(&c_dfDIKeyboard);
gPKeyboardInput->SetCooperativeLevel(hwnd, DISCL_NONEXCLUSIVE | DISCL_NONEXCLUSIVE);
gPKeyboardInput->Acquire();
if (!ObjectInit(hwnd))
{
return false;
}
SAFE_RELEASE(pD3D9);
return true;
}
HRESULT
InitDI8( TDI8Data* data )
{
DIPROPDWORD dipdw;
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = MOUSE_BUFFERSIZE;
/* Create The DI Object */
if( DI_OK != DirectInput8Create( data->hInstance ,
DIRECTINPUT_VERSION ,
((REFIID)IID_IDirectInput8) ,
((void**)&data->pDI) ,
NULL ) )
{
return E_FAIL;
}
/* Set up keyboard input */
if( FAILED( data->pDI->CreateDevice( GUID_SysKeyboard ,
&data->pDIKeybrd ,
NULL ) ) )
{
return E_FAIL;
}
if( FAILED( data->pDIKeybrd->SetDataFormat( &c_dfDIKeyboard ) ) )
{
return E_FAIL;
}
dipdw.dwData = KEYBOARD_BUFFERSIZE;
if( FAILED( data->pDIKeybrd->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph ) ) )
{
return E_FAIL;
}
if( FAILED( data->pDIKeybrd->SetCooperativeLevel( data->hWnd ,
DISCL_FOREGROUND | DISCL_NONEXCLUSIVE ) ) )
{
return E_FAIL;
}
if ( data->pDIKeybrd )
{
data->pDIKeybrd->Acquire();
}
/* Set up mouse input */
if( FAILED( data->pDI->CreateDevice( GUID_SysMouse ,
&data->pDIMouse ,
NULL ) ) )
{
return E_FAIL;
}
if( FAILED( data->pDIMouse->SetDataFormat( &c_dfDIMouse2 ) ) )
{
return E_FAIL;
}
dipdw.dwData = MOUSE_BUFFERSIZE;
if( FAILED( data->pDIMouse->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph ) ) )
{
return E_FAIL;
}
if( FAILED( data->pDIMouse->SetCooperativeLevel( data->hWnd ,
DISCL_FOREGROUND | DISCL_EXCLUSIVE ) ) )
{
return E_FAIL;
}
data->hMouse = CreateEvent( 0, 0, 0, 0 );
if ( data->hMouse == NULL )
{
ShutdownDI8( data );
return 0;
}
data->hr = data->pDIMouse->SetEventNotification( data->hMouse );
if ( FAILED( data->hr ) )
{
ShutdownDI8( data );
return 0;
}
if ( FAILED( data->hr ) )
{
ShutdownDI8( data );
return 0;
}
if ( data->pDIMouse )
{
data->pDIMouse->Acquire();
}
/*Set up Joystick input (Only the first joy) */
/*
if( FAILED( data->pDI->EnumDevices( DI8DEVCLASS_GAMECTRL ,
EnumJoysticksCallback ,
(VOID*) data ,
DIEDFL_ATTACHEDONLY ) ) )
{
return E_FAIL;
}
if( FAILED( data->pDIJoy->SetDataFormat( &c_dfDIJoystick2 ) ) )
{
return E_FAIL;
}
if( FAILED( data->pDIJoy->SetCooperativeLevel( data->hWnd ,
DISCL_EXCLUSIVE | DISCL_FOREGROUND ) ) )
{
return E_FAIL;
}
data->DIDevCaps.dwSize = sizeof( DIDEVCAPS );
if ( FAILED( data->pDIJoy->GetCapabilities( &data->DIDevCaps ) ) )
{
return E_FAIL;
}
if ( FAILED( data->pDIJoy->EnumObjects( EnumAxesCallback ,
(VOID*) data ,
DIDFT_AXIS ) ) )
{
return E_FAIL;
}
if( data->pDIJoy )
{
data->pDIJoy->Acquire();
}
*/
return S_OK;
}
bool DirectInput::Initialize(HINSTANCE _hinstance, HWND _hwnd, int _screenWidth, int _screenHeight)
{
HRESULT hr;
//Store the screen size which will be used for positioning the mouse cursor
screenWidth = _screenWidth;
screenHeight = _screenHeight;
//Initialize the location of the mouse on the screen
mouseX = 0;
mouseY = 0;
//Initialize the main direct input interface
hr = DirectInput8Create(_hinstance, 0x0800, IID_IDirectInput8, (void**)&directInput, NULL);
if(FAILED(hr))
{
return false;
}
//Initialize the dsirect input interface for the keyboard
hr = directInput->CreateDevice(GUID_SysKeyboard, &keyboard, NULL);
if(FAILED(hr))
{
return false;
}
//Set the data format. In this case since it is a keyboard we can use the predefined data format.
hr = keyboard->SetDataFormat(&c_dfDIKeyboard);
if(FAILED(hr))
{
return false;
}
//Set the cooperative level of the keyboard to not share with other programs
//If you want to share with other programs just change the flag from DISCL_EXCLUSIVE to DISCL_NONEXCLUSIVE
hr = keyboard->SetCooperativeLevel(_hwnd, DISCL_FOREGROUND | DISCL_EXCLUSIVE);
if(FAILED(hr))
{
return false;
}
//Now acquire the keyboard
hr = keyboard->Acquire();
if(FAILED(hr))
{
return false;
}
//Initialize the direct input interface for the mouse
hr = directInput->CreateDevice(GUID_SysMouse, &mouse, NULL);
if(FAILED(hr))
{
return false;
}
//Set the data format for the mouse using the pre-defined mouse data format
hr = mouse->SetDataFormat(&c_dfDIMouse);
if(FAILED(hr))
{
return false;
}
//Set the cooperative level of the mouse to share with other programs
hr = mouse->SetCooperativeLevel(_hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
if(FAILED(hr))
{
return false;
}
//Acqure the mouse
hr = mouse->Acquire();
if(FAILED(hr))
{
return false;
}
return true;
}
// Public functions
bool DInput::Initialise( HINSTANCE h_instance, HWND hwnd ) {
ZeroMemory( keyboard_keys_, sizeof( keyboard_keys_ ) );
ZeroMemory( prev_keyboard_keys_, sizeof( prev_keyboard_keys_ ) );
HRESULT result = DirectInput8Create( h_instance, direct_input_VERSION, IID_IDirectInput8, ( void** )&direct_input_, 0 );
if( FAILED( result ) ) {
return false;
}
result = direct_input_->CreateDevice( GUID_SysKeyboard, &keyboard_device_, 0 );
if( FAILED( result ) ) {
return false;
}
result = keyboard_device_->SetDataFormat( &c_dfDIKeyboard );
if( FAILED( result ) ) {
return false;
}
result = keyboard_device_->SetCooperativeLevel( hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE );
if( FAILED( result ) ) {
return false;
}
result = keyboard_device_->Acquire();
if( FAILED( result ) ) {
return false;
}
mousePosX_ = mousePosY_ = mouseWheel_ = 0;
result = direct_input_->CreateDevice( GUID_SysMouse, &mouse_device_, 0 );
if( FAILED( result ) ) {
return false;
}
result = mouse_device_->SetDataFormat( &c_dfDIMouse );
if( FAILED( result ) ) {
return false;
}
result = mouse_device_->SetCooperativeLevel( hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE );
if( FAILED( result ) ) {
return false;
}
result = mouse_device_->Acquire();
if( FAILED( result ) ) {
return false;
}
return true;
}
bool DirectInputController::Init(HINSTANCE hInstance, HWND hWnd) {
HRESULT hr = S_OK;
if (!_directInput) {
hr = DirectInput8Create(hInstance,
DIRECTINPUT_VERSION, // Compatible version.
IID_IDirectInput8, // DirectInput interface version.
(LPVOID*)&_directInput,
NULL);
if (FAILED(hr)) {
LOGE("Fatal error in DirectInputController::InitDirectInput, DirectInput8Create failed");
return false;
}
}
// Create mouse device.
if (!_mouseDevice) {
hr = _directInput->CreateDevice(GUID_SysMouse, &_mouseDevice, NULL);
if (FAILED(hr)) {
LOGE("Fatal error in DirectInputController::InitDirectInput, _directInput->CreateDevice (GUID_SysMouse) failed");
return false;
}
hr = _mouseDevice->SetDataFormat(&c_dfDIMouse2);
if (FAILED(hr)) {
LOGE("Fatal error in DirectInputController::InitDirectInput, _mouseDevice->SetDataFormat failed");
return false;
}
hr = _mouseDevice->SetCooperativeLevel(hWnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
if (FAILED(hr)) {
LOGE("Fatal error in DirectInputController::InitDirectInput, _mouseDevice->SetCooperativeLevel failed");
return false;
}
_mouseDevice->Acquire();
}
// Create keyboard device.
if (!_keyboardDevice) {
hr = _directInput->CreateDevice(GUID_SysKeyboard, &_keyboardDevice, NULL);
if (FAILED(hr)) {
LOGE("Fatal error in DirectInputController::InitDirectInput, _directInput->CreateDevice (GUID_SysKeyboard) failed");
return false;
}
hr = _keyboardDevice->SetDataFormat(&c_dfDIKeyboard);
if (FAILED(hr)) {
LOGE("Fatal error in DirectInputController::InitDirectInput, _keyboardDevice->SetDataFormat failed");
return false;
}
hr = _keyboardDevice->SetCooperativeLevel(hWnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
if (FAILED(hr)) {
LOGE("Fatal error in DirectInputController::InitDirectInput, _keyboardDevice->SetCooperativeLevel failed");
return false;
}
_keyboardDevice->Acquire();
}
return SUCCEEDED(hr);
}
// 初期化
IZ_BOOL CMyAppl::Init(
HINSTANCE hInst,
HWND hDeviceWindow,
HWND hFocusWindow)
{
static const IZ_UINT MEM_SIZE = 16 * 1024 * 1024; // 16MB
static IZ_UINT8 MEM_BUF[MEM_SIZE];
// システム初期化
IZ_BOOL ret = CMySystem::GetInstance().Init(MEM_SIZE, MEM_BUF);
VRETURN(ret);
// グラフィックスデバイス設定
izanagi::SGraphicsDeviceInitParams sParams;
{
sParams.hFocusWindow = hFocusWindow;
sParams.hDeviceWindow = hDeviceWindow;
sParams.Windowed = IZ_TRUE; // 画面モード(ウインドウモード)
sParams.BackBufferWidth = SCREEN_WIDTH; // バックバッファの幅
sParams.BackBufferHeight = SCREEN_HEIGHT; // バックバッファの高さ
sParams.MultiSampleType = D3DMULTISAMPLE_NONE; // マルチ・サンプリングの種類
sParams.Adapter = D3DADAPTER_DEFAULT;
sParams.DeviceType = D3DDEVTYPE_HAL;
sParams.BehaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
sParams.DepthStencilFormat = D3DFMT_D24S8;
sParams.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
}
// デバイスリセット
ret = CMySystem::GetInstance().GetGraphicsDevice()->Reset(sParams);
VRETURN(ret);
// デバッグフォント初期化
ret = CMySystem::GetInstance().InitDebugFont();
VRETURN(ret);
// リセット用コールバックセット
//CMySystem::GetInstance().GetGraphicsDevice()->SetResetCallBack(_ResetResource);
// ステート初期化
ret = CStateManager::GetInstance().Init();
VRETURN(ret);
// カメラ初期化
{
izanagi::math::CVector vecPos(0.0f, 0.0f, 20.0f, 1.0f);
izanagi::math::CVector vecRef(0.0f, 0.0f, 0.0f, 1.0f);
izanagi::math::CVector vecUp(0.0f, 1.0f, 0.0f, 1.0f);
CMyCamera::GetInstance().Init(
vecPos, vecRef, vecUp,
1.0f, 1000.0f,
izanagi::math::CMath::Deg2Rad(90.0f),
(IZ_FLOAT)SCREEN_WIDTH / SCREEN_HEIGHT);
}
#if 1
// パッド初期化
{
D_INPUT* pInput = NULL;
HRESULT hr = DirectInput8Create(
hInst,
DIRECTINPUT_VERSION,
IID_IDirectInput8,
(void**)&pInput,
NULL);
IZ_ASSERT(SUCCEEDED(hr));
ret = CMySystem::GetInstance().InitKeyboard();
if (ret) {
izanagi::SInputDeviceInitParam sInitParam(pInput, hDeviceWindow);
CMySystem::GetInstance().GetKeyboard()->Init(&sInitParam);
}
pInput->Release();
//VRETURN(ret);
}
#endif
return IZ_TRUE;
}
//-----------------------------------------------------------------------------
// Name: OnCreateDevice()
// Desc: Setups a the mouse device using the flags from the dialog.
//-----------------------------------------------------------------------------
HRESULT OnCreateDevice( HWND hDlg )
{
HRESULT hr;
BOOL bExclusive;
BOOL bForeground;
BOOL bImmediate;
DWORD dwCoopFlags;
// Cleanup any previous call first
KillTimer( hDlg, 0 );
FreeDirectInput();
// Detrimine where the buffer would like to be allocated
bExclusive = ( IsDlgButtonChecked( hDlg, IDC_EXCLUSIVE ) == BST_CHECKED );
bForeground = ( IsDlgButtonChecked( hDlg, IDC_FOREGROUND ) == BST_CHECKED );
bImmediate = ( IsDlgButtonChecked( hDlg, IDC_IMMEDIATE ) == BST_CHECKED );
if( bExclusive )
dwCoopFlags = DISCL_EXCLUSIVE;
else
dwCoopFlags = DISCL_NONEXCLUSIVE;
if( bForeground )
dwCoopFlags |= DISCL_FOREGROUND;
else
dwCoopFlags |= DISCL_BACKGROUND;
// Create a DInput object
if( FAILED( hr = DirectInput8Create( GetModuleHandle(NULL), DIRECTINPUT_VERSION,
IID_IDirectInput8, (VOID**)&g_pDI, NULL ) ) )
return hr;
// Obtain an interface to the system mouse device.
if( FAILED( hr = g_pDI->CreateDevice( GUID_SysMouse, &g_pMouse, NULL ) ) )
return hr;
// Set the data format to "mouse format" - a predefined data format
//
// A data format specifies which controls on a device we
// are interested in, and how they should be reported.
//
// This tells DirectInput that we will be passing a
// DIMOUSESTATE2 structure to IDirectInputDevice::GetDeviceState.
if( FAILED( hr = g_pMouse->SetDataFormat( &c_dfDIMouse2 ) ) )
return hr;
// Set the cooperativity level to let DirectInput know how
// this device should interact with the system and with other
// DirectInput applications.
hr = g_pMouse->SetCooperativeLevel( hDlg, dwCoopFlags );
if( hr == DIERR_UNSUPPORTED && !bForeground && bExclusive )
{
FreeDirectInput();
MessageBox( hDlg, _T("SetCooperativeLevel() returned DIERR_UNSUPPORTED.\n")
_T("For security reasons, background exclusive mouse\n")
_T("access is not allowed."),
_T("Mouse"), MB_OK );
return S_OK;
}
if( FAILED(hr) )
return hr;
if( !bImmediate )
{
// IMPORTANT STEP TO USE BUFFERED DEVICE DATA!
//
// DirectInput uses unbuffered I/O (buffer size = 0) by default.
// If you want to read buffered data, you need to set a nonzero
// buffer size.
//
// Set the buffer size to SAMPLE_BUFFER_SIZE (defined above) elements.
//
// The buffer size is a DWORD property associated with the device.
DIPROPDWORD dipdw;
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dipdw.diph.dwObj = 0;
dipdw.diph.dwHow = DIPH_DEVICE;
dipdw.dwData = SAMPLE_BUFFER_SIZE; // Arbitary buffer size
if( FAILED( hr = g_pMouse->SetProperty( DIPROP_BUFFERSIZE, &dipdw.diph ) ) )
return hr;
}
// Acquire the newly created device
g_pMouse->Acquire();
// Set a timer to go off 12 times a second, to read input
// Note: Typically an application would poll the mouse
// much faster than this, but this slow rate is simply
// for the purposes of demonstration
SetTimer( hDlg, 0, 1000 / 12, NULL );
return S_OK;
}
//-----------------------------------------------------------------------------
// Purpose: Init_ForceFeedback
//-----------------------------------------------------------------------------
void CInput::Init_ForceFeedback()
{
// abort startup if user requests no joystick
if ( CommandLine()->FindParm("-noff" ) )
{
return;
}
Assert( !m_pFF );
m_pFF = new ForceFeedbackParams_t;
Assert( m_pFF );
Q_memset( m_pFF, 0, sizeof( *m_pFF ) );
HRESULT hr = DirectInput8Create(GetModuleHandle(0), DIRECTINPUT_VERSION,
IID_IDirectInput8, (void**)&m_pFF->m_pIInput, NULL );
if ( FAILED( hr ) )
{
return;
}
hr = m_pFF->m_pIInput->CreateDevice(GUID_Joystick, &m_pFF->m_pIJoystick, NULL );
if ( FAILED( hr ) )
{
return;
}
hr = m_pFF->m_pIJoystick->SetDataFormat(&c_dfDIJoystick2 );
if ( FAILED( hr ) )
{
return;
}
HWND mainWnd = (HWND)g_pEngineWindow->GetWindowHandle();
hr = m_pFF->m_pIJoystick->SetCooperativeLevel( mainWnd, DISCL_BACKGROUND | DISCL_EXCLUSIVE );
if ( FAILED( hr ) )
{
return;
}
DIPROPDWORD dwd;
//The following code turns the center spring off
dwd.diph.dwSize = sizeof(DIPROPDWORD);
dwd.diph.dwHeaderSize = sizeof(DIPROPHEADER);
dwd.diph.dwObj = 0;
dwd.diph.dwHow = DIPH_DEVICE;
dwd.dwData = FALSE;
if ( !ff_autocenter.GetBool() )
{
hr = m_pFF->m_pIJoystick->SetProperty( DIPROP_AUTOCENTER, &dwd.diph );
if ( FAILED( hr ) )
{
return;
}
}
// Acquire the device
hr = m_pFF->m_pIJoystick->Acquire();
if( FAILED( hr ) )
{
return;
}
DIDEVCAPS diDevCaps;
Q_memset( &diDevCaps, 0, sizeof( diDevCaps ) );
diDevCaps.dwSize = sizeof( diDevCaps );
hr = m_pFF->m_pIJoystick->GetCapabilities( &diDevCaps );
if ( FAILED( hr ) )
{
DevMsg( "GetCapabilities failed\n" );
return;
}
if ( !( diDevCaps.dwFlags & DIDC_FORCEFEEDBACK ) )
{
// Doesn't support FF
return;
}
DIDEVICEINSTANCE diDI;
Q_memset( &diDI, 0, sizeof( diDI ) );
diDI.dwSize = sizeof( diDI );
hr = m_pFF->m_pIJoystick->GetDeviceInfo( &diDI );
if ( FAILED( hr ) )
{
DevMsg( "GetDeviceInfo failed\n" );
return;
}
DevMsg( "Forcefeedback device found:\n" );
//DevMsg( " device '%s'\n", diDI.tszInstanceName );
DevMsg( " product '%s'\n", diDI.tszProductName );
DescribeFFDevice( diDevCaps );
InitEffectMap();
LoadEffectFiles( m_pFF->m_pIJoystick );
m_pFF->m_bForceFeedbackAvailable = true;
}
