Add testing framework

source/egg/math/Quat.cc

@@ -80,6 +80,11 @@ f32 Quatf::dot(const Quatf &q) const {
     return w * q.w + v.dot(q.v);
 }
 
+void Quatf::read(Stream &stream) {
+    v.read(stream);
+    w = stream.read_f32();
+}
+
 const Quatf Quatf::ident = Quatf(1.0f, Vector3f::zero);
 
 } // namespace EGG

source/egg/math/Quat.hh

@@ -35,6 +35,14 @@ struct Quatf {
         return *this = *this * q;
     }
 
+    bool operator==(const Quatf &rhs) const {
+        return w == rhs.w && v == rhs.v;
+    }
+
+    bool operator!=(const Quatf &rhs) const {
+        return !(*this == rhs);
+    }
+
     void setRPY(const Vector3f &rpy);
     void normalise();
     Quatf conjugate() const;
@@ -43,6 +51,8 @@ struct Quatf {
     f32 dot() const;
     f32 dot(const Quatf &q) const;
 
+    void read(Stream &stream);
+
     Vector3f v;
     f32 w;
 

source/egg/math/Vector.hh

@@ -91,6 +91,14 @@ struct Vector3f {
         return *this = *this / scalar;
     }
 
+    bool operator==(const Vector3f &rhs) const {
+        return x == rhs.x && y == rhs.y && z == rhs.z;
+    }
+
+    bool operator!=(const Vector3f &rhs) const {
+        return !(*this == rhs);
+    }
+
     Vector3f cross(const EGG::Vector3f &rhs) const;
     f32 dot() const;
     f32 dot(const EGG::Vector3f &rhs) const;

source/egg/util/Stream.cc

@@ -16,6 +16,14 @@ void Stream::jump(u32 index) {
     assert(!eof());
 }
 
+void Stream::setEndian(std::endian endian) {
+    m_endian = endian;
+}
+
+u32 Stream::index() const {
+    return m_index;
+}
+
 u8 Stream::read_u8() {
     return read<u8>();
 }

source/egg/util/Stream.hh

@@ -16,6 +16,10 @@ public:
     void skip(u32 count);
     void jump(u32 index);
 
+    void setEndian(std::endian endian);
+
+    u32 index() const;
+
     u8 read_u8();
     u16 read_u16();
     u32 read_u32();

source/game/kart/KartObjectManager.cc

@@ -18,6 +18,11 @@ void KartObjectManager::calc() {
     }
 }
 
+KartObject *KartObjectManager::object(size_t i) const {
+    assert(i < m_count);
+    return m_objects[i];
+}
+
 KartObjectManager *KartObjectManager::CreateInstance() {
     assert(!s_instance);
     s_instance = new KartObjectManager;

source/game/kart/KartObjectManager.hh

@@ -9,6 +9,8 @@ public:
     void init();
     void calc();
 
+    KartObject *object(size_t i) const;
+
     static KartObjectManager *CreateInstance();
     static void DestroyInstance();
     static KartObjectManager *Instance();

source/game/kart/KartObjectProxy.cc

@@ -86,6 +86,14 @@ void KartObjectProxy::setRot(const EGG::Quatf &q) {
     dynamics()->setMainRot(q);
 }
 
+const EGG::Vector3f &KartObjectProxy::pos() const {
+    return dynamics()->pos();
+}
+
+const EGG::Quatf &KartObjectProxy::fullRot() const {
+    return dynamics()->fullRot();
+}
+
 Abstract::List *KartObjectProxy::list() const {
     return s_list;
 }

source/game/kart/KartObjectProxy.hh

@@ -51,6 +51,9 @@ public:
     void setPos(const EGG::Vector3f &pos);
     void setRot(const EGG::Quatf &q);
 
+    const EGG::Vector3f &pos() const;
+    const EGG::Quatf &fullRot() const;
+
     Abstract::List *list() const;
 
 protected:

source/host/System.cc

@@ -7,21 +7,24 @@ namespace Host {
 int KSystem::main() {
     init();
     m_sceneMgr->changeScene(0);
+    if (!m_testDirector->init()) {
+        return 1;
+    }
     run();
     return 0;
 }
 
 void KSystem::init() {
     auto *sceneCreator = new SceneCreatorDynamic;
     m_sceneMgr = new EGG::SceneManager(sceneCreator);
+
+    m_testDirector = new Test::TestDirector;
 }
 
 void KSystem::run() {
-    K_LOG("Initialized successfully!");
-    K_LOG("The program will now run in an infinite loop to test 'calc' functionality.");
-    while (true) {
+    do {
         m_sceneMgr->calc();
-    }
+    } while (m_testDirector->calc());
 }
 
 KSystem &KSystem::Instance() {

source/host/System.hh

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <egg/core/SceneManager.hh>
+#include <test/TestDirector.hh>
 
 namespace Host {
 
@@ -10,10 +11,6 @@ public:
     void init();
     void run();
 
-    EGG::SceneManager *sceneMgr() const {
-        return m_sceneMgr;
-    }
-
     static KSystem &Instance();
 
 private:
@@ -23,6 +20,7 @@ private:
     ~KSystem();
 
     EGG::SceneManager *m_sceneMgr;
+    Test::TestDirector *m_testDirector;
 };
 
 } // namespace Host

source/test/Test.hh

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <egg/math/Quat.hh>
+
+namespace Test {
+
+struct TestHeader {
+    u32 signature;
+    u16 byteOrderMark;
+    u16 frameCount;
+    u16 versionMajor;
+    u16 versionMinor;
+    u32 dataOffset;
+};
+
+struct TestData {
+    EGG::Vector3f pos;
+    EGG::Quatf fullRot;
+};
+
+} // namespace Test

source/test/TestDirector.cc

@@ -0,0 +1,101 @@
+#include "TestDirector.hh"
+
+#include <game/kart/KartObjectManager.hh>
+
+#include <abstract/File.hh>
+
+#include <cstddef>
+
+namespace Test {
+
+TestDirector::TestDirector() {
+    size_t size;
+    u8 *file = Abstract::File::Load("Test/rmc3-rta-1-17-843.krkg", size);
+    m_file = file;
+    m_stream = EGG::RamStream(file, static_cast<u32>(size));
+    m_currentFrame = -1;
+    m_sync = true;
+
+    // Initialize endianness for the RAM stream
+    u16 mark = *reinterpret_cast<u16 *>(file + offsetof(TestHeader, byteOrderMark));
+    std::endian endian = parse<u16>(mark) == 0xfeff ? std::endian::big : std::endian::little;
+    m_stream.setEndian(endian);
+
+    readHeader();
+}
+
+TestDirector::~TestDirector() = default;
+
+bool TestDirector::init() {
+    assert(m_stream.read_u32() == m_stream.index());
+    return calc();
+}
+
+bool TestDirector::calc() {
+    // Check if we're out of frames
+    constexpr u16 TARGET_FRAME = 1;
+    assert(TARGET_FRAME <= m_frameCount);
+    if (++m_currentFrame > TARGET_FRAME) {
+        return false;
+    }
+
+    // Test the current frame
+    TestData data = findNextEntry();
+    m_sync = test(data);
+    return m_sync;
+}
+
+bool TestDirector::test(const TestData &data) {
+    auto logVectorDesync = [this](const EGG::Vector3f &v0, const EGG::Vector3f v1,
+                                   const char *name) {
+        K_LOG("DESYNC! Frame: %d; Name: %s", m_currentFrame, name);
+        K_LOG("Expected [%f, %f, %f], got [%f, %f, %f]", v0.x, v0.y, v0.z, v1.x, v1.y, v1.z);
+    };
+
+    auto logQuatDesync = [this](const EGG::Quatf &q0, const EGG::Quatf q1, const char *name) {
+        K_LOG("DESYNC! Frame: %d; Name: %s", m_currentFrame, name);
+        K_LOG("Expected [%f, %f, %f, %f], got [%f, %f, %f, %f]", q0.v.x, q0.v.y, q0.v.z, q0.w,
+                q1.v.x, q1.v.y, q1.v.z, q1.w);
+    };
+
+    auto *object = Kart::KartObjectManager::Instance()->object(0);
+    const auto &pos = object->pos();
+    const auto &fullRot = object->fullRot();
+
+    if (data.pos != pos) {
+        logVectorDesync(data.pos, pos, "pos");
+        return false;
+    }
+    if (data.fullRot != fullRot) {
+        logQuatDesync(data.fullRot, fullRot, "fullRot");
+        return false;
+    }
+
+    return true;
+}
+
+TestData TestDirector::findNextEntry() {
+    EGG::Vector3f pos;
+    EGG::Quatf fullRot;
+    pos.read(m_stream);
+    fullRot.read(m_stream);
+
+    TestData data;
+    data.pos = pos;
+    data.fullRot = fullRot;
+    return data;
+}
+
+bool TestDirector::sync() const {
+    return m_sync;
+}
+
+void TestDirector::readHeader() {
+    assert(m_stream.read_u32() == 0x4b524b47); // 'KRKG'
+    m_stream.skip(2);
+    m_frameCount = m_stream.read_u16();
+    m_versionMajor = m_stream.read_u16();
+    m_versionMinor = m_stream.read_u16();
+}
+
+} // namespace Test

source/test/TestDirector.hh

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "test/Test.hh"
+
+#include <egg/util/Stream.hh>
+
+namespace Test {
+
+class TestDirector {
+public:
+    TestDirector();
+    ~TestDirector();
+
+    bool init();
+    bool calc();
+    bool test(const TestData &data);
+
+    TestData findNextEntry();
+
+    bool sync() const;
+
+private:
+    void readHeader();
+
+    void *m_file;
+    EGG::RamStream m_stream;
+
+    u16 m_versionMajor;
+    u16 m_versionMinor;
+    u16 m_frameCount;
+    u16 m_currentFrame;
+    bool m_sync;
+};
+
+} // namespace Test