Update to Bevy 0.17

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_app_compute"
-version = "0.16.0"
+version = "0.17.0"
 authors = [
     "Cornchip <cornchipgonecodin@gmail.com>",
     "Kjolnyr <kjolnyr@protonmail.com>",
@@ -30,17 +30,17 @@ wesl = { version = "0.1.2", optional = true }
 # The following are only needed to support the `pipeline_cache` "hack". See issue in bevy_easy_compute:
 # https://github.com/AnthonyTornetta/bevy_easy_compute/issues/7
 # Make sure these match bevy's versions
-wgpu = { version = "24.0.0", features = ["naga-ir"] }
-naga = { version = "24.0.0", features = ["wgsl-in"] }
-naga_oil = { version = "0.17.0", default-features = false, features = [
+wgpu = { version = "26", features = ["naga-ir"] }
+naga = { version = "26", features = ["wgsl-in"] }
+naga_oil = { version = "0.19", default-features = false, features = [
     "test_shader",
 ] }
 futures-lite = "2.0.1"
 thiserror = { version = "2", default-features = false }
 tracing = { version = "0.1", default-features = false, features = ["std"] } 
 
 [dependencies.bevy]
-version = "0.16.0"
+version = "0.17.0"
 default-features = false
 # See https://github.com/bevyengine/bevy/blob/main/docs/cargo_features.md
 features = [
@@ -54,14 +54,15 @@ features = [
 rand = ">=0.9.1"
 
 [dev-dependencies.bevy]
-version = "0.16.0"
+version = "0.17.0"
 default-features = false
 features = [
   "animation",
   "bevy_core_pipeline",
   "bevy_pbr",
   "bevy_gltf",
   "bevy_render",
+  "bevy_sprite_render",
   "bevy_ui",
   "multi_threaded",
   "png",

examples/game_of_life/render/draw_plugin.rs

@@ -4,8 +4,8 @@ use bevy::{
     core_pipeline::core_2d::graph::{Core2d, Node2d},
     prelude::*,
     render::{
-        render_graph::{RenderGraphApp, ViewNodeRunner},
         MainWorld, RenderApp,
+        render_graph::{RenderGraphExt, ViewNodeRunner},
     },
 };
 

examples/game_of_life/render/pipeline.rs

@@ -32,14 +32,14 @@ impl FromWorld for DrawParticlePipeline {
                 push_constant_ranges: Vec::new(),
                 vertex: VertexState {
                     shader: shader.clone(),
-                    entry_point: "vertex".into(),
+                    entry_point: Some("vertex".into()),
                     shader_defs: vec![],
                     buffers: vec![],
                 },
                 fragment: Some(FragmentState {
                     shader,
                     shader_defs: vec![],
-                    entry_point: "fragment".into(),
+                    entry_point: Some("fragment".into()),
                     targets: vec![Some(ColorTargetState {
                         format: TextureFormat::bevy_default(),
                         blend: None,

examples/multi_pass.rs

@@ -51,6 +51,7 @@ fn main() {
                     primary_window: None,
                     exit_condition: bevy::window::ExitCondition::DontExit,
                     close_when_requested: false,
+                    primary_cursor_options: None,
                 }),
         )
         .add_plugins(AppComputePlugin)

examples/simple.rs

@@ -36,6 +36,7 @@ fn main() {
                     primary_window: None,
                     exit_condition: bevy::window::ExitCondition::DontExit,
                     close_when_requested: false,
+                    primary_cursor_options: None,
                 }),
         )
         .add_plugins(AppComputePlugin)

src/lib.rs

@@ -3,10 +3,10 @@
 use bevy::{
     asset::{AssetEvent, Assets},
     ecs::{
-        event::EventReader,
+        message::MessageReader,
         system::{Res, ResMut},
     },
-    render::render_resource::Shader,
+    shader::Shader,
 };
 use pipeline_cache::PipelineCache;
 
@@ -30,13 +30,14 @@ pub mod prelude {
     };
 
     // Since these are always used when using this crate
-    pub use bevy::render::render_resource::{ShaderRef, ShaderType};
+    pub use bevy::render::render_resource::ShaderType;
+    pub use bevy::shader::ShaderRef;
 }
 
 pub(crate) fn extract_shaders(
     mut pipeline_cache: ResMut<PipelineCache>,
     shaders: Res<Assets<Shader>>,
-    mut events: EventReader<AssetEvent<Shader>>,
+    mut events: MessageReader<AssetEvent<Shader>>,
 ) {
     for event in events.read() {
         match event {

src/pipeline_cache.rs

@@ -15,6 +15,7 @@ use bevy::render::{
     render_resource::*,
     renderer::{RenderAdapter, RenderDevice},
 };
+use bevy::shader::*;
 use bevy::tasks::Task;
 use bevy::utils::default;
 use core::{future::Future, hash::Hash, mem, ops::Deref};
@@ -690,14 +691,14 @@ impl PipelineCache {
                 let fragment_data = descriptor.fragment.as_ref().map(|fragment| {
                     (
                         fragment_module.unwrap(),
-                        fragment.entry_point.deref(),
+                        fragment.entry_point.as_deref(),
                         fragment.targets.as_slice(),
                     )
                 });
 
                 // TODO: Expose the rest of this somehow
                 let compilation_options = PipelineCompilationOptions {
-                    constants: &default(),
+                    constants: &[],
                     zero_initialize_workgroup_memory: descriptor.zero_initialize_workgroup_memory,
                 };
 
@@ -710,15 +711,15 @@ impl PipelineCache {
                     primitive: descriptor.primitive,
                     vertex: RawVertexState {
                         buffers: &vertex_buffer_layouts,
-                        entry_point: Some(descriptor.vertex.entry_point.deref()),
+                        entry_point: descriptor.vertex.entry_point.as_deref(),
                         module: &vertex_module,
                         // TODO: Should this be the same as the fragment compilation options?
                         compilation_options: compilation_options.clone(),
                     },
                     fragment: fragment_data
                         .as_ref()
                         .map(|(module, entry_point, targets)| RawFragmentState {
-                            entry_point: Some(entry_point),
+                            entry_point: *entry_point,
                             module,
                             targets,
                             // TODO: Should this be the same as the vertex compilation options?
@@ -776,10 +777,10 @@ impl PipelineCache {
                     label: descriptor.label.as_deref(),
                     layout: layout.as_ref().map(|layout| -> &PipelineLayout { layout }),
                     module: &compute_module,
-                    entry_point: Some(&descriptor.entry_point),
+                    entry_point: descriptor.entry_point.as_deref(),
                     // TODO: Expose the rest of this somehow
                     compilation_options: PipelineCompilationOptions {
-                        constants: &default(),
+                        constants: &[],
                         zero_initialize_workgroup_memory: descriptor
                             .zero_initialize_workgroup_memory,
                     },
@@ -949,8 +950,8 @@ fn get_capabilities(features: Features, downlevel: DownlevelFlags) -> Capabiliti
         features.contains(Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING),
     );
     capabilities.set(
-        Capabilities::UNIFORM_BUFFER_AND_STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING,
-        features.contains(Features::UNIFORM_BUFFER_AND_STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING),
+        Capabilities::STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING,
+        features.contains(Features::STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING),
     );
     // TODO: This needs a proper wgpu feature
     capabilities.set(

src/traits.rs

@@ -1,7 +1,8 @@
 use bevy::{
     prelude::World,
     reflect::TypePath,
-    render::render_resource::{BindGroupLayout, ShaderDefVal, ShaderRef},
+    render::render_resource::BindGroupLayout,
+    shader::{ShaderDefVal, ShaderRef},
 };
 use wgpu::PushConstantRange;
 

src/worker.rs

@@ -234,7 +234,7 @@ impl<W: ComputeWorker> AppComputeWorker<W> {
 
     /// Read data from `target` staging buffer, return raw bytes
     #[inline]
-    pub fn try_read_raw<'a>(&'a self, target: &str) -> Result<(impl Deref<Target = [u8]> + 'a)> {
+    pub fn try_read_raw<'a>(&'a self, target: &str) -> Result<impl Deref<Target = [u8]> + 'a> {
         let Some(staging_buffer) = &self.staging_buffers.get(target) else {
             return Err(Error::StagingBufferNotFound(target.to_owned()));
         };
@@ -247,7 +247,7 @@ impl<W: ComputeWorker> AppComputeWorker<W> {
     /// Read data from `target` staging buffer, return raw bytes
     /// Panics on error.
     #[inline]
-    pub fn read_raw<'a>(&'a self, target: &str) -> (impl Deref<Target = [u8]> + 'a) {
+    pub fn read_raw<'a>(&'a self, target: &str) -> impl Deref<Target = [u8]> + 'a {
         self.try_read_raw(target).unwrap()
     }
 
@@ -351,29 +351,33 @@ impl<W: ComputeWorker> AppComputeWorker<W> {
             match self
                 .render_device
                 .wgpu_device()
-                .poll(wgpu::MaintainBase::Poll)
+                .poll(wgpu::PollType::Poll)
+                .unwrap()
             {
                 // The first few times the poll occurs the queue will be empty, because wgpu hasn't started anything yet.
-                // We need to wait until `MaintainResult::Ok`, which means wgpu has started to process our data.
-                // Then, the next time the queue is empty (`MaintainResult::SubmissionQueueEmpty`), wgpu has finished processing the data and we are done.
-                wgpu::MaintainResult::SubmissionQueueEmpty => {
+                // We need to wait until `PollStatus::Poll`, which means wgpu has started to process our data.
+                // Then, the next time the queue is empty (`PollStatus::QueueEmpty`), wgpu has finished processing the data and we are done.
+                wgpu::PollStatus::QueueEmpty => {
                     let res = self.submission_queue_processed;
                     self.submission_queue_processed = false;
                     res
                 }
-                wgpu::MaintainResult::Ok => {
+                wgpu::PollStatus::Poll => {
                     self.submission_queue_processed = true;
                     false
                 }
+                wgpu::PollStatus::WaitSucceeded => unreachable!(),
             }
         } else {
             match self
                 .render_device
                 .wgpu_device()
-                .poll(wgpu::MaintainBase::Wait)
+                .poll(wgpu::PollType::Wait)
+                .unwrap()
             {
-                wgpu::MaintainResult::SubmissionQueueEmpty => true,
-                wgpu::MaintainResult::Ok => false,
+                wgpu::PollStatus::QueueEmpty => true,
+                wgpu::PollStatus::WaitSucceeded => false,
+                wgpu::PollStatus::Poll => unreachable!(),
             }
         }
     }

src/worker_builder.rs

@@ -5,11 +5,12 @@ use bevy::{
     prelude::{AssetServer, World},
     render::{
         render_resource::{
-            Buffer, ComputePipelineDescriptor, ShaderRef, ShaderType,
+            Buffer, ComputePipelineDescriptor, ShaderType,
             encase::{StorageBuffer, UniformBuffer, private::WriteInto},
         },
         renderer::RenderDevice,
     },
+    shader::ShaderRef,
 };
 use wgpu::{BufferDescriptor, BufferUsages, util::BufferInitDescriptor};
 
@@ -264,7 +265,7 @@ impl<'a, W: ComputeWorker> AppComputeWorkerBuilder<'a, W> {
                 layout: S::layouts().to_vec(),
                 push_constant_ranges: S::push_constant_ranges().to_vec(),
                 shader_defs: S::shader_defs().to_vec(),
-                entry_point: Cow::Borrowed(S::entry_point()),
+                entry_point: Some(Cow::Borrowed(S::entry_point())),
                 shader,
                 zero_initialize_workgroup_memory: false,
             });