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
136
137
138
139

//! Macros that make it easier to load resources.
//!
//! All require the [crate::start_engine] macro to be executed before usage.
//!
//! All the macros are just a shortening of `any Resource`::new(data, &[Resources](crate::prelude::Resources)).

/// Loads a model to the engine using the vertex and index data of the inserted
/// [Data](crate::prelude::Data) and returns a [Model](crate::prelude::Model).
#[macro_export]
macro_rules! model {
    ($data:expr) => {{
        let_engine::prelude::Model::new($data, &RESOURCES)
    }};
}

/// Loads a font to the engine using binary true type font data of the inserted
/// `&[u8]` and returns an [`Option<Font>`](crate::prelude::Font).
///
/// Returns `None` in case the provided bytes don't work.
#[macro_export]
macro_rules! font {
    ($data:expr) => {{
        let_engine::prelude::Font::from_bytes($data, &RESOURCES)
    }};
}

/// Loads a texture to the engine using one of
/// the supported file formats and returns a [Texture](crate::prelude::Texture).
#[macro_export]
macro_rules! texture {
    (
        $data:expr,
        $image_format:expr,
        $settings:expr,
    ) => {{
        let_engine::prelude::Texture::from_bytes($data, $image_format, 1, $settings, &RESOURCES)
    }};
    (
        $data:expr,
        $image_format:expr,
        $layers:expr,
        $settings:expr,
    ) => {{
        let_engine::prelude::Texture::from_bytes(
            $data,
            $image_format,
            $layers,
            $settings,
            &RESOURCES,
        )
    }};
}

/// Loads a texture to the engine using raw image bytes and context and returns a [Texture](crate::prelude::Texture).
#[macro_export]
macro_rules! texture_from_raw {
    (
        $data:expr,
        $dimensions:expr,
        $format:expr,
        $settings:expr,
    ) => {{
        let_engine::prelude::Texture::from_raw(
            $data,
            $dimensions,
            $format,
            1,
            $settings,
            &RESOURCES,
        )
    }};
    (
        $data:expr,
        $dimensions:expr,
        $format:expr,
        $layers:expr,
        $settings:expr,
    ) => {{
        let_engine::prelude::Texture::from_raw(
            $data,
            $dimensions,
            $format,
            $layers,
            $settings,
            &RESOURCES,
        )
    }};
}

/// Loads a shader from glsl bytes. Takes `&[u8]` and returns [Shaders](crate::materials::Shaders).
/// Those shaders can be used when making materials.
///
/// # Safety
///
/// Doesn't validate the rightness of the given data.
/// Crashes the program in case the bytes provided aren't spirv.
#[macro_export]
macro_rules! raw_shader {
    (
        $vertex_data:expr,
        $fragment_data:expr,
    ) => {{
        let_engine::prelude::Shaders::from_bytes($vertex_data, $fragment_data, &RESOURCES)
    }};
}

/// Loads a new material.
#[macro_export]
macro_rules! material {
    (
        $settings:expr,
    ) => {{
        let_engine::prelude::Material::new($settings, &RESOURCES)
    }};
    (
        $settings:expr,
        $shaders:expr,
        $descriptor_bindings:expr,
    ) => {{
        let_engine::prelude::Material::new_with_shaders(
            $settings,
            $shaders,
            $descriptor_bindings,
            &RESOURCES,
        )
    }};
}

/// Describes a write operation for a descriptor.
/// Used with materials to interact with custom shaders inside them.
#[macro_export]
macro_rules! write_descriptor {
    (
        $buf:expr,
        $set:expr,
    ) => {{
        RESOURCES.new_descriptor_write($buf, $set)
    }};
}