Added offset and size assertions to API structs

MarathonRecomp/api/Chao/CSD/Core/csdRCObject.h

@@ -19,4 +19,10 @@ namespace Chao::CSD
         xpointer<void> m_Field0C;
         be<uint32_t> m_Field10;
     };
+
+    MARATHON_ASSERT_OFFSETOF(RCPtrAbs::RCObject, m_pVftable, 0x00);
+    MARATHON_ASSERT_OFFSETOF(RCPtrAbs::RCObject, m_pMemory, 0x04);
+    MARATHON_ASSERT_OFFSETOF(RCPtrAbs::RCObject, m_ReferenceCount, 0x08);
+    MARATHON_ASSERT_OFFSETOF(RCPtrAbs::RCObject, m_Field0C, 0x0C);
+    MARATHON_ASSERT_OFFSETOF(RCPtrAbs::RCObject, m_Field10, 0x10);
 }

MarathonRecomp/api/Chao/CSD/Core/csdRCPtrAbs.h

@@ -18,4 +18,7 @@ namespace Chao::CSD
         xpointer<Vftable> m_pVftable;
         xpointer<RCObject> m_pObject;
     };
+
+    MARATHON_ASSERT_OFFSETOF(RCPtrAbs, m_pVftable, 0x00);
+    MARATHON_ASSERT_OFFSETOF(RCPtrAbs, m_pObject, 0x04);
 }

MarathonRecomp/api/Chao/CSD/Core/csdTexList.h

@@ -16,4 +16,7 @@ namespace Chao::CSD
         xpointer<Vftable> m_pVftable;
         RCPtr<uint8_t> m_pRCData;
     };
+
+    MARATHON_ASSERT_OFFSETOF(CTexList, m_pVftable, 0x00);
+    MARATHON_ASSERT_OFFSETOF(CTexList, m_pRCData, 0x04);
 }

MarathonRecomp/api/Chao/CSD/Manager/csdmNode.h

@@ -17,4 +17,6 @@ namespace Chao::CSD
         xpointer<CMotionPattern> m_pMotionPattern;
         MARATHON_INSERT_PADDING(0x18);
     };
+
+    MARATHON_ASSERT_OFFSETOF(CNode, m_pMotionPattern, 0x50);
 }

MarathonRecomp/api/Chao/CSD/Manager/csdmObserverBase.h

@@ -16,4 +16,6 @@ namespace Chao::CSD
         xpointer<Vftable> m_pVftable;
         MARATHON_INSERT_PADDING(0x0C);
     };
+
+    MARATHON_ASSERT_OFFSETOF(CObserverBase<void>, m_pVftable, 0x00);
 }

MarathonRecomp/api/Chao/CSD/Manager/csdmProject.h

@@ -23,4 +23,8 @@ namespace Chao::CSD
         RCPtr<CTexList> m_rcTexList;
         MARATHON_INSERT_PADDING(0x1C);
     };
+
+    MARATHON_ASSERT_OFFSETOF(Project, pRootNode, 0x00);
+
+    MARATHON_ASSERT_OFFSETOF(CProject, m_rcTexList, 0x28);
 }

MarathonRecomp/api/Chao/CSD/Manager/csdmResourceBase.h

@@ -18,4 +18,7 @@ namespace Chao::CSD
         MARATHON_INSERT_PADDING(4);
         xpointer<T> m_pResource;
     };
+
+    MARATHON_ASSERT_OFFSETOF(CResourceBase<void>, m_pVftable, 0x00);
+    MARATHON_ASSERT_OFFSETOF(CResourceBase<void>, m_pResource, 0x08);
 }

MarathonRecomp/api/Chao/CSD/Manager/csdmScene.h

@@ -119,4 +119,48 @@ namespace Chao::CSD
         be<MotionRepeatType> m_MotionRepeatType;
         MARATHON_INSERT_PADDING(0x2C);
     };
+
+    MARATHON_ASSERT_OFFSETOF(CastLink, ChildCastIndex, 0x00);
+    MARATHON_ASSERT_OFFSETOF(CastLink, SiblingCastIndex, 0x04);
+
+    MARATHON_ASSERT_OFFSETOF(CastNode, CastCount, 0x00);
+    MARATHON_ASSERT_OFFSETOF(CastNode, pCasts, 0x08);
+    MARATHON_ASSERT_OFFSETOF(CastNode, RootCastIndex, 0x10);
+    MARATHON_ASSERT_OFFSETOF(CastNode, pCastLinks, 0x18);
+
+    MARATHON_ASSERT_OFFSETOF(CastIndex, pCastName, 0x00);
+    MARATHON_ASSERT_OFFSETOF(CastIndex, CastNodeIndex, 0x08);
+    MARATHON_ASSERT_OFFSETOF(CastIndex, CastIndex, 0x0C);
+
+    MARATHON_ASSERT_OFFSETOF(Scene, FPS, 0x08);
+    MARATHON_ASSERT_OFFSETOF(Scene, CastNodeCount, 0x30);
+    MARATHON_ASSERT_OFFSETOF(Scene, pCastNodes, 0x38);
+    MARATHON_ASSERT_OFFSETOF(Scene, CastCount, 0x40);
+    MARATHON_ASSERT_OFFSETOF(Scene, pCastIndices, 0x48);
+    MARATHON_ASSERT_OFFSETOF(Scene, AnimationCount, 0x50);
+    MARATHON_ASSERT_OFFSETOF(Scene, pAnimationKeyFrameDataList, 0x58);
+    MARATHON_ASSERT_OFFSETOF(Scene, pAnimationDictionary, 0x60);
+    MARATHON_ASSERT_OFFSETOF(Scene, AspectRatio, 0x68);
+    MARATHON_ASSERT_OFFSETOF(Scene, pAnimationFrameDataList, 0x70);
+
+    MARATHON_ASSERT_OFFSETOF(SceneIndex, pSceneName, 0x00);
+    MARATHON_ASSERT_OFFSETOF(SceneIndex, SceneIndex, 0x08);
+
+    MARATHON_ASSERT_OFFSETOF(SceneNodeIndex, pSceneNodeName, 0x00);
+    MARATHON_ASSERT_OFFSETOF(SceneNodeIndex, SceneNodeIndex, 0x04);
+
+    MARATHON_ASSERT_OFFSETOF(SceneNode, SceneCount, 0x00);
+    MARATHON_ASSERT_OFFSETOF(SceneNode, pScenes, 0x08);
+    MARATHON_ASSERT_OFFSETOF(SceneNode, pSceneIndices, 0x10);
+    MARATHON_ASSERT_OFFSETOF(SceneNode, SceneNodeCount, 0x18);
+    MARATHON_ASSERT_OFFSETOF(SceneNode, pSceneNodes, 0x20);
+    MARATHON_ASSERT_OFFSETOF(SceneNode, pSceneNodeIndices, 0x28);
+
+    MARATHON_ASSERT_OFFSETOF(CScene, m_PrevMotionFrame, 0x7C);
+    MARATHON_ASSERT_OFFSETOF(CScene, m_MotionFrame, 0x80);
+    MARATHON_ASSERT_OFFSETOF(CScene, m_MotionSpeed, 0x84);
+    MARATHON_ASSERT_OFFSETOF(CScene, m_MotionStartFrame, 0x88);
+    MARATHON_ASSERT_OFFSETOF(CScene, m_MotionEndFrame, 0x8C);
+    MARATHON_ASSERT_OFFSETOF(CScene, m_MotionDisableFlag, 0x9C);
+    MARATHON_ASSERT_OFFSETOF(CScene, m_MotionRepeatType, 0xB0);
 }

MarathonRecomp/api/Chao/CSD/Manager/csdmSubjectBase.h

@@ -17,4 +17,6 @@ namespace Chao::CSD
         xpointer<Vftable> m_pVftable;
         MARATHON_INSERT_PADDING(0x0C);
     };
+
+    static_assert(__builtin_offsetof(SubjectBase<void, void>, m_pVftable) == 0x00);
 }

MarathonRecomp/api/Marathon.h

@@ -157,6 +157,7 @@
 #include "Sonicteam/SoX/Graphics/Technique.h"
 #include "Sonicteam/SoX/Graphics/TechniqueFXL.h"
 #include "Sonicteam/SoX/Graphics/Transforms.h"
+#include "Sonicteam/SoX/Graphics/Vertex.h"
 #include "Sonicteam/SoX/Graphics/Xenon/DeviceXenon.h"
 #include "Sonicteam/SoX/Graphics/Xenon/TextureXenon.h"
 #include "Sonicteam/SoX/IResource.h"

MarathonRecomp/api/Sonicteam/Actor.h

@@ -11,4 +11,7 @@ namespace Sonicteam
         MARATHON_INSERT_PADDING(8); // boost::weak_ptr<Sonicteam::GameImp> GameImp;
         be<uint32_t> m_ActorID;
     };
+
+    MARATHON_ASSERT_OFFSETOF(Actor, m_ActorID, 0x54);
+    MARATHON_ASSERT_SIZEOF(Actor, 0x58);
 }

MarathonRecomp/api/Sonicteam/ActorManager.h

@@ -8,9 +8,16 @@ namespace Sonicteam
     class ActorManager
     {
     public:
-		be<uint32_t> m_ActorID[0xFFFF];
-		xpointer<Actor> m_Actor[0xFFFF];
+		be<uint32_t> m_aActorIDs[0xFFFF];
+		xpointer<Actor> m_aActors[0xFFFF];
 		be<uint32_t> m_LastActorID;
 		be<uint32_t> m_LastActorIndex;
+        MARATHON_INSERT_PADDING(4);
     };
+
+    MARATHON_ASSERT_OFFSETOF(ActorManager, m_aActorIDs, 0x00);
+    MARATHON_ASSERT_OFFSETOF(ActorManager, m_aActors, 0x3FFFC);
+    MARATHON_ASSERT_OFFSETOF(ActorManager, m_LastActorID, 0x7FFF8);
+    MARATHON_ASSERT_OFFSETOF(ActorManager, m_LastActorIndex, 0x7FFFC);
+    MARATHON_ASSERT_SIZEOF(ActorManager, 0x80004);
 }

MarathonRecomp/api/Sonicteam/AlertWindowTask.h

@@ -13,9 +13,16 @@ namespace Sonicteam
         MARATHON_INSERT_PADDING(0x2C);
         be<uint32_t> m_Operation;
         MARATHON_INSERT_PADDING(0x14);
-        boost::anonymous_shared_ptr m_spOptions[3];
+        boost::anonymous_shared_ptr m_aspOptions[3];
         MARATHON_INSERT_PADDING(4);
         be<uint32_t> m_OptionCount;
         xpointer<SelectWindowTask> m_pSelectWindowTask;
     };
+
+    MARATHON_ASSERT_OFFSETOF(AlertWindowTask, m_HasSelectWindow, 0x4C);
+    MARATHON_ASSERT_OFFSETOF(AlertWindowTask, m_Operation, 0x7C);
+    MARATHON_ASSERT_OFFSETOF(AlertWindowTask, m_aspOptions, 0x94);
+    MARATHON_ASSERT_OFFSETOF(AlertWindowTask, m_OptionCount, 0xB0);
+    MARATHON_ASSERT_OFFSETOF(AlertWindowTask, m_pSelectWindowTask, 0xB4);
+    MARATHON_ASSERT_SIZEOF(AlertWindowTask, 0xB8);
 }

MarathonRecomp/api/Sonicteam/AppMarathon.h

@@ -22,6 +22,8 @@ namespace Sonicteam
             return nullptr;
         }
     };
+
+    MARATHON_ASSERT_OFFSETOF(AppMarathon, m_pDoc, 0x180);
 }
 
 #include <Sonicteam/AppMarathon.inl>

MarathonRecomp/api/Sonicteam/AudioEngineXenon.h

@@ -14,6 +14,10 @@ namespace Sonicteam
         MARATHON_INSERT_PADDING(8);
         be<float> m_MusicVolume;
         be<float> m_EffectsVolume;
-        MARATHON_INSERT_PADDING(0x14);
+        MARATHON_INSERT_PADDING(0x18);
     };
+
+    MARATHON_ASSERT_OFFSETOF(AudioEngineXenon, m_MusicVolume, 0x0C);
+    MARATHON_ASSERT_OFFSETOF(AudioEngineXenon, m_EffectsVolume, 0x10);
+    MARATHON_ASSERT_SIZEOF(AudioEngineXenon, 0x2C);
 }   

MarathonRecomp/api/Sonicteam/ButtonWindowTask.h

@@ -9,5 +9,9 @@ namespace Sonicteam
     {
     public:
         xpointer<HUDButtonWindow> m_pHUDButtonWindow;
+        MARATHON_INSERT_PADDING(8);
     };
+
+    MARATHON_ASSERT_OFFSETOF(ButtonWindowTask, m_pHUDButtonWindow, 0x4C);
+    MARATHON_ASSERT_SIZEOF(ButtonWindowTask, 0x58);
 }

MarathonRecomp/api/Sonicteam/CObjBalloonIconDrawable.h

@@ -9,19 +9,13 @@ namespace Sonicteam
     class CObjBalloonIconDrawable : public SoX::Scenery::Drawable
     {
     public:
-        struct Vertex
-        {
-            be<float> X;
-            be<float> Y;
-            MARATHON_INSERT_PADDING(0x10);
-            be<uint32_t> Colour; // ARGB8888
-            be<float> U;
-            be<float> V;
-            MARATHON_INSERT_PADDING(0x18);
-        };
-
         xpointer<MyGraphicsDevice> m_pMyGraphicsDevice;
         MARATHON_INSERT_PADDING(0x24);
-        Vertex m_Vertices[4]; // BL, TL, BR, TR
+        SoX::Graphics::Vertex m_aVertices[4]; // BL, TL, BR, TR
+        MARATHON_INSERT_PADDING(0x18);
     };
+
+    MARATHON_ASSERT_OFFSETOF(CObjBalloonIconDrawable, m_pMyGraphicsDevice, 0x70);
+    MARATHON_ASSERT_OFFSETOF(CObjBalloonIconDrawable, m_aVertices, 0x98);
+    MARATHON_ASSERT_SIZEOF(CObjBalloonIconDrawable, 0x1A0);
 }

MarathonRecomp/api/Sonicteam/Camera/CameraMode.h

@@ -19,4 +19,8 @@ namespace Sonicteam::Camera
             return (GameImp*)m_spGame.get();
         }
     };
+
+    MARATHON_ASSERT_OFFSETOF(CameraMode, m_spGame, 0x04);
+    MARATHON_ASSERT_OFFSETOF(CameraMode, m_pCameraInputListener, 0x0C);
+    MARATHON_ASSERT_SIZEOF(CameraMode, 0x28);
 }

MarathonRecomp/api/Sonicteam/Camera/CameraModeManager.h

@@ -20,5 +20,11 @@ namespace Sonicteam::Camera
         boost::shared_ptr<CameraMode> m_spCameraMode;
         MARATHON_INSERT_PADDING(8);
         stdx::vector<UnknownStruct> m_vUnkStructs;
+        MARATHON_INSERT_PADDING(4);
     };
+
+    MARATHON_ASSERT_OFFSETOF(CameraModeManager, m_pCameraman, 0x00);
+    MARATHON_ASSERT_OFFSETOF(CameraModeManager, m_spCameraMode, 0x04);
+    MARATHON_ASSERT_OFFSETOF(CameraModeManager, m_vUnkStructs, 0x14);
+    MARATHON_ASSERT_SIZEOF(CameraModeManager, 0x28);
 }

MarathonRecomp/api/Sonicteam/Camera/Cameraman.h

@@ -14,5 +14,10 @@ namespace Sonicteam::Camera
         boost::shared_ptr<CameraModeManager> m_spCameraModeManager;
         MARATHON_INSERT_PADDING(0x2C);
         be<float> m_FOV;
+        MARATHON_INSERT_PADDING(0x0C);
     };
+
+    MARATHON_ASSERT_OFFSETOF(Cameraman, m_spCameraModeManager, 0x7C);
+    MARATHON_ASSERT_OFFSETOF(Cameraman, m_FOV, 0xB0);
+    MARATHON_ASSERT_SIZEOF(Cameraman, 0xC0);
 }

MarathonRecomp/api/Sonicteam/Camera/SonicCamera.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <Marathon.inl>
+
 namespace Sonicteam::Camera
 {
     class SonicCamera : public CameraMode
@@ -22,4 +24,17 @@ namespace Sonicteam::Camera
         be<float> m_Distance;
         MARATHON_INSERT_PADDING(0x0C);
     };
+
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_pDoc, 0x2C);
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_SpringK, 0x44);
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_DampingK, 0x48);
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_AzDamping, 0x4C);
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_AltDamping, 0x50);
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_AzDriveK, 0x54);
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_AzDampingK, 0x58);
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_AltDriveK, 0x5C);
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_AltDampingK, 0x60);
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_FovY, 0xA0);
+    MARATHON_ASSERT_OFFSETOF(SonicCamera, m_Distance, 0xE0);
+    MARATHON_ASSERT_SIZEOF(SonicCamera, 0xF0);
 }

MarathonRecomp/api/Sonicteam/CommonObjectHint.h

@@ -22,11 +22,13 @@ namespace Sonicteam
         bool m_IsHitAnim;
         MARATHON_INSERT_PADDING(2);
         be<float> m_HitTime;
+        MARATHON_INSERT_PADDING(0x10);
     };
 
     MARATHON_ASSERT_OFFSETOF(CommonObjectHint, m_MessageName, 0x184);
     MARATHON_ASSERT_OFFSETOF(CommonObjectHint, m_Type, 0x1D8);
     MARATHON_ASSERT_OFFSETOF(CommonObjectHint, m_IsFastAnim, 0x1DC);
     MARATHON_ASSERT_OFFSETOF(CommonObjectHint, m_IsHitAnim, 0x1DD);
     MARATHON_ASSERT_OFFSETOF(CommonObjectHint, m_HitTime, 0x1E0);
+    MARATHON_ASSERT_SIZEOF(CommonObjectHint, 0x200);
 }

MarathonRecomp/api/Sonicteam/CsdLink.h

@@ -30,4 +30,10 @@ namespace Sonicteam
             return GuestToHostFunction<int>(m_pVftable->fpUpdate.get(), this, deltaTime);
         }
     };
+
+    MARATHON_ASSERT_OFFSETOF(CsdLink, m_pVftable, 0x00);
+    MARATHON_ASSERT_OFFSETOF(CsdLink, m_pNext, 0x04);
+    MARATHON_ASSERT_OFFSETOF(CsdLink, m_pPrevious, 0x08);
+    MARATHON_ASSERT_OFFSETOF(CsdLink, m_Priority, 0x0C);
+    MARATHON_ASSERT_SIZEOF(CsdLink, 0x18);
 }

MarathonRecomp/api/Sonicteam/CsdManager.h

@@ -12,4 +12,6 @@ namespace Sonicteam
     public:
         MARATHON_INSERT_PADDING(0x1C);
     };
+
+    MARATHON_ASSERT_SIZEOF(CsdManager, 0x2C);
 }

MarathonRecomp/api/Sonicteam/CsdObject.h

@@ -14,4 +14,8 @@ namespace Sonicteam
         xpointer<Chao::CSD::CProject> m_pCsdProject;
         xpointer<CsdResource> m_pCsdResource;
     };
+
+    MARATHON_ASSERT_OFFSETOF(CsdObject, m_pCsdProject, 0x24);
+    MARATHON_ASSERT_OFFSETOF(CsdObject, m_pCsdResource, 0x28);
+    MARATHON_ASSERT_SIZEOF(CsdObject, 0x2C);
 }

MarathonRecomp/api/Sonicteam/CsdResource.h

@@ -11,4 +11,6 @@ namespace Sonicteam
     public:
         MARATHON_INSERT_PADDING(4);
     };
+
+    MARATHON_ASSERT_SIZEOF(CsdResource, 0x68);
 }

MarathonRecomp/api/Sonicteam/DocMarathonImp.h

@@ -16,6 +16,12 @@ namespace Sonicteam
         MARATHON_INSERT_PADDING(0x24);
         bool m_VFrame;
         MARATHON_INSERT_PADDING(0x55B58);
-        be<uint32_t> m_PlayerControllerID[4];
+        be<uint32_t> m_aPadIDs[4];
+        MARATHON_INSERT_PADDING(0x2C);
     };
+
+    MARATHON_ASSERT_OFFSETOF(DocMarathonImp, m_vspInputManager, 0x9C);
+    MARATHON_ASSERT_OFFSETOF(DocMarathonImp, m_VFrame, 0xD0);
+    MARATHON_ASSERT_OFFSETOF(DocMarathonImp, m_aPadIDs, 0x55C2C);
+    MARATHON_ASSERT_SIZEOF(DocMarathonImp, 0x55C68);
 }

MarathonRecomp/api/Sonicteam/DocMarathonState.h

@@ -6,4 +6,6 @@
 namespace Sonicteam
 {
     class DocMarathonState : public DocMarathonImp {};
+
+    MARATHON_ASSERT_SIZEOF(DocMarathonState, 0x55C68);
 }

MarathonRecomp/api/Sonicteam/Enemy/EnemyShot.h

@@ -9,4 +9,6 @@ namespace Sonicteam::Enemy
     public:
         MARATHON_INSERT_PADDING(0x1C);
     };
+
+    MARATHON_ASSERT_SIZEOF(EnemyShot, 0x68);
 }

MarathonRecomp/api/Sonicteam/Enemy/EnemyShotNormal.h

@@ -6,4 +6,6 @@
 namespace Sonicteam::Enemy
 {
     class EnemyShotNormal : public EnemyShotPoint {};
+
+    MARATHON_ASSERT_SIZEOF(EnemyShotNormal, 0x160);
 }

MarathonRecomp/api/Sonicteam/Enemy/EnemyShotPoint.h

@@ -14,4 +14,7 @@ namespace Sonicteam::Enemy
         SoX::RefSharedPointer<MyPhantom> m_spPhantom;
         MARATHON_INSERT_PADDING(0xD4);
     };
+
+    MARATHON_ASSERT_OFFSETOF(EnemyShotPoint, m_spPhantom, 0x88);
+    MARATHON_ASSERT_SIZEOF(EnemyShotPoint, 0x160);
 }

MarathonRecomp/api/Sonicteam/Fixture.h

@@ -10,8 +10,12 @@ namespace Sonicteam
     class Fixture : public Actor
     {
     public:
-        Sonicteam::SoX::Math::Quaternion m_Rotation;
-        Sonicteam::SoX::Math::Vector m_Position;
+        SoX::Math::Quaternion m_Rotation;
+        SoX::Math::Vector m_Position;
         MARATHON_INSERT_PADDING(0xF0);
     };
+
+    MARATHON_ASSERT_OFFSETOF(Fixture, m_Rotation, 0x60);
+    MARATHON_ASSERT_OFFSETOF(Fixture, m_Position, 0x70);
+    MARATHON_ASSERT_SIZEOF(Fixture, 0x170);
 }

MarathonRecomp/api/Sonicteam/Game.h

@@ -5,4 +5,6 @@
 namespace Sonicteam
 {
     class Game : public SoX::MessageReceiver {};
+
+    MARATHON_ASSERT_SIZEOF(Game, 4);
 }