telar-renderer-core 0.1.5

Renderer-agnostic drawing vocabulary for Telar: draw commands, culling, dirty tracking and GPU sync.
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

use geometry_core::{Point, Rect};

use super::gradient::{Gradient, GradientKind};
use super::paint::{Paint, Shadow, Stroke};
use super::shape::{BorderWidths, PathStyle, RectStyle};
use super::{Scale, TextStyle};
use crate::BorderRadius;

// `Scale` is local to renderer-core, so the orphan rules permit implementing it for these foreign value types here rather than adding arithmetic to the geometry-core crate.
impl Scale for Point {
    fn scale(self, sf: f32) -> Self {
        Point::new(self.x * sf, self.y * sf)
    }
}

impl Scale for Rect {
    fn scale(self, sf: f32) -> Self {
        Rect::new(self.x * sf, self.y * sf, self.width * sf, self.height * sf)
    }
}

impl Scale for Paint {
    fn scale(self, sf: f32) -> Self {
        match self {
            Paint::Solid(_) => self,
            Paint::Gradient(g) => Paint::Gradient(Gradient {
                kind: match g.kind {
                    GradientKind::Linear { start, end } => GradientKind::Linear {
                        start: start.scale(sf),
                        end: end.scale(sf),
                    },
                    GradientKind::Radial { center, radius } => GradientKind::Radial {
                        center: center.scale(sf),
                        radius: radius * sf,
                    },
                },
                stops: g.stops,
            }),
        }
    }
}

impl Scale for Stroke {
    fn scale(self, sf: f32) -> Self {
        Stroke {
            paint: self.paint.scale(sf),
            width: self.width * sf,
            cap: self.cap,
            join: self.join,
        }
    }
}

impl Scale for Shadow {
    fn scale(self, sf: f32) -> Self {
        Shadow {
            offset_x: self.offset_x * sf,
            offset_y: self.offset_y * sf,
            blur_radius: self.blur_radius * sf,
            spread: self.spread * sf,
            color: self.color,
        }
    }
}

impl Scale for BorderRadius {
    fn scale(self, sf: f32) -> Self {
        BorderRadius {
            top_left: self.top_left * sf,
            top_right: self.top_right * sf,
            bottom_right: self.bottom_right * sf,
            bottom_left: self.bottom_left * sf,
        }
    }
}

impl Scale for BorderWidths {
    fn scale(self, sf: f32) -> Self {
        match self {
            // Uniform carries no number of its own: it defers to the stroke, which scales itself.
            BorderWidths::Uniform => self,
            BorderWidths::PerSide {
                top,
                right,
                bottom,
                left,
            } => BorderWidths::PerSide {
                top: top * sf,
                right: right * sf,
                bottom: bottom * sf,
                left: left * sf,
            },
        }
    }
}

impl Scale for RectStyle {
    fn scale(self, sf: f32) -> Self {
        RectStyle {
            fill: self.fill.map(|p| p.scale(sf)),
            stroke: self.stroke.map(|s| s.scale(sf)),
            shadow: self.shadow.map(|s| s.scale(sf)),
            radius: self.radius.scale(sf),
            border_widths: self.border_widths.scale(sf),
        }
    }
}

impl Scale for PathStyle {
    fn scale(self, sf: f32) -> Self {
        PathStyle {
            fill: self.fill.map(|p| p.scale(sf)),
            stroke: self.stroke.map(|s| s.scale(sf)),
            shadow: self.shadow.map(|s| s.scale(sf)),
            fill_rule: self.fill_rule,
        }
    }
}

impl Scale for TextStyle {
    fn scale(self, sf: f32) -> Self {
        TextStyle {
            font_size: self.font_size * sf,
            paint: self.paint.scale(sf),
            shadow: self.shadow.map(|s| s.scale(sf)),
            // letter_spacing is a pixel advance, so it scales with font_size; line_height is a unitless multiple and rides along via `..self`.
            letter_spacing: self.letter_spacing * sf,
            ..self
        }
    }
}