finished client global refactoring

client/Game.cpp

@@ -1,27 +1,71 @@
 #include "client/Game.h"
 #include "client/GameClient.h"
-#include "client/packets/WorldPackets.h"
+#include "client/gui/StartGUI.h"
 #include "client/rendering/Engine.h"
 #include "common/network/Packets.h"
+#include "rendering/renderer/WorldRenderer.h"
 #include "utils/Logger.h"
 #include "utils/Utils.h"
 
-Game* Game::game = nullptr;
 BlockRegistry Game::blockRegistry;
 World Game::world{blockRegistry};
+static WorldRenderer worldRenderer{Game::world};
+Controller Game::controller;
+
+typedef void (*State)();
+static State tickState;
+static State renderState;
+
+static BaseGUI baseGUI;
+static StartGUI startGUI;
+
+static Vector3 lastPos;
+static Vector3 pos;
+static Quaternion lastRotation;
+static Quaternion rotation;
+
+static void tickConnectedState() {
+    GameClient::consumeEvents();
+}
+
+static void renderConnectedState() {
+}
+
+static void tickConnectState() {
+    startGUI.tick();
+    StartGUI::Address a;
+    if(startGUI.getAddress(a)) {
+        Error error = GameClient::connect(a, 11196, 3000);
+        if(error.has()) {
+            LOG_INFO(error.message);
+        } else {
+            LOG_INFO("connected");
+            tickState = tickConnectedState;
+            renderState = renderConnectedState;
+        }
+    }
+}
+
+static void renderConnectState() {
+    startGUI.render();
+}
+
+bool Game::init() {
+    if(worldRenderer.init()) {
+        return true;
+    }
+    controller.init();
+    tickState = tickConnectState;
+    renderState = renderConnectState;
 
-Game::Game(const Controller& controller)
-    : controller(controller), tickState(&Game::tickConnectState),
-      renderState(&Game::renderConnectState), baseGUI(controller),
-      startGUI(baseGUI), worldRenderer(world) {
     pos = Vector3(0.0f, 30.0f, 0.0f);
     rotation = Quaternion(Vector3(1.0f, 0.0f, 0.0f), 30) * rotation;
     rotation = Quaternion(Vector3(0.0f, 1.0f, 0.0f), 30) * rotation;
-    game = this;
+    return false;
 }
 
 void Game::tick() {
-    (this->*tickState)();
+    tickState();
 
     lastRotation = rotation;
     lastPos = pos;
@@ -65,52 +109,19 @@ void Game::tick() {
     }
 }
 
-void Game::renderWorld(float lag, ShaderMatrix& sm) {
+void Game::renderWorld() {
-    sm.update(Utils::interpolate(lastPos, pos, lag),
+    Engine::matrix.update(Utils::interpolate(lastPos, pos, Engine::lag),
-              lastRotation.lerp(lag, rotation));
+                          lastRotation.lerp(Engine::lag, rotation));
-    worldRenderer.render(lag, sm);
+    worldRenderer.render();
 }
 
-void Game::renderOverlay(float lag, ShaderMatrix& sm, Renderer& r) {
+void Game::renderOverlay() {
-    (this->*renderState)(lag, sm, r);
+    renderState();
-    sm.identity().scale(2.0f).update();
+    Engine::matrix.identity().scale(2.0f).update();
     StringBuffer<100> s;
     s.append("FPS: &074")
         .append(Engine::getFrameClock().getUpdatesPerSecond())
         .append(" &999TPS: &722")
         .append(Engine::getTickClock().getUpdatesPerSecond());
-    r.renderString(Vector2(10.0f, 10.0f), s);
+    Engine::renderer.renderString(Vector2(10.0f, 10.0f), s);
-}
-
-bool Game::isRunning() const {
-    return true;
-}
-
-void Game::tickConnectState() {
-    startGUI.tick();
-    StartGUI::Address a;
-    if(startGUI.getAddress(a)) {
-        Error error = GameClient::connect(a, 11196, 3000);
-        if(error.has()) {
-            LOG_INFO(error.message);
-        } else {
-            LOG_INFO("connected");
-            tickState = &Game::tickConnectedState;
-            renderState = &Game::renderConnectedState;
-        }
-    }
-}
-
-void Game::tickConnectedState() {
-    GameClient::consumeEvents();
-}
-
-void Game::renderConnectState(float lag, ShaderMatrix& sm, Renderer& r) {
-    startGUI.render(lag, sm, r);
-}
-
-void Game::renderConnectedState(float lag, ShaderMatrix& sm, Renderer& r) {
-    (void)lag;
-    (void)sm;
-    (void)r;
 }

client/Game.h

@@ -1,49 +1,20 @@
 #ifndef GAME_H
 #define GAME_H
 
-#include "client/gui/StartGUI.h"
 #include "client/input/Controller.h"
-#include "client/rendering/Renderer.h"
-#include "client/rendering/ShaderMatrix.h"
 #include "common/block/BlockRegistry.h"
 #include "common/world/World.h"
-#include "rendering/renderer/WorldRenderer.h"
 
-class Game final {
+namespace Game {
-    const Controller& controller;
+    extern BlockRegistry blockRegistry;
+    extern World world;
+    extern Controller controller;
 
-    typedef void (Game::*TickState)();
+    bool init();
-    TickState tickState;
-    typedef void (Game::*RenderState)(float, ShaderMatrix&, Renderer&);
-    RenderState renderState;
-    BaseGUI baseGUI;
-    StartGUI startGUI;
-
-    Vector3 lastPos;
-    Vector3 pos;
-    Quaternion lastRotation;
-    Quaternion rotation;
-
-    WorldRenderer worldRenderer;
-
-public:
-    static Game* game;
-    static BlockRegistry blockRegistry;
-    static World world;
-
-    Game(const Controller& controller);
 
     void tick();
-    void renderWorld(float lag, ShaderMatrix& sm);
+    void renderWorld();
-    void renderOverlay(float lag, ShaderMatrix& sm, Renderer& r);
+    void renderOverlay();
-
+}
-    bool isRunning() const;
-
-private:
-    void tickConnectState();
-    void tickConnectedState();
-    void renderConnectState(float lag, ShaderMatrix& sm, Renderer& r);
-    void renderConnectedState(float lag, ShaderMatrix& sm, Renderer& r);
-};
 
 #endif

client/Main.cpp

@@ -1,17 +1,11 @@
 #include "client/Game.h"
 #include "client/GameClient.h"
-#include "client/input/Controller.h"
 #include "client/rendering/Engine.h"
-#include "rendering/Window.h"
-#include "utils/Logger.h"
-#include "wrapper/GL.h"
 
 int main() {
-    if(GameClient::init() || Engine::init()) {
+    if(GameClient::init() || Engine::init() || Game::init()) {
         return 0;
     }
-    Controller controller(Engine::getButtons());
-    Game game(controller);
     Engine::run();
     return 0;
-}
+}

client/gui/BaseGUI.cpp

@@ -1,4 +1,5 @@
 #include "client/gui/BaseGUI.h"
+#include "client/Game.h"
 #include "client/rendering/Engine.h"
 
 static const Color4 INPUT_BACKGROUND(0x00, 0x00, 0x00, 0xA0);
@@ -8,12 +9,9 @@ const Vector2 BaseGUI::FIXED_SIZE(400.0f, 300.0f);
 BaseGUI::Base::Base() : hovered(false), pressed(false) {
 }
 
-BaseGUI::BaseGUI(const Controller& controller) : controller(controller) {
-}
-
 void BaseGUI::tickBase(Base& b) {
-    b.hovered = isIn(b.pos, b.size, controller.getMouse() / scale);
+    b.hovered = isIn(b.pos, b.size, Game::controller.getMouse() / scale);
-    b.pressed = b.hovered && controller.leftClick.wasReleased();
+    b.pressed = b.hovered && Game::controller.leftClick.wasReleased();
 }
 
 void BaseGUI::tick() {
@@ -31,53 +29,53 @@ void BaseGUI::tick() {
     }
 }
 
-void BaseGUI::updateScale(ShaderMatrix& sm) {
+void BaseGUI::updateScale() {
     const Size& size = Engine::getSize();
     scale = static_cast<int>(
         std::min(size.width / FIXED_SIZE[0], size.height / FIXED_SIZE[1]));
     scale = scale < 1.0f ? 1.0f : scale;
     scaledSize = Vector2(size.width / scale, size.height / scale);
-    sm.scale(scale).update();
+    Engine::matrix.scale(scale).update();
 }
 
-void BaseGUI::renderBase(Renderer& r, const Base& base) {
+void BaseGUI::renderBase(const Base& base) {
-    r.renderRectangle(base.pos, base.size,
+    Engine::renderer.renderRectangle(base.pos, base.size,
-                      base.hovered ? INPUT_BACKGROUND_2 : INPUT_BACKGROUND);
+                                     base.hovered ? INPUT_BACKGROUND_2
+                                                  : INPUT_BACKGROUND);
 }
 
-void BaseGUI::renderLabels(Renderer& r) {
+void BaseGUI::renderLabels() {
     for(const Label& label : labels) {
-        renderCenteredString(r, label.base, label.text);
+        renderCenteredString(label.base, label.text);
     }
 }
 
-void BaseGUI::renderInputs(Renderer& r) {
+void BaseGUI::renderInputs() {
-    for(Input& input : inputs) {
+    for(Input& i : inputs) {
-        input.text.setLimit(r.charsInSpace(input.base.size[0] - 20.0f));
+        i.text.setLimit(Engine::renderer.charsInSpace(i.base.size[0] - 20.0f));
-        renderBase(r, input.base);
+        renderBase(i.base);
-        StringBuffer<256> text(input.text);
+        StringBuffer<256> text(i.text);
-        Vector2 pos = renderCenteredString(r, input.base, text);
+        Vector2 pos = renderCenteredString(i.base, text);
-        if(Engine::isActiveTextInput(&input.text)) {
+        if(Engine::isActiveTextInput(&i.text)) {
-            Vector2 cursor = r.getStringSize(text, input.text.getCursor());
+            Vector2 c =
-            renderString(r, Vector2(pos[0] + cursor[0], pos[1] + 2.0f),
+                Engine::renderer.getStringSize(text, i.text.getCursor());
-                         "&292_");
+            renderString(Vector2(pos[0] + c[0], pos[1] + 2.0f), "&292_");
-            renderString(r, Vector2(pos[0] + cursor[0], pos[1] + 3.0f),
+            renderString(Vector2(pos[0] + c[0], pos[1] + 3.0f), "&292_");
-                         "&292_");
         }
     }
 }
 
-void BaseGUI::renderButtons(Renderer& r) {
+void BaseGUI::renderButtons() {
     for(const Button& button : buttons) {
-        renderBase(r, button.base);
+        renderBase(button.base);
-        renderCenteredString(r, button.base, button.text);
+        renderCenteredString(button.base, button.text);
     }
 }
 
-void BaseGUI::render(float, ShaderMatrix&, Renderer& r) {
+void BaseGUI::render() {
-    renderLabels(r);
+    renderLabels();
-    renderInputs(r);
+    renderInputs();
-    renderButtons(r);
+    renderButtons();
 }
 
 Vector2 BaseGUI::round(const Vector2& v) const {
@@ -85,8 +83,8 @@ Vector2 BaseGUI::round(const Vector2& v) const {
                    static_cast<int>(v[1] * scale) / scale);
 }
 
-void BaseGUI::renderString(Renderer& r, const Vector2& pos, const char* s) {
+void BaseGUI::renderString(const Vector2& pos, const char* s) {
-    r.renderString(round(pos), s);
+    Engine::renderer.renderString(round(pos), s);
 }
 
 BaseGUI::Label& BaseGUI::addLabel(const char* text) {
@@ -104,10 +102,10 @@ BaseGUI::Button& BaseGUI::addButton(const char* text) {
     return buttons[buttons.getLength() - 1];
 }
 
-Vector2 BaseGUI::renderCenteredString(Renderer& r, const Base& b,
+Vector2 BaseGUI::renderCenteredString(const Base& b, const char* text) {
-                                      const char* text) {
+    Vector2 pos =
-    Vector2 pos = b.pos + (b.size - r.getStringSize(text)) * 0.5f;
+        b.pos + (b.size - Engine::renderer.getStringSize(text)) * 0.5f;
-    renderString(r, pos, text);
+    renderString(pos, text);
     return pos;
 }
 

client/gui/BaseGUI.h

@@ -1,9 +1,6 @@
 #ifndef BASE_GUI_H
 #define BASE_GUI_H
 
-#include "client/input/Controller.h"
-#include "client/rendering/Renderer.h"
-#include "client/rendering/ShaderMatrix.h"
 #include "input/TextInput.h"
 #include "math/Vector.h"
 #include "utils/List.h"
@@ -12,8 +9,6 @@
 struct BaseGUI final {
     static const Vector2 FIXED_SIZE;
 
-    const Controller& controller;
-
     float scale;
     Vector2 scaledSize;
 
@@ -43,13 +38,11 @@ struct BaseGUI final {
     };
     List<Button> buttons;
 
-    BaseGUI(const Controller& controller);
-
     void tick();
-    void updateScale(ShaderMatrix& sm);
+    void updateScale();
-    void render(float lag, ShaderMatrix& sm, Renderer& r);
+    void render();
     Vector2 round(const Vector2& v) const;
-    void renderString(Renderer& r, const Vector2& pos, const char* s);
+    void renderString(const Vector2& pos, const char* s);
     Label& addLabel(const char* text);
     Input& addInput();
     Button& addButton(const char* text);
@@ -58,11 +51,11 @@ struct BaseGUI final {
 
 private:
     void tickBase(Base& b);
-    Vector2 renderCenteredString(Renderer& r, const Base& b, const char* text);
+    Vector2 renderCenteredString(const Base& b, const char* text);
-    void renderBase(Renderer& r, const Base& b);
+    void renderBase(const Base& b);
-    void renderLabels(Renderer& r);
+    void renderLabels();
-    void renderInputs(Renderer& r);
+    void renderInputs();
-    void renderButtons(Renderer& r);
+    void renderButtons();
 };
 
 #endif

client/gui/StartGUI.cpp

@@ -1,16 +1,17 @@
 #include "client/gui/StartGUI.h"
+#include "client/rendering/Engine.h"
 
-StartGUI::StartGUI(BaseGUI b)
+StartGUI::StartGUI()
-    : base(b), info(base.addLabel("Connect to server ...")),
+    : info(base.addLabel("Connect to server ...")), address(base.addInput()),
-      address(base.addInput()), connect(base.addButton("Connect ...")) {
+      connect(base.addButton("Connect ...")) {
 }
 
 void StartGUI::tick() {
     base.tick();
 }
 
-void StartGUI::render(float lag, ShaderMatrix& sm, Renderer& r) {
+void StartGUI::render() {
-    base.updateScale(sm);
+    base.updateScale();
 
     Vector2 size = Vector2(BaseGUI::FIXED_SIZE[0] - 80.0f, 110.0f);
     Vector2 pos = (base.scaledSize - size) * 0.5f;
@@ -24,8 +25,8 @@ void StartGUI::render(float lag, ShaderMatrix& sm, Renderer& r) {
     connect.base.pos = pos + Vector2(40.0f, 70.0f);
     connect.base.size = Vector2(size[0] - 80.0f, 30.0f);
 
-    r.renderRectangle(pos, size, Color4(0x50, 0x50, 0x50, 0xFF));
+    Engine::renderer.renderRectangle(pos, size, Color4(0x50, 0x50, 0x50, 0xFF));
-    base.render(lag, sm, r);
+    base.render();
 }
 
 bool StartGUI::getAddress(Address& a) const {

client/gui/StartGUI.h

@@ -10,10 +10,10 @@ class StartGUI final {
     BaseGUI::Button& connect;
 
 public:
-    StartGUI(BaseGUI b);
+    StartGUI();
 
     void tick();
-    void render(float lag, ShaderMatrix& sm, Renderer& r);
+    void render();
 
     typedef StringBuffer<64> Address;
     bool getAddress(Address& a) const;

client/input/Controller.cpp

@@ -1,13 +1,18 @@
 #include "client/input/Controller.h"
+#include "client/rendering/Engine.h"
 
-Controller::Controller(Buttons& b)
+Controller::Controller()
-    : buttons(b), left(GLFW_KEY_A, "Left"), right(GLFW_KEY_D, "Right"),
+    : left(GLFW_KEY_A, "Left"), right(GLFW_KEY_D, "Right"), up(GLFW_KEY_W, "X"),
-      up(GLFW_KEY_W, "X"), down(GLFW_KEY_S, "Y"), jump(GLFW_KEY_SPACE, "L"),
+      down(GLFW_KEY_S, "Y"), jump(GLFW_KEY_SPACE, "L"),
       sneak(GLFW_KEY_LEFT_SHIFT, "R"), camLeft(GLFW_KEY_LEFT, "Start"),
       camRight(GLFW_KEY_RIGHT, "Select"), camUp(GLFW_KEY_UP, "Left"),
       camDown(GLFW_KEY_DOWN, "Right"),
       leftClick(GLFW_MOUSE_BUTTON_LEFT, "Left Click"),
       rightClick(GLFW_MOUSE_BUTTON_RIGHT, "Right Click") {
+}
+
+void Controller::init() {
+    Buttons& b = Engine::getButtons();
     b.add(left);
     b.add(right);
     b.add(up);
@@ -34,12 +39,13 @@ Controller::Controller(Buttons& b)
 }
 
 Vector2 Controller::getMouse() const {
-    return Vector2(static_cast<float>(buttons.getMouseX()),
+    Buttons& b = Engine::getButtons();
-                   static_cast<float>(buttons.getMouseY()));
+    return Vector2(static_cast<float>(b.getMouseX()),
+                   static_cast<float>(b.getMouseY()));
 }
 
 Vector2 Controller::getMouseChange() const {
-    return Vector2(
+    Buttons& b = Engine::getButtons();
-        static_cast<float>(buttons.getMouseX() - buttons.getLastMouseX()),
+    return Vector2(static_cast<float>(b.getMouseX() - b.getLastMouseX()),
-        static_cast<float>(buttons.getMouseY() - buttons.getLastMouseY()));
+                   static_cast<float>(b.getMouseY() - b.getLastMouseY()));
 }

client/input/Controller.h

@@ -1,13 +1,10 @@
 #ifndef CONTROLLER_H
 #define CONTROLLER_H
 
-#include "input/Buttons.h"
+#include "input/Button.h"
 #include "math/Vector.h"
 
-class Controller {
+struct Controller {
-    Buttons& buttons;
-
-public:
     Button left;
     Button right;
     Button up;
@@ -22,7 +19,8 @@ public:
     Button leftClick;
     Button rightClick;
 
-    Controller(Buttons& buttons);
+    Controller();
+    void init();
 
     Vector2 getMouse() const;
     Vector2 getMouseChange() const;

client/rendering/Engine.cpp

@@ -3,8 +3,6 @@
 #include "client/rendering/Framebuffers.h"
 #include "client/rendering/Mesh.h"
 #include "client/rendering/NoiseTexture.h"
-#include "client/rendering/Renderer.h"
-#include "client/rendering/ShaderMatrix.h"
 #include "client/rendering/Shaders.h"
 #include "math/Frustum.h"
 #include "rendering/Window.h"
@@ -17,7 +15,9 @@ static Framebuffers framebuffers;
 static Size lastSize{0, 0};
 static Frustum frustum{60.0f, 0.1f, 1000.0f, window.getSize()};
 static MatrixStack<16> model;
-static Renderer renderer;
+Renderer Engine::renderer;
+ShaderMatrix Engine::matrix{nullptr, model, nullptr};
+float Engine::lag = 0.0f;
 static NoiseTexture ssaoNoise;
 static Mesh rectangle;
 static Matrix worldProj;
@@ -29,6 +29,7 @@ static bool useSsao = true;
 static bool useShadows = false;
 static float shadowRadius = 0.01f;
 static float shadowBias = 0.0002f;
+static bool running = true;
 
 static bool initRectangle() {
     if(rectangle.init()) {
@@ -71,7 +72,7 @@ bool Engine::init() {
     return false;
 }
 
-static void renderShadow(float lag) {
+static void renderShadow() {
     framebuffers.shadow.bindAndClear();
     GL::enableDepthTesting();
     shaders.shadow.use();
@@ -80,11 +81,11 @@ static void renderShadow(float lag) {
     shaders.shadow.setMatrix("projView", worldShadowProjView.getValues());
     model.clear();
     shaders.shadow.setMatrix("model", model.peek().getValues());
-    ShaderMatrix sm(shaders.shadow, model, worldView);
+    Engine::matrix = {&shaders.shadow, model, &worldView};
-    Game::game->renderWorld(lag, sm);
+    Game::renderWorld();
 }
 
-static void renderWorld(float lag) {
+static void renderWorld() {
     framebuffers.world.bindAndClear();
     GL::enableDepthTesting();
     shaders.world.use();
@@ -103,8 +104,8 @@ static void renderWorld(float lag) {
     shaders.world.setInt("shadows", useShadows);
     shaders.world.setFloat("radius", shadowRadius);
     shaders.world.setFloat("zbias", shadowBias);
-    ShaderMatrix sm(shaders.world, model, worldView);
+    Engine::matrix = {&shaders.world, model, &worldView};
-    Game::game->renderWorld(lag, sm);
+    Game::renderWorld();
 }
 
 static void renderSSAO() {
@@ -143,7 +144,7 @@ static void renderPostWorld() {
     rectangle.draw();
 }
 
-static void renderOverlay(float lag) {
+static void renderOverlay() {
     GL::disableDepthTesting();
     shaders.overlay.use();
 
@@ -156,8 +157,8 @@ static void renderOverlay(float lag) {
     shaders.overlay.setMatrix("model", model.peek().getValues());
 
     GL::enableBlending();
-    ShaderMatrix sm(shaders.overlay, model, m);
+    Engine::matrix = {&shaders.overlay, model, &m};
-    Game::game->renderOverlay(lag, sm, renderer);
+    Game::renderOverlay();
     GL::disableBlending();
 }
 
@@ -192,7 +193,7 @@ static void updateWorldView() {
     worldShadowView.set(3, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
 }
 
-static void startRender(float lag) {
+static void startRender() {
     const Size& size = window.getSize();
     if(size.width != lastSize.width || size.height != lastSize.height) {
         GL::setViewport(size.width, size.height);
@@ -205,27 +206,28 @@ static void startRender(float lag) {
     updateWorldView();
 
     if(useShadows) {
-        renderShadow(lag);
+        renderShadow();
     }
-    renderWorld(lag);
+    renderWorld();
     if(useSsao) {
         renderSSAO();
     }
     renderPostWorld();
-    renderOverlay(lag);
+    renderOverlay();
 }
 
 struct Loop final {
     void render(float lag) {
-        startRender(lag);
+        Engine::lag = lag;
+        startRender();
     }
 
     void tick() {
-        Game::game->tick();
+        Game::tick();
     }
 
     bool isRunning() const {
-        return Game::game->isRunning();
+        return running;
     }
 };
 
@@ -234,6 +236,10 @@ void Engine::run() {
     window.run(loop, 50'000'000);
 }
 
+void Engine::stop() {
+    running = false;
+}
+
 void Engine::setTextInput(TextInput* input) {
     window.textInput = input;
     if(input != nullptr) {

client/rendering/Engine.h

@@ -1,14 +1,22 @@
 #ifndef ENGINE_H
 #define ENGINE_H
 
+#include "client/rendering/Renderer.h"
+#include "client/rendering/ShaderMatrix.h"
 #include "input/Buttons.h"
 #include "input/TextInput.h"
 #include "utils/Clock.h"
 #include "utils/Size.h"
+#include "utils/Utils.h"
 
 namespace Engine {
+    extern Renderer renderer;
+    extern ShaderMatrix matrix;
+    extern float lag;
+
     bool init();
     void run();
+    void stop();
 
     void setTextInput(TextInput* input);
     bool isActiveTextInput(TextInput* input);

client/rendering/ShaderMatrix.cpp

@@ -1,9 +1,16 @@
 #include "client/rendering/ShaderMatrix.h"
 
-ShaderMatrix::ShaderMatrix(Shader& shader, MatrixStack<16>& stack, Matrix& view)
+ShaderMatrix::ShaderMatrix(Shader* shader, MatrixStack<16>& stack, Matrix* view)
     : shader(shader), stack(stack), view(view) {
 }
 
+ShaderMatrix& ShaderMatrix::operator=(ShaderMatrix&& other) {
+    shader = other.shader;
+    stack = other.stack;
+    view = other.view;
+    return *this;
+}
+
 void ShaderMatrix::pop() {
     stack.pop();
 }
@@ -13,7 +20,7 @@ void ShaderMatrix::push() {
 }
 
 ShaderMatrix& ShaderMatrix::update() {
-    shader.setMatrix("model", stack.peek().getValues());
+    shader->setMatrix("model", stack.peek().getValues());
     return *this;
 }
 
@@ -23,12 +30,12 @@ ShaderMatrix& ShaderMatrix::update(const Vector3& pos,
     Vector3 up = rotation * Vector3(0.0f, 1.0f, 0.0f);
     Vector3 back = rotation * Vector3(0.0f, 0.0f, -1.0f);
 
-    view.set(0, Vector4(right[0], right[1], right[2], right.dot(-pos)));
+    view->set(0, Vector4(right[0], right[1], right[2], right.dot(-pos)));
-    view.set(1, Vector4(up[0], up[1], up[2], up.dot(-pos)));
+    view->set(1, Vector4(up[0], up[1], up[2], up.dot(-pos)));
-    view.set(2, Vector4(back[0], back[1], back[2], back.dot(-pos)));
+    view->set(2, Vector4(back[0], back[1], back[2], back.dot(-pos)));
-    view.set(3, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+    view->set(3, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
 
-    shader.setMatrix("view", view.getValues());
+    shader->setMatrix("view", view->getValues());
     return *this;
 }
 

client/rendering/ShaderMatrix.h

@@ -7,8 +7,13 @@
 #include "rendering/Shader.h"
 
 class ShaderMatrix final {
+    Shader* shader;
+    MatrixStack<16>& stack;
+    Matrix* view;
+
 public:
-    ShaderMatrix(Shader& shader, MatrixStack<16>& stack, Matrix& view);
+    ShaderMatrix(Shader* shader, MatrixStack<16>& stack, Matrix* view);
+    ShaderMatrix& operator=(ShaderMatrix&& other);
 
     void pop();
     void push();
@@ -30,11 +35,6 @@ public:
     ShaderMatrix& rotateZ(float degrees);
 
     ShaderMatrix& identity();
-
-private:
-    Shader& shader;
-    MatrixStack<16>& stack;
-    Matrix& view;
 };
 
 #endif

client/rendering/renderer/WorldRenderer.cpp

@@ -1,15 +1,20 @@
 #include "client/rendering/renderer/WorldRenderer.h"
+#include "client/rendering/Engine.h"
 #include "utils/Logger.h"
 
 WorldRenderer::WorldRenderer(const World& world) : world(world) {
+}
+
+bool WorldRenderer::init() {
     mesh.init();
     Error error = texture.load("resources/textures.png", 4);
     if(error.has()) {
-        LOG_WARNING(error.message);
+        LOG_ERROR(error.message);
     }
+    return error.has();
 }
 
-void WorldRenderer::render(float lag, ShaderMatrix& sm) {
+void WorldRenderer::render() {
     if(world.dirty) {
         TypedBuffer<Triangle> buffer(100);
         for(int x = 0; x < world.getSize(); x++) {
@@ -25,11 +30,11 @@ void WorldRenderer::render(float lag, ShaderMatrix& sm) {
         world.dirty = false;
         LOG_DEBUG("world render update");
     }
-    (void)lag;
     texture.bindTo(0);
     for(int x = -1; x <= 1; x++) {
         for(int z = -1; z <= 1; z++) {
-            sm.translateTo(world.getSize() * x, 0.0f, world.getSize() * z)
+            Engine::matrix
+                .translateTo(world.getSize() * x, 0.0f, world.getSize() * z)
                 .update();
             mesh.draw();
         }

client/rendering/renderer/WorldRenderer.h

@@ -2,7 +2,6 @@
 #define WORLDRENDERER_H
 
 #include "client/rendering/Mesh.h"
-#include "client/rendering/ShaderMatrix.h"
 #include "common/world/World.h"
 #include "rendering/FileTexture.h"
 
@@ -13,8 +12,9 @@ class WorldRenderer {
 
 public:
     WorldRenderer(const World& world);
+    bool init();
 
-    void render(float lag, ShaderMatrix& sm);
+    void render();
     void addCube(TypedBuffer<Triangle>& buffer, float x, float y, float z);
     bool isAir(int x, int y, int z) const;
 };