After

Author: ReimousTH

MarathonRecomp/api/Sonicteam/Particles/Particle.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <Marathon.inl>
+#include <Sonicteam/Particles/ParticleRef.h>
+
+namespace Sonicteam::Particles
+{
+    class Particle : public ParticleRef 
+    {
+        struct Vftable : ParticleRef::Vftable
+        {
+            be<uint32_t> fpFunc8;
+            be<uint32_t> fpFuncC;
+            be<uint32_t> fpFunc10; // Hint : Used Before Release() with arg 0
+            be<uint32_t> fpFunc14;
+            be<uint32_t> fpFunc18;
+            be<uint32_t> fpFunc1C;
+            be<uint32_t> fpFunc20;
+        };
+
+       void Func10(uint32_t flag)
+       {
+           auto pVft = (Vftable*)(m_pVftable.get());
+           GuestToHostFunction<void>(pVft->fpFunc10, this, flag);
+       }
+
+    };
+}

MarathonRecomp/api/Sonicteam/Particles/ParticleRef.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <Marathon.inl>
+
+namespace Sonicteam::Particles
+{
+    class ParticleRef
+    {
+    public:
+        
+        struct Vftable
+        {
+            be<uint32_t> fpDestroy;
+            be<uint32_t> fpRelease;
+        };
+
+        void Destroy(uint32_t flag)
+        {
+            GuestToHostFunction<void>(m_pVftable->fpDestroy, this, flag);
+        }
+
+        void Release()
+        {
+            GuestToHostFunction<void>(m_pVftable->fpRelease, this);
+        }
+
+        xpointer<Vftable> m_pVftable;
+        be<uint32_t> m_RefCount;
+    };
+}

MarathonRecomp/api/Sonicteam/Player/Effect/ParticleJoint.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <Marathon.inl>
+#include <Sonicteam/SoX/LinkNode.h>
+#include <Sonicteam/SoX/Graphics/FrameObserver.h>
+#include <Sonicteam/Particles/Particle.h>
+#include <Sonicteam/SoX/Math/Vector.h>
+
+namespace Sonicteam::Player::Effect
+{
+    // Temp Name, Position
+    struct ParticleLuaInfo
+    {
+        be<uint16_t> BankID;
+        be<uint16_t> ParticleID;
+        bool IsAcroarts; //kinda?
+        bool IsReverse;
+        be<uint32_t> Direction;
+        xpointer<const char> AttachNode;  //Bone Name
+        be<float> OffsetX;
+        be<float> OffsetY;
+        be<float> OffsetZ;
+    };
+
+    MARATHON_ASSERT_OFFSETOF(ParticleLuaInfo, BankID, 0x0);
+    MARATHON_ASSERT_OFFSETOF(ParticleLuaInfo, IsAcroarts, 0x4);
+    MARATHON_ASSERT_OFFSETOF(ParticleLuaInfo, IsReverse, 0x5);
+    MARATHON_ASSERT_OFFSETOF(ParticleLuaInfo, Direction, 0x8);
+    MARATHON_ASSERT_OFFSETOF(ParticleLuaInfo, AttachNode,0xC);
+    MARATHON_ASSERT_OFFSETOF(ParticleLuaInfo, OffsetX, 0x10);
+    MARATHON_ASSERT_SIZEOF(ParticleLuaInfo, 0x1C);
+
+
+    class ParticleJoint : public SoX::Graphics::FrameObserver::FrameObserver
+    {
+    public:
+        xpointer<Particles::Particle> m_pParticle;
+        bool m_IsAcroarts;
+        bool m_IsReverse;
+        be<uint32_t> m_Direction;
+        xpointer<const char> m_pAttachNode;
+        SoX::Math::Vector m_Offset;
+        SoX::Math::Vector m_Position;
+        SoX::Math::Vector m_Rotation; //i guess
+    };
+
+    MARATHON_ASSERT_OFFSETOF(ParticleJoint, m_pParticle, 0x14);
+    MARATHON_ASSERT_OFFSETOF(ParticleJoint, m_IsAcroarts, 0x18);
+    MARATHON_ASSERT_OFFSETOF(ParticleJoint, m_IsReverse, 0x19);
+    MARATHON_ASSERT_OFFSETOF(ParticleJoint, m_Direction, 0x1C);
+    MARATHON_ASSERT_OFFSETOF(ParticleJoint, m_pAttachNode, 0x20);
+    MARATHON_ASSERT_OFFSETOF(ParticleJoint, m_Offset, 0x30);
+    MARATHON_ASSERT_OFFSETOF(ParticleJoint, m_Position, 0x40);
+    MARATHON_ASSERT_OFFSETOF(ParticleJoint, m_Rotation, 0x50);
+    MARATHON_ASSERT_SIZEOF(ParticleJoint, 0x60);
+   
+}

MarathonRecomp/gpu/video.cpp

@@ -3314,16 +3314,19 @@ void Video::Present()
 
 
             // Update surfaces and textures
-            for (auto& surface : pRenderTargetContainer->m_mspDepthStencill_1_4) {
+            for (auto& surface : pRenderTargetContainer->m_mspDepthStencill_1_4) 
+            {
                 printf("Buffer %s scaled \n", surface.first.c_str());
                 if (_buffers_.find(surface.first.c_str()) == _buffers_.end()) continue;
                 auto params = _buffers_[surface.first.c_str()];
                 GuestSurfaceCreateParams* surfaceparams = nullptr;
 
-                if (pFormatConfig[params.r8].usage != 1 || (params.r10 & 1) != 0) {
+                if (pFormatConfig[params.r8].usage != 1 || (params.r10 & 1) != 0)
+                {
                     surfaceparams = &pMyGraphicDevice->m_SurfaceParamB;
                 }
-                else {
+                else 
+                {
                     surfaceparams = (params.r10 & 2) == 0 ? &pMyGraphicDevice->m_SurfaceParamA : &pMyGraphicDevice->m_SurfaceParamC;
                 }
 
@@ -3333,7 +3336,8 @@ void Video::Present()
 
 
 
-            for (auto& texture : pRenderTargetContainer->m_mspFrameBuffer) {
+            for (auto& texture : pRenderTargetContainer->m_mspFrameBuffer) 
+            {
                 const auto& textureName = texture.first;
                 auto& texturePtr = texture.second;
                 if (_buffers_.find(textureName.c_str()) == _buffers_.end()) continue;
@@ -3348,10 +3352,12 @@ void Video::Present()
 
                 // Determine surface parameters
                 GuestSurfaceCreateParams* surfaceparams = nullptr;
-                if (pFormatConfig[s2].usage != 1 || (params.r10 & 1) != 0) {
+                if (pFormatConfig[s2].usage != 1 || (params.r10 & 1) != 0) 
+                {
                     surfaceparams = &pMyGraphicDevice->m_SurfaceParamB;
                 }
-                else {
+                else 
+                {
                     surfaceparams = (params.r10 & 2) == 0 ? &pMyGraphicDevice->m_SurfaceParamA : &pMyGraphicDevice->m_SurfaceParamC;
                 }
 
@@ -3438,6 +3444,8 @@ void Video::Present()
             // Refresh Lua Render
             // 0x82B814F8 (stdx::string) gCurrentRenderScript
             GuestToHostFunction<void>(sub_8260DF88, pDocState, 0x82B814F8, 1);
+
+            // TODO: Fix particle not updating position or disappearing after Lua refresh
 
         }
     }