Plan live stroke rasterization boundaries

src/paint_renderer/compositor.cpp

@@ -1186,6 +1186,56 @@ pp::foundation::Result<StrokeCompositePlan> plan_stroke_composite(
     return pp::foundation::Result<StrokeCompositePlan>::success(plan);
 }
 
+CanvasStrokeMaterialPlan plan_canvas_stroke_material(CanvasStrokeMaterialRequest request) noexcept
+{
+    CanvasStrokeMaterialPlan plan;
+
+    auto bind = [&plan](CanvasStrokeTextureRole role, std::uint8_t slot) noexcept {
+        if (plan.texture_binding_count >= plan.texture_bindings.size()) {
+            return;
+        }
+        plan.texture_bindings[plan.texture_binding_count] = CanvasStrokeTextureBindingPlan {
+            .role = role,
+            .slot = slot,
+        };
+        ++plan.texture_binding_count;
+    };
+
+    bind(CanvasStrokeTextureRole::main_brush_tip, 0);
+
+    plan.stroke_pass.uses_destination_feedback = request.destination_feedback_needed;
+    if (request.destination_feedback_needed) {
+        bind(CanvasStrokeTextureRole::destination_feedback, 1);
+    }
+
+    plan.stroke_pass.uses_pattern = request.pattern_enabled && request.pattern_eachsample;
+    if (plan.stroke_pass.uses_pattern) {
+        bind(CanvasStrokeTextureRole::pattern, 2);
+    }
+
+    plan.stroke_pass.uses_mixer = request.wet_blend || request.mix_blend || request.noise_enabled;
+    if (plan.stroke_pass.uses_mixer) {
+        bind(CanvasStrokeTextureRole::mixer, 3);
+    }
+
+    plan.dual_pass.enabled = request.dual_brush_enabled;
+    plan.dual_pass.uses_pattern = false;
+    if (request.dual_brush_enabled) {
+        bind(CanvasStrokeTextureRole::dual_brush_tip, 4);
+    }
+
+    plan.composite_pass.use_dual = request.dual_brush_enabled;
+    plan.composite_pass.use_pattern = request.pattern_enabled && !request.pattern_eachsample;
+    plan.composite_pass.dual_blend_mode = request.dual_blend_mode;
+    plan.composite_pass.pattern_blend_mode = request.pattern_blend_mode;
+    plan.composite_pass.dual_alpha = request.dual_alpha;
+    if (plan.composite_pass.use_pattern && !plan.stroke_pass.uses_pattern) {
+        bind(CanvasStrokeTextureRole::pattern, 2);
+    }
+
+    return plan;
+}
+
 pp::foundation::Result<CanvasBlendGatePlan> plan_canvas_blend_gate(
     pp::renderer::RenderDeviceFeatures features,
     CanvasBlendGateRequest request) noexcept
@@ -1301,6 +1351,26 @@ pp::foundation::Result<CanvasStrokeFeedbackPlan> plan_canvas_stroke_feedback(
     return pp::foundation::Result<CanvasStrokeFeedbackPlan>::success(fallback);
 }
 
+pp::foundation::Result<CanvasStrokeRasterizationPlan> plan_canvas_stroke_rasterization(
+    pp::renderer::RenderDeviceFeatures features,
+    pp::renderer::Extent2D extent) noexcept
+{
+    const auto feedback = plan_canvas_stroke_feedback(features, extent);
+    if (!feedback) {
+        return pp::foundation::Result<CanvasStrokeRasterizationPlan>::failure(feedback.status());
+    }
+
+    CanvasStrokeRasterizationPlan plan;
+    plan.feedback = feedback.value();
+    plan.copy_stroke_destination = !plan.feedback.reads_destination_color;
+    plan.can_route_feedback_through_renderer =
+        plan.feedback.reads_destination_color
+        || plan.feedback.requires_texture_copy
+        || plan.feedback.requires_render_target_blit;
+    plan.compatibility_fallback = plan.feedback.compatibility_fallback;
+    return pp::foundation::Result<CanvasStrokeRasterizationPlan>::success(plan);
+}
+
 const char* stroke_composite_path_name(StrokeCompositePath path) noexcept
 {
     switch (path) {