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 code/source-c/physics/*.c dependencies/build/glad.o \
+    code/source-c/*.c code/source-c/entity/*.c code/source-c/utility/*.c dependencies/build/glad.o \
     -I dependencies/include -I code/source-c/ -lGL -lSDL2 -lm -Wall
 

code/source-c/chunk_loader.c

@@ -63,13 +63,12 @@ tc_entity_s * tc_load_chunk_of_loader(tc_chunkloader_s *loader, tc_vec3i_s coord
     
     if(entity == NULL)
     {
-        tc_entity_s            *entity             = tc_create_entity("chunk", loader->world);
+        tc_entity_s            *entity             = tc_create_entity("chunk"); // TODO: FURTHER RESTRUCTUING FOR ENTITIES
         tc_chunk_s             *chunk           = entity->specific;
         chunk                   = entity->specific;
         chunk->position         = coord;
         
         loader->world->worldgen->fn_generate_chunk(loader->world->worldgen, chunk);
-        tc_run_hooklist(&loader->world->after_chunk_generate, chunk);
         tc_upload_chunk(chunk);
         
         tc_add_chunk_to_loader(loader, entity);
@@ -83,7 +82,7 @@ void tc_reload_chunk_of_loader(tc_chunkloader_s *loader, tc_vec3i_s coord)
     tc_chunk_s  *chunk  = entity->specific;
     if(chunk == NULL) return;
     
-    tc_meshize_chunk(chunk, NULL);
+    tc_meshize_chunk(chunk);
     tc_upload_chunk(chunk);
 }
 

code/source-c/entity.c

@@ -77,7 +77,7 @@ void tc_add_entity_instance_to_type(tc_entity_type_s *type, tc_entity_s *entity)
     ++type->num_instances;
 }
 
-tc_entity_s * tc_create_entity(char *type, void *userdata)
+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;
@@ -89,7 +89,7 @@ tc_entity_s * tc_create_entity(char *type, void *userdata)
     entity->attributes              =
         calloc(sizeof(tc_entity_attribute_s), entity->attributes_capacity);
     
-    type_struct->functions.fn_create(entity, userdata);
+    type_struct->functions.fn_create(entity);
     
     tc_add_entity_instance_to_type(type_struct, entity);
     
@@ -137,15 +137,15 @@ void tc_delete_entity(tc_entity_s *entity)
 tc_entity_attribute_s * tc_get_entity_attribute_with_name(tc_entity_s *entity, char *name)
 {
     u32_t        attribute_index         = 0;
-    while(attribute_index < entity->num_attributes)
+    while(attribute_index < entity->attributes_capacity)
     {
         tc_entity_attribute_s attribute               = entity->attributes[attribute_index];
         if(attribute.name == NULL)
         {
-            puts("NAAJAA");
             ++attribute_index;
             continue;
         }
+        
         if(!strcmp(attribute.name, name)) return &entity->attributes[attribute_index];
         ++attribute_index;
     }

code/source-c/entity.h

@@ -17,7 +17,7 @@ typedef struct tc_entity_registry           tc_entity_registry_s;
 
 typedef struct
 {
-    void                      (*fn_create)          (tc_entity_s *entity, void *userdata);
+    void                      (*fn_create)          (tc_entity_s *entity);
     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);
@@ -125,7 +125,7 @@ void                            tc_register_entity_type         (tc_entity_type_
 
 tc_entity_type_s *              tc_get_entity_type_with_name    (char *name);
 
-tc_entity_s *                   tc_create_entity                (char *type, void *userdata);
+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);

code/source-c/entity/player.c

@@ -1,5 +1,4 @@
 #include "registration.h"
-#include <state.h>
 
 #include <stdlib.h>
 
@@ -21,9 +20,7 @@ void tc_fn_spawn_player_entity(tc_entity_s *entity, tc_location_s location)
 
 void tc_fn_teleport_player_entity(tc_entity_s *entity, tc_location_s location)
 {
-    tc_set_float_for_entity(tc_game_state_g.viewer, "pos_x", location.position.x);
-    tc_set_float_for_entity(tc_game_state_g.viewer, "pos_y", location.position.y);
-    tc_set_float_for_entity(tc_game_state_g.viewer, "pos_z", location.position.z);
+    entity->location                = location;
 }
 
 void tc_fn_delete_player_entity(tc_entity_s *entity)

code/source-c/hook.c

@@ -1,35 +0,0 @@
-#include <hook.h>
-
-#include <stdlib.h>
-#include <stdio.h>
- 
-tc_hooklist_s tc_new_hooklist(u32_t capacity)
-{
-    tc_hooklist_s           hooklist;
-    hooklist.capacity           = capacity;
-    hooklist.num_hooks          = 0;
-    hooklist.hooks              = malloc(sizeof(tc_hook_s)); 
-    
-    return hooklist;
-}
-
-void tc_add_to_hooklist(tc_hooklist_s *list, tc_fn_hook function, void *userdata)
-{
-    if(list->num_hooks >= list->capacity)
-    {
-        puts("hook.c: Hook-Capacity exceeded!\n");
-        return;
-    }
-    list->hooks[list->num_hooks].function     = function;
-    list->hooks[list->num_hooks].userdata     = userdata;
-    ++list->num_hooks;
-}
-
-void tc_run_hooklist(tc_hooklist_s *list, void *subject)
-{
-    for(u32_t index = 0; index < list->num_hooks; ++index)
-    {
-        list->hooks[index].function(subject, list->hooks[index].userdata);
-    }
-}
-

code/source-c/hook.h

@@ -1,29 +0,0 @@
-
-#ifndef TC_HOOK_H
-#define TC_HOOK_H
-
-#include <utility/utility.h>
-
-typedef bool_t (*tc_fn_hook)         (void *subject, void *userdata);
-
-typedef struct tc_hook
-{
-    tc_fn_hook          function;
-    void               *userdata;
-    
-} tc_hook_s;
-
-typedef struct tc_hooklist
-{
-    u32_t               capacity;
-    u32_t               num_hooks;
-    tc_hook_s          *hooks;
-    
-} tc_hooklist_s;
-
-tc_hooklist_s               tc_new_hooklist         (u32_t capacity);
-void                        tc_add_to_hooklist      (tc_hooklist_s *list, tc_fn_hook function, void *subject);
-void                        tc_run_hooklist         (tc_hooklist_s *list, void *subject);
-
-#endif // TC_HOOK_h
-

code/source-c/initialization.c

@@ -69,24 +69,13 @@ void tc_init()
     tc_create_blocks();
     tc_game_state_g.entity_registry     = tc_init_entity_registry();
     tc_register_entities();
-    
-    tc_game_state_g.on_world_create     = tc_new_hooklist(16);
-    tc_add_to_hooklist(&tc_game_state_g.on_world_create, tc_create_world_physics, NULL);
-    
+    tc_game_state_g.player              = tc_create_entity("player");
+    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.player              = tc_create_entity("player", NULL);
-    tc_game_state_g.viewer              = tc_game_state_g.player;
-    
-    tc_location_s       spawn_location;
-    spawn_location.world                = tc_game_state_g.main_world;
-    spawn_location.position.x           = 0.0f;
-    spawn_location.position.y           = 36.0f;
-    spawn_location.position.z           = 0.0f;
-    tc_teleport_entity(tc_game_state_g.player, spawn_location);
-    
     tc_game_state_g.tps                 = 120;
     
+    
     puts("Finished initializing!");
 }
 

code/source-c/main.c

@@ -212,8 +212,8 @@ bool update()
             case SDL_MOUSEMOTION:
             {
                 if(!(event.motion.state & SDL_BUTTON_LMASK)) break;
-                camera_rotation.y += event.motion.xrel / 5.0f;
-                camera_rotation.x += event.motion.yrel / 5.0f;
+                camera_rotation.y += event.motion.xrel / 10.0f;
+                camera_rotation.x += event.motion.yrel / 10.0f;
                 
                 if(camera_rotation.x > 90) 
                     camera_rotation.x = 90;
@@ -230,12 +230,12 @@ bool update()
     
     if(shift_pressed)
     {
-        camera_position.y -= 0.75;
+        camera_position.y -= 0.25;
     }
     
     if(go_up)
     {
-        camera_position.y += 0.75;
+        camera_position.y += 0.25;
     }
     
     

code/source-c/meshize.c

@@ -177,7 +177,7 @@ uint32_t tc_meshize_block(tc_chunk_s *chunk,
     return num_vertices;
 }
 
-void tc_meshize_chunk(tc_chunk_s *chunk, void *userdata)
+void tc_meshize_chunk(tc_chunk_s *chunk)
 {
     chunk->num_vertices             = tc_count_chunk_vertices(chunk);
     chunk->vertex_positions         = calloc(sizeof(float), 3 * chunk->num_vertices);

code/source-c/physics/aabb.c

@@ -1,16 +1,4 @@
 #include "primitives.h"
 
-tc_physics_mesh_s tc_wrap_aabb(tc_vec3f_s start, tc_vec3f_s size)
-{
-    tc_aabb_s               aabb;
-    aabb.start                  = start;
-    aabb.size                   = size;
 
-    tc_physics_mesh_s       mesh;
-    mesh.num_primitives                     = 1;
-    mesh.value.simple.primitive.type        = TC_PRIMITIVE_AABB;
-    mesh.value.simple.primitive.data.aabb   = aabb;
-    
-    return mesh;
-}
 

code/source-c/physics/obb.c

@@ -1,4 +1,3 @@
 #include "primitives.h"
 
 
-

code/source-c/physics/physics.c

@@ -1,117 +1,42 @@
 #include "simulation.h"
 
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-tc_physics_simulation_s * tc_new_physics_simulation()
+tc_physics_simulation_s tc_new_physics_simulation()
 {
-    tc_physics_simulation_s        *simulation      = malloc(sizeof(tc_physics_simulation_s));
-    simulation->root                    = tc_new_physics_group(simulation);
     
-    return simulation;
+    
+    
 }
 
 
 
-void tc_add_physics_object(tc_physics_simulation_s *simulation, tc_physics_entity_s *object)
+void tc_add_physics_object(tc_physics_simulation_s *simulation, tc_physics_entity object)
 {
-    tc_add_physics_object_to(simulation->root, object);
+    
+    
+    
 }
 
-void tc_add_physics_object_to(tc_physics_entity_s *container, tc_physics_entity_s *object)
+void tc_add_physics_object_to(tc_physics_entity_s *container, tc_physics_entity_s object)
 {
-    if((container->value.group.num_entities+1)
-        >=
-       container->value.group.entities_capacity
-    ) {
-        container->value.group.entities_capacity     *= 2;
-        container->value.group.entities =
-            realloc(container->value.group.entities, sizeof(tc_physics_entity_s *) * container->value.group.entities_capacity);
-    }
-    container->value.group.entities[container->value.group.num_entities] = object;
-    ++container->value.group.num_entities;
+    
+    
+    
 }
 
 
 
-tc_physics_entity_s * tc_new_physics_entity(tc_physics_simulation_s *simulation)
+tc_phyiscs_entity_s tc_new_physics_entity()
 {
-    tc_physics_entity_s        *entity      = malloc(sizeof(tc_physics_entity_s));;
-    entity->super                   = NULL;
-    entity->simulation              = simulation;
-    entity->relative_position.x     = 0.0f;
-    entity->relative_position.y     = 0.0f;
-    entity->relative_position.z     = 0.0f;
-    entity->type                    = TC_PHYSICS_ENTITY;
     
-    entity->value.entity.mesh.num_primitives    = 0;
-    entity->value.entity.name                   = NULL;
     
-    return entity;
+    
 }
 
-tc_physics_entity_s * tc_new_physics_group(tc_physics_simulation_s *simulation)
+void tc_tick_physics(tc_physics_simulation_s *simulation, float delta)
 {
-    tc_physics_entity_s        *entity      = malloc(sizeof(tc_physics_entity_s));;
-    entity->super                   = NULL;
-    entity->simulation              = simulation;
-    entity->relative_position.x     = 0.0f;
-    entity->relative_position.y     = 0.0f;
-    entity->relative_position.z     = 0.0f;
-    entity->type                    = TC_PHYSICS_ENTITY_GROUP;
-    
-    entity->value.group.entities_capacity       = 8;
-    entity->value.group.num_entities            = 0;
-    entity->value.group.entities =
-        calloc(sizeof(tc_physics_entity_s), entity->value.group.entities_capacity);
-    
-    return entity;
-}
     
     
     
-i32_t tc_physics_find_entity_in_group(tc_physics_entity_s *group, tc_physics_entity_s *entity)
-{
-    i32_t index = 0;
-    while(index < group->value.group.num_entities)
-    {
-        if(entity->super->value.group.entities[group->value.group.num_entities]
-            ==
-           entity
-          ) return index;
-        ++index;
-    }
-    return -1;
-}
-
-void tc_free_physics_entity(tc_physics_entity_s *entity)
-{
-    if(entity->type == TC_PHYSICS_ENTITY_GROUP)
-    {
-        for(u32_t index = 0; index < entity->value.group.num_entities; ++index)
-            tc_free_physics_entity(entity->value.group.entities[index]);
-    }
-    free(entity);
-}
-
-void tc_remove_physics_entity(tc_physics_entity_s *entity)
-{
-    u32_t                       num_entities    = entity->simulation->root->value.group.num_entities;
-    if(entity->super == NULL) return;
-    
-    i32_t                       index           = 0;
-    if((index = tc_physics_find_entity_in_group(entity->super, entity)) == -1) return;
-    
-    entity->super->value.group.entities[index]  = 
-        entity->super->value.group.entities[entity->super->value.group.num_entities-1];
-}
-
-
-
-void tc_tick_physics(tc_physics_simulation_s *simulation, f32_t delta)
-{
-    
 }
 
 

code/source-c/physics/primitives.h

@@ -5,7 +5,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-#include <utility/math.h>
+#include "../utility.h"
 
 typedef struct  tc_physics_mesh                 tc_physics_mesh_s;
 
@@ -29,40 +29,40 @@ typedef enum
 
 struct tc_aabb
 {
-    tc_vec3f_s                  start;
-    tc_vec3f_s                  size;
+    tc_vec3_s                   start;
+    tc_vec3_s                   size;
 };
 
 struct tc_obb
 {
-    tc_vec3f_s                  start;
-    tc_vec3f_s                  size;
-    tc_vec3f_s                  rotation;
+    tc_vec3_s                   start;
+    tc_vec3_s                   size;
+    tc_vec3_s                   rotation;
 };
 
 struct tc_plane
 {
-    tc_vec3f_s                  center;
-    tc_vec3f_s                  rotation;
+    tc_vec3_s                   center;
+    tc_vec3_s                   rotation;
     tc_vec2i_s                  size;
 };
 
 struct tc_ellipsoid
 {
-    tc_vec3f_s                  center;
-    tc_vec3f_s                  extent;
+    tc_vec3_s                   center;
+    tc_vec3_s                   extent;
 };
 
 struct tc_ray
 {
-    tc_vec3f_s                  start;
-    tc_vec3f_s                  rotation;
+    tc_vec3_s                   start;
+    tc_vec3_s                   rotation;
 };
 
 struct tc_line
 {
-    tc_vec3f_s                  start;
-    tc_vec3f_s                  end;
+    tc_vec3_s                   start;
+    tc_vec3_s                   end;
 };
 
 
@@ -72,13 +72,14 @@ typedef union tc_primitive
     tc_obb_s        obb;
     tc_plane_s      plane;
     tc_ellipsoid_s  sphere;
+    tc_plane_s      plane;
     
     tc_line_s       line;
     tc_ray_s        ray;
     
 } tc_primitive_u;
 
-typedef struct tc_primitive_container
+typedef struct tc_primitive
 {
     tc_primitive_type_e         type;
     tc_primitive_u              data;
@@ -87,24 +88,10 @@ typedef struct tc_primitive_container
 
 struct tc_physics_mesh
 {
-    u32_t                       num_primitives;
-    union
-    {
-        struct complex
-        {
-            u32_t                       primitives_capacity;
+    uint32_t                    primitives_capacity;
+    uint32_t                    num_primitives;
     tc_primitive_s             *primitives;
-        } complex;
-        struct simple
-        {
-            tc_primitive_s              primitive;
-            
-            
-        } simple;
-    } value;
 };
 
-tc_physics_mesh_s   tc_wrap_aabb        (tc_vec3f_s start, tc_vec3f_s size);
-
 #endif // TC_PHYSICS_PRIMITIVES_H
 

code/source-c/physics/raycast.c

@@ -1,4 +1,4 @@
-#include <physics/simulation.h>
+#include "primitives.h"
 
 tc_primitive_s * tc_cast_line(tc_physics_simulation_s *simulation, tc_line_s line)
 {

code/source-c/physics/simulation.h

@@ -4,23 +4,21 @@
 
 #include <stdint.h>
 
-#include <physics/primitives.h>
 #include <utility/utility.h>
-#include <entity.h>
+#include <../entity.h>
 
 typedef struct  tc_physics_entity               tc_physics_entity_s;
-typedef struct  tc_entity_physics_attributes    tc_entity_physics_attributes_s;
-typedef struct  tc_physics_simulation           tc_physics_simulation_s;
+typedef struct  tc_entity_physics_attributes    tc_entity_physics_attributes;
 
 struct tc_entity_physics_attributes
 {
-    bool_t          has_gravity;
+    bool            has_gravity;
     
-    bool_t          raw_movement;
-    bool_t          raw_rotation;
+    bool            raw_movement;
+    bool            raw_rotation;
     
-    tc_vec3f_s      acceleration;
-    tc_vec3f_s      spin;
+    tc_vec3_s       acceleration;
+    tc_vec3_s       spin;
 };
 
 typedef enum
@@ -32,51 +30,49 @@ typedef enum
 
 struct tc_physics_entity
 {
-    tc_physics_simulation_s    *simulation;
-    tc_physics_entity_s        *super;
+    tc_physics_entity          *super;
     
     // relative_position: The position of this physics entity relative to its super-entity
-    tc_vec3f_s                  relative_position;
+    tc_vec3_s                   relative_position;
         
-    tc_physics_entity_type_e    type;
+    tc_physics_entity_e         type;
     union specific
     {
         struct entity
         {
-            char                       *name;
-            tc_physics_mesh_s           mesh;
+            tc_entity_s                *entity;
             
         } entity;
         
         struct subentity_group
         {
-            u32_t                       entities_capacity;
-            u32_t                       num_entities;
-            tc_physics_entity_s       **entities;
+            uint32_t                    num_entities;
+            tc_physics_entity_s        *entities;
             
         } group;
         
     } value;
 };
 
-struct tc_physics_simulation
+typedef struct tc_physics_simulation
 {
-    tc_physics_entity_s        *root;
+    tc_vec3_s                   limits;
     
-};
+    tc_physics_entity_s         world_root;
     
-tc_physics_simulation_s *   tc_new_physics_simulation   ();
-void                        tc_add_physics_object       (tc_physics_simulation_s *simulation, tc_physics_entity_s *object);
-void                        tc_add_physics_object_to    (tc_physics_entity_s *container, tc_physics_entity_s *object);
+} tc_physics_simulation_s;
 
-tc_physics_entity_s *       tc_new_physics_entity       (tc_physics_simulation_s *simulation);
-tc_physics_entity_s *       tc_new_physics_group        (tc_physics_simulation_s *simulation);
+tc_physics_simulation_s     tc_new_physics_simulation   ();
+void                        tc_add_physics_object       (tc_physics_simulation_s *simulation, tc_physics_entity object);
+void                        tc_add_physics_object_to    (tc_physics_entity_s *container, tc_physics_entity_s object);
 
-void                        tc_remove_physics_entity    (tc_physics_entity_s *entity);
+tc_phyiscs_entity_s         tc_new_physics_entity       ();
 
-void                        tc_tick_physics             (tc_physics_simulation_s *simulation, f32_t delta);
+void                        tc_tick_physics             (tc_physics_simulation_s *simulation, float delta);
 
-tc_primitive_s *            tc_cast_line                (tc_physics_simulation_s *simulation, tc_line_s line);
+
+
+tc_primitive_s              tc_cast_line                (tc_physics_simulation_s *simulation, tc_line_s line);
 
 #endif
 

code/source-c/state.h

@@ -41,8 +41,6 @@ typedef struct
     tc_entity_s            *viewer;
     tc_entity_s            *player;
     
-    tc_hooklist_s           on_world_create;
-    
     uint16_t                fps;
     uint16_t                tps;
     

code/source-c/world.c

@@ -8,10 +8,11 @@ tc_entity_type_s *tc_chunk_entity_type_g = NULL;
 
 void tc_upload_chunk(tc_chunk_s *chunk)
 {
-    // If the chunk has no mesh, it's probably only air.
+    // If the chunk has no mesh yet
     if(chunk->num_vertices == 0)
     {
-        return;
+        // Create one
+        tc_meshize_chunk(chunk);
     }
     
     if(chunk->vao != 0) glDeleteVertexArrays(1, &chunk->vao);
@@ -82,20 +83,14 @@ void tc_init_world_generators()
 }
 
 
-// The userdata should be the corresponding world
-void tc_create_chunk_entity(tc_entity_s *entity, void *userdata)
-{
-    tc_chunk_s         *chunk           = tc_allocate_chunk();
-    tc_world_s         *world           = userdata;
 
+void tc_create_chunk_entity(tc_entity_s *entity)
+{
     tc_set_string_for_entity(entity, "type", "chunk");
     tc_set_integer_for_entity(entity, "grid_x", 0);
     tc_set_integer_for_entity(entity, "grid_y", 0);
     tc_set_integer_for_entity(entity, "grid_z", 0);
-    entity->specific        = chunk;
-    chunk->world            = world;
-    
-    tc_run_hooklist(&world->on_chunk_create, entity);
+    entity->specific        = tc_allocate_chunk();
 }
 
 void tc_spawn_chunk_entity(tc_entity_s *entity, tc_location_s location)
@@ -112,12 +107,13 @@ void tc_teleport_chunk_entity(tc_entity_s *entity, tc_location_s location)
     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_physics_entity_s    *physics_body        = tc_get_pointer_from_entity(entity, "physics_body");
-    tc_remove_physics_entity(physics_body);
     tc_free_chunk(entity->specific);
 }
 
@@ -201,15 +197,6 @@ tc_world_s * tc_new_world(tc_worldgen_s *generator)
     world->loaders              = malloc(sizeof(tc_chunkloader_s) * world->num_loaders);
     world->loaders[0]           = tc_create_spawn_loader(world);
     world->spawn_loader         = &world->loaders[0];
-    world->on_chunk_create      = tc_new_hooklist(16);
-    world->on_chunk_generate    = tc_new_hooklist(16);
-    world->after_chunk_generate = tc_new_hooklist(16);
-    world->on_chunk_delete      = tc_new_hooklist(16);
-    world->on_chunk_update      = tc_new_hooklist(16);
-    
-    tc_add_to_hooklist(&world->after_chunk_generate, tc_meshize_chunk, NULL);
-    
-    tc_run_hooklist(&tc_game_state_g.on_world_create, world);
     
     return world;
 }

code/source-c/world.h

@@ -5,8 +5,6 @@
 #include <stdbool.h>
 
 #include <blocks.h>
-#include <hook.h>
-#include <physics/simulation.h>
 #include <utility/math.h>
 #include <entity.h>
 
@@ -89,20 +87,16 @@ struct tc_chunk_pool
 
 struct tc_world
 {
+    // tc_chunk_s                 *center_chunk;
+    
     tc_chunk_pool_s            *pool;
     tc_worldgen_s              *worldgen;
     
     u32_t                    num_loaders;
     tc_chunkloader_s           *loaders;
     
+    // chunk_loading_center: The center of loading ON THE CHUNK GRID COORDINATES
     tc_chunkloader_s           *spawn_loader;
-    tc_physics_simulation_s    *physics;
-    
-    tc_hooklist_s               on_chunk_create;
-    tc_hooklist_s               on_chunk_generate;
-    tc_hooklist_s               after_chunk_generate;
-    tc_hooklist_s               on_chunk_delete;
-    tc_hooklist_s               on_chunk_update;
 };
 
 extern tc_worldgen_s tc_default_terrain_generator_g;
@@ -120,7 +114,7 @@ void tc_set_block_in_chunk(
 );
 
 u32_t               tc_count_chunk_vertices                 (tc_chunk_s *chunk);
-void                tc_meshize_chunk                        (tc_chunk_s *chunk, void *userdata);
+void                tc_meshize_chunk                        (tc_chunk_s *chunk);
 void                tc_upload_chunk                         (tc_chunk_s *chunk);
 
 bool                tc_generate_default_terrain_chunk       (tc_worldgen_s *gen, tc_chunk_s *chunk);
@@ -142,7 +136,5 @@ void                tc_init_chunk_pool                      (u32_t capacity);
 tc_chunk_s *        tc_allocate_chunk                       ();
 void                tc_free_chunk                           (tc_chunk_s *chunk);
 
-void                tc_create_world_physics                 (tc_world_s *world, void *userdata);
-
 #endif
 

code/source-c/world_physics.c

@@ -1,50 +0,0 @@
-#include <world.h>
-#include <stddef.h> // For NULL
-#include <stdio.h>
-
-void tc_initialize_chunk_physics(tc_entity_s *chunk_entity, void *userdata)
-{
-    tc_chunk_s                     *chunk               = chunk_entity->specific;
-    tc_world_s                     *world               = chunk->world;
-    tc_physics_simulation_s        *simulation          = world->physics;
-    
-    tc_physics_entity_s            *chunk_body          = tc_new_physics_group(simulation);
-    
-    tc_vec3f_s                      block_start;
-    block_start.x                       = -0.5f;
-    block_start.y                       = -0.5f;
-    block_start.z                       = -0.5f;
-    
-    tc_vec3f_s                      block_size;
-    block_size.x                        = 1.0f;
-    block_size.y                        = 1.0f;
-    block_size.z                        = 1.0f;
-    
-    tc_physics_mesh_s               block_mesh          = tc_wrap_aabb(block_start, block_size);
-    
-    for(u32_t x = 0; x < 32; ++x)
-        for(u32_t y = 0; y < 32; ++y)
-            for(u32_t z = 0; z < 32; ++z)
-            {
-                tc_physics_entity_s            *block_entity            = tc_new_physics_entity(simulation);
-                block_entity->relative_position.x   = x;
-                block_entity->relative_position.y   = y;
-                block_entity->relative_position.z   = z;
-                block_entity->type                  = TC_PHYSICS_ENTITY;
-                block_entity->value.entity.mesh     = block_mesh;
-                
-                tc_add_physics_object_to(chunk_body, block_entity);
-            }
-    
-    
-    tc_add_physics_object(world->physics, chunk_body);
-    tc_set_pointer_for_entity(chunk_entity, "physics_body", chunk_body);
-}
-
-void tc_create_world_physics(tc_world_s *world, void *userdata)
-{
-    world->physics              = tc_new_physics_simulation();
-    tc_add_to_hooklist(&world->on_chunk_create, &tc_initialize_chunk_physics, NULL);
-    tc_add_to_hooklist(&world->on_chunk_update, &tc_initialize_chunk_physics, NULL);
-}
-