mirror of
https://github.com/korenkonder/ReDIVA.git
synced 2026-10-13 09:38:14 +03:00
466 lines
15 KiB
C++
466 lines
15 KiB
C++
/*
|
|
by korenkonder
|
|
GitHub/GitLab: korenkonder
|
|
|
|
Some input code is from samyuu's TLAC
|
|
*/
|
|
|
|
#include "input.hpp"
|
|
#include <map>
|
|
#include "../KKdLib/vec.hpp"
|
|
#include "../CRE/timer.hpp"
|
|
#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
|
|
#include <timeapi.h>
|
|
|
|
double_t input_movement_speed = 0.1;
|
|
double_t input_rotation_sensitivity = 0.5;
|
|
vec2d input_move;
|
|
vec2d input_rotate;
|
|
double_t input_roll;
|
|
bool input_reset;
|
|
bool input_reset_mouse_position;
|
|
bool input_locked;
|
|
|
|
extern bool close;
|
|
extern lock render_lock;
|
|
extern timer* render_timer;
|
|
extern HWND window_handle;
|
|
extern ImGuiContext* imgui_context;
|
|
extern lock imgui_context_lock;
|
|
|
|
namespace Input {
|
|
struct Key {
|
|
int32_t key;
|
|
int32_t scancode;
|
|
int32_t action;
|
|
int32_t mods;
|
|
};
|
|
|
|
struct MouseButton {
|
|
int32_t button;
|
|
int32_t action;
|
|
int32_t mods;
|
|
};
|
|
|
|
std::vector<Key> keys;
|
|
std::vector<MouseButton> mouse_buttons;
|
|
POINT pos;
|
|
|
|
std::vector<Key> keys_prev;
|
|
std::vector<MouseButton> mouse_buttons_prev;
|
|
POINT pos_prev;
|
|
|
|
static bool is_key_mod(int32_t key);
|
|
static bool is_key_numpad(int32_t key);
|
|
static void KeyboardCallback(GLFWwindow* window,
|
|
int32_t key, int32_t scancode, int32_t action, int32_t mods);
|
|
static void MouseButtonCallback(GLFWwindow* window,
|
|
int32_t button, int32_t action, int32_t mods);
|
|
static Key* vector_Key_find(std::vector<Key>& keys, int32_t key);
|
|
static MouseButton* vector_MouseButton_find(
|
|
std::vector<MouseButton>& mouse_buttons, int32_t button);
|
|
|
|
bool IsKeyDown(int32_t key, int32_t mods) {
|
|
Key* k = vector_Key_find(keys, key);
|
|
if (k && (mods == -1 || k->mods == mods))
|
|
return k->action != GLFW_RELEASE;
|
|
return false;
|
|
}
|
|
|
|
bool IsKeyUp(int32_t key, int32_t mods) {
|
|
Key* k = vector_Key_find(keys, key);
|
|
if (k && (mods == -1 || k->mods == mods))
|
|
return k->action == GLFW_RELEASE;
|
|
return false;
|
|
}
|
|
|
|
bool IsKeyTapped(int32_t key, int32_t mods) {
|
|
Key* k = vector_Key_find(keys, key);
|
|
Key* k_prev = vector_Key_find(keys_prev, key);
|
|
if (k)
|
|
if (k_prev) {
|
|
if (mods == -1 || (k->mods == mods && k_prev->mods == mods))
|
|
return k->action != GLFW_RELEASE && k_prev->action == GLFW_RELEASE;
|
|
}
|
|
else {
|
|
if (mods == -1 || k->mods == mods)
|
|
return k->action != GLFW_RELEASE;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool IsKeyReleased(int32_t key, int32_t mods) {
|
|
Key* k = vector_Key_find(keys, key);
|
|
Key* k_prev = vector_Key_find(keys_prev, key);
|
|
if (k)
|
|
if (k_prev) {
|
|
if ((k->mods == mods && k_prev->mods == mods))
|
|
return k->action == GLFW_RELEASE && k_prev->action != GLFW_RELEASE;
|
|
}
|
|
else {
|
|
if (mods == -1 || k->mods == mods)
|
|
return k->action == GLFW_RELEASE;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool IsMouseButtonDown(int32_t button, int32_t mods) {
|
|
MouseButton* mb = vector_MouseButton_find(mouse_buttons, button);
|
|
if (mb && (mods == -1 || mb->mods == mods))
|
|
return mb->action != GLFW_RELEASE;
|
|
return false;
|
|
}
|
|
|
|
bool IsMouseButtonUp(int32_t button, int32_t mods) {
|
|
MouseButton* mb = vector_MouseButton_find(mouse_buttons, button);
|
|
if (mb && (mods == -1 || mb->mods == mods))
|
|
return mb->action == GLFW_RELEASE;
|
|
return false;
|
|
}
|
|
|
|
bool IsMouseButtonTapped(int32_t button, int32_t mods) {
|
|
MouseButton* mb = vector_MouseButton_find(mouse_buttons, button);
|
|
MouseButton* mb_prev = vector_MouseButton_find(mouse_buttons_prev, button);
|
|
if (mb)
|
|
if (mb_prev) {
|
|
if ((mods == -1 || mb->mods == mods && mb_prev->mods == mods))
|
|
return mb->action != GLFW_RELEASE && mb_prev->action == GLFW_RELEASE;
|
|
}
|
|
else {
|
|
if (mods == -1 || mb->mods == mods)
|
|
return mb->action != GLFW_RELEASE;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool IsMouseButtonReleased(int32_t button, int32_t mods) {
|
|
MouseButton* mb = vector_MouseButton_find(mouse_buttons, button);
|
|
MouseButton* mb_prev = vector_MouseButton_find(mouse_buttons_prev, button);
|
|
if (mb)
|
|
if (mb_prev) {
|
|
if ((mods == -1 || mb->mods == mods && mb_prev->mods == mods))
|
|
return mb->action == GLFW_RELEASE && mb_prev->action != GLFW_RELEASE;
|
|
}
|
|
else {
|
|
if (mods == -1 || mb->mods == mods)
|
|
return mb->action == GLFW_RELEASE;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool WasKeyDown(int32_t key, int32_t mods) {
|
|
Key* k_prev = vector_Key_find(keys_prev, key);
|
|
if (k_prev && (mods == -1 || k_prev->mods == mods))
|
|
return k_prev->action != GLFW_RELEASE;
|
|
return false;
|
|
}
|
|
|
|
bool WasKeyUp(int32_t key, int32_t mods) {
|
|
Key* k_prev = vector_Key_find(keys_prev, key);
|
|
if (k_prev && (mods == -1 || k_prev->mods == mods))
|
|
return k_prev->action == GLFW_RELEASE;
|
|
return true;
|
|
}
|
|
|
|
bool WasMouseButtonDown(int32_t button, int32_t mods) {
|
|
MouseButton* mb_prev = vector_MouseButton_find(mouse_buttons_prev, button);
|
|
if (mb_prev && (mods == -1 || mb_prev->mods == mods))
|
|
return mb_prev->action != GLFW_RELEASE;
|
|
return true;
|
|
}
|
|
|
|
bool WasMouseButtonUp(int32_t button, int32_t mods) {
|
|
MouseButton* mb_prev = vector_MouseButton_find(mouse_buttons_prev, button);
|
|
if (mb_prev && (mods == -1 || mb_prev->mods == mods))
|
|
return mb_prev->action == GLFW_RELEASE;
|
|
return true;
|
|
}
|
|
|
|
void EndFrame() {
|
|
keys_prev = keys;
|
|
mouse_buttons_prev = mouse_buttons;
|
|
}
|
|
|
|
void NewFrame() {
|
|
pos_prev = pos;
|
|
|
|
if (window_handle) {
|
|
GetCursorPos(&pos);
|
|
ScreenToClient(window_handle, &pos);
|
|
}
|
|
|
|
input_move.x = 0.0;
|
|
input_move.y = 0.0;
|
|
input_rotate.x = 0.0;
|
|
input_rotate.y = 0.0;
|
|
input_roll = 0.0;
|
|
|
|
if (!window_handle || window_handle != GetForegroundWindow())
|
|
return;
|
|
|
|
double_t freq = render_timer->get_freq();
|
|
double_t freq_hist = render_timer->get_freq_hist();
|
|
double_t frame_speed = freq / freq_hist;
|
|
|
|
input_locked = false;
|
|
classes_process_input(classes, classes_count);
|
|
|
|
if (input_locked) {
|
|
input_reset_mouse_position = true;
|
|
return;
|
|
}
|
|
|
|
double_t speed = input_movement_speed;
|
|
double_t speed_fast = input_movement_speed * 10.0;
|
|
double_t speed_slow = input_movement_speed / 10.0;
|
|
speed *= frame_speed;
|
|
speed_fast *= frame_speed;
|
|
speed_slow *= frame_speed;
|
|
|
|
if (IsKeyDown(GLFW_KEY_W) || IsKeyDown(GLFW_KEY_W, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
|
|
input_move.x += speed;
|
|
else if (IsKeyDown(GLFW_KEY_W, GLFW_MOD_SHIFT))
|
|
input_move.x += speed_fast;
|
|
else if (IsKeyDown(GLFW_KEY_W, GLFW_MOD_CONTROL))
|
|
input_move.x += speed_slow;
|
|
else if (IsKeyDown(GLFW_KEY_W, -1))
|
|
input_move.x += speed;
|
|
|
|
if (IsKeyDown(GLFW_KEY_S) || IsKeyDown(GLFW_KEY_S, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
|
|
input_move.x -= speed;
|
|
else if (IsKeyDown(GLFW_KEY_S, GLFW_MOD_SHIFT))
|
|
input_move.x -= speed_fast;
|
|
else if (IsKeyDown(GLFW_KEY_S, GLFW_MOD_CONTROL))
|
|
input_move.x -= speed_slow;
|
|
else if (IsKeyDown(GLFW_KEY_S, -1))
|
|
input_move.x -= speed;
|
|
|
|
if (IsKeyDown(GLFW_KEY_A) || IsKeyDown(GLFW_KEY_A, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
|
|
input_move.y -= speed;
|
|
else if (IsKeyDown(GLFW_KEY_A, GLFW_MOD_SHIFT))
|
|
input_move.y -= speed_fast;
|
|
else if (IsKeyDown(GLFW_KEY_A, GLFW_MOD_CONTROL))
|
|
input_move.y -= speed_slow;
|
|
else if (IsKeyDown(GLFW_KEY_A, -1))
|
|
input_move.y -= speed;
|
|
|
|
if (IsKeyDown(GLFW_KEY_D) || IsKeyDown(GLFW_KEY_D, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
|
|
input_move.y += speed;
|
|
else if (IsKeyDown(GLFW_KEY_D, GLFW_MOD_SHIFT))
|
|
input_move.y += speed_fast;
|
|
else if (IsKeyDown(GLFW_KEY_D, GLFW_MOD_CONTROL))
|
|
input_move.y += speed_slow;
|
|
else if (IsKeyDown(GLFW_KEY_D, -1))
|
|
input_move.y += speed;
|
|
|
|
speed = input_movement_speed;
|
|
speed_fast = input_movement_speed * 2.0;
|
|
speed_slow = input_movement_speed / 2.0;
|
|
speed *= frame_speed;
|
|
speed_fast *= frame_speed;
|
|
speed_slow *= frame_speed;
|
|
speed *= freq / freq_hist;
|
|
speed_fast *= freq / freq_hist;
|
|
speed_slow *= freq / freq_hist;
|
|
speed *= 10.0;
|
|
speed_fast *= 10.0;
|
|
speed_slow *= 10.0;
|
|
|
|
if (IsKeyDown(GLFW_KEY_UP) || IsKeyDown(GLFW_KEY_UP, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
|
|
input_rotate.y += speed;
|
|
else if (IsKeyDown(GLFW_KEY_UP, GLFW_MOD_SHIFT))
|
|
input_rotate.y += speed_fast;
|
|
else if (IsKeyDown(GLFW_KEY_UP, GLFW_MOD_CONTROL))
|
|
input_rotate.y += speed_slow;
|
|
else if (IsKeyDown(GLFW_KEY_UP, -1))
|
|
input_rotate.y += speed;
|
|
|
|
if (IsKeyDown(GLFW_KEY_DOWN) || IsKeyDown(GLFW_KEY_DOWN, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
|
|
input_rotate.y -= speed;
|
|
else if (IsKeyDown(GLFW_KEY_DOWN, GLFW_MOD_SHIFT))
|
|
input_rotate.y -= speed_fast;
|
|
else if (IsKeyDown(GLFW_KEY_DOWN, GLFW_MOD_CONTROL))
|
|
input_rotate.y -= speed_slow;
|
|
else if (IsKeyDown(GLFW_KEY_DOWN, -1))
|
|
input_rotate.y -= speed;
|
|
|
|
if (IsKeyDown(GLFW_KEY_LEFT) || IsKeyDown(GLFW_KEY_LEFT, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
|
|
input_rotate.x -= speed;
|
|
else if (IsKeyDown(GLFW_KEY_LEFT, GLFW_MOD_SHIFT))
|
|
input_rotate.x -= speed_fast;
|
|
else if (IsKeyDown(GLFW_KEY_LEFT, GLFW_MOD_CONTROL))
|
|
input_rotate.x -= speed_slow;
|
|
else if (IsKeyDown(GLFW_KEY_LEFT, -1))
|
|
input_rotate.x -= speed;
|
|
|
|
if (IsKeyDown(GLFW_KEY_RIGHT) || IsKeyDown(GLFW_KEY_RIGHT, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
|
|
input_rotate.x += speed;
|
|
else if (IsKeyDown(GLFW_KEY_RIGHT, GLFW_MOD_SHIFT))
|
|
input_rotate.x += speed_fast;
|
|
else if (IsKeyDown(GLFW_KEY_RIGHT, GLFW_MOD_CONTROL))
|
|
input_rotate.x += speed_slow;
|
|
else if (IsKeyDown(GLFW_KEY_RIGHT, -1))
|
|
input_rotate.x += speed;
|
|
|
|
if (IsKeyDown(GLFW_KEY_Q) || IsKeyDown(GLFW_KEY_Q, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
|
|
input_roll += speed;
|
|
else if (IsKeyDown(GLFW_KEY_Q, GLFW_MOD_SHIFT))
|
|
input_roll += speed_fast;
|
|
else if (IsKeyDown(GLFW_KEY_Q, GLFW_MOD_CONTROL))
|
|
input_roll += speed_slow;
|
|
else if (IsKeyDown(GLFW_KEY_Q, -1))
|
|
input_roll += speed;
|
|
|
|
if (IsKeyDown(GLFW_KEY_E) || IsKeyDown(GLFW_KEY_E, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
|
|
input_roll -= speed;
|
|
else if (IsKeyDown(GLFW_KEY_E, GLFW_MOD_SHIFT))
|
|
input_roll -= speed_fast;
|
|
else if (IsKeyDown(GLFW_KEY_E, GLFW_MOD_CONTROL))
|
|
input_roll -= speed_slow;
|
|
else if (IsKeyDown(GLFW_KEY_E, -1))
|
|
input_roll -= speed;
|
|
|
|
if (IsKeyDown(GLFW_KEY_R))
|
|
input_reset = true;
|
|
|
|
if (IsMouseButtonDown(GLFW_MOUSE_BUTTON_MIDDLE, -1)) {
|
|
if (!input_reset_mouse_position) {
|
|
input_rotate.y += ((double_t)pos_prev.y - (double_t)pos.y) * input_rotation_sensitivity;
|
|
input_rotate.x += ((double_t)pos.x - (double_t)pos_prev.x) * input_rotation_sensitivity;
|
|
}
|
|
input_reset_mouse_position = false;
|
|
}
|
|
else
|
|
input_reset_mouse_position = true;
|
|
}
|
|
|
|
void SetInputs(GLFWwindow* window) {
|
|
glfwSetKeyCallback(window, (GLFWkeyfun)KeyboardCallback);
|
|
glfwSetMouseButtonCallback(window, (GLFWmousebuttonfun)MouseButtonCallback);
|
|
}
|
|
|
|
static bool is_key_mod(int32_t key) {
|
|
switch (key) {
|
|
case GLFW_KEY_LEFT_SHIFT:
|
|
case GLFW_KEY_LEFT_CONTROL:
|
|
case GLFW_KEY_LEFT_ALT:
|
|
case GLFW_KEY_LEFT_SUPER:
|
|
case GLFW_KEY_RIGHT_SHIFT:
|
|
case GLFW_KEY_RIGHT_CONTROL:
|
|
case GLFW_KEY_RIGHT_ALT:
|
|
case GLFW_KEY_RIGHT_SUPER:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static bool is_key_numpad(int32_t key) {
|
|
switch (key) {
|
|
case GLFW_KEY_KP_0:
|
|
case GLFW_KEY_KP_1:
|
|
case GLFW_KEY_KP_2:
|
|
case GLFW_KEY_KP_3:
|
|
case GLFW_KEY_KP_4:
|
|
case GLFW_KEY_KP_5:
|
|
case GLFW_KEY_KP_6:
|
|
case GLFW_KEY_KP_7:
|
|
case GLFW_KEY_KP_8:
|
|
case GLFW_KEY_KP_9:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static void KeyboardCallback(GLFWwindow* window,
|
|
int32_t key, int32_t scancode, int32_t action, int32_t mods) {
|
|
if (mods & GLFW_MOD_CAPS_LOCK)
|
|
mods &= ~GLFW_MOD_CAPS_LOCK;
|
|
|
|
if (mods & GLFW_MOD_NUM_LOCK)
|
|
mods &= ~GLFW_MOD_NUM_LOCK;
|
|
|
|
bool is_mod = false;
|
|
switch (key) {
|
|
case GLFW_KEY_LEFT_SHIFT:
|
|
case GLFW_KEY_RIGHT_SHIFT:
|
|
mods = GLFW_MOD_SHIFT;
|
|
is_mod = true;
|
|
break;
|
|
case GLFW_KEY_LEFT_CONTROL:
|
|
case GLFW_KEY_RIGHT_CONTROL:
|
|
mods = GLFW_MOD_CONTROL;
|
|
is_mod = true;
|
|
break;
|
|
case GLFW_KEY_LEFT_ALT:
|
|
case GLFW_KEY_RIGHT_ALT:
|
|
mods = GLFW_MOD_ALT;
|
|
is_mod = true;
|
|
break;
|
|
case GLFW_KEY_LEFT_SUPER:
|
|
case GLFW_KEY_RIGHT_SUPER:
|
|
mods = GLFW_MOD_SUPER;
|
|
is_mod = true;
|
|
break;
|
|
case GLFW_MOD_CAPS_LOCK:
|
|
mods = 0;
|
|
break;
|
|
case GLFW_KEY_NUM_LOCK:
|
|
mods = 0;
|
|
break;
|
|
}
|
|
|
|
if (is_mod) {
|
|
if (action != GLFW_RELEASE) {
|
|
for (Key& i : keys)
|
|
if (!is_key_mod(i.key))
|
|
i.mods |= mods;
|
|
|
|
for (MouseButton& i : mouse_buttons)
|
|
i.mods |= mods;
|
|
}
|
|
else {
|
|
mods = ~mods;
|
|
for (Key& i : keys)
|
|
if (!is_key_mod(i.key))
|
|
i.mods &= mods;
|
|
|
|
for (MouseButton& i : mouse_buttons)
|
|
i.mods &= mods;
|
|
}
|
|
mods = 0;
|
|
}
|
|
|
|
Key* k = vector_Key_find(keys, key);
|
|
if (k)
|
|
*k = { key, scancode, action, mods };
|
|
else
|
|
keys.push_back({ key, scancode, action, mods });
|
|
}
|
|
|
|
static void MouseButtonCallback(GLFWwindow* window,
|
|
int32_t button, int32_t action, int32_t mods) {
|
|
MouseButton* mb = vector_MouseButton_find(mouse_buttons, button);
|
|
if (mb)
|
|
*mb = { button, action, mods };
|
|
else
|
|
mouse_buttons.push_back({ button, action, mods });
|
|
}
|
|
|
|
static Key* vector_Key_find(std::vector<Key>& keys, int32_t key) {
|
|
for (Key& i : keys)
|
|
if (i.key == key)
|
|
return &i;
|
|
return 0;
|
|
}
|
|
|
|
static MouseButton* vector_MouseButton_find(
|
|
std::vector<MouseButton>& mouse_buttons, int32_t button) {
|
|
for (MouseButton& i : mouse_buttons)
|
|
if (i.button == button)
|
|
return &i;
|
|
return 0;
|
|
}
|
|
};
|