Merge branch 'main' into example-game_menu-DRY

.github/workflows/validation-jobs.yml

@@ -286,3 +286,31 @@ jobs:
         run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
       - name: Run cargo udeps
         run: cargo udeps
+
+  check-example-showcase-patches-still-work:
+    if: ${{ github.event_name == 'merge_group' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-check-showcase-patches-${{ hashFiles('**/Cargo.toml') }}
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Installs cargo-udeps
+        run: cargo install --force cargo-udeps
+      - name: Install alsa and udev
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - name: Apply patches
+        run: |
+          for patch in tools/example-showcase/*.patch; do
+            git apply --ignore-whitespace $patch
+          done
+      - name: Build with patches
+        run: cargo build

Cargo.toml

@@ -1013,6 +1013,17 @@ description = "Create and play an animation defined by code that operates on the
 category = "Animation"
 wasm = true
 
+[[example]]
+name = "color_animation"
+path = "examples/animation/color_animation.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.color_animation]
+name = "Color animation"
+description = "Demonstrates how to animate colors using mixing and splines in different color spaces"
+category = "Animation"
+wasm = true
+
 [[example]]
 name = "cubic_curve"
 path = "examples/animation/cubic_curve.rs"
@@ -2284,6 +2295,17 @@ description = "Illustrates how to (constantly) rotate an object around an axis"
 category = "Transforms"
 wasm = true
 
+[[example]]
+name = "align"
+path = "examples/transforms/align.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.align]
+name = "Alignment"
+description = "A demonstration of Transform's axis-alignment feature"
+category = "Transforms"
+wasm = true
+
 [[example]]
 name = "scale"
 path = "examples/transforms/scale.rs"
@@ -2329,6 +2351,17 @@ description = "Demonstrates how to create a node with a border"
 category = "UI (User Interface)"
 wasm = true
 
+[[example]]
+name = "rounded_borders"
+path = "examples/ui/rounded_borders.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.rounded_borders]
+name = "Rounded Borders"
+description = "Demonstrates how to create a node with a rounded border"
+category = "UI (User Interface)"
+wasm = true
+
 [[example]]
 name = "button"
 path = "examples/ui/button.rs"

crates/bevy_animation/Cargo.toml

@@ -12,6 +12,7 @@ keywords = ["bevy"]
 # bevy
 bevy_app = { path = "../bevy_app", version = "0.14.0-dev" }
 bevy_asset = { path = "../bevy_asset", version = "0.14.0-dev" }
+bevy_color = { path = "../bevy_color", version = "0.14.0-dev" }
 bevy_core = { path = "../bevy_core", version = "0.14.0-dev" }
 bevy_derive = { path = "../bevy_derive", version = "0.14.0-dev" }
 bevy_log = { path = "../bevy_log", version = "0.14.0-dev" }
@@ -28,7 +29,7 @@ bevy_transform = { path = "../bevy_transform", version = "0.14.0-dev" }
 bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.14.0-dev" }
 
 # other
-fixedbitset = "0.4"
+fixedbitset = "0.5"
 petgraph = { version = "0.6", features = ["serde-1"] }
 ron = "0.8"
 serde = "1"

crates/bevy_animation/src/animatable.rs

@@ -1,4 +1,5 @@
 use crate::util;
+use bevy_color::{ClampColor, Laba, LinearRgba, Oklaba, Xyza};
 use bevy_ecs::world::World;
 use bevy_math::*;
 use bevy_reflect::Reflect;
@@ -57,6 +58,31 @@ macro_rules! impl_float_animatable {
     };
 }
 
+macro_rules! impl_color_animatable {
+    ($ty: ident) => {
+        impl Animatable for $ty {
+            #[inline]
+            fn interpolate(a: &Self, b: &Self, t: f32) -> Self {
+                let value = *a * (1. - t) + *b * t;
+                value.clamped()
+            }
+
+            #[inline]
+            fn blend(inputs: impl Iterator<Item = BlendInput<Self>>) -> Self {
+                let mut value = Default::default();
+                for input in inputs {
+                    if input.additive {
+                        value += input.weight * input.value;
+                    } else {
+                        value = Self::interpolate(&value, &input.value, input.weight);
+                    }
+                }
+                value.clamped()
+            }
+        }
+    };
+}
+
 impl_float_animatable!(f32, f32);
 impl_float_animatable!(Vec2, f32);
 impl_float_animatable!(Vec3A, f32);
@@ -67,6 +93,11 @@ impl_float_animatable!(DVec2, f64);
 impl_float_animatable!(DVec3, f64);
 impl_float_animatable!(DVec4, f64);
 
+impl_color_animatable!(LinearRgba);
+impl_color_animatable!(Laba);
+impl_color_animatable!(Oklaba);
+impl_color_animatable!(Xyza);
+
 // Vec3 is special cased to use Vec3A internally for blending
 impl Animatable for Vec3 {
     #[inline]

crates/bevy_animation/src/graph.rs

@@ -6,7 +6,6 @@ use std::ops::{Index, IndexMut};
 use bevy_asset::io::Reader;
 use bevy_asset::{Asset, AssetId, AssetLoader, AssetPath, AsyncReadExt as _, Handle, LoadContext};
 use bevy_reflect::{Reflect, ReflectSerialize};
-use bevy_utils::BoxedFuture;
 use petgraph::graph::{DiGraph, NodeIndex};
 use ron::de::SpannedError;
 use serde::{Deserialize, Serialize};
@@ -336,40 +335,37 @@ impl AssetLoader for AnimationGraphAssetLoader {
 
     type Error = AnimationGraphLoadError;
 
-    fn load<'a>(
+    async fn load<'a>(
         &'a self,
-        reader: &'a mut Reader,
+        reader: &'a mut Reader<'_>,
         _: &'a Self::Settings,
-        load_context: &'a mut LoadContext,
-    ) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
-        Box::pin(async move {
-            let mut bytes = Vec::new();
-            reader.read_to_end(&mut bytes).await?;
-
-            // Deserialize a `SerializedAnimationGraph` directly, so that we can
-            // get the list of the animation clips it refers to and load them.
-            let mut deserializer = ron::de::Deserializer::from_bytes(&bytes)?;
-            let serialized_animation_graph =
-                SerializedAnimationGraph::deserialize(&mut deserializer)
-                    .map_err(|err| deserializer.span_error(err))?;
-
-            // Load all `AssetPath`s to convert from a
-            // `SerializedAnimationGraph` to a real `AnimationGraph`.
-            Ok(AnimationGraph {
-                graph: serialized_animation_graph.graph.map(
-                    |_, serialized_node| AnimationGraphNode {
-                        clip: serialized_node.clip.as_ref().map(|clip| match clip {
-                            SerializedAnimationClip::AssetId(asset_id) => Handle::Weak(*asset_id),
-                            SerializedAnimationClip::AssetPath(asset_path) => {
-                                load_context.load(asset_path)
-                            }
-                        }),
-                        weight: serialized_node.weight,
-                    },
-                    |_, _| (),
-                ),
-                root: serialized_animation_graph.root,
-            })
+        load_context: &'a mut LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let mut bytes = Vec::new();
+        reader.read_to_end(&mut bytes).await?;
+
+        // Deserialize a `SerializedAnimationGraph` directly, so that we can
+        // get the list of the animation clips it refers to and load them.
+        let mut deserializer = ron::de::Deserializer::from_bytes(&bytes)?;
+        let serialized_animation_graph = SerializedAnimationGraph::deserialize(&mut deserializer)
+            .map_err(|err| deserializer.span_error(err))?;
+
+        // Load all `AssetPath`s to convert from a
+        // `SerializedAnimationGraph` to a real `AnimationGraph`.
+        Ok(AnimationGraph {
+            graph: serialized_animation_graph.graph.map(
+                |_, serialized_node| AnimationGraphNode {
+                    clip: serialized_node.clip.as_ref().map(|clip| match clip {
+                        SerializedAnimationClip::AssetId(asset_id) => Handle::Weak(*asset_id),
+                        SerializedAnimationClip::AssetPath(asset_path) => {
+                            load_context.load(asset_path)
+                        }
+                    }),
+                    weight: serialized_node.weight,
+                },
+                |_, _| (),
+            ),
+            root: serialized_animation_graph.root,
         })
     }
 

crates/bevy_asset/src/assets.rs

@@ -549,23 +549,24 @@ impl<A: Asset> Assets<A> {
         while let Ok(drop_event) = assets.handle_provider.drop_receiver.try_recv() {
             let id = drop_event.id.typed();
 
-            assets.queued_events.push(AssetEvent::Unused { id });
-
-            let mut remove_asset = true;
-
             if drop_event.asset_server_managed {
-                let untyped_id = drop_event.id.untyped(TypeId::of::<A>());
+                let untyped_id = id.untyped();
                 if let Some(info) = infos.get(untyped_id) {
                     if let LoadState::Loading | LoadState::NotLoaded = info.load_state {
                         not_ready.push(drop_event);
                         continue;
                     }
                 }
-                remove_asset = infos.process_handle_drop(untyped_id);
-            }
-            if remove_asset {
-                assets.remove_dropped(id);
+
+                // the process_handle_drop call checks whether new handles have been created since the drop event was fired, before removing the asset
+                if !infos.process_handle_drop(untyped_id) {
+                    // a new handle has been created, or the asset doesn't exist
+                    continue;
+                }
             }
+
+            assets.queued_events.push(AssetEvent::Unused { id });
+            assets.remove_dropped(id);
         }
 
         // TODO: this is _extremely_ inefficient find a better fix

crates/bevy_asset/src/io/android.rs

@@ -2,7 +2,6 @@ use crate::io::{
     get_meta_path, AssetReader, AssetReaderError, EmptyPathStream, PathStream, Reader, VecReader,
 };
 use bevy_utils::tracing::error;
-use bevy_utils::BoxedFuture;
 use std::{ffi::CString, path::Path};
 
 /// [`AssetReader`] implementation for Android devices, built on top of Android's [`AssetManager`].
@@ -17,57 +16,47 @@ use std::{ffi::CString, path::Path};
 pub struct AndroidAssetReader;
 
 impl AssetReader for AndroidAssetReader {
-    fn read<'a>(
-        &'a self,
-        path: &'a Path,
-    ) -> BoxedFuture<'a, Result<Box<Reader<'a>>, AssetReaderError>> {
-        Box::pin(async move {
-            let asset_manager = bevy_winit::ANDROID_APP
-                .get()
-                .expect("Bevy must be setup with the #[bevy_main] macro on Android")
-                .asset_manager();
-            let mut opened_asset = asset_manager
-                .open(&CString::new(path.to_str().unwrap()).unwrap())
-                .ok_or(AssetReaderError::NotFound(path.to_path_buf()))?;
-            let bytes = opened_asset.buffer()?;
-            let reader: Box<Reader> = Box::new(VecReader::new(bytes.to_vec()));
-            Ok(reader)
-        })
+    async fn read<'a>(&'a self, path: &'a Path) -> Result<Box<Reader<'a>>, AssetReaderError> {
+        let asset_manager = bevy_winit::ANDROID_APP
+            .get()
+            .expect("Bevy must be setup with the #[bevy_main] macro on Android")
+            .asset_manager();
+        let mut opened_asset = asset_manager
+            .open(&CString::new(path.to_str().unwrap()).unwrap())
+            .ok_or(AssetReaderError::NotFound(path.to_path_buf()))?;
+        let bytes = opened_asset.buffer()?;
+        let reader: Box<Reader> = Box::new(VecReader::new(bytes.to_vec()));
+        Ok(reader)
     }
 
-    fn read_meta<'a>(
-        &'a self,
-        path: &'a Path,
-    ) -> BoxedFuture<'a, Result<Box<Reader<'a>>, AssetReaderError>> {
-        Box::pin(async move {
-            let meta_path = get_meta_path(path);
-            let asset_manager = bevy_winit::ANDROID_APP
-                .get()
-                .expect("Bevy must be setup with the #[bevy_main] macro on Android")
-                .asset_manager();
-            let mut opened_asset = asset_manager
-                .open(&CString::new(meta_path.to_str().unwrap()).unwrap())
-                .ok_or(AssetReaderError::NotFound(meta_path))?;
-            let bytes = opened_asset.buffer()?;
-            let reader: Box<Reader> = Box::new(VecReader::new(bytes.to_vec()));
-            Ok(reader)
-        })
+    async fn read_meta<'a>(&'a self, path: &'a Path) -> Result<Box<Reader<'a>>, AssetReaderError> {
+        let meta_path = get_meta_path(path);
+        let asset_manager = bevy_winit::ANDROID_APP
+            .get()
+            .expect("Bevy must be setup with the #[bevy_main] macro on Android")
+            .asset_manager();
+        let mut opened_asset = asset_manager
+            .open(&CString::new(meta_path.to_str().unwrap()).unwrap())
+            .ok_or(AssetReaderError::NotFound(meta_path))?;
+        let bytes = opened_asset.buffer()?;
+        let reader: Box<Reader> = Box::new(VecReader::new(bytes.to_vec()));
+        Ok(reader)
     }
 
-    fn read_directory<'a>(
+    async fn read_directory<'a>(
         &'a self,
         _path: &'a Path,
-    ) -> BoxedFuture<'a, Result<Box<PathStream>, AssetReaderError>> {
+    ) -> Result<Box<PathStream>, AssetReaderError> {
         let stream: Box<PathStream> = Box::new(EmptyPathStream);
         error!("Reading directories is not supported with the AndroidAssetReader");
-        Box::pin(async move { Ok(stream) })
+        Ok(stream)
     }
 
-    fn is_directory<'a>(
+    async fn is_directory<'a>(
         &'a self,
         _path: &'a Path,
-    ) -> BoxedFuture<'a, std::result::Result<bool, AssetReaderError>> {
+    ) -> std::result::Result<bool, AssetReaderError> {
         error!("Reading directories is not supported with the AndroidAssetReader");
-        Box::pin(async move { Ok(false) })
+        Ok(false)
     }
 }