[librsvg: 12/23] feFlood - resolve and render separately

[Federico Mena Quintero <federico src gnome org>]

commit 43499a14af1ad06620d500462ac0c8ad6fd8bec5
Author: Federico Mena Quintero <federico gnome org>
Date:   Thu Mar 11 14:30:16 2021 -0600

    feFlood - resolve and render separately
    
    While we are at it, make ImageSurface.flood() only take a composed
    rgba, not an rgba plus opacity.

 src/filters/flood.rs                | 33 ++++++++++++++++++++-------------
 src/filters/mod.rs                  |  5 ++---
 src/surface_utils/shared_surface.rs | 11 +++++------
 3 files changed, 27 insertions(+), 22 deletions(-)
---
diff --git a/src/filters/flood.rs b/src/filters/flood.rs
index 6dece7b6..bda861dc 100644
--- a/src/filters/flood.rs
+++ b/src/filters/flood.rs
@@ -2,6 +2,7 @@ use crate::document::AcquiredNodes;
 use crate::drawing_ctx::DrawingCtx;
 use crate::element::{ElementResult, SetAttributes};
 use crate::node::{CascadedValues, Node};
+use crate::paint_server::resolve_color;
 use crate::xml::Attributes;
 
 use super::context::{FilterContext, FilterOutput, FilterResult};
@@ -12,6 +13,12 @@ pub struct FeFlood {
     base: Primitive,
 }
 
+/// Resolved `feFlood` primitive for rendering.
+pub struct Flood {
+    base: Primitive,
+    color: cssparser::RGBA,
+}
+
 impl Default for FeFlood {
     /// Constructs a new `Flood` with empty properties.
     #[inline]
@@ -28,26 +35,16 @@ impl SetAttributes for FeFlood {
     }
 }
 
-impl FeFlood {
+impl Flood {
     pub fn render(
         &self,
-        node: &Node,
         ctx: &FilterContext,
         _acquired_nodes: &mut AcquiredNodes<'_>,
         draw_ctx: &mut DrawingCtx,
     ) -> Result<FilterResult, FilterError> {
         let bounds = self.base.get_bounds(ctx)?.into_irect(ctx, draw_ctx);
 
-        let cascaded = CascadedValues::new_from_node(node);
-        let values = cascaded.get();
-
-        let color = match values.flood_color().0 {
-            cssparser::Color::CurrentColor => values.color().0,
-            cssparser::Color::RGBA(rgba) => rgba,
-        };
-        let opacity = values.flood_opacity().0;
-
-        let surface = ctx.source_graphic().flood(bounds, color, opacity)?;
+        let surface = ctx.source_graphic().flood(bounds, self.color)?;
 
         Ok(FilterResult {
             name: self.base.result.clone(),
@@ -58,6 +55,16 @@ impl FeFlood {
 
 impl FilterEffect for FeFlood {
     fn resolve(&self, node: &Node) -> Result<PrimitiveParams, FilterError> {
-        Ok(PrimitiveParams::Flood(node.clone()))
+        let cascaded = CascadedValues::new_from_node(node);
+        let values = cascaded.get();
+
+        Ok(PrimitiveParams::Flood(Flood {
+            base: self.base.clone(),
+            color: resolve_color(
+                &values.flood_color().0,
+                values.flood_opacity().0,
+                values.color().0,
+            ),
+        }))
     }
 }
diff --git a/src/filters/mod.rs b/src/filters/mod.rs
index 1607119f..80eb5665 100644
--- a/src/filters/mod.rs
+++ b/src/filters/mod.rs
@@ -52,7 +52,6 @@ pub mod offset;
 pub mod tile;
 pub mod turbulence;
 
-use flood::FeFlood;
 use gaussian_blur::FeGaussianBlur;
 use image::FeImage;
 use lighting::{FeDiffuseLighting, FeSpecularLighting};
@@ -76,7 +75,7 @@ pub enum PrimitiveParams {
     ConvolveMatrix(convolve_matrix::ConvolveMatrix),
     DiffuseLighting(Node),
     DisplacementMap(displacement_map::DisplacementMap),
-    Flood(Node),
+    Flood(flood::Flood),
     GaussianBlur(Node),
     Image(Node),
     Merge(Node),
@@ -327,7 +326,7 @@ fn render_primitive(
         (Element::FeConvolveMatrix(_), ConvolveMatrix(p))       => p.render(ctx, acquired_nodes, draw_ctx),
         (Element::FeDiffuseLighting(ref inner), DiffuseLighting(node))     => 
FeDiffuseLighting::render(&inner.element_impl, &node, ctx, acquired_nodes, draw_ctx),
         (Element::FeDisplacementMap(_), DisplacementMap(p))     => p.render(ctx, acquired_nodes, draw_ctx),
-        (Element::FeFlood(ref inner), Flood(node))                         => 
FeFlood::render(&inner.element_impl, &node, ctx, acquired_nodes, draw_ctx),
+        (Element::FeFlood(_), Flood(p))                         => p.render(ctx, acquired_nodes, draw_ctx),
         (Element::FeGaussianBlur(ref inner), GaussianBlur(node))           => 
FeGaussianBlur::render(&inner.element_impl, &node, ctx, acquired_nodes, draw_ctx),
         (Element::FeImage(ref inner), Image(node))                         => 
FeImage::render(&inner.element_impl, &node, ctx, acquired_nodes, draw_ctx),
         (Element::FeMerge(ref inner), Merge(node))                         => 
FeMerge::render(&inner.element_impl, &node, ctx, acquired_nodes, draw_ctx),
diff --git a/src/surface_utils/shared_surface.rs b/src/surface_utils/shared_surface.rs
index b2dbe17d..c561ce25 100644
--- a/src/surface_utils/shared_surface.rs
+++ b/src/surface_utils/shared_surface.rs
@@ -968,22 +968,21 @@ impl ImageSurface<Shared> {
         &self,
         bounds: IRect,
         color: cssparser::RGBA,
-        opacity: UnitInterval,
     ) -> Result<SharedImageSurface, cairo::Status> {
         let output_surface =
             cairo::ImageSurface::create(cairo::Format::ARgb32, self.width, self.height)?;
 
-        if opacity.0 > 0.0 {
+        if color.alpha > 0 {
             let cr = cairo::Context::new(&output_surface);
             let r = cairo::Rectangle::from(bounds);
             cr.rectangle(r.x, r.y, r.width, r.height);
             cr.clip();
 
             cr.set_source_rgba(
-                f64::from(color.red) / 255f64,
-                f64::from(color.green) / 255f64,
-                f64::from(color.blue) / 255f64,
-                opacity.0,
+                f64::from(color.red_f32()),
+                f64::from(color.green_f32()),
+                f64::from(color.blue_f32()),
+                f64::from(color.alpha_f32()),
             );
             cr.paint();
         }