More main progress; tons of headers & stuff

include/MetroidPrime/CActor.hpp

@@ -244,10 +244,15 @@ public:
   void EnsureRendered(const CStateManager& mgr) const;
   void EnsureRendered(const CStateManager& mgr, const CVector3f& pos, const CAABox& bounds) const;
   void DrawTouchBounds() const;
+  bool IsModelOpaque(const CStateManager& mgr) const;
+  void RenderInternal(const CStateManager& mgr) const;
 
   const CTransform4f& GetTransform() const { return x34_transform; }
   CVector3f GetTranslation() const { return x34_transform.GetTranslation(); }
 
+  /// ????
+  bool NullModel() const { return !GetAnimationData() && !GetModelData()->HasNormalModel(); }
+
   bool HasModelData() const { return GetModelData() && (GetModelData()->HasAnimation() || GetModelData()->HasNormalModel()); }
   CModelData* ModelData() { return x64_modelData.get(); }
   const CModelData* GetModelData() const { return x64_modelData.get(); }
@@ -256,7 +261,7 @@ public:
   CAnimData* AnimationData() { return ModelData()->AnimationData(); }
   const CAnimData* GetAnimationData() const { return GetModelData()->GetAnimationData(); }
 
-  bool HasShadow() const { return !x94_simpleShadow.null(); }
+  bool HasShadow() const { return GetShadow() != nullptr; }
   CSimpleShadow* Shadow() { return x94_simpleShadow.get(); }
   const CSimpleShadow* GetShadow() const { return x94_simpleShadow.get(); }
 

include/MetroidPrime/CActorLights.hpp

@@ -50,7 +50,7 @@ public:
   bool BuildAreaLightList(const CStateManager& mgr, const CGameArea& area, const CAABox& bounds);
   void BuildDynamicLightList(const CStateManager& mgr, const CAABox& bounds);
 
-  bool GetNeedsRelight() const { return x298_24_dirty; }
+  bool GetNeedsRelight() const { return x298_24_dirty == TRUE; }
 
 private:
   rstl::reserved_vector< CLight, 4 > x0_areaLights;

include/MetroidPrime/CActorModelParticles.hpp

@@ -3,7 +3,13 @@
 
 #include "types.h"
 
+class CActor;
+class CStateManager;
+
 class CActorModelParticles {
+public:
+  void Render(const CStateManager& mgr, const CActor& actor) const;
+
 private:
   // TODO
 };

include/MetroidPrime/CAnimData.hpp

@@ -12,6 +12,7 @@
 #include "MetroidPrime/CPoseAsTransforms.hpp"
 
 #include "Kyoto/TToken.hpp"
+#include "Kyoto/Animation/CSkinnedModel.hpp"
 
 #include "rstl/reserved_vector.hpp"
 
@@ -56,6 +57,8 @@ public:
     return mSoundPOINodes.data();
   }
 
+  CParticleDatabase& GetParticleDB() { return x120_particleDB; }
+  const CParticleDatabase& GetParticleDB() const { return x120_particleDB; }
   // SetIsAnimating__9CAnimDataFb
   // SetAnimDir__9CAnimDataFQ29CAnimData8EAnimDir
   // GetBoundingBox__9CAnimDataCFv
@@ -113,7 +116,6 @@ public:
 
   // GetCharacterInfo__9CAnimDataCFv
   // GetCharLayoutInfo__9CAnimDataCFv
-  // GetParticleDB__9CAnimDataFv
   // GetDeltaRotation__9CAnimDataCFv
   // GetDeltaOffset__9CAnimDataCFv
   // IsDeltaOffsetInUse__9CAnimDataCFv
@@ -130,7 +132,6 @@ public:
   // GetAnimationManager__9CAnimDataCFv
   // GetPoseValid__9CAnimDataCFv
   // GetPoseBuilderValid__9CAnimDataCFv
-  // GetParticleDB__9CAnimDataCFv
   // GetAnimSysContext__9CAnimDataCFv
   // CacheInt32PoiList__9CAnimDataFRC13CCharAnimTimeiRCQ24rstl25ncrc_ptr<13CAnimTreeNode>
 
@@ -152,6 +153,9 @@ public:
   // CacheBoolPoiList__9CAnimDataFRCQ24rstl25ncrc_ptr<13CAnimTreeNode>RC13CCharAnimTimei
   // CacheInt32PoiList__9CAnimDataFRCQ24rstl25ncrc_ptr<13CAnimTreeNode>RC13CCharAnimTimei
 
+  static void InitializeCache();
+  static void FreeCache();
+
 private:
   TLockedToken< CCharacterFactory > x0_charFactory;
   CCharacterInfo xc_charInfo;

include/MetroidPrime/CDecalManager.hpp

@@ -0,0 +1,12 @@
+#ifndef _CDECALMANAGER_HPP
+#define _CDECALMANAGER_HPP
+
+#include "types.h"
+
+class CDecalManager {
+public:
+  static void Initialize();
+  static void ShutDown();
+};
+
+#endif

include/MetroidPrime/CEnvFxManager.hpp

@@ -35,6 +35,9 @@ private:
 };
 
 class CEnvFxManager {
+public:
+  static void Initialize();
+
 private:
   CAABox x0_particleBounds;
   CVector3f x18_focusCellPosition;
@@ -49,8 +52,8 @@ private:
   rstl::reserved_vector< CEnvFxManagerGrid, 64 > x50_grids;
   f32 xb54_baseSplashRate;
   TLockedToken< CGenDescription > xb58_envRainSplash;
-  bool xb64_ = true;
-  TUniqueId xb68_envRainSplashId = kInvalidUniqueId;
+  bool xb64_;
+  TUniqueId xb68_envRainSplashId;
   bool xb6a_rainSoundActive;
   CSfxHandle xb6c_leftRainSound;
   CSfxHandle xb70_rightRainSound;

include/MetroidPrime/CGameArchitectureSupport.hpp

@@ -3,10 +3,20 @@
 
 #include "types.h"
 
+#include "GuiSys/CGuiSys.hpp"
+#include "Kyoto/Audio/CAudioSys.hpp"
 #include "Kyoto/Basics/COsContext.hpp"
 #include "Kyoto/Basics/CStopwatch.hpp"
 #include "Kyoto/TOneStatic.hpp"
 #include "MetroidPrime/CIOWinManager.hpp"
+#include "MetroidPrime/CInputGenerator.hpp"
+
+class CSavableState;
+
+class Unknown {
+private:
+  u8 pad[0x2c];
+};
 
 class CGameArchitectureSupport : public TOneStatic< CGameArchitectureSupport > {
 public:
@@ -24,10 +34,26 @@ public:
   inline int& GetFramesDrawn() const { return *(int*)(((u8*)this) + 0x78); }
 
 private:
-  u8 pad[0x20];
+  CAudioSys x0_audioSys;
+  rstl::list< CSavableState > x8_;
+  u32 pad;
   CStopwatch x20_stopwatch1;
   CStopwatch x28_stopwatch2;
-  u8 pad2[0xa0];
+  CInputGenerator x30_inputGenerator;
+  CGuiSys x44_guiSys;
+  CIOWinManager x58_ioWinMgr;
+  uint x78_gameFrameCount;
+  f32 x7c_;
+  f32 x80_;
+  f32 x84_;
+  uint x88_;
+  uint x8c_; // unused?
+  uint x90_;
+  uint x94_;
+  uint x98_;
+  rstl::optional_object< Unknown > x9c_;
+  u8 pad2[0x4];
 };
+CHECK_SIZEOF(CGameArchitectureSupport, 0xd0)
 
 #endif

include/MetroidPrime/CGameGlobalObjects.hpp

@@ -13,23 +13,30 @@
 #include "Kyoto/CSimplePool.hpp"
 #include "Kyoto/CToken.hpp"
 #include "Kyoto/Graphics/CGraphicsSys.hpp"
-#include "Kyoto/Text/CRasterFont.hpp"
 #include "Kyoto/TOneStatic.hpp"
+#include "Kyoto/Text/CRasterFont.hpp"
 #include "MetroidPrime/CInGameTweakManager.hpp"
 #include "MetroidPrime/Enemies/CAiFuncMap.hpp"
 #include "MetroidPrime/Factories/CCharacterFactoryBuilder.hpp"
 #include "MetroidPrime/Player/CGameState.hpp"
 
+class IRenderer;
+class CStringTable;
+
 class CGameGlobalObjects : public TOneStatic< CGameGlobalObjects > {
 public:
   CGameGlobalObjects(COsContext&, CMemorySys&);
 
   void PostInitialize(COsContext&, CMemorySys&);
+  void AddPaksAndFactories();
+  void LoadStringTable();
 
   rstl::single_ptr< CGameState >& GameState() { return x134_gameState; }
 
+  static CRasterFont* LoadDefaultFont();
+
 private:
-  rstl::single_ptr< CMemoryCardSys > x0_memoryCardSys;
+  CMemoryCardSys x0_memoryCardSys;
   CResFactory x4_resFactory;
   CSimplePool xcc_simplePool;
   CCharacterFactoryBuilder xec_characterFactoryBuilder;
@@ -37,11 +44,12 @@ private:
   CGraphicsSys x130_graphicsSys;
   rstl::single_ptr< CGameState > x134_gameState;
   uint x138_;
-  rstl::optional_object< TCachedToken< unkptr > > x13c_;
-  uint x14c_;
+  rstl::optional_object< TLockedToken< CStringTable > > x13c_stringTable;
+  rstl::single_ptr< IRenderer > x14c_renderer;
   rstl::single_ptr< CInGameTweakManager > x150_inGameTweakManager;
   TToken< CRasterFont > x154_defaultFont;
 };
+CHECK_SIZEOF(CGameGlobalObjects, 0x15c)
 
 // TODO move to related headers
 extern unkptr gGuiSystem;

include/MetroidPrime/CIOWin.hpp

@@ -0,0 +1,30 @@
+#ifndef _CIOWIN_HPP
+#define _CIOWIN_HPP
+
+#include "types.h"
+
+#include "rstl/string.hpp"
+
+class CArchitectureMessage;
+class CArchitectureQueue;
+
+class CIOWin {
+public:
+  enum EMessageReturn {
+    kMR_Normal = 0,
+    kMR_Exit = 1,
+    kMR_RemoveIOWinAndExit = 2,
+    kMR_RemoveIOWin = 3,
+  };
+
+  virtual ~CIOWin();
+  virtual EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) = 0;
+  virtual bool GetIsContinueDraw() const;
+  virtual void Draw();
+  virtual void PreDraw();
+
+private:
+  rstl::string x4_name;
+};
+
+#endif

include/MetroidPrime/CIOWinManager.hpp

@@ -4,10 +4,16 @@
 #include "types.h"
 
 #include "rstl/list.hpp"
+#include "rstl/rc_ptr.hpp"
+
+class CIOWin;
 
 class CIOWinManager {
 public:
+  CIOWinManager();
+
   void Draw() const;
+  void AddIOWin(rstl::ncrc_ptr< CIOWin >, int, int);
 
   inline bool IsEmpty() const { return x4_ == 0 && x0_ == 0; }
 
@@ -16,5 +22,6 @@ private:
   uint x4_;
   rstl::list< unkptr > x8_;
 };
+CHECK_SIZEOF(CIOWinManager, 0x20)
 
 #endif

include/MetroidPrime/CInGameTweakManager.hpp

@@ -7,9 +7,12 @@
 
 class CInGameTweakManager {
 public:
+  CInGameTweakManager();
+
   bool ReadFromMemoryCard(const rstl::string&);
 
 private:
+  u8 pad[0x10];
 };
 
 extern CInGameTweakManager* gpTweakManager;

include/MetroidPrime/CInputGenerator.hpp

@@ -0,0 +1,16 @@
+#ifndef _CINPUTGENERATOR_HPP
+#define _CINPUTGENERATOR_HPP
+
+#include "types.h"
+
+class COsContext;
+
+class CInputGenerator {
+public:
+  CInputGenerator(COsContext*, f32, f32);
+
+private:
+  u8 pad[0x14];
+};
+
+#endif

include/MetroidPrime/CMain.hpp

@@ -15,8 +15,52 @@
 #include "MetroidPrime/TGameTypes.hpp"
 #include "MetroidPrime/Tweaks/CTweaks.hpp"
 
+class CMain;
+
+// TODO
+class UnkClassArena {
+public:
+  UnkClassArena(CMain*);
+};
+
+// TODO move to new header
+class CDvdRequestSys {
+public:
+  CDvdRequestSys() {
+    if (mManagerInstalled != true) {
+      mManagerInstalled = true;
+    }
+  }
+  ~CDvdRequestSys() {
+    if (mManagerInstalled == true) {
+      mManagerInstalled = false;
+    }
+  }
+
+private:
+  static bool mManagerInstalled;
+};
+
+// TODO where?
+enum EFlowState {
+  kFS_None,
+  kFS_WinBad,
+  kFS_WinGood,
+  kFS_WinBest,
+  kFS_LoseGame,
+  kFS_Default,
+  kFS_StateSetter,
+  kFS_PreFrontEnd,
+  kFS_FrontEnd,
+  kFS_Game,
+  kFS_GameExit,
+};
+
 class CMain {
 public:
+  CMain();
+  ~CMain();
+
   void UpdateStreamedAudio();
   void RegisterResourceTweaks();
   void ResetGameState();
@@ -33,16 +77,30 @@ public:
   void DrawDebugMetrics(double dt, CStopwatch& stopWatch);
   bool CheckTerminate();
   bool CheckReset();
+  void OpenWindow();
+
+  void SetMaxSpeed(bool v) {
+    // ?
+    x160_26_screenFading = v;
+  }
 
   static void EnsureWorldPaksReady();
   static void EnsureWorldPakReady(CAssetId id);
 
+  // TODO
+  COsContext& InitOsContext() {
+    OpenWindow();
+    return x0_osContext;
+  }
+
 private:
   COsContext x0_osContext;
-  u8 x6c_unk;
+  UnkClassArena x6c_unk;
   CMemorySys x6d_memorySys;
+  CDvdRequestSys x6e_dvdRequestSys;
   CTweaks x70_tweaks;
-  u8 pad[0x7c];
+  u8 pad[0x14];
+  f64 xe8_;
   TReservedAverage< f32, 4 > xf0_;
   TReservedAverage< f32, 4 > x104_;
   f32 x118_;
@@ -50,7 +108,7 @@ private:
   f32 x120_;
   f32 x124_;
   CGameGlobalObjects* x128_gameGlobalObjects;
-  uint x12c_flowState; // EFlowState
+  EFlowState x12c_flowState;
   rstl::reserved_vector< uint, 10 > x130_frameTimes;
   int x15c_frameTimeIdx;
   bool x160_24_finished : 1;

include/MetroidPrime/CMemoryCard.hpp

@@ -0,0 +1,12 @@
+#ifndef _CMEMORYCARD_HPP
+#define _CMEMORYCARD_HPP
+
+#include "types.h"
+
+class CMemoryCard {
+  // TODO
+};
+
+extern CMemoryCard* gpMemoryCard;
+
+#endif

include/MetroidPrime/CModelData.hpp

@@ -51,6 +51,9 @@ public:
   void AdvanceParticles(const CTransform4f& xf, float dt, CStateManager& mgr);
   void RenderParticles(const CFrustumPlanes& planes) const;
   void RenderUnsortedParts(EWhichModel which, const CTransform4f& xf, const CActorLights* lights, const CModelFlags& flags) const;
+  void RenderThermal(const CTransform4f& xf, const CColor& mulColor, const CColor& addColor, const CModelFlags& flags) const;
+  void Render(const CStateManager&, const CTransform4f&, const CActorLights*, const CModelFlags&) const;
+  void Render(CModelData::EWhichModel, const CTransform4f&, const CActorLights*, const CModelFlags&) const;
 
   const CAnimData* GetAnimationData() const { return xc_animData.get(); }
   CAnimData* AnimationData() { return xc_animData.get(); }
@@ -62,7 +65,9 @@ public:
 
   void SetXRayModel(const rstl::pair< CAssetId, CAssetId >& assets);
   void SetInfraModel(const rstl::pair< CAssetId, CAssetId >& assets);
+
   void SetAmbientColor(const CColor& color) { x18_ambientColor = color; }
+  bool GetSortThermal() const { return x14_25_sortThermal; }
   void SetSortThermal(bool b) { x14_25_sortThermal = b; }
 
   static EWhichModel GetRenderingModel(const CStateManager& mgr);

include/MetroidPrime/CParticleDatabase.hpp

@@ -22,6 +22,10 @@ public:
   typedef rstl::map< rstl::string, rstl::auto_ptr< CParticleGenInfo > > DrawMap;
 
   void SetParticleEffectState(const rstl::string& name, bool active, CStateManager& mgr);
+  void RenderSystemsToBeDrawnFirst() const;
+  void RenderSystemsToBeDrawnLast() const;
+
+  bool AreAnySystemsDrawnWithModel() const { return xb4_25_anySystemsDrawnWithModel; }
 
 private:
   rstl::map< CAssetId, rstl::rc_ptr< TLockedToken< CGenDescription > > > x0_particleDescs;

include/MetroidPrime/CSplashScreen.hpp

@@ -0,0 +1,23 @@
+#ifndef _CSPLASHSCREEN_HPP
+#define _CSPLASHSCREEN_HPP
+
+#include "types.h"
+
+#include "MetroidPrime/CIOWin.hpp"
+
+class CSplashScreen : public CIOWin {
+public:
+  enum ESplashScreen {
+    Nintendo,
+    Retro,
+    Dolby,
+  };
+
+  CSplashScreen(ESplashScreen);
+  ~CSplashScreen() override;
+
+  virtual EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&);
+  virtual void Draw();
+};
+
+#endif

include/MetroidPrime/CStateManager.hpp

@@ -38,6 +38,7 @@ class CStateManager {
 public:
   void SendScriptMsg(TUniqueId uid, TEditorId target, EScriptObjectMessage msg, EScriptObjectState state);
   bool AddDrawableActor(const CActor& actor, const CVector3f& pos, const CAABox& bounds) const;
+  void SetupParticleHook(const CActor& actor) const;
 
   CCameraManager* CameraManager() { return x870_cameraManager; }
   const CCameraManager* GetCameraManager() const { return x870_cameraManager; }
@@ -45,6 +46,11 @@ public:
   const CPlayerState* GetPlayerState() const { return x8b8_playerState.GetPtr(); }
   CWorld* World() { return x850_world.get(); }
   const CWorld* GetWorld() const { return x850_world.get(); }
+  CActorModelParticles* ActorModelParticles() { return x884_actorModelParticles.get(); }
+  const CActorModelParticles* GetActorModelParticles() const { return x884_actorModelParticles.get(); }
+
+  f32 GetThermalColdScale1() const { return xf24_thermColdScale1; }
+  f32 GetThermalColdScale2() const { return xf28_thermColdScale2; }
 
 private:
   u16 x0_nextFreeIndex;
@@ -69,6 +75,9 @@ private:
   rstl::rc_ptr< CScriptMailbox > x8bc_mailbox;
   rstl::rc_ptr< CMapWorldInfo > x8c0_mapWorldInfo;
   rstl::rc_ptr< CWorldTransManager > x8c4_worldTransManager;
+  u8 pad2[0x658];
+  f32 xf24_thermColdScale1;
+  f32 xf28_thermColdScale2;
 };
 
 #endif

include/MetroidPrime/Enemies/CAiFuncMap.hpp

@@ -5,6 +5,7 @@
 
 class CAiFuncMap {
 public:
+  CAiFuncMap();
   ~CAiFuncMap();
 
 private:

include/MetroidPrime/Factories/CCharacterFactoryBuilder.hpp

@@ -5,6 +5,7 @@
 
 class CCharacterFactoryBuilder {
 public:
+  CCharacterFactoryBuilder();
   ~CCharacterFactoryBuilder();
 
 private:

include/MetroidPrime/ScriptObjects/CScriptMazeNode.hpp

@@ -0,0 +1,13 @@
+#ifndef _CSCRIPTMAZENODE_HPP
+#define _CSCRIPTMAZENODE_HPP
+
+#include "types.h"
+
+#include "MetroidPrime/CActor.hpp"
+
+class CScriptMazeNode : public CActor {
+public:
+  static void LoadMazeSeeds();
+};
+
+#endif

include/MetroidPrime/Tweaks/CTweakGame.hpp

@@ -3,15 +3,56 @@
 
 #include "types.h"
 
+#include "MetroidPrime/Tweaks/ITweakObject.hpp"
+
 #include "rstl/string.hpp"
 
-class CTweakGame {
+class CTweakGame : public ITweakObject {
 public:
+  ~CTweakGame() override;
+
   const rstl::string& GetWorldPrefix() { return x4_worldPrefix; }
+  const rstl::string& GetDefaultRoom() const { return x14_defaultRoom; }
+  bool GetSplashScreensDisabled() const { return x2b_splashScreensDisabled; }
+  f32 GetFirstPersonFOV() const { return x24_fov; }
+  f32 GetPressStartDelay() const { return x30_pressStartDelay; }
+  f32 GetWavecapIntensityNormal() const { return x34_wavecapIntensityNormal; }
+  f32 GetWavecapIntensityPoison() const { return x38_wavecapIntensityPoison; }
+  f32 GetWavecapIntensityLava() const { return x3c_wavecapIntensityLava; }
+  f32 GetRippleIntensityNormal() const { return x40_rippleIntensityNormal; }
+  f32 GetRippleIntensityPoison() const { return x44_rippleIntensityPoison; }
+  f32 GetRippleIntensityLava() const { return x48_rippleIntensityLava; }
+  f32 GetFluidEnvBumpScale() const { return x4c_fluidEnvBumpScale; }
+  f32 GetWaterFogDistanceBase() const { return x50_waterFogDistanceBase; }
+  f32 GetWaterFogDistanceRange() const { return x54_waterFogDistanceRange; }
+  f32 GetGravityWaterFogDistanceBase() const { return x58_gravityWaterFogDistanceBase; }
+  f32 GetGravityWaterFogDistanceRange() const { return x5c_gravityWaterFogDistanceRange; }
+  f32 GetHardModeDamageMultiplier() const { return x60_hardmodeDamageMult; }
+  f32 GetHardModeWeaponMultiplier() const { return x64_hardmodeWeaponMult; }
 
 private:
-  uint x0_;
   rstl::string x4_worldPrefix;
+  rstl::string x14_defaultRoom;
+  f32 x24_fov;
+  bool x28_unknown1;
+  bool x29_unknown2;
+  bool x2a_unknown3;
+  bool x2b_splashScreensDisabled;
+  f32 x2c_unknown5;
+  f32 x30_pressStartDelay;
+  f32 x34_wavecapIntensityNormal;
+  f32 x38_wavecapIntensityPoison;
+  f32 x3c_wavecapIntensityLava;
+  f32 x40_rippleIntensityNormal;
+  f32 x44_rippleIntensityPoison;
+  f32 x48_rippleIntensityLava;
+  f32 x4c_fluidEnvBumpScale;
+  f32 x50_waterFogDistanceBase;
+  f32 x54_waterFogDistanceRange;
+  f32 x58_gravityWaterFogDistanceBase;
+  f32 x5c_gravityWaterFogDistanceRange;
+  f32 x60_hardmodeDamageMult;
+  f32 x64_hardmodeWeaponMult;
 };
 
 extern CTweakGame* gpTweakGame;

include/MetroidPrime/Tweaks/CTweakPlayer.hpp

@@ -0,0 +1,318 @@
+#ifndef _CTWEAKPLAYER_HPP
+#define _CTWEAKPLAYER_HPP
+
+#include "types.h"
+
+#include "MetroidPrime/Tweaks/ITweakObject.hpp"
+
+#include "rstl/string.hpp"
+
+class CTweakPlayer : public ITweakObject {
+public:
+  ~CTweakPlayer() override;
+
+  // TODO CPlayer::ESurfaceRestraints
+  f32 GetMaxTranslationalAcceleration(int s) const { return x4_maxTranslationalAcceleration[s]; }
+  f32 GetMaxRotationalAcceleration(int s) const { return x24_maxRotationalAcceleration[s]; }
+  f32 GetPlayerTranslationFriction(int s) const { return x44_translationFriction[s]; }
+  f32 GetPlayerRotationFriction(int s) const { return x64_rotationFriction[s]; }
+  f32 GetPlayerRotationMaxSpeed(int s) const { return x84_rotationMaxSpeed[s]; }
+  f32 GetPlayerTranslationMaxSpeed(int s) const { return xa4_translationMaxSpeed[s]; }
+  f32 GetNormalGravAccel() const { return xc4_normalGravAccel; }
+  f32 GetFluidGravAccel() const { return xc8_fluidGravAccel; }
+  f32 GetVerticalJumpAccel() const { return xcc_verticalJumpAccel; }
+  f32 GetHorizontalJumpAccel() const { return xd0_horizontalJumpAccel; }
+  f32 GetVerticalDoubleJumpAccel() const { return xd4_verticalDoubleJumpAccel; }
+  f32 GetHorizontalDoubleJumpAccel() const { return xd8_horizontalDoubleJumpAccel; }
+  f32 GetWaterJumpFactor() const { return xdc_waterJumpFactor; }
+  f32 GetWaterBallJumpFactor() const { return xe0_waterBallJumpFactor; }
+  f32 GetLavaJumpFactor() const { return xe4_lavaJumpFactor; }
+  f32 GetLavaBallJumpFactor() const { return xe8_lavaBallJumpFactor; }
+  f32 GetPhazonJumpFactor() const { return xec_phazonJumpFactor; }
+  f32 GetPhazonBallJumpFactor() const { return xf0_phazonBallJumpFactor; }
+  f32 GetAllowedJumpTime() const { return xf4_allowedJumpTime; }
+  f32 GetAllowedDoubleJumpTime() const { return xf8_allowedDoubleJumpTime; }
+  f32 GetMinDoubleJumpWindow() const { return xfc_minDoubleJumpWindow; }
+  f32 GetMaxDoubleJumpWindow() const { return x100_maxDoubleJumpWindow; }
+  f32 GetMinJumpTime() const { return x108_minJumpTime; }
+  f32 GetMinDoubleJumpTime() const { return x10c_minDoubleJumpTime; }
+  f32 GetAllowedLedgeTime() const { return x110_allowedLedgeTime; }
+  f32 GetDoubleJumpImpulse() const { return x114_doubleJumpImpulse; }
+  f32 GetBackwardsForceMultiplier() const { return x118_backwardsForceMultiplier; }
+  f32 GetBombJumpRadius() const { return x11c_bombJumpRadius; }
+  f32 GetBombJumpHeight() const { return x120_bombJumpHeight; }
+  f32 GetEyeOffset() const { return x124_eyeOffset; }
+  f32 GetTurnSpeedMultiplier() const { return x128_turnSpeedMultiplier; }
+  f32 GetFreeLookTurnSpeedMultiplier() const { return x12c_freeLookTurnSpeedMultiplier; }
+  f32 GetFreeLookSpeed() const { return x138_freeLookSpeed; }
+  f32 GetFreeLookSnapSpeed() const { return x13c_freeLookSnapSpeed; }
+  f32 GetFreeLookCenteredThresholdAngle() const { return x144_freeLookCenteredThresholdAngle; }
+  f32 GetFreeLookCenteredTime() const { return x148_freeLookCenteredTime; }
+  f32 GetOrbitModeTimer() const { return x180_orbitModeTimer; }
+  f32 GetOrbitUpperAngle() const { return x188_orbitUpperAngle; }
+  f32 GetOrbitLowerAngle() const { return x18c_orbitLowerAngle; }
+  f32 GetOrbitHorizAngle() const { return x190_orbitHorizAngle; }
+  f32 GetOrbitMaxTargetDistance() const { return x19c_orbitMaxTargetDistance; }
+  f32 GetOrbitMaxLockDistance() const { return x1a0_orbitMaxLockDistance; }
+  f32 GetOrbitDistanceThreshold() const { return x1a4_orbitDistanceThreshold; }
+  uint GetOrbitScreenBoxHalfExtentX(int zone) const { return x1a8_orbitScreenBoxHalfExtentX[zone]; }
+  uint GetOrbitScreenBoxHalfExtentY(int zone) const { return x1b0_orbitScreenBoxHalfExtentY[zone]; }
+  uint GetOrbitScreenBoxCenterX(int zone) const { return x1b8_orbitScreenBoxCenterX[zone]; }
+  uint GetOrbitScreenBoxCenterY(int zone) const { return x1c0_orbitScreenBoxCenterY[zone]; }
+  uint GetOrbitZoneIdealX(int zone) const { return x1c8_orbitZoneIdealX[zone]; }
+  uint GetOrbitZoneIdealY(int zone) const { return x1d0_orbitZoneIdealY[zone]; }
+  f32 GetOrbitNearX() const { return x1d8_orbitNearX; }
+  f32 GetOrbitNearZ() const { return x1dc_orbitNearZ; }
+  f32 GetOrbitFixedOffsetZDiff() const { return x1e8_orbitFixedOffsetZDiff; }
+  f32 GetOrbitZRange() const { return x1ec_orbitZRange; }
+  bool GetDashEnabled() const { return x200_24_dashEnabled; }
+  bool GetDashOnButtonRelease() const { return x200_25_dashOnButtonRelease; }
+  f32 GetDashButtonHoldCancelTime() const { return x204_dashButtonHoldCancelTime; }
+  f32 GetDashStrafeInputThreshold() const { return x208_dashStrafeInputThreshold; }
+  f32 GetSidewaysDoubleJumpImpulse() const { return x20c_sidewaysDoubleJumpImpulse; }
+  f32 GetSidewaysVerticalDoubleJumpAccel() const { return x210_sidewaysVerticalDoubleJumpAccel; }
+  f32 GetSidewaysHorizontalDoubleJumpAccel() const { return x214_sidewaysHorizontalDoubleJumpAccel; }
+  f32 GetScanningRange() const { return x218_scanningRange; }
+  bool GetScanRetention() const { return x21c_24_scanRetention; }
+  bool GetScanFreezesGame() const { return x21c_25_scanFreezesGame; }
+  bool GetOrbitWhileScanning() const { return x21c_26_orbitWhileScanning; }
+  f32 GetScanMaxTargetDistance() const { return x220_scanMaxTargetDistance; }
+  f32 GetScanMaxLockDistance() const { return x224_scanMaxLockDistance; }
+  bool GetMoveDuringFreeLook() const { return x228_27_moveDuringFreeLook; }
+  bool GetHoldButtonsForFreeLook() const { return x228_28_holdButtonsForFreeLook; }
+  bool GetTwoButtonsForFreeLook() const { return x228_29_twoButtonsForFreeLook; }
+  bool GetAimWhenOrbitingPoint() const { return x229_25_aimWhenOrbitingPoint; }
+  bool GetStayInFreeLookWhileFiring() const { return x229_26_stayInFreeLookWhileFiring; }
+  bool GetOrbitFixedOffset() const { return x229_29_orbitFixedOffset; }
+  bool GetGunButtonTogglesHolster() const { return x229_30_gunButtonTogglesHolster; }
+  bool GetGunNotFiringHolstersGun() const { return x229_31_gunNotFiringHolstersGun; }
+  bool GetFallingDoubleJump() const { return x22a_24_fallingDoubleJump; }
+  bool GetImpulseDoubleJump() const { return x22a_25_impulseDoubleJump; }
+  bool GetFiringCancelsCameraPitch() const { return x22a_26_firingCancelsCameraPitch; }
+  bool GetAssistedAimingIgnoreHorizontal() const { return x22a_27_assistedAimingIgnoreHorizontal; }
+  bool GetAssistedAimingIgnoreVertical() const { return x22a_28_assistedAimingIgnoreVertical; }
+  f32 GetAimMaxDistance() const { return x234_aimMaxDistance; }
+  f32 GetAimThresholdDistance() const { return x24c_aimThresholdDistance; }
+  f32 GetAimBoxWidth() const { return x258_aimBoxWidth; }
+  f32 GetAimBoxHeight() const { return x25c_aimBoxHeight; }
+  f32 GetAimTargetTimer() const { return x260_aimTargetTimer; }
+  f32 GetAimAssistHorizontalAngle() const { return x264_aimAssistHorizontalAngle; }
+  f32 GetAimAssistVerticalAngle() const { return x268_aimAssistVerticalAngle; }
+  f32 GetPlayerHeight() const { return x26c_playerHeight; }
+  f32 GetPlayerXYHalfExtent() const { return x270_playerXYHalfExtent; }
+  f32 GetStepUpHeight() const { return x274_stepUpHeight; }
+  f32 GetStepDownHeight() const { return x278_stepDownHeight; }
+  f32 GetPlayerBallHalfExtent() const { return x27c_playerBallHalfExtent; }
+  f32 GetOrbitDistanceMax() const { return x2a0_orbitDistanceMax; }
+  f32 GetGrappleSwingLength() const { return x2a4_grappleSwingLength; }
+  f32 GetGrappleSwingPeriod() const { return x2a8_grappleSwingPeriod; }
+  f32 GetGrapplePullSpeedMin() const { return x2ac_grapplePullSpeedMin; }
+  f32 GetMaxGrappleLockedTurnAlignDistance() const { return x2b4_maxGrappleLockedTurnAlignDistance; }
+  f32 GetGrapplePullSpeedProportion() const { return x2b8_grapplePullSpeedProportion; }
+  f32 GetGrapplePullSpeedMax() const { return x2bc_grapplePullSpeedMax; }
+  f32 GetGrappleLookCenterSpeed() const { return x2c0_grappleLookCenterSpeed; }
+  f32 GetMaxGrappleTurnSpeed() const { return x2c4_maxGrappleTurnSpeed; }
+  f32 GetGrappleJumpForce() const { return x2c8_grappleJumpForce; }
+  f32 GetGrappleReleaseTime() const { return x2cc_grappleReleaseTime; }
+  uint GetGrappleJumpMode() const { return x2d0_grappleJumpMode; }
+  bool GetOrbitReleaseBreaksGrapple() const { return x2d4_orbitReleaseBreaksGrapple; }
+  bool GetInvertGrappleTurn() const { return x2d5_invertGrappleTurn; }
+  f32 GetGrappleBeamSpeed() const { return x2d8_grappleBeamSpeed; }
+  f32 GetGrappleBeamXWaveAmplitude() const { return x2dc_grappleBeamXWaveAmplitude; }
+  f32 GetGrappleBeamZWaveAmplitude() const { return x2e0_grappleBeamZWaveAmplitude; }
+  f32 GetGrappleBeamAnglePhaseDelta() const { return x2e4_grappleBeamAnglePhaseDelta; }
+  f32 GetHorizontalFreeLookAngleVel() const { return x130_horizontalFreeLookAngleVel; }
+  f32 GetVerticalFreeLookAngleVel() const { return x134_verticalFreeLookAngleVel; }
+  f32 GetOrbitCameraSpeed() const { return x184_orbitCameraSpeed; }
+  f32 GetOrbitPreventionTime() const { return x1fc_orbitPreventionTime; }
+  bool GetFreeLookTurnsPlayer() const { return x228_24_freelookTurnsPlayer; }
+  f32 GetJumpCameraPitchDownStart() const { return x288_jumpCameraPitchDownStart; }
+  f32 GetJumpCameraPitchDownFull() const { return x28c_jumpCameraPitchDownFull; }
+  f32 GetJumpCameraPitchDownAngle() const { return x290_jumpCameraPitchDownAngle; }
+  f32 GetFallCameraPitchDownStart() const { return x294_fallCameraPitchDownStart; }
+  f32 GetFallCameraPitchDownFull() const { return x298_fallCameraPitchDownFull; }
+  f32 GetFallCameraPitchDownAngle() const { return x29c_fallCameraPitchDownAngle; }
+  f32 GetFirstPersonCameraSpeed() const { return x280_firstPersonCameraSpeed; }
+  f32 GetGrappleCameraSpeed() const { return x2b0_grappleCameraSpeed; }
+  f32 GetFreeLookDampenFactor() const { return x14c_freeLookDampenFactor; }
+  f32 GetLeftAnalogMax() const { return x150_leftDiv; }
+  f32 GetRightAnalogMax() const { return x154_rightDiv; }
+  f32 GetOrbitMinDistance(int type) const { return x158_orbitMinDistance[type]; }
+  f32 GetOrbitNormalDistance(int type) const { return x164_orbitNormalDistance[type]; }
+  f32 GetOrbitMaxDistance(int type) const { return x170_orbitMaxDistance[type]; }
+  f32 GetFrozenTimeout() const { return x2f8_frozenTimeout; }
+  uint GetIceBreakJumpCount() const { return x2fc_iceBreakJumpCount; }
+  f32 GetVariaDamageReduction() const { return x300_variaDamageReduction; }
+  f32 GetGravityDamageReduction() const { return x304_gravityDamageReduction; }
+  f32 GetPhazonDamageReduction() const { return x308_phazonDamageReduction; }
+
+private:
+  f32 x4_maxTranslationalAcceleration[8];
+  f32 x24_maxRotationalAcceleration[8];
+  f32 x44_translationFriction[8];
+  f32 x64_rotationFriction[8];
+  f32 x84_rotationMaxSpeed[8];
+  f32 xa4_translationMaxSpeed[8];
+  f32 xc4_normalGravAccel;
+  f32 xc8_fluidGravAccel;
+  f32 xcc_verticalJumpAccel;
+  f32 xd0_horizontalJumpAccel;
+  f32 xd4_verticalDoubleJumpAccel;
+  f32 xd8_horizontalDoubleJumpAccel;
+  f32 xdc_waterJumpFactor;
+  f32 xe0_waterBallJumpFactor;
+  f32 xe4_lavaJumpFactor;
+  f32 xe8_lavaBallJumpFactor;
+  f32 xec_phazonJumpFactor;
+  f32 xf0_phazonBallJumpFactor;
+  f32 xf4_allowedJumpTime;
+  f32 xf8_allowedDoubleJumpTime;
+  f32 xfc_minDoubleJumpWindow;
+  f32 x100_maxDoubleJumpWindow;
+  f32 x104_;
+  f32 x108_minJumpTime;
+  f32 x10c_minDoubleJumpTime;
+  f32 x110_allowedLedgeTime;
+  f32 x114_doubleJumpImpulse;
+  f32 x118_backwardsForceMultiplier;
+  f32 x11c_bombJumpRadius;
+  f32 x120_bombJumpHeight;
+  f32 x124_eyeOffset;
+  f32 x128_turnSpeedMultiplier;
+  f32 x12c_freeLookTurnSpeedMultiplier;
+  f32 x130_horizontalFreeLookAngleVel;
+  f32 x134_verticalFreeLookAngleVel;
+  f32 x138_freeLookSpeed;
+  f32 x13c_freeLookSnapSpeed;
+  f32 x140_;
+  f32 x144_freeLookCenteredThresholdAngle;
+  f32 x148_freeLookCenteredTime;
+  f32 x14c_freeLookDampenFactor;
+  f32 x150_leftDiv;
+  f32 x154_rightDiv;
+  f32 x158_orbitMinDistance[3];
+  f32 x164_orbitNormalDistance[3];
+  f32 x170_orbitMaxDistance[3];
+  f32 x17c_;
+  f32 x180_orbitModeTimer;
+  f32 x184_orbitCameraSpeed;
+  f32 x188_orbitUpperAngle;
+  f32 x18c_orbitLowerAngle;
+  f32 x190_orbitHorizAngle;
+  f32 x194_;
+  f32 x198_;
+  f32 x19c_orbitMaxTargetDistance;
+  f32 x1a0_orbitMaxLockDistance;
+  f32 x1a4_orbitDistanceThreshold;
+  uint x1a8_orbitScreenBoxHalfExtentX[2];
+  uint x1b0_orbitScreenBoxHalfExtentY[2];
+  uint x1b8_orbitScreenBoxCenterX[2];
+  uint x1c0_orbitScreenBoxCenterY[2];
+  uint x1c8_orbitZoneIdealX[2];
+  uint x1d0_orbitZoneIdealY[2];
+  f32 x1d8_orbitNearX;
+  f32 x1dc_orbitNearZ;
+  f32 x1e0_;
+  f32 x1e4_;
+  f32 x1e8_orbitFixedOffsetZDiff;
+  f32 x1ec_orbitZRange;
+  f32 x1f0_;
+  f32 x1f4_;
+  f32 x1f8_;
+  f32 x1fc_orbitPreventionTime;
+  bool x200_24_dashEnabled : 1;
+  bool x200_25_dashOnButtonRelease : 1;
+  f32 x204_dashButtonHoldCancelTime;
+  f32 x208_dashStrafeInputThreshold;
+  f32 x20c_sidewaysDoubleJumpImpulse;
+  f32 x210_sidewaysVerticalDoubleJumpAccel;
+  f32 x214_sidewaysHorizontalDoubleJumpAccel;
+  f32 x218_scanningRange;
+  bool x21c_24_scanRetention : 1;
+  bool x21c_25_scanFreezesGame : 1;
+  bool x21c_26_orbitWhileScanning : 1;
+  f32 x220_scanMaxTargetDistance;
+  f32 x224_scanMaxLockDistance;
+  bool x228_24_freelookTurnsPlayer : 1;
+  bool x228_25_ : 1;
+  bool x228_26_ : 1;
+  bool x228_27_moveDuringFreeLook : 1;
+  bool x228_28_holdButtonsForFreeLook : 1;
+  bool x228_29_twoButtonsForFreeLook : 1;
+  bool x228_30_ : 1;
+  bool x228_31_ : 1;
+  bool x229_24_ : 1;
+  bool x229_25_aimWhenOrbitingPoint : 1;
+  bool x229_26_stayInFreeLookWhileFiring : 1;
+  bool x229_27_ : 1;
+  bool x229_28_ : 1;
+  bool x229_29_orbitFixedOffset : 1;
+  bool x229_30_gunButtonTogglesHolster : 1;
+  bool x229_31_gunNotFiringHolstersGun : 1;
+  bool x22a_24_fallingDoubleJump : 1;
+  bool x22a_25_impulseDoubleJump : 1;
+  bool x22a_26_firingCancelsCameraPitch : 1;
+  bool x22a_27_assistedAimingIgnoreHorizontal : 1;
+  bool x22a_28_assistedAimingIgnoreVertical : 1;
+  f32 x22c_;
+  f32 x230_;
+  f32 x234_aimMaxDistance;
+  f32 x238_;
+  f32 x23c_;
+  f32 x240_;
+  f32 x244_;
+  f32 x248_;
+  f32 x24c_aimThresholdDistance;
+  f32 x250_;
+  f32 x254_;
+  f32 x258_aimBoxWidth;
+  f32 x25c_aimBoxHeight;
+  f32 x260_aimTargetTimer;
+  f32 x264_aimAssistHorizontalAngle;
+  f32 x268_aimAssistVerticalAngle;
+  f32 x26c_playerHeight;
+  f32 x270_playerXYHalfExtent;
+  f32 x274_stepUpHeight;
+  f32 x278_stepDownHeight;
+  f32 x27c_playerBallHalfExtent;
+  f32 x280_firstPersonCameraSpeed;
+  f32 x284_;
+  f32 x288_jumpCameraPitchDownStart;
+  f32 x28c_jumpCameraPitchDownFull;
+  f32 x290_jumpCameraPitchDownAngle;
+  f32 x294_fallCameraPitchDownStart;
+  f32 x298_fallCameraPitchDownFull;
+  f32 x29c_fallCameraPitchDownAngle;
+  f32 x2a0_orbitDistanceMax;
+  f32 x2a4_grappleSwingLength;
+  f32 x2a8_grappleSwingPeriod;
+  f32 x2ac_grapplePullSpeedMin;
+  f32 x2b0_grappleCameraSpeed;
+  f32 x2b4_maxGrappleLockedTurnAlignDistance;
+  f32 x2b8_grapplePullSpeedProportion;
+  f32 x2bc_grapplePullSpeedMax;
+  f32 x2c0_grappleLookCenterSpeed;
+  f32 x2c4_maxGrappleTurnSpeed;
+  f32 x2c8_grappleJumpForce;
+  f32 x2cc_grappleReleaseTime;
+  uint x2d0_grappleJumpMode;
+  bool x2d4_orbitReleaseBreaksGrapple;
+  bool x2d5_invertGrappleTurn;
+  f32 x2d8_grappleBeamSpeed;
+  f32 x2dc_grappleBeamXWaveAmplitude;
+  f32 x2e0_grappleBeamZWaveAmplitude;
+  f32 x2e4_grappleBeamAnglePhaseDelta;
+  f32 x2e8_;
+  f32 x2ec_;
+  f32 x2f0_;
+  bool x2f4_;
+  f32 x2f8_frozenTimeout;
+  uint x2fc_iceBreakJumpCount;
+  f32 x300_variaDamageReduction;
+  f32 x304_gravityDamageReduction;
+  f32 x308_phazonDamageReduction;
+};
+
+extern CTweakPlayer* gpTweakPlayer;
+
+#endif

include/MetroidPrime/Tweaks/CTweaks.hpp

@@ -3,13 +3,22 @@
 
 #include "types.h"
 
+#include "rstl/auto_ptr.hpp"
+#include "rstl/reserved_vector.hpp"
+
+class ITweakObject;
+
 class CTweaks {
 public:
+  CTweaks();
+  ~CTweaks();
+
   void RegisterResourceTweaks();
   void RegisterTweaks();
 
 private:
-  uint x0_unk;
+  rstl::reserved_vector< rstl::auto_ptr< ITweakObject >, 12 > x0_;
 };
+CHECK_SIZEOF(CTweaks, 0x64)
 
 #endif

include/MetroidPrime/Tweaks/ITweakObject.hpp

@@ -0,0 +1,11 @@
+#ifndef _ITWEAKOBJECT_HPP
+#define _ITWEAKOBJECT_HPP
+
+#include "types.h"
+
+class ITweakObject {
+public:
+  virtual ~ITweakObject() = 0;
+};
+
+#endif