Function read_input_buffer

src/rawinput.rs:44–97

(event_queue: &mut VecDeque<RawEvent>, devices: &mut Devices)

}

fn read_input_buffer(event_queue: &mut VecDeque<RawEvent>, devices: &mut Devices) {
    unsafe {
        let mut array_alloc: [u8; 16000] = MaybeUninit::uninit().assume_init();
        let mut buffer_size: UINT = 0;

        let mut numberofelements: i32 = GetRawInputBuffer(
            ptr::null_mut(),
            &mut buffer_size,
            mem::size_of::<RAWINPUTHEADER>() as UINT,
        ) as INT;

        if numberofelements == -1 {
            panic!("GetRawInputBuffer Gave Error on First Call!");
        }
        buffer_size = 1024;
        numberofelements = GetRawInputBuffer(
            array_alloc.as_mut_ptr() as PRAWINPUT,
            &mut buffer_size,
            mem::size_of::<RAWINPUTHEADER>() as UINT,
        ) as INT;

        if numberofelements == -1 {
            panic!("GetRawInputBuffer Gave Error on Second Call!");
        }

        let mut array_ptr = array_alloc.as_mut_ptr();

        for _ in 0..numberofelements as u32 {
            let header = (*(array_ptr as *mut RAWINPUT)).header;
            let raw_input = *(array_ptr as *mut RAWINPUT);
            next_raw_input_block(&mut array_ptr);
            let pos = match devices.device_map.get(&header.hDevice) {
                Some(item) => (*item).clone(),
                None => continue,
            };
            match raw_input.header.dwType {
                RIM_TYPEMOUSE => {
                    event_queue.extend(process_mouse_data(&raw_input.data.mouse(), pos));
                }
                RIM_TYPEKEYBOARD => {
                    event_queue.extend(process_keyboard_data(&raw_input.data.keyboard(), pos));
                }
                RIM_TYPEHID => {
                    event_queue.extend(process_joystick_data(
                        &raw_input.data.hid(),
                        pos,
                        &mut devices.joysticks[pos],
                    ));
                }
                _ => (),
            }
        }
    }
}

pub fn get_event(event_queue: &mut VecDeque<RawEvent>, devices: &mut Devices) -> Option<RawEvent> {
    if event_queue.is_empty() {