Vendor dependencies for 0.3.0 release

vendor/bevy/examples/picking/debug_picking.rs

@@ -0,0 +1,109 @@
+//! A simple scene to demonstrate picking events for UI and mesh entities,
+//! Demonstrates how to change debug settings
+
+use bevy::dev_tools::picking_debug::{DebugPickingMode, DebugPickingPlugin};
+use bevy::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins.set(bevy::log::LogPlugin {
+            filter: "bevy_dev_tools=trace".into(), // Show picking logs trace level and up
+            ..default()
+        }))
+        .add_plugins((MeshPickingPlugin, DebugPickingPlugin))
+        .add_systems(Startup, setup_scene)
+        .insert_resource(DebugPickingMode::Normal)
+        // A system that cycles the debugging state when you press F3:
+        .add_systems(
+            PreUpdate,
+            (|mut mode: ResMut<DebugPickingMode>| {
+                *mode = match *mode {
+                    DebugPickingMode::Disabled => DebugPickingMode::Normal,
+                    DebugPickingMode::Normal => DebugPickingMode::Noisy,
+                    DebugPickingMode::Noisy => DebugPickingMode::Disabled,
+                }
+            })
+            .distributive_run_if(bevy::input::common_conditions::input_just_pressed(
+                KeyCode::F3,
+            )),
+        )
+        .run();
+}
+
+fn setup_scene(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands
+        .spawn((
+            Text::new("Click Me to get a box\nDrag cubes to rotate\nPress F3 to cycle between picking debug levels"),
+            Node {
+                position_type: PositionType::Absolute,
+                top: Val::Percent(12.0),
+                left: Val::Percent(12.0),
+                ..default()
+            },
+        ))
+        .observe(on_click_spawn_cube)
+        .observe(
+            |out: Trigger<Pointer<Out>>, mut texts: Query<&mut TextColor>| {
+                let mut text_color = texts.get_mut(out.target()).unwrap();
+                text_color.0 = Color::WHITE;
+            },
+        )
+        .observe(
+            |over: Trigger<Pointer<Over>>, mut texts: Query<&mut TextColor>| {
+                let mut color = texts.get_mut(over.target()).unwrap();
+                color.0 = bevy::color::palettes::tailwind::CYAN_400.into();
+            },
+        );
+
+    // Base
+    commands.spawn((
+        Name::new("Base"),
+        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)),
+    ));
+
+    // Light
+    commands.spawn((
+        PointLight {
+            shadows_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),
+    ));
+}
+
+fn on_click_spawn_cube(
+    _click: Trigger<Pointer<Click>>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut num: Local<usize>,
+) {
+    commands
+        .spawn((
+            Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
+            MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
+            Transform::from_xyz(0.0, 0.25 + 0.55 * *num as f32, 0.0),
+        ))
+        // With the MeshPickingPlugin added, you can add pointer event observers to meshes:
+        .observe(on_drag_rotate);
+    *num += 1;
+}
+
+fn on_drag_rotate(drag: Trigger<Pointer<Drag>>, mut transforms: Query<&mut Transform>) {
+    if let Ok(mut transform) = transforms.get_mut(drag.target()) {
+        transform.rotate_y(drag.delta.x * 0.02);
+        transform.rotate_x(drag.delta.y * 0.02);
+    }
+}

vendor/bevy/examples/picking/mesh_picking.rs

@@ -0,0 +1,197 @@
+//! A simple 3D scene to demonstrate mesh picking.
+//!
+//! [`bevy::picking::backend`] provides an API for adding picking hit tests to any entity. To get
+//! started with picking 3d meshes, the [`MeshPickingPlugin`] is provided as a simple starting
+//! point, especially useful for debugging. For your game, you may want to use a 3d picking backend
+//! provided by your physics engine, or a picking shader, depending on your specific use case.
+//!
+//! [`bevy::picking`] allows you to compose backends together to make any entity on screen pickable
+//! with pointers, regardless of how that entity is rendered. For example, `bevy_ui` and
+//! `bevy_sprite` provide their own picking backends that can be enabled at the same time as this
+//! mesh picking backend. This makes it painless to deal with cases like the UI or sprites blocking
+//! meshes underneath them, or vice versa.
+//!
+//! If you want to build more complex interactions than afforded by the provided pointer events, you
+//! may want to use [`MeshRayCast`] or a full physics engine with raycasting capabilities.
+//!
+//! By default, the mesh picking plugin will raycast against all entities, which is especially
+//! useful for debugging. If you want mesh picking to be opt-in, you can set
+//! [`MeshPickingSettings::require_markers`] to `true` and add a [`Pickable`] component to the
+//! desired camera and target entities.
+
+use std::f32::consts::PI;
+
+use bevy::{color::palettes::tailwind::*, picking::pointer::PointerInteraction, prelude::*};
+
+fn main() {
+    App::new()
+        // MeshPickingPlugin is not a default plugin
+        .add_plugins((DefaultPlugins, MeshPickingPlugin))
+        .add_systems(Startup, setup_scene)
+        .add_systems(Update, (draw_mesh_intersections, rotate))
+        .run();
+}
+
+/// A marker component for our shapes so we can query them separately from the ground plane.
+#[derive(Component)]
+struct Shape;
+
+const SHAPES_X_EXTENT: f32 = 14.0;
+const EXTRUSION_X_EXTENT: f32 = 16.0;
+const Z_EXTENT: f32 = 5.0;
+
+fn setup_scene(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Set up the materials.
+    let white_matl = materials.add(Color::WHITE);
+    let ground_matl = materials.add(Color::from(GRAY_300));
+    let hover_matl = materials.add(Color::from(CYAN_300));
+    let pressed_matl = materials.add(Color::from(YELLOW_300));
+
+    let shapes = [
+        meshes.add(Cuboid::default()),
+        meshes.add(Tetrahedron::default()),
+        meshes.add(Capsule3d::default()),
+        meshes.add(Torus::default()),
+        meshes.add(Cylinder::default()),
+        meshes.add(Cone::default()),
+        meshes.add(ConicalFrustum::default()),
+        meshes.add(Sphere::default().mesh().ico(5).unwrap()),
+        meshes.add(Sphere::default().mesh().uv(32, 18)),
+    ];
+
+    let extrusions = [
+        meshes.add(Extrusion::new(Rectangle::default(), 1.)),
+        meshes.add(Extrusion::new(Capsule2d::default(), 1.)),
+        meshes.add(Extrusion::new(Annulus::default(), 1.)),
+        meshes.add(Extrusion::new(Circle::default(), 1.)),
+        meshes.add(Extrusion::new(Ellipse::default(), 1.)),
+        meshes.add(Extrusion::new(RegularPolygon::default(), 1.)),
+        meshes.add(Extrusion::new(Triangle2d::default(), 1.)),
+    ];
+
+    let num_shapes = shapes.len();
+
+    // Spawn the shapes. The meshes will be pickable by default.
+    for (i, shape) in shapes.into_iter().enumerate() {
+        commands
+            .spawn((
+                Mesh3d(shape),
+                MeshMaterial3d(white_matl.clone()),
+                Transform::from_xyz(
+                    -SHAPES_X_EXTENT / 2. + i as f32 / (num_shapes - 1) as f32 * SHAPES_X_EXTENT,
+                    2.0,
+                    Z_EXTENT / 2.,
+                )
+                .with_rotation(Quat::from_rotation_x(-PI / 4.)),
+                Shape,
+            ))
+            .observe(update_material_on::<Pointer<Over>>(hover_matl.clone()))
+            .observe(update_material_on::<Pointer<Out>>(white_matl.clone()))
+            .observe(update_material_on::<Pointer<Pressed>>(pressed_matl.clone()))
+            .observe(update_material_on::<Pointer<Released>>(hover_matl.clone()))
+            .observe(rotate_on_drag);
+    }
+
+    let num_extrusions = extrusions.len();
+
+    for (i, shape) in extrusions.into_iter().enumerate() {
+        commands
+            .spawn((
+                Mesh3d(shape),
+                MeshMaterial3d(white_matl.clone()),
+                Transform::from_xyz(
+                    -EXTRUSION_X_EXTENT / 2.
+                        + i as f32 / (num_extrusions - 1) as f32 * EXTRUSION_X_EXTENT,
+                    2.0,
+                    -Z_EXTENT / 2.,
+                )
+                .with_rotation(Quat::from_rotation_x(-PI / 4.)),
+                Shape,
+            ))
+            .observe(update_material_on::<Pointer<Over>>(hover_matl.clone()))
+            .observe(update_material_on::<Pointer<Out>>(white_matl.clone()))
+            .observe(update_material_on::<Pointer<Pressed>>(pressed_matl.clone()))
+            .observe(update_material_on::<Pointer<Released>>(hover_matl.clone()))
+            .observe(rotate_on_drag);
+    }
+
+    // Ground
+    commands.spawn((
+        Mesh3d(meshes.add(Plane3d::default().mesh().size(50.0, 50.0).subdivisions(10))),
+        MeshMaterial3d(ground_matl.clone()),
+        Pickable::IGNORE, // Disable picking for the ground plane.
+    ));
+
+    // Light
+    commands.spawn((
+        PointLight {
+            shadows_enabled: true,
+            intensity: 10_000_000.,
+            range: 100.0,
+            shadow_depth_bias: 0.2,
+            ..default()
+        },
+        Transform::from_xyz(8.0, 16.0, 8.0),
+    ));
+
+    // Camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 7., 14.0).looking_at(Vec3::new(0., 1., 0.), Vec3::Y),
+    ));
+
+    // Instructions
+    commands.spawn((
+        Text::new("Hover over the shapes to pick them\nDrag to rotate"),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+    ));
+}
+
+/// Returns an observer that updates the entity's material to the one specified.
+fn update_material_on<E>(
+    new_material: Handle<StandardMaterial>,
+) -> impl Fn(Trigger<E>, Query<&mut MeshMaterial3d<StandardMaterial>>) {
+    // An observer closure that captures `new_material`. We do this to avoid needing to write four
+    // versions of this observer, each triggered by a different event and with a different hardcoded
+    // material. Instead, the event type is a generic, and the material is passed in.
+    move |trigger, mut query| {
+        if let Ok(mut material) = query.get_mut(trigger.target()) {
+            material.0 = new_material.clone();
+        }
+    }
+}
+
+/// A system that draws hit indicators for every pointer.
+fn draw_mesh_intersections(pointers: Query<&PointerInteraction>, mut gizmos: Gizmos) {
+    for (point, normal) in pointers
+        .iter()
+        .filter_map(|interaction| interaction.get_nearest_hit())
+        .filter_map(|(_entity, hit)| hit.position.zip(hit.normal))
+    {
+        gizmos.sphere(point, 0.05, RED_500);
+        gizmos.arrow(point, point + normal.normalize() * 0.5, PINK_100);
+    }
+}
+
+/// A system that rotates all shapes.
+fn rotate(mut query: Query<&mut Transform, With<Shape>>, time: Res<Time>) {
+    for mut transform in &mut query {
+        transform.rotate_y(time.delta_secs() / 2.);
+    }
+}
+
+/// An observer to rotate an entity when it is dragged
+fn rotate_on_drag(drag: Trigger<Pointer<Drag>>, mut transforms: Query<&mut Transform>) {
+    let mut transform = transforms.get_mut(drag.target()).unwrap();
+    transform.rotate_y(drag.delta.x * 0.02);
+    transform.rotate_x(drag.delta.y * 0.02);
+}

vendor/bevy/examples/picking/simple_picking.rs

@@ -0,0 +1,87 @@
+//! A simple scene to demonstrate picking events for UI and mesh entities.
+
+use bevy::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins((DefaultPlugins, MeshPickingPlugin))
+        .add_systems(Startup, setup_scene)
+        .run();
+}
+
+fn setup_scene(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands
+        .spawn((
+            Text::new("Click Me to get a box\nDrag cubes to rotate"),
+            Node {
+                position_type: PositionType::Absolute,
+                top: Val::Percent(12.0),
+                left: Val::Percent(12.0),
+                ..default()
+            },
+        ))
+        .observe(on_click_spawn_cube)
+        .observe(
+            |out: Trigger<Pointer<Out>>, mut texts: Query<&mut TextColor>| {
+                let mut text_color = texts.get_mut(out.target()).unwrap();
+                text_color.0 = Color::WHITE;
+            },
+        )
+        .observe(
+            |over: Trigger<Pointer<Over>>, mut texts: Query<&mut TextColor>| {
+                let mut color = texts.get_mut(over.target()).unwrap();
+                color.0 = bevy::color::palettes::tailwind::CYAN_400.into();
+            },
+        );
+
+    // 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)),
+    ));
+
+    // Light
+    commands.spawn((
+        PointLight {
+            shadows_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),
+    ));
+}
+
+fn on_click_spawn_cube(
+    _click: Trigger<Pointer<Click>>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut num: Local<usize>,
+) {
+    commands
+        .spawn((
+            Mesh3d(meshes.add(Cuboid::new(0.5, 0.5, 0.5))),
+            MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
+            Transform::from_xyz(0.0, 0.25 + 0.55 * *num as f32, 0.0),
+        ))
+        // With the MeshPickingPlugin added, you can add pointer event observers to meshes:
+        .observe(on_drag_rotate);
+    *num += 1;
+}
+
+fn on_drag_rotate(drag: Trigger<Pointer<Drag>>, mut transforms: Query<&mut Transform>) {
+    if let Ok(mut transform) = transforms.get_mut(drag.target()) {
+        transform.rotate_y(drag.delta.x * 0.02);
+        transform.rotate_x(drag.delta.y * 0.02);
+    }
+}

vendor/bevy/examples/picking/sprite_picking.rs

@@ -0,0 +1,161 @@
+//! Demonstrates picking for sprites and sprite atlases. The picking backend only tests against the
+//! sprite bounds, so the sprite atlas can be picked by clicking on its transparent areas.
+
+use bevy::{prelude::*, sprite::Anchor};
+use std::fmt::Debug;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins.set(ImagePlugin::default_nearest()))
+        .add_systems(Startup, (setup, setup_atlas))
+        .add_systems(Update, (move_sprite, animate_sprite))
+        .run();
+}
+
+fn move_sprite(
+    time: Res<Time>,
+    mut sprite: Query<&mut Transform, (Without<Sprite>, With<Children>)>,
+) {
+    let t = time.elapsed_secs() * 0.1;
+    for mut transform in &mut sprite {
+        let new = Vec2 {
+            x: 50.0 * ops::sin(t),
+            y: 50.0 * ops::sin(t * 2.0),
+        };
+        transform.translation.x = new.x;
+        transform.translation.y = new.y;
+    }
+}
+
+/// Set up a scene that tests all sprite anchor types.
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.spawn(Camera2d);
+
+    let len = 128.0;
+    let sprite_size = Vec2::splat(len / 2.0);
+
+    commands
+        .spawn((Transform::default(), Visibility::default()))
+        .with_children(|commands| {
+            for (anchor_index, anchor) in [
+                Anchor::TopLeft,
+                Anchor::TopCenter,
+                Anchor::TopRight,
+                Anchor::CenterLeft,
+                Anchor::Center,
+                Anchor::CenterRight,
+                Anchor::BottomLeft,
+                Anchor::BottomCenter,
+                Anchor::BottomRight,
+                Anchor::Custom(Vec2::new(0.5, 0.5)),
+            ]
+            .iter()
+            .enumerate()
+            {
+                let i = (anchor_index % 3) as f32;
+                let j = (anchor_index / 3) as f32;
+
+                // Spawn black square behind sprite to show anchor point
+                commands
+                    .spawn((
+                        Sprite::from_color(Color::BLACK, sprite_size),
+                        Transform::from_xyz(i * len - len, j * len - len, -1.0),
+                        Pickable::default(),
+                    ))
+                    .observe(recolor_on::<Pointer<Over>>(Color::srgb(0.0, 1.0, 1.0)))
+                    .observe(recolor_on::<Pointer<Out>>(Color::BLACK))
+                    .observe(recolor_on::<Pointer<Pressed>>(Color::srgb(1.0, 1.0, 0.0)))
+                    .observe(recolor_on::<Pointer<Released>>(Color::srgb(0.0, 1.0, 1.0)));
+
+                commands
+                    .spawn((
+                        Sprite {
+                            image: asset_server.load("branding/bevy_bird_dark.png"),
+                            custom_size: Some(sprite_size),
+                            color: Color::srgb(1.0, 0.0, 0.0),
+                            anchor: anchor.to_owned(),
+                            ..default()
+                        },
+                        // 3x3 grid of anchor examples by changing transform
+                        Transform::from_xyz(i * len - len, j * len - len, 0.0)
+                            .with_scale(Vec3::splat(1.0 + (i - 1.0) * 0.2))
+                            .with_rotation(Quat::from_rotation_z((j - 1.0) * 0.2)),
+                        Pickable::default(),
+                    ))
+                    .observe(recolor_on::<Pointer<Over>>(Color::srgb(0.0, 1.0, 0.0)))
+                    .observe(recolor_on::<Pointer<Out>>(Color::srgb(1.0, 0.0, 0.0)))
+                    .observe(recolor_on::<Pointer<Pressed>>(Color::srgb(0.0, 0.0, 1.0)))
+                    .observe(recolor_on::<Pointer<Released>>(Color::srgb(0.0, 1.0, 0.0)));
+            }
+        });
+}
+
+#[derive(Component)]
+struct AnimationIndices {
+    first: usize,
+    last: usize,
+}
+
+#[derive(Component, Deref, DerefMut)]
+struct AnimationTimer(Timer);
+
+fn animate_sprite(
+    time: Res<Time>,
+    mut query: Query<(&AnimationIndices, &mut AnimationTimer, &mut Sprite)>,
+) {
+    for (indices, mut timer, mut sprite) in &mut query {
+        let Some(texture_atlas) = &mut sprite.texture_atlas else {
+            continue;
+        };
+
+        timer.tick(time.delta());
+
+        if timer.just_finished() {
+            texture_atlas.index = if texture_atlas.index == indices.last {
+                indices.first
+            } else {
+                texture_atlas.index + 1
+            };
+        }
+    }
+}
+
+fn setup_atlas(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut texture_atlas_layouts: ResMut<Assets<TextureAtlasLayout>>,
+) {
+    let texture_handle = asset_server.load("textures/rpg/chars/gabe/gabe-idle-run.png");
+    let layout = TextureAtlasLayout::from_grid(UVec2::new(24, 24), 7, 1, None, None);
+    let texture_atlas_layout_handle = texture_atlas_layouts.add(layout);
+    // Use only the subset of sprites in the sheet that make up the run animation
+    let animation_indices = AnimationIndices { first: 1, last: 6 };
+    commands
+        .spawn((
+            Sprite::from_atlas_image(
+                texture_handle,
+                TextureAtlas {
+                    layout: texture_atlas_layout_handle,
+                    index: animation_indices.first,
+                },
+            ),
+            Transform::from_xyz(300.0, 0.0, 0.0).with_scale(Vec3::splat(6.0)),
+            animation_indices,
+            AnimationTimer(Timer::from_seconds(0.1, TimerMode::Repeating)),
+            Pickable::default(),
+        ))
+        .observe(recolor_on::<Pointer<Over>>(Color::srgb(0.0, 1.0, 1.0)))
+        .observe(recolor_on::<Pointer<Out>>(Color::srgb(1.0, 1.0, 1.0)))
+        .observe(recolor_on::<Pointer<Pressed>>(Color::srgb(1.0, 1.0, 0.0)))
+        .observe(recolor_on::<Pointer<Released>>(Color::srgb(0.0, 1.0, 1.0)));
+}
+
+// An observer listener that changes the target entity's color.
+fn recolor_on<E: Debug + Clone + Reflect>(color: Color) -> impl Fn(Trigger<E>, Query<&mut Sprite>) {
+    move |ev, mut sprites| {
+        let Ok(mut sprite) = sprites.get_mut(ev.target()) else {
+            return;
+        };
+        sprite.color = color;
+    }
+}