alpha2-engine 0.2.0

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
131
132
133
134
135

//! Generated sources as parameters of the renderer's generator pass.

use alpha2_model::{GeneratedShape, Generator, GradientStop, Paint, Rgba, Spread, Vec2};
use alpha2_render::{
    EffectParams, FILL_PAINT_PARAMS, MAX_GENERATOR_STOPS, PaintParams, ParamValue,
    STROKE_PAINT_PARAMS,
};

// Every stop a valid project holds reaches the pass.
const _: () = assert!(alpha2_model::MAX_GRADIENT_STOPS <= MAX_GENERATOR_STOPS);

/// Parameters one generator sets at most: its shape's six and each paint's
/// seven plus a color per stop.
const MAX_GENERATOR_PARAMS: usize = 6 + 2 * (7 + MAX_GENERATOR_STOPS);

/// The generator pass's parameters for `generator`. Every name is static, so
/// the list holding them is all this allocates.
pub(crate) fn generator_params(generator: &Generator) -> EffectParams<'static> {
    let params = EffectParams::with_capacity(MAX_GENERATOR_PARAMS);
    match generator {
        Generator::Fill { paint } => with_paint(
            params.with("shape", ParamValue::Enum(0)),
            &FILL_PAINT_PARAMS,
            paint,
        ),
        Generator::Shape {
            shape,
            center,
            size,
            rotation_degrees,
            fill,
            stroke,
        } => {
            let (kind, radius) = match *shape {
                GeneratedShape::Rectangle { corner_radius } => (1, corner_radius),
                GeneratedShape::Ellipse => (2, 0.0),
            };
            let mut params = params
                .with("shape", ParamValue::Enum(kind))
                .with("center", vec2(*center))
                .with("size", vec2(*size))
                .with("rotation", ParamValue::Float(rotation_degrees.to_radians()))
                .with("radius", ParamValue::Float(radius));
            if let Some(fill) = fill {
                params = with_paint(params, &FILL_PAINT_PARAMS, fill);
            }
            if let Some(stroke) = stroke {
                params = with_paint(
                    params.with("stroke_width", ParamValue::Float(stroke.width)),
                    &STROKE_PAINT_PARAMS,
                    &stroke.paint,
                );
            }
            params
        }
        // Text is drawn from its prepared texture (`frame::PlacedText`), never by the pass.
        Generator::Text { .. } => params,
    }
}

const fn vec2(value: Vec2) -> ParamValue {
    ParamValue::Vec2([value.x, value.y])
}

const fn color(value: Rgba) -> ParamValue {
    ParamValue::Color([value.red, value.green, value.blue, value.alpha])
}

const fn spread(value: Spread) -> u32 {
    match value {
        Spread::Pad => 0,
        Spread::Repeat => 1,
        Spread::Reflect => 2,
    }
}

fn with_paint(
    params: EffectParams<'static>,
    names: &PaintParams,
    paint: &Paint,
) -> EffectParams<'static> {
    let (kind, a, b, spread, stops): (u32, Vec2, Vec2, u32, &[GradientStop]) = match paint {
        Paint::Solid { color: value } => {
            return params
                .with(names.kind, ParamValue::Enum(1))
                .with(names.count, ParamValue::Float(1.0))
                .with(names.colors[0], color(*value));
        }
        Paint::LinearGradient {
            start,
            end,
            stops,
            spread: mode,
        } => (2, *start, *end, spread(*mode), stops),
        Paint::RadialGradient {
            center,
            radius,
            stops,
            spread: mode,
        } => (3, *center, Vec2::new(*radius, 0.0), spread(*mode), stops),
        Paint::ConicGradient {
            center,
            angle_degrees,
            stops,
        } => (
            4,
            *center,
            Vec2::new(angle_degrees.to_radians(), 0.0),
            0,
            stops,
        ),
    };
    let mut offsets = [0.0_f32; MAX_GENERATOR_STOPS];
    let mut params = params
        .with(names.kind, ParamValue::Enum(kind))
        .with(names.a, vec2(a))
        .with(names.b, vec2(b))
        .with(names.spread, ParamValue::Enum(spread));
    for ((stop, name), offset) in stops.iter().zip(names.colors).zip(&mut offsets) {
        *offset = stop.offset;
        params.insert(name, color(stop.color));
    }
    #[allow(clippy::cast_precision_loss)]
    let count = stops.len().min(MAX_GENERATOR_STOPS) as f32;
    params
        .with(names.count, ParamValue::Float(count))
        .with(
            names.offsets0,
            ParamValue::Vec4([offsets[0], offsets[1], offsets[2], offsets[3]]),
        )
        .with(
            names.offsets1,
            ParamValue::Vec4([offsets[4], offsets[5], offsets[6], offsets[7]]),
        )
}