g3d: Implement nn::g3d::ResFile

CMakeLists.txt

@@ -188,6 +188,7 @@ add_library(NintendoSDK OBJECT
   include/nn/ui2d/Parts.h
   include/nn/ui2d/Types.h
   include/nn/ui2d/Util.h
+  include/nn/g3d/detail/g3d_CommonHelper.h
   include/nn/g3d/BindFuncTable.h
   include/nn/g3d/ModelObj.h
   include/nn/g3d/ResMaterialAnim.h
@@ -282,6 +283,8 @@ add_library(NintendoSDK OBJECT
   src/NintendoSDK/nvn/nvn_CppFuncPtrImpl.h
   src/NintendoSDK/nvn/nvn_FuncPtrImpl.h
   src/NintendoSDK/nvn/nvn_Impl.cpp
+
+  src/NintendoWare/g3d/g3d_ResFile.cpp
 )
 
 target_include_directories(NintendoSDK PUBLIC include/)

include/nn/g3d/ResFile.h

@@ -5,10 +5,15 @@
 
 #pragma once
 
-#include <nn/gfx/gfx_Types.h>
 #include <nn/types.h>
+
+#include <nn/gfx/gfx_Types.h>
+#include <nn/gfx/gfx_BufferInfo.h>
+#include <nn/gfx/gfx_MemoryPoolInfo.h>
+
 #include <nn/util.h>
 #include <nn/util/util_BinaryFormat.h>
+#include <nn/util/util_ResDic.h>
 
 namespace nn {
 
@@ -22,49 +27,63 @@ class ResModel;
 class ResMaterialAnim;
 class ResShapeAnim;
 class ResSceneAnim;
-typedef void* TextureRef;
+class ResSkeletalAnim;
+class ResBoneVisibilityAnim;
+struct TextureRef;
+
+using TextureBindCallback = nn::g3d::TextureRef (*)(char const*, void*);
+
+struct ResFileData {
+    util::BinaryFileHeader fileHeader;
+    util::BinTPtr<util::BinString> pFileName;
+    util::BinTPtr<ResModel> pModels;
+    util::BinTPtr<util::ResDic> pModelDict;
+    util::BinTPtr<ResSkeletalAnim> pSkeletalAnims;
+    util::BinTPtr<util::ResDic> pSkeletalAnimDict;
+    util::BinTPtr<ResMaterialAnim> pMaterialAnims;
+    util::BinTPtr<util::ResDic> pMaterialAnimsDict;
+    util::BinTPtr<ResBoneVisibilityAnim> pBoneVisibilityAnims;
+    util::BinTPtr<util::ResDic> pBoneVisiDict;
+    util::BinTPtr<ResShapeAnim> pShapeAnims;
+    util::BinTPtr<util::ResDic> pShapeAnimDict;
+    util::BinTPtr<ResSceneAnim> pSceneAnims;
+    util::BinTPtr<util::ResDic> pSceneAnimDict;
+    util::BinTPtr<gfx::MemoryPool> pMemoryPool;
+    util::BinTPtr<gfx::MemoryPoolInfo> pMemoryPoolInfo;
+    u64 embeddedFilesOffset;
+    util::BinTPtr<util::ResDic> pEmbeddedFilesDict;
+    u64 padding;
+    u64 strTableOffset;
+    u32 strTableSize;
+    u16 modelCount;
+    u16 skeletalAnimCount;
+    u16 materialAnimCount;
+    u16 boneAnimCount;
+    u16 shapeAnimCount;
+    u16 sceneAnimCount;
+    u16 externalFileCount;
+};
 
-class ResFile : public nn::util::BinaryFileHeader {
+class ResFile : public nn::util::AccessorBase<ResFileData> {
 public:
-    static bool IsValid(void const* modelSrc);
+    static constexpr s64 Signature = 0x2020202053455246; // "FRES    "
+
+    static bool IsValid(const void* modelSrc);
+
     void Relocate();
     void Unrelocate();
+
     static nn::g3d::ResFile* ResCast(void*);
-    s32 BindTexture(nn::g3d::TextureRef (*ref)(char const*, void*), void*);
+
+    s32 BindTexture(TextureBindCallback callback, void*);
     void ReleaseTexture();
+
     void Setup(gfx::Device*);
     void Setup(gfx::Device*, gfx::MemoryPool*, s64, u64);
+
     void Cleanup(gfx::Device*);
     void Reset();
-
-    u64 mFileNameLength;                  // _20
-    nn::g3d::ResModel* mModels;           // _28
-    u64 mModelDictOffset;                 // _30
-    u64 mSkeleAnimOffset;                 // _38
-    u64 mSkeleAnimDictOffset;             // _40
-    nn::g3d::ResMaterialAnim* mMatAnims;  // _48
-    u64 mMatAnimsDictOffset;              // _50
-    u64 mBoneVisiOffset;                  // _58
-    u64 mBoneVisiDictOffset;              // _60
-    nn::g3d::ResShapeAnim* mShapeAnims;   // _68
-    u64 mShapeAnimDictOffset;             // _70
-    nn::g3d::ResSceneAnim* mSceneAnims;   // _78
-    u64 mSceneAnimDictOffset;             // _80
-    u64 mMemoryPool;                      // _88
-    u64 mBufferSection;                   // _90
-    u64 mEmbeddedFilesOffset;             // _98
-    u64 mEmbeddedFilesDictOffset;         // _A0
-    u64 mPadding;                         // _A8
-    u64 mStrTableOffset;                  // _B0
-    u32 mStrTableSize;                    // _B8
-    u16 mModelCount;                      // _BC
-    u16 mSkeleAnimCount;                  // _BE
-    u16 mMatAnimCount;                    // _C0
-    u16 mBoneAnimCount;                   // _C2
-    u16 mShapeAnimCount;                  // _C4
-    u16 mSceneAnimCount;                  // _C6
-    u16 mExternalFileCount;               // _C8
-    u8 mPad[0x6];                         // _CA
 };
+static_assert(sizeof(ResFile) == 0xd0);
 }  // namespace g3d
 }  // namespace nn

include/nn/g3d/ResMaterialAnim.h

@@ -9,13 +9,15 @@
 
 namespace nn {
 namespace g3d {
-typedef void* TextureRef;
+struct TextureRef;
 
 class ResMaterialAnim {
 public:
     void ReleaseTexture();
     s32 BindTexture(nn::g3d::TextureRef (*)(char const*, void*), void*);
     void Reset();
+
+    u8 _0[0x78];
 };
 }  // namespace g3d
 }  // namespace nn

include/nn/g3d/ResModel.h

@@ -12,20 +12,21 @@ namespace nn {
 namespace g3d {
 class ResMaterial;
 
-typedef void* TextureRef;
+struct TextureRef;
 
 class ResModel {
 public:
-    u64 BindTexture(nn::g3d::TextureRef (*)(char const*, void*), void*);
+    s32 BindTexture(nn::g3d::TextureRef (*)(char const*, void*), void*);
     void ForceBindTexture(nn::g3d::TextureRef const&, char const*);
     void ReleaseTexture();
     void Setup(gfx::Device*);
+    void Setup(gfx::Device*, gfx::MemoryPool*, s64);
     void Cleanup(gfx::Device*);
     void Reset();
     void Reset(u32);
     nn::g3d::ResMaterial* FindMaterial(char const* materialName) const;
 
-    u8 _0[0x70];
+    u8 _0[0x78];
 };
 }  // namespace g3d
 }  // namespace nn

include/nn/g3d/ResSceneAnim.h

@@ -6,36 +6,34 @@
 #pragma once
 
 #include <nn/types.h>
+#include <nn/util/util_BinaryFormat.h>
 
 namespace nn {
 namespace g3d {
 class ResLightAnim;
 class ResFogAnim;
 class BindFuncTable;
 
-class ResSceneAnim {
+class ResSceneAnim : public util::BinaryBlockHeader {
 public:
     s32 Bind(nn::g3d::BindFuncTable const&);
     void Release();
     void Reset();
 
-    char mMagic[4];                      // _0
-    s32 mBlockOffset;                    // _4
-    u64 mBlockSize;                      // _8
-    u64 mNameOffset;                     // _10
-    u64 mPathOffset;                     // _18
-    u64 mCameraAnimOffset;               // _20
-    u64 mCameraAnimDictOffset;           // _28
-    nn::g3d::ResLightAnim* mLightAnims;  // _30
-    u64 mLightAnimDictOffset;            // _38
-    nn::g3d::ResFogAnim* mFogAnims;      // _40
-    u64 mFogAnimDictOffset;              // _48
-    u64 mUserDataOffset;                 // _50
-    u64 mUserDataDictOffset;             // _58
-    u16 mUserDataCount;                  // _60
-    u16 mCameraAnimCount;                // _62
-    u16 mLightAnimCount;                 // _64
-    u16 mFogAnimCount;                   // _66
+    u64 mNameOffset;
+    u64 mPathOffset;
+    u64 mCameraAnimOffset;
+    u64 mCameraAnimDictOffset;
+    nn::g3d::ResLightAnim* mLightAnims;
+    u64 mLightAnimDictOffset;
+    nn::g3d::ResFogAnim* mFogAnims;
+    u64 mFogAnimDictOffset;
+    u64 mUserDataOffset;
+    u64 mUserDataDictOffset;
+    u16 mUserDataCount;
+    u16 mCameraAnimCount;
+    u16 mLightAnimCount;
+    u16 mFogAnimCount;
 };
 }  // namespace g3d
 }  // namespace nn

include/nn/g3d/ResShapeAnim.h

@@ -5,11 +5,16 @@
 
 #pragma once
 
+#include "nn/types.h"
+#include "nn/util/util_BinaryFormat.h"
+
 namespace nn {
 namespace g3d {
-class ResShapeAnim {
+class ResShapeAnim : util::BinaryBlockHeader {
 public:
     void Reset();
+
+    u8 _0[0x50];
 };
 }  // namespace g3d
 }  // namespace nn

include/nn/g3d/ResSkeletalAnim.h

@@ -5,11 +5,15 @@
 
 #pragma once
 
+#include <nn/types.h>
+
 namespace nn {
 namespace g3d {
 class ResSkeletalAnim {
 public:
     void Reset();
+
+    u8 _0[0x60];
 };
 }  // namespace g3d
 }  // namespace nn

include/nn/g3d/detail/g3d_CommonHelper.h

@@ -0,0 +1,8 @@
+#include "nn/util.h"
+namespace nn::g3d::detail {
+NN_MIDDLEWARE(g_MiddlewareInfo, "Nintendo", "NintendoWare_G3d" NN_SDK_BUILD_STR);
+
+inline void UseMiddleWare() {
+    nn::util::ReferSymbol(g_MiddlewareInfo);
+}
+} // namespace nn::g3d::detail

include/nn/gfx/gfx_Device.h

@@ -27,6 +27,8 @@ class TDevice : public detail::DeviceImpl<TTarget>,
 public:
     typedef DeviceInfo InfoType;
 
+    using detail::DeviceImpl<TTarget>::DeviceImpl;
+
     static size_t GetRequiredMemorySize(const InfoType&);
 
     TDevice();

include/nn/gfx/gfx_MemoryPool.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <nn/gfx/detail/gfx_MemoryPool-api.nvn.8.h>
+#include <nn/gfx/gfx_Device.h>
 #include <nn/gfx/gfx_Common.h>
 
 namespace nn::gfx {
@@ -12,13 +13,22 @@ class TMemoryPool : public detail::MemoryPoolImpl<TTarget> {
 public:
     typedef MemoryPoolInfo InfoType;
 
+    using detail::MemoryPoolImpl<TTarget>::MemoryPoolImpl;
+
     static size_t GetPoolMemoryAlignment(TDevice<TTarget>*, const InfoType&);
     static size_t GetPoolMemorySizeGranularity(TDevice<TTarget>*, const InfoType&);
 
-    TMemoryPool();
+    void Initialize(TDevice<TTarget>* device, const InfoType& info, const char* debugLabel) {
+        new (this) TMemoryPool<TTarget>();
+        detail::MemoryPoolImpl<TTarget>::Initialize(device, info);
+        gfx::util::SetMemoryPoolDebugLabel(this, debugLabel);
+    }
+
+    void Finalize(TDevice<TTarget>* device) {
+        detail::MemoryPoolImpl<TTarget>::Finalize(device);
+        this->~TMemoryPool<TTarget>();
+    }
 
-    void Initialize(TDevice<TTarget>*, const InfoType&);
-    void Finalize(TDevice<TTarget>*);
     void* Map() const;
     void Unmap() const;
     void FlushMappedRange(ptrdiff_t, size_t) const;