Route colorize mask and slider shader setup through helpers

docs/modernization/debt.md

@@ -18,6 +18,17 @@ agent or engineer to remove them without reconstructing context from chat.
 
 ## Recent Reductions
 
+- 2026-06-13: DEBT-0036 was narrowed again. Depth export `TextureColorize`
+  shader setup now routes through `legacy_canvas_draw_merge_services.h`; the
+  export path still owns sampler/texture binding, layer color selection, and
+  draw execution.
+- 2026-06-13: DEBT-0036 was narrowed again. `NodeCanvas` smoothing-mask
+  `TextureMask` setup now routes through `legacy_canvas_draw_merge_services.h`;
+  the node still owns smoothing-mask texture binding, per-face MVP updates,
+  blend state, and draw execution.
+- 2026-06-13: DEBT-0036 was narrowed again. Slider `Color` and `ColorHue`
+  shader setup now routes through `legacy_ui_overlay_services.h`; the slider
+  nodes still own geometry, hue direction, border drawing, and draw execution.
 - 2026-06-13: DEBT-0036 was narrowed again. Retained `TextureAlpha` shader
   setup now routes through `legacy_canvas_draw_merge_services.h` for Canvas
   draw-merge layer redraws, depth export merged-layer rendering, NodeCanvas

docs/modernization/roadmap.md

@@ -3056,6 +3056,15 @@ Results:
   NodeCanvas cached/live layer redraws, and desktop VR layer redraws, while
   sampler/texture binding, render-task ordering, per-frame alpha updates, and
   draw execution remain in retained code.
+- Depth export `TextureColorize` setup now shares the retained draw-merge
+  shader setup helper, while sampler/texture binding, layer color selection,
+  and draw execution remain in retained Canvas code.
+- `NodeCanvas` smoothing-mask `TextureMask` setup now shares the retained
+  draw-merge shader setup helper, while smoothing-mask texture binding,
+  per-face MVP updates, blend state, and draw execution remain retained.
+- Slider `Color` and `ColorHue` setup now shares retained UI overlay helpers,
+  while slider geometry, hue direction, border drawing, and draw execution
+  remain retained.
 - `NodeCanvas` density-resolve drawing and desktop VR UI drawing now share the
   retained draw-merge texture shader setup helper, while render target,
   sampler/texture binding, viewport/state restoration, and draw execution

src/canvas.cpp

@@ -2262,10 +2262,12 @@ void Canvas::export_depth_thread(std::string file_name)
                     glm::scale(glm::vec3(2));
 
                 m_sampler.bind(0);
-                ShaderManager::use(kShader::TextureColorize);
+                pp::panopainter::setup_legacy_canvas_draw_merge_texture_colorize_shader(
-                ShaderManager::u_int(kShaderUniform::Tex, 0);
+                    pp::panopainter::LegacyCanvasDrawMergeTextureColorizeUniforms {
-                ShaderManager::u_vec4(kShaderUniform::Col, { glm::vec3((float)(layer_index + 1) / (float)(m_layers.size() + 1)), 1.f });
+                        .mvp = plane_mvp_z,
-                ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+                        .texture_slot = 0,
+                        .color = { glm::vec3((float)(layer_index + 1) / (float)(m_layers.size() + 1)), 1.f },
+                    });
 
                 set_active_texture_unit(0);
                 m_layers[layer_index]->rtt(plane_index).bindTexture();

src/legacy_canvas_draw_merge_services.h

@@ -16,6 +16,11 @@ struct LegacyCanvasDrawMergeTextureUniforms {
     int texture_slot = 0;
 };
 
+struct LegacyCanvasDrawMergeTextureMaskUniforms {
+    int texture_slot = 0;
+    glm::vec2 pattern_offset {};
+};
+
 struct LegacyCanvasDrawMergeTextureAlphaUniforms {
     glm::mat4 mvp { 1.0f };
     int texture_slot = 0;
@@ -32,10 +37,18 @@ struct LegacyCanvasDrawMergeTextureBlendUniforms {
     float alpha = 1.0f;
 };
 
+struct LegacyCanvasDrawMergeTextureColorizeUniforms {
+    glm::mat4 mvp { 1.0f };
+    int texture_slot = 0;
+    glm::vec4 color { 1.0f };
+};
+
 struct LegacyCanvasDrawMergeShaderExecution {
     std::function<void(kShader)> use_shader;
     std::function<void(kShaderUniform, int)> set_int;
     std::function<void(kShaderUniform, float)> set_float;
+    std::function<void(kShaderUniform, const glm::vec2&)> set_vec2;
+    std::function<void(kShaderUniform, const glm::vec4&)> set_vec4;
     std::function<void(kShaderUniform, const glm::mat4&)> set_mat4;
 };
 
@@ -45,10 +58,24 @@ struct LegacyCanvasDrawMergeShaderExecution {
         .use_shader = [](kShader shader) { ShaderManager::use(shader); },
         .set_int = [](kShaderUniform uniform, int value) { ShaderManager::u_int(uniform, value); },
         .set_float = [](kShaderUniform uniform, float value) { ShaderManager::u_float(uniform, value); },
+        .set_vec2 = [](kShaderUniform uniform, const glm::vec2& value) { ShaderManager::u_vec2(uniform, value); },
+        .set_vec4 = [](kShaderUniform uniform, const glm::vec4& value) { ShaderManager::u_vec4(uniform, value); },
         .set_mat4 = [](kShaderUniform uniform, const glm::mat4& value) { ShaderManager::u_mat4(uniform, value); },
     };
 }
 
+inline void apply_legacy_canvas_draw_merge_mvp(
+    const glm::mat4& mvp,
+    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
+{
+    execution.set_mat4(kShaderUniform::MVP, mvp);
+}
+
+inline void apply_legacy_canvas_draw_merge_mvp(const glm::mat4& mvp)
+{
+    apply_legacy_canvas_draw_merge_mvp(mvp, legacy_shader_manager_draw_merge_execution());
+}
+
 inline void setup_legacy_canvas_draw_merge_checkerboard_shader(
     const LegacyCanvasDrawMergeCheckerboardUniforms& uniforms,
     const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
@@ -79,6 +106,21 @@ 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_texture_mask_shader(
+    const LegacyCanvasDrawMergeTextureMaskUniforms& uniforms,
+    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
+{
+    execution.use_shader(kShader::TextureMask);
+    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
+    execution.set_vec2(kShaderUniform::PatternOffset, uniforms.pattern_offset);
+}
+
+inline void setup_legacy_canvas_draw_merge_texture_mask_shader(
+    const LegacyCanvasDrawMergeTextureMaskUniforms& uniforms)
+{
+    setup_legacy_canvas_draw_merge_texture_mask_shader(uniforms, legacy_shader_manager_draw_merge_execution());
+}
+
 inline void setup_legacy_canvas_draw_merge_texture_alpha_shader(
     const LegacyCanvasDrawMergeTextureAlphaUniforms& uniforms,
     const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
@@ -116,4 +158,20 @@ inline void setup_legacy_canvas_draw_merge_texture_blend_shader(
     setup_legacy_canvas_draw_merge_texture_blend_shader(uniforms, legacy_shader_manager_draw_merge_execution());
 }
 
+inline void setup_legacy_canvas_draw_merge_texture_colorize_shader(
+    const LegacyCanvasDrawMergeTextureColorizeUniforms& uniforms,
+    const LegacyCanvasDrawMergeShaderExecution& execution) noexcept
+{
+    execution.use_shader(kShader::TextureColorize);
+    execution.set_int(kShaderUniform::Tex, uniforms.texture_slot);
+    execution.set_vec4(kShaderUniform::Col, uniforms.color);
+    execution.set_mat4(kShaderUniform::MVP, uniforms.mvp);
+}
+
+inline void setup_legacy_canvas_draw_merge_texture_colorize_shader(
+    const LegacyCanvasDrawMergeTextureColorizeUniforms& uniforms)
+{
+    setup_legacy_canvas_draw_merge_texture_colorize_shader(uniforms, legacy_shader_manager_draw_merge_execution());
+}
+
 } // namespace pp::panopainter

src/legacy_ui_overlay_services.h

@@ -3,6 +3,7 @@
 #include "app_core/app_dialog.h"
 #include "foundation/result.h"
 #include "node.h"
+#include "shader.h"
 
 #include <functional>
 #include <memory>
@@ -15,6 +16,20 @@ class NodeProgressBar;
 
 namespace pp::panopainter {
 
+inline void configure_legacy_slider_color_shader(const glm::mat4& mvp) noexcept
+{
+    ShaderManager::use(kShader::Color);
+    ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+    ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+}
+
+inline void configure_legacy_slider_hue_shader(const glm::mat4& mvp, int direction) noexcept
+{
+    ShaderManager::use(kShader::ColorHue);
+    ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+    ShaderManager::u_int(kShaderUniform::Direction, direction);
+}
+
 void initialize_legacy_overlay_node(App& app, Node& node);
 
 void destroy_legacy_node(Node& node);

src/node_canvas.cpp

@@ -726,9 +726,11 @@ void NodeCanvas::draw()
 
     if (m_canvas->m_smask_active)
     {
-        ShaderManager::use(kShader::TextureMask);
+        pp::panopainter::setup_legacy_canvas_draw_merge_texture_mask_shader(
-        ShaderManager::u_int(kShaderUniform::Tex, 0);
+            pp::panopainter::LegacyCanvasDrawMergeTextureMaskUniforms {
-        ShaderManager::u_vec2(kShaderUniform::PatternOffset, m_outline_pan);
+                .texture_slot = 0,
+                .pattern_offset = m_outline_pan,
+            });
         set_active_texture_unit(0);
         apply_node_canvas_capability(pp::renderer::gl::blend_state(), true);
 
@@ -740,7 +742,7 @@ void NodeCanvas::draw()
                 m_canvas->m_plane_transform[plane_index] *
                 glm::translate(glm::vec3(0, 0, -1.f));
 
-            ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
+            pp::panopainter::apply_legacy_canvas_draw_merge_mvp(plane_mvp);
             m_canvas->m_smask.rtt(plane_index).bindTexture();
             m_face_plane.draw_fill();
             m_canvas->m_smask.rtt(plane_index).unbindTexture();

src/node_slider.cpp

@@ -38,9 +38,7 @@ void NodeSliderH::draw()
     glm::mat4 pos = glm::translate(glm::vec3(cur_pos , 0));
     auto mvp = m_proj * pos * scale;
 
-    ShaderManager::use(kShader::Color);
+    pp::panopainter::configure_legacy_slider_color_shader(mvp);
-    ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
-    ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
     m_plane.draw_fill();
 }
 
@@ -162,10 +160,9 @@ glm::vec4 NodeSliderHue::get_hue()
 
 void NodeSliderHue::draw()
 {
-    ShaderManager::use(kShader::ColorHue);
+    pp::panopainter::configure_legacy_slider_hue_shader(
-    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp * glm::scale(glm::vec3(1, -1, 1)));
+        m_mvp * glm::scale(glm::vec3(1, -1, 1)),
-    //ShaderManager::u_vec4(kShaderUniform::Col, m_color);
+        m_comp);
-    ShaderManager::u_int(kShaderUniform::Direction, m_comp); // set vertical
     m_plane.draw_fill();
     NodeBorder::m_color = glm::vec4(0);
     NodeSliderH::draw();