4 files changed, 274 insertions, 274 deletions
diff --git a/core/resource/image.cc b/core/resource/image.cc
index d5e256d..45fe96e 100644
--- a/core/resource/image.cc
+++ b/core/resource/image.cc
@@ -1,81 +1,81 @@
-#include "core/pch.hh"
-
-#include "core/resource/image.hh"
-
-#include "core/resource/resource.hh"
-
-#include "core/utils/physfs.hh"
-
-static int stbi_physfs_read(void* context, char* data, int size)
-{
-    return PHYSFS_readBytes(reinterpret_cast<PHYSFS_File*>(context), data, size);
-}
-
-static void stbi_physfs_skip(void* context, int count)
-{
-    auto file = reinterpret_cast<PHYSFS_File*>(context);
-    PHYSFS_seek(file, PHYSFS_tell(file) + count);
-}
-
-static int stbi_physfs_eof(void* context)
-{
-    return PHYSFS_eof(reinterpret_cast<PHYSFS_File*>(context));
-}
-
-static const void* image_load_func(const char* name, std::uint32_t flags)
-{
-    assert(name);
-
-    stbi_io_callbacks callbacks;
-    callbacks.read = &stbi_physfs_read;
-    callbacks.skip = &stbi_physfs_skip;
-    callbacks.eof = &stbi_physfs_eof;
-
-    stbi_set_flip_vertically_on_load(bool(flags & IMAGE_LOAD_FLIP));
-
-    auto file = PHYSFS_openRead(name);
-
-    if(file == nullptr) {
-        spdlog::error("image: {}: {}", name, utils::physfs_error());
-        return nullptr;
-    }
-
-    int desired_channels;
-
-    if(flags & IMAGE_LOAD_GRAY) {
-        desired_channels = STBI_grey;
-    }
-    else {
-        desired_channels = STBI_rgb_alpha;
-    }
-
-    int width, height, channels;
-    auto pixels = stbi_load_from_callbacks(&callbacks, file, &width, &height, &channels, desired_channels);
-
-    PHYSFS_close(file);
-
-    if(pixels == nullptr) {
-        spdlog::error("image: {}: {}", name, stbi_failure_reason());
-        return nullptr;
-    }
-
-    auto image = new Image;
-    image->pixels = pixels;
-    image->size = glm::ivec2(width, height);
-    return image;
-}
-
-static void image_free_func(const void* resource)
-{
-    assert(resource);
-
-    auto image = reinterpret_cast<const Image*>(resource);
-    stbi_image_free(image->pixels);
-
-    delete image;
-}
-
-void Image::register_resource(void)
-{
-    resource::register_loader<Image>(&image_load_func, &image_free_func);
-}
+#include "core/pch.hh"
+
+#include "core/resource/image.hh"
+
+#include "core/resource/resource.hh"
+
+#include "core/utils/physfs.hh"
+
+static int stbi_physfs_read(void* context, char* data, int size)
+{
+    return PHYSFS_readBytes(reinterpret_cast<PHYSFS_File*>(context), data, size);
+}
+
+static void stbi_physfs_skip(void* context, int count)
+{
+    auto file = reinterpret_cast<PHYSFS_File*>(context);
+    PHYSFS_seek(file, PHYSFS_tell(file) + count);
+}
+
+static int stbi_physfs_eof(void* context)
+{
+    return PHYSFS_eof(reinterpret_cast<PHYSFS_File*>(context));
+}
+
+static const void* image_load_func(const char* name, std::uint32_t flags)
+{
+    assert(name);
+
+    stbi_io_callbacks callbacks;
+    callbacks.read = &stbi_physfs_read;
+    callbacks.skip = &stbi_physfs_skip;
+    callbacks.eof = &stbi_physfs_eof;
+
+    stbi_set_flip_vertically_on_load(bool(flags & IMAGE_LOAD_FLIP));
+
+    auto file = PHYSFS_openRead(name);
+
+    if(file == nullptr) {
+        spdlog::error("image: {}: {}", name, utils::physfs_error());
+        return nullptr;
+    }
+
+    int desired_channels;
+
+    if(flags & IMAGE_LOAD_GRAY) {
+        desired_channels = STBI_grey;
+    }
+    else {
+        desired_channels = STBI_rgb_alpha;
+    }
+
+    int width, height, channels;
+    auto pixels = stbi_load_from_callbacks(&callbacks, file, &width, &height, &channels, desired_channels);
+
+    PHYSFS_close(file);
+
+    if(pixels == nullptr) {
+        spdlog::error("image: {}: {}", name, stbi_failure_reason());
+        return nullptr;
+    }
+
+    auto image = new Image;
+    image->pixels = pixels;
+    image->size = glm::ivec2(width, height);
+    return image;
+}
+
+static void image_free_func(const void* resource)
+{
+    assert(resource);
+
+    auto image = reinterpret_cast<const Image*>(resource);
+    stbi_image_free(image->pixels);
+
+    delete image;
+}
+
+void Image::register_resource(void)
+{
+    resource::register_loader<Image>(&image_load_func, &image_free_func);
+}
diff --git a/core/resource/image.hh b/core/resource/image.hh
index 575591f..8867b97 100644
--- a/core/resource/image.hh
+++ b/core/resource/image.hh
@@ -1,11 +1,11 @@
-#pragma once
-
-constexpr static unsigned int IMAGE_LOAD_GRAY = 0x0001U;
-constexpr static unsigned int IMAGE_LOAD_FLIP = 0x0002U;
-
-struct Image final {
-    static void register_resource(void);
-
-    stbi_uc* pixels;
-    glm::ivec2 size;
-};
+#pragma once
+
+constexpr static unsigned int IMAGE_LOAD_GRAY = 0x0001U;
+constexpr static unsigned int IMAGE_LOAD_FLIP = 0x0002U;
+
+struct Image final {
+    static void register_resource(void);
+
+    stbi_uc* pixels;
+    glm::ivec2 size;
+};
diff --git a/core/resource/resource.cc b/core/resource/resource.cc
index 600843f..21d1e4e 100644
--- a/core/resource/resource.cc
+++ b/core/resource/resource.cc
@@ -1,129 +1,129 @@
-#include "core/pch.hh"
-
-#include "core/resource/resource.hh"
-
-struct ResourceLoader final {
-    ResourceLoadFunc load_func;
-    ResourceFreeFunc free_func;
-    emhash8::HashMap<std::string, std::shared_ptr<const void>> resources;
-    std::vector<std::shared_ptr<const void>> cache;
-    std::string class_name;
-};
-
-namespace
-{
-emhash8::HashMap<std::type_index, std::unique_ptr<ResourceLoader>> loaders;
-} // namespace
-
-void resource::detail::register_loader(const std::type_info& type, ResourceLoadFunc load_func, ResourceFreeFunc free_func)
-{
-    assert(load_func);
-    assert(free_func);
-
-    auto type_index = std::type_index(type);
-    auto loader = std::make_unique<ResourceLoader>();
-    loader->class_name = type.name();
-    loader->load_func = load_func;
-    loader->free_func = free_func;
-
-    assert(!loaders.contains(type_index));
-
-    loaders.insert_or_assign(type_index, std::move(loader));
-}
-
-std::shared_ptr<const void> resource::detail::load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags)
-{
-    auto name_str = std::string(name);
-    auto type_index = std::type_index(type);
-    auto loader = loaders.find(type_index);
-
-    if(loader == loaders.cend()) {
-        spdlog::error("resource: no loader registered for type [{}]", type.name());
-        return nullptr;
-    }
-
-    auto resource_it = loader->second->resources.find(name_str);
-
-    if(resource_it == loader->second->resources.cend()) {
-        auto resource_raw = loader->second->load_func(name_str.c_str(), flags);
-
-        if(resource_raw == nullptr) {
-            spdlog::error("resource: {} [{}]: load failed", loader->second->class_name, name);
-            return nullptr;
-        }
-
-        std::shared_ptr<const void> resource_ptr(resource_raw, [](const void* ptr) { /* empty */ });
-        auto loaded_it = loader->second->resources.insert_or_assign(name_str, std::move(resource_ptr));
-
-        if(flags & RESOURCE_CACHE) {
-            loader->second->cache.push_back(loaded_it.first->second);
-        }
-
-        return loaded_it.first->second;
-    }
-
-    return resource_it->second;
-}
-
-std::shared_ptr<const void> resource::detail::find_resource(const std::type_info& type, std::string_view name)
-{
-    auto name_str = std::string(name);
-    auto type_index = std::type_index(type);
-    auto loader = loaders.find(type_index);
-
-    if(loader == loaders.cend()) {
-        spdlog::error("resource: no loader registered for type [{}]", type.name());
-        return nullptr;
-    }
-
-    auto resource_it = loader->second->resources.find(name_str);
-
-    if(resource_it == loader->second->resources.cend()) {
-        spdlog::error("resource: {} [{}]: not found", loader->second->class_name, name);
-        return nullptr;
-    }
-
-    return resource_it->second;
-}
-
-void resource::hard_cleanup(void)
-{
-    for(auto& [type_index, loader] : loaders) {
-        loader->cache.clear();
-
-        for(auto& [name, resource_ptr] : loader->resources) {
-            if(resource_ptr.use_count() > 1) {
-                spdlog::warn("resource: zombie resource: {} [{}] [use_count={}]", name, loader->class_name, resource_ptr.use_count());
-            }
-            else {
-                spdlog::debug("resource: releasing {} [{}]", name, loader->class_name);
-            }
-
-            loader->free_func(resource_ptr.get());
-        }
-
-        loader->resources.clear();
-    }
-
-    loaders.clear();
-}
-
-void resource::soft_cleanup(void)
-{
-    for(auto& [type_index, loader] : loaders) {
-        auto resource_it = loader->resources.begin();
-
-        while(resource_it != loader->resources.end()) {
-            if(resource_it->second.use_count() <= 1) {
-                spdlog::debug("resource: releasing {} [{}]", resource_it->first, loader->class_name);
-
-                loader->free_func(resource_it->second.get());
-                resource_it = loader->resources.erase(resource_it);
-
-                continue;
-            }
-
-            resource_it = std::next(resource_it);
-        }
-    }
-}
+#include "core/pch.hh"
+
+#include "core/resource/resource.hh"
+
+struct ResourceLoader final {
+    ResourceLoadFunc load_func;
+    ResourceFreeFunc free_func;
+    emhash8::HashMap<std::string, std::shared_ptr<const void>> resources;
+    std::vector<std::shared_ptr<const void>> cache;
+    std::string class_name;
+};
+
+namespace
+{
+emhash8::HashMap<std::type_index, std::unique_ptr<ResourceLoader>> loaders;
+} // namespace
+
+void resource::detail::register_loader(const std::type_info& type, ResourceLoadFunc load_func, ResourceFreeFunc free_func)
+{
+    assert(load_func);
+    assert(free_func);
+
+    auto type_index = std::type_index(type);
+    auto loader = std::make_unique<ResourceLoader>();
+    loader->class_name = type.name();
+    loader->load_func = load_func;
+    loader->free_func = free_func;
+
+    assert(!loaders.contains(type_index));
+
+    loaders.insert_or_assign(type_index, std::move(loader));
+}
+
+std::shared_ptr<const void> resource::detail::load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags)
+{
+    auto name_str = std::string(name);
+    auto type_index = std::type_index(type);
+    auto loader = loaders.find(type_index);
+
+    if(loader == loaders.cend()) {
+        spdlog::error("resource: no loader registered for type [{}]", type.name());
+        return nullptr;
+    }
+
+    auto resource_it = loader->second->resources.find(name_str);
+
+    if(resource_it == loader->second->resources.cend()) {
+        auto resource_raw = loader->second->load_func(name_str.c_str(), flags);
+
+        if(resource_raw == nullptr) {
+            spdlog::error("resource: {} [{}]: load failed", loader->second->class_name, name);
+            return nullptr;
+        }
+
+        std::shared_ptr<const void> resource_ptr(resource_raw, [](const void* ptr) { /* empty */ });
+        auto loaded_it = loader->second->resources.insert_or_assign(name_str, std::move(resource_ptr));
+
+        if(flags & RESOURCE_CACHE) {
+            loader->second->cache.push_back(loaded_it.first->second);
+        }
+
+        return loaded_it.first->second;
+    }
+
+    return resource_it->second;
+}
+
+std::shared_ptr<const void> resource::detail::find_resource(const std::type_info& type, std::string_view name)
+{
+    auto name_str = std::string(name);
+    auto type_index = std::type_index(type);
+    auto loader = loaders.find(type_index);
+
+    if(loader == loaders.cend()) {
+        spdlog::error("resource: no loader registered for type [{}]", type.name());
+        return nullptr;
+    }
+
+    auto resource_it = loader->second->resources.find(name_str);
+
+    if(resource_it == loader->second->resources.cend()) {
+        spdlog::error("resource: {} [{}]: not found", loader->second->class_name, name);
+        return nullptr;
+    }
+
+    return resource_it->second;
+}
+
+void resource::hard_cleanup(void)
+{
+    for(auto& [type_index, loader] : loaders) {
+        loader->cache.clear();
+
+        for(auto& [name, resource_ptr] : loader->resources) {
+            if(resource_ptr.use_count() > 1) {
+                spdlog::warn("resource: zombie resource: {} [{}] [use_count={}]", name, loader->class_name, resource_ptr.use_count());
+            }
+            else {
+                spdlog::debug("resource: releasing {} [{}]", name, loader->class_name);
+            }
+
+            loader->free_func(resource_ptr.get());
+        }
+
+        loader->resources.clear();
+    }
+
+    loaders.clear();
+}
+
+void resource::soft_cleanup(void)
+{
+    for(auto& [type_index, loader] : loaders) {
+        auto resource_it = loader->resources.begin();
+
+        while(resource_it != loader->resources.end()) {
+            if(resource_it->second.use_count() <= 1) {
+                spdlog::debug("resource: releasing {} [{}]", resource_it->first, loader->class_name);
+
+                loader->free_func(resource_it->second.get());
+                resource_it = loader->resources.erase(resource_it);
+
+                continue;
+            }
+
+            resource_it = std::next(resource_it);
+        }
+    }
+}
diff --git a/core/resource/resource.hh b/core/resource/resource.hh
index 105c7ff..fbca130 100644
--- a/core/resource/resource.hh
+++ b/core/resource/resource.hh
@@ -1,53 +1,53 @@
-#pragma once
-
-template<typename T>
-using resource_ptr = std::shared_ptr<const T>;
-
-constexpr std::uint32_t RESOURCE_CACHE = 0x00000001U; ///< Cache the resource after loading
-constexpr std::uint32_t RESOURCE_USER = 0xFFFFFF00U;  ///< User-defined flags for custom behavior
-
-using ResourceLoadFunc = const void* (*)(const char* name, std::uint32_t flags);
-using ResourceFreeFunc = void (*)(const void* resource);
-
-namespace resource::detail
-{
-void register_loader(const std::type_info& type, ResourceLoadFunc load_func, ResourceFreeFunc free_func);
-resource_ptr<void> load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags);
-resource_ptr<void> find_resource(const std::type_info& type, std::string_view name);
-} // namespace resource::detail
-
-namespace resource
-{
-template<typename T>
-void register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func);
-template<typename T>
-resource_ptr<T> load(std::string_view name, std::uint32_t flags = 0U);
-template<typename T>
-resource_ptr<T> find(std::string_view name);
-} // namespace resource
-
-namespace resource
-{
-void hard_cleanup(void);
-void soft_cleanup(void);
-} // namespace resource
-
-template<typename T>
-void resource::register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func)
-{
-    resource::detail::register_loader(typeid(T), load_func, free_func);
-}
-
-template<typename T>
-resource_ptr<T> resource::load(std::string_view name, std::uint32_t flags)
-{
-    auto result = resource::detail::load_resource(typeid(T), name, flags);
-    return std::reinterpret_pointer_cast<const T>(result);
-}
-
-template<typename T>
-resource_ptr<T> resource::find(std::string_view name)
-{
-    auto result = resource::detail::find_resource(typeid(T), name);
-    return std::reinterpret_pointer_cast<const T>(result);
-}
+#pragma once
+
+template<typename T>
+using resource_ptr = std::shared_ptr<const T>;
+
+constexpr std::uint32_t RESOURCE_CACHE = 0x00000001U; ///< Cache the resource after loading
+constexpr std::uint32_t RESOURCE_USER = 0xFFFFFF00U;  ///< User-defined flags for custom behavior
+
+using ResourceLoadFunc = const void* (*)(const char* name, std::uint32_t flags);
+using ResourceFreeFunc = void (*)(const void* resource);
+
+namespace resource::detail
+{
+void register_loader(const std::type_info& type, ResourceLoadFunc load_func, ResourceFreeFunc free_func);
+resource_ptr<void> load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags);
+resource_ptr<void> find_resource(const std::type_info& type, std::string_view name);
+} // namespace resource::detail
+
+namespace resource
+{
+template<typename T>
+void register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func);
+template<typename T>
+resource_ptr<T> load(std::string_view name, std::uint32_t flags = 0U);
+template<typename T>
+resource_ptr<T> find(std::string_view name);
+} // namespace resource
+
+namespace resource
+{
+void hard_cleanup(void);
+void soft_cleanup(void);
+} // namespace resource
+
+template<typename T>
+void resource::register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func)
+{
+    resource::detail::register_loader(typeid(T), load_func, free_func);
+}
+
+template<typename T>
+resource_ptr<T> resource::load(std::string_view name, std::uint32_t flags)
+{
+    auto result = resource::detail::load_resource(typeid(T), name, flags);
+    return std::reinterpret_pointer_cast<const T>(result);
+}
+
+template<typename T>
+resource_ptr<T> resource::find(std::string_view name)
+{
+    auto result = resource::detail::find_resource(typeid(T), name);
+    return std::reinterpret_pointer_cast<const T>(result);
+}