Match & link CAssetFactory, CCharacterFactory 95%

config/G2ME01/splits.txt

@@ -77,6 +77,16 @@ MetroidPrime/CAnimData.cpp:
 	.text       start:0x80025D3C end:0x8002F7A8
 	.ctors      start:0x803A54BC end:0x803A54C0
 
+MetroidPrime/Factories/CCharacterFactory.cpp:
+	.text       start:0x8002F7A8 end:0x80031E60
+	.rodata     start:0x803A64A0 end:0x803A64A8
+	.data       start:0x803B1948 end:0x803B1A10
+
+MetroidPrime/Factories/CAssetFactory.cpp:
+	.text       start:0x80031E60 end:0x800324A4
+	.rodata     start:0x803A64A8 end:0x803A64B0
+	.data       start:0x803B1A10 end:0x803B1A40
+
 MetroidPrime/Weapons/CGameProjectile.cpp:
 	.text       start:0x80032C3C end:0x80036200
 	.data       start:0x803B1A40 end:0x803B1ACC
@@ -131,6 +141,16 @@ MetroidPrime/HUD/CSamusHud.cpp:
 	.ctors      start:0x803A54CC end:0x803A54D0
 	.data       start:0x803B1F30 end:0x803B1F50
 
+MetroidPrime/CAnimationDatabaseGame.cpp:
+	.text       start:0x8006CB00 end:0x8006D3D0
+	.rodata     start:0x803A70B8 end:0x803A70F0
+	.data       start:0x803B1F50 end:0x803B1F70
+
+MetroidPrime/CTransitionDatabaseGame.cpp:
+	.text       start:0x8006D3D0 end:0x8006EB98
+	.data       start:0x803B1F70 end:0x803B1F80
+	.sbss       start:0x80418FD0 end:0x80418FE0
+
 MetroidPrime/ScriptObjects/CScriptTrigger.cpp:
 	.text       start:0x8007105C end:0x80073474
 	.data       start:0x803B2018 end:0x803B20B0

configure.py

@@ -455,6 +455,10 @@ def MatchingFor(*versions):
             Object(NonMatching, "MetroidPrime/CParticleGenInfo.cpp"),
             Object(NonMatching, "MetroidPrime/CParticleDatabase.cpp"),
             Object(NonMatching, "MetroidPrime/CAnimData.cpp"),
+            Object(NonMatching, "MetroidPrime/Factories/CCharacterFactory.cpp"),
+            Object(MatchingFor("G2ME01"), "MetroidPrime/Factories/CAssetFactory.cpp"),
+            Object(MatchingFor("G2ME01"), "MetroidPrime/CAnimationDatabaseGame.cpp"),
+            Object(MatchingFor("G2ME01"), "MetroidPrime/CTransitionDatabaseGame.cpp"),
             Object(NonMatching, "MetroidPrime/CTargetReticles.cpp"),
             Object(NonMatching, "MetroidPrime/ScriptObjects/CScriptHUDMemo.cpp"),
             Object(NonMatching, "MetroidPrime/ScriptObjects/CScriptAreaProperties.cpp"),

include/Kyoto/Animation/CAnimSysContext.hpp

@@ -1,24 +1,28 @@
 #ifndef _CANIMSYSCONTEXT
 #define _CANIMSYSCONTEXT
 
+#include "Kyoto/Animation/CAnimationSet.hpp"
 #include "Kyoto/TToken.hpp"
 
 #include "rstl/rc_ptr.hpp"
 
-class CTransitionDatabaseGame;
+class CTransitionDatabase;
 class CRandom16;
 class CSimplePool;
 
 class CAnimSysContext {
 public:
-  CAnimSysContext(const TToken< CTransitionDatabaseGame >& transDb,
-                  const rstl::ncrc_ptr< CRandom16 >& random, CSimplePool& store)
-  : mTransDb(transDb), mRandom(random), mStore(store) {}
+  CAnimSysContext(const TToken< CTransitionDatabase >& transDb,
+                  const rstl::ncrc_ptr< CRandom16 >& random, CSimplePool& store,
+                  const CAnimationSet::EventSetList& eventSets)
+  : mTransDb(transDb), mRandom(random), mStore(store), mEventSets(eventSets) {}
 
 private:
-  TToken< CTransitionDatabaseGame > mTransDb;
-  rstl::rc_ptr< CRandom16 > mRandom;
+  TToken< CTransitionDatabase > mTransDb;
+  rstl::ncrc_ptr< CRandom16 > mRandom;
   CSimplePool& mStore;
+  const CAnimationSet::EventSetList& mEventSets; // Guessed name.
 };
+CHECK_SIZEOF(CAnimSysContext, 0x18)
 
 #endif // _CANIMSYSCONTEXT

include/Kyoto/Animation/CAnimationDatabase.hpp

@@ -0,0 +1,34 @@
+#ifndef _CANIMATIONDATABASE
+#define _CANIMATIONDATABASE
+
+#include "Kyoto/TToken.hpp"
+
+#include "rstl/optional_object.hpp"
+#include "rstl/rc_ptr.hpp"
+#include "rstl/set.hpp"
+#include "rstl/string.hpp"
+#include "rstl/vector.hpp"
+
+class CPrimitive;
+class IMetaAnim;
+
+class CAnimationDatabase {
+public:
+  virtual const rstl::rc_ptr< IMetaAnim >& GetMetaAnim(uint idx) const = 0;
+  virtual uint GetNumMetaAnims() const = 0;
+  virtual rstl::string GetMetaAnimName(uint idx) const = 0;
+  virtual void GetAllUniquePrimitives(rstl::vector< CPrimitive >& primsOut) const = 0;
+  virtual void GetUniquePrimitivesFromMetaAnim(rstl::set< CPrimitive >& primsOut,
+                                               const rstl::string& name) const = 0;
+
+  explicit CAnimationDatabase(const rstl::optional_object< TToken< CAnimationDatabase > >& token =
+                                  rstl::optional_object_null())
+  : x4_(token) {}
+  ~CAnimationDatabase() {}
+
+private:
+  rstl::optional_object< TToken< CAnimationDatabase > > x4_;
+};
+CHECK_SIZEOF(CAnimationDatabase, 0x10)
+
+#endif // _CANIMATIONDATABASE

include/Kyoto/Animation/CAnimationManager.hpp

@@ -1,18 +1,21 @@
 #ifndef _CANIMATIONMANAGER
 #define _CANIMATIONMANAGER
 
+#include "Kyoto/Animation/CAnimSysContext.hpp"
 #include "Kyoto/TToken.hpp"
 
+class CAnimationDatabase;
 
 class CAnimationManager {
 public:
+  CAnimationManager(TToken< CAnimationDatabase > animDB, const CAnimSysContext& sysCtx)
+  : mAnimDB(animDB), mSysCtx(sysCtx) {}
   ~CAnimationManager();
-  //CAnimationManager(const TToken<CAnimationDatabase>& animDB, const CAnimSysContext& sysCtx);
 
 private:
-  //TToken< CAnimationDatabase > x0_animDB;
-  //CAnimSysContext x8_sysCtx;
+  TToken< CAnimationDatabase > mAnimDB;
+  CAnimSysContext mSysCtx;
 };
-
+CHECK_SIZEOF(CAnimationManager, 0x20)
 
 #endif // _CANIMATIONMANAGER

include/Kyoto/Animation/CAnimationSet.hpp

@@ -9,6 +9,7 @@
 #include "Kyoto/Animation/IMetaAnim.hpp"
 #include "Kyoto/Animation/IMetaTrans.hpp"
 
+#include "rstl/construct.hpp"
 #include "rstl/pair.hpp"
 #include "rstl/vector.hpp"
 
@@ -49,4 +50,8 @@ class CAnimationSet {
 };
 CHECK_SIZEOF(CAnimationSet, 0x64)
 
+namespace rstl {
+RSTL_DECLARE_TRIVIALLY_CONSTRUCTIBLE(CAnimationSet::AdditiveAnimationList::value_type)
+}
+
 #endif // _CANIMATIONSET

include/Kyoto/Animation/CCharacterInfo.hpp

@@ -31,6 +31,13 @@ class CCharacterInfo {
 
   explicit CCharacterInfo(CInputStream& in);
 
+  CAssetId GetModelId() const { return mCmdl; }
+  CAssetId GetSkinRulesId() const { return mCksr; }
+  CAssetId GetCharLayoutInfoId() const { return mCinf; }
+  CAssetId GetIceModelId() const { return mCmdlOverlay; }
+  CAssetId GetIceSkinRulesId() const { return mCksrOverlay; }
+  CAssetId GetSpatialPrimitiveId() const { return mSpatialPrimitiveId; }
+  bool GetAnimatedScale() const { return mAnimatedScale; }
   const CPASDatabase& GetPASDatabase() const { return mPasDatabase; }
   const CParticleResData& GetParticleResData() const { return mPartRes; }
   const TEffectList& GetEffects() const { return mEffects; }

include/Kyoto/Animation/CHalfTransition.hpp

@@ -8,10 +8,14 @@ class CInputStream;
 class CHalfTransition {
 public:
   explicit CHalfTransition(CInputStream& in);
+  uint GetPrimitiveIndex() const { return mId; }
+  const rstl::rc_ptr< IMetaTrans >& GetMetaTrans() const { return mTrans; }
 
 private:
   uint mId;
-  rstl::rc_ptr<IMetaTrans> mTrans;
+  rstl::rc_ptr< IMetaTrans > mTrans;
 };
 
+CHECK_SIZEOF(CHalfTransition, 0xc)
+
 #endif // _CHALFTRANSITION

include/Kyoto/Animation/CPrimitive.hpp

@@ -3,6 +3,7 @@
 
 #include "Kyoto/SObjectTag.hpp"
 
+#include "rstl/StringExtras.hpp"
 #include "rstl/string.hpp"
 
 class CInputStream;
@@ -12,11 +13,18 @@ class CPrimitive {
   CPrimitive(CInputStream& in);
   void PutTo(COutputStream& out) const;
   CAssetId GetAnimResId() const { return mAnimId; }
+  int Compare(const CPrimitive& other) const {
+    return CStringExtras::CompareCaseInsensitive(mAnimName, other.mAnimName);
+  }
 
 private:
   CAssetId mAnimId;
   int mAnimIdx;
   rstl::string mAnimName;
 };
 
+CHECK_SIZEOF(CPrimitive, 0x18)
+
+inline bool operator<(const CPrimitive& a, const CPrimitive& b) { return a.Compare(b) < 0; }
+
 #endif // _CPRIMITIVE

include/Kyoto/Animation/CTransition.hpp

@@ -1,24 +1,27 @@
 #ifndef _CTRANSITION
 #define _CTRANSITION
 
-#include "rstl/rc_ptr.hpp"
 #include "rstl/pair.hpp"
-
+#include "rstl/rc_ptr.hpp"
 
 class IMetaTrans;
 class CInputStream;
 class CTransition {
   uint mId;
   uint mAnimA;
   uint mAnimB;
-  rstl::rc_ptr<IMetaTrans> mTrans;
+  rstl::rc_ptr< IMetaTrans > mTrans;
 
 public:
   explicit CTransition(CInputStream& in);
+  uint GetFromAnimIndex() const { return mAnimA; }
+  uint GetToAnimIndex() const { return mAnimB; }
   u32 GetAnimA() const { return mAnimA; }
   u32 GetAnimB() const { return mAnimB; }
-  rstl::pair<uint, uint> GetAnimPair() const { return rstl::pair<uint, uint>(mAnimA, mAnimB); }
-  const rstl::rc_ptr<IMetaTrans>& GetMetaTrans() const { return mTrans; }
+  rstl::pair< uint, uint > GetAnimPair() const { return rstl::pair< uint, uint >(mAnimA, mAnimB); }
+  const rstl::rc_ptr< IMetaTrans >& GetMetaTrans() const { return mTrans; }
 };
 
+CHECK_SIZEOF(CTransition, 0x14)
+
 #endif // _CTRANSITION

include/Kyoto/Animation/CTransitionDatabase.hpp

@@ -0,0 +1,25 @@
+#ifndef _CTRANSITIONDATABASE
+#define _CTRANSITIONDATABASE
+
+#include "Kyoto/TToken.hpp"
+
+#include "rstl/optional_object.hpp"
+#include "rstl/rc_ptr.hpp"
+
+class IMetaTrans;
+
+class CTransitionDatabase {
+public:
+  virtual const rstl::rc_ptr< IMetaTrans >& GetMetaTrans(uint from, uint to) const = 0;
+
+  explicit CTransitionDatabase(const rstl::optional_object< TToken< CTransitionDatabase > >& token =
+                                   rstl::optional_object_null())
+  : mToken(token) {}
+  ~CTransitionDatabase() {}
+
+private:
+  rstl::optional_object< TToken< CTransitionDatabase > > mToken;
+};
+CHECK_SIZEOF(CTransitionDatabase, 0x10)
+
+#endif // _CTRANSITIONDATABASE

include/Kyoto/Animation/CTransitionManager.hpp

@@ -6,6 +6,7 @@
 class CAnimTreeNode;
 class CTransitionManager {
 public:
+  CTransitionManager(const CAnimSysContext& context);
   ~CTransitionManager();
   rstl::rc_ptr< CAnimTreeNode > GetTransitionTree(const rstl::ncrc_ptr< CAnimTreeNode >& a,
                                                   const rstl::ncrc_ptr< CAnimTreeNode >& b) const;

include/Kyoto/CVParamTransfer.hpp

@@ -22,7 +22,7 @@ class CVParamTransfer {
   CVParamTransfer() {}
   template < typename T >
   CVParamTransfer(TObjOwnerParam< T >* obj) : mObj(obj) {}
-  static CVParamTransfer Null();
+  static CVParamTransfer Null() { return CVParamTransfer(); }
 
   const IVParamObj& operator*() const { return *mObj; }
   const rstl::rc_ptr< IVParamObj >& GetObj() const { return mObj; }

include/Kyoto/IObjFactory.hpp

@@ -0,0 +1,9 @@
+#ifndef _IOBJFACTORY
+#define _IOBJFACTORY
+
+class IObjFactory {
+public:
+  virtual ~IObjFactory() = 0;
+};
+
+#endif // _IOBJFACTORY

include/MetroidPrime/CAnimationDatabaseGame.hpp

@@ -0,0 +1,24 @@
+#ifndef _CANIMATIONDATABASEGAME
+#define _CANIMATIONDATABASEGAME
+
+#include "Kyoto/Animation/CAnimationDatabase.hpp"
+
+class CAnimation;
+
+class CAnimationDatabaseGame : public CAnimationDatabase {
+public:
+  explicit CAnimationDatabaseGame(const rstl::vector< CAnimation >& anims);
+
+  const rstl::rc_ptr< IMetaAnim >& GetMetaAnim(uint idx) const override;
+  uint GetNumMetaAnims() const override;
+  rstl::string GetMetaAnimName(uint idx) const override;
+  void GetAllUniquePrimitives(rstl::vector< CPrimitive >& primsOut) const override;
+  void GetUniquePrimitivesFromMetaAnim(rstl::set< CPrimitive >& primsOut,
+                                       const rstl::string& name) const override;
+
+private:
+  rstl::vector< rstl::rc_ptr< IMetaAnim > > mAnims;
+};
+CHECK_SIZEOF(CAnimationDatabaseGame, 0x20)
+
+#endif // _CANIMATIONDATABASEGAME

include/MetroidPrime/CTransitionDatabaseGame.hpp

@@ -0,0 +1,29 @@
+#ifndef _CTRANSITIONDATABASEGAME
+#define _CTRANSITIONDATABASEGAME
+
+#include "Kyoto/Animation/CTransitionDatabase.hpp"
+#include "Kyoto/Animation/IMetaTrans.hpp"
+
+#include "rstl/pair.hpp"
+#include "rstl/vector.hpp"
+
+class CTransition;
+class CHalfTransition;
+
+class CTransitionDatabaseGame : public CTransitionDatabase {
+public:
+  CTransitionDatabaseGame(const rstl::vector< CTransition >& transitions,
+                          const rstl::vector< CHalfTransition >& halfTransitions,
+                          rstl::rc_ptr< IMetaTrans > defaultTrans);
+  ~CTransitionDatabaseGame() {}
+
+  const rstl::rc_ptr< IMetaTrans >& GetMetaTrans(uint from, uint to) const override;
+
+private:
+  rstl::rc_ptr< IMetaTrans > mDefaultTrans;
+  rstl::vector< rstl::pair< rstl::pair< uint, uint >, rstl::rc_ptr< IMetaTrans > > > mTransitions;
+  rstl::vector< rstl::pair< uint, rstl::rc_ptr< IMetaTrans > > > mHalfTransitions;
+};
+CHECK_SIZEOF(CTransitionDatabaseGame, 0x38)
+
+#endif // _CTRANSITIONDATABASEGAME