Max/korenkonder_ReDIVA
1
0
Fork 0
mirror of https://github.com/korenkonder/ReDIVA.git synced 2026-10-13 01:28:10 +03:00
Code Issues Packages Projects Releases Wiki Activity

Reworked Input system

Browse Source 
Yes, now Input is based on implementation based on GLUT that I bolted on
over GLFW. At least it's accurate to the game now.
This commit is contained in:
korenkonder
2026-02-23 09:57:22 +03:00
parent 7ce725d420
commit b1b11cc2c3
12 changed files with 754 additions and 677 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ReDIVA/app.cpp
+25 -24
View File
@@ -443,7 +443,7 @@ int32_t app_main(const app_init_struct& ais) {
glfwSetWindowPos(window, 8, 31);
#endif
Input::SetInputs(window);
Input::SetCallbacks(window);
RECT window_rect;
GetClientRect(window_handle, &window_rect);
@@ -741,8 +741,6 @@ static void app_main_loop(render_context* rctx) {
close |= !!glfwWindowShouldClose(window);
Input::EndFrame();
app_swap_buffers();
render_timer->end_of_cycle();
}
@@ -1095,71 +1093,72 @@ static void render_context_ctrl(render_context* rctx) {
}
}
if (Input::IsKeyTapped(GLFW_KEY_F4))
const InputState* input_state = input_state_get(0);
if (input_state->CheckTapped(INPUT_BUTTON_F4))
game_state_set_game_state_next(GAME_STATE_ADVERTISE);
#if PV_DEBUG
else if (Input::IsKeyTapped(GLFW_KEY_F5, GLFW_MOD_CONTROL)) {
else if (input_state->CheckTapped(INPUT_BUTTON_F5) && input_state->CheckDown(INPUT_BUTTON_CONTROL)) {
pv_x = false;
game_state_set_game_state_next(GAME_STATE_GAME);
}
#if BAKE_X_PACK
else if (Input::IsKeyTapped(GLFW_KEY_F5, GLFW_MOD_SHIFT)) {
else if (input_state->CheckTapped(INPUT_BUTTON_F5) && input_state->CheckDown(INPUT_BUTTON_SHIFT)) {
pv_x = true;
pv_x_bake = true;
game_state_set_game_state_next(GAME_STATE_GAME);
}
else if (Input::IsKeyTapped(GLFW_KEY_F5)) {
else if (input_state->CheckTapped(INPUT_BUTTON_F5)) {
pv_x = true;
pv_x_bake = false;
game_state_set_game_state_next(GAME_STATE_GAME);
}
#else
else if (Input::IsKeyTapped(GLFW_KEY_F5)) {
else if (input_state->CheckTapped(INPUT_BUTTON_F5)) {
pv_x = true;
game_state_set_game_state_next(GAME_STATE_GAME);
}
#endif
#else
#if BAKE_X_PACK
else if (Input::IsKeyTapped(GLFW_KEY_F5, GLFW_MOD_SHIFT)) {
else if (input_state->CheckTapped(INPUT_BUTTON_F5) && input_state->CheckDown(INPUT_BUTTON_SHIFT)) {
pv_x_bake = true;
game_state_set_game_state_next(GAME_STATE_GAME);
}
else if (Input::IsKeyTapped(GLFW_KEY_F5)) {
else if (input_state->CheckTapped(INPUT_BUTTON_F5)) {
pv_x_bake = false;
game_state_set_game_state_next(GAME_STATE_GAME);
}
#else
else if (Input::IsKeyTapped(GLFW_KEY_F5))
else if (input_state->CheckTapped(INPUT_BUTTON_F5))
game_state_set_game_state_next(GAME_STATE_GAME);
#endif
#endif
else if (Input::IsKeyTapped(GLFW_KEY_F6))
else if (input_state->CheckTapped(INPUT_BUTTON_F6))
game_state_set_game_state_next(GAME_STATE_DATA_TEST);
else if (Input::IsKeyTapped(GLFW_KEY_F7))
else if (input_state->CheckTapped(INPUT_BUTTON_F7))
game_state_set_game_state_next(GAME_STATE_TEST_MODE);
else if (Input::IsKeyTapped(GLFW_KEY_F8))
else if (input_state->CheckTapped(INPUT_BUTTON_F8))
game_state_set_game_state_next(GAME_STATE_APP_ERROR);
else if (Input::IsKeyTapped(GLFW_KEY_F9)) // Added
else if (input_state->CheckTapped(INPUT_BUTTON_F9)) // Added
game_state_set_game_state_next(GAME_STATE_DATA_EDIT); // Added
#if DISPLAY_IBL
else if (Input::IsKeyTapped(GLFW_KEY_L))
else if (input_state->CheckTapped(INPUT_BUTTON_L))
display_ibl ^= true;
else if (Input::IsKeyTapped(GLFW_KEY_1))
else if (input_state->CheckTapped(INPUT_BUTTON_1))
ibl_index = 0;
else if (Input::IsKeyTapped(GLFW_KEY_2))
else if (input_state->CheckTapped(INPUT_BUTTON_2))
ibl_index = 1;
else if (Input::IsKeyTapped(GLFW_KEY_3))
else if (input_state->CheckTapped(INPUT_BUTTON_3))
ibl_index = 2;
else if (Input::IsKeyTapped(GLFW_KEY_4))
else if (input_state->CheckTapped(INPUT_BUTTON_4))
ibl_index = 3;
else if (Input::IsKeyTapped(GLFW_KEY_5))
else if (input_state->CheckTapped(INPUT_BUTTON_5))
ibl_index = 4;
else if (Input::IsKeyTapped(GLFW_KEY_6))
else if (input_state->CheckTapped(INPUT_BUTTON_6))
ibl_index = 5;
else if (Input::IsKeyTapped(GLFW_KEY_7))
else if (input_state->CheckTapped(INPUT_BUTTON_7))
ibl_scale = max_def(ibl_scale - 1, 1);
else if (Input::IsKeyTapped(GLFW_KEY_8))
else if (input_state->CheckTapped(INPUT_BUTTON_8))
ibl_scale = min_def(ibl_scale + 1, 64);
#endif
@@ -1167,6 +1166,7 @@ static void render_context_ctrl(render_context* rctx) {
rctx_ptr = rctx;
input_state_am_ctrl();
input_state_pc_ctrl();
input_state_ctrl();
if (!get_pause() || !game_state_get_pause())
game_state_ctrl();
@@ -1176,6 +1176,7 @@ static void render_context_ctrl(render_context* rctx) {
for (int32_t i = 1; i < fast_loader_speed; i++) {
rctx_ptr = rctx;
input_state_am_ctrl();
input_state_pc_ctrl();
input_state_ctrl();
if (!get_pause() || !game_state_get_pause())
game_state_ctrl();
src/ReDIVA/classes/data_view/auth_3d.cpp
-1
View File
@@ -7,7 +7,6 @@
#include "../../../KKdLib/database/item_table.hpp"
#include "../../../CRE/auth_3d.hpp"
#include "../../imgui_helper.hpp"
#include "../../input.hpp"
static const char* auth_3d_fog_name[] = {
"Depth",
src/ReDIVA/data_edit/glitter_editor.cpp
+18 -13
View File
@@ -22,7 +22,7 @@
#include "../../CRE/static_var.hpp"
#include "../data_test/stage_test.hpp"
#include "../imgui_helper.hpp"
#include "../input.hpp"
#include "../input_state.hpp"
#include <windows.h>
#include <commdlg.h>
#include <shobjidl.h>
@@ -1104,23 +1104,24 @@ void GlitterEditor::disp() {
}
void GlitterEditor::window() {
if (Input::IsKeyTapped(GLFW_KEY_O, GLFW_MOD_CONTROL))
const InputState* input_state = input_state_get(0);
if (input_state->CheckTapped(INPUT_BUTTON_O) && input_state->CheckDown(INPUT_BUTTON_CONTROL))
glitter_editor_open_window(this);
else if (Input::IsKeyTapped(GLFW_KEY_F4, GLFW_MOD_CONTROL))
else if (input_state->CheckTapped(INPUT_BUTTON_F4) && input_state->CheckDown(INPUT_BUTTON_CONTROL))
close = true;
else if (Input::IsKeyTapped(GLFW_KEY_F3, GLFW_MOD_CONTROL))
else if (input_state->CheckTapped(INPUT_BUTTON_F4) && input_state->CheckDown(INPUT_BUTTON_CONTROL))
close_editor = true;
else if (Input::IsKeyTapped(GLFW_KEY_Q, GLFW_MOD_CONTROL))
else if (input_state->CheckTapped(INPUT_BUTTON_Q) && input_state->CheckDown(INPUT_BUTTON_CONTROL))
close = true;
else if (Input::IsKeyTapped(GLFW_KEY_P))
else if (input_state->CheckTapped(INPUT_BUTTON_P))
test ^= true;
else if (Input::IsKeyTapped(GLFW_KEY_T))
else if (input_state->CheckTapped(INPUT_BUTTON_T))
input_play = true;
else if (Input::IsKeyTapped(GLFW_KEY_Y))
else if (input_state->CheckTapped(INPUT_BUTTON_Y))
input_reload = true;
else if (Input::IsKeyTapped(GLFW_KEY_F))
else if (input_state->CheckTapped(INPUT_BUTTON_F))
input_pause = true;
else if (Input::IsKeyTapped(GLFW_KEY_G))
else if (input_state->CheckTapped(INPUT_BUTTON_G))
input_reset = true;
if (test)
@@ -1130,9 +1131,12 @@ void GlitterEditor::window() {
glitter_editor_popups(this);
if (input_locked) {
if (Input::IsKeyTapped(GLFW_KEY_S, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
if (input_state->CheckTapped(INPUT_BUTTON_S)
&& input_state->CheckDown(INPUT_BUTTON_CONTROL)
&& input_state->CheckDown(INPUT_BUTTON_SHIFT))
glitter_editor_save_as_window(this);
else if (Input::IsKeyTapped(GLFW_KEY_S, GLFW_MOD_CONTROL))
else if (input_state->CheckTapped(INPUT_BUTTON_S)
&& input_state->CheckDown(INPUT_BUTTON_CONTROL))
glitter_editor_save_window(this);
}
}
@@ -5546,7 +5550,8 @@ static void glitter_editor_curve_editor_selector_list_box_multi_selectable(Glitt
if (!ImGui::Selectable(buf, crv_edt->type == type))
return;
if (Input::IsKeyDown(GLFW_KEY_LEFT_CONTROL) || Input::IsKeyDown(GLFW_KEY_RIGHT_CONTROL))
const InputState* input_state = input_state_get(0);
if (input_state->CheckDown(INPUT_BUTTON_CONTROL))
glt_edt->curve_editor.SetFlag((Glitter::CurveTypeFlags)(1 << type));
else if (crv_edt->type != type) {
glt_edt->curve_editor.ResetState(type);
src/ReDIVA/data_edit/rob_chara_adjust.cpp
+5 -2
View File
@@ -12,7 +12,7 @@
#include "../data_test/motion_test.hpp"
#include "../dw.hpp"
#include "../imgui_helper.hpp"
#include "../input.hpp"
#include "../input_state.hpp"
static const char* chara_name[] = {
"1P",
@@ -128,7 +128,10 @@ bool RobCharaAdjust::dest() {
}
void RobCharaAdjust::window() {
if (Input::IsKeyTapped(GLFW_KEY_A, GLFW_MOD_CONTROL | GLFW_MOD_SHIFT))
const InputState* input_state = input_state_get(0);
if (input_state->CheckTapped(INPUT_BUTTON_A)
&& input_state->CheckDown(INPUT_BUTTON_CONTROL)
&& input_state->CheckDown(INPUT_BUTTON_SHIFT))
visible ^= true;
if (!visible)
src/ReDIVA/dw.cpp
+4
View File
@@ -3274,6 +3274,10 @@ void dw_gui_detail::Input::Ctrl() {
mouse_pos.y = (float_t)mouse_pos_y;
mouse_delta = mouse_pos - old_mouse_pos;
extern uint8_t disable_dw_input_update;
if (disable_dw_input_update)
return;
if (mouse_delta != 0.0f)
enum_or(mouse_input, dw::MOUSE_INPUT_MOVE);
src/ReDIVA/input.cpp
+160 -303
View File
@@ -8,11 +8,8 @@
#include "input.hpp"
#include "../KKdLib/timer.hpp"
#include "../KKdLib/vec.hpp"
#include <map>
#include <vector>
#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
#include <imgui/imgui.h>
#include <timeapi.h>
#include "input_state.hpp"
#include <GLFW/glfw3.h>
double_t input_movement_speed = 0.1;
double_t input_rotation_sensitivity = 0.5;
@@ -26,41 +23,34 @@ bool input_reset;
bool input_reset_mouse_position;
bool input_locked;
uint8_t disable_dw_input_update = false;
bool disable_cursor = false;
extern bool close;
extern timer* render_timer;
extern HWND window_handle;
extern ImGuiContext* imgui_context;
extern uint8_t disable_input_state_update;
extern bool disable_cursor;
extern void glut_get_modifiers();
extern void glut_reset_modifiers();
extern void glut_keydown_cb(uint8_t key, int32_t x, int32_t y);
extern void glut_keyup_cb(uint8_t key, int32_t x, int32_t y);
extern void glut_skeydown_cb(int32_t key, int32_t x, int32_t y);
extern void glut_skeyup_cb(int32_t key, int32_t x, int32_t y);
extern void glut_mouse_cb(int32_t bn, int32_t state, int32_t x, int32_t y);
extern void glut_motion_cb(int32_t x, int32_t y);
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;
double_t scroll;
std::vector<Key> keys_prev;
std::vector<MouseButton> mouse_buttons_prev;
POINT pos_prev;
double_t scroll_prev;
static vec2i pos;
static bool is_key_mod(int32_t key);
static bool is_key_numpad(int32_t key);
inline static void process_button(const InputState* input_state, double_t& value, InputButton button,
const double_t speed, const double_t speed_fast, const double_t speed_slow);
static void CursorPosCallback(GLFWwindow* window,
double_t xpos, double_t ypos);
static void KeyboardCallback(GLFWwindow* window,
int32_t key, int32_t scancode, int32_t action, int32_t mods);
static void MouseButtonCallback(GLFWwindow* window,
@@ -68,157 +58,25 @@ namespace Input {
static void ScrollCallback(GLFWwindow* window,
double_t x_offset, double_t y_offset);
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.assign(keys.begin(), keys.end());
mouse_buttons_prev.assign(mouse_buttons.begin(), mouse_buttons.end());
pos_prev = pos;
scroll_prev = scroll;
scroll = 0.0;
}
void NewFrame() {
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 (IsKeyTapped(GLFW_KEY_F3))
disable_input_state_update ^= 0x01;
else if (IsKeyTapped(GLFW_KEY_F3, GLFW_MOD_CONTROL))
const InputState* input_state = input_state_get(0);
if (input_state->CheckTapped(INPUT_BUTTON_F3))
disable_dw_input_update ^= 0x01;
else if (input_state->CheckTapped(INPUT_BUTTON_F3) && input_state->CheckDown(INPUT_BUTTON_CONTROL))
disable_cursor ^= true;
if (input_locked)
disable_input_state_update |= 0x02;
disable_dw_input_update |= 0x02;
else
disable_input_state_update &= ~0x02;
disable_dw_input_update &= ~0x02;
if (!window_handle || window_handle != GetForegroundWindow() || !disable_input_state_update)
if (!window_handle || window_handle != GetForegroundWindow() || !disable_dw_input_update)
return;
double_t freq = render_timer->get_freq();
@@ -238,41 +96,10 @@ namespace Input {
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;
process_button(input_state, input_move_x, INPUT_BUTTON_W, speed, speed_fast, speed_slow);
process_button(input_state, input_move_x, INPUT_BUTTON_S, -speed, -speed_fast, -speed_slow);
process_button(input_state, input_move_y, INPUT_BUTTON_A, -speed, -speed_fast, -speed_slow);
process_button(input_state, input_move_y, INPUT_BUTTON_D, speed, speed_fast, speed_slow);
speed = input_movement_speed;
speed_fast = input_movement_speed * 2.0;
@@ -284,67 +111,21 @@ namespace Input {
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;
process_button(input_state, input_rotate_y, INPUT_BUTTON_UP , speed, speed_fast, speed_slow);
process_button(input_state, input_rotate_y, INPUT_BUTTON_DOWN , -speed, -speed_fast, -speed_slow);
process_button(input_state, input_rotate_x, INPUT_BUTTON_LEFT , -speed, -speed_fast, -speed_slow);
process_button(input_state, input_rotate_x, INPUT_BUTTON_RIGHT, speed, speed_fast, speed_slow);
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;
process_button(input_state, input_roll, INPUT_BUTTON_Q, speed, speed_fast, speed_slow);
process_button(input_state, input_roll, INPUT_BUTTON_E, -speed, -speed_fast, -speed_slow);
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))
if (input_state->CheckDown(INPUT_BUTTON_R))
input_reset = true;
if (IsMouseButtonDown(GLFW_MOUSE_BUTTON_MIDDLE, -1)) {
if (input_state->CheckDown(INPUT_BUTTON_MOUSE_BUTTON_MIDDLE)) {
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_rotate_y += -input_state->sub_14018CCC0(11) * input_rotation_sensitivity;
input_rotate_x += input_state->sub_14018CCC0(10) * input_rotation_sensitivity;
}
input_reset_mouse_position = false;
}
@@ -353,7 +134,8 @@ namespace Input {
input_locked = false;
}
void SetInputs(GLFWwindow* window) {
void SetCallbacks(GLFWwindow* window) {
glfwSetCursorPosCallback(window, (GLFWcursorposfun)CursorPosCallback);
glfwSetKeyCallback(window, (GLFWkeyfun)KeyboardCallback);
glfwSetMouseButtonCallback(window, (GLFWmousebuttonfun)MouseButtonCallback);
glfwSetScrollCallback(window, (GLFWscrollfun)ScrollCallback);
@@ -393,6 +175,29 @@ namespace Input {
}
}
inline static void process_button(const InputState* input_state, double_t& value, InputButton button,
const double_t speed, const double_t speed_fast, const double_t speed_slow) {
if (input_state->CheckDown(button)
&& input_state->CheckDown(INPUT_BUTTON_CONTROL) && input_state->CheckDown(INPUT_BUTTON_SHIFT))
value += speed;
else if (input_state->CheckDown(button) && input_state->CheckDown(INPUT_BUTTON_SHIFT))
value += speed_fast;
else if (input_state->CheckDown(button) && input_state->CheckDown(INPUT_BUTTON_CONTROL))
value += speed_slow;
else if (input_state->CheckDown(button))
value += speed;
}
static void CursorPosCallback(GLFWwindow* window,
double_t xpos, double_t ypos) {
pos.x = (int32_t)xpos;
pos.y = (int32_t)ypos;
glut_get_modifiers();
glut_motion_cb(pos.x, pos.y);
glut_reset_modifiers();
}
static void KeyboardCallback(GLFWwindow* window,
int32_t key, int32_t scancode, int32_t action, int32_t mods) {
if (mods & GLFW_MOD_CAPS_LOCK)
@@ -431,60 +236,112 @@ namespace Input {
break;
}
if (is_mod) {
if (action != GLFW_RELEASE) {
for (Key& i : keys)
if (!is_key_mod(i.key))
i.mods |= mods;
if (is_mod)
return;
for (MouseButton& i : mouse_buttons)
i.mods |= mods;
}
else {
mods = ~mods;
for (Key& i : keys)
if (!is_key_mod(i.key))
i.mods &= mods;
static const std::pair<int32_t, int32_t> glut_key_table[] = {
{ GLFW_KEY_ESCAPE , 0x1B },
{ GLFW_KEY_BACKSPACE, '\b' },
{ GLFW_KEY_TAB , '\t' },
{ GLFW_KEY_ENTER , '\r' },
{ GLFW_KEY_SPACE , ' ' },
{ GLFW_KEY_DELETE , 0x7F },
};
for (MouseButton& i : mouse_buttons)
i.mods &= mods;
static const std::pair<int32_t, int32_t> glut_skey_table[] = {
{ GLFW_KEY_F1 , 1, },
{ GLFW_KEY_F2 , 2, },
{ GLFW_KEY_F3 , 3, },
{ GLFW_KEY_F4 , 4, },
{ GLFW_KEY_F5 , 5, },
{ GLFW_KEY_F6 , 6, },
{ GLFW_KEY_F7 , 7, },
{ GLFW_KEY_F8 , 8, },
{ GLFW_KEY_F9 , 9, },
{ GLFW_KEY_F10 , 10, },
{ GLFW_KEY_F11 , 11, },
{ GLFW_KEY_F12 , 12, },
{ GLFW_KEY_LEFT , 100, },
{ GLFW_KEY_UP , 101, },
{ GLFW_KEY_RIGHT , 102, },
{ GLFW_KEY_DOWN , 103, },
{ GLFW_KEY_PAGE_UP , 104, },
{ GLFW_KEY_PAGE_DOWN, 105, },
{ GLFW_KEY_HOME , 106, },
{ GLFW_KEY_END , 107, },
{ GLFW_KEY_INSERT , 108, },
};
glut_get_modifiers();
int32_t glut_key = -1;
bool is_skey = false;
for (const auto& i : glut_skey_table)
if (i.first == key) {
glut_key = i.second;
is_skey = true;
break;
}
mods = 0;
if (is_skey) {
switch (action) {
case GLFW_RELEASE:
glut_skeyup_cb(glut_key, pos.x, pos.y);
break;
case GLFW_PRESS:
glut_skeydown_cb(glut_key, pos.x, pos.y);
break;
}
}
else {
for (const auto& i : glut_key_table)
if (i.first == key) {
glut_key = i.second;
break;
}
if (glut_key == -1
&& ((key >= '0' && key <= '9')
|| (key >= 'A' && key <= 'Z')
|| (key >= 'a' && key <= 'z')))
glut_key = key;
if (glut_key != -1)
switch (action) {
case GLFW_RELEASE:
glut_keyup_cb(glut_key, pos.x, pos.y);
break;
case GLFW_PRESS:
glut_keydown_cb(glut_key, pos.x, pos.y);
break;
}
}
Key* k = vector_Key_find(keys, key);
if (k)
*k = { key, scancode, action, mods };
else
keys.push_back({ key, scancode, action, mods });
glut_reset_modifiers();
}
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 });
int32_t bn = -1;
if (button == GLFW_MOUSE_BUTTON_LEFT)
bn = 0;
else if (button == GLFW_MOUSE_BUTTON_MIDDLE)
bn = 1;
else if (button == GLFW_MOUSE_BUTTON_RIGHT)
bn = 2;
int32_t state = action == GLFW_PRESS ? 0 : 1;
glut_get_modifiers();
glut_mouse_cb(bn, state, pos.x, pos.y);
glut_reset_modifiers();
}
static void ScrollCallback(GLFWwindow* window,
double_t x_offset, double_t y_offset) {
scroll += y_offset;
}
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;
glut_get_modifiers();
glut_mouse_cb(y_offset < 0.0f ? 4 : 3, 0, pos.x, pos.y);
glut_reset_modifiers();
}
};
src/ReDIVA/input.hpp
+3 -20
View File
@@ -6,27 +6,10 @@
#pragma once
#include "../KKdLib/default.hpp"
#include <GLFW/glfw3.h>
struct GLFWwindow;
namespace Input {
extern POINT pos;
extern double_t scroll;
extern POINT pos_prev;
extern double_t scroll_prev;
extern bool IsKeyDown(int32_t key, int32_t mods = 0);
extern bool IsKeyUp(int32_t key, int32_t mods = 0);
extern bool IsKeyTapped(int32_t key, int32_t mods = 0);
extern bool IsKeyReleased(int32_t key, int32_t mods = 0);
extern bool IsMouseButtonDown(int32_t button, int32_t mods = 0);
extern bool IsMouseButtonUp(int32_t button, int32_t mods = 0);
extern bool IsMouseButtonTapped(int32_t button, int32_t mods = 0);
extern bool IsMouseButtonReleased(int32_t button, int32_t mods = 0);
extern bool WasKeyDown(int32_t key, int32_t mods = 0);
extern bool WasKeyUp(int32_t key, int32_t mods = 0);
extern bool WasMouseButtonDown(int32_t button, int32_t mods = 0);
extern bool WasMouseButtonUp(int32_t button, int32_t mods = 0);
extern void EndFrame();
extern void NewFrame();
extern void SetInputs(GLFWwindow* window);
extern void SetCallbacks(struct GLFWwindow* window);
};
src/ReDIVA/input_state.cpp
+508 -300
View File
@@ -5,8 +5,8 @@
#include "input_state.hpp"
#include "../CRE/render_context.hpp"
#include "../CRE/resolution_mode.hpp"
#include "config.hpp"
#include "input.hpp"
#ifndef USE_OPENGL
#if BAKE_PNG
@@ -38,9 +38,23 @@ Bit / Name
11 JVS_L (also triggered by pressing L on Slider Panel)
12 JVS_R (also triggered by pressing R on Slider Panel)
13 JVS_BUTTON_7
14 JVS_BUTTON_8
15 JVS_BUTTON_9
16 JVS_BUTTON_10
18 JVS_SW1
19 JVS_SW2
20 DIP_SW1
21 DIP_SW2
22 DIP_SW3
23 DIP_SW4
24 DIP_SW5
25 DIP_SW6
26 DIP_SW7
27 DIP_SW8
28 KEYBOARD_PRESS (any of keyboard keys)
29 '0'
@@ -112,6 +126,7 @@ struct amInputState {
amInputState();
void reset();
void update_modifiers(bool get);
};
struct amOutputState {
@@ -137,6 +152,8 @@ static bool am_input_output_set_output(const amOutputState value, int32_t index)
// Own stuff
static void am_input_output_pc_ctrl(amInputState& input);
static int32_t get_modifiers();
static void input_state_ctrl(InputState* input_state);
static int32_t input_state_get_delta_frame();
@@ -144,9 +161,6 @@ amInputOutputState am_input_output;
InputState* input_state;
uint8_t disable_input_state_update = 0;
bool disable_cursor = false;
extern render_context* rctx_ptr;
InputState::DoubleTap::DoubleTap() : hold_frame(), frame(), state() {
@@ -328,55 +342,30 @@ void InputState::Update(int32_t index, int32_t delta_frame) {
Released |= am_input.released;
if (updated) {
field_80[0] = am_input.field_30[0];
field_80[1] = am_input.field_30[1];
field_80[2] = am_input.field_30[2];
field_80[3] = am_input.field_30[3];
field_80[4] = am_input.field_30[4];
field_80[5] = am_input.field_30[5];
field_80[6] = am_input.field_30[6];
field_80[7] = am_input.field_30[7];
for (int32_t i = 0; i < 8; i++)
field_80[i] = am_input.field_30[i];
//Added
field_80[8] = am_input.field_30[8];
field_80[9] = am_input.field_30[9];
field_80[10] = am_input.field_30[10];
field_80[11] = am_input.field_30[11];
for (int32_t i = 8; i < 12; i++)
field_80[i] = am_input.field_30[i];
}
/*if (task_slider_control_get()->sub_140618C60(36))
am_input.tapped[INPUT_BUTTON_JVS_L] = true;
else
am_input.tapped[INPUT_BUTTON_JVS_L] = false;
/*am_input.tapped[INPUT_BUTTON_JVS_L] = task_slider_control_get()->sub_140618C60(36);
am_input.released[INPUT_BUTTON_JVS_L] = task_slider_control_get()->sub_140618C40(36);
am_input.down[INPUT_BUTTON_JVS_L] = task_slider_control_get()->sub_140618C20(36);
if (task_slider_control_get()->sub_140618C40(36))
am_input.released[INPUT_BUTTON_JVS_L] = true;
else
am_input.released[INPUT_BUTTON_JVS_L] = false;
am_input.tapped[INPUT_BUTTON_JVS_R] = task_slider_control_get()->sub_140618C60(37);
am_input.released[INPUT_BUTTON_JVS_R] = task_slider_control_get()->sub_140618C40(37);
am_input.down[INPUT_BUTTON_JVS_R] = task_slider_control_get()->sub_140618C20(37);*/
if (task_slider_control_get()->sub_140618C20(36))
am_input.down[INPUT_BUTTON_JVS_L] = true;
else
am_input.down[INPUT_BUTTON_JVS_L] = false;
if (task_slider_control_get()->sub_140618C60(37))
am_input.tapped[INPUT_BUTTON_JVS_R] = true;
else
am_input.tapped[INPUT_BUTTON_JVS_R] = false;
if (task_slider_control_get()->sub_140618C40(37))
am_input.released[INPUT_BUTTON_JVS_R] = true;
else
am_input.released[INPUT_BUTTON_JVS_R] = false;
if (task_slider_control_get()->sub_140618C20(37))
am_input.down[INPUT_BUTTON_JVS_R] = true;
else
am_input.down[INPUT_BUTTON_JVS_R] = false;*/
Tapped |= am_input.tapped;
Tapped |= am_input.tapped;
Released |= am_input.released;
Down |= am_input.down;
Down |= am_input.down;
// Added
key = 0;
if (am_input.key_ptr)
key = *am_input.key_ptr;
Released &= ~Down;
@@ -418,31 +407,29 @@ void InputState::Update(int32_t index, int32_t delta_frame) {
Toggle ^= Down;
ButtonState Down = this->Down;
ButtonState Up = ~this->Down;
ButtonState DownNew = this->Down & ~DownPrev;
ButtonState UpNew = ~this->Down & DownPrev;
ButtonState DoubleTapped;
for (int32_t i = 0; i < INPUT_BUTTON_MAX; i++)
if (DoubleTapData[i].Ctrl(delta_frame, Down[i], Up[i]))
DoubleTapped[i] = true;
else
DoubleTapped[i] = false;
this->DoubleTapped = DoubleTapped;
{
ButtonState DoubleTapped;
for (int32_t i = 0; i < INPUT_BUTTON_MAX; i++)
DoubleTapped[i] = DoubleTapData[i].Ctrl(delta_frame, DownNew[i], UpNew[i]);
this->DoubleTapped = DoubleTapped;
}
ButtonState Hold;
for (int32_t i = 0; i < INPUT_BUTTON_MAX; i++)
if (HoldTapData[i].Ctrl(delta_frame, Down[i], Up[i]))
Hold[i] = true;
else
Hold[i] = false;
this->Hold = Hold;
{
ButtonState Hold;
for (int32_t i = 0; i < INPUT_BUTTON_MAX; i++)
Hold[i] = HoldTapData[i].Ctrl(delta_frame, Down[i], UpNew[i]);
this->Hold = Hold;
}
ButtonState IntervalTapped;
for (int32_t i = 0; i < INPUT_BUTTON_MAX; i++)
if (IntervalTapData[i].Ctrl(delta_frame, Down[i]))
IntervalTapped[i] = true;
else
IntervalTapped[i] = false;
this->IntervalTapped = IntervalTapped;
{
ButtonState IntervalTapped;
for (int32_t i = 0; i < INPUT_BUTTON_MAX; i++)
IntervalTapped[i] = IntervalTapData[i].Ctrl(delta_frame, Down[i]);
this->IntervalTapped = IntervalTapped;
}
}
int32_t InputState::sub_14018CCC0(int32_t index) const {
@@ -461,6 +448,12 @@ void input_state_am_ctrl() {
am_input_output_ctrl();
}
// Own stuff
void input_state_pc_ctrl() {
if (input_state)
am_input_output_pc_ctrl(am_input_output.input[0]);
}
void input_state_ctrl() {
if (input_state)
input_state_ctrl(input_state);
@@ -495,6 +488,45 @@ void amInputState::reset() {
key_ptr = 0;
}
void amInputState::update_modifiers(bool get) {
int32_t modifiers = 0x00;
if (get)
modifiers = get_modifiers();
if (modifiers & 0x01) {
if (!down[INPUT_BUTTON_SHIFT])
tapped[INPUT_BUTTON_SHIFT] = true;
down[INPUT_BUTTON_SHIFT] = true;
}
else {
if (down[INPUT_BUTTON_SHIFT])
released[INPUT_BUTTON_SHIFT] = true;
down[INPUT_BUTTON_SHIFT] = false;
}
if (modifiers & 0x02) {
if (!down[INPUT_BUTTON_CONTROL])
tapped[INPUT_BUTTON_CONTROL] = true;
down[INPUT_BUTTON_CONTROL] = true;
}
else {
if (down[INPUT_BUTTON_CONTROL])
released[INPUT_BUTTON_CONTROL] = true;
down[INPUT_BUTTON_CONTROL] = false;
}
if (modifiers & 0x04) {
if (!down[INPUT_BUTTON_ALT])
tapped[INPUT_BUTTON_ALT] = true;
down[INPUT_BUTTON_ALT] = true;
}
else {
if (down[INPUT_BUTTON_ALT])
released[INPUT_BUTTON_ALT] = true;
down[INPUT_BUTTON_ALT] = false;
}
}
amOutputState::amOutputState() : data() {
}
@@ -532,81 +564,78 @@ void amInputOutputState::ctrl() {
/*if (v11) {
if (v11->field_0[0] & 0x80)
input.down[0] = true;
input.down[INPUT_BUTTON_JVS_TEST] = true;
if (v11->field_0[1] & 0x80)
input.down[2] = true;
input.down[JVS_SERVICE] = true;
if (v11->field_0[1] & 0x40)
input.down[1] = true;
input.down[JVS_START] = true;
if (v11->field_0[1] & 0x20)
input.down[3] = true;
input.down[JVS_UP] = true;
if (v11->field_0[1] & 0x10)
input.down[4] = true;
input.down[JVS_DOWN] = true;
if (v11->field_0[1] & 0x08)
input.down[5] = true;
input.down[JVS_LEFT] = true;
if (v11->field_0[1] & 0x04)
input.down[6] = true;
input.down[JVS_RIGHT] = true;
if (v11->field_0[1] & 0x02)
input.down[7] = true;
input.down[JVS_TRIANGLE] = true;
if (v11->field_0[1] & 0x01)
input.down[8] = true;
input.down[JVS_SQUARE] = true;
if (v11->field_0[2] & 0x80)
input.down[9] = true;
input.down[JVS_CROSS] = true;
if (v11->field_0[2] & 0x40)
input.down[10] = true;
input.down[JVS_CIRCLE] = true;
if (v11->field_0[2] & 0x20)
input.down[11] = true;
input.down[JVS_L] = true;
if (v11->field_0[2] & 0x10)
input.down[12] = true;
input.down[JVS_R] = true;
if (v11->field_0[2] & 0x08)
input.down[13] = true;
input.down[JVS_BUTTON_7] = true;
if (v11->field_0[2] & 0x04)
input.down[14] = true;
input.down[JVS_BUTTON_8] = true;
if (v11->field_0[2] & 0x02)
input.down[15] = true;
input.down[JVS_BUTTON_9] = true;
if (v11->field_0[2] & 0x01)
input.down[16] = true;
input.down[JVS_BUTTON_10] = true;
uint16_t* v15 = v11->field_4;
for (size_t j = 0; j < 18; j++, v15++)
for (size_t j = 0; j < 18; j++)
if (j < 2)
input.field_30[j] = *v15;
input.field_30[j] = v11->field_4[j];
}*/
am_input_output_pc_ctrl(input);
if (input.down[0])
this->input[0].down[0] = true;
if (input.down[1])
this->input[0].down[1] = true;
if (input.down[INPUT_BUTTON_JVS_TEST])
this->input[0].down[INPUT_BUTTON_JVS_TEST] = true;
if (input.down[INPUT_BUTTON_JVS_SERVICE])
this->input[0].down[INPUT_BUTTON_JVS_SERVICE] = true;
}
/*struc_807* v16 = sub_14066CA20();
if (v16->field_0[1] & 0x01) {
input[0].down[0] = true;
input[0].down[18] = true;
input[0].down[INPUT_BUTTON_JVS_TEST] = true;
input[0].down[INPUT_BUTTON_JVS_SW1] = true;
}
if (v16->field_0[1] & 0x02) {
input[0].down[1] = true;
input[0].down[19] = true;
input[0].down[INPUT_BUTTON_JVS_SERVICE] = true;
input[0].down[INPUT_BUTTON_JVS_SW2] = true;
}
if (v16->field_0[0] & 0x01)
input[0].down[20] = true;
input[0].down[INPUT_BUTTON_DIP_SW1] = true;
if (v16->field_0[0] & 0x02)
input[0].down[21] = true;
input[0].down[INPUT_BUTTON_DIP_SW2] = true;
if (v16->field_0[0] & 0x04)
input[0].down[22] = true;
input[0].down[INPUT_BUTTON_DIP_SW3] = true;
if (v16->field_0[0] & 0x08)
input[0].down[23] = true;
input[0].down[INPUT_BUTTON_DIP_SW4] = true;
if (v16->field_0[0] & 0x10)
input[0].down[24] = true;
input[0].down[INPUT_BUTTON_DIP_SW5] = true;
if (v16->field_0[0] & 0x20)
input[0].down[25] = true;
input[0].down[INPUT_BUTTON_DIP_SW6] = true;
if (v16->field_0[0] & 0x40)
input[0].down[26] = true;
input[0].down[INPUT_BUTTON_DIP_SW7] = true;
if (v16->field_0[0] & 0x80)
input[0].down[27] = true;*/
input[0].down[INPUT_BUTTON_DIP_SW8] = true;*/
for (size_t i = 0; i < 2; i++) {
input[i].tapped = input[i].down & ~prev_down[i];
@@ -684,200 +713,38 @@ static bool am_input_output_get_input(amInputState* data, int32_t index) {
return true;
}
struct glut_input_struct {
uint8_t key;
uint8_t key_last;
int32_t motion_x;
int32_t motion_y;
int32_t scroll_up;
int32_t scroll_down;
};
int32_t glut_modifiers;
amInputState glut_pc_input[2];
amInputState glut_key_input;
amInputState glut_mouse_input;
glut_input_struct glut_input;
// Own stuff
static void am_input_output_pc_ctrl(amInputState& input) {
if (disable_input_state_update)
return;
void glut_input_ctrl();
glut_input_ctrl();
struct key_map {
int32_t index;
int32_t keys[3];
input.tapped = glut_pc_input[0].tapped;
input.released = glut_pc_input[0].released;
input.down = glut_pc_input[0].down;
inline key_map() : index(), keys() {
for (int32_t& i : keys)
i = -1;
}
inline key_map(int32_t index, int32_t key) : key_map() {
this->index = index;
this->keys[0] = key;
}
inline key_map(int32_t index, int32_t key1, int32_t key2) : key_map() {
this->index = index;
this->keys[0] = key1;
this->keys[1] = key2;
}
inline key_map(int32_t index, int32_t key1, int32_t key2, int32_t key3) : key_map() {
this->index = index;
this->keys[0] = key1;
this->keys[1] = key2;
this->keys[2] = key3;
}
};
static const key_map key_map_array[] = {
{ INPUT_BUTTON_0, GLFW_KEY_0, },
{ INPUT_BUTTON_1, GLFW_KEY_1, },
{ INPUT_BUTTON_2, GLFW_KEY_2, },
{ INPUT_BUTTON_3, GLFW_KEY_3, },
{ INPUT_BUTTON_4, GLFW_KEY_4, },
{ INPUT_BUTTON_5, GLFW_KEY_5, },
{ INPUT_BUTTON_6, GLFW_KEY_6, },
{ INPUT_BUTTON_7, GLFW_KEY_7, },
{ INPUT_BUTTON_8, GLFW_KEY_8, },
{ INPUT_BUTTON_9, GLFW_KEY_9, },
{ INPUT_BUTTON_A, GLFW_KEY_A, },
{ INPUT_BUTTON_B, GLFW_KEY_B, },
{ INPUT_BUTTON_C, GLFW_KEY_C, },
{ INPUT_BUTTON_D, GLFW_KEY_D, },
{ INPUT_BUTTON_E, GLFW_KEY_E, },
{ INPUT_BUTTON_F, GLFW_KEY_F, },
{ INPUT_BUTTON_G, GLFW_KEY_G, },
{ INPUT_BUTTON_H, GLFW_KEY_H, },
{ INPUT_BUTTON_I, GLFW_KEY_I, },
{ INPUT_BUTTON_J, GLFW_KEY_J, },
{ INPUT_BUTTON_K, GLFW_KEY_K, },
{ INPUT_BUTTON_L, GLFW_KEY_L, },
{ INPUT_BUTTON_M, GLFW_KEY_M, },
{ INPUT_BUTTON_N, GLFW_KEY_N, },
{ INPUT_BUTTON_O, GLFW_KEY_O, },
{ INPUT_BUTTON_P, GLFW_KEY_P, },
{ INPUT_BUTTON_Q, GLFW_KEY_Q, },
{ INPUT_BUTTON_R, GLFW_KEY_R, },
{ INPUT_BUTTON_S, GLFW_KEY_S, },
{ INPUT_BUTTON_T, GLFW_KEY_T, },
{ INPUT_BUTTON_U, GLFW_KEY_U, },
{ INPUT_BUTTON_V, GLFW_KEY_V, },
{ INPUT_BUTTON_W, GLFW_KEY_W, },
{ INPUT_BUTTON_X, GLFW_KEY_X, },
{ INPUT_BUTTON_Y, GLFW_KEY_Y, },
{ INPUT_BUTTON_Z, GLFW_KEY_Z, },
{ INPUT_BUTTON_ESCAPE, GLFW_KEY_ESCAPE, },
{ INPUT_BUTTON_F1 , GLFW_KEY_F1, },
{ INPUT_BUTTON_F2 , GLFW_KEY_F2, },
{ INPUT_BUTTON_F3 , GLFW_KEY_F3, },
{ INPUT_BUTTON_F4 , GLFW_KEY_F4, },
{ INPUT_BUTTON_F5 , GLFW_KEY_F5, },
{ INPUT_BUTTON_F6 , GLFW_KEY_F6, },
{ INPUT_BUTTON_F7 , GLFW_KEY_F7, },
{ INPUT_BUTTON_F8 , GLFW_KEY_F8, },
{ INPUT_BUTTON_F9 , GLFW_KEY_F9, },
{ INPUT_BUTTON_F10, GLFW_KEY_F10, },
{ INPUT_BUTTON_F11, GLFW_KEY_F11, },
{ INPUT_BUTTON_F12, GLFW_KEY_F12, },
{ INPUT_BUTTON_BACKSPACE, GLFW_KEY_BACKSPACE, },
{ INPUT_BUTTON_TAB , GLFW_KEY_TAB, },
{ INPUT_BUTTON_ENTER , GLFW_KEY_ENTER, },
{ INPUT_BUTTON_SHIFT , GLFW_KEY_LEFT_SHIFT, GLFW_KEY_RIGHT_SHIFT, },
{ INPUT_BUTTON_CONTROL, GLFW_KEY_LEFT_CONTROL, GLFW_KEY_RIGHT_CONTROL, },
{ INPUT_BUTTON_ALT , GLFW_KEY_LEFT_ALT, GLFW_KEY_RIGHT_ALT, },
{ INPUT_BUTTON_SPACE, GLFW_KEY_SPACE, },
{ INPUT_BUTTON_INSERT , GLFW_KEY_INSERT, },
{ INPUT_BUTTON_HOME , GLFW_KEY_HOME, },
{ INPUT_BUTTON_PAGE_UP , GLFW_KEY_PAGE_UP, },
{ INPUT_BUTTON_DELETE , GLFW_KEY_DELETE, },
{ INPUT_BUTTON_END , GLFW_KEY_END, },
{ INPUT_BUTTON_PAGE_DOWN, GLFW_KEY_PAGE_DOWN, },
{ INPUT_BUTTON_UP , GLFW_KEY_UP, },
{ INPUT_BUTTON_LEFT , GLFW_KEY_LEFT, },
{ INPUT_BUTTON_DOWN , GLFW_KEY_DOWN, },
{ INPUT_BUTTON_RIGHT, GLFW_KEY_RIGHT, },
};
static const key_map mouse_button_array[] = {
{ INPUT_BUTTON_MOUSE_BUTTON_LEFT , GLFW_MOUSE_BUTTON_LEFT, },
{ INPUT_BUTTON_MOUSE_BUTTON_MIDDLE, GLFW_MOUSE_BUTTON_MIDDLE, },
{ INPUT_BUTTON_MOUSE_BUTTON_RIGHT , GLFW_MOUSE_BUTTON_RIGHT, },
};
static const key_map copy_map_array[] = {
{ INPUT_BUTTON_JVS_TEST , INPUT_BUTTON_F1, },
{ INPUT_BUTTON_JVS_SERVICE, INPUT_BUTTON_F2, },
{ INPUT_BUTTON_JVS_START , INPUT_BUTTON_ENTER, },
{ INPUT_BUTTON_JVS_UP , INPUT_BUTTON_UP, },
{ INPUT_BUTTON_JVS_DOWN , INPUT_BUTTON_DOWN, },
{ INPUT_BUTTON_JVS_LEFT , INPUT_BUTTON_LEFT, },
{ INPUT_BUTTON_JVS_RIGHT, INPUT_BUTTON_RIGHT, },
{ INPUT_BUTTON_JVS_TRIANGLE, INPUT_BUTTON_W, INPUT_BUTTON_I, },
{ INPUT_BUTTON_JVS_SQUARE , INPUT_BUTTON_A, INPUT_BUTTON_J, },
{ INPUT_BUTTON_JVS_CROSS , INPUT_BUTTON_S, INPUT_BUTTON_K, },
{ INPUT_BUTTON_JVS_CIRCLE , INPUT_BUTTON_D, INPUT_BUTTON_L, },
{ INPUT_BUTTON_JVS_L, INPUT_BUTTON_Q, INPUT_BUTTON_U, },
{ INPUT_BUTTON_JVS_R, INPUT_BUTTON_E, INPUT_BUTTON_O, },
{ INPUT_BUTTON_JVS_SW1, INPUT_BUTTON_F11, },
{ INPUT_BUTTON_JVS_SW2, INPUT_BUTTON_F12, },
};
for (const key_map& i : key_map_array) {
bool down = false;
for (const int32_t& j : i.keys) {
if (j == -1)
break;
if (!down)
if (Input::IsKeyDown(j, -1))
down = true;
}
input.down[i.index] = down;
}
for (const key_map& i : mouse_button_array) {
bool down = false;
for (const int32_t& j : i.keys) {
if (j == -1)
break;
if (Input::IsMouseButtonDown(j)) {
down = true;
break;
}
}
input.down[i.index] = down;
}
{
const int32_t index = INPUT_BUTTON_MOUSE_SCROLL_UP;
input.down[index] = Input::scroll > 0.0;
}
{
const int32_t index = INPUT_BUTTON_MOUSE_SCROLL_DOWN;
input.down[index] = Input::scroll < 0.0;
}
for (const key_map& i : copy_map_array) {
bool down = false;
for (const int32_t& j : i.keys) {
if (j == -1)
break;
down |= input.down[j];
}
input.down[i.index] = down;
}
input.field_30[0] = glut_pc_input[0].field_30[0];
input.field_30[1] = glut_pc_input[0].field_30[1];
input.field_30[2] = glut_pc_input[0].field_30[2];
input.field_30[3] = glut_pc_input[0].field_30[3];
input.field_30[4] = glut_pc_input[0].field_30[4];
input.field_30[5] = glut_pc_input[0].field_30[5];
input.field_30[6] = glut_pc_input[0].field_30[6];
input.field_30[7] = glut_pc_input[0].field_30[7];
#if BAKE_PNG || BAKE_VIDEO
int32_t x_offset = 0;
@@ -891,10 +758,22 @@ static void am_input_output_pc_ctrl(amInputState& input) {
float_t y_scale = 720.0f / (float_t)rctx_ptr->sprite_height;
#endif
input.field_30[8] = (int32_t)((float_t)(Input::pos.x - x_offset) * x_scale);
input.field_30[9] = (int32_t)((float_t)(Input::pos.y - y_offset) * y_scale);
input.field_30[10] = (int32_t)((float_t)(Input::pos_prev.x - Input::pos.x - x_offset) * x_scale);
input.field_30[11] = (int32_t)((float_t)(Input::pos_prev.y - Input::pos.y - y_offset) * y_scale);
input.field_30[8] = (int32_t)(((float_t)glut_pc_input[0].field_30[8] - x_offset) * x_scale);
input.field_30[9] = (int32_t)(((float_t)glut_pc_input[0].field_30[9] - y_offset) * y_scale);
input.field_30[10] = (int32_t)(((float_t)glut_pc_input[0].field_30[10] - x_offset) * x_scale);
input.field_30[11] = (int32_t)(((float_t)glut_pc_input[0].field_30[11] - y_offset) * y_scale);
input.field_30[12] = glut_pc_input[0].field_30[12];
input.field_30[13] = glut_pc_input[0].field_30[12];
input.key_ptr = glut_pc_input[0].key_ptr;
}
static int32_t get_modifiers() {
if (glut_modifiers == -1)
return 0x00;
return glut_modifiers;
}
static bool am_input_output_set_output(const amOutputState data, int32_t index) {
@@ -914,3 +793,332 @@ static void input_state_ctrl(InputState* input_state) {
static int32_t input_state_get_delta_frame() {
return 1;
}
static void glut_pc_input_copy_button(InputButton src, InputButton dst);
void glut_mouse_input_check_mouse_click() {
bool prev_down = glut_mouse_input.down[INPUT_BUTTON_MOUSE_PRESS];
glut_mouse_input.released[INPUT_BUTTON_MOUSE_PRESS] = false;
glut_mouse_input.tapped[INPUT_BUTTON_MOUSE_PRESS] = false;
glut_mouse_input.down[INPUT_BUTTON_MOUSE_PRESS] = false;
if (glut_mouse_input.down[INPUT_BUTTON_MOUSE_BUTTON_LEFT]
|| glut_mouse_input.down[INPUT_BUTTON_MOUSE_BUTTON_MIDDLE]
|| glut_mouse_input.down[INPUT_BUTTON_MOUSE_BUTTON_RIGHT]
|| glut_mouse_input.down[INPUT_BUTTON_MOUSE_SCROLL_UP]
|| glut_mouse_input.down[INPUT_BUTTON_MOUSE_SCROLL_DOWN])
glut_mouse_input.down[INPUT_BUTTON_MOUSE_PRESS] = true;
if (prev_down) {
if (!glut_mouse_input.down[INPUT_BUTTON_MOUSE_PRESS])
glut_mouse_input.released[INPUT_BUTTON_MOUSE_PRESS] = true;
}
else {
if (glut_mouse_input.down[INPUT_BUTTON_MOUSE_PRESS])
glut_mouse_input.tapped[INPUT_BUTTON_MOUSE_PRESS] = true;
}
}
void glut_input_ctrl() {
int32_t scroll_up = glut_input.scroll_up;
glut_input.scroll_up = 0;
int32_t motion_x_delta = glut_input.motion_x - glut_mouse_input.field_30[8];
glut_mouse_input.field_30[8] = glut_input.motion_x;
glut_mouse_input.field_30[10] = motion_x_delta;
int32_t scroll_down = glut_input.scroll_down;
glut_input.scroll_down = 0;
int32_t motion_y_delta = glut_input.motion_y - glut_mouse_input.field_30[9];
glut_mouse_input.field_30[9] = glut_input.motion_y;
glut_mouse_input.field_30[11] = motion_y_delta;
glut_mouse_input.field_30[12] = scroll_up + (scroll_up == 0 ? 0 : glut_mouse_input.field_30[12]);
glut_mouse_input.field_30[13] = scroll_down + (scroll_down == 0 ? 0 : glut_mouse_input.field_30[13]);
if ((int32_t)glut_mouse_input.field_30[12] > 0) {
glut_mouse_input.tapped[INPUT_BUTTON_MOUSE_SCROLL_UP] = true;
glut_mouse_input.released[INPUT_BUTTON_MOUSE_SCROLL_UP] = true;
glut_mouse_input.down[INPUT_BUTTON_MOUSE_SCROLL_UP] = false;
}
if ((int32_t)glut_mouse_input.field_30[13] > 0) {
glut_mouse_input.tapped[INPUT_BUTTON_MOUSE_SCROLL_DOWN] = true;
glut_mouse_input.released[INPUT_BUTTON_MOUSE_SCROLL_DOWN] = true;
glut_mouse_input.down[INPUT_BUTTON_MOUSE_SCROLL_DOWN] = false;
}
glut_mouse_input_check_mouse_click();
if (!glut_key_input.down[INPUT_BUTTON_KEYBOARD_PRESS])
glut_key_input.update_modifiers(false);
if (!glut_mouse_input.down[INPUT_BUTTON_MOUSE_PRESS])
glut_mouse_input.update_modifiers(false);
glut_pc_input[0].down = glut_key_input.down | glut_mouse_input.down;
glut_pc_input[0].tapped = glut_key_input.tapped | glut_mouse_input.tapped;
glut_pc_input[0].released = glut_key_input.released | glut_mouse_input.released;
glut_pc_input[0].tapped &= glut_pc_input[0].down;
glut_pc_input[0].released &= ~glut_pc_input[0].down;
if (glut_mouse_input.tapped[INPUT_BUTTON_MOUSE_SCROLL_UP])
glut_pc_input[0].tapped[INPUT_BUTTON_MOUSE_SCROLL_UP] = true;
if (glut_mouse_input.tapped[INPUT_BUTTON_MOUSE_SCROLL_DOWN])
glut_pc_input[0].tapped[INPUT_BUTTON_MOUSE_SCROLL_DOWN] = true;
for (int32_t i = 0; i < 14; i++)
glut_pc_input[0].field_30[i] = glut_mouse_input.field_30[i];
glut_pc_input[0].key_ptr = &glut_input.key_last;
glut_pc_input_copy_button(INPUT_BUTTON_F1, INPUT_BUTTON_JVS_TEST );
glut_pc_input_copy_button(INPUT_BUTTON_F2, INPUT_BUTTON_JVS_SERVICE);
glut_pc_input_copy_button(INPUT_BUTTON_SPACE, INPUT_BUTTON_JVS_START);
glut_pc_input_copy_button(INPUT_BUTTON_UP , INPUT_BUTTON_JVS_UP );
glut_pc_input_copy_button(INPUT_BUTTON_DOWN , INPUT_BUTTON_JVS_DOWN );
glut_pc_input_copy_button(INPUT_BUTTON_LEFT , INPUT_BUTTON_JVS_LEFT );
glut_pc_input_copy_button(INPUT_BUTTON_RIGHT, INPUT_BUTTON_JVS_RIGHT);
glut_pc_input_copy_button(INPUT_BUTTON_W, INPUT_BUTTON_JVS_TRIANGLE);
glut_pc_input_copy_button(INPUT_BUTTON_A, INPUT_BUTTON_JVS_SQUARE );
glut_pc_input_copy_button(INPUT_BUTTON_S, INPUT_BUTTON_JVS_CROSS );
glut_pc_input_copy_button(INPUT_BUTTON_D, INPUT_BUTTON_JVS_CIRCLE );
glut_pc_input_copy_button(INPUT_BUTTON_I, INPUT_BUTTON_JVS_TRIANGLE);
glut_pc_input_copy_button(INPUT_BUTTON_J, INPUT_BUTTON_JVS_SQUARE );
glut_pc_input_copy_button(INPUT_BUTTON_K, INPUT_BUTTON_JVS_CROSS );
glut_pc_input_copy_button(INPUT_BUTTON_L, INPUT_BUTTON_JVS_CIRCLE );
glut_pc_input_copy_button(INPUT_BUTTON_Q, INPUT_BUTTON_JVS_L);
glut_pc_input_copy_button(INPUT_BUTTON_E, INPUT_BUTTON_JVS_R);
glut_pc_input_copy_button(INPUT_BUTTON_U, INPUT_BUTTON_JVS_L);
glut_pc_input_copy_button(INPUT_BUTTON_O, INPUT_BUTTON_JVS_R);
glut_pc_input_copy_button(INPUT_BUTTON_F11, INPUT_BUTTON_JVS_SW1);
glut_pc_input_copy_button(INPUT_BUTTON_F12, INPUT_BUTTON_JVS_SW2);
glut_input.key_last = glut_input.key;
glut_input.key = 0;
glut_key_input.tapped = 0;
glut_key_input.released = 0;
glut_mouse_input.tapped = 0;
glut_mouse_input.released = 0;
}
static void glut_pc_input_copy_button(InputButton src, InputButton dst) {
glut_pc_input[0].down[dst] = glut_pc_input[0].down[dst] | glut_pc_input[0].down[src];
glut_pc_input[0].tapped[dst] = glut_pc_input[0].tapped[dst] | glut_pc_input[0].tapped[src];
glut_pc_input[0].released[dst] = glut_pc_input[0].released[dst] | glut_pc_input[0].released[src];
glut_pc_input[0].tapped[dst] = glut_pc_input[0].tapped[dst] & glut_pc_input[0].down[dst];
glut_pc_input[0].released[dst] = glut_pc_input[0].released[dst] & ~glut_pc_input[0].down[dst];
}
struct glut_table {
int32_t src;
InputButton dst;
};
const glut_table glut_key_table[] = {
{ 0x1B, INPUT_BUTTON_ESCAPE },
{ '\b', INPUT_BUTTON_BACKSPACE },
{ '\t', INPUT_BUTTON_TAB },
{ '\r', INPUT_BUTTON_ENTER },
{ ' ', INPUT_BUTTON_SPACE },
{ 0x7F, INPUT_BUTTON_DELETE },
{ -1, INPUT_BUTTON_MAX },
};
const glut_table glut_skey_table[] = {
{ 1, INPUT_BUTTON_F1 },
{ 2, INPUT_BUTTON_F2 },
{ 3, INPUT_BUTTON_F3 },
{ 4, INPUT_BUTTON_F4 },
{ 5, INPUT_BUTTON_F5 },
{ 6, INPUT_BUTTON_F6 },
{ 7, INPUT_BUTTON_F7 },
{ 8, INPUT_BUTTON_F8 },
{ 9, INPUT_BUTTON_F9 },
{ 10, INPUT_BUTTON_F10 },
{ 11, INPUT_BUTTON_F11 },
{ 12, INPUT_BUTTON_F12 },
{ 100, INPUT_BUTTON_LEFT },
{ 101, INPUT_BUTTON_UP },
{ 102, INPUT_BUTTON_RIGHT },
{ 103, INPUT_BUTTON_DOWN },
{ 104, INPUT_BUTTON_PAGE_UP },
{ 105, INPUT_BUTTON_PAGE_DOWN },
{ 106, INPUT_BUTTON_HOME },
{ 107, INPUT_BUTTON_END },
{ 108, INPUT_BUTTON_INSERT },
{ -1, INPUT_BUTTON_MAX },
};
void glut_motion_cb(int32_t x, int32_t y);
static void glut_key_down(int32_t key, const glut_table* table);
static void glut_key_up(int32_t key, const glut_table* table);
static void glut_mouse_input_down(InputButton button);
static void glut_mouse_input_up(InputButton button);
static InputButton glut_translate_key(const glut_table* table, int32_t key);
void glut_get_modifiers() {
int32_t modifiers = 0x00;
if (GetKeyState(VK_SHIFT) & 0xFF00)
modifiers |= 0x01;
if (GetKeyState(VK_CONTROL) & 0xFF00)
modifiers |= 0x02;
if (GetKeyState(VK_MENU) & 0xFF00)
modifiers |= 0x04;
glut_modifiers = modifiers;
}
void glut_reset_modifiers() {
glut_modifiers = -1;
}
void glut_keydown_cb(uint8_t key, int32_t x, int32_t y) {
glut_key_down(key, glut_key_table);
glut_input.key = key;
}
void glut_keyup_cb(uint8_t key, int32_t x, int32_t y) {
glut_key_up(key, glut_key_table);
}
void glut_skeydown_cb(int32_t key, int32_t x, int32_t y) {
glut_key_down(key, glut_skey_table);
}
void glut_skeyup_cb(int32_t key, int32_t x, int32_t y) {
glut_key_up(key, glut_skey_table);
}
void glut_mouse_cb(int32_t bn, int32_t state, int32_t x, int32_t y) {
InputButton button = INPUT_BUTTON_MAX;
switch (bn) {
case 0:
button = INPUT_BUTTON_MOUSE_BUTTON_LEFT;
break;
case 1:
button = INPUT_BUTTON_MOUSE_BUTTON_MIDDLE;
break;
case 2:
button = INPUT_BUTTON_MOUSE_BUTTON_RIGHT;
break;
case 3:
glut_input.scroll_up++;
break;
case 4:
glut_input.scroll_down++;
break;
}
if (button != INPUT_BUTTON_MAX) {
switch (state) {
case 0:
glut_mouse_input_down(button);
break;
case 1:
glut_mouse_input_up(button);
break;
}
}
glut_mouse_input.update_modifiers(true);
glut_motion_cb(x, y);
}
void glut_motion_cb(int32_t x, int32_t y) {
resolution_struct res = *res_window_get();
glut_input.motion_x = x;
glut_input.motion_y = y;
glut_input.motion_x = clamp_def(glut_input.motion_x, 0, res.width - 1);
glut_input.motion_y = clamp_def(glut_input.motion_y, 0, res.height - 1);
}
static void glut_key_down(int32_t key, const glut_table* table) {
InputButton button = glut_translate_key(table, key);
if (button != INPUT_BUTTON_MAX) {
glut_key_input.tapped[button] = true;
glut_key_input.released[button] = false;
glut_key_input.down[button] = true;
if (!glut_key_input.down[INPUT_BUTTON_KEYBOARD_PRESS]) {
glut_key_input.tapped[INPUT_BUTTON_KEYBOARD_PRESS] = true;
glut_key_input.released[INPUT_BUTTON_KEYBOARD_PRESS] = false;
}
glut_key_input.down[INPUT_BUTTON_KEYBOARD_PRESS] = true;
}
glut_key_input.update_modifiers(true);
}
static void glut_key_up(int32_t key, const glut_table* table) {
InputButton button = glut_translate_key(table, key);
if (button != INPUT_BUTTON_MAX) {
glut_key_input.tapped[button] = false;
glut_key_input.released[button] = true;
glut_key_input.down[button] = false;
if (glut_key_input.down[INPUT_BUTTON_KEYBOARD_PRESS]) {
glut_key_input.tapped[INPUT_BUTTON_KEYBOARD_PRESS] = false;
glut_key_input.released[INPUT_BUTTON_KEYBOARD_PRESS] = true;
}
glut_key_input.down[INPUT_BUTTON_KEYBOARD_PRESS] = false;
}
glut_key_input.update_modifiers(true);
}
static void glut_mouse_input_down(InputButton button) {
glut_mouse_input.released[button] = false;
if (!glut_mouse_input.down[button])
glut_mouse_input.tapped[button] = true;
glut_mouse_input.down[button] = true;
}
static void glut_mouse_input_up(InputButton button) {
glut_mouse_input.tapped[button] = false;
if (glut_mouse_input.down[button])
glut_mouse_input.released[button] = true;
glut_mouse_input.down[button] = false;
}
static InputButton glut_translate_key(const glut_table* table, int32_t key) {
InputButton button = INPUT_BUTTON_MAX;
if (table == glut_key_table) {
if ((key - 'a') >= 0 && (key - 'a') <= ('z' - 'a'))
return (InputButton)(INPUT_BUTTON_A + (key - 'a')); // A - Z
else if ((key - 'A') >= 0 && (key - 'A') <= ('Z' - 'A'))
return (InputButton)(INPUT_BUTTON_A + (key - 'A')); // A - Z
else if ((key - '0') >= 0 && (key - '0') <= ('9' - '0'))
return (InputButton)(INPUT_BUTTON_0 + (key - '0')); // 0 - 9
}
while (table->src >= 0) {
if (table->src == key) {
button = table->dst;
break;
}
table++;
}
return button;
}
src/ReDIVA/input_state.hpp
+16 -1
View File
@@ -29,10 +29,24 @@ enum InputButton : int32_t {
INPUT_BUTTON_JVS_L,
INPUT_BUTTON_JVS_R,
INPUT_BUTTON_JVS_BUTTON_7,
INPUT_BUTTON_JVS_BUTTON_8,
INPUT_BUTTON_JVS_BUTTON_9,
INPUT_BUTTON_JVS_BUTTON_10,
INPUT_BUTTON_JVS_SW1 = 18,
INPUT_BUTTON_JVS_SW2,
INPUT_BUTTON_KEYBOARD_PRESS = 28,
INPUT_BUTTON_DIP_SW1,
INPUT_BUTTON_DIP_SW2,
INPUT_BUTTON_DIP_SW3,
INPUT_BUTTON_DIP_SW4,
INPUT_BUTTON_DIP_SW5,
INPUT_BUTTON_DIP_SW6,
INPUT_BUTTON_DIP_SW7,
INPUT_BUTTON_DIP_SW8,
INPUT_BUTTON_KEYBOARD_PRESS,
INPUT_BUTTON_0,
INPUT_BUTTON_1,
@@ -196,6 +210,7 @@ struct InputState {
extern void input_state_init();
extern void input_state_am_ctrl();
extern void input_state_pc_ctrl();
extern void input_state_ctrl();
extern const InputState* input_state_get(int32_t index);
extern void input_state_free();
src/ReDIVA/main.hpp
-1
View File
@@ -7,4 +7,3 @@
#include "../KKdLib/default.hpp"
#include "app.hpp"
#include "input.hpp"
src/ReDIVA/pv_game/pv_game.cpp
+10 -8
View File
@@ -21,7 +21,7 @@
#include "../am_data.hpp"
#include "../game_state.hpp"
#include "../imgui_helper.hpp"
#include "../input.hpp"
#include "../input_state.hpp"
#include "../mask_screen.hpp"
#include "../task_movie.hpp"
#include "../wait_screen.hpp"
@@ -4991,22 +4991,23 @@ void pv_game::sub_140104FB0() {
}
bool pv_game::sub_14010EF00() {
//InputState* input_state = input_state_get(0);
//const InputState* input_state = input_state_get(0);
if (!wrap_collection_get()->give_up.get_value())
return false;
/*bool v5 = task_slider_control_get()->sub_140618C20(38)
&& input_state->sub_14018D480(10) && input_state->sub_14018D480(7);
&& input_state->CheckDown(INPUT_BUTTON_JVS_CIRCLE)
&& input_state->CheckDown(INPUT_BUTTON_JVS_TRIANGLE);
switch (data.field_2DB34) {
case 0:
if (v5 && input_state->sub_14018D510(2)) {
if (v5 && input_state->CheckTapped(INPUT_BUTTON_JVS_START)) {
data.field_2DB34 = 1;
data.field_2DB38.get_timestamp();
data.field_2D0AC = sub_14010F930();
}
break;
case 1:
if (!v5 || !input_state->sub_14018D480(2)) {
if (!v5 || !input_state->CheckDown(INPUT_BUTTON_JVS_START)) {
sub_14010F030();
data.field_2DB34 = 0;
data.field_2D0AC = 0;
@@ -5315,12 +5316,13 @@ void TaskPvGame::window() {
if (data.type != 2 || pv_game_parent_data.outer_state != 1)
return;
if (Input::IsKeyTapped(GLFW_KEY_K, GLFW_MOD_CONTROL))
const InputState* input_state = input_state_get(0);
if (input_state->CheckTapped(INPUT_BUTTON_K) && input_state->CheckDown(INPUT_BUTTON_CONTROL))
pv_game_ptr->end_pv = true;
else if (Input::IsKeyTapped(GLFW_KEY_K))
else if (input_state->CheckTapped(INPUT_BUTTON_K))
pause ^= true;
if (Input::IsKeyTapped(GLFW_KEY_L)) {
if (input_state->CheckTapped(INPUT_BUTTON_L)) {
pause = true;
step_frame = true;
}
src/ReDIVA/x_pv_game.cpp
+5 -4
View File
@@ -55,7 +55,7 @@
#endif
#include "information/dw_console.hpp"
#include "imgui_helper.hpp"
#include "input.hpp"
#include "input_state.hpp"
#include "print_work.hpp"
#include <atomic>
@@ -8359,12 +8359,13 @@ void x_pv_game::window() {
if (state_old != 20)
return;
if (Input::IsKeyTapped(GLFW_KEY_K, GLFW_MOD_CONTROL))
const InputState* input_state = input_state_get(0);
if (input_state->CheckTapped(INPUT_BUTTON_K) && input_state->CheckDown(INPUT_BUTTON_CONTROL))
state_old = 21;
else if (Input::IsKeyTapped(GLFW_KEY_K))
else if (input_state->CheckTapped(INPUT_BUTTON_K))
pause ^= true;
if (Input::IsKeyTapped(GLFW_KEY_L)) {
if (input_state->CheckTapped(INPUT_BUTTON_L)) {
pause = true;
step_frame = true;
}