static LRESULT WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
// WM_INPUT data
//
static RAWINPUT buffer[32];
static RAWINPUT ** pBuffer = new RAWINPUT *[32];
static unsigned int HEADERSIZE = sizeof(RAWINPUTHEADER);
switch (msg)
{
// input handling: use raw input
//
case WM_INPUT:
{
unsigned int dataRead = 32;
GetRawInputBuffer(buffer, &dataRead, HEADERSIZE);
if (!dataRead) {
// error
//
}
RAWINPUT * pri = buffer;
for (unsigned int i = 0; i < dataRead; ++i) {
pBuffer[i] = pri;
pri = NEXTRAWINPUTBLOCK(pri);
}
DefRawInputProc(pBuffer, dataRead, HEADERSIZE);
}
return 0;
}
return DefWindowProc(hwnd, msg, wparam, lparam);
}
uint32_t rawinput_process(pfn_handle_rawinput f, void* args){
static BYTE _buffer[RAWINPUT_PROCESS_BUFFER];
RINPUT_RAWINPUT* pbuffer = (RINPUT_RAWINPUT*)RINPUT_RAWINPUT_ALIGN((ULONG_PTR)_buffer);
uint32_t total = 0;
UINT _size;
UINT _result;
RINPUT_RAWINPUT* pinput;
while(true){
_size = RAWINPUT_PROCESS_BUFFER;
_result = GetRawInputBuffer((PRAWINPUT)pbuffer, &_size, sizeof(RAWINPUTHEADER));
if(-1 == _result){
auto _gla = GetLastError();
if(122 == _gla){
std::cerr << "rawinput_process(): _buffer_size too small -1 == _result && 122 == GetLastError()" << std::endl;
return total;
} else {
std::cerr << "rawinput_process(): -1 == _result, GetLastError():" << std::dec << _gla << std::endl;
return total;
}
} else if(0 == _result) {
return total;
}
total += _result;
pinput = pbuffer;
for(UINT i = 0; i < _result; ++i){
f(pinput, args);
pinput = RINPUT_NEXTRAWINPUTBLOCK(pinput);
}
}
return total;
}
DWORD WINAPI RawThread(HANDLE hCloseEvent)
{
HWND hDummy;
UINT cbSize;
MSG msg;
hDummy = CreateWindowEx(0, L"button", 0, 0, 0, 0, 1, 1, 0, 0, g_hInstance, 0);
RAWINPUTDEVICE Rid[2] ;
Rid[0].usUsagePage = 0x01;
Rid[0].usUsage = 0x02; // mouse
Rid[0].dwFlags = 0;
Rid[0].hwndTarget = hDummy;
Rid[1].usUsagePage = 0x01 ;
Rid[1].usUsage = 0x06 ; // keyboard
Rid[1].dwFlags = 0 ;
Rid[1].hwndTarget = hDummy ;
if( !RegisterRawInputDevices(Rid, 2, sizeof(Rid[0]) ) )
assert(false);
while(1)
{
DWORD result = MsgWaitForMultipleObjects(1, &hCloseEvent, 0, INFINITE, QS_RAWINPUT);
if(result == WAIT_OBJECT_0 + 1)
{
RAWINPUT *pri;
if(GetRawInputBuffer(0, &cbSize, sizeof(RAWINPUTHEADER)))
break;
cbSize *= 16;
if(!(pri = (RAWINPUT*) malloc(cbSize)))
break;
while(1)
{
DWORD cri = GetRawInputBuffer(pri, &cbSize, sizeof(RAWINPUTHEADER));
if(cri && cri != -1)
{
RAWINPUT *p = pri;
for(; cri; cri--, p = NEXTRAWINPUTBLOCK(p))
{
InputPacket inputPacket;
if(p->header.dwType == RIM_TYPEKEYBOARD)
{
inputPacket.type = 0;
inputPacket.keyboard.key = ( (RAWINPUT*)(& ( (BYTE*) p)[8]) )->data.keyboard.VKey;
inputPacket.keyboard.keyFlags = ( (RAWINPUT*)(& ( (BYTE*) p)[8]) )->data.keyboard.Flags;
}
else if(p->header.dwType == RIM_TYPEMOUSE)
{
inputPacket.type = 1;
inputPacket.mouse.x = ( (RAWINPUT*)(& ( (BYTE*) p)[8]) )->data.mouse.lLastX;
inputPacket.mouse.y = ( (RAWINPUT*)(& ( (BYTE*) p)[8]) )->data.mouse.lLastY;
inputPacket.mouse.buttonFlags = ( (RAWINPUT*)(& ( (BYTE*) p)[8]) )->data.mouse.usButtonFlags;
inputPacket.mouse.wheel = ( (RAWINPUT*)(& ( (BYTE*) p)[8]) )->data.mouse.usButtonData;
}
CApp::g_rawInputMsgsQUeue.Push(inputPacket);
}
}
else
break;
}
while(PeekMessage(&msg, 0, WM_INPUT, WM_INPUT, PM_REMOVE)){};
free(pri);
}
else
break;
}
DestroyWindow(hDummy);
return 0;
}
void wiRawInput::RetrieveBufferedData()
{
// Some temp global buffer, 1KB is overkill.
static uint64_t rawBuffer[1024 / 8];
// Then in some function,
UINT bytes = sizeof(rawBuffer);
// Loop through reading raw input until no events are left,
while (1) {
// Fill up buffer,
int32_t count = GetRawInputBuffer((PRAWINPUT)rawBuffer, &bytes, sizeof(RAWINPUTHEADER));
if (count <= 0) return;
// Process all the events,
const RAWINPUT* raw = (const RAWINPUT*) rawBuffer;
while (1) {
// Process raw event.
this->raw = *raw;
// Goto next raw event.
count--;
if (count <= 0) break;
raw = NEXTRAWINPUTBLOCK(raw);
}
}
////while (true){
// UINT cbSize;
// //Sleep(1000);
// GetRawInputBuffer(NULL, &cbSize, sizeof(RAWINPUTHEADER));
// cbSize *= 16; // this is a wild guess
// PRAWINPUT pRawInput = (PRAWINPUT)malloc(cbSize);
// if (pRawInput == NULL)
// {
// return;
// }
// for (;;)
// {
// UINT cbSizeT = cbSize;
// UINT nInput = GetRawInputBuffer(pRawInput, &cbSizeT, sizeof(RAWINPUTHEADER));
// if (nInput == 0)
// {
// break;
// }
// assert(nInput > 0);
// PRAWINPUT* paRawInput = (PRAWINPUT*)malloc(sizeof(PRAWINPUT) * nInput);
// if (paRawInput == NULL)
// {
// break;
// }
// PRAWINPUT pri = pRawInput;
// for (UINT i = 0; i < nInput; ++i)
// {
// paRawInput[i] = pri;
// pri = NEXTRAWINPUTBLOCK(pri);
// if (pri->header.dwType == RIM_TYPEHID)
// {
// int asd=32;
// asd = asd;
// }
// }
// // to clean the buffer
// DefRawInputProc(paRawInput, nInput, sizeof(RAWINPUTHEADER));
// free(paRawInput);
// }
// free(pRawInput);
////}
}
