Mid-Level Rendering w/ ShaderModel

bevy_nannou_derive/src/lib.rs

@@ -38,16 +38,6 @@ pub fn shader_model(attr: TokenStream, item: TokenStream) -> TokenStream {
                 #fragment_shader_impl
             }
         }
-
-        impl #impl_generics ::nannou::prelude::Material for #name #ty_generics #where_clause {
-            fn vertex_shader() -> ::nannou::prelude::ShaderRef {
-                <Self as ::nannou::prelude::render::ShaderModel>::vertex_shader()
-            }
-
-            fn fragment_shader() -> ::nannou::prelude::ShaderRef {
-                <Self as ::nannou::prelude::render::ShaderModel>::fragment_shader()
-            }
-        }
     };
 
     TokenStream::from(expanded)

bevy_nannou_derive/tests/shader_model_tests.rs

@@ -3,58 +3,61 @@ use bevy_nannou_derive::shader_model;
 use bevy_nannou_draw::render::ShaderModel;
 
 #[shader_model]
-struct TestMaterial {}
+struct TestShaderModel {}
 
 #[test]
 fn test_default_shaders() {
-    assert!(matches!(TestMaterial::vertex_shader(), ShaderRef::Default));
     assert!(matches!(
-        TestMaterial::fragment_shader(),
+        TestShaderModel::vertex_shader(),
+        ShaderRef::Default
+    ));
+    assert!(matches!(
+        TestShaderModel::fragment_shader(),
         ShaderRef::Default
     ));
 }
 
 #[shader_model(vertex = "custom_vertex.wgsl")]
-struct TestVertexMaterial {}
+struct TestVertexShaderModel {}
 
 #[test]
 fn test_custom_vertex_shader() {
     assert!(matches!(
-        TestVertexMaterial::vertex_shader(),
+        TestVertexShaderModel::vertex_shader(),
         ShaderRef::Path(_)
     ));
     assert!(matches!(
-        TestVertexMaterial::fragment_shader(),
+        TestVertexShaderModel::fragment_shader(),
         ShaderRef::Default
     ));
 }
 
 #[shader_model(fragment = "custom_fragment.wgsl")]
-struct TestFragmentMaterial {}
+struct TestFragmentShaderModel {}
 
 #[test]
 fn test_custom_fragment_shader() {
     assert!(matches!(
-        TestFragmentMaterial::vertex_shader(),
+        TestFragmentShaderModel::vertex_shader(),
         ShaderRef::Default
     ));
     assert!(matches!(
-        TestFragmentMaterial::fragment_shader(),
+        TestFragmentShaderModel::fragment_shader(),
         ShaderRef::Path(_)
     ));
 }
 
 #[shader_model(vertex = "custom_vertex.wgsl", fragment = "custom_fragment.wgsl")]
-struct TestBothMaterial {}
+struct TestBothShaderModel {}
 
 #[test]
 fn test_both_custom_shaders() {
     assert!(matches!(
-        TestBothMaterial::vertex_shader(),
+        TestBothShaderModel::vertex_shader(),
         ShaderRef::Path(_)
     ));
     assert!(matches!(
-        TestBothMaterial::fragment_shader(),
+        TestBothShaderModel::fragment_shader(),
         ShaderRef::Path(_)
     ));
 }

bevy_nannou_draw/Cargo.toml

@@ -12,6 +12,7 @@ num-traits = "0.2"
 bytemuck = "1.15.0"
 rayon = { workspace = true }
 uuid = "1.8"
+bitflags = "2.6.0"
 
 [features]
 nightly = []

bevy_nannou_draw/src/draw/background.rs

@@ -1,26 +1,27 @@
-use bevy::prelude::{Color, Material};
+use bevy::prelude::Color;
 
 use crate::draw::{Draw, DrawCommand};
+use crate::render::ShaderModel;
 
 /// A type used to update the background colour.
-pub struct Background<'a, M>
+pub struct Background<'a, SM>
 where
-    M: Material + Default,
+    SM: ShaderModel + Default,
 {
-    draw: &'a Draw<M>,
+    draw: &'a Draw<SM>,
 }
 
 /// Begin coloring the background.
-pub fn new<M>(draw: &Draw<M>) -> Background<M>
+pub fn new<SM>(draw: &Draw<SM>) -> Background<SM>
 where
-    M: Material + Default,
+    SM: ShaderModel + Default,
 {
     Background { draw }
 }
 
-impl<'a, M> Background<'a, M>
+impl<'a, SM> Background<'a, SM>
 where
-    M: Material + Default,
+    SM: ShaderModel + Default,
 {
     /// Clear the background with the given color.
     ///