update to new core error policy

client/Game.cpp

@@ -112,8 +112,9 @@ void Game::tickConnectState() {
     startGUI.tick();
     StartGUI::Address a;
     if(startGUI.getAddress(a)) {
-        if(client.connect(a, 11196, 3000)) {
-            LOG_INFO(client.getError());
+        Error error = client.connect(a, 11196, 3000);
+        if(error.has()) {
+            LOG_INFO(error.message);
         } else {
             LOG_INFO("connected");
             tickState = &Game::tickConnectedState;

client/Main.cpp

@@ -4,43 +4,42 @@
 #include "client/rendering/RenderSettings.h"
 #include "client/rendering/Shaders.h"
 #include "network/Client.h"
-#include "network/ENet.h"
 #include "rendering/Window.h"
 #include "utils/Logger.h"
 #include "wrapper/GL.h"
 
 int main() {
-    ENet enet;
-    if(enet.init()) {
-        LOG_ERROR("cannot initialize enet");
-        return 0;
-    }
     Client client;
-    if(client.hasError()) {
-        LOG_ERROR(client.getError());
+    Error error = client.start();
+    if(error.has()) {
+        LOG_ERROR(error.message);
         return 0;
     }
     WindowOptions options(4, 0, {1024, 620}, false, "test");
-    TextInput* textInput = nullptr;
-    Window w(textInput, options);
-    if(w.getError().has()) {
-        LOG_ERROR(w.getError().message);
+    Window w;
+    error = w.open(options);
+    if(error.has()) {
+        LOG_ERROR(error.message);
         return 0;
     }
 
     Shaders shaders;
-    if(shaders.hasError()) {
+    error = shaders.init();
+    if(error.has()) {
+        LOG_ERROR(error.message);
         return 0;
     }
 
     Framebuffers framebuffers;
-    if(framebuffers.init(w.getSize())) {
+    error = framebuffers.init(w.getSize());
+    if(error.has()) {
+        LOG_ERROR(error.message);
         return 0;
     }
 
     RenderSettings renderSettings;
-    Controller controller(w.getButtons());
-    Game game(textInput, controller, w.getFrameClock(), w.getTickClock(),
+    Controller controller(w.buttons);
+    Game game(w.textInput, controller, w.getFrameClock(), w.getTickClock(),
               renderSettings, w.getSize(), client);
     Engine engine(shaders, framebuffers, w.getSize(), renderSettings, game);
     w.run(engine, 50'000'000);

client/rendering/Framebuffers.cpp

@@ -1,11 +1,5 @@
 #include "client/rendering/Framebuffers.h"
 
-Framebuffers::Framebuffers()
-    : world(TextureFormat::float32(3), TextureFormat::float32(3), TextureFormat::color8(4), TextureFormat::float32(1),
-            TextureFormat::depth32(true)),
-      ssao(TextureFormat::float32(1)), ssaoBlur(TextureFormat::float32(1)), shadow(TextureFormat::depth32()) {
-}
-
 void Framebuffers::resize(const Size& size) {
     world.resize(size);
     ssao.resize(size);
@@ -13,6 +7,21 @@ void Framebuffers::resize(const Size& size) {
     shadow.resize(size);
 }
 
-bool Framebuffers::init(const Size& size) {
-    return world.init(size) || ssao.init(size) || ssaoBlur.init(size) || shadow.init(size);
+Error Framebuffers::init(const Size& size) {
+    Error error =
+        world.init(size, TextureFormat::float32(3), TextureFormat::float32(3),
+                   TextureFormat::color8(4), TextureFormat::float32(1),
+                   TextureFormat::depth32(true));
+    if(error.has()) {
+        return error;
+    }
+    error = ssao.init(size, TextureFormat::float32(1));
+    if(error.has()) {
+        return error;
+    }
+    error = ssaoBlur.init(size, TextureFormat::float32(1));
+    if(error.has()) {
+        return error;
+    }
+    return shadow.init(size, TextureFormat::depth32());
 }

client/rendering/Framebuffers.h

@@ -5,9 +5,8 @@
 #include "utils/Size.h"
 
 struct Framebuffers final {
-    Framebuffers();
     void resize(const Size& size);
-    bool init(const Size& size);
+    Error init(const Size& size);
 
     Framebuffer<5> world;
     Framebuffer<1> ssao;

client/rendering/Mesh.cpp

@@ -2,8 +2,7 @@
 #include "rendering/Attributes.h"
 
 Mesh::Mesh() : vertices(0) {
-    vertexBuffer.setAttributes(
-        Attributes().addFloat(3).addFloat(2).addFloat(3));
+    vertexBuffer.init(Attributes().addFloat(3).addFloat(2).addFloat(3));
 }
 
 void Mesh::build(const TypedBuffer<Triangle>& buffer) {

client/rendering/NoiseTexture.cpp

@@ -2,7 +2,8 @@
 #include "utils/Array.h"
 #include "utils/Random.h"
 
-NoiseTexture::NoiseTexture() : texture(TextureFormat::float32(3)) {
+NoiseTexture::NoiseTexture() {
+    texture.init(TextureFormat::float32(3), 0);
     Random r(1);
     Array<float, 48> data;
     for(int i = 0; i < 48; i++) {

client/rendering/Renderer.cpp

@@ -1,12 +1,16 @@
 #include "client/rendering/Renderer.h"
 #include "rendering/Attributes.h"
 #include "utils/Buffer.h"
+#include "utils/Logger.h"
 
 Renderer::Renderer()
-    : buffer(16), font("resources/font8x8.png"), text(nullptr), index(0),
-      maxIndex(0), x(0.0f), y(0.0f), vertices(0) {
-    vertexBuffer.setAttributes(
-        Attributes().addFloat(2).addFloat(2).addColor4());
+    : buffer(16), text(nullptr), index(0), maxIndex(0), x(0.0f), y(0.0f),
+      vertices(0) {
+    Error error = font.load("resources/font8x8.png", 0);
+    if(error.has()) {
+        LOG_WARNING(error.message);
+    }
+    vertexBuffer.init(Attributes().addFloat(2).addFloat(2).addColor4());
     vertexBuffer.setStreamData(1024 * 1024);
 }
 

client/rendering/Shaders.cpp

@@ -1,17 +1,31 @@
 #include "client/rendering/Shaders.h"
 
-Shaders::Shaders()
-    : world("resources/shader/world.vs", "resources/shader/world.fs"),
-      ssao("resources/shader/ssao.vs", "resources/shader/ssao.fs"),
-      ssaoBlur("resources/shader/ssaoBlur.vs", "resources/shader/ssaoBlur.fs"),
-      shadow("resources/shader/worldShadow.vs",
-             "resources/shader/worldShadow.fs"),
-      postWorld("resources/shader/worldPost.vs",
-                "resources/shader/worldPost.fs"),
-      overlay("resources/shader/overlay.vs", "resources/shader/overlay.fs") {
-}
-
-bool Shaders::hasError() const {
-    return world.hasError() || ssao.hasError() || ssaoBlur.hasError() ||
-           shadow.hasError() || postWorld.hasError() || overlay.hasError();
+Error Shaders::init() {
+    Error error = world.compile("resources/shader/world.vs", nullptr,
+                                "resources/shader/world.fs");
+    if(error.has()) {
+        return error;
+    }
+    error = ssao.compile("resources/shader/ssao.vs", nullptr,
+                         "resources/shader/ssao.fs");
+    if(error.has()) {
+        return error;
+    }
+    error = ssaoBlur.compile("resources/shader/ssaoBlur.vs", nullptr,
+                             "resources/shader/ssaoBlur.fs");
+    if(error.has()) {
+        return error;
+    }
+    error = shadow.compile("resources/shader/worldShadow.vs", nullptr,
+                           "resources/shader/worldShadow.fs");
+    if(error.has()) {
+        return error;
+    }
+    error = postWorld.compile("resources/shader/worldPost.vs", nullptr,
+                              "resources/shader/worldPost.fs");
+    if(error.has()) {
+        return error;
+    }
+    return overlay.compile("resources/shader/overlay.vs", nullptr,
+                           "resources/shader/overlay.fs");
 }

client/rendering/Shaders.h

@@ -4,8 +4,7 @@
 #include "rendering/Shader.h"
 
 struct Shaders final {
-    Shaders();
-    bool hasError() const;
+    Error init();
 
     Shader world;
     Shader ssao;

client/rendering/renderer/WorldRenderer.cpp

@@ -1,8 +1,11 @@
 #include "client/rendering/renderer/WorldRenderer.h"
 #include "utils/Logger.h"
 
-WorldRenderer::WorldRenderer(const World& world)
-    : world(world), texture("resources/textures.png", 4) {
+WorldRenderer::WorldRenderer(const World& world) : world(world) {
+    Error error = texture.load("resources/textures.png", 4);
+    if(error.has()) {
+        LOG_WARNING(error.message);
+    }
 }
 
 void WorldRenderer::render(float lag, ShaderMatrix& sm) {

server/Main.cpp

@@ -1,4 +1,3 @@
-#include "network/ENet.h"
 #include "server/Game.h"
 #include "server/GameServer.h"
 #include "server/commands/Commands.h"
@@ -31,14 +30,10 @@ void init(Server* server) {
 }
 
 int main() {
-    ENet enet;
-    if(enet.init()) {
-        LOG_ERROR("cannot initialize enet");
-        return 0;
-    }
-    Server server(11196, 50);
-    if(server.hasError()) {
-        LOG_ERROR(server.getError());
+    Server server;
+    Error error = server.start(11196, 50);
+    if(error.has()) {
+        LOG_ERROR(error.message);
         return 0;
     }
     init(&server);

subprojects/gaming-core

@@ -1 +1 @@
-Subproject commit 35bbce6cd688713970efad4fad1412d404bc2e21
+Subproject commit 87aa3c8bed59c2847831ac939dbc644b2d1c1f3f