deerith_client/include/deerith/client/graphics/input.h

@@ -4,132 +4,4 @@
 namespace deerith
 {
     glm::vec2 get_joystick_axes(int controller_id, int axe_id);
-    glm::vec2 get_mouse_delta();
+}
-    bool get_key_down(int key_id);
-    void set_mouse_locked(bool locked);
-    bool get_mouse_button(int id);
-}
-
-/* Printable keys */
-#define DEERITH_KEY_SPACE 32
-#define DEERITH_KEY_APOSTROPHE 39 /* ' */
-#define DEERITH_KEY_COMMA 44      /* , */
-#define DEERITH_KEY_MINUS 45      /* - */
-#define DEERITH_KEY_PERIOD 46     /* . */
-#define DEERITH_KEY_SLASH 47      /* / */
-#define DEERITH_KEY_0 48
-#define DEERITH_KEY_1 49
-#define DEERITH_KEY_2 50
-#define DEERITH_KEY_3 51
-#define DEERITH_KEY_4 52
-#define DEERITH_KEY_5 53
-#define DEERITH_KEY_6 54
-#define DEERITH_KEY_7 55
-#define DEERITH_KEY_8 56
-#define DEERITH_KEY_9 57
-#define DEERITH_KEY_SEMICOLON 59 /* ; */
-#define DEERITH_KEY_EQUAL 61     /* = */
-#define DEERITH_KEY_A 65
-#define DEERITH_KEY_B 66
-#define DEERITH_KEY_C 67
-#define DEERITH_KEY_D 68
-#define DEERITH_KEY_E 69
-#define DEERITH_KEY_F 70
-#define DEERITH_KEY_G 71
-#define DEERITH_KEY_H 72
-#define DEERITH_KEY_I 73
-#define DEERITH_KEY_J 74
-#define DEERITH_KEY_K 75
-#define DEERITH_KEY_L 76
-#define DEERITH_KEY_M 77
-#define DEERITH_KEY_N 78
-#define DEERITH_KEY_O 79
-#define DEERITH_KEY_P 80
-#define DEERITH_KEY_Q 81
-#define DEERITH_KEY_R 82
-#define DEERITH_KEY_S 83
-#define DEERITH_KEY_T 84
-#define DEERITH_KEY_U 85
-#define DEERITH_KEY_V 86
-#define DEERITH_KEY_W 87
-#define DEERITH_KEY_X 88
-#define DEERITH_KEY_Y 89
-#define DEERITH_KEY_Z 90
-#define DEERITH_KEY_LEFT_BRACKET 91  /* [ */
-#define DEERITH_KEY_BACKSLASH 92     /* \ */
-#define DEERITH_KEY_RIGHT_BRACKET 93 /* ] */
-#define DEERITH_KEY_GRAVE_ACCENT 96  /* ` */
-#define DEERITH_KEY_WORLD_1 161      /* non-US #1 */
-#define DEERITH_KEY_WORLD_2 162      /* non-US #2 */
-
-/* Function keys */
-#define DEERITH_KEY_ESCAPE 256
-#define DEERITH_KEY_ENTER 257
-#define DEERITH_KEY_TAB 258
-#define DEERITH_KEY_BACKSPACE 259
-#define DEERITH_KEY_INSERT 260
-#define DEERITH_KEY_DELETE 261
-#define DEERITH_KEY_RIGHT 262
-#define DEERITH_KEY_LEFT 263
-#define DEERITH_KEY_DOWN 264
-#define DEERITH_KEY_UP 265
-#define DEERITH_KEY_PAGE_UP 266
-#define DEERITH_KEY_PAGE_DOWN 267
-#define DEERITH_KEY_HOME 268
-#define DEERITH_KEY_END 269
-#define DEERITH_KEY_CAPS_LOCK 280
-#define DEERITH_KEY_SCROLL_LOCK 281
-#define DEERITH_KEY_NUM_LOCK 282
-#define DEERITH_KEY_PRINT_SCREEN 283
-#define DEERITH_KEY_PAUSE 284
-#define DEERITH_KEY_F1 290
-#define DEERITH_KEY_F2 291
-#define DEERITH_KEY_F3 292
-#define DEERITH_KEY_F4 293
-#define DEERITH_KEY_F5 294
-#define DEERITH_KEY_F6 295
-#define DEERITH_KEY_F7 296
-#define DEERITH_KEY_F8 297
-#define DEERITH_KEY_F9 298
-#define DEERITH_KEY_F10 299
-#define DEERITH_KEY_F11 300
-#define DEERITH_KEY_F12 301
-#define DEERITH_KEY_F13 302
-#define DEERITH_KEY_F14 303
-#define DEERITH_KEY_F15 304
-#define DEERITH_KEY_F16 305
-#define DEERITH_KEY_F17 306
-#define DEERITH_KEY_F18 307
-#define DEERITH_KEY_F19 308
-#define DEERITH_KEY_F20 309
-#define DEERITH_KEY_F21 310
-#define DEERITH_KEY_F22 311
-#define DEERITH_KEY_F23 312
-#define DEERITH_KEY_F24 313
-#define DEERITH_KEY_F25 314
-#define DEERITH_KEY_KP_0 320
-#define DEERITH_KEY_KP_1 321
-#define DEERITH_KEY_KP_2 322
-#define DEERITH_KEY_KP_3 323
-#define DEERITH_KEY_KP_4 324
-#define DEERITH_KEY_KP_5 325
-#define DEERITH_KEY_KP_6 326
-#define DEERITH_KEY_KP_7 327
-#define DEERITH_KEY_KP_8 328
-#define DEERITH_KEY_KP_9 329
-#define DEERITH_KEY_KP_DECIMAL 330
-#define DEERITH_KEY_KP_DIVIDE 331
-#define DEERITH_KEY_KP_MULTIPLY 332
-#define DEERITH_KEY_KP_SUBTRACT 333
-#define DEERITH_KEY_KP_ADD 334
-#define DEERITH_KEY_KP_ENTER 335
-#define DEERITH_KEY_KP_EQUAL 336
-#define DEERITH_KEY_LEFT_SHIFT 340
-#define DEERITH_KEY_LEFT_CONTROL 341
-#define DEERITH_KEY_LEFT_ALT 342
-#define DEERITH_KEY_LEFT_SUPER 343
-#define DEERITH_KEY_RIGHT_SHIFT 344
-#define DEERITH_KEY_RIGHT_CONTROL 345
-#define DEERITH_KEY_RIGHT_ALT 346
-#define DEERITH_KEY_RIGHT_SUPER 347
-#define DEERITH_KEY_MENU 348

deerith_client/include/deerith/client/graphics/mesh.h

@@ -1,6 +1,5 @@
 #pragma once
 #include <glm/glm.hpp>
-#include <vector>
 
 namespace deerith
 {
@@ -15,32 +14,17 @@ namespace deerith
         ~mesh_2d_t();
 
     private:
-        unsigned int vao = 0;
+        unsigned int vao;
-        unsigned int vbo = 0;
+        unsigned int vbo;
-        unsigned int ebo = 0;
+        unsigned int ebo;
 
         size_t index_count;
     };
 
-    struct vertex_3d_t
-    {
-        glm::vec3 position;
-        glm::vec3 normal;
-        glm::vec2 uv;
-    };
-
-    struct mesh_3d_data_t
-    {
-        std::vector<vertex_3d_t> vertices;
-        std::vector<unsigned int> indices;
-    };
-
     class mesh_3d_t
     {
     public:
-        // obsolete
         mesh_3d_t(const glm::vec3 *vertices, size_t vertex_size, const unsigned int *indices, size_t index_count);
-        mesh_3d_t(const mesh_3d_data_t &mesh_data);
 
         void bind() const;
         void draw() const;
@@ -53,8 +37,7 @@ namespace deerith
         unsigned int vbo;
         unsigned int ebo;
 
-        size_t index_count = 0;
+        size_t index_count;
-        size_t vertex_count = 0;
+        size_t vertex_count;
     };
-
 }

deerith_client/include/deerith/client/internals/cluster_generation.h

@@ -1,73 +0,0 @@
-#pragma once
-#include <glm/glm.hpp>
-
-namespace deerith
-{
-    glm::ivec3 voxel_direction_order[6] = {
-        glm::ivec3(-1, 0, 0),
-        glm::ivec3(1, 0, 0),
-        glm::ivec3(0, -1, 0),
-        glm::ivec3(0, 1, 0),
-        glm::ivec3(0, 0, -1),
-        glm::ivec3(0, 0, 1),
-    };
-
-    glm::vec3 voxel_direction_vertices[6][4] = {
-        // -X
-        {
-            {0, 0, 0},
-            {0, 0, 1},
-            {0, 1, 1},
-            {0, 1, 0},
-        },
-
-        // +X
-        {
-            {1, 0, 0},
-            {1, 1, 0},
-            {1, 1, 1},
-            {1, 0, 1},
-        },
-
-        // -Y
-        {
-            {0, 0, 0},
-            {1, 0, 0},
-            {1, 0, 1},
-            {0, 0, 1},
-        },
-
-        // +Y
-        {
-            {0, 1, 0},
-            {0, 1, 1},
-            {1, 1, 1},
-            {1, 1, 0},
-        },
-
-        // -Z
-        {
-            {0, 0, 0},
-            {0, 1, 0},
-            {1, 1, 0},
-            {1, 0, 0},
-        },
-
-        // +Z
-        {
-            {0, 0, 1},
-            {1, 0, 1},
-            {1, 1, 1},
-            {0, 1, 1},
-        },
-    };
-
-    uint32_t face_indices_order[6] = {
-        0,
-        1,
-        2,
-        0,
-        2,
-        3,
-    };
-}

deerith_client/include/deerith/client/world.h

@@ -1,6 +1,5 @@
 #pragma once
 #include <deerith/world/world_core.h>
-#include <glm/glm.hpp>
 
 namespace deerith
 {
@@ -12,8 +11,5 @@ namespace deerith
     bool is_world_running();
     void render_world();
 
-    void generate_cluster(glm::ivec2 cluster_id, size_t cluster_height_id);
-    void load_clusters_to_gpu();
-
     client_t *get_server_client();
 }

deerith_client/include/deerith/client/world/chunk_render.h

@@ -0,0 +1,13 @@
+#pragma once
+#include <deerith/engine.h>
+#include <deerith/client/graphics/mesh.h>
+
+namespace deerith
+{
+    struct chunk_render_t
+    {
+        std::unique_ptr<mesh_2d_t> chunk_mesh;
+
+        void draw();
+    };
+}

deerith_client/shaders/lit.frag.glsl

@@ -1,28 +1,10 @@
 #version 330 core
 
-in vec3 frag_position;
+uniform vec4 u_color = vec4(0.75, 0.8, 0.9, 1.0);
-in vec3 frag_normal;
 
-uniform vec3 u_color = vec3(1,1,1);
+out vec4 frag_color;
-uniform vec3 u_light_direction = vec3(1, 3, 2);
-
-out vec4 FragColor;
 
 void main()
 {
-
+    frag_color = u_color;
-    // Face normal
-    vec3 normal = normalize(frag_normal);
-    // Directional lighting
-    vec3 light_direction = normalize(u_light_direction);
-
-    float diffuse = max(dot(normal, light_direction), 0.0);
-
-    // Ambient + diffuse
-    float ambient = 0.25;
-    float lighting = ambient + diffuse * 0.75;
-
-    vec3 color = u_color * lighting;
-
-    FragColor = vec4(color, 1.0);
 }

deerith_client/shaders/lit.vert.glsl

@@ -1,21 +1,12 @@
 #version 330 core
 
 layout (location = 0) in vec3 a_position;
-layout (location = 1) in vec3 a_normal;
 
 uniform mat4 u_model;
 uniform mat4 u_view;
 uniform mat4 u_projection;
 
-out vec3 frag_position;
-out vec3 frag_normal;
-
 void main()
 {
-    vec4 world_position = u_model * vec4(a_position, 1.0);
+    gl_Position = u_projection * u_view * u_model * vec4(a_position, 1.0);
-
-    gl_Position = u_projection * u_view * world_position;
-
-    frag_position = world_position.xyz;
-    frag_normal = mat3(transpose(inverse(u_model))) * a_normal;
 }

deerith_client/src/engine.cpp

@@ -1,5 +1,5 @@
 #include <deerith/engine.h>
-#include <deerith/client/internals/network.h>
+#include <deerith/client/network/network_internals.h>
 
 void deerith::init_engine()
 {

deerith_client/src/graphics/input.cpp

@@ -28,70 +28,4 @@ glm::vec2 deerith::get_joystick_axes(int controller_id, int axe_id)
     }
 
     return glm::vec2(corrected_axe_x, corrected_axe_y);
-}
-
-glm::vec2 deerith::get_mouse_delta()
-{
-    static double last_x = 0.0;
-    static double last_y = 0.0;
-    static bool first_call = true;
-
-    GLFWwindow *window = glfwGetCurrentContext();
-
-    if (!window)
-    {
-        return glm::vec2(0.0f);
-    }
-
-    double current_x, current_y;
-    glfwGetCursorPos(window, &current_x, &current_y);
-
-    if (first_call)
-    {
-        last_x = current_x;
-        last_y = current_y;
-        first_call = false;
-
-        return glm::vec2(0.0f);
-    }
-
-    glm::vec2 delta(
-        static_cast<float>(current_x - last_x),
-        static_cast<float>(last_y - current_y));
-
-    last_x = current_x;
-    last_y = current_y;
-
-    return delta;
-}
-
-bool deerith::get_key_down(int key_id)
-{
-    GLFWwindow *window = glfwGetCurrentContext();
-    if (!window)
-    {
-        return false;
-    }
-    return glfwGetKey(window, key_id) == GLFW_PRESS;
-}
-
-bool deerith::get_mouse_button(int button)
-{
-    GLFWwindow *window = glfwGetCurrentContext();
-    if (!window)
-        return false;
-
-    return glfwGetMouseButton(window, button) == GLFW_PRESS;
-}
-
-void deerith::set_mouse_locked(bool locked)
-{
-    GLFWwindow *window = glfwGetCurrentContext();
-    if (!window)
-        return;
-
-    glfwSetInputMode(
-        window,
-        GLFW_CURSOR,
-        locked ? GLFW_CURSOR_DISABLED : GLFW_CURSOR_NORMAL);
 }

deerith_client/src/graphics/mesh.cpp

@@ -1,7 +1,5 @@
 #include <deerith/client/graphics/mesh.h>
-#include <deerith/engine.h>
 #include <glad/gl.h>
-#include <cstddef>
 
 deerith::mesh_2d_t::mesh_2d_t(
     const glm::vec2 *vertices,
@@ -67,51 +65,6 @@ void deerith::mesh_2d_t::draw() const
         nullptr);
 }
 
-deerith::mesh_3d_t::mesh_3d_t(const mesh_3d_data_t &mesh_data)
-    : index_count(mesh_data.indices.size()), vertex_count(mesh_data.vertices.size())
-{
-    glGenVertexArrays(1, &vao);
-    glGenBuffers(1, &vbo);
-    glGenBuffers(1, &ebo);
-
-    glBindVertexArray(vao);
-
-    glBindBuffer(GL_ARRAY_BUFFER, vbo);
-    glBufferData(
-        GL_ARRAY_BUFFER,
-        mesh_data.vertices.size() * sizeof(vertex_3d_t),
-        mesh_data.vertices.data(),
-        GL_STATIC_DRAW);
-
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
-    glBufferData(
-        GL_ELEMENT_ARRAY_BUFFER,
-        mesh_data.indices.size() * sizeof(unsigned int),
-        mesh_data.indices.data(),
-        GL_STATIC_DRAW);
-
-    glVertexAttribPointer(
-        0,
-        3,
-        GL_FLOAT,
-        GL_FALSE,
-        sizeof(vertex_3d_t),
-        (void *)offsetof(vertex_3d_t, position));
-
-    glVertexAttribPointer(
-        1,
-        3,
-        GL_FLOAT,
-        GL_FALSE,
-        sizeof(vertex_3d_t),
-        (void *)offsetof(vertex_3d_t, normal));
-
-    glEnableVertexAttribArray(0);
-    glEnableVertexAttribArray(1);
-
-    glBindVertexArray(0);
-}
-
 deerith::mesh_3d_t::mesh_3d_t(
     const glm::vec3 *vertices,
     std::size_t _vertex_count,
@@ -139,12 +92,13 @@ deerith::mesh_3d_t::mesh_3d_t(
         indices,
         GL_STATIC_DRAW);
 
+    // Position: vec2
     glVertexAttribPointer(
         0,
         3,
         GL_FLOAT,
         GL_FALSE,
-        sizeof(glm::vec3),
+        3 * sizeof(float),
         nullptr);
 
     glEnableVertexAttribArray(0);

deerith_client/src/graphics/window.cpp

@@ -1,6 +1,6 @@
 #include <deerith/client/graphics/window.h>
 #include <deerith/client/graphics/primitive_internals.h>
-#include <deerith/client/internals/network.h>
+#include <deerith/client/network/network_internals.h>
 #include <deerith/client/world.h>
 
 #include <glad/gl.h>
@@ -65,13 +65,11 @@ int deerith::init_window()
         return -1;
     }
 
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_CULL_FACE);
-    glCullFace(GL_FRONT);
-    glFrontFace(GL_CCW);
-
-    glDisable(GL_BLEND);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     init_primitives();
     init_imgui();
@@ -92,17 +90,6 @@ bool deerith::begin_window_display()
         return false;
     }
 
-    int display_w, display_h;
-    glfwGetFramebufferSize(window, &display_w, &display_h);
-
-    glViewport(0, 0, display_w, display_h);
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
-    glClearColor(0.1f, 0.1f, 0.15f, 1.0f);
-    glClearDepth(1.0);
-
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
     ImGui_ImplOpenGL3_NewFrame();
     ImGui_ImplGlfw_NewFrame();
     ImGui::NewFrame();
@@ -135,6 +122,10 @@ void deerith::finish_window_display()
 
     frame_id++;
     glfwSwapBuffers(window);
+
+    glClearColor(0.1f, 0.1f, 0.15f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glClear(GL_DEPTH_BUFFER_BIT);
 }
 
 void deerith::shutdown_window()

deerith_client/src/main.cpp

@@ -14,6 +14,13 @@ int main(int argc, const char **argv)
     int port = 8080;
     cmdl("port", 8080) >> port;
 
+    if (cmdl[{"-s", "--single"}] && !deerith::execute_client("../sandbox/SandboxServer", port))
+    {
+        deerith_error("could not start server");
+        deerith::shutdown_engine();
+        return 1;
+    }
+
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
     if (deerith::connect_to_world("127.0.0.1", port))

deerith_client/src/network/network.cpp

@@ -6,7 +6,7 @@
 #include <thread>
 #include <memory>
 
-#include <deerith/client/internals/network.h>
+#include <deerith/client/network/network_internals.h>
 
 namespace deerith
 {

deerith_client/src/world/cluster_generation.cpp

@@ -1,134 +0,0 @@
-#include <deerith/client/world.h>
-#include <deerith/world/environment.h>
-#include <deerith/client/internals/cluster_generation.h>
-#include <vector>
-#include <memory>
-#include <deerith/client/graphics/mesh.h>
-
-namespace deerith
-{
-    cluster_voxel_type_id_data_t *cluster_data = nullptr;
-    glm::ivec2 cluster_id;
-    size_t cluster_height_id;
-
-    void generate_voxel(int x, int y, int z);
-    voxel_type_id_t get_cluster_voxel(int x, int y, int z);
-
-    std::unique_ptr<mesh_3d_t> test_mesh;
-    std::unique_ptr<mesh_3d_data_t> build_data;
-}
-
-void deerith::load_clusters_to_gpu()
-{
-    if (build_data)
-    {
-        test_mesh = std::make_unique<mesh_3d_t>(*build_data);
-        build_data.reset();
-    }
-}
-
-void deerith::generate_cluster(glm::ivec2 _cluster_id, size_t _cluster_height_id)
-{
-    if (build_data)
-    {
-        return;
-    }
-
-    build_data = std::make_unique<mesh_3d_data_t>();
-
-    cluster_data = get_cluster_voxel_type_id_raw_ponter(_cluster_id, _cluster_height_id);
-    cluster_id = _cluster_id;
-    cluster_height_id = _cluster_height_id;
-
-    if (cluster_data == nullptr)
-    {
-        deerith_error("cluster data is null and it should not generate_cluster");
-        return;
-    }
-
-    for (int x = 0; x < CLUSTER_SIZE; x++)
-    {
-        for (int y = 0; y < CLUSTER_SIZE; y++)
-        {
-            for (int z = 0; z < CLUSTER_SIZE; z++)
-            {
-                generate_voxel(x, y, z);
-            }
-        }
-    }
-}
-
-void deerith::generate_voxel(int x, int y, int z)
-{
-    voxel_type_id_t cur_type_id = (*cluster_data)[x][y][z];
-    const voxel_type_t &cur_type = get_voxel_type(cur_type_id);
-
-    if (!cur_type.is_solid)
-    {
-        // nothing to build
-        return;
-    }
-
-    glm::vec3 voxel_position = glm::vec3(x, y, z) * VOXEL_SIZE;
-
-    for (int i = 0; i < 6; i++)
-    {
-        const int check_x = x + voxel_direction_order[i].x;
-        const int check_y = y + voxel_direction_order[i].y;
-        const int check_z = z + voxel_direction_order[i].z;
-
-        voxel_type_id_t check_voxel_id = get_cluster_voxel(check_x, check_y, check_z);
-        const voxel_type_t &check_voxel_type = get_voxel_type(check_voxel_id);
-
-        if (check_voxel_type.is_solid)
-        {
-            continue;
-        }
-
-        uint32_t starting_index = build_data->vertices.size();
-
-        // HEY BUILD FACE
-        for (int v = 0; v < 4; v++)
-        {
-            vertex_3d_t vertex = {
-                .position = voxel_position + voxel_direction_vertices[i][v] * VOXEL_SIZE,
-                .normal = voxel_direction_order[i],
-            };
-
-            build_data->vertices.push_back(vertex);
-        }
-
-        for (int index = 0; index < 6; index++)
-        {
-            build_data->indices.push_back(starting_index + face_indices_order[index]);
-        }
-    }
-}
-
-deerith::voxel_type_id_t deerith::get_cluster_voxel(int x, int y, int z)
-{
-    bool in_bounds_check = true;
-    if (x < 0 || x >= CLUSTER_SIZE)
-    {
-        in_bounds_check = false;
-    }
-    if (y < 0 || y >= CLUSTER_SIZE)
-    {
-        in_bounds_check = false;
-    }
-    if (z < 0 || z >= CLUSTER_SIZE)
-    {
-        in_bounds_check = false;
-    }
-
-    if (in_bounds_check)
-    {
-        return (*cluster_data)[x][y][z];
-    }
-
-    glm::ivec3 coords(x + CLUSTER_SIZE * cluster_id.x,
-                      y + (cluster_height_id - STARTING_CLUSTER_HEIGHT) * CLUSTER_SIZE,
-                      z + cluster_id.y * CLUSTER_SIZE);
-
-    return get_voxel_id(coords);
-}

deerith_client/src/world/player_movment.cpp

@@ -5,100 +5,11 @@
 #include <deerith/network/packets.h>
 #include <deerith/world/components.h>
 
-#include <deerith/client/internals/world.h>
+#include <deerith/client/world/world_internals.h>
 
 namespace deerith
 {
-    void process_player_look(component_client_sync_character_t &sync);
-    void process_player_movement(component_client_sync_character_t &sync);
-}
 
-void deerith::process_player_look(component_client_sync_character_t &sync)
-{
-    if (self_entity == entt::null)
-        return;
-
-    if (!is_windows_focused())
-        return;
-
-    bool looking = get_mouse_button(0);
-
-    set_mouse_locked(looking);
-
-    glm::vec2 mouse_delta = get_mouse_delta();
-
-    if (!looking)
-        return;
-
-    sync.player_look.x += mouse_delta.x * 0.1f;
-    sync.player_look.y -= mouse_delta.y * 0.1f;
-
-    sync.player_look.y = glm::clamp(
-        sync.player_look.y,
-        -89.0f,
-        89.0f);
-}
-
-void deerith::process_player_movement(component_client_sync_character_t &sync)
-{
-    if (self_entity == entt::null)
-    {
-        return;
-    }
-
-    if (!is_windows_focused())
-    {
-        sync.move_input = glm::vec3(0.0f);
-        return;
-    }
-
-    glm::vec3 movement(0.0f);
-
-    // WASD
-    if (get_key_down(DEERITH_KEY_W))
-    {
-        movement.z += 1.0f;
-    }
-
-    if (get_key_down(DEERITH_KEY_S))
-        movement.z -= 1.0f;
-
-    if (get_key_down(DEERITH_KEY_D))
-        movement.x += 1.0f;
-
-    if (get_key_down(DEERITH_KEY_A))
-        movement.x -= 1.0f;
-
-    // Up / Down
-    if (get_key_down(DEERITH_KEY_SPACE))
-        movement.y += 1.0f;
-
-    if (get_key_down(DEERITH_KEY_LEFT_CONTROL))
-        movement.y -= 1.0f;
-
-    // Normalize to prevent faster diagonal movement
-    if (glm::length(movement) > 0.0f)
-        movement = glm::normalize(movement);
-
-    float yaw = glm::radians(sync.player_look.x);
-
-    glm::vec3 forward(
-        glm::sin(yaw),
-        0.0f,
-        glm::cos(yaw));
-
-    glm::vec3 right(
-        glm::cos(yaw),
-        0.0f,
-        -glm::sin(yaw));
-
-    sync.move_input =
-        right * movement.x +
-        glm::vec3(0.0f, movement.y, 0.0f) +
-        forward * movement.z;
-
-    sync.move_input = right * movement.x + glm::vec3(0.0f, movement.y, 0.0f) + forward * movement.z;
-    sync.position = sync.position.read_value() + sync.move_input.read_value() * 0.075f;
 }
 
 void deerith::process_player_input()
@@ -106,22 +17,23 @@ void deerith::process_player_input()
     if (self_entity == entt::null)
         return;
 
-    auto &sync = get_component<component_client_sync_character_t>(self_entity);
+    glm::vec2 movment = get_joystick_axes(0, 0);
+    if (!is_windows_focused())
+    {
+        movment = glm::vec2(0, 0);
+    }
 
-    packet_update_player_input_t packet{};
+    component_player_sync_input_t &entity_sync_position = get_component<component_player_sync_input_t>(self_entity);
 
-    process_player_look(sync);
+    entity_sync_position.move_input = movment;
-    process_player_movement(sync);
+    entity_sync_position.position = entity_sync_position.position.read_value() + movment * 0.1f;
-
-    packet.input_transport.load(sync.move_input);
-    packet.position_transport.load(sync.position);
 }
 
 void deerith::send_player_input()
 {
     if (self_entity == entt::null)
         return;
-    component_client_sync_character_t &entity_sync_position = get_component<component_client_sync_character_t>(self_entity);
+    component_player_sync_input_t &entity_sync_position = get_component<component_player_sync_input_t>(self_entity);
 
     packet_update_player_input_t packet{};
     packet.input_transport.load(entity_sync_position.move_input);

deerith_client/src/world/server_communication.cpp

@@ -3,12 +3,10 @@
 #include <deerith/network/packets.h>
 #include <deerith/network/packets_voxel.h>
 #include <deerith/world/components.h>
-#include <deerith/world/environment.h>
-
 #include <deerith/client/world.h>
 
-#include <deerith/client/internals/world.h>
+#include <deerith/client/world/world_internals.h>
-#include <deerith/client/internals/network.h>
+#include <deerith/client/network/network_internals.h>
 
 void deerith::setup_base_protocols()
 {
@@ -18,8 +16,6 @@ void deerith::setup_base_protocols()
     router_add_packet_processor<packet_update_entities_coordinates_t>();
     router_add_packet_processor<packet_destroy_entity_t>();
     router_add_packet_processor<packet_voxel_data_definition_t>();
-    router_add_packet_processor<packet_surface_data_t>();
-    router_add_packet_processor<packet_cluster_data_t>();
 }
 
 template <>
@@ -33,7 +29,7 @@ template <>
 void deerith::process_packet(deerith::packet_create_player_entity_t &packet, client_t *client)
 {
     self_entity = create_entity();
-    add_component<component_client_sync_character_t>(self_entity);
+    add_component<component_player_sync_input_t>(self_entity);
 }
 
 template <>
@@ -92,17 +88,4 @@ void deerith::process_packet(deerith::packet_voxel_data_definition_t &packet, cl
     deerith_trace("recive voxel data definition with {} materials and {} types", packet.voxel_materials.size(), packet.voxel_types.size());
     set_voxel_materials(packet.voxel_materials);
     set_voxel_types(packet.voxel_types);
-}
-
-template <>
-void deerith::process_packet(deerith::packet_surface_data_t &packet, client_t *client)
-{
-    set_surface_height_raw_data(*packet.__surface_data, packet.surface_id);
-}
-
-template <>
-void deerith::process_packet(deerith::packet_cluster_data_t &packet, client_t *client)
-{
-    set_cluster_voxel_type_id_raw_data(*packet.__cluster_data, packet.surface_id, packet.cluster_height_id);
-    generate_cluster(packet.surface_id, packet.cluster_height_id);
 }

deerith_client/src/world/world.cpp

@@ -1,8 +1,8 @@
 #include <deerith/engine.h>
 #include <deerith/client/world.h>
 
-#include <deerith/client/internals/network.h>
+#include <deerith/client/network/network_internals.h>
-#include <deerith/client/internals/world.h>
+#include <deerith/client/world/world_internals.h>
 
 #include <thread>
 #include <memory>
@@ -46,6 +46,8 @@ void deerith::world_simulation()
     {
         flush_network_events();
 
+        process_player_input();
+
         if (get_world_tick() % 2 == 0)
         {
             send_player_input();

deerith_client/src/world/world_render.cpp

@@ -5,55 +5,31 @@
 #include <deerith/client/graphics/mesh.h>
 #include <deerith/client/graphics/shader.h>
 #include <deerith/client/graphics/primitive.h>
-#include <deerith/client/internals/world.h>
 
 #include <glm/glm.hpp>
 #include <glm/gtc/quaternion.hpp>
 
-namespace deerith
-{
-
-    extern std::unique_ptr<mesh_3d_t> test_mesh;
-}
-
 void deerith::render_world()
 {
-    process_player_input();
-    load_clusters_to_gpu();
-    get_lit_shader()->set_vec3("u_color", glm::vec3(0.8f, 0.8f, 0.8f));
     set_primitive_viewspace(glm::vec2(-10, -10), glm::vec2(10, 10));
 
     camera_t camera;
-
+    camera.position = glm::vec3(0, 3, -10);
-    auto self_view = get_entity_registry().view<component_sync_coordinates_t, component_client_sync_character_t>();
+    set_camera_to_shader(camera, get_lit_shader());
-    for (auto [entity, sync_coords, client_sync_coords] : self_view.each())
-    {
-        camera.position = client_sync_coords.position.read_value();
-
-        float yaw = glm::radians(client_sync_coords.player_look.x);
-        float pitch = glm::radians(client_sync_coords.player_look.y);
-
-        glm::quat yaw_rotation = glm::angleAxis(yaw, glm::vec3(0, 1, 0));
-        glm::quat pitch_rotation = glm::angleAxis(pitch, glm::vec3(1, 0, 0));
-
-        camera.rotation = glm::normalize(yaw_rotation * pitch_rotation);
-
-        set_camera_to_shader(camera, get_lit_shader());
-    }
 
     get_lit_shader()->use();
-    get_lit_shader()->set_vec3("u_color", glm::vec3(0.8f, 0.8f, 0.8f));
+    get_lit_shader()->set_vec4("u_color", glm::vec4(0.8f, 0.8f, 0.8f, 1));
     set_transform_to_shader(glm::vec3(0, 0, 0), glm::identity<glm::quat>(), glm::vec3(1, 1, 1), get_lit_shader());
     get_grid_mesh()->draw_lines();
 
-    auto entities_view = get_entity_registry().view<component_sync_coordinates_t>(entt::exclude<component_client_sync_character_t>);
+    auto entities_view = get_entity_registry().view<component_sync_coordinates_t>(entt::exclude<component_player_sync_input_t>);
     for (auto [entity, sync_coords] : entities_view.each())
     {
-        glm::vec3 chords;
+        glm::vec2 chords;
         if (sync_coords.position.read_synced(chords))
         {
 
-            glm::vec3 position = chords;
+            glm::vec3 position = glm::vec3(chords.x, 0, chords.y);
             glm::quat rotation = glm::identity<glm::quat>();
             glm::vec3 scale = glm::vec3(1, 1, 1);
 
@@ -66,17 +42,19 @@ void deerith::render_world()
     }
 
     // we should expect only one registry
-
+    auto self_view = get_entity_registry().view<component_sync_coordinates_t, component_player_sync_input_t>();
-    if (test_mesh)
+    for (auto [entity, sync_coords, client_sync_coords] : self_view.each())
     {
-        get_lit_shader()->set_vec3("u_color", glm::vec3(0.9f, 0.9f, 0.9f));
+
-        glm::vec3 position = glm::vec3(0, 0, 0);
+        glm::vec2 user_pos = client_sync_coords.position.read_value();
+        glm::vec3 position = glm::vec3(user_pos.x, 0, user_pos.y);
         glm::quat rotation = glm::identity<glm::quat>();
         glm::vec3 scale = glm::vec3(1, 1, 1);
 
+        get_lit_shader()->set_vec4("u_color", glm::vec4(0.8f, 0.8f, 0.8f, 1));
         set_transform_to_shader(position, rotation, scale, get_lit_shader());
 
         get_lit_shader()->use();
-        test_mesh->draw();
+        get_cube_mesh()->draw();
     }
 }

deerith_engine_core/include/deerith/engine.h

@@ -16,7 +16,4 @@ namespace deerith
 
     bool execute_client(const char *server_executable_path, int port);
     void shutdown_executing_servers();
-
-    void start_chrono();
-    float get_chrono_ms();
 }

deerith_engine_core/include/deerith/network/packets.h

@@ -31,8 +31,8 @@ namespace deerith
         static constexpr uint16_t packet_id = 3;
         static constexpr bool reliable = false;
 
-        sync_variable_transport_t<glm::vec3> position_transport;
+        sync_variable_transport_t<glm::vec2> position_transport;
-        sync_variable_transport_t<glm::vec3> input_transport;
+        sync_variable_transport_t<glm::vec2> input_transport;
 
         template <typename Archive>
         void serialize(Archive &archive)
@@ -80,7 +80,7 @@ namespace deerith
         static constexpr bool reliable = false;
 
         std::vector<id_t> entities_ids;
-        std::vector<sync_variable_transport_t<glm::vec3>> positions_to_update;
+        std::vector<sync_variable_transport_t<glm::vec2>> positions_to_update;
 
         template <typename Archive>
         void serialize(Archive &archive)

deerith_engine_core/include/deerith/network/packets_voxel.h

@@ -1,13 +1,9 @@
 #pragma once
 #include <deerith/engine.h>
 #include <deerith/world/voxels.h>
-#include <deerith/world/environment.h>
 
 #include <cereal/types/vector.hpp>
 #include <cereal/types/string.hpp>
-#include <cereal/types/array.hpp>
-
-#include <memory>
 
 // VOXEL SPECIFIC PACKETS 1xxx
 
@@ -28,58 +24,4 @@ namespace deerith
             archive(voxel_types);
         }
     };
-
-    struct packet_surface_data_t
-    {
-        static constexpr uint16_t packet_id = 1002;
-        static constexpr bool reliable = true;
-
-        glm::ivec2 surface_id;
-        std::unique_ptr<surface_height_data_t> __surface_data;
-
-        template <typename Archive>
-        void save(Archive &archive) const
-        {
-            archive(surface_id);
-            archive(*__surface_data);
-        }
-
-        template <typename Archive>
-        void load(Archive &archive)
-        {
-            archive(surface_id);
-
-            __surface_data = std::make_unique<surface_height_data_t>();
-            archive(*__surface_data);
-        }
-    };
-
-    struct packet_cluster_data_t
-    {
-        static constexpr uint16_t packet_id = 1003;
-        static constexpr bool reliable = true;
-
-        glm::ivec2 surface_id;
-        size_t cluster_height_id;
-
-        std::unique_ptr<cluster_voxel_type_id_data_t> __cluster_data;
-
-        template <typename Archive>
-        void save(Archive &archive) const
-        {
-            archive(surface_id);
-            archive(cluster_height_id);
-            archive(*__cluster_data);
-        }
-
-        template <typename Archive>
-        void load(Archive &archive)
-        {
-            archive(surface_id);
-            archive(cluster_height_id);
-
-            __cluster_data = std::make_unique<cluster_voxel_type_id_data_t>();
-            archive(*__cluster_data);
-        }
-    };
 }

deerith_engine_core/include/deerith/network/serialization_ext.h

@@ -15,17 +15,4 @@ namespace cereal
     {
         archive(vec.x, vec.y, vec.z);
     }
-
-    template <class Archive>
-    void serialize(Archive &archive, glm::ivec3 &vec)
-    {
-        archive(vec.x, vec.y, vec.z);
-    }
-
-    template <class Archive>
-    void serialize(Archive &archive, glm::ivec2 &vec)
-    {
-        archive(vec.x, vec.y);
-    }
-
 }

deerith_engine_core/include/deerith/world/components.h

@@ -16,15 +16,14 @@ namespace deerith
     };
 
     // struct for linking a entity to a client
-    struct component_client_sync_character_t
+    struct component_player_sync_input_t
     {
-        sync_variable_t<glm::vec3> move_input;
+        sync_variable_t<glm::vec2> move_input;
-        sync_variable_t<glm::vec3> position;
+        sync_variable_t<glm::vec2> position;
-        glm::vec2 player_look;
     };
 
     struct component_sync_coordinates_t
     {
-        sync_variable_t<glm::vec3> position;
+        sync_variable_t<glm::vec2> position;
     };
 }

deerith_engine_core/include/deerith/world/environment.h

@@ -1,70 +1,16 @@
 #pragma once
-#include <deerith/engine.h>
 #include <deerith/world/voxels.h>
 #include <glm/glm.hpp>
 
 namespace deerith
 {
-    inline constexpr int CLUSTER_SIZE = 32;
+    using voxel_coordinates_t = glm::ivec3;
-    inline constexpr int MAX_CLUSTER_IN_SURFACE = 16;
+    using surface_coordinates_t = glm::ivec2;
-    inline constexpr int STARTING_CLUSTER_HEIGHT = -8;
 
-    inline constexpr float VOXEL_SIZE = 0.5f;
+    // This sets the terrain layer for default comosition y > height -> 0; y <= height -> 1
+    void set_surface_height(surface_coordinates_t surface_pos, int height);
+    void set_voxel(voxel_type_id_t voxel_id, voxel_coordinates_t coordinates);
 
-    using surface_height_t = int16_t;
+    voxel_type_id_t get_voxel_id(voxel_coordinates_t coordinates);
-    using surface_height_data_t = std::array<std::array<surface_height_t, CLUSTER_SIZE>, CLUSTER_SIZE>;
+    const voxel_type_t &get_voxel(voxel_coordinates_t coordinates);
-    using cluster_voxel_type_id_data_t = std::array<std::array<std::array<voxel_type_id_t, CLUSTER_SIZE>, CLUSTER_SIZE>, CLUSTER_SIZE>;
-
-    void set_surface_height(glm::ivec2 surface_pos, surface_height_t height);
-
-    void set_voxel(voxel_type_id_t voxel_id, glm::ivec3 coordinates);
-    voxel_type_id_t get_voxel_id(glm::ivec3 coordinates);
-    const voxel_type_t &get_voxel(glm::ivec3 coordinates);
-
-    void get_surface_height_raw_data(surface_height_data_t &data, glm::ivec2 surface_id);
-    void set_surface_height_raw_data(const surface_height_data_t &data, glm::ivec2 surface_id);
-
-    void get_cluster_voxel_type_id_raw_data(cluster_voxel_type_id_data_t &data, glm::ivec2 surface_id, size_t cluster_height_id);
-    void set_cluster_voxel_type_id_raw_data(const cluster_voxel_type_id_data_t &data, glm::ivec2 surface_id, size_t cluster_height_id);
-    cluster_voxel_type_id_data_t *get_cluster_voxel_type_id_raw_ponter(glm::ivec2 surface_id, size_t cluster_height_id);
-
-    int32_t get_cluster_last_tick_update(glm::ivec2 surface_id, size_t height_id);
-}
-
-// UTILS
-namespace deerith
-{
-    struct environment_settings_t
-    {
-        voxel_type_id_t default_air = 0;
-        voxel_type_id_t default_surface = 1;
-        surface_height_t default_height = 0;
-    };
-
-    struct surface_pos_hash_t
-    {
-        std::size_t operator()(const glm::ivec2 &id) const noexcept
-        {
-            const std::size_t h1 = std::hash<int>{}(id.x);
-            const std::size_t h2 = std::hash<int>{}(id.y);
-
-            return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
-        }
-    };
-
-    struct world_pos_hash_t
-    {
-        std::size_t operator()(const glm::ivec3 &pos) const noexcept
-        {
-            const std::size_t h1 = std::hash<int>{}(pos.x);
-            const std::size_t h2 = std::hash<int>{}(pos.y);
-            const std::size_t h3 = std::hash<int>{}(pos.z);
-
-            std::size_t seed = h1;
-            seed ^= h2 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-            seed ^= h3 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-
-            return seed;
-        }
-    };
 }

deerith_engine_core/src/core/tick.cpp

@@ -6,8 +6,6 @@
 namespace deerith
 {
     uint32_t tick_id = 0;
-
-    std::chrono::steady_clock::time_point __chrono_start;
 }
 
 void deerith::set_tick(uint32_t v)
@@ -43,14 +41,4 @@ void deerith::wait_till_next_tick()
 
     last_tick = clock::now();
     tick_id++;
-}
-
-void deerith::start_chrono()
-{
-    __chrono_start = std::chrono::steady_clock::now();
-}
-
-float deerith::get_chrono_ms()
-{
-    return std::chrono::duration<float, std::milli>(std::chrono::steady_clock::now() - __chrono_start).count();
 }

deerith_engine_core/src/world/environment.cpp

@@ -1,47 +1,47 @@
 #include <deerith/world/environment.h>
-#include <deerith/world/world_core.h>
 #include <array>
 
 #include <glm/glm.hpp>
-#include <unordered_map>
 #include <memory>
 #include <vector>
 #include <math.h>
 
+#define CLUSTER_SIZE 32
+#define MAX_CLUSTER_IN_SURFACE 16
+#define STARTING_CLUSTER_HEIGHT 8
+
 namespace deerith
 {
+    using surface_id_t = glm::ivec2;
+    using internal_voxel_id_t = glm::ivec3;
+
     struct voxel_cluster_t
     {
-        voxel_cluster_t() : last_update_tick_id(get_world_tick()) {}
+        voxel_type_id_t data[CLUSTER_SIZE][CLUSTER_SIZE][CLUSTER_SIZE] = {};
-
-        uint32_t last_update_tick_id;
-        cluster_voxel_type_id_data_t data = {};
     };
 
     struct surface_t
     {
-        glm::ivec2 surface_id;
+        surface_id_t surface_id;
 
-        surface_height_data_t __layer_height = {};
+        int layer_height[CLUSTER_SIZE][CLUSTER_SIZE] = {};
         std::unique_ptr<voxel_cluster_t> voxel_clusters[MAX_CLUSTER_IN_SURFACE] = {};
     };
 
     std::vector<std::unique_ptr<surface_t>> surfaces;
-    std::unordered_map<glm::ivec2, size_t, surface_pos_hash_t> surface_id_index_map;
+    std::unordered_map<surface_id_t, size_t> surface_id_index_map;
 
-    voxel_type_id_t get_default_voxel(glm::ivec3);
+    voxel_type_id_t get_default_voxel(voxel_coordinates_t);
 
-    glm::ivec2 get_surface_id(glm::ivec3 coords);
+    surface_id_t get_surface_id(voxel_coordinates_t coords);
-    glm::ivec2 get_surface_id(glm::ivec2 coords);
+    internal_voxel_id_t get_internal_voxel_coords(voxel_coordinates_t coords);
-    glm::ivec3 get_internal_voxel_coords(glm::ivec3 coords);
+    internal_voxel_id_t get_internal_voxel_coords(surface_coordinates_t coords, int height = 0);
-    glm::ivec3 get_internal_voxel_coords(glm::ivec2 coords, int height = 0);
     size_t get_voxel_cluster_height_id(int height);
 
-    surface_t *create_surface(glm::ivec2);
+    surface_t *create_surface(surface_id_t);
-    voxel_cluster_t *create_cluster(glm::ivec2, size_t);
 }
 
-deerith::surface_t *deerith::create_surface(glm::ivec2 surface_id)
+deerith::surface_t *deerith::create_surface(surface_id_t surface_id)
 {
     std::unique_ptr<surface_t> new_surface = std::make_unique<surface_t>();
     size_t surface_index = surfaces.size();
@@ -52,36 +52,7 @@ deerith::surface_t *deerith::create_surface(glm::ivec2 surface_id)
     return surfaces.back().get();
 }
 
-deerith::voxel_cluster_t *deerith::create_cluster(glm::ivec2 surface_id, size_t cluster_height_id)
+deerith::voxel_type_id_t get_default_voxel(deerith::voxel_coordinates_t coords)
-{
-    surface_t *surface = nullptr;
-    if (surface_id_index_map.contains(surface_id))
-    {
-        size_t surface_index = surface_id_index_map[surface_id];
-        surface = surfaces[surface_index].get();
-    }
-
-    surface->voxel_clusters[cluster_height_id] = std::make_unique<voxel_cluster_t>();
-    voxel_cluster_t *cluster = surface->voxel_clusters[cluster_height_id].get();
-
-    for (int x = 0; x < CLUSTER_SIZE; x++)
-    {
-        for (int z = 0; z < CLUSTER_SIZE; z++)
-        {
-            int start_height = 0;
-            int end_height = surface->__layer_height[x][z] - ((int)cluster_height_id + STARTING_CLUSTER_HEIGHT) * CLUSTER_SIZE;
-
-            for (int y = start_height; y < end_height; y++)
-            {
-                cluster->data[x][y][z] = 1;
-            }
-        }
-    }
-
-    return cluster;
-}
-
-deerith::voxel_type_id_t deerith::get_default_voxel(glm::ivec3 coords)
 {
     if (coords.y > 0)
     {
@@ -107,10 +78,10 @@ size_t deerith::get_voxel_cluster_height_id(int height)
     return cluster_height_id;
 }
 
-glm::ivec3 deerith::get_internal_voxel_coords(glm::ivec3 coords)
+deerith::internal_voxel_id_t deerith::get_internal_voxel_coords(voxel_coordinates_t coords)
 {
     // this will invert negatives coords but we don't mind
-    glm::ivec3 ic = {};
+    internal_voxel_id_t ic = {};
     ic.x = std::abs(coords.x % (CLUSTER_SIZE));
     ic.y = std::abs(coords.y % (CLUSTER_SIZE));
     ic.z = std::abs(coords.z % (CLUSTER_SIZE));
@@ -118,10 +89,10 @@ glm::ivec3 deerith::get_internal_voxel_coords(glm::ivec3 coords)
     return ic;
 }
 
-glm::ivec3 deerith::get_internal_voxel_coords(glm::ivec2 coords, int height)
+deerith::internal_voxel_id_t deerith::get_internal_voxel_coords(surface_coordinates_t coords, int height = 0)
 {
     // this will invert negatives coords but we don't mind
-    glm::ivec3 ic = {};
+    internal_voxel_id_t ic = {};
     ic.x = std::abs(coords.x % (CLUSTER_SIZE));
     ic.y = std::abs(height % (CLUSTER_SIZE));
     ic.z = std::abs(coords.y % (CLUSTER_SIZE));
@@ -129,18 +100,18 @@ glm::ivec3 deerith::get_internal_voxel_coords(glm::ivec2 coords, int height)
     return ic;
 }
 
-glm::ivec2 deerith::get_surface_id(glm::ivec3 coords)
+deerith::surface_id_t deerith::get_surface_id(voxel_coordinates_t coords)
 {
-    glm::ivec2 surface_id = {};
+    surface_id_t surface_id = {};
     surface_id.x = std::floor(static_cast<float>(coords.x) / static_cast<float>(CLUSTER_SIZE));
     surface_id.y = std::floor(static_cast<float>(coords.z) / static_cast<float>(CLUSTER_SIZE));
 
     return surface_id;
 }
 
-glm::ivec2 deerith::get_surface_id(glm::ivec2 coords)
+deerith::surface_id_t deerith::get_surface_id(surface_coordinates_t coords)
 {
-    glm::ivec2 surface_id = {};
+    surface_id_t surface_id = {};
     surface_id.x = std::floor(static_cast<float>(coords.x) / static_cast<float>(CLUSTER_SIZE));
     surface_id.y = std::floor(static_cast<float>(coords.y) / static_cast<float>(CLUSTER_SIZE));
 
@@ -148,9 +119,9 @@ glm::ivec2 deerith::get_surface_id(glm::ivec2 coords)
 }
 
 // This sets the terrain layer for default comosition y > height -> 0; y <= height -> 1
-void deerith::set_surface_height(glm::ivec2 surface_pos, surface_height_t height)
+void deerith::set_surface_height(surface_coordinates_t surface_pos, int height)
 {
-    glm::ivec2 surface_id = get_surface_id(surface_pos);
+    surface_id_t surface_id = get_surface_id(surface_pos);
 
     surface_t *surface = nullptr;
     if (surface_id_index_map.contains(surface_id))
@@ -164,13 +135,13 @@ void deerith::set_surface_height(glm::ivec2 surface_pos, surface_height_t height
         surface = create_surface(surface_id);
     }
 
-    glm::ivec3 internal_voxel_id = get_internal_voxel_coords(surface_pos, height);
+    internal_voxel_id_t internal_voxel_id = get_internal_voxel_coords(surface_pos, height);
-    surface->__layer_height[internal_voxel_id.x][internal_voxel_id.z] = height;
+    surface->layer_height[internal_voxel_id.x][internal_voxel_id.z] = height;
 }
 
-void deerith::set_voxel(voxel_type_id_t voxel_id, glm::ivec3 coordinates)
+void deerith::set_voxel(voxel_type_id_t voxel_id, voxel_coordinates_t coordinates)
 {
-    glm::ivec2 surface_id = get_surface_id(coordinates);
+    surface_id_t surface_id = get_surface_id(coordinates);
 
     surface_t *surface = nullptr;
     if (surface_id_index_map.contains(surface_id))
@@ -184,7 +155,7 @@ void deerith::set_voxel(voxel_type_id_t voxel_id, glm::ivec3 coordinates)
         surface = create_surface(surface_id);
     }
 
-    glm::ivec3 internal_voxel_id = get_internal_voxel_coords(coordinates);
+    internal_voxel_id_t internal_voxel_id = get_internal_voxel_coords(coordinates);
 
     size_t cluster_height_id = get_voxel_cluster_height_id(coordinates.y);
     if (cluster_height_id >= MAX_CLUSTER_IN_SURFACE)
@@ -196,16 +167,16 @@ void deerith::set_voxel(voxel_type_id_t voxel_id, glm::ivec3 coordinates)
     voxel_cluster_t *cluster = surface->voxel_clusters[cluster_height_id].get();
     if (cluster == nullptr)
     {
-        cluster = create_cluster(surface_id, cluster_height_id);
+        surface->voxel_clusters[cluster_height_id] = std::make_unique<voxel_cluster_t>();
+        cluster = surface->voxel_clusters[cluster_height_id].get();
     }
 
-    cluster->last_update_tick_id = get_world_tick();
     cluster->data[internal_voxel_id.x][internal_voxel_id.y][internal_voxel_id.z] = voxel_id;
 }
 
-deerith::voxel_type_id_t deerith::get_voxel_id(glm::ivec3 coordinates)
+deerith::voxel_type_id_t deerith::get_voxel_id(voxel_coordinates_t coordinates)
 {
-    glm::ivec2 surface_id = get_surface_id(coordinates);
+    surface_id_t surface_id = get_surface_id(coordinates);
 
     if (!surface_id_index_map.contains(surface_id))
     {
@@ -226,11 +197,11 @@ deerith::voxel_type_id_t deerith::get_voxel_id(glm::ivec3 coordinates)
         return get_default_voxel(coordinates);
     }
 
-    glm::ivec3 internal_voxel_id = get_internal_voxel_coords(coordinates);
+    internal_voxel_id_t internal_voxel_id = get_internal_voxel_coords(coordinates);
     voxel_cluster_t *cluster = surface->voxel_clusters[cluster_height_id].get();
     if (cluster == nullptr)
     {
-        if (coordinates.y <= surface->__layer_height[internal_voxel_id.x][internal_voxel_id.y])
+        if (coordinates.y <= surface->layer_height[internal_voxel_id.x][internal_voxel_id.y])
         {
             return 1;
         }
@@ -243,161 +214,7 @@ deerith::voxel_type_id_t deerith::get_voxel_id(glm::ivec3 coordinates)
     return cluster->data[internal_voxel_id.x][internal_voxel_id.y][internal_voxel_id.z];
 }
 
-const deerith::voxel_type_t &deerith::get_voxel(glm::ivec3 coordinates)
+const deerith::voxel_type_t &deerith::get_voxel(voxel_coordinates_t coordinates)
 {
     return get_voxel_type(get_voxel_id(coordinates));
-}
-
-void deerith::get_surface_height_raw_data(surface_height_data_t &data, glm::ivec2 surface_pos)
-{
-    glm::ivec2 surface_id = get_surface_id(surface_pos);
-
-    surface_t *surface = nullptr;
-
-    if (surface_id_index_map.contains(surface_id))
-    {
-        size_t surface_index = surface_id_index_map[surface_id];
-        surface = surfaces[surface_index].get();
-    }
-
-    if (surface == nullptr)
-    {
-        surface = create_surface(surface_id);
-    }
-
-    std::memcpy(data.data(), surface->__layer_height.data(), sizeof(data));
-}
-
-void deerith::set_surface_height_raw_data(const surface_height_data_t &data, glm::ivec2 surface_pos)
-{
-    glm::ivec2 surface_id = get_surface_id(surface_pos);
-
-    surface_t *surface = nullptr;
-
-    if (surface_id_index_map.contains(surface_id))
-    {
-        size_t surface_index = surface_id_index_map[surface_id];
-        surface = surfaces[surface_index].get();
-    }
-
-    if (surface == nullptr)
-    {
-        surface = create_surface(surface_id);
-    }
-
-    std::memcpy(surface->__layer_height.data(), data.data(), sizeof(data));
-}
-
-int32_t deerith::get_cluster_last_tick_update(glm::ivec2 surface_id, size_t height_id)
-{
-    if (!surface_id_index_map.contains(surface_id))
-    {
-        return -1;
-    }
-
-    size_t surface_index = surface_id_index_map[surface_id];
-    surface_t *surface = surfaces[surface_index].get();
-
-    if (surface == nullptr)
-    {
-        return -1;
-    }
-
-    if (height_id >= MAX_CLUSTER_IN_SURFACE)
-    {
-        return -1;
-    }
-
-    voxel_cluster_t *cluster = surface->voxel_clusters[height_id].get();
-    if (cluster == nullptr)
-    {
-        return -1;
-    }
-
-    return cluster->last_update_tick_id;
-}
-
-void deerith::get_cluster_voxel_type_id_raw_data(cluster_voxel_type_id_data_t &data, glm::ivec2 surface_id, size_t cluster_height_id)
-{
-    if (cluster_height_id >= MAX_CLUSTER_IN_SURFACE)
-    {
-        deerith_warn("tried to read voxel data out of bounds");
-        return;
-    }
-
-    surface_t *surface = nullptr;
-    if (surface_id_index_map.contains(surface_id))
-    {
-        size_t surface_index = surface_id_index_map[surface_id];
-        surface = surfaces[surface_index].get();
-    }
-
-    if (surface == nullptr)
-    {
-        surface = create_surface(surface_id);
-    }
-
-    voxel_cluster_t *cluster = surface->voxel_clusters[cluster_height_id].get();
-    if (cluster == nullptr)
-    {
-        cluster = create_cluster(surface_id, cluster_height_id);
-    }
-
-    data = cluster->data;
-}
-
-void deerith::set_cluster_voxel_type_id_raw_data(const cluster_voxel_type_id_data_t &data, glm::ivec2 surface_id, size_t cluster_height_id)
-{
-    if (cluster_height_id >= MAX_CLUSTER_IN_SURFACE)
-    {
-        deerith_warn("tried to write voxel data out of bounds");
-        return;
-    }
-
-    surface_t *surface = nullptr;
-    if (surface_id_index_map.contains(surface_id))
-    {
-        size_t surface_index = surface_id_index_map[surface_id];
-        surface = surfaces[surface_index].get();
-    }
-
-    if (surface == nullptr)
-    {
-        surface = create_surface(surface_id);
-    }
-
-    voxel_cluster_t *cluster = surface->voxel_clusters[cluster_height_id].get();
-
-    if (cluster == nullptr)
-    {
-        cluster = create_cluster(surface_id, cluster_height_id);
-    }
-
-    cluster->data = data;
-    cluster->last_update_tick_id = get_world_tick();
-}
-
-deerith::cluster_voxel_type_id_data_t *deerith::get_cluster_voxel_type_id_raw_ponter(glm::ivec2 surface_id, size_t cluster_height_id)
-{
-    if (cluster_height_id >= MAX_CLUSTER_IN_SURFACE)
-    {
-        deerith_warn("tried to write voxel data out of bounds");
-        return nullptr;
-    }
-
-    surface_t *surface = nullptr;
-    if (surface_id_index_map.contains(surface_id))
-    {
-        size_t surface_index = surface_id_index_map[surface_id];
-        surface = surfaces[surface_index].get();
-    }
-
-    if (surface == nullptr)
-    {
-        return nullptr;
-    }
-
-    voxel_cluster_t *cluster = surface->voxel_clusters[cluster_height_id].get();
-
-    return &cluster->data;
 }

deerith_engine_server/include/deerith/server/network.h

@@ -1,7 +0,0 @@
-#pragma once
-
-namespace deerith
-{
-    int init_network();
-    void shutdown_network();
-}

deerith_engine_server/include/deerith/server/network/network_internals.h

@@ -1,8 +1,14 @@
 #pragma once
+#include <enet/enet.h>
+#include <vector>
 
 namespace deerith
 {
+    int init_network();
+    void shutdown_network();
+
     bool init_server(int port);
     void flush_network_events();
+
     void load_base_protocols();
 }

deerith_engine_server/include/deerith/server/world/world_internals.h

@@ -4,21 +4,17 @@
 
 namespace deerith
 {
-    // Client lifecycle
+    void update_players_characters();
     void client_connects(client_t *client);
     void client_disconnects(client_t *client);
 
-    // Entity management
-    void send_create_entity_to_client(entity_t ent, client_t *client);
-    void send_create_entity_to_all_clients(entity_t ent);
-    void send_create_all_entities_to_client(client_t *client);
-    void send_delete_entity_to_all_clients(entity_t ent);
-
-    // Player updates
-    void update_players_characters();
-
-    // Data synchronization
     void send_entity_data();
+
+    void send_create_entity_to_all_clients(entity_t ent);
+    void send_create_entity_to_client(entity_t ent, client_t *client);
+    void send_create_actual_entities_to_client(client_t *client);
+
     void send_voxel_data_to_client(client_t *client);
-    void send_clients_environment_data();
+
+    void send_delete_entity_to_all_clients(entity_t ent);
 }

deerith_engine_server/src/core.cpp

@@ -1,6 +1,6 @@
 #include <deerith/engine.h>
 
-#include <deerith/server/network.h>
+#include <deerith/server/network/network_internals.h>
 
 namespace deerith
 {

deerith_engine_server/src/network/network.cpp

@@ -1,13 +1,9 @@
-#include <deerith/engine.h>
+#include <deerith/core/log.h>
-
 #include <deerith/network/client.h>
 #include <deerith/network/router.h>
 #include <deerith/network/packets.h>
 
 #include <deerith/server/world.h>
-#include <deerith/server/network.h>
-#include <deerith/server/internals/network.h>
-#include <deerith/server/internals/world.h>
 
 #include <enet/enet.h>
 
@@ -15,15 +11,33 @@
 #include <vector>
 #include <memory>
 
+#include <deerith/server/network/network_internals.h>
+#include <deerith/server/world/world_internals.h>
+
 namespace deerith
 {
     ENetHost *server;
+
     std::vector<std::unique_ptr<client_t>> clients;
 
     void create_client(ENetPeer *peer);
     void delete_client(client_t *client);
 }
 
+void deerith::delete_client(client_t *client)
+{
+    auto it = std::find_if(
+        clients.begin(),
+        clients.end(),
+        [client](const std::unique_ptr<client_t> &ptr)
+        { return ptr.get() == client; });
+
+    if (it != clients.end())
+    {
+        clients.erase(it);
+    }
+}
+
 bool deerith::init_server(int port)
 {
     ENetAddress address = {0};
@@ -97,16 +111,4 @@ void deerith::create_client(ENetPeer *peer)
 
     clients.push_back(std::move(client));
     client_connects((client_t *)peer->data);
-}
-
-void deerith::delete_client(client_t *client)
-{
-    for (auto it = clients.begin(); it != clients.end(); ++it)
-    {
-        if (it->get() == client)
-        {
-            clients.erase(it);
-            return;
-        }
-    }
 }

deerith_engine_server/src/world/client_managment.cpp

@@ -6,8 +6,8 @@
 
 #include <deerith/server/world.h>
 
-#include <deerith/server/network.h>
+#include <deerith/server/network/network_internals.h>
-#include <deerith/server/internals/world.h>
+#include <deerith/server/world/world_internals.h>
 
 void deerith::client_connects(client_t *client)
 {
@@ -21,7 +21,7 @@ void deerith::client_connects(client_t *client)
 
     // create entity player entity
     entity_t entity = create_entity();
-    component_client_sync_character_t &position_sync = add_component<component_client_sync_character_t>(entity);
+    component_player_sync_input_t &position_sync = add_component<component_player_sync_input_t>(entity);
 
     packet_create_player_entity_t create_player_entity;
     router_send_packet(create_player_entity, client);
@@ -32,12 +32,12 @@ void deerith::client_connects(client_t *client)
 
     send_create_entity_to_all_clients(entity);
 
-    // we do this the last to avoid send_create_entity_to_all_clients send_create_all_entities_to_client create the same entity for the player
+    // we do this the last to avoid send_create_entity_to_all_clients send_create_actual_entities_to_client create the same entity for the player
     component_client_link_t &link = add_component<component_client_link_t>(entity);
     client->entity_id = entity;
     link.client = client;
 
-    send_create_all_entities_to_client(client);
+    send_create_actual_entities_to_client(client);
 }
 
 void deerith::client_disconnects(client_t *client)

deerith_engine_server/src/world/player_communication.cpp

@@ -1,13 +1,18 @@
 #include <deerith/engine.h>
-
 #include <deerith/world/components.h>
 #include <deerith/network/packets.h>
 #include <deerith/network/router.h>
 #include <deerith/network/client.h>
 
-#include <deerith/server/internals/world.h>
+#include <deerith/server/world.h>
-#include <deerith/server/internals/network.h>
 
+#include <deerith/server/network/network_internals.h>
+#include <deerith/server/world/world_internals.h>
+
+namespace deerith
+{
+
+}
 void deerith::load_base_protocols()
 {
     router_add_packet_processor<packet_update_player_input_t>();
@@ -17,7 +22,7 @@ template <>
 void deerith::process_packet(packet_update_player_input_t &packet, client_t *client)
 {
     entity_t entity = client->entity_id;
-    component_client_sync_character_t &sync_client = get_component<component_client_sync_character_t>(entity);
+    component_player_sync_input_t &sync_client = get_component<component_player_sync_input_t>(entity);
 
     packet.input_transport.recive(sync_client.move_input);
     packet.position_transport.recive(sync_client.position);
@@ -69,7 +74,7 @@ void deerith::send_delete_entity_to_all_clients(entity_t ent)
     }
 }
 
-void deerith::send_create_all_entities_to_client(client_t *client)
+void deerith::send_create_actual_entities_to_client(client_t *client)
 {
     auto entities_view = get_entity_registry().view<component_network_id_t>();
 

deerith_engine_server/src/world/voxel_data_managment.cpp

@@ -1,23 +1,10 @@
-#include <deerith/server/internals/world.h>
+#include <deerith/server/world/world_internals.h>
-
-#include <deerith/world/environment.h>
 #include <deerith/network/packets_voxel.h>
 #include <deerith/network/router.h>
-#include <unordered_map>
 
 namespace deerith
 {
-    struct component_client_environment_knowledge_t
-    {
-        std::unordered_map<glm::ivec2, bool, surface_pos_hash_t> surface_knowledge;
-        std::unordered_map<glm::ivec3, int32_t, world_pos_hash_t> cluster_knowledge;
-    };
 
-    void check_client_surface_knowledge(client_t *, component_client_environment_knowledge_t &knowledge, glm::ivec3 position);
-    bool check_client_cluster_knowledge(client_t *, component_client_environment_knowledge_t &knowledge, glm::ivec2 position);
-
-    void send_surface_info_to_client(client_t *, glm::ivec2);
-    void send_cluster_info_to_client(client_t *, glm::ivec2, size_t);
 }
 
 void deerith::send_voxel_data_to_client(client_t *client)
@@ -27,107 +14,4 @@ void deerith::send_voxel_data_to_client(client_t *client)
     voxel_data_definition.voxel_types = get_voxel_type_vector();
 
     router_send_packet(voxel_data_definition, client);
-}
-
-void deerith::send_clients_environment_data()
-{
-    // temp solution to assign this component to clients that don't have it
-    {
-        auto no_surface_knowledge_component_clients = get_entity_registry().view<component_client_link_t>(entt::exclude<component_client_environment_knowledge_t>);
-        for (auto [entity, client_link] : no_surface_knowledge_component_clients.each())
-        {
-            add_component<component_client_environment_knowledge_t>(entity);
-        }
-    }
-
-    auto update_surface_knowledge_to_clients = get_entity_registry().view<component_client_link_t, component_sync_coordinates_t, component_client_environment_knowledge_t>();
-    for (auto [entity, client_link, entity_position, surface_knowledge] : update_surface_knowledge_to_clients.each())
-    {
-        check_client_surface_knowledge(client_link.client, surface_knowledge, entity_position.position.read_value());
-    }
-}
-
-void deerith::check_client_surface_knowledge(client_t *client, component_client_environment_knowledge_t &knowledge, glm::ivec3 position)
-{
-    const int surface_x = static_cast<int>(std::floor(position.x / CLUSTER_SIZE));
-    const int surface_z = static_cast<int>(std::floor(position.z / CLUSTER_SIZE));
-
-    const int SURFACE_RADIUS = 4;
-
-    for (int x = -SURFACE_RADIUS; x <= SURFACE_RADIUS; x++)
-    {
-        for (int z = -SURFACE_RADIUS; z <= SURFACE_RADIUS; z++)
-        {
-            glm::ivec2 surface_id = {surface_x + x, surface_z + z};
-
-            if (knowledge.surface_knowledge.contains(surface_id) && knowledge.surface_knowledge[surface_id] == true)
-            {
-                if (check_client_cluster_knowledge(client, knowledge, surface_id))
-                {
-                    return;
-                }
-            }
-
-            if (!knowledge.surface_knowledge.contains(surface_id) || knowledge.surface_knowledge[surface_id] == false)
-            {
-                knowledge.surface_knowledge[surface_id] = true;
-                send_surface_info_to_client(client, surface_id);
-                return;
-            }
-        }
-    }
-}
-
-void deerith::send_surface_info_to_client(client_t *client, glm::ivec2 surface_id)
-{
-    start_chrono();
-    packet_surface_data_t surface_data;
-    surface_data.surface_id = surface_id;
-    surface_data.__surface_data = std::make_unique<surface_height_data_t>();
-
-    get_surface_height_raw_data(*surface_data.__surface_data, surface_id);
-
-    router_send_packet(surface_data, client);
-}
-
-bool deerith::check_client_cluster_knowledge(client_t *client, component_client_environment_knowledge_t &knowledge, glm::ivec2 position)
-{
-    for (int y = 0; y < MAX_CLUSTER_IN_SURFACE; y++)
-    {
-        int32_t cluster_last_update = get_cluster_last_tick_update(position, y);
-        if (cluster_last_update < 0)
-        {
-            continue;
-        }
-
-        glm::ivec3 cluster_pos = glm::ivec3(position.x, y, position.y);
-        int32_t actual_cluster_kknowledge = -1;
-        if (knowledge.cluster_knowledge.contains(cluster_pos))
-        {
-            actual_cluster_kknowledge = knowledge.cluster_knowledge[cluster_pos];
-        }
-
-        if (actual_cluster_kknowledge < cluster_last_update)
-        {
-            knowledge.cluster_knowledge[cluster_pos] = cluster_last_update;
-            send_cluster_info_to_client(client, position, y);
-            return true;
-        }
-    }
-
-    return false;
-}
-
-void deerith::send_cluster_info_to_client(client_t *client, glm::ivec2 surface_pos, size_t cluster_height_id)
-{
-    start_chrono();
-    packet_cluster_data_t cluster_data;
-    cluster_data.surface_id = surface_pos;
-    cluster_data.cluster_height_id = cluster_height_id;
-    cluster_data.__cluster_data = std::make_unique<cluster_voxel_type_id_data_t>();
-
-    get_cluster_voxel_type_id_raw_data(*cluster_data.__cluster_data, surface_pos, cluster_height_id);
-
-    router_send_packet(cluster_data, client);
-    deerith_trace("sent cluster data to client in {}ms", get_chrono_ms());
 }

deerith_engine_server/src/world/world.cpp

@@ -1,16 +1,37 @@
-#include <deerith/engine.h>
 #include <deerith/server/world.h>
+#include <deerith/core/log.h>
+#include <deerith/network/router.h>
 
-#include <deerith/server/internals/world.h>
+#include <deerith/server/network/network_internals.h>
-#include <deerith/server/internals/network.h>
+#include <deerith/server/world/world_internals.h>
+
+#include <deerith/world/components.h>
+#include <deerith/network/packets.h>
+
+#include <csignal>
+#include <atomic>
 
 namespace deerith
 {
-    void server_loop();
+    int world_tick = 0;
+    void world_simulation();
+
+    std::atomic<bool> running = true;
+
+    void create_client(ENetPeer *peer);
+    void handle_signal(int signal);
+}
+
+void deerith::handle_signal(int signal)
+{
+    if (signal == SIGTERM)
+        running = false;
 }
 
 void deerith::run_world(int port)
 {
+    std::signal(SIGTERM, handle_signal);
+
     if (!init_server(port))
     {
         deerith_error("could not init server");
@@ -18,13 +39,13 @@ void deerith::run_world(int port)
     }
 
     deerith_trace("server init on port {}", port);
-    while (true)
+    while (running)
     {
-        server_loop();
+        world_simulation();
     }
 }
 
-void deerith::server_loop()
+void deerith::world_simulation()
 {
     flush_network_events();
 
@@ -33,8 +54,6 @@ void deerith::server_loop()
 
     if (get_world_tick() % 2 == 0)
     {
-        send_clients_environment_data();
-
         send_entity_data();
     }
 

deerith_engine_server/src/world/world_simulation.cpp

@@ -1,16 +1,17 @@
-#include <deerith/server/internals/world.h>
+#include <deerith/server/world/world_internals.h>
 
+#include <deerith/server/world.h>
 #include <deerith/world/components.h>
 #include <deerith/network/packets.h>
 #include <deerith/network/router.h>
 
 void deerith::update_players_characters()
 {
-    auto view = get_entity_registry().view<component_client_sync_character_t, component_client_link_t, component_sync_coordinates_t>();
+    auto view = get_entity_registry().view<component_player_sync_input_t, component_client_link_t, component_sync_coordinates_t>();
 
     for (auto [entity, position_input, client, sync_coords] : view.each())
     {
-        glm::vec3 ps{};
+        glm::vec2 ps{};
         if (position_input.position.read_synced(ps))
         {
             sync_coords.position = ps;
@@ -31,7 +32,7 @@ void deerith::send_entity_data()
     {
         sync_entities_coordinates.entities_ids.push_back(network_id.network_id);
         sync_entities_coordinates.positions_to_update.push_back({});
-        sync_variable_transport_t<glm::vec3> &position_trasport = sync_entities_coordinates.positions_to_update.back();
+        sync_variable_transport_t<glm::vec2> &position_trasport = sync_entities_coordinates.positions_to_update.back();
         position_trasport.load(sync_coords.position);
     }
 

sandbox/src/build_world.cpp

@@ -1,17 +0,0 @@
-#include "world.h"
-
-#include <deerith/world/environment.h>
-
-namespace deerith
-{
-
-}
-
-void sandbox::build_world()
-{
-    deerith::set_surface_height(glm::ivec2(2, 2), 5);
-    deerith::set_surface_height(glm::ivec2(2, 3), 7);
-    deerith::set_surface_height(glm::ivec2(2, 1), 6);
-    deerith::set_voxel(1, glm::vec3(2, 2, 2));
-    deerith::set_voxel(1, glm::vec3(3, 4, 1));
-}

sandbox/src/main.cpp

@@ -18,7 +18,7 @@ int main(int argc, const char **argv)
     sandbox::define_voxel_materials();
     sandbox::define_voxels_types();
 
-    sandbox::build_world();
+    // sandbox::build_world();
 
 #ifdef DEBUG
     if (cmdl[{"-s", "--single"}] && !deerith::execute_client("../deerith_client/DeerithClient", port))