Route UI and VR shader setup through helpers

docs/modernization/debt.md

@@ -18,6 +18,10 @@ agent or engineer to remove them without reconstructing context from chat.
 
 ## Recent Reductions
 
+- 2026-06-13: DEBT-0036 was narrowed again. Scrollbar, text-input, and VR
+  frame/cursor/controller shader setup now routes through retained UI/preview
+  helpers; those paths still own geometry, blend/depth state, sampler/texture
+  binding, and draw execution.
 - 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

docs/modernization/roadmap.md

@@ -3065,6 +3065,9 @@ Results:
 - Slider `Color` and `ColorHue` setup now shares retained UI overlay helpers,
   while slider geometry, hue direction, border drawing, and draw execution
   remain retained.
+- 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.
 - `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/app_vr.cpp

@@ -6,6 +6,7 @@
 #include "legacy_canvas_draw_merge_services.h"
 #include "legacy_canvas_stroke_composite_services.h"
 #include "legacy_canvas_stroke_erase_services.h"
+#include "legacy_canvas_stroke_preview_services.h"
 #include "legacy_ui_gl_dispatch.h"
 #include "node_panel_grid.h"
 #include "util.h"
@@ -427,9 +428,11 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
             glm::transpose(canvas->m_canvas->m_cam_rot) *
             glm::translate(glm::vec3(0, 0, -1)) *
             glm::scale(aspect * tan_fov);
-        ShaderManager::use(kShader::Color);
+        pp::panopainter::setup_legacy_vr_color_shader(
-        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+            pp::panopainter::LegacyVrColorUniforms {
-        ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+                .color = { 0, 0, 0, 1 },
+                .mvp = mvp,
+            });
         m_face_plane.draw_stroke();
     }
 
@@ -496,12 +499,17 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
             glm::scale(glm::vec3(100)) *
             glm::transpose(canvas->m_canvas->m_cam_rot) *
             glm::translate(glm::vec3(cur * glm::vec2(aspect * tan_fov), -1));
-        ShaderManager::use(kShader::Color);
+        pp::panopainter::setup_legacy_vr_color_shader(
-        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+            pp::panopainter::LegacyVrColorUniforms {
-        ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.01)));
+                .color = { 0, 0, 0, 1 },
+                .mvp = mvp * glm::scale(glm::vec3(.01f)),
+            });
         m_face_plane.draw_fill();
-        ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, 1 });
+        pp::panopainter::setup_legacy_vr_color_shader(
-        ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.005)));
+            pp::panopainter::LegacyVrColorUniforms {
+                .color = { 1, 1, 1, 1 },
+                .mvp = mvp * glm::scale(glm::vec3(.005f)),
+            });
         m_face_plane.draw_fill();
     }
 
@@ -510,9 +518,11 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
     if (vr_controllers_enabled && ui_visible && ui_inside)
     {
         auto mvp = proj * camera * vr_controllers[0].m_mat * glm::eulerAngleX(glm::radians(-30.f));
-        ShaderManager::use(kShader::Color);
+        pp::panopainter::setup_legacy_vr_color_shader(
-        ShaderManager::u_vec4(kShaderUniform::Col, { 1, 0, 1, 1 });
+            pp::panopainter::LegacyVrColorUniforms {
-        ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.0125, .0125, .07)));
+                .color = { 1, 0, 1, 1 },
+                .mvp = mvp * glm::scale(glm::vec3(.0125f, .0125f, .07f)),
+            });
         sphere.draw_fill();
     }
 
@@ -522,18 +532,18 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
     {
         glm::vec3 cpos = vr_controllers[0].get_pos() - xyz(pose[3]);
         auto pos = glm::translate(glm::normalize(cpos) * 100.f);
-        ShaderManager::use(kShader::StrokePreview);
-        ShaderManager::u_int(kShaderUniform::Tex, 0);
-        ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_brush->m_tip_flow);
-        ShaderManager::u_int(kShaderUniform::DrawOutline, false);
         auto tip_color = glm::vec4(glm::vec3(canvas->m_canvas->m_current_brush->m_tip_color), 1);
-        ShaderManager::u_vec4(kShaderUniform::Col, tip_color);
+        pp::panopainter::setup_legacy_vr_stroke_preview_shader(
-        ShaderManager::u_mat4(kShaderUniform::MVP,
+            pp::panopainter::LegacyVrStrokePreviewUniforms {
-            proj * camera * pos *
+                .texture_slot = 0,
-            glm::inverse(glm::lookAt({ 0, 0, 0 }, cpos, { 0, 1, 0 })) *
+                .alpha = canvas->m_canvas->m_current_brush->m_tip_flow,
-            glm::scale(glm::vec3(canvas->m_canvas->m_current_brush->m_tip_size * 100.f / height)) *
+                .draw_outline = false,
-            glm::eulerAngleZ(canvas->m_canvas->m_current_brush->m_tip_angle  * (float)(M_PI * 2.0))
+                .color = tip_color,
-        );
+                .mvp = proj * camera * pos *
+                    glm::inverse(glm::lookAt({ 0, 0, 0 }, cpos, { 0, 1, 0 })) *
+                    glm::scale(glm::vec3(canvas->m_canvas->m_current_brush->m_tip_size * 100.f / height)) *
+                    glm::eulerAngleZ(canvas->m_canvas->m_current_brush->m_tip_angle * (float)(M_PI * 2.0)),
+            });
         apply_vr_render_capability(pp::renderer::gl::blend_state(), true);
         set_active_texture_unit(0);
         auto& tex = *canvas->m_canvas->m_current_brush->m_tip_texture;

src/legacy_canvas_stroke_preview_services.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include "shader.h"
+#include "util.h"
+
 namespace pp::panopainter {
 
 struct LegacyStrokePreviewCopySize {
@@ -7,6 +10,36 @@ struct LegacyStrokePreviewCopySize {
     int height = 0;
 };
 
+struct LegacyVrColorUniforms {
+    glm::vec4 color { 1.0f };
+    glm::mat4 mvp { 1.0f };
+};
+
+struct LegacyVrStrokePreviewUniforms {
+    int texture_slot = 0;
+    float alpha = 1.0f;
+    bool draw_outline = false;
+    glm::vec4 color { 1.0f };
+    glm::mat4 mvp { 1.0f };
+};
+
+inline void setup_legacy_vr_color_shader(const LegacyVrColorUniforms& uniforms) noexcept
+{
+    ShaderManager::use(kShader::Color);
+    ShaderManager::u_vec4(kShaderUniform::Col, uniforms.color);
+    ShaderManager::u_mat4(kShaderUniform::MVP, uniforms.mvp);
+}
+
+inline void setup_legacy_vr_stroke_preview_shader(const LegacyVrStrokePreviewUniforms& uniforms) noexcept
+{
+    ShaderManager::use(kShader::StrokePreview);
+    ShaderManager::u_int(kShaderUniform::Tex, uniforms.texture_slot);
+    ShaderManager::u_float(kShaderUniform::Alpha, uniforms.alpha);
+    ShaderManager::u_int(kShaderUniform::DrawOutline, uniforms.draw_outline);
+    ShaderManager::u_vec4(kShaderUniform::Col, uniforms.color);
+    ShaderManager::u_mat4(kShaderUniform::MVP, uniforms.mvp);
+}
+
 template <
     typename SetupCheckerboard,
     typename DrawPlane,

src/legacy_ui_overlay_services.h

@@ -30,6 +30,25 @@ inline void configure_legacy_slider_hue_shader(const glm::mat4& mvp, int directi
     ShaderManager::u_int(kShaderUniform::Direction, direction);
 }
 
+inline void configure_legacy_ui_color_shader(
+    const glm::mat4& mvp,
+    const glm::vec4& color) noexcept
+{
+    ShaderManager::use(kShader::Color);
+    ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+    ShaderManager::u_vec4(kShaderUniform::Col, color);
+}
+
+inline void configure_legacy_ui_font_shader(
+    const glm::mat4& mvp,
+    const glm::vec4& color) noexcept
+{
+    ShaderManager::use(kShader::Font);
+    ShaderManager::u_int(kShaderUniform::Tex, 0);
+    ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+    ShaderManager::u_vec4(kShaderUniform::Col, color);
+}
+
 void initialize_legacy_overlay_node(App& app, Node& node);
 
 void destroy_legacy_node(Node& node);

src/node_scroll.cpp

@@ -113,7 +113,6 @@ void NodeScroll::draw()
     if (rect.w > 0 && rect.z > 0)
     {
         pp::legacy::ui_gl::set_blend_enabled(false, "NodeScroll");
-        ShaderManager::use(kShader::Color);
 
         if (m_direction == kScrollDirection::Vertical)
         {
@@ -121,11 +120,12 @@ void NodeScroll::draw()
             float h = glm::max(30.f, sz / rect.w * sz);
             float offset_percent = m_offset.y / (rect.w - sz);
             float pr = YGNodeLayoutGetPadding(y_node, YGEdgeRight) - 5;
-            ShaderManager::u_mat4(kShaderUniform::MVP, m_proj
+            pp::panopainter::configure_legacy_ui_color_shader(
+                m_proj
                 * glm::translate(glm::vec3(m_pos.x + m_size.x - pr, m_pos.y - offset_percent * (sz - h) + pad[0], 0))
                 * glm::scale(glm::vec3(pr, h, 1))
-                * glm::translate(glm::vec3(.5, .5, 0))
+                * glm::translate(glm::vec3(.5, .5, 0)),
-            );
+                m_scrollbar_color);
         }
         else
         {
@@ -133,13 +133,13 @@ void NodeScroll::draw()
             float h = glm::max(30.f, sz / rect.z * sz);
             float offset_percent = m_offset.x / (rect.z - sz);
             float pr = YGNodeLayoutGetPadding(y_node, YGEdgeBottom) - 5;
-            ShaderManager::u_mat4(kShaderUniform::MVP, m_proj
+            pp::panopainter::configure_legacy_ui_color_shader(
+                m_proj
                 * glm::translate(glm::vec3(m_pos.x - offset_percent * (sz - h) + pad[3], m_pos.y + m_size.y - pr, 0))
                 * glm::scale(glm::vec3(h, pr, 1))
-                * glm::translate(glm::vec3(.5, .5, 0))
+                * glm::translate(glm::vec3(.5, .5, 0)),
-            );
+                m_scrollbar_color);
         }
-        ShaderManager::u_vec4(kShaderUniform::Col, m_scrollbar_color);
         m_plane.draw_fill();
     }
 }

src/node_text_input.cpp

@@ -2,6 +2,7 @@
 #include "app.h"
 #include "log.h"
 #include "legacy_ui_gl_dispatch.h"
+#include "legacy_ui_overlay_services.h"
 #include "node_text_input.h"
 #include "node_border.h"
 
@@ -216,10 +217,7 @@ void NodeTextInput::draw()
     NodeBorder::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, "NodeTextInput");
     m_text_mesh.draw();
     pp::legacy::ui_gl::set_blend_enabled(false, "NodeTextInput");
@@ -230,9 +228,9 @@ void NodeTextInput::draw()
         glm::mat4 cur_pos = glm::translate(glm::vec3(m_pos + m_off + xy(m_text_mesh.cur_box), 0));
         glm::mat4 cur_scale = glm::scale(glm::vec3(zw(m_text_mesh.cur_box), 1));
         glm::mat4 cur_pivot = glm::translate(glm::vec3(0.5, 0.5, 0));
-        ShaderManager::use(kShader::Color);
+        pp::panopainter::configure_legacy_ui_color_shader(
-        ShaderManager::u_mat4(kShaderUniform::MVP, m_proj * cur_pos * cur_scale * cur_pivot);
+            m_proj * cur_pos * cur_scale * cur_pivot,
-        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+            { 0, 0, 0, 1 });
         m_plane.draw_fill();
     }
 }