Vendor dependencies for 0.3.0 release

vendor/bevy/examples/transforms/3d_rotation.rs

@@ -0,0 +1,55 @@
+//! Illustrates how to rotate an object around an axis.
+
+use bevy::prelude::*;
+
+use std::f32::consts::TAU;
+
+// Define a component to designate a rotation speed to an entity.
+#[derive(Component)]
+struct Rotatable {
+    speed: f32,
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, rotate_cube)
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Spawn a cube to rotate.
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::WHITE)),
+        Transform::from_translation(Vec3::ZERO),
+        Rotatable { speed: 0.3 },
+    ));
+
+    // Spawn a camera looking at the entities to show what's happening in this example.
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 10.0, 20.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    // Add a light source so we can see clearly.
+    commands.spawn((
+        DirectionalLight::default(),
+        Transform::from_xyz(3.0, 3.0, 3.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+// This system will rotate any entity in the scene with a Rotatable component around its y-axis.
+fn rotate_cube(mut cubes: Query<(&mut Transform, &Rotatable)>, timer: Res<Time>) {
+    for (mut transform, cube) in &mut cubes {
+        // The speed is first multiplied by TAU which is a full rotation (360deg) in radians,
+        // and then multiplied by delta_secs which is the time that passed last frame.
+        // In other words. Speed is equal to the amount of rotations per second.
+        transform.rotate_y(cube.speed * TAU * timer.delta_secs());
+    }
+}

vendor/bevy/examples/transforms/align.rs

@@ -0,0 +1,227 @@
+//! This example shows how to align the orientations of objects in 3D space along two axes using the `Transform::align` API.
+
+use bevy::{
+    color::palettes::basic::{GRAY, RED, WHITE},
+    input::mouse::{AccumulatedMouseMotion, MouseButtonInput},
+    math::StableInterpolate,
+    prelude::*,
+};
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, (draw_ship_axes, draw_random_axes))
+        .add_systems(Update, (handle_keypress, handle_mouse, rotate_ship).chain())
+        .run();
+}
+
+/// This struct stores metadata for a single rotational move of the ship
+#[derive(Component, Default)]
+struct Ship {
+    /// The target transform of the ship move, the endpoint of interpolation
+    target_transform: Transform,
+
+    /// Whether the ship is currently in motion; allows motion to be paused
+    in_motion: bool,
+}
+
+#[derive(Component)]
+struct RandomAxes(Dir3, Dir3);
+
+#[derive(Component)]
+struct Instructions;
+
+#[derive(Resource)]
+struct MousePressed(bool);
+
+#[derive(Resource)]
+struct SeededRng(ChaCha8Rng);
+
+// Setup
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    asset_server: Res<AssetServer>,
+) {
+    // We're seeding the PRNG here to make this example deterministic for testing purposes.
+    // This isn't strictly required in practical use unless you need your app to be deterministic.
+    let mut seeded_rng = ChaCha8Rng::seed_from_u64(19878367467712);
+
+    // A camera looking at the origin
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(3., 2.5, 4.).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    // A plane that we can sit on top of
+    commands.spawn((
+        Mesh3d(meshes.add(Plane3d::default().mesh().size(100.0, 100.0))),
+        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
+        Transform::from_xyz(0., -2., 0.),
+    ));
+
+    // A light source
+    commands.spawn((
+        PointLight {
+            shadows_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(4.0, 7.0, -4.0),
+    ));
+
+    // Initialize random axes
+    let first = seeded_rng.r#gen();
+    let second = seeded_rng.r#gen();
+    commands.spawn(RandomAxes(first, second));
+
+    // Finally, our ship that is going to rotate
+    commands.spawn((
+        SceneRoot(
+            asset_server
+                .load(GltfAssetLabel::Scene(0).from_asset("models/ship/craft_speederD.gltf")),
+        ),
+        Ship {
+            target_transform: random_axes_target_alignment(&RandomAxes(first, second)),
+            ..default()
+        },
+    ));
+
+    // Instructions for the example
+    commands.spawn((
+        Text::new(
+            "The bright red axis is the primary alignment axis, and it will always be\n\
+            made to coincide with the primary target direction (white) exactly.\n\
+            The fainter red axis is the secondary alignment axis, and it is made to\n\
+            line up with the secondary target direction (gray) as closely as possible.\n\
+            Press 'R' to generate random target directions.\n\
+            Press 'T' to align the ship to those directions.\n\
+            Click and drag the mouse to rotate the camera.\n\
+            Press 'H' to hide/show these instructions.",
+        ),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+        Instructions,
+    ));
+
+    commands.insert_resource(MousePressed(false));
+    commands.insert_resource(SeededRng(seeded_rng));
+}
+
+// Update systems
+
+// Draw the main and secondary axes on the rotating ship
+fn draw_ship_axes(mut gizmos: Gizmos, ship_transform: Single<&Transform, With<Ship>>) {
+    // Local Z-axis arrow, negative direction
+    let z_ends = arrow_ends(*ship_transform, Vec3::NEG_Z, 1.5);
+    gizmos.arrow(z_ends.0, z_ends.1, RED);
+
+    // local X-axis arrow
+    let x_ends = arrow_ends(*ship_transform, Vec3::X, 1.5);
+    gizmos.arrow(x_ends.0, x_ends.1, Color::srgb(0.65, 0., 0.));
+}
+
+// Draw the randomly generated axes
+fn draw_random_axes(mut gizmos: Gizmos, random_axes: Single<&RandomAxes>) {
+    let RandomAxes(v1, v2) = *random_axes;
+    gizmos.arrow(Vec3::ZERO, 1.5 * *v1, WHITE);
+    gizmos.arrow(Vec3::ZERO, 1.5 * *v2, GRAY);
+}
+
+// Actually update the ship's transform according to its initial source and target
+fn rotate_ship(ship: Single<(&mut Ship, &mut Transform)>, time: Res<Time>) {
+    let (mut ship, mut ship_transform) = ship.into_inner();
+
+    if !ship.in_motion {
+        return;
+    }
+
+    let target_rotation = ship.target_transform.rotation;
+
+    ship_transform
+        .rotation
+        .smooth_nudge(&target_rotation, 3.0, time.delta_secs());
+
+    if ship_transform.rotation.angle_between(target_rotation) <= f32::EPSILON {
+        ship.in_motion = false;
+    }
+}
+
+// Handle user inputs from the keyboard for dynamically altering the scenario
+fn handle_keypress(
+    mut ship: Single<&mut Ship>,
+    mut random_axes: Single<&mut RandomAxes>,
+    mut instructions_viz: Single<&mut Visibility, With<Instructions>>,
+    keyboard: Res<ButtonInput<KeyCode>>,
+    mut seeded_rng: ResMut<SeededRng>,
+) {
+    if keyboard.just_pressed(KeyCode::KeyR) {
+        // Randomize the target axes
+        let first = seeded_rng.0.r#gen();
+        let second = seeded_rng.0.r#gen();
+        **random_axes = RandomAxes(first, second);
+
+        // Stop the ship and set it up to transform from its present orientation to the new one
+        ship.in_motion = false;
+        ship.target_transform = random_axes_target_alignment(&random_axes);
+    }
+
+    if keyboard.just_pressed(KeyCode::KeyT) {
+        ship.in_motion ^= true;
+    }
+
+    if keyboard.just_pressed(KeyCode::KeyH) {
+        if *instructions_viz.as_ref() == Visibility::Hidden {
+            **instructions_viz = Visibility::Visible;
+        } else {
+            **instructions_viz = Visibility::Hidden;
+        }
+    }
+}
+
+// Handle user mouse input for panning the camera around
+fn handle_mouse(
+    accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
+    mut button_events: EventReader<MouseButtonInput>,
+    mut camera_transform: Single<&mut Transform, With<Camera>>,
+    mut mouse_pressed: ResMut<MousePressed>,
+) {
+    // Store left-pressed state in the MousePressed resource
+    for button_event in button_events.read() {
+        if button_event.button != MouseButton::Left {
+            continue;
+        }
+        *mouse_pressed = MousePressed(button_event.state.is_pressed());
+    }
+
+    // If the mouse is not pressed, just ignore motion events
+    if !mouse_pressed.0 {
+        return;
+    }
+    if accumulated_mouse_motion.delta != Vec2::ZERO {
+        let displacement = accumulated_mouse_motion.delta.x;
+        camera_transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(-displacement / 75.));
+    }
+}
+
+// Helper functions (i.e. non-system functions)
+
+fn arrow_ends(transform: &Transform, axis: Vec3, length: f32) -> (Vec3, Vec3) {
+    let local_vector = length * (transform.rotation * axis);
+    (transform.translation, transform.translation + local_vector)
+}
+
+// This is where `Transform::align` is actually used!
+// Note that the choice of `Vec3::X` and `Vec3::Y` here matches the use of those in `draw_ship_axes`.
+fn random_axes_target_alignment(random_axes: &RandomAxes) -> Transform {
+    let RandomAxes(first, second) = random_axes;
+    Transform::IDENTITY.aligned_by(Vec3::NEG_Z, *first, Vec3::X, *second)
+}

vendor/bevy/examples/transforms/scale.rs

@@ -0,0 +1,95 @@
+//! Illustrates how to scale an object in each direction.
+
+use std::f32::consts::PI;
+
+use bevy::prelude::*;
+
+// Define a component to keep information for the scaled object.
+#[derive(Component)]
+struct Scaling {
+    scale_direction: Vec3,
+    scale_speed: f32,
+    max_element_size: f32,
+    min_element_size: f32,
+}
+
+// Implement a simple initialization.
+impl Scaling {
+    fn new() -> Self {
+        Scaling {
+            scale_direction: Vec3::X,
+            scale_speed: 2.0,
+            max_element_size: 5.0,
+            min_element_size: 1.0,
+        }
+    }
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, (change_scale_direction, scale_cube))
+        .run();
+}
+
+// Startup system to setup the scene and spawn all relevant entities.
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Spawn a cube to scale.
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::WHITE)),
+        Transform::from_rotation(Quat::from_rotation_y(PI / 4.0)),
+        Scaling::new(),
+    ));
+
+    // Spawn a camera looking at the entities to show what's happening in this example.
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 10.0, 20.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    // Add a light source for better 3d visibility.
+    commands.spawn((
+        DirectionalLight::default(),
+        Transform::from_xyz(3.0, 3.0, 3.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+// This system will check if a scaled entity went above or below the entities scaling bounds
+// and change the direction of the scaling vector.
+fn change_scale_direction(mut cubes: Query<(&mut Transform, &mut Scaling)>) {
+    for (mut transform, mut cube) in &mut cubes {
+        // If an entity scaled beyond the maximum of its size in any dimension
+        // the scaling vector is flipped so the scaling is gradually reverted.
+        // Additionally, to ensure the condition does not trigger again we floor the elements to
+        // their next full value, which should be max_element_size at max.
+        if transform.scale.max_element() > cube.max_element_size {
+            cube.scale_direction *= -1.0;
+            transform.scale = transform.scale.floor();
+        }
+        // If an entity scaled beyond the minimum of its size in any dimension
+        // the scaling vector is also flipped.
+        // Additionally the Values are ceiled to be min_element_size at least
+        // and the scale direction is flipped.
+        // This way the entity will change the dimension in which it is scaled any time it
+        // reaches its min_element_size.
+        if transform.scale.min_element() < cube.min_element_size {
+            cube.scale_direction *= -1.0;
+            transform.scale = transform.scale.ceil();
+            cube.scale_direction = cube.scale_direction.zxy();
+        }
+    }
+}
+
+// This system will scale any entity with assigned Scaling in each direction
+// by cycling through the directions to scale.
+fn scale_cube(mut cubes: Query<(&mut Transform, &Scaling)>, timer: Res<Time>) {
+    for (mut transform, cube) in &mut cubes {
+        transform.scale += cube.scale_direction * cube.scale_speed * timer.delta_secs();
+    }
+}

vendor/bevy/examples/transforms/transform.rs

@@ -0,0 +1,151 @@
+//! Shows multiple transformations of objects.
+
+use std::f32::consts::PI;
+
+use bevy::{color::palettes::basic::YELLOW, prelude::*};
+
+// A struct for additional data of for a moving cube.
+#[derive(Component)]
+struct CubeState {
+    start_pos: Vec3,
+    move_speed: f32,
+    turn_speed: f32,
+}
+
+// A struct adding information to a scalable entity,
+// that will be stationary at the center of the scene.
+#[derive(Component)]
+struct Center {
+    max_size: f32,
+    min_size: f32,
+    scale_factor: f32,
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(
+            Update,
+            (
+                move_cube,
+                rotate_cube,
+                scale_down_sphere_proportional_to_cube_travel_distance,
+            )
+                .chain(),
+        )
+        .run();
+}
+
+// Startup system to setup the scene and spawn all relevant entities.
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Add an object (sphere) for visualizing scaling.
+    commands.spawn((
+        Mesh3d(meshes.add(Sphere::new(3.0).mesh().ico(32).unwrap())),
+        MeshMaterial3d(materials.add(Color::from(YELLOW))),
+        Transform::from_translation(Vec3::ZERO),
+        Center {
+            max_size: 1.0,
+            min_size: 0.1,
+            scale_factor: 0.05,
+        },
+    ));
+
+    // Add the cube to visualize rotation and translation.
+    // This cube will circle around the center_sphere
+    // by changing its rotation each frame and moving forward.
+    // Define a start transform for an orbiting cube, that's away from our central object (sphere)
+    // and rotate it so it will be able to move around the sphere and not towards it.
+    let cube_spawn =
+        Transform::from_translation(Vec3::Z * -10.0).with_rotation(Quat::from_rotation_y(PI / 2.));
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::WHITE)),
+        cube_spawn,
+        CubeState {
+            start_pos: cube_spawn.translation,
+            move_speed: 2.0,
+            turn_speed: 0.2,
+        },
+    ));
+
+    // Spawn a camera looking at the entities to show what's happening in this example.
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 10.0, 20.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+
+    // Add a light source for better 3d visibility.
+    commands.spawn((
+        DirectionalLight::default(),
+        Transform::from_xyz(3.0, 3.0, 3.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+// This system will move the cube forward.
+fn move_cube(mut cubes: Query<(&mut Transform, &mut CubeState)>, timer: Res<Time>) {
+    for (mut transform, cube) in &mut cubes {
+        // Move the cube forward smoothly at a given move_speed.
+        let forward = transform.forward();
+        transform.translation += forward * cube.move_speed * timer.delta_secs();
+    }
+}
+
+// This system will rotate the cube slightly towards the center_sphere.
+// Due to the forward movement the resulting movement
+// will be a circular motion around the center_sphere.
+fn rotate_cube(
+    mut cubes: Query<(&mut Transform, &mut CubeState), Without<Center>>,
+    center_spheres: Query<&Transform, With<Center>>,
+    timer: Res<Time>,
+) {
+    // Calculate the point to circle around. (The position of the center_sphere)
+    let mut center: Vec3 = Vec3::ZERO;
+    for sphere in &center_spheres {
+        center += sphere.translation;
+    }
+    // Update the rotation of the cube(s).
+    for (mut transform, cube) in &mut cubes {
+        // Calculate the rotation of the cube if it would be looking at the sphere in the center.
+        let look_at_sphere = transform.looking_at(center, *transform.local_y());
+        // Interpolate between the current rotation and the fully turned rotation
+        // when looking a the sphere,  with a given turn speed to get a smooth motion.
+        // With higher speed the curvature of the orbit would be smaller.
+        let incremental_turn_weight = cube.turn_speed * timer.delta_secs();
+        let old_rotation = transform.rotation;
+        transform.rotation = old_rotation.lerp(look_at_sphere.rotation, incremental_turn_weight);
+    }
+}
+
+// This system will scale down the sphere in the center of the scene
+// according to the traveling distance of the orbiting cube(s) from their start position(s).
+fn scale_down_sphere_proportional_to_cube_travel_distance(
+    cubes: Query<(&Transform, &CubeState), Without<Center>>,
+    mut centers: Query<(&mut Transform, &Center)>,
+) {
+    // First we need to calculate the length of between
+    // the current position of the orbiting cube and the spawn position.
+    let mut distances = 0.0;
+    for (cube_transform, cube_state) in &cubes {
+        distances += (cube_state.start_pos - cube_transform.translation).length();
+    }
+    // Now we use the calculated value to scale the sphere in the center accordingly.
+    for (mut transform, center) in &mut centers {
+        // Calculate the new size from the calculated distances and the centers scale_factor.
+        // Since we want to have the sphere at its max_size at the cubes spawn location we start by
+        // using the max_size as start value and subtract the distances scaled by a scaling factor.
+        let mut new_size: f32 = center.max_size - center.scale_factor * distances;
+
+        // The new size should also not be smaller than the centers min_size.
+        // Therefore the max value out of (new_size, center.min_size) is used.
+        new_size = new_size.max(center.min_size);
+
+        // Now scale the sphere uniformly in all directions using new_size.
+        // Here Vec3:splat is used to create a vector with new_size in x, y and z direction.
+        transform.scale = Vec3::splat(new_size);
+    }
+}

vendor/bevy/examples/transforms/translation.rs

@@ -0,0 +1,71 @@
+//! Illustrates how to move an object along an axis.
+
+use bevy::prelude::*;
+
+// Define a struct to keep some information about our entity.
+// Here it's an arbitrary movement speed, the spawn location, and a maximum distance from it.
+#[derive(Component)]
+struct Movable {
+    spawn: Vec3,
+    max_distance: f32,
+    speed: f32,
+}
+
+// Implement a utility function for easier Movable struct creation.
+impl Movable {
+    fn new(spawn: Vec3) -> Self {
+        Movable {
+            spawn,
+            max_distance: 5.0,
+            speed: 2.0,
+        }
+    }
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(Update, move_cube)
+        .run();
+}
+
+// Startup system to setup the scene and spawn all relevant entities.
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Add a cube to visualize translation.
+    let entity_spawn = Vec3::ZERO;
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::default())),
+        MeshMaterial3d(materials.add(Color::WHITE)),
+        Transform::from_translation(entity_spawn),
+        Movable::new(entity_spawn),
+    ));
+
+    // Spawn a camera looking at the entities to show what's happening in this example.
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 10.0, 20.0).looking_at(entity_spawn, Vec3::Y),
+    ));
+
+    // Add a light source for better 3d visibility.
+    commands.spawn((
+        DirectionalLight::default(),
+        Transform::from_xyz(3.0, 3.0, 3.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+// This system will move all Movable entities with a Transform
+fn move_cube(mut cubes: Query<(&mut Transform, &mut Movable)>, timer: Res<Time>) {
+    for (mut transform, mut cube) in &mut cubes {
+        // Check if the entity moved too far from its spawn, if so invert the moving direction.
+        if (cube.spawn - transform.translation).length() > cube.max_distance {
+            cube.speed *= -1.0;
+        }
+        let direction = transform.local_x();
+        transform.translation += direction * cube.speed * timer.delta_secs();
+    }
+}