Simplified the derive macro quite a bit, need to investigate serde to…

… evaluate how to do this sort of stuff.

Cargo.toml

@@ -6,5 +6,4 @@ members = [
     "crates/rusteroids",
     "crates/wgpu_utils",
     "crates/wgpu_utils/vertex_attribute_derive",
-    "crates/wgpu_utils/wgpu_utils_base",
 ]

crates/rusteroids/src/mesh.rs

@@ -2,8 +2,8 @@ use std::ops::Range;
 
 use glam::Mat4;
 use wgpu::util::DeviceExt;
-use wgpu::{Queue, RenderPass};
-use wgpu_utils::{Attribute, VertexAttributeArray};
+use wgpu::{Queue, RenderPass, VertexAttribute};
+use wgpu_utils::VertexAttributeArray;
 
 use crate::utils::{common_layout_descriptor, Bindable, UniformBuffer};
 #[repr(C)]
@@ -13,6 +13,10 @@ pub struct Vertex {
     pub color: [f32; 3],
 }
 
+impl Vertex {
+    const ATTR: [VertexAttribute; 2] = wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32x3];
+}
+
 pub struct Geometry {
     vertex_buffer: Option<wgpu::Buffer>,
     model_uniform: Option<UniformBuffer>,

crates/wgpu_utils/Cargo.toml

@@ -5,4 +5,4 @@ edition = "2021"
 
 [dependencies]
 vertex_attribute_derive = { path = "vertex_attribute_derive" }
-wgpu_utils_base = { path = "wgpu_utils_base" }
+wgpu = "22.0"

crates/wgpu_utils/src/lib.rs

@@ -1,2 +1,7 @@
 pub use vertex_attribute_derive::VertexAttributeArray;
-pub use wgpu_utils_base::{Attribute, VertexAttributeArray};
+
+pub trait VertexAttributeArray {
+    /// Generates a VertexBufferLayout to be used in a RenderPipeline
+    /// TODO: refactor static out of it.
+    fn desc() -> wgpu::VertexBufferLayout<'static>;
+}

crates/wgpu_utils/vertex_attribute_derive/Cargo.toml

@@ -9,5 +9,4 @@ proc-macro = true
 [dependencies]
 quote = "1.0.37"
 syn = "2.0.79"
-wgpu = "22.0"
-wgpu_utils_base = {path = "../wgpu_utils_base" }
+wgpu = "22.0"

crates/wgpu_utils/vertex_attribute_derive/src/lib.rs

@@ -1,8 +1,23 @@
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{Data, Fields};
-use wgpu_utils_base::Attribute;
 
+/// Ensures the struct is capable of generating a VertexBufferLayout
+/// by calling desc. Requires the existing of a ```const ATTR: [wgpu::VertexAttribute; N]```
+///
+/// Example
+/// ```
+/// struct Vertex {
+///     pos: [f32; 3]
+///     uv:  [f32; 2]
+/// }
+///
+/// impl Vertex{
+///     const ATTR: [wgpu::VertexAttribute; 2] = wpug::vertex_attr_array![0 => Float32x3; 1 Float32x2];
+/// }
+/// ```
+///
+/// TODO: make a bind_to_group(binding: u32, bind_group: &BindGroup, offsets: &[DynamicOffset])
+/// TODO: refactor ATTR requirement out
 #[proc_macro_derive(VertexAttributeArray)]
 pub fn vertex_attribute_derive(input: TokenStream) -> TokenStream {
     // Construct a representation of Rust code as a syntax tree
@@ -15,50 +30,13 @@ pub fn vertex_attribute_derive(input: TokenStream) -> TokenStream {
 
 fn impl_vertex_attribute(ast: &syn::DeriveInput) -> TokenStream {
     let name = &ast.ident;
-
-    let fields = match &ast.data {
-        Data::Struct(data) => {
-            if let Fields::Named(named_fields) = &data.fields {
-                named_fields.named.clone()
-            } else {
-                panic!("#[derive(VertexAttributeArray)] is only supported on structs with named fields");
-            }
-        }
-        // TODO: Add enums
-        _ => panic!("#[derive(VertexAttributeArray)] is only supported on structs"),
-    };
-
-    // Generate the vertex attributes
-    let field_types = fields.iter().enumerate().map(|(i, f)| {
-        let ty = &f.ty;
-        quote! {
-            wgpu::VertexAttribute {
-                format: <#ty as Attribute>::format(),
-                offset: <#ty as Attribute>::format().size(),
-                shader_location: #i as u32,
-            }
-        }
-    });
-
-    // The length of the array to be generated
-    let attrs_array_len = fields.len();
-
     let gen = quote! {
-        impl #name {
-            pub const fn attrs() -> &'static [wgpu::VertexAttribute; #attrs_array_len] {
-                static ATTRS: [wgpu::VertexAttribute; #attrs_array_len] = [
-                    #(#field_types),*
-                ];
-                &ATTRS
-            }
-        }
-
         impl VertexAttributeArray for #name {
             fn desc() -> wgpu::VertexBufferLayout<'static> {
                 wgpu::VertexBufferLayout {
                     array_stride: std::mem::size_of::<Self>() as wgpu::BufferAddress,
                     step_mode: wgpu::VertexStepMode::Vertex,
-                    attributes: Self::attrs(),
+                    attributes: &Self::ATTR,
                 }
             }
         }