spreet 0.13.1

Create a spritesheet from a set of SVG images
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

use resvg::usvg::Rect;
use serde::ser::SerializeSeq;
use serde::{Serialize, Serializer};

/// Custom Serde field serialiser for [`Rect`].
///
/// Serialises an [`f32`] with a zero fractional part as a [`u32`], and otherwise as an `f32`
/// unchanged. Allows JSON outputted by Spreet to match the JavaScript style of intermingling
/// integers and floats (because there's only one number type in JavaScript).
///
/// Used to serialise a stretchable icon's [content area](`super::Sprite::content_area`). The
/// serialised data is almost always integers (exceptions being transformed or rotated elements) and
/// so it's a waste to serialise the extra `.0` every time.
pub fn serialize_rect<S>(rect: &Option<Rect>, serializer: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    match rect {
        Some(r) => {
            let mut seq = serializer.serialize_seq(Some(4))?;
            for num in [r.left(), r.top(), r.right(), r.bottom()] {
                if num.fract() == 0.0 {
                    seq.serialize_element(&(num.round() as i32))?;
                } else {
                    seq.serialize_element(&((num * 1e3).round() / 1e3))?;
                }
            }
            seq.end()
        }
        None => serializer.serialize_none(),
    }
}

/// Custom Serde field serialiser for a vector of [`Rect`]s.
///
/// Serialises the left and right edges of each `Rect` as a [`u32`] if the value has no fractional
/// part, or an unchanged [`f32`] otherwise. Allows JSON outputted by Spreet to match the JavaScript
/// style of intermingling integers and floats (because there's only one number type in JavaScript).
///
/// Used to serialise a stretchable icon's [stretch-x areas](`super::Sprite::stretch_x_areas`). The
/// serialised data is almost always integers (exceptions being transformed or rotated elements) and
/// so it's a waste to serialise the extra `.0` every time.
pub fn serialize_stretch_x_area<S>(
    rects: &Option<Vec<Rect>>,
    serializer: S,
) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    match rects {
        Some(rects) => {
            let mut seq = serializer.serialize_seq(Some(rects.len()))?;
            for rect in rects {
                let line = [icon_number(rect.left()), icon_number(rect.right())];
                seq.serialize_element(&line)?;
            }
            seq.end()
        }
        None => serializer.serialize_none(),
    }
}

/// Custom Serde field serialiser for a vector of [`Rect`]s.
///
/// Serialises the top and bottom edges of each `Rect` as a [`u32`] if the value has no fractional
/// part, or an unchanged [`f32`] otherwise. Allows JSON outputted by Spreet to match the JavaScript
/// style of intermingling integers and floats (because there's only one number type in JavaScript).
///
/// Used to serialise a stretchable icon's [stretch-y areas](`super::Sprite::stretch_y_areas`). The
/// serialised data is almost always integers (exceptions being transformed or rotated elements) and
/// so it's a waste to serialise the extra `.0` every time.
pub fn serialize_stretch_y_area<S>(
    rects: &Option<Vec<Rect>>,
    serializer: S,
) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    match rects {
        Some(rects) => {
            let mut seq = serializer.serialize_seq(Some(rects.len()))?;
            for rect in rects {
                let line = [icon_number(rect.top()), icon_number(rect.bottom())];
                seq.serialize_element(&line)?;
            }
            seq.end()
        }
        None => serializer.serialize_none(),
    }
}

/// Represents a number, whether integer or floating point, that can be serialised to JSON.
#[derive(Serialize)]
#[serde(untagged)]
enum Number {
    Int(u32),
    Float(f32),
}

/// Converts an [`f32`] to a [`Number`], so it can be serialised to JSON in its most minimal form.
fn icon_number(num: f32) -> Number {
    if num.fract() == 0.0 {
        Number::Int(num.round() as u32)
    } else {
        Number::Float((num * 1e3).round() / 1e3)
    }
}