all: Fix all existing mismatches

CMakeLists.txt

@@ -1,6 +1,8 @@
 project(agl CXX ASM)
 
 add_library(agl OBJECT
+  include/aglVersion.h
+
   include/common/aglDisplayList.h
   include/common/aglDrawContext.h
   include/common/aglGPUCommon.hpp

include/aglVersion.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#define AGL_VERSION_BOTW 1
+#define AGL_VERSION_SMO 2
+#define AGL_VERSION_SPL3 3
+#define AGL_VERSION_TOTK 4
+#define AGL_VERSION_SMBW 5
+#define AGL_VERSION_SMM2 6
+#define AGL_VERSION_CUSTOM 0
+
+#ifndef AGL_VERSION
+#define AGL_VERSION AGL_VERSION_BOTW
+#endif

include/common/aglResBinaryShaderArchive.h

@@ -3,6 +3,7 @@
 #include "common/aglResBinaryShaderProgram.h"
 #include "common/aglResShaderBinary.h"
 #include "common/aglResShaderProgram.h"
+#include <nvn/nvn.h>
 
 namespace agl {
 
@@ -14,8 +15,12 @@ struct ResBinaryShaderArchiveData {
     u32 mVersion;
     u32 mFileSize;
     u32 mEndian;
-    u32 mResolved;
+    u32 mUnknown10;
     u32 mNameLen;
+    u32 mMemoryPoolSize;
+    u32 mMemoryPoolOffset;
+    NVNmemoryPool mMemoryPool;
+    NVNbuffer mBuffer;
     // char mName[];
 
 public:
@@ -24,14 +29,14 @@ struct ResBinaryShaderArchiveData {
     static const char* getExtension();
 
 private:
-    static const u32 cVersion = 8;
+    static const u32 cVersion = 9;
     static const u32 cSignature = 0x53484142;  // SHAB
     static const u32 cEndianCheckBit = 0x01000001;
 
     friend class ResCommon<ResBinaryShaderArchiveData>;
     friend class ResBinaryShaderArchive;
 };
-static_assert(sizeof(ResBinaryShaderArchiveData) == 0x18,
+static_assert(sizeof(ResBinaryShaderArchiveData) == 0x150,
               "agl::ResBinaryShaderArchiveData size mismatch");
 
 class ResBinaryShaderArchive : public ResCommon<ResBinaryShaderArchiveData> {
@@ -47,19 +52,24 @@ class ResBinaryShaderArchive : public ResCommon<ResBinaryShaderArchiveData> {
 
     ResShaderBinaryArray getResShaderBinaryArray() const {
         const DataType* const data = ptr();
-        return (const ResShaderBinaryArrayData*)((uintptr_t)(data + 1) + data->mNameLen);
+        uintptr_t offset = data->mNameLen;
+        offset += (uintptr_t)data;
+        return (const ResShaderBinaryArrayData*)(offset + sizeof(DataType));
     }
 
     s32 getResShaderBinaryNum() const { return getResShaderBinaryArray().getNum(); }
 
     ResBinaryShaderProgramArray getResBinaryShaderProgramArray() const {
         const ResShaderBinaryArrayData* const data = getResShaderBinaryArray().ptr();
-        return (const ResBinaryShaderProgramArrayData*)((uintptr_t)data + data->mSize);
+        return (const ResBinaryShaderProgramArrayData*)((uintptr_t)data + (u32)data->mSize);
     }
 
     s32 getResBinaryShaderProgramNum() const { return getResBinaryShaderProgramArray().getNum(); }
 
     bool setUp(bool le_resolve_pointers);
+
+private:
+    void createMemoryPoolBuffer_();
 };
 
 }  // namespace agl

include/common/aglResBinaryShaderProgram.h

@@ -6,7 +6,7 @@
 namespace agl {
 
 struct ResBinaryShaderProgramData {
-    u32 mSize;
+    s32 mSize;
     u32 mNameLen;
     u32 mKind;
     u32 mBaseIndex;
@@ -23,7 +23,10 @@ class ResBinaryShaderProgram : public ResCommon<ResBinaryShaderProgramData> {
 
     ResShaderVariationArray getResShaderVariationArray() const {
         const DataType* const data = ptr();
-        return (const ResShaderVariationArrayData*)((uintptr_t)(data + 1) + data->mNameLen);
+        const u8* address = (const u8*)data;
+        address += sizeof(DataType);
+        address += data->mNameLen;
+        return (const ResShaderVariationArrayData*)address;
     }
 
     ResShaderVariationArray getResShaderVariationDefaultArray() const {

include/common/aglResCommon.h

@@ -109,7 +109,9 @@ class ResArray : public ResCommon<ResArrayData<typename Type::DataType>> {
 
         iterator& operator++() {
             ++mIndex;
-            mElem = (ElemDataType*)((uintptr_t)mElem + Type(mElem).ref().mSize);
+            u8* elem = (u8*)mElem;
+            elem += Type(mElem).ref().mSize;
+            mElem = (ElemDataType*)elem;
             return *this;
         }
 

include/common/aglResShaderBinary.h

@@ -5,13 +5,48 @@
 
 namespace agl {
 
+#pragma pack(push, 4)
+template <typename T>
+union ResShaderBinaryPtr {
+    s32 mOffset;
+    T* mPtr;
+};
+
+template <u32 Size>
+struct ResShaderBinaryPtrEntry {
+    ResShaderBinaryPtr<const void> mValue;
+    u8 mPadding[Size - sizeof(mValue)];
+};
+
+using ResShaderBinaryPtrEntry16 = ResShaderBinaryPtrEntry<0x10>;
+using ResShaderBinaryPtrEntry12 = ResShaderBinaryPtrEntry<0xC>;
+
+struct ResShaderBinaryNvnData {
+    u8 mUnknown00[0xC];
+    ResShaderBinaryPtr<void> mData;
+    u32 mEntry16ANum;
+    ResShaderBinaryPtr<ResShaderBinaryPtrEntry16> mEntry16A;
+    u32 mEntry16BNum;
+    ResShaderBinaryPtr<ResShaderBinaryPtrEntry16> mEntry16B;
+    u32 mEntry12ANum;
+    ResShaderBinaryPtr<ResShaderBinaryPtrEntry12> mEntry12A;
+    u32 mEntry12BNum;
+    ResShaderBinaryPtr<ResShaderBinaryPtrEntry12> mEntry12B;
+    u32 mEntry12CNum;
+    ResShaderBinaryPtr<ResShaderBinaryPtrEntry12> mEntry12C;
+    u32 mEntry12DNum;
+    ResShaderBinaryPtr<ResShaderBinaryPtrEntry12> mEntry12D;
+};
+#pragma pack(pop)
+
+static_assert(sizeof(ResShaderBinaryNvnData) == 0x5C);
+
 struct ResShaderBinaryData {
-    u32 mSize;
+    s32 mSize;
     u32 mShaderType;
     s32 mDataOffset;  // Relative to end of struct
     u32 mDataSize;
 };
-static_assert(sizeof(ResShaderBinaryData) == 0x10, "agl::ResShaderBinaryData size mismatch");
 
 class ResShaderBinary : public ResCommon<ResShaderBinaryData> {
 public:
@@ -25,12 +60,12 @@ class ResShaderBinary : public ResCommon<ResShaderBinaryData> {
     }
 
     void modifyBinaryEndian();
+    void resolvePtr(const void* base);
     void setUp();
 };
 
 using ResShaderBinaryArray = ResArray<ResShaderBinary>;
 
 using ResShaderBinaryArrayData = ResShaderBinaryArray::DataType;
-static_assert(sizeof(ResShaderBinaryArrayData) == 8, "agl::ResShaderBinaryArrayData size mismatch");
 
 }  // namespace agl

include/common/aglResShaderMacro.h

@@ -5,7 +5,7 @@
 namespace agl {
 
 struct ResShaderMacroData {
-    u32 mSize;
+    s32 mSize;
     u32 mNameLen;
     u32 mValueLen;
     // char mName[];

include/common/aglResShaderProgram.h

@@ -7,7 +7,7 @@
 namespace agl {
 
 struct ResShaderProgramData {
-    u32 mSize;
+    s32 mSize;
     u32 mNameLen;
     s32 mSourceIndex[cShaderType_Num];
     // char mName[];

include/common/aglResShaderSource.h

@@ -5,7 +5,7 @@
 namespace agl {
 
 struct ResShaderSourceData {
-    u32 mSize;
+    s32 mSize;
     u32 mNameLen;
     u32 mTextLen;  // Text Length
     u32 _c;        // Text Length... 2

include/common/aglResShaderVariation.h

@@ -5,7 +5,7 @@
 namespace agl {
 
 struct ResShaderVariationData {
-    u32 mSize;
+    s32 mSize;
     u32 mNameLen;
     s32 mValueNum;
     u32 mIDLen;

include/detail/aglGPUMemBlockMgr.h

@@ -57,6 +57,7 @@ class GPUMemBlockMgrHeapEx : public sead::hostio::Node, public sead::IDisposer {
     ~GPUMemBlockMgrHeapEx() override;
 
     void finalize();
+    sead::Heap* getDisposerHeap() const { return getDisposerHeap_(); }
 
 private:
     s32 mAllowSharing;

include/driver/aglNVNMgr.h

@@ -2,21 +2,31 @@
 
 #include <heap/seadDisposer.h>
 #include <hostio/seadHostIONode.h>
+#include <nvn/nvn.h>
 #include "driver/aglGraphicsDriverMgr.h"
 
 namespace agl::driver {
 
 class NVNMgr : public GraphicsDriverMgr {
-    // TODO: This is wrong and should actually touch the GraphicsDriverMgr implementation
-    SEAD_SINGLETON_DISPOSER(NVNMgr)
 public:
+    static NVNMgr* instance() { return (NVNMgr*)GraphicsDriverMgr::instance(); }
+    static NVNMgr* createInstance(sead::Heap* heap);
+
+    NVNdevice* getDevice() const { return mDevice; }
+
     NVNMgr();
     ~NVNMgr() override;
 
+    NVNMgr(const NVNMgr&) = delete;
+    NVNMgr& operator=(const NVNMgr&) = delete;
+    NVNMgr(NVNMgr&&) = delete;
+    NVNMgr& operator=(NVNMgr&&) = delete;
+
 private:
+    NVNdevice* mDevice;
+    u8 mUnknown[0x470];
 };
 
-// TODO: need sead::Graphics reversing...
-// static_assert(sizeof(NVNMgr) == 0x548);
+static_assert(sizeof(NVNMgr) == 0x4B0);
 
 }  // namespace agl::driver

include/utility/aglParameterCurve.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <aglVersion.h>
+
 #ifndef AGL_UTILS_PARAMETER_H_
 #include "utility/aglParameter.h"
 #endif
@@ -27,6 +29,26 @@ inline void ParameterCurve<4>::reset() {
     }
 }
 
+template <>
+__attribute__((noinline, used)) inline void ParameterCurve<3>::reset() {
+    static f32 s_initialize[9] = {0.0, 0.0, 0.5, 0.5, 0.5, 0.5, 1.0, 1.0, 0.5};
+
+    sead::MemUtil::copy(mCurveData[0].f, s_initialize, sizeof(s_initialize));
+    for (u32 j = 9; j < cUnitCurveParamNum; ++j)
+        mCurveData[0].f[j] = 1.0;
+    mCurves[0].setData(&mCurveData[0], sead::hostio::CurveType::Hermit2D, cUnitCurveParamNum, 9);
+
+    sead::MemUtil::copy(mCurveData[1].f, s_initialize, sizeof(s_initialize));
+    for (u32 j = 9; j < cUnitCurveParamNum; ++j)
+        mCurveData[1].f[j] = 1.0;
+    mCurves[1].setData(&mCurveData[1], sead::hostio::CurveType::Hermit2D, cUnitCurveParamNum, 9);
+
+    sead::MemUtil::copy(mCurveData[2].f, s_initialize, sizeof(s_initialize));
+    for (u32 j = 9; j < cUnitCurveParamNum; ++j)
+        mCurveData[2].f[j] = 1.0;
+    mCurves[2].setData(&mCurveData[2], sead::hostio::CurveType::Hermit2D, cUnitCurveParamNum, 9);
+}
+
 template <u32 N>
 inline void ParameterCurve<N>::reset() {
     static f32 s_initialize[9] = {0.0, 0.0, 0.5, 0.5, 0.5, 0.5, 1.0, 1.0, 0.5};
@@ -91,16 +113,87 @@ inline ParameterBase* ParameterCurve<N>::clone(sead::Heap* heap, IParameterObj*
 template <u32 N>
 inline void ParameterCurve<N>::postApplyResource_(const void*, size_t size) {
     if (this->size() == size) {
-        for (u32 i = 0; i < N; ++i) {
-            mCurves[i].setCurveType(sead::hostio::CurveType(mCurveData[i].curveType));
-            mCurves[i].mFloats = mCurveData[i].f;
-            mCurves[i].mInfo.numFloats = cUnitCurveParamNum;
-            mCurves[i].setNumUse(mCurveData[i].numUse);
+        if constexpr (N == 3) {
+            for (u32 i = 0; i < 2; ++i) {
+                auto& curve = mCurves[i];
+                auto& data = mCurveData[i];
+                const auto type = sead::hostio::CurveType(data.curveType);
+                curve.setCurveType(type);
+                auto* floats = data.f;
+                curve.setNumUse(data.numUse);
+                curve.mFloats = floats;
+                curve.mInfo.numFloats = cUnitCurveParamNum;
+            }
+            auto& curve = mCurves[2];
+            auto& data = mCurveData[2];
+            auto* floats = data.f;
+            const auto type = sead::hostio::CurveType(data.curveType);
+            curve.setCurveType(type);
+            curve.mFloats = floats;
+            curve.setNumUse(data.numUse);
+            curve.mInfo.numFloats = cUnitCurveParamNum;
+        } else {
+            for (u32 i = 0; i < N; ++i) {
+                auto& curve = mCurves[i];
+                auto& data = mCurveData[i];
+                if constexpr (N == 1) {
+                    mCurves[i].setCurveType(sead::hostio::CurveType(mCurveData[i].curveType));
+#if AGL_VERSION == AGL_VERSION_BOTW
+                    mCurves[i].mFloats = mCurveData[i].f;
+                    mCurves[i].mInfo.numFloats = cUnitCurveParamNum;
+                    mCurves[i].setNumUse(mCurveData[i].numUse);
+#else
+                    mCurves[i].setNumUse(mCurveData[i].numUse);
+                    mCurves[i].setFloats(&mCurveData[i], cUnitCurveParamNum);
+#endif
+                } else {
+                    auto* floats = data.f;
+                    const auto type = sead::hostio::CurveType(data.curveType);
+                    curve.mInfo.curveType = u8(type);
+                    curve.mInfo.numFloats = cUnitCurveParamNum;
+                    curve.mFloats = floats;
+                    const u32 num_use = data.numUse;
+                    curve.mInfo.numUse = u8(num_use);
+                }
+            }
         }
     } else {
-        for (u32 i = 0; i < N; ++i) {
-            mCurves[i].mInfo.numFloats = cUnitCurveParamNum;
-            mCurves[i].mFloats = mCurveData[i].f;
+        if constexpr (N == 1) {
+            for (u32 i = 0; i < N; ++i) {
+                mCurves[i].mInfo.numFloats = cUnitCurveParamNum;
+                mCurves[i].mFloats = mCurveData[i].f;
+            }
+        } else if constexpr (N == 2) {
+            mCurves[0].mInfo.numFloats = cUnitCurveParamNum;
+            mCurves[0].mFloats = mCurveData[0].f;
+            mCurves[1].mFloats = mCurveData[1].f;
+            mCurves[1].mInfo.numFloats = cUnitCurveParamNum;
+        } else if constexpr (N == 3) {
+            auto* floats0 = mCurveData[0].f;
+            mCurves[0].mInfo.numFloats = cUnitCurveParamNum;
+            auto* floats1 = mCurveData[1].f;
+            mCurves[0].mFloats = floats0;
+            auto* floats2 = mCurveData[2].f;
+            mCurves[1].mInfo.numFloats = cUnitCurveParamNum;
+            mCurves[1].mFloats = floats1;
+            mCurves[2].mInfo.numFloats = cUnitCurveParamNum;
+            mCurves[2].mFloats = floats2;
+        } else if constexpr (N == 4) {
+            mCurves[0].mInfo.numFloats = cUnitCurveParamNum;
+            mCurves[0].mFloats = mCurveData[0].f;
+            auto* floats1 = mCurveData[1].f;
+            mCurves[1].mInfo.numFloats = cUnitCurveParamNum;
+            mCurves[1].mFloats = floats1;
+            mCurves[2].mFloats = mCurveData[2].f;
+            mCurves[2].mInfo.numFloats = cUnitCurveParamNum;
+            auto* floats3 = mCurveData[3].f;
+            mCurves[3].mInfo.numFloats = cUnitCurveParamNum;
+            mCurves[3].mFloats = floats3;
+        } else {
+            for (u32 i = 0; i < N; ++i) {
+                mCurves[i].mFloats = mCurveData[i].f;
+                mCurves[i].mInfo.numFloats = cUnitCurveParamNum;
+            }
         }
     }
 }