Route remaining shader setup through helpers

docs/modernization/debt.md

@@ -18,6 +18,12 @@ agent or engineer to remove them without reconstructing context from chat.
 
 ## Recent Reductions
 
+- 2026-06-13: DEBT-0036 was narrowed again. Remaining live shader setup
+  outside retained helper headers now routes through retained helper surfaces
+  for canvas modes, equirect layer export, `NodeCanvas` debug dirty bounds,
+  atlas image drawing, and text drawing; those paths still own geometry,
+  framebuffer flow, texture/sampler binding, blend/depth state, readback, and
+  draw execution.
 - 2026-06-13: DEBT-0036 was narrowed again. Remaining simple color, hue,
   color-quad, grid heightmap, and pen/line preview shader setup in UI nodes
   and canvas modes now routes through retained helper surfaces; those paths

docs/modernization/roadmap.md

@@ -3068,6 +3068,11 @@ Results:
 - Scrollbar, text-input, and VR frame/cursor/controller shader setup now share
   retained UI/preview helpers, while geometry, blend/depth state,
   sampler/texture binding, and draw execution remain retained.
+- Remaining live shader setup outside retained helper headers now shares
+  retained helper surfaces for canvas modes, equirect layer export,
+  `NodeCanvas` debug dirty bounds, atlas image drawing, and text drawing, while
+  geometry, framebuffer flow, texture/sampler binding, blend/depth state,
+  readback, and draw execution remain retained.
 - Remaining simple color, hue, color-quad, grid heightmap, and pen/line
   preview shader setup in UI nodes and canvas modes now shares retained helper
   surfaces, while geometry, texture/sampler binding, blend/depth state,

src/canvas_layer.cpp

@@ -1,6 +1,7 @@
 #include "pch.h"
 #include "canvas_layer.h"
 #include "app.h"
+#include "legacy_canvas_draw_merge_services.h"
 #include "legacy_ui_gl_dispatch.h"
 #include "log.h"
 #include "renderer_gl/opengl_capabilities.h"
@@ -145,9 +146,8 @@ Texture2D Layer::gen_equirect(glm::ivec2 size /*= { 0, 0 }*/)
         set_layer_active_texture_unit(0U);
         bind_layer_texture_cube(cube.m_cubetex_id);
 
-        ShaderManager::use(kShader::Equirect);
+        pp::panopainter::setup_legacy_canvas_draw_merge_equirect_shader(
-        ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
+            {.mvp = glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f), .texture_slot = 0});
-        ShaderManager::u_int(kShaderUniform::Tex, 0);
         Canvas::I->m_sampler.bind(0);
         Canvas::I->m_plane.draw_fill();
 
@@ -187,9 +187,8 @@ PBO Layer::gen_equirect_pbo(glm::ivec2 size /*= { 0, 0 }*/)
         set_layer_active_texture_unit(0U);
         bind_layer_texture_cube(cube.m_cubetex_id);
 
-        ShaderManager::use(kShader::Equirect);
+        pp::panopainter::setup_legacy_canvas_draw_merge_equirect_shader(
-        ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
+            {.mvp = glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f), .texture_slot = 0});
-        ShaderManager::u_int(kShaderUniform::Tex, 0);
         Canvas::I->m_sampler.bind(0);
         Canvas::I->m_plane.draw_fill();
 

src/canvas_modes.cpp

@@ -593,9 +593,10 @@ void CanvasModeGrid::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, cons
         auto const& l = m_lines[i];
         auto origin = l.o;
         auto dir = l.d;
-        ShaderManager::use(kShader::Color);
+        pp::panopainter::setup_legacy_vr_color_shader({
-        ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+            .color = m_highlight && i == m_selected_index ? blue : red,
-        ShaderManager::u_vec4(kShaderUniform::Col, m_highlight && i == m_selected_index ? blue : red);
+            .mvp = proj * camera,
+        });
         static glm::vec4 AB[2];
         AB[0] = {origin - dir * 10.f, 1};
         AB[1] = {origin + dir * 10.f, 1 };
@@ -612,9 +613,10 @@ void CanvasModeGrid::init()
 void CanvasModeGrid::commit()
 {
     auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj){
-        ShaderManager::use(kShader::Color);
+        pp::panopainter::setup_legacy_vr_color_shader({
-        ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+            .color = { 1, 0, 0, 1 },
-        ShaderManager::u_vec4(kShaderUniform::Col, {1, 0, 0, 1});
+            .mvp = proj * camera,
+        });
         static glm::vec4 AB[2];
         AB[0] = {origin - dir * 10.f, 1};
         AB[1] = {origin + dir * 10.f, 1 };
@@ -742,10 +744,10 @@ void CanvasModeMaskFree::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
                 auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
                     // blending state intentionally left unchanged here.
                     apply_canvas_mode_capability(pp::renderer::gl::depth_test_state(), false);
-                    ShaderManager::use(kShader::Color);
+                    pp::panopainter::setup_legacy_vr_color_shader({
-                    ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+                        .color = App::I->keys[(int)kKey::KeyCtrl] ? glm::vec4(0, 0, 0, 1) : glm::vec4(1, 1, 1, 1),
-                    ShaderManager::u_vec4(kShaderUniform::Col,
+                        .mvp = proj * camera,
-                        App::I->keys[(int)kKey::KeyCtrl] ? glm::vec4(0, 0, 0, 1) : glm::vec4(1, 1, 1, 1));
+                    });
                     m_shape.draw_fill();
                 };
                 // use m_shape to render the mask polygon
@@ -825,9 +827,10 @@ void CanvasModeMaskFree::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
     {
         if (m_dragging)
         {
-            ShaderManager::use(kShader::Color);
+            pp::panopainter::setup_legacy_vr_color_shader({
-            ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
+                .color = { 0, 0, 0, 1 },
-            ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+                .mvp = glm::scale(glm::vec3(1, -1, 1)) * ortho,
+            });
             //m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill();
             m_shape.draw_stroke();
         }
@@ -877,9 +880,10 @@ void CanvasModeMaskLine::leave(kCanvasMode next)
         {
             auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
                 // blending state intentionally left unchanged here.
-                ShaderManager::use(kShader::Color);
+                pp::panopainter::setup_legacy_vr_color_shader({
-                ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+                    .color = { 1, 1, 1, 1 },
-                ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
+                    .mvp = proj * camera,
+                });
                 m_shape.draw_fill();
             };
             Canvas::I->draw_objects_direct(std::bind(drawer, std::placeholders::_1, std::placeholders::_2), Canvas::I->m_smask, 0);
@@ -982,17 +986,19 @@ void CanvasModeMaskLine::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
     {
         if (m_active_tool)
         {
-            ShaderManager::use(kShader::Color);
+            pp::panopainter::setup_legacy_vr_color_shader({
-            ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
+                .color = { 0, 0, 0, 1 },
-            ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+                .mvp = glm::scale(glm::vec3(1, -1, 1)) * ortho,
+            });
             //m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill();
             m_shape.draw_stroke();
         }
         else
         {
-            ShaderManager::use(kShader::Color);
+            pp::panopainter::setup_legacy_vr_color_shader({
-            ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+                .color = { 0, 0, 0, 1 },
-            ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+                .mvp = proj * camera,
+            });
             m_shape.draw_stroke();
         }
     }
@@ -1010,9 +1016,10 @@ void CanvasModeFill::leave(kCanvasMode next)
     if (m_points.size() > 2)
     {
         auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
-            ShaderManager::use(kShader::Color);
+            pp::panopainter::setup_legacy_vr_color_shader({
-            ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+                .color = { 1, 1, 1, 1 },
-            ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
+                .mvp = proj * camera,
+            });
             m_shape.draw_fill();
         };
         Canvas::I->draw_objects_direct(std::bind(drawer, std::placeholders::_1, std::placeholders::_2), Canvas::I->m_smask, 0);
@@ -1102,9 +1109,10 @@ void CanvasModeFill::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, cons
 {
     if (!m_points.empty())
     {
-        ShaderManager::use(kShader::Color);
+        pp::panopainter::setup_legacy_vr_color_shader({
-        ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+            .color = { 0, 0, 0, .25 },
-        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, .25 });
+            .mvp = proj * camera,
+        });
         m_dragging ? m_shape.draw_fill() : m_shape.draw_stroke();
     }
 }
@@ -1352,9 +1360,10 @@ void CanvasModeTransform::enter(kCanvasMode prev)
                 apply_canvas_mode_capability(pp::renderer::gl::depth_test_state(), false);
                 apply_canvas_mode_capability(pp::renderer::gl::blend_state(), false);
                 set_canvas_mode_active_texture_unit(0);
-                ShaderManager::use(kShader::Color);
+                pp::panopainter::setup_legacy_vr_color_shader({
-                ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+                    .color = { 0, 0, 0, 0 },
-                ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 0 });
+                    .mvp = mvp,
+                });
                 layer->rtt(i).bindFramebuffer();
                 // copy framebuffer to action data
                 layer->rtt(i).readPixelsRgba8(
@@ -1522,9 +1531,10 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
     apply_canvas_mode_capability(pp::renderer::gl::blend_state(), true);
     for (int i = 0; i < 6; i++)
     {
-        ShaderManager::use(kShader::Color);
+        pp::panopainter::setup_legacy_vr_color_shader({
-        ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
+            .color = { 0, 1, 1, .1 },
-        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 1, 1, .1 });
+            .mvp = proj * camera * m_xform * m_xform_local,
+        });
         m_shape[i].draw_fill();
 
         pp::panopainter::setup_legacy_canvas_draw_merge_texture_shader({
@@ -1538,7 +1548,6 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
         m_tex[i].unbind();
     }
 
-    ShaderManager::use(kShader::Color);
     auto m2d = Canvas::I->m_proj * Canvas::I->m_mv * m_xform * m_xform_local;
     for (int i = 0; i < corners.size(); i++)
     {
@@ -1548,15 +1557,17 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
         auto c3d = c / c.w;
         auto c2d = (xy(c3d) * 0.5f + 0.5f) * zw(Canvas::I->m_box);
 
-        ShaderManager::u_mat4(kShaderUniform::MVP,
+        pp::panopainter::setup_legacy_vr_color_shader({
-            ortho * glm::translate(glm::vec3(c2d, 0)) * glm::scale(glm::vec3(20.f) * App::I->zoom));
+            .color = { 1, 1, 1, i == corner_hl ? 1.f : .1f },
-
+            .mvp = ortho * glm::translate(glm::vec3(c2d, 0)) * glm::scale(glm::vec3(20.f) * App::I->zoom),
-        // draw inside
+        });
-        ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, i == corner_hl ? 1.f : .1f });
         m_circle.draw_fill();
 
         // draw black border
-        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+        pp::panopainter::setup_legacy_vr_color_shader({
+            .color = { 0, 0, 0, 1 },
+            .mvp = ortho * glm::translate(glm::vec3(c2d, 0)) * glm::scale(glm::vec3(20.f) * App::I->zoom),
+        });
         m_circle.draw_stroke();
     }
 

src/legacy_canvas_draw_merge_services.h

@@ -16,6 +16,18 @@ struct LegacyCanvasDrawMergeTextureUniforms {
     int texture_slot = 0;
 };
 
+struct LegacyCanvasDrawMergeAtlasUniforms {
+    glm::mat4 mvp { 1.0f };
+    int texture_slot = 0;
+    glm::vec2 offset {};
+    glm::vec2 size { 1.0f };
+};
+
+struct LegacyCanvasDrawMergeEquirectUniforms {
+    glm::mat4 mvp { 1.0f };
+    int texture_slot = 0;
+};
+
 struct LegacyCanvasDrawMergeTextureMaskUniforms {
     int texture_slot = 0;
     glm::vec2 pattern_offset {};
@@ -106,6 +118,38 @@ inline void setup_legacy_canvas_draw_merge_texture_shader(
     setup_legacy_canvas_draw_merge_texture_shader(uniforms, legacy_shader_manager_draw_merge_execution());
 }
 
+inline void setup_legacy_canvas_draw_merge_atlas_shader(
+    const LegacyCanvasDrawMergeAtlasUniforms& uniforms,
+    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
+{
+    execution.use_shader(kShader::Atlas);
+    execution.set_vec2(kShaderUniform::Tof, uniforms.offset);
+    execution.set_vec2(kShaderUniform::Tsz, uniforms.size);
+    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
+    execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
+}
+
+inline void setup_legacy_canvas_draw_merge_atlas_shader(
+    const LegacyCanvasDrawMergeAtlasUniforms& uniforms)
+{
+    setup_legacy_canvas_draw_merge_atlas_shader(uniforms, legacy_shader_manager_draw_merge_execution());
+}
+
+inline void setup_legacy_canvas_draw_merge_equirect_shader(
+    const LegacyCanvasDrawMergeEquirectUniforms& uniforms,
+    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
+{
+    execution.use_shader(kShader::Equirect);
+    execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
+    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
+}
+
+inline void setup_legacy_canvas_draw_merge_equirect_shader(
+    const LegacyCanvasDrawMergeEquirectUniforms& uniforms)
+{
+    setup_legacy_canvas_draw_merge_equirect_shader(uniforms, legacy_shader_manager_draw_merge_execution());
+}
+
 inline void setup_legacy_canvas_draw_merge_texture_mask_shader(
     const LegacyCanvasDrawMergeTextureMaskUniforms& uniforms,
     const LegacyCanvasDrawMergeShaderExecution& execution) noexcept

src/legacy_ui_overlay_services.h

@@ -39,6 +39,12 @@ inline void configure_legacy_ui_color_shader(
     ShaderManager::u_vec4(kShaderUniform::Col, color);
 }
 
+inline void configure_legacy_ui_color_shader(
+    const glm::mat4& mvp) noexcept
+{
+    configure_legacy_ui_color_shader(mvp, { 0, 0, 0, 1 });
+}
+
 inline void configure_legacy_grid_lambert_shader(
     const glm::mat4& mvp,
     const glm::vec3& light_dir,

src/node_canvas.cpp

@@ -657,14 +657,13 @@ void NodeCanvas::draw()
                     auto bb = m_canvas->m_layers[layer_index]->box(plane_index) / (float)m_canvas->m_layers[layer_index]->w;
                     glm::vec2 bbmin = xy(bb);
                     glm::vec2 bbsz = zw(bb) - xy(bb);
-                    ShaderManager::use(kShader::Color);
+                    pp::panopainter::configure_legacy_ui_color_shader(
-                    ShaderManager::u_vec4(kShaderUniform::Col, { 1, 0, 0, 1 });
+                        plane_mvp_z
-                    ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z 
+                            * glm::translate(glm::vec3(bbmin * 2.f, 0))
-                        * glm::translate(glm::vec3(bbmin * 2.f, 0))
+                            * glm::translate(glm::vec3(-1, -1, 0))
-                        * glm::translate(glm::vec3(-1, -1, 0))
+                            * glm::scale(glm::vec3(bbsz, 1))
-                        * glm::scale(glm::vec3(bbsz, 1))
+                            * glm::translate(glm::vec3(1, 1, 0)),
-                        * glm::translate(glm::vec3(1, 1, 0))
+                        { 1, 0, 0, 1 });
-                    );
                     m_face_plane.draw_stroke();
                 }
     #endif

src/node_image.cpp

@@ -107,11 +107,11 @@ void NodeImage::draw()
     pp::legacy::ui_gl::set_blend_enabled(true, "NodeImage");
     if (m_use_atlas)
     {
-        ShaderManager::use(kShader::Atlas);
+        pp::panopainter::setup_legacy_canvas_draw_merge_atlas_shader(
-        ShaderManager::u_vec2(kShaderUniform::Tof, m_off);
+            {.mvp = m_mvp * glm::scale(glm::vec3(m_scale, 1.f)),
-        ShaderManager::u_vec2(kShaderUniform::Tsz, m_sz);
+             .texture_slot = 0,
-        ShaderManager::u_int(kShaderUniform::Tex, 0);
+             .offset = m_off,
-        ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp * glm::scale(glm::vec3(m_scale, 1.f)));
+             .size = m_sz});
     }
     else
     {

src/node_text.cpp

@@ -1,4 +1,5 @@
 #include "pch.h"
+#include "legacy_ui_overlay_services.h"
 #include "log.h"
 #include "legacy_ui_gl_dispatch.h"
 #include "node_text.h"
@@ -170,10 +171,7 @@ void NodeText::update_layout()
 void NodeText::draw()
 {
     glm::mat4 pos = glm::translate(glm::vec3(glm::floor(m_pos + m_off), 0));
-    ShaderManager::use(kShader::Font);
+    pp::panopainter::configure_legacy_ui_font_shader(m_proj * pos, m_color);
-    ShaderManager::u_int(kShaderUniform::Tex, 0);
-    ShaderManager::u_mat4(kShaderUniform::MVP, m_proj * pos);
-    ShaderManager::u_vec4(kShaderUniform::Col, m_color);
     pp::legacy::ui_gl::set_blend_enabled(true, "NodeText");
     m_text_mesh.draw();
     pp::legacy::ui_gl::set_blend_enabled(false, "NodeText");