bevy_resvg 2.3.2

A simple library for rendering SVGs in Bevy using the amazing Resvg library.
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

macro_rules! enum_def {
    // Base case: nothing left to process
    () => {};

    // Match an enum, expand it, then process the rest
    (
        $(#[$struct_meta:meta])*
        $vis:vis enum $name:ident -> $foreign:ident {
            $(
                $(#[$field_meta:meta])*
                $variant_name:ident
            ),* $(,)?
        }
        $($rest:tt)*
    ) => {
        pastey::paste! {
            #[derive(Debug, Serialize, Deserialize, Clone, Copy)]
            #[serde(remote = "" $foreign "")]
            $(#[$struct_meta])*
            $vis enum $name {
                $(
                    $(#[$field_meta])*
                    $variant_name,
                )*
            }
        }

        impl From<$foreign> for $name {
            fn from(value: $foreign) -> Self {
                match value {
                    $(<$foreign>::$variant_name => Self::$variant_name,)*
                }
            }
        }

        impl From<$name> for $foreign {
            fn from(value: $name) -> Self {
                match value {
                    $($name::$variant_name => <$foreign>::$variant_name,)*
                }
            }
        }


        impl Default for $name {
            fn default() -> Self {
                <$foreign>::default().into()
            }
        }

        // Recursively process the remaining tokens
        enum_def!($($rest)*);
    };
}

macro_rules! options_def {
    // Match a struct, expand it
    (
        $(#[$struct_meta:meta])*
        $vis:vis struct $name:ident -> $foreign:ty {
            $(
                $(#[$field_meta:meta])*
                $field_vis:vis $field_name:ident : $field_ty:ty
            ),* $(,)?
        }
        $($rest:tt)*
    ) => {
        #[derive(Debug, Serialize, Deserialize, Clone)]
        $(#[$struct_meta])*
        $vis struct $name {
            $(
                $(#[$field_meta])*
                $field_vis $field_name : $field_ty,
            )*
        }

        impl From<$foreign> for $name {
            fn from(value: $foreign) -> Self {
                Self {
                    $($field_name: value.$field_name,)*
                }
            }
        }

        impl From<$name> for $foreign {
            fn from(value: $name) -> Self {
                Self {
                    $($field_name: value.$field_name,)*
                    ..Default::default()
                }
            }
        }

        impl Default for $name {
            fn default() -> Self {
                <$foreign>::default().into()
            }
        }
    };
}

pub(super) use enum_def;
pub(super) use options_def;