window and input moved to gaming core

client/Game.cpp

@@ -1,8 +1,10 @@
 #include "client/Game.h"
 #include "gaming-core/utils/Utils.h"
 
-Game::Game(const Control& control, const Clock& fps, const Clock& tps, RenderSettings& settings, const Size& size) :
+Game::Game(const Controller& controller, const Clock& fps, const Clock& tps,
-control(control), fps(fps), tps(tps), renderSettings(settings), size(size), world(blockRegistry), worldRenderer(world) {
+        RenderSettings& settings, const Size& size) :
+controller(controller), fps(fps), tps(tps), renderSettings(settings), size(size),
+world(blockRegistry), worldRenderer(world) {
     pos = Vector3(16.0f, 24.0f, 0.0f);
 }
 
@@ -15,36 +17,36 @@ void Game::tick() {
     Vector3 back = rotation * Vector3(0.0f, 0.0f, -1.0f);
 
     const float speed = 1.0f;
-    if(control.keys.down.isDown()) {
+    if(controller.down.isDown()) {
         pos += back * speed;
     }
-    if(control.keys.up.isDown()) {
+    if(controller.up.isDown()) {
         pos -= back * speed;
     }
-    if(control.keys.left.isDown()) {
+    if(controller.left.isDown()) {
         pos -= right * speed;
     }
-    if(control.keys.right.isDown()) {
+    if(controller.right.isDown()) {
         pos += right * speed;
     }
-    if(control.keys.jump.isDown()) {
+    if(controller.jump.isDown()) {
         pos += up * speed;
     }
-    if(control.keys.sneak.isDown()) {
+    if(controller.sneak.isDown()) {
         pos -= up * speed;
     }
 
     const float rotationSpeed = 5.0f;
-    if(control.keys.camLeft.isDown()) {
+    if(controller.camLeft.isDown()) {
         rotation = Quaternion(up, -rotationSpeed) * rotation;
     }
-    if(control.keys.camRight.isDown()) {
+    if(controller.camRight.isDown()) {
         rotation = Quaternion(up, rotationSpeed) * rotation;
     }
-    if(control.keys.camUp.isDown()) {
+    if(controller.camUp.isDown()) {
         rotation = Quaternion(right, -rotationSpeed) * rotation;
     }
-    if(control.keys.camDown.isDown()) {
+    if(controller.camDown.isDown()) {
         rotation = Quaternion(right, rotationSpeed) * rotation;
     }
 }

client/Game.h

@@ -1,7 +1,7 @@
 #ifndef GAME_H
 #define GAME_H
 
-#include "client/input/Control.h"
+#include "client/input/Controller.h"
 #include "gaming-core/utils/Clock.h"
 #include "client/rendering/RenderSettings.h"
 #include "client/rendering/Renderer.h"
@@ -13,7 +13,7 @@
 
 class Game final {
 public:
-    Game(const Control& control, const Clock& fps, const Clock& tps, RenderSettings& renderSettings, const Size& size);
+    Game(const Controller& controller, const Clock& fps, const Clock& tps, RenderSettings& renderSettings, const Size& size);
 
     void tick();
     void renderWorld(float lag, Renderer& renderer);
@@ -23,7 +23,7 @@ public:
     bool isRunning() const;
 
 private:
-    const Control& control;
+    const Controller& controller;
     const Clock& fps;
     const Clock& tps;
     RenderSettings& renderSettings;

client/Main.cpp

@@ -3,89 +3,71 @@
 #include "gaming-core/wrapper/GLFW.h"
 #include "gaming-core/wrapper/GL.h"
 #include "gaming-core/wrapper/GLEW.h"
-#include "gaming-core/utils/Size.h"
+#include "gaming-core/wrapper/Window.h"
-#include "client/rendering/wrapper/Window.h"
 #include "client/rendering/Shaders.h"
 #include "client/rendering/Framebuffers.h"
-#include "client/input/Control.h"
+#include "client/input/Controller.h"
 #include "client/rendering/Engine.h"
 #include "gaming-core/utils/Clock.h"
 #include "client/rendering/RenderSettings.h"
+#include "gaming-core/wrapper/WindowOptions.h"
 
-void initCallbacks(Window& w, Size& size, Framebuffers& framebuffers, Control& control) {
+void updateSize(const Window& window, Size& size, Framebuffers& framebuffers) {
-    static Size& cSize = size;
+    Size newSize = window.getSize();
-    static Framebuffers& cFramebuffers = framebuffers;
+    if(newSize.width != size.width || newSize.height != size.height) {
-    static Control& cControl = control;
+        size = newSize;
-    w.setFramebufferSizeCallback([](GLFWwindow*, int newWidth, int newHeight) {
+        GL::setViewport(size.width, size.height);
-        glViewport(0, 0, newWidth, newHeight);
+        framebuffers.resize(size);
-        cSize.width = newWidth;
+    }
-        cSize.height = newHeight;
-        cFramebuffers.resize(newWidth, newHeight);
-    });
-    w.setKeyCallback([](GLFWwindow*, int key, int, int action, int) {
-        if(action == GLFW_PRESS) {
-            cControl.keys.press(key);
-        } else if(action == GLFW_RELEASE) {
-            cControl.keys.release(key);
-        }
-    });
-    w.setMouseButtonCallback([](GLFWwindow*, int button, int action, int) {
-        if(action == GLFW_PRESS) {
-            cControl.buttons.press(button);
-        } else if(action == GLFW_RELEASE) {
-            cControl.buttons.release(button);
-        }
-    });
-    w.setCursorPosCallback([](GLFWwindow*, double x, double y) {
-        cControl.buttons.move(x, y);
-    });
 }
 
 int main() {
     if(GLFW::init()) {
         return 0;
     }
-    
+
     Size size(1024, 620);
-    Window window(size, "Test");
+    WindowOptions options(4, 0, size, false, "test");
+    Window window(options);
     if(window.hasError() || GLEW::init()) {
         return 0;
     }
-    
+
     Shaders shaders;
     if(shaders.hasError()) {
         return 0;
     }
-    
+
     Framebuffers framebuffers(size);
     if(framebuffers.hasError()) {
         return 0;
     }
-    
+
     RenderSettings renderSettings;
     Engine engine(shaders, framebuffers, size, renderSettings);
-    
+
-    Control control;
+    Buttons buttons(window);
+    Controller controller(buttons);
     Clock fps;
     Clock tps;
-    static Game game(control, fps, tps, renderSettings, size);
+    static Game game(controller, fps, tps, renderSettings, size);
 
-    initCallbacks(window, size, framebuffers, control);
     window.show();
-    
+
     GL::checkAndPrintError("setup error");
 
     const Clock::Nanos nanosPerTick = 50000000;
     Clock::Nanos lag = 0;
     while(!window.shouldClose() && game.isRunning()) {
         GL::checkAndPrintError("loop error");
+        updateSize(window, size, framebuffers);
         engine.renderTick(static_cast<float> (lag) / nanosPerTick, game);
         window.swapBuffers();
         lag += fps.update();
         while(lag >= nanosPerTick) {
             lag -= nanosPerTick;
             tps.update();
-            control.tick();
+            buttons.tick();
             game.tick();
         }
         glfwPollEvents();

client/input/Control.cpp

@@ -1,6 +0,0 @@
-#include "client/input/Control.h"
-
-void Control::tick() {
-    keys.tick();
-    buttons.tick();
-}

client/input/Control.h

@@ -1,14 +0,0 @@
-#ifndef CONTROL_H
-#define CONTROL_H
-
-#include "client/input/Keys.h"
-#include "client/input/MouseButtons.h"
-
-struct Control final {
-    void tick();
-    
-    Keys keys;
-    MouseButtons buttons;
-};
-
-#endif

client/input/Controller.cpp

@@ -0,0 +1,16 @@
+#include "client/input/Controller.h"
+
+Controller::Controller(Buttons& b) : list(b.get()), left(b.add(GLFW_KEY_A, "Left")), right(b.add(GLFW_KEY_D, "Right")),
+up(b.add(GLFW_KEY_W, "X")), down(b.add(GLFW_KEY_S, "Y")), jump(b.add(GLFW_KEY_SPACE, "L")),
+sneak(b.add(GLFW_KEY_LEFT_SHIFT, "R")), camLeft(b.add(GLFW_KEY_LEFT, "Start")),
+camRight(b.add(GLFW_KEY_RIGHT, "Select")), camUp(b.add(GLFW_KEY_UP, "Left")), camDown(b.add(GLFW_KEY_DOWN, "Right")) {
+    b.mapGamepadAxis(left, -0.5f, GLFW_GAMEPAD_AXIS_LEFT_X);
+    b.mapGamepadAxis(right, 0.5f, GLFW_GAMEPAD_AXIS_LEFT_X);
+    b.mapGamepadAxis(up, -0.5f, GLFW_GAMEPAD_AXIS_LEFT_Y);
+    b.mapGamepadAxis(down, 0.5f, GLFW_GAMEPAD_AXIS_LEFT_Y);
+    
+    b.mapGamepadAxis(camUp, -0.5f, GLFW_GAMEPAD_AXIS_RIGHT_Y);
+    b.mapGamepadAxis(camDown, 0.5f, GLFW_GAMEPAD_AXIS_RIGHT_Y);
+    b.mapGamepadAxis(camLeft, -0.5f, GLFW_GAMEPAD_AXIS_RIGHT_X);
+    b.mapGamepadAxis(camRight, 0.5f, GLFW_GAMEPAD_AXIS_RIGHT_X);
+}

client/input/Controller.h

@@ -0,0 +1,22 @@
+#ifndef CONTROLLER_H
+#define CONTROLLER_H
+
+#include "gaming-core/input/Buttons.h"
+
+struct Controller {
+    const ButtonList& list;
+    const Button& left;
+    const Button& right;
+    const Button& up;
+    const Button& down;
+    const Button& jump;
+    const Button& sneak;
+    const Button& camLeft;
+    const Button& camRight;
+    const Button& camUp;
+    const Button& camDown;
+
+    Controller(Buttons& buttons);
+};
+
+#endif

client/input/Keys.cpp

@@ -1,73 +0,0 @@
-#include <GLFW/glfw3.h>
-
-#include "client/input/Keys.h"
-
-Keys::Key::Key() : down(false), shouldRelease(false), downTime(0) {
-}
-
-bool Keys::Key::isDown() const {
-    return down;
-}
-
-bool Keys::Key::isReleased() const {
-    return shouldRelease;
-}
-
-int Keys::Key::getDownTime() const {
-    return downTime;
-}
-
-std::ostream& operator<<(std::ostream& os, const Keys::Key& k) {
-    os << "Key(down: " << k.isDown() << ", release: " << k.isReleased() <<
-            ", time: " << k.getDownTime() << ")";
-    return os;
-}
-
-Keys::Keys() : left(keys[0]), right(keys[1]), up(keys[2]), down(keys[3]), jump(keys[4]), sneak(keys[5]),
-camLeft(keys[6]), camRight(keys[7]), camUp(keys[8]), camDown(keys[9]), test(keys[10]), test2(keys[11]), test3(keys[12]),
-test4(keys[13]), test5(keys[14]), test6(keys[15]), factor(keys[16]), kdTree(keys[17]) {
-    keys[0].glfwKey = GLFW_KEY_A;
-    keys[1].glfwKey = GLFW_KEY_D;
-    keys[2].glfwKey = GLFW_KEY_W;
-    keys[3].glfwKey = GLFW_KEY_S;
-    keys[4].glfwKey = GLFW_KEY_SPACE;
-    keys[5].glfwKey = GLFW_KEY_LEFT_SHIFT;
-    keys[6].glfwKey = GLFW_KEY_LEFT;
-    keys[7].glfwKey = GLFW_KEY_RIGHT;
-    keys[8].glfwKey = GLFW_KEY_UP;
-    keys[9].glfwKey = GLFW_KEY_DOWN;
-    keys[10].glfwKey = GLFW_KEY_R;
-    keys[11].glfwKey = GLFW_KEY_T;
-    keys[12].glfwKey = GLFW_KEY_Y;
-    keys[13].glfwKey = GLFW_KEY_G;
-    keys[14].glfwKey = GLFW_KEY_H;
-    keys[15].glfwKey = GLFW_KEY_U;
-    keys[16].glfwKey = GLFW_KEY_F;
-    keys[17].glfwKey = GLFW_KEY_K;
-}
-
-void Keys::release(int key) {
-    for(Key& k : keys) {
-        if(k.glfwKey == key) {
-            k.shouldRelease = true;
-        }
-    }
-}
-
-void Keys::press(int key) {
-    for(Key& k : keys) {
-        if(k.glfwKey == key) {
-            k.down = true;
-            k.shouldRelease = false;
-        }
-    }
-}
-
-void Keys::tick() {
-    for(Key& k : keys) {
-        k.downTime += k.down;
-        k.down = k.down && !k.shouldRelease;
-        k.downTime *= !k.shouldRelease;
-        k.shouldRelease = false;
-    }
-}

client/input/Keys.h

@@ -1,68 +0,0 @@
-#ifndef KEYS_H
-#define KEYS_H
-
-#include <iostream>
-#include <array>
-
-class Keys final {
-public:
-
-    class Key final {
-    public:
-        friend class Keys;
-
-        bool isDown() const;
-        bool isReleased() const;
-        int getDownTime() const;
-
-    private:
-        Key();
-        Key(const Key&) = delete;
-        Key(Key&&) = delete;
-        Key& operator=(const Key&) = delete;
-        Key& operator=(Key&&) = delete;
-
-        int glfwKey;
-        bool down;
-        bool shouldRelease;
-        int downTime;
-    };
-
-private:
-    Key keys[18];
-
-public:
-    Keys();
-    const Key& left;
-    const Key& right;
-    const Key& up;
-    const Key& down;
-    const Key& jump;
-    const Key& sneak;
-    const Key& camLeft;
-    const Key& camRight;
-    const Key& camUp;
-    const Key& camDown;
-    const Key& test;
-    const Key& test2;
-    const Key& test3;
-    const Key& test4;
-    const Key& test5;
-    const Key& test6;
-    const Key& factor;
-    const Key& kdTree;
-
-    void release(int key);
-    void press(int key);
-    void tick();
-
-private:
-    Keys(const Keys&) = delete;
-    Keys& operator=(const Keys&) = delete;
-    Keys(Key&&) = delete;
-    Keys& operator=(Keys&&) = delete;
-};
-
-std::ostream& operator<<(std::ostream& os, const Keys::Key& k);
-
-#endif

client/rendering/Engine.cpp

@@ -1,6 +1,3 @@
-#include <cmath>
-#include <cfloat>
-
 #include "client/rendering/Engine.h"
 #include "gaming-core/wrapper/GL.h"
 #include "client/rendering/Renderer.h"
@@ -94,7 +91,8 @@ void Engine::renderSSAO() {
 }
 
 void Engine::renderPostWorld() {
-    GL::prepareMainFramebuffer();
+    GL::bindMainFramebuffer();
+    GL::clearFramebuffer();
     shaders.postWorld.use();
     framebuffers.world.bindColorTexture(0);
     framebuffers.ssaoBlur.bindRedTexture(1);

client/rendering/Framebuffers.cpp

@@ -7,11 +7,11 @@ ssaoBlur(size, Framebuffer::RED),
 shadow(size, Framebuffer::DEPTH) {
 }
 
-void Framebuffers::resize(int width, int height) {
+void Framebuffers::resize(const Size& size) {
-    world.resize(width, height);
+    world.resize(size);
-    ssao.resize(width, height);
+    ssao.resize(size);
-    ssaoBlur.resize(width, height);
+    ssaoBlur.resize(size);
-    shadow.resize(width, height);
+    shadow.resize(size);
 }
 
 bool Framebuffers::hasError() const {

client/rendering/Framebuffers.h

@@ -6,7 +6,7 @@
 
 struct Framebuffers final {
     Framebuffers(const Size& size);
-    void resize(int width, int height);
+    void resize(const Size& size);
     bool hasError() const;
 
     Framebuffer world;

client/rendering/wrapper/Framebuffer.cpp

@@ -17,11 +17,11 @@ buffer(0), error(false) {
     int counter = 0;
     for(int i = 0; i < 4; i++) {
         if(mode & data[i].mask) {
-            setupTexture(i, size.width, size.height, attachments, counter);
+            setupTexture(i, size, attachments, counter);
         }
     }
     if(mode & DEPTH) {
-        genTexture(4, size.width, size.height);
+        genTexture(4, size);
         if(texCompare) {
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
@@ -54,11 +54,12 @@ void Framebuffer::bind() const {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 }
 
-void Framebuffer::resize(int width, int height) const {
+void Framebuffer::resize(const Size& size) const {
     for(int i = 0; i < 5; i++) {
         if(mode & data[i].mask) {
             glBindTexture(GL_TEXTURE_2D, textures[i]);
-            glTexImage2D(GL_TEXTURE_2D, 0, data[i].internalFormat, width, height, 0, data[i].format, data[i].type, nullptr);
+            glTexImage2D(GL_TEXTURE_2D, 0, data[i].internalFormat, 
+                    size.width, size.height, 0, data[i].format, data[i].type, nullptr);
         }
     }
 }
@@ -88,18 +89,19 @@ void Framebuffer::bindDepthTexture(int textureUnit) const {
     bindTexture(textureUnit, textures[4]);
 }
 
-void Framebuffer::genTexture(int index, int width, int height) {
+void Framebuffer::genTexture(int index, const Size& size) {
     glGenTextures(1, &(textures[index]));
     glBindTexture(GL_TEXTURE_2D, textures[index]);
-    glTexImage2D(GL_TEXTURE_2D, 0, data[index].internalFormat, width, height, 0, data[index].format, data[index].type, nullptr);
+    glTexImage2D(GL_TEXTURE_2D, 0, data[index].internalFormat, 
+            size.width, size.height, 0, data[index].format, data[index].type, nullptr);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 }
 
-void Framebuffer::setupTexture(int index, int width, int height, GLuint* attachments, int& counter) {
+void Framebuffer::setupTexture(int index, const Size& size, GLuint* attachments, int& counter) {
-    genTexture(index, width, height);
+    genTexture(index, size);
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + counter, GL_TEXTURE_2D, textures[index], 0);
     attachments[counter] = GL_COLOR_ATTACHMENT0 + counter;
     counter++;

client/rendering/wrapper/Framebuffer.h

@@ -24,7 +24,7 @@ public:
     bool hasError() const;
     void bind() const;
 
-    void resize(int width, int height) const;
+    void resize(const Size& size) const;
 
     void bindPositionTexture(int textureUnit) const;
     void bindNormalTexture(int textureUnit) const;
@@ -33,8 +33,8 @@ public:
     void bindDepthTexture(int textureUnit) const;
 
 private:
-    void genTexture(int index, int width, int height);
+    void genTexture(int index, const Size& size);
-    void setupTexture(int index, int width, int height, GLuint* attachments, int& counter);
+    void setupTexture(int index, const Size& size, GLuint* attachments, int& counter);
     void bindTexture(int textureUnit, GLuint texture) const;
     const char* getErrorString(GLenum error) const;
 

client/rendering/wrapper/Window.cpp

@@ -1,61 +0,0 @@
-#include <iostream>
-
-#include "client/rendering/wrapper/Window.h"
-
-Window::Window(const Size& size, const char* windowName) : window(nullptr) {
-    glfwDefaultWindowHints();
-    glfwWindowHint(GLFW_VISIBLE, 0);
-    glfwWindowHint(GLFW_RESIZABLE, 1);
-
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
-    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-    
-    window = glfwCreateWindow(size.width, size.height, windowName, nullptr, nullptr);
-    if(window == nullptr) {
-        std::cout << "could not create window\n";
-        return;
-    }
-    glfwMakeContextCurrent(window);
-    glfwSwapInterval(1);
-
-    glfwSetWindowUserPointer(window, this);
-}
-
-Window::~Window() {
-    if(window != nullptr) {
-        glfwDestroyWindow(window);
-    }
-}
-
-bool Window::hasError() const {
-    return window == nullptr;
-}
-
-void Window::show() {
-    glfwShowWindow(window);
-}
-
-bool Window::shouldClose() const {
-    return glfwWindowShouldClose(window);
-}
-
-void Window::swapBuffers() {
-    glfwSwapBuffers(window);
-}
-
-void Window::setFramebufferSizeCallback(GLFWframebuffersizefun f) {
-    glfwSetFramebufferSizeCallback(window, f);
-}
-
-void Window::setKeyCallback(GLFWkeyfun f) {
-    glfwSetKeyCallback(window, f);
-}
-
-void Window::setMouseButtonCallback(GLFWmousebuttonfun f) {
-    glfwSetMouseButtonCallback(window, f);
-}
-
-void Window::setCursorPosCallback(GLFWcursorposfun f) {
-    glfwSetCursorPosCallback(window, f);
-}

client/rendering/wrapper/Window.h

@@ -1,33 +0,0 @@
-#ifndef WINDOW_H
-#define WINDOW_H
-
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
-
-#include "gaming-core/utils/Size.h"
-
-class Window final {
-public:
-    Window(const Size& size, const char* windowName);
-    ~Window();
-
-    Window(const Window&) = delete;
-    Window& operator=(const Window&) = delete;
-    Window(Window&&) = delete;
-    Window& operator=(Window&&) = delete;
-
-    bool hasError() const;
-    void show();
-    bool shouldClose() const;
-    void swapBuffers();
-
-    void setFramebufferSizeCallback(GLFWframebuffersizefun f);
-    void setKeyCallback(GLFWkeyfun f);
-    void setMouseButtonCallback(GLFWmousebuttonfun f);
-    void setCursorPosCallback(GLFWcursorposfun f);
-
-private:
-    GLFWwindow* window;
-};
-
-#endif

gaming-core

@@ -1 +1 @@
-Subproject commit b8f6e4c345b1e9618cf7daadb4c635b813e24fce
+Subproject commit b071869bd3f254d2c1d619ff0dc2b47d7bd9899c

meson.build

@@ -33,18 +33,19 @@ sourcesClient = ['client/Main.cpp',
     'gaming-core/wrapper/Attributes.cpp',
     'gaming-core/rendering/FileTexture.cpp',
     'gaming-core/images/PNGReader.cpp',
+    'gaming-core/wrapper/Window.cpp',
+    'gaming-core/wrapper/WindowOptions.cpp',
+    'gaming-core/input/Button.cpp',
+    'gaming-core/input/Buttons.cpp',
     'client/rendering/Framebuffers.cpp',
-    'client/rendering/wrapper/Window.cpp',
     'client/rendering/Engine.cpp',
-    'client/input/Keys.cpp',
     'client/rendering/Shaders.cpp',
     'client/rendering/Mesh.cpp',
     'client/Game.cpp',
-    'client/input/MouseButtons.cpp',
     'client/rendering/FontRenderer.cpp',
     'client/rendering/wrapper/Framebuffer.cpp',
     'client/rendering/NoiseTexture.cpp',
-    'client/input/Control.cpp',
+    'client/input/Controller.cpp',
     'client/rendering/RenderSettings.cpp',
     'client/rendering/Renderer.cpp',
     'client/rendering/renderer/WorldRenderer.cpp',