Isolate legacy stroke sample execution

src/legacy_canvas_stroke_execution_services.h

@@ -0,0 +1,106 @@
+#pragma once
+
+#include "util.h"
+
+#include <array>
+#include <functional>
+#include <span>
+#include <string_view>
+
+namespace pp::panopainter {
+
+struct LegacyStrokeSampleExecutionRequest {
+    std::string_view context;
+    glm::vec2 target_size {};
+    std::span<const vertex_t> vertices;
+    bool copy_stroke_destination = false;
+    std::function<void()> bind_destination_texture;
+    std::function<void(int, int, int, int, int, int)> copy_framebuffer_to_destination_texture;
+    std::function<void()> unbind_destination_texture;
+    std::function<void(std::span<const vertex_t>)> upload_brush_vertices;
+    std::function<void()> draw_brush_shape;
+};
+
+struct LegacyStrokeSampleExecutionResult {
+    bool ok = false;
+    glm::ivec2 copy_position {};
+    glm::ivec2 copy_size {};
+    glm::vec4 dirty_bounds {};
+};
+
+[[nodiscard]] inline LegacyStrokeSampleExecutionResult execute_legacy_canvas_stroke_sample(
+    const LegacyStrokeSampleExecutionRequest& request)
+{
+    LegacyStrokeSampleExecutionResult result;
+    if (request.target_size.x <= 0.0f ||
+        request.target_size.y <= 0.0f ||
+        request.vertices.empty() ||
+        !request.upload_brush_vertices ||
+        !request.draw_brush_shape) {
+        return result;
+    }
+
+    if (request.copy_stroke_destination) {
+        if (!request.bind_destination_texture ||
+            !request.copy_framebuffer_to_destination_texture ||
+            !request.unbind_destination_texture) {
+            return result;
+        }
+        request.bind_destination_texture();
+    }
+
+    glm::vec2 bb_min(request.target_size);
+    glm::vec2 bb_max(0.0f, 0.0f);
+    for (const auto& vertex : request.vertices) {
+        bb_min = glm::max({ 0.0f, 0.0f }, glm::min(bb_min, xy(vertex.pos)));
+        bb_max = glm::min(request.target_size, glm::max(bb_max, xy(vertex.pos)));
+    }
+
+    const auto bb_sz = bb_max - bb_min;
+    const glm::vec2 pad(1.0f);
+    const glm::ivec2 target_extent(request.target_size);
+    result.copy_position = glm::clamp(
+        glm::floor(bb_min) - pad,
+        glm::vec2(0.0f),
+        request.target_size);
+    result.copy_size = glm::clamp(
+        glm::ceil(bb_sz) + pad * 2.0f,
+        glm::vec2(0.0f),
+        glm::vec2(target_extent - result.copy_position));
+    result.dirty_bounds = glm::vec4(result.copy_position, result.copy_position + result.copy_size);
+
+    if (request.copy_stroke_destination) {
+        request.copy_framebuffer_to_destination_texture(
+            result.copy_position.x,
+            result.copy_position.y,
+            result.copy_position.x,
+            result.copy_position.y,
+            result.copy_size.x,
+            result.copy_size.y);
+    }
+
+    if (request.vertices.size() == 4) {
+        std::array<vertex_t, 6> rect {
+            request.vertices[0],
+            request.vertices[1],
+            request.vertices[2],
+            request.vertices[0],
+            request.vertices[2],
+            request.vertices[3],
+        };
+        request.upload_brush_vertices(rect);
+    } else {
+        request.upload_brush_vertices(request.vertices);
+    }
+
+    request.draw_brush_shape();
+
+    if (request.copy_stroke_destination) {
+        request.unbind_destination_texture();
+    }
+
+    result.ok = true;
+    return result;
+}
+
+} // namespace pp::panopainter