Share retained stroke sample dirty tracking

src/legacy_canvas_stroke_execution_services.h

@@ -218,6 +218,95 @@ std::size_t execute_legacy_canvas_stroke_frame_samples(
     return executed_faces;
 }
 
+template <
+    typename Frames,
+    typename BeginFrame,
+    typename BeginFace,
+    typename ExecuteSample,
+    typename PrepareDirtyRequest,
+    typename FinishFace>
+std::size_t execute_legacy_canvas_stroke_frame_samples_with_dirty_tracking(
+    Frames&& frames,
+    pp::renderer::Extent2D extent,
+    std::span<glm::vec4> accumulated_dirty_boxes,
+    std::span<glm::vec4> pass_dirty_boxes,
+    std::span<const bool> include_in_committed_dirty_box,
+    BeginFrame&& begin_frame,
+    BeginFace&& begin_face,
+    ExecuteSample&& execute_sample,
+    PrepareDirtyRequest&& prepare_dirty_request,
+    FinishFace&& finish_face,
+    std::span<bool> committed_dirty_faces = {},
+    std::span<bool> pass_dirty_faces = {})
+{
+    std::size_t executed_faces = 0;
+    for (auto& frame : frames) {
+        begin_frame(frame);
+        for (int face_index = 0; face_index < 6; ++face_index) {
+            auto& vertices = frame.shapes[face_index];
+            if (vertices.size() < 3) {
+                continue;
+            }
+
+            const glm::vec4 previous_accumulated_dirty_box =
+                face_index < accumulated_dirty_boxes.size()
+                ? accumulated_dirty_boxes[face_index]
+                : glm::vec4(0.0f);
+            const glm::vec4 previous_pass_dirty_box =
+                face_index < pass_dirty_boxes.size()
+                ? pass_dirty_boxes[face_index]
+                : glm::vec4(0.0f);
+            const bool include_dirty_box =
+                face_index < include_in_committed_dirty_box.size()
+                ? include_in_committed_dirty_box[face_index]
+                : true;
+
+            glm::vec4* accumulated_dirty_box =
+                face_index < accumulated_dirty_boxes.size()
+                ? &accumulated_dirty_boxes[face_index]
+                : nullptr;
+            glm::vec4* pass_dirty_box =
+                face_index < pass_dirty_boxes.size()
+                ? &pass_dirty_boxes[face_index]
+                : nullptr;
+            bool* committed_dirty =
+                face_index < committed_dirty_faces.size()
+                ? &committed_dirty_faces[face_index]
+                : nullptr;
+            bool* pass_dirty =
+                face_index < pass_dirty_faces.size()
+                ? &pass_dirty_faces[face_index]
+                : nullptr;
+
+            execute_legacy_canvas_stroke_face_sample(
+                LegacyCanvasStrokeFaceDirtyRequest {
+                    .extent = extent,
+                    .previous_accumulated_dirty_box = previous_accumulated_dirty_box,
+                    .previous_pass_dirty_box = previous_pass_dirty_box,
+                    .include_in_committed_dirty_box = include_dirty_box,
+                },
+                [&] {
+                    return execute_sample(frame, face_index, vertices);
+                },
+                [&] {
+                    begin_face(frame, face_index, vertices);
+                },
+                [&](auto& request) {
+                    prepare_dirty_request(frame, face_index, vertices, request);
+                },
+                [&](glm::vec4 sample_dirty_box) {
+                    finish_face(frame, face_index, vertices, sample_dirty_box);
+                },
+                accumulated_dirty_box,
+                pass_dirty_box,
+                committed_dirty,
+                pass_dirty);
+            ++executed_faces;
+        }
+    }
+    return executed_faces;
+}
+
 [[nodiscard]] inline pp::paint_renderer::CanvasStrokeBox legacy_canvas_stroke_box(glm::vec4 box) noexcept
 {
     return pp::paint_renderer::CanvasStrokeBox {