Merge branch 'main' into preconvert-to-srgb

Author: tylercritchlow

benches/benches/bevy_ecs/events/iter.rs

@@ -1,6 +1,6 @@
 use bevy_ecs::prelude::*;
 
-#[derive(Event, BufferedEvent)]
+#[derive(BufferedEvent)]
 struct BenchEvent<const SIZE: usize>([u8; SIZE]);
 
 pub struct Benchmark<const SIZE: usize>(Events<BenchEvent<SIZE>>);

benches/benches/bevy_ecs/events/write.rs

@@ -1,6 +1,6 @@
 use bevy_ecs::prelude::*;
 
-#[derive(Event, BufferedEvent)]
+#[derive(BufferedEvent)]
 struct BenchEvent<const SIZE: usize>([u8; SIZE]);
 
 impl<const SIZE: usize> Default for BenchEvent<SIZE> {

crates/bevy_a11y/src/lib.rs

@@ -26,10 +26,7 @@ use accesskit::Node;
 use bevy_app::Plugin;
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
-    component::Component,
-    event::{BufferedEvent, Event},
-    resource::Resource,
-    schedule::SystemSet,
+    component::Component, event::BufferedEvent, resource::Resource, schedule::SystemSet,
 };
 
 #[cfg(feature = "bevy_reflect")]
@@ -45,7 +42,7 @@ use serde::{Deserialize, Serialize};
 use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
 
 /// Wrapper struct for [`accesskit::ActionRequest`]. Required to allow it to be used as an `Event`.
-#[derive(Event, BufferedEvent, Deref, DerefMut)]
+#[derive(BufferedEvent, Deref, DerefMut)]
 #[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
 pub struct ActionRequest(pub accesskit::ActionRequest);
 

crates/bevy_app/src/app.rs

@@ -355,7 +355,7 @@ impl App {
     /// # use bevy_app::prelude::*;
     /// # use bevy_ecs::prelude::*;
     /// #
-    /// # #[derive(Event, BufferedEvent)]
+    /// # #[derive(BufferedEvent)]
     /// # struct MyEvent;
     /// # let mut app = App::new();
     /// #
@@ -1417,7 +1417,7 @@ fn run_once(mut app: App) -> AppExit {
 /// This type is roughly meant to map to a standard definition of a process exit code (0 means success, not 0 means error). Due to portability concerns
 /// (see [`ExitCode`](https://doc.rust-lang.org/std/process/struct.ExitCode.html) and [`process::exit`](https://doc.rust-lang.org/std/process/fn.exit.html#))
 /// we only allow error codes between 1 and [255](u8::MAX).
-#[derive(Event, BufferedEvent, Debug, Clone, Default, PartialEq, Eq)]
+#[derive(BufferedEvent, Debug, Clone, Default, PartialEq, Eq)]
 pub enum AppExit {
     /// [`App`] exited without any problems.
     #[default]
@@ -1485,7 +1485,7 @@ mod tests {
         change_detection::{DetectChanges, ResMut},
         component::Component,
         entity::Entity,
-        event::{BufferedEvent, Event, EventWriter, Events},
+        event::{BufferedEvent, EventWriter, Events},
         lifecycle::RemovedComponents,
         query::With,
         resource::Resource,
@@ -1851,7 +1851,7 @@ mod tests {
     }
     #[test]
     fn events_should_be_updated_once_per_update() {
-        #[derive(Event, BufferedEvent, Clone)]
+        #[derive(BufferedEvent, Clone)]
         struct TestEvent;
 
         let mut app = App::new();

crates/bevy_asset/src/event.rs

@@ -1,12 +1,12 @@
 use crate::{Asset, AssetId, AssetLoadError, AssetPath, UntypedAssetId};
-use bevy_ecs::event::{BufferedEvent, Event};
+use bevy_ecs::event::BufferedEvent;
 use bevy_reflect::Reflect;
 use core::fmt::Debug;
 
 /// A [`BufferedEvent`] emitted when a specific [`Asset`] fails to load.
 ///
 /// For an untyped equivalent, see [`UntypedAssetLoadFailedEvent`].
-#[derive(Event, BufferedEvent, Clone, Debug)]
+#[derive(BufferedEvent, Clone, Debug)]
 pub struct AssetLoadFailedEvent<A: Asset> {
     /// The stable identifier of the asset that failed to load.
     pub id: AssetId<A>,
@@ -24,7 +24,7 @@ impl<A: Asset> AssetLoadFailedEvent<A> {
 }
 
 /// An untyped version of [`AssetLoadFailedEvent`].
-#[derive(Event, BufferedEvent, Clone, Debug)]
+#[derive(BufferedEvent, Clone, Debug)]
 pub struct UntypedAssetLoadFailedEvent {
     /// The stable identifier of the asset that failed to load.
     pub id: UntypedAssetId,
@@ -46,7 +46,7 @@ impl<A: Asset> From<&AssetLoadFailedEvent<A>> for UntypedAssetLoadFailedEvent {
 
 /// [`BufferedEvent`]s that occur for a specific loaded [`Asset`], such as "value changed" events and "dependency" events.
 #[expect(missing_docs, reason = "Documenting the id fields is unhelpful.")]
-#[derive(Event, BufferedEvent, Reflect)]
+#[derive(BufferedEvent, Reflect)]
 pub enum AssetEvent<A: Asset> {
     /// Emitted whenever an [`Asset`] is added.
     Added { id: AssetId<A> },

crates/bevy_asset/src/loader_builders.rs

@@ -314,7 +314,7 @@ impl NestedLoader<'_, '_, StaticTyped, Deferred> {
         } else {
             self.load_context
                 .asset_server
-                .get_or_create_path_handle(path, None)
+                .get_or_create_path_handle(path, self.meta_transform)
         };
         self.load_context.dependencies.insert(handle.id().untyped());
         handle

crates/bevy_camera/src/camera.rs

@@ -567,6 +567,30 @@ impl Camera {
     /// To get the world space coordinates with Normalized Device Coordinates, you should use
     /// [`ndc_to_world`](Self::ndc_to_world).
     ///
+    /// # Example
+    /// ```no_run
+    /// # use bevy_window::Window;
+    /// # use bevy_ecs::prelude::{Single, IntoScheduleConfigs};
+    /// # use bevy_transform::prelude::{GlobalTransform, TransformSystems};
+    /// # use bevy_camera::Camera;
+    /// # use bevy_app::{App, PostUpdate};
+    /// #
+    /// fn system(camera_query: Single<(&Camera, &GlobalTransform)>, window: Single<&Window>) {
+    ///     let (camera, camera_transform) = *camera_query;
+    ///
+    ///     if let Some(cursor_position) = window.cursor_position()
+    ///         // Calculate a ray pointing from the camera into the world based on the cursor's position.
+    ///         && let Ok(ray) = camera.viewport_to_world(camera_transform, cursor_position)
+    ///     {
+    ///         println!("{ray:?}");
+    ///     }
+    /// }
+    ///
+    /// # let mut app = App::new();
+    /// // Run the system after transform propagation so the camera's global transform is up-to-date.
+    /// app.add_systems(PostUpdate, system.after(TransformSystems::Propagate));
+    /// ```
+    ///
     /// # Panics
     ///
     /// Will panic if the camera's projection matrix is invalid (has a determinant of 0) and
@@ -605,6 +629,30 @@ impl Camera {
     /// To get the world space coordinates with Normalized Device Coordinates, you should use
     /// [`ndc_to_world`](Self::ndc_to_world).
     ///
+    /// # Example
+    /// ```no_run
+    /// # use bevy_window::Window;
+    /// # use bevy_ecs::prelude::*;
+    /// # use bevy_transform::prelude::{GlobalTransform, TransformSystems};
+    /// # use bevy_camera::Camera;
+    /// # use bevy_app::{App, PostUpdate};
+    /// #
+    /// fn system(camera_query: Single<(&Camera, &GlobalTransform)>, window: Single<&Window>) {
+    ///     let (camera, camera_transform) = *camera_query;
+    ///
+    ///     if let Some(cursor_position) = window.cursor_position()
+    ///         // Calculate a world position based on the cursor's position.
+    ///         && let Ok(world_pos) = camera.viewport_to_world_2d(camera_transform, cursor_position)
+    ///     {
+    ///         println!("World position: {world_pos:.2}");
+    ///     }
+    /// }
+    ///
+    /// # let mut app = App::new();
+    /// // Run the system after transform propagation so the camera's global transform is up-to-date.
+    /// app.add_systems(PostUpdate, system.after(TransformSystems::Propagate));
+    /// ```
+    ///
     /// # Panics
     ///
     /// Will panic if the camera's projection matrix is invalid (has a determinant of 0) and

crates/bevy_core_pipeline/src/blit/mod.rs

@@ -36,7 +36,7 @@ impl Plugin for BlitPlugin {
 
 #[derive(Resource)]
 pub struct BlitPipeline {
-    pub texture_bind_group: BindGroupLayout,
+    pub layout: BindGroupLayout,
     pub sampler: Sampler,
     pub fullscreen_shader: FullscreenShader,
     pub fragment_shader: Handle<Shader>,
@@ -46,7 +46,7 @@ impl FromWorld for BlitPipeline {
     fn from_world(render_world: &mut World) -> Self {
         let render_device = render_world.resource::<RenderDevice>();
 
-        let texture_bind_group = render_device.create_bind_group_layout(
+        let layout = render_device.create_bind_group_layout(
             "blit_bind_group_layout",
             &BindGroupLayoutEntries::sequential(
                 ShaderStages::FRAGMENT,
@@ -60,14 +60,28 @@ impl FromWorld for BlitPipeline {
         let sampler = render_device.create_sampler(&SamplerDescriptor::default());
 
         BlitPipeline {
-            texture_bind_group,
+            layout,
             sampler,
             fullscreen_shader: render_world.resource::<FullscreenShader>().clone(),
             fragment_shader: load_embedded_asset!(render_world, "blit.wgsl"),
         }
     }
 }
 
+impl BlitPipeline {
+    pub fn create_bind_group(
+        &self,
+        render_device: &RenderDevice,
+        src_texture: &TextureView,
+    ) -> BindGroup {
+        render_device.create_bind_group(
+            None,
+            &self.layout,
+            &BindGroupEntries::sequential((src_texture, &self.sampler)),
+        )
+    }
+}
+
 #[derive(PartialEq, Eq, Hash, Clone, Copy)]
 pub struct BlitPipelineKey {
     pub texture_format: TextureFormat,
@@ -81,7 +95,7 @@ impl SpecializedRenderPipeline for BlitPipeline {
     fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
         RenderPipelineDescriptor {
             label: Some("blit pipeline".into()),
-            layout: vec![self.texture_bind_group.clone()],
+            layout: vec![self.layout.clone()],
             vertex: self.fullscreen_shader.to_vertex_state(),
             fragment: Some(FragmentState {
                 shader: self.fragment_shader.clone(),

crates/bevy_core_pipeline/src/msaa_writeback.rs

@@ -98,11 +98,8 @@ impl ViewNode for MsaaWritebackNode {
             occlusion_query_set: None,
         };
 
-        let bind_group = render_context.render_device().create_bind_group(
-            None,
-            &blit_pipeline.texture_bind_group,
-            &BindGroupEntries::sequential((post_process.source, &blit_pipeline.sampler)),
-        );
+        let bind_group =
+            blit_pipeline.create_bind_group(render_context.render_device(), post_process.source);
 
         let mut render_pass = render_context
             .command_encoder()

crates/bevy_core_pipeline/src/upscaling/node.rs

@@ -3,9 +3,7 @@ use bevy_ecs::{prelude::*, query::QueryItem};
 use bevy_render::{
     camera::{CameraOutputMode, ClearColor, ClearColorConfig, ExtractedCamera},
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
-    render_resource::{
-        BindGroup, BindGroupEntries, PipelineCache, RenderPassDescriptor, TextureViewId,
-    },
+    render_resource::{BindGroup, PipelineCache, RenderPassDescriptor, TextureViewId},
     renderer::RenderContext,
     view::ViewTarget,
 };
@@ -30,9 +28,9 @@ impl ViewNode for UpscalingNode {
         (target, upscaling_target, camera): QueryItem<Self::ViewQuery>,
         world: &World,
     ) -> Result<(), NodeRunError> {
-        let pipeline_cache = world.get_resource::<PipelineCache>().unwrap();
-        let blit_pipeline = world.get_resource::<BlitPipeline>().unwrap();
-        let clear_color_global = world.get_resource::<ClearColor>().unwrap();
+        let pipeline_cache = world.resource::<PipelineCache>();
+        let blit_pipeline = world.resource::<BlitPipeline>();
+        let clear_color_global = world.resource::<ClearColor>();
 
         let clear_color = if let Some(camera) = camera {
             match camera.output_mode {
@@ -48,19 +46,18 @@ impl ViewNode for UpscalingNode {
             ClearColorConfig::None => None,
         };
         let converted_clear_color = clear_color.map(Into::into);
-        let upscaled_texture = target.main_texture_view();
+        // texture to be upscaled to the output texture
+        let main_texture_view = target.main_texture_view();
 
         let mut cached_bind_group = self.cached_texture_bind_group.lock().unwrap();
         let bind_group = match &mut *cached_bind_group {
-            Some((id, bind_group)) if upscaled_texture.id() == *id => bind_group,
+            Some((id, bind_group)) if main_texture_view.id() == *id => bind_group,
             cached_bind_group => {
-                let bind_group = render_context.render_device().create_bind_group(
-                    None,
-                    &blit_pipeline.texture_bind_group,
-                    &BindGroupEntries::sequential((upscaled_texture, &blit_pipeline.sampler)),
-                );
+                let bind_group = blit_pipeline
+                    .create_bind_group(render_context.render_device(), main_texture_view);
 
-                let (_, bind_group) = cached_bind_group.insert((upscaled_texture.id(), bind_group));
+                let (_, bind_group) =
+                    cached_bind_group.insert((main_texture_view.id(), bind_group));
                 bind_group
             }
         };