refactor last files! :)

TODO.txt

···
-peony_parser
-peony_parser_utils
-queue
-spatial
-stackarray
-util

src/behavior_functions.cpp

···
         logs::error("Could not get physics::Component for behavior::Component");
         return;
     }
-    Obb *obb = &physics_component->transformed_obb;
+    spatial::Obb *obb = &physics_component->transformed_obb;
 
     // Update position
     spatial_component->position.x =
···
     // Check ray collision
 #if 0
     {
-        Ray ray = {
+        spatial::Ray ray = {
             .origin = obb->center + obb->y_axis * obb->extents[1],
             .direction = obb->y_axis,
         };

src/debugdraw.cpp

···
 
 
 void
-debugdraw::draw_ray(Ray *ray, real32 length, v4 color)
+debugdraw::draw_ray(spatial::Ray *ray, real32 length, v4 color)
 {
     v3 end_pos = ray->origin + ray->direction * length;
     v3 x_axis = util::get_orthogonal_vector(&ray->direction);
···
 
 
 void
-debugdraw::draw_obb(Obb *obb, v4 color)
+debugdraw::draw_obb(spatial::Obb *obb, v4 color)
 {
     v3 z_axis = cross(obb->x_axis, obb->y_axis);
     v3 dir1 = obb->x_axis * obb->extents[0];
···
 void
 debugdraw::draw_point(v3 position, real32 size, v4 color)
 {
-    Obb obb = {
+    spatial::Obb obb = {
         .center=position,
         .x_axis=v3(1.0f, 0.0f, 0.0f),
         .y_axis=v3(0.0f, 1.0f, 0.0f),

src/debugdraw.hpp

···
     };
 
     static void draw_line(v3 start_pos, v3 end_pos, v4 color);
-    static void draw_ray(Ray *ray, real32 length, v4 color);
+    static void draw_ray(spatial::Ray *ray, real32 length, v4 color);
     static void draw_quad(
         v3 p1, // clockwise: top left
         v3 p2, // top right
···
         v3 p8, // top left
         v4 color
     );
-    static void draw_obb(Obb *obb, v4 color);
+    static void draw_obb(spatial::Obb *obb, v4 color);
     static void draw_point(v3 position, real32 size, v4 color);
     static void clear();
     static void render();

src/engine.cpp

···
     pstr_vcat(scene_path, MAX_PATH, SCENE_DIR, scene_name, SCENE_EXTENSION, NULL);
     gui::log("Loading scene: %s", scene_path);
 
-    PeonyFile *scene_file = MEMORY_PUSH(&temp_memory_pool, PeonyFile, "scene_file");
+    peony_parser::PeonyFile *scene_file = MEMORY_PUSH(&temp_memory_pool,
+        peony_parser::PeonyFile, "scene_file");
     if (!peony_parser::parse_file(scene_file, scene_path)) {
         gui::log("Could not load scene: %s", scene_path);
         return false;
···
         scene_file, &used_materials, "materials");
 
     // Create Materials
-    PeonyFile *material_file = MEMORY_PUSH(&temp_memory_pool, PeonyFile, "material_file");
+    peony_parser::PeonyFile *material_file = MEMORY_PUSH(&temp_memory_pool,
+        peony_parser::PeonyFile, "material_file");
     each (used_material, used_materials) {
-        memset(material_file, 0, sizeof(PeonyFile));
+        memset(material_file, 0, sizeof(peony_parser::PeonyFile));
         char material_file_path[MAX_PATH] = {};
         pstr_vcat(material_file_path, MAX_PATH,
             MATERIAL_FILE_DIRECTORY, *used_material, MATERIAL_FILE_EXTENSION, nullptr);
···
     }
 
     range (0, scene_file->n_entries) {
-        PeonyFileEntry *entry = &scene_file->entries[idx];
+        peony_parser::Entry *entry = &scene_file->entries[idx];
 
         // Create entities::Entity
         entities::Entity *entity = entities::add_entity_to_set(entry->name);
···
         char const *model_path = peony_parser_utils::get_string(
             peony_parser_utils::find_prop(entry, "model_path")
         );
-        // NOTE: We only want to make a models::ModelLoader from this PeonyFileEntry if we haven't
+        // NOTE: We only want to make a models::ModelLoader from this peony_parser::Entry if we haven't
         // already encountered this model in a previous entry. If two entities
         // have the same `model_path`, we just make one model and use it in both.
         models::ModelLoader *found_model_loader = engine::state->model_loaders.find(

src/peony_parser.cpp

···
 #include "intrinsics.hpp"
 
 
-namespace peony_parser {
-  pny_internal void print_value(PeonyFilePropValue *value) {
-    if (value->type == PeonyFilePropValueType::unknown) {
-      logs::info("<unknown>");
-    } else if (value->type == PeonyFilePropValueType::string) {
-      logs::info("%s", value->string_value);
-    } else if (value->type == PeonyFilePropValueType::boolean) {
-      logs::info("%d", value->boolean_value);
-    } else if (value->type == PeonyFilePropValueType::number) {
-      logs::info("%f", value->number_value);
-    } else if (value->type == PeonyFilePropValueType::vec2) {
-      logs::print_v2(&value->vec2_value);
-    } else if (value->type == PeonyFilePropValueType::vec3) {
-      logs::print_v3(&value->vec3_value);
-    } else if (value->type == PeonyFilePropValueType::vec4) {
-      logs::print_v4(&value->vec4_value);
+bool32
+peony_parser::parse_file(PeonyFile *pf, char const *path)
+{
+    int32 idx_entry = -1;
+    Entry *entry = nullptr;
+
+    FILE *f = fopen(path, "r");
+    if (!f) {
+        logs::error("Could not open file %s.", path);
+        return false;
+    }
+    defer { fclose(f); };
+
+    char token[MAX_TOKEN_LENGTH];
+
+    while (get_non_trivial_token(token, f)) {
+        if (token[0] == TOKEN_HEADER_START) {
+            idx_entry++;
+            entry = &pf->entries[idx_entry];
+            parse_header(token, f);
+            pstr_copy(entry->name, MAX_TOKEN_LENGTH, token);
+        } else if (is_token_name(token)) {
+            if (!entry) {
+                logs::fatal("Tried to parse file, but encountered data before header.");
+            }
+            Prop *prop = &entry->props[entry->n_props];
+            parse_property(prop, token, f);
+            entry->n_props++;
+            if (entry->n_props > MAX_N_ENTRY_PROPS) {
+                logs::fatal("Too many props in peony file");
+                assert(false);
+            }
+        } else {
+            logs::info("Unhandled token: %s", token);
+        }
+    }
+
+    pf->n_entries = idx_entry + 1;
+    return true;
+}
+
+
+void
+peony_parser::print_value(PropValue *value)
+{
+    if (value->type == PropValueType::unknown) {
+        logs::info("<unknown>");
+    } else if (value->type == PropValueType::string) {
+        logs::info("%s", value->string_value);
+    } else if (value->type == PropValueType::boolean) {
+        logs::info("%d", value->boolean_value);
+    } else if (value->type == PropValueType::number) {
+        logs::info("%f", value->number_value);
+    } else if (value->type == PropValueType::vec2) {
+        logs::print_v2(&value->vec2_value);
+    } else if (value->type == PropValueType::vec3) {
+        logs::print_v3(&value->vec3_value);
+    } else if (value->type == PropValueType::vec4) {
+        logs::print_v4(&value->vec4_value);
     } else {
-      logs::info("<invalid>");
+        logs::info("<invalid>");
     }
-  }
+}
 
 
-  pny_internal bool32 is_char_whitespace(const char target) {
-    return target == TOKEN_NEWLINE ||
-      target == TOKEN_SPACE;
-  }
+bool32
+peony_parser::is_char_whitespace(const char target)
+{
+    return target == TOKEN_NEWLINE || target == TOKEN_SPACE;
+}
 
 
-  pny_internal bool32 is_token_whitespace(const char *token) {
+bool32
+peony_parser::is_token_whitespace(const char *token)
+{
     return is_char_whitespace(token[0]);
-  }
+}
 
 
-  pny_internal bool32 is_char_allowed_in_name(const char target) {
-    return isalpha(target) ||
-      isdigit(target) ||
-      target == '_' ||
-      target == '-' ||
-      target == '/' ||
-      target == ':' ||
-      target == '.';
-  }
+bool32
+peony_parser::is_char_allowed_in_name(const char target)
+{
+    return isalpha(target) || isdigit(target) || target == '_' || target == '-' ||
+        target == '/' || target == ':' || target == '.';
+}
 
 
-  pny_internal bool32 is_token_name(const char *token) {
+bool32
+peony_parser::is_token_name(const char *token)
+{
     range (0, pstr_len(token)) {
-      if (!is_char_allowed_in_name(token[idx])) {
-        return false;
-      }
+        if (!is_char_allowed_in_name(token[idx])) {
+            return false;
+        }
     }
     return true;
-  }
+}
 
 
-  pny_internal bool32 is_char_token_boundary(char target) {
+bool32
+peony_parser::is_char_token_boundary(char target)
+{
     return is_char_whitespace(target) ||
-      target == TOKEN_HEADER_START ||
-      target == TOKEN_ELEMENT_SEPARATOR ||
-      target == TOKEN_TUPLE_START ||
-      target == TOKEN_TUPLE_END ||
-      target == TOKEN_ARRAY_START ||
-      target == TOKEN_ARRAY_END ||
-      target == TOKEN_OBJECT_START ||
-      target == TOKEN_OBJECT_END;
-  }
+        target == TOKEN_HEADER_START ||
+        target == TOKEN_ELEMENT_SEPARATOR ||
+        target == TOKEN_TUPLE_START ||
+        target == TOKEN_TUPLE_END ||
+        target == TOKEN_ARRAY_START ||
+        target == TOKEN_ARRAY_END ||
+        target == TOKEN_OBJECT_START ||
+        target == TOKEN_OBJECT_END;
+}
 
 
-  pny_internal bool32 get_token(char *token, FILE *f) {
+bool32
+peony_parser::get_token(char *token, FILE *f)
+{
     uint32 idx_token = 0;
     bool32 could_get_token = true;
 
     while (true) {
-      char new_char = (char)fgetc(f);
+        char new_char = (char)fgetc(f);
 
-      *(token + idx_token) = new_char;
-      idx_token++;
+        *(token + idx_token) = new_char;
+        idx_token++;
 
-      if (is_char_token_boundary(new_char)) {
-        if (idx_token - 1 == 0) {
-          // Our first character is already a boundary. Radical!
-        } else {
-          // Return the boundary to the buffer so we can put it in its own token.
-          ungetc(new_char, f);
-          *(token + idx_token - 1) = '\0';
+        if (is_char_token_boundary(new_char)) {
+            if (idx_token - 1 == 0) {
+                // Our first character is already a boundary. Radical!
+            } else {
+                // Return the boundary to the buffer so we can put it in its own token.
+                ungetc(new_char, f);
+                *(token + idx_token - 1) = '\0';
+            }
+            break;
         }
-        break;
-      }
 
-      if (new_char == EOF) {
-        could_get_token = false;
-        break;
-      }
+        if (new_char == EOF) {
+            could_get_token = false;
+            break;
+        }
 
-      if (idx_token >= MAX_TOKEN_LENGTH) {
-        logs::error("Reached max token length for token %s.", token);
-        break;
-      }
+        if (idx_token >= MAX_TOKEN_LENGTH) {
+            logs::error("Reached max token length for token %s.", token);
+            break;
+        }
     }
 
     *(token + idx_token) = '\0';
 
     return could_get_token;
-  }
+}
 
 
-  pny_internal bool32 get_non_trivial_token(char *token, FILE *f) {
+bool32
+peony_parser::get_non_trivial_token(char *token, FILE *f)
+{
     bool32 could_get_token;
     do {
-      could_get_token = get_token(token, f);
-      if (token[0] == TOKEN_COMMENT_START) {
-        while ((could_get_token = get_token(token, f)) != false) {
-          if (token[0] == TOKEN_NEWLINE) {
-            break;
-          }
+        could_get_token = get_token(token, f);
+        if (token[0] == TOKEN_COMMENT_START) {
+            while ((could_get_token = get_token(token, f)) != false) {
+                if (token[0] == TOKEN_NEWLINE) {
+                    break;
+                }
+            }
         }
-      }
     } while (is_token_whitespace(token) || token[0] == TOKEN_ELEMENT_SEPARATOR);
     return could_get_token;
-  }
+}
 
 
-  pny_internal void parse_vec2(char *token, FILE *f, v2 *parsed_vector) {
+void
+peony_parser::parse_vec2(char *token, FILE *f, v2 *parsed_vector)
+{
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_START);
     get_non_trivial_token(token, f);
···
     (*parsed_vector).y = (real32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_END);
-  }
+}
 
 
-  pny_internal void parse_vec3(char *token, FILE *f, v3 *parsed_vector) {
+void
+peony_parser::parse_vec3(char *token, FILE *f, v3 *parsed_vector)
+{
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_START);
     get_non_trivial_token(token, f);
···
     (*parsed_vector).z = (real32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_END);
-  }
+}
 
 
-  pny_internal void parse_vec4(char *token, FILE *f, v4 *parsed_vector) {
+void
+peony_parser::parse_vec4(char *token, FILE *f, v4 *parsed_vector)
+{
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_START);
     get_non_trivial_token(token, f);
···
     (*parsed_vector).w = (real32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_END);
-  }
+}
 
 
-  pny_internal void get_value_from_token(
-    char *token, FILE *f, PeonyFilePropValue *prop_value
-  ) {
+void
+peony_parser::get_value_from_token(char *token, FILE *f, PropValue *prop_value)
+{
     // NOTE: Type names the can start a value: vec2, vec3, vec4
     if (pstr_eq(token, "vec2")) {
-      prop_value->type = PeonyFilePropValueType::vec2;
-      parse_vec2(token, f, &prop_value->vec2_value);
+        prop_value->type = PropValueType::vec2;
+        parse_vec2(token, f, &prop_value->vec2_value);
     } else if (pstr_eq(token, "vec3")) {
-      prop_value->type = PeonyFilePropValueType::vec3;
-      parse_vec3(token, f, &prop_value->vec3_value);
+        prop_value->type = PropValueType::vec3;
+        parse_vec3(token, f, &prop_value->vec3_value);
     } else if (pstr_eq(token, "vec4")) {
-      prop_value->type = PeonyFilePropValueType::vec4;
-      parse_vec4(token, f, &prop_value->vec4_value);
+        prop_value->type = PropValueType::vec4;
+        parse_vec4(token, f, &prop_value->vec4_value);
     } else if (pstr_eq(token, "true")) {
-      prop_value->type = PeonyFilePropValueType::boolean;
-      prop_value->boolean_value = true;
+        prop_value->type = PropValueType::boolean;
+        prop_value->boolean_value = true;
     } else if (pstr_eq(token, "false")) {
-      prop_value->type = PeonyFilePropValueType::boolean;
-      prop_value->boolean_value = false;
+        prop_value->type = PropValueType::boolean;
+        prop_value->boolean_value = false;
     } else if (pstr_eq(token, "0.0") || strtod(token, nullptr) != 0.0f) {
-      // NOTE: `strtod()` returns 0.0 if parsing fails, so we need to check
-      // if our value actually was 0.0;
-      prop_value->type = PeonyFilePropValueType::number;
-      prop_value->number_value = (real32)strtod(token, nullptr);
+        // NOTE: `strtod()` returns 0.0 if parsing fails, so we need to check
+        // if our value actually was 0.0;
+        prop_value->type = PropValueType::number;
+        prop_value->number_value = (real32)strtod(token, nullptr);
     } else {
-      prop_value->type = PeonyFilePropValueType::string;
-      pstr_copy(prop_value->string_value, MAX_TOKEN_LENGTH, token);
+        prop_value->type = PropValueType::string;
+        pstr_copy(prop_value->string_value, MAX_TOKEN_LENGTH, token);
     }
-  }
+}
 
 
-  pny_internal void parse_header(char *token, FILE *f) {
+void
+peony_parser::parse_header(char *token, FILE *f)
+{
     get_non_trivial_token(token, f);
     assert(is_token_name(token));
-  }
+}
 
 
-  pny_internal void parse_property(
-    PeonyFileProp *prop,
-    char *token,
-    FILE *f
-  ) {
+void
+peony_parser::parse_property(Prop *prop, char *token, FILE *f)
+{
     pstr_copy(prop->name, MAX_TOKEN_LENGTH, token);
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_EQUALS);
     get_non_trivial_token(token, f);
 
-    assert(
-      is_token_name(token) || token[0] == TOKEN_ARRAY_START
-    );
+    assert(is_token_name(token) || token[0] == TOKEN_ARRAY_START);
 
     if (is_token_name(token)) {
-      get_value_from_token(token, f, &prop->values[prop->n_values]);
-      prop->n_values++;
-      if (prop->n_values > MAX_N_ARRAY_VALUES) {
-        logs::fatal("Too many array values in peony file");
-        assert(false);
-      }
-    } else if (token[0] == TOKEN_ARRAY_START) {
-      while (true) {
-        get_non_trivial_token(token, f);
-        if (token[0] == TOKEN_ARRAY_END) {
-          break;
-        }
         get_value_from_token(token, f, &prop->values[prop->n_values]);
         prop->n_values++;
-      }
-    }
-  }
-}
-
-
-bool32 peony_parser::parse_file(PeonyFile *pf, char const *path) {
-  int32 idx_entry = -1;
-  PeonyFileEntry *entry = nullptr;
-
-  FILE *f = fopen(path, "r");
-  if (!f) {
-    logs::error("Could not open file %s.", path);
-    return false;
-  }
-  defer { fclose(f); };
-
-  char token[MAX_TOKEN_LENGTH];
-
-  while (get_non_trivial_token(token, f)) {
-    if (token[0] == TOKEN_HEADER_START) {
-      idx_entry++;
-      entry = &pf->entries[idx_entry];
-      parse_header(token, f);
-      pstr_copy(entry->name, MAX_TOKEN_LENGTH, token);
-    } else if (is_token_name(token)) {
-      if (!entry) {
-        logs::fatal("Tried to parse file, but encountered data before header.");
-      }
-      PeonyFileProp *prop = &entry->props[entry->n_props];
-      parse_property(prop, token, f);
-      entry->n_props++;
-      if (entry->n_props > MAX_N_ENTRY_PROPS) {
-        logs::fatal("Too many props in peony file");
-        assert(false);
-      }
-    } else {
-      logs::info("Unhandled token: %s", token);
+        if (prop->n_values > MAX_N_ARRAY_VALUES) {
+            logs::fatal("Too many array values in peony file");
+            assert(false);
+        }
+    } else if (token[0] == TOKEN_ARRAY_START) {
+        while (true) {
+            get_non_trivial_token(token, f);
+            if (token[0] == TOKEN_ARRAY_END) {
+                break;
+            }
+            get_value_from_token(token, f, &prop->values[prop->n_values]);
+            prop->n_values++;
+        }
     }
-  }
-
-  pf->n_entries = idx_entry + 1;
-  return true;
 }

src/peony_parser.hpp

···
 
 #include "types.hpp"
 
-namespace peony_parser {
-  constexpr uint32 MAX_N_FILE_ENTRIES = 128;
-  constexpr uint32 MAX_N_ENTRY_PROPS = 32;
-  constexpr uint32 MAX_N_ARRAY_VALUES = 8;
-  constexpr uint32 MAX_TOKEN_LENGTH = 128;
+class peony_parser {
+public:
+    static constexpr uint32 MAX_N_FILE_ENTRIES = 128;
+    static constexpr uint32 MAX_N_ENTRY_PROPS = 32;
+    static constexpr uint32 MAX_N_ARRAY_VALUES = 8;
+    static constexpr uint32 MAX_TOKEN_LENGTH = 128;
 
-  constexpr const char TOKEN_SPACE = ' ';
-  constexpr const char TOKEN_NEWLINE = '\n';
-  constexpr const char TOKEN_EQUALS = '=';
-  constexpr const char TOKEN_HEADER_START = '>';
-  constexpr const char TOKEN_ARRAY_START = '[';
-  constexpr const char TOKEN_ARRAY_END = ']';
-  constexpr const char TOKEN_OBJECT_START = '{';
-  constexpr const char TOKEN_OBJECT_END = '}';
-  constexpr const char TOKEN_TUPLE_START = '(';
-  constexpr const char TOKEN_TUPLE_END = ')';
-  constexpr const char TOKEN_ELEMENT_SEPARATOR = ',';
-  constexpr const char TOKEN_COMMENT_START = ';';
+    static constexpr const char TOKEN_SPACE = ' ';
+    static constexpr const char TOKEN_NEWLINE = '\n';
+    static constexpr const char TOKEN_EQUALS = '=';
+    static constexpr const char TOKEN_HEADER_START = '>';
+    static constexpr const char TOKEN_ARRAY_START = '[';
+    static constexpr const char TOKEN_ARRAY_END = ']';
+    static constexpr const char TOKEN_OBJECT_START = '{';
+    static constexpr const char TOKEN_OBJECT_END = '}';
+    static constexpr const char TOKEN_TUPLE_START = '(';
+    static constexpr const char TOKEN_TUPLE_END = ')';
+    static constexpr const char TOKEN_ELEMENT_SEPARATOR = ',';
+    static constexpr const char TOKEN_COMMENT_START = ';';
 
-  enum class PeonyFilePropValueType {
-    unknown, string, boolean, number, vec2, vec3, vec4
-  };
+    enum class PropValueType {
+        unknown, string, boolean, number, vec2, vec3, vec4
+    };
 
-  struct PeonyFilePropValue {
-    PeonyFilePropValueType type;
-    union {
-      char string_value[MAX_TOKEN_LENGTH];
-      bool32 boolean_value;
-      real32 number_value;
-      v2 vec2_value;
-      v3 vec3_value;
-      v4 vec4_value;
+    struct PropValue {
+        PropValueType type;
+        union {
+            char string_value[MAX_TOKEN_LENGTH];
+            bool32 boolean_value;
+            real32 number_value;
+            v2 vec2_value;
+            v3 vec3_value;
+            v4 vec4_value;
+        };
     };
-  };
 
-  struct PeonyFileProp {
-    char name[MAX_TOKEN_LENGTH];
-    PeonyFilePropValue values[MAX_N_ARRAY_VALUES];
-    uint32 n_values;
-  };
+    struct Prop {
+        char name[MAX_TOKEN_LENGTH];
+        PropValue values[MAX_N_ARRAY_VALUES];
+        uint32 n_values;
+    };
 
-  struct PeonyFileEntry {
-    char name[MAX_TOKEN_LENGTH];
-    PeonyFileProp props[MAX_N_ENTRY_PROPS];
-    uint32 n_props;
-  };
+    struct Entry {
+        char name[MAX_TOKEN_LENGTH];
+        Prop props[MAX_N_ENTRY_PROPS];
+        uint32 n_props;
+    };
 
-  struct PeonyFile {
-    PeonyFileEntry entries[MAX_N_FILE_ENTRIES];
-    uint32 n_entries;
-  };
+    struct PeonyFile {
+        Entry entries[MAX_N_FILE_ENTRIES];
+        uint32 n_entries;
+    };
 
-  bool32 parse_file(PeonyFile *pf, char const *path);
-}
+    static bool32 parse_file(PeonyFile *pf, char const *path);
 
-using peony_parser::PeonyFileEntry,
-  peony_parser::PeonyFileProp,
-  peony_parser::PeonyFilePropValue,
-  peony_parser::PeonyFile;
+private:
+    static void print_value(PropValue *value);
+    static bool32 is_char_whitespace(const char target);
+    static bool32 is_token_whitespace(const char *token);
+    static bool32 is_char_allowed_in_name(const char target);
+    static bool32 is_token_name(const char *token);
+    static bool32 is_char_token_boundary(char target);
+    static bool32 get_token(char *token, FILE *f);
+    static bool32 get_non_trivial_token(char *token, FILE *f);
+    static void parse_vec2(char *token, FILE *f, v2 *parsed_vector);
+    static void parse_vec3(char *token, FILE *f, v3 *parsed_vector);
+    static void parse_vec4(char *token, FILE *f, v4 *parsed_vector);
+    static void get_value_from_token(char *token, FILE *f, PropValue *prop_value);
+    static void parse_header(char *token, FILE *f);
+    static void parse_property(Prop *prop, char *token, FILE *f);
+};

src/peony_parser_utils.cpp

···
 #include "intrinsics.hpp"
 
 
-char* peony_parser_utils::get_string(PeonyFileProp *prop) {
-  if (!prop) { return nullptr; }
-  return prop->values[0].string_value;
+char *
+peony_parser_utils::get_string(peony_parser::Prop *prop)
+{
+    if (!prop) { return nullptr; }
+    return prop->values[0].string_value;
 }
 
 
-bool32* peony_parser_utils::get_boolean(PeonyFileProp *prop) {
-  if (!prop) { return nullptr; }
-  return &prop->values[0].boolean_value;
+bool32 *
+peony_parser_utils::get_boolean(peony_parser::Prop *prop)
+{
+    if (!prop) { return nullptr; }
+    return &prop->values[0].boolean_value;
 }
 
 
-real32* peony_parser_utils::get_number(PeonyFileProp *prop) {
-  if (!prop) { return nullptr; }
-  return &prop->values[0].number_value;
+real32 *
+peony_parser_utils::get_number(peony_parser::Prop *prop)
+{
+    if (!prop) { return nullptr; }
+    return &prop->values[0].number_value;
 }
 
 
-v2* peony_parser_utils::get_vec2(PeonyFileProp *prop) {
-  if (!prop) { return nullptr; }
-  return &prop->values[0].vec2_value;
+v2 *
+peony_parser_utils::get_vec2(peony_parser::Prop *prop)
+{
+    if (!prop) { return nullptr; }
+    return &prop->values[0].vec2_value;
 }
 
 
-v3* peony_parser_utils::get_vec3(PeonyFileProp *prop) {
-  if (!prop) { return nullptr; }
-  return &prop->values[0].vec3_value;
+v3 *
+peony_parser_utils::get_vec3(peony_parser::Prop *prop)
+{
+    if (!prop) { return nullptr; }
+    return &prop->values[0].vec3_value;
 }
 
 
-v4* peony_parser_utils::get_vec4(PeonyFileProp *prop) {
-  if (!prop) { return nullptr; }
-  return &prop->values[0].vec4_value;
+v4 *
+peony_parser_utils::get_vec4(peony_parser::Prop *prop)
+{
+    if (!prop) { return nullptr; }
+    return &prop->values[0].vec4_value;
 }
 
 
-PeonyFileProp* peony_parser_utils::find_prop(PeonyFileEntry *entry, char const *name) {
-  range (0, entry->n_props) {
-    if (pstr_eq(name, entry->props[idx].name)) {
-      return &entry->props[idx];
+peony_parser::Prop *
+peony_parser_utils::find_prop(peony_parser::Entry *entry, char const *name)
+{
+    range (0, entry->n_props) {
+        if (pstr_eq(name, entry->props[idx].name)) {
+            return &entry->props[idx];
+        }
     }
-  }
-  logs::warning("Could not find prop %s", name);
-  return nullptr;
+    logs::warning("Could not find prop %s", name);
+    return nullptr;
 }
 
 
-void peony_parser_utils::get_unique_string_values_for_prop_name(
-  PeonyFile *pf,
-  Array<char[MAX_COMMON_NAME_LENGTH]> *unique_values,
-  char const *prop_name
+void
+peony_parser_utils::get_unique_string_values_for_prop_name(
+    peony_parser::PeonyFile *pf,
+    Array<char[MAX_COMMON_NAME_LENGTH]> *unique_values,
+    char const *prop_name
 ) {
-  range_named (idx_entry, 0, pf->n_entries) {
-    PeonyFileEntry *entry = &pf->entries[idx_entry];
-    PeonyFileProp *prop = find_prop(entry, prop_name);
-    if (!prop) {
-      continue;
-    }
-    range_named (idx_value, 0, prop->n_values) {
-      PeonyFilePropValue *value = &prop->values[idx_value];
-      bool32 does_material_already_exist = false;
-      each (unique_value, *unique_values) {
-        if (pstr_eq(value->string_value, *unique_value)) {
-          does_material_already_exist = true;
-          break;
+    range_named (idx_entry, 0, pf->n_entries) {
+        peony_parser::Entry *entry = &pf->entries[idx_entry];
+        peony_parser::Prop *prop = find_prop(entry, prop_name);
+        if (!prop) {
+            continue;
         }
-      }
-      if (!does_material_already_exist) {
-        pstr_copy(
-          *(unique_values->push()),
-          MAX_COMMON_NAME_LENGTH,
-          value->string_value
-        );
-      }
+        range_named (idx_value, 0, prop->n_values) {
+            peony_parser::PropValue *value = &prop->values[idx_value];
+            bool32 does_material_already_exist = false;
+            each (unique_value, *unique_values) {
+                if (pstr_eq(value->string_value, *unique_value)) {
+                    does_material_already_exist = true;
+                    break;
+                }
+            }
+            if (!does_material_already_exist) {
+                pstr_copy(*(unique_values->push()),
+                    MAX_COMMON_NAME_LENGTH, value->string_value);
+            }
+        }
     }
-  }
 }
 
 
-void peony_parser_utils::create_material_from_peony_file_entry(
-  mats::Material *material,
-  PeonyFileEntry *entry,
-  memory::Pool *memory_pool
+void
+peony_parser_utils::create_material_from_peony_file_entry(
+    mats::Material *material,
+    peony_parser::Entry *entry,
+    memory::Pool *memory_pool
 ) {
-  mats::init_material(material, entry->name);
+    mats::init_material(material, entry->name);
 
-  // We're calling `find_prop()` a lot here, which goes through the full
-  // list of props every time, and so this is kind of #slow. Not a huge deal, but
-  // good to keep in mind.
-  PeonyFileProp *prop;
+    // We're calling `find_prop()` a lot here, which goes through the full
+    // list of props every time, and so this is kind of #slow. Not a huge deal, but
+    // good to keep in mind.
+    peony_parser::Prop *prop;
 
-  if ((prop = find_prop(entry, "albedo_static"))) {
-    material->albedo_static = *get_vec4(prop);
-  }
-  if ((prop = find_prop(entry, "metallic_static"))) {
-    material->metallic_static = *get_number(prop);
-  }
-  if ((prop = find_prop(entry, "roughness_static"))) {
-    material->roughness_static = *get_number(prop);
-  }
-  if ((prop = find_prop(entry, "ao_static"))) {
-    material->ao_static = *get_number(prop);
-  }
+    if ((prop = find_prop(entry, "albedo_static"))) {
+        material->albedo_static = *get_vec4(prop);
+    }
+    if ((prop = find_prop(entry, "metallic_static"))) {
+        material->metallic_static = *get_number(prop);
+    }
+    if ((prop = find_prop(entry, "roughness_static"))) {
+        material->roughness_static = *get_number(prop);
+    }
+    if ((prop = find_prop(entry, "ao_static"))) {
+        material->ao_static = *get_number(prop);
+    }
 
-  if ((prop = find_prop(entry, "shader_asset.vert_path"))) {
-    if (!pstr_is_empty(get_string(prop))) {
-      shaders::init_shader_asset(
-        &material->shader_asset,
-        memory_pool,
-        entry->name,
-        shaders::Type::standard,
-        get_string(find_prop(entry, "shader_asset.vert_path")),
-        get_string(find_prop(entry, "shader_asset.frag_path")),
-        get_string(find_prop(entry, "shader_asset.geom_path"))
-      );
+    if ((prop = find_prop(entry, "shader_asset.vert_path"))) {
+        if (!pstr_is_empty(get_string(prop))) {
+            shaders::init_shader_asset(&material->shader_asset,
+                memory_pool,
+                entry->name,
+                shaders::Type::standard,
+                get_string(find_prop(entry, "shader_asset.vert_path")),
+                get_string(find_prop(entry, "shader_asset.frag_path")),
+                get_string(find_prop(entry, "shader_asset.geom_path")));
+        }
     }
-  }
 
-  if ((prop = find_prop(entry, "depth_shader_asset.vert_path"))) {
-    if (!pstr_is_empty(get_string(prop))) {
-       shaders::init_shader_asset(
-        &material->depth_shader_asset,
-        memory_pool,
-        entry->name,
-        shaders::Type::depth,
-        get_string(find_prop(entry, "depth_shader_asset.vert_path")),
-        get_string(find_prop(entry, "depth_shader_asset.frag_path")),
-        get_string(find_prop(entry, "depth_shader_asset.geom_path"))
-      );
+    if ((prop = find_prop(entry, "depth_shader_asset.vert_path"))) {
+        if (!pstr_is_empty(get_string(prop))) {
+            shaders::init_shader_asset(&material->depth_shader_asset,
+                memory_pool,
+                entry->name,
+                shaders::Type::depth,
+                get_string(find_prop(entry, "depth_shader_asset.vert_path")),
+                get_string(find_prop(entry, "depth_shader_asset.frag_path")),
+                get_string(find_prop(entry, "depth_shader_asset.geom_path")));
+        }
     }
-  }
 
-  auto *builtin_textures = renderer::get_builtin_textures();
+    auto *builtin_textures = renderer::get_builtin_textures();
 
-  // Iterate through all props to get textures, since those could have any name
-  range (0, entry->n_props) {
-    prop = &entry->props[idx];
+    // Iterate through all props to get textures, since those could have any name
+    range (0, entry->n_props) {
+        prop = &entry->props[idx];
 
-    if (pstr_starts_with(prop->name, TEXTURE_PREFIX)) {
-      // Handle a texture
-      mats::Texture texture = {};
-      // The uniform name is the prop name without the prefix
-      // The first value is the type, and the second the path
-      // e.g. textures.foam_texture = [other, water_foam.png]
-      char const *uniform_name = &prop->name[TEXTURE_PREFIX_LENGTH];
-      mats::init_texture(
-        &texture,
-        mats::texture_type_from_string(prop->values[0].string_value),
-        prop->values[1].string_value
-      );
-      mats::add_texture_to_material(
-        material,
-        texture,
-        uniform_name
-      );
-    } else if (pstr_starts_with(prop->name, BUILTIN_TEXTURE_PREFIX)) {
-      // Handle a builtin texture
-      char const *builtin_uniform_name = &prop->name[BUILTIN_TEXTURE_PREFIX_LENGTH];
-      if (pstr_eq(builtin_uniform_name, "g_position_texture")) {
-        mats::add_texture_to_material(
-          material, *builtin_textures->g_position_texture, builtin_uniform_name
-        );
-      } else if (pstr_eq(builtin_uniform_name, "g_albedo_texture")) {
-        mats::add_texture_to_material(
-          material, *builtin_textures->g_albedo_texture, builtin_uniform_name
-        );
-      } else if (pstr_eq(builtin_uniform_name, "shadowmaps_3d")) {
-        mats::add_texture_to_material(
-          material, *builtin_textures->shadowmaps_3d_texture, builtin_uniform_name
-        );
-      } else if (pstr_eq(builtin_uniform_name, "shadowmaps_2d")) {
-        mats::add_texture_to_material(
-          material, *builtin_textures->shadowmaps_2d_texture, builtin_uniform_name
-        );
-      } else {
-        logs::fatal(
-          "Attempted to use unsupported built-in texture %s",
-          builtin_uniform_name
-        );
-      }
+        if (pstr_starts_with(prop->name, TEXTURE_PREFIX)) {
+            // Handle a texture
+            mats::Texture texture = {};
+            // The uniform name is the prop name without the prefix
+            // The first value is the type, and the second the path
+            // e.g. textures.foam_texture = [other, water_foam.png]
+            char const *uniform_name = &prop->name[TEXTURE_PREFIX_LENGTH];
+            mats::init_texture(&texture,
+                mats::texture_type_from_string(prop->values[0].string_value),
+                prop->values[1].string_value);
+            mats::add_texture_to_material(material, texture, uniform_name);
+        } else if (pstr_starts_with(prop->name, BUILTIN_TEXTURE_PREFIX)) {
+            // Handle a builtin texture
+            char const *builtin_uniform_name = &prop->name[BUILTIN_TEXTURE_PREFIX_LENGTH];
+            if (pstr_eq(builtin_uniform_name, "g_position_texture")) {
+                mats::add_texture_to_material(
+                    material, *builtin_textures->g_position_texture, builtin_uniform_name);
+            } else if (pstr_eq(builtin_uniform_name, "g_albedo_texture")) {
+                mats::add_texture_to_material(
+                    material, *builtin_textures->g_albedo_texture, builtin_uniform_name);
+            } else if (pstr_eq(builtin_uniform_name, "shadowmaps_3d")) {
+                mats::add_texture_to_material(
+                    material, *builtin_textures->shadowmaps_3d_texture, builtin_uniform_name);
+            } else if (pstr_eq(builtin_uniform_name, "shadowmaps_2d")) {
+                mats::add_texture_to_material(
+                    material, *builtin_textures->shadowmaps_2d_texture, builtin_uniform_name);
+            } else {
+                logs::fatal("Attempted to use unsupported built-in texture %s",
+                    builtin_uniform_name);
+            }
+        }
     }
-  }
 }
 
 
-void peony_parser_utils::create_model_loader_from_peony_file_entry(
-  PeonyFileEntry *entry,
-  entities::Handle entity_handle,
-  models::ModelLoader *model_loader
+void
+peony_parser_utils::create_model_loader_from_peony_file_entry(
+    peony_parser::Entry *entry,
+    entities::Handle entity_handle,
+    models::ModelLoader *model_loader
 ) {
-  PeonyFileProp *model_path_prop = find_prop(entry, "model_path");
-  assert(model_path_prop);
-  char const *model_path = get_string(model_path_prop);
+    peony_parser::Prop *model_path_prop = find_prop(entry, "model_path");
+    assert(model_path_prop);
+    char const *model_path = get_string(model_path_prop);
 
-  models::init_model_loader(model_loader, model_path);
+    models::init_model_loader(model_loader, model_path);
 
-  PeonyFileProp *materials_prop = find_prop(entry, "materials");
-  model_loader->n_material_names = materials_prop->n_values;
-  range (0, materials_prop->n_values) {
-    pstr_copy(
-      model_loader->material_names[idx],
-      MAX_COMMON_NAME_LENGTH,
-      materials_prop->values[idx].string_value
-    );
-  }
+    peony_parser::Prop *materials_prop = find_prop(entry, "materials");
+    model_loader->n_material_names = materials_prop->n_values;
+    range (0, materials_prop->n_values) {
+        pstr_copy(model_loader->material_names[idx],
+            MAX_COMMON_NAME_LENGTH,
+            materials_prop->values[idx].string_value);
+    }
 }
 
 
-void peony_parser_utils::create_entity_loader_from_peony_file_entry(
-  PeonyFileEntry *entry,
-  entities::Handle entity_handle,
-  models::EntityLoader *entity_loader
+void
+peony_parser_utils::create_entity_loader_from_peony_file_entry(
+    peony_parser::Entry *entry,
+    entities::Handle entity_handle,
+    models::EntityLoader *entity_loader
 ) {
-  PeonyFileProp *model_path_prop = find_prop(entry, "model_path");
-  assert(model_path_prop);
-  char const *model_path = get_string(model_path_prop);
+    peony_parser::Prop *model_path_prop = find_prop(entry, "model_path");
+    assert(model_path_prop);
+    char const *model_path = get_string(model_path_prop);
 
-  // Get render pass
-  auto render_pass = drawable::Pass::none;
-  PeonyFileProp *render_passes_prop = find_prop(entry, "render_passes");
-  if (render_passes_prop) {
-    range (0, render_passes_prop->n_values) {
-      render_pass = (drawable::Pass)(
-        (uint32)render_pass |
-        (uint32)drawable::render_pass_from_string(
-          render_passes_prop->values[idx].string_value
-        )
-      );
+    // Get render pass
+    auto render_pass = drawable::Pass::none;
+    peony_parser::Prop *render_passes_prop = find_prop(entry, "render_passes");
+    if (render_passes_prop) {
+        range (0, render_passes_prop->n_values) {
+            render_pass = (drawable::Pass)(
+                (uint32)render_pass |
+                (uint32)drawable::render_pass_from_string(
+                    render_passes_prop->values[idx].string_value));
+        }
+    } else {
+        logs::warning(
+            "Loading EntityLoader with no RenderPasses, you probably don't want this?");
     }
-  } else {
-    logs::warning(
-      "Loading EntityLoader with no RenderPasses, you probably don't want this?"
-    );
-  }
 
-  // Initialise everything except the components
-  models::init_entity_loader(
-    entity_loader,
-    entry->name,
-    model_path,
-    render_pass,
-    entity_handle
-  );
+    // Initialise everything except the components
+    models::init_entity_loader(entity_loader, entry->name, model_path,
+        render_pass, entity_handle);
 
-  // Build physics::Component, spatial::Component, lights::Component, behavior::Component
-  range (0, entry->n_props) {
-    PeonyFileProp *prop = &entry->props[idx];
-    if (pstr_eq(prop->name, "physics_component.obb.center")) {
-      entity_loader->physics_component.obb.center = *get_vec3(prop);
-    } else if (pstr_eq(prop->name, "physics_component.obb.x_axis")) {
-      entity_loader->physics_component.obb.x_axis = *get_vec3(prop);
-    } else if (pstr_eq(prop->name, "physics_component.obb.y_axis")) {
-      entity_loader->physics_component.obb.y_axis = *get_vec3(prop);
-    } else if (pstr_eq(prop->name, "physics_component.obb.extents")) {
-      entity_loader->physics_component.obb.extents = *get_vec3(prop);
-    } else if (pstr_eq(prop->name, "spatial_component.position")) {
-      entity_loader->spatial_component.position = *get_vec3(prop);
-    } else if (pstr_eq(prop->name, "spatial_component.rotation")) {
-      entity_loader->spatial_component.rotation =
-        glm::angleAxis(
-          radians((*get_vec4(prop))[0]),
-          v3(
-            (*get_vec4(prop))[1],
-            (*get_vec4(prop))[2],
-            (*get_vec4(prop))[3]
-          )
-        );
-    } else if (pstr_eq(prop->name, "spatial_component.scale")) {
-      entity_loader->spatial_component.scale = *get_vec3(prop);
-    } else if (pstr_eq(prop->name, "light_component.type")) {
-      entity_loader->light_component.type =
-        lights::light_type_from_string(get_string(prop));
-    } else if (pstr_eq(prop->name, "light_component.direction")) {
-      entity_loader->light_component.direction = *get_vec3(prop);
-    } else if (pstr_eq(prop->name, "light_component.color")) {
-      entity_loader->light_component.color = *get_vec4(prop);
-    } else if (pstr_eq(prop->name, "light_component.attenuation")) {
-      entity_loader->light_component.attenuation = *get_vec4(prop);
-    } else if (pstr_eq(prop->name, "behavior_component.behavior")) {
-      entity_loader->behavior_component.behavior =
-        behavior::behavior_from_string(get_string(prop));
+    // Build physics::Component, spatial::Component, lights::Component, behavior::Component
+    range (0, entry->n_props) {
+        peony_parser::Prop *prop = &entry->props[idx];
+        if (pstr_eq(prop->name, "physics_component.obb.center")) {
+            entity_loader->physics_component.obb.center = *get_vec3(prop);
+        } else if (pstr_eq(prop->name, "physics_component.obb.x_axis")) {
+            entity_loader->physics_component.obb.x_axis = *get_vec3(prop);
+        } else if (pstr_eq(prop->name, "physics_component.obb.y_axis")) {
+            entity_loader->physics_component.obb.y_axis = *get_vec3(prop);
+        } else if (pstr_eq(prop->name, "physics_component.obb.extents")) {
+            entity_loader->physics_component.obb.extents = *get_vec3(prop);
+        } else if (pstr_eq(prop->name, "spatial_component.position")) {
+            entity_loader->spatial_component.position = *get_vec3(prop);
+        } else if (pstr_eq(prop->name, "spatial_component.rotation")) {
+            entity_loader->spatial_component.rotation = glm::angleAxis(
+                    radians((*get_vec4(prop))[0]),
+                    v3((*get_vec4(prop))[1],
+                        (*get_vec4(prop))[2],
+                        (*get_vec4(prop))[3]));
+        } else if (pstr_eq(prop->name, "spatial_component.scale")) {
+            entity_loader->spatial_component.scale = *get_vec3(prop);
+        } else if (pstr_eq(prop->name, "light_component.type")) {
+            entity_loader->light_component.type =
+                lights::light_type_from_string(get_string(prop));
+        } else if (pstr_eq(prop->name, "light_component.direction")) {
+            entity_loader->light_component.direction = *get_vec3(prop);
+        } else if (pstr_eq(prop->name, "light_component.color")) {
+            entity_loader->light_component.color = *get_vec4(prop);
+        } else if (pstr_eq(prop->name, "light_component.attenuation")) {
+            entity_loader->light_component.attenuation = *get_vec4(prop);
+        } else if (pstr_eq(prop->name, "behavior_component.behavior")) {
+            entity_loader->behavior_component.behavior =
+                behavior::behavior_from_string(get_string(prop));
+        }
     }
-  }
 }

src/peony_parser_utils.hpp

···
 #include "models.hpp"
 #include "renderer.hpp"
 
-namespace peony_parser_utils {
-  constexpr const char *TEXTURE_PREFIX = "textures.";
-  constexpr size_t TEXTURE_PREFIX_LENGTH = 9;
-  constexpr const char *BUILTIN_TEXTURE_PREFIX = "builtin_textures.";
-  constexpr size_t BUILTIN_TEXTURE_PREFIX_LENGTH = 17;
+class peony_parser_utils {
+public:
+    static constexpr const char *TEXTURE_PREFIX = "textures.";
+    static constexpr size_t TEXTURE_PREFIX_LENGTH = 9;
+    static constexpr const char *BUILTIN_TEXTURE_PREFIX = "builtin_textures.";
+    static constexpr size_t BUILTIN_TEXTURE_PREFIX_LENGTH = 17;
 
-  char* get_string(PeonyFileProp *prop);
-  bool32* get_boolean(PeonyFileProp *prop);
-  real32* get_number(PeonyFileProp *prop);
-  v2* get_vec2(PeonyFileProp *prop);
-  v3* get_vec3(PeonyFileProp *prop);
-  v4* get_vec4(PeonyFileProp *prop);
-  PeonyFileProp* find_prop(PeonyFileEntry *entry, char const *name);
-  void get_unique_string_values_for_prop_name(
-    PeonyFile *pf,
-    Array<char[MAX_COMMON_NAME_LENGTH]> *unique_values,
-    char const *prop_name
-  );
-  void create_material_from_peony_file_entry(
-    mats::Material *material,
-    PeonyFileEntry *entry,
-    memory::Pool *memory_pool
-  );
-  void create_model_loader_from_peony_file_entry(
-    PeonyFileEntry *entry,
-    entities::Handle entity_handle,
-    models::ModelLoader *model_loader
-  );
-  void create_entity_loader_from_peony_file_entry(
-    PeonyFileEntry *entry,
-    entities::Handle entity_handle,
-    models::EntityLoader *entity_loader
-  );
-}
+    static char * get_string(peony_parser::Prop *prop);
+    static bool32 * get_boolean(peony_parser::Prop *prop);
+    static real32 * get_number(peony_parser::Prop *prop);
+    static v2 * get_vec2(peony_parser::Prop *prop);
+    static v3 * get_vec3(peony_parser::Prop *prop);
+    static v4 * get_vec4(peony_parser::Prop *prop);
+    static peony_parser::Prop * find_prop(peony_parser::Entry *entry, char const *name);
+    static void get_unique_string_values_for_prop_name(
+        peony_parser::PeonyFile *pf,
+        Array<char[MAX_COMMON_NAME_LENGTH]> *unique_values,
+        char const *prop_name
+    );
+    static void create_material_from_peony_file_entry(
+        mats::Material *material,
+        peony_parser::Entry *entry,
+        memory::Pool *memory_pool
+    );
+    static void create_model_loader_from_peony_file_entry(
+        peony_parser::Entry *entry,
+        entities::Handle entity_handle,
+        models::ModelLoader *model_loader
+    );
+    static void create_entity_loader_from_peony_file_entry(
+        peony_parser::Entry *entry,
+        entities::Handle entity_handle,
+        models::EntityLoader *entity_loader
+    );
+};

src/physics.cpp

···
 
 physics::RayCollisionResult
 physics::find_ray_collision(
-    Ray *ray,
+    spatial::Ray *ray,
     // TODO: Replace this with some kind of collision layers.
     physics::Component *physics_component_to_ignore_or_nullptr
 ) {
···
 }
 
 
-Obb
-physics::transform_obb(Obb obb, spatial::Component *spatial)
+spatial::Obb
+physics::transform_obb(spatial::Obb obb, spatial::Component *spatial)
 {
     m3 rotation = glm::toMat3(normalize(spatial->rotation));
     obb.center = spatial->position + (rotation * (spatial->scale * obb.center));
···
 
 
 physics::RaycastResult
-physics::intersect_obb_ray(Obb *obb, Ray *ray)
+physics::intersect_obb_ray(spatial::Obb *obb, spatial::Ray *ray)
 {
     // Gabor Szauer, Game Physics Cookbook, “Raycast Oriented Bounding Box”
     v3 obb_z_axis = cross(obb->x_axis, obb->y_axis);
···
 }
 
 
-Face
+spatial::Face
 physics::get_incident_face(
     m3 *cob, // incident change of base
     v3 e, // incident extents
     v3 c, // incident center
     v3 n // incident normal
 ) {
-    Face face;
+    spatial::Face face;
     n = transpose(*cob) * n;
     v3 abs_n = abs(n);
 
···
 physics::clip_faces(
     v3 reference_center, v3 reference_face_extents,
     uint32 clip_edges[4], m3 reference_face_cob,
-    Face incident_face,
+    spatial::Face incident_face,
     v3 clip_vertices[8], real32 clip_depths[8]
 ) {
     return 0;
···
 */
 physics::CollisionManifold
 physics::intersect_obb_obb(
-    Obb *a,
-    Obb *b,
+    spatial::Obb *a,
+    spatial::Obb *b,
     spatial::Component *spatial_a,
     spatial::Component *spatial_b
 ) {
···
     }
 
     if (manifold.axis < 6) {
-        // Face-something collision
+        // spatial::Face-something collision
         v3 reference_extents, incident_extents, reference_center, incident_center;
         m3 reference_cob, incident_cob;
 
···
             incident_center = a->center;
         }
 
-        Face incident_face = get_incident_face(&incident_cob, incident_extents, incident_center, manifold.normal);
+        spatial::Face incident_face = get_incident_face(&incident_cob, incident_extents, incident_center, manifold.normal);
 
         uint32 clip_edges[4];
         m3 reference_face_cob;

src/physics.hpp

···
 
     struct Component {
         entities::Handle entity_handle;
-        Obb obb;
-        Obb transformed_obb;
+        spatial::Obb obb;
+        spatial::Obb transformed_obb;
     };
 
     struct ComponentSet {
···
     };
 
     static RayCollisionResult find_ray_collision(
-        Ray *ray,
+        spatial::Ray *ray,
         Component *physics_component_to_ignore_or_nullptr
     );
     static CollisionManifold find_collision(
···
     static void update_components();
 
 private:
-    static Obb transform_obb(Obb obb, spatial::Component *spatial);
-    static RaycastResult intersect_obb_ray(Obb *obb, Ray *ray);
+    static spatial::Obb transform_obb(spatial::Obb obb, spatial::Component *spatial);
+    static RaycastResult intersect_obb_ray(spatial::Obb *obb, spatial::Ray *ray);
     static bool is_component_valid(Component *physics_component);
     static v3 get_edge_contact_point(
         v3 a_edge_point,
···
         real32 b_axis_length,
         bool32 should_use_a_midpoint
     );
-    static Face get_incident_face(m3 *cob, v3 e, v3 c, v3 n);
+    static spatial::Face get_incident_face(m3 *cob, v3 e, v3 c, v3 n);
     static void get_reference_face_edges_and_basis(
         m3 *cob,
         v3 e,
···
     static uint32 clip_faces(
         v3 reference_center, v3 reference_face_extents,
         uint32 clip_edges[4], m3 reference_face_cob,
-        Face incident_face,
+        spatial::Face incident_face,
         v3 clip_vertices[8], real32 clip_depths[8]
     );
     static void update_best_for_face_axis(
···
         real32 sep, uint32 axis, v3 normal
     );
     static CollisionManifold intersect_obb_obb(
-        Obb *a,
-        Obb *b,
+        spatial::Obb *a,
+        spatial::Obb *b,
         spatial::Component *spatial_a,
         spatial::Component *spatial_b
     );

src/queue.hpp

···
 template <typename T>
 class Queue {
 public:
-  uint32 size = 0;
-  uint32 max_size = 0;
-  T *items = nullptr;
-  uint32 head = 0;
-  uint32 tail = 0;
+    uint32 size = 0;
+    uint32 max_size = 0;
+    T *items = nullptr;
+    uint32 head = 0;
+    uint32 tail = 0;
 
-  T* push() {
-    assert(this->size < this->max_size);
-    T* new_slot = this->items + this->tail;
-    if (this->tail + 1 >= this->max_size) {
-      this->tail = 0;
-    } else {
-      this->tail++;
+    T* push() {
+        assert(this->size < this->max_size);
+        T* new_slot = this->items + this->tail;
+        if (this->tail + 1 >= this->max_size) {
+            this->tail = 0;
+        } else {
+            this->tail++;
+        }
+        this->size++;
+        return new_slot;
     }
-    this->size++;
-    return new_slot;
-  }
 
-  T push(T new_item) {
-    T* new_slot = push();
-    *new_slot = new_item;
-    return new_item;
-  }
+    T push(T new_item) {
+        T* new_slot = push();
+        *new_slot = new_item;
+        return new_item;
+    }
 
-  T* pop() {
-    assert(this->size > 0);
-    T* item = this->items + this->head;
-    if (this->head + 1 >= this->max_size) {
-      this->head = 0;
-    } else {
-      this->head++;
+    T* pop() {
+        assert(this->size > 0);
+        T* item = this->items + this->head;
+        if (this->head + 1 >= this->max_size) {
+            this->head = 0;
+        } else {
+            this->head++;
+        }
+        this->size--;
+        return item;
     }
-    this->size--;
-    return item;
-  }
 
-  Queue(memory::Pool *memory_pool, uint32 new_max_size, const char *debug_name) {
-    this->max_size = new_max_size;
-    this->items = (T*)memory::push(memory_pool, sizeof(T) * this->max_size, debug_name);
-  }
+    Queue(memory::Pool *memory_pool, uint32 new_max_size, const char *debug_name) {
+        this->max_size = new_max_size;
+        this->items = (T*)memory::push(memory_pool, sizeof(T) * this->max_size, debug_name);
+    }
 
-  Queue(memory::Pool *memory_pool, uint32 new_size, uint32 new_max_size, T *new_items) {
-    this->size = new_size;
-    this->head = 0;
-    this->tail = new_size;
-    this->max_size = new_max_size;
-    this->items = new_items;
-  }
+    Queue(memory::Pool *memory_pool, uint32 new_size, uint32 new_max_size, T *new_items) {
+        this->size = new_size;
+        this->head = 0;
+        this->tail = new_size;
+        this->max_size = new_max_size;
+        this->items = new_items;
+    }
 };

src/renderer.cpp

···
     drawable::Mode render_mode,
     shaders::Asset *standard_depth_shader_asset
 ) {
-    ModelMatrixCache cache = { m4(1.0f), nullptr };
+    spatial::ModelMatrixCache cache = { m4(1.0f), nullptr };
 
     each (drawable_component, *engine::get_drawable_components()) {
         if (!drawable::is_component_valid(drawable_component)) {

src/spatial.cpp

···
 #include "engine.hpp"
 
 
-void spatial::print_spatial_component(spatial::Component *spatial_component) {
-  logs::info("spatial::Component:");
-  logs::info("  entity_handle: %d", spatial_component->entity_handle);
-  logs::info("  position:");
-  logs::print_v3(&spatial_component->position);
-  logs::info("  rotation:");
-  logs::info("(don't know how to print rotation, sorry)");
-  /* logs::print_v4(&spatial_component->rotation); */
-  logs::info("  scale:");
-  logs::print_v3(&spatial_component->scale);
-  logs::info("  parent_entity_handle: %d", spatial_component->parent_entity_handle);
+void
+spatial::print_spatial_component(spatial::Component *spatial_component)
+{
+    logs::info("spatial::Component:");
+    logs::info("  entity_handle: %d", spatial_component->entity_handle);
+    logs::info("  position:");
+    logs::print_v3(&spatial_component->position);
+    logs::info("  rotation:");
+    logs::info("(don't know how to print rotation, sorry)");
+    /* logs::print_v4(&spatial_component->rotation); */
+    logs::info("  scale:");
+    logs::print_v3(&spatial_component->scale);
+    logs::info("  parent_entity_handle: %d", spatial_component->parent_entity_handle);
 }
 
 
-bool32 spatial::does_spatial_component_have_dimensions(
-  spatial::Component *spatial_component
-) {
-  return (
-    spatial_component->scale.x > 0.0f &&
-    spatial_component->scale.y > 0.0f &&
-    spatial_component->scale.z > 0.0f
-  );
+bool32
+spatial::does_spatial_component_have_dimensions(spatial::Component *spatial_component)
+{
+    return (
+        spatial_component->scale.x > 0.0f &&
+        spatial_component->scale.y > 0.0f &&
+        spatial_component->scale.z > 0.0f
+    );
 }
 
 
-bool32 spatial::is_spatial_component_valid(spatial::Component *spatial_component) {
-  return does_spatial_component_have_dimensions(spatial_component) ||
-    spatial_component->parent_entity_handle != entities::NO_ENTITY_HANDLE;
+bool32
+spatial::is_spatial_component_valid(spatial::Component *spatial_component)
+{
+    return does_spatial_component_have_dimensions(spatial_component) ||
+        spatial_component->parent_entity_handle != entities::NO_ENTITY_HANDLE;
 }
 
 
-m4 spatial::make_model_matrix(
-  spatial::Component *spatial_component,
-  ModelMatrixCache *cache
+m4
+spatial::make_model_matrix(
+    spatial::Component *spatial_component,
+    ModelMatrixCache *cache
 ) {
-  m4 model_matrix = m4(1.0f);
+    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_entity_handle);
-    model_matrix = make_model_matrix(parent, cache);
-  }
+    if (spatial_component->parent_entity_handle != entities::NO_ENTITY_HANDLE) {
+        spatial::Component *parent = engine::get_spatial_component(
+            spatial_component->parent_entity_handle);
+        model_matrix = make_model_matrix(parent, cache);
+    }
 
-  if (does_spatial_component_have_dimensions(spatial_component)) {
-    // TODO: This is somehow really #slow, the multiplication in particular.
-    // Is there a better way?
-    if (
-      spatial_component == cache->last_model_matrix_spatial_component
-    ) {
-      model_matrix = cache->last_model_matrix;
-    } else {
-      model_matrix = glm::translate(model_matrix, spatial_component->position);
-      model_matrix = glm::scale(model_matrix, spatial_component->scale);
-      model_matrix = model_matrix *
-        glm::toMat4(normalize(spatial_component->rotation));
-      cache->last_model_matrix = model_matrix;
-      cache->last_model_matrix_spatial_component = spatial_component;
+    if (does_spatial_component_have_dimensions(spatial_component)) {
+        // TODO: This is somehow really #slow, the multiplication in particular.
+        // Is there a better way?
+        if (
+            spatial_component == cache->last_model_matrix_spatial_component
+        ) {
+            model_matrix = cache->last_model_matrix;
+        } else {
+            model_matrix = glm::translate(model_matrix, spatial_component->position);
+            model_matrix = glm::scale(model_matrix, spatial_component->scale);
+            model_matrix = model_matrix *
+                glm::toMat4(normalize(spatial_component->rotation));
+            cache->last_model_matrix = model_matrix;
+            cache->last_model_matrix_spatial_component = spatial_component;
+        }
     }
-  }
 
-  return model_matrix;
+    return model_matrix;
 }

src/spatial.hpp

···
 #include "types.hpp"
 #include "entities.hpp"
 
-namespace spatial {
-  struct Obb {
-    v3 center;
-    v3 x_axis;
-    v3 y_axis; // We can get the z axis with a cross product
-    v3 extents;
-  };
-
-  struct Face {
-    v3 vertices[4];
-  };
+class spatial {
+public:
+    struct Obb {
+        v3 center;
+        v3 x_axis;
+        v3 y_axis; // We can get the z axis with a cross product
+        v3 extents;
+    };
 
-  struct Ray {
-    v3 origin;
-    v3 direction;
-  };
+    struct Face {
+        v3 vertices[4];
+    };
 
+    struct Ray {
+        v3 origin;
+        v3 direction;
+    };
 
-  struct Component {
-    entities::Handle entity_handle;
-    v3 position;
-    quat rotation;
-    v3 scale;
-    entities::Handle parent_entity_handle;
-  };
 
+    struct Component {
+        entities::Handle entity_handle;
+        v3 position;
+        quat rotation;
+        v3 scale;
+        entities::Handle parent_entity_handle;
+    };
 
-  struct ModelMatrixCache {
-    m4 last_model_matrix;
-    Component *last_model_matrix_spatial_component;
-  };
 
-  struct ComponentSet {
-    Array<Component> components;
-  };
+    struct ModelMatrixCache {
+        m4 last_model_matrix;
+        Component *last_model_matrix_spatial_component;
+    };
 
+    struct ComponentSet {
+        Array<Component> components;
+    };
 
-  void print_spatial_component(Component *spatial_component);
-  bool32 does_spatial_component_have_dimensions(Component *spatial_component);
-  bool32 is_spatial_component_valid(Component *spatial_component);
-  m4 make_model_matrix(
-    Component *spatial_component,
-    ModelMatrixCache *cache
-  );
-}
 
-using spatial::Obb, spatial::Face, spatial::Ray, spatial::Component,
-  spatial::ModelMatrixCache, spatial::ComponentSet;
+    static void print_spatial_component(Component *spatial_component);
+    static bool32 does_spatial_component_have_dimensions(Component *spatial_component);
+    static bool32 is_spatial_component_valid(Component *spatial_component);
+    static m4 make_model_matrix(
+        Component *spatial_component,
+        ModelMatrixCache *cache
+    );
+};

src/stackarray.hpp

···
 template <typename T, uint32 capacity>
 class StackArray {
 public:
-  T items[capacity] = {{}};
-  uint32 length = 0;
-  bool32 is_sparse = false;
-  uint32 starting_idx = 0;
+    T items[capacity] = {{}};
+    uint32 length = 0;
+    bool32 is_sparse = false;
+    uint32 starting_idx = 0;
 
-  T* push() {
-    assert(this->length < capacity);
-    uint32 new_idx = this->length;
-    this->length++;
-    T* new_slot = &this->items[new_idx];
-    return new_slot;
-  }
+    T* push() {
+        assert(this->length < capacity);
+        uint32 new_idx = this->length;
+        this->length++;
+        T* new_slot = &this->items[new_idx];
+        return new_slot;
+    }
 
-  T* push(T new_item) {
-    T* new_slot = push();
-    *new_slot = new_item;
-    return new_slot;
-  }
-
-  T* get(uint32 idx) {
-    assert(idx >= this->starting_idx && idx < capacity);
-    if (idx >= this->length) {
-      assert(this->is_sparse);
-      this->length = idx + 1;
+    T* push(T new_item) {
+        T* new_slot = push();
+        *new_slot = new_item;
+        return new_slot;
     }
-    return &this->items[idx];
-  }
 
-  T* operator[](uint32 idx) {
-    return get(idx);
-  }
+    T* get(uint32 idx) {
+        assert(idx >= this->starting_idx && idx < capacity);
+        if (idx >= this->length) {
+            assert(this->is_sparse);
+            this->length = idx + 1;
+        }
+        return &this->items[idx];
+    }
 
-  template <typename F>
-  T* find(F match) {
-    for (auto item = begin(); item < end(); item++) {
-      if (match(item)) {
-        return item;
-      }
+    T* operator[](uint32 idx) {
+        return get(idx);
     }
-    return nullptr;
-  }
+
+    template <typename F>
+        T* find(F match) {
+            for (auto item = begin(); item < end(); item++) {
+                if (match(item)) {
+                    return item;
+                }
+            }
+            return nullptr;
+        }
 
-  T* begin() {
-    return &this->items[this->starting_idx];
-  }
+    T* begin() {
+        return &this->items[this->starting_idx];
+    }
 
-  T* end() {
-    return &this->items[this->length];
-  }
+    T* end() {
+        return &this->items[this->length];
+    }
 
-  void clear() {
-    memset(this->items, 0, sizeof(this->items));
-    this->length = 0;
-  }
+    void clear() {
+        memset(this->items, 0, sizeof(this->items));
+        this->length = 0;
+    }
 
-  void delete_elements_after_index(uint32 idx) {
-    memset(&this->items[idx], 0, sizeof(T) * (this->length - idx));
-    this->length = idx;
-  }
+    void delete_elements_after_index(uint32 idx) {
+        memset(&this->items[idx], 0, sizeof(T) * (this->length - idx));
+        this->length = idx;
+    }
 };

src/util.cpp

···
 #include "util.hpp"
 
 
-const char* util::stringify_glenum(GLenum thing) {
-  switch (thing) {
+char const *
+util::stringify_glenum(GLenum thing)
+{
+    switch (thing) {
     case 0:
-      return "(none)";
+        return "(none)";
     case GL_BYTE:
-      return "GLbyte";
+        return "GLbyte";
     case GL_UNSIGNED_BYTE:
-      return "GLubyte";
+        return "GLubyte";
     case GL_SHORT:
-      return "GLshort";
+        return "GLshort";
     case GL_UNSIGNED_SHORT:
-      return "GLushort";
+        return "GLushort";
     case GL_INT:
-      return "GLint";
+        return "GLint";
     case GL_UNSIGNED_INT:
-      return "GLuint";
+        return "GLuint";
     case GL_HALF_FLOAT:
-      return "GLhalf";
+        return "GLhalf";
     case GL_FLOAT:
-      return "GLfloat";
+        return "GLfloat";
     case GL_DOUBLE:
-      return "GLdouble";
+        return "GLdouble";
     case GL_RGB8:
-      return "GL_RGB8";
+        return "GL_RGB8";
     case GL_RGBA8:
-      return "GL_RGBA8";
+        return "GL_RGBA8";
     case GL_SRGB8:
-      return "GL_SRGB8";
+        return "GL_SRGB8";
     case GL_UNSIGNED_INT_8_8_8_8:
-      return "GL_UNSIGNED_INT_8_8_8_8";
+        return "GL_UNSIGNED_INT_8_8_8_8";
     case GL_UNSIGNED_INT_8_8_8_8_REV:
-      return "GL_UNSIGNED_INT_8_8_8_8_REV";
+        return "GL_UNSIGNED_INT_8_8_8_8_REV";
     case GL_DEPTH_COMPONENT:
-      return "GL_DEPTH_COMPONENT";
+        return "GL_DEPTH_COMPONENT";
     case GL_DEPTH_STENCIL:
-      return "GL_DEPTH_STENCIL";
+        return "GL_DEPTH_STENCIL";
     case GL_RED:
-      return "GL_RED";
+        return "GL_RED";
     case GL_RGB:
-      return "GL_RGB";
+        return "GL_RGB";
     case GL_RGBA:
-      return "GL_RGBA";
+        return "GL_RGBA";
     default:
-      logs::warning("Unknown GLenum %d", thing);
-      return "Unknown GLenum";
-  }
+        logs::warning("Unknown GLenum %d", thing);
+        return "Unknown GLenum";
+    }
 }
 
 
-GLenum util::get_texture_format_from_n_components(int32 n_components) {
-  if (n_components == 1) {
-    return GL_RED;
-  } else if (n_components == 3) {
-    return GL_BGR;
-  } else if (n_components == 4) {
-    return GL_BGRA;
-  } else {
-    logs::fatal("Don't know what to do with n_components = %d", n_components);
-    return 0;
-  }
+GLenum
+util::get_texture_format_from_n_components(int32 n_components)
+{
+    if (n_components == 1) {
+        return GL_RED;
+    } else if (n_components == 3) {
+        return GL_BGR;
+    } else if (n_components == 4) {
+        return GL_BGRA;
+    } else {
+        logs::fatal("Don't know what to do with n_components = %d", n_components);
+        return 0;
+    }
 }
 
 
-real64 util::random(real64 min, real64 max) {
-  uint32 r = rand();
-  real64 r_normalized = (real64)r / (real64)RAND_MAX;
-  return min + ((r_normalized) * (max - min));
+real64
+util::random(real64 min, real64 max)
+{
+    uint32 r = rand();
+    real64 r_normalized = (real64)r / (real64)RAND_MAX;
+    return min + ((r_normalized) * (max - min));
 }
 
 
-v3 util::aiVector3D_to_glm(aiVector3D *vec) {
-  return v3(vec->x, vec->y, vec->z);
+v3
+util::aiVector3D_to_glm(aiVector3D *vec)
+{
+    return v3(vec->x, vec->y, vec->z);
 }
 
 
-quat util::aiQuaternion_to_glm(aiQuaternion *rotation) {
-  return quat(rotation->w, rotation->x, rotation->y, rotation->z);
+quat
+util::aiQuaternion_to_glm(aiQuaternion *rotation)
+{
+    return quat(rotation->w, rotation->x, rotation->y, rotation->z);
 }
 
 
-m4 util::aimatrix4x4_to_glm(aiMatrix4x4 *from) {
-  m4 to;
+m4
+util::aimatrix4x4_to_glm(aiMatrix4x4 *from)
+{
+    m4 to;
 
-  to[0][0] = (GLfloat)from->a1;
-  to[0][1] = (GLfloat)from->b1;
-  to[0][2] = (GLfloat)from->c1;
-  to[0][3] = (GLfloat)from->d1;
+    to[0][0] = (GLfloat)from->a1;
+    to[0][1] = (GLfloat)from->b1;
+    to[0][2] = (GLfloat)from->c1;
+    to[0][3] = (GLfloat)from->d1;
 
-  to[1][0] = (GLfloat)from->a2;
-  to[1][1] = (GLfloat)from->b2;
-  to[1][2] = (GLfloat)from->c2;
-  to[1][3] = (GLfloat)from->d2;
+    to[1][0] = (GLfloat)from->a2;
+    to[1][1] = (GLfloat)from->b2;
+    to[1][2] = (GLfloat)from->c2;
+    to[1][3] = (GLfloat)from->d2;
 
-  to[2][0] = (GLfloat)from->a3;
-  to[2][1] = (GLfloat)from->b3;
-  to[2][2] = (GLfloat)from->c3;
-  to[2][3] = (GLfloat)from->d3;
+    to[2][0] = (GLfloat)from->a3;
+    to[2][1] = (GLfloat)from->b3;
+    to[2][2] = (GLfloat)from->c3;
+    to[2][3] = (GLfloat)from->d3;
 
-  to[3][0] = (GLfloat)from->a4;
-  to[3][1] = (GLfloat)from->b4;
-  to[3][2] = (GLfloat)from->c4;
-  to[3][3] = (GLfloat)from->d4;
+    to[3][0] = (GLfloat)from->a4;
+    to[3][1] = (GLfloat)from->b4;
+    to[3][2] = (GLfloat)from->c4;
+    to[3][3] = (GLfloat)from->d4;
 
-  return to;
+    return to;
 }
 
 
-void util::print_texture_internalformat_info(GLenum internal_format) {
-  if (!GLAD_GL_ARB_internalformat_query) {
-    logs::warning(
-      "Not printing texture_internalformat as this feature is not supported "
-      "on this system."
-    );
-    return;
-  }
+void
+util::print_texture_internalformat_info(GLenum internal_format)
+{
+    if (!GLAD_GL_ARB_internalformat_query) {
+        logs::warning("Not printing texture_internalformat as this feature is not supported on this system.");
+        return;
+    }
 
-  if (!GLAD_GL_ARB_internalformat_query2) {
-    logs::warning(
-      "Printing texture_internalformat, but some information may be missing, "
-      "as internalformat_query2 is not supported on this system."
-    );
-  }
+    if (!GLAD_GL_ARB_internalformat_query2) {
+        logs::warning("Printing texture_internalformat, but some information may be missing, as internalformat_query2 is not supported on this system.");
+    }
 
-  GLint preferred_format;
-  GLint optimal_image_format;
-  GLint optimal_image_type;
+    GLint preferred_format;
+    GLint optimal_image_format;
+    GLint optimal_image_type;
 
-  glGetInternalformativ(
-    GL_TEXTURE_2D, internal_format, GL_INTERNALFORMAT_PREFERRED, 1, &preferred_format
-  );
-  glGetInternalformativ(
-    GL_TEXTURE_2D, internal_format, GL_TEXTURE_IMAGE_FORMAT, 1, &optimal_image_format
-  );
-  glGetInternalformativ(
-    GL_TEXTURE_2D, internal_format, GL_TEXTURE_IMAGE_TYPE, 1, &optimal_image_type
-  );
+    glGetInternalformativ(GL_TEXTURE_2D, internal_format, GL_INTERNALFORMAT_PREFERRED, 1, &preferred_format);
+    glGetInternalformativ(GL_TEXTURE_2D, internal_format, GL_TEXTURE_IMAGE_FORMAT, 1, &optimal_image_format);
+    glGetInternalformativ(GL_TEXTURE_2D, internal_format, GL_TEXTURE_IMAGE_TYPE, 1, &optimal_image_type);
 
-  logs::info("internal format: %s", stringify_glenum(internal_format));
-  logs::info("preferred format: %s", stringify_glenum(preferred_format));
-  logs::info("optimal image format: %s", stringify_glenum(optimal_image_format));
-  logs::info("optimal image type: %s", stringify_glenum(optimal_image_type));
-  logs::print_newline();
+    logs::info("internal format: %s", stringify_glenum(internal_format));
+    logs::info("preferred format: %s", stringify_glenum(preferred_format));
+    logs::info("optimal image format: %s", stringify_glenum(optimal_image_format));
+    logs::info("optimal image type: %s", stringify_glenum(optimal_image_type));
+    logs::print_newline();
 }
 
 
-void APIENTRY util::debug_message_callback(
-  GLenum source, GLenum type, unsigned int id, GLenum severity, GLsizei length,
-  const char *message, const void *userParam
+void
+APIENTRY util::debug_message_callback(
+    GLenum source,
+    GLenum type,
+    unsigned int id,
+    GLenum severity,
+    GLsizei length,
+    char const *message,
+    const void *userParam
 ) {
-  // Ignore insignificant error/warning codes
-  if (
-    // Framebuffer detailed info: The driver allocated storage for
-    // renderbuffer 1.
-    id == 131169 ||
-    // Program/shader state performance warning: Vertex shader in program 19
-    // is being recompiled based on GL state.
-    id == 131218 ||
-    // Buffer detailed info: Buffer object 1522 (bound to
-    // GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (0), and GL_ARRAY_BUFFER_ARB,
-    // usage hint is GL_DYNAMIC_DRAW) will use VIDEO memory as the source for
-    // buffer object operations.
-    id == 131185 ||
-    // Texture state usage warning: The texture object (0) bound to texture
-    // image unit 4 does not have a defined base level and cannot be used for
-    // texture mapping.
-    id == 131204 ||
-    // Pixel-path performance warning: Pixel transfer is synchronized with 3D rendering.
-    id == 131154
-  ) {
-    return;
-  }
+    // Ignore insignificant error/warning codes
+    if (
+        // Framebuffer detailed info: The driver allocated storage for
+        // renderbuffer 1.
+        id == 131169 ||
+        // Program/shader state performance warning: Vertex shader in program 19
+        // is being recompiled based on GL state.
+        id == 131218 ||
+        // Buffer detailed info: Buffer object 1522 (bound to
+        // GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB (0), and GL_ARRAY_BUFFER_ARB,
+        // usage hint is GL_DYNAMIC_DRAW) will use VIDEO memory as the source for
+        // buffer object operations.
+        id == 131185 ||
+        // Texture state usage warning: The texture object (0) bound to texture
+        // image unit 4 does not have a defined base level and cannot be used for
+        // texture mapping.
+        id == 131204 ||
+        // Pixel-path performance warning: Pixel transfer is synchronized with 3D rendering.
+        id == 131154
+    ) {
+        return;
+    }
 
-  logs::warning("Debug message (%d): %s", id, message);
+    logs::warning("Debug message (%d): %s", id, message);
 
-  switch (source) {
+    switch (source) {
     case GL_DEBUG_SOURCE_API:
-      logs::warning("Source: API");
-      break;
+        logs::warning("Source: API");
+        break;
     case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
-      logs::warning("Source: Window System");
-      break;
+        logs::warning("Source: Window System");
+        break;
     case GL_DEBUG_SOURCE_SHADER_COMPILER:
-      logs::warning("Source: Shader Compiler");
-      break;
+        logs::warning("Source: Shader Compiler");
+        break;
     case GL_DEBUG_SOURCE_THIRD_PARTY:
-      logs::warning("Source: Third Party");
-      break;
+        logs::warning("Source: Third Party");
+        break;
     case GL_DEBUG_SOURCE_APPLICATION:
-      logs::warning("Source: Application");
-      break;
+        logs::warning("Source: Application");
+        break;
     case GL_DEBUG_SOURCE_OTHER:
-      logs::warning("Source: Other");
-      break;
-  }
+        logs::warning("Source: Other");
+        break;
+    }
 
-  switch (type) {
+    switch (type) {
     case GL_DEBUG_TYPE_ERROR:
-      logs::warning("Type: Error");
-      break;
+        logs::warning("Type: Error");
+        break;
     case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
-      logs::warning("Type: Deprecated Behaviour");
-      break;
+        logs::warning("Type: Deprecated Behaviour");
+        break;
     case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
-      logs::warning("Type: Undefined Behaviour");
-      break;
+        logs::warning("Type: Undefined Behaviour");
+        break;
     case GL_DEBUG_TYPE_PORTABILITY:
-      logs::warning("Type: Portability");
-      break;
+        logs::warning("Type: Portability");
+        break;
     case GL_DEBUG_TYPE_PERFORMANCE:
-      logs::warning("Type: Performance");
-      break;
+        logs::warning("Type: Performance");
+        break;
     case GL_DEBUG_TYPE_MARKER:
-      logs::warning("Type: Marker");
-      break;
+        logs::warning("Type: Marker");
+        break;
     case GL_DEBUG_TYPE_PUSH_GROUP:
-      logs::warning("Type: Push Group");
-      break;
+        logs::warning("Type: Push Group");
+        break;
     case GL_DEBUG_TYPE_POP_GROUP:
-      logs::warning("Type: Pop Group");
-      break;
+        logs::warning("Type: Pop Group");
+        break;
     case GL_DEBUG_TYPE_OTHER:
-      logs::warning("Type: Other");
-      break;
-  }
+        logs::warning("Type: Other");
+        break;
+    }
 
-  switch (severity) {
+    switch (severity) {
     case GL_DEBUG_SEVERITY_HIGH:
-      logs::warning("Severity: high");
-      break;
+        logs::warning("Severity: high");
+        break;
     case GL_DEBUG_SEVERITY_MEDIUM:
-      logs::warning("Severity: medium");
-      break;
+        logs::warning("Severity: medium");
+        break;
     case GL_DEBUG_SEVERITY_LOW:
-      logs::warning("Severity: low");
-      break;
+        logs::warning("Severity: low");
+        break;
     case GL_DEBUG_SEVERITY_NOTIFICATION:
-      logs::warning("Severity: notification");
-      break;
-  }
+        logs::warning("Severity: notification");
+        break;
+    }
 
-  logs::print_newline();
+    logs::print_newline();
 }
 
 
-real32 util::round_to_nearest_multiple(real32 n, real32 multiple_of) {
-  return (floor((n) / multiple_of) * multiple_of) + multiple_of;
+real32
+util::round_to_nearest_multiple(real32 n, real32 multiple_of)
+{
+    return (floor((n) / multiple_of) * multiple_of) + multiple_of;
 }
 
 
-real64 util::get_us_from_duration(chrono::duration<real64> duration) {
-  return chrono::duration_cast<chrono::duration<real64>>(duration).count();
+real64
+util::get_us_from_duration(chrono::duration<real64> duration)
+{
+    return chrono::duration_cast<chrono::duration<real64>>(duration).count();
 }
 
 
-v3 util::get_orthogonal_vector(v3 *v) {
-  if (v->z < v->x) {
-    return v3(v->y, -v->x, 0.0f);
-  } else {
-    return v3(0.0f, -v->z, v->y);
-  }
+v3
+util::get_orthogonal_vector(v3 *v)
+{
+    if (v->z < v->x) {
+        return v3(v->y, -v->x, 0.0f);
+    } else {
+        return v3(0.0f, -v->z, v->y);
+    }
 }
 
 

src/util.hpp

···
 #include "../src_external/glad/glad.h"
 #include "types.hpp"
 
-namespace util {
-  const char* stringify_glenum(GLenum thing);
-  GLenum get_texture_format_from_n_components(int32 n_components);
-  real64 random(real64 min, real64 max);
-  v3 aiVector3D_to_glm(aiVector3D *vec);
-  quat aiQuaternion_to_glm(aiQuaternion *rotation);
-  m4 aimatrix4x4_to_glm(aiMatrix4x4 *from);
-  void print_texture_internalformat_info(GLenum internal_format);
-  void APIENTRY debug_message_callback(
-    GLenum source, GLenum type, unsigned int id, GLenum severity, GLsizei length,
-    const char *message, const void *userParam
-  );
-  real32 round_to_nearest_multiple(real32 n, real32 multiple_of);
-  real64 get_us_from_duration(chrono::duration<real64> duration);
-  v3 get_orthogonal_vector(v3 *v);
-  uint32 kb_to_b(uint32 value);
-  uint32 mb_to_b(uint32 value);
-  uint32 gb_to_b(uint32 value);
-  uint32 tb_to_b(uint32 value);
-  real32 b_to_kb(uint32 value);
-  real32 b_to_mb(uint32 value);
-  real32 b_to_gb(uint32 value);
-  real32 b_to_tb(uint32 value);
-}
+class util {
+public:
+    static char const * stringify_glenum(GLenum thing);
+    static GLenum get_texture_format_from_n_components(int32 n_components);
+    static real64 random(real64 min, real64 max);
+    static v3 aiVector3D_to_glm(aiVector3D *vec);
+    static quat aiQuaternion_to_glm(aiQuaternion *rotation);
+    static m4 aimatrix4x4_to_glm(aiMatrix4x4 *from);
+    static void print_texture_internalformat_info(GLenum internal_format);
+    static void APIENTRY debug_message_callback(
+        GLenum source, GLenum type, unsigned int id, GLenum severity, GLsizei length,
+        char const *message, const void *userParam
+    );
+    static real32 round_to_nearest_multiple(real32 n, real32 multiple_of);
+    static real64 get_us_from_duration(chrono::duration<real64> duration);
+    static v3 get_orthogonal_vector(v3 *v);
+    static uint32 kb_to_b(uint32 value);
+    static uint32 mb_to_b(uint32 value);
+    static uint32 gb_to_b(uint32 value);
+    static uint32 tb_to_b(uint32 value);
+    static real32 b_to_kb(uint32 value);
+    static real32 b_to_mb(uint32 value);
+    static real32 b_to_gb(uint32 value);
+    static real32 b_to_tb(uint32 value);
+};