Bevy

https://docs.rs/bevy/latest/
Admin
Bevy is an open-source, modular game engine built in Rust with a focus on developer productivity and...
Tokens:15,911,295
Snippets:132,640
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### setup_view_root function start in scrollbars example

Source: https://docs.rs/bevy/latest/bevy/ui/prelude/struct.UiRect.html

From examples/ui/scroll_and_overflow/scrollbars.rs (line 32). This is the beginning of a setup function; the full example is not shown on this page.

```rust
fn setup_view_root(mut commands: Commands) {
```

--------------------------------

### Atmosphere example setup and controls

Source: https://docs.rs/bevy/latest/src/atmosphere/atmosphere.rs.html

The beginning of the atmosphere example, including imports, resource definitions, the main app setup, control handling, and the start of the camera fog setup function. It sets up deferred rendering, black clear color, no global ambient light, and registers the FreeCameraPlugin when the free_camera feature is enabled.

```rust
//! This example showcases pbr atmospheric scattering
#[cfg(feature = "free_camera")]
use bevy::camera_controller::free_camera::{FreeCamera, FreeCameraPlugin};
use std::f32::consts::PI;

use bevy::{
    anti_alias::taa::TemporalAntiAliasing,
    camera::Exposure,
    color::palettes::css::BLACK,
    core_pipeline::tonemapping::Tonemapping,
    image::{
        ImageAddressMode, ImageFilterMode, ImageLoaderSettings, ImageSampler,
        ImageSamplerDescriptor,
    },
    input::keyboard::KeyCode,
    light::{
        atmosphere::ScatteringMedium, light_consts::lux, Atmosphere, AtmosphereEnvironmentMapLight,
        FogVolume, VolumetricFog, VolumetricLight,
    },
    pbr::{
        AtmosphereMode, AtmosphereSettings, DefaultOpaqueRendererMethod, ExtendedMaterial,
        MaterialExtension, ScreenSpaceReflections,
    },
    post_process::bloom::Bloom,
    prelude::*,
    render::render_resource::{AsBindGroup, ShaderType},
    shader::ShaderRef,
};

#[derive(Resource, Default)]
struct GameState {
    paused: bool,
}

#[derive(Resource)]
struct AtmospherePresets {
    earth: Handle<ScatteringMedium>,
    mars: Handle<ScatteringMedium>,
}

fn main() {
    App::new()
        .insert_resource(DefaultOpaqueRendererMethod::deferred())
        .insert_resource(ClearColor(Color::BLACK))
        .insert_resource(GameState::default())
        .insert_resource(GlobalAmbientLight::NONE)
        .add_plugins((
            DefaultPlugins,
            #[cfg(feature = "free_camera")]
            FreeCameraPlugin,
        ))
        .add_plugins(MaterialPlugin::<ExtendedMaterial<StandardMaterial, Water>>::default())
        .add_systems(
            Startup,
            (setup_camera_fog, setup_terrain_scene, print_controls),
        )
        .add_systems(Update, (dynamic_scene, atmosphere_controls))
        .run();
}

fn print_controls() {
    println!("Atmosphere Example Controls:");
    println!("    1          - Switch to lookup texture rendering method");
    println!("    2          - Switch to raymarched rendering method");
    println!("    3          - Switch to Earth atmosphere");
    println!("    4          - Switch to Mars atmosphere");
    println!("    Enter      - Pause/Resume sun motion");
    println!("    Up/Down    - Increase/Decrease exposure");
}

fn atmosphere_controls(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut planet_atmosphere: Query<(&mut Atmosphere, &mut GlobalTransform)>,
    mut camera_settings: Query<&mut AtmosphereSettings, With<Camera3d>>,
    atmosphere_presets: Res<AtmospherePresets>,
    mut game_state: ResMut<GameState>,
    mut camera_exposure: Query<&mut Exposure, With<Camera3d>>,
    time: Res<Time>,
) {
    if keyboard_input.just_pressed(KeyCode::Digit3) {
        for (mut atmosphere, mut transform) in &mut planet_atmosphere {
            *atmosphere = Atmosphere::earth(atmosphere_presets.earth.clone());
            *transform = GlobalTransform::from_translation(-Vec3::Y * atmosphere.inner_radius);
            println!("Switched to Earth atmosphere");
        }
    }

    if keyboard_input.just_pressed(KeyCode::Digit4) {
        for (mut atmosphere, mut transform) in &mut planet_atmosphere {
            *atmosphere = Atmosphere::mars(atmosphere_presets.mars.clone());
            *transform = GlobalTransform::from_translation(-Vec3::Y * atmosphere.inner_radius);
            println!("Switched to Mars atmosphere");
        }
    }

    if keyboard_input.just_pressed(KeyCode::Digit1) {
        for mut settings in &mut camera_settings {
            settings.rendering_method = AtmosphereMode::LookupTexture;
            println!("Switched to lookup texture rendering method");
        }
    }

    if keyboard_input.just_pressed(KeyCode::Digit2) {
        for mut settings in &mut camera_settings {
            settings.rendering_method = AtmosphereMode::Raymarched;
            println!("Switched to raymarched rendering method");
        }
    }

    if keyboard_input.just_pressed(KeyCode::Enter) {
        game_state.paused = !game_state.paused;
    }

    if keyboard_input.pressed(KeyCode::ArrowUp) {
        for mut exposure in &mut camera_exposure {
            exposure.ev100 -= time.delta_secs() * 2.0;
        }
    }

    if keyboard_input.pressed(KeyCode::ArrowDown) {
        for mut exposure in &mut camera_exposure {
            exposure.ev100 += time.delta_secs() * 2.0;
        }
    }
}

fn setup_camera_fog(
    mut commands: Commands,
    mut scattering_mediums: ResMut<Assets<ScatteringMedium>>,
    asset_server: Res<AssetServer>,
```

--------------------------------

### Setup function for 3D shapes example

Source: https://docs.rs/bevy/latest/bevy/math/prelude/struct.Extrusion.html

Starts a setup function for a 3D shapes example, creating a debug material with a UV debug texture. This is the beginning of a larger example that likely includes Extrusion shapes.

```rust
fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut images: ResMut<Assets<Image>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    let debug_material = materials.add(StandardMaterial {
        base_color_texture: Some(images.add(uv_debug_texture())),
        ..default()
    });

    let shapes = [
```

--------------------------------

### Mirror example setup system

Source: https://docs.rs/bevy/latest/bevy/math/prelude/fn.vec3.html

Startup system that spawns the scene, mirror, and UI for the mirror example.

```rust
143/// A startup system that spawns the scene and sets up the mirror render target.
144fn setup(
145    mut commands: Commands,
146    windows_query: Query<&Window>,
147    asset_server: Res<AssetServer>,
148    mut meshes: ResMut<Assets<Mesh>>,
149    mut standard_materials: ResMut<Assets<StandardMaterial>>,
150    mut screen_space_texture_materials: ResMut<
151        Assets<ExtendedMaterial<StandardMaterial, ScreenSpaceTextureExtension>>,
152    >,
153    mut images: ResMut<Assets<Image>>,
154    app_status: Res<AppStatus>,
155) {
156    // Spawn the main camera.
157    let camera_projection = PerspectiveProjection::default();
158    let camera_transform = spawn_main_camera(&mut commands, &camera_projection);
159
160    // Spawn the light.
161    spawn_light(&mut commands);
162
163    // Spawn the objects reflected in the mirror.
164    spawn_ground_plane(&mut commands, &mut meshes, &mut standard_materials);
165    spawn_fox(&mut commands, &asset_server);
166
167    // Spawn the mirror and associated camera.
168    let mirror_render_target_image =
169        create_mirror_texture_resource(&mut commands, &windows_query, &mut images);
170    let mirror_transform = spawn_mirror(
171        &mut commands,
172        &mut meshes,
173        &mut screen_space_texture_materials,
174        mirror_render_target_image.clone(),
175    );
176    spawn_mirror_camera(
177        &mut commands,
        &camera_transform,
        &camera_projection,
        &mirror_transform,
        mirror_render_target_image,
    );
178
179    // Spawn the UI.
180    spawn_buttons(&mut commands);
181    spawn_help_text(&mut commands, &app_status);
182}
```

--------------------------------

### Bevy 3D lighting setup example

Source: https://docs.rs/bevy/latest/bevy/camera/struct.Exposure.html

Example from examples/3d/lighting.rs (line 249) showing a setup function that spawns meshes, materials, lights, and a global ambient light. It demonstrates using Exposure-related lighting setup in a Bevy 3D scene.

```rust
fn setup(
    parameters: Res<Parameters>,
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    asset_server: Res<AssetServer>,
) {
    // ground plane
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(10.0, 10.0))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Color::WHITE,
            perceptual_roughness: 1.0,
            ..default()
        })),
    ));

    // left wall
    let mut transform = Transform::from_xyz(2.5, 2.5, 0.0);
    transform.rotate_z(PI / 2.);
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::new(5.0, 0.15, 5.0))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: INDIGO.into(),
            perceptual_roughness: 1.0,
            ..default()
        })),
        transform,
    ));
    // back (right) wall
    let mut transform = Transform::from_xyz(0.0, 2.5, -2.5);
    transform.rotate_x(PI / 2.);
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::new(5.0, 0.15, 5.0))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: INDIGO.into(),
            perceptual_roughness: 1.0,
            ..default()
        })),
        transform,
    ));

    // Bevy logo to demonstrate alpha mask shadows
    let mut transform = Transform::from_xyz(-2.2, 0.5, 1.0);
    transform.rotate_y(PI / 8.);
    commands.spawn((
        Mesh3d(meshes.add(Rectangle::new(2.0, 0.5))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color_texture: Some(asset_server.load("branding/bevy_logo_light.png")),
            perceptual_roughness: 1.0,
            alpha_mode: AlphaMode::Mask(0.5),
            cull_mode: None,
            ..default()
        })),
        transform,
        Movable,
    ));

    // cube
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::default())),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: DEEP_PINK.into(),
            ..default()
        })),
        Transform::from_xyz(0.0, 0.5, 0.0),
        Movable,
    ));
    // sphere
    commands.spawn((
        Mesh3d(meshes.add(Sphere::new(0.5).mesh().uv(32, 18))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: LIMEGREEN.into(),
            ..default()
        })),
        Transform::from_xyz(1.5, 1.0, 1.5),
        Movable,
    ));

    // ambient light
    // ambient lights' brightnesses are measured in candela per meter square, calculable as (color * brightness)
    commands.insert_resource(GlobalAmbientLight {
        color: ORANGE_RED.into(),
        brightness: 200.0,
        ..default()
    });

    // red point light
    commands.spawn((
        PointLight {
            intensity: 100_000.0,
            color: RED.into(),
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_xyz(1.0, 2.0, 0.0),
        children![(
            Mesh3d(meshes.add(Sphere::new(0.1).mesh().uv(32, 18))),
            MeshMaterial3d(materials.add(StandardMaterial {
                base_color: RED.into(),
                emissive: LinearRgba::new(4.0, 0.0, 0.0, 0.0),
                ..default()
            })),
```

--------------------------------

### Setup system with init_resource (log_diagnostics.rs)

Source: https://docs.rs/bevy/latest/bevy/ecs/prelude/struct.Commands.html

Repository example (log_diagnostics.rs) showing a setup system that spawns meshes, lights, and camera, and initializes two diagnostic resources with `init_resource`.

```rust
fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // circular base
    commands.spawn((
        Mesh3d(meshes.add(Circle::new(4.0))),
        MeshMaterial3d(materials.add(Color::WHITE)),
        Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2)),
    ));
    // cube
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
        MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
        Transform::from_xyz(0.0, 0.5, 0.0),
    ));
    // light
    commands.spawn((
        PointLight {
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_xyz(4.0, 8.0, 4.0),
    ));
    // camera
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
    ));

    commands.init_resource::<LogDiagnosticsFilters>();
    commands.init_resource::<LogDiagnosticsStatus>();

    commands.spawn((
        LogDiagnosticsCommands,
        Node {
            top: px(5),
            left: px(5),
            flex_direction: FlexDirection::Column,
            ..default()
        },
    ));
}
```

--------------------------------

### Bevy mirror example setup system

Source: https://docs.rs/bevy/latest/bevy/math/f32/fn.vec3.html

Bevy startup system that spawns the main camera, light, ground plane, fox, mirror, mirror camera, and UI for the mirror example.

```rust
144fn setup(
145    mut commands: Commands,
146    windows_query: Query<&Window>,
147    asset_server: Res<AssetServer>,
148    mut meshes: ResMut<Assets<Mesh>>,
149    mut standard_materials: ResMut<Assets<StandardMaterial>>,
150    mut screen_space_texture_materials: ResMut<
151        Assets<ExtendedMaterial<StandardMaterial, ScreenSpaceTextureExtension>>,
152    >,
153    mut images: ResMut<Assets<Image>>,
154    app_status: Res<AppStatus>,
155) {
156    // Spawn the main camera.
157    let camera_projection = PerspectiveProjection::default();
158    let camera_transform = spawn_main_camera(&mut commands, &camera_projection);
159
160    // Spawn the light.
161    spawn_light(&mut commands);
162
163    // Spawn the objects reflected in the mirror.
164    spawn_ground_plane(&mut commands, &mut meshes, &mut standard_materials);
165    spawn_fox(&mut commands, &asset_server);
166
167    // Spawn the mirror and associated camera.
168    let mirror_render_target_image =
169        create_mirror_texture_resource(&mut commands, &windows_query, &mut images);
170    let mirror_transform = spawn_mirror(
171        &mut commands,
172        &mut meshes,
173        &mut screen_space_texture_materials,
174        mirror_render_target_image.clone(),
175    );
176    spawn_mirror_camera(
177        &mut commands,
        &camera_transform,
        &camera_projection,
        &mirror_transform,
        mirror_render_target_image,
    );
178
179    // Spawn the UI.
180    spawn_buttons(&mut commands);
181    spawn_help_text(&mut commands, &app_status);
182}
```

--------------------------------

### UI drag and drop setup example (partial)

Source: https://docs.rs/bevy/latest/bevy/ecs/prelude/struct.Query.html

Partial snippet from `examples/ui/ui_drag_and_drop.rs` (line 91) showing a `setup` function that spawns a camera and a grid node with children. The snippet is truncated at the source and is provided as an example found in the repository.

```rust
fn setup(mut commands: Commands) {
    commands.spawn(Camera2d);
    commands
        .spawn((Node {
            display: Display::Grid,
            align_self: AlignSelf::Center,
            justify_self: JustifySelf::Center,
            ..Default::default()
        }, Pickable::IGNORE, BackgroundColor(Color::srgb(0.4, 0.4, 0.4))))
        .with_children(|parent| {
            let tile_colors = [
                Color::srgb(0.2, 0.2, 0.8),
                Color::srgb(0.8, 0.2, 0.2)
            ];
            for column in 0..COLUMNS {
                for row in 0..ROWS {
                    let i = column + row * COLUMNS;
```

--------------------------------

### Linear gradient setup

Source: https://docs.rs/bevy/latest/bevy/prelude/fn.vmin.html

Starts the linear gradient example setup. Spawns a camera and begins spawning a node with a linear gradient background, using imports for color stops, interpolation color space, and grid placement.

```rust
mod linear_gradient {
    use bevy::camera::Camera2d;
    use bevy::color::palettes::css::BLUE;
    use bevy::color::palettes::css::LIME;
    use bevy::color::palettes::css::RED;
    use bevy::color::palettes::css::YELLOW;
    use bevy::color::Color;
    use bevy::ecs::prelude::*;
    use bevy::state::state_scoped::DespawnOnExit;
    use bevy::text::TextFont;
    use bevy::ui::AlignItems;
    use bevy::ui::BackgroundGradient;
    use bevy::ui::ColorStop;
    use bevy::ui::GridPlacement;
    use bevy::ui::InterpolationColorSpace;
    use bevy::ui::JustifyContent;
    use bevy::ui::LinearGradient;
    use bevy::ui::Node;
    use bevy::ui::PositionType;
    use bevy::utils::default;

    pub fn setup(mut commands: Commands) {
        commands.spawn((Camera2d, DespawnOnExit(super::Scene::LinearGradient)));
        commands
            .spawn((
                Node {
```

--------------------------------

### Gradient styling example setup with ColorStop vector

Source: https://docs.rs/bevy/latest/bevy/ui/gradients/struct.ColorStop.html

Starts a gradient styling example. Spawns a camera and a column flex node, then begins a loop over tuples of a border value and a vector of color stops (the vector is truncated in the source).

```rust
27fn setup(mut commands: Commands) {
28    commands.spawn(Camera2d);
29
30    commands
31        .spawn(Node {
32            flex_direction: FlexDirection::Column,
33            row_gap: px(20),
34            margin: UiRect::all(px(20)),
35            ..Default::default()
36        })
37        .with_children(|commands| {
38            for (b, stops) in [
39                (
40                    4.,
41                    vec![
```

--------------------------------

### Repository example: examples/testbed/ui.rs (line 284)

Source: https://docs.rs/bevy/latest/bevy/ui/prelude/struct.UiRect.html

A snippet from `examples/testbed/ui.rs` showing a `setup` function that spawns UI nodes with `Node` components, using `px()` for margins, borders, and padding, along with `ImageNode` and `BorderColor`.

```rust
pub fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn((Camera2d, DespawnOnExit(super::Scene::ImageMeasure)));
    commands.spawn((
        Node {
            margin: auto().all(),
            column_gap: px(5.),
            ..Default::default()
        },
        DespawnOnExit(super::Scene::ImageMeasure),
        children![
            (
                Node {
                    width: vmin(20.),
                    ..default()
                },
                children![(
                    Node {
                        position_type: PositionType::Absolute,
                        width: vmin(20.),
                        ..default()
                    },
                    BackgroundColor(GREEN.into()),
                    ImageNode::new(asset_server.load("branding/icon.png")),
                )],
            ),
            (
                Node {
                    width: vmin(20.),
                    ..default()
                },
                children![(
                    Node {
                        position_type: PositionType::Absolute,
                        width: vmin(20.),
                        border: px(8.).all(),
                        ..default()
                    },
                    BorderColor::all(RED),
                    BackgroundColor(GREEN.into()),
                    ImageNode::new(asset_server.load("branding/icon.png")),
                )],
            ),
            (
                Node {
                    width: vmin(20.),
                    ..default()
                },
                children![(
                    Node {
                        position_type: PositionType::Absolute,
                        width: vmin(20.),
                        border: px(8.).all(),
                        padding: px(4.).all(),
                        ..default()
                    },
                    BorderColor::all(RED),
                    BackgroundColor(GREEN.into()),
                    ImageNode::new(asset_server.load("branding/icon.png")),
                )],
            ),
        ],
    ));
}
```

--------------------------------

### Lighting example setup in lighting.rs

Source: https://docs.rs/bevy/latest/bevy/math/prelude/struct.Capsule3d.html

Example from examples/3d/lighting.rs (line 160) showing a setup function that spawns various meshes (plane, cuboids, rectangle, cube, sphere) with StandardMaterial and adds a GlobalAmbientLight and a PointLight. The snippet is truncated at the end in the source.

```rust
fn setup(
    parameters: Res<Parameters>,
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    asset_server: Res<AssetServer>,
) {
    // ground plane
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(10.0, 10.0))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Color::WHITE,
            perceptual_roughness: 1.0,
            ..default()
        })),
    ));

    // left wall
    let mut transform = Transform::from_xyz(2.5, 2.5, 0.0);
    transform.rotate_z(PI / 2.);
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::new(5.0, 0.15, 5.0))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: INDIGO.into(),
            perceptual_roughness: 1.0,
            ..default()
        })),
        transform,
    ));
    // back (right) wall
    let mut transform = Transform::from_xyz(0.0, 2.5, -2.5);
    transform.rotate_x(PI / 2.);
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::new(5.0, 0.15, 5.0))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: INDIGO.into(),
            perceptual_roughness: 1.0,
            ..default()
        })),
        transform,
    ));

    // Bevy logo to demonstrate alpha mask shadows
    let mut transform = Transform::from_xyz(-2.2, 0.5, 1.0);
    transform.rotate_y(PI / 8.);
    commands.spawn((
        Mesh3d(meshes.add(Rectangle::new(2.0, 0.5))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color_texture: Some(asset_server.load("branding/bevy_logo_light.png")),
            perceptual_roughness: 1.0,
            alpha_mode: AlphaMode::Mask(0.5),
            cull_mode: None,
            ..default()
        })),
        transform,
        Movable,
    ));

    // cube
    commands.spawn((
        Mesh3d(meshes.add(Cuboid::default())),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: DEEP_PINK.into(),
            ..default()
        })),
        Transform::from_xyz(0.0, 0.5, 0.0),
        Movable,
    ));
    // sphere
    commands.spawn((
        Mesh3d(meshes.add(Sphere::new(0.5).mesh().uv(32, 18))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: LIMEGREEN.into(),
            ..default()
        })),
        Transform::from_xyz(1.5, 1.0, 1.5),
        Movable,
    ));

    // ambient light
    // ambient lights' brightnesses are measured in candela per meter square, calculable as (color * brightness)
    commands.insert_resource(GlobalAmbientLight {
        color: ORANGE_RED.into(),
        brightness: 200.0,
        ..default()
    });

    // red point light
    commands.spawn((
        PointLight {
            intensity: 100_000.0,
```

--------------------------------

### Bevy animation masks example (Rust)

Source: https://docs.rs/bevy/latest/src/animation_masks/animation_masks.rs.html

This is the beginning of the Rust example for the Bevy animation masks feature. It defines constants for mask group IDs and bone paths, and starts the main function and scene setup. The code is incomplete as the source is truncated.

```rust
1//! Demonstrates how to use masks to limit the scope of animations.
2
3use bevy::{
4    animation::{AnimatedBy, AnimationTargetId},
5    color::palettes::css::{LIGHT_GRAY, WHITE},
6    prelude::*,
7};
8use std::collections::HashSet;
9
10// IDs of the mask groups we define for the running fox model.
11//
12// Each mask group defines a set of bones for which animations can be toggled on
13// and off.
14const MASK_GROUP_HEAD: u32 = 0;
15const MASK_GROUP_LEFT_FRONT_LEG: u32 = 1;
16const MASK_GROUP_RIGHT_FRONT_LEG: u32 = 2;
17const MASK_GROUP_LEFT_HIND_LEG: u32 = 3;
18const MASK_GROUP_RIGHT_HIND_LEG: u32 = 4;
19const MASK_GROUP_TAIL: u32 = 5;
20
21// The width in pixels of the small buttons that allow the user to toggle a mask
22// group on or off.
23const MASK_GROUP_BUTTON_WIDTH: f32 = 250.0;
24
25// The names of the bones that each mask group consists of. Each mask group is
26// defined as a (prefix, suffix) tuple. The mask group consists of a single
27// bone chain rooted at the prefix. For example, if the chain's prefix is
28// "A/B/C" and the suffix is "D/E", then the bones that will be included in the
29// mask group are "A/B/C", "A/B/C/D", and "A/B/C/D/E".
30//
31// The fact that our mask groups are single chains of bones isn't an engine
32// requirement; it just so happens to be the case for the model we're using. A
33// mask group can consist of any set of animation targets, regardless of whether
34// they form a single chain.
35const MASK_GROUP_PATHS: [(&str, &str); 6] = [
36    // Head
37    (
38        "root/_rootJoint/b_Root_00/b_Hip_01/b_Spine01_02/b_Spine02_03",
39        "b_Neck_04/b_Head_05",
40    ),
41    // Left front leg
42    (
        "root/_rootJoint/b_Root_00/b_Hip_01/b_Spine01_02/b_Spine02_03/b_LeftUpperArm_09",
        "b_LeftForeArm_010/b_LeftHand_011",
    ),
    // Right front leg
    (
        "root/_rootJoint/b_Root_00/b_Hip_01/b_Spine01_02/b_Spine02_03/b_RightUpperArm_06",
        "b_RightForeArm_07/b_RightHand_08",
    ),
    // Left hind leg
    (
        "root/_rootJoint/b_Root_00/b_Hip_01/b_LeftLeg01_015",
        "b_LeftLeg02_016/b_LeftFoot01_017/b_LeftFoot02_018",
    ),
    // Right hind leg
    (
        "root/_rootJoint/b_Root_00/b_Hip_01/b_RightLeg01_019",
        "b_RightLeg02_020/b_RightFoot01_021/b_RightFoot02_022",
    ),
    // Tail
    (
        "root/_rootJoint/b_Root_00/b_Hip_01/b_Tail01_012",
        "b_Tail02_013/b_Tail03_014",
    ),
];

#[derive(Clone, Copy, Component)]
struct AnimationControl {
    // The ID of the mask group that this button controls.
    group_id: u32,
    label: AnimationLabel,
}

#[derive(Clone, Copy, Component, PartialEq, Debug)]
enum AnimationLabel {
    Idle = 0,
    Walk = 1,
    Run = 2,
    Off = 3,
}

#[derive(Clone, Debug, Resource)]
struct AnimationNodes([AnimationNodeIndex; 3]);

#[derive(Clone, Copy, Debug, Resource)]
struct AppState([MaskGroupState; 6]);

#[derive(Clone, Copy, Debug)]
struct MaskGroupState {
    clip: u8,
}

// The application entry point.
fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(WindowPlugin {
            primary_window: Some(Window {
                title: "Bevy Animation Masks Example".into(),
                ..default()
            }),
            ..default()
        }))
        .add_systems(Startup, (setup_scene, setup_ui))
        .add_systems(Update, setup_animation_graph_once_loaded)
        .add_systems(Update, handle_button_toggles)
        .add_systems(Update, update_ui)
        .insert_resource(GlobalAmbientLight {
            color: WHITE.into(),
            brightness: 100.0,
            ..default()
        })
        .init_resource::<AppState>()
        .run();
}

// Spawns the 3D objects in the scene, and loads the fox animation from the glTF
// file.
fn setup_scene(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // Spawn the camera.
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(-15.0, 10.0, 20.0).looking_at(Vec3::new(0., 1., 0.), Vec3::Y),
    ));

    // Spawn the light.
    commands.spawn((
        PointLight {
            intensity: 10_000_000.0,
            shadow_maps_enabled: true,
            ..default()
        },
        Transform::from_xyz(-4.0, 8.0, 13.0),
    ));

    // Spawn the fox.
    commands.spawn((
        WorldAssetRoot(
            asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/animated/Fox.glb")),
        ),
        Transform::from_scale(Vec3::splat(0.07)),
```

--------------------------------

### Example: Display settings menu setup with children! macro

Source: https://docs.rs/bevy/latest/bevy/ecs/hierarchy/type.ChildSpawner.html

Example from `examples/showcase/game_menu.rs` showing a setup function that spawns a UI node with children using the `children!` macro. It includes helper functions for button styling and uses `DespawnOnExit` and `OnDisplaySettingsMenuScreen` components.

```rust
fn display_settings_menu_setup(mut commands: Commands, display_quality: Res<DisplayQuality>) {
    fn button_node() -> Node {
        Node {
            width: px(200),
            height: px(65),
            margin: UiRect::all(px(20)),
            justify_content: JustifyContent::Center,
            align_items: AlignItems::Center,
            ..default()
        }
    }
    fn button_text_style() -> impl Bundle {
        (
            TextFont {
                font_size: FontSize::Px(33.0),
                ..default()
            },
            TextColor(TEXT_COLOR),
        )
    }

    let display_quality = *display_quality;
    commands.spawn((
        DespawnOnExit(MenuState::SettingsDisplay),
        Node {
            width: percent(100),
            height: percent(100),
            align_items: AlignItems::Center,
            justify_content: JustifyContent::Center,
            ..default()
        },
        OnDisplaySettingsMenuScreen,
        children![(
            Node {
                flex_direction: FlexDirection::Column,
                align_items: AlignItems::Center,
                ..default()
            },
            BackgroundColor(CRIMSON.into()),
            children![
                // Create a new `Node`, this time not setting its `flex_direction`. It will
                // use the default value, `FlexDirection::Row`, from left to right.

```

--------------------------------

### Directional navigation setup with InputFocus

Source: https://docs.rs/bevy/latest/bevy/input_focus/struct.InputFocus.html

Starts a directional navigation example by spawning a camera and a full-screen background node, then begins creating an instructions text. The snippet is truncated in the source.

```rust
fn setup_scattered_ui(mut commands: Commands, mut input_focus: ResMut<InputFocus>) {
    commands.spawn(Camera2d);

    // Create a full-screen background node
    let root_node = commands
        .spawn(Node {
            width: percent(100),
            height: percent(100),
            ..default()
        })
        .id();

    // Instructions
    let instructions = commands
        .spawn((
            Text::new(
                "Directional Navigation Demo\n\n\
                 Use arrow keys or D-pad to navigate.\n\
                 Press Enter or A button to interact.\n\n\
                 Buttons are scattered irregularly,\n\
```

--------------------------------

### Get active handle with get_handle in texture atlas setup

Source: https://docs.rs/bevy/latest/bevy/prelude/struct.AssetServer.html

Example from examples/2d/texture_atlas.rs (line 144). Shows usage of asset_server.get_handle to retrieve an active handle for an asset path. The example creates texture atlases with different padding and sampling, then spawns sprites using the textures.

```rust
fn setup(
    mut commands: Commands,
    rpg_sprite_handles: Res<RpgSpriteFolder>,
    asset_server: Res<AssetServer>,
    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
    loaded_folders: Res<Assets<LoadedFolder>>,
    mut textures: ResMut<Assets<Image>>,
) {
    let loaded_folder = loaded_folders.get(&rpg_sprite_handles.0).unwrap();

    // Create texture atlases with different padding and sampling

    let (texture_atlas_linear, linear_sources, linear_texture) = create_texture_atlas(
        loaded_folder,
        None,
        Some(ImageSampler::linear()),
        &mut textures,
    );
    let atlas_linear_handle = texture_atlases.add(texture_atlas_linear);

    let (texture_atlas_nearest, nearest_sources, nearest_texture) = create_texture_atlas(
        loaded_folder,
        None,
        Some(ImageSampler::nearest()),
        &mut textures,
    );
    let atlas_nearest_handle = texture_atlases.add(texture_atlas_nearest);

    let (texture_atlas_linear_padded, linear_padded_sources, linear_padded_texture) =
        create_texture_atlas(
            loaded_folder,
            Some(UVec2::new(6, 6)),
            Some(ImageSampler::linear()),
            &mut textures,
        );
    let atlas_linear_padded_handle = texture_atlases.add(texture_atlas_linear_padded.clone());

    let (texture_atlas_nearest_padded, nearest_padded_sources, nearest_padded_texture) =
        create_texture_atlas(
            loaded_folder,
            Some(UVec2::new(6, 6)),
            Some(ImageSampler::nearest()),
            &mut textures,
        );
    let atlas_nearest_padded_handle = texture_atlases.add(texture_atlas_nearest_padded);

    commands.spawn(Camera2d);

    // Padded textures are to the right, unpadded to the left

    // Draw unpadded texture atlas
    commands.spawn((
        Sprite::from_image(linear_texture.clone()),
        Transform {
            translation: Vec3::new(-250.0, -160.0, 0.0),
            scale: Vec3::splat(0.5),
            ..default()
        },
    ));

    // Draw padded texture atlas
    commands.spawn((
        Sprite::from_image(linear_padded_texture.clone()),
        Transform {
            translation: Vec3::new(250.0, -160.0, 0.0),
            scale: Vec3::splat(0.5),
            ..default()
        },
    ));
```

--------------------------------

### Full UI example using LinearGradient::to_bottom

Source: https://docs.rs/bevy/latest/bevy/ui/gradients/struct.LinearGradient.html

Example from examples/testbed/full_ui.rs (lines 175-178) showing a setup function that spawns a camera with UI components and a root node with a border and background color, demonstrating a full UI layout.

```rust
fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    // Camera
    commands.spawn((Camera2d, IsDefaultUiCamera, BoxShadowSamples(6)));

    // root node
    commands
        .spawn(Node {
            width: percent(100),
            height: percent(100),
            justify_content: JustifyContent::SpaceBetween,
            ..default()
        })
        .insert(Pickable::IGNORE)
        .with_children(|parent| {
            // left vertical fill (border)
            parent
                .spawn((
                    Node {
                        width: px(200),
                        border: UiRect::all(px(2)),
                        ..default()
                    },
                    BackgroundColor(Color::srgb(0.65, 0.65, 0.65)),
                ))
                .with_children(|parent| {
                    // left vertical fill (content)
                    parent
                        .spawn((
                            Node {
                                width: percent(100),
```

--------------------------------

### Bevy mixed lighting example setup

Source: https://docs.rs/bevy/latest/bevy/math/f32/fn.vec3.html

Sets up a Bevy app with mixed lighting, including plugins, resources, and systems. It defines the main function, scene setup, camera, scene loading, UI buttons, help text, and the start of the lightmap update logic.

```rust
const INITIAL_SPHERE_POSITION: Vec3 = vec3(0.0, 0.5233223, 0.0);

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(WindowPlugin {
            primary_window: Some(Window {
                title: "Bevy Mixed Lighting Example".into(),
                ..default()
            }),
            ..default()
        }))
        .add_plugins(MeshPickingPlugin)
        .insert_resource(GlobalAmbientLight {
            color: ClearColor::default().0,
            brightness: 10000.0,
            affects_lightmapped_meshes: true,
        })
        .init_resource::<AppStatus>()
        .add_message::<WidgetClickEvent<LightingMode>>()
        .add_message::<LightingModeChanged>()
        .add_systems(Startup, setup)
        .add_systems(Update, update_lightmaps)
        .add_systems(Update, update_directional_light)
        .add_systems(Update, make_sphere_nonpickable)
        .add_systems(Update, update_radio_buttons)
        .add_systems(Update, handle_lighting_mode_change)
        .add_systems(Update, widgets::handle_ui_interactions::<LightingMode>)
        .add_systems(Update, reset_sphere_position)
        .add_systems(Update, move_sphere)
        .add_systems(Update, adjust_help_text)
        .run();
}

/// Creates the scene.
fn setup(mut commands: Commands, asset_server: Res<AssetServer>, app_status: Res<AppStatus>) {
    spawn_camera(&mut commands);
    spawn_scene(&mut commands, &asset_server);
    spawn_buttons(&mut commands);
    spawn_help_text(&mut commands, &app_status);
}

/// Spawns the 3D camera.
fn spawn_camera(commands: &mut Commands) {
    commands
        .spawn(Camera3d::default())
        .insert(Transform::from_xyz(-0.7, 0.7, 1.0).looking_at(vec3(0.0, 0.3, 0.0), Vec3::Y));
}

/// Spawns the scene.
///
/// The scene is loaded from a glTF file.
fn spawn_scene(commands: &mut Commands, asset_server: &AssetServer) {
    commands
        .spawn(WorldAssetRoot(
            asset_server.load(
                GltfAssetLabel::Scene(0)
                    .from_asset("models/MixedLightingExample/MixedLightingExample.gltf"),
            ),
        ))
        .observe(
            |_: On<WorldInstanceReady>,
             mut lighting_mode_changed_writer: MessageWriter<LightingModeChanged>| {
                // When the scene loads, send a `LightingModeChanged` event so
                // that we set up the lightmaps.
                lighting_mode_changed_writer.write(LightingModeChanged);
            },
        );
}

/// Spawns the buttons that allow the user to change the lighting mode.
fn spawn_buttons(commands: &mut Commands) {
    commands.spawn((
        widgets::main_ui_node(),
        children![widgets::option_buttons(
            "Lighting",
            &[
                (LightingMode::Baked, "Baked"),
                (LightingMode::MixedDirect, "Mixed (Direct)"),
                (LightingMode::MixedIndirect, "Mixed (Indirect)"),
                (LightingMode::RealTime, "Real-Time"),
            ],
        )],
    ));
}

/// Spawns the help text at the top of the window.
fn spawn_help_text(commands: &mut Commands, app_status: &AppStatus) {
    commands.spawn((
        create_help_text(app_status),
        Node {
            position_type: PositionType::Absolute,
            top: px(12),
            left: px(12),
            ..default()
        },
        HelpText,
    ));
}

/// Adds lightmaps to and/or removes lightmaps from objects in the scene when
/// the lighting mode changes.
///
/// This is also called right after the scene loads in order to set up the
/// lightmaps.
fn update_lightmaps(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    meshes: Query<(Entity, &GltfMeshName, &MeshMaterial3d<StandardMaterial>), With<Mesh3d>>,
    mut lighting_mode_changed_reader: MessageReader<LightingModeChanged>,
    app_status: Res<AppStatus>,
) {
    // Only run if the lighting mode changed. (Note that a change event is fired
    // when the scene first loads.)
    if lighting_mode_changed_reader.read().next().is_none() {
        return;
    }

    // Select the lightmap to use, based on the lighting mode.
    let lightmap: Option<Handle<Image>> = match app_status.lighting_mode {
        LightingMode::Baked => {

```

--------------------------------

### Setup scene with lights and gizmo config (light_gizmos.rs)

Source: https://docs.rs/bevy/latest/bevy/gizmos/config/struct.GizmoConfigStore.html

This example shows a setup system that spawns a circular base, cubes, and point lights. It also retrieves the gizmo config store to configure gizmos for the scene.

```rust
fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut config_store: ResMut<GizmoConfigStore>,
) {
    // Circular base.
    commands.spawn((
        Mesh3d(meshes.add(Circle::new(4.0))),
        MeshMaterial3d(materials.add(Color::WHITE)),
        Transform::from_rotation(Quat::from_rotation_x(-FRAC_PI_2)),
    ));

    // Cubes.
    {
        let mesh = meshes.add(Cuboid::new(1.0, 1.0, 1.0));
        let material = materials.add(Color::srgb_u8(124, 144, 255));
        for x in [-2.0, 0.0, 2.0] {
            commands.spawn((
                Mesh3d(mesh.clone()),
                MeshMaterial3d(material.clone()),
                Transform::from_xyz(x, 0.5, 0.0),
            ));
        }
    }

    // Lights.
    {
        commands.spawn((
            PointLight {
                shadow_maps_enabled: true,
                range: 2.0,
                color: DARK_CYAN.into(),
                ..default()
            },
```

--------------------------------

### Custom clearing context setup for Gizmos

Source: https://docs.rs/bevy/latest/bevy/gizmos/gizmos/struct.Gizmos.html

Example plugin setup for a custom clearing context, useful for custom scheduling similar to `FixedMain`. It initializes a `GizmoStorage` and adds systems to start, clear, collect, and end the gizmo context, plus propagate gizmos before `GizmoMeshSystems`.

```rust
use bevy_gizmos::{prelude::*, *, gizmos::GizmoStorage};
struct ClearContextSetup;
impl Plugin for ClearContextSetup {
    fn build(&self, app: &mut App) {
        app.init_resource::<GizmoStorage<DefaultGizmoConfigGroup, MyContext>>()
           // Make sure this context starts/ends cleanly if inside another context. E.g. it
           // should start after the parent context starts and end after the parent context ends.
           .add_systems(StartOfMyContext, start_gizmo_context::<DefaultGizmoConfigGroup, MyContext>)
           // If not running multiple times, put this with [`start_gizmo_context`].
           .add_systems(StartOfRun, clear_gizmo_context::<DefaultGizmoConfigGroup, MyContext>)
           // If not running multiple times, put this with [`end_gizmo_context`].
           .add_systems(EndOfRun, collect_requested_gizmos::<DefaultGizmoConfigGroup, MyContext>)
           .add_systems(EndOfMyContext, end_gizmo_context::<DefaultGizmoConfigGroup, MyContext>)
           .add_systems(
               Last,
               propagate_gizmos::<DefaultGizmoConfigGroup, MyContext>.before(GizmoMeshSystems),
           );
    }
}
```
Tokens:
Raw