Add EGG::Stream

configure.py

@@ -81,6 +81,7 @@
     os.path.join('source', 'egg', 'core', 'SceneManager.cc'),
     os.path.join('source', 'egg', 'math', 'Math.cc'),
     os.path.join('source', 'egg', 'math', 'Vector.cc'),
+    os.path.join('source', 'egg', 'util', 'Stream.cc'),
     os.path.join('source', 'game', 'kart', 'KartObject.cc'),
     os.path.join('source', 'game', 'kart', 'KartObjectManager.cc'),
     os.path.join('source', 'game', 'kart', 'KartObjectProxy.cc'),

source/egg/util/Stream.cc

@@ -0,0 +1,91 @@
+#include "Stream.hh"
+
+namespace EGG {
+
+Stream::Stream() : m_endian(std::endian::big), m_index(0) {}
+
+Stream::~Stream() = default;
+
+u8 Stream::read_u8() {
+    return read<u8>();
+}
+
+u16 Stream::read_u16() {
+    return read<u16>();
+}
+
+u32 Stream::read_u32() {
+    return read<u32>();
+}
+
+u64 Stream::read_u64() {
+    return read<u64>();
+}
+
+s8 Stream::read_s8() {
+    return read<s8>();
+}
+
+s16 Stream::read_s16() {
+    return read<s16>();
+}
+
+s32 Stream::read_s32() {
+    return read<s32>();
+}
+
+s64 Stream::read_s64() {
+    return read<s64>();
+}
+
+// Floating point numbers are not integral, so we have special cases outside of the template
+f32 Stream::read_f32() {
+    f32 val;
+    read(&val, sizeof(val));
+    m_index += sizeof(val);
+    assert(!eof());
+
+    return std::bit_cast<f32>(parse<u32>(std::bit_cast<u32>(val), m_endian));
+}
+
+f64 Stream::read_f64() {
+    f64 val;
+    read(&val, sizeof(val));
+    m_index += sizeof(val);
+    assert(!eof());
+
+    return std::bit_cast<f64>(parse<u64>(std::bit_cast<u64>(val), m_endian));
+}
+
+RamStream::RamStream() : m_buffer(nullptr), m_size(0) {}
+
+RamStream::RamStream(u8 *buffer, u32 size) : m_buffer(nullptr), m_size(0) {
+    setBufferAndSize(buffer, size);
+}
+
+RamStream::~RamStream() = default;
+
+void RamStream::read(void *output, u32 size) {
+    u8 *buffer = reinterpret_cast<u8 *>(output);
+    for (size_t i = 0; i < size; ++i) {
+        buffer[i] = m_buffer[m_index + i];
+    }
+}
+
+void RamStream::write(void *input, u32 size) {
+    u8 *buffer = reinterpret_cast<u8 *>(input);
+    for (size_t i = 0; i < size; ++i) {
+        m_buffer[m_index + i] = buffer[i];
+    }
+}
+
+bool RamStream::eof() {
+    return m_index > m_size;
+}
+
+void RamStream::setBufferAndSize(u8 *buffer, u32 size) {
+    m_buffer = buffer;
+    m_size = size;
+}
+
+} // namespace EGG

source/egg/util/Stream.hh

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <Common.hh>
+
+namespace EGG {
+
+class Stream {
+public:
+    Stream();
+    virtual ~Stream();
+
+    virtual void read(void *output, u32 size) = 0;
+    virtual void write(void *input, u32 size) = 0;
+    virtual bool eof() = 0;
+
+    u8 read_u8();
+    u16 read_u16();
+    u32 read_u32();
+    u64 read_u64();
+    s8 read_s8();
+    s16 read_s16();
+    s32 read_s32();
+    s64 read_s64();
+    f32 read_f32();
+    f64 read_f64();
+
+protected:
+    std::endian m_endian;
+    u32 m_index;
+
+private:
+    template <typename T>
+    T read() {
+        static_assert(std::is_integral<T>::value);
+        T val;
+        read(&val, sizeof(val));
+        m_index += sizeof(val);
+        assert(!eof());
+
+        return parse<T>(val, m_endian);
+    }
+};
+
+class RamStream : public Stream {
+public:
+    RamStream();
+    RamStream(u8 *buffer, u32 size);
+    ~RamStream() override;
+
+    void read(void *output, u32 size) override;
+    void write(void *input, u32 size) override;
+    bool eof() override;
+
+    void setBufferAndSize(u8 *buffer, u32 size);
+
+private:
+    u8 *m_buffer;
+    u32 m_size;
+};
+
+} // namespace EGG