voxelcoreprojects/voxelcore
1
0
Fork 0
mirror of https://github.com/MihailRis/voxelcore.git synced 2026-10-09 21:11:50 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Fix mouse pos detect

Browse source
This commit is contained in:
Stepanov Igor 2025-10-05 02:51:05 +03:00
parent 2293f6f5fa
commit 433a2eae15
4 changed files with 264 additions and 165 deletions
Download patch file Download diff file Expand all files Collapse all files

161
src/window/detail/input_sdl.cpp
View file

@ -3,65 +3,119 @@
#include <SDL3/SDL.h>
#include <SDL3/SDL_clipboard.h>
#include <SDL3/SDL_events.h>
#include <SDL3/SDL_keyboard.h>
#include <SDL3/SDL_keycode.h>
#include <SDL3/SDL_mouse.h>
#include <unordered_map>
#include "debug/Logger.hpp"
#include "window/input.hpp"
static debug::Logger logger("input");
std::string input_util::to_string(Keycode code) {
return {};
int icode_repr = static_cast<int>(code);
const char* name = SDL_GetKeyName(icode_repr);
logger.info() << icode_repr << ": " << name;
return std::string(name);
}
Keycode input_util::keycode_from(const std::string& name) {
logger.info() << name << ": " << SDL_GetKeyFromName(name.c_str());
return static_cast<Keycode>(SDL_GetKeyFromName(name.c_str()));
}
input_sdl::input_sdl() {
input_util::initialize();
}
void input_sdl::pollEvents() {
/* static */ SDL_Event event;
delta.x = 0.0f;
delta.y = 0.0f;
scroll = 0;
currentFrame++;
codepoints.clear();
pressedKeys.clear();
bool prevPressed = false;
static SDL_Event event;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_EVENT_QUIT:
break;
case SDL_EVENT_KEY_DOWN:
logger.info() << "Keyboard button: " << event.key.key;
if (event.key.key >= keys_buffer_size) {
// Win key return 1073742051
break;
}
prevPressed = keys[event.key.key];
keys[event.key.key] = true;
frames[event.key.key] = currentFrame;
if (!prevPressed) {
keyCallbacks[static_cast<Keycode>(event.key.key)].notify();
}
pressedKeys.push_back(static_cast<Keycode>(event.key.key));
break;
case SDL_EVENT_KEY_UP:
if (event.key.key >= keys_buffer_size) {
// Win key return 1073742051
break;
}
keys[event.key.key] = false;
frames[event.key.key] = currentFrame;
break;
case SDL_EVENT_MOUSE_BUTTON_DOWN:
prevPressed = keys[event.button.button + mouse_keys_offset];
keys[event.button.button + mouse_keys_offset] = true;
frames[event.button.button + mouse_keys_offset] = currentFrame;
if (!prevPressed) {
keyCallbacks[static_cast<Keycode>(
event.button.button + mouse_keys_offset
)]
.notify();
}
break;
case SDL_EVENT_MOUSE_BUTTON_UP:
keys[event.button.button + mouse_keys_offset] = false;
frames[event.button.button + mouse_keys_offset] = currentFrame;
break;
case SDL_EVENT_MOUSE_MOTION:
cursor = {event.motion.x, event.motion.y};
delta = {event.motion.xrel, event.motion.yrel};
break;
}
}
// delta.x = 0.0f;
// delta.y = 0.0f;
// scroll = 0;
// currentFrame++;
// codepoints.clear();
// pressedKeys.clear();
// glfwPollEvents();
for (auto& [_, binding] : bindings.getAll()) {
if (!binding.enabled) {
binding.state = false;
continue;
}
binding.justChanged = false;
// for (auto& [_, binding] : bindings.getAll()) {
// if (!binding.enabled) {
// binding.state = false;
// continue;
// }
// binding.justChanged = false;
bool newstate = false;
switch (binding.type) {
case InputType::KEYBOARD:
newstate = pressed(static_cast<Keycode>(binding.code));
break;
case InputType::MOUSE:
newstate = clicked(static_cast<Mousecode>(binding.code));
break;
}
// bool newstate = false;
// switch (binding.type) {
// case InputType::KEYBOARD:
// newstate = pressed(static_cast<Keycode>(binding.code));
// break;
// case InputType::MOUSE:
// newstate = clicked(static_cast<Mousecode>(binding.code));
// break;
// }
// if (newstate) {
// if (!binding.state) {
// binding.state = true;
// binding.justChanged = true;
// binding.onactived.notify();
// }
// } else {
// if (binding.state) {
// binding.state = false;
// binding.justChanged = true;
// }
// }
// }
if (newstate) {
if (!binding.state) {
binding.state = true;
binding.justChanged = true;
binding.onactived.notify();
}
} else {
if (binding.state) {
binding.state = false;
binding.justChanged = true;
}
}
}
}
const char* input_sdl::getClipboardText() const {
@ -73,29 +127,38 @@ void input_sdl::setClipboardText(const char* text) {
}
int input_sdl::getScroll() {
return {};
return scroll;
}
bool input_sdl::pressed(Keycode key) const {
return {};
int keycode = static_cast<int>(key);
if (keycode < 0 || keycode >= keys_buffer_size) {
return false;
}
if (keys[keycode]) logger.info() << "lol";
return keys[keycode];
}
bool input_sdl::jpressed(Keycode keycode) const {
return {};
return pressed(keycode) &&
frames[static_cast<int>(keycode)] == currentFrame;
}
bool input_sdl::clicked(Mousecode code) const {
return {};
return pressed(
static_cast<Keycode>(mouse_keys_offset + static_cast<int>(code))
);
}
bool input_sdl::jclicked(Mousecode code) const {
return {};
return clicked(code) &&
frames[static_cast<int>(code) + mouse_keys_offset] == currentFrame;
}
CursorState input_sdl::getCursor() const {
return {isCursorLocked(), {}, {}};
return {isCursorLocked(), cursor, delta};
}
bool input_sdl::isCursorLocked() const {
return {};
return cursorLocked;
}
void input_sdl::toggleCursor() {
@ -117,7 +180,7 @@ const Bindings& input_sdl::getBindings() const {
}
ObserverHandler input_sdl::addKeyCallback(Keycode key, KeyCallback callback) {
return {};
return keyCallbacks[key].add(std::move(callback));
}
const std::vector<Keycode>& input_sdl::getPressedKeys() const {

15
src/window/detail/input_sdl.hpp
View file

@ -1,9 +1,15 @@
#include <SDL3/SDL_keycode.h>
#include "window/input.hpp"
#include "window/window.hpp"
struct SDL_Window;
class input_sdl final : public Input {
public:
inline static constexpr short keys_buffer_size = 1036;
inline static constexpr short mouse_keys_offset = 1024;
input_sdl();
void pollEvents() override;
@ -33,7 +39,16 @@ public:
const std::vector<Keycode>& getPressedKeys() const override;
const std::vector<uint>& getCodepoints() const override;
private:
glm::vec2 delta;
glm::vec2 cursor;
std::int32_t scroll = 0;
std::uint32_t currentFrame = 0;
std::uint32_t frames[keys_buffer_size] {};
bool keys[keys_buffer_size] {};
bool cursorLocked = false;
bool cursorDrag = false;
Bindings bindings;
std::vector<uint> codepoints;
std::vector<Keycode> pressedKeys;
std::unordered_map<Keycode, util::HandlersList<>> keyCallbacks;
};