Graphics debug groups and bug fixes

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

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

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) {
       {

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];

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) {

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);

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));

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);

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;

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();

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;

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);

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());

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);

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;

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();

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;

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));
 

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;

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;

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);

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));

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);

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;