alpha2-engine 0.4.4

Player and exporter facade for alpha2.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! A prepared layout drawn into the render graph: one composite of its
//! paint list over transparency, as a text generator's picture is.

use super::paint::{PaintItem, Placement};
use crate::TextTexture;
use alpha2_render::{
    BlendMode, GraphError, GraphLayer, LayerTransform, RenderError, RenderGraph, RenderNodeId,
    RenderSize,
};
use std::sync::Arc;

/// A layout resolved and drawn at one render size: its paint list, and the
/// store key of each text node's texture (`None` for empty text).
///
/// A host's [`crate::TextTextures`] prepares it, and lends it to the graph
/// through [`crate::FrameProvider::layout`].
#[derive(Debug)]
pub struct PreparedLayout {
    pub(crate) items: Vec<PaintItem>,
    pub(crate) texts: Vec<Option<u64>>,
}

/// A prepared layout with the textures its text nodes draw.
#[derive(Clone, Debug)]
pub(crate) struct LaidOut<'t> {
    pub(crate) layout: Arc<PreparedLayout>,
    pub(crate) texts: Vec<Option<TextTexture<'t>>>,
}

impl<'t> LaidOut<'t> {
    /// `layout` with its textures from `frames`, or `None` when one is
    /// missing.
    pub(crate) fn attach(
        layout: Arc<PreparedLayout>,
        frames: &'t dyn crate::FrameProvider,
    ) -> Option<Self> {
        let texts = layout
            .texts
            .iter()
            .map(|key| {
                key.map(|key| frames.text(key))
                    .map_or(Some(None), |text| text.map(Some))
            })
            .collect::<Option<Vec<_>>>()?;
        Some(Self { layout, texts })
    }

    /// The layout's picture: its paint list composited over transparency.
    pub(crate) fn add_to(&self, graph: &mut RenderGraph<'t>) -> Result<RenderNodeId, RenderError> {
        let layers = self.layers(graph, &self.layout.items)?;
        graph
            .add_composite(layers)
            .map_err(GraphError::into_render_error)
    }

    fn layers(
        &self,
        graph: &mut RenderGraph<'t>,
        items: &[PaintItem],
    ) -> Result<Vec<GraphLayer>, RenderError> {
        let size = graph.size();
        let canvas = [size.width, size.height];
        let mut layers = Vec::with_capacity(items.len());
        for item in items {
            let (source, place, extent) = match item {
                PaintItem::Vector { scene, place } => {
                    (graph.add_vector(Arc::clone(scene)), *place, canvas)
                }
                PaintItem::Text { index, place } => {
                    let texture = self
                        .texts
                        .get(*index)
                        .copied()
                        .flatten()
                        .ok_or(RenderError::MissingText)?;
                    let source = match texture.cache_key {
                        Some(key) => graph.add_source_with_key(texture.texture, key),
                        None => graph.add_source(texture.texture),
                    };
                    (source, *place, [texture.width, texture.height])
                }
                PaintItem::Group { items, clip, place } => {
                    let inner = self.layers(graph, items)?;
                    let mut node = graph
                        .add_composite(inner)
                        .map_err(GraphError::into_render_error)?;
                    if let Some(clip) = clip {
                        let coverage = graph.add_vector(Arc::clone(clip));
                        node = crate::frame::coverage_mask(
                            graph,
                            node,
                            &[(coverage, false, alpha2_model::MaskMode::Add)],
                        )?;
                    }
                    (node, *place, canvas)
                }
            };
            layers.push(GraphLayer {
                source,
                visual: layer_transform(place, extent, size),
                blend_mode: BlendMode::Normal,
            });
        }
        Ok(layers)
    }
}

/// `place` as the compositor's layer transform, for a source `extent`
/// pixels in size drawn 1:1 on a picture of `size`.
#[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss)]
fn layer_transform(place: Placement, extent: [u32; 2], size: RenderSize) -> LayerTransform {
    let output = [f64::from(size.width), f64::from(size.height)];
    let extent = extent.map(f64::from);
    LayerTransform {
        position: [
            (place.position[0] / output[0]) as f32,
            (place.position[1] / output[1]) as f32,
        ],
        anchor: [
            (place.anchor[0] / extent[0]) as f32,
            (place.anchor[1] / extent[1]) as f32,
        ],
        scale: [
            (place.scale[0] * extent[0] / output[0]) as f32,
            (place.scale[1] * extent[1] / output[1]) as f32,
        ],
        rotation_degrees: place.rotation_degrees as f32,
        opacity: place.opacity,
    }
}