Mesh overhaul with custom vertex attributes #592

crates/bevy_derive/src/lib.rs

@@ -1,7 +1,6 @@
 extern crate proc_macro;
 
 mod app_plugin;
-mod as_vertex_buffer_descriptor;
 mod bytes;
 mod modules;
 mod render_resource;
@@ -44,12 +43,6 @@ pub fn derive_shader_defs(input: TokenStream) -> TokenStream {
     shader_defs::derive_shader_defs(input)
 }
 
-/// Derives the AsVertexBufferDescriptor trait.
-#[proc_macro_derive(AsVertexBufferDescriptor, attributes(vertex, as_crate))]
-pub fn derive_as_vertex_buffer_descriptor(input: TokenStream) -> TokenStream {
-    as_vertex_buffer_descriptor::derive_as_vertex_buffer_descriptor(input)
-}
-
 /// Generates a dynamic plugin entry point function for the given `Plugin` type.  
 #[proc_macro_derive(DynamicPlugin)]
 pub fn derive_dynamic_plugin(input: TokenStream) -> TokenStream {

crates/bevy_gltf/src/loader.rs

@@ -1,5 +1,5 @@
 use bevy_render::{
-    mesh::{Indices, Mesh, VertexAttribute},
+    mesh::{Indices, Mesh, VertexAttributeData},
     pipeline::PrimitiveTopology,
 };
 
@@ -74,27 +74,27 @@ fn load_node(buffer_data: &[Vec<u8>], node: &gltf::Node, depth: i32) -> Result<M
         if let Some(primitive) = mesh.primitives().next() {
             let reader = primitive.reader(|buffer| Some(&buffer_data[buffer.index()]));
             let primitive_topology = get_primitive_topology(primitive.mode())?;
-            let mut mesh = Mesh::new(primitive_topology);
+            let mut mesh = Mesh::new_empty(primitive_topology);
 
             if let Some(vertex_attribute) = reader
                 .read_positions()
-                .map(|v| VertexAttribute::position(v.collect()))
+                .map(|v| VertexAttributeData::position(v.collect()))
             {
-                mesh.attributes.push(vertex_attribute);
+                mesh.insert_attribute(vertex_attribute);
             }
 
             if let Some(vertex_attribute) = reader
                 .read_normals()
-                .map(|v| VertexAttribute::normal(v.collect()))
+                .map(|v| VertexAttributeData::normal(v.collect()))
             {
-                mesh.attributes.push(vertex_attribute);
+                mesh.insert_attribute(vertex_attribute);
             }
 
             if let Some(vertex_attribute) = reader
                 .read_tex_coords(0)
-                .map(|v| VertexAttribute::uv(v.into_f32().collect()))
+                .map(|v| VertexAttributeData::uv(v.into_f32().collect()))
             {
-                mesh.attributes.push(vertex_attribute);
+                mesh.insert_attribute(vertex_attribute);
             }
 
             if let Some(indices) = reader.read_indices() {

crates/bevy_render/Cargo.toml

@@ -44,6 +44,7 @@ anyhow = "1.0"
 hex = "0.4.2"
 hexasphere = "1.0.0"
 parking_lot = "0.11.0"
+fnv = "1.0.7"
 
 [target.'cfg(not(target_os = "ios"))'.dependencies]
 bevy-glsl-to-spirv = "0.1.7"

crates/bevy_render/src/draw.rs

@@ -1,7 +1,7 @@
 use crate::{
     pipeline::{
         PipelineCompiler, PipelineDescriptor, PipelineLayout, PipelineSpecialization,
-        VertexBufferDescriptors,
+        VertexBufferDescriptor,
     },
     renderer::{
         BindGroup, BindGroupId, BufferId, BufferUsage, RenderResource, RenderResourceBinding,
@@ -128,7 +128,6 @@ pub struct DrawContext<'a> {
     pub shaders: ResMut<'a, Assets<Shader>>,
     pub pipeline_compiler: ResMut<'a, PipelineCompiler>,
     pub render_resource_context: Res<'a, Box<dyn RenderResourceContext>>,
-    pub vertex_buffer_descriptors: Res<'a, VertexBufferDescriptors>,
     pub shared_buffers: Res<'a, SharedBuffers>,
     pub current_pipeline: Option<Handle<PipelineDescriptor>>,
 }
@@ -140,7 +139,6 @@ impl<'a> UnsafeClone for DrawContext<'a> {
             shaders: self.shaders.unsafe_clone(),
             pipeline_compiler: self.pipeline_compiler.unsafe_clone(),
             render_resource_context: self.render_resource_context.unsafe_clone(),
-            vertex_buffer_descriptors: self.vertex_buffer_descriptors.unsafe_clone(),
             shared_buffers: self.shared_buffers.unsafe_clone(),
             current_pipeline: self.current_pipeline,
         }
@@ -162,7 +160,6 @@ impl<'a> FetchResource<'a> for FetchDrawContext {
         resources.borrow_mut::<Assets<Shader>>();
         resources.borrow_mut::<PipelineCompiler>();
         resources.borrow::<Box<dyn RenderResourceContext>>();
-        resources.borrow::<VertexBufferDescriptors>();
         resources.borrow::<SharedBuffers>();
     }
 
@@ -171,7 +168,6 @@ impl<'a> FetchResource<'a> for FetchDrawContext {
         resources.release_mut::<Assets<Shader>>();
         resources.release_mut::<PipelineCompiler>();
         resources.release::<Box<dyn RenderResourceContext>>();
-        resources.release::<VertexBufferDescriptors>();
         resources.release::<SharedBuffers>();
     }
 
@@ -201,9 +197,6 @@ impl<'a> FetchResource<'a> for FetchDrawContext {
             render_resource_context: Res::new(
                 resources.get_unsafe_ref::<Box<dyn RenderResourceContext>>(ResourceIndex::Global),
             ),
-            vertex_buffer_descriptors: Res::new(
-                resources.get_unsafe_ref::<VertexBufferDescriptors>(ResourceIndex::Global),
-            ),
             shared_buffers: Res::new(
                 resources.get_unsafe_ref::<SharedBuffers>(ResourceIndex::Global),
             ),
@@ -221,9 +214,6 @@ impl<'a> FetchResource<'a> for FetchDrawContext {
         access
             .immutable
             .insert(TypeId::of::<Box<dyn RenderResourceContext>>());
-        access
-            .immutable
-            .insert(TypeId::of::<VertexBufferDescriptors>());
         access.immutable.insert(TypeId::of::<SharedBuffers>());
         access
     }
@@ -264,7 +254,6 @@ impl<'a> DrawContext<'a> {
                 &mut self.pipelines,
                 &mut self.shaders,
                 pipeline_handle,
-                &self.vertex_buffer_descriptors,
                 specialization,
             )
         };
@@ -341,29 +330,29 @@ impl<'a> DrawContext<'a> {
         &self,
         draw: &mut Draw,
         render_resource_bindings: &[&RenderResourceBindings],
+        vertex_buffer_descriptors: &[VertexBufferDescriptor],
     ) -> Result<(), DrawError> {
-        let pipeline = self.current_pipeline.ok_or(DrawError::NoPipelineSet)?;
-        let pipeline_descriptor = self
-            .pipelines
-            .get(&pipeline)
-            .ok_or(DrawError::NonExistentPipeline)?;
-        let layout = pipeline_descriptor
-            .get_layout()
-            .ok_or(DrawError::PipelineHasNoLayout)?;
-        for (slot, vertex_buffer_descriptor) in layout.vertex_buffer_descriptors.iter().enumerate()
-        {
-            for bindings in render_resource_bindings.iter() {
-                if let Some((vertex_buffer, index_buffer)) =
-                    bindings.get_vertex_buffer(&vertex_buffer_descriptor.name)
+        for bindings in render_resource_bindings.iter() {
+            for vertex_buffer_descriptor in vertex_buffer_descriptors {
+                if let Some(vertex_buffer) =
+                    bindings.vertex_buffers.get(&vertex_buffer_descriptor.name)
                 {
-                    draw.set_vertex_buffer(slot as u32, vertex_buffer, 0);
-                    if let Some(index_buffer) = index_buffer {
-                        draw.set_index_buffer(index_buffer, 0);
-                    }
-
-                    break;
+                    draw.set_vertex_buffer(
+                        vertex_buffer_descriptor.attribute.shader_location,
+                        *vertex_buffer,
+                        0,
+                    );
+                } else {
+                    panic!(
+                        "Attribute {} is required by shader, but no vertex buffer was found.",
+                        &vertex_buffer_descriptor.name
+                    );
                 }
             }
+
+            if let Some(index_buffer) = bindings.index_buffer {
+                draw.set_index_buffer(index_buffer, 0);
+            }
         }
         Ok(())
     }

crates/bevy_render/src/lib.rs

@@ -38,7 +38,7 @@ use camera::{
 };
 use pipeline::{
     DynamicBinding, PipelineCompiler, PipelineDescriptor, PipelineSpecialization,
-    PrimitiveTopology, ShaderSpecialization, VertexBufferDescriptors,
+    PrimitiveTopology, ShaderSpecialization,
 };
 use render_graph::{
     base::{self, BaseRenderGraphBuilder, BaseRenderGraphConfig},
@@ -114,7 +114,6 @@ impl Plugin for RenderPlugin {
             .init_resource::<RenderGraph>()
             .init_resource::<PipelineCompiler>()
             .init_resource::<RenderResourceBindings>()
-            .init_resource::<VertexBufferDescriptors>()
             .init_resource::<TextureResourceSystemState>()
             .init_resource::<AssetRenderResourceBindings>()
             .init_resource::<ActiveCameras>()