From 96bd73ae020ecca1f94698744c77498a89ad19f7 Mon Sep 17 00:00:00 2001 From: untodesu Date: Thu, 11 Sep 2025 13:10:52 +0500 Subject: Graft build scripts and buffer code from QFengine --- core/io/buffer.cc | 213 ++++++++++++++++++++++++++++++++++++++++++---------- core/io/buffer.hh | 221 +++++++----------------------------------------------- 2 files changed, 202 insertions(+), 232 deletions(-) (limited to 'core/io') 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(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(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(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(0x00); } -std::uint8_t io::ReadBuffer::read_UI8(void) +template<> +std::uint8_t io::ReadBuffer::read(void) { if((m_position + 1U) <= m_vector.size()) { auto result = static_cast(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(void) { if((m_position + 2U) <= m_vector.size()) { auto result = UINT16_C(0x0000); - result |= static_cast(m_vector[m_position + 0U]) << 8U; - result |= static_cast(m_vector[m_position + 1U]) << 0U; + 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; } @@ -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(void) { if((m_position + 4U) <= m_vector.size()) { auto result = UINT32_C(0x00000000); - result |= static_cast(m_vector[m_position + 0U]) << 24U; - result |= static_cast(m_vector[m_position + 1U]) << 16U; - result |= static_cast(m_vector[m_position + 2U]) << 8U; - result |= static_cast(m_vector[m_position + 3U]) << 0U; + 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; } @@ -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(void) { if((m_position + 8U) <= m_vector.size()) { auto result = UINT64_C(0x0000000000000000); - result |= (0x00000000000000FF & static_cast(m_vector[m_position + 0U])) << 56U; - result |= (0x00000000000000FF & static_cast(m_vector[m_position + 1U])) << 48U; - result |= (0x00000000000000FF & static_cast(m_vector[m_position + 2U])) << 40U; - result |= (0x00000000000000FF & static_cast(m_vector[m_position + 3U])) << 32U; - result |= (0x00000000000000FF & static_cast(m_vector[m_position + 4U])) << 24U; - result |= (0x00000000000000FF & static_cast(m_vector[m_position + 5U])) << 16U; - result |= (0x00000000000000FF & static_cast(m_vector[m_position + 6U])) << 8U; - result |= (0x00000000000000FF & static_cast(m_vector[m_position + 7U])) << 0U; + 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; } @@ -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(void) +{ + return std::bit_cast(read()); +} + +template<> +std::int8_t io::ReadBuffer::read(void) { - auto size = static_cast(read_UI16()); - auto result = std::string(); + return std::bit_cast(read()); +} - for(std::size_t i = 0; i < size; ++i) { +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.push_back(static_cast(m_vector[m_position])); + result[i] = static_cast(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(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(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)); } -void io::WriteBuffer::write_UI16(std::uint16_t 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))); } -void io::WriteBuffer::write_UI32(std::uint32_t value) +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))); @@ -169,7 +268,8 @@ void io::WriteBuffer::write_UI32(std::uint32_t value) m_vector.push_back(static_cast(UINT32_C(0xFF) & ((value & UINT32_C(0x000000FF)) >> 0U))); } -void io::WriteBuffer::write_UI64(std::uint64_t value) +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))); @@ -181,25 +281,62 @@ void io::WriteBuffer::write_UI64(std::uint64_t value) m_vector.push_back(static_cast(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(UINT16_MAX, value.size()); + write(std::bit_cast(value)); +} - write_UI16(static_cast(size)); +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(std::size_t i = 0; i < size; m_vector.push_back(static_cast(value[i++]))) { - // empty + for(const auto& character : value) { + m_vector.push_back(static_cast(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 + 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 + ReadBuffer& operator>>(T& value); private: std::vector 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 + 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 + 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(read_UI8()); -} - -inline std::int16_t io::ReadBuffer::read_I16(void) -{ - return static_cast(read_UI16()); -} - -inline std::int32_t io::ReadBuffer::read_I32(void) -{ - return static_cast(read_UI32()); -} - -inline std::int64_t io::ReadBuffer::read_I64(void) -{ - return static_cast(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(value)); -} - -inline void io::WriteBuffer::write_I16(std::int16_t value) -{ - write_UI16(static_cast(value)); -} - -inline void io::WriteBuffer::write_I32(std::int32_t value) -{ - write_UI32(static_cast(value)); -} - -inline void io::WriteBuffer::write_I64(std::int64_t value) -{ - write_UI64(static_cast(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 +io::ReadBuffer& io::ReadBuffer::operator>>(T& value) { - write_UI64(value); + value = read(); return *this; } -inline io::WriteBuffer& io::WriteBuffer::operator<<(const std::string& value) +template +io::WriteBuffer& io::WriteBuffer::operator<<(const T value) { - write_string(value); + write(value); return *this; } -- cgit