Graphics debug groups and bug fixes

2019-07-20 22:42:52 -10:00 · 2019-07-20 22:42:52 -10:00 · 5acf9ecbcf
parent b4fe474de3
commit 5acf9ecbcf
90 changed files with 217 additions and 27 deletions
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@ -17,6 +17,7 @@
    <mapping directory="$PROJECT_DIR$/hecl/extern/boo/lib/graphicsdev/nx/libdrm_nouveau" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/hecl/extern/boo/lib/graphicsdev/nx/mesa" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/hecl/extern/boo/logvisor" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/hecl/extern/boo/logvisor/fmt" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/hecl/extern/libSquish" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/hecl/extern/libjpeg-turbo" vcs="Git" />
    <mapping directory="$PROJECT_DIR$/jbus" vcs="Git" />
--- a/Runtime/AutoMapper/CAutoMapper.cpp
+++ b/Runtime/AutoMapper/CAutoMapper.cpp
@ -1293,6 +1293,7 @@ void CAutoMapper::Update(float dt, const CStateManager& mgr) {
 }

 void CAutoMapper::Draw(const CStateManager& mgr, const zeus::CTransform& xf, float alpha) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CAutoMapper::Draw", zeus::skPurple);
  alpha *= g_GameState->GameOptions().GetHUDAlpha() / 255.f;
  // Blend mode alpha
  // Backface cull
--- a/Runtime/AutoMapper/CMapUniverse.cpp
+++ b/Runtime/AutoMapper/CMapUniverse.cpp
@ -41,6 +41,7 @@ CMapUniverse::CMapWorldData::CMapWorldData(CInputStream& in, u32 version)
 void CMapUniverse::Draw(const CMapUniverseDrawParms& parms, const zeus::CVector3f&, float, float) const {
  if (!x4_hexagonToken.IsLoaded())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CMapUniverse::Draw", zeus::skBlue);

  u32 totalSurfaceCount = 0;
  for (const CMapWorldData& data : x10_worldDatas)
--- a/Runtime/AutoMapper/CMapWorld.cpp
+++ b/Runtime/AutoMapper/CMapWorld.cpp
@ -121,6 +121,7 @@ void CMapWorld::Draw(const CMapWorld::CMapWorldDrawParms& parms, int curArea, in
                     bool inMapScreen) const {
  if (depth1 == 0.f && depth2 == 0.f)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CMapWorld::Draw", zeus::skBlue);

  ClearTraversedFlags();
  int areaDepth = std::ceil(std::max(depth1, depth2));
--- a/Runtime/AutoMapper/CMappableObject.cpp
+++ b/Runtime/AutoMapper/CMappableObject.cpp
@ -105,6 +105,7 @@ std::pair<zeus::CColor, zeus::CColor> CMappableObject::GetDoorColors(int curArea
 void CMappableObject::PostConstruct(const void*) { x10_transform = AdjustTransformForType(); }

 void CMappableObject::Draw(int curArea, const CMapWorldInfo& mwInfo, float alpha, bool needsVtxLoad) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CMappableObject::Draw", zeus::skCyan);
  if (IsDoorType(x0_type)) {
    std::pair<zeus::CColor, zeus::CColor> colors = GetDoorColors(curArea, mwInfo, alpha);
    for (int s = 0; s < 6; ++s) {
--- a/Runtime/CStateManager.cpp
+++ b/Runtime/CStateManager.cpp
@ -638,6 +638,7 @@ void CStateManager::ResetViewAfterDraw(const SViewport& backupViewport,
 }

 void CStateManager::DrawWorld() const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CStateManager::DrawWorld", zeus::skBlue);
  CTimeProvider timeProvider(xf14_curTimeMod900);
  SViewport backupViewport = g_Viewport;

@ -894,6 +895,8 @@ void CStateManager::DrawActorCubeFaces(CActor& actor, int& cubeInst) const {
  }

  for (int f = 0; f < 6; ++f) {
+    SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CStateManager::DrawActorCubeFaces [{}] {} {} {}"),
+      f, actor.GetUniqueId(), actor.GetEditorId(), actor.GetName()).c_str(), zeus::skOrange);
    CGraphics::g_BooMainCommandQueue->setRenderTarget(actor.m_reflectionCube, f);
    SetupViewForCubeFaceDraw(actor.GetRenderBounds().center(), f);
    CGraphics::g_BooMainCommandQueue->clearTarget();
@ -1036,6 +1039,7 @@ bool CStateManager::SetupFogForDraw() const {

 void CStateManager::PreRender() {
  if (xf94_24_readyToRender) {
+    SCOPED_GRAPHICS_DEBUG_GROUP("CStateManager::PreRender", zeus::skBlue);
    zeus::CFrustum frustum = SetupDrawFrustum(g_Viewport);
    x86c_stateManagerContainer->xf370_.clear();
    x86c_stateManagerContainer->xf39c_renderLast.clear();
--- a/Runtime/Graphics/CBooRenderer.cpp
+++ b/Runtime/Graphics/CBooRenderer.cpp
@ -430,6 +430,7 @@ void CBooRenderer::SetupRendererStates() const {

 void CBooRenderer::ReallyRenderFogVolume(const zeus::CColor& color, const zeus::CAABox& aabb, const CModel* model,
                                         const CSkinnedModel* sModel) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::ReallyRenderFogVolume", zeus::skPurple);
  zeus::CMatrix4f proj = CGraphics::GetPerspectiveProjectionMatrix(false);
  zeus::CVector4f points[8];

@ -755,6 +756,7 @@ void CBooRenderer::RemoveStaticGeometry(const std::vector<CMetroidModelInstance>
 }

 void CBooRenderer::DrawAreaGeometry(int areaIdx, int mask, int targetMask) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DrawAreaGeometry", zeus::skPurple);
  x318_30_inAreaDraw = true;
  // SetupRendererStates();
  CModelFlags flags;
@ -789,6 +791,7 @@ void CBooRenderer::DrawAreaGeometry(int areaIdx, int mask, int targetMask) {
 }

 void CBooRenderer::DrawUnsortedGeometry(int areaIdx, int mask, int targetMask, bool shadowRender) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DrawUnsortedGeometry", zeus::skPurple);
  // SetupRendererStates();
  CModelFlags flags;
  flags.m_extendedShader = shadowRender ? EExtendedShader::SolidColor : EExtendedShader::Lighting;
@ -858,6 +861,7 @@ void CBooRenderer::DrawUnsortedGeometry(int areaIdx, int mask, int targetMask, b
 }

 void CBooRenderer::DrawSortedGeometry(int areaIdx, int mask, int targetMask) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DrawSortedGeometry", zeus::skPurple);
  // SetupRendererStates();

  CAreaListItem* lastOctreeItem = nullptr;
@ -1035,6 +1039,7 @@ void CBooRenderer::DrawString(const char*, int, int) {}
 u32 CBooRenderer::GetFPS() { return 0; }

 void CBooRenderer::CacheReflection(TReflectionCallback cb, void* ctx, bool clearAfter) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::CacheReflection", zeus::skPurple);
  if (!x318_24_refectionDirty)
    return;
  x318_24_refectionDirty = false;
@ -1052,11 +1057,13 @@ void CBooRenderer::CacheReflection(TReflectionCallback cb, void* ctx, bool clear
 }

 void CBooRenderer::DrawSpaceWarp(const zeus::CVector3f& pt, float strength) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DrawSpaceWarp", zeus::skPurple);
  m_spaceWarpFilter.setStrength(strength);
  m_spaceWarpFilter.draw(pt);
 }

 void CBooRenderer::DrawThermalModel(const CModel& model, const zeus::CColor& mulCol, const zeus::CColor& addCol) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DrawThermalModel", zeus::skPurple);
  CModelFlags flags;
  flags.m_extendedShader = EExtendedShader::Thermal;
  flags.x4_color = mulCol;
@ -1066,6 +1073,7 @@ void CBooRenderer::DrawThermalModel(const CModel& model, const zeus::CColor& mul
 }

 void CBooRenderer::DrawXRayOutline(const zeus::CAABox& aabb) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DrawXRayOutline", zeus::skPurple);
  CModelFlags flags;
  flags.m_extendedShader = EExtendedShader::ForcedAlpha;

@ -1117,6 +1125,7 @@ void CBooRenderer::SetThermal(bool thermal, float level, const zeus::CColor& col
 void CBooRenderer::SetThermalColdScale(float scale) { x2f8_thermColdScale = zeus::clamp(0.f, scale, 1.f); }

 void CBooRenderer::DoThermalBlendCold() {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DoThermalBlendCold", zeus::skMagenta);
  zeus::CColor a = zeus::CColor::lerp(x2f4_thermColor, zeus::skWhite, x2f8_thermColdScale);
  m_thermColdFilter->setColorA(a);
  float bAlpha = 1.f;
@ -1143,6 +1152,7 @@ void CBooRenderer::DoThermalBlendCold() {
 }

 void CBooRenderer::DoThermalBlendHot() {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DoThermalBlendHot", zeus::skMagenta);
  m_thermHotFilter->draw();
  m_thermalHotPass = false;
 }
@ -1175,22 +1185,26 @@ void CBooRenderer::SetWorldLightFadeLevel(float level) { x2fc_tevReg1Color = zeu
 void CBooRenderer::ReallyDrawPhazonSuitIndirectEffect(const zeus::CColor& vertColor, /*const CTexture& maskTex,*/
                                                      const CTexture& indTex, const zeus::CColor& modColor, float scale,
                                                      float offX, float offY) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::ReallyDrawPhazonSuitIndirectEffect", zeus::skMagenta);
  float qScale = scale / 8.f; // Adjustment for URDE
  m_phazonSuitFilter.draw(modColor, scale, offX * qScale, offY * qScale);
 }

 void CBooRenderer::ReallyDrawPhazonSuitEffect(const zeus::CColor& modColor /*, const CTexture& maskTex*/) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::ReallyDrawPhazonSuitEffect", zeus::skMagenta);
  m_phazonSuitFilter.draw(modColor, 0.f, 0.f, 0.f);
 }

 void CBooRenderer::DoPhazonSuitIndirectAlphaBlur(float blurRadius /*, float f2*/,
                                                 const TLockedToken<CTexture>& indTex) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DoPhazonSuitIndirectAlphaBlur", zeus::skMagenta);
  m_phazonSuitFilter.drawBlurPasses(blurRadius, indTex.IsLoaded() ? indTex.GetObj() : nullptr);
 }

 void CBooRenderer::DrawPhazonSuitIndirectEffect(const zeus::CColor& nonIndirectMod,
                                                const TLockedToken<CTexture>& indTex, const zeus::CColor& indirectMod,
                                                float blurRadius, float scale, float offX, float offY) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DrawPhazonSuitIndirectEffect", zeus::skPurple);
  /* Indirect background already in binding 0 */

  /* Resolve alpha channel of just-drawn phazon suit into binding 1 */
@ -1253,6 +1267,7 @@ void CBooRenderer::FindOverlappingWorldModels(std::vector<u32>& modelBits, const

 int CBooRenderer::DrawOverlappingWorldModelIDs(int alphaVal, const std::vector<u32>& modelBits,
                                               const zeus::CAABox& aabb) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DrawOverlappingWorldModelIDs", zeus::skGrey);
  SetupRendererStates();
  UpdateAreaUniforms(-1, EWorldShadowMode::BallOnWorldIds, false);

@ -1294,6 +1309,7 @@ int CBooRenderer::DrawOverlappingWorldModelIDs(int alphaVal, const std::vector<u

 void CBooRenderer::DrawOverlappingWorldModelShadows(int alphaVal, const std::vector<u32>& modelBits,
                                                    const zeus::CAABox& aabb, float alpha) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CBooRenderer::DrawOverlappingWorldModelShadows", zeus::skGrey);
  CModelFlags flags;
  flags.x4_color.a() = alpha;
  flags.m_extendedShader = EExtendedShader::MorphBallShadow; // Do shadow draw
--- a/Runtime/Graphics/CGraphics.hpp
+++ b/Runtime/Graphics/CGraphics.hpp
@ -344,4 +344,25 @@ public:
  void Draw() const { CGraphics::DrawArray(m_start, m_vec.size() - m_start); }
 };

+#ifdef BOO_GRAPHICS_DEBUG_GROUPS
+class GraphicsDebugGroup {
+  /* Stack only */
+  void* operator new(size_t);
+  void operator delete(void*);
+  void* operator new[](size_t);
+  void operator delete[](void*);
+public:
+  explicit GraphicsDebugGroup(const char* name, const zeus::CColor& color = zeus::skWhite) {
+    zeus::simd_floats f(color.mSimd);
+    CGraphics::g_BooMainCommandQueue->pushDebugGroup(name, f.array());
+  }
+  ~GraphicsDebugGroup() {
+    CGraphics::g_BooMainCommandQueue->popDebugGroup();
+  }
+};
+#define SCOPED_GRAPHICS_DEBUG_GROUP(...) GraphicsDebugGroup _GfxDbg_(__VA_ARGS__);
+#else
+#define SCOPED_GRAPHICS_DEBUG_GROUP(...)
+#endif
+
 } // namespace urde
--- a/Runtime/Graphics/CLineRenderer.cpp
+++ b/Runtime/Graphics/CLineRenderer.cpp
@ -238,6 +238,8 @@ void CLineRenderer::AddVertex(const zeus::CVector3f& position, const zeus::CColo
 }

 void CLineRenderer::Render(bool alphaWrite, const zeus::CColor& moduColor) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CLineRenderer::Render", zeus::skGrey);
+
  if (!m_final && m_nextVert > 1) {
    if (m_mode == EPrimitiveMode::LineLoop) {
      {
--- a/Runtime/Graphics/CMoviePlayer.cpp
+++ b/Runtime/Graphics/CMoviePlayer.cpp
@ -406,6 +406,7 @@ void CMoviePlayer::SetFrame(const zeus::CVector3f& a, const zeus::CVector3f& b,
 void CMoviePlayer::DrawFrame() {
  if (xd0_drawTexSlot == UINT32_MAX)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CMoviePlayer::DrawFrame", zeus::skYellow);

  /* draw appropriate field */
  CTHPTextureSet& tex = x80_textures[xd0_drawTexSlot];
--- a/Runtime/Graphics/CRainSplashGenerator.cpp
+++ b/Runtime/Graphics/CRainSplashGenerator.cpp
@ -44,6 +44,7 @@ void CRainSplashGenerator::SRainSplash::Draw(float alpha, float dt, const zeus::
 }

 void CRainSplashGenerator::DoDraw(const zeus::CTransform& xf) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CRainSplashGenerator::DoDraw", zeus::skYellow);
  CGraphics::SetModelMatrix(xf);
  if (x40_queueSize > 0) {
    if (x38_queueTail <= x3c_queueHead) {
--- a/Runtime/Graphics/CSimpleShadow.cpp
+++ b/Runtime/Graphics/CSimpleShadow.cpp
@ -29,6 +29,7 @@ zeus::CAABox CSimpleShadow::GetBounds() const {
 void CSimpleShadow::Render(const TLockedToken<CTexture>& tex) const {
  if (!x48_24_collision)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CSimpleShadow::Render", zeus::skGrey);

  CGraphics::DisableAllLights();
  CGraphics::SetModelMatrix(x0_xf);
--- a/Runtime/Graphics/Shaders/CAABoxShader.cpp
+++ b/Runtime/Graphics/Shaders/CAABoxShader.cpp
@ -60,6 +60,8 @@ void CAABoxShader::setAABB(const zeus::CAABox& aabb) {
 }

 void CAABoxShader::draw(const zeus::CColor& color) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CAABoxShader::draw", zeus::skMagenta);
+
  m_uniform.m_xf = CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f();
  m_uniform.m_color = color;
  m_uniBuf->load(&m_uniform, sizeof(Uniform));
--- a/Runtime/Graphics/Shaders/CCameraBlurFilter.cpp
+++ b/Runtime/Graphics/Shaders/CCameraBlurFilter.cpp
@ -26,6 +26,7 @@ CCameraBlurFilter::CCameraBlurFilter() {
 void CCameraBlurFilter::draw(float amount, bool clearDepth) {
  if (amount <= 0.f)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CCameraBlurFilter::draw", zeus::skMagenta);

  SClipScreenRect clipRect(g_Viewport);
  CGraphics::ResolveSpareTexture(clipRect, 0, clearDepth);
--- a/Runtime/Graphics/Shaders/CColoredQuadFilter.cpp
+++ b/Runtime/Graphics/Shaders/CColoredQuadFilter.cpp
@ -54,6 +54,8 @@ CColoredQuadFilter::CColoredQuadFilter(EFilterType type) {
 }

 void CColoredQuadFilter::draw(const zeus::CColor& color, const zeus::CRectangle& rect) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CColoredQuadFilter::draw", zeus::skMagenta);
+
  m_uniform.m_matrix[0][0] = rect.size.x() * 2.f;
  m_uniform.m_matrix[1][1] = rect.size.y() * 2.f;
  m_uniform.m_matrix[3][0] = rect.position.x() * 2.f - 1.f;
--- a/Runtime/Graphics/Shaders/CColoredStripShader.cpp
+++ b/Runtime/Graphics/Shaders/CColoredStripShader.cpp
@ -67,6 +67,8 @@ CColoredStripShader::CColoredStripShader(boo::IGraphicsDataFactory::Context& ctx
 }

 void CColoredStripShader::draw(const zeus::CColor& color, size_t numVerts, const Vert* verts) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CColoredStripShader::draw", zeus::skMagenta);
+
  m_vbo->load(verts, sizeof(Vert) * numVerts);

  m_uniform.m_matrix = CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f();
--- a/Runtime/Graphics/Shaders/CEnergyBarShader.cpp
+++ b/Runtime/Graphics/Shaders/CEnergyBarShader.cpp
@ -18,6 +18,8 @@ void CEnergyBarShader::updateModelMatrix() {
 void CEnergyBarShader::draw(const zeus::CColor& color0, const std::vector<Vertex>& verts0, const zeus::CColor& color1,
                            const std::vector<Vertex>& verts1, const zeus::CColor& color2,
                            const std::vector<Vertex>& verts2, const CTexture* tex) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CEnergyBarShader::draw", zeus::skMagenta);
+
  size_t totalVerts = verts0.size() + verts1.size() + verts2.size();
  if (!totalVerts)
    return;
--- a/Runtime/Graphics/Shaders/CFogVolumeFilter.cpp
+++ b/Runtime/Graphics/Shaders/CFogVolumeFilter.cpp
@ -47,12 +47,16 @@ CFogVolumeFilter::CFogVolumeFilter() {
 }

 void CFogVolumeFilter::draw2WayPass(const zeus::CColor& color) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CFogVolumeFilter::draw2WayPass", zeus::skMagenta);
+
  m_uniBuf->load(&color, sizeof(zeus::CColor));
  CGraphics::SetShaderDataBinding(m_dataBind2Way);
  CGraphics::DrawArray(0, 4);
 }

 void CFogVolumeFilter::draw1WayPass(const zeus::CColor& color) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CFogVolumeFilter::draw1WayPass", zeus::skMagenta);
+
  m_uniBuf->load(&color, sizeof(zeus::CColor));
  CGraphics::SetShaderDataBinding(m_dataBind1Way);
  CGraphics::DrawArray(0, 4);
--- a/Runtime/Graphics/Shaders/CFogVolumePlaneShader.cpp
+++ b/Runtime/Graphics/Shaders/CFogVolumePlaneShader.cpp
@ -49,6 +49,7 @@ void CFogVolumePlaneShader::addFan(const zeus::CVector3f* verts, int numVerts) {
 void CFogVolumePlaneShader::draw(int pass) {
  if (m_verts.empty())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CFogVolumePlaneShader::draw", zeus::skMagenta);
  if (pass == 0) {
    if (m_vertCapacity < m_verts.size())
      CommitResources(m_verts.size());
--- a/Runtime/Graphics/Shaders/CMapSurfaceShader.cpp
+++ b/Runtime/Graphics/Shaders/CMapSurfaceShader.cpp
@ -22,6 +22,7 @@ CMapSurfaceShader::CMapSurfaceShader(boo::IGraphicsDataFactory::Context& ctx,
 }

 void CMapSurfaceShader::draw(const zeus::CColor& color, u32 start, u32 count) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CMapSurfaceShader::draw", zeus::skMagenta);
  Uniform uniform = {CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f(), color};
  m_uniBuf->load(&uniform, sizeof(Uniform));
  CGraphics::SetShaderDataBinding(m_dataBind);
--- a/Runtime/Graphics/Shaders/CPhazonSuitFilter.cpp
+++ b/Runtime/Graphics/Shaders/CPhazonSuitFilter.cpp
@ -24,6 +24,7 @@ void CPhazonSuitFilter::Shutdown() {
 #define BLUR_SCALE (1.f / 128.f)

 void CPhazonSuitFilter::drawBlurPasses(float radius, const CTexture* indTex) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CPhazonSuitFilter::drawBlurPasses", zeus::skMagenta);
  if (!m_dataBind || indTex != m_indTex) {
    m_indTex = indTex;
    CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
@ -120,6 +121,7 @@ void CPhazonSuitFilter::drawBlurPasses(float radius, const CTexture* indTex) {
 }

 void CPhazonSuitFilter::draw(const zeus::CColor& color, float indScale, float indOffX, float indOffY) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CPhazonSuitFilter::draw", zeus::skMagenta);
  struct Uniform {
    zeus::CColor color;
    zeus::CVector4f indScaleOff;
--- a/Runtime/Graphics/Shaders/CRadarPaintShader.cpp
+++ b/Runtime/Graphics/Shaders/CRadarPaintShader.cpp
@ -14,6 +14,7 @@ void CRadarPaintShader::Shutdown() { s_Pipeline.reset(); }
 void CRadarPaintShader::draw(const std::vector<Instance>& instances, const CTexture* tex) {
  if (!instances.size())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CRadarPaintShader::draw", zeus::skMagenta);

  if (instances.size() > m_maxInsts) {
    m_maxInsts = instances.size();
--- a/Runtime/Graphics/Shaders/CRandomStaticFilter.cpp
+++ b/Runtime/Graphics/Shaders/CRandomStaticFilter.cpp
@ -62,6 +62,8 @@ CRandomStaticFilter::CRandomStaticFilter(EFilterType type, bool cookieCutter) :
 }

 void CRandomStaticFilter::draw(const zeus::CColor& color, float t) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CRandomStaticFilter::draw", zeus::skMagenta);
+
  m_uniform.color = color;
  m_uniform.randOff = ROUND_UP_32(int64_t(rand()) * 32767 / RAND_MAX);
  m_uniform.discardThres = 1.f - t;
--- a/Runtime/Graphics/Shaders/CScanLinesFilter.cpp
+++ b/Runtime/Graphics/Shaders/CScanLinesFilter.cpp
@ -49,6 +49,8 @@ CScanLinesFilter::CScanLinesFilter(EFilterType type, bool even) : m_even(even) {
 }

 void CScanLinesFilter::draw(const zeus::CColor& color) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CScanLinesFilter::draw", zeus::skMagenta);
+
  m_uniform.color = color;
  m_uniBuf->load(&m_uniform, sizeof(Uniform));

--- a/Runtime/Graphics/Shaders/CSpaceWarpFilter.cpp
+++ b/Runtime/Graphics/Shaders/CSpaceWarpFilter.cpp
@ -59,6 +59,8 @@ CSpaceWarpFilter::CSpaceWarpFilter() {
 }

 void CSpaceWarpFilter::draw(const zeus::CVector3f& pt) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CSpaceWarpFilter::draw", zeus::skMagenta);
+
  /* Indirect coords are full-texture sampling when warp is completely in viewport */
  m_uniform.m_indXf[1][1] = 1.f;
  m_uniform.m_indXf[0][0] = 1.f;
--- a/Runtime/Graphics/Shaders/CTexturedQuadFilter.cpp
+++ b/Runtime/Graphics/Shaders/CTexturedQuadFilter.cpp
@ -200,6 +200,8 @@ CTexturedQuadFilter::CTexturedQuadFilter(EFilterType type, TLockedToken<CTexture
 }

 void CTexturedQuadFilter::draw(const zeus::CColor& color, float uvScale, const zeus::CRectangle& rect, float z) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CTexturedQuadFilter::draw", zeus::skMagenta);
+
  Vert verts[4] = {
      {{0.f, 0.f, z}, {0.f, 0.f}},
      {{0.f, 1.f, z}, {0.f, uvScale}},
@ -227,6 +229,8 @@ void CTexturedQuadFilter::draw(const zeus::CColor& color, float uvScale, const z
 }

 void CTexturedQuadFilter::drawCropped(const zeus::CColor& color, float uvScale) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CTexturedQuadFilter::drawCropped", zeus::skMagenta);
+
  float xFac = CGraphics::g_CroppedViewport.xc_width / float(g_Viewport.x8_width);
  float yFac = CGraphics::g_CroppedViewport.x10_height / float(g_Viewport.xc_height);
  float xBias = CGraphics::g_CroppedViewport.x4_left / float(g_Viewport.x8_width);
@ -248,6 +252,8 @@ void CTexturedQuadFilter::drawCropped(const zeus::CColor& color, float uvScale)
 }

 void CTexturedQuadFilter::drawVerts(const zeus::CColor& color, const Vert verts[4], float lod) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CTexturedQuadFilter::drawVerts", zeus::skMagenta);
+
  m_vbo->load(verts, sizeof(Vert) * 4);

  m_uniform.m_matrix = CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f();
@ -260,6 +266,8 @@ void CTexturedQuadFilter::drawVerts(const zeus::CColor& color, const Vert verts[
 }

 void CTexturedQuadFilter::DrawFilter(EFilterShape shape, const zeus::CColor& color, float t) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CTexturedQuadFilter::DrawFilter", zeus::skMagenta);
+
  m_uniform.m_matrix = zeus::CMatrix4f();
  m_uniform.m_lod = 0.f;
  m_uniform.m_color = color;
--- a/Runtime/Graphics/Shaders/CThermalColdFilter.cpp
+++ b/Runtime/Graphics/Shaders/CThermalColdFilter.cpp
@ -40,6 +40,8 @@ CThermalColdFilter::CThermalColdFilter() {
 }

 void CThermalColdFilter::draw() {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CThermalColdFilter::draw", zeus::skMagenta);
+
  CGraphics::ResolveSpareTexture(CGraphics::g_CroppedViewport);
  m_uniBuf->load(&m_uniform, sizeof(m_uniform));
  CGraphics::SetShaderDataBinding(m_dataBind);
--- a/Runtime/Graphics/Shaders/CThermalHotFilter.cpp
+++ b/Runtime/Graphics/Shaders/CThermalHotFilter.cpp
@ -35,6 +35,8 @@ CThermalHotFilter::CThermalHotFilter() {
 }

 void CThermalHotFilter::draw() {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CThermalHotFilter::draw", zeus::skMagenta);
+
  CGraphics::ResolveSpareTexture(CGraphics::g_CroppedViewport);

  // m_uniBuf->load(&m_uniform, sizeof(m_uniform));
--- a/Runtime/Graphics/Shaders/CWorldShadowShader.cpp
+++ b/Runtime/Graphics/Shaders/CWorldShadowShader.cpp
@ -35,6 +35,8 @@ CWorldShadowShader::CWorldShadowShader(u32 w, u32 h) : m_w(w), m_h(h) {
 void CWorldShadowShader::bindRenderTarget() { CGraphics::g_BooMainCommandQueue->setRenderTarget(m_tex); }

 void CWorldShadowShader::drawBase(float extent) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CWorldShadowShader::drawBase", zeus::skMagenta);
+
  zeus::CVector3f verts[] = {
      {-extent, 0.f, extent}, {extent, 0.f, extent}, {-extent, 0.f, -extent}, {extent, 0.f, -extent}};
  m_vbo->load(verts, sizeof(zeus::CVector3f) * 4);
@ -48,6 +50,8 @@ void CWorldShadowShader::drawBase(float extent) {
 }

 void CWorldShadowShader::lightenShadow() {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CWorldShadowShader::lightenShadow", zeus::skMagenta);
+
  m_uniform.m_color = zeus::CColor(1.f, 0.25f);
  m_uniBuf->load(&m_uniform, sizeof(m_uniform));

@ -56,6 +60,8 @@ void CWorldShadowShader::lightenShadow() {
 }

 void CWorldShadowShader::blendPreviousShadow() {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CWorldShadowShader::blendPreviousShadow", zeus::skMagenta);
+
  if (!m_prevQuad)
    m_prevQuad.emplace(EFilterType::Blend, m_tex.get());
  zeus::CRectangle rect(0.f, 1.f, 1.f, -1.f);
--- a/Runtime/Graphics/Shaders/CXRayBlurFilter.cpp
+++ b/Runtime/Graphics/Shaders/CXRayBlurFilter.cpp
@ -35,6 +35,8 @@ CXRayBlurFilter::CXRayBlurFilter(TLockedToken<CTexture>& tex) : m_paletteTex(tex
 }

 void CXRayBlurFilter::draw(float amount) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CXRayBlurFilter::draw", zeus::skMagenta);
+
  CGraphics::ResolveSpareTexture(CGraphics::g_CroppedViewport);

  float blurL = amount * g_tweakGui->GetXrayBlurScaleLinear() * 0.25f;
--- a/Runtime/GuiSys/CAuiEnergyBarT01.cpp
+++ b/Runtime/GuiSys/CAuiEnergyBarT01.cpp
@ -55,6 +55,7 @@ void CAuiEnergyBarT01::Update(float dt) {
 void CAuiEnergyBarT01::Draw(const CGuiWidgetDrawParms& drawParms) const {
  if (!xbc_tex || !xbc_tex.IsLoaded() || !xd8_coordFunc)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CAuiEnergyBarT01::Draw {}"), m_name).c_str(), zeus::skCyan);

  CGraphics::SetModelMatrix(x34_worldXF);
  const_cast<CEnergyBarShader&>(m_energyBarShader).updateModelMatrix();
--- a/Runtime/GuiSys/CAuiImagePane.cpp
+++ b/Runtime/GuiSys/CAuiImagePane.cpp
@ -101,6 +101,7 @@ void CAuiImagePane::Draw(const CGuiWidgetDrawParms& params) const {
  CGraphics::SetModelMatrix(x34_worldXF);
  if (!GetIsVisible() || !xb8_tex0Tok.IsLoaded())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CAuiImagePane::Draw {}"), m_name).c_str(), zeus::skCyan);
  GetIsFinishedLoadingWidgetSpecific();
  if (!m_filters || m_filters->m_texId != xb8_tex0Tok.GetObjectTag()->id)
    const_cast<CAuiImagePane*>(this)->m_filters.emplace(const_cast<CAuiImagePane*>(this)->xb8_tex0Tok);
--- a/Runtime/GuiSys/CCompoundTargetReticle.cpp
+++ b/Runtime/GuiSys/CCompoundTargetReticle.cpp
@ -412,6 +412,7 @@ void CCompoundTargetReticle::UpdateOrbitZoneGroup(float dt, const CStateManager&
 void CCompoundTargetReticle::Draw(const CStateManager& mgr, bool hideLockon) const {
  if (mgr.GetPlayer().GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed &&
      !mgr.GetCameraManager()->IsInCinematicCamera()) {
+    SCOPED_GRAPHICS_DEBUG_GROUP("CCompoundTargetReticle::Draw", zeus::skCyan);
    zeus::CTransform camXf = mgr.GetCameraManager()->GetCurrentCameraTransform(mgr);
    CGraphics::SetViewPointMatrix(camXf);
    if (!hideLockon) {
--- a/Runtime/GuiSys/CConsoleOutputWindow.cpp
+++ b/Runtime/GuiSys/CConsoleOutputWindow.cpp
@ -9,6 +9,8 @@ CIOWin::EMessageReturn CConsoleOutputWindow::OnMessage(const CArchitectureMessag
  return EMessageReturn::Normal;
 }

-void CConsoleOutputWindow::Draw() const {}
+void CConsoleOutputWindow::Draw() const {
+  //SCOPED_GRAPHICS_DEBUG_GROUP("CConsoleOutputWindow::Draw", zeus::skGreen);
+}

 } // namespace urde
--- a/Runtime/GuiSys/CErrorOutputWindow.cpp
+++ b/Runtime/GuiSys/CErrorOutputWindow.cpp
@ -1,4 +1,5 @@
 #include "CErrorOutputWindow.hpp"
+#include "Graphics/CGraphics.hpp"

 namespace urde {

@ -13,6 +14,8 @@ CIOWin::EMessageReturn CErrorOutputWindow::OnMessage(const CArchitectureMessage&
  return EMessageReturn::Normal;
 }

-void CErrorOutputWindow::Draw() const {}
+void CErrorOutputWindow::Draw() const {
+  //SCOPED_GRAPHICS_DEBUG_GROUP("CErrorOutputWindow::Draw", zeus::skGreen);
+}

 } // namespace urde
--- a/Runtime/GuiSys/CGuiFrame.cpp
+++ b/Runtime/GuiSys/CGuiFrame.cpp
@ -20,7 +20,7 @@ CGuiFrame::CGuiFrame(CAssetId id, CGuiSys& sys, int a, int b, int c, CSimplePool
  m_indexedLights.reserve(8);
  x10_rootWidget.reset(new CGuiWidget(CGuiWidget::CGuiWidgetParms(
      this, false, 0, 0, false, false, false, zeus::skWhite, CGuiWidget::EGuiModelDrawFlags::Alpha, false,
-      x8_guiSys.x8_mode != CGuiSys::EUsageMode::Zero)));
+      x8_guiSys.x8_mode != CGuiSys::EUsageMode::Zero, "<root>"s)));
  x8_guiSys.m_registeredFrames.insert(this);
 }

@ -131,6 +131,7 @@ void CGuiFrame::Reset() {
 void CGuiFrame::Update(float dt) { xc_headWidget->Update(dt); }

 void CGuiFrame::Draw(const CGuiWidgetDrawParms& parms) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CGuiFrame::Draw FRME_{}"), x0_id).c_str(), zeus::skMagenta);
  CGraphics::SetCullMode(ERglCullMode::None);
  CGraphics::SetAmbientColor(zeus::skWhite);
  DisableLights();
--- a/Runtime/GuiSys/CGuiModel.cpp
+++ b/Runtime/GuiSys/CGuiModel.cpp
@ -41,6 +41,7 @@ void CGuiModel::Draw(const CGuiWidgetDrawParms& parms) const {
    return;

  if (GetIsVisible()) {
+    SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CGuiModel::Draw {}"), m_name).c_str(), zeus::skCyan);
    zeus::CColor moduCol = xa8_color2;
    moduCol.a() *= parms.x0_alphaMod;
    xb0_frame->EnableLights(xcc_lightMask, const_cast<CBooModel&>(model->GetInstance()));
--- a/Runtime/GuiSys/CGuiTextPane.cpp
+++ b/Runtime/GuiSys/CGuiTextPane.cpp
@ -34,6 +34,7 @@ void CGuiTextPane::ScaleDimensions(const zeus::CVector3f& scale) {}
 void CGuiTextPane::Draw(const CGuiWidgetDrawParms& parms) const {
  if (!GetIsVisible())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CGuiTextPane::Draw {}"), m_name).c_str(), zeus::skCyan);

  zeus::CVector2f dims = GetDimensions();

--- a/Runtime/GuiSys/CGuiTextSupport.cpp
+++ b/Runtime/GuiSys/CGuiTextSupport.cpp
@ -188,6 +188,7 @@ void CGuiTextSupport::AutoSetExtent() {
 void CGuiTextSupport::Render() const {
  const_cast<CGuiTextSupport*>(this)->CheckAndRebuildRenderBuffer();
  if (CTextRenderBuffer* buf = GetCurrentPageRenderBuffer()) {
+    SCOPED_GRAPHICS_DEBUG_GROUP("CGuiTextSupport::Draw", zeus::skBlue);
    zeus::CTransform oldModel = CGraphics::g_GXModelMatrix;
    CGraphics::SetModelMatrix(oldModel * zeus::CTransform::Scale(1.f, 1.f, -1.f));
    buf->Render(x2c_geometryColor, x10_curTimeMod900);
--- a/Runtime/GuiSys/CGuiWidget.cpp
+++ b/Runtime/GuiSys/CGuiWidget.cpp
@ -11,7 +11,8 @@ CGuiWidget::CGuiWidget(const CGuiWidgetParms& parms)
 , xa4_color(parms.x10_color)
 , xa8_color2(parms.x10_color)
 , xac_drawFlags(parms.x14_drawFlags)
-, xb0_frame(parms.x0_frame) {
+, xb0_frame(parms.x0_frame)
+, m_name(parms.m_name) {
  xb6_24_pg = parms.xd_g;
  xb6_25_isVisible = parms.xa_defaultVisible;
  xb6_26_isActive = parms.xb_defaultActive;
@ -41,7 +42,7 @@ CGuiWidget::CGuiWidgetParms CGuiWidget::ReadWidgetHeader(CGuiFrame* frame, CInpu
  EGuiModelDrawFlags df = EGuiModelDrawFlags(in.readUint32Big());

  return CGuiWidget::CGuiWidgetParms(frame, useAnimController, selfId, parentId, defaultVis, defaultActive, cullFaces,
-                                     color, df, true, false);
+                                     color, df, true, false, std::move(name));
 }

 std::shared_ptr<CGuiWidget> CGuiWidget::Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp) {
--- a/Runtime/GuiSys/CGuiWidget.hpp
+++ b/Runtime/GuiSys/CGuiWidget.hpp
@ -34,9 +34,10 @@ public:
    bool xe_h;
    zeus::CColor x10_color;
    EGuiModelDrawFlags x14_drawFlags;
+    std::string m_name;
    CGuiWidgetParms(CGuiFrame* frame, bool useAnimController, s16 selfId, s16 parentId, bool defaultVisible,
                    bool defaultActive, bool cullFaces, const zeus::CColor& color, EGuiModelDrawFlags drawFlags, bool g,
-                    bool h)
+                    bool h, std::string&& name)
    : x0_frame(frame)
    , x4_useAnimController(useAnimController)
    , x6_selfId(selfId)
@ -47,7 +48,8 @@ public:
    , xd_g(g)
    , xe_h(h)
    , x10_color(color)
-    , x14_drawFlags(drawFlags) {}
+    , x14_drawFlags(drawFlags)
+    , m_name(std::move(name)) {}
  };

 protected:
@ -76,6 +78,8 @@ protected:
  std::optional<boo::SScrollDelta> m_lastScroll;
  boo::SScrollDelta m_integerScroll;

+  std::string m_name;
+
 public:
  CGuiWidget(const CGuiWidgetParms& parms);

--- a/Runtime/GuiSys/COrbitPointMarker.cpp
+++ b/Runtime/GuiSys/COrbitPointMarker.cpp
@ -67,6 +67,7 @@ void COrbitPointMarker::Update(float dt, const CStateManager& mgr) {
 void COrbitPointMarker::Draw(const CStateManager& mgr) const {
  if ((x1c_lastFreeOrbit || x20_interpTimer > 0.f) && g_tweakTargeting->DrawOrbitPoint() &&
      x28_orbitPointModel.IsLoaded()) {
+    SCOPED_GRAPHICS_DEBUG_GROUP("COrbitPointMarker::Draw", zeus::skCyan);
    const CGameCamera* curCam = mgr.GetCameraManager()->GetCurrentCamera(mgr);
    zeus::CTransform camXf = mgr.GetCameraManager()->GetCurrentCameraTransform(mgr);
    CGraphics::SetViewPointMatrix(camXf);
--- a/Runtime/GuiSys/CSplashScreen.cpp
+++ b/Runtime/GuiSys/CSplashScreen.cpp
@ -49,6 +49,7 @@ CIOWin::EMessageReturn CSplashScreen::OnMessage(const CArchitectureMessage& msg,
 void CSplashScreen::Draw() const {
  if (!x25_textureLoaded)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CSplashScreen::Draw", zeus::skGreen);

  zeus::CColor color;
  if (x14_which == ESplashScreen::Nintendo)
--- a/Runtime/MP1/CArtifactDoll.cpp
+++ b/Runtime/MP1/CArtifactDoll.cpp
@ -77,6 +77,7 @@ void CArtifactDoll::CompleteArtifactHeadScan(const CStateManager& mgr) { UpdateA
 void CArtifactDoll::Draw(float alpha, const CStateManager& mgr, bool inArtifactCategory, int selectedArtifact) {
  if (!IsLoaded())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CArtifactDoll::Draw", zeus::skPurple);

  alpha *= x24_fader;
  g_Renderer->SetPerspective(55.f, g_Viewport.x8_width, g_Viewport.xc_height, 0.2f, 4096.f);
--- a/Runtime/MP1/CCredits.cpp
+++ b/Runtime/MP1/CCredits.cpp
@ -1,4 +1,5 @@
 #include "CCredits.hpp"
+#include "Graphics/CGraphics.hpp"

 namespace urde::MP1 {

@ -8,6 +9,8 @@ CIOWin::EMessageReturn CCredits::OnMessage(const CArchitectureMessage& msg, CArc
  return EMessageReturn::Normal;
 }

-void CCredits::Draw() const {}
+void CCredits::Draw() const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CCredits::Draw", zeus::skGreen);
+}

 } // namespace urde::MP1
--- a/Runtime/MP1/CFaceplateDecoration.cpp
+++ b/Runtime/MP1/CFaceplateDecoration.cpp
@ -35,6 +35,7 @@ void CFaceplateDecoration::Update(float dt, CStateManager& stateMgr) {

 void CFaceplateDecoration::Draw(CStateManager& stateMgr) {
  if (xc_ready && m_texFilter) {
+    SCOPED_GRAPHICS_DEBUG_GROUP("CFaceplateDecoration::Draw", zeus::skPurple);
    zeus::CColor color = zeus::skWhite;
    color.a() = stateMgr.GetPlayer().GetVisorSteam().GetAlpha();
    m_texFilter->DrawFilter(EFilterShape::FullscreenQuarters, color, 1.f);
--- a/Runtime/MP1/CFrontEndUI.cpp
+++ b/Runtime/MP1/CFrontEndUI.cpp
@ -1884,6 +1884,7 @@ void CFrontEndUI::HandleDebugMenuReturnValue(CGameDebug::EReturnValue val, CArch
 void CFrontEndUI::Draw() const {
  if (x14_phase < EPhase::DisplayFrontEnd)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CFrontEndUI::Draw", zeus::skGreen);

  if (xec_emuFrme) {
    xec_emuFrme->Draw(xdc_saveUI.get());
--- a/Runtime/MP1/CGameCubeDoll.cpp
+++ b/Runtime/MP1/CGameCubeDoll.cpp
@ -29,6 +29,7 @@ void CGameCubeDoll::Update(float dt) {
 void CGameCubeDoll::Draw(float alpha) {
  if (!IsLoaded())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CGameCubeDoll::Draw", zeus::skPurple);

  g_Renderer->SetPerspective(55.f, g_Viewport.x8_width, g_Viewport.xc_height, 0.2f, 4096.f);
  CGraphics::SetViewPointMatrix(zeus::CTransform::Translate(0.f, -2.f, 0.f));
--- a/Runtime/MP1/CInGameGuiManager.cpp
+++ b/Runtime/MP1/CInGameGuiManager.cpp
@ -461,6 +461,7 @@ void CInGameGuiManager::PreDraw(CStateManager& stateMgr, bool cameraActive) {
 }

 void CInGameGuiManager::Draw(CStateManager& stateMgr) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CInGameGuiManager::Draw", zeus::skBlue);
  // if (!GetIsGameDraw())
  //    g_Renderer->x318_26_requestRGBA6 = true;
  if (x1d8_onScreenTexAlpha > 0.f && x1dc_onScreenTexTok.IsLoaded()) {
--- a/Runtime/MP1/CInventoryScreen.cpp
+++ b/Runtime/MP1/CInventoryScreen.cpp
@ -240,6 +240,7 @@ void CInventoryScreen::ProcessControllerInput(const CFinalInput& input) {
 }

 void CInventoryScreen::Draw(float transInterp, float totalAlpha, float yOff) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CInventoryScreen::Draw", zeus::skPurple);
  CPauseScreenBase::Draw(transInterp, totalAlpha, std::fabs(x19c_samusDoll->GetViewInterpolation()));
  x19c_samusDoll->Draw(x4_mgr, transInterp * (1.f - x1a4_textBodyAlpha));
 }
--- a/Runtime/MP1/CLogBookScreen.cpp
+++ b/Runtime/MP1/CLogBookScreen.cpp
@ -331,6 +331,7 @@ void CLogBookScreen::ProcessControllerInput(const CFinalInput& input) {
 }

 void CLogBookScreen::Draw(float transInterp, float totalAlpha, float yOff) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CInventoryScreen::Draw", zeus::skPurple);
  CPauseScreenBase::Draw(transInterp, totalAlpha, yOff);
  bool artifactSel = x10_mode == EMode::RightTable && IsArtifactCategorySelected();
  x258_artifactDoll->Draw(transInterp * (1.f - x254_viewInterp), x4_mgr, artifactSel,
--- a/Runtime/MP1/CMFGame.cpp
+++ b/Runtime/MP1/CMFGame.cpp
@ -194,6 +194,7 @@ void CMFGame::Touch() {
 void CMFGame::Draw() const {
  if (!x2a_24_initialized)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CMFGame::Draw", zeus::skGreen);

  const_cast<CMFGame&>(*this).Touch();
  if (x18_guiManager->GetIsGameDraw()) {
@ -360,6 +361,9 @@ CIOWin::EMessageReturn CMFGameLoader::OnMessage(const CArchitectureMessage& msg,
  return EMessageReturn::Exit;
 }

-void CMFGameLoader::Draw() const { g_GameState->GetWorldTransitionManager()->Draw(); }
+void CMFGameLoader::Draw() const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CMFGameLoader::Draw", zeus::skGreen);
+  g_GameState->GetWorldTransitionManager()->Draw();
+}

 } // namespace urde::MP1
--- a/Runtime/MP1/CMessageScreen.cpp
+++ b/Runtime/MP1/CMessageScreen.cpp
@ -127,6 +127,7 @@ bool CMessageScreen::Update(float dt, float blurAmt) {
 void CMessageScreen::Draw() const {
  if (!x18_loadedMsgScreen)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CMessageScreen::Draw", zeus::skPurple);

  x18_loadedMsgScreen->Draw(CGuiWidgetDrawParms(x70_blurAmt, zeus::skZero3f));
 }
--- a/Runtime/MP1/COptionsScreen.cpp
+++ b/Runtime/MP1/COptionsScreen.cpp
@ -163,6 +163,7 @@ void COptionsScreen::ProcessControllerInput(const CFinalInput& input) {
 }

 void COptionsScreen::Draw(float transInterp, float totalAlpha, float yOff) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("COptionsScreen::Draw", zeus::skPurple);
  CPauseScreenBase::Draw(transInterp, totalAlpha, yOff);
  x1a0_gameCube->Draw(transInterp * (1.f - x29c_optionAlpha));
  if (x19c_quitGame) {
--- a/Runtime/MP1/CPauseScreen.cpp
+++ b/Runtime/MP1/CPauseScreen.cpp
@ -320,6 +320,7 @@ void CPauseScreen::PreDraw() {
 void CPauseScreen::Draw() {
  if (!IsLoaded())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CPauseScreen::Draw", zeus::skPurple);

  float totalAlpha = 0.f;
  float yOff = 0.f;
--- a/Runtime/MP1/CPauseScreenBase.cpp
+++ b/Runtime/MP1/CPauseScreenBase.cpp
@ -344,6 +344,8 @@ void CPauseScreenBase::ResetMouseState() {
 }

 void CPauseScreenBase::Draw(float mainAlpha, float frameAlpha, float yOff) {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CPauseScreenBase::Draw", zeus::skBlue);
+
  zeus::CColor color = zeus::skWhite;
  color.a() = mainAlpha * x14_alpha;
  x60_basewidget_pivot->SetColor(color);
--- a/Runtime/MP1/CPauseScreenBlur.cpp
+++ b/Runtime/MP1/CPauseScreenBlur.cpp
@ -84,6 +84,7 @@ void CPauseScreenBlur::Update(float dt, const CStateManager& stateMgr, bool b) {
 }

 void CPauseScreenBlur::Draw(const CStateManager&) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CPauseScreenBlur::Draw", zeus::skPurple);
  const_cast<CCameraBlurPass&>(x1c_camBlur).Draw(true);
  float t = std::fabs(x18_blurAmt);
  if (x1c_camBlur.GetCurrType() != EBlurType::NoBlur) {
--- a/Runtime/MP1/CPlayerVisor.cpp
+++ b/Runtime/MP1/CPlayerVisor.cpp
@ -320,6 +320,8 @@ void CPlayerVisor::LockUnlockAssets() {
 }

 void CPlayerVisor::DrawScanEffect(const CStateManager& mgr, const CTargetingManager* tgtMgr) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CPlayerVisor::DrawScanEffect", zeus::skMagenta);
+
  bool indicatorsDrawn = DrawScanObjectIndicators(mgr);
  if (tgtMgr && indicatorsDrawn) {
    CGraphics::SetDepthRange(DEPTH_TARGET_MANAGER, DEPTH_TARGET_MANAGER);
@ -454,7 +456,10 @@ void CPlayerVisor::DrawScanEffect(const CStateManager& mgr, const CTargetingMana
  // cull faces
 }

-void CPlayerVisor::DrawXRayEffect(const CStateManager&) const { const_cast<CCameraBlurPass&>(x90_xrayBlur).Draw(); }
+void CPlayerVisor::DrawXRayEffect(const CStateManager&) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CPlayerVisor::DrawXRayEffect", zeus::skMagenta);
+  const_cast<CCameraBlurPass&>(x90_xrayBlur).Draw();
+}

 void CPlayerVisor::DrawThermalEffect(const CStateManager&) const {
  // Empty
--- a/Runtime/MP1/CQuitGameScreen.cpp
+++ b/Runtime/MP1/CQuitGameScreen.cpp
@ -8,6 +8,7 @@
 #include "GuiSys/CStringTable.hpp"
 #include "GuiSys/CGuiWidgetDrawParms.hpp"
 #include "Audio/CSfxManager.hpp"
+#include "Graphics/CGraphics.hpp"

 namespace urde::MP1 {

@ -80,6 +81,7 @@ EQuitAction CQuitGameScreen::Update(float dt) {
 }

 void CQuitGameScreen::Draw() {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CQuitGameScreen::Draw", zeus::skPurple);
  if (x0_type == EQuitType::QuitGame)
    m_blackScreen->draw(zeus::CColor(0.f, 0.5f));

--- a/Runtime/MP1/CSamusDoll.cpp
+++ b/Runtime/MP1/CSamusDoll.cpp
@ -267,6 +267,7 @@ void CSamusDoll::Update(float dt, CRandom16& rand) {
 void CSamusDoll::Draw(const CStateManager& mgr, float alpha) {
  if (!IsLoaded())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CSamusDoll::Draw", zeus::skPurple);

  alpha *= x40_alphaIn;

--- a/Runtime/MP1/CSamusFaceReflection.cpp
+++ b/Runtime/MP1/CSamusFaceReflection.cpp
@ -34,6 +34,7 @@ void CSamusFaceReflection::Draw(const CStateManager& mgr) const {
    return;

  if (TCastToConstPtr<CFirstPersonCamera> fpCam = (mgr.GetCameraManager()->GetCurrentCamera(mgr))) {
+    SCOPED_GRAPHICS_DEBUG_GROUP("CSamusFaceReflection::Draw", zeus::skBlue);
    zeus::CQuaternion camRot(fpCam->GetTransform().basis);
    float dist = ITweakGui::FaceReflectionDistanceDebugValueToActualValue(g_tweakGui->GetFaceReflectionDistance());
    float height = ITweakGui::FaceReflectionHeightDebugValueToActualValue(g_tweakGui->GetFaceReflectionHeight());
--- a/Runtime/MP1/CSamusHud.cpp
+++ b/Runtime/MP1/CSamusHud.cpp
@ -291,7 +291,7 @@ void CSamusHud::InitializeDamageLight() {
  s16 parentId = x288_loadedSelectedHud->FindWidget("basewidget_pivot")->GetSelfId();
  CGuiWidget::CGuiWidgetParms parms(x288_loadedSelectedHud, false, lightId, parentId, true, true, false,
                                    g_tweakGuiColors->GetHudDamageLightColor(), CGuiWidget::EGuiModelDrawFlags::Alpha,
-                                    false, false);
+                                    false, false, "DamageSpotLight"s);

  std::shared_ptr<CGuiLight> light = std::make_shared<CGuiLight>(
      parms, CLight::BuildSpot(zeus::skZero3f, zeus::skForward, zeus::skWhite,
@ -1382,6 +1382,7 @@ void CSamusHud::Draw(const CStateManager& mgr, float alpha, CInGameGuiManager::E
                     bool targetingManager) const {
  if (x2bc_nextState == EHudState::None)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CSamusHud::Draw", zeus::skBlue);
  x3a8_camFilter.Draw();
  if (mgr.GetPlayer().GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed) {
    DrawAttachedEnemyEffect(mgr);
--- a/Runtime/MP1/CSaveGameScreen.cpp
+++ b/Runtime/MP1/CSaveGameScreen.cpp
@ -319,6 +319,7 @@ void CSaveGameScreen::SetUIColors() {
 }

 void CSaveGameScreen::Draw() const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CSaveGameScreen::Draw", zeus::skPurple);
  if (x50_loadedFrame)
    x50_loadedFrame->Draw(CGuiWidgetDrawParms::Default);
 }
--- a/Runtime/MP1/CSlideShow.cpp
+++ b/Runtime/MP1/CSlideShow.cpp
@ -134,6 +134,7 @@ void CSlideShow::SSlideData::Draw() const {
 }

 void CSlideShow::Draw() const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CSlideShow::Draw", zeus::skGreen);
  if (x14_phase == Phase::Five) {
    x5c_slideA.Draw();
    x90_slideB.Draw();
--- a/Runtime/Particle/CDecal.cpp
+++ b/Runtime/Particle/CDecal.cpp
@ -233,6 +233,7 @@ void CDecal::RenderMdl() const {
 }

 void CDecal::Render() const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CDecal::Render", zeus::skYellow);
  CGlobalRandom gr(sDecalRandom);
  if (x5c_29_modelInvalid && x5c_30_quad2Invalid && x5c_31_quad1Invalid)
    return;
--- a/Runtime/Particle/CElementGen.cpp
+++ b/Runtime/Particle/CElementGen.cpp
@ -792,6 +792,9 @@ u32 CElementGen::GetSystemCount() {
 }

 void CElementGen::Render(const CActorLights* actorLights) {
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CElementGen::Render {}"),
+    *x1c_genDesc.GetObjectTag()).c_str(), zeus::skYellow);
+
  CGenDescription* desc = x1c_genDesc.GetObj();

  x274_backupLightActive = CGraphics::g_LightActive;
--- a/Runtime/Particle/CParticleElectric.cpp
+++ b/Runtime/Particle/CParticleElectric.cpp
@ -548,6 +548,9 @@ bool CParticleElectric::Update(double dt) {
 }

 void CParticleElectric::Render(const CActorLights* lights) {
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CParticleElectric::Render {}"),
+    *x1c_elecDesc.GetObjectTag()).c_str(), zeus::skYellow);
+
  if (x3e8_electricManagers.size()) {
    if (x450_29_transformDirty)
      UpdateCachedTransform();
--- a/Runtime/Particle/CParticleSwoosh.cpp
+++ b/Runtime/Particle/CParticleSwoosh.cpp
@ -870,6 +870,8 @@ void CParticleSwoosh::Render2SidedNoSplineNoGaps() {
 void CParticleSwoosh::Render(const CActorLights*) {
  if (x1b4_LENG < 2 || x1ac_particleCount <= 1)
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CParticleSwoosh::Render {}"),
+    *x1c_desc.GetObjectTag()).c_str(), zeus::skYellow);

  m_cachedVerts.clear();
  if (m_dataBind[0])
--- a/Runtime/Weapon/CEnergyProjectile.cpp
+++ b/Runtime/Weapon/CEnergyProjectile.cpp
@ -184,6 +184,8 @@ void CEnergyProjectile::Think(float dt, CStateManager& mgr) {
 }

 void CEnergyProjectile::Render(const CStateManager& mgr) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CEnergyProjectile::Render WPSC_{}"), x2cc_wpscId).c_str(), zeus::skOrange);
+
  CPlayerState::EPlayerVisor visor = mgr.GetPlayerState()->GetActiveVisor(mgr);
  if (visor == CPlayerState::EPlayerVisor::Combat) {
    if ((xe8_projectileAttribs & EProjectileAttrib::Charged) == EProjectileAttrib::Charged ||
--- a/Runtime/Weapon/CGrappleArm.cpp
+++ b/Runtime/Weapon/CGrappleArm.cpp
@ -490,6 +490,7 @@ void CGrappleArm::PointGenerator(void* ctx, const std::vector<std::pair<zeus::CV
 void CGrappleArm::Render(const CStateManager& mgr, const zeus::CVector3f& pos, const CModelFlags& flags,
                         const CActorLights* lights) const {
  if (x3b2_24_active && !x3b2_29_suitLoading) {
+    SCOPED_GRAPHICS_DEBUG_GROUP("CGrappleArm::Render", zeus::skOrange);
    zeus::CTransform modelXf = zeus::CTransform::Translate(pos) * x220_xf * x2e0_auxXf;
    if (x50_grappleArmSkeletonModel)
      RenderXRayModel(mgr, modelXf, flags);
--- a/Runtime/Weapon/CPlasmaProjectile.cpp
+++ b/Runtime/Weapon/CPlasmaProjectile.cpp
@ -406,6 +406,7 @@ void CPlasmaProjectile::AddToRenderer(const zeus::CFrustum& frustum, const CStat
 void CPlasmaProjectile::Render(const CStateManager& mgr) const {
  if (!GetActive())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP("CPlasmaProjectile::Render", zeus::skOrange);

  zeus::CTransform xf = GetBeamTransform();

--- a/Runtime/Weapon/CPlayerGun.cpp
+++ b/Runtime/Weapon/CPlayerGun.cpp
@ -2082,6 +2082,8 @@ static const CModelFlags kHandThermalFlag = {7, 0, 3, zeus::skWhite};
 static const CModelFlags kHandHoloFlag = {1, 0, 3, zeus::CColor(0.75f, 0.5f, 0.f, 1.f)};

 void CPlayerGun::Render(const CStateManager& mgr, const zeus::CVector3f& pos, const CModelFlags& flags) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CPlayerGun::Render", zeus::skMagenta);
+
  CGraphics::CProjectionState projState = CGraphics::GetProjectionState();
  CModelFlags useFlags = flags;
  if (x0_lights.HasShadowLight())
--- a/Runtime/World/CActor.cpp
+++ b/Runtime/World/CActor.cpp
@ -204,6 +204,9 @@ void CActor::DrawTouchBounds() const {
 }

 void CActor::RenderInternal(const CStateManager& mgr) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CActor::RenderInternal {} {} {}"),
+    x8_uid, xc_editorId, x10_name).c_str(), zeus::skOrange);
+
  CModelData::EWhichModel which = CModelData::GetRenderingModel(mgr);
  if (which == CModelData::EWhichModel::ThermalHot) {
    if (x64_modelData->GetSortThermal()) {
--- a/Runtime/World/CEnvFxManager.cpp
+++ b/Runtime/World/CEnvFxManager.cpp
@ -538,6 +538,7 @@ void CEnvFxManager::Render(const CStateManager& mgr) const {
    if (mgr.GetPlayer().GetMorphballTransitionState() != CPlayer::EPlayerMorphBallState::Unmorphed ||
        (mgr.GetPlayerState()->GetCurrentVisor() != CPlayerState::EPlayerVisor::Thermal &&
         (fxType != EEnvFxType::Snow || mgr.GetPlayerState()->GetCurrentVisor() != CPlayerState::EPlayerVisor::XRay))) {
+      SCOPED_GRAPHICS_DEBUG_GROUP("CEnvFxManager::Render", zeus::skCyan);
      // No Cull
      // ZTest, No ZWrite
      zeus::CTransform xf = GetParticleBoundsToWorldTransform();
--- a/Runtime/World/CFishCloud.cpp
+++ b/Runtime/World/CFishCloud.cpp
@ -523,6 +523,8 @@ void CFishCloud::RenderBoid(int idx, const CBoid& boid, u32& drawMask,
 void CFishCloud::Render(const CStateManager& mgr) const {
  if (!GetActive())
    return;
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CFishCloud::Render {} {} {}"),
+                                          x8_uid, xc_editorId, x10_name).c_str(), zeus::skOrange);
  bool thermalHot = mgr.GetThermalDrawFlag() == EThermalDrawFlag::Hot;
  CModelFlags flags(0, 0, 3, zeus::skWhite);
  if (mgr.GetPlayerState()->GetActiveVisor(mgr) == CPlayerState::EPlayerVisor::XRay)
--- a/Runtime/World/CFluidPlaneCPU.cpp
+++ b/Runtime/World/CFluidPlaneCPU.cpp
@ -739,11 +739,12 @@ void CFluidPlaneCPU::Render(const CStateManager& mgr, float alpha, const zeus::C
                            const std::optional<CRippleManager>& rippleManager, TUniqueId waterId,
                            const bool* gridFlags, u32 gridDimX, u32 gridDimY,
                            const zeus::CVector3f& areaCenter) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CFluidPlaneCPU::Render", zeus::skCyan);
  TCastToConstPtr<CScriptWater> water = mgr.GetObjectById(waterId);
  CFluidPlaneShader::RenderSetupInfo setupInfo = RenderSetup(mgr, alpha, xf, areaXf, aabb, water.GetPtr());

-  if (!m_shader->isReady())
-    return;
+  //if (!m_shader->isReady())
+  //  return;

  CFluidPlaneRender::NormalMode normalMode;
  if (xb0_bumpMap && kEnableWaterBumpMaps)
--- a/Runtime/World/CFluidPlaneDoor.cpp
+++ b/Runtime/World/CFluidPlaneDoor.cpp
@ -62,10 +62,11 @@ void CFluidPlaneDoor::Render(const CStateManager& mgr, float alpha, const zeus::
                             const std::optional<CRippleManager>& rippleManager, TUniqueId waterId,
                             const bool* gridFlags, u32 gridDimX, u32 gridDimY,
                             const zeus::CVector3f& areaCenter) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CFluidPlaneDoor::Render", zeus::skCyan);
  CFluidPlaneShader::RenderSetupInfo setupInfo = RenderSetup(mgr, alpha, xf, aabb, noNormals);

-  if (!m_shader->isReady())
-    return;
+  //if (!m_shader->isReady())
+  //  return;

  CFluidPlaneRender::numSubdivisionsInTile = xa4_tileSubdivisions;
  CFluidPlaneRender::numTilesInHField = 42 / xa4_tileSubdivisions;
--- a/Runtime/World/CHUDBillboardEffect.cpp
+++ b/Runtime/World/CHUDBillboardEffect.cpp
@ -96,6 +96,7 @@ void CHUDBillboardEffect::PreRender(CStateManager& mgr, const zeus::CFrustum& fr

 void CHUDBillboardEffect::Render(const CStateManager& mgr) const {
  if (x104_25_enableRender && !x104_24_renderAsParticleGen) {
+    SCOPED_GRAPHICS_DEBUG_GROUP("CHUDBillboardEffect::Render", zeus::skPurple);
    xe8_generator->Render();
  }
 }
--- a/Runtime/World/CMorphBall.cpp
+++ b/Runtime/World/CMorphBall.cpp
@ -1407,6 +1407,7 @@ static const u8 BallSwooshColorsJaggy[9][3] = {{0xFF, 0xCC, 0x00}, {0xFF, 0xCC,
                                               {0xFF, 0xCC, 0x00}, {0xFF, 0xCC, 0x00}, {0xFF, 0xCC, 0x00}};

 void CMorphBall::Render(const CStateManager& mgr, const CActorLights* lights) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CPlayer::Render", zeus::skPurple);
  zeus::CTransform ballToWorld = GetBallToWorld();
  if (x28_tireMode) {
    ballToWorld = ballToWorld * zeus::CQuaternion::fromAxisAngle(ballToWorld.transposeRotate(x0_player.x500_lookDir),
--- a/Runtime/World/CPlayer.cpp
+++ b/Runtime/World/CPlayer.cpp
@ -1156,6 +1156,7 @@ void CPlayer::Render(const CStateManager& mgr) const {
    if (TCastToConstPtr<CCinematicCamera> cam = mgr.GetCameraManager()->GetCurrentCamera(mgr))
      doRender = (x2f8_morphBallState == EPlayerMorphBallState::Morphed && cam->GetFlags() & 0x40);
  if (x2f4_cameraState != EPlayerCameraState::FirstPerson && doRender) {
+    SCOPED_GRAPHICS_DEBUG_GROUP("CPlayer::Render", zeus::skOrange);
    CBooModel::SetReflectionCube(m_reflectionCube);
    bool doTransitionRender = false;
    bool doBallRender = false;
--- a/Runtime/World/CWallCrawlerSwarm.cpp
+++ b/Runtime/World/CWallCrawlerSwarm.cpp
@ -991,6 +991,8 @@ void CWallCrawlerSwarm::RenderBoid(const CBoid* boid, u32& drawMask, bool therma
 }

 void CWallCrawlerSwarm::Render(const CStateManager& mgr) const {
+  SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(fmt("CWallCrawlerSwarm::Render {} {} {}"),
+                                          x8_uid, xc_editorId, x10_name).c_str(), zeus::skOrange);
  u32 drawMask = 0xffffffff;
  bool r24 = x560_24_enableLighting;
  bool r23 = x560_25_useSoftwareLight;
--- a/Runtime/World/CWorld.cpp
+++ b/Runtime/World/CWorld.cpp
@ -646,6 +646,8 @@ void CWorld::DrawSky(const zeus::CTransform& xf) const {
  if (!x70_27_skyboxVisible)
    return;

+  SCOPED_GRAPHICS_DEBUG_GROUP("CWorld::DrawSky", zeus::skCyan);
+
  CGraphics::DisableAllLights();
  CGraphics::SetModelMatrix(xf);
  g_Renderer->SetAmbientColor(zeus::skWhite);
--- a/Runtime/World/CWorldTransManager.cpp
+++ b/Runtime/World/CWorldTransManager.cpp
@ -232,6 +232,7 @@ void CWorldTransManager::DrawSecondPass(CActorLights* lights) {
 }

 void CWorldTransManager::DrawEnabled() {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CWorldTransManager::DrawEnabled", zeus::skPurple);
  CActorLights lights(0, zeus::skZero3f, 4, 4, 0, 0, 0, 0.1f);
  lights.BuildFakeLightList(x4_modelData->x1a0_lights, zeus::CColor{0.1f, 0.1f, 0.1f, 1.0f});

@ -305,9 +306,13 @@ void CWorldTransManager::DrawEnabled() {
    m_fadeToBlack.draw(zeus::CColor{0.f, 0.f, 0.f, ftbT});
 }

-void CWorldTransManager::DrawDisabled() { m_fadeToBlack.draw(zeus::CColor{0.f, 0.f, 0.f, 0.01f}); }
+void CWorldTransManager::DrawDisabled() {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CWorldTransManager::DrawDisabled", zeus::skPurple);
+  m_fadeToBlack.draw(zeus::CColor{0.f, 0.f, 0.f, 0.01f});
+}

 void CWorldTransManager::DrawText() {
+  SCOPED_GRAPHICS_DEBUG_GROUP("CWorldTransManager::DrawText", zeus::skPurple);
  float width = 448.f * g_Viewport.aspect;
  CGraphics::SetOrtho(0.f, width, 448.f, 0.f, -4096.f, 4096.f);
  CGraphics::SetViewPointMatrix(zeus::CTransform());
--- a/Shaders/CModelShaders.frag.glsl
+++ b/Shaders/CModelShaders.frag.glsl
@ -309,7 +309,13 @@ vec4 PostFunc(vec4 colorIn) {
 #endif

 #if defined(URDE_LIGHTING_CUBE_REFLECTION) || defined(URDE_LIGHTING_CUBE_REFLECTION_SHADOW)
-vec3 ReflectionFunc(float roughness) { return texture(reflectionTex, reflect(vtf.mvPos.xyz, vtf.mvNorm.xyz), roughness).rgb; }
+vec3 ReflectionFunc(float roughness) {
+  vec3 coords = reflect(vtf.mvPos.xyz, vtf.mvNorm.xyz);
+#ifdef VULKAN
+  coords = vec3(coords.x, -coords.y, coords.z);
+#endif
+  return texture(reflectionTex, coords, roughness).rgb;
+}
 #elif defined(URDE_REFLECTION_SIMPLE)
 vec3 ReflectionFunc() { return texture(reflectionTex, vtf.dynReflectionUvs[1]).rgb * vtf.dynReflectionAlpha; }
 #elif defined(URDE_REFLECTION_INDIRECT)
--- a/Shaders/CModelShaders.frag.hlsl
+++ b/Shaders/CModelShaders.frag.hlsl
@ -308,7 +308,8 @@ float4 PostFunc(in VertToFrag vtf, float4 colorIn) {

 #if defined(URDE_LIGHTING_CUBE_REFLECTION) || defined(URDE_LIGHTING_CUBE_REFLECTION_SHADOW)
 float3 ReflectionFunc(in VertToFrag vtf, float roughness) {
-  return reflectionTex.SampleBias(reflectSamp, reflect(vtf.mvPos.xyz, vtf.mvNorm.xyz), roughness).rgb;
+  float3 coords = reflect(vtf.mvPos.xyz, vtf.mvNorm.xyz);
+  return reflectionTex.SampleBias(reflectSamp, float3(coords.x, -coords.y, coords.z), roughness).rgb;
 }
 #elif defined(URDE_REFLECTION_SIMPLE)
 float3 ReflectionFunc(in VertToFrag vtf)
--- a/Shaders/CModelShaders.frag.metal
+++ b/Shaders/CModelShaders.frag.metal
@ -303,7 +303,7 @@ float4 PostFunc(thread VertToFrag& vtf, constant LightingUniform& lu,

 #if defined(URDE_LIGHTING_CUBE_REFLECTION) || defined(URDE_LIGHTING_CUBE_REFLECTION_SHADOW)
 #define ReflectionFunc(roughness) \
-  (reflectionTex.sample(reflectSamp, reflect(vtf.mvPos.xyz, vtf.mvNorm.xyz), bias(roughness)).rgb)
+  (reflectionTex.sample(reflectSamp, float3(reflectionCoords.x, -reflectionCoords.y, reflectionCoords.z), bias(roughness)).rgb)
 #elif defined(URDE_REFLECTION_SIMPLE)
 #define ReflectionFunc() \
  (reflectionTex.sample(reflectSamp, vtf.dynReflectionUvs1).rgb * vtf.dynReflectionAlpha)
@ -342,6 +342,7 @@ fragment float4 fmain(VertToFrag vtf [[ stage_in ]],
  float3 lighting = LightingFunc(vtf, lu, extTex0, clampSamp);
  float4 tmp;
 #if defined(URDE_LIGHTING_CUBE_REFLECTION) || defined(URDE_LIGHTING_CUBE_REFLECTION_SHADOW)
+  float3 reflectionCoords = reflect(vtf.mvPos.xyz, vtf.mvNorm.xyz);
  tmp.rgb = (SampleTexture_lightmap() * colorReg1.rgb + lighting) * SampleTexture_diffuse() +
  SampleTexture_emissive() + (SampleTexture_specular() + SampleTexture_extendedSpecular() * lighting) *
  (SampleTexture_reflection() * ReflectionFunc(saturate(0.5 - SampleTextureAlpha_specular())) * 2.0);
--- a/Shaders/shader_CFluidPlaneShaderGLSL.cpp
+++ b/Shaders/shader_CFluidPlaneShaderGLSL.cpp
@ -166,7 +166,7 @@ static const char* TessES =
    "SBINDING(0) patch in vec4 minMaxPos;\n"
    "SBINDING(0) out VertToFrag vtf;\n"
    "\n"
-    "TBINDING##RIPPLE_TEXTURE_IDX uniform sampler2D RippleMap;\n"
+    "RIPPLE_TEXTURE_BINDING uniform sampler2D RippleMap;\n"
    "\n"
    "const float PI_X2 = 6.283185307179586;\n"
    "\n"
@ -600,6 +600,7 @@ static void _BuildAdditionalTCGs(std::stringstream& out, const SFluidPlaneShader
  int nextTCG = 3;
  int nextMtx = 4;

+  out << "#define ADDITIONAL_TCGS ";
  if (info.m_hasBumpMap)
    fmt::print(out, fmt("vtf.uvs[{}] = (texMtxs[0] * pos).xy;"), nextTCG++);
  if (info.m_hasEnvBumpMap)
@ -687,7 +688,7 @@ static std::string BuildES(const SFluidPlaneShaderInfo& info) {

  std::stringstream out;
  _BuildAdditionalTCGs(out, info);
-  out << "#define RIPPLE_TEXTURE_IDX " << nextTex << '\n';
+  out << "#define RIPPLE_TEXTURE_BINDING TBINDING" << nextTex << '\n';
  out << TessES;
  return out.str();
 }
@ -718,7 +719,7 @@ static std::string _BuildFS(const SFluidPlaneDoorShaderInfo& info) {
  int nextTex = 0;
  std::stringstream out;

-  out << "#define TEXTURE_PARAMS ";
+  out << "#define TEXTURE_DECLS ";
  if (info.m_hasPatternTex1)
    fmt::print(out, fmt("TBINDING{} uniform sampler2D patternTex1;"), nextTex++);
  if (info.m_hasPatternTex2)
--- a/Shaders/shader_CFluidPlaneShaderHLSL.cpp
+++ b/Shaders/shader_CFluidPlaneShaderHLSL.cpp
@ -197,7 +197,7 @@ static const char* TessES =
    "struct ControlPoint\n"
    "{};\n"
    "\n"
-    "Texture2D RippleMap : register(t##RIPPLE_TEXTURE_IDX);\n"
+    "Texture2D RippleMap : register(RIPPLE_TEXTURE_REG);\n"
    "SamplerState samp : register(s2);\n"
    "\n"
    "static const float PI_X2 = 6.283185307179586;\n"
@ -703,7 +703,7 @@ static std::string BuildES(const SFluidPlaneShaderInfo& info) {

  std::stringstream out;
  _BuildAdditionalTCGs(out, info);
-  out << "#define RIPPLE_TEXTURE_IDX " << nextTex << '\n';
+  out << "#define RIPPLE_TEXTURE_REG t" << nextTex << '\n';
  out << TessES;
  return out.str();
 }
@ -724,7 +724,7 @@ static std::string _BuildFS(const SFluidPlaneDoorShaderInfo& info) {
  int nextTex = 0;
  std::stringstream out;

-  out << "#define TEXTURE_PARAMS ";
+  out << "#define TEXTURE_DECLS ";
  if (info.m_hasPatternTex1)
    fmt::print(out, fmt("Texture2D patternTex1 : register(t{});"), nextTex++);
  if (info.m_hasPatternTex2)
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit bd781e15bdbdc737e49afb0e5ab6f4b7752fea4b
+Subproject commit 056c2f330e2dc1c5b5f93bfca848e73036046a0f
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 539585f52719caf0a2d3c433c512ccc23c851b7f
+Subproject commit cd88683372cbc59140a66ee98587058f8bdb985f