freya_core/
render_pipeline.rs

1use freya_engine::prelude::{
2    Canvas,
3    ClipOp,
4    FontCollection,
5    FontMgr,
6    SaveLayerRec,
7    SkMatrix,
8    SkPoint,
9    SkRect,
10    blur,
11};
12
13use crate::{
14    element::{
15        ClipContext,
16        RenderContext,
17    },
18    prelude::Color,
19    tree::Tree,
20};
21
22pub struct RenderPipeline<'a> {
23    pub font_collection: &'a mut FontCollection,
24    pub font_manager: &'a FontMgr,
25    pub canvas: &'a Canvas,
26    pub tree: &'a Tree,
27    pub scale_factor: f64,
28    pub background: Color,
29}
30
31impl RenderPipeline<'_> {
32    #[cfg_attr(feature = "hotpath", hotpath::measure)]
33    pub fn render(self) {
34        self.canvas.clear(self.background);
35
36        // TODO: Use incremental rendering
37        for i16 in itertools::sorted(self.tree.layers.keys()) {
38            let nodes = self.tree.layers.get(i16).unwrap();
39            'rendering: for node_id in nodes {
40                let layer = self.canvas.save();
41
42                let element = self.tree.elements.get(node_id).unwrap();
43                let text_style_state = self.tree.text_style_state.get(node_id).unwrap();
44                let layout_node = self.tree.layout.get(node_id).unwrap();
45                let effect_state = self.tree.effect_state.get(node_id);
46
47                if let Some(effect_state) = effect_state {
48                    let mut visible_area = layout_node.visible_area();
49
50                    // Transform the element area given the scale effects
51                    for id in effect_state.scales.iter() {
52                        let layout_node = self.tree.layout.get(id).unwrap();
53                        let effect = self.tree.effect_state.get(id).unwrap();
54                        let area = layout_node.visible_area();
55                        let center = area.center();
56                        let scale = effect.scale.unwrap();
57
58                        visible_area = visible_area.translate(-center.to_vector());
59                        visible_area = visible_area.scale(scale.x, scale.y);
60                        visible_area = visible_area.translate(center.to_vector());
61                    }
62
63                    hotpath::measure_block!("Element Clipping", {
64                        for clip_node_id in effect_state.clips.iter() {
65                            let clip_element = self.tree.elements.get(clip_node_id).unwrap();
66                            let clip_layout_node = self.tree.layout.get(clip_node_id).unwrap();
67                            let clip_effect = self.tree.effect_state.get(clip_node_id).unwrap();
68
69                            let mut transformed_clip_area = clip_layout_node.visible_area();
70
71                            // For every clip area that his element gets we also need to apply the effects to each one so that
72                            // we can properly assume whether this element is actually visible or not
73                            for id in clip_effect.scales.iter() {
74                                let scale_layout_node = self.tree.layout.get(id).unwrap();
75                                let scale_effect = self.tree.effect_state.get(id).unwrap();
76                                let area = scale_layout_node.visible_area();
77                                let center = area.center();
78                                let scale = scale_effect.scale.unwrap();
79
80                                transformed_clip_area =
81                                    transformed_clip_area.translate(-center.to_vector());
82                                transformed_clip_area =
83                                    transformed_clip_area.scale(scale.x, scale.y);
84                                transformed_clip_area =
85                                    transformed_clip_area.translate(center.to_vector());
86                            }
87
88                            // No need to render this element as it is completely clipped
89                            if !visible_area.intersects(&transformed_clip_area) {
90                                self.canvas.restore_to_count(layer);
91                                continue 'rendering;
92                            }
93
94                            let clip_context = ClipContext {
95                                canvas: self.canvas,
96                                visible_area: &transformed_clip_area,
97                                scale_factor: self.scale_factor,
98                            };
99
100                            clip_element.clip(clip_context);
101                        }
102                    });
103
104                    // Pass rotate effect to children
105                    for id in effect_state.rotations.iter() {
106                        let layout_node = self.tree.layout.get(id).unwrap();
107                        let effect = self.tree.effect_state.get(id).unwrap();
108                        let area = layout_node.visible_area();
109                        let mut matrix = SkMatrix::new_identity();
110                        matrix.set_rotate(
111                            effect.rotation.unwrap(),
112                            Some(SkPoint {
113                                x: area.min_x() + area.width() / 2.0,
114                                y: area.min_y() + area.height() / 2.0,
115                            }),
116                        );
117                        self.canvas.concat(&matrix);
118                    }
119
120                    // Apply inherited opacity effects
121                    let rect = SkRect::new(
122                        visible_area.min_x(),
123                        visible_area.min_y(),
124                        visible_area.max_x(),
125                        visible_area.max_y(),
126                    );
127                    for opacity in effect_state.opacities.iter() {
128                        self.canvas.save_layer_alpha_f(rect, *opacity);
129                    }
130
131                    // Transform the canvas area given the scale effects
132                    for id in effect_state.scales.iter() {
133                        let layout_node = self.tree.layout.get(id).unwrap();
134                        let effect = self.tree.effect_state.get(id).unwrap();
135                        let area = layout_node.visible_area();
136                        let center = area.center();
137                        let scale = effect.scale.unwrap();
138
139                        self.canvas.translate((center.x, center.y));
140                        self.canvas.scale((scale.x, scale.y));
141                        self.canvas.translate((-center.x, -center.y));
142                    }
143
144                    // Apply inherited blur effects
145                    for id in effect_state.blurs.iter() {
146                        let layout_node = self.tree.layout.get(id).unwrap();
147                        let effect = self.tree.effect_state.get(id).unwrap();
148                        let element = self.tree.elements.get(id).unwrap();
149                        let area = layout_node.visible_area();
150                        let style = element.style();
151                        let render_rect = element.render_rect(&area, self.scale_factor as f32);
152                        let blur_radius = effect.blur.unwrap();
153                        let image_filter = blur(
154                            (
155                                blur_radius * self.scale_factor as f32,
156                                blur_radius * self.scale_factor as f32,
157                            ),
158                            None,
159                            None,
160                            render_rect.rect(),
161                        );
162                        if let Some(image_filter) = image_filter {
163                            let rec = SaveLayerRec::default()
164                                .bounds(&rect)
165                                .backdrop(&image_filter);
166                            if style.corner_radius.is_round() {
167                                self.canvas.clip_rrect(render_rect, ClipOp::Intersect, true);
168                                self.canvas.save_layer(&rec);
169                                self.canvas.restore();
170                                self.canvas.restore();
171                            } else {
172                                self.canvas.save_layer(&rec);
173                                self.canvas.restore();
174                            }
175                        }
176                    }
177                }
178
179                let render_context = RenderContext {
180                    font_collection: self.font_collection,
181                    canvas: self.canvas,
182                    layout_node,
183                    tree: self.tree,
184                    text_style_state,
185                    scale_factor: self.scale_factor,
186                };
187
188                hotpath::measure_block!("Element Render", {
189                    element.render(render_context);
190                });
191
192                self.canvas.restore_to_count(layer);
193            }
194        }
195    }
196}
freya_core/render_pipeline.rs

freya_core/
render_pipeline.rs
