Graft build scripts and buffer code from QFengine

4 files changed, 202 insertions, 289 deletions

diff --git a/core/io/buffer.cc b/core/io/buffer.cc
index 62f981c..02b810e 100644
--- a/core/io/buffer.cc
+++ b/core/io/buffer.cc
@@ -4,18 +4,29 @@
 
 #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);
 }
 
@@ -31,6 +42,8 @@ const std::byte* io::ReadBuffer::data(void) const
 
 void io::ReadBuffer::reset(const void* data, std::size_t size)
 {
+    assert(data);
+
     auto bytes = reinterpret_cast<const std::byte*>(data);
     m_vector.assign(bytes, bytes + size);
     m_position = 0U;
@@ -38,6 +51,8 @@ void io::ReadBuffer::reset(const void* data, std::size_t size)
 
 void io::ReadBuffer::reset(const ENetPacket* packet)
 {
+    assert(packet);
+
     auto bytes_ptr = reinterpret_cast<const std::byte*>(packet->data);
     m_vector.assign(bytes_ptr, bytes_ptr + packet->dataLength);
     m_position = 0;
@@ -45,6 +60,8 @@ void io::ReadBuffer::reset(const ENetPacket* packet)
 
 void io::ReadBuffer::reset(PHYSFS_File* file)
 {
+    assert(file);
+
     m_vector.resize(PHYSFS_fileLength(file));
     m_position = 0;
 
@@ -52,12 +69,21 @@ void io::ReadBuffer::reset(PHYSFS_File* file)
     PHYSFS_readBytes(file, m_vector.data(), m_vector.size());
 }
 
-float io::ReadBuffer::read_FP32(void)
+template<>
+std::byte io::ReadBuffer::read<std::byte>(void)
 {
-    return math::uint32_to_float(read_UI32());
+    if(m_position < m_vector.size()) {
+        auto result = m_vector[m_position];
+        m_position += 1U;
+        return result;
+    }
+
+    m_position += 1U;
+    return static_cast<std::byte>(0x00);
 }
 
-std::uint8_t io::ReadBuffer::read_UI8(void)
+template<>
+std::uint8_t io::ReadBuffer::read<std::uint8_t>(void)
 {
     if((m_position + 1U) <= m_vector.size()) {
         auto result = static_cast<std::uint8_t>(m_vector[m_position]);
@@ -69,12 +95,13 @@ std::uint8_t io::ReadBuffer::read_UI8(void)
     return 0;
 }
 
-std::uint16_t io::ReadBuffer::read_UI16(void)
+template<>
+std::uint16_t io::ReadBuffer::read<std::uint16_t>(void)
 {
     if((m_position + 2U) <= m_vector.size()) {
         auto result = UINT16_C(0x0000);
-        result |= static_cast<std::uint16_t>(m_vector[m_position + 0U]) << 8U;
-        result |= static_cast<std::uint16_t>(m_vector[m_position + 1U]) << 0U;
+        result |= (UINT16_C(0x00FF) & static_cast<std::uint16_t>(m_vector[m_position + 0U])) << 8U;
+        result |= (UINT16_C(0x00FF) & static_cast<std::uint16_t>(m_vector[m_position + 1U])) << 0U;
         m_position += 2U;
         return result;
     }
@@ -83,14 +110,15 @@ std::uint16_t io::ReadBuffer::read_UI16(void)
     return 0;
 }
 
-std::uint32_t io::ReadBuffer::read_UI32(void)
+template<>
+std::uint32_t io::ReadBuffer::read<std::uint32_t>(void)
 {
     if((m_position + 4U) <= m_vector.size()) {
         auto result = UINT32_C(0x00000000);
-        result |= static_cast<std::uint32_t>(m_vector[m_position + 0U]) << 24U;
-        result |= static_cast<std::uint32_t>(m_vector[m_position + 1U]) << 16U;
-        result |= static_cast<std::uint32_t>(m_vector[m_position + 2U]) << 8U;
-        result |= static_cast<std::uint32_t>(m_vector[m_position + 3U]) << 0U;
+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 0U])) << 24U;
+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 1U])) << 16U;
+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 2U])) << 8U;
+        result |= (UINT32_C(0x000000FF) & static_cast<std::uint32_t>(m_vector[m_position + 3U])) << 0U;
         m_position += 4U;
         return result;
     }
@@ -99,18 +127,19 @@ std::uint32_t io::ReadBuffer::read_UI32(void)
     return 0;
 }
 
-std::uint64_t io::ReadBuffer::read_UI64(void)
+template<>
+std::uint64_t io::ReadBuffer::read<std::uint64_t>(void)
 {
     if((m_position + 8U) <= m_vector.size()) {
         auto result = UINT64_C(0x0000000000000000);
-        result |= (0x00000000000000FF & static_cast<std::uint64_t>(m_vector[m_position + 0U])) << 56U;
-        result |= (0x00000000000000FF & static_cast<std::uint64_t>(m_vector[m_position + 1U])) << 48U;
-        result |= (0x00000000000000FF & static_cast<std::uint64_t>(m_vector[m_position + 2U])) << 40U;
-        result |= (0x00000000000000FF & static_cast<std::uint64_t>(m_vector[m_position + 3U])) << 32U;
-        result |= (0x00000000000000FF & static_cast<std::uint64_t>(m_vector[m_position + 4U])) << 24U;
-        result |= (0x00000000000000FF & static_cast<std::uint64_t>(m_vector[m_position + 5U])) << 16U;
-        result |= (0x00000000000000FF & static_cast<std::uint64_t>(m_vector[m_position + 6U])) << 8U;
-        result |= (0x00000000000000FF & static_cast<std::uint64_t>(m_vector[m_position + 7U])) << 0U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 0U])) << 56U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 1U])) << 48U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 2U])) << 40U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 3U])) << 32U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 4U])) << 24U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 5U])) << 16U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 6U])) << 8U;
+        result |= (UINT64_C(0x00000000000000FF) & static_cast<std::uint64_t>(m_vector[m_position + 7U])) << 0U;
         m_position += 8U;
         return result;
     }
@@ -119,14 +148,45 @@ std::uint64_t io::ReadBuffer::read_UI64(void)
     return 0;
 }
 
-std::string io::ReadBuffer::read_string(void)
+template<>
+float io::ReadBuffer::read<float>(void)
+{
+    return std::bit_cast<float>(read<std::uint32_t>());
+}
+
+template<>
+std::int8_t io::ReadBuffer::read<std::int8_t>(void)
 {
-    auto size = static_cast<std::size_t>(read_UI16());
-    auto result = std::string();
+    return std::bit_cast<std::int8_t>(read<std::uint8_t>());
+}
 
-    for(std::size_t i = 0; i < size; ++i) {
+template<>
+std::int16_t io::ReadBuffer::read<std::int16_t>(void)
+{
+    return std::bit_cast<std::int16_t>(read<std::uint16_t>());
+}
+
+template<>
+std::int32_t io::ReadBuffer::read<std::int32_t>(void)
+{
+    return std::bit_cast<std::int32_t>(read<std::uint32_t>());
+}
+
+template<>
+std::int64_t io::ReadBuffer::read<std::int64_t>(void)
+{
+    return std::bit_cast<std::int64_t>(read<std::uint64_t>());
+}
+
+template<>
+std::string io::ReadBuffer::read<std::string>(void)
+{
+    std::string result;
+    result.resize(read<std::uint16_t>());
+
+    for(std::size_t i = 0; i < result.size(); ++i) {
         if(m_position < m_vector.size()) {
-            result.push_back(static_cast<char>(m_vector[m_position]));
+            result[i] = static_cast<char>(m_vector[m_position]);
         }
 
         m_position += 1U;
@@ -135,6 +195,23 @@ std::string io::ReadBuffer::read_string(void)
     return result;
 }
 
+void io::ReadBuffer::read(void* buffer, std::size_t size)
+{
+    auto bytes = reinterpret_cast<std::byte*>(buffer);
+    auto amount_to_read = std::min(size, m_vector.size() - m_position);
+
+    if(amount_to_read > 0) {
+        std::copy(m_vector.cbegin() + m_position, m_vector.cbegin() + m_position + amount_to_read, bytes);
+    }
+
+    m_position += size;
+}
+
+io::WriteBuffer::WriteBuffer(const WriteBuffer& other)
+{
+    m_vector = other.m_vector;
+}
+
 std::size_t io::WriteBuffer::size(void) const
 {
     return m_vector.size();
@@ -150,18 +227,40 @@ void io::WriteBuffer::reset(void)
     m_vector.clear();
 }
 
-void io::WriteBuffer::write_UI8(std::uint8_t value)
+void io::WriteBuffer::write(const WriteBuffer& other)
+{
+    m_vector.insert(m_vector.end(), other.m_vector.begin(), other.m_vector.end());
+}
+
+void io::WriteBuffer::write(const void* data, std::size_t size)
+{
+    assert(data);
+
+    auto bytes = reinterpret_cast<const std::byte*>(data);
+    m_vector.insert(m_vector.end(), bytes, bytes + size);
+}
+
+template<>
+void io::WriteBuffer::write<std::byte>(const std::byte value)
+{
+    m_vector.push_back(value);
+}
+
+template<>
+void io::WriteBuffer::write<std::uint8_t>(const std::uint8_t value)
 {
     m_vector.push_back(static_cast<std::byte>(value));
 }
 
-void io::WriteBuffer::write_UI16(std::uint16_t value)
+template<>
+void io::WriteBuffer::write<std::uint16_t>(const std::uint16_t value)
 {
     m_vector.push_back(static_cast<std::byte>(UINT16_C(0xFF) & ((value & UINT16_C(0xFF00)) >> 8U)));
     m_vector.push_back(static_cast<std::byte>(UINT16_C(0xFF) & ((value & UINT16_C(0x00FF)) >> 0U)));
 }
 
-void io::WriteBuffer::write_UI32(std::uint32_t value)
+template<>
+void io::WriteBuffer::write<std::uint32_t>(const std::uint32_t value)
 {
     m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0xFF000000)) >> 24U)));
     m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x00FF0000)) >> 16U)));
@@ -169,7 +268,8 @@ void io::WriteBuffer::write_UI32(std::uint32_t value)
     m_vector.push_back(static_cast<std::byte>(UINT32_C(0xFF) & ((value & UINT32_C(0x000000FF)) >> 0U)));
 }
 
-void io::WriteBuffer::write_UI64(std::uint64_t value)
+template<>
+void io::WriteBuffer::write<std::uint64_t>(const std::uint64_t value)
 {
     m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0xFF00000000000000)) >> 56U)));
     m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00FF000000000000)) >> 48U)));
@@ -181,25 +281,62 @@ void io::WriteBuffer::write_UI64(std::uint64_t value)
     m_vector.push_back(static_cast<std::byte>(UINT64_C(0xFF) & ((value & UINT64_C(0x00000000000000FF)) >> 0U)));
 }
 
-void io::WriteBuffer::write_string(const std::string& value)
+template<>
+void io::WriteBuffer::write(const float value)
 {
-    const std::size_t size = math::min<std::size_t>(UINT16_MAX, value.size());
+    write(std::bit_cast<std::uint32_t>(value));
+}
 
-    write_UI16(static_cast<std::uint16_t>(size));
+template<>
+void io::WriteBuffer::write(const std::int8_t value)
+{
+    write(std::bit_cast<std::uint8_t>(value));
+}
+
+template<>
+void io::WriteBuffer::write(const std::int16_t value)
+{
+    write(std::bit_cast<std::uint16_t>(value));
+}
+
+template<>
+void io::WriteBuffer::write(const std::int32_t value)
+{
+    write(std::bit_cast<std::uint32_t>(value));
+}
+
+template<>
+void io::WriteBuffer::write(const std::int64_t value)
+{
+    write(std::bit_cast<std::uint64_t>(value));
+}
+
+template<>
+void io::WriteBuffer::write<std::string_view>(const std::string_view value)
+{
+    write<std::uint16_t>(value.size());
 
-    for(std::size_t i = 0; i < size; m_vector.push_back(static_cast<std::byte>(value[i++]))) {
-        // empty
+    for(const auto& character : value) {
+        m_vector.push_back(static_cast<std::byte>(character));
     }
 }
 
-PHYSFS_File* io::WriteBuffer::to_file(const char* path, bool append) const
+PHYSFS_File* io::WriteBuffer::to_file(const std::string& path, bool append) const
 {
-    if(auto file = (append ? PHYSFS_openAppend(path) : PHYSFS_openWrite(path))) {
+    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;
     }
 
-    return nullptr;
+    return file;
 }
 
 ENetPacket* io::WriteBuffer::to_packet(enet_uint32 flags) const
diff --git a/core/io/buffer.hh b/core/io/buffer.hh
index 205381f..c301204 100644
--- a/core/io/buffer.hh
+++ b/core/io/buffer.hh
@@ -1,13 +1,12 @@
 #ifndef CORE_IO_BUFFER_HH
 #define CORE_IO_BUFFER_HH 1
 
-#include "core/math/floathacks.hh"
-
 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);
@@ -20,28 +19,16 @@ public:
     void reset(const ENetPacket* packet);
     void reset(PHYSFS_File* file);
 
-    float read_FP32(void);
-    std::uint8_t read_UI8(void);
-    std::uint16_t read_UI16(void);
-    std::uint32_t read_UI32(void);
-    std::uint64_t read_UI64(void);
-    std::string read_string(void);
+    constexpr void rewind(void);
+    constexpr bool is_ended(void) const;
+
+    void read(void* buffer, std::size_t size);
 
-    inline std::int8_t read_I8(void);
-    inline std::int16_t read_I16(void);
-    inline std::int32_t read_I32(void);
-    inline std::int64_t read_I64(void);
+    template<typename T>
+    T read(void);
 
-    inline ReadBuffer& operator>>(float& value);
-    inline ReadBuffer& operator>>(std::int8_t& value);
-    inline ReadBuffer& operator>>(std::int16_t& value);
-    inline ReadBuffer& operator>>(std::int32_t& value);
-    inline ReadBuffer& operator>>(std::int64_t& value);
-    inline ReadBuffer& operator>>(std::uint8_t& value);
-    inline ReadBuffer& operator>>(std::uint16_t& value);
-    inline ReadBuffer& operator>>(std::uint32_t& value);
-    inline ReadBuffer& operator>>(std::uint64_t& value);
-    inline ReadBuffer& operator>>(std::string& value);
+    template<typename T>
+    ReadBuffer& operator>>(T& value);
 
 private:
     std::vector<std::byte> m_vector;
@@ -54,6 +41,7 @@ namespace io
 class WriteBuffer final {
 public:
     WriteBuffer(void) = default;
+    explicit WriteBuffer(const WriteBuffer& other);
     virtual ~WriteBuffer(void) = default;
 
     std::size_t size(void) const;
@@ -61,30 +49,16 @@ public:
 
     void reset(void);
 
-    void write_FP32(float value);
-    void write_UI8(std::uint8_t value);
-    void write_UI16(std::uint16_t value);
-    void write_UI32(std::uint32_t value);
-    void write_UI64(std::uint64_t value);
-    void write_string(const std::string& value);
+    void write(const WriteBuffer& other);
+    void write(const void* data, std::size_t size);
 
-    inline void write_I8(std::int8_t value);
-    inline void write_I16(std::int16_t value);
-    inline void write_I32(std::int32_t value);
-    inline void write_I64(std::int64_t value);
+    template<typename T>
+    void write(const T value);
 
-    inline WriteBuffer& operator<<(float value);
-    inline WriteBuffer& operator<<(std::int8_t value);
-    inline WriteBuffer& operator<<(std::int16_t value);
-    inline WriteBuffer& operator<<(std::int32_t value);
-    inline WriteBuffer& operator<<(std::int64_t value);
-    inline WriteBuffer& operator<<(std::uint8_t value);
-    inline WriteBuffer& operator<<(std::uint16_t value);
-    inline WriteBuffer& operator<<(std::uint32_t value);
-    inline WriteBuffer& operator<<(std::uint64_t value);
-    inline WriteBuffer& operator<<(const std::string& value);
+    template<typename T>
+    WriteBuffer& operator<<(const T value);
 
-    PHYSFS_File* to_file(const char* path, bool append = false) const;
+    PHYSFS_File* to_file(const std::string& path, bool append = false) const;
     ENetPacket* to_packet(enet_uint32 flags = ENET_PACKET_FLAG_RELIABLE) const;
 
 private:
@@ -92,168 +66,27 @@ private:
 };
 } // namespace io
 
-inline std::int8_t io::ReadBuffer::read_I8(void)
-{
-    return static_cast<std::int8_t>(read_UI8());
-}
-
-inline std::int16_t io::ReadBuffer::read_I16(void)
-{
-    return static_cast<std::int16_t>(read_UI16());
-}
-
-inline std::int32_t io::ReadBuffer::read_I32(void)
-{
-    return static_cast<std::int32_t>(read_UI32());
-}
-
-inline std::int64_t io::ReadBuffer::read_I64(void)
-{
-    return static_cast<std::int64_t>(read_UI64());
-}
-
-inline io::ReadBuffer& io::ReadBuffer::operator>>(float& value)
-{
-    value = read_FP32();
-    return *this;
-}
-
-inline io::ReadBuffer& io::ReadBuffer::operator>>(std::int8_t& value)
-{
-    value = read_I8();
-    return *this;
-}
-
-inline io::ReadBuffer& io::ReadBuffer::operator>>(std::int16_t& value)
-{
-    value = read_I16();
-    return *this;
-}
-
-inline io::ReadBuffer& io::ReadBuffer::operator>>(std::int32_t& value)
-{
-    value = read_I32();
-    return *this;
-}
-
-inline io::ReadBuffer& io::ReadBuffer::operator>>(std::int64_t& value)
-{
-    value = read_I64();
-    return *this;
-}
-
-inline io::ReadBuffer& io::ReadBuffer::operator>>(std::uint8_t& value)
-{
-    value = read_UI8();
-    return *this;
-}
-
-inline io::ReadBuffer& io::ReadBuffer::operator>>(std::uint16_t& value)
-{
-    value = read_UI16();
-    return *this;
-}
-
-inline io::ReadBuffer& io::ReadBuffer::operator>>(std::uint32_t& value)
+constexpr void io::ReadBuffer::rewind(void)
 {
-    value = read_UI32();
-    return *this;
-}
-
-inline io::ReadBuffer& io::ReadBuffer::operator>>(std::uint64_t& value)
-{
-    value = read_UI64();
-    return *this;
+    m_position = 0;
 }
 
-inline io::ReadBuffer& io::ReadBuffer::operator>>(std::string& value)
+constexpr bool io::ReadBuffer::is_ended(void) const
 {
-    value = read_string();
-    return *this;
-}
-
-inline void io::WriteBuffer::write_FP32(float value)
-{
-    write_UI32(math::float_to_uint32(value));
-}
-
-inline void io::WriteBuffer::write_I8(std::int8_t value)
-{
-    write_UI8(static_cast<std::uint8_t>(value));
-}
-
-inline void io::WriteBuffer::write_I16(std::int16_t value)
-{
-    write_UI16(static_cast<std::uint16_t>(value));
-}
-
-inline void io::WriteBuffer::write_I32(std::int32_t value)
-{
-    write_UI32(static_cast<std::uint32_t>(value));
-}
-
-inline void io::WriteBuffer::write_I64(std::int64_t value)
-{
-    write_UI64(static_cast<std::uint64_t>(value));
-}
-
-inline io::WriteBuffer& io::WriteBuffer::operator<<(float value)
-{
-    write_FP32(value);
-    return *this;
-}
-
-inline io::WriteBuffer& io::WriteBuffer::operator<<(std::int8_t value)
-{
-    write_I8(value);
-    return *this;
-}
-
-inline io::WriteBuffer& io::WriteBuffer::operator<<(std::int16_t value)
-{
-    write_I16(value);
-    return *this;
-}
-
-inline io::WriteBuffer& io::WriteBuffer::operator<<(std::int32_t value)
-{
-    write_I32(value);
-    return *this;
-}
-
-inline io::WriteBuffer& io::WriteBuffer::operator<<(std::int64_t value)
-{
-    write_I64(value);
-    return *this;
-}
-
-inline io::WriteBuffer& io::WriteBuffer::operator<<(std::uint8_t value)
-{
-    write_UI8(value);
-    return *this;
-}
-
-inline io::WriteBuffer& io::WriteBuffer::operator<<(std::uint16_t value)
-{
-    write_UI16(value);
-    return *this;
-}
-
-inline io::WriteBuffer& io::WriteBuffer::operator<<(std::uint32_t value)
-{
-    write_UI32(value);
-    return *this;
+    return m_position >= m_vector.size();
 }
 
-inline io::WriteBuffer& io::WriteBuffer::operator<<(std::uint64_t value)
+template<typename T>
+io::ReadBuffer& io::ReadBuffer::operator>>(T& value)
 {
-    write_UI64(value);
+    value = read<T>();
     return *this;
 }
 
-inline io::WriteBuffer& io::WriteBuffer::operator<<(const std::string& value)
+template<typename T>
+io::WriteBuffer& io::WriteBuffer::operator<<(const T value)
 {
-    write_string(value);
+    write<T>(value);
     return *this;
 }
 
diff --git a/core/math/CMakeLists.txt b/core/math/CMakeLists.txt
index ab03087..692492e 100644
--- a/core/math/CMakeLists.txt
+++ b/core/math/CMakeLists.txt
@@ -6,6 +6,5 @@ target_sources(core PRIVATE
     "${CMAKE_CURRENT_LIST_DIR}/constexpr.hh"
     "${CMAKE_CURRENT_LIST_DIR}/crc64.cc"
     "${CMAKE_CURRENT_LIST_DIR}/crc64.hh"
-    "${CMAKE_CURRENT_LIST_DIR}/floathacks.hh"
     "${CMAKE_CURRENT_LIST_DIR}/randomizer.hh"
     "${CMAKE_CURRENT_LIST_DIR}/vectors.hh")
diff --git a/core/math/floathacks.hh b/core/math/floathacks.hh
deleted file mode 100644
index dc8c235..0000000
--- a/core/math/floathacks.hh
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef CORE_MATH_FLOATHACKS_HH
-#define CORE_MATH_FLOATHACKS_HH 1
-#pragma once
-
-namespace math
-{
-static inline float int32_to_float(const std::int32_t value);
-static inline float uint32_to_float(const std::uint32_t value);
-static inline std::int32_t float_to_int32(const float value);
-static inline std::uint32_t float_to_uint32(const float value);
-} // namespace math
-
-static_assert(std::numeric_limits<float>::is_iec559, "Floathacks only works with IEEE 754 compliant floats");
-static_assert(sizeof(std::int32_t) == sizeof(float), "Floathacks requires 32-bit integers to match float size");
-
-static inline float math::int32_to_float(const std::int32_t value)
-{
-    union {
-        std::int32_t src;
-        float dst;
-    } hack;
-    hack.src = value;
-    return hack.dst;
-}
-
-static inline float math::uint32_to_float(const std::uint32_t value)
-{
-    union {
-        std::uint32_t src;
-        float dst;
-    } hack;
-    hack.src = value;
-    return hack.dst;
-}
-
-static inline std::int32_t math::float_to_int32(const float value)
-{
-    union {
-        float src;
-        std::int32_t dst;
-    } hack;
-    hack.src = value;
-    return hack.dst;
-}
-
-static inline std::uint32_t math::float_to_uint32(const float value)
-{
-    union {
-        float src;
-        std::uint32_t dst;
-    } hack;
-    hack.src = value;
-    return hack.dst;
-}
-
-#endif // CORE_MATH_FLOATHACKS_HH