Run clang-format across the project

35 files changed, 2268 insertions, 2268 deletions

diff --git a/core/config/boolean.cc b/core/config/boolean.cc
index 45d5a38..5981b6d 100644
--- a/core/config/boolean.cc
+++ b/core/config/boolean.cc
@@ -1,43 +1,43 @@
-#include "core/pch.hh"
-
-#include "core/config/boolean.hh"
-
-config::Boolean::Boolean(bool default_value)
-{
-    m_value = default_value;
-}
-
-void config::Boolean::set(std::string_view value)
-{
-    m_value = from_string(value);
-}
-
-std::string_view config::Boolean::get(void) const
-{
-    return to_string(m_value);
-}
-
-bool config::Boolean::get_value(void) const
-{
-    return m_value;
-}
-
-void config::Boolean::set_value(bool value)
-{
-    m_value = value;
-}
-
-std::string_view config::Boolean::to_string(bool value)
-{
-    if(value) {
-        return "true";
-    }
-    else {
-        return "false";
-    }
-}
-
-bool config::Boolean::from_string(std::string_view value)
-{
-    return value == "true" && value != "false";
-}
+#include "core/pch.hh"

+

+#include "core/config/boolean.hh"

+

+config::Boolean::Boolean(bool default_value)

+{

+    m_value = default_value;

+}

+

+void config::Boolean::set(std::string_view value)

+{

+    m_value = from_string(value);

+}

+

+std::string_view config::Boolean::get(void) const

+{

+    return to_string(m_value);

+}

+

+bool config::Boolean::get_value(void) const

+{

+    return m_value;

+}

+

+void config::Boolean::set_value(bool value)

+{

+    m_value = value;

+}

+

+std::string_view config::Boolean::to_string(bool value)

+{

+    if(value) {

+        return "true";

+    }

+    else {

+        return "false";

+    }

+}

+

+bool config::Boolean::from_string(std::string_view value)

+{

+    return value == "true" && value != "false";

+}

diff --git a/core/config/boolean.hh b/core/config/boolean.hh
index cfd8b0b..f4d3acd 100644
--- a/core/config/boolean.hh
+++ b/core/config/boolean.hh
@@ -1,25 +1,25 @@
-#pragma once
-
-#include "core/config/ivalue.hh"
-
-namespace config
-{
-class Boolean : public IValue {
-public:
-    explicit Boolean(bool default_value = false);
-    virtual ~Boolean(void) = default;
-
-    virtual void set(std::string_view value) override;
-    virtual std::string_view get(void) const override;
-
-    bool get_value(void) const;
-    void set_value(bool value);
-
-private:
-    bool m_value;
-
-public:
-    static std::string_view to_string(bool value);
-    static bool from_string(std::string_view value);
-};
-} // namespace config
+#pragma once

+

+#include "core/config/ivalue.hh"

+

+namespace config

+{

+class Boolean : public IValue {

+public:

+    explicit Boolean(bool default_value = false);

+    virtual ~Boolean(void) = default;

+

+    virtual void set(std::string_view value) override;

+    virtual std::string_view get(void) const override;

+

+    bool get_value(void) const;

+    void set_value(bool value);

+

+private:

+    bool m_value;

+

+public:

+    static std::string_view to_string(bool value);

+    static bool from_string(std::string_view value);

+};

+} // namespace config

diff --git a/core/config/ivalue.hh b/core/config/ivalue.hh
index 13e9a3a..782da76 100644
--- a/core/config/ivalue.hh
+++ b/core/config/ivalue.hh
@@ -1,11 +1,11 @@
-#pragma once
-
-namespace config
-{
-class IValue {
-public:
-    virtual ~IValue(void) = default;
-    virtual void set(std::string_view value) = 0;
-    virtual std::string_view get(void) const = 0;
-};
-} // namespace config
+#pragma once

+

+namespace config

+{

+class IValue {

+public:

+    virtual ~IValue(void) = default;

+    virtual void set(std::string_view value) = 0;

+    virtual std::string_view get(void) const = 0;

+};

+} // namespace config

diff --git a/core/config/number.hh b/core/config/number.hh
index 45d4773..5533459 100644
--- a/core/config/number.hh
+++ b/core/config/number.hh
@@ -1,130 +1,130 @@
-#pragma once
-
-#include "core/config/ivalue.hh"
-
-#include "core/math/concepts.hh"
-
-namespace config
-{
-template<math::Arithmetic T>
-class Number : public IValue {
-public:
-    explicit Number(T default_value = T(0));
-    explicit Number(T default_value, T min_value, T max_value);
-    virtual ~Number(void) = default;
-
-    virtual void set(std::string_view value) override;
-    virtual std::string_view get(void) const override;
-
-    T get_value(void) const;
-    void set_value(T value);
-
-    T get_min_value(void) const;
-    T get_max_value(void) const;
-    void set_limits(T min_value, T max_value);
-
-private:
-    T m_value;
-    T m_min_value;
-    T m_max_value;
-    std::string m_string;
-};
-} // namespace config
-
-namespace config
-{
-class Int final : public Number<int> {
-public:
-    using Number<int>::Number;
-};
-
-class Float final : public Number<float> {
-public:
-    using Number<float>::Number;
-};
-
-class Unsigned final : public Number<unsigned int> {
-public:
-    using Number<unsigned int>::Number;
-};
-
-class Unsigned64 final : public Number<std::uint64_t> {
-public:
-    using Number<std::uint64_t>::Number;
-};
-
-class SizeType final : public Number<std::size_t> {
-public:
-    using Number<std::size_t>::Number;
-};
-} // namespace config
-
-template<math::Arithmetic T>
-inline config::Number<T>::Number(T default_value)
-{
-    m_value = default_value;
-    m_min_value = std::numeric_limits<T>::lowest();
-    m_max_value = std::numeric_limits<T>::max();
-    m_string = std::to_string(default_value);
-}
-
-template<math::Arithmetic T>
-inline config::Number<T>::Number(T default_value, T min_value, T max_value)
-{
-    m_value = default_value;
-    m_min_value = min_value;
-    m_max_value = max_value;
-    m_string = std::to_string(default_value);
-}
-
-template<math::Arithmetic T>
-inline void config::Number<T>::set(std::string_view value)
-{
-    T parsed_value;
-    auto result = std::from_chars(value.data(), value.data() + value.size(), parsed_value);
-
-    if(result.ec == std::errc()) {
-        m_value = std::clamp(parsed_value, m_min_value, m_max_value);
-        m_string = std::to_string(m_value);
-    }
-}
-
-template<math::Arithmetic T>
-inline std::string_view config::Number<T>::get(void) const
-{
-    return m_string;
-}
-
-template<math::Arithmetic T>
-inline T config::Number<T>::get_value(void) const
-{
-    return m_value;
-}
-
-template<math::Arithmetic T>
-inline void config::Number<T>::set_value(T value)
-{
-    m_value = std::clamp(value, m_min_value, m_max_value);
-    m_string = std::to_string(m_value);
-}
-
-template<math::Arithmetic T>
-inline T config::Number<T>::get_min_value(void) const
-{
-    return m_min_value;
-}
-
-template<math::Arithmetic T>
-inline T config::Number<T>::get_max_value(void) const
-{
-    return m_max_value;
-}
-
-template<math::Arithmetic T>
-inline void config::Number<T>::set_limits(T min_value, T max_value)
-{
-    m_min_value = min_value;
-    m_max_value = max_value;
-    m_value = std::clamp(m_value, m_min_value, m_max_value);
-    m_string = std::to_string(m_value);
-}
+#pragma once

+

+#include "core/config/ivalue.hh"

+

+#include "core/math/concepts.hh"

+

+namespace config

+{

+template<math::Arithmetic T>

+class Number : public IValue {

+public:

+    explicit Number(T default_value = T(0));

+    explicit Number(T default_value, T min_value, T max_value);

+    virtual ~Number(void) = default;

+

+    virtual void set(std::string_view value) override;

+    virtual std::string_view get(void) const override;

+

+    T get_value(void) const;

+    void set_value(T value);

+

+    T get_min_value(void) const;

+    T get_max_value(void) const;

+    void set_limits(T min_value, T max_value);

+

+private:

+    T m_value;

+    T m_min_value;

+    T m_max_value;

+    std::string m_string;

+};

+} // namespace config

+

+namespace config

+{

+class Int final : public Number<int> {

+public:

+    using Number<int>::Number;

+};

+

+class Float final : public Number<float> {

+public:

+    using Number<float>::Number;

+};

+

+class Unsigned final : public Number<unsigned int> {

+public:

+    using Number<unsigned int>::Number;

+};

+

+class Unsigned64 final : public Number<std::uint64_t> {

+public:

+    using Number<std::uint64_t>::Number;

+};

+

+class SizeType final : public Number<std::size_t> {

+public:

+    using Number<std::size_t>::Number;

+};

+} // namespace config

+

+template<math::Arithmetic T>

+inline config::Number<T>::Number(T default_value)

+{

+    m_value = default_value;

+    m_min_value = std::numeric_limits<T>::lowest();

+    m_max_value = std::numeric_limits<T>::max();

+    m_string = std::to_string(default_value);

+}

+

+template<math::Arithmetic T>

+inline config::Number<T>::Number(T default_value, T min_value, T max_value)

+{

+    m_value = default_value;

+    m_min_value = min_value;

+    m_max_value = max_value;

+    m_string = std::to_string(default_value);

+}

+

+template<math::Arithmetic T>

+inline void config::Number<T>::set(std::string_view value)

+{

+    T parsed_value;

+    auto result = std::from_chars(value.data(), value.data() + value.size(), parsed_value);

+

+    if(result.ec == std::errc()) {

+        m_value = std::clamp(parsed_value, m_min_value, m_max_value);

+        m_string = std::to_string(m_value);

+    }

+}

+

+template<math::Arithmetic T>

+inline std::string_view config::Number<T>::get(void) const

+{

+    return m_string;

+}

+

+template<math::Arithmetic T>

+inline T config::Number<T>::get_value(void) const

+{

+    return m_value;

+}

+

+template<math::Arithmetic T>

+inline void config::Number<T>::set_value(T value)

+{

+    m_value = std::clamp(value, m_min_value, m_max_value);

+    m_string = std::to_string(m_value);

+}

+

+template<math::Arithmetic T>

+inline T config::Number<T>::get_min_value(void) const

+{

+    return m_min_value;

+}

+

+template<math::Arithmetic T>

+inline T config::Number<T>::get_max_value(void) const

+{

+    return m_max_value;

+}

+

+template<math::Arithmetic T>

+inline void config::Number<T>::set_limits(T min_value, T max_value)

+{

+    m_min_value = min_value;

+    m_max_value = max_value;

+    m_value = std::clamp(m_value, m_min_value, m_max_value);

+    m_string = std::to_string(m_value);

+}

diff --git a/core/config/string.cc b/core/config/string.cc
index 198b448..8fb9d70 100644
--- a/core/config/string.cc
+++ b/core/config/string.cc
@@ -1,18 +1,18 @@
-#include "core/pch.hh"
-
-#include "core/config/string.hh"
-
-config::String::String(std::string_view default_value)
-{
-    m_value = default_value;
-}
-
-void config::String::set(std::string_view value)
-{
-    m_value = value;
-}
-
-std::string_view config::String::get(void) const
-{
-    return m_value;
-}
+#include "core/pch.hh"

+

+#include "core/config/string.hh"

+

+config::String::String(std::string_view default_value)

+{

+    m_value = default_value;

+}

+

+void config::String::set(std::string_view value)

+{

+    m_value = value;

+}

+

+std::string_view config::String::get(void) const

+{

+    return m_value;

+}

diff --git a/core/config/string.hh b/core/config/string.hh
index 8fd3901..d7bbbc1 100644
--- a/core/config/string.hh
+++ b/core/config/string.hh
@@ -1,31 +1,31 @@
-#pragma once
-
-#include "core/config/ivalue.hh"
-
-namespace config
-{
-class String : public IValue {
-public:
-    explicit String(std::string_view default_value);
-    virtual ~String(void) = default;
-
-    virtual void set(std::string_view value) override;
-    virtual std::string_view get(void) const override;
-
-    constexpr const std::string& get_value(void) const noexcept;
-    constexpr const char* c_str(void) const noexcept;
-
-private:
-    std::string m_value;
-};
-} // namespace config
-
-constexpr const std::string& config::String::get_value(void) const noexcept
-{
-    return m_value;
-}
-
-constexpr const char* config::String::c_str(void) const noexcept
-{
-    return m_value.c_str();
-}
+#pragma once

+

+#include "core/config/ivalue.hh"

+

+namespace config

+{

+class String : public IValue {

+public:

+    explicit String(std::string_view default_value);

+    virtual ~String(void) = default;

+

+    virtual void set(std::string_view value) override;

+    virtual std::string_view get(void) const override;

+

+    constexpr const std::string& get_value(void) const noexcept;

+    constexpr const char* c_str(void) const noexcept;

+

+private:

+    std::string m_value;

+};

+} // namespace config

+

+constexpr const std::string& config::String::get_value(void) const noexcept

+{

+    return m_value;

+}

+

+constexpr const char* config::String::c_str(void) const noexcept

+{

+    return m_value.c_str();

+}

diff --git a/core/io/buffer.cc b/core/io/buffer.cc
index 02b810e..d3bf7bb 100644
--- a/core/io/buffer.cc
+++ b/core/io/buffer.cc
@@ -1,345 +1,345 @@
-#include "core/pch.hh"
-
-#include "core/io/buffer.hh"
-
-#include "core/math/constexpr.hh"
-
-io::ReadBuffer::ReadBuffer(const ReadBuffer& other)
-{
-    reset(other.data(), other.size());
-}
-
-io::ReadBuffer::ReadBuffer(const void* data, std::size_t size)
-{
-    assert(data);
-
-    reset(data, size);
-}
-
-io::ReadBuffer::ReadBuffer(const ENetPacket* packet)
-{
-    assert(packet);
-
-    reset(packet);
-}
-
-io::ReadBuffer::ReadBuffer(PHYSFS_File* file)
-{
-    assert(file);
-
-    reset(file);
-}
-
-std::size_t io::ReadBuffer::size(void) const
-{
-    return m_vector.size();
-}
-
-const std::byte* io::ReadBuffer::data(void) const
-{
-    return m_vector.data();
-}
-
-void io::ReadBuffer::reset(const void* data, std::size_t size)
-{
-    assert(data);
-
-    auto bytes = reinterpret_cast<const std::byte*>(data);
-    m_vector.assign(bytes, bytes + size);
-    m_position = 0U;
-}
-
-void io::ReadBuffer::reset(const ENetPacket* packet)
-{
-    assert(packet);
-
-    auto bytes_ptr = reinterpret_cast<const std::byte*>(packet->data);
-    m_vector.assign(bytes_ptr, bytes_ptr + packet->dataLength);
-    m_position = 0;
-}
-
-void io::ReadBuffer::reset(PHYSFS_File* file)
-{
-    assert(file);
-
-    m_vector.resize(PHYSFS_fileLength(file));
-    m_position = 0;
-
-    PHYSFS_seek(file, 0);
-    PHYSFS_readBytes(file, m_vector.data(), m_vector.size());
-}
-
-template<>
-std::byte io::ReadBuffer::read<std::byte>(void)
-{
-    if(m_position < m_vector.size()) {
-        auto result = m_vector[m_position];
-        m_position += 1U;
-        return result;
-    }
-
-    m_position += 1U;
-    return static_cast<std::byte>(0x00);
-}
-
-template<>
-std::uint8_t io::ReadBuffer::read<std::uint8_t>(void)
-{
-    if((m_position + 1U) <= m_vector.size()) {
-        auto result = static_cast<std::uint8_t>(m_vector[m_position]);
-        m_position += 1U;
-        return result;
-    }
-
-    m_position += 1U;
-    return 0;
-}
-
-template<>
-std::uint16_t io::ReadBuffer::read<std::uint16_t>(void)
-{
-    if((m_position + 2U) <= m_vector.size()) {
-        auto result = UINT16_C(0x0000);
-        result |= (UINT16_C(0x00FF) & static_cast<std::uint16_t>(m_vector[m_position + 0U])) << 8U;
-        result |= (UINT16_C(0x00FF) & static_cast<std::uint16_t>(m_vector[m_position + 1U])) << 0U;
-        m_position += 2U;
-        return result;
-    }
-
-    m_position += 2U;
-    return 0;
-}
-
-template<>
-std::uint32_t io::ReadBuffer::read<std::uint32_t>(void)
-{
-    if((m_position + 4U) <= m_vector.size()) {
-        auto result = UINT32_C(0x00000000);
-        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 0U])) << 24U;
-        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 1U])) << 16U;
-        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 2U])) << 8U;
-        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 3U])) << 0U;
-        m_position += 4U;
-        return result;
-    }
-
-    m_position += 4U;
-    return 0;
-}
-
-template<>
-std::uint64_t io::ReadBuffer::read<std::uint64_t>(void)
-{
-    if((m_position + 8U) <= m_vector.size()) {
-        auto result = UINT64_C(0x0000000000000000);
-        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 0U])) << 56U;
-        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 1U])) << 48U;
-        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 2U])) << 40U;
-        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 3U])) << 32U;
-        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 4U])) << 24U;
-        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 5U])) << 16U;
-        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 6U])) << 8U;
-        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 7U])) << 0U;
-        m_position += 8U;
-        return result;
-    }
-
-    m_position += 8U;
-    return 0;
-}
-
-template<>
-float io::ReadBuffer::read<float>(void)
-{
-    return std::bit_cast<float>(read<std::uint32_t>());
-}
-
-template<>
-std::int8_t io::ReadBuffer::read<std::int8_t>(void)
-{
-    return std::bit_cast<std::int8_t>(read<std::uint8_t>());
-}
-
-template<>
-std::int16_t io::ReadBuffer::read<std::int16_t>(void)
-{
-    return std::bit_cast<std::int16_t>(read<std::uint16_t>());
-}
-
-template<>
-std::int32_t io::ReadBuffer::read<std::int32_t>(void)
-{
-    return std::bit_cast<std::int32_t>(read<std::uint32_t>());
-}
-
-template<>
-std::int64_t io::ReadBuffer::read<std::int64_t>(void)
-{
-    return std::bit_cast<std::int64_t>(read<std::uint64_t>());
-}
-
-template<>
-std::string io::ReadBuffer::read<std::string>(void)
-{
-    std::string result;
-    result.resize(read<std::uint16_t>());
-
-    for(std::size_t i = 0; i < result.size(); ++i) {
-        if(m_position < m_vector.size()) {
-            result[i] = static_cast<char>(m_vector[m_position]);
-        }
-
-        m_position += 1U;
-    }
-
-    return result;
-}
-
-void io::ReadBuffer::read(void* buffer, std::size_t size)
-{
-    auto bytes = reinterpret_cast<std::byte*>(buffer);
-    auto amount_to_read = std::min(size, m_vector.size() - m_position);
-
-    if(amount_to_read > 0) {
-        std::copy(m_vector.cbegin() + m_position, m_vector.cbegin() + m_position + amount_to_read, bytes);
-    }
-
-    m_position += size;
-}
-
-io::WriteBuffer::WriteBuffer(const WriteBuffer& other)
-{
-    m_vector = other.m_vector;
-}
-
-std::size_t io::WriteBuffer::size(void) const
-{
-    return m_vector.size();
-}
-
-const std::byte* io::WriteBuffer::data(void) const
-{
-    return m_vector.data();
-}
-
-void io::WriteBuffer::reset(void)
-{
-    m_vector.clear();
-}
-
-void io::WriteBuffer::write(const WriteBuffer& other)
-{
-    m_vector.insert(m_vector.end(), other.m_vector.begin(), other.m_vector.end());
-}
-
-void io::WriteBuffer::write(const void* data, std::size_t size)
-{
-    assert(data);
-
-    auto bytes = reinterpret_cast<const std::byte*>(data);
-    m_vector.insert(m_vector.end(), bytes, bytes + size);
-}
-
-template<>
-void io::WriteBuffer::write<std::byte>(const std::byte value)
-{
-    m_vector.push_back(value);
-}
-
-template<>
-void io::WriteBuffer::write<std::uint8_t>(const std::uint8_t value)
-{
-    m_vector.push_back(static_cast<std::byte>(value));
-}
-
-template<>
-void io::WriteBuffer::write<std::uint16_t>(const std::uint16_t value)
-{
-    m_vector.push_back(static_cast<std::byte>(UINT16_C(0xFF) & ((value & UINT16_C(0xFF00)) >> 8U)));
-    m_vector.push_back(static_cast<std::byte>(UINT16_C(0xFF) & ((value & UINT16_C(0x00FF)) >> 0U)));
-}
-
-template<>
-void io::WriteBuffer::write<std::uint32_t>(const std::uint32_t value)
-{
-    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0xFF000000)) >> 24U)));
-    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x00FF0000)) >> 16U)));
-    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x0000FF00)) >> 8U)));
-    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x000000FF)) >> 0U)));
-}
-
-template<>
-void io::WriteBuffer::write<std::uint64_t>(const std::uint64_t value)
-{
-    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0xFF00000000000000)) >> 56U)));
-    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00FF000000000000)) >> 48U)));
-    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x0000FF0000000000)) >> 40U)));
-    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x000000FF00000000)) >> 32U)));
-    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000FF000000)) >> 24U)));
-    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x0000000000FF0000)) >> 16U)));
-    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x000000000000FF00)) >> 8U)));
-    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000000000FF)) >> 0U)));
-}
-
-template<>
-void io::WriteBuffer::write(const float value)
-{
-    write(std::bit_cast<std::uint32_t>(value));
-}
-
-template<>
-void io::WriteBuffer::write(const std::int8_t value)
-{
-    write(std::bit_cast<std::uint8_t>(value));
-}
-
-template<>
-void io::WriteBuffer::write(const std::int16_t value)
-{
-    write(std::bit_cast<std::uint16_t>(value));
-}
-
-template<>
-void io::WriteBuffer::write(const std::int32_t value)
-{
-    write(std::bit_cast<std::uint32_t>(value));
-}
-
-template<>
-void io::WriteBuffer::write(const std::int64_t value)
-{
-    write(std::bit_cast<std::uint64_t>(value));
-}
-
-template<>
-void io::WriteBuffer::write<std::string_view>(const std::string_view value)
-{
-    write<std::uint16_t>(value.size());
-
-    for(const auto& character : value) {
-        m_vector.push_back(static_cast<std::byte>(character));
-    }
-}
-
-PHYSFS_File* io::WriteBuffer::to_file(const std::string& path, bool append) const
-{
-    PHYSFS_File* file = nullptr;
-
-    if(append) {
-        file = PHYSFS_openAppend(path.c_str());
-    }
-    else {
-        file = PHYSFS_openWrite(path.c_str());
-    }
-
-    if(file) {
-        PHYSFS_writeBytes(file, m_vector.data(), m_vector.size());
-    }
-
-    return file;
-}
-
-ENetPacket* io::WriteBuffer::to_packet(enet_uint32 flags) const
-{
-    return enet_packet_create(m_vector.data(), m_vector.size(), flags);
-}
+#include "core/pch.hh"

+

+#include "core/io/buffer.hh"

+

+#include "core/math/constexpr.hh"

+

+io::ReadBuffer::ReadBuffer(const ReadBuffer& other)

+{

+    reset(other.data(), other.size());

+}

+

+io::ReadBuffer::ReadBuffer(const void* data, std::size_t size)

+{

+    assert(data);

+

+    reset(data, size);

+}

+

+io::ReadBuffer::ReadBuffer(const ENetPacket* packet)

+{

+    assert(packet);

+

+    reset(packet);

+}

+

+io::ReadBuffer::ReadBuffer(PHYSFS_File* file)

+{

+    assert(file);

+

+    reset(file);

+}

+

+std::size_t io::ReadBuffer::size(void) const

+{

+    return m_vector.size();

+}

+

+const std::byte* io::ReadBuffer::data(void) const

+{

+    return m_vector.data();

+}

+

+void io::ReadBuffer::reset(const void* data, std::size_t size)

+{

+    assert(data);

+

+    auto bytes = reinterpret_cast<const std::byte*>(data);

+    m_vector.assign(bytes, bytes + size);

+    m_position = 0U;

+}

+

+void io::ReadBuffer::reset(const ENetPacket* packet)

+{

+    assert(packet);

+

+    auto bytes_ptr = reinterpret_cast<const std::byte*>(packet->data);

+    m_vector.assign(bytes_ptr, bytes_ptr + packet->dataLength);

+    m_position = 0;

+}

+

+void io::ReadBuffer::reset(PHYSFS_File* file)

+{

+    assert(file);

+

+    m_vector.resize(PHYSFS_fileLength(file));

+    m_position = 0;

+

+    PHYSFS_seek(file, 0);

+    PHYSFS_readBytes(file, m_vector.data(), m_vector.size());

+}

+

+template<>

+std::byte io::ReadBuffer::read<std::byte>(void)

+{

+    if(m_position < m_vector.size()) {

+        auto result = m_vector[m_position];

+        m_position += 1U;

+        return result;

+    }

+

+    m_position += 1U;

+    return static_cast<std::byte>(0x00);

+}

+

+template<>

+std::uint8_t io::ReadBuffer::read<std::uint8_t>(void)

+{

+    if((m_position + 1U) <= m_vector.size()) {

+        auto result = static_cast<std::uint8_t>(m_vector[m_position]);

+        m_position += 1U;

+        return result;

+    }

+

+    m_position += 1U;

+    return 0;

+}

+

+template<>

+std::uint16_t io::ReadBuffer::read<std::uint16_t>(void)

+{

+    if((m_position + 2U) <= m_vector.size()) {

+        auto result = UINT16_C(0x0000);

+        result |= (UINT16_C(0x00FF) & static_cast<std::uint16_t>(m_vector[m_position + 0U])) << 8U;

+        result |= (UINT16_C(0x00FF) & static_cast<std::uint16_t>(m_vector[m_position + 1U])) << 0U;

+        m_position += 2U;

+        return result;

+    }

+

+    m_position += 2U;

+    return 0;

+}

+

+template<>

+std::uint32_t io::ReadBuffer::read<std::uint32_t>(void)

+{

+    if((m_position + 4U) <= m_vector.size()) {

+        auto result = UINT32_C(0x00000000);

+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 0U])) << 24U;

+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 1U])) << 16U;

+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 2U])) << 8U;

+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 3U])) << 0U;

+        m_position += 4U;

+        return result;

+    }

+

+    m_position += 4U;

+    return 0;

+}

+

+template<>

+std::uint64_t io::ReadBuffer::read<std::uint64_t>(void)

+{

+    if((m_position + 8U) <= m_vector.size()) {

+        auto result = UINT64_C(0x0000000000000000);

+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 0U])) << 56U;

+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 1U])) << 48U;

+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 2U])) << 40U;

+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 3U])) << 32U;

+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 4U])) << 24U;

+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 5U])) << 16U;

+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 6U])) << 8U;

+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 7U])) << 0U;

+        m_position += 8U;

+        return result;

+    }

+

+    m_position += 8U;

+    return 0;

+}

+

+template<>

+float io::ReadBuffer::read<float>(void)

+{

+    return std::bit_cast<float>(read<std::uint32_t>());

+}

+

+template<>

+std::int8_t io::ReadBuffer::read<std::int8_t>(void)

+{

+    return std::bit_cast<std::int8_t>(read<std::uint8_t>());

+}

+

+template<>

+std::int16_t io::ReadBuffer::read<std::int16_t>(void)

+{

+    return std::bit_cast<std::int16_t>(read<std::uint16_t>());

+}

+

+template<>

+std::int32_t io::ReadBuffer::read<std::int32_t>(void)

+{

+    return std::bit_cast<std::int32_t>(read<std::uint32_t>());

+}

+

+template<>

+std::int64_t io::ReadBuffer::read<std::int64_t>(void)

+{

+    return std::bit_cast<std::int64_t>(read<std::uint64_t>());

+}

+

+template<>

+std::string io::ReadBuffer::read<std::string>(void)

+{

+    std::string result;

+    result.resize(read<std::uint16_t>());

+

+    for(std::size_t i = 0; i < result.size(); ++i) {

+        if(m_position < m_vector.size()) {

+            result[i] = static_cast<char>(m_vector[m_position]);

+        }

+

+        m_position += 1U;

+    }

+

+    return result;

+}

+

+void io::ReadBuffer::read(void* buffer, std::size_t size)

+{

+    auto bytes = reinterpret_cast<std::byte*>(buffer);

+    auto amount_to_read = std::min(size, m_vector.size() - m_position);

+

+    if(amount_to_read > 0) {

+        std::copy(m_vector.cbegin() + m_position, m_vector.cbegin() + m_position + amount_to_read, bytes);

+    }

+

+    m_position += size;

+}

+

+io::WriteBuffer::WriteBuffer(const WriteBuffer& other)

+{

+    m_vector = other.m_vector;

+}

+

+std::size_t io::WriteBuffer::size(void) const

+{

+    return m_vector.size();

+}

+

+const std::byte* io::WriteBuffer::data(void) const

+{

+    return m_vector.data();

+}

+

+void io::WriteBuffer::reset(void)

+{

+    m_vector.clear();

+}

+

+void io::WriteBuffer::write(const WriteBuffer& other)

+{

+    m_vector.insert(m_vector.end(), other.m_vector.begin(), other.m_vector.end());

+}

+

+void io::WriteBuffer::write(const void* data, std::size_t size)

+{

+    assert(data);

+

+    auto bytes = reinterpret_cast<const std::byte*>(data);

+    m_vector.insert(m_vector.end(), bytes, bytes + size);

+}

+

+template<>

+void io::WriteBuffer::write<std::byte>(const std::byte value)

+{

+    m_vector.push_back(value);

+}

+

+template<>

+void io::WriteBuffer::write<std::uint8_t>(const std::uint8_t value)

+{

+    m_vector.push_back(static_cast<std::byte>(value));

+}

+

+template<>

+void io::WriteBuffer::write<std::uint16_t>(const std::uint16_t value)

+{

+    m_vector.push_back(static_cast<std::byte>(UINT16_C(0xFF) & ((value & UINT16_C(0xFF00)) >> 8U)));

+    m_vector.push_back(static_cast<std::byte>(UINT16_C(0xFF) & ((value & UINT16_C(0x00FF)) >> 0U)));

+}

+

+template<>

+void io::WriteBuffer::write<std::uint32_t>(const std::uint32_t value)

+{

+    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0xFF000000)) >> 24U)));

+    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x00FF0000)) >> 16U)));

+    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x0000FF00)) >> 8U)));

+    m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x000000FF)) >> 0U)));

+}

+

+template<>

+void io::WriteBuffer::write<std::uint64_t>(const std::uint64_t value)

+{

+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0xFF00000000000000)) >> 56U)));

+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00FF000000000000)) >> 48U)));

+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x0000FF0000000000)) >> 40U)));

+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x000000FF00000000)) >> 32U)));

+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000FF000000)) >> 24U)));

+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x0000000000FF0000)) >> 16U)));

+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x000000000000FF00)) >> 8U)));

+    m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000000000FF)) >> 0U)));

+}

+

+template<>

+void io::WriteBuffer::write(const float value)

+{

+    write(std::bit_cast<std::uint32_t>(value));

+}

+

+template<>

+void io::WriteBuffer::write(const std::int8_t value)

+{

+    write(std::bit_cast<std::uint8_t>(value));

+}

+

+template<>

+void io::WriteBuffer::write(const std::int16_t value)

+{

+    write(std::bit_cast<std::uint16_t>(value));

+}

+

+template<>

+void io::WriteBuffer::write(const std::int32_t value)

+{

+    write(std::bit_cast<std::uint32_t>(value));

+}

+

+template<>

+void io::WriteBuffer::write(const std::int64_t value)

+{

+    write(std::bit_cast<std::uint64_t>(value));

+}

+

+template<>

+void io::WriteBuffer::write<std::string_view>(const std::string_view value)

+{

+    write<std::uint16_t>(value.size());

+

+    for(const auto& character : value) {

+        m_vector.push_back(static_cast<std::byte>(character));

+    }

+}

+

+PHYSFS_File* io::WriteBuffer::to_file(const std::string& path, bool append) const

+{

+    PHYSFS_File* file = nullptr;

+

+    if(append) {

+        file = PHYSFS_openAppend(path.c_str());

+    }

+    else {

+        file = PHYSFS_openWrite(path.c_str());

+    }

+

+    if(file) {

+        PHYSFS_writeBytes(file, m_vector.data(), m_vector.size());

+    }

+

+    return file;

+}

+

+ENetPacket* io::WriteBuffer::to_packet(enet_uint32 flags) const

+{

+    return enet_packet_create(m_vector.data(), m_vector.size(), flags);

+}

diff --git a/core/io/buffer.hh b/core/io/buffer.hh
index 96a37b1..5f1ab66 100644
--- a/core/io/buffer.hh
+++ b/core/io/buffer.hh
@@ -1,88 +1,88 @@
-namespace io
-{
-class ReadBuffer final {
-public:
-    ReadBuffer(void) = default;
-    explicit ReadBuffer(const ReadBuffer& other);
-    explicit ReadBuffer(const void* data, std::size_t size);
-    explicit ReadBuffer(const ENetPacket* packet);
-    explicit ReadBuffer(PHYSFS_File* file);
-    virtual ~ReadBuffer(void) = default;
-
-    std::size_t size(void) const;
-    const std::byte* data(void) const;
-
-    void reset(const void* data, std::size_t size);
-    void reset(const ENetPacket* packet);
-    void reset(PHYSFS_File* file);
-
-    constexpr void rewind(void);
-    constexpr bool is_ended(void) const;
-
-    void read(void* buffer, std::size_t size);
-
-    template<typename T>
-    T read(void);
-
-    template<typename T>
-    ReadBuffer& operator>>(T& value);
-
-private:
-    std::vector<std::byte> m_vector;
-    std::size_t m_position;
-};
-} // namespace io
-
-namespace io
-{
-class WriteBuffer final {
-public:
-    WriteBuffer(void) = default;
-    explicit WriteBuffer(const WriteBuffer& other);
-    virtual ~WriteBuffer(void) = default;
-
-    std::size_t size(void) const;
-    const std::byte* data(void) const;
-
-    void reset(void);
-
-    void write(const WriteBuffer& other);
-    void write(const void* data, std::size_t size);
-
-    template<typename T>
-    void write(const T value);
-
-    template<typename T>
-    WriteBuffer& operator<<(const T value);
-
-    PHYSFS_File* to_file(const std::string& path, bool append = false) const;
-    ENetPacket* to_packet(enet_uint32 flags = ENET_PACKET_FLAG_RELIABLE) const;
-
-private:
-    std::vector<std::byte> m_vector;
-};
-} // namespace io
-
-constexpr void io::ReadBuffer::rewind(void)
-{
-    m_position = 0;
-}
-
-constexpr bool io::ReadBuffer::is_ended(void) const
-{
-    return m_position >= m_vector.size();
-}
-
-template<typename T>
-io::ReadBuffer& io::ReadBuffer::operator>>(T& value)
-{
-    value = read<T>();
-    return *this;
-}
-
-template<typename T>
-io::WriteBuffer& io::WriteBuffer::operator<<(const T value)
-{
-    write<T>(value);
-    return *this;
-}
+namespace io

+{

+class ReadBuffer final {

+public:

+    ReadBuffer(void) = default;

+    explicit ReadBuffer(const ReadBuffer& other);

+    explicit ReadBuffer(const void* data, std::size_t size);

+    explicit ReadBuffer(const ENetPacket* packet);

+    explicit ReadBuffer(PHYSFS_File* file);

+    virtual ~ReadBuffer(void) = default;

+

+    std::size_t size(void) const;

+    const std::byte* data(void) const;

+

+    void reset(const void* data, std::size_t size);

+    void reset(const ENetPacket* packet);

+    void reset(PHYSFS_File* file);

+

+    constexpr void rewind(void);

+    constexpr bool is_ended(void) const;

+

+    void read(void* buffer, std::size_t size);

+

+    template<typename T>

+    T read(void);

+

+    template<typename T>

+    ReadBuffer& operator>>(T& value);

+

+private:

+    std::vector<std::byte> m_vector;

+    std::size_t m_position;

+};

+} // namespace io

+

+namespace io

+{

+class WriteBuffer final {

+public:

+    WriteBuffer(void) = default;

+    explicit WriteBuffer(const WriteBuffer& other);

+    virtual ~WriteBuffer(void) = default;

+

+    std::size_t size(void) const;

+    const std::byte* data(void) const;

+

+    void reset(void);

+

+    void write(const WriteBuffer& other);

+    void write(const void* data, std::size_t size);

+

+    template<typename T>

+    void write(const T value);

+

+    template<typename T>

+    WriteBuffer& operator<<(const T value);

+

+    PHYSFS_File* to_file(const std::string& path, bool append = false) const;

+    ENetPacket* to_packet(enet_uint32 flags = ENET_PACKET_FLAG_RELIABLE) const;

+

+private:

+    std::vector<std::byte> m_vector;

+};

+} // namespace io

+

+constexpr void io::ReadBuffer::rewind(void)

+{

+    m_position = 0;

+}

+

+constexpr bool io::ReadBuffer::is_ended(void) const

+{

+    return m_position >= m_vector.size();

+}

+

+template<typename T>

+io::ReadBuffer& io::ReadBuffer::operator>>(T& value)

+{

+    value = read<T>();

+    return *this;

+}

+

+template<typename T>

+io::WriteBuffer& io::WriteBuffer::operator<<(const T value)

+{

+    write<T>(value);

+    return *this;

+}

diff --git a/core/io/cmdline.cc b/core/io/cmdline.cc
index 7a00f37..a876ace 100644
--- a/core/io/cmdline.cc
+++ b/core/io/cmdline.cc
@@ -1,95 +1,95 @@
-#include "core/pch.hh"
-
-#include "core/io/cmdline.hh"
-
-// Valid options always start with OPTION_PREFIX, can contain
-// a bunch of OPTION_PREFIX'es inside and never end with one
-constexpr static char OPTION_PREFIX = '-';
-
-static std::unordered_map<std::string, std::string> options;
-
-static inline bool is_option_string(const std::string& string)
-{
-    if(string.find_last_of(OPTION_PREFIX) >= (string.size() - 1)) {
-        return false;
-    }
-
-    return string[0] == OPTION_PREFIX;
-}
-
-static inline std::string get_option(const std::string& string)
-{
-    std::size_t i;
-    for(i = 0; string[i] == OPTION_PREFIX; ++i) {
-        // empty
-    }
-
-    return std::string(string.cbegin() + i, string.cend());
-}
-
-void io::cmdline::create(int argc, char** argv)
-{
-    for(int idx = 1; idx < argc; ++idx) {
-        std::string string = argv[idx];
-
-        if(!is_option_string(string)) {
-            spdlog::warn("cmdline: non-argument at {}: {}", idx, string);
-            continue;
-        }
-
-        auto option_string = get_option(string);
-        auto next_idx = idx + 1;
-
-        if(next_idx < argc) {
-            std::string argument = argv[next_idx];
-
-            if(!is_option_string(argument)) {
-                options.insert_or_assign(option_string, argument);
-                idx = next_idx;
-                continue;
-            }
-        }
-
-        // The option is either last or has no
-        // argument (happens when there is a valid
-        // option right next to the one we're parsing)
-        options.insert_or_assign(option_string, std::string());
-    }
-}
-
-void io::cmdline::insert(std::string_view option)
-{
-    options.insert_or_assign(std::string(option), std::string());
-}
-
-void io::cmdline::insert(std::string_view option, std::string_view argument)
-{
-    options.insert_or_assign(std::string(option), std::string(argument));
-}
-
-std::string_view io::cmdline::get(std::string_view option, std::string_view fallback)
-{
-    auto it = options.find(std::string(option));
-
-    if(it == options.cend()) {
-        return fallback;
-    }
-
-    return it->second;
-}
-
-const char* io::cmdline::get_cstr(std::string_view option, const char* fallback)
-{
-    auto it = options.find(std::string(option));
-
-    if(it == options.cend()) {
-        return fallback;
-    }
-
-    return it->second.c_str();
-}
-
-bool io::cmdline::contains(std::string_view option)
-{
-    return options.count(std::string(option));
-}
+#include "core/pch.hh"

+

+#include "core/io/cmdline.hh"

+

+// Valid options always start with OPTION_PREFIX, can contain

+// a bunch of OPTION_PREFIX'es inside and never end with one

+constexpr static char OPTION_PREFIX = '-';

+

+static std::unordered_map<std::string, std::string> options;

+

+static inline bool is_option_string(const std::string& string)

+{

+    if(string.find_last_of(OPTION_PREFIX) >= (string.size() - 1)) {

+        return false;

+    }

+

+    return string[0] == OPTION_PREFIX;

+}

+

+static inline std::string get_option(const std::string& string)

+{

+    std::size_t i;

+    for(i = 0; string[i] == OPTION_PREFIX; ++i) {

+        // empty

+    }

+

+    return std::string(string.cbegin() + i, string.cend());

+}

+

+void io::cmdline::create(int argc, char** argv)

+{

+    for(int idx = 1; idx < argc; ++idx) {

+        std::string string = argv[idx];

+

+        if(!is_option_string(string)) {

+            spdlog::warn("cmdline: non-argument at {}: {}", idx, string);

+            continue;

+        }

+

+        auto option_string = get_option(string);

+        auto next_idx = idx + 1;

+

+        if(next_idx < argc) {

+            std::string argument = argv[next_idx];

+

+            if(!is_option_string(argument)) {

+                options.insert_or_assign(option_string, argument);

+                idx = next_idx;

+                continue;

+            }

+        }

+

+        // The option is either last or has no

+        // argument (happens when there is a valid

+        // option right next to the one we're parsing)

+        options.insert_or_assign(option_string, std::string());

+    }

+}

+

+void io::cmdline::insert(std::string_view option)

+{

+    options.insert_or_assign(std::string(option), std::string());

+}

+

+void io::cmdline::insert(std::string_view option, std::string_view argument)

+{

+    options.insert_or_assign(std::string(option), std::string(argument));

+}

+

+std::string_view io::cmdline::get(std::string_view option, std::string_view fallback)

+{

+    auto it = options.find(std::string(option));

+

+    if(it == options.cend()) {

+        return fallback;

+    }

+

+    return it->second;

+}

+

+const char* io::cmdline::get_cstr(std::string_view option, const char* fallback)

+{

+    auto it = options.find(std::string(option));

+

+    if(it == options.cend()) {

+        return fallback;

+    }

+

+    return it->second.c_str();

+}

+

+bool io::cmdline::contains(std::string_view option)

+{

+    return options.count(std::string(option));

+}

diff --git a/core/io/cmdline.hh b/core/io/cmdline.hh
index e90433c..6e2ab9a 100644
--- a/core/io/cmdline.hh
+++ b/core/io/cmdline.hh
@@ -1,11 +1,11 @@
-#pragma once
-
-namespace io::cmdline
-{
-void create(int argc, char** argv);
-void insert(std::string_view option);
-void insert(std::string_view option, std::string_view argument);
-std::string_view get(std::string_view option, std::string_view fallback = "");
-const char* get_cstr(std::string_view option, const char* fallback = nullptr);
-bool contains(std::string_view option);
-} // namespace io::cmdline
+#pragma once

+

+namespace io::cmdline

+{

+void create(int argc, char** argv);

+void insert(std::string_view option);

+void insert(std::string_view option, std::string_view argument);

+std::string_view get(std::string_view option, std::string_view fallback = "");

+const char* get_cstr(std::string_view option, const char* fallback = nullptr);

+bool contains(std::string_view option);

+} // namespace io::cmdline

diff --git a/core/io/config_map.cc b/core/io/config_map.cc
index d22913e..24206f2 100644
--- a/core/io/config_map.cc
+++ b/core/io/config_map.cc
@@ -1,136 +1,136 @@
-#include "core/pch.hh"
-
-#include "core/io/config_map.hh"
-
-#include "core/config/ivalue.hh"
-
-#include "core/io/cmdline.hh"
-
-#include "core/utils/string.hh"
-
-#include "core/version.hh"
-
-void io::ConfigMap::load_cmdline(void)
-{
-    for(auto it : m_values) {
-        if(auto value = io::cmdline::get_cstr(it.first.c_str())) {
-            it.second->set(value);
-        }
-    }
-}
-
-bool io::ConfigMap::load_file(std::string_view path)
-{
-    if(auto file = PHYSFS_openRead(std::string(path).c_str())) {
-        auto source = std::string(PHYSFS_fileLength(file), char(0x00));
-        PHYSFS_readBytes(file, source.data(), source.size());
-        PHYSFS_close(file);
-
-        std::string line;
-        std::string kv_string;
-        std::istringstream stream(source);
-
-        while(std::getline(stream, line)) {
-            auto comment = line.find_first_of('#');
-
-            if(comment == std::string::npos) {
-                kv_string = utils::trim_whitespace(line);
-            }
-            else {
-                kv_string = utils::trim_whitespace(line.substr(0, comment));
-            }
-
-            if(utils::is_whitespace(kv_string)) {
-                // Ignore empty or commented out lines
-                continue;
-            }
-
-            auto separator = kv_string.find('=');
-
-            if(separator == std::string::npos) {
-                spdlog::warn("config: {}: invalid line: {}", path, line);
-                continue;
-            }
-
-            auto kv_name = utils::trim_whitespace(kv_string.substr(0, separator));
-            auto kv_value = utils::trim_whitespace(kv_string.substr(separator + 1));
-
-            auto kv_pair = m_values.find(kv_name);
-
-            if(kv_pair == m_values.cend()) {
-                spdlog::warn("config: {}: unknown key: {}", path, kv_name);
-                continue;
-            }
-
-            kv_pair->second->set(kv_value.c_str());
-        }
-
-        return true;
-    }
-
-    return false;
-}
-
-bool io::ConfigMap::save_file(std::string_view path) const
-{
-    std::ostringstream stream;
-
-    auto curtime = std::time(nullptr);
-
-    stream << "# Voxelius " << version::semver << " configuration file" << std::endl;
-    stream << "# Generated at: " << std::put_time(std::gmtime(&curtime), "%Y-%m-%d %H:%M:%S %z") << std::endl << std::endl;
-
-    for(const auto& it : m_values) {
-        stream << it.first << "=";
-        stream << it.second->get();
-        stream << std::endl;
-    }
-
-    if(auto file = PHYSFS_openWrite(std::string(path).c_str())) {
-        auto source = stream.str();
-        PHYSFS_writeBytes(file, source.data(), source.size());
-        PHYSFS_close(file);
-        return true;
-    }
-
-    return false;
-}
-
-bool io::ConfigMap::set_value(std::string_view name, std::string_view value)
-{
-    auto kv_pair = m_values.find(std::string(name));
-
-    if(kv_pair != m_values.cend()) {
-        kv_pair->second->set(value);
-        return true;
-    }
-
-    return false;
-}
-
-std::string_view io::ConfigMap::get_value(std::string_view name) const
-{
-    auto kv_pair = m_values.find(std::string(name));
-    if(kv_pair != m_values.cend()) {
-        return kv_pair->second->get();
-    }
-
-    return std::string_view();
-}
-
-void io::ConfigMap::add_value(std::string_view name, config::IValue& vref)
-{
-    m_values.insert_or_assign(std::string(name), &vref);
-}
-
-const config::IValue* io::ConfigMap::find(std::string_view name) const
-{
-    auto kv_pair = m_values.find(std::string(name));
-
-    if(kv_pair != m_values.cend()) {
-        return kv_pair->second;
-    }
-    else {
-        return nullptr;
-    }
-}
+#include "core/pch.hh"

+

+#include "core/io/config_map.hh"

+

+#include "core/config/ivalue.hh"

+

+#include "core/io/cmdline.hh"

+

+#include "core/utils/string.hh"

+

+#include "core/version.hh"

+

+void io::ConfigMap::load_cmdline(void)

+{

+    for(auto it : m_values) {

+        if(auto value = io::cmdline::get_cstr(it.first.c_str())) {

+            it.second->set(value);

+        }

+    }

+}

+

+bool io::ConfigMap::load_file(std::string_view path)

+{

+    if(auto file = PHYSFS_openRead(std::string(path).c_str())) {

+        auto source = std::string(PHYSFS_fileLength(file), char(0x00));

+        PHYSFS_readBytes(file, source.data(), source.size());

+        PHYSFS_close(file);

+

+        std::string line;

+        std::string kv_string;

+        std::istringstream stream(source);

+

+        while(std::getline(stream, line)) {

+            auto comment = line.find_first_of('#');

+

+            if(comment == std::string::npos) {

+                kv_string = utils::trim_whitespace(line);

+            }

+            else {

+                kv_string = utils::trim_whitespace(line.substr(0, comment));

+            }

+

+            if(utils::is_whitespace(kv_string)) {

+                // Ignore empty or commented out lines

+                continue;

+            }

+

+            auto separator = kv_string.find('=');

+

+            if(separator == std::string::npos) {

+                spdlog::warn("config: {}: invalid line: {}", path, line);

+                continue;

+            }

+

+            auto kv_name = utils::trim_whitespace(kv_string.substr(0, separator));

+            auto kv_value = utils::trim_whitespace(kv_string.substr(separator + 1));

+

+            auto kv_pair = m_values.find(kv_name);

+

+            if(kv_pair == m_values.cend()) {

+                spdlog::warn("config: {}: unknown key: {}", path, kv_name);

+                continue;

+            }

+

+            kv_pair->second->set(kv_value.c_str());

+        }

+

+        return true;

+    }

+

+    return false;

+}

+

+bool io::ConfigMap::save_file(std::string_view path) const

+{

+    std::ostringstream stream;

+

+    auto curtime = std::time(nullptr);

+

+    stream << "# Voxelius " << version::semver << " configuration file" << std::endl;

+    stream << "# Generated at: " << std::put_time(std::gmtime(&curtime), "%Y-%m-%d %H:%M:%S %z") << std::endl << std::endl;

+

+    for(const auto& it : m_values) {

+        stream << it.first << "=";

+        stream << it.second->get();

+        stream << std::endl;

+    }

+

+    if(auto file = PHYSFS_openWrite(std::string(path).c_str())) {

+        auto source = stream.str();

+        PHYSFS_writeBytes(file, source.data(), source.size());

+        PHYSFS_close(file);

+        return true;

+    }

+

+    return false;

+}

+

+bool io::ConfigMap::set_value(std::string_view name, std::string_view value)

+{

+    auto kv_pair = m_values.find(std::string(name));

+

+    if(kv_pair != m_values.cend()) {

+        kv_pair->second->set(value);

+        return true;

+    }

+

+    return false;

+}

+

+std::string_view io::ConfigMap::get_value(std::string_view name) const

+{

+    auto kv_pair = m_values.find(std::string(name));

+    if(kv_pair != m_values.cend()) {

+        return kv_pair->second->get();

+    }

+

+    return std::string_view();

+}

+

+void io::ConfigMap::add_value(std::string_view name, config::IValue& vref)

+{

+    m_values.insert_or_assign(std::string(name), &vref);

+}

+

+const config::IValue* io::ConfigMap::find(std::string_view name) const

+{

+    auto kv_pair = m_values.find(std::string(name));

+

+    if(kv_pair != m_values.cend()) {

+        return kv_pair->second;

+    }

+    else {

+        return nullptr;

+    }

+}

diff --git a/core/io/config_map.hh b/core/io/config_map.hh
index b0cd579..6b99564 100644
--- a/core/io/config_map.hh
+++ b/core/io/config_map.hh
@@ -1,29 +1,29 @@
-#pragma once
-
-namespace config
-{
-class IValue;
-} // namespace config
-
-namespace io
-{
-class ConfigMap final {
-public:
-    ConfigMap(void) = default;
-    virtual ~ConfigMap(void) = default;
-
-    void load_cmdline(void);
-    bool load_file(std::string_view path);
-    bool save_file(std::string_view path) const;
-
-    bool set_value(std::string_view name, std::string_view value);
-    std::string_view get_value(std::string_view name) const;
-
-    void add_value(std::string_view name, config::IValue& vref);
-
-    const config::IValue* find(std::string_view name) const;
-
-private:
-    std::unordered_map<std::string, config::IValue*> m_values;
-};
-} // namespace io
+#pragma once

+

+namespace config

+{

+class IValue;

+} // namespace config

+

+namespace io

+{

+class ConfigMap final {

+public:

+    ConfigMap(void) = default;

+    virtual ~ConfigMap(void) = default;

+

+    void load_cmdline(void);

+    bool load_file(std::string_view path);

+    bool save_file(std::string_view path) const;

+

+    bool set_value(std::string_view name, std::string_view value);

+    std::string_view get_value(std::string_view name) const;

+

+    void add_value(std::string_view name, config::IValue& vref);

+

+    const config::IValue* find(std::string_view name) const;

+

+private:

+    std::unordered_map<std::string, config::IValue*> m_values;

+};

+} // namespace io

diff --git a/core/math/aabb.cc b/core/math/aabb.cc
index f5c7e14..1111149 100644
--- a/core/math/aabb.cc
+++ b/core/math/aabb.cc
@@ -1,59 +1,59 @@
-#include "core/pch.hh"
-
-#include "core/math/aabb.hh"
-
-math::AABB::AABB(const glm::fvec3& min, const glm::fvec3& max)
-{
-    set_bounds(min, max);
-}
-
-void math::AABB::set_bounds(const glm::fvec3& min, const glm::fvec3& max)
-{
-    this->min = min;
-    this->max = max;
-}
-
-void math::AABB::set_offset(const glm::fvec3& base, const glm::fvec3& size)
-{
-    this->min = base;
-    this->max = base + size;
-}
-
-bool math::AABB::contains(const glm::fvec3& point) const
-{
-    auto result = true;
-    result = result && (point.x >= min.x) && (point.x <= max.x);
-    result = result && (point.y >= min.y) && (point.y <= max.y);
-    result = result && (point.z >= min.z) && (point.z <= max.z);
-    return result;
-}
-
-bool math::AABB::intersect(const AABB& other_box) const
-{
-    auto result = true;
-    result = result && (min.x < other_box.max.x) && (max.x > other_box.min.x);
-    result = result && (min.y < other_box.max.y) && (max.y > other_box.min.y);
-    result = result && (min.z < other_box.max.z) && (max.z > other_box.min.z);
-    return result;
-}
-
-math::AABB math::AABB::combine_with(const math::AABB& other_box) const
-{
-    AABB result;
-    result.set_bounds(min, other_box.max);
-    return result;
-}
-
-math::AABB math::AABB::multiply_with(const math::AABB& other_box) const
-{
-    AABB result;
-    result.set_bounds(other_box.min, max);
-    return result;
-}
-
-math::AABB math::AABB::push(const glm::fvec3& vector) const
-{
-    AABB result;
-    result.set_bounds(min + vector, max + vector);
-    return result;
-}
+#include "core/pch.hh"

+

+#include "core/math/aabb.hh"

+

+math::AABB::AABB(const glm::fvec3& min, const glm::fvec3& max)

+{

+    set_bounds(min, max);

+}

+

+void math::AABB::set_bounds(const glm::fvec3& min, const glm::fvec3& max)

+{

+    this->min = min;

+    this->max = max;

+}

+

+void math::AABB::set_offset(const glm::fvec3& base, const glm::fvec3& size)

+{

+    this->min = base;

+    this->max = base + size;

+}

+

+bool math::AABB::contains(const glm::fvec3& point) const

+{

+    auto result = true;

+    result = result && (point.x >= min.x) && (point.x <= max.x);

+    result = result && (point.y >= min.y) && (point.y <= max.y);

+    result = result && (point.z >= min.z) && (point.z <= max.z);

+    return result;

+}

+

+bool math::AABB::intersect(const AABB& other_box) const

+{

+    auto result = true;

+    result = result && (min.x < other_box.max.x) && (max.x > other_box.min.x);

+    result = result && (min.y < other_box.max.y) && (max.y > other_box.min.y);

+    result = result && (min.z < other_box.max.z) && (max.z > other_box.min.z);

+    return result;

+}

+

+math::AABB math::AABB::combine_with(const math::AABB& other_box) const

+{

+    AABB result;

+    result.set_bounds(min, other_box.max);

+    return result;

+}

+

+math::AABB math::AABB::multiply_with(const math::AABB& other_box) const

+{

+    AABB result;

+    result.set_bounds(other_box.min, max);

+    return result;

+}

+

+math::AABB math::AABB::push(const glm::fvec3& vector) const

+{

+    AABB result;

+    result.set_bounds(min + vector, max + vector);

+    return result;

+}

diff --git a/core/math/aabb.hh b/core/math/aabb.hh
index b843cd9..bff8e04 100644
--- a/core/math/aabb.hh
+++ b/core/math/aabb.hh
@@ -1,28 +1,28 @@
-#pragma once
-
-namespace math
-{
-class AABB final {
-public:
-    AABB(void) = default;
-    explicit AABB(const glm::fvec3& min, const glm::fvec3& max);
-    virtual ~AABB(void) = default;
-
-    void set_bounds(const glm::fvec3& min, const glm::fvec3& max);
-    void set_offset(const glm::fvec3& base, const glm::fvec3& size);
-
-    const glm::fvec3& get_min(void) const;
-    const glm::fvec3& get_max(void) const;
-
-    bool contains(const glm::fvec3& point) const;
-    bool intersect(const AABB& other_box) const;
-
-    AABB combine_with(const AABB& other_box) const;
-    AABB multiply_with(const AABB& other_box) const;
-    AABB push(const glm::fvec3& vector) const;
-
-public:
-    glm::fvec3 min;
-    glm::fvec3 max;
-};
-} // namespace math
+#pragma once

+

+namespace math

+{

+class AABB final {

+public:

+    AABB(void) = default;

+    explicit AABB(const glm::fvec3& min, const glm::fvec3& max);

+    virtual ~AABB(void) = default;

+

+    void set_bounds(const glm::fvec3& min, const glm::fvec3& max);

+    void set_offset(const glm::fvec3& base, const glm::fvec3& size);

+

+    const glm::fvec3& get_min(void) const;

+    const glm::fvec3& get_max(void) const;

+

+    bool contains(const glm::fvec3& point) const;

+    bool intersect(const AABB& other_box) const;

+

+    AABB combine_with(const AABB& other_box) const;

+    AABB multiply_with(const AABB& other_box) const;

+    AABB push(const glm::fvec3& vector) const;

+

+public:

+    glm::fvec3 min;

+    glm::fvec3 max;

+};

+} // namespace math

diff --git a/core/math/angles.hh b/core/math/angles.hh
index 174f320..edc2f65 100644
--- a/core/math/angles.hh
+++ b/core/math/angles.hh
@@ -1,103 +1,103 @@
-#pragma once
-
-#include "core/math/constexpr.hh"
-
-constexpr float A180 = math::radians(180.0f);
-constexpr float A360 = math::radians(360.0f);
-
-namespace math
-{
-float wrap_180(float angle);
-float wrap_360(float angle);
-} // namespace math
-
-namespace math
-{
-glm::fvec3 wrap_180(const glm::fvec3& angles);
-glm::fvec3 wrap_360(const glm::fvec3& angles);
-} // namespace math
-
-namespace math
-{
-void vectors(const glm::fvec3& angles, glm::fvec3& forward);
-void vectors(const glm::fvec3& angles, glm::fvec3* forward, glm::fvec3* right, glm::fvec3* up);
-} // namespace math
-
-inline float math::wrap_180(float angle)
-{
-    const auto result = std::fmod(angle + A180, A360);
-
-    if(result < 0.0f) {
-        return result + A180;
-    }
-
-    return result - A180;
-}
-
-inline float math::wrap_360(float angle)
-{
-    return std::fmod(std::fmod(angle, A360) + A360, A360);
-}
-
-inline glm::fvec3 math::wrap_180(const glm::fvec3& angles)
-{
-    return glm::fvec3 {
-        math::wrap_180(angles.x),
-        math::wrap_180(angles.y),
-        math::wrap_180(angles.z),
-    };
-}
-
-inline glm::fvec3 math::wrap_360(const glm::fvec3& angles)
-{
-    return glm::fvec3 {
-        math::wrap_360(angles.x),
-        math::wrap_360(angles.y),
-        math::wrap_360(angles.z),
-    };
-}
-
-inline void math::vectors(const glm::fvec3& angles, glm::fvec3& forward)
-{
-    const float cosp = std::cos(angles.x);
-    const float cosy = std::cos(angles.y);
-    const float sinp = std::sin(angles.x);
-    const float siny = std::sin(angles.y);
-
-    forward.x = cosp * siny * (-1.0f);
-    forward.y = sinp;
-    forward.z = cosp * cosy * (-1.0f);
-}
-
-inline void math::vectors(const glm::fvec3& angles, glm::fvec3* forward, glm::fvec3* right, glm::fvec3* up)
-{
-    if(!forward && !right && !up) {
-        // There's no point in figuring out
-        // direction vectors if nothing is passed
-        // in the function to store that stuff in
-        return;
-    }
-
-    const auto pcv = glm::cos(angles);
-    const auto psv = glm::sin(angles);
-    const auto ncv = pcv * (-1.0f);
-    const auto nsv = psv * (-1.0f);
-
-    if(forward) {
-        forward->x = pcv.x * nsv.y;
-        forward->y = psv.x;
-        forward->z = pcv.x * ncv.y;
-    }
-
-    if(right) {
-        right->x = pcv.z * pcv.y;
-        right->y = psv.z * pcv.y;
-        right->z = nsv.y;
-    }
-
-    if(up) {
-        up->x = psv.x * psv.y * pcv.z + ncv.y * psv.z;
-        up->y = pcv.x * pcv.z;
-        up->z = nsv.x * ncv.y * pcv.z + psv.y * psv.z;
-    }
-}
+#pragma once

+

+#include "core/math/constexpr.hh"

+

+constexpr float A180 = math::radians(180.0f);

+constexpr float A360 = math::radians(360.0f);

+

+namespace math

+{

+float wrap_180(float angle);

+float wrap_360(float angle);

+} // namespace math

+

+namespace math

+{

+glm::fvec3 wrap_180(const glm::fvec3& angles);

+glm::fvec3 wrap_360(const glm::fvec3& angles);

+} // namespace math

+

+namespace math

+{

+void vectors(const glm::fvec3& angles, glm::fvec3& forward);

+void vectors(const glm::fvec3& angles, glm::fvec3* forward, glm::fvec3* right, glm::fvec3* up);

+} // namespace math

+

+inline float math::wrap_180(float angle)

+{

+    const auto result = std::fmod(angle + A180, A360);

+

+    if(result < 0.0f) {

+        return result + A180;

+    }

+

+    return result - A180;

+}

+

+inline float math::wrap_360(float angle)

+{

+    return std::fmod(std::fmod(angle, A360) + A360, A360);

+}

+

+inline glm::fvec3 math::wrap_180(const glm::fvec3& angles)

+{

+    return glm::fvec3 {

+        math::wrap_180(angles.x),

+        math::wrap_180(angles.y),

+        math::wrap_180(angles.z),

+    };

+}

+

+inline glm::fvec3 math::wrap_360(const glm::fvec3& angles)

+{

+    return glm::fvec3 {

+        math::wrap_360(angles.x),

+        math::wrap_360(angles.y),

+        math::wrap_360(angles.z),

+    };

+}

+

+inline void math::vectors(const glm::fvec3& angles, glm::fvec3& forward)

+{

+    const float cosp = std::cos(angles.x);

+    const float cosy = std::cos(angles.y);

+    const float sinp = std::sin(angles.x);

+    const float siny = std::sin(angles.y);

+

+    forward.x = cosp * siny * (-1.0f);

+    forward.y = sinp;

+    forward.z = cosp * cosy * (-1.0f);

+}

+

+inline void math::vectors(const glm::fvec3& angles, glm::fvec3* forward, glm::fvec3* right, glm::fvec3* up)

+{

+    if(!forward && !right && !up) {

+        // There's no point in figuring out

+        // direction vectors if nothing is passed

+        // in the function to store that stuff in

+        return;

+    }

+

+    const auto pcv = glm::cos(angles);

+    const auto psv = glm::sin(angles);

+    const auto ncv = pcv * (-1.0f);

+    const auto nsv = psv * (-1.0f);

+

+    if(forward) {

+        forward->x = pcv.x * nsv.y;

+        forward->y = psv.x;

+        forward->z = pcv.x * ncv.y;

+    }

+

+    if(right) {

+        right->x = pcv.z * pcv.y;

+        right->y = psv.z * pcv.y;

+        right->z = nsv.y;

+    }

+

+    if(up) {

+        up->x = psv.x * psv.y * pcv.z + ncv.y * psv.z;

+        up->y = pcv.x * pcv.z;

+        up->z = nsv.x * ncv.y * pcv.z + psv.y * psv.z;

+    }

+}

diff --git a/core/math/concepts.hh b/core/math/concepts.hh
index 70859c2..10cb74a 100644
--- a/core/math/concepts.hh
+++ b/core/math/concepts.hh
@@ -1,11 +1,11 @@
-#pragma once
-
-namespace math
-{
-template<typename T>
-concept Arithmetic = std::is_arithmetic_v<T>;
-template<typename T>
-concept Integer = std::is_integral_v<T>;
-template<typename T>
-concept FloatingPoint = std::is_floating_point_v<T>;
-} // namespace math
+#pragma once

+

+namespace math

+{

+template<typename T>

+concept Arithmetic = std::is_arithmetic_v<T>;

+template<typename T>

+concept Integer = std::is_integral_v<T>;

+template<typename T>

+concept FloatingPoint = std::is_floating_point_v<T>;

+} // namespace math

diff --git a/core/math/constexpr.hh b/core/math/constexpr.hh
index 65dbbbf..e6c4b6d 100644
--- a/core/math/constexpr.hh
+++ b/core/math/constexpr.hh
@@ -1,198 +1,198 @@
-#pragma once
-
-#include "core/math/concepts.hh"
-
-namespace math
-{
-template<math::Arithmetic T>
-constexpr static inline const T abs(const T x);
-template<typename T, std::size_t L>
-constexpr static inline const std::size_t array_size(const T (&)[L]);
-template<math::Integer T, math::FloatingPoint F>
-constexpr static inline const T ceil(const F x);
-template<math::Arithmetic T>
-constexpr static inline const T degrees(const T x);
-template<math::Integer T, math::FloatingPoint F>
-constexpr static inline const T floor(const F x);
-template<math::Arithmetic T>
-constexpr static inline const T clamp(const T x, const T min, const T max);
-template<math::Arithmetic T, math::FloatingPoint F>
-constexpr static inline const T lerp(const T x, const T y, const F a);
-template<math::Arithmetic T>
-constexpr static inline const T log2(const T x);
-template<math::Arithmetic T>
-constexpr static inline const T max(const T x, const T y);
-template<math::Arithmetic T>
-constexpr static inline const T min(const T x, const T y);
-template<math::Integer T>
-requires std::is_signed_v<T>
-constexpr static inline const T mod_signed(const T x, const T m);
-template<math::Arithmetic T>
-constexpr static inline const T pow2(const T x);
-template<math::Arithmetic T>
-constexpr static inline const T radians(const T x);
-template<math::Arithmetic T>
-constexpr static inline const bool range(const T x, const T min, const T max);
-template<math::Arithmetic T, math::FloatingPoint F>
-constexpr static inline const T sign(const F x);
-template<math::Arithmetic T, math::FloatingPoint F>
-constexpr static inline const T smoothstep(const T x, const T y, const F a);
-} // namespace math
-
-template<math::Arithmetic T>
-constexpr static inline const T math::abs(const T x)
-{
-    if(x < static_cast<T>(0)) {
-        return -x;
-    }
-    else {
-        return x;
-    }
-}
-
-template<typename T, std::size_t L>
-constexpr static inline const std::size_t math::array_size(const T (&)[L])
-{
-    return L;
-}
-
-template<math::Integer T, math::FloatingPoint F>
-constexpr static inline const T math::ceil(const F x)
-{
-    const T ival = static_cast<T>(x);
-
-    if(ival < x) {
-        return ival + static_cast<T>(1);
-    }
-    else {
-        return ival;
-    }
-}
-
-template<math::Arithmetic T>
-constexpr static inline const T math::degrees(const T x)
-{
-    return x * static_cast<T>(180.0) / static_cast<T>(M_PI);
-}
-
-template<math::Integer T, math::FloatingPoint F>
-constexpr static inline const T math::floor(const F x)
-{
-    const T ival = static_cast<T>(x);
-
-    if(ival > x) {
-        return ival - static_cast<T>(1);
-    }
-    else {
-        return ival;
-    }
-}
-
-template<math::Arithmetic T>
-constexpr static inline const T math::clamp(const T x, const T min, const T max)
-{
-    if(x < min) {
-        return min;
-    }
-    else if(x > max) {
-        return max;
-    }
-    else {
-        return x;
-    }
-}
-
-template<math::Arithmetic T, math::FloatingPoint F>
-constexpr static inline const T math::lerp(const T x, const T y, const F a)
-{
-    return static_cast<T>(static_cast<F>(x) * (static_cast<F>(1.0f) - a) + static_cast<F>(y) * a);
-}
-
-template<math::Arithmetic T>
-constexpr static inline const T math::log2(const T x)
-{
-    if(x < 2) {
-        return 0;
-    }
-    else {
-        return math::log2<T>((x + 1) >> 1) + 1;
-    }
-}
-
-template<math::Arithmetic T>
-constexpr static inline const T math::max(const T x, const T y)
-{
-    if(x < y) {
-        return y;
-    }
-    else {
-        return x;
-    }
-}
-
-template<math::Arithmetic T>
-constexpr static inline const T math::min(const T x, const T y)
-{
-    if(x > y) {
-        return y;
-    }
-    else {
-        return x;
-    }
-}
-
-template<math::Integer T>
-requires std::is_signed_v<T>
-constexpr static inline const T math::mod_signed(const T x, const T m)
-{
-    auto result = static_cast<T>(x % m);
-
-    if(result < T(0)) {
-        return result + m;
-    }
-    else {
-        return result;
-    }
-}
-
-template<math::Arithmetic T>
-constexpr static inline const T math::pow2(const T x)
-{
-    T value = static_cast<T>(1);
-    while(value < x)
-        value *= static_cast<T>(2);
-    return value;
-}
-
-template<math::Arithmetic T>
-constexpr static inline const T math::radians(const T x)
-{
-    return x * static_cast<T>(M_PI) / static_cast<T>(180.0);
-}
-
-template<math::Arithmetic T>
-constexpr static inline const bool math::range(const T x, const T min, const T max)
-{
-    return ((x >= min) && (x <= max));
-}
-
-template<math::Arithmetic T, math::FloatingPoint F>
-constexpr static inline const T math::sign(const F x)
-{
-    if(x < F(0)) {
-        return T(-1);
-    }
-    else if(x > F(0)) {
-        return T(+1);
-    }
-    else {
-        return T(0);
-    }
-}
-
-template<math::Arithmetic T, math::FloatingPoint F>
-constexpr static inline const T math::smoothstep(const T x, const T y, const F a)
-{
-    const F t = math::clamp<F>((a - x) / (y - x), F(0), F(1));
-    return static_cast<T>(t * t * (F(3) - F(2) * t));
-}
+#pragma once

+

+#include "core/math/concepts.hh"

+

+namespace math

+{

+template<math::Arithmetic T>

+constexpr static inline const T abs(const T x);

+template<typename T, std::size_t L>

+constexpr static inline const std::size_t array_size(const T (&)[L]);

+template<math::Integer T, math::FloatingPoint F>

+constexpr static inline const T ceil(const F x);

+template<math::Arithmetic T>

+constexpr static inline const T degrees(const T x);

+template<math::Integer T, math::FloatingPoint F>

+constexpr static inline const T floor(const F x);

+template<math::Arithmetic T>

+constexpr static inline const T clamp(const T x, const T min, const T max);

+template<math::Arithmetic T, math::FloatingPoint F>

+constexpr static inline const T lerp(const T x, const T y, const F a);

+template<math::Arithmetic T>

+constexpr static inline const T log2(const T x);

+template<math::Arithmetic T>

+constexpr static inline const T max(const T x, const T y);

+template<math::Arithmetic T>

+constexpr static inline const T min(const T x, const T y);

+template<math::Integer T>

+requires std::is_signed_v<T>

+constexpr static inline const T mod_signed(const T x, const T m);

+template<math::Arithmetic T>

+constexpr static inline const T pow2(const T x);

+template<math::Arithmetic T>

+constexpr static inline const T radians(const T x);

+template<math::Arithmetic T>

+constexpr static inline const bool range(const T x, const T min, const T max);

+template<math::Arithmetic T, math::FloatingPoint F>

+constexpr static inline const T sign(const F x);

+template<math::Arithmetic T, math::FloatingPoint F>

+constexpr static inline const T smoothstep(const T x, const T y, const F a);

+} // namespace math

+

+template<math::Arithmetic T>

+constexpr static inline const T math::abs(const T x)

+{

+    if(x < static_cast<T>(0)) {

+        return -x;

+    }

+    else {

+        return x;

+    }

+}

+

+template<typename T, std::size_t L>

+constexpr static inline const std::size_t math::array_size(const T (&)[L])

+{

+    return L;

+}

+

+template<math::Integer T, math::FloatingPoint F>

+constexpr static inline const T math::ceil(const F x)

+{

+    const T ival = static_cast<T>(x);

+

+    if(ival < x) {

+        return ival + static_cast<T>(1);

+    }

+    else {

+        return ival;

+    }

+}

+

+template<math::Arithmetic T>

+constexpr static inline const T math::degrees(const T x)

+{

+    return x * static_cast<T>(180.0) / static_cast<T>(M_PI);

+}

+

+template<math::Integer T, math::FloatingPoint F>

+constexpr static inline const T math::floor(const F x)

+{

+    const T ival = static_cast<T>(x);

+

+    if(ival > x) {

+        return ival - static_cast<T>(1);

+    }

+    else {

+        return ival;

+    }

+}

+

+template<math::Arithmetic T>

+constexpr static inline const T math::clamp(const T x, const T min, const T max)

+{

+    if(x < min) {

+        return min;

+    }

+    else if(x > max) {

+        return max;

+    }

+    else {

+        return x;

+    }

+}

+

+template<math::Arithmetic T, math::FloatingPoint F>

+constexpr static inline const T math::lerp(const T x, const T y, const F a)

+{

+    return static_cast<T>(static_cast<F>(x) * (static_cast<F>(1.0f) - a) + static_cast<F>(y) * a);

+}

+

+template<math::Arithmetic T>

+constexpr static inline const T math::log2(const T x)

+{

+    if(x < 2) {

+        return 0;

+    }

+    else {

+        return math::log2<T>((x + 1) >> 1) + 1;

+    }

+}

+

+template<math::Arithmetic T>

+constexpr static inline const T math::max(const T x, const T y)

+{

+    if(x < y) {

+        return y;

+    }

+    else {

+        return x;

+    }

+}

+

+template<math::Arithmetic T>

+constexpr static inline const T math::min(const T x, const T y)

+{

+    if(x > y) {

+        return y;

+    }

+    else {

+        return x;

+    }

+}

+

+template<math::Integer T>

+requires std::is_signed_v<T>

+constexpr static inline const T math::mod_signed(const T x, const T m)

+{

+    auto result = static_cast<T>(x % m);

+

+    if(result < T(0)) {

+        return result + m;

+    }

+    else {

+        return result;

+    }

+}

+

+template<math::Arithmetic T>

+constexpr static inline const T math::pow2(const T x)

+{

+    T value = static_cast<T>(1);

+    while(value < x)

+        value *= static_cast<T>(2);

+    return value;

+}

+

+template<math::Arithmetic T>

+constexpr static inline const T math::radians(const T x)

+{

+    return x * static_cast<T>(M_PI) / static_cast<T>(180.0);

+}

+

+template<math::Arithmetic T>

+constexpr static inline const bool math::range(const T x, const T min, const T max)

+{

+    return ((x >= min) && (x <= max));

+}

+

+template<math::Arithmetic T, math::FloatingPoint F>

+constexpr static inline const T math::sign(const F x)

+{

+    if(x < F(0)) {

+        return T(-1);

+    }

+    else if(x > F(0)) {

+        return T(+1);

+    }

+    else {

+        return T(0);

+    }

+}

+

+template<math::Arithmetic T, math::FloatingPoint F>

+constexpr static inline const T math::smoothstep(const T x, const T y, const F a)

+{

+    const F t = math::clamp<F>((a - x) / (y - x), F(0), F(1));

+    return static_cast<T>(t * t * (F(3) - F(2) * t));

+}

diff --git a/core/math/crc64.cc b/core/math/crc64.cc
index 4311eaf..0b6a830 100644
--- a/core/math/crc64.cc
+++ b/core/math/crc64.cc
@@ -1,71 +1,71 @@
-#include "core/pch.hh"
-
-#include "core/math/crc64.hh"
-
-// The lookup table for CRC64 checksum; this lookup
-// table is generated using ECMA-182 compilant parameters:
-// - Polynomial: `0x42F0E1EBA9EA3693`
-// - Initial value: `0x0000000000000000`
-// - Final xor: `0x0000000000000000`
-// CRC Calculator: https://www.sunshine2k.de/coding/javascript/crc/crc_js.html
-constexpr static const std::uint64_t crc_table[256] = { 0x0000000000000000, 0x42F0E1EBA9EA3693, 0x85E1C3D753D46D26, 0xC711223CFA3E5BB5,
-    0x493366450E42ECDF, 0x0BC387AEA7A8DA4C, 0xCCD2A5925D9681F9, 0x8E224479F47CB76A, 0x9266CC8A1C85D9BE, 0xD0962D61B56FEF2D,
-    0x17870F5D4F51B498, 0x5577EEB6E6BB820B, 0xDB55AACF12C73561, 0x99A54B24BB2D03F2, 0x5EB4691841135847, 0x1C4488F3E8F96ED4,
-    0x663D78FF90E185EF, 0x24CD9914390BB37C, 0xE3DCBB28C335E8C9, 0xA12C5AC36ADFDE5A, 0x2F0E1EBA9EA36930, 0x6DFEFF5137495FA3,
-    0xAAEFDD6DCD770416, 0xE81F3C86649D3285, 0xF45BB4758C645C51, 0xB6AB559E258E6AC2, 0x71BA77A2DFB03177, 0x334A9649765A07E4,
-    0xBD68D2308226B08E, 0xFF9833DB2BCC861D, 0x388911E7D1F2DDA8, 0x7A79F00C7818EB3B, 0xCC7AF1FF21C30BDE, 0x8E8A101488293D4D,
-    0x499B3228721766F8, 0x0B6BD3C3DBFD506B, 0x854997BA2F81E701, 0xC7B97651866BD192, 0x00A8546D7C558A27, 0x4258B586D5BFBCB4,
-    0x5E1C3D753D46D260, 0x1CECDC9E94ACE4F3, 0xDBFDFEA26E92BF46, 0x990D1F49C77889D5, 0x172F5B3033043EBF, 0x55DFBADB9AEE082C,
-    0x92CE98E760D05399, 0xD03E790CC93A650A, 0xAA478900B1228E31, 0xE8B768EB18C8B8A2, 0x2FA64AD7E2F6E317, 0x6D56AB3C4B1CD584,
-    0xE374EF45BF6062EE, 0xA1840EAE168A547D, 0x66952C92ECB40FC8, 0x2465CD79455E395B, 0x3821458AADA7578F, 0x7AD1A461044D611C,
-    0xBDC0865DFE733AA9, 0xFF3067B657990C3A, 0x711223CFA3E5BB50, 0x33E2C2240A0F8DC3, 0xF4F3E018F031D676, 0xB60301F359DBE0E5,
-    0xDA050215EA6C212F, 0x98F5E3FE438617BC, 0x5FE4C1C2B9B84C09, 0x1D14202910527A9A, 0x93366450E42ECDF0, 0xD1C685BB4DC4FB63,
-    0x16D7A787B7FAA0D6, 0x5427466C1E109645, 0x4863CE9FF6E9F891, 0x0A932F745F03CE02, 0xCD820D48A53D95B7, 0x8F72ECA30CD7A324,
-    0x0150A8DAF8AB144E, 0x43A04931514122DD, 0x84B16B0DAB7F7968, 0xC6418AE602954FFB, 0xBC387AEA7A8DA4C0, 0xFEC89B01D3679253,
-    0x39D9B93D2959C9E6, 0x7B2958D680B3FF75, 0xF50B1CAF74CF481F, 0xB7FBFD44DD257E8C, 0x70EADF78271B2539, 0x321A3E938EF113AA,
-    0x2E5EB66066087D7E, 0x6CAE578BCFE24BED, 0xABBF75B735DC1058, 0xE94F945C9C3626CB, 0x676DD025684A91A1, 0x259D31CEC1A0A732,
-    0xE28C13F23B9EFC87, 0xA07CF2199274CA14, 0x167FF3EACBAF2AF1, 0x548F120162451C62, 0x939E303D987B47D7, 0xD16ED1D631917144,
-    0x5F4C95AFC5EDC62E, 0x1DBC74446C07F0BD, 0xDAAD56789639AB08, 0x985DB7933FD39D9B, 0x84193F60D72AF34F, 0xC6E9DE8B7EC0C5DC,
-    0x01F8FCB784FE9E69, 0x43081D5C2D14A8FA, 0xCD2A5925D9681F90, 0x8FDAB8CE70822903, 0x48CB9AF28ABC72B6, 0x0A3B7B1923564425,
-    0x70428B155B4EAF1E, 0x32B26AFEF2A4998D, 0xF5A348C2089AC238, 0xB753A929A170F4AB, 0x3971ED50550C43C1, 0x7B810CBBFCE67552,
-    0xBC902E8706D82EE7, 0xFE60CF6CAF321874, 0xE224479F47CB76A0, 0xA0D4A674EE214033, 0x67C58448141F1B86, 0x253565A3BDF52D15,
-    0xAB1721DA49899A7F, 0xE9E7C031E063ACEC, 0x2EF6E20D1A5DF759, 0x6C0603E6B3B7C1CA, 0xF6FAE5C07D3274CD, 0xB40A042BD4D8425E,
-    0x731B26172EE619EB, 0x31EBC7FC870C2F78, 0xBFC9838573709812, 0xFD39626EDA9AAE81, 0x3A28405220A4F534, 0x78D8A1B9894EC3A7,
-    0x649C294A61B7AD73, 0x266CC8A1C85D9BE0, 0xE17DEA9D3263C055, 0xA38D0B769B89F6C6, 0x2DAF4F0F6FF541AC, 0x6F5FAEE4C61F773F,
-    0xA84E8CD83C212C8A, 0xEABE6D3395CB1A19, 0x90C79D3FEDD3F122, 0xD2377CD44439C7B1, 0x15265EE8BE079C04, 0x57D6BF0317EDAA97,
-    0xD9F4FB7AE3911DFD, 0x9B041A914A7B2B6E, 0x5C1538ADB04570DB, 0x1EE5D94619AF4648, 0x02A151B5F156289C, 0x4051B05E58BC1E0F,
-    0x87409262A28245BA, 0xC5B073890B687329, 0x4B9237F0FF14C443, 0x0962D61B56FEF2D0, 0xCE73F427ACC0A965, 0x8C8315CC052A9FF6,
-    0x3A80143F5CF17F13, 0x7870F5D4F51B4980, 0xBF61D7E80F251235, 0xFD913603A6CF24A6, 0x73B3727A52B393CC, 0x31439391FB59A55F,
-    0xF652B1AD0167FEEA, 0xB4A25046A88DC879, 0xA8E6D8B54074A6AD, 0xEA16395EE99E903E, 0x2D071B6213A0CB8B, 0x6FF7FA89BA4AFD18,
-    0xE1D5BEF04E364A72, 0xA3255F1BE7DC7CE1, 0x64347D271DE22754, 0x26C49CCCB40811C7, 0x5CBD6CC0CC10FAFC, 0x1E4D8D2B65FACC6F,
-    0xD95CAF179FC497DA, 0x9BAC4EFC362EA149, 0x158E0A85C2521623, 0x577EEB6E6BB820B0, 0x906FC95291867B05, 0xD29F28B9386C4D96,
-    0xCEDBA04AD0952342, 0x8C2B41A1797F15D1, 0x4B3A639D83414E64, 0x09CA82762AAB78F7, 0x87E8C60FDED7CF9D, 0xC51827E4773DF90E,
-    0x020905D88D03A2BB, 0x40F9E43324E99428, 0x2CFFE7D5975E55E2, 0x6E0F063E3EB46371, 0xA91E2402C48A38C4, 0xEBEEC5E96D600E57,
-    0x65CC8190991CB93D, 0x273C607B30F68FAE, 0xE02D4247CAC8D41B, 0xA2DDA3AC6322E288, 0xBE992B5F8BDB8C5C, 0xFC69CAB42231BACF,
-    0x3B78E888D80FE17A, 0x7988096371E5D7E9, 0xF7AA4D1A85996083, 0xB55AACF12C735610, 0x724B8ECDD64D0DA5, 0x30BB6F267FA73B36,
-    0x4AC29F2A07BFD00D, 0x08327EC1AE55E69E, 0xCF235CFD546BBD2B, 0x8DD3BD16FD818BB8, 0x03F1F96F09FD3CD2, 0x41011884A0170A41,
-    0x86103AB85A2951F4, 0xC4E0DB53F3C36767, 0xD8A453A01B3A09B3, 0x9A54B24BB2D03F20, 0x5D45907748EE6495, 0x1FB5719CE1045206,
-    0x919735E51578E56C, 0xD367D40EBC92D3FF, 0x1476F63246AC884A, 0x568617D9EF46BED9, 0xE085162AB69D5E3C, 0xA275F7C11F7768AF,
-    0x6564D5FDE549331A, 0x279434164CA30589, 0xA9B6706FB8DFB2E3, 0xEB46918411358470, 0x2C57B3B8EB0BDFC5, 0x6EA7525342E1E956,
-    0x72E3DAA0AA188782, 0x30133B4B03F2B111, 0xF7021977F9CCEAA4, 0xB5F2F89C5026DC37, 0x3BD0BCE5A45A6B5D, 0x79205D0E0DB05DCE,
-    0xBE317F32F78E067B, 0xFCC19ED95E6430E8, 0x86B86ED5267CDBD3, 0xC4488F3E8F96ED40, 0x0359AD0275A8B6F5, 0x41A94CE9DC428066,
-    0xCF8B0890283E370C, 0x8D7BE97B81D4019F, 0x4A6ACB477BEA5A2A, 0x089A2AACD2006CB9, 0x14DEA25F3AF9026D, 0x562E43B4931334FE,
-    0x913F6188692D6F4B, 0xD3CF8063C0C759D8, 0x5DEDC41A34BBEEB2, 0x1F1D25F19D51D821, 0xD80C07CD676F8394, 0x9AFCE626CE85B507 };
-
-std::uint64_t math::crc64(const void* buffer, std::size_t size, std::uint64_t combine)
-{
-    auto data = reinterpret_cast<const std::uint8_t*>(buffer);
-    for(std::size_t i = 0; i < size; ++i)
-        combine = crc_table[((combine >> 56) ^ data[i]) & 0xFF] ^ (combine << 8);
-    return combine;
-}
-
-std::uint64_t math::crc64(const std::vector<std::byte>& buffer, std::uint64_t combine)
-{
-    return math::crc64(buffer.data(), buffer.size(), combine);
-}
-
-std::uint64_t math::crc64(const std::string& buffer, std::uint64_t combine)
-{
-    return math::crc64(buffer.data(), buffer.size(), combine);
-}
+#include "core/pch.hh"

+

+#include "core/math/crc64.hh"

+

+// The lookup table for CRC64 checksum; this lookup

+// table is generated using ECMA-182 compilant parameters:

+// - Polynomial: `0x42F0E1EBA9EA3693`

+// - Initial value: `0x0000000000000000`

+// - Final xor: `0x0000000000000000`

+// CRC Calculator: https://www.sunshine2k.de/coding/javascript/crc/crc_js.html

+constexpr static const std::uint64_t crc_table[256] = { 0x0000000000000000, 0x42F0E1EBA9EA3693, 0x85E1C3D753D46D26, 0xC711223CFA3E5BB5,

+    0x493366450E42ECDF, 0x0BC387AEA7A8DA4C, 0xCCD2A5925D9681F9, 0x8E224479F47CB76A, 0x9266CC8A1C85D9BE, 0xD0962D61B56FEF2D,

+    0x17870F5D4F51B498, 0x5577EEB6E6BB820B, 0xDB55AACF12C73561, 0x99A54B24BB2D03F2, 0x5EB4691841135847, 0x1C4488F3E8F96ED4,

+    0x663D78FF90E185EF, 0x24CD9914390BB37C, 0xE3DCBB28C335E8C9, 0xA12C5AC36ADFDE5A, 0x2F0E1EBA9EA36930, 0x6DFEFF5137495FA3,

+    0xAAEFDD6DCD770416, 0xE81F3C86649D3285, 0xF45BB4758C645C51, 0xB6AB559E258E6AC2, 0x71BA77A2DFB03177, 0x334A9649765A07E4,

+    0xBD68D2308226B08E, 0xFF9833DB2BCC861D, 0x388911E7D1F2DDA8, 0x7A79F00C7818EB3B, 0xCC7AF1FF21C30BDE, 0x8E8A101488293D4D,

+    0x499B3228721766F8, 0x0B6BD3C3DBFD506B, 0x854997BA2F81E701, 0xC7B97651866BD192, 0x00A8546D7C558A27, 0x4258B586D5BFBCB4,

+    0x5E1C3D753D46D260, 0x1CECDC9E94ACE4F3, 0xDBFDFEA26E92BF46, 0x990D1F49C77889D5, 0x172F5B3033043EBF, 0x55DFBADB9AEE082C,

+    0x92CE98E760D05399, 0xD03E790CC93A650A, 0xAA478900B1228E31, 0xE8B768EB18C8B8A2, 0x2FA64AD7E2F6E317, 0x6D56AB3C4B1CD584,

+    0xE374EF45BF6062EE, 0xA1840EAE168A547D, 0x66952C92ECB40FC8, 0x2465CD79455E395B, 0x3821458AADA7578F, 0x7AD1A461044D611C,

+    0xBDC0865DFE733AA9, 0xFF3067B657990C3A, 0x711223CFA3E5BB50, 0x33E2C2240A0F8DC3, 0xF4F3E018F031D676, 0xB60301F359DBE0E5,

+    0xDA050215EA6C212F, 0x98F5E3FE438617BC, 0x5FE4C1C2B9B84C09, 0x1D14202910527A9A, 0x93366450E42ECDF0, 0xD1C685BB4DC4FB63,

+    0x16D7A787B7FAA0D6, 0x5427466C1E109645, 0x4863CE9FF6E9F891, 0x0A932F745F03CE02, 0xCD820D48A53D95B7, 0x8F72ECA30CD7A324,

+    0x0150A8DAF8AB144E, 0x43A04931514122DD, 0x84B16B0DAB7F7968, 0xC6418AE602954FFB, 0xBC387AEA7A8DA4C0, 0xFEC89B01D3679253,

+    0x39D9B93D2959C9E6, 0x7B2958D680B3FF75, 0xF50B1CAF74CF481F, 0xB7FBFD44DD257E8C, 0x70EADF78271B2539, 0x321A3E938EF113AA,

+    0x2E5EB66066087D7E, 0x6CAE578BCFE24BED, 0xABBF75B735DC1058, 0xE94F945C9C3626CB, 0x676DD025684A91A1, 0x259D31CEC1A0A732,

+    0xE28C13F23B9EFC87, 0xA07CF2199274CA14, 0x167FF3EACBAF2AF1, 0x548F120162451C62, 0x939E303D987B47D7, 0xD16ED1D631917144,

+    0x5F4C95AFC5EDC62E, 0x1DBC74446C07F0BD, 0xDAAD56789639AB08, 0x985DB7933FD39D9B, 0x84193F60D72AF34F, 0xC6E9DE8B7EC0C5DC,

+    0x01F8FCB784FE9E69, 0x43081D5C2D14A8FA, 0xCD2A5925D9681F90, 0x8FDAB8CE70822903, 0x48CB9AF28ABC72B6, 0x0A3B7B1923564425,

+    0x70428B155B4EAF1E, 0x32B26AFEF2A4998D, 0xF5A348C2089AC238, 0xB753A929A170F4AB, 0x3971ED50550C43C1, 0x7B810CBBFCE67552,

+    0xBC902E8706D82EE7, 0xFE60CF6CAF321874, 0xE224479F47CB76A0, 0xA0D4A674EE214033, 0x67C58448141F1B86, 0x253565A3BDF52D15,

+    0xAB1721DA49899A7F, 0xE9E7C031E063ACEC, 0x2EF6E20D1A5DF759, 0x6C0603E6B3B7C1CA, 0xF6FAE5C07D3274CD, 0xB40A042BD4D8425E,

+    0x731B26172EE619EB, 0x31EBC7FC870C2F78, 0xBFC9838573709812, 0xFD39626EDA9AAE81, 0x3A28405220A4F534, 0x78D8A1B9894EC3A7,

+    0x649C294A61B7AD73, 0x266CC8A1C85D9BE0, 0xE17DEA9D3263C055, 0xA38D0B769B89F6C6, 0x2DAF4F0F6FF541AC, 0x6F5FAEE4C61F773F,

+    0xA84E8CD83C212C8A, 0xEABE6D3395CB1A19, 0x90C79D3FEDD3F122, 0xD2377CD44439C7B1, 0x15265EE8BE079C04, 0x57D6BF0317EDAA97,

+    0xD9F4FB7AE3911DFD, 0x9B041A914A7B2B6E, 0x5C1538ADB04570DB, 0x1EE5D94619AF4648, 0x02A151B5F156289C, 0x4051B05E58BC1E0F,

+    0x87409262A28245BA, 0xC5B073890B687329, 0x4B9237F0FF14C443, 0x0962D61B56FEF2D0, 0xCE73F427ACC0A965, 0x8C8315CC052A9FF6,

+    0x3A80143F5CF17F13, 0x7870F5D4F51B4980, 0xBF61D7E80F251235, 0xFD913603A6CF24A6, 0x73B3727A52B393CC, 0x31439391FB59A55F,

+    0xF652B1AD0167FEEA, 0xB4A25046A88DC879, 0xA8E6D8B54074A6AD, 0xEA16395EE99E903E, 0x2D071B6213A0CB8B, 0x6FF7FA89BA4AFD18,

+    0xE1D5BEF04E364A72, 0xA3255F1BE7DC7CE1, 0x64347D271DE22754, 0x26C49CCCB40811C7, 0x5CBD6CC0CC10FAFC, 0x1E4D8D2B65FACC6F,

+    0xD95CAF179FC497DA, 0x9BAC4EFC362EA149, 0x158E0A85C2521623, 0x577EEB6E6BB820B0, 0x906FC95291867B05, 0xD29F28B9386C4D96,

+    0xCEDBA04AD0952342, 0x8C2B41A1797F15D1, 0x4B3A639D83414E64, 0x09CA82762AAB78F7, 0x87E8C60FDED7CF9D, 0xC51827E4773DF90E,

+    0x020905D88D03A2BB, 0x40F9E43324E99428, 0x2CFFE7D5975E55E2, 0x6E0F063E3EB46371, 0xA91E2402C48A38C4, 0xEBEEC5E96D600E57,

+    0x65CC8190991CB93D, 0x273C607B30F68FAE, 0xE02D4247CAC8D41B, 0xA2DDA3AC6322E288, 0xBE992B5F8BDB8C5C, 0xFC69CAB42231BACF,

+    0x3B78E888D80FE17A, 0x7988096371E5D7E9, 0xF7AA4D1A85996083, 0xB55AACF12C735610, 0x724B8ECDD64D0DA5, 0x30BB6F267FA73B36,

+    0x4AC29F2A07BFD00D, 0x08327EC1AE55E69E, 0xCF235CFD546BBD2B, 0x8DD3BD16FD818BB8, 0x03F1F96F09FD3CD2, 0x41011884A0170A41,

+    0x86103AB85A2951F4, 0xC4E0DB53F3C36767, 0xD8A453A01B3A09B3, 0x9A54B24BB2D03F20, 0x5D45907748EE6495, 0x1FB5719CE1045206,

+    0x919735E51578E56C, 0xD367D40EBC92D3FF, 0x1476F63246AC884A, 0x568617D9EF46BED9, 0xE085162AB69D5E3C, 0xA275F7C11F7768AF,

+    0x6564D5FDE549331A, 0x279434164CA30589, 0xA9B6706FB8DFB2E3, 0xEB46918411358470, 0x2C57B3B8EB0BDFC5, 0x6EA7525342E1E956,

+    0x72E3DAA0AA188782, 0x30133B4B03F2B111, 0xF7021977F9CCEAA4, 0xB5F2F89C5026DC37, 0x3BD0BCE5A45A6B5D, 0x79205D0E0DB05DCE,

+    0xBE317F32F78E067B, 0xFCC19ED95E6430E8, 0x86B86ED5267CDBD3, 0xC4488F3E8F96ED40, 0x0359AD0275A8B6F5, 0x41A94CE9DC428066,

+    0xCF8B0890283E370C, 0x8D7BE97B81D4019F, 0x4A6ACB477BEA5A2A, 0x089A2AACD2006CB9, 0x14DEA25F3AF9026D, 0x562E43B4931334FE,

+    0x913F6188692D6F4B, 0xD3CF8063C0C759D8, 0x5DEDC41A34BBEEB2, 0x1F1D25F19D51D821, 0xD80C07CD676F8394, 0x9AFCE626CE85B507 };

+

+std::uint64_t math::crc64(const void* buffer, std::size_t size, std::uint64_t combine)

+{

+    auto data = reinterpret_cast<const std::uint8_t*>(buffer);

+    for(std::size_t i = 0; i < size; ++i)

+        combine = crc_table[((combine >> 56) ^ data[i]) & 0xFF] ^ (combine << 8);

+    return combine;

+}

+

+std::uint64_t math::crc64(const std::vector<std::byte>& buffer, std::uint64_t combine)

+{

+    return math::crc64(buffer.data(), buffer.size(), combine);

+}

+

+std::uint64_t math::crc64(const std::string& buffer, std::uint64_t combine)

+{

+    return math::crc64(buffer.data(), buffer.size(), combine);

+}

diff --git a/core/math/crc64.hh b/core/math/crc64.hh
index 4dc484d..f68c951 100644
--- a/core/math/crc64.hh
+++ b/core/math/crc64.hh
@@ -1,8 +1,8 @@
-#pragma once
-
-namespace math
-{
-std::uint64_t crc64(const void* buffer, std::size_t size, std::uint64_t combine = UINT64_C(0));
-std::uint64_t crc64(const std::vector<std::byte>& buffer, std::uint64_t combine = UINT64_C(0));
-std::uint64_t crc64(const std::string& buffer, std::uint64_t combine = UINT64_C(0));
-} // namespace math
+#pragma once

+

+namespace math

+{

+std::uint64_t crc64(const void* buffer, std::size_t size, std::uint64_t combine = UINT64_C(0));

+std::uint64_t crc64(const std::vector<std::byte>& buffer, std::uint64_t combine = UINT64_C(0));

+std::uint64_t crc64(const std::string& buffer, std::uint64_t combine = UINT64_C(0));

+} // namespace math

diff --git a/core/math/randomizer.hh b/core/math/randomizer.hh
index 04665f9..db21c95 100644
--- a/core/math/randomizer.hh
+++ b/core/math/randomizer.hh
@@ -1,56 +1,56 @@
-#pragma once
-
-namespace math
-{
-template<typename T>
-class Randomizer final {
-public:
-    explicit Randomizer(void);
-    explicit Randomizer(std::uint64_t seed);
-    virtual ~Randomizer(void) = default;
-    void add(const T& value);
-    const T& get(void);
-    void clear(void);
-
-private:
-    std::vector<T> m_vector;
-    std::mt19937_64 m_twister;
-    std::uniform_int_distribution<std::size_t> m_dist;
-};
-} // namespace math
-
-template<typename T>
-inline math::Randomizer<T>::Randomizer(void)
-{
-    m_vector.clear();
-    m_twister.seed(std::random_device()());
-    m_dist = std::uniform_int_distribution<std::size_t>(0, 0);
-}
-
-template<typename T>
-inline math::Randomizer<T>::Randomizer(std::uint64_t seed)
-{
-    m_vector.clear();
-    m_twister.seed(seed);
-    m_dist = std::uniform_int_distribution<std::size_t>(0, 0);
-}
-
-template<typename T>
-inline void math::Randomizer<T>::add(const T& value)
-{
-    m_vector.push_back(value);
-    m_dist = std::uniform_int_distribution<std::size_t>(0, m_vector.size() - 1);
-}
-
-template<typename T>
-inline const T& math::Randomizer<T>::get(void)
-{
-    return m_vector.at(m_dist(m_twister));
-}
-
-template<typename T>
-inline void math::Randomizer<T>::clear(void)
-{
-    m_vector.clear();
-    m_dist = std::uniform_int_distribution<std::size_t>(0, 0);
-}
+#pragma once

+

+namespace math

+{

+template<typename T>

+class Randomizer final {

+public:

+    explicit Randomizer(void);

+    explicit Randomizer(std::uint64_t seed);

+    virtual ~Randomizer(void) = default;

+    void add(const T& value);

+    const T& get(void);

+    void clear(void);

+

+private:

+    std::vector<T> m_vector;

+    std::mt19937_64 m_twister;

+    std::uniform_int_distribution<std::size_t> m_dist;

+};

+} // namespace math

+

+template<typename T>

+inline math::Randomizer<T>::Randomizer(void)

+{

+    m_vector.clear();

+    m_twister.seed(std::random_device()());

+    m_dist = std::uniform_int_distribution<std::size_t>(0, 0);

+}

+

+template<typename T>

+inline math::Randomizer<T>::Randomizer(std::uint64_t seed)

+{

+    m_vector.clear();

+    m_twister.seed(seed);

+    m_dist = std::uniform_int_distribution<std::size_t>(0, 0);

+}

+

+template<typename T>

+inline void math::Randomizer<T>::add(const T& value)

+{

+    m_vector.push_back(value);

+    m_dist = std::uniform_int_distribution<std::size_t>(0, m_vector.size() - 1);

+}

+

+template<typename T>

+inline const T& math::Randomizer<T>::get(void)

+{

+    return m_vector.at(m_dist(m_twister));

+}

+

+template<typename T>

+inline void math::Randomizer<T>::clear(void)

+{

+    m_vector.clear();

+    m_dist = std::uniform_int_distribution<std::size_t>(0, 0);

+}

diff --git a/core/math/vectors.hh b/core/math/vectors.hh
index 73c9ab0..9b9e762 100644
--- a/core/math/vectors.hh
+++ b/core/math/vectors.hh
@@ -1,43 +1,43 @@
-#pragma once
-
-#include "core/math/concepts.hh"
-
-// core/vectors.hh - because NO ONE would POSSIBLY
-// need integer-based distance calculations in a
-// game about voxels. That would be INSANE! :D
-
-namespace math
-{
-template<math::Arithmetic T>
-constexpr static inline const T length2(const glm::vec<2, T>& vector);
-template<math::Arithmetic T>
-constexpr static inline const T length2(const glm::vec<3, T>& vector);
-template<math::Arithmetic T>
-constexpr static inline const T distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b);
-template<math::Arithmetic T>
-constexpr static inline const T distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b);
-} // namespace math
-
-template<math::Arithmetic T>
-constexpr static inline const T math::length2(const glm::vec<2, T>& vector)
-{
-    return (vector.x * vector.x) + (vector.y * vector.y);
-}
-
-template<math::Arithmetic T>
-constexpr static inline const T math::length2(const glm::vec<3, T>& vector)
-{
-    return (vector.x * vector.x) + (vector.y * vector.y) + (vector.z * vector.z);
-}
-
-template<math::Arithmetic T>
-constexpr static inline const T math::distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b)
-{
-    return math::length2(vector_a - vector_b);
-}
-
-template<math::Arithmetic T>
-constexpr static inline const T math::distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b)
-{
-    return math::length2(vector_a - vector_b);
-}
+#pragma once

+

+#include "core/math/concepts.hh"

+

+// core/vectors.hh - because NO ONE would POSSIBLY

+// need integer-based distance calculations in a

+// game about voxels. That would be INSANE! :D

+

+namespace math

+{

+template<math::Arithmetic T>

+constexpr static inline const T length2(const glm::vec<2, T>& vector);

+template<math::Arithmetic T>

+constexpr static inline const T length2(const glm::vec<3, T>& vector);

+template<math::Arithmetic T>

+constexpr static inline const T distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b);

+template<math::Arithmetic T>

+constexpr static inline const T distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b);

+} // namespace math

+

+template<math::Arithmetic T>

+constexpr static inline const T math::length2(const glm::vec<2, T>& vector)

+{

+    return (vector.x * vector.x) + (vector.y * vector.y);

+}

+

+template<math::Arithmetic T>

+constexpr static inline const T math::length2(const glm::vec<3, T>& vector)

+{

+    return (vector.x * vector.x) + (vector.y * vector.y) + (vector.z * vector.z);

+}

+

+template<math::Arithmetic T>

+constexpr static inline const T math::distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b)

+{

+    return math::length2(vector_a - vector_b);

+}

+

+template<math::Arithmetic T>

+constexpr static inline const T math::distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b)

+{

+    return math::length2(vector_a - vector_b);

+}

diff --git a/core/pch.hh b/core/pch.hh
index 17417a5..410b819 100644
--- a/core/pch.hh
+++ b/core/pch.hh
@@ -1,49 +1,49 @@
-#pragma once
-
-#include <cinttypes>
-#include <cmath>
-#include <cstdarg>
-#include <cstddef>
-#include <cstdint>
-
-#include <algorithm>
-#include <chrono>
-#include <concepts>
-#include <filesystem>
-#include <format>
-#include <iostream>
-#include <limits>
-#include <mutex>
-#include <random>
-#include <sstream>
-#include <stdexcept>
-#include <thread>
-#include <type_traits>
-#include <typeindex>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include <BS_thread_pool.hpp>
-
-#include <emhash/hash_table8.hpp>
-
-#include <enet/enet.h>
-
-#include <glm/fwd.hpp>
-
-#include <glm/mat4x4.hpp>
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
-#include <glm/vec4.hpp>
-
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/quaternion.hpp>
-#include <glm/gtc/type_ptr.hpp>
-
-#include <physfs.h>
-
-#include <spdlog/spdlog.h>
-
-#include <stb_image.h>
-#include <stb_image_write.h>
+#pragma once

+

+#include <cinttypes>

+#include <cmath>

+#include <cstdarg>

+#include <cstddef>

+#include <cstdint>

+

+#include <algorithm>

+#include <chrono>

+#include <concepts>

+#include <filesystem>

+#include <format>

+#include <iostream>

+#include <limits>

+#include <mutex>

+#include <random>

+#include <sstream>

+#include <stdexcept>

+#include <thread>

+#include <type_traits>

+#include <typeindex>

+#include <unordered_map>

+#include <unordered_set>

+#include <vector>

+

+#include <BS_thread_pool.hpp>

+

+#include <emhash/hash_table8.hpp>

+

+#include <enet/enet.h>

+

+#include <glm/fwd.hpp>

+

+#include <glm/mat4x4.hpp>

+#include <glm/vec2.hpp>

+#include <glm/vec3.hpp>

+#include <glm/vec4.hpp>

+

+#include <glm/gtc/matrix_transform.hpp>

+#include <glm/gtc/quaternion.hpp>

+#include <glm/gtc/type_ptr.hpp>

+

+#include <physfs.h>

+

+#include <spdlog/spdlog.h>

+

+#include <stb_image.h>

+#include <stb_image_write.h>

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);

+}

diff --git a/core/threading.cc b/core/threading.cc
index 641e634..dcbdb9a 100644
--- a/core/threading.cc
+++ b/core/threading.cc
@@ -1,128 +1,128 @@
-#include "core/pch.hh"
-
-#include "core/threading.hh"
-
-#include "core/io/cmdline.hh"
-
-#include "core/math/constexpr.hh"
-
-constexpr static std::string_view DEFAULT_POOL_SIZE_ARG = "4";
-
-static BS::light_thread_pool* thread_pool;
-static std::deque<Task*> task_deque;
-
-static void task_process(Task* task)
-{
-    task->set_status(task_status::PROCESSING);
-    task->process();
-
-    if(task->get_status() == task_status::PROCESSING) {
-        // If the task status is still PROCESSING
-        // it can be deduced it hasn't been cancelled
-        task->set_status(task_status::COMPLETED);
-    }
-}
-
-task_status Task::get_status(void) const
-{
-    return m_status;
-}
-
-void Task::set_status(task_status status)
-{
-    m_status = status;
-}
-
-void threading::init(void)
-{
-    auto argument = io::cmdline::get("threads", DEFAULT_POOL_SIZE_ARG);
-    auto num_concurrent_threads = std::thread::hardware_concurrency();
-    unsigned int thread_pool_size;
-
-    if(num_concurrent_threads && 0 == argument.compare("max")) {
-        // Use the maximum available number of concurrent
-        // hardware threads provided by the implementation
-        thread_pool_size = num_concurrent_threads;
-    }
-    else {
-        if(num_concurrent_threads) {
-            auto result = std::from_chars(argument.data(), argument.data() + argument.size(), thread_pool_size);
-
-            if(result.ec == std::errc()) {
-                thread_pool_size = math::clamp<unsigned int>(thread_pool_size, 1U, num_concurrent_threads);
-            }
-            else {
-                thread_pool_size = 4U;
-            }
-        }
-        else {
-            auto result = std::from_chars(argument.data(), argument.data() + argument.size(), thread_pool_size);
-
-            if(result.ec == std::errc()) {
-                thread_pool_size = math::max<unsigned int>(thread_pool_size, 1U);
-            }
-            else {
-                thread_pool_size = 4U;
-            }
-        }
-    }
-
-    spdlog::info("threading: using {} threads for pooling tasks", thread_pool_size);
-
-    thread_pool = new BS::light_thread_pool(thread_pool_size);
-
-    task_deque.clear();
-}
-
-void threading::shutdown(void)
-{
-    for(auto task : task_deque) {
-        auto status = task->get_status();
-        if((status != task_status::CANCELLED) || (status != task_status::COMPLETED)) {
-            task->set_status(task_status::CANCELLED);
-        }
-    }
-
-    thread_pool->purge();
-    thread_pool->wait();
-
-    for(auto task : task_deque)
-        delete task;
-    task_deque.clear();
-
-    delete thread_pool;
-}
-
-void threading::update(void)
-{
-    auto task_iter = task_deque.cbegin();
-
-    while(task_iter != task_deque.cend()) {
-        auto task_ptr = *task_iter;
-        auto status = task_ptr->get_status();
-
-        if(status == task_status::CANCELLED) {
-            delete task_ptr;
-            task_iter = task_deque.erase(task_iter);
-            continue;
-        }
-
-        if(status == task_status::COMPLETED) {
-            task_ptr->finalize();
-            delete task_ptr;
-            task_iter = task_deque.erase(task_iter);
-            continue;
-        }
-
-        task_iter = std::next(task_iter);
-    }
-}
-
-void threading::detail::submit_new(Task* task)
-{
-    task->set_status(task_status::ENQUEUED);
-
-    static_cast<void>(thread_pool->submit_task(std::bind(&task_process, task)));
-
-    task_deque.push_back(task);
-}
+#include "core/pch.hh"

+

+#include "core/threading.hh"

+

+#include "core/io/cmdline.hh"

+

+#include "core/math/constexpr.hh"

+

+constexpr static std::string_view DEFAULT_POOL_SIZE_ARG = "4";

+

+static BS::light_thread_pool* thread_pool;

+static std::deque<Task*> task_deque;

+

+static void task_process(Task* task)

+{

+    task->set_status(task_status::PROCESSING);

+    task->process();

+

+    if(task->get_status() == task_status::PROCESSING) {

+        // If the task status is still PROCESSING

+        // it can be deduced it hasn't been cancelled

+        task->set_status(task_status::COMPLETED);

+    }

+}

+

+task_status Task::get_status(void) const

+{

+    return m_status;

+}

+

+void Task::set_status(task_status status)

+{

+    m_status = status;

+}

+

+void threading::init(void)

+{

+    auto argument = io::cmdline::get("threads", DEFAULT_POOL_SIZE_ARG);

+    auto num_concurrent_threads = std::thread::hardware_concurrency();

+    unsigned int thread_pool_size;

+

+    if(num_concurrent_threads && 0 == argument.compare("max")) {

+        // Use the maximum available number of concurrent

+        // hardware threads provided by the implementation

+        thread_pool_size = num_concurrent_threads;

+    }

+    else {

+        if(num_concurrent_threads) {

+            auto result = std::from_chars(argument.data(), argument.data() + argument.size(), thread_pool_size);

+

+            if(result.ec == std::errc()) {

+                thread_pool_size = math::clamp<unsigned int>(thread_pool_size, 1U, num_concurrent_threads);

+            }

+            else {

+                thread_pool_size = 4U;

+            }

+        }

+        else {

+            auto result = std::from_chars(argument.data(), argument.data() + argument.size(), thread_pool_size);

+

+            if(result.ec == std::errc()) {

+                thread_pool_size = math::max<unsigned int>(thread_pool_size, 1U);

+            }

+            else {

+                thread_pool_size = 4U;

+            }

+        }

+    }

+

+    spdlog::info("threading: using {} threads for pooling tasks", thread_pool_size);

+

+    thread_pool = new BS::light_thread_pool(thread_pool_size);

+

+    task_deque.clear();

+}

+

+void threading::shutdown(void)

+{

+    for(auto task : task_deque) {

+        auto status = task->get_status();

+        if((status != task_status::CANCELLED) || (status != task_status::COMPLETED)) {

+            task->set_status(task_status::CANCELLED);

+        }

+    }

+

+    thread_pool->purge();

+    thread_pool->wait();

+

+    for(auto task : task_deque)

+        delete task;

+    task_deque.clear();

+

+    delete thread_pool;

+}

+

+void threading::update(void)

+{

+    auto task_iter = task_deque.cbegin();

+

+    while(task_iter != task_deque.cend()) {

+        auto task_ptr = *task_iter;

+        auto status = task_ptr->get_status();

+

+        if(status == task_status::CANCELLED) {

+            delete task_ptr;

+            task_iter = task_deque.erase(task_iter);

+            continue;

+        }

+

+        if(status == task_status::COMPLETED) {

+            task_ptr->finalize();

+            delete task_ptr;

+            task_iter = task_deque.erase(task_iter);

+            continue;

+        }

+

+        task_iter = std::next(task_iter);

+    }

+}

+

+void threading::detail::submit_new(Task* task)

+{

+    task->set_status(task_status::ENQUEUED);

+

+    static_cast<void>(thread_pool->submit_task(std::bind(&task_process, task)));

+

+    task_deque.push_back(task);

+}

diff --git a/core/threading.hh b/core/threading.hh
index 14f17f8..2225907 100644
--- a/core/threading.hh
+++ b/core/threading.hh
@@ -1,46 +1,46 @@
-#pragma once
-
-enum class task_status : unsigned int {
-    ENQUEUED = 0x0000U,
-    PROCESSING = 0x0001U,
-    COMPLETED = 0x0002U,
-    CANCELLED = 0x0004U,
-};
-
-class Task {
-public:
-    virtual ~Task(void) = default;
-    virtual void process(void) = 0;
-    virtual void finalize(void) = 0;
-
-    task_status get_status(void) const;
-    void set_status(task_status status);
-
-protected:
-    std::atomic<task_status> m_status;
-    std::future<void> m_future;
-};
-
-namespace threading
-{
-void init(void);
-void shutdown(void);
-void update(void);
-} // namespace threading
-
-namespace threading::detail
-{
-void submit_new(Task* task);
-} // namespace threading::detail
-
-namespace threading
-{
-template<typename T, typename... AT>
-void submit(AT&&... args);
-} // namespace threading
-
-template<typename T, typename... AT>
-inline void threading::submit(AT&&... args)
-{
-    threading::detail::submit_new(new T(args...));
-}
+#pragma once

+

+enum class task_status : unsigned int {

+    ENQUEUED = 0x0000U,

+    PROCESSING = 0x0001U,

+    COMPLETED = 0x0002U,

+    CANCELLED = 0x0004U,

+};

+

+class Task {

+public:

+    virtual ~Task(void) = default;

+    virtual void process(void) = 0;

+    virtual void finalize(void) = 0;

+

+    task_status get_status(void) const;

+    void set_status(task_status status);

+

+protected:

+    std::atomic<task_status> m_status;

+    std::future<void> m_future;

+};

+

+namespace threading

+{

+void init(void);

+void shutdown(void);

+void update(void);

+} // namespace threading

+

+namespace threading::detail

+{

+void submit_new(Task* task);

+} // namespace threading::detail

+

+namespace threading

+{

+template<typename T, typename... AT>

+void submit(AT&&... args);

+} // namespace threading

+

+template<typename T, typename... AT>

+inline void threading::submit(AT&&... args)

+{

+    threading::detail::submit_new(new T(args...));

+}

diff --git a/core/utils/epoch.cc b/core/utils/epoch.cc
index 36bdb79..be5d4bd 100644
--- a/core/utils/epoch.cc
+++ b/core/utils/epoch.cc
@@ -1,39 +1,39 @@
-#include "core/pch.hh"
-
-#include "core/utils/epoch.hh"
-
-std::uint64_t utils::unix_seconds(void)
-{
-    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
-    return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(elapsed).count());
-}
-
-std::uint64_t utils::unix_milliseconds(void)
-{
-    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
-    return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count());
-}
-
-std::uint64_t utils::unix_microseconds(void)
-{
-    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
-    return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count());
-}
-
-std::int64_t utils::signed_unix_seconds(void)
-{
-    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
-    return static_cast<std::int64_t>(std::chrono::duration_cast<std::chrono::seconds>(elapsed).count());
-}
-
-std::int64_t utils::signed_unix_milliseconds(void)
-{
-    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
-    return static_cast<std::int64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count());
-}
-
-std::int64_t utils::signed_unix_microseconds(void)
-{
-    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();
-    return static_cast<std::int64_t>(std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count());
-}
+#include "core/pch.hh"

+

+#include "core/utils/epoch.hh"

+

+std::uint64_t utils::unix_seconds(void)

+{

+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();

+    return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(elapsed).count());

+}

+

+std::uint64_t utils::unix_milliseconds(void)

+{

+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();

+    return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count());

+}

+

+std::uint64_t utils::unix_microseconds(void)

+{

+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();

+    return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count());

+}

+

+std::int64_t utils::signed_unix_seconds(void)

+{

+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();

+    return static_cast<std::int64_t>(std::chrono::duration_cast<std::chrono::seconds>(elapsed).count());

+}

+

+std::int64_t utils::signed_unix_milliseconds(void)

+{

+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();

+    return static_cast<std::int64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count());

+}

+

+std::int64_t utils::signed_unix_microseconds(void)

+{

+    const auto elapsed = std::chrono::system_clock::now().time_since_epoch();

+    return static_cast<std::int64_t>(std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count());

+}

diff --git a/core/utils/epoch.hh b/core/utils/epoch.hh
index 4bf5460..1df564c 100644
--- a/core/utils/epoch.hh
+++ b/core/utils/epoch.hh
@@ -1,15 +1,15 @@
-#pragma once
-
-namespace utils
-{
-std::uint64_t unix_seconds(void);
-std::uint64_t unix_milliseconds(void);
-std::uint64_t unix_microseconds(void);
-} // namespace utils
-
-namespace utils
-{
-std::int64_t signed_unix_seconds(void);
-std::int64_t signed_unix_milliseconds(void);
-std::int64_t signed_unix_microseconds(void);
-} // namespace utils
+#pragma once

+

+namespace utils

+{

+std::uint64_t unix_seconds(void);

+std::uint64_t unix_milliseconds(void);

+std::uint64_t unix_microseconds(void);

+} // namespace utils

+

+namespace utils

+{

+std::int64_t signed_unix_seconds(void);

+std::int64_t signed_unix_milliseconds(void);

+std::int64_t signed_unix_microseconds(void);

+} // namespace utils

diff --git a/core/utils/physfs.cc b/core/utils/physfs.cc
index cb310df..b801963 100644
--- a/core/utils/physfs.cc
+++ b/core/utils/physfs.cc
@@ -1,76 +1,76 @@
-#include "core/pch.hh"
-
-#include "core/utils/physfs.hh"
-
-bool utils::read_file(std::string_view path, std::vector<std::byte>& buffer)
-{
-    auto file = PHYSFS_openRead(std::string(path).c_str());
-
-    if(file == nullptr) {
-        spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
-        return false;
-    }
-
-    PHYSFS_sint64 file_size = PHYSFS_fileLength(file);
-    buffer.resize(static_cast<std::size_t>(file_size));
-
-    PHYSFS_readBytes(file, buffer.data(), file_size);
-    PHYSFS_close(file);
-
-    return true;
-}
-
-bool utils::read_file(std::string_view path, std::string& buffer)
-{
-    auto file = PHYSFS_openRead(std::string(path).c_str());
-
-    if(file == nullptr) {
-        spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
-        return false;
-    }
-
-    PHYSFS_sint64 file_size = PHYSFS_fileLength(file);
-    buffer.resize(static_cast<std::size_t>(file_size));
-
-    PHYSFS_readBytes(file, buffer.data(), file_size);
-    PHYSFS_close(file);
-
-    return true;
-}
-
-bool utils::write_file(std::string_view path, const std::vector<std::byte>& buffer)
-{
-    auto file = PHYSFS_openWrite(std::string(path).c_str());
-
-    if(file == nullptr) {
-        spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
-        return false;
-    }
-
-    PHYSFS_writeBytes(file, buffer.data(), static_cast<PHYSFS_uint64>(buffer.size()));
-    PHYSFS_close(file);
-
-    return true;
-}
-
-bool utils::write_file(std::string_view path, const std::string& buffer)
-{
-    auto file = PHYSFS_openWrite(std::string(path).c_str());
-
-    if(file == nullptr) {
-        spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
-        return false;
-    }
-
-    PHYSFS_writeBytes(file, buffer.data(), static_cast<PHYSFS_uint64>(buffer.size()));
-    PHYSFS_close(file);
-
-    return true;
-}
-
-std::string_view utils::physfs_error(void)
-{
-    auto error_code = PHYSFS_getLastErrorCode();
-    auto error_string = PHYSFS_getErrorByCode(error_code);
-    return std::string_view(error_string, std::strlen(error_string));
-}
+#include "core/pch.hh"

+

+#include "core/utils/physfs.hh"

+

+bool utils::read_file(std::string_view path, std::vector<std::byte>& buffer)

+{

+    auto file = PHYSFS_openRead(std::string(path).c_str());

+

+    if(file == nullptr) {

+        spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));

+        return false;

+    }

+

+    PHYSFS_sint64 file_size = PHYSFS_fileLength(file);

+    buffer.resize(static_cast<std::size_t>(file_size));

+

+    PHYSFS_readBytes(file, buffer.data(), file_size);

+    PHYSFS_close(file);

+

+    return true;

+}

+

+bool utils::read_file(std::string_view path, std::string& buffer)

+{

+    auto file = PHYSFS_openRead(std::string(path).c_str());

+

+    if(file == nullptr) {

+        spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));

+        return false;

+    }

+

+    PHYSFS_sint64 file_size = PHYSFS_fileLength(file);

+    buffer.resize(static_cast<std::size_t>(file_size));

+

+    PHYSFS_readBytes(file, buffer.data(), file_size);

+    PHYSFS_close(file);

+

+    return true;

+}

+

+bool utils::write_file(std::string_view path, const std::vector<std::byte>& buffer)

+{

+    auto file = PHYSFS_openWrite(std::string(path).c_str());

+

+    if(file == nullptr) {

+        spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));

+        return false;

+    }

+

+    PHYSFS_writeBytes(file, buffer.data(), static_cast<PHYSFS_uint64>(buffer.size()));

+    PHYSFS_close(file);

+

+    return true;

+}

+

+bool utils::write_file(std::string_view path, const std::string& buffer)

+{

+    auto file = PHYSFS_openWrite(std::string(path).c_str());

+

+    if(file == nullptr) {

+        spdlog::error("physfs: {}: {}", path, PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));

+        return false;

+    }

+

+    PHYSFS_writeBytes(file, buffer.data(), static_cast<PHYSFS_uint64>(buffer.size()));

+    PHYSFS_close(file);

+

+    return true;

+}

+

+std::string_view utils::physfs_error(void)

+{

+    auto error_code = PHYSFS_getLastErrorCode();

+    auto error_string = PHYSFS_getErrorByCode(error_code);

+    return std::string_view(error_string, std::strlen(error_string));

+}

diff --git a/core/utils/physfs.hh b/core/utils/physfs.hh
index 4af94dc..220954e 100644
--- a/core/utils/physfs.hh
+++ b/core/utils/physfs.hh
@@ -1,14 +1,14 @@
-#pragma once
-
-namespace utils
-{
-bool read_file(std::string_view path, std::vector<std::byte>& buffer);
-bool read_file(std::string_view path, std::string& buffer);
-bool write_file(std::string_view path, const std::vector<std::byte>& buffer);
-bool write_file(std::string_view path, const std::string& buffer);
-} // namespace utils
-
-namespace utils
-{
-std::string_view physfs_error(void);
-} // namespace utils
+#pragma once

+

+namespace utils

+{

+bool read_file(std::string_view path, std::vector<std::byte>& buffer);

+bool read_file(std::string_view path, std::string& buffer);

+bool write_file(std::string_view path, const std::vector<std::byte>& buffer);

+bool write_file(std::string_view path, const std::string& buffer);

+} // namespace utils

+

+namespace utils

+{

+std::string_view physfs_error(void);

+} // namespace utils

diff --git a/core/utils/string.cc b/core/utils/string.cc
index dd3d567..4bdc073 100644
--- a/core/utils/string.cc
+++ b/core/utils/string.cc
@@ -1,57 +1,57 @@
-#include "core/pch.hh"
-
-#include "core/utils/string.hh"
-
-constexpr static const char* WHITESPACE_CHARS = " \t\r\n";
-
-bool utils::is_whitespace(const std::string& string)
-{
-    if(string.find_first_not_of(WHITESPACE_CHARS) == std::string::npos) {
-        return true;
-    }
-    else if((string.size() == 1) && string[0] == 0x00) {
-        return true;
-    }
-    else {
-        return string.empty();
-    }
-}
-
-std::string utils::join(const std::vector<std::string>& strings, const std::string& separator)
-{
-    std::ostringstream stream;
-    for(const std::string& str : strings)
-        stream << str << separator;
-    return stream.str();
-}
-
-std::vector<std::string> utils::split(const std::string& string, const std::string& separator)
-{
-    std::size_t pos = 0;
-    std::size_t prev = 0;
-    std::vector<std::string> result;
-
-    while((pos = string.find(separator, prev)) != std::string::npos) {
-        result.push_back(string.substr(prev, pos - prev));
-        prev = pos + separator.length();
-    }
-
-    if(prev <= string.length()) {
-        result.push_back(string.substr(prev, string.length() - prev));
-    }
-
-    return result;
-}
-
-std::string utils::trim_whitespace(const std::string& string)
-{
-    auto su = string.find_first_not_of(WHITESPACE_CHARS);
-    auto sv = string.find_last_not_of(WHITESPACE_CHARS);
-
-    if(su == std::string::npos) {
-        return std::string();
-    }
-    else {
-        return string.substr(su, sv - su + 1);
-    }
-}
+#include "core/pch.hh"

+

+#include "core/utils/string.hh"

+

+constexpr static const char* WHITESPACE_CHARS = " \t\r\n";

+

+bool utils::is_whitespace(const std::string& string)

+{

+    if(string.find_first_not_of(WHITESPACE_CHARS) == std::string::npos) {

+        return true;

+    }

+    else if((string.size() == 1) && string[0] == 0x00) {

+        return true;

+    }

+    else {

+        return string.empty();

+    }

+}

+

+std::string utils::join(const std::vector<std::string>& strings, const std::string& separator)

+{

+    std::ostringstream stream;

+    for(const std::string& str : strings)

+        stream << str << separator;

+    return stream.str();

+}

+

+std::vector<std::string> utils::split(const std::string& string, const std::string& separator)

+{

+    std::size_t pos = 0;

+    std::size_t prev = 0;

+    std::vector<std::string> result;

+

+    while((pos = string.find(separator, prev)) != std::string::npos) {

+        result.push_back(string.substr(prev, pos - prev));

+        prev = pos + separator.length();

+    }

+

+    if(prev <= string.length()) {

+        result.push_back(string.substr(prev, string.length() - prev));

+    }

+

+    return result;

+}

+

+std::string utils::trim_whitespace(const std::string& string)

+{

+    auto su = string.find_first_not_of(WHITESPACE_CHARS);

+    auto sv = string.find_last_not_of(WHITESPACE_CHARS);

+

+    if(su == std::string::npos) {

+        return std::string();

+    }

+    else {

+        return string.substr(su, sv - su + 1);

+    }

+}

diff --git a/core/utils/string.hh b/core/utils/string.hh
index 827c3ca..0e896fd 100644
--- a/core/utils/string.hh
+++ b/core/utils/string.hh
@@ -1,17 +1,17 @@
-#pragma once
-
-namespace utils
-{
-bool is_whitespace(const std::string& string);
-} // namespace utils
-
-namespace utils
-{
-std::string join(const std::vector<std::string>& strings, const std::string& separator);
-std::vector<std::string> split(const std::string& string, const std::string& separator);
-} // namespace utils
-
-namespace utils
-{
-std::string trim_whitespace(const std::string& string);
-} // namespace utils
+#pragma once

+

+namespace utils

+{

+bool is_whitespace(const std::string& string);

+} // namespace utils

+

+namespace utils

+{

+std::string join(const std::vector<std::string>& strings, const std::string& separator);

+std::vector<std::string> split(const std::string& string, const std::string& separator);

+} // namespace utils

+

+namespace utils

+{

+std::string trim_whitespace(const std::string& string);

+} // namespace utils

diff --git a/core/version.hh b/core/version.hh
index fc33374..50f128a 100644
--- a/core/version.hh
+++ b/core/version.hh
@@ -1,14 +1,14 @@
-#pragma once
-
-namespace version
-{
-extern const unsigned long major;
-extern const unsigned long minor;
-extern const unsigned long patch;
-} // namespace version
-
-namespace version
-{
-extern const std::string_view commit;
-extern const std::string_view semver;
-} // namespace version
+#pragma once

+

+namespace version

+{

+extern const unsigned long major;

+extern const unsigned long minor;

+extern const unsigned long patch;

+} // namespace version

+

+namespace version

+{

+extern const std::string_view commit;

+extern const std::string_view semver;

+} // namespace version