HLSL shader sync, Windows build fixes

DataSpec/DNACommon/AROTBuilder.cpp

@@ -208,15 +208,13 @@ void AROTBuilder::Node::writeColNodes(uint8_t*& ptr, const zeus::CAABox& curAABB
     {
         if (childNodes.empty())
         {
-            zeus::CAABox swapAABB = curAABB;
+            float* aabbOut = reinterpret_cast<float*>(ptr);
-            swapAABB.min[0] = hecl::SBig(swapAABB.min[0]);
+            aabbOut[0] = hecl::SBig(curAABB.min[0]);
-            swapAABB.min[1] = hecl::SBig(swapAABB.min[1]);
+            aabbOut[1] = hecl::SBig(curAABB.min[1]);
-            swapAABB.min[2] = hecl::SBig(swapAABB.min[2]);
+            aabbOut[2] = hecl::SBig(curAABB.min[2]);
-            swapAABB.max[0] = hecl::SBig(swapAABB.max[0]);
+            aabbOut[3] = hecl::SBig(curAABB.max[0]);
-            swapAABB.max[1] = hecl::SBig(swapAABB.max[1]);
+            aabbOut[4] = hecl::SBig(curAABB.max[1]);
-            swapAABB.max[2] = hecl::SBig(swapAABB.max[2]);
+            aabbOut[5] = hecl::SBig(curAABB.max[2]);
-            *reinterpret_cast<zeus::CVector3f*>(ptr) = swapAABB.min;
-            *reinterpret_cast<zeus::CVector3f*>(ptr + 12) = swapAABB.max;
             athena::io::MemoryWriter w(ptr + 24, INT32_MAX);
             w.writeUint16Big(childIndices.size());
             for (int idx : childIndices)
@@ -227,7 +225,7 @@ void AROTBuilder::Node::writeColNodes(uint8_t*& ptr, const zeus::CAABox& curAABB
         {
             uint16_t* pflags = reinterpret_cast<uint16_t*>(ptr);
             uint32_t* offsets = reinterpret_cast<uint32_t*>(ptr + 4);
-            *pflags = 0;
+            memset(pflags, 0, sizeof(uint32_t) * 9);
             for (int i=0 ; i < 1 + ((flags & 0x1) != 0) ; ++i)
             {
                 for (int j=0 ; j < 1 + ((flags & 0x2) != 0) ; ++j)

Runtime/CStateManager.cpp

@@ -18,6 +18,7 @@
 #include "World/CMorphBall.hpp"
 #include "World/CScriptSpawnPoint.hpp"
 #include "AutoMapper/CMapWorldInfo.hpp"
+#include "Particle/CGenDescription.hpp"
 
 #include <cmath>
 

Runtime/Camera/CCameraFilter.cpp

@@ -1,3 +1,4 @@
+#include "Graphics/CGraphics.hpp"
 #include "CCameraFilter.hpp"
 #include "GameGlobalObjects.hpp"
 #include "Graphics/CBooRenderer.hpp"

Runtime/Camera/CCameraManager.hpp

@@ -71,6 +71,7 @@ public:
         return x0_curCameraId;
     }
 
+    CFirstPersonCamera* GetFirstPersonCamera() { return x7c_fpCamera; }
     CBallCamera* GetBallCamera() { return x80_ballCamera; }
 };
 

Runtime/Graphics/CBooRenderer.cpp

@@ -1,6 +1,4 @@
-#if _WIN32
+#include "boo/System.hpp"
-#include <D3Dcommon.h>
-#endif
 #include "GameGlobalObjects.hpp"
 #include "CBooRenderer.hpp"
 #include "CTexture.hpp"
@@ -660,7 +658,7 @@ void CBooRenderer::SetThermalColdScale(float scale)
 }
 
 void CBooRenderer::DoThermalBlendCold()
-{    
+{
     zeus::CColor a = zeus::CColor::lerp(x2f4_thermColor, zeus::CColor::skWhite, x2f8_thermColdScale);
     m_thermColdFilter.setColorA(a);
     float bFac = 0.f;

Runtime/Graphics/CGraphics.hpp

@@ -1,14 +1,14 @@
 #ifndef __URDE_CGRAPHICS_HPP__
 #define __URDE_CGRAPHICS_HPP__
 
+#include "boo/graphicsdev/IGraphicsDataFactory.hpp"
+#include "boo/graphicsdev/IGraphicsCommandQueue.hpp"
+
 #include "RetroTypes.hpp"
 #include "zeus/CTransform.hpp"
 #include "zeus/CVector2i.hpp"
 #include "zeus/CColor.hpp"
 
-#include "boo/graphicsdev/IGraphicsDataFactory.hpp"
-#include "boo/graphicsdev/IGraphicsCommandQueue.hpp"
-
 #include "hecl/Runtime.hpp"
 
 namespace urde

Runtime/Graphics/CMakeLists.txt

@@ -1,6 +1,6 @@
 if(WIN32)
   set(PLAT_SRCS
-      Shaders/CLineRendererShaderHLSL.cpp
+      Shaders/CLineRendererShadersHLSL.cpp
       Shaders/CTexturedQuadFilterHLSL.cpp
       Shaders/CColoredQuadFilterHLSL.cpp
       Shaders/CModelShadersHLSL.cpp

Runtime/Graphics/CModelBoo.cpp

@@ -1,6 +1,3 @@
-#if _WIN32
-#include <D3Dcommon.h>
-#endif
 #include "Graphics/CModel.hpp"
 #include "Graphics/CTexture.hpp"
 #include "Graphics/CGraphics.hpp"

Runtime/Graphics/IRenderer.hpp

@@ -19,7 +19,7 @@ class CParticleGen;
 class CModel;
 class CSkinnedModel;
 class CPVSVisSet;
-class CAreaRenderOctTree;
+struct CAreaRenderOctTree;
 
 class IRenderer
 {

Runtime/Graphics/Shaders/CColoredQuadFilterHLSL.cpp

@@ -0,0 +1,87 @@
+#include "CColoredQuadFilter.hpp"
+#include "TMultiBlendShader.hpp"
+#include "Graphics/CTexture.hpp"
+
+namespace urde
+{
+
+static const char* VS =
+"struct VertData\n"
+"{\n"
+"    float4 posIn : POSITION;\n"
+"};\n"
+"\n"
+"cbuffer ColoredQuadUniform : register(b0)\n"
+"{\n"
+"    float4 color;\n"
+"};\n"
+"\n"
+"struct VertToFrag\n"
+"{\n"
+"    float4 position : SV_Position;\n"
+"    float4 color : COLOR;\n"
+"};\n"
+"\n"
+"VertToFrag main(in VertData v)\n"
+"{\n"
+"    VertToFrag vtf;\n"
+"    vtf.color = color;\n"
+"    vtf.position = float4(v.posIn.xyz, 1.0);\n"
+"    return vtf;\n"
+"}\n";
+
+static const char* FS =
+"struct VertToFrag\n"
+"{\n"
+"    float4 position : SV_Position;\n"
+"    float4 color : COLOR;\n"
+"};\n"
+"\n"
+"float4 main(in VertToFrag vtf) : SV_Target0\n"
+"{\n"
+"    return vtf.color;\n"
+"}\n";
+
+URDE_DECL_SPECIALIZE_MULTI_BLEND_SHADER(CColoredQuadFilter)
+
+struct CColoredQuadFilterD3DDataBindingFactory : TMultiBlendShader<CColoredQuadFilter>::IDataBindingFactory
+{
+    boo::IShaderDataBinding* BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx,
+                                                    boo::IShaderPipeline* pipeline,
+                                                    boo::IVertexFormat* vtxFmt,
+                                                    CColoredQuadFilter& filter)
+    {
+        boo::ID3DDataFactory::Context& cctx = static_cast<boo::ID3DDataFactory::Context&>(ctx);
+
+        boo::IGraphicsBuffer* bufs[] = {filter.m_uniBuf};
+        return cctx.newShaderDataBinding(pipeline, vtxFmt,
+                                         filter.m_vbo, nullptr, nullptr, 1, bufs,
+                                         nullptr, nullptr, nullptr, 0, nullptr);
+    }
+};
+
+TMultiBlendShader<CColoredQuadFilter>::IDataBindingFactory*
+CColoredQuadFilter::Initialize(boo::ID3DDataFactory::Context& ctx,
+                               boo::IShaderPipeline*& alphaPipeOut,
+                               boo::IShaderPipeline*& additivePipeOut,
+                               boo::IShaderPipeline*& colorMultiplyPipeOut,
+                               boo::IVertexFormat*& vtxFmtOut)
+{
+    const boo::VertexElementDescriptor VtxVmt[] =
+    {
+        {nullptr, nullptr, boo::VertexSemantic::Position4}
+    };
+    vtxFmtOut = ctx.newVertexFormat(1, VtxVmt);
+    alphaPipeOut = ctx.newShaderPipeline(VS, FS, ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(),
+                                         vtxFmtOut, boo::BlendFactor::SrcAlpha,
+                                         boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, false, false, false);
+    additivePipeOut = ctx.newShaderPipeline(VS, FS, ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(),
+                                            vtxFmtOut, boo::BlendFactor::SrcAlpha,
+                                            boo::BlendFactor::One, boo::Primitive::TriStrips, false, false, false);
+    colorMultiplyPipeOut = ctx.newShaderPipeline(VS, FS, ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(),
+                                                 vtxFmtOut, boo::BlendFactor::SrcColor,
+                                                 boo::BlendFactor::DstColor, boo::Primitive::TriStrips, false, false, false);
+    return new CColoredQuadFilterD3DDataBindingFactory;
+}
+
+}

Runtime/Graphics/Shaders/CSpaceWarpFilterHLSL.cpp

@@ -57,14 +57,16 @@ URDE_DECL_SPECIALIZE_SHADER(CSpaceWarpFilter)
 
 struct CSpaceWarpFilterD3DDataBindingFactory : TShader<CSpaceWarpFilter>::IDataBindingFactory
 {
-    boo::IShaderDataBinding* BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CSpaceWarpFilter& filter)
+    boo::IShaderDataBinding* BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx,
+                                                    boo::IShaderPipeline* pipeline,
+                                                    boo::IVertexFormat* vtxFmt,
+                                                    CSpaceWarpFilter& filter)
     {
         boo::ID3DDataFactory::Context& cctx = static_cast<boo::ID3DDataFactory::Context&>(ctx);
 
         boo::IGraphicsBuffer* bufs[] = {filter.m_uniBuf};
         boo::ITexture* texs[] = {CGraphics::g_SpareTexture, filter.m_warpTex};
-        return cctx.newShaderDataBinding(TShader<CSpaceWarpFilter>::m_pipeline,
+        return cctx.newShaderDataBinding(pipeline, vtxFmt,
-                                         TShader<CSpaceWarpFilter>::m_vtxFmt,
                                          filter.m_vbo, nullptr, nullptr, 1, bufs,
                                          nullptr, nullptr, nullptr, 2, texs);
     }

Runtime/Graphics/Shaders/CTexturedQuadFilterHLSL.cpp

@@ -0,0 +1,96 @@
+#include "CTexturedQuadFilter.hpp"
+#include "TMultiBlendShader.hpp"
+#include "Graphics/CTexture.hpp"
+
+namespace urde
+{
+
+static const char* VS =
+"struct VertData\n"
+"{\n"
+"    float4 posIn : POSITION;\n"
+"    float4 uvIn : UV;\n"
+"};\n"
+"\n"
+"cbuffer TexuredQuadUniform : register(b0)\n"
+"{\n"
+"    float4 color;\n"
+"};\n"
+"\n"
+"struct VertToFrag\n"
+"{\n"
+"    float4 position : SV_Position;\n"
+"    float4 color : COLOR;\n"
+"    float2 uv : UV;\n"
+"};\n"
+"\n"
+"VertToFrag main(in VertData v)\n"
+"{\n"
+"    VertToFrag vtf;\n"
+"    vtf.color = color;\n"
+"    vtf.uv = v.uvIn.xy;\n"
+"    vtf.position = float4(v.posIn.xyz, 1.0);\n"
+"    return vtf;\n"
+"}\n";
+
+static const char* FS =
+"struct VertToFrag\n"
+"{\n"
+"    float4 position : SV_Position;\n"
+"    float4 color : COLOR;\n"
+"    float2 uv : UV;\n"
+"};\n"
+"\n"
+"Texture2D tex : register(t0);\n"
+"SamplerState samp : register(s0);\n"
+"\n"
+"float4 main(in VertToFrag vtf) : SV_Target0\n"
+"{\n"
+"    return vtf.color * tex.Sample(samp, vtf.uv);\n"
+"}\n";
+
+URDE_DECL_SPECIALIZE_MULTI_BLEND_SHADER(CTexturedQuadFilter)
+
+struct CTexturedQuadFilterD3DDataBindingFactory : TMultiBlendShader<CTexturedQuadFilter>::IDataBindingFactory
+{
+    boo::IShaderDataBinding* BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx,
+                                                    boo::IShaderPipeline* pipeline,
+                                                    boo::IVertexFormat* vtxFmt,
+                                                    CTexturedQuadFilter& filter)
+    {
+        boo::ID3DDataFactory::Context& cctx = static_cast<boo::ID3DDataFactory::Context&>(ctx);
+
+        boo::IGraphicsBuffer* bufs[] = {filter.m_uniBuf};
+        boo::ITexture* texs[] = {filter.m_tex->GetBooTexture()};
+        return cctx.newShaderDataBinding(pipeline, vtxFmt,
+                                         filter.m_vbo, nullptr, nullptr, 1, bufs,
+                                         nullptr, nullptr, nullptr, 1, texs);
+    }
+};
+
+TMultiBlendShader<CTexturedQuadFilter>::IDataBindingFactory*
+CTexturedQuadFilter::Initialize(boo::ID3DDataFactory::Context& ctx,
+                                boo::IShaderPipeline*& alphaPipeOut,
+                                boo::IShaderPipeline*& additivePipeOut,
+                                boo::IShaderPipeline*& colorMultiplyPipeOut,
+                                boo::IVertexFormat*& vtxFmtOut)
+{
+    const boo::VertexElementDescriptor VtxVmt[] =
+    {
+        {nullptr, nullptr, boo::VertexSemantic::Position4},
+        {nullptr, nullptr, boo::VertexSemantic::UV4}
+    };
+    vtxFmtOut = ctx.newVertexFormat(2, VtxVmt);
+    alphaPipeOut = ctx.newShaderPipeline(VS, FS, ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(),
+                                         vtxFmtOut, boo::BlendFactor::SrcAlpha,
+                                         boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, false, false, false);
+    additivePipeOut = ctx.newShaderPipeline(VS, FS, ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(),
+                                            vtxFmtOut, boo::BlendFactor::SrcAlpha,
+                                            boo::BlendFactor::One, boo::Primitive::TriStrips, false, false, false);
+    colorMultiplyPipeOut = ctx.newShaderPipeline(VS, FS, ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(), ComPtr<ID3DBlob>(),
+                                                 vtxFmtOut, boo::BlendFactor::SrcColor,
+                                                 boo::BlendFactor::DstColor, boo::Primitive::TriStrips, false, false, false);
+    return new CTexturedQuadFilterD3DDataBindingFactory;
+}
+
+}

Runtime/Graphics/Shaders/CThermalColdFilterHLSL.cpp

@@ -79,14 +79,16 @@ URDE_DECL_SPECIALIZE_SHADER(CThermalColdFilter)
 
 struct CThermalColdFilterD3DDataBindingFactory : TShader<CThermalColdFilter>::IDataBindingFactory
 {
-    boo::IShaderDataBinding* BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CThermalColdFilter& filter)
+    boo::IShaderDataBinding* BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx,
+                                                    boo::IShaderPipeline* pipeline,
+                                                    boo::IVertexFormat* vtxFmt,
+                                                    CThermalColdFilter& filter)
     {
         boo::ID3DDataFactory::Context& cctx = static_cast<boo::ID3DDataFactory::Context&>(ctx);
 
         boo::IGraphicsBuffer* bufs[] = {filter.m_uniBuf};
         boo::ITexture* texs[] = {CGraphics::g_SpareTexture, filter.m_shiftTex};
-        return cctx.newShaderDataBinding(TShader<CThermalColdFilter>::m_pipeline,
+        return cctx.newShaderDataBinding(pipeline, vtxFmt,
-                                         TShader<CThermalColdFilter>::m_vtxFmt,
                                          filter.m_vbo, nullptr, nullptr, 1, bufs,
                                          nullptr, nullptr, nullptr, 2, texs);
     }

Runtime/Graphics/Shaders/CThermalHotFilterHLSL.cpp

@@ -56,14 +56,16 @@ URDE_DECL_SPECIALIZE_SHADER(CThermalHotFilter)
 
 struct CThermalHotFilterD3DDataBindingFactory : TShader<CThermalHotFilter>::IDataBindingFactory
 {
-    boo::IShaderDataBinding* BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx, CThermalHotFilter& filter)
+    boo::IShaderDataBinding* BuildShaderDataBinding(boo::IGraphicsDataFactory::Context& ctx,
+                                                    boo::IShaderPipeline* pipeline,
+                                                    boo::IVertexFormat* vtxFmt,
+                                                    CThermalHotFilter& filter)
     {
         boo::ID3DDataFactory::Context& cctx = static_cast<boo::ID3DDataFactory::Context&>(ctx);
 
         boo::IGraphicsBuffer* bufs[] = {filter.m_uniBuf};
         boo::ITexture* texs[] = {CGraphics::g_SpareTexture, g_Renderer->GetThermoPalette()};
-        return cctx.newShaderDataBinding(TShader<CThermalHotFilter>::m_pipeline,
+        return cctx.newShaderDataBinding(pipeline, vtxFmt,
-                                         TShader<CThermalHotFilter>::m_vtxFmt,
                                          filter.m_vbo, nullptr, nullptr, 1, bufs,
                                          nullptr, nullptr, nullptr, 2, texs);
     }

Runtime/World/CGameArea.cpp

@@ -1,6 +1,3 @@
-#if _WIN32
-#include <D3Dcommon.h>
-#endif
 #include "CGameArea.hpp"
 #include "GameGlobalObjects.hpp"
 #include "Graphics/CBooRenderer.hpp"

Runtime/World/CPlayer.cpp

@@ -2,6 +2,8 @@
 #include "CActorParameters.hpp"
 #include "CMorphBall.hpp"
 #include "CPlayerGun.hpp"
+#include "CStateManager.hpp"
+#include "Particle/CGenDescription.hpp"
 
 namespace urde
 {
@@ -21,6 +23,7 @@ CPlayer::CPlayer(TUniqueId uid, const zeus::CTransform& xf, const zeus::CAABox&
 
 bool CPlayer::IsTransparent() const
 {
+    return false;
 }
 
 void CPlayer::Update(float, CStateManager& mgr)
@@ -29,6 +32,7 @@ void CPlayer::Update(float, CStateManager& mgr)
 
 bool CPlayer::IsPlayerDeadEnough() const
 {
+    return false;
 }
 
 void CPlayer::AsyncLoadSuit(CStateManager& mgr)
@@ -42,24 +46,29 @@ void CPlayer::LoadAnimationTokens()
 
 bool CPlayer::CanRenderUnsorted(CStateManager& mgr) const
 {
+    return false;
 }
 
-const CDamageVulnerability& CPlayer::GetDamageVulnerability(const zeus::CVector3f& v1,
+const CDamageVulnerability* CPlayer::GetDamageVulnerability(const zeus::CVector3f& v1,
                                                             const zeus::CVector3f& v2,
                                                             const CDamageInfo& info) const
 {
+    return nullptr;
 }
 
-const CDamageVulnerability& CPlayer::GetDamageVulnerability() const
+const CDamageVulnerability* CPlayer::GetDamageVulnerability() const
 {
+    return nullptr;
 }
 
 zeus::CVector3f CPlayer::GetHomingPosition(CStateManager& mgr, float) const
 {
+    return {};
 }
 
 zeus::CVector3f CPlayer::GetAimPosition(CStateManager& mgr, float) const
 {
+    return {};
 }
 
 void CPlayer::FluidFXThink(CActor::EFluidState, CScriptWater& water, CStateManager& mgr)
@@ -68,18 +77,22 @@ void CPlayer::FluidFXThink(CActor::EFluidState, CScriptWater& water, CStateManag
 
 zeus::CVector3f CPlayer::GetDamageLocationWR() const
 {
+    return {};
 }
 
 float CPlayer::GetPrevDamageAmount() const
 {
+    return 0.f;
 }
 
 float CPlayer::GetDamageAmount() const
 {
+    return 0.f;
 }
 
 bool CPlayer::WasDamaged() const
 {
+    return false;
 }
 
 void CPlayer::TakeDamage(bool, const zeus::CVector3f&, float, EWeaponType, CStateManager& mgr)
@@ -90,16 +103,19 @@ void CPlayer::Accept(IVisitor& visitor)
 {
 }
 
-CHealthInfo& CPlayer::HealthInfo(CStateManager& mgr)
+CHealthInfo* CPlayer::HealthInfo(CStateManager& mgr)
 {
+    return nullptr;
 }
 
 bool CPlayer::IsUnderBetaMetroidAttack(CStateManager& mgr) const
 {
+    return false;
 }
 
 rstl::optional_object<zeus::CAABox> CPlayer::GetTouchBounds() const
 {
+    return {};
 }
 
 void CPlayer::Touch(CActor&, CStateManager& mgr)
@@ -120,10 +136,12 @@ void CPlayer::SetScanningState(EPlayerScanState, CStateManager& mgr)
 
 bool CPlayer::GetExplorationMode() const
 {
+    return false;
 }
 
 bool CPlayer::GetCombatMode() const
 {
+    return false;
 }
 
 void CPlayer::RenderGun(CStateManager& mgr, const zeus::CVector3f&) const
@@ -160,6 +178,7 @@ void CPlayer::UpdateFreeLook(float dt)
 
 float CPlayer::GetMaximumPlayerPositiveVerticalVelocity(CStateManager&) const
 {
+    return 0.f;
 }
 
 void CPlayer::ProcessInput(const CFinalInput&, CStateManager&)
@@ -168,6 +187,7 @@ void CPlayer::ProcessInput(const CFinalInput&, CStateManager&)
 
 bool CPlayer::GetFrozenState() const
 {
+    return false;
 }
 
 void CPlayer::Think(float, CStateManager&)
@@ -192,10 +212,12 @@ void CPlayer::UpdateFootstepBounds(const CFinalInput& input, CStateManager&, flo
 
 u16 CPlayer::GetMaterialSoundUnderPlayer(CStateManager& mgr, const u16*, int, u16)
 {
+    return 0;
 }
 
 u16 CPlayer::SfxIdFromMaterial(const CMaterialList&, const u16*, u16)
 {
+    return 0;
 }
 
 void CPlayer::UpdateCrosshairsState(const CFinalInput&)
@@ -220,6 +242,7 @@ void CPlayer::UpdateDebugCamera(CStateManager& mgr)
 
 CFirstPersonCamera& CPlayer::GetFirstPersonCamera(CStateManager& mgr)
 {
+    return *mgr.GetCameraManager()->GetFirstPersonCamera();
 }
 
 void CPlayer::UpdateGunTransform(const zeus::CVector3f&, float, CStateManager& mgr, bool)
@@ -236,6 +259,7 @@ void CPlayer::HolsterGun(CStateManager& mgr)
 
 bool CPlayer::GetMorphballTransitionState() const
 {
+    return false;
 }
 
 void CPlayer::UpdateGrappleArmTransform(const zeus::CVector3f&, CStateManager& mgr, float)
@@ -248,6 +272,7 @@ void CPlayer::ApplyGrappleForces(const CFinalInput& input, CStateManager& mgr, f
 
 bool CPlayer::ValidateFPPosition(const zeus::CVector3f& pos, CStateManager& mgr)
 {
+    return false;
 }
 
 void CPlayer::UpdateGrappleState(const CFinalInput& input, CStateManager& mgr)
@@ -280,6 +305,7 @@ void CPlayer::OrbitPoint(EPlayerOrbitType, CStateManager& mgr)
 
 zeus::CVector3f CPlayer::GetHUDOrbitTargetPosition() const
 {
+    return {};
 }
 
 void CPlayer::SetOrbitState(EPlayerOrbitState, CStateManager& mgr)
@@ -316,23 +342,28 @@ void CPlayer::UpdateAimTargetTimer(float)
 
 bool CPlayer::ValidateAimTargetId(TUniqueId, CStateManager& mgr)
 {
+    return false;
 }
 
 bool CPlayer::ValidateObjectForMode(TUniqueId, CStateManager& mgr) const
 {
+    return false;
 }
 
 TUniqueId CPlayer::FindAimTargetId(CStateManager& mgr)
 {
+    return {};
 }
 
 TUniqueId CPlayer::CheckEnemiesAgainstOrbitZone(const std::vector<TUniqueId>&, EPlayerZoneInfo,
                                                 EPlayerZoneType, CStateManager& mgr) const
 {
+    return {};
 }
 
 TUniqueId CPlayer::FindOrbitTargetId(CStateManager& mgr)
 {
+    return {};
 }
 
 void CPlayer::UpdateOrbitableObjects(CStateManager& mgr)
@@ -341,6 +372,7 @@ void CPlayer::UpdateOrbitableObjects(CStateManager& mgr)
 
 TUniqueId CPlayer::FindBestOrbitableObject(const std::vector<TUniqueId>&, EPlayerZoneInfo, CStateManager& mgr) const
 {
+    return {};
 }
 
 void CPlayer::FindOrbitableObjects(const std::vector<TUniqueId>&, std::vector<TUniqueId>&, EPlayerZoneInfo,
@@ -350,10 +382,12 @@ void CPlayer::FindOrbitableObjects(const std::vector<TUniqueId>&, std::vector<TU
 
 bool CPlayer::WithinOrbitScreenBox(const zeus::CVector3f&, EPlayerZoneInfo, EPlayerZoneType) const
 {
+    return false;
 }
 
 bool CPlayer::WithinOrbitScreenEllipse(const zeus::CVector3f&, EPlayerZoneInfo) const
 {
+    return false;
 }
 
 void CPlayer::CheckOrbitDisableSourceList(CStateManager& mgr)
@@ -402,42 +436,52 @@ void CPlayer::UpdateOrbitTarget(CStateManager& mgr)
 
 float CPlayer::GetOrbitMaxLockDistance(CStateManager& mgr) const
 {
+    return 0.f;
 }
 
 float CPlayer::GetOrbitMaxTargetDistance(CStateManager& mgr) const
 {
+    return 0.f;
 }
 
 bool CPlayer::ValidateOrbitTargetId(TUniqueId, CStateManager& mgr) const
 {
+    return false;
 }
 
 bool CPlayer::ValidateCurrentOrbitTargetId(CStateManager& mgr)
 {
+    return false;
 }
 
 bool CPlayer::ValidateOrbitTargetIdAndPointer(TUniqueId, CStateManager& mgr) const
 {
+    return false;
 }
 
 zeus::CVector3f CPlayer::GetBallPosition() const
 {
+    return {};
 }
 
 zeus::CVector3f CPlayer::GetEyePosition() const
 {
+    return {};
 }
 
 float CPlayer::GetEyeHeight() const
 {
+    return 0.f;
 }
 
 float CPlayer::GetStepUpHeight() const
 {
+    return 0.f;
 }
 
 float CPlayer::GetStepDownHeight() const
 {
+    return 0.f;
 }
 
 void CPlayer::Teleport(const zeus::CTransform& xf, CStateManager& mgr, bool)
@@ -446,22 +490,27 @@ void CPlayer::Teleport(const zeus::CTransform& xf, CStateManager& mgr, bool)
 
 zeus::CTransform CPlayer::CreateTransformFromMovementDirection() const
 {
+    return {};
 }
 
 const CCollisionPrimitive& CPlayer::GetCollisionPrimitive() const
 {
+    return *CPhysicsActor::GetCollisionPrimitive();
 }
 
 zeus::CTransform CPlayer::GetPrimitiveTransform() const
 {
+    return {};
 }
 
 bool CPlayer::CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager& mgr)
 {
+    return false;
 }
 
 float CPlayer::GetActualFirstPersonMaxVelocity() const
 {
+    return 0.f;
 }
 
 void CPlayer::SetMoveState(EPlayerMovementState, CStateManager& mgr)
@@ -470,18 +519,22 @@ void CPlayer::SetMoveState(EPlayerMovementState, CStateManager& mgr)
 
 float CPlayer::JumpInput(const CFinalInput& input, CStateManager& mgr)
 {
+    return 0.f;
 }
 
 float CPlayer::TurnInput(const CFinalInput& input) const
 {
+    return 0.f;
 }
 
 float CPlayer::StrafeInput(const CFinalInput& input) const
 {
+    return 0.f;
 }
 
 float CPlayer::ForwardInput(const CFinalInput& input, float) const
 {
+    return 0.f;
 }
 
 void CPlayer::ComputeMovement(const CFinalInput& input, CStateManager& mgr, float)
@@ -490,10 +543,12 @@ void CPlayer::ComputeMovement(const CFinalInput& input, CStateManager& mgr, floa
 
 float CPlayer::GetWeight() const
 {
+    return 0.f;
 }
 
 float CPlayer::GetDampedClampedVelocityWR() const
 {
+    return 0.f;
 }
 
 }

Runtime/World/CPlayer.hpp

@@ -85,10 +85,10 @@ public:
     void AsyncLoadSuit(CStateManager& mgr);
     void LoadAnimationTokens();
     bool CanRenderUnsorted(CStateManager& mgr) const;
-    const CDamageVulnerability& GetDamageVulnerability(const zeus::CVector3f& v1,
+    const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f& v1,
                                                        const zeus::CVector3f& v2,
                                                        const CDamageInfo& info) const;
-    const CDamageVulnerability& GetDamageVulnerability() const;
+    const CDamageVulnerability* GetDamageVulnerability() const;
     zeus::CVector3f GetHomingPosition(CStateManager& mgr, float) const;
     zeus::CVector3f GetAimPosition(CStateManager& mgr, float) const;
     void FluidFXThink(CActor::EFluidState, CScriptWater& water, CStateManager& mgr);
@@ -98,7 +98,7 @@ public:
     bool WasDamaged() const;
     void TakeDamage(bool, const zeus::CVector3f&, float, EWeaponType, CStateManager& mgr);
     void Accept(IVisitor& visitor);
-    CHealthInfo& HealthInfo(CStateManager& mgr);
+    CHealthInfo* HealthInfo(CStateManager& mgr);
     bool IsUnderBetaMetroidAttack(CStateManager& mgr) const;
     rstl::optional_object<zeus::CAABox> GetTouchBounds() const;
     void Touch(CActor&, CStateManager& mgr);

Runtime/World/CPlayerGun.cpp

@@ -1,4 +1,5 @@
 #include "CPlayerGun.hpp"
+#include "Particle/CGenDescription.hpp"
 #include "GameGlobalObjects.hpp"
 
 namespace urde

Runtime/World/CWorldTransManager.cpp

@@ -7,6 +7,8 @@
 #include "Character/CAssetFactory.hpp"
 #include "Character/CCharacterFactory.hpp"
 #include "Character/IAnimReader.hpp"
+#include "Character/CSkinRules.hpp"
+#include "Graphics/CModel.hpp"
 
 namespace urde
 {
@@ -150,7 +152,7 @@ void CWorldTransManager::DrawEnabled()
 
 void CWorldTransManager::DrawDisabled()
 {
-    m_fadeToBlack.draw(zeus::CColor{0.f, 0.f, 0.f, 0.01});
+    m_fadeToBlack.draw(zeus::CColor{0.f, 0.f, 0.f, 0.01f});
 }
 
 void CWorldTransManager::DrawText()

hecl

@@ -1 +1 @@
-Subproject commit effad6f44787daa620a7a3b4655c872dac7c1d4d
+Subproject commit 53ae402b2b130e6d0e1742d0a9d864223149c8ac