refactor spatial

src/anim.cpp

···
 
 
 void
-anim::update_animation_components(
-    anim::ComponentSet *animation_component_set,
-    spatial::ComponentSet *spatial_component_set
-) {
+anim::update_animation_components(anim::ComponentSet *animation_component_set)
+{
     each (animation_component, animation_component_set->components) {
         if (!is_animation_component_valid(animation_component)) {
             continue;
···
     }
 
     if (spatial_component->parent_entity_handle != entities::NO_ENTITY_HANDLE) {
-        spatial::Component *parent =
-            engine::get_spatial_component(spatial_component->parent_entity_handle);
+        spatial::Component *parent = spatial::get_component(spatial_component->parent_entity_handle);
         return find_animation_component(parent);
     }
 

src/anim.hpp

···
         u32 idx_bone,
         u32 idx_anim_key
     );
-    static void update_animation_components(
-        ComponentSet *animation_component_set,
-        spatial::ComponentSet *spatial_component_set
-    );
+    static void update_animation_components(ComponentSet *animation_component_set);
     static void make_bone_matrices_for_animation_bone(
         Component *animation_component,
         aiNodeAnim *ai_channel,

src/behavior_functions.cpp

···
 void
 behavior_functions::test(entities::Handle entity_handle)
 {
-    spatial::Component *spatial_component =
-        engine::get_spatial_component(entity_handle);
+    spatial::Component *spatial_component = spatial::get_component(entity_handle);
     if (!spatial_component) {
         logs::error("Could not get spatial::Component for behavior::Component");
         return;
···
 void
 behavior_functions::char_movement_test(entities::Handle entity_handle)
 {
-    spatial::Component *spatial_component =
-        engine::get_spatial_component(entity_handle);
+    spatial::Component *spatial_component = spatial::get_component(entity_handle);
     if (!spatial_component) {
         logs::error("Could not get spatial::Component for behavior::Component");
         return;

src/core.cpp

···
 
     state->asset_memory_pool = asset_memory_pool;
 
+    spatial::init(&state->spatial_state, asset_memory_pool);
     engine::init(&state->engine_state, asset_memory_pool);
     mats::init(&state->materials_state, asset_memory_pool);
     input::init(&state->input_state, state->window);

src/debug_ui.cpp

···
     engine::State *engine_state = engine::debug_get_engine_state();
 
     entities::Handle handle = entity->handle;
-    spatial::Component *spatial_component = engine_state->spatial_component_set.components[handle];
+    spatial::Component *spatial_component = spatial::get_component(handle);
 
     // Children will be drawn under their parents.
     if (
···
     if (spatial::is_spatial_component_valid(spatial_component)) {
         // NOTE: This is super slow lol.
         u32 n_children_found = 0;
-        each (child_spatial_component, engine_state->spatial_component_set.components) {
+        each (child_spatial_component, *spatial::get_components()) {
             if (
                 child_spatial_component->parent_entity_handle ==
                 spatial_component->entity_handle

src/engine.cpp

···
 }
 
 
-Array<spatial::Component> *
-engine::get_spatial_components()
-{
-    return &engine::state->spatial_component_set.components;
-}
-
-
 Array<behavior::Component> *
 engine::get_behavior_components()
 {
···
 engine::get_light_component(entities::Handle entity_handle)
 {
     return engine::state->light_component_set.components[entity_handle];
-}
-
-
-spatial::Component *
-engine::get_spatial_component(entities::Handle entity_handle)
-{
-    return engine::state->spatial_component_set.components[entity_handle];
 }
 
 
···
 void engine::init(engine::State *engine_state, memory::Pool *asset_memory_pool) {
     engine::state = engine_state;
     engine::state->model_loaders = Array<models::ModelLoader>(
-        asset_memory_pool, MAX_N_MODELS, "model_loaders"
-    );
+        asset_memory_pool, MAX_N_MODELS, "model_loaders");
     engine::state->entity_loader_set = {
         .loaders = Array<models::EntityLoader>(
-            asset_memory_pool, MAX_N_ENTITIES, "entity_loaders", true, 1
-        )
+            asset_memory_pool, MAX_N_ENTITIES, "entity_loaders", true, 1)
     };
     engine::state->entity_set = {
         .entities = Array<entities::Entity>(
-            asset_memory_pool, MAX_N_ENTITIES, "entities", true, 1
-        )
+            asset_memory_pool, MAX_N_ENTITIES, "entities", true, 1)
     };
     engine::state->drawable_component_set = {
         .components = Array<drawable::Component>(
-            asset_memory_pool, MAX_N_ENTITIES, "drawable_components", true, 1
-        )
+            asset_memory_pool, MAX_N_ENTITIES, "drawable_components", true, 1)
     };
     engine::state->light_component_set = {
         .components = Array<lights::Component>(
-            asset_memory_pool, MAX_N_ENTITIES, "light_components", true, 1
-        )
-    };
-    engine::state->spatial_component_set = {
-        .components = Array<spatial::Component>(
-            asset_memory_pool, MAX_N_ENTITIES, "spatial_components", true, 1
-        )
+            asset_memory_pool, MAX_N_ENTITIES, "light_components", true, 1)
     };
     engine::state->behavior_component_set = {
         .components = Array<behavior::Component>(
-            asset_memory_pool, MAX_N_ENTITIES, "behavior_components", true, 1
-        )
+            asset_memory_pool, MAX_N_ENTITIES, "behavior_components", true, 1)
     };
     engine::state->animation_component_set = {
         .components = Array<anim::Component>(
-            asset_memory_pool, MAX_N_ENTITIES, "animation_components", true, 1
-        )
+            asset_memory_pool, MAX_N_ENTITIES, "animation_components", true, 1)
     };
     engine::state->physics_component_set = {
         .components = Array<physics::Component>(
-            asset_memory_pool, MAX_N_ENTITIES, "physics_components", true, 1
-        )
+            asset_memory_pool, MAX_N_ENTITIES, "physics_components", true, 1)
     };
 }
 
···
         engine::state->entity_set.first_non_internal_handle);
     engine::state->light_component_set.components.delete_elements_after_index(
         engine::state->entity_set.first_non_internal_handle);
-    engine::state->spatial_component_set.components.delete_elements_after_index(
+    spatial::get_components()->delete_elements_after_index(
         engine::state->entity_set.first_non_internal_handle);
     engine::state->drawable_component_set.components.delete_elements_after_index(
         engine::state->entity_set.first_non_internal_handle);
···
 
     lights::update_light_components(
         &engine::state->light_component_set,
-        &engine::state->spatial_component_set,
         cameras::get_main()->position);
 
     behavior::update_behavior_components(&engine::state->behavior_component_set);
 
-    anim::update_animation_components(
-        &engine::state->animation_component_set,
-        &engine::state->spatial_component_set);
+    anim::update_animation_components(&engine::state->animation_component_set);
 
     physics::update_components();
 }

src/engine.hpp

···
         entities::Set entity_set;
         drawable::ComponentSet drawable_component_set;
         lights::ComponentSet light_component_set;
-        spatial::ComponentSet spatial_component_set;
         behavior::ComponentSet behavior_component_set;
         anim::ComponentSet animation_component_set;
         physics::ComponentSet physics_component_set;

src/lights.cpp

···
 void
 lights::update_light_components(
     lights::ComponentSet *light_component_set,
-    spatial::ComponentSet *spatial_component_set,
     v3 camera_position
 ) {
     each (light_component, light_component_set->components) {
···
         }
 
         spatial::Component *spatial_component =
-            spatial_component_set->components[light_component->entity_handle];
+            spatial::get_component(light_component->entity_handle);
 
         if (!(
             is_light_component_valid(light_component) &&

src/lights.hpp

···
     static bool is_light_component_valid(Component *light_component);
     static void update_light_components(
         ComponentSet *light_component_set,
-        spatial::ComponentSet *spatial_component_set,
         v3 camera_position
     );
     static void init(lights::State *state);

src/models.cpp

···
             return false;
         }
 
-        spatial::Component *spatial_component = engine::get_spatial_component(entity_loader->entity_handle);
+        spatial::Component *spatial_component = spatial::get_component(entity_loader->entity_handle);
         *spatial_component = entity_loader->spatial_component;
         spatial_component->entity_handle = entity_loader->entity_handle;
 
···
                 entities::Entity *child_entity = entities::add_entity_to_set(entity_loader->name);
 
                 if (spatial::is_spatial_component_valid(&entity_loader->spatial_component)) {
-                    spatial::Component *child_spatial_component = engine::get_spatial_component(child_entity->handle);
+                    spatial::Component *child_spatial_component = spatial::get_component(child_entity->handle);
                     assert(child_spatial_component);
                     *child_spatial_component = {
                         .entity_handle = child_entity->handle,

src/physics.cpp

···
         if (!is_component_valid(candidate_physics)) {
             continue;
         }
-        spatial::Component *candidate_spatial =
-            engine::get_spatial_component(candidate_physics->entity_handle);
+        spatial::Component *candidate_spatial = spatial::get_component(candidate_physics->entity_handle);
         if (!candidate_spatial) {
             logs::error("Could not get spatial::Component for candidate");
             return physics::CollisionManifold {};
···
             continue;
         }
 
-        spatial::Component *spatial_component =
-            engine::get_spatial_component(physics_component->entity_handle);
+        spatial::Component *spatial_component = spatial::get_component(physics_component->entity_handle);
 
         if (!spatial::is_spatial_component_valid(spatial_component)) {
             logs::warning("Tried to update physics component but it had no spatial component.");

src/renderer.cpp

···
                 }
 
                 spatial::Component *spatial_component =
-                    engine::get_spatial_component(light_component->entity_handle);
+                    spatial::get_component(light_component->entity_handle);
 
                 if (!(
                         lights::is_light_component_valid(light_component) &&
···
                 }
 
                 spatial::Component *spatial_component =
-                    engine::get_spatial_component(light_component->entity_handle);
+                    spatial::get_component(light_component->entity_handle);
 
                 if (!(
                         lights::is_light_component_valid(light_component) &&
···
         }
 
         spatial::Component *spatial_component =
-            engine::get_spatial_component(light_component->entity_handle);
+            spatial::get_component(light_component->entity_handle);
 
         if (!(
             lights::is_light_component_valid(light_component) &&
···
             material = mats::get_material_by_name("unknown");
         }
 
-        spatial::Component *spatial_component =
-            engine::get_spatial_component(drawable_component->entity_handle);
+        spatial::Component *spatial_component = spatial::get_component(drawable_component->entity_handle);
 
         m4 model_matrix = m4(1.0f);
         m3 model_normal_matrix = m3(1.0f);

src/spatial.cpp

···
 #include "engine.hpp"
 
 
+spatial::State *spatial::state = nullptr;
+
+
 void
 spatial::print_spatial_component(spatial::Component *spatial_component)
 {
···
     m4 model_matrix = m4(1.0f);
 
     if (spatial_component->parent_entity_handle != entities::NO_ENTITY_HANDLE) {
-        spatial::Component *parent = engine::get_spatial_component(
+        spatial::Component *parent = spatial::get_component(
             spatial_component->parent_entity_handle);
         model_matrix = make_model_matrix(parent, cache);
     }
···
 
     return model_matrix;
 }
+
+
+Array<spatial::Component> *
+spatial::get_components()
+{
+    return &spatial::state->component_set.components;
+}
+
+
+spatial::Component *
+spatial::get_component(entities::Handle entity_handle)
+{
+    return spatial::state->component_set.components[entity_handle];
+}
+
+
+void
+spatial::init(spatial::State *spatial_state, memory::Pool *asset_memory_pool)
+{
+    spatial::state = spatial_state;
+    spatial::state->component_set = {
+        .components = Array<spatial::Component>(
+            asset_memory_pool, MAX_N_ENTITIES, "spatial_components", true, 1
+        )
+    };
+}

src/spatial.hpp

···
         Array<Component> components;
     };
 
+    struct State {
+        ComponentSet component_set;
+    };
+
 
     static void print_spatial_component(Component *spatial_component);
     static bool does_spatial_component_have_dimensions(Component *spatial_component);
···
         Component *spatial_component,
         ModelMatrixCache *cache
     );
+    static Array<spatial::Component> * get_components();
+    static spatial::Component * get_component(entities::Handle entity_handle);
+    static void init(spatial::State *spatial_state, memory::Pool *asset_memory_pool);
+
+private:
+    static spatial::State *state;
 };

src/state.hpp

···
 struct State {
     GLFWwindow *window;
     WindowSize window_size;
+    spatial::State spatial_state;
     engine::State engine_state;
     renderer::State renderer_state;
     cameras::State cameras_state;