Function default

pub fn default<T>() -> T
where
    T: Default,

An ergonomic abbreviation for Default::default() to make initializing structs easier.

This is especially helpful when combined with “struct update syntax”.

use bevy_utils::default;

#[derive(Default)]
struct Foo {
  a: usize,
  b: usize,
  c: usize,
}

// Normally you would initialize a struct with defaults using "struct update syntax"
// combined with `Default::default()`. This example sets `Foo::bar` to 10 and the remaining
// values to their defaults.
let foo = Foo {
  a: 10,
  ..Default::default()
};

// But now you can do this, which is equivalent:
let foo = Foo {
  a: 10,
  ..default()
};

Examples found in repository

examples/3d/color_grading.rs (line 74)

    fn default() -> Self {
        Self::Global(default())
    }
}

/// Buttons consist of three parts: the button itself, a label child, and a
/// value child. This specifies one of the three entities.
#[derive(Clone, Copy, PartialEq, Component)]
enum ColorGradingOptionWidgetType {
    /// The parent button.
    Button,
    /// The label of the button.
    Label,
    /// The numerical value that the button displays.
    Value,
}

#[derive(Clone, Copy, Component)]
struct ColorGradingOptionWidget {
    widget_type: ColorGradingOptionWidgetType,
    option: SelectedColorGradingOption,
}

/// A marker component for the help text at the top left of the screen.
#[derive(Clone, Copy, Component)]
struct HelpText;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .init_resource::<SelectedColorGradingOption>()
        .add_systems(Startup, setup)
        .add_systems(
            Update,
            (
                handle_button_presses,
                adjust_color_grading_option,
                update_ui_state,
            )
                .chain(),
        )
        .run();
}

fn setup(
    mut commands: Commands,
    currently_selected_option: Res<SelectedColorGradingOption>,
    asset_server: Res<AssetServer>,
) {
    // Create the scene.
    add_basic_scene(&mut commands, &asset_server);

    // Create the root UI element.
    let font = asset_server.load(FONT_PATH);
    let color_grading = ColorGrading::default();
    add_buttons(&mut commands, &font, &color_grading);

    // Spawn help text.
    add_help_text(&mut commands, &font, &currently_selected_option);

    // Spawn the camera.
    add_camera(&mut commands, &asset_server, color_grading);
}

/// Adds all the buttons on the bottom of the scene.
fn add_buttons(commands: &mut Commands, font: &Handle<Font>, color_grading: &ColorGrading) {
    // Spawn the parent node that contains all the buttons.
    commands
        .spawn(Node {
            flex_direction: FlexDirection::Column,
            position_type: PositionType::Absolute,
            row_gap: Val::Px(6.0),
            left: Val::Px(12.0),
            bottom: Val::Px(12.0),
            ..default()
        })
        .with_children(|parent| {
            // Create the first row, which contains the global controls.
            add_buttons_for_global_controls(parent, color_grading, font);

            // Create the rows for individual controls.
            for section in [
                SelectedColorGradingSection::Highlights,
                SelectedColorGradingSection::Midtones,
                SelectedColorGradingSection::Shadows,
            ] {
                add_buttons_for_section(parent, section, color_grading, font);
            }
        });
}

/// Adds the buttons for the global controls (those that control the scene as a
/// whole as opposed to shadows, midtones, or highlights).
fn add_buttons_for_global_controls(
    parent: &mut ChildSpawnerCommands,
    color_grading: &ColorGrading,
    font: &Handle<Font>,
) {
    // Add the parent node for the row.
    parent.spawn(Node::default()).with_children(|parent| {
        // Add some placeholder text to fill this column.
        parent.spawn(Node {
            width: Val::Px(125.0),
            ..default()
        });

        // Add each global color grading option button.
        for option in [
            SelectedGlobalColorGradingOption::Exposure,
            SelectedGlobalColorGradingOption::Temperature,
            SelectedGlobalColorGradingOption::Tint,
            SelectedGlobalColorGradingOption::Hue,
        ] {
            add_button_for_value(
                parent,
                SelectedColorGradingOption::Global(option),
                color_grading,
                font,
            );
        }
    });
}

/// Adds the buttons that control color grading for individual sections
/// (highlights, midtones, shadows).
fn add_buttons_for_section(
    parent: &mut ChildSpawnerCommands,
    section: SelectedColorGradingSection,
    color_grading: &ColorGrading,
    font: &Handle<Font>,
) {
    // Spawn the row container.
    parent
        .spawn(Node {
            align_items: AlignItems::Center,
            ..default()
        })
        .with_children(|parent| {
            // Spawn the label ("Highlights", etc.)
            add_text(parent, &section.to_string(), font, Color::WHITE).insert(Node {
                width: Val::Px(125.0),
                ..default()
            });

            // Spawn the buttons.
            for option in [
                SelectedSectionColorGradingOption::Saturation,
                SelectedSectionColorGradingOption::Contrast,
                SelectedSectionColorGradingOption::Gamma,
                SelectedSectionColorGradingOption::Gain,
                SelectedSectionColorGradingOption::Lift,
            ] {
                add_button_for_value(
                    parent,
                    SelectedColorGradingOption::Section(section, option),
                    color_grading,
                    font,
                );
            }
        });
}

/// Adds a button that controls one of the color grading values.
fn add_button_for_value(
    parent: &mut ChildSpawnerCommands,
    option: SelectedColorGradingOption,
    color_grading: &ColorGrading,
    font: &Handle<Font>,
) {
    // Add the button node.
    parent
        .spawn((
            Button,
            Node {
                border: UiRect::all(Val::Px(1.0)),
                width: Val::Px(200.0),
                justify_content: JustifyContent::Center,
                align_items: AlignItems::Center,
                padding: UiRect::axes(Val::Px(12.0), Val::Px(6.0)),
                margin: UiRect::right(Val::Px(12.0)),
                ..default()
            },
            BorderColor(Color::WHITE),
            BorderRadius::MAX,
            BackgroundColor(Color::BLACK),
        ))
        .insert(ColorGradingOptionWidget {
            widget_type: ColorGradingOptionWidgetType::Button,
            option,
        })
        .with_children(|parent| {
            // Add the button label.
            let label = match option {
                SelectedColorGradingOption::Global(option) => option.to_string(),
                SelectedColorGradingOption::Section(_, option) => option.to_string(),
            };
            add_text(parent, &label, font, Color::WHITE).insert(ColorGradingOptionWidget {
                widget_type: ColorGradingOptionWidgetType::Label,
                option,
            });

            // Add a spacer.
            parent.spawn(Node {
                flex_grow: 1.0,
                ..default()
            });

            // Add the value text.
            add_text(
                parent,
                &format!("{:.3}", option.get(color_grading)),
                font,
                Color::WHITE,
            )
            .insert(ColorGradingOptionWidget {
                widget_type: ColorGradingOptionWidgetType::Value,
                option,
            });
        });
}

/// Creates the help text at the top of the screen.
fn add_help_text(
    commands: &mut Commands,
    font: &Handle<Font>,
    currently_selected_option: &SelectedColorGradingOption,
) {
    commands.spawn((
        Text::new(create_help_text(currently_selected_option)),
        TextFont {
            font: font.clone(),
            ..default()
        },
        Node {
            position_type: PositionType::Absolute,
            left: Val::Px(12.0),
            top: Val::Px(12.0),
            ..default()
        },
        HelpText,
    ));
}

/// Adds some text to the scene.
fn add_text<'a>(
    parent: &'a mut ChildSpawnerCommands,
    label: &str,
    font: &Handle<Font>,
    color: Color,
) -> EntityCommands<'a> {
    parent.spawn((
        Text::new(label),
        TextFont {
            font: font.clone(),
            font_size: 15.0,
            ..default()
        },
        TextColor(color),
    ))
}

fn add_camera(commands: &mut Commands, asset_server: &AssetServer, color_grading: ColorGrading) {
    commands.spawn((
        Camera3d::default(),
        Camera {
            hdr: true,
            ..default()
        },
        Transform::from_xyz(0.7, 0.7, 1.0).looking_at(Vec3::new(0.0, 0.3, 0.0), Vec3::Y),
        color_grading,
        DistanceFog {
            color: Color::srgb_u8(43, 44, 47),
            falloff: FogFalloff::Linear {
                start: 1.0,
                end: 8.0,
            },
            ..default()
        },
        EnvironmentMapLight {
            diffuse_map: asset_server.load("environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2"),
            specular_map: asset_server.load("environment_maps/pisa_specular_rgb9e5_zstd.ktx2"),
            intensity: 2000.0,
            ..default()
        },
    ));
}

fn add_basic_scene(commands: &mut Commands, asset_server: &AssetServer) {
    // Spawn the main scene.
    commands.spawn(SceneRoot(asset_server.load(
        GltfAssetLabel::Scene(0).from_asset("models/TonemappingTest/TonemappingTest.gltf"),
    )));

    // Spawn the flight helmet.
    commands.spawn((
        SceneRoot(
            asset_server
                .load(GltfAssetLabel::Scene(0).from_asset("models/FlightHelmet/FlightHelmet.gltf")),
        ),
        Transform::from_xyz(0.5, 0.0, -0.5).with_rotation(Quat::from_rotation_y(-0.15 * PI)),
    ));

    // Spawn the light.
    commands.spawn((
        DirectionalLight {
            illuminance: 15000.0,
            shadows_enabled: true,
            ..default()
        },
        Transform::from_rotation(Quat::from_euler(EulerRot::ZYX, 0.0, PI * -0.15, PI * -0.15)),
        CascadeShadowConfigBuilder {
            maximum_distance: 3.0,
            first_cascade_far_bound: 0.9,
            ..default()
        }
        .build(),
    ));
}

examples/3d/pcss.rs (line 66)

    fn default() -> Self {
        Self {
            light_type: default(),
            shadow_filter: default(),
            soft_shadows: true,
        }
    }
}

/// The type of light presently in the scene: directional, point, or spot.
#[derive(Clone, Copy, Default, PartialEq)]
enum LightType {
    /// A directional light, with a cascaded shadow map.
    #[default]
    Directional,
    /// A point light, with a cube shadow map.
    Point,
    /// A spot light, with a cube shadow map.
    Spot,
}

/// The type of shadow filter.
///
/// Generally, `Gaussian` is preferred when temporal antialiasing isn't in use,
/// while `Temporal` is preferred when TAA is in use. In this example, this
/// setting also turns TAA on and off.
#[derive(Clone, Copy, Default, PartialEq)]
enum ShadowFilter {
    /// The non-temporal Gaussian filter (Castano '13 for directional lights, an
    /// analogous alternative for point and spot lights).
    #[default]
    NonTemporal,
    /// The temporal Gaussian filter (Jimenez '14 for directional lights, an
    /// analogous alternative for point and spot lights).
    Temporal,
}

/// Each example setting that can be toggled in the UI.
#[derive(Clone, Copy, PartialEq)]
enum AppSetting {
    /// The type of light presently in the scene: directional, point, or spot.
    LightType(LightType),
    /// The type of shadow filter.
    ShadowFilter(ShadowFilter),
    /// Whether PCSS is enabled or disabled.
    SoftShadows(bool),
}

/// The example application entry point.
fn main() {
    App::new()
        .init_resource::<AppStatus>()
        .add_plugins(DefaultPlugins.set(WindowPlugin {
            primary_window: Some(Window {
                title: "Bevy Percentage Closer Soft Shadows Example".into(),
                ..default()
            }),
            ..default()
        }))
        .add_plugins(TemporalAntiAliasPlugin)
        .add_event::<WidgetClickEvent<AppSetting>>()
        .add_systems(Startup, setup)
        .add_systems(Update, widgets::handle_ui_interactions::<AppSetting>)
        .add_systems(
            Update,
            update_radio_buttons.after(widgets::handle_ui_interactions::<AppSetting>),
        )
        .add_systems(
            Update,
            (
                handle_light_type_change,
                handle_shadow_filter_change,
                handle_pcss_toggle,
            )
                .after(widgets::handle_ui_interactions::<AppSetting>),
        )
        .run();
}

/// Creates all the objects in the scene.
fn setup(mut commands: Commands, asset_server: Res<AssetServer>, app_status: Res<AppStatus>) {
    spawn_camera(&mut commands, &asset_server);
    spawn_light(&mut commands, &app_status);
    spawn_gltf_scene(&mut commands, &asset_server);
    spawn_buttons(&mut commands);
}

/// Spawns the camera, with the initial shadow filtering method.
fn spawn_camera(commands: &mut Commands, asset_server: &AssetServer) {
    commands
        .spawn((
            Camera3d::default(),
            Transform::from_xyz(-12.912 * 0.7, 4.466 * 0.7, -10.624 * 0.7).with_rotation(
                Quat::from_euler(EulerRot::YXZ, -134.76 / 180.0 * PI, -0.175, 0.0),
            ),
        ))
        .insert(ShadowFilteringMethod::Gaussian)
        // `TemporalJitter` is needed for TAA. Note that it does nothing without
        // `TemporalAntiAliasSettings`.
        .insert(TemporalJitter::default())
        // We want MSAA off for TAA to work properly.
        .insert(Msaa::Off)
        // The depth prepass is needed for TAA.
        .insert(DepthPrepass)
        // The motion vector prepass is needed for TAA.
        .insert(MotionVectorPrepass)
        // Add a nice skybox.
        .insert(Skybox {
            image: asset_server.load("environment_maps/sky_skybox.ktx2"),
            brightness: 500.0,
            rotation: Quat::IDENTITY,
        });
}

/// Spawns the initial light.
fn spawn_light(commands: &mut Commands, app_status: &AppStatus) {
    // Because this light can become a directional light, point light, or spot
    // light depending on the settings, we add the union of the components
    // necessary for this light to behave as all three of those.
    commands
        .spawn((
            create_directional_light(app_status),
            Transform::from_rotation(Quat::from_array([
                0.6539259,
                -0.34646285,
                0.36505926,
                -0.5648683,
            ]))
            .with_translation(vec3(57.693, 34.334, -6.422)),
        ))
        // These two are needed for point lights.
        .insert(CubemapVisibleEntities::default())
        .insert(CubemapFrusta::default())
        // These two are needed for spot lights.
        .insert(VisibleMeshEntities::default())
        .insert(Frustum::default());
}

/// Loads and spawns the glTF palm tree scene.
fn spawn_gltf_scene(commands: &mut Commands, asset_server: &AssetServer) {
    commands.spawn(SceneRoot(
        asset_server.load("models/PalmTree/PalmTree.gltf#Scene0"),
    ));
}

/// Spawns all the buttons at the bottom of the screen.
fn spawn_buttons(commands: &mut Commands) {
    commands
        .spawn(widgets::main_ui_node())
        .with_children(|parent| {
            widgets::spawn_option_buttons(
                parent,
                "Light Type",
                &[
                    (AppSetting::LightType(LightType::Directional), "Directional"),
                    (AppSetting::LightType(LightType::Point), "Point"),
                    (AppSetting::LightType(LightType::Spot), "Spot"),
                ],
            );
            widgets::spawn_option_buttons(
                parent,
                "Shadow Filter",
                &[
                    (AppSetting::ShadowFilter(ShadowFilter::Temporal), "Temporal"),
                    (
                        AppSetting::ShadowFilter(ShadowFilter::NonTemporal),
                        "Non-Temporal",
                    ),
                ],
            );
            widgets::spawn_option_buttons(
                parent,
                "Soft Shadows",
                &[
                    (AppSetting::SoftShadows(true), "On"),
                    (AppSetting::SoftShadows(false), "Off"),
                ],
            );
        });
}

/// Updates the style of the radio buttons that enable and disable soft shadows
/// to reflect whether PCSS is enabled.
fn update_radio_buttons(
    mut widgets: Query<
        (
            Entity,
            Option<&mut BackgroundColor>,
            Has<Text>,
            &WidgetClickSender<AppSetting>,
        ),
        Or<(With<RadioButton>, With<RadioButtonText>)>,
    >,
    app_status: Res<AppStatus>,
    mut writer: TextUiWriter,
) {
    for (entity, image, has_text, sender) in widgets.iter_mut() {
        let selected = match **sender {
            AppSetting::LightType(light_type) => light_type == app_status.light_type,
            AppSetting::ShadowFilter(shadow_filter) => shadow_filter == app_status.shadow_filter,
            AppSetting::SoftShadows(soft_shadows) => soft_shadows == app_status.soft_shadows,
        };

        if let Some(mut bg_color) = image {
            widgets::update_ui_radio_button(&mut bg_color, selected);
        }
        if has_text {
            widgets::update_ui_radio_button_text(entity, &mut writer, selected);
        }
    }
}

/// Handles requests from the user to change the type of light.
fn handle_light_type_change(
    mut commands: Commands,
    mut lights: Query<Entity, Or<(With<DirectionalLight>, With<PointLight>, With<SpotLight>)>>,
    mut events: EventReader<WidgetClickEvent<AppSetting>>,
    mut app_status: ResMut<AppStatus>,
) {
    for event in events.read() {
        let AppSetting::LightType(light_type) = **event else {
            continue;
        };
        app_status.light_type = light_type;

        for light in lights.iter_mut() {
            let mut light_commands = commands.entity(light);
            light_commands
                .remove::<DirectionalLight>()
                .remove::<PointLight>()
                .remove::<SpotLight>();
            match light_type {
                LightType::Point => {
                    light_commands.insert(create_point_light(&app_status));
                }
                LightType::Spot => {
                    light_commands.insert(create_spot_light(&app_status));
                }
                LightType::Directional => {
                    light_commands.insert(create_directional_light(&app_status));
                }
            }
        }
    }
}

/// Handles requests from the user to change the shadow filter method.
///
/// This system is also responsible for enabling and disabling TAA as
/// appropriate.
fn handle_shadow_filter_change(
    mut commands: Commands,
    mut cameras: Query<(Entity, &mut ShadowFilteringMethod)>,
    mut events: EventReader<WidgetClickEvent<AppSetting>>,
    mut app_status: ResMut<AppStatus>,
) {
    for event in events.read() {
        let AppSetting::ShadowFilter(shadow_filter) = **event else {
            continue;
        };
        app_status.shadow_filter = shadow_filter;

        for (camera, mut shadow_filtering_method) in cameras.iter_mut() {
            match shadow_filter {
                ShadowFilter::NonTemporal => {
                    *shadow_filtering_method = ShadowFilteringMethod::Gaussian;
                    commands.entity(camera).remove::<TemporalAntiAliasing>();
                }
                ShadowFilter::Temporal => {
                    *shadow_filtering_method = ShadowFilteringMethod::Temporal;
                    commands
                        .entity(camera)
                        .insert(TemporalAntiAliasing::default());
                }
            }
        }
    }
}

/// Handles requests from the user to toggle soft shadows on and off.
fn handle_pcss_toggle(
    mut lights: Query<AnyOf<(&mut DirectionalLight, &mut PointLight, &mut SpotLight)>>,
    mut events: EventReader<WidgetClickEvent<AppSetting>>,
    mut app_status: ResMut<AppStatus>,
) {
    for event in events.read() {
        let AppSetting::SoftShadows(value) = **event else {
            continue;
        };
        app_status.soft_shadows = value;

        // Recreating the lights is the simplest way to toggle soft shadows.
        for (directional_light, point_light, spot_light) in lights.iter_mut() {
            if let Some(mut directional_light) = directional_light {
                *directional_light = create_directional_light(&app_status);
            }
            if let Some(mut point_light) = point_light {
                *point_light = create_point_light(&app_status);
            }
            if let Some(mut spot_light) = spot_light {
                *spot_light = create_spot_light(&app_status);
            }
        }
    }
}

/// Creates the [`DirectionalLight`] component with the appropriate settings.
fn create_directional_light(app_status: &AppStatus) -> DirectionalLight {
    DirectionalLight {
        shadows_enabled: true,
        soft_shadow_size: if app_status.soft_shadows {
            Some(LIGHT_RADIUS)
        } else {
            None
        },
        shadow_depth_bias: DIRECTIONAL_SHADOW_DEPTH_BIAS,
        ..default()
    }
}

/// Creates the [`PointLight`] component with the appropriate settings.
fn create_point_light(app_status: &AppStatus) -> PointLight {
    PointLight {
        intensity: POINT_LIGHT_INTENSITY,
        range: POINT_LIGHT_RANGE,
        shadows_enabled: true,
        radius: LIGHT_RADIUS,
        soft_shadows_enabled: app_status.soft_shadows,
        shadow_depth_bias: POINT_SHADOW_DEPTH_BIAS,
        shadow_map_near_z: SHADOW_MAP_NEAR_Z,
        ..default()
    }
}

/// Creates the [`SpotLight`] component with the appropriate settings.
fn create_spot_light(app_status: &AppStatus) -> SpotLight {
    SpotLight {
        intensity: POINT_LIGHT_INTENSITY,
        range: POINT_LIGHT_RANGE,
        radius: LIGHT_RADIUS,
        shadows_enabled: true,
        soft_shadows_enabled: app_status.soft_shadows,
        shadow_depth_bias: DIRECTIONAL_SHADOW_DEPTH_BIAS,
        shadow_map_near_z: SHADOW_MAP_NEAR_Z,
        ..default()
    }
}

tests/3d/no_prepass.rs (line 9)

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(PbrPlugin {
            prepass_enabled: false,
            ..default()
        }))
        .run();
}

examples/app/log_layers.rs (line 44)

fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(bevy::log::LogPlugin {
            custom_layer,

            ..default()
        }))
        .add_systems(Update, log_system)
        .run();
}

examples/3d/spherical_area_lights.rs (line 9)

fn main() {
    App::new()
        .insert_resource(AmbientLight {
            brightness: 60.0,
            ..default()
        })
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, setup)
        .run();
}

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    // camera
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.2, 1.5, 2.5).looking_at(Vec3::ZERO, Vec3::Y),
    ));

    // plane
    commands.spawn((
        Mesh3d(meshes.add(Plane3d::default().mesh().size(100.0, 100.0))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Color::srgb(0.2, 0.2, 0.2),
            perceptual_roughness: 0.08,
            ..default()
        })),
    ));

    const COUNT: usize = 6;
    let position_range = -2.0..2.0;
    let radius_range = 0.0..0.4;
    let pos_len = position_range.end - position_range.start;
    let radius_len = radius_range.end - radius_range.start;
    let mesh = meshes.add(Sphere::new(1.0).mesh().uv(120, 64));

    for i in 0..COUNT {
        let percent = i as f32 / COUNT as f32;
        let radius = radius_range.start + percent * radius_len;

        // sphere light
        commands
            .spawn((
                Mesh3d(mesh.clone()),
                MeshMaterial3d(materials.add(StandardMaterial {
                    base_color: Color::srgb(0.5, 0.5, 1.0),
                    unlit: true,
                    ..default()
                })),
                Transform::from_xyz(position_range.start + percent * pos_len, 0.3, 0.0)
                    .with_scale(Vec3::splat(radius)),
            ))
            .with_child(PointLight {
                radius,
                color: Color::srgb(0.2, 0.2, 1.0),
                ..default()
            });
    }
}

examples/asset/asset_decompression.rs (line 111)

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn(Camera2d);

    commands.spawn(Compressed::<Image> {
        compressed: asset_server.load("data/compressed_image.png.gz"),
        ..default()
    });
}

Additional examples can be found in:

• examples/3d/../helpers/widgets.rs
• examples/animation/animated_transform.rs
• examples/3d/reflection_probes.rs
• examples/animation/gltf_skinned_mesh.rs
• examples/animation/custom_skinned_mesh.rs
• examples/window/monitor_info.rs
• examples/3d/spotlight.rs
• examples/3d/ssao.rs
• examples/camera/2d_screen_shake.rs
• examples/audio/decodable.rs
• examples/math/render_primitives.rs
• examples/3d/fog.rs
• examples/app/no_renderer.rs
• examples/audio/spatial_audio_2d.rs
• examples/animation/animated_mesh.rs
• examples/camera/2d_top_down_camera.rs
• examples/app/log_layers_ecs.rs
• examples/animation/animated_mesh_control.rs
• examples/scene/scene.rs
• examples/ui/grid.rs
• examples/3d/fog_volumes.rs
• examples/movement/physics_in_fixed_timestep.rs
• examples/testbed/ui.rs
• examples/window/window_resizing.rs
• examples/app/return_after_run.rs
• examples/asset/alter_sprite.rs
• examples/window/window_drag_move.rs
• examples/3d/scrolling_fog.rs
• examples/ui/text_debug.rs
• tests/window/minimizing.rs
• examples/window/scale_factor_override.rs
• tests/ecs/ambiguity_detection.rs
• examples/animation/morph_targets.rs
• examples/animation/animated_mesh_events.rs
• examples/app/logs.rs
• examples/window/custom_cursor_image.rs
• examples/2d/sprite_tile.rs
• examples/3d/depth_of_field.rs
• examples/audio/audio_control.rs
• examples/3d/anisotropy.rs
• examples/3d/visibility_range.rs
• examples/3d/post_processing.rs
• examples/gizmos/2d_gizmos.rs
• examples/animation/animation_masks.rs
• examples/ecs/one_shot_systems.rs
• examples/games/breakout.rs
• examples/3d/specular_tint.rs
• examples/3d/transmission.rs
• examples/ui/window_fallthrough.rs
• tests/window/resizing.rs
• examples/2d/custom_gltf_vertex_attribute.rs
• examples/games/loading_screen.rs
• examples/2d/transparency_2d.rs
• examples/stress_tests/text_pipeline.rs
• examples/3d/rotate_environment_map.rs
• examples/shader/shader_prepass.rs
• examples/ecs/entity_disabling.rs
• examples/3d/ssr.rs
• examples/animation/animation_graph.rs
• examples/3d/load_gltf_extras.rs
• examples/stress_tests/many_lights.rs
• examples/window/transparent_window.rs
• examples/shader/compute_shader_game_of_life.rs
• examples/3d/clearcoat.rs
• examples/3d/3d_scene.rs
• examples/diagnostics/log_diagnostics.rs
• examples/games/game_menu.rs
• examples/stress_tests/many_text2d.rs
• examples/stress_tests/many_materials.rs
• examples/stress_tests/many_gizmos.rs
• examples/shader/custom_post_processing.rs
• examples/ui/font_atlas_debug.rs
• examples/ecs/system_piping.rs
• examples/testbed/2d.rs
• examples/stress_tests/many_glyphs.rs
• examples/picking/debug_picking.rs
• examples/asset/multi_asset_sync.rs
• examples/3d/tonemapping.rs
• examples/camera/camera_orbit.rs
• examples/stress_tests/many_animated_sprites.rs
• examples/stress_tests/many_cubes.rs
• examples/dev_tools/fps_overlay.rs
• examples/remote/server.rs
• examples/3d/parenting.rs
• examples/3d/occlusion_culling.rs
• examples/stress_tests/many_sprites.rs
• examples/ecs/fallible_params.rs
• examples/3d/animated_material.rs
• examples/window/screenshot.rs
• examples/camera/custom_projection.rs
• examples/3d/skybox.rs
• examples/3d/mixed_lighting.rs
• examples/3d/load_gltf.rs
• examples/3d/two_passes.rs
• examples/3d/clustered_decals.rs
• examples/input/text_input.rs
• examples/window/low_power.rs
• examples/ui/button.rs
• examples/state/custom_transitions.rs
• examples/state/states.rs
• examples/shader/extended_material_bindless.rs
• examples/games/desk_toy.rs
• examples/3d/wireframe.rs
• examples/3d/update_gltf_scene.rs
• examples/stress_tests/transform_hierarchy.rs
• examples/2d/wireframe_2d.rs
• examples/shader/custom_render_phase.rs
• examples/3d/atmospheric_fog.rs
• examples/3d/atmosphere.rs
• examples/asset/processing/asset_processing.rs
• examples/3d/order_independent_transparency.rs
• examples/state/sub_states.rs
• examples/ecs/hierarchy.rs
• examples/stress_tests/many_foxes.rs
• examples/app/headless_renderer.rs
• examples/3d/generate_custom_mesh.rs
• examples/audio/soundtrack.rs
• examples/movement/smooth_follow.rs
• examples/stress_tests/bevymark.rs
• examples/3d/lightmaps.rs
• examples/3d/mesh_ray_cast.rs
• examples/ui/relative_cursor_position.rs
• examples/3d/vertex_colors.rs
• examples/picking/simple_picking.rs
• examples/ui/ui_material.rs
• examples/animation/animation_events.rs
• examples/games/contributors.rs
• examples/2d/2d_shapes.rs
• examples/ecs/observers.rs
• examples/ui/ui_scaling.rs
• examples/2d/pixel_grid_snap.rs
• examples/math/bounding_2d.rs
• examples/2d/2d_viewport_to_world.rs
• examples/window/multiple_windows.rs
• examples/ui/ui_texture_atlas.rs
• examples/gizmos/axes.rs
• examples/3d/motion_blur.rs
• examples/2d/bloom_2d.rs
• examples/window/window_settings.rs
• examples/math/custom_primitives.rs
• examples/camera/first_person_view_model.rs
• examples/ui/ghost_nodes.rs
• examples/ui/overflow_debug.rs
• examples/animation/eased_motion.rs
• examples/stress_tests/many_buttons.rs
• examples/audio/spatial_audio_3d.rs
• examples/ecs/error_handling.rs
• examples/camera/projection_zoom.rs
• examples/2d/rotation.rs
• examples/ui/ui_texture_slice.rs
• examples/2d/sprite_animation.rs
• examples/math/cubic_splines.rs
• examples/3d/irradiance_volumes.rs
• examples/testbed/3d.rs
• examples/ecs/nondeterministic_system_order.rs
• examples/stress_tests/many_cameras_lights.rs
• examples/3d/volumetric_fog.rs
• examples/3d/texture.rs
• examples/animation/animated_ui.rs
• examples/time/virtual_time.rs
• examples/3d/shadow_caster_receiver.rs
• examples/ui/ui_texture_slice_flip_and_tile.rs
• examples/ui/viewport_debug.rs
• examples/ui/size_constraints.rs
• examples/gizmos/3d_gizmos.rs
• examples/games/stepping.rs
• examples/3d/bloom_3d.rs
• examples/3d/anti_aliasing.rs
• examples/ui/transparency_ui.rs
• examples/transforms/align.rs
• examples/3d/decal.rs
• examples/math/random_sampling.rs
• examples/ui/render_ui_to_texture.rs
• examples/ui/ui_texture_atlas_slice.rs
• examples/shader/gpu_readback.rs
• examples/picking/sprite_picking.rs
• examples/2d/mesh2d_alpha_mode.rs
• examples/2d/mesh2d_arcs.rs
• examples/asset/repeated_texture.rs
• examples/ecs/iter_combinations.rs
• examples/state/computed_states.rs
• examples/shader/custom_phase_item.rs
• examples/ui/text_wrap_debug.rs
• examples/games/alien_cake_addict.rs
• examples/asset/alter_mesh.rs
• examples/2d/sprite_slice.rs
• examples/3d/transparency_3d.rs
• examples/ui/text.rs
• examples/2d/mesh2d_repeated_texture.rs
• examples/3d/3d_shapes.rs
• examples/3d/meshlet.rs
• examples/gizmos/light_gizmos.rs
• examples/3d/render_to_texture.rs
• examples/3d/pbr.rs
• examples/asset/asset_loading.rs
• examples/3d/auto_exposure.rs
• examples/ui/overflow.rs
• examples/ui/flex_layout.rs
• examples/ui/overflow_clip_margin.rs
• examples/animation/easing_functions.rs
• examples/shader/specialized_mesh_pipeline.rs
• examples/ui/display_and_visibility.rs
• examples/ui/tab_navigation.rs
• examples/picking/mesh_picking.rs
• examples/3d/shadow_biases.rs
• examples/3d/split_screen.rs
• examples/ui/z_index.rs
• examples/2d/text2d.rs
• examples/math/sampling_primitives.rs
• examples/2d/texture_atlas.rs
• examples/2d/sprite_scale.rs
• examples/3d/parallax_mapping.rs
• examples/ui/directional_navigation.rs
• examples/3d/deferred_rendering.rs
• examples/3d/blend_modes.rs
• examples/3d/lighting.rs
• examples/ui/box_shadow.rs
• examples/3d/camera_sub_view.rs
• examples/ui/borders.rs
• examples/ui/scroll.rs
• examples/testbed/full_ui.rs