Newer
Older
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
# Micro Game Macros
A collection of utility macros for building games
## Macros
For executable examples, visit the rustdoc and/or read the doctests in `src/lib.rs`
### JSON Loader
Generate a Bevy asset loader for a given asset, supporting JSON files that define a single instance of that asset type, or a
list of that asset type. Instances of an asset need to be identifiable, though the property that is used to identify a particular
asset is customisable
```rust
#[derive(JsonLoader, TypePath, TypeUuid, Serialize, Deserialize)]
#[loader(
extension = "asset.json", uuid = "00000000-0000-0000-0000-000000000000",
storage = inner_module::SimpleAssetLocator,
asset_name = some_asset_prop, index_name = set_of_assets
)]
#[uuid = "00000000-0000-0000-0000-000000000001"]
pub struct MyAsset {
/// The asset identifier needs to implement [std::fmt::Display]
#[asset_id]
uniq_ident: usize,
}
```
### Asset System
Generate a set of structs and systems for managed loading in a Bevy game
```rust
use bevy::prelude::{Image, Res, Resource};
use micro_games_macros::asset_system;
#[asset_system]
pub struct AssetHandles {
my_asset: Image,
}
pub fn loading_system(mut loader: AssetHandlesLoader) {
loader.load_my_asset("path/to/asset.png", "Asset");
}
pub fn use_asset_system(assets: Res<AssetHandles>) {
let handle = assets.my_asset("Asset");
}
```
### From Inner
Derive an impl of `From<T>` for structs that wrap a single inner type (Tuple and Named Property structs are supported)
```rust
use micro_game_macros::FromInner;
#[derive(FromInner)]
struct MyType(usize);
fn example() {
let value = MyType::from(123usize);
}
```
### Kayak Widget
A simple derive for Kayak UI's "Widget" trait
```rust
use micro_game_macros::Widget;
#[derive(Widget)]
struct MyComponent;
// ... Other Kayak Setup ...
```