Merge branch 'bevyengine:main' into main

Cargo.toml

@@ -2340,6 +2340,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/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/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)
  }
 }