Fallback on no metadata if hot-reload is enabled, implement MaterialSettings

Author: ProfLander

src/rust_gpu.rs

@@ -1,6 +1,6 @@
 //! Wrapper for extending a `Material` with `rust-gpu` shader functionality.
 
-use std::marker::PhantomData;
+use std::{any::TypeId, marker::PhantomData, sync::RwLock};
 
 use bevy::{
     pbr::MaterialPipelineKey,
@@ -9,8 +9,10 @@ use bevy::{
         MaterialPlugin, Plugin, Shader,
     },
     reflect::TypeUuid,
-    render::render_resource::{AsBindGroup, PreparedBindGroup},
+    render::render_resource::{AsBindGroup, PreparedBindGroup, ShaderRef},
+    utils::HashMap,
 };
+use once_cell::sync::Lazy;
 
 use crate::{
     prelude::{EntryPoint, Export, ExportHandle, RustGpuMaterial, SHADER_META},
@@ -25,6 +27,8 @@ const SHADER_DEFS: &[&'static str] = &[
     "SIXTEEN_BYTE_ALIGNMENT",
 ];
 
+static MATERIAL_SETTINGS: Lazy<RwLock<HashMap<TypeId, RustGpuSettings>>> = Lazy::new(default);
+
 /// Configures backend support for [`RustGpu<M>`].
 pub struct RustGpuMaterialPlugin<M>
 where
@@ -63,6 +67,15 @@ where
     }
 }
 
+/// Type-level RustGpu material settings
+#[derive(Debug, Default, Copy, Clone)]
+pub struct RustGpuSettings {
+    /// If true, use M::vertex as a fallback instead of ShaderRef::default
+    pub fallback_base_vertex: bool,
+    /// If true, use M::fragment as a fallback instead of ShaderRef::default
+    pub fallback_base_fragment: bool,
+}
+
 /// [`RustGpu`] pipeline key.
 pub struct RustGpuKey<M>
 where
@@ -241,11 +254,29 @@ where
     M: RustGpuMaterial,
 {
     fn vertex_shader() -> bevy::render::render_resource::ShaderRef {
-        M::vertex_shader()
+        if let Some(true) = MATERIAL_SETTINGS
+            .read()
+            .unwrap()
+            .get(&TypeId::of::<Self>())
+            .map(|settings| settings.fallback_base_vertex)
+        {
+            M::vertex_shader()
+        } else {
+            ShaderRef::Default
+        }
     }
 
     fn fragment_shader() -> bevy::render::render_resource::ShaderRef {
-        M::fragment_shader()
+        if let Some(true) = MATERIAL_SETTINGS
+            .read()
+            .unwrap()
+            .get(&TypeId::of::<Self>())
+            .map(|settings| settings.fallback_base_vertex)
+        {
+            M::fragment_shader()
+        } else {
+            ShaderRef::Default
+        }
     }
 
     fn alpha_mode(&self) -> bevy::prelude::AlphaMode {
@@ -300,10 +331,13 @@ where
                 let metas = SHADER_META.read().unwrap();
                 if let Some(vertex_meta) = metas.get(&vertex_shader) {
                     info!("Vertex meta is valid");
+                    info!("Checking entry point {entry_point:}");
                     if !vertex_meta.entry_points.contains(&entry_point) {
                         warn!("Missing entry point {entry_point:}");
                         apply = false;
                     }
+                } else {
+                    apply = false;
                 }
             }
 
@@ -350,10 +384,13 @@ where
                     let metas = SHADER_META.read().unwrap();
                     if let Some(fragment_meta) = metas.get(&fragment_shader) {
                         info!("Fragment meta is valid");
+                        info!("Checking entry point {entry_point:}");
                         if !fragment_meta.entry_points.contains(&entry_point) {
                             apply = false;
                             warn!("Missing entry point {entry_point:}, falling back to default fragment shader.");
                         }
+                    } else {
+                        apply = false;
                     }
                 }
 
@@ -384,3 +421,13 @@ where
         Ok(())
     }
 }
+
+impl<M> RustGpu<M>
+where
+    M: 'static,
+{
+    pub fn map_settings<F: FnOnce(&mut RustGpuSettings)>(f: F) {
+        let mut settings = MATERIAL_SETTINGS.write().unwrap();
+        f(&mut settings.entry(TypeId::of::<Self>()).or_default());
+    }
+}

src/shader_meta.rs

@@ -16,7 +16,10 @@ use bevy_common_assets::json::JsonAssetPlugin;
 
 use serde::{Deserialize, Serialize};
 
-use crate::prelude::{reload_materials, RustGpuMaterial};
+use crate::{
+    prelude::{reload_materials, RustGpuMaterial},
+    systems::shader_events,
+};
 
 pub(crate) static SHADER_META: Lazy<RwLock<ShaderMeta>> = Lazy::new(Default::default);
 pub(crate) static SHADER_META_MAP: Lazy<RwLock<ShaderMetaMap>> = Lazy::new(Default::default);
@@ -46,7 +49,9 @@ where
 
         app.add_system_to_stage(
             bevy::prelude::CoreStage::Last,
-            module_meta_events::<M>.before(reload_materials::<M>),
+            module_meta_events::<M>
+                .after(shader_events::<M>)
+                .before(reload_materials::<M>),
         );
     }
 }