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
//! Shows how to modify texture assets after spawning.
use bevy::{
asset::RenderAssetUsages, image::ImageLoaderSettings,
input::common_conditions::input_just_pressed, prelude::*,
};
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_systems(Startup, (setup, spawn_text))
.add_systems(
Update,
alter_handle.run_if(input_just_pressed(KeyCode::Space)),
)
.add_systems(
Update,
alter_asset.run_if(input_just_pressed(KeyCode::Enter)),
)
.run();
}
#[derive(Component, Debug)]
enum Bird {
Normal,
Logo,
}
impl Bird {
fn get_texture_path(&self) -> String {
match self {
Bird::Normal => "branding/bevy_bird_dark.png".into(),
Bird::Logo => "branding/bevy_logo_dark.png".into(),
}
}
fn set_next_variant(&mut self) {
*self = match self {
Bird::Normal => Bird::Logo,
Bird::Logo => Bird::Normal,
}
}
}
#[derive(Component, Debug)]
struct Left;
fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
let bird_left = Bird::Normal;
let bird_right = Bird::Normal;
commands.spawn(Camera2d);
let texture_left = asset_server.load_with_settings(
bird_left.get_texture_path(),
// `RenderAssetUsages::all()` is already the default, so the line below could be omitted.
// It's helpful to know it exists, however.
//
// `RenderAssetUsages` tell Bevy whether to keep the data around:
// - for the GPU (`RenderAssetUsages::RENDER_WORLD`),
// - for the CPU (`RenderAssetUsages::MAIN_WORLD`),
// - or both.
// `RENDER_WORLD` is necessary to render the image, `MAIN_WORLD` is necessary to inspect
// and modify the image (via `ResMut<Assets<Image>>`).
//
// Since most games will not need to modify textures at runtime, many developers opt to pass
// only `RENDER_WORLD`. This is more memory efficient, as we don't need to keep the image in
// RAM. For this example however, this would not work, as we need to inspect and modify the
// image at runtime.
|settings: &mut ImageLoaderSettings| settings.asset_usage = RenderAssetUsages::all(),
);
commands.spawn((
Name::new("Bird Left"),
// This marker component ensures we can easily find either of the Birds by using With and
// Without query filters.
Left,
Sprite::from_image(texture_left),
Transform::from_xyz(-200.0, 0.0, 0.0),
bird_left,
));
commands.spawn((
Name::new("Bird Right"),
// In contrast to the above, here we rely on the default `RenderAssetUsages` loader setting
Sprite::from_image(asset_server.load(bird_right.get_texture_path())),
Transform::from_xyz(200.0, 0.0, 0.0),
bird_right,
));
}
fn spawn_text(mut commands: Commands) {
commands.spawn((
Name::new("Instructions"),
Text::new(
"Space: swap the right sprite's image handle\n\
Return: modify the image Asset of the left sprite, affecting all uses of it",
),
Node {
position_type: PositionType::Absolute,
top: px(12),
left: px(12),
..default()
},
));
}
fn alter_handle(
asset_server: Res<AssetServer>,
right_bird: Single<(&mut Bird, &mut Sprite), Without<Left>>,
) {
// Image handles, like other parts of the ECS, can be queried as mutable and modified at
// runtime. We only spawned one bird without the `Left` marker component.
let (mut bird, mut sprite) = right_bird.into_inner();
// Switch to a new Bird variant
bird.set_next_variant();
// Modify the handle associated with the Bird on the right side. Note that we will only
// have to load the same path from storage media once: repeated attempts will re-use the
// asset.
sprite.image = asset_server.load(bird.get_texture_path());
}
fn alter_asset(mut images: ResMut<Assets<Image>>, left_bird: Single<&Sprite, With<Left>>) {
// Obtain a mutable reference to the Image asset.
let Some(image) = images.get_mut(&left_bird.image) else {
return;
};
for pixel in image.data.as_mut().unwrap() {
// Directly modify the asset data, which will affect all users of this asset. By
// contrast, mutating the handle (as we did above) affects only one copy. In this case,
// we'll just invert the colors, by way of demonstration. Notice that both uses of the
// asset show the change, not just the one on the left.
*pixel = 255 - *pixel;
}
}