delegate layout reflection to RenderResourceContext

crates/bevy_pbr/src/entity.rs

@@ -4,7 +4,7 @@ use bevy_ecs::Bundle;
 use bevy_render::{
  draw::Draw,
  mesh::Mesh,
- pipeline::{DynamicBinding, PipelineSpecialization, RenderPipeline, RenderPipelines},
+ pipeline::{RenderPipeline, RenderPipelines},
  render_graph::base::MainPass,
 };
 use bevy_transform::prelude::{GlobalTransform, Transform};
@@ -24,23 +24,8 @@ pub struct PbrComponents {
 impl Default for PbrComponents {
  fn default() -> Self {
  Self {
- render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::specialized(
+ render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
  FORWARD_PIPELINE_HANDLE,
- PipelineSpecialization {
- dynamic_bindings: vec![
- // Transform
- DynamicBinding {
- bind_group: 2,
- binding: 0,
- },
- // StandardMaterial_albedo
- DynamicBinding {
- bind_group: 3,
- binding: 0,
- },
- ],
- ..Default::default()
- },
  )]),
  mesh: Default::default(),
  material: Default::default(),

crates/bevy_render/src/lib.rs

@@ -37,8 +37,8 @@ use camera::{
  ActiveCameras, Camera, OrthographicProjection, PerspectiveProjection, VisibleEntities,
 };
 use pipeline::{
- DynamicBinding, IndexFormat, PipelineCompiler, PipelineDescriptor, PipelineSpecialization,
- PrimitiveTopology, ShaderSpecialization,
+ IndexFormat, PipelineCompiler, PipelineDescriptor, PipelineSpecialization, PrimitiveTopology,
+ ShaderSpecialization,
 };
 use render_graph::{
  base::{self, BaseRenderGraphBuilder, BaseRenderGraphConfig},
@@ -66,7 +66,7 @@ pub mod stage {
 
 /// Adds core render types and systems to an App
 pub struct RenderPlugin {
- /// configures the "base render graph". If this is not `None`, the "base render graph" will be added 
+ /// configures the "base render graph". If this is not `None`, the "base render graph" will be added
  pub base_render_graph_config: Option<BaseRenderGraphConfig>,
 }
 
@@ -112,7 +112,6 @@ impl Plugin for RenderPlugin {
  .register_property::<Color>()
  .register_property::<Range<f32>>()
  .register_property::<ShaderSpecialization>()
- .register_property::<DynamicBinding>()
  .register_property::<PrimitiveTopology>()
  .register_property::<IndexFormat>()
  .register_properties::<PipelineSpecialization>()

crates/bevy_render/src/pipeline/pipeline.rs

@@ -4,13 +4,9 @@ use super::{
  CompareFunction, CullMode, DepthStencilStateDescriptor, FrontFace, IndexFormat,
  PrimitiveTopology, RasterizationStateDescriptor, StencilStateFaceDescriptor,
  },
- BindType, DynamicBinding, PipelineLayout, StencilStateDescriptor,
+ PipelineLayout, StencilStateDescriptor,
 };
-use crate::{
- shader::{Shader, ShaderStages},
- texture::TextureFormat,
-};
-use bevy_asset::Assets;
+use crate::{shader::ShaderStages, texture::TextureFormat};
 use bevy_type_registry::TypeUuid;
 
 #[derive(Clone, Debug, TypeUuid)]
@@ -117,63 +113,4 @@ impl PipelineDescriptor {
  pub fn get_layout_mut(&mut self) -> Option<&mut PipelineLayout> {
  self.layout.as_mut()
  }
-
- /// Reflects the pipeline layout from its shaders.
- ///
- /// If `bevy_conventions` is true, it will be assumed that the shader follows "bevy shader conventions". These allow
- /// richer reflection, such as inferred Vertex Buffer names and inferred instancing.
- ///
- /// If `dynamic_bindings` has values, shader uniforms will be set to "dynamic" if there is a matching binding in the list
- ///
- /// If `vertex_buffer_descriptors` is set, the pipeline's vertex buffers
- /// will inherit their layouts from global descriptors, otherwise the layout will be assumed to be complete / local.
- pub fn reflect_layout(
- &mut self,
- shaders: &Assets<Shader>,
- bevy_conventions: bool,
- dynamic_bindings: &[DynamicBinding],
- ) {
- let vertex_spirv = shaders.get(&self.shader_stages.vertex).unwrap();
- let fragment_spirv = self
- .shader_stages
- .fragment
- .as_ref()
- .map(|handle| shaders.get(handle).unwrap());
-
- let mut layouts = vec![vertex_spirv.reflect_layout(bevy_conventions).unwrap()];
- if let Some(ref fragment_spirv) = fragment_spirv {
- layouts.push(fragment_spirv.reflect_layout(bevy_conventions).unwrap());
- }
-
- let mut layout = PipelineLayout::from_shader_layouts(&mut layouts);
-
- if !dynamic_bindings.is_empty() {
- // set binding uniforms to dynamic if render resource bindings use dynamic
- for bind_group in layout.bind_groups.iter_mut() {
- let mut binding_changed = false;
- for binding in bind_group.bindings.iter_mut() {
- let current = DynamicBinding {
- bind_group: bind_group.index,
- binding: binding.index,
- };
-
- if dynamic_bindings.contains(&current) {
- if let BindType::Uniform {
- ref mut dynamic, ..
- } = binding.bind_type
- {
- *dynamic = true;
- binding_changed = true;
- }
- }
- }
-
- if binding_changed {
- bind_group.update_id();
- }
- }
- }
-
- self.layout = Some(layout);
- }
 }

crates/bevy_render/src/pipeline/pipeline_compiler.rs

@@ -1,7 +1,7 @@
 use super::{state_descriptors::PrimitiveTopology, IndexFormat, PipelineDescriptor};
 use crate::{
  pipeline::{
- InputStepMode, VertexAttributeDescriptor, VertexBufferDescriptor, VertexFormat,
+ BindType, InputStepMode, VertexAttributeDescriptor, VertexBufferDescriptor, VertexFormat,
  VERTEX_FALLBACK_LAYOUT_NAME,
  },
  renderer::RenderResourceContext,
@@ -18,7 +18,7 @@ use std::borrow::Cow;
 pub struct PipelineSpecialization {
  pub shader_specialization: ShaderSpecialization,
  pub primitive_topology: PrimitiveTopology,
- pub dynamic_bindings: Vec<DynamicBinding>,
+ pub dynamic_bindings: Vec<String>,
  pub index_format: IndexFormat,
  pub vertex_buffer_descriptor: VertexBufferDescriptor,
  pub sample_count: u32,
@@ -61,12 +61,6 @@ struct SpecializedPipeline {
  specialization: PipelineSpecialization,
 }
 
-#[derive(Clone, Eq, PartialEq, Debug, Default, Serialize, Deserialize, Property)]
-pub struct DynamicBinding {
- pub bind_group: u32,
- pub binding: u32,
-}
-
 #[derive(Debug, Default)]
 pub struct PipelineCompiler {
  specialized_shaders: HashMap<Handle<Shader>, Vec<SpecializedShader>>,
@@ -163,12 +157,39 @@ impl PipelineCompiler {
  )
  });
 
- specialized_descriptor.reflect_layout(
- shaders,
+ let mut layout = render_resource_context.reflect_pipeline_layout(
+ &shaders,
+ &specialized_descriptor.shader_stages,
  true,
- &pipeline_specialization.dynamic_bindings,
  );
 
+ if !pipeline_specialization.dynamic_bindings.is_empty() {
+ // set binding uniforms to dynamic if render resource bindings use dynamic
+ for bind_group in layout.bind_groups.iter_mut() {
+ let mut binding_changed = false;
+ for binding in bind_group.bindings.iter_mut() {
+ if pipeline_specialization
+ .dynamic_bindings
+ .iter()
+ .any(|b| b == &binding.name)
+ {
+ if let BindType::Uniform {
+ ref mut dynamic, ..
+ } = binding.bind_type
+ {
+ *dynamic = true;
+ binding_changed = true;
+ }
+ }
+ }
+
+ if binding_changed {
+ bind_group.update_id();
+ }
+ }
+ }
+ specialized_descriptor.layout = Some(layout);
+
  // create a vertex layout that provides all attributes from either the specialized vertex buffers or a zero buffer
  let mut pipeline_layout = specialized_descriptor.layout.as_mut().unwrap();
  // the vertex buffer descriptor of the mesh

crates/bevy_render/src/pipeline/render_pipelines.rs

@@ -14,13 +14,16 @@ use bevy_property::Properties;
 pub struct RenderPipeline {
  pub pipeline: Handle<PipelineDescriptor>,
  pub specialization: PipelineSpecialization,
+ /// used to track if PipelineSpecialization::dynamic_bindings is in sync with RenderResourceBindings
+ pub dynamic_bindings_generation: usize,
 }
 
 impl RenderPipeline {
  pub fn new(pipeline: Handle<PipelineDescriptor>) -> Self {
  RenderPipeline {
+ specialization: Default::default(),
  pipeline,
- ..Default::default()
+ dynamic_bindings_generation: std::usize::MAX,
  }
  }
 
@@ -31,6 +34,7 @@ impl RenderPipeline {
  RenderPipeline {
  pipeline,
  specialization,
+ dynamic_bindings_generation: std::usize::MAX,
  }
  }
 }
@@ -100,10 +104,24 @@ pub fn draw_render_pipelines_system(
  let render_pipelines = &mut *render_pipelines;
  for pipeline in render_pipelines.pipelines.iter_mut() {
  pipeline.specialization.sample_count = msaa.samples;
- // TODO: move these to mesh.rs?
+ if pipeline.dynamic_bindings_generation
+ != render_pipelines.bindings.dynamic_bindings_generation()
+ {
+ pipeline.specialization.dynamic_bindings = render_pipelines
+ .bindings
+ .iter_dynamic_bindings()
+ .map(|name| name.to_string())
+ .collect::<Vec<String>>();
+ pipeline.dynamic_bindings_generation =
+ render_pipelines.bindings.dynamic_bindings_generation();
+ }
  }
 
- for render_pipeline in render_pipelines.pipelines.iter() {
+ for render_pipeline in render_pipelines.pipelines.iter_mut() {
+ let render_resource_bindings = &mut [
+ &mut render_pipelines.bindings,
+ &mut render_resource_bindings,
+ ];
  draw_context
  .set_pipeline(
  &mut draw,
@@ -112,13 +130,7 @@ pub fn draw_render_pipelines_system(
  )
  .unwrap();
  draw_context
- .set_bind_groups_from_bindings(
- &mut draw,
- &mut [
- &mut render_pipelines.bindings,
- &mut render_resource_bindings,
- ],
- )
+ .set_bind_groups_from_bindings(&mut draw, render_resource_bindings)
  .unwrap();
  draw_context
  .set_vertex_buffers_from_bindings(&mut draw, &[&render_pipelines.bindings])

crates/bevy_render/src/renderer/render_resource/render_resource_bindings.rs

@@ -35,6 +35,13 @@ impl RenderResourceBinding {
  }
  }
 
+ pub fn is_dynamic_buffer(&self) -> bool {
+ matches!(self, RenderResourceBinding::Buffer {
+ dynamic_index: Some(_),
+ ..
+ })
+ }
+
  pub fn get_sampler(&self) -> Option<SamplerId> {
  if let RenderResourceBinding::Sampler(sampler) = self {
  Some(*sampler)
@@ -103,7 +110,7 @@ pub enum BindGroupStatus {
 // PERF: if the bindings are scoped to a specific pipeline layout, then names could be replaced with indices here for a perf boost
 #[derive(Eq, PartialEq, Debug, Default, Clone)]
 pub struct RenderResourceBindings {
- bindings: HashMap<String, RenderResourceBinding>,
+ pub bindings: HashMap<String, RenderResourceBinding>,
  /// A Buffer that contains all attributes a mesh has defined
  pub vertex_attribute_buffer: Option<BufferId>,
  /// A Buffer that is filled with zeros that will be used for attributes required by the shader, but undefined by the mesh.
@@ -112,6 +119,7 @@ pub struct RenderResourceBindings {
  bind_groups: HashMap<BindGroupId, BindGroup>,
  bind_group_descriptors: HashMap<BindGroupDescriptorId, Option<BindGroupId>>,
  dirty_bind_groups: HashSet<BindGroupId>,
+ dynamic_bindings_generation: usize,
 }
 
 impl RenderResourceBindings {
@@ -124,9 +132,17 @@ impl RenderResourceBindings {
  self.bindings.insert(name.to_string(), binding);
  }
 
+ /// The current "generation" of dynamic bindings. This number increments every time a dynamic binding changes
+ pub fn dynamic_bindings_generation(&self) -> usize {
+ self.dynamic_bindings_generation
+ }
+
  fn try_set_dirty(&mut self, name: &str, binding: &RenderResourceBinding) {
  if let Some(current_binding) = self.bindings.get(name) {
  if current_binding != binding {
+ if current_binding.is_dynamic_buffer() {
+ self.dynamic_bindings_generation += 1;
+ }
  // TODO: this is crude. we shouldn't need to invalidate all bind groups
  for id in self.bind_groups.keys() {
  self.dirty_bind_groups.insert(*id);
@@ -236,6 +252,18 @@ impl RenderResourceBindings {
 
  Some(bind_group_builder.finish())
  }
+
+ pub fn iter_dynamic_bindings(&self) -> impl Iterator<Item = &str> {
+ self.bindings
+ .iter()
+ .filter(|(_, binding)| {
+ matches!(binding, RenderResourceBinding::Buffer {
+ dynamic_index: Some(_),
+ ..
+ })
+ })
+ .map(|(name, _)| name.as_str())
+ }
 }
 
 #[derive(Debug, Default)]

crates/bevy_render/src/renderer/render_resource_context.rs

@@ -1,7 +1,7 @@
 use crate::{
- pipeline::{BindGroupDescriptorId, PipelineDescriptor},
+ pipeline::{BindGroupDescriptorId, PipelineDescriptor, PipelineLayout},
  renderer::{BindGroup, BufferId, BufferInfo, RenderResourceId, SamplerId, TextureId},
- shader::Shader,
+ shader::{Shader, ShaderLayout, ShaderStages},
  texture::{SamplerDescriptor, TextureDescriptor},
 };
 use bevy_asset::{Asset, Assets, Handle, HandleUntyped};
@@ -60,6 +60,34 @@ pub trait RenderResourceContext: Downcast + Send + Sync + 'static {
  bind_group: &BindGroup,
  );
  fn clear_bind_groups(&self);
+ /// Reflects the pipeline layout from its shaders.
+ ///
+ /// If `bevy_conventions` is true, it will be assumed that the shader follows "bevy shader conventions". These allow
+ /// richer reflection, such as inferred Vertex Buffer names and inferred instancing.
+ ///
+ /// If `dynamic_bindings` has values, shader uniforms will be set to "dynamic" if there is a matching binding in the list
+ ///
+ /// If `vertex_buffer_descriptors` is set, the pipeline's vertex buffers
+ /// will inherit their layouts from global descriptors, otherwise the layout will be assumed to be complete / local.
+ fn reflect_pipeline_layout(
+ &self,
+ shaders: &Assets<Shader>,
+ shader_stages: &ShaderStages,
+ enforce_bevy_conventions: bool,
+ ) -> PipelineLayout {
+ // TODO: maybe move this default implementation to PipelineLayout?
+ let mut shader_layouts: Vec<ShaderLayout> = shader_stages
+ .iter()
+ .map(|handle| {
+ shaders
+ .get(&handle)
+ .unwrap()
+ .reflect_layout(enforce_bevy_conventions)
+ .unwrap()
+ })
+ .collect();
+ PipelineLayout::from_shader_layouts(&mut shader_layouts)
+ }
 }
 
 impl dyn RenderResourceContext {