Route stroke frame planning through helper

src/legacy_canvas_stroke_execution_services.h

@@ -1,13 +1,18 @@
 #pragma once
 
 #include "paint_renderer/compositor.h"
+#include "brush.h"
 #include "../libs/glm/glm/glm.hpp"
+#include "../libs/glm/glm/gtc/matrix_transform.hpp"
+#include "../libs/glm/glm/gtx/rotate_vector.hpp"
 #include "util.h"
 
 #include <array>
 #include <functional>
 #include <span>
 #include <string_view>
+#include <utility>
+#include <vector>
 
 namespace pp::panopainter {
 
@@ -58,6 +63,95 @@ struct LegacyCanvasStrokePadRegionResult {
     std::array<pp::paint_renderer::CanvasStrokePoint, 6> ndc_quad {};
 };
 
+struct LegacyCanvasStrokeComputeRequest {
+    StrokeSample previous_sample {};
+    std::span<const StrokeSample> samples;
+    float zoom = 1.0f;
+    glm::vec2 mixer_size {};
+    glm::mat4 model_view { 1.0f };
+};
+
+template <typename ProjectStroke, typename MakeFrame>
+[[nodiscard]] auto plan_legacy_canvas_stroke_frames(
+    const LegacyCanvasStrokeComputeRequest& request,
+    ProjectStroke&& project_stroke,
+    MakeFrame&& make_frame)
+{
+    using StrokeFrame = decltype(make_frame(
+        std::declval<glm::vec4>(),
+        std::declval<glm::vec4>(),
+        0.0f,
+        0.0f,
+        project_stroke(std::declval<std::array<vertex_t, 4>&>(), false, request.model_view)));
+
+    std::vector<StrokeFrame> frames;
+    StrokeSample prev = request.previous_sample;
+    std::array<vertex_t, 4> brush_quad = {
+        vertex_t{ {0, 0, 1, 1}, {0, 0}, {0, 0} },
+        vertex_t{ {0, 0, 1, 1}, {0, 1}, {0, 1} },
+        vertex_t{ {0, 0, 1, 1}, {1, 1}, {1, 1} },
+        vertex_t{ {0, 0, 1, 1}, {1, 0}, {1, 0} },
+    };
+
+    for (const auto& sample : request.samples) {
+        if (!sample.valid()) {
+            continue;
+        }
+
+        const glm::vec2 mixer_dx(prev.size * 0.5f, 0);
+        const glm::vec2 mixer_dy(0, prev.size * 0.5f);
+        const glm::vec2 mixer_offsets[4] = {
+            -mixer_dx - mixer_dy,
+            -mixer_dx + mixer_dy,
+            +mixer_dx + mixer_dy,
+            +mixer_dx - mixer_dy,
+        };
+
+        const glm::vec2 brush_dx(sample.size * 0.5f, 0);
+        const glm::vec2 brush_dy(0, sample.size * 0.5f);
+        const glm::vec2 brush_offsets[4] = {
+            -brush_dx - brush_dy,
+            -brush_dx + brush_dy,
+            +brush_dx + brush_dy,
+            +brush_dx - brush_dy,
+        };
+
+        glm::vec2 mixer_bb_min(request.mixer_size);
+        glm::vec2 mixer_bb_max(0, 0);
+        for (int i = 0; i < 4; ++i) {
+            const auto mixer_point =
+                xy(prev.pos) + request.zoom * sample.scale * mixer_offsets[i] * glm::orientate2(-sample.angle);
+            mixer_bb_min = glm::max(glm::vec2(0, 0), glm::min(mixer_bb_min, mixer_point));
+            mixer_bb_max = glm::min(request.mixer_size, glm::max(mixer_bb_max, mixer_point));
+
+            if (sample.pos.z == 0.0f) {
+                brush_quad[i].pos = glm::vec4(
+                    xy(sample.pos) +
+                        request.zoom * sample.scale * brush_offsets[i] * glm::orientate2(-sample.angle) -
+                        glm::vec2(0, 1),
+                    1,
+                    1);
+            } else {
+                const auto inverse_view = glm::inverse(glm::lookAt({ 0, 0, 0 }, sample.pos, { 0, 1, 0 }));
+                const glm::vec3 offset_3d = inverse_view * glm::vec4(brush_offsets[i], 0, 1);
+                brush_quad[i].pos = glm::vec4(sample.pos + offset_3d, 1.0f);
+            }
+            brush_quad[i].uvs2 = mixer_point / request.mixer_size;
+        }
+
+        const auto mixer_rect =
+            glm::vec4(glm::floor(mixer_bb_min), glm::ceil(mixer_bb_max - mixer_bb_min)) / request.zoom;
+        auto shapes = sample.pos.z == 0.0f
+            ? project_stroke(brush_quad, false, request.model_view)
+            : project_stroke(brush_quad, true, glm::lookAt({ 0, 0, 0 }, sample.pos, { 0, 1, 0 }));
+        frames.push_back(make_frame(mixer_rect, glm::vec4(sample.col, 1), sample.flow, sample.opacity, std::move(shapes)));
+
+        prev = sample;
+    }
+
+    return frames;
+}
+
 [[nodiscard]] inline pp::paint_renderer::CanvasStrokeBox legacy_canvas_stroke_box(glm::vec4 box) noexcept
 {
     return pp::paint_renderer::CanvasStrokeBox {