Update to bevy 0.10.0, bump version to 0.5.0

Author: ProfLander

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy-rust-gpu"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 
 [features]
@@ -10,8 +10,8 @@ hot-rebuild = []
 bevy-pbr-rust = []
 
 [dependencies]
-bevy = "0.9.1"
+bevy = "0.10.0"
 serde = "1.0.152"
 serde_json = "1.0.93"
-bevy_common_assets = { version = "0.4.0", features = ["json"] }
+bevy_common_assets = { version = "0.5.0", features = ["json"] }
 once_cell = "1.17.1"

src/entry_point.rs

@@ -1,5 +1,7 @@
 //! Trait representation of a `rust-gpu` entry point.
 
+use bevy::render::render_resource::ShaderDefVal;
+
 /// An entry point name for use with the [`EntryPoint`] trait.
 pub type EntryPointName = &'static str;
 
@@ -30,12 +32,12 @@ pub trait EntryPoint: 'static + Send + Sync {
     const PARAMETERS: EntryPointParameters;
 
     /// Constructs a permutation set from the provided shader defs
-    fn permutation(shader_defs: &Vec<String>) -> Vec<String> {
+    fn permutation(shader_defs: &Vec<ShaderDefVal>) -> Vec<String> {
         let mut permutation = vec![];
 
         for (defined, undefined) in Self::PARAMETERS.iter() {
             if let Some(mapping) = defined.iter().find_map(|(def, mapping)| {
-                if shader_defs.contains(&def.to_string()) {
+                if shader_defs.contains(&ShaderDefVal::Bool(def.to_string(), true)) {
                     Some(mapping)
                 } else {
                     None
@@ -51,7 +53,7 @@ pub trait EntryPoint: 'static + Send + Sync {
     }
 
     /// Build an entry point name from the provided shader defs
-    fn build(shader_defs: &Vec<String>) -> String {
+    fn build(shader_defs: &Vec<ShaderDefVal>) -> String {
         std::iter::once(Self::NAME.to_string())
             .chain(
                 Self::permutation(shader_defs)

src/entry_point_export.rs

@@ -9,9 +9,7 @@ use std::{
 };
 
 use bevy::{
-    prelude::{
-        default, info, CoreStage, Deref, DerefMut, IntoSystemDescriptor, NonSendMut, Plugin,
-    },
+    prelude::{default, info, CoreSet, Deref, DerefMut, IntoSystemConfig, NonSendMut, Plugin},
     tasks::IoTaskPool,
     utils::HashMap,
 };
@@ -34,19 +32,13 @@ impl Plugin for EntryPointExportPlugin {
     fn build(&self, app: &mut bevy::prelude::App) {
         app.world.init_non_send_resource::<EntryPointExport>();
 
-        app.add_system_to_stage(
-            CoreStage::Update,
-            EntryPointExport::create_export_containers_system,
-        )
-        .add_system_to_stage(
-            CoreStage::Last,
-            EntryPointExport::receive_entry_points_system,
-        )
-        .add_system_to_stage(
-            CoreStage::Last,
+        app.add_systems((
+            EntryPointExport::create_export_containers_system.in_base_set(CoreSet::Update),
+            EntryPointExport::receive_entry_points_system.in_base_set(CoreSet::Last),
             EntryPointExport::export_entry_points_system
+                .in_base_set(CoreSet::Last)
                 .after(EntryPointExport::receive_entry_points_system),
-        );
+        ));
     }
 }
 

src/plugin.rs

@@ -1,8 +1,8 @@
 //! Main Rust-GPU plugin.
 
 use bevy::{
-    prelude::{default, info, Plugin},
-    render::{settings::WgpuSettings, RenderPlugin},
+    prelude::{default, Plugin},
+    render::settings::{WgpuLimits, WgpuSettings},
 };
 
 use crate::prelude::ChangedShaders;
@@ -13,31 +13,6 @@ pub struct RustGpuPlugin;
 
 impl Plugin for RustGpuPlugin {
     fn build(&self, app: &mut bevy::prelude::App) {
-        // Panic if added too late for `WgpuSettings` to take effect
-        if app.is_plugin_added::<RenderPlugin>() {
-            panic!("BevyRustGpuPlugin must be added before bevy_render::RenderPlugin");
-        }
-
-        // Forcibly disable storage buffers to account for rust-gpu limitations
-        let mut wgpu_settings = app
-            .world
-            .get_resource_or_insert_with::<WgpuSettings>(default);
-
-        let constrained_limits = match &mut wgpu_settings.constrained_limits {
-            Some(constrained_limits) => {
-                info!("Constrained limits exists");
-                constrained_limits
-            }
-            None => {
-                info!("Constrained limits does not exist");
-                wgpu_settings.constrained_limits = Some(wgpu_settings.limits.clone());
-                wgpu_settings.constrained_limits.as_mut().unwrap()
-            }
-        };
-
-        info!("Setting max storage buffers per shader stage");
-        constrained_limits.max_storage_buffers_per_shader_stage = 0;
-
         // Initialize `ChangedShaders` resource
         app.init_resource::<ChangedShaders>();
 
@@ -46,3 +21,15 @@ impl Plugin for RustGpuPlugin {
         app.add_plugin(crate::prelude::EntryPointExportPlugin);
     }
 }
+
+impl RustGpuPlugin {
+    pub fn wgpu_settings() -> WgpuSettings {
+        WgpuSettings {
+            constrained_limits: Some(WgpuLimits {
+                max_storage_buffers_per_shader_stage: 0,
+                ..default()
+            }),
+            ..default()
+        }
+    }
+}

src/rust_gpu.rs

@@ -5,8 +5,8 @@ use std::{any::TypeId, marker::PhantomData, path::PathBuf, sync::RwLock};
 use bevy::{
     pbr::MaterialPipelineKey,
     prelude::{
-        default, info, warn, CoreStage, Image, IntoSystemDescriptor, Material, MaterialPlugin,
-        Plugin, Handle, Shader, Deref, DerefMut, Resource,
+        default, info, warn, CoreSet, Deref, DerefMut, Handle, Image, IntoSystemConfig, Material,
+        MaterialPlugin, Plugin, Resource, Shader,
     },
     reflect::TypeUuid,
     render::render_resource::{AsBindGroup, PreparedBindGroup, ShaderRef},
@@ -20,14 +20,6 @@ use crate::{
     systems::{reload_materials, shader_events},
 };
 
-const SHADER_DEFS: &[&'static str] = &[
-    "NO_STORAGE_BUFFERS_SUPPORT",
-    #[cfg(feature = "webgl")]
-    "NO_TEXTURE_ARRAYS_SUPPORT",
-    #[cfg(feature = "webgl")]
-    "SIXTEEN_BYTE_ALIGNMENT",
-];
-
 static MATERIAL_SETTINGS: Lazy<RwLock<HashMap<TypeId, RustGpuSettings>>> = Lazy::new(default);
 
 /// Configures backend support for [`RustGpu<M>`].
@@ -55,11 +47,8 @@ where
     M::Data: Clone + Eq + std::hash::Hash,
 {
     fn build(&self, app: &mut bevy::prelude::App) {
-        app.add_system_to_stage(CoreStage::Last, reload_materials::<M>);
-        app.add_system_to_stage(
-            CoreStage::Last,
-            shader_events::<M>.before(reload_materials::<M>),
-        );
+        app.add_system(reload_materials::<M>.in_base_set(CoreSet::Last));
+        app.add_system(shader_events::<M>.before(reload_materials::<M>));
 
         app.add_plugin(MaterialPlugin::<RustGpu<M>>::default());
 
@@ -221,7 +210,7 @@ where
         images: &bevy::render::render_asset::RenderAssets<Image>,
         fallback_image: &bevy::render::texture::FallbackImage,
     ) -> Result<
-        bevy::render::render_resource::PreparedBindGroup<Self>,
+        bevy::render::render_resource::PreparedBindGroup<Self::Data>,
         bevy::render::render_resource::AsBindGroupError,
     > {
         self.base

src/shader_meta.rs

@@ -6,19 +6,20 @@ use once_cell::sync::Lazy;
 
 use bevy::{
     prelude::{
-        default, info, AssetEvent, Assets, Deref, DerefMut, EventReader, Handle,
-        IntoSystemDescriptor, Plugin, Res, ResMut, Resource, Shader,
+        default, info, AssetEvent, Assets, CoreSet, Deref, DerefMut, EventReader, Handle,
+        IntoSystemConfig, Plugin, Res, ResMut, Resource, Shader,
     },
     reflect::TypeUuid,
-    utils::{HashMap, HashSet},
+    utils::HashMap,
 };
 use bevy_common_assets::json::JsonAssetPlugin;
 
 use serde::{Deserialize, Serialize};
 
 use crate::{
     prelude::{reload_materials, RustGpuMaterial},
-    systems::shader_events, ChangedShaders,
+    systems::shader_events,
+    ChangedShaders,
 };
 
 pub(crate) static SHADER_META: Lazy<RwLock<ShaderMeta>> = Lazy::new(Default::default);
@@ -47,9 +48,9 @@ where
             app.add_plugin(JsonAssetPlugin::<ModuleMeta>::new(&["spv.json"]));
         }
 
-        app.add_system_to_stage(
-            bevy::prelude::CoreStage::Last,
+        app.add_system(
             module_meta_events::<M>
+                .in_base_set(CoreSet::Last)
                 .after(shader_events::<M>)
                 .before(reload_materials::<M>),
         );