Continue work on CActor::UpdateAnimation; lots of headers n stuff

include/Kyoto/Audio/CAudioSys.hpp

@@ -5,7 +5,7 @@
 
 class CAudioSys {
 public:
-  static const u8 kMaxVolume;
+  static const u8 kkMaxVolume;
 };
 
 #endif

include/Kyoto/Math/CQuaternion.hpp

@@ -4,6 +4,9 @@
 #include "types.h"
 
 class CQuaternion {
+public:
+  CQuaternion(f32 w, f32 x, f32 y, f32 z) : w(w), x(x), y(y), z(z) {}
+
 private:
   f32 w;
   f32 x;

include/Kyoto/Math/CVector3f.hpp

@@ -14,6 +14,8 @@ public:
   explicit CVector3f(f32 x, f32 y, f32 z) : mX(x), mY(y), mZ(z) {}
   CVector3f(const CVector2f& v, f32 z) : mX(v.GetX()), mY(v.GetY()), mZ(z) {}
 
+  CVector3f(const CVector3f& other) : mX(other.mX), mY(other.mY), mZ(other.mZ) {}
+
   CVector3f(CInputStream& in);
   void PutTo(COutputStream& out) const;
 

include/Kyoto/TToken.hpp

@@ -31,6 +31,9 @@ public:
   TCachedToken() {}
   TCachedToken(const CToken& token) : TToken(token), x8_item(nullptr) {}
 
+  // TODO
+  operator const TToken< T >&() const;
+
 private:
   T* x8_item;
 };
@@ -40,6 +43,9 @@ class TLockedToken : public TCachedToken< T > {
 public:
   TLockedToken() {}
   TLockedToken(const CToken& token) : TCachedToken(token) { Lock(); }
+
+  // TODO
+  operator const TToken< T >&() const;
 };
 
 #endif

include/MetroidPrime/CActor.hpp

@@ -7,31 +7,192 @@
 #include "Collision/CMaterialList.hpp"
 
 #include "MetroidPrime/CEntity.hpp"
+#include "MetroidPrime/CModelData.hpp"
 #include "MetroidPrime/CModelFlags.hpp"
 #include "MetroidPrime/CSfxHandle.hpp"
 
 #include "Kyoto/Graphics/CColor.hpp"
 #include "Kyoto/Math/CAABox.hpp"
 #include "Kyoto/Math/CTransform4f.hpp"
-#include "Kyoto/Math/CQuaternion.hpp"
 #include "Kyoto/TToken.hpp"
 
+#include "rstl/optional_object.hpp"
 #include "rstl/pair.hpp"
 #include "rstl/reserved_vector.hpp"
 #include "rstl/single_ptr.hpp"
 
 class CActorLights;
 class CActorParameters;
-class CModelData;
 class CScannableObjectInfo;
 class CSimpleShadow;
 
-// TODO move
-struct SAdvancementDeltas {
-  CVector3f x0_posDelta;
-  CQuaternion xc_rotDelta;
+class CDamageInfo;
+class CDamageVulnerability;
+class CFrustum;
+class CHealthInfo;
+class CScriptWater;
+class CWeaponMode;
+class CInt32POINode;
+
+enum EWeaponCollisionResponseTypes {
+  kWCR_None,
+  kWCR_Default,
+  kWCR_Unknown2,
+  kWCR_Metal,
+  kWCR_Grass,
+  kWCR_Ice,
+  kWCR_Goo,
+  kWCR_Wood,
+  kWCR_Water,
+  kWCR_Mud,
+  kWCR_Lava,
+  kWCR_Sand,
+  kWCR_Projectile,
+  kWCR_OtherProjectile,
+  kWCR_Unknown14,
+  kWCR_Unknown15,
+  kWCR_EnemyNormal,
+  kWCR_EnemySpecial,
+  kWCR_EnemyShielded,
+  kWCR_Unknown19,
+  kWCR_Unknown20,
+  kWCR_Unknown21,
+  kWCR_Unknown22,
+  kWCR_Unknown23,
+  kWCR_Unknown24,
+  kWCR_Unknown25,
+  kWCR_Unknown26,
+  kWCR_Unknown27,
+  kWCR_Unknown28,
+  kWCR_Unknown29,
+  kWCR_Unknown30,
+  kWCR_Unknown31,
+  kWCR_Unknown32,
+  kWCR_Unknown33,
+  kWCR_Unknown34,
+  kWCR_Unknown35,
+  kWCR_Unknown36,
+  kWCR_Unknown37,
+  kWCR_ChozoGhost,
+  kWCR_Unknown39,
+  kWCR_Unknown40,
+  kWCR_Unknown41,
+  kWCR_AtomicBeta,
+  kWCR_AtomicAlpha,
+  kWCR_Unknown44,
+  kWCR_Unknown45,
+  kWCR_Unknown46,
+  kWCR_Unknown47,
+  kWCR_Unknown48,
+  kWCR_Unknown49,
+  kWCR_Unknown50,
+  kWCR_Unknown51,
+  kWCR_Unknown52,
+  kWCR_Unknown53,
+  kWCR_Unknown54,
+  kWCR_Unknown55,
+  kWCR_Unknown56,
+  kWCR_Unknown57,
+  kWCR_Unknown58,
+  kWCR_Unknown59,
+  kWCR_Unknown60,
+  kWCR_Unknown61,
+  kWCR_Unknown62,
+  kWCR_Unknown63,
+  kWCR_Unknown64,
+  kWCR_Unknown65,
+  kWCR_Unknown66,
+  kWCR_Unknown67,
+  kWCR_Unknown68,
+  kWCR_Unknown69,
+  kWCR_Unknown70,
+  kWCR_Unknown71,
+  kWCR_Unknown72,
+  kWCR_Unknown73,
+  kWCR_Unknown74,
+  kWCR_Unknown75,
+  kWCR_Unknown76,
+  kWCR_Unknown77,
+  kWCR_Unknown78,
+  kWCR_Unknown79,
+  kWCR_Unknown80,
+  kWCR_Unknown81,
+  kWCR_Unknown82,
+  kWCR_Unknown83,
+  kWCR_Unknown84,
+  kWCR_Unknown85,
+  kWCR_Unknown86,
+  kWCR_Unknown87,
+  kWCR_Unknown88,
+  kWCR_Unknown89,
+  kWCR_Unknown90,
+  kWCR_Unknown91,
+  kWCR_AtomicBetaReflect,
+  kWCR_AtomicAlphaReflect,
 };
-CHECK_SIZEOF(SAdvancementDeltas, 0x1c)
+enum EProjectileAttrib {
+  kPA_None = 0,
+  kPA_PartialCharge = (1 << 0),
+  kPA_PlasmaProjectile = (1 << 1),
+  kPA_Charged = (1 << 2),
+  kPA_Ice = (1 << 3),
+  kPA_Wave = (1 << 4),
+  kPA_Plasma = (1 << 5),
+  kPA_Phazon = (1 << 6),
+  kPA_ComboShot = (1 << 7),
+  kPA_Bombs = (1 << 8),
+  kPA_PowerBombs = (1 << 9),
+  kPA_BigProjectile = (1 << 10),
+  kPA_ArmCannon = (1 << 11),
+  kPA_BigStrike = (1 << 12),
+  kPA_DamageFalloff = (1 << 13),
+  kPA_StaticInterference = (1 << 14),
+  kPA_PlayerUnFreeze = (1 << 15),
+  kPA_ParticleOPTS = (1 << 16),
+  kPA_KeepInCinematic = (1 << 17),
+};
+enum EUserEventType {
+  kUE_Projectile = 0,
+  kUE_EggLay = 1,
+  kUE_LoopedSoundStop = 2,
+  kUE_AlignTargetPos = 3,
+  kUE_AlignTargetRot = 4,
+  kUE_ChangeMaterial = 5,
+  kUE_Delete = 6,
+  kUE_GenerateEnd = 7,
+  kUE_DamageOn = 8,
+  kUE_DamageOff = 9,
+  kUE_AlignTargetPosStart = 10,
+  kUE_DeGenerate = 11,
+  kUE_Landing = 12,
+  kUE_TakeOff = 13,
+  kUE_FadeIn = 14,
+  kUE_FadeOut = 15,
+  kUE_ScreenShake = 16,
+  kUE_BeginAction = 17,
+  kUE_EndAction = 18,
+  kUE_BecomeRagDoll = 19,
+  kUE_IkLock = 20,
+  kUE_IkRelease = 21,
+  kUE_BreakLockOn = 22,
+  kUE_BecomeShootThrough = 23,
+  kUE_RemoveCollision = 24,
+  kUE_ObjectPickUp = 25,
+  kUE_ObjectDrop = 26,
+  kUE_EventStart = 27,
+  kUE_EventStop = 28,
+  kUE_Activate = 29,
+  kUE_Deactivate = 30,
+  kUE_SoundPlay = 31,
+  kUE_SoundStop = 32,
+  kUE_EffectOn = 33,
+  kUE_EffectOff = 34,
+};
+
+// class CBoolPOINode;
+// class CInt32POINode;
+// class CParticlePOINode;
+// class CSoundPOINode;
 
 class CActor : public CEntity {
 public:
@@ -40,17 +201,67 @@ public:
     kTF_Cold = 1,
     kTF_Hot = 2,
   };
+  enum EFluidState {
+    kFS_EnteredFluid,
+    kFS_InFluid,
+    kFS_LeftFluid,
+  };
+  enum EScanState {
+    kSS_Start,
+    kSS_Processing,
+    kSS_Done,
+  };
 
   CActor(TUniqueId uid, bool active, const rstl::string& name, const CEntityInfo& info, const CTransform4f& xf, const CModelData& mData,
          const CMaterialList& list, const CActorParameters& params, TUniqueId nextDrawNode);
   ~CActor();
 
+  virtual void PreRender(CStateManager&, const CFrustum&);
+  virtual void AddToRenderer(const CFrustum&, CStateManager&);
+  virtual void Render(CStateManager&);
+  virtual bool CanRenderUnsorted(const CStateManager&) const;
+  virtual void CalculateRenderBounds();
+  virtual CHealthInfo* HealthInfo(CStateManager&);
+  virtual const CDamageVulnerability* GetDamageVulnerability() const;
+  virtual const CDamageVulnerability* GetDamageVulnerability(const CVector3f&, const CVector3f&, const CDamageInfo&) const;
+  virtual rstl::optional_object< CAABox > GetTouchBounds() const;
+  virtual void Touch(CActor&, CStateManager&);
+  virtual CVector3f GetOrbitPosition(const CStateManager&) const;
+  virtual CVector3f GetAimPosition(const CStateManager&, float) const;
+  virtual CVector3f GetHomingPosition(const CStateManager&, float) const;
+  virtual CVector3f GetScanObjectIndicatorPosition(const CStateManager&) const;
+  virtual EWeaponCollisionResponseTypes GetCollisionResponseType(const CVector3f&, const CVector3f&, const CWeaponMode&,
+                                                                 EProjectileAttrib) const;
+  virtual void FluidFXThink(EFluidState, CScriptWater&, CStateManager&);
+  virtual void OnScanStateChanged(EScanState, CStateManager&);
+  virtual CAABox GetSortingBounds(const CStateManager&) const;
+  virtual void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt);
+
   SAdvancementDeltas UpdateAnimation(float dt, CStateManager& mgr, bool advTree);
 
+  void ProcessSoundEvent(s32 sfxId, f32 weight, s32 flags, f32 fallOff, f32 maxDist, u8 minVol, u8 maxVol, const CVector3f& toListener,
+                         const CVector3f& position, s32 aid, CStateManager& mgr, bool translateId);
+
   void UpdateSfxEmitters();
   void RemoveEmitter();
 
   const CTransform4f& GetTransform() const { return x34_transform; }
+  CVector3f GetTranslation() const { return x34_transform.GetTranslation(); }
+  bool GetMuted() const { return xe5_26_muted; }
+  bool HasAnimation() const { return x64_modelData && x64_modelData->GetAnimationData(); }
+
+  // const CBoolPOINode* GetBoolPOIList(s32& count) {
+  //   return HasAnimation() ? x64_modelData->GetAnimationData()->GetBoolPOIList(count) : nullptr;
+  // }
+  // const CInt32POINode* GetInt32POIList(s32& count) {
+  //   return HasAnimation() ? x64_modelData->GetAnimationData()->GetInt32POIList(count) : nullptr;
+  // }
+  // const CParticlePOINode* GetParticlePOIList(s32& count) {
+  //   return HasAnimation() ? x64_modelData->GetAnimationData()->GetParticlePOIList(count) : nullptr;
+  // }
+  // const CSoundPOINode* GetSoundPOIList(s32& count) {
+  //   return HasAnimation() ? x64_modelData->GetAnimationData()->GetSoundPOIList(count) : nullptr;
+  // }
 
 protected:
   CTransform4f x34_transform;

include/MetroidPrime/CAdditiveAnimPlayback.hpp

@@ -0,0 +1,38 @@
+#ifndef _CADDITIVEANIMPLAYBACK_HPP
+#define _CADDITIVEANIMPLAYBACK_HPP
+
+#include "types.h"
+
+#include "rstl/rc_ptr.hpp"
+
+class CAnimTreeNode;
+
+class CAdditiveAnimationInfo {
+private:
+  f32 x0_fadeInDur;
+  f32 x4_fadeOutDur;
+};
+
+class CAdditiveAnimPlayback {
+public:
+  enum EPlaybackPhase {
+    kPP_None,
+    kPP_FadingIn,
+    kPP_FadingOut,
+    kPP_FadedIn,
+    kPP_FadedOut,
+  };
+
+private:
+  CAdditiveAnimationInfo x0_info;
+  rstl::ncrc_ptr< CAnimTreeNode > x8_anim;
+  f32 xc_targetWeight;
+  f32 x10_curWeight;
+  bool x14_active;
+  f32 x18_weightTimer;
+  EPlaybackPhase x1c_phase;
+  bool x20_needsFadeOut;
+};
+CHECK_SIZEOF(CAdditiveAnimPlayback, 0x24)
+
+#endif

include/MetroidPrime/CAnimData.hpp

@@ -3,8 +3,198 @@
 
 #include "types.h"
 
+#include "MetroidPrime/CAdditiveAnimPlayback.hpp"
+#include "MetroidPrime/CAnimPlaybackParms.hpp"
+#include "MetroidPrime/CCharacterInfo.hpp"
+#include "MetroidPrime/CHierarchyPoseBuilder.hpp"
+#include "MetroidPrime/CPOINode.hpp"
+#include "MetroidPrime/CParticleDatabase.hpp"
+#include "MetroidPrime/CPoseAsTransforms.hpp"
+
+#include "Kyoto/TToken.hpp"
+
+#include "rstl/reserved_vector.hpp"
+
+class CAnimationManager;
+class CAnimSysContext;
+class CAnimTreeNode;
+class CCharacterFactory;
+class CCharLayoutInfo;
+class CSkinnedModel;
+class CSkinnedModelWithAvgNormals;
+class CTransitionManager;
+
 class CAnimData {
-  // TODO
+public:
+  enum EAnimDir {
+    kAD_Forward,
+    kAD_Backward,
+  };
+
+  void SetParticleEffectState(const rstl::string& name, bool active, CStateManager& mgr) {
+    x120_particleDB.SetParticleEffectState(name, active, mgr);
+  }
+
+  s32 GetCharacterIndex() const { return x204_charIdx; }
+
+  const CBoolPOINode* GetBoolPOIList(s32& count) {
+    count = x20c_passedBoolCount;
+    return mBoolPOINodes.data();
+  }
+  const CInt32POINode* GetInt32POIList(s32& count) {
+    count = x210_passedIntCount;
+    return mInt32POINodes.data();
+  }
+  const CParticlePOINode* GetParticlePOIList(s32& count) {
+    count = x214_passedParticleCount;
+    return mParticlePOINodes.data();
+  }
+  const CSoundPOINode* GetSoundPOIList(s32& count) {
+    count = x218_passedSoundCount;
+    return mSoundPOINodes.data();
+  }
+
+  // SetIsAnimating__9CAnimDataFb
+  // SetAnimDir__9CAnimDataFQ29CAnimData8EAnimDir
+  // GetBoundingBox__9CAnimDataCFv
+  // GetBoundingBox__9CAnimDataCFRC12CTransform4f
+  // GetLocatorSegId__9CAnimDataCFRCQ24rstl66basic_string
+  // ResetPOILists__9CAnimDataFv
+  // GetAverageVelocity__9CAnimDataCFi
+  // AdvanceParticles__9CAnimDataFRC12CTransform4ffRC9CVector3fR13CStateManager
+  // PoseSkinnedModel__9CAnimDataCFRC13CSkinnedModelRC17CPoseAsTransformsRCQ24rstl37optional_object<18CVertexMorphEffect>PCf
+  // DrawSkinnedModel__9CAnimDataCFRC13CSkinnedModelRC11CModelFlags
+  // InitializeCache__9CAnimDataFv
+  // FreeCache__9CAnimDataFv
+  // SetInfraModel__9CAnimDataFRC21TLockedToken<6CModel>RC26TLockedToken<10CSkinRules>
+  // SetXRayModel__9CAnimDataFRC21TLockedToken<6CModel>RC26TLockedToken<10CSkinRules>
+  // AdvanceAnim__9CAnimDataFR13CCharAnimTimeR9CVector3fR11CQuaternion
+  // AdvanceIgnoreParticles__9CAnimDataFfR9CRandom16b
+  // Advance__9CAnimDataFfRC9CVector3fR13CStateManagerb
+  // DoAdvance__9CAnimDataFfRbR9CRandom16b
+  // SetAnimation__9CAnimDataFRC18CAnimPlaybackParmsb
+  // GetAnimationPrimitives__9CAnimDataCFRC18CAnimPlaybackParmsRQ24rstl72set<10CPrimitive,Q24rstl18less<10CPrimitive>,Q24rstl17rmemory_allocator>
+  // PrimitiveSetToTokenVector__9CAnimDataFRCQ24rstl72set<10CPrimitive,Q24rstl18less<10CPrimitive>,Q24rstl17rmemory_allocator>RQ24rstl42vector<6CToken,Q24rstl17rmemory_allocator>b
+  // BuildPose__9CAnimDataFv
+  // PreRender__9CAnimDataFv
+  // SetupRender__9CAnimDataCFRC13CSkinnedModelRCQ24rstl37optional_object<18CVertexMorphEffect>PCf
+  // Render__9CAnimDataCFRC13CSkinnedModelRC11CModelFlagsRCQ24rstl37optional_object<18CVertexMorphEffect>PCf
+  // RenderAuxiliary__9CAnimDataCFRC14CFrustumPlanes
+  // RecalcPoseBuilder__9CAnimDataCFPC13CCharAnimTime
+  // GetAnimationDuration__9CAnimDataCFi
+  // GetAnimTimeRemaining__9CAnimDataCFRCQ24rstl66basic_string<c,Q24rstl14char_traits<c>,Q24rstl17rmemory_allocator>
+  // IsAnimTimeRemaining__9CAnimDataCFfRCQ24rstl66basic_string<c,Q24rstl14char_traits<c>,Q24rstl17rmemory_allocator>
+  // GetLocatorTransform__9CAnimDataCFRCQ24rstl66basic_string<c,Q24rstl14char_traits<c>,Q24rstl17rmemory_allocator>PC13CCharAnimTime
+  // GetLocatorTransform__9CAnimDataCF6CSegIdPC13CCharAnimTime
+  // CalcPlaybackAlignmentParms__9CAnimDataFRC18CAnimPlaybackParmsRCQ24rstl25ncrc_ptr<13CAnimTreeNode>
+  // SetRandomPlaybackRate__9CAnimDataFR9CRandom16
+  // SetPlaybackRate__9CAnimDataFf
+  // MultiplyPlaybackRate__9CAnimDataFf
+  // GetTimeOfUserEvent__9CAnimDataCF14EUserEventTypeRC13CCharAnimTime
+  // GetAdvancementDeltas__9CAnimDataCFRC13CCharAnimTimeRC13CCharAnimTime
+  // Touch__9CAnimDataCFRC13CSkinnedModeli
+  // InitializeEffects__9CAnimDataFR13CStateManagerRC9CVector3f
+  // SetPhase__9CAnimDataFf -> SetPhase__11IAnimReaderFf
+  // AddAdditiveAnimation__9CAnimDataFUifbb
+  // DelAdditiveAnimation__9CAnimDataFUi
+  // IsAdditiveAnimationActive__9CAnimDataCFUi
+  // GetAdditiveAnimationTree__9CAnimDataCFUi
+  // GetAnimationTree__9CAnimDataCFv
+  // AnimationTree__9CAnimDataFv
+  // IsAdditiveAnimation__9CAnimDataCFUi
+  // UpdateAdditiveAnims__9CAnimDataFf
+  // AdvanceAdditiveAnims__9CAnimDataFf
+  // AddAdditiveSegData__9CAnimDataCFRC10CSegIdListR16CSegStatementSet
+  // GetEventResourceIdForAnimResourceId__9CAnimDataCFi
+  // GetAnimationManager__9CAnimDataFv
+  // SetPoseValid__9CAnimDataFb
+
+  // GetCharacterInfo__9CAnimDataCFv
+  // GetCharLayoutInfo__9CAnimDataCFv
+  // GetParticleDB__9CAnimDataFv
+  // GetDeltaRotation__9CAnimDataCFv
+  // GetDeltaOffset__9CAnimDataCFv
+  // IsDeltaOffsetInUse__9CAnimDataCFv
+  // GetAdvancementDeltas__19CAdvancementResultsCFv
+  // SetDeltaRotation__9CAnimDataFRC11CQuaternionb
+  // SetDeltaOffset__9CAnimDataFRC9CVector3fb
+  // SetDeltaOffsetInUse__9CAnimDataFv
+  // IsDeltaRotationInUse__9CAnimDataCFv
+  // IsDeltaOffsetPrimed__9CAnimDataCFv
+  // GetAnimDir__9CAnimDataCFv
+  // GetIsLoop__9CAnimDataCFv
+  // IsAnimating__9CAnimDataCFv
+  // SetPoseBuilderValid__9CAnimDataFb
+  // GetAnimationManager__9CAnimDataCFv
+  // GetPoseValid__9CAnimDataCFv
+  // GetPoseBuilderValid__9CAnimDataCFv
+  // GetParticleDB__9CAnimDataCFv
+  // GetAnimSysContext__9CAnimDataCFv
+  // CacheInt32PoiList__9CAnimDataFRC13CCharAnimTimeiRCQ24rstl25ncrc_ptr<13CAnimTreeNode>
+
+  // GetIceModel__9CAnimDataCFv
+  // GetPASDatabase__9CAnimDataCFv
+  // EnableLooping__9CAnimDataFb
+  // GetCurrentAnimation__9CAnimDataCFv
+  // GetSkinnedModel__9CAnimDataCFv
+  // GetXRayModel__9CAnimDataCFv
+  // GetInfraModel__9CAnimDataCFv
+  // GetPose__9CAnimDataCFv
+  // PoseBuilder__9CAnimDataCFv
+  // GetPlaybackRate__9CAnimDataCFv
+  // Pose__9CAnimDataFv
+  // GetPoseBuilder__9CAnimDataCFv
+
+  // CacheSoundPoiList__9CAnimDataFRCQ24rstl25ncrc_ptr<13CAnimTreeNode>RC13CCharAnimTimei
+  // CacheParticlePoiList__9CAnimDataFRCQ24rstl25ncrc_ptr<13CAnimTreeNode>RC13CCharAnimTimei
+  // CacheBoolPoiList__9CAnimDataFRCQ24rstl25ncrc_ptr<13CAnimTreeNode>RC13CCharAnimTimei
+  // CacheInt32PoiList__9CAnimDataFRCQ24rstl25ncrc_ptr<13CAnimTreeNode>RC13CCharAnimTimei
+
+private:
+  TLockedToken< CCharacterFactory > x0_charFactory;
+  CCharacterInfo xc_charInfo;
+  TLockedToken< CCharLayoutInfo > xcc_layoutData;
+  TLockedToken< CSkinnedModel > xd8_modelData;
+  rstl::optional_object< TLockedToken< CSkinnedModelWithAvgNormals > > xe4_iceModelData;
+  rstl::rc_ptr< CSkinnedModel > xf4_xrayModel;
+  rstl::rc_ptr< CSkinnedModel > xf8_infraModel;
+  rstl::rc_ptr< CAnimSysContext > xfc_animCtx;
+  rstl::rc_ptr< CAnimationManager > x100_animMgr;
+  EAnimDir x104_animDir;
+  CAABox x108_aabb;
+  CParticleDatabase x120_particleDB;
+  CAssetId x1d8_selfId;
+  CVector3f x1dc_alignPos;
+  CQuaternion x1e8_alignRot;
+  rstl::rc_ptr< CAnimTreeNode > x1f8_animRoot;
+  rstl::rc_ptr< CTransitionManager > x1fc_transMgr;
+  f32 x200_speedScale;
+  s32 x204_charIdx;
+  s32 x208_defaultAnim;
+  u32 x20c_passedBoolCount;
+  u32 x210_passedIntCount;
+  u32 x214_passedParticleCount;
+  u32 x218_passedSoundCount;
+  s32 x21c_particleLightIdx;
+  bool x220_24_animating : 1;
+  bool x220_25_loop : 1;
+  bool x220_26_aligningPos : 1;
+  bool x220_27_ : 1;
+  bool x220_28_ : 1;
+  bool x220_29_animationJustStarted : 1;
+  bool x220_30_poseBuilt : 1;
+  bool x220_31_poseCached : 1;
+  CPoseAsTransforms x224_pose;
+  CHierarchyPoseBuilder x2fc_poseBuilder;
+  CAnimPlaybackParms x40c_playbackParms;
+  rstl::reserved_vector< rstl::pair< s32, CAdditiveAnimPlayback >, 8 > x434_additiveAnims;
+
+  static rstl::reserved_vector< CBoolPOINode, 8 > mBoolPOINodes;
+  static rstl::reserved_vector< CInt32POINode, 16 > mInt32POINodes;
+  static rstl::reserved_vector< CParticlePOINode, 20 > mParticlePOINodes;
+  static rstl::reserved_vector< CSoundPOINode, 20 > mSoundPOINodes;
+  // in cpp -> rstl::reserved_vector< CInt32POINode, 16 > sInt32TransientCache;
 };
+CHECK_SIZEOF(CAnimData, 0x434 + 0x144)
 
 #endif

include/MetroidPrime/CAnimPlaybackParms.hpp

@@ -0,0 +1,25 @@
+#ifndef _CANIMPLAYBACKPARMS_HPP
+#define _CANIMPLAYBACKPARMS_HPP
+
+#include "types.h"
+
+class CQuaternion;
+class CTransform4f;
+class CVector3f;
+
+class CAnimPlaybackParms {
+private:
+  s32 x0_animA;
+  s32 x4_animB;
+  f32 x8_blendWeight;
+  bool xc_animating;
+  s32 x10_;
+  CVector3f* x14_targetPos;
+  bool x18_useLocator;
+  CQuaternion* x1c_deltaOrient;
+  CTransform4f* x20_objectXf;
+  CVector3f* x24_objectScale;
+};
+CHECK_SIZEOF(CAnimPlaybackParms, 0x28)
+
+#endif

include/MetroidPrime/CCharAnimTime.hpp

@@ -0,0 +1,22 @@
+#ifndef _CCHARANIMTIME_HPP
+#define _CCHARANIMTIME_HPP
+
+#include "types.h"
+
+class CCharAnimTime {
+public:
+  enum EType {
+    kT_NonZero,
+    kT_ZeroIncreasing,
+    kT_ZeroSteady,
+    kT_ZeroDecreasing,
+    kT_Infinity,
+  };
+
+private:
+  f32 x0_time;
+  EType x4_type;
+};
+CHECK_SIZEOF(CCharAnimTime, 0x8)
+
+#endif

include/MetroidPrime/CCharacterInfo.hpp

@@ -0,0 +1,44 @@
+#ifndef _CCHARACTERINFO_HPP
+#define _CCHARACTERINFO_HPP
+
+#include "types.h"
+
+#include "MetroidPrime/CEffectComponent.hpp"
+#include "MetroidPrime/CPASDatabase.hpp"
+
+#include "Kyoto/IObjectStore.hpp"
+#include "Kyoto/Math/CAABox.hpp"
+
+#include "rstl/pair.hpp"
+#include "rstl/string.hpp"
+#include "rstl/vector.hpp"
+
+class CCharacterInfo {
+public:
+  class CParticleResData {
+  private:
+    rstl::vector< CAssetId > x0_part;
+    rstl::vector< CAssetId > x10_swhc;
+    rstl::vector< CAssetId > x20_elsc;
+    rstl::vector< CAssetId > x30_elsc;
+  };
+
+private:
+  u16 x0_tableCount;
+  rstl::string x4_name;
+  CAssetId x14_cmdl;
+  CAssetId x18_cksr;
+  CAssetId x1c_cinf;
+  rstl::vector< rstl::pair< s32, rstl::pair< rstl::string, rstl::string > > > x20_animInfo;
+  CPASDatabase x30_pasDatabase;
+  CParticleResData x44_partRes;
+  u32 x84_unk;
+  rstl::vector< rstl::pair< rstl::string, CAABox > > x88_aabbs;
+  rstl::vector< rstl::pair< rstl::string, rstl::vector< CEffectComponent > > > x98_effects;
+  u32 xa8_cmdlOverlay;
+  u32 xac_cksrOverlay;
+  rstl::vector< s32 > xb0_animIdxs;
+};
+CHECK_SIZEOF(CCharacterInfo, 0xc0)
+
+#endif

include/MetroidPrime/CEffectComponent.hpp

@@ -0,0 +1,18 @@
+#ifndef _CEFFECTCOMPONENT_HPP
+#define _CEFFECTCOMPONENT_HPP
+
+#include "types.h"
+
+#include "MetroidPrime/CParticleData.hpp"
+
+class CEffectComponent {
+private:
+  rstl::string x0_name;
+  SObjectTag x10_tag;
+  rstl::string x18_boneName;
+  f32 x28_scale;
+  CParticleData::EParentedMode x2c_parentedMode;
+  u32 x30_flags;
+};
+
+#endif

include/MetroidPrime/CHierarchyPoseBuilder.hpp

@@ -0,0 +1,62 @@
+#ifndef _CHIERARCHYPOSEBUILDER_HPP
+#define _CHIERARCHYPOSEBUILDER_HPP
+
+#include "types.h"
+
+#include "MetroidPrime/TGameTypes.hpp"
+
+#include "Kyoto/Math/CQuaternion.hpp"
+#include "Kyoto/Math/CVector3f.hpp"
+#include "Kyoto/TToken.hpp"
+
+#include "rstl/construction_deferred.hpp"
+#include "rstl/optional_object.hpp"
+
+class CCharLayoutInfo;
+
+template < typename T >
+class TSegIdMap {
+private:
+  CSegId x0_boneCount;
+  CSegId x1_capacity;
+  u32 x4_maxCapacity;
+  CSegId x8_indirectionMap[200];
+  T* xd0_nodes;
+  CSegId xd4_curPrevBone;
+};
+typedef TSegIdMap< void > unk_TSegIdMap;
+CHECK_SIZEOF(unk_TSegIdMap, 0xd8)
+
+class CLayoutDescription {
+public:
+  class CScaledLayoutDescription {
+  private:
+    TCachedToken< CCharLayoutInfo > x0_layoutToken;
+    f32 xc_scale;
+    rstl::optional_object< CVector3f > x10_scaleVec;
+  };
+
+private:
+  TCachedToken< CCharLayoutInfo > x0_layoutToken;
+  rstl::optional_object< CScaledLayoutDescription > xc_scaled;
+};
+CHECK_SIZEOF(CLayoutDescription, 0x30)
+
+class CHierarchyPoseBuilder {
+public:
+  class CTreeNode {
+  private:
+    CSegId x0_child;
+    CSegId x1_sibling;
+    CQuaternion x4_rotation;
+    CVector3f x14_offset;
+  };
+
+private:
+  CLayoutDescription x0_layoutDesc;
+  rstl::construction_deferred< CSegId > x30_rootId;
+  TSegIdMap< CTreeNode > x38_treeMap;
+};
+CHECK_SIZEOF(CHierarchyPoseBuilder, 0x110)
+
+#endif

include/MetroidPrime/CModelData.hpp

@@ -17,6 +17,14 @@
 class CAnimData;
 class CModel;
 
+// TODO move
+#include "Kyoto/Math/CQuaternion.hpp"
+struct SAdvancementDeltas {
+  CVector3f x0_posDelta;
+  CQuaternion xc_rotDelta;
+};
+CHECK_SIZEOF(SAdvancementDeltas, 0x1c)
+
 class CModelData {
 public:
   bool IsStaticModel() const { return xc_animData.get() == nullptr && !x1c_normalModel; }
@@ -30,7 +38,7 @@ public:
   SAdvancementDeltas AdvanceAnimation(float dt, CStateManager& mgr, TAreaId aid, bool advTree);
   void AdvanceParticles(const CTransform4f& xf, float dt, CStateManager& mgr);
 
-  rstl::auto_ptr< CAnimData >& GetAnimData() { return xc_animData; }
+  CAnimData* GetAnimationData() const { return xc_animData.get(); }
 
   void SetXRayModel(const rstl::pair< CAssetId, CAssetId >& assets);
   void SetInfraModel(const rstl::pair< CAssetId, CAssetId >& assets);

include/MetroidPrime/CPASAnimState.hpp

@@ -0,0 +1,93 @@
+#ifndef _CPASANIMSTATE_HPP
+#define _CPASANIMSTATE_HPP
+
+#include "types.h"
+
+#include "rstl/vector.hpp"
+
+namespace pas {
+enum EAnimationState {
+  kAS_Invalid = -1,
+  kAS_Fall = 0,
+  kAS_Getup = 1,
+  kAS_LieOnGround = 2,
+  kAS_Step = 3,
+  kAS_Death = 4,
+  kAS_Locomotion = 5,
+  kAS_KnockBack = 6,
+  kAS_MeleeAttack = 7,
+  kAS_Turn = 8,
+  kAS_LoopAttack = 9,
+  kAS_LoopReaction = 10,
+  kAS_GroundHit = 11,
+  kAS_Generate = 12,
+  kAS_Jump = 13,
+  kAS_Hurled = 14,
+  kAS_Slide = 15,
+  kAS_Taunt = 16,
+  kAS_Scripted = 17,
+  kAS_ProjectileAttack = 18,
+  kAS_Cover = 19,
+  kAS_WallHang = 20,
+  kAS_AdditiveIdle = 21,
+  kAS_AdditiveAim = 22,
+  kAS_AdditiveFlinch = 23,
+  kAS_AdditiveReaction = 24,
+};
+} // namespace pas
+
+class CPASAnimParm {
+public:
+  enum EParmType {
+    kPT_None = -1,
+    kPT_Int32 = 0,
+    kPT_UInt32 = 1,
+    kPT_Float = 2,
+    kPT_Bool = 3,
+    kPT_Enum = 4,
+  };
+  union UParmValue {
+    s32 m_int;
+    u32 m_uint;
+    f32 m_float;
+    bool m_bool;
+  };
+
+private:
+  UParmValue x0_value;
+  EParmType x4_type;
+};
+
+class CPASParmInfo {
+public:
+  enum EWeightFunction {
+    kWF_ExactMatch,
+    kWF_PercentError,
+    kWF_AngularPercent,
+    kWF_NoWeight,
+  };
+
+private:
+  CPASAnimParm::EParmType x0_type;
+  EWeightFunction x4_weightFunction;
+  float x8_weight;
+  CPASAnimParm::UParmValue xc_min;
+  CPASAnimParm::UParmValue x10_max;
+};
+
+class CPASAnimInfo {
+private:
+  u32 x0_id;
+  rstl::reserved_vector< CPASAnimParm::UParmValue, 8 > x4_parms;
+};
+
+class CPASAnimState {
+private:
+  pas::EAnimationState x0_id;
+  rstl::vector< CPASParmInfo > x4_parms;
+  rstl::vector< CPASAnimInfo > x14_anims;
+  rstl::vector< s32 > x24_selectionCache;
+};
+CHECK_SIZEOF(CPASAnimState, 0x34)
+
+#endif

include/MetroidPrime/CPASDatabase.hpp

@@ -0,0 +1,17 @@
+#ifndef _CPASDATABASE_HPP
+#define _CPASDATABASE_HPP
+
+#include "types.h"
+
+#include "MetroidPrime/CPASAnimState.hpp"
+
+#include "rstl/vector.hpp"
+
+class CPASDatabase {
+private:
+  rstl::vector< CPASAnimState > x0_states;
+  s32 x10_defaultState;
+};
+CHECK_SIZEOF(CPASDatabase, 0x14)
+
+#endif

include/MetroidPrime/CPOINode.hpp

@@ -0,0 +1,86 @@
+#ifndef _CPOINODE_HPP
+#define _CPOINODE_HPP
+
+#include "types.h"
+
+#include "MetroidPrime/CCharAnimTime.hpp"
+#include "MetroidPrime/CParticleData.hpp"
+
+#include "rstl/string.hpp"
+
+#define POITYPE_LOOP 0
+#define POITYPE_EMPTYBOOL 1
+#define POITYPE_EMPTYINT32 2
+#define POITYPE_SOUNDINT32 4
+#define POITYPE_PARTICLE 5
+#define POITYPE_USEREVENT 6
+#define POITYPE_RANDRATE 7
+#define POITYPE_SOUND 8
+
+class CPOINode {
+public:
+  virtual ~CPOINode();
+
+  const rstl::string& GetString() const { return x8_name; }
+  s32 GetPoiType() const { return x18_type; }
+  const CCharAnimTime& GetTime() const { return x1c_time; }
+  f32 GetWeight() const { return x2c_weight; }
+  s32 GetCharacterIndex() const { return x30_charIdx; }
+  s32 GetFlags() const { return x34_flags; }
+
+protected:
+  u16 x4_;
+  rstl::string x8_name;
+  s16 x18_type;
+  CCharAnimTime x1c_time;
+  s32 x24_index;
+  bool x28_unique;
+  f32 x2c_weight;
+  s32 x30_charIdx;
+  s32 x34_flags;
+};
+CHECK_SIZEOF(CPOINode, 0x38)
+
+class CBoolPOINode : public CPOINode {
+public:
+  // __ct__12CBoolPOINodeFQ24rstl66basic_string<c,Q24rstl14char_traits<c>,Q24rstl17rmemory_allocator>UsRC13CCharAnimTimeibfiib
+  // __ct__12CBoolPOINodeFR12CInputStream
+  // CopyNodeMinusStartTime__12CBoolPOINodeFRC12CBoolPOINodeRC13CCharAnimTime
+
+  bool GetValue() const { return x38_val; }
+
+private:
+  bool x38_val;
+};
+
+class CInt32POINode : public CPOINode {
+public:
+  // __ct__13CInt32POINodeFQ24rstl66basic_string<c,Q24rstl14char_traits<c>,Q24rstl17rmemory_allocator>UsRC13CCharAnimTimeibfiiiRCQ24rstl66basic_string<c,Q24rstl14char_traits<c>,Q24rstl17rmemory_allocator>
+  // CopyNodeMinusStartTime__13CInt32POINodeFRC13CInt32POINodeRC13CCharAnimTime
+
+  s32 GetValue() const { return x38_val; }
+  const rstl::string& GetLocatorName() const { return x3c_lctrName; }
+
+private:
+  s32 x38_val;
+  rstl::string x3c_lctrName;
+};
+
+class CParticlePOINode : public CPOINode {
+private:
+  CParticleData x38_data;
+};
+
+class CSoundPOINode : public CPOINode {
+public:
+  u32 GetSoundId() const { return x38_sfxId; }
+  f32 GetFallOff() const { return x3c_falloff; }
+  f32 GetMaxDistance() const { return x40_maxDist; }
+
+private:
+  u32 x38_sfxId;
+  f32 x3c_falloff;
+  f32 x40_maxDist;
+};
+
+#endif

include/MetroidPrime/CParticleData.hpp

@@ -0,0 +1,35 @@
+#ifndef _CPARTICLEDATA_HPP
+#define _CPARTICLEDATA_HPP
+
+#include "types.h"
+
+#include "Kyoto/IObjectStore.hpp"
+#include "Kyoto/Math/CVector3f.hpp"
+
+#include "rstl/string.hpp"
+
+class CParticleData {
+public:
+  enum EParentedMode {
+    kPM_Initial,
+    kPM_ContinuousEmitter,
+    kPM_ContinuousSystem,
+  };
+
+private:
+  u32 x0_duration;
+  SObjectTag x4_particle;
+  rstl::string xc_boneName;
+  f32 x1c_scale;
+  EParentedMode x20_parentMode;
+};
+
+class CAuxiliaryParticleData {
+private:
+  u32 x0_duration;
+  SObjectTag x4_particle;
+  CVector3f xc_translation;
+  f32 x18_scale;
+};
+
+#endif

include/MetroidPrime/CParticleDatabase.hpp

@@ -0,0 +1,41 @@
+#ifndef _CPARTICLEDATABASE_HPP
+#define _CPARTICLEDATABASE_HPP
+
+#include "types.h"
+
+#include "Kyoto/IObjectStore.hpp"
+#include "Kyoto/TToken.hpp"
+
+#include "rstl/auto_ptr.hpp"
+#include "rstl/map.hpp"
+#include "rstl/rc_ptr.hpp"
+#include "rstl/string.hpp"
+
+class CElectricDescription;
+class CGenDescription;
+class CParticleGenInfo;
+class CStateManager;
+class CSwooshDescription;
+
+class CParticleDatabase {
+public:
+  typedef rstl::map< rstl::string, rstl::auto_ptr< CParticleGenInfo > > DrawMap;
+
+  void SetParticleEffectState(const rstl::string& name, bool active, CStateManager& mgr);
+
+private:
+  rstl::map< CAssetId, rstl::rc_ptr< TLockedToken< CGenDescription > > > x0_particleDescs;
+  rstl::map< CAssetId, rstl::rc_ptr< TLockedToken< CSwooshDescription > > > x14_swooshDescs;
+  rstl::map< CAssetId, rstl::rc_ptr< TLockedToken< CElectricDescription > > > x28_electricDescs;
+  DrawMap x3c_rendererDrawLoop;
+  DrawMap x50_firstDrawLoop;
+  DrawMap x64_lastDrawLoop;
+  DrawMap x78_rendererDraw;
+  DrawMap x8c_firstDraw;
+  DrawMap xa0_lastDraw;
+  bool xb4_24_updatesEnabled : 1;
+  bool xb4_25_anySystemsDrawnWithModel : 1;
+};
+CHECK_SIZEOF(CParticleDatabase, 0xb5)
+
+#endif

include/MetroidPrime/CPoseAsTransforms.hpp

@@ -0,0 +1,24 @@
+#ifndef _CPOSEASTRANSFORMS_HPP
+#define _CPOSEASTRANSFORMS_HPP
+
+#include "types.h"
+
+#include "MetroidPrime/TGameTypes.hpp"
+
+#include "Kyoto/Math/CTransform4f.hpp"
+
+#include "rstl/reserved_vector.hpp"
+#include "rstl/single_ptr.hpp"
+
+class CPoseAsTransforms {
+private:
+  CSegId x0_nextId;
+  CSegId x1_count;
+  // TODO TSegIdMapVariableSize<CPoseAsTransforms::CElementType>
+  rstl::reserved_vector< rstl::pair< CSegId, CSegId >, 100 > x4_links;
+  rstl::single_ptr< CTransform4f > xd0_transformArr;
+  CSegId xd4_lastInserted;
+};
+CHECK_SIZEOF(CPoseAsTransforms, 0xd8)
+
+#endif

include/MetroidPrime/Cameras/CCameraManager.hpp

@@ -22,7 +22,7 @@ class CStateManager;
 
 class CCameraManager {
 public:
-  CGameCamera* GetCurrentCamera(CStateManager& mgr);
+  CGameCamera* GetCurrentCamera(CStateManager& mgr) const;
 
 private:
   TUniqueId x0_curCameraId;

include/MetroidPrime/TGameTypes.hpp

@@ -56,4 +56,9 @@ CHECK_SIZEOF(TUniqueId, 0x2)
 typedef u16 TSfxId;
 static TSfxId InvalidSfxId = 0xFFFFu;
 
+class CSegId {
+private:
+  u8 x0_id;
+};
+
 #endif

include/rstl/auto_ptr.hpp

@@ -28,7 +28,7 @@ public:
   //   other.x0_has = false;
   // }
   T* get() { return x4_item; }
-  const T* get() const { return x4_item; }
+  /* const*/ T* get() const { return x4_item; }
   T* operator->() { return get(); }
   const T* operator->() const { return get(); }
   T* release() const {

include/rstl/construction_deferred.hpp

@@ -0,0 +1,37 @@
+#ifndef _RSTL_CONSTRUCTION_DEFERRED_HPP
+#define _RSTL_CONSTRUCTION_DEFERRED_HPP
+
+#include "types.h"
+
+#include "rstl/construct.hpp"
+
+namespace rstl {
+template < typename T >
+class construction_deferred {
+public:
+  construction_deferred() : m_valid(false) {}
+
+  template < typename A >
+  void build(const A& arg) {
+    rstl::construct(get_ptr(), arg);
+    makeValid();
+  }
+  void clear(); // TODO
+  bool valid() const { return m_valid; }
+
+  T* get_ptr() { return reinterpret_cast< T* >(x0_data); }
+  T& data() {
+    // TODO ensureIsValid
+    return *get_ptr();
+  }
+  T& operator*() { return data(); }
+
+private:
+  u8 x0_data[sizeof(T)];
+  bool m_valid __attribute__((aligned(4)));
+
+  void makeValid() { m_valid = true; }
+};
+} // namespace rstl
+
+#endif

include/rstl/map.hpp

@@ -3,15 +3,13 @@
 
 #include "types.h"
 
+#include "rstl/red_black_tree.hpp"
 #include "rstl/rmemory_allocator.hpp"
 
 namespace rstl {
-template < typename T >
-struct less {};
-
 template < typename K, typename V, typename Cmp = less< K >, typename Alloc = rmemory_allocator >
 class map {
-  u8 pad[0x10];
+  u8 pad[0x14];
 };
 } // namespace rstl
 

include/rstl/rc_ptr.hpp

@@ -20,6 +20,11 @@ public:
   T* get() { return x0_refData->x0_ptr; }
   T* operator->() { return get(); }
 };
+
+template < typename T >
+class ncrc_ptr : public rc_ptr< T > {
+  // TODO
+};
 } // namespace rstl
 
 #endif

include/rstl/red_black_tree.hpp

@@ -0,0 +1,16 @@
+#ifndef _RSTL_RED_BLACK_TREE_HPP
+#define _RSTL_RED_BLACK_TREE_HPP
+
+#include "types.h"
+
+namespace rstl {
+template < typename P >
+struct select1st {};
+
+template < typename T >
+struct less {};
+
+template < typename T, typename P, int U, typename S = select1st< P >, typename Cmp = less< T > >
+class red_black_tree {};
+}; // namespace rstl
+#endif

include/rstl/single_ptr.hpp

@@ -15,6 +15,7 @@ public:
   T* get() { return x0_ptr; }
   const T* get() const { return x0_ptr; }
   T* operator->() { return x0_ptr; }
+  const T* operator->() const { return x0_ptr; }
   void operator=(T* ptr) {
     delete x0_ptr;
     x0_ptr = ptr;

include/rstl/vector.hpp

@@ -107,7 +107,7 @@ void vector< T, Alloc >::reserve(size_t size) {
   x8_capacity = size;
 }
 
-typedef vector<void> unk_vector;
+typedef vector< void > unk_vector;
 CHECK_SIZEOF(unk_vector, 0x10)
 } // namespace rstl