build.bash

@@ -7,6 +7,6 @@ gcc -g3 -o dependencies/build/glad.o \
     -I dependencies/include/ -Wall
 
 gcc -g3 -o techneck.elf \
-    code/source-c/*.c code/source-c/entity/*.c code/source-c/utility/*.c dependencies/build/glad.o \
+    code/source-c/*.c code/source-c/entity/*.c dependencies/build/glad.o \
-    -I dependencies/include -I code/source-c/ -lGL -lSDL2 -lm -Wall
+    -I dependencies/include -lGL -lSDL2 -lm -Wall
 

code/source-c/chunk_loader.c

@@ -1,5 +1,4 @@
 #include "world.h"
-#include "entity.h"
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -60,8 +59,7 @@ tc_chunk_s * tc_load_chunk_of_loader(tc_chunkloader_s *loader, tc_vec3i_s coord)
     
     if(chunk == NULL)
     {
-        tc_entity_s            *entity             = tc_create_entity("chunk"); // TODO: FURTHER RESTRUCTUING FOR ENTITIES
+        chunk                   = tc_allocate_chunk(loader->world);
-        chunk                   = entity->specific;
         chunk->position         = coord;
         
         loader->world->worldgen->fn_generate_chunk(loader->world->worldgen, chunk);
@@ -91,7 +89,7 @@ void tc_reload_chunk(tc_world_s *world, tc_vec3i_s coord)
 
 void tc_remove_loaders_chunk(tc_chunkloader_s *loader, uint32_t index)
 {
-    tc_free_chunk(loader->chunks[index]);
+    tc_free_chunk(loader->world, loader->chunks[index]);
     
     if(loader->num_chunks != 0)
     {

code/source-c/chunk_pool.c

@@ -3,8 +3,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-tc_chunk_pool_s        *tc_chunk_pool_g     = NULL;
-
 void tc_reset_chunk_pool(tc_chunk_pool_s *chunk_pool)
 {
     chunk_pool->used_entries        = 0;
@@ -22,7 +20,7 @@ void tc_reset_chunk_pool(tc_chunk_pool_s *chunk_pool)
     chunk_pool->entries[chunk_pool->capacity-1].next    = NULL;
 }
 
-tc_chunk_pool_s * tc_internal_new_chunk_pool(uint32_t capacity)
+tc_chunk_pool_s * tc_new_chunk_pool(uint32_t capacity)
 {
     tc_chunk_pool_s        *pool            = malloc(sizeof(tc_chunk_pool_s));
     pool->capacity              = capacity;
@@ -32,17 +30,11 @@ tc_chunk_pool_s * tc_internal_new_chunk_pool(uint32_t capacity)
     return pool;
 }
 
-void tc_init_chunk_pool(uint32_t capacity)
-{
-    tc_chunk_pool_g             = tc_internal_new_chunk_pool(capacity);
-}
-
 tc_chunk_pool_entry_s * tc_allocate_chunk_pool_entry(tc_chunk_pool_s *pool)
 {
     if(pool->first_free == NULL)
     {
-        if(pool->continuation == NULL)
+        pool->continuation          = tc_new_chunk_pool(pool->capacity * 2);
-            pool->continuation          = tc_internal_new_chunk_pool(pool->capacity * 2);
         return tc_allocate_chunk_pool_entry(pool->continuation);
     }
     tc_chunk_pool_entry_s  *allocated       = pool->first_free;
@@ -51,16 +43,18 @@ tc_chunk_pool_entry_s * tc_allocate_chunk_pool_entry(tc_chunk_pool_s *pool)
     return allocated;
 }
 
-tc_chunk_s * tc_allocate_chunk()
+tc_chunk_s * tc_allocate_chunk(tc_world_s *world)
 {
-    tc_chunk_pool_entry_s *entry = tc_allocate_chunk_pool_entry(tc_chunk_pool_g);
+    tc_chunk_pool_entry_s *entry = tc_allocate_chunk_pool_entry(world->pool);
     entry->chunk.pool_entry  = entry;
     
     return &entry->chunk;
 }
 
-void tc_free_chunk(tc_chunk_s *chunk)
+void tc_free_chunk(tc_world_s *world, tc_chunk_s *chunk)
 {
+    tc_chunk_pool_s         *pool       = world->pool;
+    
     if(chunk->vao != 0)
     {
         glDeleteVertexArrays(1, &chunk->vertex_data);
@@ -90,7 +84,7 @@ void tc_free_chunk(tc_chunk_s *chunk)
     chunk->position.y           = 0;
     chunk->position.z           = 0;
     memset(&chunk->blocks, 0x00, sizeof(uint32_t) * 32 * 32 * 32);
-    chunk->pool_entry->next         = tc_chunk_pool_g->first_free;
+    chunk->pool_entry->next     = pool->first_free;
-    tc_chunk_pool_g->first_free     = chunk->pool_entry;
+    pool->first_free            = chunk->pool_entry;
 }
 

code/source-c/entity.c

@@ -10,12 +10,9 @@ tc_entity_registry_s tc_init_entity_registry()
     registry.types_capacity         = 64;
     registry.num_types              = 0;
     registry.types                  = calloc(sizeof(tc_entity_type_s), registry.types_capacity);
-    registry.entities_capacity      = 1024;
+    registry.entities_capacity      = 512;
     registry.num_entities           = 0;
     registry.entities               = calloc(sizeof(tc_entity_s *), registry.entities_capacity);
-    registry.intervals_capacity     = 256;
-    registry.num_intervals          = 0;
-    registry.intervals              = calloc(sizeof(tc_interval_s *), registry.intervals_capacity);
     
     return registry;
 }
@@ -58,11 +55,7 @@ tc_entity_s * tc_create_entity(char *type)
     tc_entity_type_s *type_struct = tc_get_entity_type_with_name(type);
     if(type_struct == NULL) return NULL;
     
-    tc_entity_s        *entity      = type_struct->functions.fn_create();
+    return type_struct->functions.fn_create();
-    entity->type            = type_struct;
-    ++tc_game_state_g.entity_registry.num_entities;
-    
-    return entity;
 }
 
 void tc_spawn_entity(tc_entity_s *entity, tc_location_s location)
@@ -75,14 +68,9 @@ void tc_teleport_entity(tc_entity_s *entity, tc_location_s location)
     entity->type->functions.fn_teleport(entity, location);
 }
 
-void tc_draw_entity(tc_entity_s *entity)
-{
-    entity->type->functions.fn_draw(entity);
-}
-
 void tc_delete_entity(tc_entity_s *entity)
 {
-    entity->type->functions.fn_draw(entity);
+    entity->type->functions.fn_delete(entity);
 }
 
 
@@ -110,7 +98,7 @@ tc_entity_attribute_s * tc_allocate_entity_attribute(tc_entity_s *entity)
     if(entity->num_attributes >= entity->attributes_capacity)
     {
         entity->attributes_capacity        *= 2;
-        entity->attributes                  = realloc(entity->attributes, sizeof(tc_entity_attribute_s) * entity->attributes_capacity);
+        entity->attributes                  = realloc(entity->attributes, sizeof(tc_entity_s) * entity->attributes_capacity);
     }
     ++entity->num_attributes;
     return &entity->attributes[entity->num_attributes-1];
@@ -198,54 +186,6 @@ void tc_forget_entity_attribute(tc_entity_s *entity, char *attr_name)
 
 
 
-int32_t tc_find_index_of_entity_in_intervals(tc_entity_s *entity)
-{
-    uint32_t            interval_index        = 0;
-    while(interval_index < tc_game_state_g.entity_registry.num_intervals)
-    {
-        if(tc_game_state_g.entity_registry.intervals[interval_index].entity == entity)
-            return interval_index;
-        
-        ++interval_index;
-    }
-    return -1;
-}
-
-uint32_t tc_allocate_interval()
-{
-    if(
-      tc_game_state_g.entity_registry.num_intervals
-        >=
-      tc_game_state_g.entity_registry.intervals_capacity
-    ) {
-        tc_game_state_g.entity_registry.intervals_capacity *= 2;
-        tc_game_state_g.entity_registry.intervals =
-            realloc(
-              tc_game_state_g.entity_registry.intervals,
-              sizeof(tc_interval_s) * tc_game_state_g.entity_registry.intervals_capacity
-            );
-    }
-    uint32_t            last        = tc_game_state_g.entity_registry.num_intervals;
-    tc_game_state_g.entity_registry.intervals[last].last_invocation = 0.0f;
-    ++tc_game_state_g.entity_registry.num_intervals;
-    
-    return last;
-}
-
-void tc_schedule_interval(tc_entity_s *entity, float wanted_delta, void (*fn_interval)(tc_entity_s *entity))
-{
-    int32_t         interval_index;
-    if((interval_index = tc_find_index_of_entity_in_intervals(entity)) == -1)
-    {
-        interval_index          = tc_allocate_interval();
-    }
-    tc_interval_s entry;
-    entry.entity                = entity;
-    entry.wanted_delta          = wanted_delta;
-    entry.fn_interval           = fn_interval;
-    tc_game_state_g.entity_registry.intervals[interval_index]  = entry;
-}
-
 void tc_send_pointer_to_entity(tc_entity_s *entity, char *event_name, void *pointer)
 {
     tc_entity_event_s event;
@@ -278,46 +218,3 @@ void tc_send_float_to_entity(tc_entity_s *entity, char *event_name, double  floa
     entity->type->functions.fn_send_event(entity, event);
 }
 
-void tc_tick_intervals()
-{
-    uint64_t                    current_ms      =  SDL_GetTicks64();
-    tc_entity_registry_s        registry        = tc_game_state_g.entity_registry;
-    
-    uint32_t                    interval_index  = 0;
-    while(interval_index < registry.num_intervals)
-    {
-        tc_interval_s        interval        = registry.intervals[interval_index];
-        uint32_t                    elapsed_time    = current_ms - interval.last_invocation;
-        if(elapsed_time >= interval.wanted_delta)
-        {
-            if(interval.fn_interval == NULL)
-            {
-                ++interval_index;
-                continue;
-            }
-            interval.fn_interval(interval.entity);
-        }
-        ++interval_index;
-    }
-}
-
-
-void tc_draw_all_entities_of_type(char *name)
-{
-    tc_entity_type_s           *type            = tc_get_entity_type_with_name(name);
-    tc_entity_registry_s        registry        = tc_game_state_g.entity_registry;
-    
-    uint32_t                    drawn_entities  = 0;
-    uint32_t                    entity_index    = 0;
-    while(entity_index < registry.num_entities)
-    {
-        tc_entity_s            *entity          = registry.entities[entity_index];
-        if(entity->type == type)
-        {
-            tc_draw_entity(entity);
-            ++drawn_entities;
-        }
-        ++entity_index;
-    }
-}
-

code/source-c/entity.h

@@ -2,14 +2,13 @@
 #ifndef TC_ENTITY_H
 #define TC_ENTITY_H
 
-#include "utility/location.h"
+#include "location.h"
-#include "utility/utility.h"
+#include "utility.h"
 
 typedef struct tc_entity_event          tc_entity_event_s;
 typedef struct tc_entity_type           tc_entity_type_s;
 typedef struct tc_entity_attribute      tc_entity_attribute_s;
 typedef struct tc_entity                tc_entity_s;
-typedef struct tc_interval                  tc_interval_s;
 typedef struct tc_entity_registry       tc_entity_registry_s;
 
 
@@ -18,7 +17,6 @@ typedef struct
     tc_entity_s *             (*fn_create)          ();
     void                      (*fn_spawn)           (tc_entity_s *entity, tc_location_s location);
     void                      (*fn_teleport)        (tc_entity_s *entity, tc_location_s location);
-    void                      (*fn_draw)            (tc_entity_s *entity);
     void                      (*fn_delete)          (tc_entity_s *entity);
     void                      (*fn_send_event)      (tc_entity_s *entity, tc_entity_event_s event);
     
@@ -43,6 +41,7 @@ struct tc_entity_type
     char                       *display_name;
     
     tc_fn_entity_s              functions;
+    
 };
 
 struct tc_entity_attribute
@@ -73,14 +72,6 @@ struct tc_entity
     
 };
 
-struct tc_interval
-{
-    uint64_t                        last_invocation;
-    uint64_t                        wanted_delta;
-    tc_entity_s                    *entity;
-    void                          (*fn_interval)        (tc_entity_s *entity);
-};
-
 struct tc_entity_registry
 {
     uint32_t                    types_capacity;
@@ -90,10 +81,6 @@ struct tc_entity_registry
     uint32_t                    entities_capacity;
     uint32_t                    num_entities;
     tc_entity_s               **entities;
-    
-    uint32_t                        intervals_capacity;
-    uint32_t                        num_intervals;
-    tc_interval_s                  *intervals;
 };
 
 tc_entity_registry_s            tc_init_entity_registry         ();
@@ -104,7 +91,6 @@ tc_entity_type_s *              tc_get_entity_type_with_name    (char *name);
 tc_entity_s *                   tc_create_entity                (char *type);
 void                            tc_spawn_entity                 (tc_entity_s *entity, tc_location_s location);
 void                            tc_teleport_entity              (tc_entity_s *entity, tc_location_s location);
-void                            tc_draw_entity                  (tc_entity_s *entity);
 void                            tc_delete_entity                (tc_entity_s *entity);
 
 void                            tc_set_pointer_for_entity       (tc_entity_s *entity, char *attr_name, void *pointer);
@@ -122,10 +108,6 @@ void                            tc_send_string_to_entity        (tc_entity_s *en
 void                            tc_send_integer_to_entity       (tc_entity_s *entity, char *event_name, int64_t integer);
 void                            tc_send_float_to_entity         (tc_entity_s *entity, char *event_name, double  floating);
 
-void                            tc_schedule_interval            (tc_entity_s *entity, float wanted_delta, void (*fn_interval)(tc_entity_s *entity));
-void                            tc_tick_intervals               ();
-void                            tc_draw_all_entities_of_type    (char *name);
-
 tc_entity_s *                   tc_allocate_entity              ();
 void                            tc_deallocate_entity            (tc_entity_s *entity);
 

code/source-c/entity_pool.c

@@ -3,17 +3,6 @@
 
 #include <stdlib.h>
 
-// TODO: Write a *real* pool allocator
-
-void tc_reset_entity(tc_entity_s *entity)
-{
-    if(entity->attributes != NULL) free(entity->attributes);
-    entity->attributes_capacity     = 8;
-    entity->attributes              =
-        calloc(sizeof(tc_entity_attribute_s), entity->attributes_capacity);
-    
-}
-
 tc_entity_s * tc_allocate_entity()
 {
     tc_entity_registry_s    registry        = tc_game_state_g.entity_registry;
@@ -25,24 +14,16 @@ tc_entity_s * tc_allocate_entity()
         {
             registry.entities[entity_index] = calloc(sizeof(tc_entity_s), 1);
             ++registry.num_entities;
-            
-            registry.entities[entity_index]->attributes_capacity     = 8;
-            registry.entities[entity_index]->attributes              =
-                calloc(sizeof(tc_entity_attribute_s), registry.entities[entity_index]->attributes_capacity);
-            
-            tc_reset_entity(registry.entities[entity_index]);
             return registry.entities[entity_index];
         }
         ++entity_index;
     }
     
-    registry.entities               =
-        realloc(registry.entities, sizeof(tc_entity_s *) * registry.entities_capacity * 2);
-    memset(&registry.entities[registry.entities_capacity], 0x00, sizeof(tc_entity_s *) * registry.entities_capacity);
     registry.entities_capacity     *= 2;
+    registry.entities               =
+        realloc(registry.entities, sizeof(tc_entity_s *) * registry.entities_capacity);
     
     registry.entities[registry.num_entities] = malloc(sizeof(tc_entity_s));
-    tc_reset_entity(registry.entities[registry.num_entities]);
     ++registry.num_entities;
     
     return registry.entities[registry.num_entities-1];

code/source-c/initialization.c

@@ -73,8 +73,6 @@ void tc_init()
     tc_game_state_g.viewer              = tc_game_state_g.player;
     tc_init_worlds();
     tc_game_state_g.main_world          = tc_new_world(&tc_default_terrain_generator_g);
-    tc_game_state_g.tps                 = 120;
-    
     
     puts("Finished initializing!");
 }

code/source-c/location.c

@@ -1,4 +1,4 @@
-#include <utility/location.h>
+#include "location.h"
 
 #include <stdlib.h>
 

code/source-c/location.h

@@ -2,13 +2,13 @@
 #ifndef TC_LOCATION_H
 #define TC_LOCATION_H
 
-#include <world.h>
+#include "world.h"
 
 typedef struct tc_location
 {
     tc_world_s             *world;
-    tc_vec3f_s              position;
+    tc_vec3_s               position;
-    tc_vec3f_s              rotation;
+    tc_vec3_s               rotation;
     
 } tc_location_s;
 

code/source-c/main.c

@@ -1,10 +1,69 @@
-#include <state.h>
+#include "state.h"
-#include <utility/math.h>
 
 #include <glad/glad.h>
 #include <SDL2/SDL.h>
 #include <linmath.h>
 
+mat4x4                  projection_matrix;
+mat4x4                  view_matrix;
+
+float triangle_vertices[108] =
+{
+    // Front
+    -0.5f, -0.5f, -0.5f,
+    -0.5f,  0.5f, -0.5f,
+     0.5f, -0.5f, -0.5f,
+    
+     0.5f,  0.5f, -0.5f,
+     0.5f, -0.5f, -0.5f,
+    -0.5f,  0.5f, -0.5f,
+    
+    // Back
+     0.5f, -0.5f,  0.5f,
+    -0.5f,  0.5f,  0.5f,
+    -0.5f, -0.5f,  0.5f,
+    
+    -0.5f,  0.5f,  0.5f,
+     0.5f, -0.5f,  0.5f,
+     0.5f,  0.5f,  0.5f,
+    
+    // Left
+    -0.5f,  0.5f, -0.5f,
+    -0.5f, -0.5f, -0.5f,
+    -0.5f, -0.5f,  0.5f,
+    
+    -0.5f, -0.5f,  0.5f,
+    -0.5f,  0.5f,  0.5f,
+    -0.5f,  0.5f, -0.5f,
+    
+    // Right
+     0.5f, -0.5f,  0.5f,
+     0.5f, -0.5f, -0.5f,
+     0.5f,  0.5f, -0.5f,
+    
+     0.5f,  0.5f, -0.5f,
+     0.5f,  0.5f,  0.5f,
+     0.5f, -0.5f,  0.5f,
+    
+    // Top
+    -0.5f,  0.5f, -0.5f,
+    -0.5f,  0.5f,  0.5f,
+     0.5f,  0.5f, -0.5f,
+    
+    -0.5f,  0.5f,  0.5f,
+     0.5f,  0.5f,  0.5f,
+     0.5f,  0.5f, -0.5f,
+    
+    // Bottom
+    -0.5f, -0.5f,  0.5f,
+    -0.5f, -0.5f, -0.5f,
+     0.5f, -0.5f, -0.5f,
+    
+     0.5f, -0.5f,  0.5f,
+    -0.5f, -0.5f,  0.5f,
+     0.5f, -0.5f, -0.5f
+};
+
 void tc_move_viewer_to(float x, float y, float z)
 {
     if(tc_game_state_g.viewer == NULL) return;
@@ -41,11 +100,45 @@ void tc_get_viewer_rotation(float *x, float *y, float *z)
     if(z != NULL) (*z) = tc_get_float_from_entity(tc_game_state_g.viewer, "rot_z");
 }
 
+void render_block(tc_block_s block)
+{
+    mat4x4              model_matrix;
+    mat4x4_identity(model_matrix);
+    mat4x4_rotate_X(view_matrix, model_matrix, block.rotation.x);
+    mat4x4_rotate_Y(view_matrix, model_matrix, block.rotation.y);
+    mat4x4_rotate_Z(view_matrix, model_matrix, block.rotation.z);
+    mat4x4_translate_in_place(model_matrix, block.position.x, block.position.y, block.position.z);
+    
+    int model_matrix_uniform_location = glGetUniformLocation(tc_game_state_g.renderer.draw_shader.program_id, "model_matrix");
+    glUniformMatrix4fv(model_matrix_uniform_location, 1, GL_FALSE, &model_matrix[0][0]);
+    
+    glBindBuffer(GL_ARRAY_BUFFER, block.drawing.vbo);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *) 0);
+    glEnableVertexAttribArray(0);
+    glDrawArrays(GL_TRIANGLES, 0, 36);
+}
+
+tc_block_s tc_new_block_at_3f(float x, float y, float z)
+{
+    tc_block_s          block;
+    block.position.x            = x;
+    block.position.y            = y;
+    block.position.z            = z;
+    block.rotation.x            = 0.0f;
+    block.rotation.y            = 0.0f;
+    block.rotation.z            = 0.0f;
+    glGenBuffers(1, &block.drawing.vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, block.drawing.vbo);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 108, &triangle_vertices[0], GL_STATIC_DRAW);
+    
+    return block;
+}
+
 void render()
 {
     float           color[4] = { 0.12f, 0.5f, 0.8f, 1.0f };
     glClearBufferfv(GL_COLOR, 0, color);
-    float depth = 1000.0f;
+    float depth = 10000000.0f;
     glClearBufferfv(GL_DEPTH, 0, &depth);
     
     int fb_width = 0;
@@ -53,35 +146,29 @@ void render()
     SDL_GetWindowSize(tc_game_state_g.renderer.window, &fb_width, &fb_height);
     
     glViewport(0, 0, fb_width, fb_height);
+    mat4x4_perspective(projection_matrix, 120, ((float) fb_width) / ((float) fb_height), 0.0001f, 1000.0f);
     
-    tc_vec3f_s      camera_rotation;
+    tc_vec3_s   camera_rotation;
-    tc_vec3f_s      camera_position;
-    
     tc_get_viewer_rotation(&camera_rotation.x, &camera_rotation.y, &camera_rotation.z);
+    
+    tc_vec3_s   camera_position;
     tc_get_viewer_position(&camera_position.x, &camera_position.y, &camera_position.z);
     
-    tc_vec3f_s      camera_offset;
+    mat4x4_identity(view_matrix);
-    camera_offset.z     =  camera_position.z;
+    mat4x4_rotate_X(view_matrix, view_matrix, camera_rotation.x);
-    camera_offset.y     = -camera_position.y;
+    mat4x4_rotate_Y(view_matrix, view_matrix, camera_rotation.y);
-    camera_offset.x     = -camera_position.x;
+    mat4x4_rotate_Z(view_matrix, view_matrix, camera_rotation.z);
     
-    tc_mat4f_s      view_matrix             = tc_mat4f_identity();
+    mat4x4_translate_in_place(view_matrix, -camera_position.x, -camera_position.y, camera_position.z);
-    tc_mat4f_s      projection_matrix       =
-      tc_mat4f_perspective(120,
-        ((float) fb_width) / ((float) fb_height),
-        0.0001f, 1000.0f
-      );
-    
-    view_matrix = tc_mat4f_translate(view_matrix, camera_offset);
-    
-    view_matrix = tc_mat4_rotate_z(view_matrix, tc_deg_to_rad(camera_rotation.z));
-    view_matrix = tc_mat4_rotate_y(view_matrix, tc_deg_to_rad(camera_rotation.y));
-    view_matrix = tc_mat4_rotate_x(view_matrix, tc_deg_to_rad(camera_rotation.x));
     
     glUseProgram(tc_game_state_g.renderer.draw_shader.program_id);
     
-    tc_shader_uniform_mat4f(&tc_game_state_g.renderer.draw_shader, "projection_matrix", projection_matrix);
+    int projection_uniform_location = glGetUniformLocation(tc_game_state_g.renderer.draw_shader.program_id, "projection_matrix");
-    tc_shader_uniform_mat4f(&tc_game_state_g.renderer.draw_shader, "view_matrix", view_matrix);
+    glUniformMatrix4fv(projection_uniform_location, 1, GL_FALSE, &projection_matrix[0][0]);
+    
+    int view_uniform_location       = glGetUniformLocation(tc_game_state_g.renderer.draw_shader.program_id, "view_matrix");
+    glUniformMatrix4fv(view_uniform_location, 1, GL_FALSE, &view_matrix[0][0]);
+    // printf("%d\n", view_uniform_location);
     
     tc_draw_world(tc_game_state_g.main_world);
     
@@ -97,11 +184,9 @@ bool                    go_backwards        = false;
 bool                    rotate_left         = false;
 bool                    rotate_right        = false;
 
-uint64_t                tc_last_update      = 0;
-
 bool update()
 {
-    tc_vec3f_s      camera_rotation;
+    tc_vec3_s   camera_rotation;
     tc_get_viewer_rotation(&camera_rotation.x, &camera_rotation.y, &camera_rotation.z);
     
     SDL_Event               event;
@@ -212,20 +297,20 @@ bool update()
             case SDL_MOUSEMOTION:
             {
                 if(!(event.motion.state & SDL_BUTTON_LMASK)) break;
-                camera_rotation.y += event.motion.xrel / 10.0f;
+                camera_rotation.y += event.motion.xrel / 50.0f;
-                camera_rotation.x += event.motion.yrel / 10.0f;
+                camera_rotation.x += event.motion.yrel / 50.0f;
                 
-                if(camera_rotation.x > 90) 
+                if(camera_rotation.x > (3.1415f/2.0f)) 
-                    camera_rotation.x = 90;
+                    camera_rotation.x = (3.1415f/2.0f);
                 
-                if(camera_rotation.x < -90) 
+                if(camera_rotation.x < -(3.1415f/2.0f)) 
-                    camera_rotation.x = -90;
+                    camera_rotation.x = -(3.1415f/2.0f);
                 
             } break;
         }
     }
     
-    tc_vec3f_s   camera_position;
+    tc_vec3_s   camera_position;
     tc_get_viewer_position(&camera_position.x, &camera_position.y, &camera_position.z);
     
     if(shift_pressed)
@@ -240,7 +325,7 @@ bool update()
     
     
     
-    tc_vec3f_s       difference_in_perspective;
+    tc_vec3_s       difference_in_perspective;
     difference_in_perspective.x         = 0.0f;
     difference_in_perspective.y         = 0.0f;
     difference_in_perspective.z         = 0.0f;
@@ -270,9 +355,9 @@ bool update()
     
     mat4x4_translate(position_matrix, difference_in_perspective.x, 0.0f, difference_in_perspective.z);
     
-    mat4x4_rotate_Z(position_matrix, position_matrix, tc_deg_to_rad(camera_rotation.z));
+    mat4x4_rotate_X(position_matrix, position_matrix, camera_rotation.x);
-    mat4x4_rotate_Y(position_matrix, position_matrix, tc_deg_to_rad(camera_rotation.y));
+    mat4x4_rotate_Y(position_matrix, position_matrix, camera_rotation.y);
-    mat4x4_rotate_X(position_matrix, position_matrix, tc_deg_to_rad(camera_rotation.x));
+    mat4x4_rotate_Z(position_matrix, position_matrix, camera_rotation.z);
     
     vec4            viewed_difference = { difference_in_perspective.x, 0.0f, difference_in_perspective.z };
     vec4            raw_difference = { 0.0f, 0.0f, 0.0f };
@@ -286,13 +371,10 @@ bool update()
     
     tc_game_state_g.main_world->spawn_loader->center.x        = ((int32_t) camera_position.x) / 32 - UPDATE_DISTANCE;
     tc_game_state_g.main_world->spawn_loader->center.y        = ((int32_t) camera_position.y) / 32 - UPDATE_DISTANCE;
-    tc_game_state_g.main_world->spawn_loader->center.z        = - ((int32_t) camera_position.z) / 32 - UPDATE_DISTANCE;
+    tc_game_state_g.main_world->spawn_loader->center.z        = ((int32_t) camera_position.z) / 32 - UPDATE_DISTANCE;
     
     tc_update_world(tc_game_state_g.main_world);
     
-    // uint64_t            current_ms              = SDL_GetTicks64();
-    // uint32_t            ticks_between           = current_ms - tc_last_update;
-    
     return true;
 }
 
@@ -307,8 +389,6 @@ int main(int argc, char **argv)
         {
                 frame_index = -1;
         }
-        tc_tick_intervals();
-        
         render();
         
         if(frame_index == 1)
@@ -317,7 +397,7 @@ int main(int argc, char **argv)
         }
         
         ++frame_index;
-        SDL_Delay(2);
+        SDL_Delay(1000/60);
     }
     
     tc_cleanup();

code/source-c/shaders.c

@@ -92,10 +92,3 @@ tc_shader_program_s tc_make_shader_program(char *vertex_path, char *fragment_pat
     return shader_program;
 }
 
-void tc_shader_uniform_mat4f(tc_shader_program_s *program, char *location, tc_mat4f_s matrix)
-{
-    int                 location_id =
-        glGetUniformLocation(program->program_id, location);
-    glUniformMatrix4fv(location_id, 1, GL_TRUE, &matrix.values[0][0]);
-}
-

code/source-c/shaders.h

@@ -9,8 +9,6 @@
 
 #include <glad/glad.h>
 
-#include <utility/math.h>
-
 typedef struct tc_shader_program
 {
     uint32_t                program_id;
@@ -19,8 +17,5 @@ typedef struct tc_shader_program
 
 tc_shader_program_s tc_make_shader_program(char *vertex_path, char *fragment_path);
 
-void                tc_shader_uniform_mat4f         (tc_shader_program_s *program, char *location, tc_mat4f_s matrix);
-
-
 #endif
 

code/source-c/state.h

@@ -6,17 +6,17 @@
 #include <stdint.h>
 #include <SDL2/SDL.h>
 
-#include <assets.h>
+#include "assets.h"
-#include <shaders.h>
+#include "shaders.h"
-#include <entity.h>
+#include "entity.h"
-#include <blocks.h>
+#include "blocks.h"
-#include <world.h>
+#include "world.h"
-#include <utility/utility.h>
+#include "utility.h"
 
 typedef struct tc_camera
 {
-    tc_vec3f_s              position;
+    tc_vec3_s               position;
-    tc_vec3f_s              rotation;
+    tc_vec3_s               rotation;
     float                   fov;
     
 } tc_camera_s;
@@ -41,9 +41,6 @@ typedef struct
     tc_entity_s            *viewer;
     tc_entity_s            *player;
     
-    uint16_t                fps;
-    uint16_t                tps;
-    
     tc_image_s             *block_texture_atlas;
     
 } techneck_s;

code/source-c/utility.h

@@ -0,0 +1,36 @@
+
+#ifndef TC_UTILITY_H
+#define TC_UTILITY_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef struct tc_vec3
+{
+    float               x;
+    float               y;
+    float               z;
+    
+} tc_vec3_s;
+
+typedef struct tc_vec3i
+{
+    int32_t             x;
+    int32_t             y;
+    int32_t             z;
+    
+} tc_vec3i_s;
+
+bool tc_vec3i_equ(tc_vec3i_s first, tc_vec3i_s second);
+
+typedef struct tc_object
+{
+    uint32_t            vbo;
+    uint32_t            vao;
+    tc_vec3_s           position;
+    tc_vec3_s           rotation;
+    
+} tc_object_s;
+
+#endif
+

code/source-c/utility/math.c

@@ -1,12 +0,0 @@
-#include <utility/math.h>
-
-f32_t tc_deg_to_rad(f32_t degrees)
-{
-    return (degrees / 360.0f) * (3.1415 * 2.0f);
-}
-
-f32_t tc_rad_to_deg(f32_t radians)
-{
-    return radians / (3.1415*2.0f) * 360.0f;
-}
-

code/source-c/utility/math.h

@@ -1,96 +0,0 @@
-
-#ifndef TC_MATH_H
-#define TC_MATH_H
-
-#include <utility/utility.h>
-
-typedef struct  tc_vec4f            tc_vec4f_s;
-typedef struct  tc_vec3f            tc_vec3f_s;
-typedef struct  tc_vec2f            tc_vec2f_s;
-
-typedef struct  tc_vec4i            tc_vec4i_s;
-typedef struct  tc_vec3i            tc_vec3i_s;
-typedef struct  tc_vec2i            tc_vec2i_s;
-
-typedef struct  tc_mat4f            tc_mat4f_s;
-typedef struct  tc_mat3f            tc_mat3f_s;
-
-struct tc_vec4f
-{
-    f32_t               x;
-    f32_t               y;
-    f32_t               z;
-    f32_t               w;
-};
-
-struct tc_vec3f
-{
-    f32_t               x;
-    f32_t               y;
-    f32_t               z;
-};
-
-struct tc_vec2f
-{
-    f32_t               x;
-    f32_t               y;
-};
-
-struct tc_vec4i
-{
-    i32_t               x;
-    i32_t               y;
-    i32_t               z;
-    i32_t               w;
-};
-
-struct tc_vec3i
-{
-    i32_t               x;
-    i32_t               y;
-    i32_t               z;
-};
-
-struct tc_vec2i
-{
-    i32_t               x;
-    i32_t               y;
-};
-
-
-
-struct tc_mat4f
-{
-    f32_t               values[4][4];
-};
-
-struct tc_mat3f
-{
-    f32_t               values[3][3];
-};
-
-f32_t       tc_deg_to_rad           (f32_t degrees);
-f32_t       tc_rad_to_deg           (f32_t radians);
-
-bool_t      tc_vec4f_equ            (tc_vec4f_s vector_1, tc_vec4f_s vector_2);
-bool_t      tc_vec3f_equ            (tc_vec3f_s vector_1, tc_vec3f_s vector_2);
-bool_t      tc_vec2f_equ            (tc_vec2f_s vector_1, tc_vec2f_s vector_2);
-
-bool_t      tc_vec4i_equ            (tc_vec4i_s vector_1, tc_vec4i_s vector_2);
-bool_t      tc_vec3i_equ            (tc_vec3i_s vector_1, tc_vec3i_s vector_2);
-bool_t      tc_vec2i_equ            (tc_vec2i_s vector_1, tc_vec2i_s vector_2);
-
-tc_mat4f_s  tc_mat4f_identity       ();
-tc_mat3f_s  tc_mat3f_identity       ();
-
-tc_mat4f_s  tc_mat4_rotate_x        (tc_mat4f_s matrix, float radians);
-tc_mat4f_s  tc_mat4_rotate_y        (tc_mat4f_s matrix, float radians);
-tc_mat4f_s  tc_mat4_rotate_z        (tc_mat4f_s matrix, float radians);
-
-tc_mat4f_s  tc_mat4f_translate      (tc_mat4f_s matrix, tc_vec3f_s translation);
-tc_mat3f_s  tc_mat3f_translate      (tc_mat3f_s matrix, tc_vec3f_s translation);
-
-tc_mat4f_s  tc_mat4f_perspective    (float fov, float aspect_ratio, float near, float far);
-
-#endif // TC_MATH_H
-

code/source-c/utility/matrix.c

@@ -1,169 +0,0 @@
-#include <utility/math.h>
-
-#include <math.h>
-
-tc_mat4f_s tc_mat4f_zero()
-{
-    tc_mat4f_s              matrix;
-    matrix.values[0][0]             = 0.0f;
-    matrix.values[0][1]             = 0.0f;
-    matrix.values[0][2]             = 0.0f;
-    matrix.values[0][3]             = 0.0f;
-    
-    matrix.values[1][0]             = 0.0f;
-    matrix.values[1][1]             = 0.0f;
-    matrix.values[1][2]             = 0.0f;
-    matrix.values[1][3]             = 0.0f;
-    
-    matrix.values[2][0]             = 0.0f;
-    matrix.values[2][1]             = 0.0f;
-    matrix.values[2][2]             = 0.0f;
-    matrix.values[2][3]             = 0.0f;
-    
-    matrix.values[3][0]             = 0.0f;
-    matrix.values[3][1]             = 0.0f;
-    matrix.values[3][2]             = 0.0f;
-    matrix.values[3][3]             = 0.0f;
-    
-    return matrix;
-}
-
-tc_mat4f_s tc_mat4f_identity()
-{
-    tc_mat4f_s              matrix;
-    matrix.values[0][0]             = 1.0f;
-    matrix.values[0][1]             = 0.0f;
-    matrix.values[0][2]             = 0.0f;
-    matrix.values[0][3]             = 0.0f;
-    
-    matrix.values[1][0]             = 0.0f;
-    matrix.values[1][1]             = 1.0f;
-    matrix.values[1][2]             = 0.0f;
-    matrix.values[1][3]             = 0.0f;
-    
-    matrix.values[2][0]             = 0.0f;
-    matrix.values[2][1]             = 0.0f;
-    matrix.values[2][2]             = 1.0f;
-    matrix.values[2][3]             = 0.0f;
-    
-    matrix.values[3][0]             = 0.0f;
-    matrix.values[3][1]             = 0.0f;
-    matrix.values[3][2]             = 0.0f;
-    matrix.values[3][3]             = 1.0f;
-    
-    return matrix;
-}
-
-tc_mat3f_s tc_mat3f_identity()
-{
-    tc_mat3f_s              matrix;
-    matrix.values[0][0]             = 1.0f;
-    matrix.values[0][1]             = 0.0f;
-    matrix.values[0][2]             = 0.0f;
-    
-    matrix.values[1][0]             = 0.0f;
-    matrix.values[1][1]             = 1.0f;
-    matrix.values[1][2]             = 0.0f;
-    
-    matrix.values[2][0]             = 0.0f;
-    matrix.values[2][1]             = 0.0f;
-    matrix.values[2][2]             = 1.0f;
-    
-    return matrix;
-}
-
-tc_mat4f_s tc_mat4f_multiply(tc_mat4f_s first, tc_mat4f_s second)
-{
-    tc_mat4f_s          result;
-    
-    u32_t               k, r, c;
-	for(c = 0; c < 4; ++c)
-	{
-	    for(r = 0; r < 4; ++r)
-	    {
-	        result.values[c][r] = 0.f;
-	        for(k=0; k<4; ++k)
-	        {
-		        result.values[c][r] += first.values[k][r] * second.values[c][k];
-            }
-		}
-	}
-	
-	return result;
-}
-
-
-
-tc_mat4f_s tc_mat4_rotate_x(tc_mat4f_s matrix, float radians)
-{
-    tc_mat4f_s          rotation        = tc_mat4f_identity();
-    rotation.values[1][1]               =  cosf(radians);
-    rotation.values[1][2]               = -sinf(radians);
-    rotation.values[2][1]               =  sinf(radians);
-    rotation.values[2][2]               =  cosf(radians);
-    
-    return tc_mat4f_multiply(matrix, rotation);
-}
-
-tc_mat4f_s tc_mat4_rotate_y(tc_mat4f_s matrix, float radians)
-{
-    tc_mat4f_s          rotation        = tc_mat4f_identity();
-    rotation.values[0][0]               =  cosf(radians);
-    rotation.values[0][2]               =  sinf(radians);
-    rotation.values[2][0]               = -sinf(radians);
-    rotation.values[2][2]               =  cosf(radians);
-    
-    return tc_mat4f_multiply(matrix, rotation);
-}
-
-tc_mat4f_s tc_mat4_rotate_z(tc_mat4f_s matrix, float radians)
-{
-    tc_mat4f_s          rotation        = tc_mat4f_identity();
-    rotation.values[0][0]               =  cosf(radians);
-    rotation.values[0][1]               = -sinf(radians);
-    rotation.values[1][0]               =  sinf(radians);
-    rotation.values[1][1]               =  cosf(radians);
-    
-    return tc_mat4f_multiply(matrix, rotation);
-}
-
-
-
-tc_mat4f_s tc_mat4f_translate(tc_mat4f_s matrix, tc_vec3f_s translation)
-{
-    matrix.values[0][3]        += translation.x;
-    matrix.values[1][3]        += translation.y;
-    matrix.values[2][3]        += translation.z;
-    
-    return matrix;
-}
-
-tc_mat3f_s tc_mat3f_translate(tc_mat3f_s matrix, tc_vec3f_s translation)
-{
-    matrix.values[0][2]        += translation.x;
-    matrix.values[1][2]        += translation.y;
-    matrix.values[2][2]        += translation.z;
-    
-    return matrix;
-}
-
-
-
-tc_mat4f_s tc_mat4f_perspective(float fov, float aspect_ratio, float near, float far)
-{
-    float           range               = tanf(fov / 2) * near;
-    float           scale_x             = (2 * near) / (range * aspect_ratio * 2);
-    float           scale_y             = near / range;
-    float           scale_z             = -(far + near) / (far - near);
-    float           position_z          = -(2 * far * near) / (far - near);
-    
-    tc_mat4f_s      matrix              = tc_mat4f_zero();
-    matrix.values[0][0]                 = scale_x;
-    matrix.values[1][1]                 = scale_y;
-    matrix.values[2][2]                 = scale_z;
-    matrix.values[3][2]                 = -1.0f;
-    matrix.values[2][3]                 = position_z;
-    
-    return matrix;
-}
-

code/source-c/utility/utility.h

@@ -1,23 +0,0 @@
-
-#ifndef TC_UTILITY_H
-#define TC_UTILITY_H
-
-typedef     unsigned char       u8_t;
-typedef     unsigned short      u16_t;
-typedef     unsigned int        u32_t;
-typedef     unsigned long       u64_t;
-
-typedef     signed char         i8_t;
-typedef     signed short        i16_t;
-typedef     signed int          i32_t;
-typedef     signed long         i64_t;
-
-typedef     float               f32_t;
-typedef     double              f64_t;
-
-typedef     unsigned char       bool_t;
-#define         TRUE                1
-#define         FALSE               0
-
-#endif
-

code/source-c/utility/vector.c

@@ -1,52 +0,0 @@
-#include <utility/math.h>
-
-bool_t tc_vec4f_equ(tc_vec4f_s vector_1, tc_vec4f_s vector_2)
-{
-    if(vector_1.x != vector_2.x) return FALSE;
-    if(vector_1.y != vector_2.y) return FALSE;
-    if(vector_1.z != vector_2.z) return FALSE;
-    if(vector_1.w != vector_2.w) return FALSE;
-    return TRUE;
-}
-
-bool_t tc_vec3f_equ(tc_vec3f_s vector_1, tc_vec3f_s vector_2)
-{
-    if(vector_1.x != vector_2.x) return FALSE;
-    if(vector_1.y != vector_2.y) return FALSE;
-    if(vector_1.z != vector_2.z) return FALSE;
-    return TRUE;
-}
-
-bool_t tc_vec2f_equ(tc_vec2f_s vector_1, tc_vec2f_s vector_2)
-{
-    if(vector_1.x != vector_2.x) return FALSE;
-    if(vector_1.y != vector_2.y) return FALSE;
-    return TRUE;
-}
-
-
-
-bool_t tc_vec4i_equ(tc_vec4i_s vector_1, tc_vec4i_s vector_2)
-{
-    if(vector_1.x != vector_2.x) return FALSE;
-    if(vector_1.y != vector_2.y) return FALSE;
-    if(vector_1.z != vector_2.z) return FALSE;
-    if(vector_1.w != vector_2.w) return FALSE;
-    return TRUE;
-}
-
-bool_t tc_vec3i_equ(tc_vec3i_s vector_1, tc_vec3i_s vector_2)
-{
-    if(vector_1.x != vector_2.x) return FALSE;
-    if(vector_1.y != vector_2.y) return FALSE;
-    if(vector_1.z != vector_2.z) return FALSE;
-    return TRUE;
-}
-
-bool_t tc_vec2i_equ(tc_vec2i_s vector_1, tc_vec2i_s vector_2)
-{
-    if(vector_1.x != vector_2.x) return FALSE;
-    if(vector_1.y != vector_2.y) return FALSE;
-    return TRUE;
-}
-

code/source-c/vector.c

@@ -0,0 +1,9 @@
+#include "utility.h"
+
+bool tc_vec3i_equ(tc_vec3i_s first, tc_vec3i_s second)
+{
+    if(first.x != second.x) return false;
+    if(first.y != second.y) return false;
+    if(first.z != second.z) return false;
+    return true;
+}

code/source-c/world.c

@@ -1,10 +1,10 @@
-#include <world.h>
+#include "world.h"
-#include <state.h>
+#include "state.h"
+#include <linmath.h>
 
 #include <stdlib.h>
 
 tc_worldgen_s tc_default_terrain_generator_g;
-tc_entity_type_s *tc_chunk_entity_type_g = NULL;
 
 void tc_upload_chunk(tc_chunk_s *chunk)
 {
@@ -36,23 +36,17 @@ void tc_upload_chunk(tc_chunk_s *chunk)
     );
     glBindVertexArray(0);
 }
-
+void tc_draw_chunk(tc_chunk_s *chunk, tc_world_s *world)
-void tc_draw_chunk_entity(tc_entity_s *entity)
 {
-    tc_chunk_s         *chunk           = entity->specific;
+    mat4x4              model_matrix;
+    mat4x4_identity(model_matrix);
+    mat4x4_translate_in_place(model_matrix, chunk->position.x*32, chunk->position.y*32, -chunk->position.z*32);
     
-    tc_mat4f_s          model_matrix    = tc_mat4f_identity();
+    int                 model_matrix_uniform_location =
-    
+        glGetUniformLocation(tc_game_state_g.renderer.draw_shader.program_id, "model_matrix");
-    tc_vec3f_s          position_3f;
+    glUniformMatrix4fv(model_matrix_uniform_location, 1, GL_FALSE, &model_matrix[0][0]);
-    position_3f.x           = chunk->position.x * 32;
-    position_3f.y           = chunk->position.y * 32;
-    position_3f.z           = chunk->position.z * 32;
-    
-    model_matrix            =
-      tc_mat4f_translate(model_matrix, position_3f);
-    
-    tc_shader_uniform_mat4f(&tc_game_state_g.renderer.draw_shader, "model_matrix", model_matrix);
     
+    // glBindVertexArray(chunk->vao);
     glBindBuffer(GL_ARRAY_BUFFER, chunk->vertex_data);
     glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *) 0);
     glEnableVertexAttribArray(0);
@@ -82,77 +76,8 @@ void tc_init_world_generators()
     tc_default_terrain_generator_g.fn_generate_chunk    = &tc_generate_default_terrain_chunk;
 }
  
-
-
-tc_entity_s * tc_create_chunk_entity()
-{
-    tc_entity_s            *chunk       = tc_allocate_entity();
-    tc_set_string_for_entity(chunk, "type", "chunk");
-    tc_set_integer_for_entity(chunk, "grid_x", 0);
-    tc_set_integer_for_entity(chunk, "grid_y", 0);
-    tc_set_integer_for_entity(chunk, "grid_z", 0);
-    chunk->specific         = tc_allocate_chunk();
-    
-    return chunk;
-}
-
-void tc_spawn_chunk_entity(tc_entity_s *entity, tc_location_s location)
-{
-    
-    
-    
-}
-
-void tc_teleport_chunk_entity(tc_entity_s *entity, tc_location_s location)
-{
-    tc_chunk_s         *chunk           = entity->specific;
-    chunk->world            = location.world;
-    chunk->position.x       = location.position.x / 32;
-    chunk->position.y       = location.position.y / 32;
-    chunk->position.z       = location.position.z / 32;
-    
-    
-    
-}
-
-void tc_delete_chunk_entity(tc_entity_s *entity)
-{
-    tc_free_chunk(entity->specific);
-    
-    
-    
-}
-
-void tc_receive_chunk_entity_event(tc_entity_s *entity, tc_entity_event_s event)
-{
-    
-    
-    
-}
-
-void tc_add_chunk_entity_type()
-{
-    tc_fn_entity_s          chunk_functions;
-    chunk_functions.fn_create       = &tc_create_chunk_entity;
-    chunk_functions.fn_spawn        = &tc_spawn_chunk_entity;
-    chunk_functions.fn_teleport     = &tc_teleport_chunk_entity;
-    chunk_functions.fn_draw         = &tc_draw_chunk_entity;
-    chunk_functions.fn_delete       = &tc_delete_chunk_entity;
-    chunk_functions.fn_send_event   = &tc_receive_chunk_entity_event;
-    
-    tc_entity_type_s        chunk_type;
-    chunk_type.internal_name        = "chunk";
-    chunk_type.display_name         = NULL;
-    chunk_type.functions            = chunk_functions;
-    
-    tc_register_entity_type(chunk_type);
-    tc_chunk_entity_type_g = tc_get_entity_type_with_name("chunk");
-}
- 
 void tc_init_worlds()
 {
-    tc_init_chunk_pool(256);
-    tc_add_chunk_entity_type();
     tc_init_world_generators();
 }
 
@@ -166,10 +91,14 @@ void tc_set_block_in_chunk(
     chunk->blocks[x][y][z]      = block.type_identifier;
 }
 
+
 void tc_draw_world(tc_world_s *world)
 {
-    tc_draw_all_entities_of_type("chunk");
+    for(uint32_t loader_index = 0; loader_index < world->num_loaders; ++loader_index)
+        for(uint32_t chunk_index = 0; chunk_index < world->loaders[loader_index].num_chunks; ++chunk_index)
+            tc_draw_chunk(world->loaders[loader_index].chunks[chunk_index], world);
 }
+
 tc_chunkloader_s tc_create_chunkloader(tc_world_s *world)
 {
     tc_chunkloader_s        loader;
@@ -199,6 +128,7 @@ tc_chunkloader_s tc_create_spawn_loader(tc_world_s *world)
 tc_world_s * tc_new_world(tc_worldgen_s *generator)
 {
     tc_world_s             *world               = calloc(sizeof(tc_world_s), 1);
+    world->pool                 = tc_new_chunk_pool(512);
     world->worldgen             = &tc_default_terrain_generator_g;
     world->num_loaders          = 1;
     world->loaders              = malloc(sizeof(tc_chunkloader_s) * world->num_loaders);

code/source-c/world.h

@@ -5,8 +5,8 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-#include <blocks.h>
+#include "blocks.h"
-#include <utility/math.h>
+#include "utility.h"
 
 
 #define UPDATE_DISTANCE 2
@@ -30,14 +30,14 @@ struct tc_worldgen
 struct tc_block
 {
     uint32_t            type_identifier;
-    tc_vec3f_s          position;
+    tc_vec3_s           position;
-    tc_vec3f_s          rotation;
+    tc_vec3_s           rotation;
+    tc_object_s         drawing;
     
 };
 
 struct tc_chunk
 {
-    tc_world_s                 *world;
     tc_chunk_pool_entry_s      *pool_entry;
     
     tc_vec3i_s                  position;
@@ -75,8 +75,6 @@ typedef struct tc_chunkloader
 
 struct tc_chunk_pool
 {
-    tc_world_s                 *world;
-    
     uint32_t                    capacity;
     uint32_t                    used_entries;
     tc_chunk_pool_entry_s      *entries;
@@ -132,9 +130,9 @@ void                tc_on_each_loaded_chunk                 (
     void *userdata
 );
 
-void                tc_init_chunk_pool                      (uint32_t capacity);
+tc_chunk_pool_s *   tc_new_chunk_pool                       (uint32_t capacity);
-tc_chunk_s *        tc_allocate_chunk                       ();
+tc_chunk_s *        tc_allocate_chunk                       (tc_world_s *world);
-void                tc_free_chunk                           (tc_chunk_s *chunk);
+void                tc_free_chunk                           (tc_world_s *world, tc_chunk_s *chunk);
 
 #endif