pub enum Color {
Srgba(Srgba),
LinearRgba(LinearRgba),
Hsla(Hsla),
Hsva(Hsva),
Hwba(Hwba),
Laba(Laba),
Lcha(Lcha),
Oklaba(Oklaba),
Oklcha(Oklcha),
Xyza(Xyza),
}Expand description
An enumerated type that can represent any of the color types in this crate.
This is useful when you need to store a color in a data structure that can’t be generic over the color type.
§Conversion
Conversion between the various color spaces is achieved using Rust’s native From trait. Because certain color spaces are defined by their transformation to and from another space, these From implementations reflect that set of definitions.
let color = Srgba::rgb(0.5, 0.5, 0.5);
// Using From explicitly
let linear_color = LinearRgba::from(color);
// Using Into
let linear_color: LinearRgba = color.into();For example, the sRGB space is defined by its relationship with Linear RGB, and HWB by its with sRGB. As such, it is the responsibility of sRGB to provide From implementations for Linear RGB, and HWB for sRGB. To then provide conversion between Linear RGB and HWB directly, HWB is responsible for implementing these conversions, delegating to sRGB as an intermediatory. This ensures that all conversions take the shortest path between any two spaces, and limit the proliferation of domain specific knowledge for each color space to their respective definitions.
§Operations
Color supports all the standard color operations, such as mixing,
luminance and hue adjustment,
and diffing. These operations delegate to the concrete color space contained
by Color, but will convert to Oklch for operations which aren’t supported in the
current space. After performing the operation, if a conversion was required, the result will be
converted back into the original color space.
let red_hsv = Color::hsv(0., 1., 1.);
let red_srgb = Color::srgb(1., 0., 0.);
// HSV has a definition of hue, so it will be returned.
red_hsv.hue();
// SRGB doesn't have a native definition for hue.
// Converts to Oklch and returns that result.
red_srgb.hue();Oklch has been chosen as the intermediary space in cases where conversion is required
due to its perceptual uniformity and broad support for Bevy’s color operations.
To avoid the cost of repeated conversion, and ensure consistent results where that is desired,
first convert this Color into your desired color space.
Variants§
Srgba(Srgba)
A color in the sRGB color space with alpha.
LinearRgba(LinearRgba)
A color in the linear sRGB color space with alpha.
Hsla(Hsla)
A color in the HSL color space with alpha.
Hsva(Hsva)
A color in the HSV color space with alpha.
Hwba(Hwba)
A color in the HWB color space with alpha.
Laba(Laba)
A color in the LAB color space with alpha.
Lcha(Lcha)
A color in the LCH color space with alpha.
Oklaba(Oklaba)
A color in the Oklab color space with alpha.
Oklcha(Oklcha)
A color in the Oklch color space with alpha.
Xyza(Xyza)
A color in the XYZ color space with alpha.
Implementations§
Source§impl Color
impl Color
Sourcepub const WHITE: Color
pub const WHITE: Color
A fully white Color::LinearRgba color with an alpha of 1.0.
Sourcepub const BLACK: Color
pub const BLACK: Color
A fully black Color::LinearRgba color with an alpha of 1.0.
Sourcepub const NONE: Color
pub const NONE: Color
A fully transparent Color::LinearRgba color with 0 red, green and blue.
Sourcepub fn to_linear(&self) -> LinearRgba
pub fn to_linear(&self) -> LinearRgba
Return the color as a linear RGBA color.
Examples found in repository?
examples/ui/ui_material.rs (line 101)
90fn animate(
91 mut materials: ResMut<Assets<CustomUiMaterial>>,
92 q: Query<&MaterialNode<CustomUiMaterial>>,
93 time: Res<Time>,
94) {
95 let duration = 2.0;
96 for handle in &q {
97 if let Some(mut material) = materials.get_mut(handle) {
98 // rainbow color effect
99 let new_color = Color::hsl((time.elapsed_secs() * 60.0) % 360.0, 1., 0.5);
100 let border_color = Color::hsl((time.elapsed_secs() * 60.0) % 360.0, 0.75, 0.75);
101 material.color = new_color.to_linear().to_vec4();
102 material.slider.x =
103 ((time.elapsed_secs() % (duration * 2.0)) - duration).abs() / duration;
104 material.border_color = border_color.to_linear().to_vec4();
105 }
106 }
107}More examples
examples/3d/light_textures.rs (line 262)
228fn spawn_light_textures(
229 commands: &mut Commands,
230 asset_server: &AssetServer,
231 meshes: &mut Assets<Mesh>,
232 materials: &mut Assets<StandardMaterial>,
233) {
234 commands.spawn((
235 SpotLight {
236 color: Color::srgb(1.0, 1.0, 0.8),
237 intensity: 10e6,
238 outer_angle: 0.25,
239 inner_angle: 0.25,
240 shadow_maps_enabled: true,
241 ..default()
242 },
243 Transform::from_translation(Vec3::new(6.0, 1.0, 2.0)).looking_at(Vec3::ZERO, Vec3::Y),
244 SpotLightTexture {
245 image: asset_server.load("lightmaps/torch_spotlight_texture.png"),
246 },
247 Visibility::Inherited,
248 Selection::SpotLight,
249 ));
250
251 commands.spawn((
252 Visibility::Hidden,
253 Transform::from_translation(Vec3::new(0.0, 1.8, 0.01)).with_scale(Vec3::splat(0.1)),
254 Selection::PointLight,
255 children![
256 WorldAssetRoot(
257 asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/Faces/faces.glb")),
258 ),
259 (
260 Mesh3d(meshes.add(Sphere::new(1.0))),
261 MeshMaterial3d(materials.add(StandardMaterial {
262 emissive: Color::srgb(0.0, 0.0, 300.0).to_linear(),
263 ..default()
264 })),
265 ),
266 (
267 PointLight {
268 color: Color::srgb(0.0, 0.0, 1.0),
269 intensity: 1e6,
270 shadow_maps_enabled: true,
271 ..default()
272 },
273 PointLightTexture {
274 image: asset_server.load("lightmaps/faces_pointlight_texture_blurred.png"),
275 cubemap_layout: CubemapLayout::CrossVertical,
276 },
277 )
278 ],
279 ));
280}Sourcepub fn to_srgba(&self) -> Srgba
pub fn to_srgba(&self) -> Srgba
Return the color as an SRGBA color.
Examples found in repository?
examples/2d/wireframe_2d.rs (line 119)
101fn update_colors(
102 keyboard_input: Res<ButtonInput<KeyCode>>,
103 mut config: ResMut<Wireframe2dConfig>,
104 mut wireframe_colors: Query<&mut Wireframe2dColor>,
105 mut text: Single<&mut Text>,
106) {
107 text.0 = format!(
108 "Controls
109---------------
110Z - Toggle global
111X - Change global color
112C - Change color of the circle wireframe
113
114Wireframe2dConfig
115-------------
116Global: {}
117Color: {:?}",
118 config.global,
119 config.default_color.to_srgba(),
120 );
121
122 // Toggle showing a wireframe on all meshes
123 if keyboard_input.just_pressed(KeyCode::KeyZ) {
124 config.global = !config.global;
125 }
126
127 // Toggle the global wireframe color
128 if keyboard_input.just_pressed(KeyCode::KeyX) {
129 config.default_color = if config.default_color == WHITE.into() {
130 RED.into()
131 } else {
132 WHITE.into()
133 };
134 }
135
136 // Toggle the color of a wireframe using `Wireframe2dColor` and not the global color
137 if keyboard_input.just_pressed(KeyCode::KeyC) {
138 for mut color in &mut wireframe_colors {
139 color.color = if color.color == GREEN.into() {
140 RED.into()
141 } else {
142 GREEN.into()
143 };
144 }
145 }
146}Sourcepub const fn srgba(red: f32, green: f32, blue: f32, alpha: f32) -> Color
pub const fn srgba(red: f32, green: f32, blue: f32, alpha: f32) -> Color
Creates a new Color object storing a Srgba color.
§Arguments
red- Red channel. [0.0, 1.0]green- Green channel. [0.0, 1.0]blue- Blue channel. [0.0, 1.0]alpha- Alpha channel. [0.0, 1.0]
Examples found in repository?
examples/picking/dragdrop_picking.rs (line 116)
102fn on_drag_enter(
103 mut event: On<Pointer<DragEnter>>,
104 button: Single<Entity, With<DraggableButton>>,
105 mut commands: Commands,
106 mut meshes: ResMut<Assets<Mesh>>,
107 mut materials: ResMut<Assets<ColorMaterial>>,
108) {
109 if event.dragged == *button {
110 let Some(position) = event.hit.position else {
111 return;
112 };
113 commands.spawn((
114 GhostPreview,
115 Mesh2d(meshes.add(Circle::new(ELEMENT_SIZE))),
116 MeshMaterial2d(materials.add(Color::srgba(1.0, 1.0, 0.6, 0.5))),
117 Transform::from_translation(position + 2. * Vec3::Z),
118 Pickable::IGNORE,
119 ));
120 event.propagate(false);
121 }
122}More examples
examples/3d/clearcoat.rs (line 140)
127fn spawn_coated_glass_bubble_sphere(
128 commands: &mut Commands,
129 materials: &mut Assets<StandardMaterial>,
130 sphere: &Handle<Mesh>,
131) {
132 commands
133 .spawn((
134 Mesh3d(sphere.clone()),
135 MeshMaterial3d(materials.add(StandardMaterial {
136 clearcoat: 1.0,
137 clearcoat_perceptual_roughness: 0.1,
138 metallic: 0.5,
139 perceptual_roughness: 0.1,
140 base_color: Color::srgba(0.9, 0.9, 0.9, 0.3),
141 alpha_mode: AlphaMode::Blend,
142 ..default()
143 })),
144 Transform::from_xyz(-1.0, -1.0, 0.0).with_scale(Vec3::splat(SPHERE_SCALE)),
145 ))
146 .insert(ExampleSphere);
147}examples/2d/transparency_2d.rs (line 26)
13fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
14 commands.spawn(Camera2d);
15
16 let sprite_handle = asset_server.load("branding/icon.png");
17
18 commands.spawn((
19 Sprite::from_image(sprite_handle.clone()),
20 Transform::from_xyz(-100.0, 0.0, 0.0),
21 ));
22 commands.spawn((
23 Sprite {
24 image: sprite_handle.clone(),
25 // Alpha channel of the color controls transparency.
26 color: Color::srgba(0.0, 0.0, 1.0, 0.7),
27 ..default()
28 },
29 Transform::from_xyz(0.0, 0.0, 0.1),
30 ));
31 commands.spawn((
32 Sprite {
33 image: sprite_handle,
34 color: Color::srgba(0.0, 1.0, 0.0, 0.3),
35 ..default()
36 },
37 Transform::from_xyz(100.0, 0.0, 0.2),
38 ));
39}examples/3d/atmospheric_fog.rs (line 31)
26fn setup_camera_fog(mut commands: Commands) {
27 commands.spawn((
28 Camera3d::default(),
29 Transform::from_xyz(-1.0, 0.1, 1.0).looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
30 DistanceFog {
31 color: Color::srgba(0.35, 0.48, 0.66, 1.0),
32 directional_light_color: Color::srgba(1.0, 0.95, 0.85, 0.5),
33 directional_light_exponent: 30.0,
34 falloff: FogFalloff::from_visibility_colors(
35 15.0, // distance in world units up to which objects retain visibility (>= 5% contrast)
36 Color::srgb(0.35, 0.5, 0.66), // atmospheric extinction color (after light is lost due to absorption by atmospheric particles)
37 Color::srgb(0.8, 0.844, 1.0), // atmospheric inscattering color (light gained due to scattering from the sun)
38 ),
39 },
40 ));
41}examples/dev_tools/infinite_grid.rs (lines 52-54)
25fn setup_system(
26 mut commands: Commands,
27 mut meshes: ResMut<Assets<Mesh>>,
28 mut standard_materials: ResMut<Assets<StandardMaterial>>,
29) {
30 commands.spawn((
31 // You need to spawn an entity with this component
32 InfiniteGrid,
33 // Optional component you can use to configure the grid
34 InfiniteGridSettings::default(),
35 ));
36
37 commands.spawn((
38 Camera3d::default(),
39 Transform::from_xyz(-12.5, 5.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
40 FreeCamera::default(),
41 ));
42
43 commands.spawn((
44 DirectionalLight { ..default() },
45 Transform::from_translation(Vec3::X * 15. + Vec3::Y * 20.).looking_at(Vec3::ZERO, Vec3::Y),
46 ));
47
48 // cube
49 commands.spawn((
50 Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
51 MeshMaterial3d(
52 standard_materials.add(StandardMaterial::from_color(Color::srgba(
53 1.0, 1.0, 1.0, 0.5,
54 ))),
55 ),
56 Transform::from_xyz(0.0, 2.0, 0.0),
57 ));
58
59 commands.spawn((
60 Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
61 MeshMaterial3d(
62 standard_materials.add(StandardMaterial::from_color(Color::srgba(
63 1.0, 1.0, 1.0, 0.5,
64 ))),
65 ),
66 Transform::from_xyz(0.0, -2.0, 0.0),
67 ));
68}examples/3d/texture.rs (line 39)
15fn setup(
16 mut commands: Commands,
17 asset_server: Res<AssetServer>,
18 mut meshes: ResMut<Assets<Mesh>>,
19 mut materials: ResMut<Assets<StandardMaterial>>,
20) {
21 // load a texture and retrieve its aspect ratio
22 let texture_handle = asset_server.load("branding/bevy_logo_dark_big.png");
23 let aspect = 0.25;
24
25 // create a new quad mesh. this is what we will apply the texture to
26 let quad_width = 8.0;
27 let quad_handle = meshes.add(Rectangle::new(quad_width, quad_width * aspect));
28
29 // this material renders the texture normally
30 let material_handle = materials.add(StandardMaterial {
31 base_color_texture: Some(texture_handle.clone()),
32 alpha_mode: AlphaMode::Blend,
33 unlit: true,
34 ..default()
35 });
36
37 // this material modulates the texture to make it red (and slightly transparent)
38 let red_material_handle = materials.add(StandardMaterial {
39 base_color: Color::srgba(1.0, 0.0, 0.0, 0.5),
40 base_color_texture: Some(texture_handle.clone()),
41 alpha_mode: AlphaMode::Blend,
42 unlit: true,
43 ..default()
44 });
45
46 // and lets make this one blue! (and also slightly transparent)
47 let blue_material_handle = materials.add(StandardMaterial {
48 base_color: Color::srgba(0.0, 0.0, 1.0, 0.5),
49 base_color_texture: Some(texture_handle),
50 alpha_mode: AlphaMode::Blend,
51 unlit: true,
52 ..default()
53 });
54
55 // textured quad - normal
56 commands.spawn((
57 Mesh3d(quad_handle.clone()),
58 MeshMaterial3d(material_handle),
59 Transform::from_xyz(0.0, 0.0, 1.5).with_rotation(Quat::from_rotation_x(-PI / 5.0)),
60 ));
61 // textured quad - modulated
62 commands.spawn((
63 Mesh3d(quad_handle.clone()),
64 MeshMaterial3d(red_material_handle),
65 Transform::from_rotation(Quat::from_rotation_x(-PI / 5.0)),
66 ));
67 // textured quad - modulated
68 commands.spawn((
69 Mesh3d(quad_handle),
70 MeshMaterial3d(blue_material_handle),
71 Transform::from_xyz(0.0, 0.0, -1.5).with_rotation(Quat::from_rotation_x(-PI / 5.0)),
72 ));
73 // camera
74 commands.spawn((
75 Camera3d::default(),
76 Transform::from_xyz(3.0, 5.0, 8.0).looking_at(Vec3::ZERO, Vec3::Y),
77 ));
78}Additional examples can be found in:
- examples/ui/styling/transparency_ui.rs
- examples/math/random_sampling.rs
- examples/showcase/stepping.rs
- examples/3d/transparency_3d.rs
- examples/3d/solari.rs
- examples/showcase/desk_toy.rs
- examples/ui/navigation/directional_navigation.rs
- examples/3d/transmission.rs
- examples/ui/navigation/directional_navigation_overrides.rs
- examples/testbed/full_ui.rs
Sourcepub const fn srgb(red: f32, green: f32, blue: f32) -> Color
pub const fn srgb(red: f32, green: f32, blue: f32) -> Color
Creates a new Color object storing a Srgba color with an alpha of 1.0.
§Arguments
red- Red channel. [0.0, 1.0]green- Green channel. [0.0, 1.0]blue- Blue channel. [0.0, 1.0]
Examples found in repository?
More examples
examples/showcase/game_menu.rs (line 7)
7const TEXT_COLOR: Color = Color::srgb(0.9, 0.9, 0.9);
8
9// Enum that will be used as a global state for the game
10#[derive(Clone, Copy, Default, Eq, PartialEq, Debug, Hash, States)]
11enum GameState {
12 #[default]
13 Splash,
14 Menu,
15 Game,
16}
17
18// One of the two settings that can be set through the menu. It will be a resource in the app
19#[derive(Resource, Debug, PartialEq, Eq, Clone, Copy)]
20enum DisplayQuality {
21 Low,
22 Medium,
23 High,
24}
25
26#[derive(Component)]
27struct Setting<T>(T);
28
29// One of the two settings that can be set through the menu. It will be a resource in the app
30#[derive(Resource, Debug, PartialEq, Eq, Clone, Copy)]
31struct Volume(u32);
32
33fn main() {
34 App::new()
35 .add_plugins(DefaultPlugins)
36 // Insert as resource the initial value for the settings resources
37 .insert_resource(DisplayQuality::Medium)
38 .insert_resource(Volume(7))
39 // Declare the game state, whose starting value is determined by the `Default` trait
40 .init_state::<GameState>()
41 .add_systems(Startup, setup)
42 // Adds the plugins for each state
43 .add_plugins((splash::splash_plugin, menu::menu_plugin, game::game_plugin))
44 .run();
45}
46
47fn setup(mut commands: Commands) {
48 commands.spawn(Camera2d);
49}
50
51mod splash {
52 use bevy::prelude::*;
53
54 use super::GameState;
55
56 // This plugin will display a splash screen with Bevy logo for 1 second before switching to the menu
57 pub fn splash_plugin(app: &mut App) {
58 // As this plugin is managing the splash screen, it will focus on the state `GameState::Splash`
59 app
60 // When entering the state, spawn everything needed for this screen
61 .add_systems(OnEnter(GameState::Splash), splash_setup)
62 // While in this state, run the `countdown` system
63 .add_systems(Update, countdown.run_if(in_state(GameState::Splash)));
64 }
65
66 // Tag component used to tag entities added on the splash screen
67 #[derive(Component)]
68 struct OnSplashScreen;
69
70 // Newtype to use a `Timer` for this screen as a resource
71 #[derive(Resource, Deref, DerefMut)]
72 struct SplashTimer(Timer);
73
74 fn splash_setup(mut commands: Commands, asset_server: Res<AssetServer>) {
75 let icon = asset_server.load("branding/icon.png");
76 // Display the logo
77 commands.spawn((
78 // This entity will be despawned when exiting the state
79 DespawnOnExit(GameState::Splash),
80 Node {
81 align_items: AlignItems::Center,
82 justify_content: JustifyContent::Center,
83 width: percent(100),
84 height: percent(100),
85 ..default()
86 },
87 OnSplashScreen,
88 children![(
89 ImageNode::new(icon),
90 Node {
91 // This will set the logo to be 200px wide, and auto adjust its height
92 width: px(200),
93 ..default()
94 },
95 )],
96 ));
97 // Insert the timer as a resource
98 commands.insert_resource(SplashTimer(Timer::from_seconds(1.0, TimerMode::Once)));
99 }
100
101 // Tick the timer, and change state when finished
102 fn countdown(
103 mut game_state: ResMut<NextState<GameState>>,
104 time: Res<Time>,
105 mut timer: ResMut<SplashTimer>,
106 ) {
107 if timer.tick(time.delta()).is_finished() {
108 game_state.set(GameState::Menu);
109 }
110 }
111}
112
113mod game {
114 use bevy::{
115 color::palettes::basic::{BLUE, LIME},
116 prelude::*,
117 };
118
119 use super::{DisplayQuality, GameState, Volume, TEXT_COLOR};
120
121 // This plugin will contain the game. In this case, it's just be a screen that will
122 // display the current settings for 5 seconds before returning to the menu
123 pub fn game_plugin(app: &mut App) {
124 app.add_systems(OnEnter(GameState::Game), game_setup)
125 .add_systems(Update, game.run_if(in_state(GameState::Game)));
126 }
127
128 // Tag component used to tag entities added on the game screen
129 #[derive(Component)]
130 struct OnGameScreen;
131
132 #[derive(Resource, Deref, DerefMut)]
133 struct GameTimer(Timer);
134
135 fn game_setup(
136 mut commands: Commands,
137 display_quality: Res<DisplayQuality>,
138 volume: Res<Volume>,
139 ) {
140 commands.spawn((
141 DespawnOnExit(GameState::Game),
142 Node {
143 width: percent(100),
144 height: percent(100),
145 // center children
146 align_items: AlignItems::Center,
147 justify_content: JustifyContent::Center,
148 ..default()
149 },
150 OnGameScreen,
151 children![(
152 Node {
153 // This will display its children in a column, from top to bottom
154 flex_direction: FlexDirection::Column,
155 // `align_items` will align children on the cross axis. Here the main axis is
156 // vertical (column), so the cross axis is horizontal. This will center the
157 // children
158 align_items: AlignItems::Center,
159 ..default()
160 },
161 BackgroundColor(Color::BLACK),
162 children![
163 (
164 Text::new("Will be back to the menu shortly..."),
165 TextFont {
166 font_size: FontSize::Px(67.0),
167 ..default()
168 },
169 TextColor(TEXT_COLOR),
170 Node {
171 margin: UiRect::all(px(50)),
172 ..default()
173 },
174 ),
175 (
176 Text::default(),
177 Node {
178 margin: UiRect::all(px(50)),
179 ..default()
180 },
181 children![
182 (
183 TextSpan(format!("quality: {:?}", *display_quality)),
184 TextFont {
185 font_size: FontSize::Px(50.0),
186 ..default()
187 },
188 TextColor(BLUE.into()),
189 ),
190 (
191 TextSpan::new(" - "),
192 TextFont {
193 font_size: FontSize::Px(50.0),
194 ..default()
195 },
196 TextColor(TEXT_COLOR),
197 ),
198 (
199 TextSpan(format!("volume: {:?}", *volume)),
200 TextFont {
201 font_size: FontSize::Px(50.0),
202 ..default()
203 },
204 TextColor(LIME.into()),
205 ),
206 ]
207 ),
208 ]
209 )],
210 ));
211 // Spawn a 5 seconds timer to trigger going back to the menu
212 commands.insert_resource(GameTimer(Timer::from_seconds(5.0, TimerMode::Once)));
213 }
214
215 // Tick the timer, and change state when finished
216 fn game(
217 time: Res<Time>,
218 mut game_state: ResMut<NextState<GameState>>,
219 mut timer: ResMut<GameTimer>,
220 ) {
221 if timer.tick(time.delta()).is_finished() {
222 game_state.set(GameState::Menu);
223 }
224 }
225}
226
227mod menu {
228 use bevy::{
229 app::AppExit,
230 color::palettes::css::CRIMSON,
231 ecs::component::Mutable,
232 ecs::spawn::{SpawnIter, SpawnWith},
233 prelude::*,
234 };
235
236 use super::{DisplayQuality, GameState, Setting, Volume, TEXT_COLOR};
237
238 // This plugin manages the menu, with 5 different screens:
239 // - a main menu with "New Game", "Settings", "Quit"
240 // - a settings menu with two submenus and a back button
241 // - two settings screen with a setting that can be set and a back button
242 pub fn menu_plugin(app: &mut App) {
243 app
244 // At start, the menu is not enabled. This will be changed in `menu_setup` when
245 // entering the `GameState::Menu` state.
246 // Current screen in the menu is handled by an independent state from `GameState`
247 .init_state::<MenuState>()
248 .add_systems(OnEnter(GameState::Menu), menu_setup)
249 // Systems to handle the main menu screen
250 .add_systems(OnEnter(MenuState::Main), main_menu_setup)
251 // Systems to handle the settings menu screen
252 .add_systems(OnEnter(MenuState::Settings), settings_menu_setup)
253 // Systems to handle the display settings screen
254 .add_systems(
255 OnEnter(MenuState::SettingsDisplay),
256 display_settings_menu_setup,
257 )
258 .add_systems(
259 Update,
260 (setting_button::<DisplayQuality>.run_if(in_state(MenuState::SettingsDisplay)),),
261 )
262 // Systems to handle the sound settings screen
263 .add_systems(OnEnter(MenuState::SettingsSound), sound_settings_menu_setup)
264 .add_systems(
265 Update,
266 setting_button::<Volume>.run_if(in_state(MenuState::SettingsSound)),
267 )
268 // Common systems to all screens that handles buttons behavior
269 .add_systems(
270 Update,
271 (menu_action, button_system).run_if(in_state(GameState::Menu)),
272 );
273 }
274
275 // State used for the current menu screen
276 #[derive(Clone, Copy, Default, Eq, PartialEq, Debug, Hash, States)]
277 enum MenuState {
278 Main,
279 Settings,
280 SettingsDisplay,
281 SettingsSound,
282 #[default]
283 Disabled,
284 }
285
286 // Tag component used to tag entities added on the main menu screen
287 #[derive(Component)]
288 struct OnMainMenuScreen;
289
290 // Tag component used to tag entities added on the settings menu screen
291 #[derive(Component)]
292 struct OnSettingsMenuScreen;
293
294 // Tag component used to tag entities added on the display settings menu screen
295 #[derive(Component)]
296 struct OnDisplaySettingsMenuScreen;
297
298 // Tag component used to tag entities added on the sound settings menu screen
299 #[derive(Component)]
300 struct OnSoundSettingsMenuScreen;
301
302 const NORMAL_BUTTON: Color = Color::srgb(0.15, 0.15, 0.15);
303 const HOVERED_BUTTON: Color = Color::srgb(0.25, 0.25, 0.25);
304 const HOVERED_PRESSED_BUTTON: Color = Color::srgb(0.25, 0.65, 0.25);
305 const PRESSED_BUTTON: Color = Color::srgb(0.35, 0.75, 0.35);examples/ui/layout/display_and_visibility.rs (line 10)
10const HIDDEN_COLOR: Color = Color::srgb(1.0, 0.7, 0.7);
11
12fn main() {
13 App::new()
14 .add_plugins(DefaultPlugins)
15 .add_systems(Startup, setup)
16 .add_systems(
17 Update,
18 (
19 buttons_handler::<Display>,
20 buttons_handler::<Visibility>,
21 text_hover,
22 ),
23 )
24 .run();
25}
26
27#[derive(Component)]
28struct Target<T> {
29 id: Entity,
30 phantom: std::marker::PhantomData<T>,
31}
32
33impl<T> Target<T> {
34 fn new(id: Entity) -> Self {
35 Self {
36 id,
37 phantom: std::marker::PhantomData,
38 }
39 }
40}
41
42trait TargetUpdate {
43 type TargetComponent: Component<Mutability = Mutable>;
44 const NAME: &'static str;
45 fn update_target(&self, target: &mut Self::TargetComponent) -> String;
46}
47
48impl TargetUpdate for Target<Display> {
49 type TargetComponent = Node;
50 const NAME: &'static str = "Display";
51 fn update_target(&self, node: &mut Self::TargetComponent) -> String {
52 node.display = match node.display {
53 Display::Flex => Display::None,
54 Display::None => Display::Flex,
55 Display::Block | Display::Grid => unreachable!(),
56 };
57 format!("{}::{:?} ", Self::NAME, node.display)
58 }
59}
60
61impl TargetUpdate for Target<Visibility> {
62 type TargetComponent = Visibility;
63 const NAME: &'static str = "Visibility";
64 fn update_target(&self, visibility: &mut Self::TargetComponent) -> String {
65 *visibility = match *visibility {
66 Visibility::Inherited => Visibility::Visible,
67 Visibility::Visible => Visibility::Hidden,
68 Visibility::Hidden => Visibility::Inherited,
69 };
70 format!("{}::{visibility:?}", Self::NAME)
71 }
72}
73
74fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
75 let palette: [Color; 4] = PALETTE.map(|hex| Srgba::hex(hex).unwrap().into());
76
77 let text_font = TextFont {
78 font: asset_server.load("fonts/FiraSans-Bold.ttf").into(),
79 ..default()
80 };
81
82 commands.spawn(Camera2d);
83 commands
84 .spawn((
85 Node {
86 width: percent(100),
87 height: percent(100),
88 flex_direction: FlexDirection::Column,
89 align_items: AlignItems::Center,
90 justify_content: JustifyContent::SpaceEvenly,
91 ..Default::default()
92 },
93 BackgroundColor(Color::BLACK),
94 ))
95 .with_children(|parent| {
96 parent.spawn((
97 Text::new("Use the panel on the right to change the Display and Visibility properties for the respective nodes of the panel on the left"),
98 text_font.clone(),
99 TextLayout::justify(Justify::Center),
100 Node {
101 margin: UiRect::bottom(px(10)),
102 ..Default::default()
103 },
104 ));
105
106 parent
107 .spawn(Node {
108 width: percent(100),
109 ..default()
110 })
111 .with_children(|parent| {
112 let mut target_ids = vec![];
113 parent
114 .spawn(Node {
115 width: percent(50),
116 height: px(520),
117 justify_content: JustifyContent::Center,
118 ..default()
119 })
120 .with_children(|parent| {
121 target_ids = spawn_left_panel(parent, &palette);
122 });
123
124 parent
125 .spawn(Node {
126 width: percent(50),
127 justify_content: JustifyContent::Center,
128 ..default()
129 })
130 .with_children(|parent| {
131 spawn_right_panel(parent, text_font, &palette, target_ids);
132 });
133 });
134
135 parent
136 .spawn(Node {
137 flex_direction: FlexDirection::Row,
138 align_items: AlignItems::Start,
139 justify_content: JustifyContent::Start,
140 column_gap: px(10),
141 ..default()
142 })
143 .with_children(|builder| {
144 let text_font = TextFont {
145 font: asset_server.load("fonts/FiraSans-Bold.ttf").into(),
146 ..default()
147 };
148
149 builder.spawn((
150 Text::new("Display::None\nVisibility::Hidden\nVisibility::Inherited"),
151 text_font.clone(),
152 TextColor(HIDDEN_COLOR),
153 TextLayout::justify(Justify::Center),
154 ));
155 builder.spawn((
156 Text::new("-\n-\n-"),
157 text_font.clone(),
158 TextColor(DARK_GRAY.into()),
159 TextLayout::justify(Justify::Center),
160 ));
161 builder.spawn((Text::new("The UI Node and its descendants will not be visible and will not be allotted any space in the UI layout.\nThe UI Node will not be visible but will still occupy space in the UI layout.\nThe UI node will inherit the visibility property of its parent. If it has no parent it will be visible."), text_font));
162 });
163 });
164}
165
166fn spawn_left_panel(builder: &mut ChildSpawnerCommands, palette: &[Color; 4]) -> Vec<Entity> {
167 let mut target_ids = vec![];
168 builder
169 .spawn((
170 Node {
171 padding: UiRect::all(px(10)),
172 ..default()
173 },
174 BackgroundColor(Color::WHITE),
175 ))
176 .with_children(|parent| {
177 parent
178 .spawn((Node::default(), BackgroundColor(Color::BLACK)))
179 .with_children(|parent| {
180 let id = parent
181 .spawn((
182 Node {
183 align_items: AlignItems::FlexEnd,
184 justify_content: JustifyContent::FlexEnd,
185 ..default()
186 },
187 BackgroundColor(palette[0]),
188 Outline {
189 width: px(4),
190 color: DARK_CYAN.into(),
191 offset: px(10),
192 },
193 ))
194 .with_children(|parent| {
195 parent.spawn(Node {
196 width: px(100),
197 height: px(500),
198 ..default()
199 });
200
201 let id = parent
202 .spawn((
203 Node {
204 height: px(400),
205 align_items: AlignItems::FlexEnd,
206 justify_content: JustifyContent::FlexEnd,
207 ..default()
208 },
209 BackgroundColor(palette[1]),
210 ))
211 .with_children(|parent| {
212 parent.spawn(Node {
213 width: px(100),
214 height: px(400),
215 ..default()
216 });
217
218 let id = parent
219 .spawn((
220 Node {
221 height: px(300),
222 align_items: AlignItems::FlexEnd,
223 justify_content: JustifyContent::FlexEnd,
224 ..default()
225 },
226 BackgroundColor(palette[2]),
227 ))
228 .with_children(|parent| {
229 parent.spawn(Node {
230 width: px(100),
231 height: px(300),
232 ..default()
233 });
234
235 let id = parent
236 .spawn((
237 Node {
238 width: px(200),
239 height: px(200),
240 ..default()
241 },
242 BackgroundColor(palette[3]),
243 ))
244 .id();
245 target_ids.push(id);
246 })
247 .id();
248 target_ids.push(id);
249 })
250 .id();
251 target_ids.push(id);
252 })
253 .id();
254 target_ids.push(id);
255 });
256 });
257 target_ids
258}
259
260fn spawn_right_panel(
261 parent: &mut ChildSpawnerCommands,
262 text_font: TextFont,
263 palette: &[Color; 4],
264 mut target_ids: Vec<Entity>,
265) {
266 let spawn_buttons = |parent: &mut ChildSpawnerCommands, target_id| {
267 spawn_button::<Display>(parent, text_font.clone(), target_id);
268 spawn_button::<Visibility>(parent, text_font.clone(), target_id);
269 };
270 parent
271 .spawn((
272 Node {
273 padding: UiRect::all(px(10)),
274 ..default()
275 },
276 BackgroundColor(Color::WHITE),
277 ))
278 .with_children(|parent| {
279 parent
280 .spawn((
281 Node {
282 width: px(500),
283 height: px(500),
284 flex_direction: FlexDirection::Column,
285 align_items: AlignItems::FlexEnd,
286 justify_content: JustifyContent::SpaceBetween,
287 padding: UiRect {
288 left: px(5),
289 top: px(5),
290 ..default()
291 },
292 ..default()
293 },
294 BackgroundColor(palette[0]),
295 Outline {
296 width: px(4),
297 color: DARK_CYAN.into(),
298 offset: px(10),
299 },
300 ))
301 .with_children(|parent| {
302 spawn_buttons(parent, target_ids.pop().unwrap());
303
304 parent
305 .spawn((
306 Node {
307 width: px(400),
308 height: px(400),
309 flex_direction: FlexDirection::Column,
310 align_items: AlignItems::FlexEnd,
311 justify_content: JustifyContent::SpaceBetween,
312 padding: UiRect {
313 left: px(5),
314 top: px(5),
315 ..default()
316 },
317 ..default()
318 },
319 BackgroundColor(palette[1]),
320 ))
321 .with_children(|parent| {
322 spawn_buttons(parent, target_ids.pop().unwrap());
323
324 parent
325 .spawn((
326 Node {
327 width: px(300),
328 height: px(300),
329 flex_direction: FlexDirection::Column,
330 align_items: AlignItems::FlexEnd,
331 justify_content: JustifyContent::SpaceBetween,
332 padding: UiRect {
333 left: px(5),
334 top: px(5),
335 ..default()
336 },
337 ..default()
338 },
339 BackgroundColor(palette[2]),
340 ))
341 .with_children(|parent| {
342 spawn_buttons(parent, target_ids.pop().unwrap());
343
344 parent
345 .spawn((
346 Node {
347 width: px(200),
348 height: px(200),
349 align_items: AlignItems::FlexStart,
350 justify_content: JustifyContent::SpaceBetween,
351 flex_direction: FlexDirection::Column,
352 padding: UiRect {
353 left: px(5),
354 top: px(5),
355 ..default()
356 },
357 ..default()
358 },
359 BackgroundColor(palette[3]),
360 ))
361 .with_children(|parent| {
362 spawn_buttons(parent, target_ids.pop().unwrap());
363
364 parent.spawn(Node {
365 width: px(100),
366 height: px(100),
367 ..default()
368 });
369 });
370 });
371 });
372 });
373 });
374}
375
376fn spawn_button<T>(parent: &mut ChildSpawnerCommands, text_font: TextFont, target: Entity)
377where
378 T: Default + std::fmt::Debug + Send + Sync + 'static,
379 Target<T>: TargetUpdate,
380{
381 parent
382 .spawn((
383 Button,
384 Node {
385 align_self: AlignSelf::FlexStart,
386 padding: UiRect::axes(px(5), px(1)),
387 ..default()
388 },
389 BackgroundColor(Color::BLACK.with_alpha(0.5)),
390 Target::<T>::new(target),
391 ))
392 .with_children(|builder| {
393 builder.spawn((
394 Text(format!("{}::{:?}", Target::<T>::NAME, T::default())),
395 text_font,
396 TextLayout::justify(Justify::Center),
397 ));
398 });
399}
400
401fn buttons_handler<T>(
402 mut left_panel_query: Query<&mut <Target<T> as TargetUpdate>::TargetComponent>,
403 mut visibility_button_query: Query<(&Target<T>, &Interaction, &Children), Changed<Interaction>>,
404 mut text_query: Query<(&mut Text, &mut TextColor)>,
405) where
406 T: Send + Sync,
407 Target<T>: TargetUpdate + Component,
408{
409 for (target, interaction, children) in visibility_button_query.iter_mut() {
410 if matches!(interaction, Interaction::Pressed) {
411 let mut target_value = left_panel_query.get_mut(target.id).unwrap();
412 for &child in children {
413 if let Ok((mut text, mut text_color)) = text_query.get_mut(child) {
414 **text = target.update_target(target_value.as_mut());
415 text_color.0 = if text.contains("None") || text.contains("Hidden") {
416 Color::srgb(1.0, 0.7, 0.7)
417 } else {
418 Color::WHITE
419 };
420 }
421 }
422 }
423 }
424}examples/ui/widgets/vertical_slider.rs (line 13)
13const SLIDER_TRACK: Color = Color::srgb(0.05, 0.05, 0.05);
14const SLIDER_THUMB: Color = Color::srgb(0.35, 0.75, 0.35);
15
16fn main() {
17 App::new()
18 .add_plugins((DefaultPlugins, TabNavigationPlugin))
19 .add_systems(Startup, setup)
20 .add_systems(Update, (update_slider_visuals, update_value_labels))
21 .run();
22}
23
24#[derive(Component)]
25struct ValueLabel(Entity);
26
27#[derive(Component)]
28struct DemoSlider;
29
30#[derive(Component)]
31struct DemoSliderThumb;
32
33#[derive(Component)]
34struct VerticalSlider;
35
36fn setup(mut commands: Commands, assets: Res<AssetServer>) {
37 commands.spawn(Camera2d);
38
39 commands
40 .spawn((
41 Node {
42 width: percent(100),
43 height: percent(100),
44 align_items: AlignItems::Center,
45 justify_content: JustifyContent::Center,
46 display: Display::Flex,
47 flex_direction: FlexDirection::Row,
48 column_gap: px(50),
49 ..default()
50 },
51 TabGroup::default(),
52 ))
53 .with_children(|parent| {
54 // Vertical slider
55 parent
56 .spawn(Node {
57 display: Display::Flex,
58 flex_direction: FlexDirection::Column,
59 align_items: AlignItems::Center,
60 row_gap: px(10),
61 ..default()
62 })
63 .with_children(|parent| {
64 parent.spawn((
65 Text::new("Vertical"),
66 TextFont {
67 font: assets.load("fonts/FiraSans-Bold.ttf").into(),
68 font_size: FontSize::Px(20.0),
69 ..default()
70 },
71 TextColor(Color::srgb(0.9, 0.9, 0.9)),
72 ));
73
74 let label_id = parent
75 .spawn((
76 Text::new("50"),
77 TextFont {
78 font: assets.load("fonts/FiraSans-Bold.ttf").into(),
79 font_size: FontSize::Px(24.0),
80 ..default()
81 },
82 TextColor(Color::srgb(0.9, 0.9, 0.9)),
83 ))
84 .id();
85
86 parent.spawn((
87 vertical_slider(),
88 ValueLabel(label_id),
89 observe(slider_self_update),
90 ));
91 });
92
93 // Horizontal slider
94 parent
95 .spawn(Node {
96 display: Display::Flex,
97 flex_direction: FlexDirection::Column,
98 align_items: AlignItems::Center,
99 row_gap: px(10),
100 ..default()
101 })
102 .with_children(|parent| {
103 parent.spawn((
104 Text::new("Horizontal"),
105 TextFont {
106 font: assets.load("fonts/FiraSans-Bold.ttf").into(),
107 font_size: FontSize::Px(20.0),
108 ..default()
109 },
110 TextColor(Color::srgb(0.9, 0.9, 0.9)),
111 ));
112
113 let label_id = parent
114 .spawn((
115 Text::new("50"),
116 TextFont {
117 font: assets.load("fonts/FiraSans-Bold.ttf").into(),
118 font_size: FontSize::Px(24.0),
119 ..default()
120 },
121 TextColor(Color::srgb(0.9, 0.9, 0.9)),
122 ))
123 .id();
124
125 parent.spawn((
126 horizontal_slider(),
127 ValueLabel(label_id),
128 observe(slider_self_update),
129 ));
130 });
131 });
132}Additional examples can be found in:
- examples/state/custom_transitions.rs
- examples/state/states.rs
- examples/ui/styling/box_shadow.rs
- examples/ui/widgets/button.rs
- examples/ui/widgets/standard_widgets.rs
- examples/ui/widgets/standard_widgets_observers.rs
- examples/ui/widgets/tab_navigation.rs
- examples/showcase/desk_toy.rs
- examples/ui/layout/flex_layout.rs
- examples/ui/layout/size_constraints.rs
- examples/state/computed_states.rs
- examples/state/sub_states.rs
- examples/2d/tilemap_chunk_orientation.rs
- examples/window/clear_color.rs
- examples/ecs/removal_detection.rs
- examples/3d/fog.rs
- examples/math/cubic_splines.rs
- examples/async_tasks/async_compute.rs
- examples/ui/text/text.rs
- examples/async_tasks/async_channel_pattern.rs
- examples/ecs/state_scoped.rs
- examples/ui/layout/ghost_nodes.rs
- examples/camera/2d_top_down_camera.rs
- examples/shader_advanced/fullscreen_material.rs
- examples/3d/3d_viewport_to_world.rs
- examples/ui/scroll_and_overflow/scrollbars.rs
- examples/asset/multi_asset_sync.rs
- examples/ui/layout/anchor_layout.rs
- tests/window/minimizing.rs
- tests/window/resizing.rs
- examples/3d/atmospheric_fog.rs
- examples/testbed/2d.rs
- examples/animation/animated_mesh.rs
- examples/window/scale_factor_override.rs
- examples/3d/parenting.rs
- examples/animation/animation_graph.rs
- examples/ui/scroll_and_overflow/overflow_debug.rs
- examples/app/settings.rs
- examples/shader/shader_material_screenspace_texture.rs
- examples/3d/mesh_ray_cast.rs
- examples/camera/2d_screen_shake.rs
- examples/camera/camera_orbit.rs
- examples/animation/animation_masks.rs
- examples/window/screenshot.rs
- examples/shader_advanced/custom_post_processing.rs
- tests/window/desktop_request_redraw.rs
- examples/3d/two_passes.rs
- examples/gltf/gltf_extension_animation_graph.rs
- examples/window/low_power.rs
- examples/movement/smooth_follow.rs
- examples/ui/relative_cursor_position.rs
- examples/3d/vertex_colors.rs
- examples/animation/animated_mesh_control.rs
- examples/3d/orthographic.rs
- examples/remote/app_under_test.rs
- examples/stress_tests/many_buttons.rs
- examples/3d/spherical_area_lights.rs
- examples/2d/bloom_2d.rs
- examples/gizmos/axes.rs
- examples/3d/light_textures.rs
- examples/3d/ssao.rs
- examples/animation/animated_mesh_events.rs
- examples/ecs/error_handling.rs
- examples/camera/projection_zoom.rs
- examples/3d/order_independent_transparency.rs
- examples/3d/rect_light.rs
- examples/ui/images/ui_texture_slice.rs
- examples/3d/visibility_range.rs
- tests/3d/test_invalid_skinned_mesh.rs
- examples/time/virtual_time.rs
- examples/testbed/ui.rs
- examples/3d/anti_aliasing.rs
- examples/gizmos/3d_gizmos.rs
- examples/picking/dragdrop_picking.rs
- examples/transforms/align.rs
- examples/ui/styling/transparency_ui.rs
- examples/math/random_sampling.rs
- examples/testbed/3d.rs
- examples/ui/images/ui_texture_atlas_slice.rs
- examples/picking/sprite_picking.rs
- examples/ecs/iter_combinations.rs
- examples/ui/text/text_wrap_debug.rs
- examples/3d/render_to_texture.rs
- examples/showcase/alien_cake_addict.rs
- examples/gizmos/transform_gizmo.rs
- examples/3d/transparency_3d.rs
- examples/asset/alter_mesh.rs
- examples/ui/text/system_fonts.rs
- examples/3d/auto_exposure.rs
- examples/asset/asset_loading.rs
- examples/ui/scroll_and_overflow/overflow.rs
- examples/ui/scroll_and_overflow/overflow_clip_margin.rs
- examples/shader/shader_prepass.rs
- examples/3d/split_screen.rs
- examples/ui/scroll_and_overflow/scroll.rs
- examples/stress_tests/many_foxes.rs
- examples/ui/ui_drag_and_drop.rs
- examples/3d/deferred_rendering.rs
- examples/3d/contact_shadows.rs
- examples/2d/text2d.rs
- examples/animation/custom_skinned_mesh.rs
- examples/usage/debug_frustum_culling.rs
- examples/3d/blend_modes.rs
- examples/3d/solari.rs
- examples/animation/animated_transform.rs
- examples/ui/styling/borders.rs
- examples/3d/camera_sub_view.rs
- examples/ui/text/text_debug.rs
- examples/ui/layout/grid.rs
- examples/3d/transmission.rs
- examples/ui/styling/gradients.rs
- examples/testbed/full_ui.rs
Sourcepub const fn srgb_from_array(array: [f32; 3]) -> Color
pub const fn srgb_from_array(array: [f32; 3]) -> Color
Sourcepub const fn srgba_u8(red: u8, green: u8, blue: u8, alpha: u8) -> Color
pub const fn srgba_u8(red: u8, green: u8, blue: u8, alpha: u8) -> Color
Creates a new Color object storing a Srgba color from u8 values.
§Arguments
red- Red channel. [0, 255]green- Green channel. [0, 255]blue- Blue channel. [0, 255]alpha- Alpha channel. [0, 255]
Examples found in repository?
examples/3d/anti_aliasing.rs (line 476)
412fn setup(
413 mut commands: Commands,
414 mut meshes: ResMut<Assets<Mesh>>,
415 mut materials: ResMut<Assets<StandardMaterial>>,
416 mut images: ResMut<Assets<Image>>,
417 asset_server: Res<AssetServer>,
418) {
419 // Plane
420 commands.spawn((
421 Mesh3d(meshes.add(Plane3d::default().mesh().size(20.0, 20.0))),
422 MeshMaterial3d(materials.add(Color::srgb(0.1, 0.2, 0.1))),
423 ));
424
425 let cube_material = materials.add(StandardMaterial {
426 base_color_texture: Some(images.add(uv_debug_texture())),
427 ..default()
428 });
429
430 // Cubes
431 for i in 0..5 {
432 commands.spawn((
433 Mesh3d(meshes.add(Cuboid::new(0.25, 0.25, 0.25))),
434 MeshMaterial3d(cube_material.clone()),
435 Transform::from_xyz(i as f32 * 0.25 - 1.0, 0.125, -i as f32 * 0.5),
436 ));
437 }
438
439 // Flight Helmet
440 commands.spawn(WorldAssetRoot(asset_server.load(
441 GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf"),
442 )));
443
444 // Light
445 commands.spawn((
446 DirectionalLight {
447 illuminance: light_consts::lux::FULL_DAYLIGHT,
448 shadow_maps_enabled: true,
449 ..default()
450 },
451 Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, PI * -0.15, PI * -0.15)),
452 CascadeShadowConfigBuilder {
453 maximum_distance: 3.0,
454 first_cascade_far_bound: 0.9,
455 ..default()
456 }
457 .build(),
458 ));
459
460 // Camera
461 commands.spawn((
462 Camera3d::default(),
463 Hdr,
464 Transform::from_xyz(0.7, 0.7, 1.0).looking_at(Vec3::new(0.0, 0.3, 0.0), Vec3::Y),
465 ContrastAdaptiveSharpening {
466 enabled: false,
467 ..default()
468 },
469 EnvironmentMapLight {
470 diffuse_map: asset_server.load("environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2"),
471 specular_map: asset_server.load("environment_maps/pisa_specular_rgb9e5_zstd.ktx2"),
472 intensity: 150.0,
473 ..default()
474 },
475 DistanceFog {
476 color: Color::srgba_u8(43, 44, 47, 255),
477 falloff: FogFalloff::Linear {
478 start: 1.0,
479 end: 4.0,
480 },
481 ..default()
482 },
483 ));
484
485 // example instructions
486 commands.spawn((
487 Text::default(),
488 Node {
489 position_type: PositionType::Absolute,
490 top: px(12),
491 left: px(12),
492 ..default()
493 },
494 ));
495}Sourcepub const fn srgb_u8(red: u8, green: u8, blue: u8) -> Color
pub const fn srgb_u8(red: u8, green: u8, blue: u8) -> Color
Creates a new Color object storing a Srgba color from u8 values with an alpha of 1.0.
§Arguments
red- Red channel. [0, 255]green- Green channel. [0, 255]blue- Blue channel. [0, 255]
Examples found in repository?
examples/picking/debug_picking.rs (line 96)
86fn on_click_spawn_cube(
87 _click: On<Pointer<Click>>,
88 mut commands: Commands,
89 mut meshes: ResMut<Assets<Mesh>>,
90 mut materials: ResMut<Assets<StandardMaterial>>,
91 mut num: Local<usize>,
92) {
93 commands
94 .spawn((
95 Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
96 MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
97 Transform::from_xyz(0.0, 0.25 + 0.55 * *num as f32, 0.0),
98 ))
99 // With the MeshPickingPlugin added, you can add pointer event observers to meshes:
100 .observe(on_drag_rotate);
101 *num += 1;
102}More examples
examples/picking/simple_picking.rs (line 72)
62fn on_click_spawn_cube(
63 _click: On<Pointer<Click>>,
64 mut commands: Commands,
65 mut meshes: ResMut<Assets<Mesh>>,
66 mut materials: ResMut<Assets<StandardMaterial>>,
67 mut num: Local<usize>,
68) {
69 commands
70 .spawn((
71 Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
72 MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
73 Transform::from_xyz(0.0, 0.25 + 0.55 * *num as f32, 0.0),
74 ))
75 // With the MeshPickingPlugin added, you can add pointer event observers to meshes:
76 .observe(on_drag_rotate);
77 *num += 1;
78}examples/app/externally_driven_headless_renderer.rs (line 142)
130fn spawn_test_scene(
131 mut commands: Commands,
132 mut meshes: ResMut<Assets<Mesh>>,
133 mut materials: ResMut<Assets<StandardMaterial>>,
134) {
135 commands.spawn((
136 Mesh3d(meshes.add(Circle::new(4.0))),
137 MeshMaterial3d(materials.add(Color::WHITE)),
138 Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
139 ));
140 commands.spawn((
141 Mesh3d(meshes.add(Cuboid::new(2.0, 2.0, 2.0))),
142 MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
143 Transform::from_xyz(0.0, 1.0, 0.0),
144 ));
145 commands.spawn((
146 PointLight {
147 shadow_maps_enabled: true,
148 ..default()
149 },
150 Transform::from_xyz(4.0, 8.0, 4.0),
151 ));
152}examples/3d/color_grading.rs (line 329)
322fn add_camera(commands: &mut Commands, asset_server: &AssetServer, color_grading: ColorGrading) {
323 commands.spawn((
324 Camera3d::default(),
325 Hdr,
326 Transform::from_xyz(0.7, 0.7, 1.0).looking_at(Vec3::new(0.0, 0.3, 0.0), Vec3::Y),
327 color_grading,
328 DistanceFog {
329 color: Color::srgb_u8(43, 44, 47),
330 falloff: FogFalloff::Linear {
331 start: 1.0,
332 end: 8.0,
333 },
334 ..default()
335 },
336 EnvironmentMapLight {
337 diffuse_map: asset_server.load("environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2"),
338 specular_map: asset_server.load("environment_maps/pisa_specular_rgb9e5_zstd.ktx2"),
339 intensity: 2000.0,
340 ..default()
341 },
342 ));
343}examples/3d/3d_scene.rs (line 24)
13fn scene() -> impl SceneList {
14 bsn_list! [
15 (
16 #CircularBase
17 Mesh3d(asset_value(Circle::new(4.0)))
18 MeshMaterial3d::<StandardMaterial>(asset_value(Color::WHITE))
19 Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2))
20 ),
21 (
22 #Cube
23 Mesh3d(asset_value(Cuboid::new(1.0, 1.0, 1.0)))
24 MeshMaterial3d::<StandardMaterial>(asset_value(Color::srgb_u8(124, 144, 255)))
25 Transform::from_xyz(0.0, 0.5, 0.0)
26 ),
27 (
28 PointLight {
29 shadow_maps_enabled: true,
30 }
31 Transform::from_xyz(4.0, 8.0, 4.0)
32 ),
33 (
34 Camera3d
35 template_value(Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y))
36 )
37 ]
38}examples/3d/motion_blur.rs (line 182)
174fn spawn_barriers(
175 meshes: &mut Assets<Mesh>,
176 materials: &mut Assets<StandardMaterial>,
177 commands: &mut Commands,
178) {
179 const N_CONES: usize = 100;
180 let capsule = meshes.add(Capsule3d::default());
181 let matl = materials.add(StandardMaterial {
182 base_color: Color::srgb_u8(255, 87, 51),
183 reflectance: 1.0,
184 ..default()
185 });
186 let mut spawn_with_offset = |offset: f32| {
187 for i in 0..N_CONES {
188 let pos = race_track_pos(
189 offset,
190 (i as f32) / (N_CONES as f32) * std::f32::consts::PI * 2.0,
191 );
192 commands.spawn((
193 Mesh3d(capsule.clone()),
194 MeshMaterial3d(matl.clone()),
195 Transform::from_xyz(pos.x, -0.65, pos.y).with_scale(Vec3::splat(0.07)),
196 ));
197 }
198 };
199 spawn_with_offset(0.04);
200 spawn_with_offset(-0.04);
201}Additional examples can be found in:
- examples/3d/tonemapping.rs
- examples/3d/post_processing.rs
- examples/remote/server.rs
- examples/camera/custom_projection.rs
- examples/diagnostics/log_diagnostics.rs
- examples/shader_advanced/custom_render_phase.rs
- examples/stress_tests/many_cubes.rs
- examples/3d/skybox.rs
- examples/stress_tests/bevymark.rs
- examples/app/headless_renderer.rs
- examples/app/render_recovery.rs
- examples/3d/spotlight.rs
- examples/gizmos/light_gizmos.rs
- examples/3d/parallax_mapping.rs
- examples/3d/deferred_rendering.rs
Sourcepub fn srgba_u32(color: u32) -> Color
pub fn srgba_u32(color: u32) -> Color
Creates a new Color object storing a Srgba color from a u32 value with the alpha value extracted from the input.
For example, a value of 0x000000ff results in black with full opacity, and a value of 0xff000080 results in red with half opacity.
§Examples
let black = Color::srgba_u32(0x000000ff);
let semi_transparent_red = Color::srgba_u32(0xff000080);Sourcepub const fn linear_rgba(red: f32, green: f32, blue: f32, alpha: f32) -> Color
pub const fn linear_rgba(red: f32, green: f32, blue: f32, alpha: f32) -> Color
Creates a new Color object storing a LinearRgba color.
§Arguments
red- Red channel. [0.0, 1.0]green- Green channel. [0.0, 1.0]blue- Blue channel. [0.0, 1.0]alpha- Alpha channel. [0.0, 1.0]
Examples found in repository?
examples/2d/tilemap_chunk_orientation.rs (line 39)
17fn setup(mut commands: Commands, assets: Res<AssetServer>) {
18 let chunk_size = UVec2::splat(8);
19 let tile_display_size = UVec2::splat(64);
20
21 // We'll use each possible orientation, one per column
22 let orientation = [
23 TileOrientation::Default,
24 TileOrientation::Rotate90,
25 TileOrientation::Rotate180,
26 TileOrientation::Rotate270,
27 TileOrientation::MirrorH,
28 TileOrientation::MirrorHRotate90,
29 TileOrientation::MirrorHRotate180,
30 TileOrientation::MirrorHRotate270,
31 ];
32
33 // Show different color/alpha on each row
34 let colors = [
35 Color::WHITE,
36 Color::linear_rgb(1.0, 0.0, 0.0),
37 Color::linear_rgb(0.0, 1.0, 0.0),
38 Color::linear_rgb(0.0, 0.0, 1.0),
39 Color::linear_rgba(1.0, 0.0, 0.0, 0.25),
40 Color::linear_rgba(0.0, 1.0, 0.0, 0.25),
41 Color::linear_rgba(0.0, 0.0, 1.0, 0.25),
42 Color::linear_rgba(1.0, 1.0, 1.0, 0.5),
43 ];
44
45 let tile_data = (0..chunk_size.element_product())
46 .map(|i| {
47 let row = i / 8;
48 let col = i % 8;
49 Some(TileData {
50 // Alternate tiles per row
51 tileset_index: (row % 2) as u16,
52 color: colors[row as usize],
53 // Last (top) row is invisible
54 visible: row != 7,
55 orientation: orientation[col as usize],
56 })
57 })
58 .collect();
59
60 commands.spawn((
61 TilemapChunk {
62 chunk_size,
63 tile_display_size,
64 tileset: assets
65 .load_builder()
66 .with_settings(|settings: &mut ImageLoaderSettings| {
67 // The tileset texture is expected to be an array of tile textures, so we tell the
68 // `ImageLoader` that our texture is composed of 2 stacked tile images.
69 settings.array_layout = Some(ImageArrayLayout::RowCount { rows: 2 });
70 })
71 .load("textures/arrow.png"),
72 alpha_mode: AlphaMode2d::Blend,
73 },
74 TilemapChunkTileData(tile_data),
75 ));
76
77 commands.spawn(Camera2d);
78}Sourcepub const fn linear_rgb(red: f32, green: f32, blue: f32) -> Color
pub const fn linear_rgb(red: f32, green: f32, blue: f32) -> Color
Creates a new Color object storing a LinearRgba color with an alpha of 1.0.
§Arguments
red- Red channel. [0.0, 1.0]green- Green channel. [0.0, 1.0]blue- Blue channel. [0.0, 1.0]
Examples found in repository?
More examples
examples/stress_tests/bevymark_3d.rs (line 313)
297fn mouse_handler(
298 mut commands: Commands,
299 args: Res<Args>,
300 time: Res<Time>,
301 mouse_button_input: Res<ButtonInput<MouseButton>>,
302 cube_resources: ResMut<CubeResources>,
303 mut counter: ResMut<BevyCounter>,
304 mut rng: Local<Option<ChaCha8Rng>>,
305 mut wave: Local<usize>,
306) {
307 if rng.is_none() {
308 *rng = Some(ChaCha8Rng::seed_from_u64(42));
309 }
310 let rng = rng.as_mut().unwrap();
311
312 if mouse_button_input.just_released(MouseButton::Left) {
313 counter.color = Color::linear_rgb(rng.random(), rng.random(), rng.random());
314 }
315
316 if mouse_button_input.pressed(MouseButton::Left) {
317 let spawn_count = (CUBES_PER_SECOND as f64 * time.delta_secs_f64()) as usize;
318 spawn_cubes(
319 &mut commands,
320 args.into_inner(),
321 &mut counter,
322 spawn_count,
323 cube_resources.into_inner(),
324 None,
325 *wave,
326 );
327 *wave += 1;
328 }
329}
330
331fn cube_velocity_transform(
332 mut translation: Vec3,
333 velocity_rng: &mut ChaCha8Rng,
334 waves: Option<usize>,
335 dt: f32,
336) -> (Transform, Vec3) {
337 let mut velocity = Vec3::new(0., 0., MAX_VELOCITY * velocity_rng.random::<f32>());
338
339 if let Some(waves) = waves {
340 for _ in 0..(waves * (FIXED_TIMESTEP / dt).round() as usize) {
341 step_movement(&mut translation, &mut velocity, dt);
342 handle_collision(&translation, &mut velocity);
343 }
344 }
345 (Transform::from_translation(translation), velocity)
346}
347
348const FIXED_DELTA_TIME: f32 = 1.0 / 60.0;
349
350fn spawn_cubes(
351 commands: &mut Commands,
352 args: &Args,
353 counter: &mut BevyCounter,
354 spawn_count: usize,
355 cube_resources: &mut CubeResources,
356 waves_to_simulate: Option<usize>,
357 wave: usize,
358) {
359 let batch_material = cube_resources.materials[wave % cube_resources.materials.len()].clone();
360
361 let spawn_y = VOLUME_SIZE.y / 2.0 - HALF_CUBE_SIZE;
362 let spawn_z = -VOLUME_SIZE.z / 2.0 + HALF_CUBE_SIZE;
363
364 let batch = (0..spawn_count)
365 .map(|_| {
366 let spawn_pos = Vec3::new(
367 (cube_resources.transform_rng.random::<f32>() - 0.5) * VOLUME_SIZE.x,
368 spawn_y,
369 spawn_z,
370 );
371
372 let (transform, velocity) = cube_velocity_transform(
373 spawn_pos,
374 &mut cube_resources.velocity_rng,
375 waves_to_simulate,
376 FIXED_DELTA_TIME,
377 );
378
379 let material = if args.vary_per_instance {
380 cube_resources
381 .materials
382 .choose(&mut cube_resources.material_rng)
383 .unwrap()
384 .clone()
385 } else {
386 batch_material.clone()
387 };
388
389 (
390 Mesh3d(cube_resources.cube_mesh.clone()),
391 MeshMaterial3d(material),
392 transform,
393 Cube { velocity },
394 )
395 })
396 .collect::<Vec<_>>();
397 commands.spawn_batch(batch);
398
399 counter.count += spawn_count;
400 counter.color = Color::linear_rgb(
401 cube_resources.color_rng.random(),
402 cube_resources.color_rng.random(),
403 cube_resources.color_rng.random(),
404 );
405}
406
407fn step_movement(translation: &mut Vec3, velocity: &mut Vec3, dt: f32) {
408 translation.x += velocity.x * dt;
409 translation.y += velocity.y * dt;
410 translation.z += velocity.z * dt;
411 velocity.y += GRAVITY * dt;
412}
413
414fn movement_system(
415 args: Res<Args>,
416 time: Res<Time>,
417 mut cube_query: Query<(&mut Cube, &mut Transform)>,
418) {
419 let dt = if args.benchmark {
420 FIXED_DELTA_TIME
421 } else {
422 time.delta_secs()
423 };
424 for (mut cube, mut transform) in &mut cube_query {
425 step_movement(&mut transform.translation, &mut cube.velocity, dt);
426 }
427}
428
429fn handle_collision(translation: &Vec3, velocity: &mut Vec3) {
430 if (velocity.x > 0. && translation.x + HALF_CUBE_SIZE > VOLUME_SIZE.x / 2.0)
431 || (velocity.x <= 0. && translation.x - HALF_CUBE_SIZE < -VOLUME_SIZE.x / 2.0)
432 {
433 velocity.x = -velocity.x;
434 }
435 if (velocity.z > 0. && translation.z + HALF_CUBE_SIZE > VOLUME_SIZE.z / 2.0)
436 || (velocity.z <= 0. && translation.z - HALF_CUBE_SIZE < -VOLUME_SIZE.z / 2.0)
437 {
438 velocity.z = -velocity.z;
439 }
440
441 let velocity_y = velocity.y;
442 if velocity_y < 0. && translation.y - HALF_CUBE_SIZE < -VOLUME_SIZE.y / 2.0 {
443 velocity.y = -velocity_y;
444 }
445 if translation.y + HALF_CUBE_SIZE > VOLUME_SIZE.y / 2.0 && velocity_y > 0.0 {
446 velocity.y = 0.0;
447 }
448}
449
450fn collision_system(mut cube_query: Query<(&mut Cube, &Transform)>) {
451 cube_query.par_iter_mut().for_each(|(mut cube, transform)| {
452 handle_collision(&transform.translation, &mut cube.velocity);
453 });
454}
455
456fn counter_system(
457 diagnostics: Res<DiagnosticsStore>,
458 counter: Res<BevyCounter>,
459 query: Single<Entity, With<StatsText>>,
460 mut writer: TextUiWriter,
461) {
462 let text = *query;
463
464 if counter.is_changed() {
465 *writer.text(text, 2) = counter.count.to_string();
466 }
467
468 if let Some(fps) = diagnostics.get(&FrameTimeDiagnosticsPlugin::FPS) {
469 if let Some(raw) = fps.value() {
470 *writer.text(text, 4) = format!("{raw:.2}");
471 }
472 if let Some(sma) = fps.average() {
473 *writer.text(text, 6) = format!("{sma:.2}");
474 }
475 if let Some(ema) = fps.smoothed() {
476 *writer.text(text, 8) = format!("{ema:.2}");
477 }
478 };
479}
480
481fn init_textures(textures: &mut Vec<Handle<Image>>, args: &Args, images: &mut Assets<Image>) {
482 let mut color_rng = ChaCha8Rng::seed_from_u64(42);
483 while textures.len() < args.material_texture_count {
484 let pixel = [
485 color_rng.random(),
486 color_rng.random(),
487 color_rng.random(),
488 255,
489 ];
490 textures.push(images.add(Image::new_fill(
491 Extent3d {
492 width: CUBE_TEXTURE_SIZE as u32,
493 height: CUBE_TEXTURE_SIZE as u32,
494 depth_or_array_layers: 1,
495 },
496 TextureDimension::D2,
497 &pixel,
498 TextureFormat::Rgba8UnormSrgb,
499 RenderAssetUsages::RENDER_WORLD,
500 )));
501 }
502}
503
504fn init_materials(
505 args: &Args,
506 textures: &[Handle<Image>],
507 assets: &mut Assets<StandardMaterial>,
508) -> Vec<Handle<StandardMaterial>> {
509 let mut capacity = if args.vary_per_instance {
510 args.per_wave * args.waves
511 } else {
512 args.material_texture_count.max(args.waves)
513 };
514 if !args.benchmark {
515 capacity = capacity.max(256);
516 }
517 capacity = capacity.max(1);
518
519 let alpha_mode = match args.alpha_mode {
520 AlphaMode::Opaque => bevy::prelude::AlphaMode::Opaque,
521 AlphaMode::Blend => bevy::prelude::AlphaMode::Blend,
522 AlphaMode::AlphaMask => bevy::prelude::AlphaMode::Mask(0.5),
523 };
524
525 let mut materials = Vec::with_capacity(capacity);
526 materials.push(assets.add(StandardMaterial {
527 base_color: Color::WHITE,
528 base_color_texture: textures.first().cloned(),
529 alpha_mode,
530 ..default()
531 }));
532
533 let mut color_rng = ChaCha8Rng::seed_from_u64(42);
534 let mut texture_rng = ChaCha8Rng::seed_from_u64(42);
535 materials.extend(
536 std::iter::repeat_with(|| {
537 assets.add(StandardMaterial {
538 base_color: Color::linear_rgb(
539 color_rng.random(),
540 color_rng.random(),
541 color_rng.random(),
542 ),
543 base_color_texture: textures.choose(&mut texture_rng).cloned(),
544 alpha_mode,
545 ..default()
546 })
547 })
548 .take(capacity - materials.len()),
549 );
550
551 materials
552}examples/stress_tests/bevymark.rs (line 346)
323fn mouse_handler(
324 mut commands: Commands,
325 args: Res<Args>,
326 time: Res<Time>,
327 mouse_button_input: Res<ButtonInput<MouseButton>>,
328 window: Query<&Window>,
329 bird_resources: ResMut<BirdResources>,
330 mut counter: ResMut<BevyCounter>,
331 mut rng: Local<Option<ChaCha8Rng>>,
332 mut wave: Local<usize>,
333) {
334 let Ok(window) = window.single() else {
335 return;
336 };
337
338 if rng.is_none() {
339 // We're seeding the PRNG here to make this example deterministic for testing purposes.
340 // This isn't strictly required in practical use unless you need your app to be deterministic.
341 *rng = Some(ChaCha8Rng::seed_from_u64(42));
342 }
343 let rng = rng.as_mut().unwrap();
344
345 if mouse_button_input.just_released(MouseButton::Left) {
346 counter.color = Color::linear_rgb(rng.random(), rng.random(), rng.random());
347 }
348
349 if mouse_button_input.pressed(MouseButton::Left) {
350 let spawn_count = (BIRDS_PER_SECOND as f64 * time.delta_secs_f64()) as usize;
351 spawn_birds(
352 &mut commands,
353 args.into_inner(),
354 &window.resolution,
355 &mut counter,
356 spawn_count,
357 bird_resources.into_inner(),
358 None,
359 *wave,
360 );
361 *wave += 1;
362 }
363}
364
365fn bird_velocity_transform(
366 half_extents: Vec2,
367 mut translation: Vec3,
368 velocity_rng: &mut ChaCha8Rng,
369 waves: Option<usize>,
370 dt: f32,
371) -> (Transform, Vec3) {
372 let mut velocity = Vec3::new(MAX_VELOCITY * (velocity_rng.random::<f32>() - 0.5), 0., 0.);
373
374 if let Some(waves) = waves {
375 // Step the movement and handle collisions as if the wave had been spawned at fixed time intervals
376 // and with dt-spaced frames of simulation
377 for _ in 0..(waves * (FIXED_TIMESTEP / dt).round() as usize) {
378 step_movement(&mut translation, &mut velocity, dt);
379 handle_collision(half_extents, &translation, &mut velocity);
380 }
381 }
382 (
383 Transform::from_translation(translation).with_scale(Vec3::splat(BIRD_SCALE)),
384 velocity,
385 )
386}
387
388const FIXED_DELTA_TIME: f32 = 1.0 / 60.0;
389
390fn spawn_birds(
391 commands: &mut Commands,
392 args: &Args,
393 primary_window_resolution: &WindowResolution,
394 counter: &mut BevyCounter,
395 spawn_count: usize,
396 bird_resources: &mut BirdResources,
397 waves_to_simulate: Option<usize>,
398 wave: usize,
399) {
400 let bird_x = (primary_window_resolution.width() / -2.) + HALF_BIRD_SIZE;
401 let bird_y = (primary_window_resolution.height() / 2.) - HALF_BIRD_SIZE;
402
403 let half_extents = 0.5 * primary_window_resolution.size();
404
405 let color = counter.color;
406 let current_count = counter.count;
407
408 match args.mode {
409 Mode::Sprite => {
410 let batch = (0..spawn_count)
411 .map(|count| {
412 let bird_z = if args.ordered_z {
413 (current_count + count) as f32 * 0.00001
414 } else {
415 bird_resources.transform_rng.random::<f32>()
416 };
417
418 let (transform, velocity) = bird_velocity_transform(
419 half_extents,
420 Vec3::new(bird_x, bird_y, bird_z),
421 &mut bird_resources.velocity_rng,
422 waves_to_simulate,
423 FIXED_DELTA_TIME,
424 );
425
426 let color = if args.vary_per_instance {
427 Color::linear_rgb(
428 bird_resources.color_rng.random(),
429 bird_resources.color_rng.random(),
430 bird_resources.color_rng.random(),
431 )
432 } else {
433 color
434 };
435 (
436 Sprite {
437 image: bird_resources
438 .textures
439 .choose(&mut bird_resources.material_rng)
440 .unwrap()
441 .clone(),
442 color,
443 ..default()
444 },
445 transform,
446 Bird { velocity },
447 )
448 })
449 .collect::<Vec<_>>();
450 commands.spawn_batch(batch);
451 }
452 Mode::SpriteMesh => {
453 let alpha_mode = match args.alpha_mode {
454 AlphaMode::Opaque => SpriteAlphaMode::Opaque,
455 AlphaMode::Blend => SpriteAlphaMode::Blend,
456 AlphaMode::AlphaMask => SpriteAlphaMode::Mask(0.5),
457 };
458
459 let batch = (0..spawn_count)
460 .map(|count| {
461 let bird_z = if args.ordered_z {
462 (current_count + count) as f32 * 0.00001
463 } else {
464 bird_resources.transform_rng.random::<f32>()
465 };
466
467 let (transform, velocity) = bird_velocity_transform(
468 half_extents,
469 Vec3::new(bird_x, bird_y, bird_z),
470 &mut bird_resources.velocity_rng,
471 waves_to_simulate,
472 FIXED_DELTA_TIME,
473 );
474
475 let color = if args.vary_per_instance {
476 Color::linear_rgb(
477 bird_resources.color_rng.random(),
478 bird_resources.color_rng.random(),
479 bird_resources.color_rng.random(),
480 )
481 } else {
482 color
483 };
484 (
485 SpriteMesh {
486 image: bird_resources
487 .textures
488 .choose(&mut bird_resources.material_rng)
489 .unwrap()
490 .clone(),
491 color,
492 alpha_mode,
493 ..default()
494 },
495 transform,
496 Bird { velocity },
497 )
498 })
499 .collect::<Vec<_>>();
500 commands.spawn_batch(batch);
501 }
502 Mode::Mesh2d => {
503 let batch = (0..spawn_count)
504 .map(|count| {
505 let bird_z = if args.ordered_z {
506 (current_count + count) as f32 * 0.00001
507 } else {
508 bird_resources.transform_rng.random::<f32>()
509 };
510
511 let (transform, velocity) = bird_velocity_transform(
512 half_extents,
513 Vec3::new(bird_x, bird_y, bird_z),
514 &mut bird_resources.velocity_rng,
515 waves_to_simulate,
516 FIXED_DELTA_TIME,
517 );
518
519 let material =
520 if args.vary_per_instance || args.material_texture_count > args.waves {
521 bird_resources
522 .materials
523 .choose(&mut bird_resources.material_rng)
524 .unwrap()
525 .clone()
526 } else {
527 bird_resources.materials[wave % bird_resources.materials.len()].clone()
528 };
529 (
530 Mesh2d(bird_resources.quad.clone()),
531 MeshMaterial2d(material),
532 transform,
533 Bird { velocity },
534 )
535 })
536 .collect::<Vec<_>>();
537 commands.spawn_batch(batch);
538 }
539 }
540
541 counter.count += spawn_count;
542 counter.color = Color::linear_rgb(
543 bird_resources.color_rng.random(),
544 bird_resources.color_rng.random(),
545 bird_resources.color_rng.random(),
546 );
547}examples/usage/context_menu.rs (line 101)
81fn on_trigger_menu(event: On<OpenContextMenu>, mut commands: Commands) {
82 commands.trigger(CloseContextMenus);
83
84 let pos = event.pos;
85
86 debug!("open context menu at: {pos}");
87
88 commands
89 .spawn((
90 Name::new("context menu"),
91 ContextMenu,
92 Node {
93 position_type: PositionType::Absolute,
94 left: px(pos.x),
95 top: px(pos.y),
96 flex_direction: FlexDirection::Column,
97 border_radius: BorderRadius::all(px(4)),
98 ..default()
99 },
100 BorderColor::all(Color::BLACK),
101 BackgroundColor(Color::linear_rgb(0.1, 0.1, 0.1)),
102 children![
103 context_item("fuchsia", basic::FUCHSIA),
104 context_item("gray", basic::GRAY),
105 context_item("maroon", basic::MAROON),
106 context_item("purple", basic::PURPLE),
107 context_item("teal", basic::TEAL),
108 ],
109 ))
110 .observe(
111 |event: On<Pointer<Press>>,
112 menu_items: Query<&ContextMenuItem>,
113 mut clear_col: ResMut<ClearColor>,
114 mut commands: Commands| {
115 let target = event.original_event_target();
116
117 if let Ok(item) = menu_items.get(target) {
118 clear_col.0 = item.0.into();
119 commands.trigger(CloseContextMenus);
120 }
121 },
122 );
123}examples/2d/cpu_draw.rs (lines 102-106)
92fn draw(
93 my_handle: Res<MyProcGenImage>,
94 mut images: ResMut<Assets<Image>>,
95 // Used to keep track of where we are
96 mut i: Local<u32>,
97 mut draw_color: Local<Color>,
98 mut seeded_rng: ResMut<SeededRng>,
99) {
100 if *i == 0 {
101 // Generate a random color on first run.
102 *draw_color = Color::linear_rgb(
103 seeded_rng.0.random(),
104 seeded_rng.0.random(),
105 seeded_rng.0.random(),
106 );
107 }
108
109 // Get the image from Bevy's asset storage.
110 let mut image = images.get_mut(&my_handle.0).expect("Image not found");
111
112 // Compute the position of the pixel to draw.
113
114 let center = Vec2::new(IMAGE_WIDTH as f32 / 2.0, IMAGE_HEIGHT as f32 / 2.0);
115 let max_radius = IMAGE_HEIGHT.min(IMAGE_WIDTH) as f32 / 2.0;
116 let rot_speed = 0.0123;
117 let period = 0.12345;
118
119 let r = ops::sin(*i as f32 * period) * max_radius;
120 let xy = Vec2::from_angle(*i as f32 * rot_speed) * r + center;
121 let (x, y) = (xy.x as u32, xy.y as u32);
122
123 // Get the old color of that pixel.
124 let old_color = image.get_color_at(x, y).unwrap();
125
126 // If the old color is our current color, change our drawing color.
127 let tolerance = 1.0 / 255.0;
128 if old_color.distance(&draw_color) <= tolerance {
129 *draw_color = Color::linear_rgb(
130 seeded_rng.0.random(),
131 seeded_rng.0.random(),
132 seeded_rng.0.random(),
133 );
134 }
135
136 // Set the new color, but keep old alpha value from image.
137 image
138 .set_color_at(x, y, draw_color.with_alpha(old_color.alpha()))
139 .unwrap();
140
141 *i += 1;
142}examples/2d/2d_viewport_to_world.rs (line 173)
126fn setup(
127 mut commands: Commands,
128 mut meshes: ResMut<Assets<Mesh>>,
129 mut materials: ResMut<Assets<ColorMaterial>>,
130 window: Single<&Window>,
131) {
132 let window_size = window.resolution.physical_size().as_vec2();
133
134 // Initialize centered, non-window-filling viewport
135 commands.spawn((
136 Camera2d,
137 Camera {
138 viewport: Some(Viewport {
139 physical_position: (window_size * 0.125).as_uvec2(),
140 physical_size: (window_size * 0.75).as_uvec2(),
141 ..default()
142 }),
143 ..default()
144 },
145 ));
146
147 // Create a minimal UI explaining how to interact with the example
148 commands.spawn((
149 Text::new(
150 "Move the mouse to see the circle follow your cursor.\n\
151 Use the arrow keys to move the camera.\n\
152 Use the comma and period keys to zoom in and out.\n\
153 Use the WASD keys to move the viewport.\n\
154 Use the IJKL keys to resize the viewport.",
155 ),
156 Node {
157 position_type: PositionType::Absolute,
158 top: px(12),
159 left: px(12),
160 ..default()
161 },
162 ));
163
164 // Add mesh to make camera movement visible
165 commands.spawn((
166 Mesh2d(meshes.add(Rectangle::new(40.0, 20.0))),
167 MeshMaterial2d(materials.add(Color::from(GREEN))),
168 ));
169
170 // Add background to visualize viewport bounds
171 commands.spawn((
172 Mesh2d(meshes.add(Rectangle::new(50000.0, 50000.0))),
173 MeshMaterial2d(materials.add(Color::linear_rgb(0.01, 0.01, 0.01))),
174 Transform::from_translation(Vec3::new(0.0, 0.0, -200.0)),
175 ));
176}Additional examples can be found in:
Sourcepub const fn hsla(
hue: f32,
saturation: f32,
lightness: f32,
alpha: f32,
) -> Color
pub const fn hsla( hue: f32, saturation: f32, lightness: f32, alpha: f32, ) -> Color
Creates a new Color object storing a Hsla color.
§Arguments
hue- Hue channel. [0.0, 360.0]saturation- Saturation channel. [0.0, 1.0]lightness- Lightness channel. [0.0, 1.0]alpha- Alpha channel. [0.0, 1.0]
Examples found in repository?
examples/shader_advanced/custom_shader_instancing.rs (line 65)
56fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>) {
57 commands.spawn((
58 Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
59 InstanceMaterialData(
60 (1..=10)
61 .flat_map(|x| (1..=10).map(move |y| (x as f32 / 10.0, y as f32 / 10.0)))
62 .map(|(x, y)| InstanceData {
63 position: Vec3::new(x * 10.0 - 5.0, y * 10.0 - 5.0, 0.0),
64 scale: 1.0,
65 color: LinearRgba::from(Color::hsla(x * 360., y, 0.5, 1.0)).to_f32_array(),
66 })
67 .collect(),
68 ),
69 // NOTE: Frustum culling is done based on the Aabb of the Mesh and the GlobalTransform.
70 // As the cube is at the origin, if its Aabb moves outside the view frustum, all the
71 // instanced cubes will be culled.
72 // The InstanceMaterialData contains the 'GlobalTransform' information for this custom
73 // instancing, and that is not taken into account with the built-in frustum culling.
74 // We must disable the built-in frustum culling by adding the `NoFrustumCulling` marker
75 // component to avoid incorrect culling.
76 NoFrustumCulling,
77 ));
78
79 // camera
80 commands.spawn((
81 Camera3d::default(),
82 Transform::from_xyz(0.0, 0.0, 15.0).looking_at(Vec3::ZERO, Vec3::Y),
83 // We need this component because we use `draw_indexed` and `draw`
84 // instead of `draw_indirect_indexed` and `draw_indirect` in
85 // `DrawMeshInstanced::render`.
86 NoIndirectDrawing,
87 ));
88}More examples
examples/testbed/2d.rs (line 227)
193 pub fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
194 commands.spawn((Camera2d, DespawnOnExit(super::Scene::Text)));
195
196 for (i, justify) in [
197 Justify::Left,
198 Justify::Right,
199 Justify::Center,
200 Justify::Justified,
201 ]
202 .into_iter()
203 .enumerate()
204 {
205 let y = 230. - 150. * i as f32;
206 spawn_anchored_text(&mut commands, -300. * Vec3::X + y * Vec3::Y, justify, None);
207 spawn_anchored_text(
208 &mut commands,
209 300. * Vec3::X + y * Vec3::Y,
210 justify,
211 Some(TextBounds::new(150., 60.)),
212 );
213 }
214
215 let sans_serif = TextFont::from(asset_server.load("fonts/FiraSans-Bold.ttf"));
216
217 const NUM_ITERATIONS: usize = 10;
218 for i in 0..NUM_ITERATIONS {
219 let fraction = i as f32 / (NUM_ITERATIONS - 1) as f32;
220
221 commands.spawn((
222 Text2d::new("Bevy"),
223 sans_serif.clone(),
224 Transform::from_xyz(0.0, fraction * 200.0, i as f32)
225 .with_scale(1.0 + Vec2::splat(fraction).extend(1.))
226 .with_rotation(Quat::from_rotation_z(fraction * core::f32::consts::PI)),
227 TextColor(Color::hsla(fraction * 360.0, 0.8, 0.8, 0.8)),
228 DespawnOnExit(super::Scene::Text),
229 ));
230 }
231
232 commands.spawn((
233 Text2d::new("This text is invisible."),
234 Visibility::Hidden,
235 DespawnOnExit(super::Scene::Text),
236 ));
237 }Sourcepub const fn hsl(hue: f32, saturation: f32, lightness: f32) -> Color
pub const fn hsl(hue: f32, saturation: f32, lightness: f32) -> Color
Creates a new Color object storing a Hsla color with an alpha of 1.0.
§Arguments
hue- Hue channel. [0.0, 360.0]saturation- Saturation channel. [0.0, 1.0]lightness- Lightness channel. [0.0, 1.0]
Examples found in repository?
More examples
examples/stress_tests/many_materials.rs (lines 96-100)
89fn animate_materials(
90 material_handles: Query<&MeshMaterial3d<StandardMaterial>>,
91 time: Res<Time>,
92 mut materials: ResMut<Assets<StandardMaterial>>,
93) {
94 for (i, material_handle) in material_handles.iter().enumerate() {
95 if let Some(mut material) = materials.get_mut(material_handle) {
96 let color = Color::hsl(
97 ((i as f32 * 2.345 + time.elapsed_secs()) * 100.0) % 360.0,
98 1.0,
99 0.5,
100 );
101 material.base_color = color;
102 }
103 }
104}examples/ui/ui_material.rs (line 99)
90fn animate(
91 mut materials: ResMut<Assets<CustomUiMaterial>>,
92 q: Query<&MaterialNode<CustomUiMaterial>>,
93 time: Res<Time>,
94) {
95 let duration = 2.0;
96 for handle in &q {
97 if let Some(mut material) = materials.get_mut(handle) {
98 // rainbow color effect
99 let new_color = Color::hsl((time.elapsed_secs() * 60.0) % 360.0, 1., 0.5);
100 let border_color = Color::hsl((time.elapsed_secs() * 60.0) % 360.0, 0.75, 0.75);
101 material.color = new_color.to_linear().to_vec4();
102 material.slider.x =
103 ((time.elapsed_secs() % (duration * 2.0)) - duration).abs() / duration;
104 material.border_color = border_color.to_linear().to_vec4();
105 }
106 }
107}examples/ecs/entity_disabling.rs (line 123)
104fn setup_scene(
105 mut commands: Commands,
106 mut meshes: ResMut<Assets<Mesh>>,
107 mut materials: ResMut<Assets<ColorMaterial>>,
108) {
109 commands.spawn(Camera2d);
110
111 let named_shapes = [
112 (Name::new("Annulus"), meshes.add(Annulus::new(25.0, 50.0))),
113 (
114 Name::new("Bestagon"),
115 meshes.add(RegularPolygon::new(50.0, 6)),
116 ),
117 (Name::new("Rhombus"), meshes.add(Rhombus::new(75.0, 100.0))),
118 ];
119 let num_shapes = named_shapes.len();
120
121 for (i, (name, shape)) in named_shapes.into_iter().enumerate() {
122 // Distribute colors evenly across the rainbow.
123 let color = Color::hsl(360. * i as f32 / num_shapes as f32, 0.95, 0.7);
124
125 commands.spawn((
126 name,
127 DisableOnClick,
128 Mesh2d(shape),
129 MeshMaterial2d(materials.add(color)),
130 Transform::from_xyz(
131 // Distribute shapes from -X_EXTENT/2 to +X_EXTENT/2.
132 -X_EXTENT / 2. + i as f32 / (num_shapes - 1) as f32 * X_EXTENT,
133 0.0,
134 0.0,
135 ),
136 ));
137 }
138}examples/stress_tests/many_gradients.rs (line 153)
137fn animate_gradients(
138 mut gradients: Query<(&mut BackgroundGradient, &GradientNode)>,
139 args: Res<Args>,
140 time: Res<Time>,
141) {
142 if !args.animate {
143 return;
144 }
145
146 let t = time.elapsed_secs();
147
148 for (mut bg_gradient, node) in &mut gradients {
149 let offset = node.index as f32 * 0.01;
150 let hue_shift = sin(t + offset) * 0.5 + 0.5;
151
152 if let Some(Gradient::Linear(gradient)) = bg_gradient.0.get_mut(0) {
153 let color1 = Color::hsl(hue_shift * 360.0, 1.0, 0.5);
154 let color2 = Color::hsl((hue_shift + 0.3) * 360.0 % 360.0, 1.0, 0.5);
155
156 gradient.stops = vec![
157 ColorStop::new(color1, percent(0)),
158 ColorStop::new(color2, percent(100)),
159 ColorStop::new(
160 Color::hsl((hue_shift + 0.1) * 360.0 % 360.0, 1.0, 0.5),
161 percent(20),
162 ),
163 ColorStop::new(
164 Color::hsl((hue_shift + 0.15) * 360.0 % 360.0, 1.0, 0.5),
165 percent(40),
166 ),
167 ColorStop::new(
168 Color::hsl((hue_shift + 0.2) * 360.0 % 360.0, 1.0, 0.5),
169 percent(60),
170 ),
171 ColorStop::new(
172 Color::hsl((hue_shift + 0.25) * 360.0 % 360.0, 1.0, 0.5),
173 percent(80),
174 ),
175 ColorStop::new(
176 Color::hsl((hue_shift + 0.28) * 360.0 % 360.0, 1.0, 0.5),
177 percent(90),
178 ),
179 ];
180 }
181 }
182}examples/testbed/2d.rs (line 139)
112 pub fn setup(
113 mut commands: Commands,
114 mut meshes: ResMut<Assets<Mesh>>,
115 mut materials: ResMut<Assets<ColorMaterial>>,
116 ) {
117 commands.spawn((Camera2d, DespawnOnExit(super::Scene::Shapes)));
118
119 let shapes = [
120 meshes.add(Circle::new(50.0)),
121 meshes.add(CircularSector::new(50.0, 1.0)),
122 meshes.add(CircularSegment::new(50.0, 1.25)),
123 meshes.add(Ellipse::new(25.0, 50.0)),
124 meshes.add(Annulus::new(25.0, 50.0)),
125 meshes.add(Capsule2d::new(25.0, 50.0)),
126 meshes.add(Rhombus::new(75.0, 100.0)),
127 meshes.add(Rectangle::new(50.0, 100.0)),
128 meshes.add(RegularPolygon::new(50.0, 6)),
129 meshes.add(Triangle2d::new(
130 Vec2::Y * 50.0,
131 Vec2::new(-50.0, -50.0),
132 Vec2::new(50.0, -50.0),
133 )),
134 ];
135 let num_shapes = shapes.len();
136
137 for (i, shape) in shapes.into_iter().enumerate() {
138 // Distribute colors evenly across the rainbow.
139 let color = Color::hsl(360. * i as f32 / num_shapes as f32, 0.95, 0.7);
140
141 commands.spawn((
142 Mesh2d(shape),
143 MeshMaterial2d(materials.add(color)),
144 Transform::from_xyz(
145 // Distribute shapes from -X_EXTENT/2 to +X_EXTENT/2.
146 -X_EXTENT / 2. + i as f32 / (num_shapes - 1) as f32 * X_EXTENT,
147 0.0,
148 0.0,
149 ),
150 DespawnOnExit(super::Scene::Shapes),
151 ));
152 }
153 }Sourcepub const fn hsva(hue: f32, saturation: f32, value: f32, alpha: f32) -> Color
pub const fn hsva(hue: f32, saturation: f32, value: f32, alpha: f32) -> Color
Creates a new Color object storing a Hsva color.
§Arguments
hue- Hue channel. [0.0, 360.0]saturation- Saturation channel. [0.0, 1.0]value- Value channel. [0.0, 1.0]alpha- Alpha channel. [0.0, 1.0]
Examples found in repository?
examples/3d/specular_tint.rs (line 111)
75fn setup(
76 mut commands: Commands,
77 asset_server: Res<AssetServer>,
78 app_status: Res<AppStatus>,
79 mut meshes: ResMut<Assets<Mesh>>,
80 mut standard_materials: ResMut<Assets<StandardMaterial>>,
81) {
82 // Spawns a camera.
83 commands.spawn((
84 Transform::from_xyz(-2.0, 0.0, 3.5).looking_at(Vec3::ZERO, Vec3::Y),
85 Hdr,
86 Camera3d::default(),
87 Skybox {
88 image: Some(asset_server.load("environment_maps/pisa_specular_rgb9e5_zstd.ktx2")),
89 brightness: 3000.0,
90 ..default()
91 },
92 EnvironmentMapLight {
93 diffuse_map: asset_server.load("environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2"),
94 specular_map: asset_server.load("environment_maps/pisa_specular_rgb9e5_zstd.ktx2"),
95 // We want relatively high intensity here in order for the specular
96 // tint to show up well.
97 intensity: 25000.0,
98 ..default()
99 },
100 ));
101
102 // Spawn the sphere.
103 commands.spawn((
104 Transform::from_rotation(Quat::from_rotation_x(PI * 0.5)),
105 Mesh3d(meshes.add(Sphere::default().mesh().uv(32, 18))),
106 MeshMaterial3d(standard_materials.add(StandardMaterial {
107 // We want only reflected specular light here, so we set the base
108 // color as black.
109 base_color: Color::BLACK,
110 reflectance: 1.0,
111 specular_tint: Color::hsva(app_status.hue, 1.0, 1.0, 1.0),
112 // The object must not be metallic, or else the reflectance is
113 // ignored per the Filament spec:
114 //
115 // <https://google.github.io/filament/Filament.md.html#listing_fnormal>
116 metallic: 0.0,
117 perceptual_roughness: 0.0,
118 ..default()
119 })),
120 ));
121
122 // Spawn the help text.
123 commands.spawn((
124 Node {
125 position_type: PositionType::Absolute,
126 bottom: px(12),
127 left: px(12),
128 ..default()
129 },
130 app_status.create_text(),
131 ));
132}
133
134/// Rotates the camera a bit every frame.
135fn rotate_camera(mut cameras: Query<&mut Transform, With<Camera3d>>) {
136 for mut camera_transform in cameras.iter_mut() {
137 camera_transform.translation =
138 Quat::from_rotation_y(ROTATION_SPEED) * camera_transform.translation;
139 camera_transform.look_at(Vec3::ZERO, Vec3::Y);
140 }
141}
142
143/// Alters the hue of the solid color a bit every frame.
144fn shift_hue(
145 mut app_status: ResMut<AppStatus>,
146 objects_with_materials: Query<&MeshMaterial3d<StandardMaterial>>,
147 mut standard_materials: ResMut<Assets<StandardMaterial>>,
148) {
149 if app_status.tint_type != TintType::Solid {
150 return;
151 }
152
153 app_status.hue += HUE_SHIFT_SPEED;
154
155 for material_handle in objects_with_materials.iter() {
156 let Some(mut material) = standard_materials.get_mut(material_handle) else {
157 continue;
158 };
159 material.specular_tint = Color::hsva(app_status.hue, 1.0, 1.0, 1.0);
160 }
161}Sourcepub const fn hsv(hue: f32, saturation: f32, value: f32) -> Color
pub const fn hsv(hue: f32, saturation: f32, value: f32) -> Color
Creates a new Color object storing a Hsva color with an alpha of 1.0.
§Arguments
hue- Hue channel. [0.0, 360.0]saturation- Saturation channel. [0.0, 1.0]value- Value channel. [0.0, 1.0]
Examples found in repository?
examples/stress_tests/many_cameras_lights.rs (line 59)
34fn setup(
35 mut commands: Commands,
36 mut meshes: ResMut<Assets<Mesh>>,
37 mut materials: ResMut<Assets<StandardMaterial>>,
38 window: Query<&Window>,
39) -> Result {
40 // circular base
41 commands.spawn((
42 Mesh3d(meshes.add(Circle::new(4.0))),
43 MeshMaterial3d(materials.add(Color::WHITE)),
44 Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
45 ));
46
47 // cube
48 commands.spawn((
49 Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
50 MeshMaterial3d(materials.add(Color::WHITE)),
51 Transform::from_xyz(0.0, 0.5, 0.0),
52 ));
53
54 // lights
55 for i in 0..NUM_LIGHTS {
56 let angle = (i as f32) / (NUM_LIGHTS as f32) * PI * 2.0;
57 commands.spawn((
58 PointLight {
59 color: Color::hsv(angle.to_degrees(), 1.0, 1.0),
60 intensity: 2_000_000.0 / NUM_LIGHTS as f32,
61 shadow_maps_enabled: true,
62 ..default()
63 },
64 Transform::from_xyz(sin(angle) * 4.0, 2.0, cos(angle) * 4.0),
65 ));
66 }
67
68 // cameras
69 let window = window.single()?;
70 let width = window.resolution.width() / CAMERA_COLS as f32 * window.resolution.scale_factor();
71 let height = window.resolution.height() / CAMERA_ROWS as f32 * window.resolution.scale_factor();
72 let mut i = 0;
73 for y in 0..CAMERA_COLS {
74 for x in 0..CAMERA_ROWS {
75 let angle = i as f32 / (CAMERA_ROWS * CAMERA_COLS) as f32 * PI * 2.0;
76 commands.spawn((
77 Camera3d::default(),
78 Camera {
79 viewport: Some(Viewport {
80 physical_position: UVec2::new(
81 (x as f32 * width) as u32,
82 (y as f32 * height) as u32,
83 ),
84 physical_size: UVec2::new(width as u32, height as u32),
85 ..default()
86 }),
87 order: i,
88 ..default()
89 },
90 Transform::from_xyz(sin(angle) * 4.0, 2.5, cos(angle) * 4.0)
91 .looking_at(Vec3::ZERO, Vec3::Y),
92 ));
93 i += 1;
94 }
95 }
96 Ok(())
97}Trait Implementations§
Source§impl Alpha for Color
impl Alpha for Color
Source§fn with_alpha(&self, alpha: f32) -> Color
fn with_alpha(&self, alpha: f32) -> Color
Return a new version of this color with the given alpha value.
Source§fn is_fully_transparent(&self) -> bool
fn is_fully_transparent(&self) -> bool
Is the alpha component of this color less than or equal to 0.0?
Source§fn is_fully_opaque(&self) -> bool
fn is_fully_opaque(&self) -> bool
Is the alpha component of this color greater than or equal to 1.0?
impl Copy for Color
Source§impl Default for Color
impl Default for Color
Source§fn default() -> Color
fn default() -> Color
A fully white Color::LinearRgba color with an alpha of 1.0.
Source§impl<'de> Deserialize<'de> for Color
impl<'de> Deserialize<'de> for Color
Source§fn deserialize<__D>(
__deserializer: __D,
) -> Result<Color, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(
__deserializer: __D,
) -> Result<Color, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Source§impl Enum for Color
impl Enum for Color
Source§fn field(&self, __name_param: &str) -> Option<&(dyn PartialReflect + 'static)>
fn field(&self, __name_param: &str) -> Option<&(dyn PartialReflect + 'static)>
Returns a reference to the value of the field (in the current variant) with the given name. Read more
Source§fn field_at(
&self,
__index_param: usize,
) -> Option<&(dyn PartialReflect + 'static)>
fn field_at( &self, __index_param: usize, ) -> Option<&(dyn PartialReflect + 'static)>
Returns a reference to the value of the field (in the current variant) at the given index.
Source§fn field_mut(
&mut self,
__name_param: &str,
) -> Option<&mut (dyn PartialReflect + 'static)>
fn field_mut( &mut self, __name_param: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>
Returns a mutable reference to the value of the field (in the current variant) with the given name. Read more
Source§fn field_at_mut(
&mut self,
__index_param: usize,
) -> Option<&mut (dyn PartialReflect + 'static)>
fn field_at_mut( &mut self, __index_param: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>
Returns a mutable reference to the value of the field (in the current variant) at the given index.
Source§fn index_of(&self, __name_param: &str) -> Option<usize>
fn index_of(&self, __name_param: &str) -> Option<usize>
Returns the index of the field (in the current variant) with the given name. Read more
Source§fn name_at(&self, __index_param: usize) -> Option<&str>
fn name_at(&self, __index_param: usize) -> Option<&str>
Returns the name of the field (in the current variant) with the given index. Read more
Source§fn iter_fields(&self) -> VariantFieldIter<'_> ⓘ
fn iter_fields(&self) -> VariantFieldIter<'_> ⓘ
Returns an iterator over the values of the current variant’s fields.
Source§fn variant_name(&self) -> &str
fn variant_name(&self) -> &str
The name of the current variant.
Source§fn variant_index(&self) -> usize
fn variant_index(&self) -> usize
The index of the current variant.
Source§fn variant_type(&self) -> VariantType
fn variant_type(&self) -> VariantType
The type of the current variant.
Source§fn to_dynamic_enum(&self) -> DynamicEnum
fn to_dynamic_enum(&self) -> DynamicEnum
Creates a new
DynamicEnum from this enum.Source§fn is_variant(&self, variant_type: VariantType) -> bool
fn is_variant(&self, variant_type: VariantType) -> bool
Returns true if the current variant’s type matches the given one.
Source§fn variant_path(&self) -> String
fn variant_path(&self) -> String
Returns the full path to the current variant.
Source§impl EuclideanDistance for Color
impl EuclideanDistance for Color
Source§impl From<Color> for LinearRgba
impl From<Color> for LinearRgba
Source§fn from(value: Color) -> LinearRgba
fn from(value: Color) -> LinearRgba
Converts to this type from the input type.
Source§impl From<Color> for ClearColorConfig
impl From<Color> for ClearColorConfig
Source§fn from(value: Color) -> ClearColorConfig
fn from(value: Color) -> ClearColorConfig
Converts to this type from the input type.
Source§impl From<Color> for StandardMaterial
impl From<Color> for StandardMaterial
Source§fn from(color: Color) -> StandardMaterial
fn from(color: Color) -> StandardMaterial
Converts to this type from the input type.
Source§impl From<Color> for AngularColorStop
impl From<Color> for AngularColorStop
Source§fn from(color: Color) -> AngularColorStop
fn from(color: Color) -> AngularColorStop
Converts to this type from the input type.
Source§impl From<Color> for ColorMaterial
impl From<Color> for ColorMaterial
Source§fn from(color: Color) -> ColorMaterial
fn from(color: Color) -> ColorMaterial
Converts to this type from the input type.
Source§impl From<LinearRgba> for Color
impl From<LinearRgba> for Color
Source§fn from(value: LinearRgba) -> Color
fn from(value: LinearRgba) -> Color
Converts to this type from the input type.
Source§impl FromReflect for Color
impl FromReflect for Color
Source§fn from_reflect(__param0: &(dyn PartialReflect + 'static)) -> Option<Color>
fn from_reflect(__param0: &(dyn PartialReflect + 'static)) -> Option<Color>
Constructs a concrete instance of
Self from a reflected value.Source§fn take_from_reflect(
reflect: Box<dyn PartialReflect>,
) -> Result<Self, Box<dyn PartialReflect>>
fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>
Attempts to downcast the given value to
Self using,
constructing the value using from_reflect if that fails. Read moreSource§impl GetTypeRegistration for Color
impl GetTypeRegistration for Color
Source§fn get_type_registration() -> TypeRegistration
fn get_type_registration() -> TypeRegistration
Returns the default
TypeRegistration for this type.Source§fn register_type_dependencies(registry: &mut TypeRegistry)
fn register_type_dependencies(registry: &mut TypeRegistry)
Registers other types needed by this type. Read more
Source§impl Hue for Color
impl Hue for Color
Source§impl IntoReturn for Color
impl IntoReturn for Color
Source§impl Luminance for Color
impl Luminance for Color
Source§fn with_luminance(&self, value: f32) -> Color
fn with_luminance(&self, value: f32) -> Color
Return a new version of this color with the given luminance. The resulting color will
be clamped to the valid range for the color space; for some color spaces, clamping
may cause the hue or chroma to change.
Source§fn darker(&self, amount: f32) -> Color
fn darker(&self, amount: f32) -> Color
Return a darker version of this color. The
amount should be between 0.0 and 1.0.
The amount represents an absolute decrease in luminance, and is distributive:
color.darker(a).darker(b) == color.darker(a + b). Colors are clamped to black
if the amount would cause them to go below black. Read moreSource§fn lighter(&self, amount: f32) -> Color
fn lighter(&self, amount: f32) -> Color
Return a lighter version of this color. The
amount should be between 0.0 and 1.0.
The amount represents an absolute increase in luminance, and is distributive:
color.lighter(a).lighter(b) == color.lighter(a + b). Colors are clamped to white
if the amount would cause them to go above white. Read moreSource§impl Mix for Color
impl Mix for Color
Source§fn mix(&self, other: &Color, factor: f32) -> Color
fn mix(&self, other: &Color, factor: f32) -> Color
Linearly interpolate between this and another color, by factor.
Factor should be between 0.0 and 1.0.
Source§fn mix_assign(&mut self, other: Self, factor: f32)
fn mix_assign(&mut self, other: Self, factor: f32)
Linearly interpolate between this and another color, by factor, storing the result
in this color. Factor should be between 0.0 and 1.0.
Source§impl PartialReflect for Color
impl PartialReflect for Color
Source§fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
Source§fn try_apply(
&mut self,
__value_param: &(dyn PartialReflect + 'static),
) -> Result<(), ApplyError>
fn try_apply( &mut self, __value_param: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>
Source§fn reflect_kind(&self) -> ReflectKind
fn reflect_kind(&self) -> ReflectKind
Returns a zero-sized enumeration of “kinds” of type. Read more
Source§fn reflect_ref(&self) -> ReflectRef<'_>
fn reflect_ref(&self) -> ReflectRef<'_>
Returns an immutable enumeration of “kinds” of type. Read more
Source§fn reflect_mut(&mut self) -> ReflectMut<'_>
fn reflect_mut(&mut self) -> ReflectMut<'_>
Returns a mutable enumeration of “kinds” of type. Read more
Source§fn reflect_owned(self: Box<Color>) -> ReflectOwned
fn reflect_owned(self: Box<Color>) -> ReflectOwned
Returns an owned enumeration of “kinds” of type. Read more
Source§fn try_into_reflect(
self: Box<Color>,
) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>
fn try_into_reflect( self: Box<Color>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>
Attempts to cast this type to a boxed, fully-reflected value.
Source§fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>
fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>
Attempts to cast this type to a fully-reflected value.
Source§fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>
fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>
Attempts to cast this type to a mutable, fully-reflected value.
Source§fn into_partial_reflect(self: Box<Color>) -> Box<dyn PartialReflect>
fn into_partial_reflect(self: Box<Color>) -> Box<dyn PartialReflect>
Casts this type to a boxed, reflected value. Read more
Source§fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)
fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)
Casts this type to a reflected value. Read more
Source§fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)
fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)
Casts this type to a mutable, reflected value. Read more
Source§fn reflect_hash(&self) -> Option<u64>
fn reflect_hash(&self) -> Option<u64>
Returns a hash of the value (which includes the type). Read more
Source§fn reflect_partial_eq(
&self,
value: &(dyn PartialReflect + 'static),
) -> Option<bool>
fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>
Returns a “partial equality” comparison result. Read more
Source§fn reflect_partial_cmp(
&self,
value: &(dyn PartialReflect + 'static),
) -> Option<Ordering>
fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>
Returns a “partial comparison” result. Read more
Source§fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>
fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>
Attempts to clone
Self using reflection. Read moreSource§fn apply(&mut self, value: &(dyn PartialReflect + 'static))
fn apply(&mut self, value: &(dyn PartialReflect + 'static))
Applies a reflected value to this value. Read more
Source§fn to_dynamic(&self) -> Box<dyn PartialReflect>
fn to_dynamic(&self) -> Box<dyn PartialReflect>
Source§fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>
fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>
For a type implementing
PartialReflect, combines reflect_clone and
take in a useful fashion, automatically constructing an appropriate
ReflectCloneError if the downcast fails.Source§fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Debug formatter for the value. Read more
Source§fn is_dynamic(&self) -> bool
fn is_dynamic(&self) -> bool
Indicates whether or not this type is a dynamic type. Read more
Source§impl Reflect for Color
impl Reflect for Color
Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Returns the value as a
&mut dyn Any. Read moreSource§fn into_reflect(self: Box<Color>) -> Box<dyn Reflect>
fn into_reflect(self: Box<Color>) -> Box<dyn Reflect>
Casts this type to a boxed, fully-reflected value.
Source§fn as_reflect(&self) -> &(dyn Reflect + 'static)
fn as_reflect(&self) -> &(dyn Reflect + 'static)
Casts this type to a fully-reflected value.
Source§fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
Casts this type to a mutable, fully-reflected value.
Source§impl Saturation for Color
impl Saturation for Color
Source§fn with_saturation(&self, saturation: f32) -> Color
fn with_saturation(&self, saturation: f32) -> Color
Return a new version of this color with the saturation channel set to the given value.
Source§fn saturation(&self) -> f32
fn saturation(&self) -> f32
Return the saturation of this color [0.0, 1.0].
Source§fn set_saturation(&mut self, saturation: f32)
fn set_saturation(&mut self, saturation: f32)
Sets the saturation of this color.
Source§impl Serialize for Color
impl Serialize for Color
Source§fn serialize<__S>(
&self,
__serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
fn serialize<__S>(
&self,
__serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
Serialize this value into the given Serde serializer. Read more
impl StructuralPartialEq for Color
Source§impl TryStableInterpolate for Color
impl TryStableInterpolate for Color
Source§type Error = MismatchedUnitsError
type Error = MismatchedUnitsError
Error produced when the value cannot be interpolated.
Source§fn try_interpolate_stable(
&self,
other: &Color,
t: f32,
) -> Result<Color, <Color as TryStableInterpolate>::Error>
fn try_interpolate_stable( &self, other: &Color, t: f32, ) -> Result<Color, <Color as TryStableInterpolate>::Error>
Attempt to interpolate the value. This may fail if the two interpolation values have
different units, or if the type is not interpolable.
Source§impl TypePath for Color
impl TypePath for Color
Source§fn type_path() -> &'static str
fn type_path() -> &'static str
Returns the fully qualified path of the underlying type. Read more
Source§fn short_type_path() -> &'static str
fn short_type_path() -> &'static str
Returns a short, pretty-print enabled path to the type. Read more
Source§fn type_ident() -> Option<&'static str>
fn type_ident() -> Option<&'static str>
Source§fn crate_name() -> Option<&'static str>
fn crate_name() -> Option<&'static str>
Auto Trait Implementations§
impl Freeze for Color
impl RefUnwindSafe for Color
impl Send for Color
impl Sync for Color
impl Unpin for Color
impl UnsafeUnpin for Color
impl UnwindSafe for Color
Blanket Implementations§
Source§impl<T, U> AsBindGroupShaderType<U> for T
impl<T, U> AsBindGroupShaderType<U> for T
Source§fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
Return the
T ShaderType for self. When used in AsBindGroup
derives, it is safe to assume that all images in self exist.Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<T> Brush for T
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> ConditionalSend for Twhere
T: Send,
impl<T> DeserializeOwned for Twhere
T: for<'de> Deserialize<'de>,
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Converts
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be
downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Converts
Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further
downcast into Rc<ConcreteType> where ConcreteType implements Trait.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Converts
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Converts
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s.Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Convert
Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can
then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Convert
Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be
further downcast into Rc<ConcreteType> where ConcreteType implements Trait.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Convert
&Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &Any’s vtable from &Trait’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert
&mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot
generate &mut Any’s vtable from &mut Trait’s.Source§impl<T> DowncastSend for T
impl<T> DowncastSend for T
Source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
impl<S, T> Duplex<S> for Twhere
T: FromSample<S> + ToSample<S>,
Source§impl<T> DynamicTypePath for Twhere
T: TypePath,
impl<T> DynamicTypePath for Twhere
T: TypePath,
Source§fn reflect_type_path(&self) -> &str
fn reflect_type_path(&self) -> &str
See
TypePath::type_path.Source§fn reflect_short_type_path(&self) -> &str
fn reflect_short_type_path(&self) -> &str
Source§fn reflect_type_ident(&self) -> Option<&str>
fn reflect_type_ident(&self) -> Option<&str>
See
TypePath::type_ident.Source§fn reflect_crate_name(&self) -> Option<&str>
fn reflect_crate_name(&self) -> Option<&str>
See
TypePath::crate_name.Source§fn reflect_module_path(&self) -> Option<&str>
fn reflect_module_path(&self) -> Option<&str>
Source§impl<T> DynamicTyped for Twhere
T: Typed,
impl<T> DynamicTyped for Twhere
T: Typed,
Source§fn reflect_type_info(&self) -> &'static TypeInfo
fn reflect_type_info(&self) -> &'static TypeInfo
See
Typed::type_info.impl<T> ErasedDestructor for Twhere
T: 'static,
Source§impl<T> FmtForward for T
impl<T> FmtForward for T
Source§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
Causes
self to use its Binary implementation when Debug-formatted.Source§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
Causes
self to use its Display implementation when
Debug-formatted.Source§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
Causes
self to use its LowerExp implementation when
Debug-formatted.Source§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
Causes
self to use its LowerHex implementation when
Debug-formatted.Source§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
Causes
self to use its Octal implementation when Debug-formatted.Source§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
Causes
self to use its Pointer implementation when
Debug-formatted.Source§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
Causes
self to use its UpperExp implementation when
Debug-formatted.Source§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
Causes
self to use its UpperHex implementation when
Debug-formatted.Source§impl<S> FromSample<S> for S
impl<S> FromSample<S> for S
fn from_sample_(s: S) -> S
Source§impl<T> FromTemplate for T
impl<T> FromTemplate for T
Source§impl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere
T: Default,
Source§fn from_world(_world: &mut World) -> T
fn from_world(_world: &mut World) -> T
Creates Self using default().
Source§impl<T> GetPath for T
impl<T> GetPath for T
Source§fn reflect_path<'p>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>
fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>
Returns a reference to the value specified by
path. Read moreSource§fn reflect_path_mut<'p>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>
fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>
Returns a mutable reference to the value specified by
path. Read moreSource§fn path<'p, T>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
fn path<'p, T>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
Returns a statically typed reference to the value specified by
path. Read moreSource§fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
Returns a statically typed mutable reference to the value specified by
path. Read moreSource§impl<T, W> HasTypeWitness<W> for Twhere
W: MakeTypeWitness<Arg = T>,
T: ?Sized,
impl<T, W> HasTypeWitness<W> for Twhere
W: MakeTypeWitness<Arg = T>,
T: ?Sized,
impl<T> HitDataExtra for T
Source§impl<T> Identity for Twhere
T: ?Sized,
impl<T> Identity for Twhere
T: ?Sized,
Source§impl<T> InitializeFromFunction<T> for T
impl<T> InitializeFromFunction<T> for T
Source§fn initialize_from_function(f: fn() -> T) -> T
fn initialize_from_function(f: fn() -> T) -> T
Create an instance of this type from an initialization function
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
Converts
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
Converts
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§impl<T> IntoResult<T> for T
impl<T> IntoResult<T> for T
Source§fn into_result(self) -> Result<T, RunSystemError>
fn into_result(self) -> Result<T, RunSystemError>
Converts this type into the system output type.
Source§impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
fn into_sample(self) -> T
Source§impl<G> PatchFromTemplate for Gwhere
G: FromTemplate,
impl<G> PatchFromTemplate for Gwhere
G: FromTemplate,
Source§fn patch<F>(func: F) -> TemplatePatch<F, <G as PatchFromTemplate>::Template>
fn patch<F>(func: F) -> TemplatePatch<F, <G as PatchFromTemplate>::Template>
Takes a “patch function”
func, and turns it into a TemplatePatch.Source§impl<T> PatchTemplate for Twhere
T: Template,
impl<T> PatchTemplate for Twhere
T: Template,
Source§fn patch_template<F>(func: F) -> TemplatePatch<F, T>
fn patch_template<F>(func: F) -> TemplatePatch<F, T>
Source§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
Source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
Source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
Borrows
self and passes that borrow into the pipe function. Read moreSource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
Mutably borrows
self and passes that borrow into the pipe function. Read moreSource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
Source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
Source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
Borrows
self, then passes self.as_ref() into the pipe function.Source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
Mutably borrows
self, then passes self.as_mut() into the pipe
function.Source§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
Borrows
self, then passes self.deref() into the pipe function.impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
Source§impl<R, P> ReadPrimitive<R> for P
impl<R, P> ReadPrimitive<R> for P
Source§fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
Read this value from the supplied reader. Same as
ReadEndian::read_from_little_endian().impl<T> Reflectable for T
Source§impl<T> Serialize for T
impl<T> Serialize for T
fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), Error>
fn do_erased_serialize( &self, serializer: &mut dyn Serializer, ) -> Result<(), ErrorImpl>
impl<T> Settings for T
Source§impl<Ret> SpawnIfAsync<(), Ret> for Ret
impl<Ret> SpawnIfAsync<(), Ret> for Ret
Source§impl<T, O> SuperFrom<T> for Owhere
O: From<T>,
impl<T, O> SuperFrom<T> for Owhere
O: From<T>,
Source§fn super_from(input: T) -> O
fn super_from(input: T) -> O
Convert from a type to another type.
Source§impl<T, O, M> SuperInto<O, M> for Twhere
O: SuperFrom<T, M>,
impl<T, O, M> SuperInto<O, M> for Twhere
O: SuperFrom<T, M>,
Source§fn super_into(self) -> O
fn super_into(self) -> O
Convert from a type to another type.
Source§impl<T> Tap for T
impl<T> Tap for T
Source§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Immutable access to the
Borrow<B> of a value. Read moreSource§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
Mutable access to the
BorrowMut<B> of a value. Read moreSource§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
Immutable access to the
AsRef<R> view of a value. Read moreSource§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
Mutable access to the
AsMut<R> view of a value. Read moreSource§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Immutable access to the
Deref::Target of a value. Read moreSource§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Mutable access to the
Deref::Target of a value. Read moreSource§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls
.tap() only in debug builds, and is erased in release builds.Source§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls
.tap_mut() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
Calls
.tap_borrow() only in debug builds, and is erased in release
builds.Source§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
Calls
.tap_borrow_mut() only in debug builds, and is erased in release
builds.Source§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
Calls
.tap_ref() only in debug builds, and is erased in release
builds.Source§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
Calls
.tap_ref_mut() only in debug builds, and is erased in release
builds.Source§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
Calls
.tap_deref() only in debug builds, and is erased in release
builds.Source§impl<T> Template for T
impl<T> Template for T
Source§fn build_template(
&self,
_context: &mut TemplateContext<'_, '_>,
) -> Result<<T as Template>::Output, BevyError>
fn build_template( &self, _context: &mut TemplateContext<'_, '_>, ) -> Result<<T as Template>::Output, BevyError>
Uses this template and the given
entity context to produce a Template::Output.Source§fn clone_template(&self) -> T
fn clone_template(&self) -> T
Clones this template. See
Clone.Source§impl<T, U> ToSample<U> for Twhere
U: FromSample<T>,
impl<T, U> ToSample<U> for Twhere
U: FromSample<T>,
fn to_sample_(self) -> U
Source§impl<T> TypeData for T
impl<T> TypeData for T
Source§fn clone_type_data(&self) -> Box<dyn TypeData>
fn clone_type_data(&self) -> Box<dyn TypeData>
Creates a type-erased clone of this value.