change type names

src/anim.cpp

···
 anim::State *anim::state = nullptr;
 
 
-bool32
+bool
 anim::is_animation_component_valid(anim::Component *animation_component)
 {
     return animation_component->n_bones > 0 &&
···
 }
 
 
-uint32
+u32
 anim::push_to_bone_matrix_pool()
 {
     return anim::state->bone_matrix_pool.n_bone_matrix_sets++;
···
 
 
 m4 *
-anim::get_bone_matrix(uint32 idx, uint32 idx_bone, uint32 idx_anim_key)
+anim::get_bone_matrix(u32 idx, u32 idx_bone, u32 idx_anim_key)
 {
     return anim::state->bone_matrix_pool.bone_matrices[
         idx * MAX_N_ANIM_KEYS * MAX_N_BONES +
···
 
                 // If we have multiple anim keys, find the right ones and interpolate.
             } else {
-                real64 animation_timepoint = fmod(engine::get_t(), animation->duration);
+                f64 animation_timepoint = fmod(engine::get_t(), animation->duration);
 
-                uint32 idx_anim_key = get_bone_matrix_anim_key_for_timepoint(
+                u32 idx_anim_key = get_bone_matrix_anim_key_for_timepoint(
                     animation_component,
                     animation_timepoint, animation->idx_bone_matrix_set,
                     idx_bone);
 
-                real64 t0 = *get_bone_matrix_time(
+                f64 t0 = *get_bone_matrix_time(
                     animation->idx_bone_matrix_set, idx_bone, idx_anim_key);
                 m4 transform_t0 = *get_bone_matrix(
                     animation->idx_bone_matrix_set, idx_bone, idx_anim_key);
 
-                real64 t1 = *get_bone_matrix_time(
+                f64 t1 = *get_bone_matrix_time(
                     animation->idx_bone_matrix_set, idx_bone, idx_anim_key + 1);
                 m4 transform_t1 = *get_bone_matrix(
                     animation->idx_bone_matrix_set, idx_bone, idx_anim_key + 1);
 
-                real32 lerp_factor = (real32)((animation_timepoint - t0) / (t1 - t0));
+                f32 lerp_factor = (f32)((animation_timepoint - t0) / (t1 - t0));
 
                 // NOTE: This is probably bad if we have scaling in our transform?
                 m4 interpolated_matrix =
···
 anim::make_bone_matrices_for_animation_bone(
     anim::Component *animation_component,
     aiNodeAnim *ai_channel,
-    uint32 idx_animation,
-    uint32 idx_bone
+    u32 idx_animation,
+    u32 idx_bone
 ) {
     assert(ai_channel->mNumPositionKeys == ai_channel->mNumRotationKeys);
     assert(ai_channel->mNumPositionKeys == ai_channel->mNumScalingKeys);
···
             ai_channel->mRotationKeys[idx_anim_key].mTime);
         assert(ai_channel->mPositionKeys[idx_anim_key].mTime ==
             ai_channel->mScalingKeys[idx_anim_key].mTime);
-        real64 anim_key_time = ai_channel->mPositionKeys[idx_anim_key].mTime;
+        f64 anim_key_time = ai_channel->mPositionKeys[idx_anim_key].mTime;
 
         m4 *bone_matrix = get_bone_matrix(
             animation_component->animations[idx_animation].idx_bone_matrix_set,
             idx_bone, idx_anim_key);
 
-        real64 *time = get_bone_matrix_time(
+        f64 *time = get_bone_matrix_time(
             animation_component->animations[idx_animation].idx_bone_matrix_set,
             idx_bone, idx_anim_key);
 
···
     anim::state->bone_matrix_pool.bone_matrices = Array<m4>(pool,
         MAX_N_ANIMATED_MODELS * MAX_N_BONES * MAX_N_ANIMATIONS * MAX_N_ANIM_KEYS,
         "bone_matrices", true);
-    anim::state->bone_matrix_pool.times = Array<real64>(pool,
+    anim::state->bone_matrix_pool.times = Array<f64>(pool,
         MAX_N_ANIMATED_MODELS * MAX_N_BONES * MAX_N_ANIMATIONS * MAX_N_ANIM_KEYS,
         "bone_matrix_times", true);
 }
 
 
-real64 *
+f64 *
 anim::get_bone_matrix_time(
-    uint32 idx,
-    uint32 idx_bone,
-    uint32 idx_anim_key
+    u32 idx,
+    u32 idx_bone,
+    u32 idx_anim_key
 ) {
     return anim::state->bone_matrix_pool.times[
         idx * MAX_N_ANIM_KEYS * MAX_N_BONES +
···
 }
 
 
-uint32
+u32
 anim::get_bone_matrix_anim_key_for_timepoint(
     anim::Component *animation_component,
-    real64 animation_timepoint,
-    uint32 idx_bone_matrix_set,
-    uint32 idx_bone
+    f64 animation_timepoint,
+    u32 idx_bone_matrix_set,
+    u32 idx_bone
 ) {
     Bone *bone = &animation_component->bones[idx_bone];
     assert(bone->n_anim_keys > 1);
-    uint32 idx_anim_key = bone->last_anim_key;
+    u32 idx_anim_key = bone->last_anim_key;
     do {
-        real64 t0 = *get_bone_matrix_time(idx_bone_matrix_set, idx_bone, idx_anim_key);
-        real64 t1 = *get_bone_matrix_time(idx_bone_matrix_set, idx_bone, idx_anim_key + 1);
+        f64 t0 = *get_bone_matrix_time(idx_bone_matrix_set, idx_bone, idx_anim_key);
+        f64 t1 = *get_bone_matrix_time(idx_bone_matrix_set, idx_bone, idx_anim_key + 1);
         if (animation_timepoint > t0 && animation_timepoint < t1) {
             bone->last_anim_key = idx_anim_key;
             return idx_anim_key;

src/anim.hpp

···
 public:
     struct BoneMatrixPool {
         Array<m4> bone_matrices;
-        Array<real64> times;
-        uint32 n_bone_matrix_sets;
+        Array<f64> times;
+        u32 n_bone_matrix_sets;
     };
 
     struct Bone {
         char name[MAX_NODE_NAME_LENGTH];
-        uint32 idx_parent;
-        uint32 n_anim_keys;
-        uint32 last_anim_key;
+        u32 idx_parent;
+        u32 n_anim_keys;
+        u32 last_anim_key;
         m4 offset;
     };
 
     struct Animation {
         char name[MAX_NODE_NAME_LENGTH];
-        real64 duration;
+        f64 duration;
         // NOTE: Index into the BoneMatrixPool
-        uint32 idx_bone_matrix_set;
+        u32 idx_bone_matrix_set;
     };
 
     struct Component {
         entities::Handle entity_handle;
         Bone bones[MAX_N_BONES];
         m4 bone_matrices[MAX_N_BONES];
-        uint32 n_bones;
+        u32 n_bones;
         Animation animations[MAX_N_ANIMATIONS];
-        uint32 n_animations;
+        u32 n_animations;
     };
 
     struct ComponentSet {
···
         BoneMatrixPool bone_matrix_pool;
     };
 
-    static bool32 is_animation_component_valid(Component *animation_component);
-    static uint32 push_to_bone_matrix_pool();
+    static bool is_animation_component_valid(Component *animation_component);
+    static u32 push_to_bone_matrix_pool();
     static m4 * get_bone_matrix(
-        uint32 idx,
-        uint32 idx_bone,
-        uint32 idx_anim_key
+        u32 idx,
+        u32 idx_bone,
+        u32 idx_anim_key
     );
     static void update_animation_components(
         ComponentSet *animation_component_set,
···
     static void make_bone_matrices_for_animation_bone(
         Component *animation_component,
         aiNodeAnim *ai_channel,
-        uint32 idx_animation,
-        uint32 idx_bone
+        u32 idx_animation,
+        u32 idx_bone
     );
     static Component * find_animation_component(spatial::Component *spatial_component);
     static void init(anim::State *anim_state, memory::Pool *pool);
 
 private:
-    static real64 * get_bone_matrix_time(
-        uint32 idx,
-        uint32 idx_bone,
-        uint32 idx_anim_key
+    static f64 * get_bone_matrix_time(
+        u32 idx,
+        u32 idx_bone,
+        u32 idx_anim_key
     );
-    static uint32 get_bone_matrix_anim_key_for_timepoint(
+    static u32 get_bone_matrix_anim_key_for_timepoint(
         Component *animation_component,
-        real64 animation_timepoint,
-        uint32 idx_bone_matrix_set,
-        uint32 idx_bone
+        f64 animation_timepoint,
+        u32 idx_bone_matrix_set,
+        u32 idx_bone
     );
 
     static anim::State *state;

src/array.hpp

···
 public:
     memory::Pool *memory_pool = nullptr;
     const char *debug_name = nullptr;
-    uint32 length = 0;
-    uint32 capacity = 0;
-    bool32 is_sparse = false;
-    uint32 starting_idx = 0;
+    u32 length = 0;
+    u32 capacity = 0;
+    bool is_sparse = false;
+    u32 starting_idx = 0;
     T *items = nullptr;
 
     void alloc() {
···
             alloc();
         }
         assert(this->length < this->capacity);
-        uint32 new_idx = this->length;
+        u32 new_idx = this->length;
         this->length++;
         T* new_slot = &this->items[new_idx];
         return new_slot;
···
         return new_slot;
     }
 
-    T* get(uint32 idx) {
+    T* get(u32 idx) {
         if (!this->items) {
             alloc();
         }
···
         return &this->items[idx];
     }
 
-    T* operator[](uint32 idx) {
+    T* operator[](u32 idx) {
         return get(idx);
     }
 
···
         this->length = 0;
     }
 
-    void delete_elements_after_index(uint32 idx) {
+    void delete_elements_after_index(u32 idx) {
         memset(&this->items[idx], 0, sizeof(T) * (this->length - idx));
         this->length = idx;
     }
 
     Array(
         memory::Pool *memory_pool,
-        uint32 capacity,
+        u32 capacity,
         const char *debug_name,
-        bool32 is_sparse = false,
-        uint32 starting_idx = 0
+        bool is_sparse = false,
+        u32 starting_idx = 0
     ) :
         memory_pool(memory_pool),
         debug_name(debug_name),

src/behavior.cpp

···
 behavior::State *behavior::state = nullptr;
 
 
-behavior::Function behavior::function_map[(uint32)Behavior::length] = {
+behavior::Function behavior::function_map[(u32)Behavior::length] = {
     (behavior::Function)nullptr,
     (behavior::Function)behavior_functions::test,
     (behavior::Function)behavior_functions::char_movement_test,
···
 }
 
 
-bool32
+bool
 behavior::is_behavior_component_valid(behavior::Component *behavior_component)
 {
     return behavior_component->behavior != Behavior::none;
···
 
         entities::Handle entity_handle = behavior_component->entity_handle;
 
-        auto handler = function_map[(uint32)behavior_component->behavior];
+        auto handler = function_map[(u32)behavior_component->behavior];
         if (handler) {
             handler(entity_handle);
         }

src/behavior.hpp

···
 
     typedef void (*Function) (entities::Handle entity_handle);
 
-    static Function function_map[(uint32)Behavior::length];
+    static Function function_map[(u32)Behavior::length];
 
     static char const * behavior_to_string(Behavior behavior);
     static Behavior behavior_from_string(const char *str);
-    static bool32 is_behavior_component_valid(Component *behavior_component);
+    static bool is_behavior_component_valid(Component *behavior_component);
     static void update_behavior_components(ComponentSet *component_set);
     static void init(
         behavior::State *behavior_state,

src/behavior_functions.cpp

···
     }
 
     spatial_component->rotation =
-        glm::angleAxis((real32)sin(1.0f - (engine::get_t())), v3(0.0f, 1.0f, 0.0f)) *
-        glm::angleAxis((real32)cos(1.0f - (engine::get_t())), v3(1.0f, 0.0f, 0.0f));
+        glm::angleAxis((f32)sin(1.0f - (engine::get_t())), v3(0.0f, 1.0f, 0.0f)) *
+        glm::angleAxis((f32)cos(1.0f - (engine::get_t())), v3(1.0f, 0.0f, 0.0f));
 }
 
 
···
 
     // Update position
     spatial_component->position.x =
-        (real32)sin((engine::get_t()) * 1.0f) * 4.0f +
-        (real32)sin((engine::get_t()) * 2.0f) * 0.1f +
-        (real32)cos((engine::get_t()) * 3.0f) * 0.3f;
+        (f32)sin((engine::get_t()) * 1.0f) * 4.0f +
+        (f32)sin((engine::get_t()) * 2.0f) * 0.1f +
+        (f32)cos((engine::get_t()) * 3.0f) * 0.3f;
     spatial_component->position.z =
-        (real32)cos((engine::get_t()) * 1.0f) * 4.0f +
-        (real32)cos((engine::get_t()) * 2.0f) * 0.3f +
-        (real32)sin((engine::get_t()) * 3.0f) * 0.1f;
+        (f32)cos((engine::get_t()) * 1.0f) * 4.0f +
+        (f32)cos((engine::get_t()) * 2.0f) * 0.3f +
+        (f32)sin((engine::get_t()) * 3.0f) * 0.1f;
     spatial_component->rotation =
         glm::angleAxis(
-            (real32)sin((engine::get_t()) * 3.0f) + radians(70.0f), v3(0.0f, 1.0f, 0.0f)
+            (f32)sin((engine::get_t()) * 3.0f) + radians(70.0f), v3(0.0f, 1.0f, 0.0f)
         ) *
         glm::angleAxis(
-            (real32)cos((engine::get_t()) * 2.0f) / 3.0f, v3(0.0f, 1.0f, 0.0f)
+            (f32)cos((engine::get_t()) * 2.0f) / 3.0f, v3(0.0f, 1.0f, 0.0f)
         ) *
-        glm::angleAxis((real32)cos((engine::get_t()) * 2.0f), v3(1.0f, 0.0f, 0.0f)) *
-        glm::angleAxis((real32)sin((engine::get_t()) * 1.5f) / 2.0f, v3(1.0f, 0.0f, 0.0f)) *
-        glm::angleAxis((real32)sin((engine::get_t()) * 2.5f) / 1.5f, v3(0.5f, 0.5f, 0.2f));
+        glm::angleAxis((f32)cos((engine::get_t()) * 2.0f), v3(1.0f, 0.0f, 0.0f)) *
+        glm::angleAxis((f32)sin((engine::get_t()) * 1.5f) / 2.0f, v3(1.0f, 0.0f, 0.0f)) *
+        glm::angleAxis((f32)sin((engine::get_t()) * 2.5f) / 1.5f, v3(0.5f, 0.5f, 0.2f));
 #if 0
     spatial_component->position.x = -5.0f;
     spatial_component->position.z = -5.0f;
     spatial_component->rotation =
-        glm::angleAxis((real32)sin((engine::get_t())) + radians(70.0f), v3(0.0f, 1.0f, 0.0f)) *
+        glm::angleAxis((f32)sin((engine::get_t())) + radians(70.0f), v3(0.0f, 1.0f, 0.0f)) *
         glm::angleAxis(radians(90.0f), v3(1.0f, 0.0f, 0.0f));
 #endif
 

src/cameras.cpp

···
 
 void
 cameras::update_matrices(
-    Camera *camera, uint32 window_width, uint32 window_height
+    Camera *camera, u32 window_width, u32 window_height
 ) {
     if (window_width == 0 || window_height == 0) {
         return;
···
 
 void
 cameras::update_ui_matrices(
-    Camera *camera, uint32 window_width, uint32 window_height
+    Camera *camera, u32 window_width, u32 window_height
 ) {
-    camera->ui_projection = glm::ortho(0.0f, (real32)window_width,
-        0.0f, (real32)window_height);
+    camera->ui_projection = glm::ortho(0.0f, (f32)window_width,
+        0.0f, (f32)window_height);
 }
 
 
 void
-cameras::move_front_back(Camera *camera, real32 sign, real64 dt)
+cameras::move_front_back(Camera *camera, f32 sign, f64 dt)
 {
-    camera->position += (sign * camera->speed * (real32)dt) * camera->front;
+    camera->position += (sign * camera->speed * (f32)dt) * camera->front;
 }
 
 
 void
-cameras::move_left_right(Camera *camera, real32 sign, real64 dt)
+cameras::move_left_right(Camera *camera, f32 sign, f64 dt)
 {
     v3 direction = normalize(cross(
             camera->front, camera->up
     ));
-    camera->position += (sign * camera->speed * (real32)dt) * direction;
+    camera->position += (sign * camera->speed * (f32)dt) * direction;
 }
 
 
 void
-cameras::move_up_down(Camera *camera, real32 sign, real64 dt)
+cameras::move_up_down(Camera *camera, f32 sign, f64 dt)
 {
-    camera->position += (sign * camera->speed * (real32)dt) * camera->up;
+    camera->position += (sign * camera->speed * (f32)dt) * camera->up;
 }
 
 
···
 void
 cameras::init(
     cameras::State *cameras_state,
-    uint32 window_width,
-    uint32 window_height
+    u32 window_width,
+    u32 window_height
 ) {
     cameras::state = cameras_state;
     cameras::state->camera_main.type = CameraType::perspective;
···
 
 void
 cameras::update_matrices_ortho(
-    Camera *camera, uint32 window_width, uint32 window_height
+    Camera *camera, u32 window_width, u32 window_height
 ) {
     if (window_width == 0 || window_height == 0) {
         return;
···
 
 void
 cameras::update_matrices_perspective(
-    Camera *camera, uint32 window_width, uint32 window_height
+    Camera *camera, u32 window_width, u32 window_height
 ) {
     if (window_width == 0 || window_height == 0) {
         return;
···
         camera->position + camera->front, camera->up);
 
     camera->projection = glm::perspective(radians(camera->horizontal_fov),
-        (real32)window_width / (real32)window_height,
+        (f32)window_width / (f32)window_height,
         camera->near_clip_dist, camera->far_clip_dist);
     // https://en.wikipedia.org/wiki/Field_of_view_in_video_games#Field_of_view_calculations
-    camera->vertical_fov = (real32)degrees(2 *
+    camera->vertical_fov = (f32)degrees(2 *
         atan(tan(radians(camera->horizontal_fov) / 2) * window_height / window_width));
 }

src/cameras.hpp

···
     struct Camera {
         m4 view;
         v3 position;
-        real64 pitch;
+        f64 pitch;
         m4 projection;
         m4 ui_projection;
-        real32 exposure;
-        real32 horizontal_fov;
-        real32 vertical_fov;
-        real32 near_clip_dist;
-        real32 far_clip_dist;
+        f32 exposure;
+        f32 horizontal_fov;
+        f32 vertical_fov;
+        f32 near_clip_dist;
+        f32 far_clip_dist;
         CameraType type;
-        real64 yaw;
+        f64 yaw;
         v3 front;
         v3 up;
-        real32 speed;
+        f32 speed;
     };
 
     struct State {
···
 
     static Camera * get_main();
     static void update_matrices(
-        Camera *camera, uint32 window_width, uint32 window_height
+        Camera *camera, u32 window_width, u32 window_height
     );
     static void update_ui_matrices(
-        Camera *camera, uint32 window_width, uint32 window_height
+        Camera *camera, u32 window_width, u32 window_height
     );
-    static void move_front_back(Camera *camera, real32 sign, real64 dt);
-    static void move_left_right(Camera *camera, real32 sign, real64 dt);
-    static void move_up_down(Camera *camera, real32 sign, real64 dt);
+    static void move_front_back(Camera *camera, f32 sign, f64 dt);
+    static void move_left_right(Camera *camera, f32 sign, f64 dt);
+    static void move_up_down(Camera *camera, f32 sign, f64 dt);
     static void update_mouse(Camera *camera, v2 mouse_offset);
     static void init(
         cameras::State *cameras_state,
-        uint32 window_width,
-        uint32 window_height
+        u32 window_width,
+        u32 window_height
     );
 
 private:
     static void update_matrices_ortho(
-        Camera *camera, uint32 window_width, uint32 window_height
+        Camera *camera, u32 window_width, u32 window_height
     );
     static void update_matrices_perspective(
-        Camera *camera, uint32 window_width, uint32 window_height
+        Camera *camera, u32 window_width, u32 window_height
     );
 
     static cameras::State *state;

src/common.hpp

···
 #pragma once
 
 struct WindowSize {
-    int32 width; // in pixels (size of framebuffer)
-    int32 height; // in pixels (size of framebuffer)
-    uint32 screencoord_width; // in screen coordinates
-    uint32 screencoord_height; // in screen coordinates
+    i32 width; // in pixels (size of framebuffer)
+    i32 height; // in pixels (size of framebuffer)
+    u32 screencoord_width; // in screen coordinates
+    u32 screencoord_height; // in screen coordinates
 };
 

src/constants.hpp

···
 #include "types.hpp"
 
 // Math things
-constexpr real32 PI32 = 3.14159265359f;
-constexpr real64 PI = 3.14159265358979323846;
+constexpr f32 PI32 = 3.14159265359f;
+constexpr f64 PI = 3.14159265358979323846;
 
 // Platform things
 #if !defined(MAX_PATH)
···
 constexpr char DEFAULT_SCENE[] = "terraintest";
 constexpr char SCENE_EXTENSION[] = ".peony_scene";
 constexpr char MATERIAL_FILE_EXTENSION[] = ".peony_materials";
-constexpr uint32 N_LOADING_THREADS = 5;
-constexpr uint32 MAX_N_ENTITIES = 256;
-constexpr uint32 MAX_N_MODELS = 128;
-constexpr uint32 MAX_N_ANIMATED_MODELS = 128;
-constexpr uint32 MAX_DEBUG_NAME_LENGTH = 256;
-constexpr uint32 MAX_GENEROUS_STRING_LENGTH = 512;
-constexpr uint32 MAX_N_MESHES = 128;
-constexpr uint32 MAX_N_MATERIALS = 256;
-constexpr uint32 MAX_N_MATERIALS_PER_MODEL = 16;
-constexpr uint32 MAX_UNIFORM_LENGTH = 256;
-constexpr uint32 MAX_N_TEXTURE_POOL_SIZES = 6;
-constexpr uint32 MAX_N_TEXTURES_PER_MATERIAL = 16;
-constexpr uint8 MAX_N_UNIFORMS = 64;
-constexpr uint8 MAX_UNIFORM_NAME_LENGTH = 64;
-constexpr uint8 MAX_N_TEXTURE_UNITS = 80;
-constexpr uint32 MAX_COMMON_NAME_LENGTH = 128;
-constexpr uint32 MAX_N_BONES = 128;
-constexpr uint32 MAX_N_BONES_PER_VERTEX = 4;
-constexpr uint32 MAX_NODE_NAME_LENGTH = 32;
-constexpr uint32 MAX_N_ANIMATIONS = 2;
-constexpr uint32 MAX_N_ANIM_KEYS = 256;
-constexpr uint16 MAX_N_LIGHTS = 8;
+constexpr u32 N_LOADING_THREADS = 5;
+constexpr u32 MAX_N_ENTITIES = 256;
+constexpr u32 MAX_N_MODELS = 128;
+constexpr u32 MAX_N_ANIMATED_MODELS = 128;
+constexpr u32 MAX_DEBUG_NAME_LENGTH = 256;
+constexpr u32 MAX_GENEROUS_STRING_LENGTH = 512;
+constexpr u32 MAX_N_MESHES = 128;
+constexpr u32 MAX_N_MATERIALS = 256;
+constexpr u32 MAX_N_MATERIALS_PER_MODEL = 16;
+constexpr u32 MAX_UNIFORM_LENGTH = 256;
+constexpr u32 MAX_N_TEXTURE_POOL_SIZES = 6;
+constexpr u32 MAX_N_TEXTURES_PER_MATERIAL = 16;
+constexpr u8 MAX_N_UNIFORMS = 64;
+constexpr u8 MAX_UNIFORM_NAME_LENGTH = 64;
+constexpr u8 MAX_N_TEXTURE_UNITS = 80;
+constexpr u32 MAX_COMMON_NAME_LENGTH = 128;
+constexpr u32 MAX_N_BONES = 128;
+constexpr u32 MAX_N_BONES_PER_VERTEX = 4;
+constexpr u32 MAX_NODE_NAME_LENGTH = 32;
+constexpr u32 MAX_N_ANIMATIONS = 2;
+constexpr u32 MAX_N_ANIM_KEYS = 256;
+constexpr u16 MAX_N_LIGHTS = 8;

src/core.cpp

···
 
 
 void
-core::mouse_callback(GLFWwindow *window, real64 x, real64 y)
+core::mouse_callback(GLFWwindow *window, f64 x, f64 y)
 {
     v2 mouse_pos = v2(x, y);
     input::update_mouse(mouse_pos);
···
 
 
 void
-core::char_callback(GLFWwindow* window, uint32 codepoint) {
+core::char_callback(GLFWwindow* window, u32 codepoint) {
     input::update_text_input(codepoint);
 }
 

src/core.hpp

···
     static int run();
     static void framebuffer_size_callback(GLFWwindow* window, int width, int height);
     static void mouse_button_callback(GLFWwindow *window, int button, int action, int mods);
-    static void mouse_callback(GLFWwindow *window, real64 x, real64 y);
+    static void mouse_callback(GLFWwindow *window, f64 x, f64 y);
     static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
-    static void char_callback(GLFWwindow* window, uint32 codepoint);
+    static void char_callback(GLFWwindow* window, u32 codepoint);
 
 private:
     static bool init_state(State *state, memory::Pool *asset_memory_pool);

src/debug.cpp

···
 }
 
 
-real64 debug_end_timer(chrono::steady_clock::time_point t0) {
-    return ((chrono::duration<real64, std::milli>)(chrono::steady_clock::now() - t0)).count();
+f64 debug_end_timer(chrono::steady_clock::time_point t0) {
+    return ((chrono::duration<f64, std::milli>)(chrono::steady_clock::now() - t0)).count();
 }

src/debug.hpp

···
 #include "types.hpp"
 
 chrono::steady_clock::time_point debug_start_timer();
-real64 debug_end_timer(chrono::steady_clock::time_point t0);
+f64 debug_end_timer(chrono::steady_clock::time_point t0);
 
 #if USE_TIMERS
 #define START_TIMER(name) \
···
 
 #define END_TIMER_MIN(name, min_duration_ms) \
 { \
-    real64 duration = debug_end_timer(debug_timerstart_##name); \
+    f64 duration = debug_end_timer(debug_timerstart_##name); \
     if (duration >= min_duration_ms) { \
         logs::info("Timer %s took %0.fms", #name, duration); \
     } \

src/debug_ui.cpp

···
 
 
 void
-debug_ui::get_entity_text_representation(char *text, entities::Entity *entity, uint8 depth)
+debug_ui::get_entity_text_representation(char *text, entities::Entity *entity, u8 depth)
 {
     // TODO: fixme
     engine::State *engine_state = engine::todo_fixme_get_engine_state();
···
         return;
     }
 
-    bool32 has_spatial_component = spatial::is_spatial_component_valid(spatial_component);
-    bool32 has_drawable_component = drawable::is_component_valid(
+    bool has_spatial_component = spatial::is_spatial_component_valid(spatial_component);
+    bool has_drawable_component = drawable::is_component_valid(
         engine_state->drawable_component_set.components[handle]);
-    bool32 has_light_component = lights::is_light_component_valid(
+    bool has_light_component = lights::is_light_component_valid(
         engine_state->light_component_set.components[handle]);
-    bool32 has_behavior_component = behavior::is_behavior_component_valid(
+    bool has_behavior_component = behavior::is_behavior_component_valid(
         engine_state->behavior_component_set.components[handle]);
-    bool32 has_animation_component = anim::is_animation_component_valid(
+    bool has_animation_component = anim::is_animation_component_valid(
         engine_state->animation_component_set.components[handle]);
 
-    for (uint8 level = 0; level < depth; level++) {
+    for (u8 level = 0; level < depth; level++) {
         strcat(text, "  ");
     }
 
···
 
     if (spatial::is_spatial_component_valid(spatial_component)) {
         // NOTE: This is super slow lol.
-        uint32 n_children_found = 0;
+        u32 n_children_found = 0;
         each (child_spatial_component, engine_state->spatial_component_set.components) {
             if (
                 child_spatial_component->parent_entity_handle ==
···
             }
         }
         if (n_children_found > 5) {
-            for (uint8 level = 0; level < (depth + 1); level++) {
+            for (u8 level = 0; level < (depth + 1); level++) {
                 strcat(text, "  ");
             }
             strcat(text, "(and ");
···
 
     text[0] = '\0';
 
-    constexpr uint32 const MAX_N_SHOWN_ENTITIES = 35;
-    uint32 idx_entity = 0;
+    constexpr u32 const MAX_N_SHOWN_ENTITIES = 35;
+    u32 idx_entity = 0;
     each (entity, engine_state->entity_set.entities) {
         if (idx_entity > MAX_N_SHOWN_ENTITIES) {
             sprintf(text + strlen(text),
···
 
     bool have_seen_non_internal = false;
 
-    uint32 idx = 0;
+    u32 idx = 0;
     each (material, *mats::get_materials()) {
         strcat(text, "- ");
         strcat(text, material->name);

src/debug_ui.hpp

···
     static void render_debug_ui(WindowSize *window_size);
 
 private:
-    static void get_entity_text_representation(char *text, entities::Entity *entity, uint8 depth);
+    static void get_entity_text_representation(char *text, entities::Entity *entity, u8 depth);
     static void get_scene_text_representation(char *text);
     static void get_materials_text_representation(char *text);
 };

src/debugdraw.cpp

···
 
 
 void
-debugdraw::draw_ray(spatial::Ray *ray, real32 length, v4 color)
+debugdraw::draw_ray(spatial::Ray *ray, f32 length, v4 color)
 {
     v3 end_pos = ray->origin + ray->direction * length;
     v3 x_axis = util::get_orthogonal_vector(&ray->direction);
     v3 z_axis = cross(ray->direction, x_axis);
-    real32 chevron_size = 0.2f;
+    f32 chevron_size = 0.2f;
     v3 chevron_1_pos = end_pos + ((-ray->direction + x_axis) * chevron_size);
     v3 chevron_2_pos = end_pos + ((-ray->direction - x_axis) * chevron_size);
     v3 chevron_3_pos = end_pos + ((-ray->direction + z_axis) * chevron_size);
···
 
 
 void
-debugdraw::draw_point(v3 position, real32 size, v4 color)
+debugdraw::draw_point(v3 position, f32 size, v4 color)
 {
     spatial::Obb obb = {
         .center=position,
···
         glBindBuffer(GL_ARRAY_BUFFER, debugdraw::state->vbo);
         glBufferData(GL_ARRAY_BUFFER, VERTEX_SIZE * MAX_N_VERTICES, NULL, GL_DYNAMIC_DRAW);
 
-        uint32 location;
+        u32 location;
 
         // position (vec3)
         location = 0;
···
         location = 1;
         glEnableVertexAttribArray(location);
         glVertexAttribPointer(location, 4, GL_FLOAT, GL_FALSE, VERTEX_SIZE,
-            (void*)(3 * sizeof(real32)));
+            (void*)(3 * sizeof(f32)));
     }
 
     memory::destroy_memory_pool(&temp_memory_pool);
···
 
 
 void
-debugdraw::push_vertices(DebugDrawVertex vertices[], uint32 n_vertices)
+debugdraw::push_vertices(DebugDrawVertex vertices[], u32 n_vertices)
 {
     if (debugdraw::state->n_vertices_pushed + n_vertices > MAX_N_VERTICES) {
         logs::error("Pushed too many DebugDraw vertices, did you forget to call debugdraw::clear()?");

src/debugdraw.hpp

···
 
 class debugdraw {
 public:
-    static constexpr uint32 MAX_N_VERTICES = 2048;
-    static constexpr uint32 VERTEX_LENGTH = 7;
-    static constexpr size_t VERTEX_SIZE = sizeof(real32) * VERTEX_LENGTH;
+    static constexpr u32 MAX_N_VERTICES = 2048;
+    static constexpr u32 VERTEX_LENGTH = 7;
+    static constexpr size_t VERTEX_SIZE = sizeof(f32) * VERTEX_LENGTH;
 
     struct DebugDrawVertex {
         v3 position;
···
 
     struct State {
         shaders::Asset shader_asset;
-        uint32 vao;
-        uint32 vbo;
+        u32 vao;
+        u32 vbo;
         DebugDrawVertex vertices[MAX_N_VERTICES];
-        uint32 n_vertices_pushed;
+        u32 n_vertices_pushed;
     };
 
     static void draw_line(v3 start_pos, v3 end_pos, v4 color);
-    static void draw_ray(spatial::Ray *ray, real32 length, v4 color);
+    static void draw_ray(spatial::Ray *ray, f32 length, v4 color);
     static void draw_quad(
         v3 p1, // clockwise: top left
         v3 p2, // top right
···
         v4 color
     );
     static void draw_obb(spatial::Obb *obb, v4 color);
-    static void draw_point(v3 position, real32 size, v4 color);
+    static void draw_point(v3 position, f32 size, v4 color);
     static void clear();
     static void render();
     static void init(debugdraw::State *debug_draw_state, memory::Pool *memory_pool);
 
 private:
-    static void push_vertices(DebugDrawVertex vertices[], uint32 n_vertices);
+    static void push_vertices(DebugDrawVertex vertices[], u32 n_vertices);
 
     static debugdraw::State *state;
 };

src/drawable.cpp

···
 }
 
 
-bool32
+bool
 drawable::is_component_valid(drawable::Component *drawable_component)
 {
     return geom::is_mesh_valid(&drawable_component->mesh);

src/drawable.hpp

···
 public:
     enum class Mode { regular, depth };
 
-    enum class Pass : uint32 {
+    enum class Pass : u32 {
         none = 0,
         shadowcaster = (1 << 0),
         deferred = (1 << 1),
···
 
     struct ComponentSet {
         Array<drawable::Component> components;
-        uint32 last_drawn_shader_program;
+        u32 last_drawn_shader_program;
     };
 
     static char const * render_pass_to_string(drawable::Pass render_pass);
     static drawable::Pass render_pass_from_string(const char* str);
-    static bool32 is_component_valid(drawable::Component *drawable_component);
+    static bool is_component_valid(drawable::Component *drawable_component);
     static void destroy_component(drawable::Component *drawable_component);
 };

src/drawinfo.hpp

···
 public:
     enum class Mode { regular, depth };
 
-    enum class Pass : uint32 {
+    enum class Pass : u32 {
         none = 0,
         shadowcaster = (1 << 0),
         deferred = (1 << 1),

src/engine.cpp

···
 }
 
 
-real64
+f64
 engine::get_t()
 {
     return engine::state->t;
 }
 
 
-real64
+f64
 engine::get_dt()
 {
     return engine::state->dt;
···
 engine::destroy_non_internal_entities()
 {
     for (
-        uint32 idx = engine::state->entity_set.first_non_internal_handle;
+        u32 idx = engine::state->entity_set.first_non_internal_handle;
         idx < engine::state->entity_set.entities.length;
         idx++
     ) {
···
 }
 
 
-bool32
+bool
 engine::load_scene(const char *scene_name)
 {
     // If the current scene has not finished loading, we can neither
···
         // 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(
-            [model_path](models::ModelLoader *candidate_model_loader) -> bool32 {
+            [model_path](models::ModelLoader *candidate_model_loader) -> bool {
                 return pstr_eq(model_path, candidate_model_loader->model_path);
             }
         );
···
 
 
 void
-engine::update_light_position(real32 amount)
+engine::update_light_position(f32 amount)
 {
     each (light_component, engine::state->light_component_set.components) {
         if (light_component->type == lights::LightType::directional) {
···
     }
 
     if (input::is_key_down(GLFW_KEY_Z)) {
-        update_light_position(0.10f * (real32)(engine::get_dt()));
+        update_light_position(0.10f * (f32)(engine::get_dt()));
     }
 
     if (input::is_key_down(GLFW_KEY_X)) {
-        update_light_position(-0.10f * (real32)(engine::get_dt()));
+        update_light_position(-0.10f * (f32)(engine::get_dt()));
     }
 
     if (input::is_key_down(GLFW_KEY_SPACE)) {
···
 }
 
 
-bool32
+bool
 engine::check_all_entities_loaded()
 {
     bool are_all_done_loading = true;
···
         }
     }
 
-    uint32 new_n_valid_model_loaders = 0;
+    u32 new_n_valid_model_loaders = 0;
     each (model_loader, engine::state->model_loaders) {
         if (!models::is_model_loader_valid(model_loader)) {
             continue;
···
     }
     engine::state->n_valid_model_loaders = new_n_valid_model_loaders;
 
-    uint32 new_n_valid_entity_loaders = 0;
+    u32 new_n_valid_entity_loaders = 0;
     each (entity_loader, engine::state->entity_loader_set.loaders) {
         if (!models::is_entity_loader_valid(entity_loader)) {
             continue;
···
         new_n_valid_entity_loaders++;
 
         models::ModelLoader *model_loader = engine::state->model_loaders.find(
-            [entity_loader](models::ModelLoader *candidate_model_loader) -> bool32 {
+            [entity_loader](models::ModelLoader *candidate_model_loader) -> bool {
                 return pstr_eq(entity_loader->model_path, candidate_model_loader->model_path);
             }
         );
···
 
 
 engine::TimingInfo
-engine::init_timing_info(uint32 target_fps)
+engine::init_timing_info(u32 target_fps)
 {
     TimingInfo timing_info = {};
     timing_info.second_start = chrono::steady_clock::now();
     timing_info.frame_start = chrono::steady_clock::now();
     timing_info.last_frame_start = chrono::steady_clock::now();
     timing_info.frame_duration = chrono::nanoseconds(
-        (uint32)((real64)1.0f / (real64)target_fps)
+        (u32)((f64)1.0f / (f64)target_fps)
     );
     return timing_info;
 }
 
 
 void
-engine::update_timing_info(TimingInfo *timing, uint32 *last_fps)
+engine::update_timing_info(TimingInfo *timing, u32 *last_fps)
 {
     timing->n_frames_since_start++;
     timing->last_frame_start = timing->frame_start;
···
     timing->time_frame_should_end = timing->frame_start + timing->frame_duration;
 
     timing->n_frames_this_second++;
-    chrono::duration<real64> time_since_second_start =
+    chrono::duration<f64> time_since_second_start =
         timing->frame_start - timing->second_start;
     if (time_since_second_start >= chrono::seconds(1)) {
         timing->second_start = timing->frame_start;
···
     engine::state->dt = util::get_us_from_duration(
         timing->frame_start - timing->last_frame_start);
     if (engine::state->timescale_diff != 0.0f) {
-        engine::state->dt *= max(1.0f + engine::state->timescale_diff, (real64)0.01f);
+        engine::state->dt *= max(1.0f + engine::state->timescale_diff, (f64)0.01f);
     }
 
     engine::state->perf_counters.dt_hist[engine::state->perf_counters.dt_hist_idx] =
···
     if (engine::state->perf_counters.dt_hist_idx >= DT_HIST_LENGTH) {
         engine::state->perf_counters.dt_hist_idx = 0;
     }
-    real64 dt_hist_sum = 0.0f;
-    for (uint32 idx = 0; idx < DT_HIST_LENGTH; idx++) {
+    f64 dt_hist_sum = 0.0f;
+    for (u32 idx = 0; idx < DT_HIST_LENGTH; idx++) {
         dt_hist_sum += engine::state->perf_counters.dt_hist[idx];
     }
     engine::state->perf_counters.dt_average = dt_hist_sum / DT_HIST_LENGTH;

src/engine.hpp

···
 #include "cameras.hpp"
 
 
-static constexpr uint32 DT_HIST_LENGTH = 512;
+static constexpr u32 DT_HIST_LENGTH = 512;
 
 
 class engine {
···
         chrono::steady_clock::time_point time_frame_should_end;
 
         chrono::steady_clock::time_point second_start;
-        uint32 n_frames_this_second;
-        uint32 n_frames_since_start;
+        u32 n_frames_this_second;
+        u32 n_frames_since_start;
     };
 
     struct PerfCounters {
-        real64 dt_average;
-        real64 dt_hist[DT_HIST_LENGTH];
-        uint32 dt_hist_idx;
-        uint32 last_fps;
+        f64 dt_average;
+        f64 dt_hist[DT_HIST_LENGTH];
+        u32 dt_hist_idx;
+        u32 last_fps;
     };
 
     struct State {
-        bool32 is_manual_frame_advance_enabled;
-        bool32 should_manually_advance_to_next_frame;
-        bool32 should_stop;
-        bool32 should_pause;
-        bool32 should_limit_fps;
+        bool is_manual_frame_advance_enabled;
+        bool should_manually_advance_to_next_frame;
+        bool should_stop;
+        bool should_pause;
+        bool should_limit_fps;
         char current_scene_name[MAX_COMMON_NAME_LENGTH];
         // NOTE: `t` and `dt` will not change when gameplay is paused.
-        real64 t; // us
-        real64 dt; // us
-        real64 timescale_diff;
+        f64 t; // us
+        f64 dt; // us
+        f64 timescale_diff;
         PerfCounters perf_counters;
-        uint32 n_valid_model_loaders;
-        uint32 n_valid_entity_loaders;
-        bool32 is_world_loaded;
-        bool32 was_world_ever_loaded;
+        u32 n_valid_model_loaders;
+        u32 n_valid_entity_loaders;
+        bool is_world_loaded;
+        bool was_world_ever_loaded;
         Array<models::ModelLoader> model_loaders;
         models::EntityLoaderSet entity_loader_set;
         entities::Set entity_set;
···
     static behavior::Component * get_behavior_component(entities::Handle entity_handle);
     static anim::Component * get_animation_component(entities::Handle entity_handle);
     static physics::Component * get_physics_component(entities::Handle entity_handle);
-    static real64 get_t();
-    static real64 get_dt();
+    static f64 get_t();
+    static f64 get_dt();
     static void run_main_loop(GLFWwindow *window, WindowSize *window_size);
     static void init(engine::State *engine_state, memory::Pool *asset_memory_pool);
 
···
     static void destroy_model_loaders();
     static void destroy_non_internal_entities();
     static void destroy_scene();
-    static bool32 load_scene(const char *scene_name);
+    static bool load_scene(const char *scene_name);
     static void handle_console_command();
-    static void update_light_position(real32 amount);
+    static void update_light_position(f32 amount);
     static void process_input(GLFWwindow *window);
-    static bool32 check_all_entities_loaded();
+    static bool check_all_entities_loaded();
     static void update(WindowSize *window_size);
-    static TimingInfo init_timing_info(uint32 target_fps);
-    static void update_timing_info(TimingInfo *timing, uint32 *last_fps);
+    static TimingInfo init_timing_info(u32 target_fps);
+    static void update_timing_info(TimingInfo *timing, u32 *last_fps);
     static void update_dt_and_perf_counters(TimingInfo *timing);
 };

src/entities.hpp

···
 class entities {
 public:
     // NOTE: 0 is an invalid handle.
-    typedef uint32 Handle;
+    typedef u32 Handle;
 
     struct Entity {
         Handle handle;

src/files.cpp

···
 unsigned char *
 files::load_image(
     const char *path,
-    int32 *width,
-    int32 *height,
-    int32 *n_channels,
+    i32 *width,
+    i32 *height,
+    i32 *n_channels,
     bool should_flip
 ) {
     stbi_set_flip_vertically_on_load(should_flip);
···
 unsigned char *
 files::load_image(
     const char *path,
-    int32 *width,
-    int32 *height,
-    int32 *n_channels
+    i32 *width,
+    i32 *height,
+    i32 *n_channels
 ) {
     return load_image(path, width, height, n_channels, true);
 }
···
 }
 
 
-uint32
+u32
 files::get_file_size(char const *path)
 {
     FILE *f = fopen(path, "rb");
···
         return 0;
     }
     fseek(f, 0, SEEK_END);
-    uint32 size = ftell(f);
+    u32 size = ftell(f);
     fclose(f);
     return size;
 }
···
         return nullptr;
     }
     fseek(f, 0, SEEK_END);
-    uint32 file_size = ftell(f);
+    u32 file_size = ftell(f);
     fseek(f, 0, SEEK_SET);
 
     char *string = (char*)memory::push(memory_pool, file_size + 1, path);
···
         return nullptr;
     }
     fseek(f, 0, SEEK_END);
-    uint32 file_size = ftell(f);
+    u32 file_size = ftell(f);
     fseek(f, 0, SEEK_SET);
 
     size_t result = fread(string, file_size, 1, f);

src/files.hpp

···
 class files {
 public:
     static unsigned char * load_image(
-        char const *path, int32 *width, int32 *height, int32 *n_channels, bool should_flip
+        char const *path, i32 *width, i32 *height, i32 *n_channels, bool should_flip
     );
     static unsigned char * load_image(
-        char const *path, int32 *width, int32 *height, int32 *n_channels
+        char const *path, i32 *width, i32 *height, i32 *n_channels
     );
     static void free_image(unsigned char *image_data);
-    static uint32 get_file_size(char const *path);
+    static u32 get_file_size(char const *path);
     static char const * load_file(memory::Pool *memory_pool, char const *path);
     static char const * load_file(char *string, char const *path);
 };

src/fonts.cpp

···
 #include "intrinsics.hpp"
 
 
-real32
-fonts::frac_px_to_px(uint32 n)
+f32
+fonts::frac_px_to_px(u32 n)
 {
-    return (real32)(n >> 6);
+    return (f32)(n >> 6);
 }
 
 
-real32
-fonts::font_unit_to_px(uint32 n)
+f32
+fonts::font_unit_to_px(u32 n)
 {
     // NOTE: We should be dividing by units_per_em here...probably?
     // This is because we expect height etc. to be in "font units".
     // But treating these metrics as "fractional pixels" seems to work,
     // whereas division by units_per_em doesn't.
     // Check this in more detail.
-    return (real32)(n >> 6);
+    return (f32)(n >> 6);
 }
 
 
···
     FT_Library *ft_library,
     const char *name,
     const char *filename,
-    uint16 font_size
+    u16 font_size
 ) {
     font_asset->name = name;
     font_asset->font_size = font_size;
···
     FT_GlyphSlot glyph = face->glyph;
 
     // TODO: Can we avoid loading all characters twice here?
-    for (uint32 c = 0; c < CHAR_MAX_CODEPOINT_TO_LOAD; c++) {
+    for (u32 c = 0; c < CHAR_MAX_CODEPOINT_TO_LOAD; c++) {
         Character *character = font_asset->characters.push();
 
         if (FT_Load_Char(face, c, FT_LOAD_RENDER)) {
···
 
     mats::activate_font_texture(texture_atlas->texture_name);
 
-    for (uint32 c = 0; c < CHAR_MAX_CODEPOINT_TO_LOAD; c++) {
+    for (u32 c = 0; c < CHAR_MAX_CODEPOINT_TO_LOAD; c++) {
         if (
             // Unicode C0 controls
             (c <= 0x1F) ||

src/fonts.hpp

···
 public:
     // NOTE: Unicode is only the same as ASCII until 0x7F.
     // We can change this to 0xFF when we add Unicode support.
-    static constexpr uint32 CHAR_MAX_CODEPOINT_TO_LOAD = 0x7F;
+    static constexpr u32 CHAR_MAX_CODEPOINT_TO_LOAD = 0x7F;
 
     struct Character {
         iv2 size;
···
     struct FontAsset {
         const char *name;
         Array<Character> characters;
-        uint32 texture;
-        uint32 font_size;
-        uint32 units_per_em;
-        uint32 ascender;
-        uint32 descender;
-        uint32 height;
+        u32 texture;
+        u32 font_size;
+        u32 units_per_em;
+        u32 ascender;
+        u32 descender;
+        u32 height;
     };
 
-    static real32 frac_px_to_px(uint32 n);
-    static real32 font_unit_to_px(uint32 n);
+    static f32 frac_px_to_px(u32 n);
+    static f32 font_unit_to_px(u32 n);
     static FontAsset * get_by_name(Array<FontAsset> *assets, const char *name);
     static FontAsset * init_font_asset(
         FontAsset *font_asset,
···
         FT_Library *ft_library,
         const char *name,
         const char *filename,
-        uint16 font_size
+        u16 font_size
     );
 
 private:

src/geom.cpp

···
 void
 geom::setup_mesh_vertex_buffers(
     Mesh *mesh,
-    Vertex *vertex_data, uint32 n_vertices,
-    uint32 *index_data, uint32 n_indices
+    Vertex *vertex_data, u32 n_vertices,
+    u32 *index_data, u32 n_indices
 ) {
     assert(vertex_data && n_vertices > 0);
 
-    uint32 vertex_size = sizeof(Vertex);
-    uint32 index_size = sizeof(uint32);
+    u32 vertex_size = sizeof(Vertex);
+    u32 index_size = sizeof(u32);
 
     glGenVertexArrays(1, &mesh->vao);
     glGenBuffers(1, &mesh->vbo);
···
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->ebo);
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, index_size * n_indices, index_data, GL_STATIC_DRAW);
 
-    uint32 location;
+    u32 location;
 
     location = 0;
     glEnableVertexAttribArray(location);
···
 }
 
 
-bool32
+bool
 geom::is_mesh_valid(geom::Mesh *mesh)
 {
     return mesh->vao > 0;
···
 void
 geom::make_plane(
     memory::Pool *memory_pool,
-    uint32 x_size, uint32 z_size,
-    uint32 n_x_segments, uint32 n_z_segments,
-    uint32 *n_vertices, uint32 *n_indices,
-    geom::Vertex **vertex_data, uint32 **index_data
+    u32 x_size, u32 z_size,
+    u32 n_x_segments, u32 n_z_segments,
+    u32 *n_vertices, u32 *n_indices,
+    geom::Vertex **vertex_data, u32 **index_data
 ) {
     *n_vertices = 0;
     *n_indices = 0;
 
-    uint32 n_total_vertices = (n_x_segments + 1) * (n_z_segments + 1);
-    uint32 index_data_length = (n_x_segments) * (n_z_segments) * 6;
+    u32 n_total_vertices = (n_x_segments + 1) * (n_z_segments + 1);
+    u32 index_data_length = (n_x_segments) * (n_z_segments) * 6;
 
     *vertex_data = (geom::Vertex*)memory::push(memory_pool, sizeof(geom::Vertex) * n_total_vertices, "plane_vertex_data");
-    *index_data = (uint32*)memory::push(memory_pool, sizeof(uint32) * index_data_length, "plane_index_data");
+    *index_data = (u32*)memory::push(memory_pool, sizeof(u32) * index_data_length, "plane_index_data");
 
-    for (uint32 idx_x = 0; idx_x <= n_x_segments; idx_x++) {
-        for (uint32 idx_z = 0; idx_z <= n_z_segments; idx_z++) {
-            real32 x_segment = (real32)idx_x / (real32)n_x_segments;
-            real32 z_segment = (real32)idx_z / (real32)n_z_segments;
-            real32 x_pos = x_segment * x_size - (x_size / 2);
-            real32 y_pos = 0;
-            real32 z_pos = z_segment * z_size - (z_size / 2);
+    for (u32 idx_x = 0; idx_x <= n_x_segments; idx_x++) {
+        for (u32 idx_z = 0; idx_z <= n_z_segments; idx_z++) {
+            f32 x_segment = (f32)idx_x / (f32)n_x_segments;
+            f32 z_segment = (f32)idx_z / (f32)n_z_segments;
+            f32 x_pos = x_segment * x_size - (x_size / 2);
+            f32 y_pos = 0;
+            f32 z_pos = z_segment * z_size - (z_size / 2);
 
             (*vertex_data)[(*n_vertices)++] = {
                 .position = { x_pos, y_pos, z_pos },
···
 
     // NOTE: Counterclockwise winding order. I could swear this code is CW
     // order though. Not sure where the confusion happens.
-    for (uint32 idx_x = 0; idx_x < n_x_segments; idx_x++) {
-        for (uint32 idx_z = 0; idx_z < n_z_segments; idx_z++) {
+    for (u32 idx_x = 0; idx_x < n_x_segments; idx_x++) {
+        for (u32 idx_z = 0; idx_z < n_z_segments; idx_z++) {
             // This current vertex.
             (*index_data)[(*n_indices)++] = (idx_x * (n_z_segments + 1)) + idx_z;
             // Next row, right of this one.
···
 void
 geom::make_sphere(
     memory::Pool *memory_pool,
-    uint32 n_x_segments, uint32 n_y_segments,
-    uint32 *n_vertices, uint32 *n_indices,
-    geom::Vertex **vertex_data, uint32 **index_data
+    u32 n_x_segments, u32 n_y_segments,
+    u32 *n_vertices, u32 *n_indices,
+    geom::Vertex **vertex_data, u32 **index_data
 ) {
     *n_vertices = 0;
     *n_indices = 0;
 
-    uint32 total_n_vertices = (n_x_segments + 1) * (n_y_segments + 1);
-    uint32 index_data_length = (n_x_segments + 1) * (n_y_segments) * 2;
+    u32 total_n_vertices = (n_x_segments + 1) * (n_y_segments + 1);
+    u32 index_data_length = (n_x_segments + 1) * (n_y_segments) * 2;
 
     *vertex_data = (geom::Vertex*)memory::push(memory_pool, sizeof(geom::Vertex) * total_n_vertices, "sphere_vertex_data");
-    *index_data = (uint32*)memory::push(memory_pool, sizeof(uint32) * index_data_length, "sphere_index_data");
+    *index_data = (u32*)memory::push(memory_pool, sizeof(u32) * index_data_length, "sphere_index_data");
 
-    for (uint32 y = 0; y <= n_y_segments; y++) {
-        for (uint32 x = 0; x <= n_x_segments; x++) {
-            real32 x_segment = (real32)x / (real32)n_x_segments;
-            real32 y_segment = (real32)y / (real32)n_y_segments;
-            real32 x_pos = cos(x_segment * 2.0f * PI32) * sin(y_segment * PI32);
-            real32 y_pos = cos(y_segment * PI32);
-            real32 z_pos = sin(x_segment * 2.0f * PI32) * sin(y_segment * PI32);
+    for (u32 y = 0; y <= n_y_segments; y++) {
+        for (u32 x = 0; x <= n_x_segments; x++) {
+            f32 x_segment = (f32)x / (f32)n_x_segments;
+            f32 y_segment = (f32)y / (f32)n_y_segments;
+            f32 x_pos = cos(x_segment * 2.0f * PI32) * sin(y_segment * PI32);
+            f32 y_pos = cos(y_segment * PI32);
+            f32 z_pos = sin(x_segment * 2.0f * PI32) * sin(y_segment * PI32);
 
             (*vertex_data)[(*n_vertices)++] = {
                 .position = {x_pos, y_pos, z_pos},
···
         }
     }
 
-    for (uint32 y = 0; y < n_y_segments; y++) {
+    for (u32 y = 0; y < n_y_segments; y++) {
         if (y % 2 == 0) {
-            for (uint32 x = 0; x <= n_x_segments; x++) {
+            for (u32 x = 0; x <= n_x_segments; x++) {
                 (*index_data)[(*n_indices)++] = (y + 1) * (n_x_segments + 1) + x;
                 (*index_data)[(*n_indices)++] = y * (n_x_segments + 1) + x;
             }
         } else {
-            for (int32 x = n_x_segments; x >= 0; x--) {
+            for (i32 x = n_x_segments; x >= 0; x--) {
                 (*index_data)[(*n_indices)++] = y * (n_x_segments + 1) + x;
                 (*index_data)[(*n_indices)++] = (y + 1) * (n_x_segments + 1) + x;
             }

src/geom.hpp

···
         v3 position;
         v3 normal;
         v2 tex_coords;
-        uint32 bone_idxs[MAX_N_BONES_PER_VERTEX];
-        real32 bone_weights[MAX_N_BONES_PER_VERTEX];
+        u32 bone_idxs[MAX_N_BONES_PER_VERTEX];
+        f32 bone_weights[MAX_N_BONES_PER_VERTEX];
     };
 
     struct Mesh {
···
         m4 transform;
         char material_name[MAX_COMMON_NAME_LENGTH];
         pack::Pack indices_pack;
-        uint32 vao;
-        uint32 vbo;
-        uint32 ebo;
+        u32 vao;
+        u32 vbo;
+        u32 ebo;
         GLenum mode;
         Vertex *vertices;
-        uint32 *indices;
-        uint32 n_vertices;
-        uint32 n_indices;
+        u32 *indices;
+        u32 n_vertices;
+        u32 n_indices;
     };
 
     static void setup_mesh_vertex_buffers(
         Mesh *mesh,
-        Vertex *vertex_data, uint32 n_vertices,
-        uint32 *index_data, uint32 n_indices
+        Vertex *vertex_data, u32 n_vertices,
+        u32 *index_data, u32 n_indices
     );
-    static bool32 is_mesh_valid(Mesh *mesh);
+    static bool is_mesh_valid(Mesh *mesh);
     static void destroy_mesh(Mesh *mesh);
     static void make_plane(
         memory::Pool *memory_pool,
-        uint32 x_size, uint32 z_size,
-        uint32 n_x_segments, uint32 n_z_segments,
-        uint32 *n_vertices, uint32 *n_indices,
-        Vertex **vertex_data, uint32 **index_data
+        u32 x_size, u32 z_size,
+        u32 n_x_segments, u32 n_z_segments,
+        u32 *n_vertices, u32 *n_indices,
+        Vertex **vertex_data, u32 **index_data
     );
     static void make_sphere(
         memory::Pool *memory_pool,
-        uint32 n_x_segments, uint32 n_y_segments,
-        uint32 *n_vertices, uint32 *n_indices,
-        Vertex **vertex_data, uint32 **index_data
+        u32 n_x_segments, u32 n_y_segments,
+        u32 *n_vertices, u32 *n_indices,
+        Vertex **vertex_data, u32 **index_data
     );
 };

src/gui.cpp

···
 
 
 void
-gui::update_screen_dimensions(uint32 new_window_width, uint32 new_window_height)
+gui::update_screen_dimensions(u32 new_window_width, u32 new_window_height)
 {
     gui::state->window_dimensions = v2(new_window_width, new_window_height);
 }
···
         draw_heading(gui::state->heading_text,
             v4(0.0f, 0.33f, 0.93f, gui::state->heading_opacity));
         if (gui::state->heading_fadeout_delay > 0.0f) {
-            gui::state->heading_fadeout_delay -= (real32)(engine::get_dt());
+            gui::state->heading_fadeout_delay -= (f32)(engine::get_dt());
         } else {
             gui::state->heading_opacity -=
-                gui::state->heading_fadeout_duration * (real32)(engine::get_dt());
+                gui::state->heading_fadeout_duration * (f32)(engine::get_dt());
         }
     }
 }
 
 
-bool32
-gui::draw_toggle(Container *container, const char *text, bool32 toggle_state)
+bool
+gui::draw_toggle(Container *container, const char *text, bool toggle_state)
 {
-    bool32 is_pressed = false;
+    bool is_pressed = false;
 
     v2 text_dimensions = get_text_dimensions(fonts::get_by_name(gui::state->font_assets, "body"), text);
     v2 button_dimensions = TOGGLE_BUTTON_SIZE + BUTTON_DEFAULT_BORDER * 2.0f;
···
 }
 
 
-bool32
+bool
 gui::draw_button(Container *container, const char *text)
 {
-    bool32 is_pressed = false;
+    bool is_pressed = false;
 
     v2 text_dimensions = get_text_dimensions(fonts::get_by_name(gui::state->font_assets, "body"), text);
     v2 button_dimensions = text_dimensions + BUTTON_AUTOSIZE_PADDING + BUTTON_DEFAULT_BORDER * 2.0f;
···
     }
 
     fonts::FontAsset *font_asset = fonts::get_by_name(gui::state->font_assets, "body");
-    real32 line_height = fonts::font_unit_to_px(font_asset->height);
-    real32 line_spacing = floor(line_height * CONSOLE_LINE_SPACING_FACTOR);
+    f32 line_height = fonts::font_unit_to_px(font_asset->height);
+    f32 line_spacing = floor(line_height * CONSOLE_LINE_SPACING_FACTOR);
 
     // Draw console log
     {
···
             v2(gui::state->window_dimensions.x, MAX_CONSOLE_LOG_HEIGHT),
             CONSOLE_BG_COLOR);
 
-        uint32 idx_line = gui::state->console.idx_log_start;
+        u32 idx_line = gui::state->console.idx_log_start;
         while (idx_line != gui::state->console.idx_log_end) {
             v2 text_dimensions = get_text_dimensions(font_asset, gui::state->console.log[idx_line]);
             next_element_position.y -= text_dimensions.y + line_spacing;
···
 
     // Draw console input
     {
-        real32 console_input_height = line_height + (2.0f * CONSOLE_PADDING.y);
+        f32 console_input_height = line_height + (2.0f * CONSOLE_PADDING.y);
         v2 console_input_position = v2(0.0f, MAX_CONSOLE_LOG_HEIGHT);
 
         draw_rect(console_input_position,
···
 
 void
 gui::set_heading(
-    const char *text, real32 opacity,
-    real32 fadeout_duration, real32 fadeout_delay
+    const char *text, f32 opacity,
+    f32 fadeout_duration, f32 fadeout_delay
 ) {
     gui::state->heading_text = text;
     gui::state->heading_opacity = opacity;
···
     gui::State* gui_state,
     iv2 texture_atlas_size,
     Array<fonts::FontAsset> *font_assets,
-    uint32 window_width, uint32 window_height
+    u32 window_width, u32 window_height
 ) {
     gui::state = gui_state;
 
···
 
 
 void
-gui::push_vertices(real32 *vertices, uint32 n_vertices)
+gui::push_vertices(f32 *vertices, u32 n_vertices)
 {
     renderer::push_gui_vertices(vertices, n_vertices);
 }
···
 {
     // NOTE: This returns the dimensions around the main body of the text.
     // This does not include descenders.
-    real32 line_height = fonts::font_unit_to_px(font_asset->height);
-    real32 line_spacing = line_height * LINE_SPACING_FACTOR;
-    real32 ascender = fonts::font_unit_to_px(font_asset->ascender);
+    f32 line_height = fonts::font_unit_to_px(font_asset->height);
+    f32 line_spacing = line_height * LINE_SPACING_FACTOR;
+    f32 ascender = fonts::font_unit_to_px(font_asset->ascender);
 
-    real32 start_x = 0.0f;
-    real32 start_y = 0.0f - (line_height - ascender);
-    real32 max_x = 0.0f;
-    real32 curr_x = start_x;
-    real32 curr_y = start_y;
+    f32 start_x = 0.0f;
+    f32 start_y = 0.0f - (line_height - ascender);
+    f32 max_x = 0.0f;
+    f32 curr_x = start_x;
+    f32 curr_y = start_y;
     size_t str_length = strlen(str);
 
-    for (uint32 idx = 0; idx < str_length; idx++) {
+    for (u32 idx = 0; idx < str_length; idx++) {
         char c = str[idx];
 
         if (c < 32) {
···
 {
     // NOTE: We use top-left as our origin, but OpenGL uses bottom-left.
     // Flip the y axis before drawing.
-    real32 x0 = position.x;
-    real32 x1 = x0 + dimensions.x;
-    real32 y0 = (real32)gui::state->window_dimensions.y - position.y;
-    real32 y1 = y0 - dimensions.y;
+    f32 x0 = position.x;
+    f32 x1 = x0 + dimensions.x;
+    f32 y0 = (f32)gui::state->window_dimensions.y - position.y;
+    f32 y1 = y0 - dimensions.y;
 
-    real32 vertices[VERTEX_LENGTH * 6] = {
+    f32 vertices[VERTEX_LENGTH * 6] = {
         x0, y0, -1.0f, -1.0f, color.r, color.g, color.b, color.a,
         x0, y1, -1.0f, -1.0f, color.r, color.g, color.b, color.a,
         x1, y1, -1.0f, -1.0f, color.r, color.g, color.b, color.a,
···
 ) {
     fonts::FontAsset *font_asset = fonts::get_by_name(gui::state->font_assets, font_name);
 
-    real32 line_height = fonts::font_unit_to_px(font_asset->height);
-    real32 line_spacing = line_height * LINE_SPACING_FACTOR;
-    real32 ascender = fonts::font_unit_to_px(font_asset->ascender);
+    f32 line_height = fonts::font_unit_to_px(font_asset->height);
+    f32 line_spacing = line_height * LINE_SPACING_FACTOR;
+    f32 ascender = fonts::font_unit_to_px(font_asset->ascender);
 
     // NOTE: When changing this code, remember that the text positioning logic
     // needs to be replicated in `get_text_dimensions()`!
-    real32 start_x = position.x;
-    real32 start_y = position.y - (line_height - ascender);
-    real32 curr_x = start_x;
-    real32 curr_y = start_y;
+    f32 start_x = position.x;
+    f32 start_y = position.y - (line_height - ascender);
+    f32 curr_x = start_x;
+    f32 curr_y = start_y;
     size_t str_length = strlen(str);
 
-    for (uint32 idx = 0; idx < str_length; idx++) {
+    for (u32 idx = 0; idx < str_length; idx++) {
         char c = str[idx];
 
         if (c < 32) {
···
             continue;
         }
 
-        real32 char_x = curr_x + character->bearing.x;
-        real32 char_y = curr_y + fonts::font_unit_to_px(font_asset->height) - character->bearing.y;
+        f32 char_x = curr_x + character->bearing.x;
+        f32 char_y = curr_y + fonts::font_unit_to_px(font_asset->height) - character->bearing.y;
 
-        real32 tex_x = (real32)character->tex_coords.x / gui::state->texture_atlas_size.x;
-        real32 tex_y = (real32)character->tex_coords.y / gui::state->texture_atlas_size.y;
-        real32 tex_w = (real32)character->size.x / gui::state->texture_atlas_size.x;
-        real32 tex_h = (real32)character->size.y / gui::state->texture_atlas_size.y;
+        f32 tex_x = (f32)character->tex_coords.x / gui::state->texture_atlas_size.x;
+        f32 tex_y = (f32)character->tex_coords.y / gui::state->texture_atlas_size.y;
+        f32 tex_w = (f32)character->size.x / gui::state->texture_atlas_size.x;
+        f32 tex_h = (f32)character->size.y / gui::state->texture_atlas_size.y;
 
-        real32 w = (real32)character->size.x;
-        real32 h = (real32)character->size.y;
+        f32 w = (f32)character->size.x;
+        f32 h = (f32)character->size.y;
 
         curr_x += fonts::frac_px_to_px(character->advance.x);
         curr_y += fonts::frac_px_to_px(character->advance.y);
···
 
         // NOTE: We use top-left as our origin, but OpenGL uses bottom-left.
         // Flip the y axis before drawing.
-        real32 x0 = char_x;
-        real32 x1 = x0 + w;
-        real32 y0 = (real32)gui::state->window_dimensions.y - char_y;
-        real32 y1 = y0 - h;
+        f32 x0 = char_x;
+        f32 x1 = x0 + w;
+        f32 y0 = (f32)gui::state->window_dimensions.y - char_y;
+        f32 y1 = y0 - h;
 
-        real32 tex_x0 = tex_x;
-        real32 tex_x1 = tex_x0 + tex_w;
-        real32 tex_y0 = tex_y;
-        real32 tex_y1 = tex_y0 + tex_h;
+        f32 tex_x0 = tex_x;
+        f32 tex_x1 = tex_x0 + tex_w;
+        f32 tex_y0 = tex_y;
+        f32 tex_y1 = tex_y0 + tex_h;
 
-        real32 vertices[VERTEX_LENGTH * 6] = {
+        f32 vertices[VERTEX_LENGTH * 6] = {
             x0, y0, tex_x0, tex_y0, color.r, color.g, color.b, color.a,
             x0, y1, tex_x0, tex_y1, color.r, color.g, color.b, color.a,
             x1, y1, tex_x1, tex_y1, color.r, color.g, color.b, color.a,
···
 
 
 void
-gui::draw_line(v2 start, v2 end, real32 thickness, v4 color)
+gui::draw_line(v2 start, v2 end, f32 thickness, v4 color)
 {
     // NOTE: We use top-left as our origin, but OpenGL uses bottom-left.
     // Flip the y axis before drawing.
···
     // 0------------------3
     // |                  |
     // 1------------------2
-    real32 x0 = start.x + delta.y;
-    real32 y0 = gui::state->window_dimensions.y - start.y;
-    real32 x1 = start.x;
-    real32 y1 = gui::state->window_dimensions.y - start.y - delta.x;
-    real32 x2 = end.x;
-    real32 y2 = gui::state->window_dimensions.y - end.y - delta.x;
-    real32 x3 = end.x + delta.y;
-    real32 y3 = gui::state->window_dimensions.y - end.y;
+    f32 x0 = start.x + delta.y;
+    f32 y0 = gui::state->window_dimensions.y - start.y;
+    f32 x1 = start.x;
+    f32 y1 = gui::state->window_dimensions.y - start.y - delta.x;
+    f32 x2 = end.x;
+    f32 y2 = gui::state->window_dimensions.y - end.y - delta.x;
+    f32 x3 = end.x + delta.y;
+    f32 y3 = gui::state->window_dimensions.y - end.y;
 
-    real32 vertices[VERTEX_LENGTH * 6] = {
+    f32 vertices[VERTEX_LENGTH * 6] = {
         x0, y0, -1.0f, -1.0f, color.r, color.g, color.b, color.a,
         x1, y1, -1.0f, -1.0f, color.r, color.g, color.b, color.a,
         x2, y2, -1.0f, -1.0f, color.r, color.g, color.b, color.a,

src/gui.hpp

···
 
 class gui {
 public:
-    static constexpr uint32 MAX_CONSOLE_LINE_LENGTH = 200;
-    static constexpr uint32 MAX_N_CONSOLE_LINES = 30;
+    static constexpr u32 MAX_CONSOLE_LINE_LENGTH = 200;
+    static constexpr u32 MAX_N_CONSOLE_LINES = 30;
     static constexpr char CONSOLE_SYMBOL[] = "> ";
     static constexpr size_t CONSOLE_SYMBOL_LENGTH = 2;
 
     static constexpr const char *MAIN_FONT_REGULAR = "SofiaProRegular.otf";
     static constexpr const char *MAIN_FONT_BOLD = "SofiaProBold.otf";
-    static constexpr real32 LINE_SPACING_FACTOR = 1.8f;
-    static constexpr real32 CONSOLE_LINE_SPACING_FACTOR = 1.2f;
+    static constexpr f32 LINE_SPACING_FACTOR = 1.8f;
+    static constexpr f32 CONSOLE_LINE_SPACING_FACTOR = 1.2f;
 
-    static constexpr uint32 VERTEX_LENGTH = 8;
+    static constexpr u32 VERTEX_LENGTH = 8;
 
     static constexpr v2 TEXT_SHADOW_OFFSET = v2(1.0f);
 
···
     static constexpr v2 BUTTON_AUTOSIZE_PADDING = v2(20.0f, 20.0f);
     static constexpr v2 BUTTON_DEFAULT_BORDER = v2(0.0f);
 
-    static constexpr real32 NAMED_VALUE_NAME_WIDTH = 250.0f;
-    static constexpr real32 TOGGLE_SPACING = 20.0f;
+    static constexpr f32 NAMED_VALUE_NAME_WIDTH = 250.0f;
+    static constexpr f32 TOGGLE_SPACING = 20.0f;
     static constexpr v2 TOGGLE_BUTTON_SIZE = v2(20.0f);
     static constexpr v2 TOGGLE_BUTTON_DEFAULT_BORDER = v2(0.0f);
 
-    static constexpr real32 MAX_CONSOLE_LOG_HEIGHT = 350.0f;
+    static constexpr f32 MAX_CONSOLE_LOG_HEIGHT = 350.0f;
     static constexpr v2 CONSOLE_PADDING = v2(10.0f);
 
     struct Container {
···
         // The main axis has a 1.0f, while the orthogonal axis has a 0.0f.
         v2 direction;
         v2 padding;
-        real32 title_bar_height;
-        uint32 n_elements;
-        real32 element_margin;
+        f32 title_bar_height;
+        u32 n_elements;
+        f32 element_margin;
     };
 
     struct GameConsole {
-        bool32 is_enabled;
+        bool is_enabled;
         char log[gui::MAX_N_CONSOLE_LINES][gui::MAX_CONSOLE_LINE_LENGTH];
-        uint32 idx_log_start;
-        uint32 idx_log_end;
+        u32 idx_log_start;
+        u32 idx_log_end;
     };
 
     struct State {
···
         Container *container_being_moved;
 
         // Heading
-        real32 heading_opacity;
+        f32 heading_opacity;
         const char *heading_text;
-        real32 heading_fadeout_duration;
-        real32 heading_fadeout_delay;
+        f32 heading_fadeout_duration;
+        f32 heading_fadeout_delay;
     };
 
     static void update_screen_dimensions(
-        uint32 new_window_width, uint32 new_window_height
+        u32 new_window_width, u32 new_window_height
     );
     static void update_mouse_button();
     static void update_mouse();
···
     static Container * make_container(const char *title, v2 position);
     static void draw_heading(const char *str, v4 color);
     static void tick_heading();
-    static bool32 draw_toggle(
+    static bool draw_toggle(
         Container *container,
         const char *text,
-        bool32 toggle_state
+        bool toggle_state
     );
     static void draw_named_value(
         Container *container,
···
         const char *value_text
     );
     static void draw_body_text(Container *container, const char *text);
-    static bool32 draw_button(Container *container, const char *text);
+    static bool draw_button(Container *container, const char *text);
     static void draw_console(char *console_input_text);
     static bool is_console_enabled();
     static void set_console_enabled(bool val);
     static void log(const char *format, ...);
     static void set_heading(
-        const char *text, real32 opacity,
-        real32 fadeout_duration, real32 fadeout_delay
+        const char *text, f32 opacity,
+        f32 fadeout_duration, f32 fadeout_delay
     );
     static void init(
         memory::Pool *memory_pool,
         gui::State* gui_state,
         iv2 texture_atlas_size,
         Array<fonts::FontAsset> *font_assets,
-        uint32 window_width, uint32 window_height
+        u32 window_width, u32 window_height
     );
 
 private:
     static void request_cursor(input::CursorType cursor);
     static void set_cursor();
-    static void push_vertices(real32 *vertices, uint32 n_vertices);
+    static void push_vertices(f32 *vertices, u32 n_vertices);
     static v2 get_text_dimensions(fonts::FontAsset *font_asset, char const *str);
     static v2 center_bb(v2 container_position, v2 container_dimensions, v2 element_dimensions);
     static v2 add_element_to_container(Container *container, v2 element_dimensions);
···
         v4 color
     );
     static void draw_container(Container *container);
-    static void draw_line(v2 start, v2 end, real32 thickness, v4 color);
+    static void draw_line(v2 start, v2 end, f32 thickness, v4 color);
     static void draw_frame(v2 position, v2 bottomright, v2 thickness, v4 color);
 
     static gui::State *state;

src/input.cpp

···
 void
 input::update_mouse_button(int button, int action, int mods)
 {
-    bool32 new_state = (action == GLFW_PRESS);
+    bool new_state = (action == GLFW_PRESS);
     if (new_state != input::state->mouse_button_states[button]) {
         input::state->mouse_button_states[button] = new_state;
         input::state->n_mouse_button_state_changes_this_frame[button]++;
···
 }
 
 
-bool32
+bool
 input::is_mouse_button_down(int button)
 {
     return input::state->mouse_button_states[button];
 }
 
 
-bool32
+bool
 input::is_mouse_button_up(int button)
 {
     return !is_mouse_button_down(button);
 }
 
 
-bool32
+bool
 input::is_mouse_button_now_down(int button)
 {
     return is_mouse_button_down(button) &&
···
 }
 
 
-bool32
+bool
 input::is_mouse_button_now_up(int button)
 {
     return is_mouse_button_up(button) &&
···
 
     input::state->mouse_offset = new_mouse_pos - input::state->mouse_pos;
     input::state->mouse_3d_offset =
-        input::state->mouse_offset * (real32)input::state->mouse_3d_sensitivity;
+        input::state->mouse_offset * (f32)input::state->mouse_3d_sensitivity;
     input::state->mouse_pos = new_mouse_pos;
 }
 
···
 
 
 void
-input::update_text_input(uint32 codepoint)
+input::update_text_input(u32 codepoint)
 {
     if (!input::state->is_text_input_enabled) {
         return;
···
 void
 input::update_keys(int key, int scancode, int action, int mods)
 {
-    bool32 new_state = (action == GLFW_PRESS || action == GLFW_REPEAT);
+    bool new_state = (action == GLFW_PRESS || action == GLFW_REPEAT);
     if (new_state != input::state->key_states[key]) {
         input::state->key_states[key] = new_state;
         input::state->n_key_state_changes_this_frame[key]++;
···
 }
 
 
-bool32
+bool
 input::is_key_down(int key)
 {
     return input::state->key_states[key];
 }
 
 
-bool32
+bool
 input::is_key_up(int key)
 {
     return !is_key_down(key);
 }
 
 
-bool32
+bool
 input::is_key_now_down(int key)
 {
     return is_key_down(key) && input::state->n_key_state_changes_this_frame[key] > 0;
 }
 
 
-bool32
+bool
 input::is_key_now_up(int key)
 {
     return is_key_up(key) && input::state->n_key_state_changes_this_frame[key] > 0;
 }
 
 
-bool32
+bool
 input::is_mouse_in_bb(v2 topleft, v2 bottomright)
 {
     return input::state->mouse_pos.x > topleft.x &&

src/input.hpp

···
 
 class input {
 public:
-    static constexpr uint32 MAX_TEXT_INPUT_LENGTH = 512;
-    static constexpr uint32 MAX_TEXT_INPUT_COMMAND_LENGTH = 50;
-    static constexpr uint32 MAX_TEXT_INPUT_ARGUMENTS_LENGTH =
+    static constexpr u32 MAX_TEXT_INPUT_LENGTH = 512;
+    static constexpr u32 MAX_TEXT_INPUT_COMMAND_LENGTH = 50;
+    static constexpr u32 MAX_TEXT_INPUT_ARGUMENTS_LENGTH =
         MAX_TEXT_INPUT_LENGTH - MAX_TEXT_INPUT_COMMAND_LENGTH;
 
     enum class CursorType {
···
         v2 mouse_pos;
         v2 mouse_offset;
         v2 mouse_3d_offset;
-        real64 mouse_3d_sensitivity;
-        bool32 mouse_button_states[GLFW_MOUSE_BUTTON_LAST];
-        uint32 n_mouse_button_state_changes_this_frame[GLFW_MOUSE_BUTTON_LAST];
-        bool32 key_states[GLFW_KEY_LAST];
-        uint32 n_key_state_changes_this_frame[GLFW_KEY_LAST];
+        f64 mouse_3d_sensitivity;
+        bool mouse_button_states[GLFW_MOUSE_BUTTON_LAST];
+        u32 n_mouse_button_state_changes_this_frame[GLFW_MOUSE_BUTTON_LAST];
+        bool key_states[GLFW_KEY_LAST];
+        u32 n_key_state_changes_this_frame[GLFW_KEY_LAST];
         GLFWcursor *current_cursor;
         GLFWcursor *arrow_cursor;
         GLFWcursor *ibeam_cursor;
···
         GLFWcursor *hand_cursor;
         GLFWcursor *hresize_cursor;
         GLFWcursor *vresize_cursor;
-        bool32 have_ever_gotten_mouse_pos;
-        bool32 is_text_input_enabled;
+        bool have_ever_gotten_mouse_pos;
+        bool is_text_input_enabled;
         char text_input[MAX_TEXT_INPUT_LENGTH];
     };
 
···
     static v2 get_mouse_offset();
     static v2 get_mouse_3d_offset();
     static void update_mouse_button(int button, int action, int mods);
-    static bool32 is_mouse_button_down(int button);
-    static bool32 is_mouse_button_up(int button);
-    static bool32 is_mouse_button_now_down(int button);
-    static bool32 is_mouse_button_now_up(int button);
+    static bool is_mouse_button_down(int button);
+    static bool is_mouse_button_up(int button);
+    static bool is_mouse_button_now_down(int button);
+    static bool is_mouse_button_now_up(int button);
     static void update_mouse(v2 new_mouse_pos);
     static void clear_text_input();
     static void enable_text_input();
     static void disable_text_input();
     static void do_text_input_backspace();
-    static void update_text_input(uint32 codepoint);
+    static void update_text_input(u32 codepoint);
     static void update_keys(int key, int scancode, int action, int mods);
-    static bool32 is_key_down(int key);
-    static bool32 is_key_up(int key);
-    static bool32 is_key_now_down(int key);
-    static bool32 is_key_now_up(int key);
-    static bool32 is_mouse_in_bb(v2 topleft, v2 bottomright);
+    static bool is_key_down(int key);
+    static bool is_key_up(int key);
+    static bool is_key_now_down(int key);
+    static bool is_key_now_up(int key);
+    static bool is_mouse_in_bb(v2 topleft, v2 bottomright);
     static void set_cursor(GLFWcursor *new_cursor);
     static void set_cursor(CursorType type);
     static void reset_n_mouse_button_state_changes_this_frame();

src/intrinsics.hpp

···
 // Loops
 #define range_named(idx, start, end) \
     for ( \
-        uint32 idx = (start); \
+        u32 idx = (start); \
         idx < (end); \
         idx++ \
     )

src/lights.cpp

···
 }
 
 
-uint32
+u32
 lights::light_type_to_int(LightType light_type)
 {
     if (light_type == LightType::point) {
···
 }
 
 
-bool32
+bool
 lights::is_light_component_valid(lights::Component *light_component)
 {
     return light_component->type != LightType::none;
···
         }
 
         if (light_component->type == LightType::point) {
-            light_component->color.b = ((real32)sin(engine::get_t()) + 1.0f) / 2.0f * 50.0f;
+            light_component->color.b = ((f32)sin(engine::get_t()) + 1.0f) / 2.0f * 50.0f;
         }
 
         // For the sun! :)

src/lights.hpp

···
     };
 
     struct State {
-        real32 dir_light_angle;
+        f32 dir_light_angle;
     };
 
     static void adjust_dir_light_angle(f32 amount);
     static const char* light_type_to_string(LightType light_type);
     static LightType light_type_from_string(const char *str);
-    static uint32 light_type_to_int(LightType light_type);
-    static bool32 is_light_component_valid(Component *light_component);
+    static u32 light_type_to_int(LightType light_type);
+    static bool is_light_component_valid(Component *light_component);
     static void update_light_components(
         ComponentSet *light_component_set,
         spatial::ComponentSet *spatial_component_set,

src/main.cpp

···
 main()
 {
     // Seed RNG
-    srand((uint32)time(NULL));
+    srand((u32)time(NULL));
 
     //
     //                                    ___

src/mats.cpp

···
 mats::destroy_non_internal_materials()
 {
     for (
-        uint32 idx = mats::state->first_non_internal_material_idx;
+        u32 idx = mats::state->first_non_internal_material_idx;
         idx < mats::state->materials.length;
         idx++
     ) {
···
     Texture *texture,
     GLenum target,
     TextureType type,
-    uint32 texture_name,
-    int32 width,
-    int32 height,
-    int32 n_components
+    u32 texture_name,
+    i32 width,
+    i32 height,
+    i32 n_components
 ) {
     texture->target = target;
     texture->type = type;
···
         shaders::destroy_shader_asset(&material->depth_shader_asset);
     }
 
-    for (uint32 idx = 0; idx < material->n_textures; idx++) {
+    for (u32 idx = 0; idx < material->n_textures; idx++) {
         Texture *texture = &material->textures[idx];
         if (!texture->is_builtin) {
             destroy_texture(texture);
···
         glUseProgram(shader_asset->program);
 
         for (
-            uint32 uniform_idx = 0;
+            u32 uniform_idx = 0;
             uniform_idx < shader_asset->n_intrinsic_uniforms;
             uniform_idx++
         ) {
···
 
         shaders::reset_texture_units(shader_asset);
 
-        for (uint32 idx = 0; idx < material->n_textures; idx++) {
+        for (u32 idx = 0; idx < material->n_textures; idx++) {
             Texture *texture = &material->textures[idx];
             const char *uniform_name = material->texture_uniform_names[idx];
 #if USE_SHADER_DEBUG
···
 }
 
 
-bool32
+bool
 mats::prepare_material_and_check_if_done(Material *material)
 {
     if (material->state == MaterialState::empty) {
···
     if (material->state == MaterialState::initialized) {
         // NOTE: We only have to copy stuff if we have one or more textures that
         // don't have names yet.
-        bool32 should_try_to_copy_textures = false;
-        for (uint32 idx = 0; idx < material->n_textures; idx++) {
+        bool should_try_to_copy_textures = false;
+        for (u32 idx = 0; idx < material->n_textures; idx++) {
             Texture *texture = &material->textures[idx];
             if (!texture->texture_name) {
                 should_try_to_copy_textures = true;
···
 }
 
 
-bool32
+bool
 mats::is_texture_type_screensize_dependent(TextureType type)
 {
     return (
···
 }
 
 
-uint16
+u16
 mats::get_new_persistent_pbo_idx()
 {
     auto *ppbo = &mats::state->persistent_pbo;
-    uint16 current_idx = ppbo->next_idx;
+    u16 current_idx = ppbo->next_idx;
     ppbo->next_idx++;
     if (ppbo->next_idx >= ppbo->texture_count) {
         ppbo->next_idx = 0;
···
 
 
 void *
-mats::get_memory_for_persistent_pbo_idx(uint16 idx)
+mats::get_memory_for_persistent_pbo_idx(u16 idx)
 {
     auto *ppbo = &mats::state->persistent_pbo;
-    return (char*)ppbo->memory + ((uint64)idx * ppbo->texture_size);
+    return (char*)ppbo->memory + ((u64)idx * ppbo->texture_size);
 }
 
 
 void
 mats::copy_textures_to_pbo(Material *material)
 {
-    for (uint32 idx = 0; idx < material->n_textures; idx++) {
+    for (u32 idx = 0; idx < material->n_textures; idx++) {
         Texture *texture = &material->textures[idx];
         if (texture->texture_name) {
             continue;
···
 }
 
 
-uint32
-mats::get_new_texture_name(uint32 target_size)
+u32
+mats::get_new_texture_name(u32 target_size)
 {
     auto *pool = &mats::state->texture_name_pool;
-    for (uint32 idx_size = 0; idx_size < pool->n_sizes; idx_size++) {
+    for (u32 idx_size = 0; idx_size < pool->n_sizes; idx_size++) {
         if (pool->sizes[idx_size] == target_size) {
             assert(pool->idx_next[idx_size] < pool->n_textures);
-            uint32 idx_name = (idx_size * pool->n_textures) + pool->idx_next[idx_size];
-            uint32 texture_name = pool->texture_names[idx_name];
+            u32 idx_name = (idx_size * pool->n_textures) + pool->idx_next[idx_size];
+            u32 texture_name = pool->texture_names[idx_name];
             pool->idx_next[idx_size]++;
             return texture_name;
         }
···
 
 
 void *
-mats::get_offset_for_persistent_pbo_idx(uint16 idx)
+mats::get_offset_for_persistent_pbo_idx(u16 idx)
 {
-    return (void*)((uint64)idx * mats::state->persistent_pbo.texture_size);
+    return (void*)((u64)idx * mats::state->persistent_pbo.texture_size);
 }
 
 
···
     }
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, mats::state->persistent_pbo.pbo);
 
-    for (uint32 idx = 0; idx < material->n_textures; idx++) {
+    for (u32 idx = 0; idx < material->n_textures; idx++) {
         Texture *texture = &material->textures[idx];
         if (texture->texture_name != 0) {
             continue;
···
 
 mats::PersistentPbo *
 mats::init_persistent_pbo(
-    uint16 texture_count, int32 width, int32 height, int32 n_components
+    u16 texture_count, i32 width, i32 height, i32 n_components
 ) {
     auto *ppbo = &mats::state->persistent_pbo;
     ppbo->texture_count = texture_count;
···
 mats::TextureNamePool *
 mats::init_texture_name_pool(
     memory::Pool *memory_pool,
-    uint32 n_textures,
-    uint32 mipmap_max_level
+    u32 n_textures,
+    u32 mipmap_max_level
 ) {
     auto *pool = &mats::state->texture_name_pool;
     pool->n_textures = n_textures;
···
     pool->sizes[pool->n_sizes++] = 512;
     pool->sizes[pool->n_sizes++] = 2048;
 
-    pool->texture_names = (uint32*)memory::push(memory_pool,
-        sizeof(uint32) * pool->n_textures * pool->n_sizes, "texture_names");
+    pool->texture_names = (u32*)memory::push(memory_pool,
+        sizeof(u32) * pool->n_textures * pool->n_sizes, "texture_names");
 
     glGenTextures(pool->n_textures * pool->n_sizes, pool->texture_names);
 
     range_named (idx_size, 0, pool->n_sizes) {
         range_named (idx_texture, 0, pool->n_textures) {
-            uint32 idx_name = (idx_size * pool->n_textures) + idx_texture;
+            u32 idx_name = (idx_size * pool->n_textures) + idx_texture;
             glBindTexture(GL_TEXTURE_2D, pool->texture_names[idx_name]);
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

src/mats.hpp

···
 class mats {
 public:
     struct TextureNamePool {
-        uint32 mipmap_max_level;
-        uint32 n_textures;
-        uint32 n_sizes;
-        uint32 sizes[MAX_N_TEXTURE_POOL_SIZES];
-        uint32 idx_next[MAX_N_TEXTURE_POOL_SIZES];
-        uint32 *texture_names;
+        u32 mipmap_max_level;
+        u32 n_textures;
+        u32 n_sizes;
+        u32 sizes[MAX_N_TEXTURE_POOL_SIZES];
+        u32 idx_next[MAX_N_TEXTURE_POOL_SIZES];
+        u32 *texture_names;
     };
 
     struct PersistentPbo {
-        uint32 pbo;
+        u32 pbo;
         void *memory;
-        int32 width;
-        int32 height;
-        int32 n_components;
-        uint16 texture_count;
-        uint32 texture_size;
-        uint32 total_size;
-        uint16 next_idx;
+        i32 width;
+        i32 height;
+        i32 n_components;
+        u16 texture_count;
+        u32 texture_size;
+        u32 total_size;
+        u16 next_idx;
     };
 
     struct TextureAtlas {
         iv2 size;
         iv2 next_position;
         iv2 max_allocated_position_per_axis;
-        uint32 texture_name;
+        u32 texture_name;
     };
 
     enum class TextureType {
···
         GLenum target;
         TextureType type;
         char path[MAX_PATH];
-        uint32 texture_name;
-        int32 width;
-        int32 height;
-        int32 n_components;
-        uint16 pbo_idx_for_copy;
-        bool32 is_screensize_dependent;
+        u32 texture_name;
+        i32 width;
+        i32 height;
+        i32 n_components;
+        u16 pbo_idx_for_copy;
+        bool is_screensize_dependent;
         // NOTE: We assume a builtin texture can belong to multiple materials,
         // but a non-builtin texture can belong to only one material.
         // If we delete a material, we delete all its non-builtin textures.
-        bool32 is_builtin;
+        bool is_builtin;
     };
 
     enum class MaterialState {
···
     struct Material {
         char name[MAX_COMMON_NAME_LENGTH];
         MaterialState state;
-        bool32 have_textures_been_generated;
-        bool32 is_screensize_dependent;
+        bool have_textures_been_generated;
+        bool is_screensize_dependent;
         shaders::Asset shader_asset;
         shaders::Asset depth_shader_asset;
-        uint32 n_textures;
+        u32 n_textures;
         Texture textures[MAX_N_TEXTURES_PER_MATERIAL];
         char texture_uniform_names[MAX_N_UNIFORMS][MAX_UNIFORM_LENGTH];
-        uint32 idx_texture_uniform_names;
+        u32 idx_texture_uniform_names;
 
         v4 albedo_static;
-        real32 metallic_static;
-        real32 roughness_static;
-        real32 ao_static;
-        bool32 should_use_normal_map;
+        f32 metallic_static;
+        f32 roughness_static;
+        f32 ao_static;
+        bool should_use_normal_map;
     };
 
     struct State {
         PersistentPbo persistent_pbo;
         TextureNamePool texture_name_pool;
         Array<Material> materials;
-        uint32 first_non_internal_material_idx;
+        u32 first_non_internal_material_idx;
     };
 
     static Array<Material> * get_materials();
···
         Texture *texture,
         GLenum target,
         TextureType type,
-        uint32 texture_name,
-        int32 width,
-        int32 height,
-        int32 n_components
+        u32 texture_name,
+        i32 width,
+        i32 height,
+        i32 n_components
     );
     static void destroy_texture(Texture *texture);
     static TextureAtlas * init_texture_atlas(
···
         mats::State *materials_state,
         memory::Pool *memory_pool
     );
-    static bool32 prepare_material_and_check_if_done(Material *material);
+    static bool prepare_material_and_check_if_done(Material *material);
     static void reload_shaders();
 
 private:
-    static bool32 is_texture_type_screensize_dependent(TextureType type);
-    static uint16 get_new_persistent_pbo_idx();
-    static void * get_memory_for_persistent_pbo_idx(uint16 idx);
+    static bool is_texture_type_screensize_dependent(TextureType type);
+    static u16 get_new_persistent_pbo_idx();
+    static void * get_memory_for_persistent_pbo_idx(u16 idx);
     static void copy_textures_to_pbo(Material *material);
-    static uint32 get_new_texture_name(uint32 target_size);
-    static void * get_offset_for_persistent_pbo_idx(uint16 idx);
+    static u32 get_new_texture_name(u32 target_size);
+    static void * get_offset_for_persistent_pbo_idx(u16 idx);
     static void generate_textures_from_pbo(Material *material);
     static char const * material_state_to_string(MaterialState material_state);
     static PersistentPbo * init_persistent_pbo(
-        uint16 texture_count, int32 width, int32 height, int32 n_components
+        u16 texture_count, i32 width, i32 height, i32 n_components
     );
     static TextureNamePool * init_texture_name_pool(
         memory::Pool *memory_pool,
-        uint32 n_textures,
-        uint32 mipmap_max_level
+        u32 n_textures,
+        u32 mipmap_max_level
     );
 
     static mats::State *state;

src/memory.cpp

···
     if (pool->memory == nullptr) {
 #if USE_MEMORY_DEBUG_LOGS
         logs::info("Allocating memory pool: %.2fMB (%dB)",
-            util::b_to_mb((real64)pool->size), pool->size);
+            util::b_to_mb((f64)pool->size), pool->size);
 #endif
 
-        pool->memory = (uint8*)calloc(1, pool->size);
+        pool->memory = (u8*)calloc(1, pool->size);
         if (!pool->memory) {
             logs::fatal("Could not allocate memory. Buy more RAM!");
             assert(false); // A little hint for the compiler
···
 
 #if USE_MEMORY_DEBUG_LOGS
     logs::info("Pusing to memory pool: %.2fMB (%dB) for %s, now at %.2fMB (%dB)",
-        util::b_to_mb((real64)item_size),
+        util::b_to_mb((f64)item_size),
         item_size, item_debug_name,
-        util::b_to_mb((real64)pool->used),
+        util::b_to_mb((f64)pool->used),
         pool->used);
 #endif
 
···
 memory::print_memory_pool(Pool *pool)
 {
     logs::info("memory::Pool:");
-    logs::info("  Used: %.2fMB (%dB)", util::b_to_mb((uint32)pool->used), pool->used);
-    logs::info("  Size: %.2fMB (%dB)", util::b_to_mb((uint32)pool->size), pool->size);
+    logs::info("  Used: %.2fMB (%dB)", util::b_to_mb((u32)pool->used), pool->used);
+    logs::info("  Size: %.2fMB (%dB)", util::b_to_mb((u32)pool->size), pool->size);
     logs::info("  Items:");
     if (pool->n_items == 0) {
         logs::info("    (none)");
     }
     #if USE_MEMORYPOOL_ITEM_DEBUG
-    for (uint32 idx = 0; idx < pool->n_items; idx++) {
+    for (u32 idx = 0; idx < pool->n_items; idx++) {
         logs::info("    %02d. %s, %.2fMB (%dB)",
             idx,
             pool->item_debug_names[idx],
-            util::b_to_mb((real64)pool->item_debug_sizes[idx]),
+            util::b_to_mb((f64)pool->item_debug_sizes[idx]),
             pool->item_debug_sizes[idx]);
     }
     #endif

src/memory.hpp

···
 class memory {
 public:
 #if USE_MEMORYPOOL_ITEM_DEBUG
-    constexpr uint32 MAX_N_MEMORYPOOL_ITEMS = 1024;
+    constexpr u32 MAX_N_MEMORYPOOL_ITEMS = 1024;
 #endif
 
     struct Pool {
-        uint8 *memory;
+        u8 *memory;
         size_t size;
         size_t used;
-        uint32 n_items;
+        u32 n_items;
         #if USE_MEMORYPOOL_ITEM_DEBUG
         const char *item_debug_names[MAX_N_MEMORYPOOL_ITEMS];
         size_t item_debug_sizes[MAX_N_MEMORYPOOL_ITEMS];

src/models.cpp

···
 #include "intrinsics.hpp"
 
 
-bool32
+bool
 models::prepare_model_loader_and_check_if_done(ModelLoader *model_loader) {
     if (model_loader->state == ModelLoaderState::initialized) {
         if (pstr_starts_with(model_loader->model_path, "builtin:")) {
···
     }
 
     if (model_loader->state == ModelLoaderState::mesh_data_loaded) {
-        for (uint32 idx = 0; idx < model_loader->n_meshes; idx++) {
+        for (u32 idx = 0; idx < model_loader->n_meshes; idx++) {
             geom::Mesh *mesh = &model_loader->meshes[idx];
             geom::setup_mesh_vertex_buffers(mesh, mesh->vertices, mesh->n_vertices, mesh->indices, mesh->n_indices);
             memory::destroy_memory_pool(&mesh->temp_memory_pool);
···
         range_named (idx_material, 0, model_loader->n_material_names) {
             range_named (idx_mesh, 0, model_loader->n_meshes) {
                 geom::Mesh *mesh = &model_loader->meshes[idx_mesh];
-                uint8 mesh_number = pack::get(&mesh->indices_pack, 0);
+                u8 mesh_number = pack::get(&mesh->indices_pack, 0);
                 // For our model's mesh number `mesh_number`, we want to choose
                 // material `idx_mesh` such that `mesh_number == idx_mesh`, i.e.
                 // we choose the 4th material for mesh number 4.
···
 }
 
 
-bool32
+bool
 models::prepare_entity_loader_and_check_if_done(
     EntityLoader *entity_loader,
     ModelLoader *model_loader
···
                 .target_render_pass = entity_loader->render_pass,
             };
         } else if (model_loader->n_meshes > 1) {
-            for (uint32 idx = 0; idx < model_loader->n_meshes; idx++) {
+            for (u32 idx = 0; idx < model_loader->n_meshes; idx++) {
                 geom::Mesh *mesh = &model_loader->meshes[idx];
 
                 entities::Entity *child_entity = entities::add_entity_to_set(entity_loader->name);
···
 }
 
 
-bool32
+bool
 models::is_model_loader_valid(ModelLoader *model_loader)
 {
     return model_loader->state != ModelLoaderState::empty;
 }
 
 
-bool32
+bool
 models::is_entity_loader_valid(EntityLoader *entity_loader)
 {
     return entity_loader->state != EntityLoaderState::empty;
···
 }
 
 
-bool32
+bool
 models::is_bone_only_node(aiNode *node)
 {
     if (node->mNumMeshes > 0) {
         return false;
     }
-    bool32 have_we_found_it = true;
+    bool have_we_found_it = true;
     range (0, node->mNumChildren) {
         if (!is_bone_only_node(node->mChildren[idx])) {
             have_we_found_it = false;
···
 models::add_bone_tree_to_animation_component(
     anim::Component *animation_component,
     aiNode *node,
-    uint32 idx_parent
+    u32 idx_parent
 ) {
-    uint32 idx_new_bone = animation_component->n_bones;
+    u32 idx_new_bone = animation_component->n_bones;
     animation_component->bones[idx_new_bone] = {
         .idx_parent = idx_parent,
         // NOTE: offset is added later, since we don't have the aiBone at this stage.
···
         range_named(idx_bone, 0, animation_component->n_bones) {
             anim::Bone *bone = &animation_component->bones[idx_bone];
 
-            uint32 found_channel_idx = 0;
-            bool32 did_find_channel = false;
+            u32 found_channel_idx = 0;
+            bool did_find_channel = false;
 
             range_named (idx_channel, 0, ai_animation->mNumChannels) {
                 aiNodeAnim *ai_channel = ai_animation->mChannels[idx_channel];
···
     mesh->vertices = (geom::Vertex*)memory::push(&mesh->temp_memory_pool,
         mesh->n_vertices * sizeof(geom::Vertex), "mesh_vertices");
 
-    for (uint32 idx = 0; idx < ai_mesh->mNumVertices; idx++) {
+    for (u32 idx = 0; idx < ai_mesh->mNumVertices; idx++) {
         geom::Vertex *vertex = &mesh->vertices[idx];
         *vertex = {};
 
···
     }
 
     // Indices
-    uint32 n_indices = 0;
-    for (uint32 idx_face = 0; idx_face < ai_mesh->mNumFaces; idx_face++) {
+    u32 n_indices = 0;
+    for (u32 idx_face = 0; idx_face < ai_mesh->mNumFaces; idx_face++) {
         aiFace face = ai_mesh->mFaces[idx_face];
         n_indices += face.mNumIndices;
     }
 
     mesh->n_indices = n_indices;
-    mesh->indices = (uint32*)memory::push(&mesh->temp_memory_pool,
-        mesh->n_indices * sizeof(uint32), "mesh_indices");
-    uint32 idx_index = 0;
+    mesh->indices = (u32*)memory::push(&mesh->temp_memory_pool,
+        mesh->n_indices * sizeof(u32), "mesh_indices");
+    u32 idx_index = 0;
 
-    for (uint32 idx_face = 0; idx_face < ai_mesh->mNumFaces; idx_face++) {
+    for (u32 idx_face = 0; idx_face < ai_mesh->mNumFaces; idx_face++) {
         aiFace face = ai_mesh->mFaces[idx_face];
         for (
-            uint32 idx_face_index = 0;
+            u32 idx_face_index = 0;
             idx_face_index < face.mNumIndices;
             idx_face_index++
         ) {
···
     anim::Component *animation_component = &model_loader->animation_component;
     range_named (idx_bone, 0, ai_mesh->mNumBones) {
         aiBone *ai_bone = ai_mesh->mBones[idx_bone];
-        uint32 idx_found_bone = 0;
-        bool32 did_find_bone = false;
+        u32 idx_found_bone = 0;
+        bool did_find_bone = false;
 
         range_named (idx_animcomp_bone, 0, animation_component->n_bones) {
             if (pstr_eq(
···
             util::aimatrix4x4_to_glm(&ai_bone->mOffsetMatrix);
 
         range_named (idx_weight, 0, ai_bone->mNumWeights) {
-            uint32 vertex_idx = ai_bone->mWeights[idx_weight].mVertexId;
-            real32 weight = ai_bone->mWeights[idx_weight].mWeight;
+            u32 vertex_idx = ai_bone->mWeights[idx_weight].mVertexId;
+            f32 weight = ai_bone->mWeights[idx_weight].mWeight;
             assert(vertex_idx < mesh->n_vertices);
             range_named (idx_vertex_weight, 0, MAX_N_BONES_PER_VERTEX) {
                 // Put it in the next free space, if there is any.
···
         pack::Pack new_indices_pack = indices_pack;
         // NOTE: We can only store 4 bits per pack element. Our indices can be way
         // bigger than that, but that's fine. We don't need that much precision.
-        // Just smash the number down to a uint8.
-        pack::push(&new_indices_pack, (uint8)idx);
+        // Just smash the number down to a u8.
+        pack::push(&new_indices_pack, (u8)idx);
         load_node(model_loader, node->mChildren[idx], scene, transform, new_indices_pack);
     }
 }
···
     memory::Pool temp_memory_pool = {};
 
     geom::Vertex *vertex_data = nullptr;
-    uint32 n_vertices = 0;
-    uint32 *index_data = nullptr;
-    uint32 n_indices = 0;
+    u32 n_vertices = 0;
+    u32 *index_data = nullptr;
+    u32 n_indices = 0;
     GLenum mode = 0;
 
     if (pstr_eq(model_loader->model_path, "builtin:axes")) {

src/models.hpp

···
 class models {
 public:
     // NOTE: Should be at least peony_parser::MAX_N_ARRAY_VALUES
-    static constexpr uint32 const MAX_N_COMMON_ARRAY_VALUES = 8;
+    static constexpr u32 const MAX_N_COMMON_ARRAY_VALUES = 8;
 
     enum class ModelLoaderState {
         empty,
···
         // These from from the file
         char model_path[MAX_PATH];
         char material_names[MAX_COMMON_NAME_LENGTH][MAX_N_COMMON_ARRAY_VALUES];
-        uint32 n_material_names;
+        u32 n_material_names;
 
         // These are created later
         geom::Mesh meshes[MAX_N_MESHES];
-        uint32 n_meshes;
+        u32 n_meshes;
         anim::Component animation_component;
         ModelLoaderState state;
     };
···
 
 #include "models_data.hpp"
 
-    static bool32 prepare_model_loader_and_check_if_done(ModelLoader *model_loader);
-    static bool32 prepare_entity_loader_and_check_if_done(
+    static bool prepare_model_loader_and_check_if_done(ModelLoader *model_loader);
+    static bool prepare_entity_loader_and_check_if_done(
         EntityLoader *entity_loader,
         ModelLoader *model_loader
     );
-    static bool32 is_model_loader_valid(ModelLoader *model_loader);
-    static bool32 is_entity_loader_valid(EntityLoader *entity_loader);
+    static bool is_model_loader_valid(ModelLoader *model_loader);
+    static bool is_entity_loader_valid(EntityLoader *entity_loader);
     static void add_material_to_model_loader(
         ModelLoader *model_loader,
         char const *material_name
···
     );
 
 private:
-    static bool32 is_bone_only_node(aiNode *node);
+    static bool is_bone_only_node(aiNode *node);
     static aiNode * find_root_bone(const aiScene *scene);
     static void add_bone_tree_to_animation_component(
         anim::Component *animation_component,
         aiNode *node,
-        uint32 idx_parent
+        u32 idx_parent
     );
     static void load_bones(
         anim::Component *animation_component,

src/pack.cpp

···
 
 
 void
-pack::set(Pack *pack, uint8 value, uint8 idx)
+pack::set(Pack *pack, u8 value, u8 idx)
 {
     assert(idx < MAX_LENGTH);
     Pack mask = 0b1111ULL << (idx * ELEMENT_SIZE);
···
 }
 
 
-uint8
-pack::get(Pack *pack, uint8 idx)
+u8
+pack::get(Pack *pack, u8 idx)
 {
     Pack mask = 0b1111ULL << (idx * ELEMENT_SIZE);
-    return (uint8)((*pack & mask) >> (idx * ELEMENT_SIZE));
+    return (u8)((*pack & mask) >> (idx * ELEMENT_SIZE));
 }
 
 
-uint8
+u8
 pack::get_count(Pack *pack)
 {
     return get(pack, COUNTER_IDX);
···
 
 
 void
-pack::push(Pack *pack, uint8 value)
+pack::push(Pack *pack, u8 value)
 {
-    uint8 count = get_count(pack);
+    u8 count = get_count(pack);
     // Last element is reserved for count;
     assert(count < COUNTER_IDX);
     set(pack, value, count);

src/pack.hpp

···
 
 class pack {
 public:
-    static constexpr uint16 ELEMENT_SIZE = 4;
-    static constexpr uint16 MAX_LENGTH  = (64 / ELEMENT_SIZE);
-    static constexpr uint16 COUNTER_IDX  = (MAX_LENGTH - 1);
+    static constexpr u16 ELEMENT_SIZE = 4;
+    static constexpr u16 MAX_LENGTH  = (64 / ELEMENT_SIZE);
+    static constexpr u16 COUNTER_IDX  = (MAX_LENGTH - 1);
 
-    typedef uint64 Pack;
+    typedef u64 Pack;
 
     static void init(Pack *pack);
-    static void set(Pack *pack, uint8 value, uint8 idx);
-    static uint8 get(Pack *pack, uint8 idx);
-    static uint8 get_count(Pack *pack);
-    static void push(Pack *pack, uint8 value);
+    static void set(Pack *pack, u8 value, u8 idx);
+    static u8 get(Pack *pack, u8 idx);
+    static u8 get_count(Pack *pack);
+    static void push(Pack *pack, u8 value);
 };

src/peony_parser.cpp

···
 #include "intrinsics.hpp"
 
 
-bool32
+bool
 peony_parser::parse_file(PeonyFile *pf, char const *path)
 {
-    int32 idx_entry = -1;
+    i32 idx_entry = -1;
     Entry *entry = nullptr;
 
     FILE *f = fopen(path, "r");
···
 }
 
 
-bool32
+bool
 peony_parser::is_char_whitespace(const char target)
 {
     return target == TOKEN_NEWLINE || target == TOKEN_SPACE;
 }
 
 
-bool32
+bool
 peony_parser::is_token_whitespace(const char *token)
 {
     return is_char_whitespace(token[0]);
 }
 
 
-bool32
+bool
 peony_parser::is_char_allowed_in_name(const char target)
 {
     return isalpha(target) || isdigit(target) || target == '_' || target == '-' ||
···
 }
 
 
-bool32
+bool
 peony_parser::is_token_name(const char *token)
 {
     range (0, pstr_len(token)) {
···
 }
 
 
-bool32
+bool
 peony_parser::is_char_token_boundary(char target)
 {
     return is_char_whitespace(target) ||
···
 }
 
 
-bool32
+bool
 peony_parser::get_token(char *token, FILE *f)
 {
-    uint32 idx_token = 0;
-    bool32 could_get_token = true;
+    u32 idx_token = 0;
+    bool could_get_token = true;
 
     while (true) {
         char new_char = (char)fgetc(f);
···
 }
 
 
-bool32
+bool
 peony_parser::get_non_trivial_token(char *token, FILE *f)
 {
-    bool32 could_get_token;
+    bool could_get_token;
     do {
         could_get_token = get_token(token, f);
         if (token[0] == TOKEN_COMMENT_START) {
···
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_START);
     get_non_trivial_token(token, f);
-    (*parsed_vector).x = (real32)strtod(token, nullptr);
+    (*parsed_vector).x = (f32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
-    (*parsed_vector).y = (real32)strtod(token, nullptr);
+    (*parsed_vector).y = (f32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_END);
 }
···
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_START);
     get_non_trivial_token(token, f);
-    (*parsed_vector).x = (real32)strtod(token, nullptr);
+    (*parsed_vector).x = (f32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
-    (*parsed_vector).y = (real32)strtod(token, nullptr);
+    (*parsed_vector).y = (f32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
-    (*parsed_vector).z = (real32)strtod(token, nullptr);
+    (*parsed_vector).z = (f32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_END);
 }
···
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_START);
     get_non_trivial_token(token, f);
-    (*parsed_vector).x = (real32)strtod(token, nullptr);
+    (*parsed_vector).x = (f32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
-    (*parsed_vector).y = (real32)strtod(token, nullptr);
+    (*parsed_vector).y = (f32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
-    (*parsed_vector).z = (real32)strtod(token, nullptr);
+    (*parsed_vector).z = (f32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
-    (*parsed_vector).w = (real32)strtod(token, nullptr);
+    (*parsed_vector).w = (f32)strtod(token, nullptr);
     get_non_trivial_token(token, f);
     assert(token[0] == TOKEN_TUPLE_END);
 }
···
         // 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);
+        prop_value->number_value = (f32)strtod(token, nullptr);
     } else {
         prop_value->type = PropValueType::string;
         pstr_copy(prop_value->string_value, MAX_TOKEN_LENGTH, token);

src/peony_parser.hpp

···
 
 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;
+    static constexpr u32 MAX_N_FILE_ENTRIES = 128;
+    static constexpr u32 MAX_N_ENTRY_PROPS = 32;
+    static constexpr u32 MAX_N_ARRAY_VALUES = 8;
+    static constexpr u32 MAX_TOKEN_LENGTH = 128;
 
     static constexpr const char TOKEN_SPACE = ' ';
     static constexpr const char TOKEN_NEWLINE = '\n';
···
         PropValueType type;
         union {
             char string_value[MAX_TOKEN_LENGTH];
-            bool32 boolean_value;
-            real32 number_value;
+            bool boolean_value;
+            f32 number_value;
             v2 vec2_value;
             v3 vec3_value;
             v4 vec4_value;
···
     struct Prop {
         char name[MAX_TOKEN_LENGTH];
         PropValue values[MAX_N_ARRAY_VALUES];
-        uint32 n_values;
+        u32 n_values;
     };
 
     struct Entry {
         char name[MAX_TOKEN_LENGTH];
         Prop props[MAX_N_ENTRY_PROPS];
-        uint32 n_props;
+        u32 n_props;
     };
 
     struct PeonyFile {
         Entry entries[MAX_N_FILE_ENTRIES];
-        uint32 n_entries;
+        u32 n_entries;
     };
 
-    static bool32 parse_file(PeonyFile *pf, char const *path);
+    static bool parse_file(PeonyFile *pf, char const *path);
 
 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 bool is_char_whitespace(const char target);
+    static bool is_token_whitespace(const char *token);
+    static bool is_char_allowed_in_name(const char target);
+    static bool is_token_name(const char *token);
+    static bool is_char_token_boundary(char target);
+    static bool get_token(char *token, FILE *f);
+    static bool 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);

src/peony_parser_utils.cpp

···
 }
 
 
-bool32 *
+bool *
 peony_parser_utils::get_boolean(peony_parser::Prop *prop)
 {
     if (!prop) { return nullptr; }
···
 }
 
 
-real32 *
+f32 *
 peony_parser_utils::get_number(peony_parser::Prop *prop)
 {
     if (!prop) { return nullptr; }
···
         }
         range_named (idx_value, 0, prop->n_values) {
             peony_parser::PropValue *value = &prop->values[idx_value];
-            bool32 does_material_already_exist = false;
+            bool does_material_already_exist = false;
             each (unique_value, *unique_values) {
                 if (pstr_eq(value->string_value, *unique_value)) {
                     does_material_already_exist = true;
···
     if (render_passes_prop) {
         range (0, render_passes_prop->n_values) {
             render_pass = (drawable::Pass)(
-                (uint32)render_pass |
-                (uint32)drawable::render_pass_from_string(
+                (u32)render_pass |
+                (u32)drawable::render_pass_from_string(
                     render_passes_prop->values[idx].string_value));
         }
     } else {

src/peony_parser_utils.hpp

···
     static constexpr size_t BUILTIN_TEXTURE_PREFIX_LENGTH = 17;
 
     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 bool * get_boolean(peony_parser::Prop *prop);
+    static f32 * 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);

src/physics.cpp

···
     // Calculate slab intersection points for ray
     // `t is the distance along the ray (or “time” along the ray, as Szauer
     // calls it) that the intersection happens at.
-    real32 t[6] = {};
+    f32 t[6] = {};
     range_named (i, 0, 3) {
         if (f[i] == 0) {
             if (-e[i] - obb->extents[i] > 0 || -e[i] + obb->extents[i] < 0) {
···
 
     // After the above loop, we've hit all three slabs. We now need to find the
     // largest minimum `t^{min}` and smallest maximum `t^{max}`.
-    real32 tmin = max(
+    f32 tmin = max(
         max(min(t[0], t[1]), min(t[2], t[3])),
         min(t[4], t[5]));
-    real32 tmax = min(
+    f32 tmax = min(
         min(max(t[0], t[1]), max(t[2], t[3])),
         max(t[4], t[5]));
 
···
 physics::get_edge_contact_point(
     v3 a_edge_point,
     v3 a_axis,
-    real32 a_axis_length,
+    f32 a_axis_length,
     v3 b_edge_point,
     v3 b_axis,
-    real32 b_axis_length,
-    bool32 should_use_a_midpoint
+    f32 b_axis_length,
+    bool should_use_a_midpoint
 ) {
-    real32 a_axis_sqlen = length2(a_axis);
-    real32 b_axis_sqlen = length2(b_axis);
-    real32 a_b_axes_dotprod = dot(b_axis, a_axis);
+    f32 a_axis_sqlen = length2(a_axis);
+    f32 b_axis_sqlen = length2(b_axis);
+    f32 a_b_axes_dotprod = dot(b_axis, a_axis);
 
     v3 a_ep_to_b_ep = a_edge_point - b_edge_point;
-    real32 a_ep_projection = dot(a_axis, a_ep_to_b_ep);
-    real32 b_ep_projection = dot(b_axis, a_ep_to_b_ep);
+    f32 a_ep_projection = dot(a_axis, a_ep_to_b_ep);
+    f32 b_ep_projection = dot(b_axis, a_ep_to_b_ep);
 
-    real32 denom = a_axis_sqlen * b_axis_sqlen - a_b_axes_dotprod * a_b_axes_dotprod;
+    f32 denom = a_axis_sqlen * b_axis_sqlen - a_b_axes_dotprod * a_b_axes_dotprod;
 
     // Zero denominator indicates parallel lines
     if (abs(denom) < 0.0001f) {
         return should_use_a_midpoint ? a_edge_point : b_edge_point;
     }
 
-    real32 mua = (a_b_axes_dotprod * b_ep_projection - b_axis_sqlen * a_ep_projection) / denom;
-    real32 mub = (a_axis_sqlen * b_ep_projection - a_b_axes_dotprod * a_ep_projection) / denom;
+    f32 mua = (a_b_axes_dotprod * b_ep_projection - b_axis_sqlen * a_ep_projection) / denom;
+    f32 mub = (a_axis_sqlen * b_ep_projection - a_b_axes_dotprod * a_ep_projection) / denom;
 
     // If either of the edges has the nearest point out of bounds, then the edges
     // aren't crossed, we have an edge-face contact. Our point is on the edge,
···
     v3 e, // object extents
     v3 c, // object center
     v3 n, // collision normal
-    uint32 axis, // axis of separation
-    uint32 clip_edges[4], // the indices of the reference face edges
+    u32 axis, // axis of separation
+    u32 clip_edges[4], // the indices of the reference face edges
     m3 *reference_face_cob, // the change of basis of the reference face
     v3 *reference_face_e // the extents of the reference face
 ) {
···
 }
 
 
-uint32
+u32
 physics::clip_faces(
     v3 reference_center, v3 reference_face_extents,
-    uint32 clip_edges[4], m3 reference_face_cob,
+    u32 clip_edges[4], m3 reference_face_cob,
     spatial::Face incident_face,
-    v3 clip_vertices[8], real32 clip_depths[8]
+    v3 clip_vertices[8], f32 clip_depths[8]
 ) {
     return 0;
 }
···
 
 void
 physics::update_best_for_face_axis(
-    real32 *best_sep, uint32 *best_axis, v3 *best_normal,
-    real32 sep, uint32 axis, v3 normal
+    f32 *best_sep, u32 *best_axis, v3 *best_normal,
+    f32 sep, u32 axis, v3 normal
 ) {
     if (sep > *best_sep) {
         *best_sep = sep;
···
 
 void
 physics::update_best_for_edge_axis(
-    real32 *best_sep, uint32 *best_axis, v3 *best_normal,
-    real32 sep, uint32 axis, v3 normal
+    f32 *best_sep, u32 *best_axis, v3 *best_normal,
+    f32 sep, u32 axis, v3 normal
 ) {
-    real32 normal_len = length(normal);
+    f32 normal_len = length(normal);
     sep /= normal_len;
     if (sep > *best_sep) {
         *best_sep = sep;
···
     spatial::Component *spatial_b
 ) {
     // The radius from a/b's center to its outer vertex
-    real32 a_radius, b_radius;
+    f32 a_radius, b_radius;
     // The distance between a and b
-    real32 a_to_b;
+    f32 a_to_b;
     // The separation between a and b
-    real32 sep;
+    f32 sep;
     // The rotation matrix expression b in a's coordinate frame
     m3 r;
     // abs(r) is used in a lot of calculations so we precompute it
···
     // their cross product will give us something we can't use. I'm not sure why
     // we're not skipping the specific axes specifically, and we're skipping
     // everything instead.
-    bool32 do_obbs_share_one_axis = false;
+    bool do_obbs_share_one_axis = false;
 
     // Compute common subexpressions. Add in an epsilon term to counteract
     // arithmetic errors when two edges are parallel and their cross product
···
         }
     }
 
-    real32 a_face_max_sep = -FLT_MAX;
-    uint32 a_face_best_axis = 0;
+    f32 a_face_max_sep = -FLT_MAX;
+    u32 a_face_best_axis = 0;
     v3 a_face_best_normal = v3(0.0f);
-    real32 b_face_max_sep = -FLT_MAX;
-    uint32 b_face_best_axis = 0;
+    f32 b_face_max_sep = -FLT_MAX;
+    u32 b_face_best_axis = 0;
     v3 b_face_best_normal = v3(0.0f);
-    real32 edge_max_sep = -FLT_MAX;
-    uint32 edge_best_axis = 0;
+    f32 edge_max_sep = -FLT_MAX;
+    u32 edge_best_axis = 0;
     v3 edge_best_normal = v3(0.0f);
 
     // Test a's face axes (a.x, a.y, a.z)
···
     }
 
     // Find the best option for the face cases
-    real32 face_max_sep;
-    uint32 face_best_axis;
+    f32 face_max_sep;
+    u32 face_best_axis;
     if (a_face_max_sep > b_face_max_sep) {
         face_max_sep = a_face_max_sep;
         face_best_axis = a_face_best_axis;
···
 
         spatial::Face incident_face = get_incident_face(&incident_cob, incident_extents, incident_center, manifold.normal);
 
-        uint32 clip_edges[4];
+        u32 clip_edges[4];
         m3 reference_face_cob;
         v3 reference_face_extents;
         get_reference_face_edges_and_basis(
             &reference_cob, reference_extents, reference_center, manifold.normal,
             manifold.axis, clip_edges, &reference_face_cob, &reference_face_extents);
 
-        uint32 n_clip_vertices;
+        u32 n_clip_vertices;
         v3 clip_vertices[8];
-        real32 clip_depths[8];
+        f32 clip_depths[8];
         n_clip_vertices = clip_faces(
             reference_center, reference_face_extents,
             clip_edges, reference_face_cob,
···
             v4(0.0f, 1.0f, 0.0f, 1.0f));
     } else {
         // Edge-edge collision
-        uint32 edge_axis = manifold.axis - 6;
-        uint32 a_axis = edge_axis / 3;
-        uint32 b_axis = edge_axis % 3;
+        u32 edge_axis = manifold.axis - 6;
+        u32 a_axis = edge_axis / 3;
+        u32 b_axis = edge_axis % 3;
 
         v3 a_edge_point = a->extents;
         v3 b_edge_point = b->extents;

src/physics.hpp

···
 
 class physics {
 public:
-    static constexpr real32 PARALLEL_FACE_TOLERANCE = 1.0e-2;
-    static constexpr real32 RELATIVE_TOLERANCE = 1.00f;
-    static constexpr real32 ABSOLUTE_TOLERANCE = 0.10f;
+    static constexpr f32 PARALLEL_FACE_TOLERANCE = 1.0e-2;
+    static constexpr f32 RELATIVE_TOLERANCE = 1.00f;
+    static constexpr f32 ABSOLUTE_TOLERANCE = 0.10f;
 
     struct Component {
         entities::Handle entity_handle;
···
     };
 
     struct CollisionManifold {
-        bool32 did_collide;
+        bool did_collide;
         Component *collidee;
-        real32 sep_max;
-        uint32 axis;
+        f32 sep_max;
+        u32 axis;
         v3 normal;
     };
 
     struct RaycastResult {
-        bool32 did_intersect;
-        real32 distance;
+        bool did_intersect;
+        f32 distance;
     };
 
     struct RayCollisionResult {
-        bool32 did_intersect;
-        real32 distance;
+        bool did_intersect;
+        f32 distance;
         Component *collidee;
     };
 
···
     static v3 get_edge_contact_point(
         v3 a_edge_point,
         v3 a_axis,
-        real32 a_axis_length,
+        f32 a_axis_length,
         v3 b_edge_point,
         v3 b_axis,
-        real32 b_axis_length,
-        bool32 should_use_a_midpoint
+        f32 b_axis_length,
+        bool should_use_a_midpoint
     );
     static spatial::Face get_incident_face(m3 *cob, v3 e, v3 c, v3 n);
     static void get_reference_face_edges_and_basis(
···
         v3 e,
         v3 c,
         v3 n,
-        uint32 axis,
-        uint32 clip_edges[4],
+        u32 axis,
+        u32 clip_edges[4],
         m3 *reference_face_cob,
         v3 *reference_face_e
     );
-    static uint32 clip_faces(
+    static u32 clip_faces(
         v3 reference_center, v3 reference_face_extents,
-        uint32 clip_edges[4], m3 reference_face_cob,
+        u32 clip_edges[4], m3 reference_face_cob,
         spatial::Face incident_face,
-        v3 clip_vertices[8], real32 clip_depths[8]
+        v3 clip_vertices[8], f32 clip_depths[8]
     );
     static void update_best_for_face_axis(
-        real32 *best_sep, uint32 *best_axis, v3 *best_normal,
-        real32 sep, uint32 axis, v3 normal
+        f32 *best_sep, u32 *best_axis, v3 *best_normal,
+        f32 sep, u32 axis, v3 normal
     );
     static void update_best_for_edge_axis(
-        real32 *best_sep, uint32 *best_axis, v3 *best_normal,
-        real32 sep, uint32 axis, v3 normal
+        f32 *best_sep, u32 *best_axis, v3 *best_normal,
+        f32 sep, u32 axis, v3 normal
     );
     static CollisionManifold intersect_obb_obb(
         spatial::Obb *a,

src/queue.hpp

···
 template <typename T>
 class Queue {
 public:
-    uint32 size = 0;
-    uint32 max_size = 0;
+    u32 size = 0;
+    u32 max_size = 0;
     T *items = nullptr;
-    uint32 head = 0;
-    uint32 tail = 0;
+    u32 head = 0;
+    u32 tail = 0;
 
     T* push() {
         assert(this->size < this->max_size);
···
         return item;
     }
 
-    Queue(memory::Pool *memory_pool, uint32 new_max_size, const char *debug_name) {
+    Queue(memory::Pool *memory_pool, u32 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) {
+    Queue(memory::Pool *memory_pool, u32 new_size, u32 new_max_size, T *new_items) {
         this->size = new_size;
         this->head = 0;
         this->tail = new_size;

src/renderer.cpp

···
     // not pixels!
 
 #if USE_FULLSCREEN
-    int32 n_monitors;
+    i32 n_monitors;
     GLFWmonitor **monitors = glfwGetMonitors(&n_monitors);
     GLFWmonitor *target_monitor = monitors[TARGET_MONITOR];
     const GLFWvidmode *video_mode = glfwGetVideoMode(target_monitor);
···
 renderer::resize_renderer_buffers(
     memory::Pool *memory_pool,
     BuiltinTextures *builtin_textures,
-    uint32 width,
-    uint32 height
+    u32 width,
+    u32 height
 ) {
     // TODO: Only regenerate once we're done resizing, not for every little bit
     // of the resize.
···
 
     each (material, *mats::get_materials()) {
         if (material->n_textures > 0 && material->is_screensize_dependent) {
-            for (uint32 idx_texture = 0; idx_texture < material->n_textures; idx_texture++) {
+            for (u32 idx_texture = 0; idx_texture < material->n_textures; idx_texture++) {
                 mats::Texture *texture = &material->textures[idx_texture];
                 if (texture->type == mats::TextureType::g_position) {
                     material->textures[idx_texture] = *builtin_textures->g_position_texture;
···
     {
         // Point lights
         {
-            real32 ratio = (real32)renderer::state->builtin_textures.shadowmap_3d_width /
-                (real32)renderer::state->builtin_textures.shadowmap_3d_height;
+            f32 ratio = (f32)renderer::state->builtin_textures.shadowmap_3d_width /
+                (f32)renderer::state->builtin_textures.shadowmap_3d_height;
             m4 perspective_projection = glm::perspective(
                 radians(90.0f), ratio,
                 renderer::state->builtin_textures.shadowmap_near_clip_dist,
                 renderer::state->builtin_textures.shadowmap_far_clip_dist);
 
-            uint32 idx_light = 0;
+            u32 idx_light = 0;
 
             each (light_component, *engine::get_light_components()) {
                 if (light_component->entity_handle == entities::NO_ENTITY_HANDLE) {
···
 
                 v3 position = spatial_component->position;
 
-                for (uint32 idx_face = 0; idx_face < 6; idx_face++) {
+                for (u32 idx_face = 0; idx_face < 6; idx_face++) {
                     renderer::state->shadowmap_3d_transforms[(idx_light * 6) + idx_face] =
                         perspective_projection * glm::lookAt(
                             position,
···
 
         // Directional lights
         {
-            real32 ortho_ratio = (
-                (real32)renderer::state->builtin_textures.shadowmap_2d_width /
-                (real32)renderer::state->builtin_textures.shadowmap_2d_height);
-            real32 ortho_width = 100.0f;
-            real32 ortho_height = ortho_width / ortho_ratio;
+            f32 ortho_ratio = (
+                (f32)renderer::state->builtin_textures.shadowmap_2d_width /
+                (f32)renderer::state->builtin_textures.shadowmap_2d_height);
+            f32 ortho_width = 100.0f;
+            f32 ortho_height = ortho_width / ortho_ratio;
             m4 ortho_projection = glm::ortho(
                 -ortho_width, ortho_width, -ortho_height, ortho_height,
                 renderer::state->builtin_textures.shadowmap_near_clip_dist,
                 renderer::state->builtin_textures.shadowmap_far_clip_dist);
 
-            uint32 idx_light = 0;
+            u32 idx_light = 0;
 
             each (light_component, *engine::get_light_components()) {
                 if (light_component->entity_handle == entities::NO_ENTITY_HANDLE) {
···
         copy_scene_data_to_ubo(window_size, 0, 0, false);
         render_scene(drawable::Pass::blur2, drawable::Mode::regular);
 
-        for (uint32 idx = 0; idx < 3; idx++) {
+        for (u32 idx = 0; idx < 3; idx++) {
             glBindFramebuffer(GL_FRAMEBUFFER, renderer::state->builtin_textures.blur1_buffer);
             copy_scene_data_to_ubo(window_size, 0, 0, true);
             render_scene(drawable::Pass::blur1, drawable::Mode::regular);
···
 renderer::init(
     renderer::State *renderer_state,
     memory::Pool *memory_pool,
-    uint32 width,
-    uint32 height,
+    u32 width,
+    u32 height,
     GLFWwindow *window
 ) {
     renderer::state = renderer_state;
···
         .shadowmap_2d_width = 800,
         .shadowmap_2d_height = 600,
 #elif defined(GRAPHICS_HIGH)
-        .shadowmap_3d_width = min((uint32)width, (uint32)2000),
-        .shadowmap_3d_height = min((uint32)width, (uint32)2000),
+        .shadowmap_3d_width = min((u32)width, (u32)2000),
+        .shadowmap_3d_height = min((u32)width, (u32)2000),
         .shadowmap_2d_width = 2560 * 2,
         .shadowmap_2d_height = 1440 * 2,
 #endif
···
 void
 renderer::init_g_buffer(
     memory::Pool *memory_pool,
-    uint32 *g_buffer,
+    u32 *g_buffer,
     mats::Texture **g_position_texture,
     mats::Texture **g_normal_texture,
     mats::Texture **g_albedo_texture,
     mats::Texture **g_pbr_texture,
-    uint32 width,
-    uint32 height
+    u32 width,
+    u32 height
 ) {
     glGenFramebuffers(1, g_buffer);
     glBindFramebuffer(GL_FRAMEBUFFER, *g_buffer);
 
-    uint32 g_position_texture_name;
-    uint32 g_normal_texture_name;
-    uint32 g_albedo_texture_name;
-    uint32 g_pbr_texture_name;
+    u32 g_position_texture_name;
+    u32 g_normal_texture_name;
+    u32 g_albedo_texture_name;
+    u32 g_pbr_texture_name;
 
     glGenTextures(1, &g_position_texture_name);
     glGenTextures(1, &g_normal_texture_name);
···
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_2D,
         (*g_pbr_texture)->texture_name, 0);
 
-    uint32 attachments[4] = {
+    u32 attachments[4] = {
         GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1,
         GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3
     };
     glDrawBuffers(4, attachments);
 
-    uint32 rbo_depth;
+    u32 rbo_depth;
     glGenRenderbuffers(1, &rbo_depth);
     glBindRenderbuffer(GL_RENDERBUFFER, rbo_depth);
     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
···
 void
 renderer::init_l_buffer(
     memory::Pool *memory_pool,
-    uint32 *l_buffer,
+    u32 *l_buffer,
     mats::Texture **l_color_texture,
     mats::Texture **l_bright_color_texture,
     mats::Texture **l_depth_texture,
-    uint32 width,
-    uint32 height
+    u32 width,
+    u32 height
 ) {
     glGenFramebuffers(1, l_buffer);
     glBindFramebuffer(GL_FRAMEBUFFER, *l_buffer);
 
     // l_color_texture
     {
-        uint32 l_color_texture_name;
+        u32 l_color_texture_name;
         glGenTextures(1, &l_color_texture_name);
 
         *l_color_texture = mats::init_texture(
···
 
     // l_bright_color_texture
     {
-        uint32 l_bright_color_texture_name;
+        u32 l_bright_color_texture_name;
         glGenTextures(1, &l_bright_color_texture_name);
 
         *l_bright_color_texture = mats::init_texture(
···
 
     // Attach textures
     {
-        uint32 attachments[2] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
+        u32 attachments[2] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
         glDrawBuffers(2, attachments);
     }
 
···
     // way, we know we can copy the depth from one to the other without issues.  For the
     // moment, we're not using fog, so this is just commented out.
     {
-        uint32 l_depth_texture_name;
+        u32 l_depth_texture_name;
         glGenTextures(1, &l_depth_texture_name);
 
         *l_depth_texture = mats::init_texture(
···
     // Depth buffer
     // NOTE: Either this or the l_depth_texure should be enabled, not both
     {
-        uint32 rbo_depth;
+        u32 rbo_depth;
         glGenRenderbuffers(1, &rbo_depth);
         glBindRenderbuffer(GL_RENDERBUFFER, rbo_depth);
         glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
···
 void
 renderer::init_blur_buffers(
     memory::Pool *memory_pool,
-    uint32 *blur1_buffer,
-    uint32 *blur2_buffer,
+    u32 *blur1_buffer,
+    u32 *blur2_buffer,
     mats::Texture **blur1_texture,
     mats::Texture **blur2_texture,
-    uint32 width,
-    uint32 height
+    u32 width,
+    u32 height
 ) {
 #if !USE_BLOOM
     return;
 #endif
     glGenFramebuffers(1, blur1_buffer);
     glBindFramebuffer(GL_FRAMEBUFFER, *blur1_buffer);
-    uint32 blur1_texture_name;
+    u32 blur1_texture_name;
     glGenTextures(1, &blur1_texture_name);
 
     *blur1_texture = mats::init_texture(
···
 
     glGenFramebuffers(1, blur2_buffer);
     glBindFramebuffer(GL_FRAMEBUFFER, *blur2_buffer);
-    uint32 blur2_texture_name;
+    u32 blur2_texture_name;
     glGenTextures(1, &blur2_texture_name);
 
     *blur2_texture = mats::init_texture(
···
 
 
 void
-renderer::init_ubo(uint32 *ubo_shader_common)
+renderer::init_ubo(u32 *ubo_shader_common)
 {
     glGenBuffers(1, ubo_shader_common);
     glBindBuffer(GL_UNIFORM_BUFFER, *ubo_shader_common);
···
 void
 renderer::init_3d_shadowmaps(
     memory::Pool *memory_pool,
-    uint32 *shadowmaps_3d_framebuffer,
-    uint32 *shadowmaps_3d,
+    u32 *shadowmaps_3d_framebuffer,
+    u32 *shadowmaps_3d,
     mats::Texture **shadowmaps_3d_texture,
-    uint32 shadowmap_3d_width,
-    uint32 shadowmap_3d_height
+    u32 shadowmap_3d_width,
+    u32 shadowmap_3d_height
 ) {
     glGenFramebuffers(1, shadowmaps_3d_framebuffer);
     glGenTextures(1, shadowmaps_3d);
···
 void
 renderer::init_2d_shadowmaps(
     memory::Pool *memory_pool,
-    uint32 *shadowmaps_2d_framebuffer,
-    uint32 *shadowmaps_2d,
+    u32 *shadowmaps_2d_framebuffer,
+    u32 *shadowmaps_2d,
     mats::Texture **shadowmaps_2d_texture,
-    uint32 shadowmap_2d_width,
-    uint32 shadowmap_2d_height
+    u32 shadowmap_2d_width,
+    u32 shadowmap_2d_height
 ) {
     glGenFramebuffers(1, shadowmaps_2d_framebuffer);
     glGenTextures(1, shadowmaps_2d);
···
     glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
     glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-    real32 border_color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
+    f32 border_color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
     glTexParameterfv(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BORDER_COLOR, border_color);
     glBindFramebuffer(GL_FRAMEBUFFER, *shadowmaps_2d_framebuffer);
     glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, *shadowmaps_2d, 0);
···
         glBindVertexArray(renderer::state->gui_vao);
         glBindBuffer(GL_ARRAY_BUFFER, renderer::state->gui_vbo);
         glBufferData(GL_ARRAY_BUFFER, GUI_VERTEX_SIZE * GUI_MAX_N_VERTICES, NULL, GL_DYNAMIC_DRAW);
-        uint32 location;
+        u32 location;
 
         // position (vec2)
         location = 0;
···
         location = 1;
         glEnableVertexAttribArray(location);
         glVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, GUI_VERTEX_SIZE,
-            (void*)(2 * sizeof(real32)));
+            (void*)(2 * sizeof(f32)));
 
         // color (vec4)
         location = 2;
         glEnableVertexAttribArray(location);
         glVertexAttribPointer(location, 4, GL_FLOAT, GL_FALSE, GUI_VERTEX_SIZE,
-            (void*)(4 * sizeof(real32)));
+            (void*)(4 * sizeof(f32)));
     }
 
     // Shaders
···
 void
 renderer::copy_scene_data_to_ubo(
     WindowSize *window_size,
-    uint32 current_shadow_light_idx,
-    uint32 current_shadow_light_type,
-    bool32 is_blur_horizontal
+    u32 current_shadow_light_idx,
+    u32 current_shadow_light_type,
+    bool is_blur_horizontal
 ) {
     ShaderCommon *shader_common = &renderer::state->shader_common;
     cameras::Camera *camera = cameras::get_main();
···
     shader_common->window_width = window_size->width;
     shader_common->window_height = window_size->height;
 
-    uint32 n_point_lights = 0;
-    uint32 n_directional_lights = 0;
+    u32 n_point_lights = 0;
+    u32 n_directional_lights = 0;
 
     each (light_component, *engine::get_light_components()) {
         if (light_component->entity_handle == entities::NO_ENTITY_HANDLE) {
···
 
         if (render_mode == drawable::Mode::regular) {
             for (
-                uint32 texture_idx = 1;
+                u32 texture_idx = 1;
                 texture_idx < shader_asset->n_texture_units + 1; texture_idx++
             ) {
                 if (shader_asset->texture_units[texture_idx] != 0) {
···
     }
 
     for (
-        uint32 uniform_idx = 0;
+        u32 uniform_idx = 0;
         uniform_idx < shader_asset->n_intrinsic_uniforms;
         uniform_idx++
     ) {
···
             continue;
         }
 
-        if (!((uint32)render_pass & (uint32)drawable_component->target_render_pass)) {
+        if (!((u32)render_pass & (u32)drawable_component->target_render_pass)) {
             continue;
         }
 

src/renderer.hpp

···
 
 class renderer {
 public:
-    static constexpr uint32 GUI_MAX_N_VERTICES = 65536;
-    static constexpr size_t GUI_VERTEX_SIZE = sizeof(real32) * gui::VERTEX_LENGTH;
+    static constexpr u32 GUI_MAX_N_VERTICES = 65536;
+    static constexpr size_t GUI_VERTEX_SIZE = sizeof(f32) * gui::VERTEX_LENGTH;
 
     struct ShaderCommon {
         m4 view;
···
     };
 
     struct BuiltinTextures {
-        uint32 g_buffer;
+        u32 g_buffer;
         mats::Texture *g_position_texture;
         mats::Texture *g_normal_texture;
         mats::Texture *g_albedo_texture;
         mats::Texture *g_pbr_texture;
 
-        uint32 l_buffer;
+        u32 l_buffer;
         mats::Texture *l_color_texture;
         mats::Texture *l_bright_color_texture;
         mats::Texture *l_depth_texture;
 
-        uint32 blur1_buffer;
-        uint32 blur2_buffer;
+        u32 blur1_buffer;
+        u32 blur2_buffer;
         mats::Texture *blur1_texture;
         mats::Texture *blur2_texture;
 
-        uint32 shadowmaps_3d_framebuffer;
-        uint32 shadowmaps_3d;
+        u32 shadowmaps_3d_framebuffer;
+        u32 shadowmaps_3d;
         mats::Texture *shadowmaps_3d_texture;
-        uint32 shadowmap_3d_width;
-        uint32 shadowmap_3d_height;
+        u32 shadowmap_3d_width;
+        u32 shadowmap_3d_height;
 
-        uint32 shadowmaps_2d_framebuffer;
-        uint32 shadowmaps_2d;
+        u32 shadowmaps_2d_framebuffer;
+        u32 shadowmaps_2d;
         mats::Texture *shadowmaps_2d_texture;
-        uint32 shadowmap_2d_width;
-        uint32 shadowmap_2d_height;
+        u32 shadowmap_2d_width;
+        u32 shadowmap_2d_height;
 
-        real32 shadowmap_near_clip_dist;
-        real32 shadowmap_far_clip_dist;
+        f32 shadowmap_near_clip_dist;
+        f32 shadowmap_far_clip_dist;
     };
 
     struct State {
-        bool32 should_hide_ui;
-        bool32 should_use_wireframe;
+        bool should_hide_ui;
+        bool should_use_wireframe;
         mats::TextureType renderdebug_displayed_texture_type;
         shaders::Asset standard_depth_shader_asset;
-        uint32 ubo_shader_common;
+        u32 ubo_shader_common;
         ShaderCommon shader_common;
         m4 shadowmap_3d_transforms[6 * MAX_N_LIGHTS];
         m4 shadowmap_2d_transforms[MAX_N_LIGHTS];
         BuiltinTextures builtin_textures;
-        uint32 gui_vao;
-        uint32 gui_vbo;
+        u32 gui_vao;
+        u32 gui_vbo;
         mats::TextureAtlas gui_texture_atlas;
         shaders::Asset gui_shader_asset;
         Array<fonts::FontAsset> gui_font_assets;
-        uint32 gui_n_vertices_pushed;
+        u32 gui_n_vertices_pushed;
     };
 
     static GLFWwindow * init_window(WindowSize *window_size);
-    bool32 is_drawable_component_valid(drawable::Component *drawable_component);
+    bool is_drawable_component_valid(drawable::Component *drawable_component);
     void destroy_drawable_component(drawable::Component *drawable_component);
     static void resize_renderer_buffers(
         memory::Pool *memory_pool,
         BuiltinTextures *builtin_textures,
-        uint32 width,
-        uint32 height
+        u32 width,
+        u32 height
     );
     static void update_drawing_options(GLFWwindow *window);
     static void render(GLFWwindow *window, WindowSize *window_size);
     static void init(
         renderer::State *renderer_state,
         memory::Pool *memory_pool,
-        uint32 width,
-        uint32 height,
+        u32 width,
+        u32 height,
         GLFWwindow *window
     );
     static void start_drawing_gui();
···
 private:
     static void init_g_buffer(
         memory::Pool *memory_pool,
-        uint32 *g_buffer,
+        u32 *g_buffer,
         mats::Texture **g_position_texture,
         mats::Texture **g_normal_texture,
         mats::Texture **g_albedo_texture,
         mats::Texture **g_pbr_texture,
-        uint32 width,
-        uint32 height
+        u32 width,
+        u32 height
     );
     static void init_l_buffer(
         memory::Pool *memory_pool,
-        uint32 *l_buffer,
+        u32 *l_buffer,
         mats::Texture **l_color_texture,
         mats::Texture **l_bright_color_texture,
         mats::Texture **l_depth_texture,
-        uint32 width,
-        uint32 height
+        u32 width,
+        u32 height
     );
     static void init_blur_buffers(
         memory::Pool *memory_pool,
-        uint32 *blur1_buffer,
-        uint32 *blur2_buffer,
+        u32 *blur1_buffer,
+        u32 *blur2_buffer,
         mats::Texture **blur1_texture,
         mats::Texture **blur2_texture,
-        uint32 width,
-        uint32 height
+        u32 width,
+        u32 height
     );
-    static void init_ubo(uint32 *ubo_shader_common);
+    static void init_ubo(u32 *ubo_shader_common);
     static void init_3d_shadowmaps(
         memory::Pool *memory_pool,
-        uint32 *shadowmaps_3d_framebuffer,
-        uint32 *shadowmaps_3d,
+        u32 *shadowmaps_3d_framebuffer,
+        u32 *shadowmaps_3d,
         mats::Texture **shadowmaps_3d_texture,
-        uint32 shadowmap_3d_width,
-        uint32 shadowmap_3d_height
+        u32 shadowmap_3d_width,
+        u32 shadowmap_3d_height
     );
     static void init_2d_shadowmaps(
         memory::Pool *memory_pool,
-        uint32 *shadowmaps_2d_framebuffer,
-        uint32 *shadowmaps_2d,
+        u32 *shadowmaps_2d_framebuffer,
+        u32 *shadowmaps_2d,
         mats::Texture **shadowmaps_2d_texture,
-        uint32 shadowmap_2d_width,
-        uint32 shadowmap_2d_height
+        u32 shadowmap_2d_width,
+        u32 shadowmap_2d_height
     );
     static void init_gui(memory::Pool *memory_pool);
     static void copy_scene_data_to_ubo(
         WindowSize *window_size,
-        uint32 current_shadow_light_idx,
-        uint32 current_shadow_light_type,
-        bool32 is_blur_horizontal
+        u32 current_shadow_light_idx,
+        u32 current_shadow_light_type,
+        bool is_blur_horizontal
     );
     static void draw(
         drawable::Mode render_mode,

src/shaders.cpp

···
 
 void
 shaders::set_int(
-    shaders::Asset *shader_asset, const char *uniform_name, uint32 value
+    shaders::Asset *shader_asset, const char *uniform_name, u32 value
 ) {
-    int32 location = get_uniform_location(shader_asset, uniform_name);
+    i32 location = get_uniform_location(shader_asset, uniform_name);
     if (location >= 0) {
         glUniform1i(location, value);
     }
···
 shaders::set_bool(
     shaders::Asset *shader_asset, const char *uniform_name, bool value
 ) {
-    set_int(shader_asset, uniform_name, (uint32)value);
+    set_int(shader_asset, uniform_name, (u32)value);
 }
 
 
···
 shaders::set_float(
     shaders::Asset *shader_asset, const char *uniform_name, float value
 ) {
-    int32 location = get_uniform_location(shader_asset, uniform_name);
+    i32 location = get_uniform_location(shader_asset, uniform_name);
     if (location >= 0) {
         glUniform1f(location, value);
     }
···
 void
 shaders::set_vec2(shaders::Asset *shader_asset, const char *uniform_name, v2 *value)
 {
-    int32 location = get_uniform_location(shader_asset, uniform_name);
+    i32 location = get_uniform_location(shader_asset, uniform_name);
     if (location >= 0) {
         glUniform2fv(location, 1, glm::value_ptr(*value));
     }
···
 void
 shaders::set_vec3(shaders::Asset *shader_asset, const char *uniform_name, v3 *value)
 {
-    int32 location = get_uniform_location(shader_asset, uniform_name);
+    i32 location = get_uniform_location(shader_asset, uniform_name);
     if (location >= 0) {
         glUniform3fv(location, 1, glm::value_ptr(*value));
     }
···
 void
 shaders::set_vec4(shaders::Asset *shader_asset, const char *uniform_name, v4 *value)
 {
-    int32 location = get_uniform_location(shader_asset, uniform_name);
+    i32 location = get_uniform_location(shader_asset, uniform_name);
     if (location >= 0) {
         glUniform4fv(location, 1, glm::value_ptr(*value));
     }
···
 void
 shaders::set_mat2(shaders::Asset *shader_asset, const char *uniform_name, m2 *mat)
 {
-    int32 location = get_uniform_location(shader_asset, uniform_name);
+    i32 location = get_uniform_location(shader_asset, uniform_name);
     if (location >= 0) {
         glUniformMatrix2fv(location, 1, GL_FALSE, glm::value_ptr(*mat));
     }
···
 void
 shaders::set_mat3(shaders::Asset *shader_asset, const char *uniform_name, m3 *mat)
 {
-    int32 location = get_uniform_location(shader_asset, uniform_name);
+    i32 location = get_uniform_location(shader_asset, uniform_name);
     if (location >= 0) {
         glUniformMatrix3fv(location, 1, GL_FALSE, glm::value_ptr(*mat));
     }
···
 
 void
 shaders::set_mat4_multiple(
-    shaders::Asset *shader_asset, uint32 n, const char *uniform_name, m4 *mat
+    shaders::Asset *shader_asset, u32 n, const char *uniform_name, m4 *mat
 ) {
-    int32 location = get_uniform_location(shader_asset, uniform_name);
+    i32 location = get_uniform_location(shader_asset, uniform_name);
     if (location >= 0) {
         glUniformMatrix4fv(location, n, GL_FALSE, glm::value_ptr(*mat));
     }
···
 void
 shaders::set_mat4(shaders::Asset *shader_asset, const char *uniform_name, m4 *mat)
 {
-    int32 location = get_uniform_location(shader_asset, uniform_name);
+    i32 location = get_uniform_location(shader_asset, uniform_name);
     if (location >= 0) {
         glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(*mat));
     }
···
 }
 
 
-uint32
+u32
 shaders::add_texture_unit(
     shaders::Asset *shader_asset,
-    uint32 new_texture_unit,
+    u32 new_texture_unit,
     GLenum new_texture_unit_type
 ) {
-    uint32 idx = ++shader_asset->n_texture_units;
+    u32 idx = ++shader_asset->n_texture_units;
     shader_asset->texture_units[idx] = new_texture_unit;
     shader_asset->texture_unit_types[idx] = new_texture_unit_type;
     return idx;
···
 
 
 void
-shaders::assert_shader_status_ok(uint32 new_shader, const char *path)
+shaders::assert_shader_status_ok(u32 new_shader, const char *path)
 {
-    int32 status;
+    i32 status;
     glGetShaderiv(new_shader, GL_COMPILE_STATUS, &status);
 
     if (status != 1) {
···
 
 
 void
-shaders::assert_program_status_ok(uint32 new_program)
+shaders::assert_program_status_ok(u32 new_program)
 {
-    int32 status;
+    i32 status;
     glGetProgramiv(new_program, GL_LINK_STATUS, &status);
 
     if (status != 1) {
···
 }
 
 
-uint32
+u32
 shaders::make_shader(const char *path, const char *source, GLenum shader_type)
 {
-    uint32 shader = glCreateShader(shader_type);
+    u32 shader = glCreateShader(shader_type);
     glShaderSource(shader, 1, &source, NULL);
     glCompileShader(shader);
     assert_shader_status_ok(shader, path);
···
 }
 
 
-uint32
-shaders::make_program(uint32 vertex_shader, uint32 fragment_shader)
+u32
+shaders::make_program(u32 vertex_shader, u32 fragment_shader)
 {
-    uint32 new_program = glCreateProgram();
+    u32 new_program = glCreateProgram();
     glAttachShader(new_program, vertex_shader);
     glAttachShader(new_program, fragment_shader);
     glLinkProgram(new_program);
···
 }
 
 
-uint32
+u32
 shaders::make_program(
-    uint32 vertex_shader, uint32 fragment_shader, uint32 geometry_shader
+    u32 vertex_shader, u32 fragment_shader, u32 geometry_shader
 ) {
-    uint32 new_program = glCreateProgram();
+    u32 new_program = glCreateProgram();
     glAttachShader(new_program, vertex_shader);
     glAttachShader(new_program, fragment_shader);
     glAttachShader(new_program, geometry_shader);
···
     char full_path[MAX_PATH];
     strcpy(full_path, SHADER_DIR); // TODO: Fix unsafe strings?
     strcat(full_path, path);
-    uint32 f1_size = files::get_file_size(SHADER_COMMON_PATH);
-    uint32 f2_size = files::get_file_size(full_path);
+    u32 f1_size = files::get_file_size(SHADER_COMMON_PATH);
+    u32 f2_size = files::get_file_size(full_path);
     char *file_memory = (char*)memory::push(memory_pool, f1_size + f2_size + 1, full_path);
     files::load_file(file_memory, SHADER_COMMON_PATH);
     files::load_file(file_memory + f1_size, full_path);
···
     char full_path[MAX_PATH];
     strcpy(full_path, SHADER_DIR); // TODO: Fix unsafe strings?
     strcat(full_path, path);
-    uint32 f1_size = files::get_file_size(SHADER_COMMON_PATH);
-    uint32 f2_size = files::get_file_size(SHADER_COMMON_FRAGMENT_PATH);
-    uint32 f3_size = files::get_file_size(full_path);
+    u32 f1_size = files::get_file_size(SHADER_COMMON_PATH);
+    u32 f2_size = files::get_file_size(SHADER_COMMON_FRAGMENT_PATH);
+    u32 f3_size = files::get_file_size(full_path);
     char *file_memory = (char*)memory::push(memory_pool, f1_size + f2_size + f3_size + 1, full_path);
     files::load_file(file_memory, SHADER_COMMON_PATH);
     files::load_file(file_memory + f1_size, SHADER_COMMON_FRAGMENT_PATH);
···
 }
 
 
-int32
+i32
 shaders::get_uniform_location(
     shaders::Asset *shader_asset,
     const char *uniform_name
 ) {
     // Look up in cache.
-    for (uint32 idx = 0; idx < shader_asset->n_intrinsic_uniforms; idx++) {
+    for (u32 idx = 0; idx < shader_asset->n_intrinsic_uniforms; idx++) {
         if (strcmp(shader_asset->intrinsic_uniform_names[idx], uniform_name) == 0) {
             return shader_asset->intrinsic_uniform_locations[idx];
         }
···
 void
 shaders::load_uniforms(shaders::Asset *shader_asset)
 {
-    for (uint16 idx = 0; idx < MAX_N_UNIFORMS; idx++) {
+    for (u16 idx = 0; idx < MAX_N_UNIFORMS; idx++) {
         shader_asset->intrinsic_uniform_locations[idx] = -1;
     }
 
     // Bind uniform block
-    uint32 uniform_block_index = glGetUniformBlockIndex(shader_asset->program, "shader_common");
+    u32 uniform_block_index = glGetUniformBlockIndex(shader_asset->program, "shader_common");
     glUniformBlockBinding(shader_asset->program, uniform_block_index, 0);
 
     // Load uniforms
     // NOTE: We may want to skip all shader_asset stuff, because fallback on loading the locations
     // in `shader::set_*` anyway. But, it's kind of cool to know we're loading everything we can
     // up front in shader_asset function.
-    uint32 new_n_intrinsic_uniforms = 0;
+    u32 new_n_intrinsic_uniforms = 0;
     GLint n_active_uniforms;
     char uniform_name[MAX_UNIFORM_NAME_LENGTH];
     GLint uniform_name_length;

src/shaders.hpp

···
         char vert_path[MAX_PATH];
         char frag_path[MAX_PATH];
         char geom_path[MAX_PATH];
-        uint32 program;
+        u32 program;
         Type type;
-        uint32 n_texture_units;
-        uint32 texture_units[MAX_N_TEXTURE_UNITS];
+        u32 n_texture_units;
+        u32 texture_units[MAX_N_TEXTURE_UNITS];
         GLenum texture_unit_types[MAX_N_TEXTURE_UNITS];
         bool did_set_texture_uniforms;
 
···
            uniform buffer object.
        */
 
-        uint32 n_intrinsic_uniforms;
-        int32 intrinsic_uniform_locations[MAX_N_UNIFORMS];
+        u32 n_intrinsic_uniforms;
+        i32 intrinsic_uniform_locations[MAX_N_UNIFORMS];
         char intrinsic_uniform_names[MAX_UNIFORM_NAME_LENGTH][MAX_N_UNIFORMS];
     };
 
     static const char* shader_type_to_string(Type shader_type);
     static Type shader_type_from_string(const char* str);
     static bool is_shader_asset_valid(Asset *shader_asset);
-    static void set_int(Asset *shader_asset, const char *uniform_name, uint32 value);
+    static void set_int(Asset *shader_asset, const char *uniform_name, u32 value);
     static void set_bool(Asset *shader_asset, const char *uniform_name, bool value);
     static void set_float(Asset *shader_asset, const char *uniform_name, float value);
     static void set_vec2(Asset *shader_asset, const char *uniform_name, v2 *value);
···
     static void set_mat2(Asset *shader_asset, const char *uniform_name, m2 *mat);
     static void set_mat3(Asset *shader_asset, const char *uniform_name, m3 *mat);
     static void set_mat4_multiple(
-        Asset *shader_asset, uint32 n, const char *uniform_name, m4 *mat
+        Asset *shader_asset, u32 n, const char *uniform_name, m4 *mat
     );
     static void set_mat4(Asset *shader_asset, const char *uniform_name, m4 *mat);
     static void reset_texture_units(Asset *shader_asset);
-    static uint32 add_texture_unit(
+    static u32 add_texture_unit(
         Asset *shader_asset,
-        uint32 new_texture_unit,
+        u32 new_texture_unit,
         GLenum new_texture_unit_type
     );
     static void load_shader_asset(Asset *shader_asset, memory::Pool *memory_pool);
···
     static void destroy_shader_asset(Asset *shader_asset);
 
 private:
-    static void assert_shader_status_ok(uint32 new_shader, const char *path);
-    static void assert_program_status_ok(uint32 new_program);
-    static uint32 make_shader(const char *path, const char *source, GLenum shader_type);
-    static uint32 make_program(uint32 vertex_shader, uint32 fragment_shader);
-    static uint32 make_program(
-        uint32 vertex_shader, uint32 fragment_shader, uint32 geometry_shader
+    static void assert_shader_status_ok(u32 new_shader, const char *path);
+    static void assert_program_status_ok(u32 new_program);
+    static u32 make_shader(const char *path, const char *source, GLenum shader_type);
+    static u32 make_program(u32 vertex_shader, u32 fragment_shader);
+    static u32 make_program(
+        u32 vertex_shader, u32 fragment_shader, u32 geometry_shader
     );
     static const char* load_file(memory::Pool *memory_pool, const char *path);
     static const char* load_frag_file(memory::Pool *memory_pool, const char *path);
-    static int32 get_uniform_location(
+    static i32 get_uniform_location(
         Asset *shader_asset,
         const char *uniform_name
     );

src/spatial.cpp

···
 }
 
 
-bool32
+bool
 spatial::does_spatial_component_have_dimensions(spatial::Component *spatial_component)
 {
     return (
···
 }
 
 
-bool32
+bool
 spatial::is_spatial_component_valid(spatial::Component *spatial_component)
 {
     return does_spatial_component_have_dimensions(spatial_component) ||

src/spatial.hpp

···
 
 
     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 bool does_spatial_component_have_dimensions(Component *spatial_component);
+    static bool is_spatial_component_valid(Component *spatial_component);
     static m4 make_model_matrix(
         Component *spatial_component,
         ModelMatrixCache *cache

src/stackarray.hpp

···
 
 #include "memory.hpp"
 
-template <typename T, uint32 capacity>
+template <typename T, u32 capacity>
 class StackArray {
 public:
     T items[capacity] = {{}};
-    uint32 length = 0;
-    bool32 is_sparse = false;
-    uint32 starting_idx = 0;
+    u32 length = 0;
+    bool is_sparse = false;
+    u32 starting_idx = 0;
 
     T* push() {
         assert(this->length < capacity);
-        uint32 new_idx = this->length;
+        u32 new_idx = this->length;
         this->length++;
         T* new_slot = &this->items[new_idx];
         return new_slot;
···
         return new_slot;
     }
 
-    T* get(uint32 idx) {
+    T* get(u32 idx) {
         assert(idx >= this->starting_idx && idx < capacity);
         if (idx >= this->length) {
             assert(this->is_sparse);
···
         return &this->items[idx];
     }
 
-    T* operator[](uint32 idx) {
+    T* operator[](u32 idx) {
         return get(idx);
     }
 
···
         this->length = 0;
     }
 
-    void delete_elements_after_index(uint32 idx) {
+    void delete_elements_after_index(u32 idx) {
         memset(&this->items[idx], 0, sizeof(T) * (this->length - idx));
         this->length = idx;
     }

src/tasks.cpp

···
 void
 tasks::run_loading_loop(
     std::mutex *mutex,
-    bool32 *should_stop,
-    uint32 idx_thread
+    bool *should_stop,
+    u32 idx_thread
 ) {
     while (!*should_stop) {
         Task *task = nullptr;
···
 {
     auto t0 = debug_start_timer();
     task->fn(task->argument_1);
-    real64 duration = debug_end_timer(t0);
+    f64 duration = debug_end_timer(t0);
     logs::info("Task took %.0fms", duration);
 }

src/tasks.hpp

···
     static void push(Task task);
     static void run_loading_loop(
         std::mutex *mutex,
-        bool32 *should_stop,
-        uint32 idx_thread
+        bool *should_stop,
+        u32 idx_thread
     );
     static void init(tasks::State *tasks_state, memory::Pool *pool);
 

src/types.hpp

···
 #include <stdint.h>
 #include "glm.hpp"
 
-typedef int8_t int8;
-typedef int16_t int16;
-typedef int32_t int32;
-typedef int64_t int64;
-typedef int8 s8;
-typedef int16 s16;
-typedef int32 s32;
-typedef int64 s64;
+typedef int8_t i8;
+typedef int16_t i16;
+typedef int32_t i32;
+typedef int64_t i64;
 
-typedef int8 bool8;
-typedef int16 bool16;
-typedef int32 bool32;
-typedef int64 bool64;
-typedef bool8 b8;
-typedef bool16 b16;
-typedef bool32 b32;
-typedef bool64 b64;
+typedef int8_t b8;
+typedef int16_t b16;
+typedef int32_t b32;
+typedef int64_t b64;
 
-typedef uint8_t uint8;
-typedef uint16_t uint16;
-typedef uint32_t uint32;
-typedef uint64_t uint64;
-typedef uint8 u8;
-typedef uint16 u16;
-typedef uint32 u32;
-typedef uint64 u64;
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
 
-typedef float real32;
-typedef double real64;
-typedef real32 r32;
-typedef real64 r64;
-typedef real32 f32;
-typedef real64 f64;
+typedef float f32;
+typedef double f64;
 
 typedef glm::vec2 v2;
 typedef glm::vec3 v3;

src/util.cpp

···
 
 
 GLenum
-util::get_texture_format_from_n_components(int32 n_components)
+util::get_texture_format_from_n_components(i32 n_components)
 {
     if (n_components == 1) {
         return GL_RED;
···
 }
 
 
-real64
-util::random(real64 min, real64 max)
+f64
+util::random(f64 min, f64 max)
 {
-    uint32 r = rand();
-    real64 r_normalized = (real64)r / (real64)RAND_MAX;
+    u32 r = rand();
+    f64 r_normalized = (f64)r / (f64)RAND_MAX;
     return min + ((r_normalized) * (max - min));
 }
 
···
 }
 
 
-real32
-util::round_to_nearest_multiple(real32 n, real32 multiple_of)
+f32
+util::round_to_nearest_multiple(f32 n, f32 multiple_of)
 {
     return (floor((n) / multiple_of) * multiple_of) + multiple_of;
 }
 
 
-real64
-util::get_us_from_duration(chrono::duration<real64> duration)
+f64
+util::get_us_from_duration(chrono::duration<f64> duration)
 {
-    return chrono::duration_cast<chrono::duration<real64>>(duration).count();
+    return chrono::duration_cast<chrono::duration<f64>>(duration).count();
 }
 
 
···
 }
 
 
-uint32 util::kb_to_b(uint32 value) { return value * 1024; }
-uint32 util::mb_to_b(uint32 value) { return kb_to_b(value) * 1024; }
-uint32 util::gb_to_b(uint32 value) { return mb_to_b(value) * 1024; }
-uint32 util::tb_to_b(uint32 value) { return gb_to_b(value) * 1024; }
-real32 util::b_to_kb(uint32 value) { return value / 1024.0f; }
-real32 util::b_to_mb(uint32 value) { return b_to_kb(value) / 1024.0f; }
-real32 util::b_to_gb(uint32 value) { return b_to_mb(value) / 1024.0f; }
-real32 util::b_to_tb(uint32 value) { return b_to_gb(value) / 1024.0f; }
+u32 util::kb_to_b(u32 value) { return value * 1024; }
+u32 util::mb_to_b(u32 value) { return kb_to_b(value) * 1024; }
+u32 util::gb_to_b(u32 value) { return mb_to_b(value) * 1024; }
+u32 util::tb_to_b(u32 value) { return gb_to_b(value) * 1024; }
+f32 util::b_to_kb(u32 value) { return value / 1024.0f; }
+f32 util::b_to_mb(u32 value) { return b_to_kb(value) / 1024.0f; }
+f32 util::b_to_gb(u32 value) { return b_to_mb(value) / 1024.0f; }
+f32 util::b_to_tb(u32 value) { return b_to_gb(value) / 1024.0f; }

src/util.hpp

···
 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 GLenum get_texture_format_from_n_components(i32 n_components);
+    static f64 random(f64 min, f64 max);
     static v3 aiVector3D_to_glm(aiVector3D *vec);
     static quat aiQuaternion_to_glm(aiQuaternion *rotation);
     static m4 aimatrix4x4_to_glm(aiMatrix4x4 *from);
···
         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 f32 round_to_nearest_multiple(f32 n, f32 multiple_of);
+    static f64 get_us_from_duration(chrono::duration<f64> 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);
+    static u32 kb_to_b(u32 value);
+    static u32 mb_to_b(u32 value);
+    static u32 gb_to_b(u32 value);
+    static u32 tb_to_b(u32 value);
+    static f32 b_to_kb(u32 value);
+    static f32 b_to_mb(u32 value);
+    static f32 b_to_gb(u32 value);
+    static f32 b_to_tb(u32 value);
 };