blade-macros 0.3.0

Macros helpers for Blade users
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

mod as_primitive;
mod flat;
mod shader_data;
mod vertex;

use proc_macro::TokenStream;

/// Derive the `ShaderData` trait for a struct
///
/// ## Example
///
/// ```rust
/// #[derive(blade_macros::ShaderData)]
/// struct Test {
///   sm: blade_graphics::Sampler,
/// }
/// ```
#[proc_macro_derive(ShaderData)]
pub fn shader_data_derive(input: TokenStream) -> TokenStream {
    let stream = match shader_data::generate(input) {
        Ok(tokens) => tokens,
        Err(err) => err.into_compile_error(),
    };
    stream.into()
}

/// Derive the `Vertex` trait for a struct.
///
/// ## Example
///
/// ```rust
/// #[derive(blade_macros::Vertex)]
/// struct Test {
///   pos: [f32; 3],
///   tc: mint::Vector2<f32>,
/// }
/// ```
#[proc_macro_derive(Vertex)]
pub fn vertex_derive(input: TokenStream) -> TokenStream {
    let stream = match vertex::generate(input) {
        Ok(tokens) => tokens,
        Err(err) => err.into_compile_error(),
    };
    stream.into()
}

/// Derive the `Flat` for a type.
///
/// Can either be used on a struct that has every field already implementing `blade_asset::Flat`:
///
/// ```rust
/// #[derive(blade_macros::Flat)]
/// struct FlatData<'a> {
///    array: [u32; 2],
///    single: f32,
///    slice: &'a [u16],
///}
/// ```
///
/// The struct may have a lifetime describing borrowed data members. Borrowing is
/// needed for zero-copy deserialization.
///
/// Alternatively, can be used on a transparent wrapper to force `blade_asset::Flat`
/// implementation even if the wrapped type doesn't implement it:
///
/// ```rust
/// #[derive(Clone, Copy)]
/// #[repr(u32)]
/// #[non_exhaustive]
/// enum Foo {
///     A,
///     B,
/// }
/// #[derive(blade_macros::Flat, Clone, Copy)]
/// #[repr(transparent)]
/// struct FooWrap(Foo);
/// ```
///
/// This can be particularly useful for types like `bytemuck::Pod` implementors,
/// or plain non-exhaustive enums from 3rd party crates.
#[proc_macro_derive(Flat)]
pub fn flat_derive(input: TokenStream) -> TokenStream {
    let stream = match flat::generate(input) {
        Ok(tokens) => tokens,
        Err(err) => err.into_compile_error(),
    };
    stream.into()
}

/// Derive the `Into<primitive>` trait for an enum
///
/// ## Example
///
/// ```rust
/// #[derive(blade_macros::AsPrimitive)]
/// #[repr(u32)]
/// enum Foo {
///   A,
///   B,
/// }
/// ```
#[proc_macro_derive(AsPrimitive)]
pub fn as_primitive_derive(input: TokenStream) -> TokenStream {
    let stream = match as_primitive::generate(input) {
        Ok(tokens) => tokens,
        Err(err) => err.into_compile_error(),
    };
    stream.into()
}