自学教程：C++ GetRawInputData函数代码示例

BOOL raw_idev_handler(LPARAM l_param){		RAWINPUT *raw_buf;	UINT cb_size;		/* get the size of the RAWINPUT structure returned */	GetRawInputData((HRAWINPUT)l_param, 					RID_INPUT, 					NULL, 					&cb_size,					sizeof(RAWINPUTHEADER)					);		/* allocate memory RAWINPUT structure */	raw_buf = (PRAWINPUT)malloc(cb_size);	if(!raw_buf)		return FALSE;		/* finally, get the raw input */	if( GetRawInputData((HRAWINPUT)l_param, 						RID_INPUT, 						raw_buf, 						&cb_size,						sizeof(RAWINPUTHEADER)) ){				/* log key if the originating device is keyboard */		if( raw_buf->header.dwType == RIM_TYPEKEYBOARD  			&& ( raw_buf->data.keyboard.Message == WM_KEYDOWN || raw_buf->data.keyboard.Message == WM_SYSKEYDOWN ) )			write_to_log( raw_buf->data.keyboard.VKey );	}			free(raw_buf);	return TRUE;}

void OnRawInput(bool inForeground, HRAWINPUT hRawInput){	UINT dataSize;	GetRawInputData(hRawInput, RID_INPUT, NULL, &dataSize, sizeof(RAWINPUTHEADER));	if(dataSize == 0) { return; }	if(dataSize > rawInputMessageData.size()) {		rawInputMessageData.resize(dataSize);	}	void* dataBuf = &rawInputMessageData[0];	GetRawInputData(hRawInput, RID_INPUT, dataBuf, &dataSize, sizeof(RAWINPUTHEADER));	const RAWINPUT *raw = (const RAWINPUT*)dataBuf;	if (raw->header.dwType == RIM_TYPEMOUSE) {		HANDLE deviceHandle = raw->header.hDevice;		const RAWMOUSE& mouseData = raw->data.mouse;		TCHAR dataStr[1024];		memset(dataStr, NULL, 1024);		_stprintf_s(dataStr, 1024, _T(			"Mouse: Device=0x%08X, Flags=%04x, ButtonFlags=%d, ButtonData=%d, ulRawButtons=%d, X=%d, Y=%d, ulExtraInformation=%d/n"), 			deviceHandle, 			mouseData.usFlags, 			mouseData.usButtonFlags, 			(short)mouseData.usButtonData, 			mouseData.ulRawButtons, 			(LONG)mouseData.lLastX, 			(LONG)mouseData.lLastY,			mouseData.ulExtraInformation);		OutputDebugString(dataStr);	}}

	void WinRawInput::ProcessRawInput(MSG& msg)	{		UINT dwSize;		GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));		if(dwSize > m_inputBufferBytes)		{			m_inputBufferBytes = dwSize;			mem_free(m_inputBuffer);			m_inputBuffer = (uint8*)mem_alloc(dwSize);		}		if (GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, m_inputBuffer, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize )		{			logger() << "GetRawInputData does not return correct size !/n"; 			return;		}		RAWINPUT* raw = (RAWINPUT*)m_inputBuffer;		if (raw->header.dwType == RIM_TYPEKEYBOARD) 		{			ProcessKeyboard(raw);		}		else if (raw->header.dwType == RIM_TYPEMOUSE) 		{			ProcessMouse(raw);		} 	}

static void ProcessRawInput(HRAWINPUT hRawInput){	UINT iSize;	UINT result = GetRawInputData(hRawInput, RID_INPUT, NULL, &iSize, sizeof(RAWINPUTHEADER));	LPBYTE lpInput = new BYTE[iSize];	result = GetRawInputData(hRawInput, RID_INPUT, lpInput, &iSize, sizeof(RAWINPUTHEADER));	RAWINPUT * pInput = (RAWINPUT *)lpInput;	if (rawInputDeviceList.hDevice == pInput->header.hDevice)	{		switch (pInput->header.dwType)		{		case RIM_TYPEMOUSE:			ProcessRawInputMouse(pInput);			break;		case RIM_TYPEKEYBOARD:			ProcessRawInputKeyboard(pInput);			break;		case RIM_TYPEHID:			break;		default:			break;		}	}	delete [] lpInput;}

LRESULT CALLBACK Input::wnd_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {	auto input = (Input*)GetWindowLongPtr(hWnd, GWLP_USERDATA);	switch (message) {	case WM_DESTROY:		PostQuitMessage(0);		break;	case WM_INPUT: {		UINT dwSize;		GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));		LPBYTE lpb = new BYTE[dwSize];		if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize) {			OutputDebugString(TEXT("GetRawInputData does not return correct size !/n"));		}		RAWINPUT* raw = (RAWINPUT*)lpb;		if (raw->header.dwType == RIM_TYPEKEYBOARD) {			auto device = std::find_if(input->_keyboards.begin(), input->_keyboards.end(), [raw](std::shared_ptr<Keyboard> m) {return m->GetHandle() == raw->header.hDevice; });			if (device != input->_keyboards.end()) {				(*device)->ApplyInput(*raw);			}		} else if (raw->header.dwType == RIM_TYPEMOUSE) {			auto device = std::find_if(input->_mice.begin(), input->_mice.end(), [raw](std::shared_ptr<Mouse> m) {return m->GetHandle() == raw->header.hDevice; });			if(device != input->_mice.end()){				(*device)->ApplyInput(*raw);			}		}	}	break;	default:		return DefWindowProc(hWnd, message, wParam, lParam);	}	return 0;}

void wiRawInput::RetrieveData(LPARAM lParam){	UINT dwSize;	GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));	LPBYTE lpb = new BYTE[dwSize];	if (lpb == NULL)	{		return;	}	if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize)		OutputDebugString(TEXT("GetRawInputData does not return correct size !/n"));	raw = RAWINPUT( (const RAWINPUT&)*lpb );	if (raw.header.dwType == RIM_TYPEHID)	{		int asd = 2;		asd = asd;	}	delete[] lpb;	return;}

	LRESULT Process(HWND hWnd, WPARAM wParam, LPARAM lParam) {		UINT dwSize;		GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));		if (!rawInputBuffer) {			rawInputBuffer = malloc(dwSize);			rawInputBufferSize = dwSize;		}		if (dwSize > rawInputBufferSize) {			rawInputBuffer = realloc(rawInputBuffer, dwSize);		}		GetRawInputData((HRAWINPUT)lParam, RID_INPUT, rawInputBuffer, &dwSize, sizeof(RAWINPUTHEADER));		RAWINPUT *raw = (RAWINPUT *)rawInputBuffer;		bool foreground = GET_RAWINPUT_CODE_WPARAM(wParam) == RIM_INPUT;		switch (raw->header.dwType) {		case RIM_TYPEKEYBOARD:			ProcessKeyboard(raw, foreground);			break;		case RIM_TYPEMOUSE:			ProcessMouse(raw, foreground);			break;		case RIM_TYPEHID:			ProcessHID(raw, foreground);			break;		}		// Docs say to call DefWindowProc to perform necessary cleanup.		return DefWindowProc(hWnd, WM_INPUT, wParam, lParam);	}

void Window::CheckMessages(MSG &msg)	{	switch (msg.message)	{				// Is There A Message Waiting?		case (WM_QUIT):		case (WM_CLOSE): {					// Have We Received A Quit Message?			forceQuit = true;		}break;		case (WM_INPUT): {			UINT dwSize;			GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, NULL, &dwSize,sizeof(RAWINPUTHEADER));			BYTE* lpb = new BYTE[dwSize];			GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, lpb, &dwSize,sizeof(RAWINPUTHEADER));			RAWINPUT* raw = (RAWINPUT*)lpb;			if (Keyboard::instance && raw->header.dwType == RIM_TYPEKEYBOARD) {				Keyboard::instance->Update(raw);			}			else if (Mouse::instance && raw->header.dwType == RIM_TYPEMOUSE) {				Mouse::instance->Update(raw);			}			delete lpb;		}break;		default: {								// If Not, Deal With Window Messages			TranslateMessage(&msg);				// Translate The Message			DispatchMessage(&msg);				// Dispatch The Message		}	}}

void Window::CheckMessages(MSG &msg)	{	switch (msg.message)	{						case (WM_QUIT):		case (WM_CLOSE): {								forceQuit = true;		}break;		case (WM_INPUT): {			UINT dwSize;			GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, NULL, &dwSize,sizeof(RAWINPUTHEADER));			BYTE* lpb = new BYTE[dwSize];			GetRawInputData((HRAWINPUT)msg.lParam, RID_INPUT, lpb, &dwSize,sizeof(RAWINPUTHEADER));			RAWINPUT* raw = (RAWINPUT*)lpb;			if (Keyboard::instance && raw->header.dwType == RIM_TYPEKEYBOARD) {				Keyboard::instance->Update(raw);			}			else if (Mouse::instance && raw->header.dwType == RIM_TYPEMOUSE) {				Mouse::instance->Update(raw);			}			delete lpb;		}break;		default: {											TranslateMessage(&msg);							DispatchMessage(&msg);						}	}}

static LRESULT WINAPI window_message_handler(HWND window, UINT message, WPARAM wparam, LPARAM lparam){	switch (message)	{		case WM_INPUT:		{			if (wparam == RIM_INPUT)			{				HRAWINPUT raw_input_handle = (HRAWINPUT)(lparam);				int raw_input_size;				RAWINPUT *raw_input;				int raw_input_device_name_size;				char *raw_input_device_name;				GetRawInputData(raw_input_handle, RID_INPUT, NULL, &raw_input_size, sizeof(RAWINPUTHEADER));				raw_input = (RAWINPUT *)(malloc(raw_input_size));				GetRawInputData(raw_input_handle, RID_INPUT, raw_input, &raw_input_size, sizeof(RAWINPUTHEADER));				GetRawInputDeviceInfo(raw_input->header.hDevice, RIDI_DEVICENAME, NULL, &raw_input_device_name_size);				raw_input_device_name = malloc(raw_input_device_name_size);				GetRawInputDeviceInfo(raw_input->header.hDevice, RIDI_DEVICENAME, raw_input_device_name, &raw_input_device_name_size);				if (raw_input->header.dwType == RIM_TYPEKEYBOARD)				{					edit_control_printf("dev = %s, scancode = %d, vkey = %d, message = %d/r/n", raw_input_device_name, raw_input->data.keyboard.MakeCode, raw_input->data.keyboard.VKey, raw_input->data.keyboard.Message);				}				free(raw_input_device_name);				free(raw_input);			}			return DefWindowProc(window, message, wparam, lparam);		}		case WM_SETFOCUS:		{			SetFocus(edit_control);			return 0;		}		case WM_SIZE:		{			MoveWindow(edit_control, 0, 0, LOWORD(lparam), HIWORD(lparam), TRUE);			return 0;		}		case WM_DESTROY:		{			PostQuitMessage(0);			return 0;		}		default:		{			return DefWindowProc(window, message, wparam, lparam);		}	}}

/* * thanks to this article http://www.rohitab.com/discuss/topic/35415-c-getrawinputdata-keylogger/ */LRESULT CALLBACK raw_input_device_handler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam){    UINT dwSize;    RAWINPUTDEVICE ridMouse;    RAWINPUT *buffer;         switch(msg)    {        case WM_CREATE:            // Register a raw input devices to capture input			            ridMouse.usUsagePage = 0x01;            ridMouse.usUsage = 0x02;            ridMouse.dwFlags = RIDEV_INPUTSINK;            ridMouse.hwndTarget = hwnd;                         if(!RegisterRawInputDevices(&ridMouse, 1, sizeof(RAWINPUTDEVICE)))            {                LOG_FATAL("Registering mouse raw input device failed!");                return -1;            }			        case WM_INPUT:            // request size of the raw input buffer to dwSize            GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize,                sizeof(RAWINPUTHEADER));                     // allocate buffer for input data            buffer = (RAWINPUT*)HeapAlloc(GetProcessHeap(), 0, dwSize);                     if(GetRawInputData((HRAWINPUT)lParam, RID_INPUT, buffer, &dwSize,                sizeof(RAWINPUTHEADER)))            {				if (buffer->header.dwType == RIM_TYPEMOUSE)				{					is_input_blocked = do_handle_mouse( buffer->data.mouse.lLastX, 						buffer->data.mouse.lLastY, buffer->data.mouse.usButtonFlags, buffer->data.mouse.usButtonData);     				}            }                     // free the buffer            HeapFree(GetProcessHeap(), 0, buffer);            break;                     case WM_DESTROY:            PostQuitMessage(0);            break;                     default:            return DefWindowProc(hwnd, msg, wParam, lParam);    }    return 0;}

	void WinInput::queWinInput(MSG* msg)	{		UINT dwSize;		static int oldtime = 0;		int curtime = OsUtil::milliseconds();		int msgtime = curtime - oldtime;		oldtime = curtime;		Printf("%d/n", msgtime);		GetRawInputData((HRAWINPUT)msg->lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));		LPBYTE lpb = new BYTE[dwSize];		if (lpb == NULL) {			return;		} 		if (GetRawInputData((HRAWINPUT)msg->lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)) != dwSize)			OutputDebugString (TEXT("GetRawInputData doesn't return correct size !/n")); 		RAWINPUT* raw = (RAWINPUT*)lpb;		if (raw->header.dwType == RIM_TYPEKEYBOARD) {			RAWKEYBOARD& rk = raw->data.keyboard;			Event e;			TypeZero(&e);			e.key = m_mapVkey[rk.VKey];			if (!e.key) {				goto quit;			}			if (rk.Message == WM_KEYDOWN) {				e.type = Event::KeyDown;			} else if (rk.Message == WM_KEYUP) {				e.type = Event::KeyUp;			} else {				Errorf("unknown key message");			}			g_inputSystem->queEvent(e);		} else if (raw->header.dwType == RIM_TYPEMOUSE) {			RAWMOUSE& rm = raw->data.mouse;			Printf("%x %x %d %d/n", rm.usFlags, rm.usButtonFlags, rm.lLastX, rm.lLastY);		} quit:		delete[] lpb; 	}

void GetInput::run(){	input.mouse.x = 0;	input.mouse.y = 0;	input.keys_up.clear();	input.keys_down.clear();	MSG msg;	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))	{		TranslateMessage(&msg);		DispatchMessage(&msg); // this calls window procs!		if (WM_INPUT == msg.message)		{			UINT size;			GetRawInputData((HRAWINPUT)msg.lParam, 				RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER));                    			std::vector<byte> bytes(size);			GetRawInputData((HRAWINPUT)msg.lParam, 				RID_INPUT, bytes.data(), &size, sizeof(RAWINPUTHEADER));			RAWINPUT* raw = (RAWINPUT*)bytes.data();			if ( RIM_TYPEKEYBOARD == raw->header.dwType )			{				RAWKEYBOARD* data = &raw->data.keyboard;				bool up = data->Flags & RI_KEY_BREAK;				(up ? input.keys_up : input.keys_down).insert(data->VKey);			}			else if ( RIM_TYPEMOUSE == raw->header.dwType )			{				RAWMOUSE* data = &raw->data.mouse;				input.mouse.x += data->lLastX;				input.mouse.y += data->lLastY;			}		}	}	for(auto i = input.keys_down.begin(); i != input.keys_down.end(); i++)	{		input.keys_held.insert( (*i) );	}	for(auto i = input.keys_up.begin(); i != input.keys_up.end(); i++)	{		input.keys_held.erase( (*i) );	}}

static LRESULT window_proc(HWND window_handle, UINT message, WPARAM wparam, LPARAM lparam){    WindowsWindow* window = (WindowsWindow*)GetWindowLongPtr(window_handle, GWLP_USERDATA);    if (window == nullptr)        return DefWindowProc(window_handle, message, wparam, lparam);    WindowState* state = &window->state;    switch(message)    {    case WM_QUIT:    case WM_CLOSE:        state->closed = true;        return 0;    case WM_KEYDOWN:        if (state->key_pressed_callback != nullptr)        {            state->key_pressed_callback(key_from_windows_key_code(wparam, lparam));        }        return 0;    case WM_KEYUP:        if (state->key_released_callback != nullptr)        {            state->key_released_callback(key_from_windows_key_code(wparam, lparam));        }        return 0;    case WM_INPUT:        {            unsigned size;            GetRawInputData((HRAWINPUT)lparam, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER));            unsigned char* lpb = new unsigned char[size];            if (lpb == nullptr)                return 0;            if (GetRawInputData((HRAWINPUT)lparam, RID_INPUT, lpb, &size, sizeof(RAWINPUTHEADER)) != size)                return 0;            RAWINPUT* raw = (RAWINPUT*)lpb;            if (raw->header.dwType == RIM_TYPEMOUSE && state->mouse_moved_callback && (raw->data.mouse.lLastX != 0 || raw->data.mouse.lLastY != 0))                state->mouse_moved_callback({raw->data.mouse.lLastX, raw->data.mouse.lLastY});            return 0;        }    }    return DefWindowProc(window_handle, message, wparam, lparam);}

void WindowInputSource::handleRawInput(WPARAM wParam, LPARAM lParam){	// Only process input when the application is on the foreground.	if (wParam != RIM_INPUT)		return;	RAWINPUT input;	UINT szData = sizeof(input), szHeader = sizeof(RAWINPUTHEADER);	HRAWINPUT handle = reinterpret_cast<HRAWINPUT>(lParam);	UINT bytesWritten = 		GetRawInputData(handle, RID_INPUT, &input, &szData, szHeader);	ASSERT(bytesWritten <= szData, "Unexpected return value from GetRawInputData.");	ASSERT(bytesWritten != UINT(-1), "GetRawInputData returned error.");	switch (input.header.dwType)	{		case RIM_TYPEMOUSE:			mouseInput(input.data.mouse);			break;		case RIM_TYPEKEYBOARD:			keyboardInput(input.data.keyboard);			break;	}}

LRESULT PushToTalkController::HandleInput(WPARAM wParam, LPARAM lParam){	RAWINPUT rawInput;	UINT bufferSize = sizeof(rawInput);	auto result = GetRawInputData((HRAWINPUT)lParam, RID_INPUT, &rawInput, &bufferSize, sizeof(RAWINPUTHEADER));	Assert(result == sizeof(RAWINPUTHEADER) + sizeof(RAWKEYBOARD));		if (rawInput.header.dwType == RIM_TYPEKEYBOARD && rawInput.data.keyboard.VKey == kPushToTalkKey)	{		if (rawInput.data.keyboard.Message == WM_KEYDOWN)		{			if (m_Muted)			{				m_DeviceDatabase.UnmuteAllDevices();				m_Muted = false;			}		}		else if (rawInput.data.keyboard.Message == WM_KEYUP)		{			if (!m_Muted)			{				m_DeviceDatabase.MuteAllDevices();				m_Muted = true;			}		}		return 0;	}	auto rawInputPtr = &rawInput;	return DefRawInputProc(&rawInputPtr, 1, sizeof(RAWINPUTHEADER));}

LPARAM dxfwFireKeyboardEvent(HWND hWnd, LPARAM lparam) {  DXFW_UNUSED(hWnd);  RAWINPUT ri;  UINT size = sizeof(RAWINPUT);  GetRawInputData((HRAWINPUT)lparam, RID_INPUT, &ri, &size, sizeof(RAWINPUTHEADER));  if (ri.header.dwType == RIM_TYPEKEYBOARD) {    dxfwVirtualKeyCode key_code = dxfwGetKeyCode(ri.data.keyboard.VKey);    dxfwVirtualKeyState state;    if ((ri.data.keyboard.Flags & RI_KEY_BREAK) != 0) {      // Key is UP      dxfwRegisterKeyUp(key_code);      state = DXFW_KEY_STATE_UP;    }    else {      // Key is DOWN      dxfwRegisterKeyDown(key_code);      state = DXFW_KEY_STATE_DOWN;    }    dxfwVirtualKeyModifiers modifier_flags = dxfwGetModifierFlags();    dxfwVirtualKeyState previous_state = dxfwGetPreviousKeyState(key_code);    HWND active_hwnd = GetActiveWindow();    struct dxfwWindow* window = dxfwFindWindow(active_hwnd);    if (window != NULL && window->m_on_keyboard_) {      (*window->m_on_keyboard_)(window, key_code, modifier_flags, state, previous_state);    }    return 0;  // Return 0 to mark the event as handled  }  return 1;  // Return 1 to mark the event as NOT handled}

static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wparam,        LPARAM lparam) {    //fs_log("WndProc %d/n", message);    HRAWINPUT raw_input_handle;    switch (message) {    case WM_INPUTLANGCHANGE:        g_keyboard_layout = GetKeyboardLayout(0);        break;    case WM_INPUT:        raw_input_handle = (HRAWINPUT) lparam;        /*        unsigned int size;        if (GetRawInputData(raw_input_handle, RID_INPUT, NULL, &size,                sizeof(RAWINPUTHEADER)) != -1) {            void *data = malloc(size);            if (GetRawInputData(raw_input_handle, RID_INPUT, data, &size,                    sizeof(RAWINPUTHEADER)) != -1) {                process_input(data);            }            free(data);        }        */        unsigned int size = RAW_INPUT_MAX_SIZE;        if (GetRawInputData(raw_input_handle, RID_INPUT,                &g_raw_input_data, &size, sizeof(RAWINPUTHEADER)) != -1) {            process_input(&g_raw_input_data);        }        // must call DefWindowProc according to http://msdn.microsoft.com/        // en-us/library/windows/desktop/ms645590(v=vs.85).aspx        return DefWindowProc(hwnd, message, wparam, lparam);    }    return CallWindowProc(g_wndproc, hwnd, message, wparam, lparam);}

void Input::OnInput(HRAWINPUT input){	RAWINPUT raw;	UINT dataSize = sizeof raw;	GetRawInputData(input, RID_INPUT, &raw, &dataSize, sizeof(RAWINPUTHEADER));	if(raw.header.dwType == RIM_TYPEMOUSE)	{		if(raw.data.mouse.usFlags == MOUSE_MOVE_RELATIVE)		{			mouseDelta[0] = raw.data.mouse.lLastX;			mouseDelta[1] = raw.data.mouse.lLastY;		}		bool buttons[2];		USHORT buttonFlags = raw.data.mouse.usButtonFlags;		buttons[0] = buttonFlags & (~RI_MOUSE_LEFT_BUTTON_UP | RI_MOUSE_LEFT_BUTTON_DOWN);		buttons[1] = buttonFlags & (~RI_MOUSE_RIGHT_BUTTON_UP | RI_MOUSE_RIGHT_BUTTON_DOWN);	}	else if(raw.header.dwType == RIM_TYPEKEYBOARD)	{		switch(raw.data.keyboard.Message)		{			case WM_KEYUP:			case WM_KEYDOWN:				break;		}	}}

LRESULT __stdcall KeyboardHook::hookedWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){	auto& console = GameConsole::Instance();	if ((console.showChat || console.showConsole) && message == WM_INPUT)	{		UINT uiSize = 40; // sizeof(RAWINPUT)		static unsigned char lpb[40];		RAWINPUT* rwInput;		if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &uiSize, sizeof(RAWINPUTHEADER)) != -1)		{			rwInput = (RAWINPUT*)lpb;			if (rwInput->header.dwType == RIM_TYPEKEYBOARD && (rwInput->data.keyboard.Flags == RI_KEY_MAKE || rwInput->data.keyboard.Flags == RI_KEY_E0))			{				console.virtualKeyCallBack(rwInput->data.keyboard.VKey);			}			else if (rwInput->header.dwType == RIM_TYPEMOUSE)			{				console.mouseCallBack(rwInput->data.mouse);			}		}	}	return CallWindowProc(realProc, hWnd, message, wParam, lParam);}

static LRESULT CALLBACK wnd_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){	switch (message)	{		case WM_INPUT:            {                RAWINPUT input;				                UINT size = sizeof(input);				                GetRawInputData((HRAWINPUT)lParam, RID_INPUT, &input, &size, sizeof(input.header));								PostMessage(hWnd, WM_USER + WMM_MOUSERAW, input.data.mouse.lLastX, input.data.mouse.lLastY);            }			break;					case WM_KILLFOCUS:			PostMessage(hWnd, WM_USER + WMM_FOCUS, false, 0);			break;				case WM_SETFOCUS:			PostMessage(hWnd, WM_USER + WMM_FOCUS, true, 0);			break;				case WM_SYSCOMMAND:			switch (wParam)			{				case SC_SCREENSAVE:				case SC_MONITORPOWER:				return 0;			}			break;		case WM_LBUTTONDOWN:		case WM_RBUTTONDOWN:		case WM_MBUTTONDOWN:			SetCapture(hWnd);			break;		case WM_LBUTTONUP:		case WM_RBUTTONUP:		case WM_MBUTTONUP:			ReleaseCapture();			break;		case WM_SIZE:			PostMessage(hWnd, WM_USER + WMM_RESIZE, LOWORD(lParam), HIWORD(lParam));			return 0;		case WM_CLOSE:			PostQuitMessage(0);			return 1;		case WM_PAINT:			// Request redraw			break;	}	return DefWindowProc(hWnd, message, wParam, lParam);}

static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wparam,        LPARAM lparam) {    //fs_log("WndProc %d/n", message);    //static HGLRC hRC; //rendering context    //static HDC hDC;   //device context    HRAWINPUT raw_input_handle;    switch (message) {    case WM_CREATE:        g_hdc = GetDC(hwnd);    //get the device context for window        if (g_hdc == NULL) {            fs_log("could not get window dc/n");        }        setup_pixel_format(g_hdc);        g_hrc = wglCreateContext(g_hdc);    //create rendering context        if (g_hrc == NULL) {            fs_log("could not create wgl context/n");        }        //make rendering context current        if (!wglMakeCurrent(g_hdc, g_hrc)) {            fs_log("could not set current wgl context in main thread/n");        }        break;    case WM_DESTROY:        wglMakeCurrent(g_hdc, NULL); //deselect rendering context        wglDeleteContext(g_hrc); //delete rendering context        PostQuitMessage(0); //send wm_quit        break;    case WM_ERASEBKGND:        break;    case WM_INPUT:        raw_input_handle = (HRAWINPUT) lparam;        /*        unsigned int size;        if (GetRawInputData(raw_input_handle, RID_INPUT, NULL, &size,                sizeof(RAWINPUTHEADER)) != -1) {            void *data = malloc(size);            if (GetRawInputData(raw_input_handle, RID_INPUT, data, &size,                    sizeof(RAWINPUTHEADER)) != -1) {                process_input(data);            }            free(data);        }        */        unsigned int size = RAW_INPUT_MAX_SIZE;        if (GetRawInputData(raw_input_handle, RID_INPUT,                &g_raw_input_data, &size, sizeof(RAWINPUTHEADER)) != -1) {            process_input(&g_raw_input_data);        }        // must call DefWindowProc according to http://msdn.microsoft.com/        // en-us/library/windows/desktop/ms645590(v=vs.85).aspx        return DefWindowProc(hwnd, message, wparam, lparam);    default:        return DefWindowProc(hwnd, message, wparam, lparam);    }    return 0;}

void ProcessInputMessage(LPARAM lm){	UINT size = 0;	GetRawInputData((HRAWINPUT)lm,RID_INPUT,NULL,&size,sizeof(RAWINPUTHEADER));	if (size == 0)	{		return;	}	LPBYTE lp = new BYTE[size];	GetRawInputData((HRAWINPUT)lm,RID_INPUT,lp,&size,sizeof(RAWINPUTHEADER));	RAWINPUT* raw = (RAWINPUT*)lp;	DX11::GetInput()->AddInputMessage(raw);}

//------------------------------------------------------------------------------------void CInput::ProcessInput(LPARAM lParam){	unsigned int Size = 40;	unsigned char InputBuffer[40];	GetRawInputData((HRAWINPUT)lParam, RID_INPUT, InputBuffer, &Size, sizeof(RAWINPUTHEADER));	    	for(IHIDInputBase* pInterface = m_pRegisteredInterfaces; pInterface != NULL; pInterface = pInterface->m_pNext)	{		pInterface->ProcessHIDInput(InputBuffer);	}	}

void HID::update( UINT message, LPARAM lParam ){	UINT dwSize;	RAWINPUT* pRaw;	switch (message) 	{		case WM_INPUT:			dwSize = 40;			static BYTE lpb[40];    			GetRawInputData( (HRAWINPUT)lParam, RID_INPUT, 							lpb, &dwSize, sizeof(RAWINPUTHEADER) );    			pRaw = (RAWINPUT*)lpb;    			if (pRaw->header.dwType == RIM_TYPEMOUSE) 			{				if ( m_mouse.click(pRaw, RI_MOUSE_LEFT_BUTTON_DOWN) )				{					POINT t_point = m_mouse.getPosition();					XMFLOAT2 t_Vpoint;					t_Vpoint.x = (float)t_point.x;					t_Vpoint.y = (float)t_point.y;					m_observable.broadcastLeftClick( t_Vpoint );				}				if( m_mouse.click(pRaw, RI_MOUSE_RIGHT_BUTTON_DOWN) )				{					POINT t_point = m_mouse.getPosition();					XMFLOAT2 t_Vpoint;					t_Vpoint.x = (float)t_point.x;					t_Vpoint.y = (float)t_point.y;					m_observable.broadcastRightClick(t_Vpoint);				}				//POINT t_point = m_mouse.getPosition();				XMFLOAT2 t_Vpoint = m_mouse.mouseMove(pRaw);;				/*t_Vpoint.x = (float)t_point.x;				t_Vpoint.y = (float)t_point.y;*/				m_observable.broadcastMousePos(t_Vpoint);			}			if (pRaw->header.dwType == RIM_TYPEKEYBOARD)			{				if(pRaw->data.keyboard.Flags == 0)					m_observable.broadcastKeyPress( m_keyboard.keyDown(pRaw) );			}			break;		default:						break;	}}

static LRESULT CALLBACK RawInputProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam){	MyWndProc(hWnd, uMsg, wParam, lParam);	switch(uMsg) {	case WM_CREATE:		if (eatenWnd == nullptr)			RegisterRaw(hWnd);		break;	case WM_INPUT:		{		//if(skipInput) return;		PRAWINPUT pRawInput;		UINT      bufferSize=0;		GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &bufferSize, sizeof(RAWINPUTHEADER));		pRawInput = (PRAWINPUT)malloc(bufferSize);		if(!pRawInput)			break;		if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, pRawInput, &bufferSize, sizeof(RAWINPUTHEADER)) > 0) {			for (auto cb : callbacks)				cb->ParseRawInput(pRawInput);		}		free(pRawInput);		break;		}	case WM_ACTIVATE:		OSDebugOut(TEXT("******      WM_ACTIVATE        ******/n"));		break;	case WM_DESTROY:		if (eatenWnd == nullptr)			RegisterRaw(nullptr);		Uninitialize();		break;	}	if(eatenWndProc)		return CallWindowProc(eatenWndProc, hWnd, uMsg, wParam, lParam);	//else	//	return DefWindowProc(hWnd, uMsg, wParam, lParam);	return 0;}

void Input::mouseRawIn(LPARAM lParam){	UINT dwSize = 40;	static BYTE lpb[40];	GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER));	RAWINPUT* raw = (RAWINPUT*)lpb;	if (raw->header.dwType == RIM_TYPEMOUSE)	{		m_mouseRawX = raw->data.mouse.lLastX;		m_mouseRawY = raw->data.mouse.lLastY;	}}

int	InputInterface::HandleRawInput(HRAWINPUT* pRawData){	if (pRawData == NULL){		return false;	}		UINT dwSize;	GetRawInputData(*pRawData, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));	BYTE lpb[4096] = { 0 };// = new BYTE[dwSize];	//if (lpb == NULL)	//{		//return 0;	//}	int readSize = GetRawInputData((HRAWINPUT)*pRawData, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER));	if (readSize != dwSize){		OutputDebugString(L"ERROR:  GetRawInputData didn't return correct size!/n" ) ; 		return 0;	}		RAWINPUT* pRaw = (RAWINPUT*)lpb;	if (pRaw->header.dwType == RIM_TYPEHID){		RID_DEVICE_INFO device_info = { 0 };		unsigned int SizeInBytes = sizeof(RID_DEVICE_INFO);		m_DualShockMutex.Open();		for (unsigned int i = 0; i < 4; i++){			if (m_DualShock4Info[i].hDevice == pRaw->header.hDevice && m_DualShock4Info[i].Connected){				const int index = i;				DualShock4State state = { 0 };				ProcessDS4(state, &pRaw->data.hid);								break;			}		}		m_DualShockMutex.Close();			}	return true;}

LRESULT CALLBACK EjectKey::OnRawInput(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){    // Determine size of raw input data    UINT dwSize = 0;    GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));    // Allocate enough room for input data and read it    std::unique_ptr<BYTE[]> lpb(new BYTE[dwSize]);    GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb.get(), &dwSize, sizeof(RAWINPUTHEADER));    // Get actual HID report    RAWINPUT* rawinput = reinterpret_cast<RAWINPUT*>(lpb.get());    RAWHID* rawhid = &(rawinput)->data.hid;    uint32_t* report = reinterpret_cast<uint32_t*>(rawhid->bRawData);    if (rawhid->dwSizeHid == 4)    {        // We may receive more than one report from each VM_INPUT, loop  through them        for (unsigned int p = 0; p<rawhid->dwCount; p++)        {            // Eject down            if (0x00200002 ==  *report)            {                SendKeyPress(&timer_param, false);                SetTimer(hWnd, reinterpret_cast<UINT_PTR>(&timer_param), timer_param.delay, TimerProc);            }            // Eject up            else if (0x00000002 == *report)            {                SendKeyPress(&timer_param, true);                KillTimer(hWnd, reinterpret_cast<UINT_PTR>(&timer_param));            }            report++;        }    }    return DefWindowProc(hWnd, message, wParam, lParam);}