From d0fbd68055e3f4a796330cc8acc6c0954b5327ff Mon Sep 17 00:00:00 2001 From: untodesu Date: Thu, 11 Sep 2025 15:48:53 +0500 Subject: Run clang-format across the project --- core/config/boolean.cc | 86 +++--- core/config/boolean.hh | 50 ++-- core/config/ivalue.hh | 22 +- core/config/number.hh | 260 ++++++++--------- core/config/string.cc | 36 +-- core/config/string.hh | 62 ++--- core/io/buffer.cc | 690 +++++++++++++++++++++++----------------------- core/io/buffer.hh | 176 ++++++------ core/io/cmdline.cc | 190 ++++++------- core/io/cmdline.hh | 22 +- core/io/config_map.cc | 272 +++++++++--------- core/io/config_map.hh | 58 ++-- core/math/aabb.cc | 118 ++++---- core/math/aabb.hh | 56 ++-- core/math/angles.hh | 206 +++++++------- core/math/concepts.hh | 22 +- core/math/constexpr.hh | 396 +++++++++++++------------- core/math/crc64.cc | 142 +++++----- core/math/crc64.hh | 16 +- core/math/randomizer.hh | 112 ++++---- core/math/vectors.hh | 86 +++--- core/pch.hh | 98 +++---- core/resource/image.cc | 162 +++++------ core/resource/image.hh | 22 +- core/resource/resource.cc | 258 ++++++++--------- core/resource/resource.hh | 106 +++---- core/threading.cc | 256 ++++++++--------- core/threading.hh | 92 +++---- core/utils/epoch.cc | 78 +++--- core/utils/epoch.hh | 30 +- core/utils/physfs.cc | 152 +++++----- core/utils/physfs.hh | 28 +- core/utils/string.cc | 114 ++++---- core/utils/string.hh | 34 +-- core/version.hh | 28 +- 35 files changed, 2268 insertions(+), 2268 deletions(-) (limited to 'core') 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 -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 { -public: - using Number::Number; -}; - -class Float final : public Number { -public: - using Number::Number; -}; - -class Unsigned final : public Number { -public: - using Number::Number; -}; - -class Unsigned64 final : public Number { -public: - using Number::Number; -}; - -class SizeType final : public Number { -public: - using Number::Number; -}; -} // namespace config - -template -inline config::Number::Number(T default_value) -{ - m_value = default_value; - m_min_value = std::numeric_limits::lowest(); - m_max_value = std::numeric_limits::max(); - m_string = std::to_string(default_value); -} - -template -inline config::Number::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 -inline void config::Number::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 -inline std::string_view config::Number::get(void) const -{ - return m_string; -} - -template -inline T config::Number::get_value(void) const -{ - return m_value; -} - -template -inline void config::Number::set_value(T value) -{ - m_value = std::clamp(value, m_min_value, m_max_value); - m_string = std::to_string(m_value); -} - -template -inline T config::Number::get_min_value(void) const -{ - return m_min_value; -} - -template -inline T config::Number::get_max_value(void) const -{ - return m_max_value; -} - -template -inline void config::Number::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 +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 { +public: + using Number::Number; +}; + +class Float final : public Number { +public: + using Number::Number; +}; + +class Unsigned final : public Number { +public: + using Number::Number; +}; + +class Unsigned64 final : public Number { +public: + using Number::Number; +}; + +class SizeType final : public Number { +public: + using Number::Number; +}; +} // namespace config + +template +inline config::Number::Number(T default_value) +{ + m_value = default_value; + m_min_value = std::numeric_limits::lowest(); + m_max_value = std::numeric_limits::max(); + m_string = std::to_string(default_value); +} + +template +inline config::Number::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 +inline void config::Number::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 +inline std::string_view config::Number::get(void) const +{ + return m_string; +} + +template +inline T config::Number::get_value(void) const +{ + return m_value; +} + +template +inline void config::Number::set_value(T value) +{ + m_value = std::clamp(value, m_min_value, m_max_value); + m_string = std::to_string(m_value); +} + +template +inline T config::Number::get_min_value(void) const +{ + return m_min_value; +} + +template +inline T config::Number::get_max_value(void) const +{ + return m_max_value; +} + +template +inline void config::Number::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(data); - m_vector.assign(bytes, bytes + size); - m_position = 0U; -} - -void io::ReadBuffer::reset(const ENetPacket* packet) -{ - assert(packet); - - auto bytes_ptr = reinterpret_cast(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(void) -{ - if(m_position < m_vector.size()) { - auto result = m_vector[m_position]; - m_position += 1U; - return result; - } - - m_position += 1U; - return static_cast(0x00); -} - -template<> -std::uint8_t io::ReadBuffer::read(void) -{ - if((m_position + 1U) <= m_vector.size()) { - auto result = static_cast(m_vector[m_position]); - m_position += 1U; - return result; - } - - m_position += 1U; - return 0; -} - -template<> -std::uint16_t io::ReadBuffer::read(void) -{ - if((m_position + 2U) <= m_vector.size()) { - auto result = UINT16_C(0x0000); - result |= (UINT16_C(0x00FF) & static_cast(m_vector[m_position + 0U])) << 8U; - result |= (UINT16_C(0x00FF) & static_cast(m_vector[m_position + 1U])) << 0U; - m_position += 2U; - return result; - } - - m_position += 2U; - return 0; -} - -template<> -std::uint32_t io::ReadBuffer::read(void) -{ - if((m_position + 4U) <= m_vector.size()) { - auto result = UINT32_C(0x00000000); - result |= (UINT32_C(0x000000FF) & static_cast(m_vector[m_position + 0U])) << 24U; - result |= (UINT32_C(0x000000FF) & static_cast(m_vector[m_position + 1U])) << 16U; - result |= (UINT32_C(0x000000FF) & static_cast(m_vector[m_position + 2U])) << 8U; - result |= (UINT32_C(0x000000FF) & static_cast(m_vector[m_position + 3U])) << 0U; - m_position += 4U; - return result; - } - - m_position += 4U; - return 0; -} - -template<> -std::uint64_t io::ReadBuffer::read(void) -{ - if((m_position + 8U) <= m_vector.size()) { - auto result = UINT64_C(0x0000000000000000); - result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 0U])) << 56U; - result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 1U])) << 48U; - result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 2U])) << 40U; - result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 3U])) << 32U; - result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 4U])) << 24U; - result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 5U])) << 16U; - result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 6U])) << 8U; - result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 7U])) << 0U; - m_position += 8U; - return result; - } - - m_position += 8U; - return 0; -} - -template<> -float io::ReadBuffer::read(void) -{ - return std::bit_cast(read()); -} - -template<> -std::int8_t io::ReadBuffer::read(void) -{ - return std::bit_cast(read()); -} - -template<> -std::int16_t io::ReadBuffer::read(void) -{ - return std::bit_cast(read()); -} - -template<> -std::int32_t io::ReadBuffer::read(void) -{ - return std::bit_cast(read()); -} - -template<> -std::int64_t io::ReadBuffer::read(void) -{ - return std::bit_cast(read()); -} - -template<> -std::string io::ReadBuffer::read(void) -{ - std::string result; - result.resize(read()); - - for(std::size_t i = 0; i < result.size(); ++i) { - if(m_position < m_vector.size()) { - result[i] = static_cast(m_vector[m_position]); - } - - m_position += 1U; - } - - return result; -} - -void io::ReadBuffer::read(void* buffer, std::size_t size) -{ - auto bytes = reinterpret_cast(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(data); - m_vector.insert(m_vector.end(), bytes, bytes + size); -} - -template<> -void io::WriteBuffer::write(const std::byte value) -{ - m_vector.push_back(value); -} - -template<> -void io::WriteBuffer::write(const std::uint8_t value) -{ - m_vector.push_back(static_cast(value)); -} - -template<> -void io::WriteBuffer::write(const std::uint16_t value) -{ - m_vector.push_back(static_cast(UINT16_C(0xFF) & ((value & UINT16_C(0xFF00)) >> 8U))); - m_vector.push_back(static_cast(UINT16_C(0xFF) & ((value & UINT16_C(0x00FF)) >> 0U))); -} - -template<> -void io::WriteBuffer::write(const std::uint32_t value) -{ - m_vector.push_back(static_cast(UINT32_C(0xFF) & ((value & UINT32_C(0xFF000000)) >> 24U))); - m_vector.push_back(static_cast(UINT32_C(0xFF) & ((value & UINT32_C(0x00FF0000)) >> 16U))); - m_vector.push_back(static_cast(UINT32_C(0xFF) & ((value & UINT32_C(0x0000FF00)) >> 8U))); - m_vector.push_back(static_cast(UINT32_C(0xFF) & ((value & UINT32_C(0x000000FF)) >> 0U))); -} - -template<> -void io::WriteBuffer::write(const std::uint64_t value) -{ - m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0xFF00000000000000)) >> 56U))); - m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x00FF000000000000)) >> 48U))); - m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x0000FF0000000000)) >> 40U))); - m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x000000FF00000000)) >> 32U))); - m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000FF000000)) >> 24U))); - m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x0000000000FF0000)) >> 16U))); - m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x000000000000FF00)) >> 8U))); - m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000000000FF)) >> 0U))); -} - -template<> -void io::WriteBuffer::write(const float value) -{ - write(std::bit_cast(value)); -} - -template<> -void io::WriteBuffer::write(const std::int8_t value) -{ - write(std::bit_cast(value)); -} - -template<> -void io::WriteBuffer::write(const std::int16_t value) -{ - write(std::bit_cast(value)); -} - -template<> -void io::WriteBuffer::write(const std::int32_t value) -{ - write(std::bit_cast(value)); -} - -template<> -void io::WriteBuffer::write(const std::int64_t value) -{ - write(std::bit_cast(value)); -} - -template<> -void io::WriteBuffer::write(const std::string_view value) -{ - write(value.size()); - - for(const auto& character : value) { - m_vector.push_back(static_cast(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(data); + m_vector.assign(bytes, bytes + size); + m_position = 0U; +} + +void io::ReadBuffer::reset(const ENetPacket* packet) +{ + assert(packet); + + auto bytes_ptr = reinterpret_cast(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(void) +{ + if(m_position < m_vector.size()) { + auto result = m_vector[m_position]; + m_position += 1U; + return result; + } + + m_position += 1U; + return static_cast(0x00); +} + +template<> +std::uint8_t io::ReadBuffer::read(void) +{ + if((m_position + 1U) <= m_vector.size()) { + auto result = static_cast(m_vector[m_position]); + m_position += 1U; + return result; + } + + m_position += 1U; + return 0; +} + +template<> +std::uint16_t io::ReadBuffer::read(void) +{ + if((m_position + 2U) <= m_vector.size()) { + auto result = UINT16_C(0x0000); + result |= (UINT16_C(0x00FF) & static_cast(m_vector[m_position + 0U])) << 8U; + result |= (UINT16_C(0x00FF) & static_cast(m_vector[m_position + 1U])) << 0U; + m_position += 2U; + return result; + } + + m_position += 2U; + return 0; +} + +template<> +std::uint32_t io::ReadBuffer::read(void) +{ + if((m_position + 4U) <= m_vector.size()) { + auto result = UINT32_C(0x00000000); + result |= (UINT32_C(0x000000FF) & static_cast(m_vector[m_position + 0U])) << 24U; + result |= (UINT32_C(0x000000FF) & static_cast(m_vector[m_position + 1U])) << 16U; + result |= (UINT32_C(0x000000FF) & static_cast(m_vector[m_position + 2U])) << 8U; + result |= (UINT32_C(0x000000FF) & static_cast(m_vector[m_position + 3U])) << 0U; + m_position += 4U; + return result; + } + + m_position += 4U; + return 0; +} + +template<> +std::uint64_t io::ReadBuffer::read(void) +{ + if((m_position + 8U) <= m_vector.size()) { + auto result = UINT64_C(0x0000000000000000); + result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 0U])) << 56U; + result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 1U])) << 48U; + result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 2U])) << 40U; + result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 3U])) << 32U; + result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 4U])) << 24U; + result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 5U])) << 16U; + result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 6U])) << 8U; + result |= (UINT64_C(0x00000000000000FF) & static_cast(m_vector[m_position + 7U])) << 0U; + m_position += 8U; + return result; + } + + m_position += 8U; + return 0; +} + +template<> +float io::ReadBuffer::read(void) +{ + return std::bit_cast(read()); +} + +template<> +std::int8_t io::ReadBuffer::read(void) +{ + return std::bit_cast(read()); +} + +template<> +std::int16_t io::ReadBuffer::read(void) +{ + return std::bit_cast(read()); +} + +template<> +std::int32_t io::ReadBuffer::read(void) +{ + return std::bit_cast(read()); +} + +template<> +std::int64_t io::ReadBuffer::read(void) +{ + return std::bit_cast(read()); +} + +template<> +std::string io::ReadBuffer::read(void) +{ + std::string result; + result.resize(read()); + + for(std::size_t i = 0; i < result.size(); ++i) { + if(m_position < m_vector.size()) { + result[i] = static_cast(m_vector[m_position]); + } + + m_position += 1U; + } + + return result; +} + +void io::ReadBuffer::read(void* buffer, std::size_t size) +{ + auto bytes = reinterpret_cast(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(data); + m_vector.insert(m_vector.end(), bytes, bytes + size); +} + +template<> +void io::WriteBuffer::write(const std::byte value) +{ + m_vector.push_back(value); +} + +template<> +void io::WriteBuffer::write(const std::uint8_t value) +{ + m_vector.push_back(static_cast(value)); +} + +template<> +void io::WriteBuffer::write(const std::uint16_t value) +{ + m_vector.push_back(static_cast(UINT16_C(0xFF) & ((value & UINT16_C(0xFF00)) >> 8U))); + m_vector.push_back(static_cast(UINT16_C(0xFF) & ((value & UINT16_C(0x00FF)) >> 0U))); +} + +template<> +void io::WriteBuffer::write(const std::uint32_t value) +{ + m_vector.push_back(static_cast(UINT32_C(0xFF) & ((value & UINT32_C(0xFF000000)) >> 24U))); + m_vector.push_back(static_cast(UINT32_C(0xFF) & ((value & UINT32_C(0x00FF0000)) >> 16U))); + m_vector.push_back(static_cast(UINT32_C(0xFF) & ((value & UINT32_C(0x0000FF00)) >> 8U))); + m_vector.push_back(static_cast(UINT32_C(0xFF) & ((value & UINT32_C(0x000000FF)) >> 0U))); +} + +template<> +void io::WriteBuffer::write(const std::uint64_t value) +{ + m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0xFF00000000000000)) >> 56U))); + m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x00FF000000000000)) >> 48U))); + m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x0000FF0000000000)) >> 40U))); + m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x000000FF00000000)) >> 32U))); + m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000FF000000)) >> 24U))); + m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x0000000000FF0000)) >> 16U))); + m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x000000000000FF00)) >> 8U))); + m_vector.push_back(static_cast(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000000000FF)) >> 0U))); +} + +template<> +void io::WriteBuffer::write(const float value) +{ + write(std::bit_cast(value)); +} + +template<> +void io::WriteBuffer::write(const std::int8_t value) +{ + write(std::bit_cast(value)); +} + +template<> +void io::WriteBuffer::write(const std::int16_t value) +{ + write(std::bit_cast(value)); +} + +template<> +void io::WriteBuffer::write(const std::int32_t value) +{ + write(std::bit_cast(value)); +} + +template<> +void io::WriteBuffer::write(const std::int64_t value) +{ + write(std::bit_cast(value)); +} + +template<> +void io::WriteBuffer::write(const std::string_view value) +{ + write(value.size()); + + for(const auto& character : value) { + m_vector.push_back(static_cast(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 - T read(void); - - template - ReadBuffer& operator>>(T& value); - -private: - std::vector 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 - void write(const T value); - - template - 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 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 -io::ReadBuffer& io::ReadBuffer::operator>>(T& value) -{ - value = read(); - return *this; -} - -template -io::WriteBuffer& io::WriteBuffer::operator<<(const T value) -{ - write(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 + T read(void); + + template + ReadBuffer& operator>>(T& value); + +private: + std::vector 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 + void write(const T value); + + template + 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 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 +io::ReadBuffer& io::ReadBuffer::operator>>(T& value) +{ + value = read(); + return *this; +} + +template +io::WriteBuffer& io::WriteBuffer::operator<<(const T value) +{ + write(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 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 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 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 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 -concept Arithmetic = std::is_arithmetic_v; -template -concept Integer = std::is_integral_v; -template -concept FloatingPoint = std::is_floating_point_v; -} // namespace math +#pragma once + +namespace math +{ +template +concept Arithmetic = std::is_arithmetic_v; +template +concept Integer = std::is_integral_v; +template +concept FloatingPoint = std::is_floating_point_v; +} // 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 -constexpr static inline const T abs(const T x); -template -constexpr static inline const std::size_t array_size(const T (&)[L]); -template -constexpr static inline const T ceil(const F x); -template -constexpr static inline const T degrees(const T x); -template -constexpr static inline const T floor(const F x); -template -constexpr static inline const T clamp(const T x, const T min, const T max); -template -constexpr static inline const T lerp(const T x, const T y, const F a); -template -constexpr static inline const T log2(const T x); -template -constexpr static inline const T max(const T x, const T y); -template -constexpr static inline const T min(const T x, const T y); -template -requires std::is_signed_v -constexpr static inline const T mod_signed(const T x, const T m); -template -constexpr static inline const T pow2(const T x); -template -constexpr static inline const T radians(const T x); -template -constexpr static inline const bool range(const T x, const T min, const T max); -template -constexpr static inline const T sign(const F x); -template -constexpr static inline const T smoothstep(const T x, const T y, const F a); -} // namespace math - -template -constexpr static inline const T math::abs(const T x) -{ - if(x < static_cast(0)) { - return -x; - } - else { - return x; - } -} - -template -constexpr static inline const std::size_t math::array_size(const T (&)[L]) -{ - return L; -} - -template -constexpr static inline const T math::ceil(const F x) -{ - const T ival = static_cast(x); - - if(ival < x) { - return ival + static_cast(1); - } - else { - return ival; - } -} - -template -constexpr static inline const T math::degrees(const T x) -{ - return x * static_cast(180.0) / static_cast(M_PI); -} - -template -constexpr static inline const T math::floor(const F x) -{ - const T ival = static_cast(x); - - if(ival > x) { - return ival - static_cast(1); - } - else { - return ival; - } -} - -template -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 -constexpr static inline const T math::lerp(const T x, const T y, const F a) -{ - return static_cast(static_cast(x) * (static_cast(1.0f) - a) + static_cast(y) * a); -} - -template -constexpr static inline const T math::log2(const T x) -{ - if(x < 2) { - return 0; - } - else { - return math::log2((x + 1) >> 1) + 1; - } -} - -template -constexpr static inline const T math::max(const T x, const T y) -{ - if(x < y) { - return y; - } - else { - return x; - } -} - -template -constexpr static inline const T math::min(const T x, const T y) -{ - if(x > y) { - return y; - } - else { - return x; - } -} - -template -requires std::is_signed_v -constexpr static inline const T math::mod_signed(const T x, const T m) -{ - auto result = static_cast(x % m); - - if(result < T(0)) { - return result + m; - } - else { - return result; - } -} - -template -constexpr static inline const T math::pow2(const T x) -{ - T value = static_cast(1); - while(value < x) - value *= static_cast(2); - return value; -} - -template -constexpr static inline const T math::radians(const T x) -{ - return x * static_cast(M_PI) / static_cast(180.0); -} - -template -constexpr static inline const bool math::range(const T x, const T min, const T max) -{ - return ((x >= min) && (x <= max)); -} - -template -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 -constexpr static inline const T math::smoothstep(const T x, const T y, const F a) -{ - const F t = math::clamp((a - x) / (y - x), F(0), F(1)); - return static_cast(t * t * (F(3) - F(2) * t)); -} +#pragma once + +#include "core/math/concepts.hh" + +namespace math +{ +template +constexpr static inline const T abs(const T x); +template +constexpr static inline const std::size_t array_size(const T (&)[L]); +template +constexpr static inline const T ceil(const F x); +template +constexpr static inline const T degrees(const T x); +template +constexpr static inline const T floor(const F x); +template +constexpr static inline const T clamp(const T x, const T min, const T max); +template +constexpr static inline const T lerp(const T x, const T y, const F a); +template +constexpr static inline const T log2(const T x); +template +constexpr static inline const T max(const T x, const T y); +template +constexpr static inline const T min(const T x, const T y); +template +requires std::is_signed_v +constexpr static inline const T mod_signed(const T x, const T m); +template +constexpr static inline const T pow2(const T x); +template +constexpr static inline const T radians(const T x); +template +constexpr static inline const bool range(const T x, const T min, const T max); +template +constexpr static inline const T sign(const F x); +template +constexpr static inline const T smoothstep(const T x, const T y, const F a); +} // namespace math + +template +constexpr static inline const T math::abs(const T x) +{ + if(x < static_cast(0)) { + return -x; + } + else { + return x; + } +} + +template +constexpr static inline const std::size_t math::array_size(const T (&)[L]) +{ + return L; +} + +template +constexpr static inline const T math::ceil(const F x) +{ + const T ival = static_cast(x); + + if(ival < x) { + return ival + static_cast(1); + } + else { + return ival; + } +} + +template +constexpr static inline const T math::degrees(const T x) +{ + return x * static_cast(180.0) / static_cast(M_PI); +} + +template +constexpr static inline const T math::floor(const F x) +{ + const T ival = static_cast(x); + + if(ival > x) { + return ival - static_cast(1); + } + else { + return ival; + } +} + +template +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 +constexpr static inline const T math::lerp(const T x, const T y, const F a) +{ + return static_cast(static_cast(x) * (static_cast(1.0f) - a) + static_cast(y) * a); +} + +template +constexpr static inline const T math::log2(const T x) +{ + if(x < 2) { + return 0; + } + else { + return math::log2((x + 1) >> 1) + 1; + } +} + +template +constexpr static inline const T math::max(const T x, const T y) +{ + if(x < y) { + return y; + } + else { + return x; + } +} + +template +constexpr static inline const T math::min(const T x, const T y) +{ + if(x > y) { + return y; + } + else { + return x; + } +} + +template +requires std::is_signed_v +constexpr static inline const T math::mod_signed(const T x, const T m) +{ + auto result = static_cast(x % m); + + if(result < T(0)) { + return result + m; + } + else { + return result; + } +} + +template +constexpr static inline const T math::pow2(const T x) +{ + T value = static_cast(1); + while(value < x) + value *= static_cast(2); + return value; +} + +template +constexpr static inline const T math::radians(const T x) +{ + return x * static_cast(M_PI) / static_cast(180.0); +} + +template +constexpr static inline const bool math::range(const T x, const T min, const T max) +{ + return ((x >= min) && (x <= max)); +} + +template +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 +constexpr static inline const T math::smoothstep(const T x, const T y, const F a) +{ + const F t = math::clamp((a - x) / (y - x), F(0), F(1)); + return static_cast(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(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& 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(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& 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& 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& 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 -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 m_vector; - std::mt19937_64 m_twister; - std::uniform_int_distribution m_dist; -}; -} // namespace math - -template -inline math::Randomizer::Randomizer(void) -{ - m_vector.clear(); - m_twister.seed(std::random_device()()); - m_dist = std::uniform_int_distribution(0, 0); -} - -template -inline math::Randomizer::Randomizer(std::uint64_t seed) -{ - m_vector.clear(); - m_twister.seed(seed); - m_dist = std::uniform_int_distribution(0, 0); -} - -template -inline void math::Randomizer::add(const T& value) -{ - m_vector.push_back(value); - m_dist = std::uniform_int_distribution(0, m_vector.size() - 1); -} - -template -inline const T& math::Randomizer::get(void) -{ - return m_vector.at(m_dist(m_twister)); -} - -template -inline void math::Randomizer::clear(void) -{ - m_vector.clear(); - m_dist = std::uniform_int_distribution(0, 0); -} +#pragma once + +namespace math +{ +template +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 m_vector; + std::mt19937_64 m_twister; + std::uniform_int_distribution m_dist; +}; +} // namespace math + +template +inline math::Randomizer::Randomizer(void) +{ + m_vector.clear(); + m_twister.seed(std::random_device()()); + m_dist = std::uniform_int_distribution(0, 0); +} + +template +inline math::Randomizer::Randomizer(std::uint64_t seed) +{ + m_vector.clear(); + m_twister.seed(seed); + m_dist = std::uniform_int_distribution(0, 0); +} + +template +inline void math::Randomizer::add(const T& value) +{ + m_vector.push_back(value); + m_dist = std::uniform_int_distribution(0, m_vector.size() - 1); +} + +template +inline const T& math::Randomizer::get(void) +{ + return m_vector.at(m_dist(m_twister)); +} + +template +inline void math::Randomizer::clear(void) +{ + m_vector.clear(); + m_dist = std::uniform_int_distribution(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 -constexpr static inline const T length2(const glm::vec<2, T>& vector); -template -constexpr static inline const T length2(const glm::vec<3, T>& vector); -template -constexpr static inline const T distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b); -template -constexpr static inline const T distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b); -} // namespace math - -template -constexpr static inline const T math::length2(const glm::vec<2, T>& vector) -{ - return (vector.x * vector.x) + (vector.y * vector.y); -} - -template -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 -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 -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 +constexpr static inline const T length2(const glm::vec<2, T>& vector); +template +constexpr static inline const T length2(const glm::vec<3, T>& vector); +template +constexpr static inline const T distance2(const glm::vec<2, T>& vector_a, const glm::vec<2, T>& vector_b); +template +constexpr static inline const T distance2(const glm::vec<3, T>& vector_a, const glm::vec<3, T>& vector_b); +} // namespace math + +template +constexpr static inline const T math::length2(const glm::vec<2, T>& vector) +{ + return (vector.x * vector.x) + (vector.y * vector.y); +} + +template +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 +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 +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 -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include - -#include - -#include - -#include -#include -#include -#include - -#include -#include -#include - -#include - -#include - -#include -#include +#pragma once + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include + +#include + +#include +#include +#include +#include + +#include +#include +#include + +#include + +#include + +#include +#include 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(context), data, size); -} - -static void stbi_physfs_skip(void* context, int count) -{ - auto file = reinterpret_cast(context); - PHYSFS_seek(file, PHYSFS_tell(file) + count); -} - -static int stbi_physfs_eof(void* context) -{ - return PHYSFS_eof(reinterpret_cast(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(resource); - stbi_image_free(image->pixels); - - delete image; -} - -void Image::register_resource(void) -{ - resource::register_loader(&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(context), data, size); +} + +static void stbi_physfs_skip(void* context, int count) +{ + auto file = reinterpret_cast(context); + PHYSFS_seek(file, PHYSFS_tell(file) + count); +} + +static int stbi_physfs_eof(void* context) +{ + return PHYSFS_eof(reinterpret_cast(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(resource); + stbi_image_free(image->pixels); + + delete image; +} + +void Image::register_resource(void) +{ + resource::register_loader(&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> resources; - std::vector> cache; - std::string class_name; -}; - -namespace -{ -emhash8::HashMap> 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(); - 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 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 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 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> resources; + std::vector> cache; + std::string class_name; +}; + +namespace +{ +emhash8::HashMap> 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(); + 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 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 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 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 -using resource_ptr = std::shared_ptr; - -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 load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags); -resource_ptr find_resource(const std::type_info& type, std::string_view name); -} // namespace resource::detail - -namespace resource -{ -template -void register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func); -template -resource_ptr load(std::string_view name, std::uint32_t flags = 0U); -template -resource_ptr find(std::string_view name); -} // namespace resource - -namespace resource -{ -void hard_cleanup(void); -void soft_cleanup(void); -} // namespace resource - -template -void resource::register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func) -{ - resource::detail::register_loader(typeid(T), load_func, free_func); -} - -template -resource_ptr 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(result); -} - -template -resource_ptr resource::find(std::string_view name) -{ - auto result = resource::detail::find_resource(typeid(T), name); - return std::reinterpret_pointer_cast(result); -} +#pragma once + +template +using resource_ptr = std::shared_ptr; + +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 load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags); +resource_ptr find_resource(const std::type_info& type, std::string_view name); +} // namespace resource::detail + +namespace resource +{ +template +void register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func); +template +resource_ptr load(std::string_view name, std::uint32_t flags = 0U); +template +resource_ptr find(std::string_view name); +} // namespace resource + +namespace resource +{ +void hard_cleanup(void); +void soft_cleanup(void); +} // namespace resource + +template +void resource::register_loader(ResourceLoadFunc load_func, ResourceFreeFunc free_func) +{ + resource::detail::register_loader(typeid(T), load_func, free_func); +} + +template +resource_ptr 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(result); +} + +template +resource_ptr resource::find(std::string_view name) +{ + auto result = resource::detail::find_resource(typeid(T), name); + return std::reinterpret_pointer_cast(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_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(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(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(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_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(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(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(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 m_status; - std::future 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 -void submit(AT&&... args); -} // namespace threading - -template -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 m_status; + std::future 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 +void submit(AT&&... args); +} // namespace threading + +template +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::chrono::duration_cast(elapsed).count()); -} - -std::uint64_t utils::unix_milliseconds(void) -{ - const auto elapsed = std::chrono::system_clock::now().time_since_epoch(); - return static_cast(std::chrono::duration_cast(elapsed).count()); -} - -std::uint64_t utils::unix_microseconds(void) -{ - const auto elapsed = std::chrono::system_clock::now().time_since_epoch(); - return static_cast(std::chrono::duration_cast(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::chrono::duration_cast(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::chrono::duration_cast(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::chrono::duration_cast(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::chrono::duration_cast(elapsed).count()); +} + +std::uint64_t utils::unix_milliseconds(void) +{ + const auto elapsed = std::chrono::system_clock::now().time_since_epoch(); + return static_cast(std::chrono::duration_cast(elapsed).count()); +} + +std::uint64_t utils::unix_microseconds(void) +{ + const auto elapsed = std::chrono::system_clock::now().time_since_epoch(); + return static_cast(std::chrono::duration_cast(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::chrono::duration_cast(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::chrono::duration_cast(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::chrono::duration_cast(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& 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(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(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& 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(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(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& 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(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(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& 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(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(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& buffer); -bool read_file(std::string_view path, std::string& buffer); -bool write_file(std::string_view path, const std::vector& 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& buffer); +bool read_file(std::string_view path, std::string& buffer); +bool write_file(std::string_view path, const std::vector& 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& strings, const std::string& separator) -{ - std::ostringstream stream; - for(const std::string& str : strings) - stream << str << separator; - return stream.str(); -} - -std::vector utils::split(const std::string& string, const std::string& separator) -{ - std::size_t pos = 0; - std::size_t prev = 0; - std::vector 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& strings, const std::string& separator) +{ + std::ostringstream stream; + for(const std::string& str : strings) + stream << str << separator; + return stream.str(); +} + +std::vector utils::split(const std::string& string, const std::string& separator) +{ + std::size_t pos = 0; + std::size_t prev = 0; + std::vector 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& strings, const std::string& separator); -std::vector 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& strings, const std::string& separator); +std::vector 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 -- cgit