carnelian/render/
dynamic.rs

1// Copyright 2020 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::color::Color;
6use crate::render::generic::forma::*;
7use crate::render::generic::{
8    self, Composition as _, Context as _, PathBuilder as _, Raster as _, RasterBuilder as _,
9};
10pub use crate::render::generic::{BlendMode, Fill, FillRule, Gradient, GradientType, Order, Style};
11use crate::{Point, ViewAssistantContext};
12use anyhow::Error;
13use display_utils::PixelFormat;
14use euclid::default::{Point2D, Rect, Size2D, Transform2D, Vector2D};
15use euclid::{point2, size2};
16use std::io::Read;
17use std::ops::Add;
18use std::{mem, u32};
19/// Rendering context and API start point.
20#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
21pub struct Image {
22    inner: ImageInner,
23}
24#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
25enum ImageInner {
26    Forma(FormaImage),
27}
28/// Rectangular copy region.
29#[derive(Clone, Copy, Debug, PartialEq)]
30pub struct CopyRegion {
31    /// Top-left origin of source rectangle.
32    pub src_offset: Point2D<u32>,
33    /// Top-left origin of destination rectangle.
34    pub dst_offset: Point2D<u32>,
35    /// Size of both source and destination rectangles.
36    pub extent: Size2D<u32>,
37}
38/// Rendering extensions.
39#[derive(Clone, Debug, Default, PartialEq)]
40pub struct RenderExt {
41    /// Clears render image before rendering.
42    pub pre_clear: Option<PreClear>,
43    /// Copies from source image to render image before rendering.
44    pub pre_copy: Option<PreCopy>,
45    /// Copies from render image to destination image after rendering.
46    pub post_copy: Option<PostCopy>,
47}
48/// Pre-render image clear.
49#[derive(Clone, Debug, PartialEq)]
50pub struct PreClear {
51    /// Clear color.
52    pub color: Color,
53}
54/// Pre-render image copy.
55#[derive(Clone, Debug, PartialEq)]
56pub struct PreCopy {
57    /// Source image to copy from.
58    pub image: Image,
59    /// Copy region properties.
60    pub copy_region: CopyRegion,
61}
62/// Post-render image copy.
63#[derive(Clone, Debug, PartialEq)]
64pub struct PostCopy {
65    /// Destination image to copy to. Must be different from render image.
66    pub image: Image,
67    /// Copy region properties.
68    pub copy_region: CopyRegion,
69}
70/// Rendering context and API start point.
71#[derive(Debug)]
72pub struct Context {
73    pub inner: ContextInner,
74}
75#[derive(Debug)]
76pub enum ContextInner {
77    Forma(FormaContext),
78}
79impl Context {
80    /// Returns the context's pixel format.
81    pub fn pixel_format(&self) -> PixelFormat {
82        match &self.inner {
83            ContextInner::Forma(context) => context.pixel_format(),
84        }
85    }
86    /// Optionally returns a `PathBuilder`. May return `None` of old builder is still alive.
87    pub fn path_builder(&self) -> Option<PathBuilder> {
88        match &self.inner {
89            ContextInner::Forma(context) => context
90                .path_builder()
91                .map(|path_builder| PathBuilder { inner: PathBuilderInner::Forma(path_builder) }),
92        }
93    }
94    /// Optionally returns a `RasterBuilder`. May return `None` of old builder is still alive.
95    pub fn raster_builder(&self) -> Option<RasterBuilder> {
96        match &self.inner {
97            ContextInner::Forma(context) => context.raster_builder().map(|raster_builder| {
98                RasterBuilder { inner: RasterBuilderInner::Forma(raster_builder) }
99            }),
100        }
101    }
102    /// Creates a new image with `size`.
103    pub fn new_image(&mut self, size: Size2D<u32>) -> Image {
104        match &mut self.inner {
105            ContextInner::Forma(ref mut context) => {
106                Image { inner: ImageInner::Forma(context.new_image(size)) }
107            }
108        }
109    }
110    /// Creates a new image from PNG `reader`.
111    pub fn new_image_from_png<R: Read>(
112        &mut self,
113        reader: &mut png::Reader<R>,
114    ) -> Result<Image, Error> {
115        Ok(Image {
116            inner: match &mut self.inner {
117                ContextInner::Forma(ref mut context) => {
118                    ImageInner::Forma(context.new_image_from_png(reader)?)
119                }
120            },
121        })
122    }
123    /// Returns the image at `image_index`.
124    pub fn get_image(&mut self, image_index: u32) -> Image {
125        match &mut self.inner {
126            ContextInner::Forma(ref mut render_context) => {
127                Image { inner: ImageInner::Forma(render_context.get_image(image_index)) }
128            }
129        }
130    }
131    /// Returns the `context`'s current image.
132    pub fn get_current_image(&mut self, context: &ViewAssistantContext) -> Image {
133        match &mut self.inner {
134            ContextInner::Forma(ref mut render_context) => {
135                Image { inner: ImageInner::Forma(render_context.get_current_image(context)) }
136            }
137        }
138    }
139
140    /// Renders the composition with an optional clip to the image.
141    pub fn render(
142        &mut self,
143        composition: &mut Composition,
144        clip: Option<Rect<u32>>,
145        image: Image,
146        ext: &RenderExt,
147    ) {
148        self.render_with_clip(
149            composition,
150            clip.unwrap_or_else(|| {
151                Rect::new(point2(u32::MIN, u32::MIN), size2(u32::MAX, u32::MAX))
152            }),
153            image,
154            ext,
155        );
156    }
157    /// Renders the composition with a clip to the image.
158    pub fn render_with_clip(
159        &mut self,
160        composition: &mut Composition,
161        clip: Rect<u32>,
162        image: Image,
163        ext: &RenderExt,
164    ) {
165        let background_color = composition.background_color;
166
167        match &mut self.inner {
168            ContextInner::Forma(ref mut context) => {
169                let ImageInner::Forma(image) = image.inner;
170                let ext = generic::RenderExt {
171                    pre_clear: ext
172                        .pre_clear
173                        .clone()
174                        .map(|pre_clear| generic::PreClear { color: pre_clear.color }),
175                    pre_copy: ext.pre_copy.clone().map(|pre_copy| generic::PreCopy {
176                        image: image,
177                        copy_region: generic::CopyRegion {
178                            src_offset: pre_copy.copy_region.src_offset,
179                            dst_offset: pre_copy.copy_region.dst_offset,
180                            extent: pre_copy.copy_region.extent,
181                        },
182                    }),
183                    post_copy: ext.post_copy.clone().map(|post_copy| generic::PostCopy {
184                        image: image,
185                        copy_region: generic::CopyRegion {
186                            src_offset: post_copy.copy_region.src_offset,
187                            dst_offset: post_copy.copy_region.dst_offset,
188                            extent: post_copy.copy_region.extent,
189                        },
190                    }),
191                };
192                composition.with_inner_composition(|inner| {
193                    let mut composition = match inner {
194                        CompositionInner::Forma(composition) => composition,
195                        CompositionInner::Empty => FormaComposition::new(background_color),
196                    };
197                    context.render_with_clip(&mut composition, clip, image, &ext);
198                    CompositionInner::Forma(composition)
199                });
200            }
201        }
202    }
203}
204/// Closed path built by a `PathBuilder`.
205#[derive(Clone, Debug, Eq, PartialEq)]
206pub struct Path {
207    inner: PathInner,
208}
209#[derive(Clone, Debug, Eq, PartialEq)]
210enum PathInner {
211    Forma(FormaPath),
212}
213/// Builds one closed path.
214#[derive(Debug)]
215pub struct PathBuilder {
216    inner: PathBuilderInner,
217}
218#[derive(Debug)]
219enum PathBuilderInner {
220    Forma(FormaPathBuilder),
221}
222impl PathBuilder {
223    /// Move end-point to.
224    pub fn move_to(&mut self, point: Point) -> &mut Self {
225        match &mut self.inner {
226            PathBuilderInner::Forma(ref mut path_builder) => {
227                path_builder.move_to(point);
228            }
229        }
230        self
231    }
232    /// Create line from end-point to point and update end-point.
233    pub fn line_to(&mut self, point: Point) -> &mut Self {
234        match &mut self.inner {
235            PathBuilderInner::Forma(ref mut path_builder) => {
236                path_builder.line_to(point);
237            }
238        }
239        self
240    }
241    /// Create quadratic Bézier from end-point to `p2` with `p1` as control point.
242    pub fn quad_to(&mut self, p1: Point, p2: Point) -> &mut Self {
243        match &mut self.inner {
244            PathBuilderInner::Forma(ref mut path_builder) => {
245                path_builder.quad_to(p1, p2);
246            }
247        }
248        self
249    }
250    /// Create cubic Bézier from end-point to `p3` with `p1` and `p2` as control points.
251    pub fn cubic_to(&mut self, p1: Point, p2: Point, p3: Point) -> &mut Self {
252        match &mut self.inner {
253            PathBuilderInner::Forma(ref mut path_builder) => {
254                path_builder.cubic_to(p1, p2, p3);
255            }
256        }
257        self
258    }
259    /// Create rational quadratic Bézier from end-point to `p2` with `p1` as control point
260    /// and `w` as its weight.
261    pub fn rat_quad_to(&mut self, p1: Point, p2: Point, w: f32) -> &mut Self {
262        match &mut self.inner {
263            PathBuilderInner::Forma(ref mut path_builder) => {
264                path_builder.rat_quad_to(p1, p2, w);
265            }
266        }
267        self
268    }
269    /// Create rational cubic Bézier from end-point to `p3` with `p1` and `p2` as control
270    /// points, and `w1` and `w2` their weights.
271    pub fn rat_cubic_to(&mut self, p1: Point, p2: Point, p3: Point, w1: f32, w2: f32) -> &mut Self {
272        match &mut self.inner {
273            PathBuilderInner::Forma(ref mut path_builder) => {
274                path_builder.rat_cubic_to(p1, p2, p3, w1, w2);
275            }
276        }
277        self
278    }
279    /// Closes the path with a line if not yet closed and builds the path.
280    ///
281    /// Consumes the builder; another one can be requested from the `Context`.
282    pub fn build(self) -> Path {
283        match self.inner {
284            PathBuilderInner::Forma(path_builder) => {
285                Path { inner: PathInner::Forma(path_builder.build()) }
286            }
287        }
288    }
289}
290/// Raster built by a `RasterBuilder`.
291#[derive(Clone, Debug, Eq, PartialEq)]
292pub struct Raster {
293    inner: RasterInner,
294}
295#[derive(Clone, Debug, Eq, PartialEq)]
296enum RasterInner {
297    Forma(FormaRaster),
298}
299impl Raster {
300    /// Translate raster.
301    pub fn translate(self, translation: Vector2D<i32>) -> Self {
302        match self.inner {
303            RasterInner::Forma(raster) => {
304                Raster { inner: RasterInner::Forma(raster.translate(translation)) }
305            }
306        }
307    }
308}
309impl Add for Raster {
310    type Output = Self;
311    fn add(self, other: Self) -> Self::Output {
312        let RasterInner::Forma(other_raster) = other.inner;
313        match self.inner {
314            RasterInner::Forma(raster) => {
315                Raster { inner: RasterInner::Forma(raster + other_raster) }
316            }
317        }
318    }
319}
320/// Builds one Raster.
321#[derive(Debug)]
322pub struct RasterBuilder {
323    inner: RasterBuilderInner,
324}
325#[derive(Debug)]
326enum RasterBuilderInner {
327    Forma(FormaRasterBuilder),
328}
329impl RasterBuilder {
330    /// Add a path to the raster with optional transform.
331    pub fn add(&mut self, path: &Path, transform: Option<&Transform2D<f32>>) -> &mut Self {
332        #[allow(clippy::or_fun_call)] // TODO(https://fxbug.dev/379717231)
333        self.add_with_transform(path, transform.unwrap_or(&Transform2D::identity()))
334    }
335    /// Add a path to the raster with transform.
336    pub fn add_with_transform(&mut self, path: &Path, transform: &Transform2D<f32>) -> &mut Self {
337        match &mut self.inner {
338            RasterBuilderInner::Forma(ref mut raster_builder) => {
339                let PathInner::Forma(path) = &path.inner;
340                raster_builder.add_with_transform(path, transform);
341            }
342        }
343        self
344    }
345    /// Builds the raster.
346    ///
347    /// Consumes the builder; another one can be requested from the `Context`.
348    pub fn build(self) -> Raster {
349        match self.inner {
350            RasterBuilderInner::Forma(raster_builder) => {
351                Raster { inner: RasterInner::Forma(raster_builder.build()) }
352            }
353        }
354    }
355}
356
357#[derive(Clone, Debug)]
358pub struct Layer {
359    /// Layer raster.
360    pub raster: Raster,
361    /// Layer clip.
362    pub clip: Option<Raster>,
363    /// Layer style.
364    pub style: Style, // Will also contain txty when available.
365}
366#[derive(Debug)]
367/// A group of ordered layers.
368pub struct Composition {
369    inner: CompositionInner,
370    background_color: Color,
371}
372#[derive(Debug)]
373enum CompositionInner {
374    Forma(FormaComposition),
375    Empty,
376}
377impl Composition {
378    /// Creates a composition of ordered layers where the layers with lower index appear on top.
379    pub fn new(background_color: Color) -> Self {
380        Self { inner: CompositionInner::Empty, background_color }
381    }
382    fn with_inner_composition(&mut self, mut f: impl FnMut(CompositionInner) -> CompositionInner) {
383        let inner = f(mem::replace(&mut self.inner, CompositionInner::Empty));
384        self.inner = inner;
385    }
386    /// Resets composition by removing all layers.
387    pub fn clear(&mut self) {
388        match &mut self.inner {
389            CompositionInner::Forma(composition) => composition.clear(),
390            CompositionInner::Empty => (),
391        }
392    }
393    /// Insert layer into composition.
394    pub fn insert(&mut self, order: Order, layer: Layer) {
395        if let CompositionInner::Empty = self.inner {
396            match layer {
397                Layer { raster: Raster { inner: RasterInner::Forma(_) }, .. } => {
398                    self.inner =
399                        CompositionInner::Forma(FormaComposition::new(self.background_color));
400                }
401            }
402        }
403        match &mut self.inner {
404            CompositionInner::Forma(composition) => composition.insert(
405                order,
406                generic::Layer {
407                    raster: {
408                        let RasterInner::Forma(raster) = layer.raster.inner;
409                        raster
410                    },
411                    clip: layer.clip.map(|clip| {
412                        let RasterInner::Forma(clip) = clip.inner;
413                        clip
414                    }),
415                    style: layer.style,
416                },
417            ),
418            _ => unreachable!(),
419        }
420    }
421    /// Remove layer from composition.
422    pub fn remove(&mut self, order: Order) {
423        match &mut self.inner {
424            CompositionInner::Forma(composition) => composition.remove(order),
425            _ => (),
426        }
427    }
428}
carnelian/render/dynamic.rs

carnelian/render/
dynamic.rs
