More API

PostureCommon(Recreation), 100.0%
*Testing
*Cleanup 1
*Attempt to fix Shadow KDV Glider Bug
*Vehicle Enter on Spawn Fixed (Adjusted m_radius for Zock a little,
depends on fps)
*Deque class (not tested)
*Entity & EntityRef & EntityWrapper (all of them fixed)
*Config::DisableEdgeGrabLeftover -> Edge Oscallation experimental fix
*BodyHavok Experimental Delta Fix
*Silver Psycho Fix(Removed due BodyHavok Fix)
*Aqa Mercury API
*Cleanup 2
closes issue #96
closes issue #33
*New Code Config::AlwaysResetSpringState
*classes have been updated : Object2, CommonObject,
*Fixed SoX::AI::StateMachine, new class SoX::AI::State,Player::State::CommonSprintTemplate
closes issue #26
*New Codes : AllowSpinDashJump, DisableMachStateLockInput(Blue Gem),
AlwaysBlueGem(allow to using blue for states like spindash, kick ...)
RTTI API
Graphics API
Particle API

Author: ReimousTH

MarathonRecomp/api/Marathon.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cpu/guest_stack_var.h>
+#include <cpu/guest_heap_var.h>
 #include <kernel/function.h>
 
 constexpr float RAD2DEGf = 57.2958f;
@@ -24,6 +25,9 @@ constexpr double DEG2RAD = 0.01745329238474369;
 #define MARATHON_VIRTUAL_FUNCTION(returnType, virtualIndex, ...) \
     GuestToHostFunction<returnType>(*(be<uint32_t>*)(g_memory.Translate(*(be<uint32_t>*)(this) + (4 * virtualIndex))), __VA_ARGS__)
 
+#define MARATHON_CALL_VIRTUAL_FUNCTION(base, returnType, func, ...) \
+    GuestToHostFunction<returnType>((Vftable*)(static_cast<base*>(this)->m_pVftable.get())->*func, ##__VA_ARGS__)
+
 struct marathon_null_ctor {};
 
 inline std::vector<std::string_view> ParseTextVariables(const char* pVariables)
@@ -138,3 +142,13 @@ inline void printU16(const uint16_t* str, bool endianSwap = false)
 
     printf("\n");
 }
+
+struct MARATHON_NULL_CTOR {};
+
+struct MARATHON_STD_MAP_CONST_CHAR_COMPARE
+{
+    bool operator()(xpointer<const char> lhs, xpointer<const char> rhs) const
+    {
+        return std::strcmp(lhs.get(), rhs.get()) < 0;
+    }
+};

MarathonRecomp/api/Marathon.inl

@@ -8,16 +8,13 @@ namespace Sonicteam
     class ActorManager
     {
     public:
-		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);
-    };
+        be<uint32_t> m_ActorID[0xFFFF];
+        xpointer<Actor> m_Actor[0xFFFF];
+        be<uint32_t> m_LastActorID;
+        be<uint32_t> m_LastActorIndex;
 
-    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);
+        Sonicteam::Actor* FindActor(uint32_t ActorID);
+    };
 }
+
+#include "ActorManager.inl"

MarathonRecomp/api/Sonicteam/ActorManager.h

@@ -0,0 +1,27 @@
+#pragma once
+
+namespace Sonicteam
+{
+    inline Actor* ActorManager::FindActor(uint32_t ActorID)
+    {
+        unsigned int left = 0;
+        unsigned int right = this->m_LastActorIndex - 1;
+        int Index = 0;
+
+        while (left <= right) {
+            unsigned int mid = left + (right - left) / 2;
+            if (this->m_ActorID[mid] == ActorID) {
+                Index = mid;
+                break;
+            }
+            if (this->m_ActorID[mid] < ActorID) {
+                left = mid + 1;
+            }
+            else {
+                right = mid - 1;
+            }
+        }
+        if (!this->m_Actor[Index]) return 0;
+        return this->m_Actor[Index];
+    }
+}

MarathonRecomp/api/Sonicteam/ActorManager.inl

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <Marathon.inl>
+#include <Sonicteam/SoX/Engine/Task.h>
+
+namespace Sonicteam
+{
+    class BasicIScriptParamsDesc
+    {
+        xpointer<void> m_pDefaultDesc; //points to static, (0x82..., NOT VFT )
+    };
+    //static 0x8202AC38 (??????)
+}

MarathonRecomp/api/Sonicteam/BasicIScriptParamsDesc.h

@@ -1,26 +1,50 @@
 #pragma once
 
 #include <Marathon.inl>
+#include <boost/smart_ptr/shared_ptr.h>
 #include <Sonicteam/SoX/Engine/Doc.h>
 #include <Sonicteam/SoX/Input/Manager.h>
-#include <boost/smart_ptr/shared_ptr.h>
-#include <api/stdx/vector.h>
+#include <Sonicteam/SoX/LinkNode.h>
+#include <Sonicteam/SoX/Thread.h>
+#include <Sonicteam/MyGraphicsDevice.h>
+#include <Sonicteam/RaderMapManager.h>
+#include <Sonicteam/Particles/ParticleManager.h>
+#include <stdx/vector.h>
 
 namespace Sonicteam
 {
+    class RenderTargetContainer;
+    class SFXAgent;
+
     class DocMarathonImp : public SoX::Engine::Doc
     {
     public:
-        MARATHON_INSERT_PADDING(0x40);
-        stdx::vector<boost::shared_ptr<SoX::Input::Manager>> m_vspInputManager;
+        MARATHON_INSERT_PADDING(4);
+        xpointer<MyGraphicsDevice> m_pMyGraphicsDevice;
+        MARATHON_INSERT_PADDING(0x38);
+        stdx::vector<boost::shared_ptr<SoX::Input::Manager>> m_vspInputManagers;
         MARATHON_INSERT_PADDING(0x24);
         bool m_VFrame;
-        MARATHON_INSERT_PADDING(0x55B58);
+        MARATHON_INSERT_PADDING(4);
+        xpointer<RenderTargetContainer> m_pRenderTargetContainer;
+        xpointer<SFXAgent> m_pSFXAgent;
+        MARATHON_INSERT_PADDING(0x8);
+        be<float> m_DocSpeed;
+        be<uint32_t> m_PauseFlags;
+        MARATHON_INSERT_PADDING(0x8);
+        xpointer<SoX::LinkedList<SoX::Thread>> m_lnThread;
+        MARATHON_INSERT_PADDING(0x288);
+        xpointer<Particles::ParticleManager> m_pParticleManager;
+        MARATHON_INSERT_PADDING(0x15D0);
+        xpointer<RaderMapManager> m_pRaderMapManager;
+        MARATHON_INSERT_PADDING(0x542D0);
         be<uint32_t> m_aPadIDs[4];
         MARATHON_INSERT_PADDING(0x2C);
     };
 
-    MARATHON_ASSERT_OFFSETOF(DocMarathonImp, m_vspInputManager, 0x9C);
+    MARATHON_ASSERT_OFFSETOF(DocMarathonImp, m_DocSpeed, 0xE8);
+    MARATHON_ASSERT_OFFSETOF(DocMarathonImp, m_PauseFlags, 0xEC);
+    MARATHON_ASSERT_OFFSETOF(DocMarathonImp, m_vspInputManagers, 0x9C);
     MARATHON_ASSERT_OFFSETOF(DocMarathonImp, m_VFrame, 0xD0);
     MARATHON_ASSERT_OFFSETOF(DocMarathonImp, m_aPadIDs, 0x55C2C);
     MARATHON_ASSERT_SIZEOF(DocMarathonImp, 0x55C68);

MarathonRecomp/api/Sonicteam/DocMarathonImp.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <Marathon.inl>
+#include <Sonicteam/ObjectPsi.h>
+#include <Sonicteam/SoX/Math/Vector.h>
+
+namespace Sonicteam
+{
+    class EnemyPsiCommon : public ObjectPsi
+    {
+    public:
+        xpointer<void> m_pFigure;
+        be<float> m_Field2C;
+        SoX::Math::Vector m_Velocity;
+        SoX::Math::Vector m_Rotation;
+    };
+
+    MARATHON_ASSERT_SIZEOF(EnemyPsiCommon, 0x50);
+    MARATHON_ASSERT_OFFSETOF(EnemyPsiCommon, m_pFigure, 0x28);
+    MARATHON_ASSERT_OFFSETOF(EnemyPsiCommon, m_Field2C, 0x2C);
+    MARATHON_ASSERT_OFFSETOF(EnemyPsiCommon, m_Velocity, 0x30);
+    MARATHON_ASSERT_OFFSETOF(EnemyPsiCommon, m_Rotation, 0x40);
+}

MarathonRecomp/api/Sonicteam/EnemyPsiCommon.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <Marathon.inl>
+#include <Sonicteam/GE1PE/RefCountObject.h>
+#include <stdx/map.h>
+#include <stdx/string.h>
+
+namespace Sonicteam::GE1PE
+{
+    class ParticleEngine;
+
+    struct EffectBankData
+    {
+        be<uint32_t> Field00;
+        stdx::string Name;
+        xpointer<void> pData1;
+        xpointer<void> pData2;
+        xpointer<void> pData3;
+        stdx::map<stdx::string, be<uint32_t>> mEffectDataIndices;
+    };
+
+    class EffectBank : public RefCountObject
+    {
+    public:
+        xpointer<ParticleEngine> m_pParticleEngine;
+        be<uint32_t> m_Field0C; // Index?
+        xpointer<EffectBankData> m_pEffectBankA;
+    };
+
+    MARATHON_ASSERT_OFFSETOF(EffectBankData, Field00, 0x00);
+    MARATHON_ASSERT_OFFSETOF(EffectBankData, Name, 0x04);
+    MARATHON_ASSERT_OFFSETOF(EffectBankData, pData1, 0x20);
+    MARATHON_ASSERT_OFFSETOF(EffectBankData, pData2, 0x24);
+    MARATHON_ASSERT_OFFSETOF(EffectBankData, pData3, 0x28);
+    MARATHON_ASSERT_OFFSETOF(EffectBankData, mEffectDataIndices, 0x2C);
+    MARATHON_ASSERT_SIZEOF(EffectBankData, 0x38);
+
+    MARATHON_ASSERT_OFFSETOF(EffectBank, m_pParticleEngine, 0x08);
+    MARATHON_ASSERT_OFFSETOF(EffectBank, m_Field0C, 0x0C);
+    MARATHON_ASSERT_OFFSETOF(EffectBank, m_pEffectBankA, 0x10);
+    MARATHON_ASSERT_SIZEOF(EffectBank, 0x14);
+}

MarathonRecomp/api/Sonicteam/GE1PE/EffectBank.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <Marathon.inl>
+
+namespace Sonicteam::GE1PE
+{
+    class EmitterListener
+    {
+    public:
+        xpointer<void> m_pVftable;
+    };
+}

MarathonRecomp/api/Sonicteam/GE1PE/EmitterListener.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <Marathon.inl>
+#include <Sonicteam/SoX/LinkNode.h>
+
+namespace Sonicteam::GE1PE
+{
+    class Effect;
+    class Emitter;
+    class Particle;
+    class ParticleEngine;
+
+    class Manager
+    {
+    public:
+        struct Vftable
+        {
+            be<uint32_t> fpDestroy;
+        };
+
+        xpointer<Vftable> m_pVftable;
+        xpointer<ParticleEngine> m_pParticleEngine;
+        SoX::LinkNode<Manager> m_lnManager;
+        SoX::LinkNode<void> m_lnField14;
+        SoX::LinkNode<Particle> m_lnParticle;
+        SoX::LinkNode<void> m_lnField2C;
+        SoX::LinkNode<void> m_lnField38;
+        SoX::LinkNode<Emitter> m_lnEmitter;
+        SoX::LinkNode<Effect> m_lnEffect;
+        SoX::LinkNode<Effect> m_lnField5C;
+        MARATHON_INSERT_PADDING(0x24);
+    };
+
+    MARATHON_ASSERT_OFFSETOF(Manager, m_pParticleEngine, 0x04);
+    MARATHON_ASSERT_OFFSETOF(Manager, m_lnManager, 0x08);
+    MARATHON_ASSERT_OFFSETOF(Manager, m_lnField14, 0x14);
+    MARATHON_ASSERT_OFFSETOF(Manager, m_lnParticle, 0x20);
+    MARATHON_ASSERT_OFFSETOF(Manager, m_lnField2C, 0x2C);
+    MARATHON_ASSERT_OFFSETOF(Manager, m_lnField38, 0x38);
+    MARATHON_ASSERT_OFFSETOF(Manager, m_lnEmitter, 0x44);
+    MARATHON_ASSERT_OFFSETOF(Manager, m_lnEffect, 0x50);
+    MARATHON_ASSERT_OFFSETOF(Manager, m_lnField5C, 0x5C);
+}