PulseStudio/VoxelEngine
PulseStudio/VoxelEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Merge pull request #74 from QuFlax/my

Browse Source 
Fix and Optimize Events
This commit is contained in:
MihailRis 2023-12-27 18:07:58 +03:00 committed by GitHub
commit e8d882c32e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 69 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/files/WorldFiles.cpp
View File

@ -454,8 +454,8 @@ void WorldFiles::writePlayer(Player* player){
posarr.put(position.z);
json::JArray& rotarr = root.putArray("rotation");
rotarr.put(player->camX);
rotarr.put(player->camY);
rotarr.put(player->cam.x);
rotarr.put(player->cam.y);
root.put("flight", player->flight);
root.put("noclip", player->noclip);
@ -479,8 +479,8 @@ bool WorldFiles::readPlayer(Player* player) {
player->camera->position = position;
json::JArray* rotarr = root->arr("rotation");
player->camX = rotarr->num(0);
player->camY = rotarr->num(1);
player->cam.x = rotarr->num(0);
player->cam.y = rotarr->num(1);
root->flag("flight", player->flight);
root->flag("noclip", player->noclip);

12
src/frontend/gui/GUI.cpp
View File

@ -40,10 +40,8 @@ PagesControl* GUI::getMenu() {
}
void GUI::actMouse(float delta) {
int mx = Events::x;
int my = Events::y;
auto hover = container->getAt(vec2(mx, my), nullptr);
auto hover = container->getAt(Events::cursor, nullptr);
if (this->hover && this->hover != hover) {
this->hover->hover(false);
}
@ -58,7 +56,7 @@ void GUI::actMouse(float delta) {
if (Events::jclicked(0)) {
if (pressed == nullptr && this->hover) {
pressed = hover;
pressed->click(this, mx, my);
pressed->click(this, Events::cursor.x, Events::cursor.y);
if (focus && focus != pressed) {
focus->defocus();
}
@ -72,7 +70,7 @@ void GUI::actMouse(float delta) {
focus = nullptr;
}
} else if (pressed) {
pressed->mouseRelease(this, mx, my);
pressed->mouseRelease(this, Events::cursor.x, Events::cursor.y);
pressed = nullptr;
}
}
@ -100,9 +98,7 @@ void GUI::act(float delta) {
if (!Events::_cursor_locked) {
if (Events::clicked(mousecode::BUTTON_1)) {
int mx = Events::x;
int my = Events::y;
focus->mouseMove(this, mx, my);
focus->mouseMove(this, Events::cursor.x, Events::cursor.y);
}
if (prevfocus == focus){
for (int i = mousecode::BUTTON_1; i < mousecode::BUTTON_1+12; i++) {

4
src/frontend/hud.cpp
View File

@ -229,8 +229,8 @@ void HudRenderer::drawContentAccess(const GfxContext& ctx, Player* player) {
int ys = inv_y + pad_y;
vec4 tint = vec4(1.0f);
int mx = Events::x;
int my = Events::y;
int mx = Events::cursor.x;
int my = Events::cursor.y;
// background
batch->texture(nullptr);

28
src/logic/PlayerController.cpp
View File

@ -41,28 +41,22 @@ void CameraControl::refresh() {
}
void CameraControl::updateMouse(PlayerInput& input) {
float sensitivity = settings.sensitivity;
float rotX = -Events::deltaX / Window::height * sensitivity;
float rotY = -Events::deltaY / Window::height * sensitivity;
glm::vec2 &cam = player->cam;
if (input.zoom) {
cam += -Events::delta / (float)Window::height * settings.sensitivity / 4.f;
} else {
cam += -Events::delta / (float)Window::height * settings.sensitivity;
}
if (input.zoom){
rotX /= 4;
rotY /= 4;
if (cam.y < -glm::radians(89.9f)) {
cam.y = -glm::radians(89.9f);
}
float& camX = player->camX;
float& camY = player->camY;
camX += rotX;
camY += rotY;
if (camY < -glm::radians(89.9f)){
camY = -glm::radians(89.9f);
}
if (camY > glm::radians(89.9f)){
camY = glm::radians(89.9f);
if (cam.y > glm::radians(89.9f)) {
cam.y = glm::radians(89.9f);
}
camera->rotation = glm::mat4(1.0f);
camera->rotate(camY, camX, 0);
camera->rotate(cam.y, cam.x, 0);
}
void CameraControl::update(PlayerInput& input, float delta, Chunks* chunks) {

3
src/objects/Player.h
View File

@ -38,8 +38,7 @@ public:
int chosenBlock;
voxel selectedVoxel {0, 0};
float camX = 0.0f;
float camY = 0.0f;
glm::vec2 cam = {};
Player(glm::vec3 position, float speed);
~Player();

59
src/window/Events.cpp
View File

@ -4,42 +4,22 @@
#include <GLFW/glfw3.h>
#include <string.h>
const short KEYS_BUFFER_SIZE = 1032;
const short _MOUSE_KEYS_OFFSET = 1024;
bool* Events::_keys;
uint* Events::_frames;
bool Events::_keys[KEYS_BUFFER_SIZE] = {};
uint Events::_frames[KEYS_BUFFER_SIZE] = {};
uint Events::_current = 0;
float Events::deltaX = 0.0f;
float Events::deltaY = 0.0f;
float Events::x = 0.0f;
float Events::y = 0.0f;
int Events::scroll = 0;
glm::vec2 Events::delta = {};
glm::vec2 Events::cursor = {};
bool Events::cursor_drag = false;
bool Events::_cursor_locked = false;
bool Events::_cursor_started = false;
std::vector<uint> Events::codepoints;
std::vector<int> Events::pressedKeys;
std::unordered_map<std::string, Binding> Events::bindings;
int Events::initialize(){
_keys = new bool[KEYS_BUFFER_SIZE];
_frames = new uint[KEYS_BUFFER_SIZE];
memset(_keys, false, KEYS_BUFFER_SIZE*sizeof(bool));
memset(_frames, 0, KEYS_BUFFER_SIZE*sizeof(uint));
return 0;
}
void Events::finalize(){
delete[] _keys;
delete[] _frames;
}
// Returns bool repr. of key state
bool Events::pressed(int keycode){
if (keycode < 0 || keycode >= KEYS_BUFFER_SIZE){
// VERY bad behaviour and it happens constantly! (so console-printing is not a good idea)
bool Events::pressed(int keycode) {
if (keycode < 0 || keycode >= KEYS_BUFFER_SIZE) {
fprintf(stderr, "pressed %i\n", keycode);
return false;
}
return _keys[keycode];
@ -67,8 +47,8 @@ void Events::toggleCursor(){
void Events::pollEvents(){
_current++;
deltaX = 0.0f;
deltaY = 0.0f;
delta.x = 0.f;
delta.y = 0.f;
scroll = 0;
codepoints.clear();
pressedKeys.clear();
@ -117,3 +97,22 @@ bool Events::jactive(std::string name) {
}
return found->second.jactive();
}
void Events::setKey(int key, bool b) {
Events::_keys[key] = b;
Events::_frames[key] = Events::_current;
}
void Events::setButton(int button, bool b) {
setKey(_MOUSE_KEYS_OFFSET + button, b);
}
void Events::setPosition(float xpos, float ypos) {
if (Events::cursor_drag) {
Events::delta.x += xpos - Events::cursor.x;
Events::delta.y += ypos - Events::cursor.y;
} else
Events::cursor_drag = true;
Events::cursor.x = xpos;
Events::cursor.y = ypos;
}

25
src/window/Events.h
View File

@ -10,27 +10,23 @@
typedef unsigned int uint;
extern const short KEYS_BUFFER_SIZE;
extern const short _MOUSE_KEYS_OFFSET;
const short KEYS_BUFFER_SIZE = 1036;
const short _MOUSE_KEYS_OFFSET = 1024;
class Events {
public:
static bool* _keys;
static uint* _frames;
static bool _keys[KEYS_BUFFER_SIZE];
static uint _frames[KEYS_BUFFER_SIZE];
static uint _current;
static float deltaX;
static float deltaY;
static float x;
static float y;
static int scroll;
static int scroll;
static glm::vec2 delta;
static glm::vec2 cursor;
static bool cursor_drag;
static bool _cursor_locked;
static bool _cursor_started;
static std::vector<uint> codepoints;
static std::vector<int> pressedKeys;
static std::unordered_map<std::string, Binding> bindings;
static int initialize();
static void finalize();
static void pollEvents();
static bool pressed(int keycode);
@ -44,6 +40,11 @@ public:
static void bind(std::string name, inputtype type, int code);
static bool active(std::string name);
static bool jactive(std::string name);
static void setKey(int key, bool b);
static void setButton(int button, bool b);
static void setPosition(float xpos, float ypos);
};
#endif /* WINDOW_EVENTS_H_ */

34
src/window/Window.cpp
View File

@ -21,42 +21,21 @@ int Window::posX = 0;
int Window::posY = 0;
void cursor_position_callback(GLFWwindow*, double xpos, double ypos) {
if (Events::_cursor_started) {
Events::deltaX += xpos - Events::x;
Events::deltaY += ypos - Events::y;
}
else {
Events::_cursor_started = true;
}
Events::x = xpos;
Events::y = ypos;
Events::setPosition(xpos, ypos);
}
void mouse_button_callback(GLFWwindow*, int button, int action, int) {
if (action == GLFW_PRESS) {
// Unsafe assignments! (no checks)
Events::_keys[_MOUSE_KEYS_OFFSET + button] = true;
Events::_frames[_MOUSE_KEYS_OFFSET + button] = Events::_current;
}
else if (action == GLFW_RELEASE) {
// Unsafe assignments! (no checks)
Events::_keys[_MOUSE_KEYS_OFFSET + button] = false;
Events::_frames[_MOUSE_KEYS_OFFSET + button] = Events::_current;
}
Events::setButton(button, action == GLFW_PRESS);
}
void key_callback(GLFWwindow*, int key, int scancode, int action, int /*mode*/) {
if (key == GLFW_KEY_UNKNOWN) return;
if (action == GLFW_PRESS) {
// Unsafe assignments! (no checks)
Events::_keys[key] = true;
Events::_frames[key] = Events::_current;
Events::setKey(key, true);
Events::pressedKeys.push_back(key);
}
else if (action == GLFW_RELEASE) {
// Unsafe assignments! (no checks)
Events::_keys[key] = false;
Events::_frames[key] = Events::_current;
Events::setKey(key, false);
}
else if (action == GLFW_REPEAT) {
Events::pressedKeys.push_back(key);
@ -163,7 +142,6 @@ int Window::initialize(DisplaySettings& settings){
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
Events::initialize();
glfwSetKeyCallback(window, key_callback);
glfwSetMouseButtonCallback(window, mouse_button_callback);
glfwSetCursorPosCallback(window, cursor_position_callback);
@ -255,7 +233,6 @@ void Window::popScissor() {
}
void Window::terminate(){
Events::finalize();
glfwTerminate();
}
@ -290,8 +267,7 @@ void Window::toggleFullscreen(){
double xPos, yPos;
glfwGetCursorPos(window, &xPos, &yPos);
Events::x = xPos;
Events::y = yPos;
Events::setPosition(xPos, yPos);
}
bool Window::isFullscreen() {