441 lines
11 KiB
C
441 lines
11 KiB
C
/*************************************************************************
|
|
*
|
|
* Orca
|
|
* Copyright 2023 Martin Fouilleul and the Orca project contributors
|
|
* See LICENSE.txt for licensing information
|
|
*
|
|
**************************************************************************/
|
|
#include "input_state.h"
|
|
|
|
//---------------------------------------------------------------
|
|
// Input state updating
|
|
//---------------------------------------------------------------
|
|
|
|
static void oc_update_key_state(oc_input_state* state, oc_key_state* key, oc_key_action action)
|
|
{
|
|
u64 frameCounter = state->frameCounter;
|
|
if(key->lastUpdate != frameCounter)
|
|
{
|
|
key->transitionCount = 0;
|
|
key->repeatCount = 0;
|
|
key->sysClicked = false;
|
|
key->sysDoubleClicked = false;
|
|
key->sysTripleClicked = false;
|
|
key->lastUpdate = frameCounter;
|
|
}
|
|
|
|
switch(action)
|
|
{
|
|
case OC_KEY_PRESS:
|
|
{
|
|
if(!key->down)
|
|
{
|
|
key->transitionCount++;
|
|
}
|
|
key->down = true;
|
|
}
|
|
break;
|
|
|
|
case OC_KEY_REPEAT:
|
|
{
|
|
key->repeatCount++;
|
|
key->down = true;
|
|
}
|
|
break;
|
|
|
|
case OC_KEY_RELEASE:
|
|
{
|
|
if(key->down)
|
|
{
|
|
key->transitionCount++;
|
|
}
|
|
key->down = false;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void oc_update_key_mods(oc_input_state* state, oc_keymod_flags mods)
|
|
{
|
|
state->keyboard.mods = mods;
|
|
}
|
|
|
|
static void oc_update_clipboard_paste(oc_input_state* state, oc_arena* arena)
|
|
{
|
|
state->clipboard.lastUpdate = state->frameCounter;
|
|
state->clipboard.pastedText = oc_clipboard_get_string(arena);
|
|
}
|
|
|
|
static void oc_update_mouse_move(oc_input_state* state, f32 x, f32 y, f32 deltaX, f32 deltaY)
|
|
{
|
|
u64 frameCounter = state->frameCounter;
|
|
oc_mouse_state* mouse = &state->mouse;
|
|
if(mouse->lastUpdate != frameCounter)
|
|
{
|
|
mouse->delta = (oc_vec2){ 0, 0 };
|
|
mouse->wheel = (oc_vec2){ 0, 0 };
|
|
mouse->lastUpdate = frameCounter;
|
|
}
|
|
mouse->posValid = true;
|
|
mouse->pos = (oc_vec2){ x, y };
|
|
mouse->delta.x += deltaX;
|
|
mouse->delta.y += deltaY;
|
|
}
|
|
|
|
static void oc_update_mouse_leave(oc_input_state* state)
|
|
{
|
|
u64 frameCounter = state->frameCounter;
|
|
oc_mouse_state* mouse = &state->mouse;
|
|
if(mouse->lastUpdate != frameCounter)
|
|
{
|
|
mouse->delta = (oc_vec2){ 0, 0 };
|
|
mouse->wheel = (oc_vec2){ 0, 0 };
|
|
mouse->lastUpdate = frameCounter;
|
|
}
|
|
mouse->posValid = false;
|
|
}
|
|
|
|
static void oc_update_mouse_wheel(oc_input_state* state, f32 deltaX, f32 deltaY)
|
|
{
|
|
u64 frameCounter = state->frameCounter;
|
|
oc_mouse_state* mouse = &state->mouse;
|
|
if(mouse->lastUpdate != frameCounter)
|
|
{
|
|
mouse->delta = (oc_vec2){ 0, 0 };
|
|
mouse->wheel = (oc_vec2){ 0, 0 };
|
|
mouse->lastUpdate = frameCounter;
|
|
}
|
|
mouse->wheel.x += deltaX;
|
|
mouse->wheel.y += deltaY;
|
|
}
|
|
|
|
static void oc_update_text(oc_input_state* state, oc_utf32 codepoint)
|
|
{
|
|
u64 frameCounter = state->frameCounter;
|
|
oc_text_state* text = &state->text;
|
|
|
|
if(text->lastUpdate != frameCounter)
|
|
{
|
|
text->codePoints.len = 0;
|
|
text->lastUpdate = frameCounter;
|
|
}
|
|
|
|
text->codePoints.ptr = text->backing;
|
|
if(text->codePoints.len < OC_INPUT_TEXT_BACKING_SIZE)
|
|
{
|
|
text->codePoints.ptr[text->codePoints.len] = codepoint;
|
|
text->codePoints.len++;
|
|
}
|
|
else
|
|
{
|
|
oc_log_warning("too many input codepoints per frame, dropping input");
|
|
}
|
|
}
|
|
|
|
void oc_input_next_frame(oc_input_state* state)
|
|
{
|
|
state->frameCounter++;
|
|
}
|
|
|
|
void oc_input_process_event(oc_input_state* state, oc_arena* arena, oc_event* event)
|
|
{
|
|
switch(event->type)
|
|
{
|
|
case OC_EVENT_KEYBOARD_KEY:
|
|
{
|
|
oc_key_state* key = &state->keyboard.keys[event->key.keyCode];
|
|
oc_update_key_state(state, key, event->key.action);
|
|
oc_update_key_mods(state, event->key.mods);
|
|
}
|
|
break;
|
|
|
|
case OC_EVENT_KEYBOARD_CHAR:
|
|
oc_update_text(state, event->character.codepoint);
|
|
break;
|
|
|
|
case OC_EVENT_KEYBOARD_MODS:
|
|
oc_update_key_mods(state, event->key.mods);
|
|
break;
|
|
|
|
case OC_EVENT_CLIPBOARD_PASTE:
|
|
oc_update_clipboard_paste(state, arena);
|
|
break;
|
|
|
|
case OC_EVENT_MOUSE_MOVE:
|
|
oc_update_mouse_move(state, event->mouse.x, event->mouse.y, event->mouse.deltaX, event->mouse.deltaY);
|
|
break;
|
|
|
|
case OC_EVENT_MOUSE_LEAVE:
|
|
oc_update_mouse_leave(state);
|
|
break;
|
|
|
|
case OC_EVENT_MOUSE_WHEEL:
|
|
oc_update_mouse_wheel(state, event->mouse.deltaX, event->mouse.deltaY);
|
|
break;
|
|
|
|
case OC_EVENT_MOUSE_BUTTON:
|
|
{
|
|
oc_key_state* key = &state->mouse.buttons[event->key.button];
|
|
oc_update_key_state(state, key, event->key.action);
|
|
|
|
if(event->key.action == OC_KEY_PRESS)
|
|
{
|
|
if(event->key.clickCount >= 1)
|
|
{
|
|
key->sysClicked = true;
|
|
}
|
|
|
|
if(event->key.clickCount % 2 == 0)
|
|
{
|
|
key->sysDoubleClicked = true;
|
|
}
|
|
else if(event->key.clickCount > 1)
|
|
{
|
|
key->sysTripleClicked = true;
|
|
}
|
|
}
|
|
|
|
oc_update_key_mods(state, event->key.mods);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// Input state polling
|
|
//--------------------------------------------------------------------
|
|
|
|
oc_key_state oc_key_get_state(oc_input_state* input, oc_key_code key)
|
|
{
|
|
oc_key_state state = { 0 };
|
|
if(key <= OC_KEY_COUNT)
|
|
{
|
|
state = input->keyboard.keys[key];
|
|
}
|
|
return (state);
|
|
}
|
|
|
|
oc_key_state oc_mouse_button_get_state(oc_input_state* input, oc_mouse_button button)
|
|
{
|
|
oc_key_state state = { 0 };
|
|
if(button <= OC_MOUSE_BUTTON_COUNT)
|
|
{
|
|
state = input->mouse.buttons[button];
|
|
}
|
|
return (state);
|
|
}
|
|
|
|
int oc_key_state_press_count(oc_input_state* input, oc_key_state* key)
|
|
{
|
|
int count = 0;
|
|
if(key->lastUpdate == input->frameCounter)
|
|
{
|
|
count = key->transitionCount / 2;
|
|
if(key->down)
|
|
{
|
|
//NOTE: add one if state is down transition count is odd
|
|
count += (key->transitionCount & 0x01);
|
|
}
|
|
}
|
|
return (count);
|
|
}
|
|
|
|
int oc_key_state_release_count(oc_input_state* input, oc_key_state* key)
|
|
{
|
|
int count = 0;
|
|
if(key->lastUpdate == input->frameCounter)
|
|
{
|
|
count = key->transitionCount / 2;
|
|
if(!key->down)
|
|
{
|
|
//NOTE: add one if state is up and transition count is odd
|
|
count += (key->transitionCount & 0x01);
|
|
}
|
|
}
|
|
return (count);
|
|
}
|
|
|
|
int oc_key_state_repeat_count(oc_input_state* input, oc_key_state* key)
|
|
{
|
|
int count = 0;
|
|
if(key->lastUpdate == input->frameCounter)
|
|
{
|
|
count = key->repeatCount;
|
|
}
|
|
return (count);
|
|
}
|
|
|
|
bool oc_key_down(oc_input_state* input, oc_key_code key)
|
|
{
|
|
oc_key_state state = oc_key_get_state(input, key);
|
|
return (state.down);
|
|
}
|
|
|
|
int oc_key_pressed(oc_input_state* input, oc_key_code key)
|
|
{
|
|
oc_key_state state = oc_key_get_state(input, key);
|
|
int res = oc_key_state_press_count(input, &state);
|
|
return (res);
|
|
}
|
|
|
|
int oc_key_released(oc_input_state* input, oc_key_code key)
|
|
{
|
|
oc_key_state state = oc_key_get_state(input, key);
|
|
int res = oc_key_state_release_count(input, &state);
|
|
return (res);
|
|
}
|
|
|
|
int oc_key_repeated(oc_input_state* input, oc_key_code key)
|
|
{
|
|
oc_key_state state = oc_key_get_state(input, key);
|
|
int res = oc_key_state_repeat_count(input, &state);
|
|
return (res);
|
|
}
|
|
|
|
bool oc_key_down_scancode(oc_input_state* state, oc_scan_code scanCode)
|
|
{
|
|
oc_key_code key = oc_scancode_to_keycode(scanCode);
|
|
return (oc_key_down(state, key));
|
|
}
|
|
|
|
int oc_key_pressed_scancode(oc_input_state* state, oc_scan_code scanCode)
|
|
{
|
|
oc_key_code key = oc_scancode_to_keycode(scanCode);
|
|
return (oc_key_pressed(state, key));
|
|
}
|
|
|
|
int oc_key_released_scancode(oc_input_state* state, oc_scan_code scanCode)
|
|
{
|
|
oc_key_code key = oc_scancode_to_keycode(scanCode);
|
|
return (oc_key_released(state, key));
|
|
}
|
|
|
|
int oc_key_repeated_scancode(oc_input_state* state, oc_scan_code scanCode)
|
|
{
|
|
oc_key_code key = oc_scancode_to_keycode(scanCode);
|
|
return (oc_key_repeated(state, key));
|
|
}
|
|
|
|
bool oc_mouse_down(oc_input_state* input, oc_mouse_button button)
|
|
{
|
|
oc_key_state state = oc_mouse_button_get_state(input, button);
|
|
return (state.down);
|
|
}
|
|
|
|
int oc_mouse_pressed(oc_input_state* input, oc_mouse_button button)
|
|
{
|
|
oc_key_state state = oc_mouse_button_get_state(input, button);
|
|
int res = oc_key_state_press_count(input, &state);
|
|
return (res);
|
|
}
|
|
|
|
int oc_mouse_released(oc_input_state* input, oc_mouse_button button)
|
|
{
|
|
oc_key_state state = oc_mouse_button_get_state(input, button);
|
|
int res = oc_key_state_release_count(input, &state);
|
|
return (res);
|
|
}
|
|
|
|
bool oc_mouse_clicked(oc_input_state* input, oc_mouse_button button)
|
|
{
|
|
oc_key_state state = oc_mouse_button_get_state(input, button);
|
|
bool clicked = state.sysClicked && (state.lastUpdate == input->frameCounter);
|
|
return (clicked);
|
|
}
|
|
|
|
bool oc_mouse_double_clicked(oc_input_state* input, oc_mouse_button button)
|
|
{
|
|
oc_key_state state = oc_mouse_button_get_state(input, button);
|
|
bool doubleClicked = state.sysDoubleClicked && (state.lastUpdate == input->frameCounter);
|
|
return (doubleClicked);
|
|
}
|
|
|
|
bool oc_mouse_triple_clicked(oc_input_state* input, oc_mouse_button button)
|
|
{
|
|
oc_key_state state = oc_mouse_button_get_state(input, button);
|
|
bool tripleClicked = state.sysTripleClicked && (state.lastUpdate == input->frameCounter);
|
|
return (tripleClicked);
|
|
}
|
|
|
|
oc_keymod_flags oc_key_mods(oc_input_state* input)
|
|
{
|
|
return (input->keyboard.mods);
|
|
}
|
|
|
|
oc_vec2 oc_mouse_position(oc_input_state* input)
|
|
{
|
|
if(input->mouse.posValid)
|
|
{
|
|
return (input->mouse.pos);
|
|
}
|
|
else
|
|
{
|
|
return ((oc_vec2){ -1, -1 });
|
|
}
|
|
}
|
|
|
|
oc_vec2 oc_mouse_delta(oc_input_state* input)
|
|
{
|
|
if(input->mouse.lastUpdate == input->frameCounter)
|
|
{
|
|
return (input->mouse.delta);
|
|
}
|
|
else
|
|
{
|
|
return ((oc_vec2){ 0, 0 });
|
|
}
|
|
}
|
|
|
|
oc_vec2 oc_mouse_wheel(oc_input_state* input)
|
|
{
|
|
if(input->mouse.lastUpdate == input->frameCounter)
|
|
{
|
|
return (input->mouse.wheel);
|
|
}
|
|
else
|
|
{
|
|
return ((oc_vec2){ 0, 0 });
|
|
}
|
|
}
|
|
|
|
oc_str32 oc_input_text_utf32(oc_input_state* input, oc_arena* arena)
|
|
{
|
|
oc_str32 res = { 0 };
|
|
if(input->text.lastUpdate == input->frameCounter)
|
|
{
|
|
res = oc_str32_push_copy(arena, input->text.codePoints);
|
|
}
|
|
return (res);
|
|
}
|
|
|
|
oc_str8 oc_input_text_utf8(oc_input_state* input, oc_arena* arena)
|
|
{
|
|
oc_str8 res = { 0 };
|
|
if(input->text.lastUpdate == input->frameCounter)
|
|
{
|
|
res = oc_utf8_push_from_codepoints(arena, input->text.codePoints);
|
|
}
|
|
return (res);
|
|
}
|
|
|
|
bool oc_clipboard_pasted(oc_input_state* input)
|
|
{
|
|
return input->clipboard.lastUpdate == input->frameCounter;
|
|
}
|
|
|
|
oc_str8 oc_clipboard_pasted_text(oc_input_state* input)
|
|
{
|
|
oc_str8 res = { 0 };
|
|
if(input->clipboard.lastUpdate == input->frameCounter)
|
|
{
|
|
res = input->clipboard.pastedText;
|
|
}
|
|
return (res);
|
|
}
|