crates/renderer/src/egui.rs

@@ -631,6 +631,7 @@ pub fn egui_pass(
 
     let record: Box<RecordFn> = Box::new({
         let pipeline = egui_state.pipeline.clone();
+        let pipeline_layout = egui_state.pipeline_layout.clone();
         let descriptor_set = egui_state.descriptor_set;
         let screen_rect = egui.screen_rect();
 
@@ -732,7 +733,7 @@ pub fn egui_pass(
             cmd.bind_indices(indices.raw(), 0, vk::IndexType::UINT32);
             cmd.bind_vertex_buffers(&[vertices.raw()], &[0]);
             cmd.push_constants(
-                pipeline.layout(),
+                &pipeline_layout,
                 vk::ShaderStageFlags::VERTEX,
                 0,
                 bytemuck::cast_slice(
@@ -740,7 +741,7 @@ pub fn egui_pass(
                 ),
             );
             cmd.bind_descriptor_sets(
-                pipeline.layout(),
+                &pipeline_layout,
                 vk::PipelineBindPoint::GRAPHICS,
                 &[descriptor_set],
             );

crates/renderer/src/lib.rs

@@ -690,6 +690,7 @@ pub struct EguiState {
     descriptor_set: vk::DescriptorSet,
     #[allow(unused)]
     descriptor_layout: pipeline::DescriptorSetLayout,
+    pipeline_layout: Arc<pipeline::PipelineLayout>,
     pipeline: Arc<pipeline::Pipeline>,
 }
 
@@ -788,7 +789,7 @@ impl EguiState {
                 Result::Ok((descriptor_pool, descriptor_layout, sets))
             })?;
 
-        let pipeline_layout = Arc::new(pipeline::PipelineLayout::new(
+        let pipeline_layout = pipeline::PipelineLayout::new(
             device.clone(),
             pipeline::PipelineLayoutDesc {
                 descriptor_set_layouts: &[&descriptor_layout],
@@ -799,7 +800,7 @@ impl EguiState {
                 }],
                 name: Some("egui-pipeline-layout".into()),
             },
-        )?);
+        )?;
 
         let frag_shader = pipeline::ShaderModule::new_from_path(
             device.clone(),
@@ -830,7 +831,7 @@ impl EguiState {
                     },
                 ],
                 render_pass: None,
-                layout: pipeline_layout,
+                layout: &pipeline_layout,
                 subpass: None,
                 base_pipeline: None,
                 vertex_input: Some(pipeline::VertexInputState {
@@ -914,6 +915,7 @@ impl EguiState {
             descriptor_layout,
             descriptor_set: sets[0],
             pipeline: Arc::new(pipeline),
+            pipeline_layout: Arc::new(pipeline_layout),
         })
     }
 

crates/renderer/src/pipeline.rs

@@ -773,9 +773,6 @@ impl Pipeline {
     pub fn bind_point(&self) -> vk::PipelineBindPoint {
         self.bind_point
     }
-    pub fn layout(&self) -> &Arc<PipelineLayout> {
-        &self.layout
-    }
 }
 
 pub(crate) mod pipeline_cache {

crates/renderer/src/render_graph/commands.rs

@@ -14,7 +14,6 @@
 
 use crate::{
     device::DeviceOwned,
-    pipeline::Pipeline,
     render_graph::recorder::{CommandRecorder, SideEffectMap},
 };
 
@@ -319,26 +318,18 @@ impl Command for EndRendering {
     fn apply(self, _recorder: &mut CommandRecorder) {}
 }
 
-pub struct BindPipeline<'cmd>(pub &'cmd Pipeline);
+pub struct BindPipeline;
 
-impl<'cmd> Command for BindPipeline<'cmd> {
+impl Command for BindPipeline {
     fn side_effects(&self, _map: SideEffectMap) {
         // No resource access, but affects the pipeline state
     }
 
-    fn apply(self, recorder: &mut CommandRecorder) {
-        let cmd = recorder.cmd_buffer();
-        let dev = &cmd.device().raw;
-
-        unsafe {
-            dev.cmd_bind_pipeline(cmd.raw(), self.0.bind_point(), self.0.raw());
-        }
-    }
+    fn apply(self, _recorder: &mut CommandRecorder) {}
 }
 
 pub struct BindVertexBuffers {
     pub buffers: Vec<BufferSlice>,
-    pub first_binding: u32,
 }
 
 impl Command for BindVertexBuffers {
@@ -352,26 +343,7 @@ impl Command for BindVertexBuffers {
         }
     }
 
-    fn apply(self, recorder: &mut CommandRecorder) {
-        let cmd = recorder.cmd_buffer();
-        let dev = &cmd.device().raw;
-
-        let buffers = self
-            .buffers
-            .iter()
-            .map(|buffer| recorder.get_buffer_handle(buffer.id()))
-            .collect::<Vec<_>>();
-
-        let offsets = self
-            .buffers
-            .iter()
-            .map(|buffer| buffer.range.offset)
-            .collect::<Vec<_>>();
-
-        unsafe {
-            dev.cmd_bind_vertex_buffers(cmd.raw(), self.first_binding, &buffers, &offsets);
-        }
-    }
+    fn apply(self, _recorder: &mut CommandRecorder) {}
 }
 
 pub struct BindIndexBuffer(pub BufferSlice, pub IndexFormat);
@@ -382,50 +354,17 @@ impl Command for BindIndexBuffer {
             .side_effect(map.reborrow(), vk::AccessFlags2::INDEX_READ, None);
     }
 
-    fn apply(self, recorder: &mut CommandRecorder) {
-        let cmd = recorder.cmd_buffer();
-        let dev = &cmd.device().raw;
-
-        let buffer = recorder.get_buffer_handle(self.0.id());
-        let index_type = match self.1 {
-            IndexFormat::Uint8 => vk::IndexType::UINT8_KHR,
-            IndexFormat::Uint16 => vk::IndexType::UINT16,
-            IndexFormat::Uint32 => vk::IndexType::UINT32,
-        };
-
-        unsafe {
-            dev.cmd_bind_index_buffer(cmd.raw(), buffer, self.0.range.offset, index_type);
-        }
-    }
+    fn apply(self, _recorder: &mut CommandRecorder) {}
 }
 
-pub struct BindDescriptorSets {
-    pub first_set: u32,
-    pub pipeline_layout: vk::PipelineLayout,
-    pub bind_point: vk::PipelineBindPoint,
-    pub sets: Vec<vk::DescriptorSet>,
-}
+pub struct BindDescriptorSets;
 
 impl Command for BindDescriptorSets {
     fn side_effects(&self, _map: SideEffectMap) {
         // No resource access, but affects the descriptor set state
     }
 
-    fn apply(self, recorder: &mut CommandRecorder) {
-        let cmd = recorder.cmd_buffer();
-        let dev = &cmd.device().raw;
-
-        unsafe {
-            dev.cmd_bind_descriptor_sets(
-                cmd.raw(),
-                self.bind_point,
-                self.pipeline_layout,
-                self.first_set,
-                &self.sets,
-                &[],
-            );
-        }
-    }
+    fn apply(self, _recorder: &mut CommandRecorder) {}
 }
 
 pub struct SetViewport {
@@ -460,32 +399,14 @@ impl Command for SetScissor {
     fn apply(self, _recorder: &mut CommandRecorder) {}
 }
 
-pub struct PushConstants {
-    pub pipeline_layout: vk::PipelineLayout,
-    pub stage_flags: vk::ShaderStageFlags,
-    pub offset: u32,
-    pub data: Vec<u8>,
-}
+pub struct PushConstants;
 
 impl Command for PushConstants {
     fn side_effects(&self, _map: SideEffectMap) {
         // No resource access, but affects the push constant state
     }
 
-    fn apply(self, recorder: &mut CommandRecorder) {
-        let cmd = recorder.cmd_buffer();
-        let dev = &cmd.device().raw;
-
-        unsafe {
-            dev.cmd_push_constants(
-                cmd.raw(),
-                self.pipeline_layout,
-                self.stage_flags,
-                self.offset,
-                &self.data,
-            );
-        }
-    }
+    fn apply(self, _recorder: &mut CommandRecorder) {}
 }
 
 pub struct DrawData {
@@ -602,8 +523,8 @@ impl<T: Resource, U: Resource> OutsideRenderPass for Copy<T, U> {}
 impl OutsideRenderPass for ClearTexture {}
 impl OutsideRenderPass for UpdateBuffer {}
 
-impl InsideRenderPass for BindPipeline<'_> {}
-impl OutsideRenderPass for BindPipeline<'_> {}
+impl InsideRenderPass for BindPipeline {}
+impl OutsideRenderPass for BindPipeline {}
 impl InsideRenderPass for BindVertexBuffers {}
 impl OutsideRenderPass for BindVertexBuffers {}
 impl InsideRenderPass for BindIndexBuffer {}

crates/renderer/src/render_graph/recorder.rs

@@ -1,6 +1,5 @@
 use std::{
     collections::{BTreeMap, BTreeSet},
-    marker::PhantomData,
     mem::{MaybeUninit, size_of},
     ptr::NonNull,
 };
@@ -97,40 +96,37 @@ impl<'a> SideEffectMap<'a> {
     }
 }
 
-pub struct CommandList<'cmd> {
+pub struct CommandList {
     command_bytes: Vec<MaybeUninit<u8>>,
     cursor: usize,
     // each command that accesses a resource adds an entry to this map (id, command_index) -> access
     // during command recording, we fold accesses to the same resource as commands are recorded, and when a command reads a resource, we check for any previous writes to be made available/visible
     side_effects: SideEffects,
     num_commands: u32,
-
-    _pd: PhantomData<fn(&'cmd ())>,
 }
 
 #[must_use]
-pub struct RenderPass<'cmd, 'a> {
-    cmd_list: &'a mut CommandList<'cmd>,
+pub struct RenderPass<'a> {
+    cmd_list: &'a mut CommandList,
 }
 
-impl<'cmd, 'a> RenderPass<'cmd, 'a> {
+impl<'a> RenderPass<'a> {
     pub fn finalise(self) {
         self.cmd_list.push_inner(super::commands::EndRendering);
     }
 
-    pub fn push<C: Command + InsideRenderPass + 'cmd>(&mut self, command: C) {
+    pub fn push<C: Command + InsideRenderPass>(&mut self, command: C) {
         self.cmd_list.push_inner(command);
     }
 }
 
-impl<'cmd> CommandList<'cmd> {
+impl CommandList {
     pub fn new() -> Self {
         Self {
             command_bytes: Vec::new(),
             cursor: 0,
             side_effects: SideEffects::default(),
             num_commands: 0,
-            _pd: PhantomData,
         }
     }
 
@@ -141,7 +137,7 @@ impl<'cmd> CommandList<'cmd> {
         stencil_attachment: Option<TextureRegion>,
         area: (u32, u32),
         layers: u32,
-    ) -> RenderPass<'cmd, '_> {
+    ) -> RenderPass<'_> {
         self.push(super::commands::BeginRendering {
             color_attachments,
             depth_attachment,
@@ -152,7 +148,7 @@ impl<'cmd> CommandList<'cmd> {
         RenderPass { cmd_list: self }
     }
 
-    pub fn push<C: Command + OutsideRenderPass + 'cmd>(&mut self, command: C) {
+    pub fn push<C: Command + OutsideRenderPass>(&mut self, command: C) {
         self.push_inner(command);
     }
 

crates/renderer/src/render_graph/resources.rs

@@ -258,6 +258,9 @@ mod impls {
     }
 }
 
+pub struct Pipeline;
+pub struct DescriptorSet;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct ResourceId(pub u32);
 

crates/renderer/src/rendering/mod.rs

@@ -26,6 +26,7 @@ pub struct Wireframe {
     num_indices: u32,
     colors: Arc<Buffer>,
     pipeline: Arc<pipeline::Pipeline>,
+    layout: Arc<pipeline::PipelineLayout>,
 }
 
 impl Wireframe {
@@ -167,7 +168,7 @@ impl Wireframe {
             Arc::new(sync::Fence::from_pool(&dev.pools.fences, None)?),
         )?;
 
-        let pipeline = Self::create_pipeline(dev.clone())?;
+        let (pipeline, layout) = Self::create_pipeline(dev.clone())?;
 
         future.await;
 
@@ -176,12 +177,13 @@ impl Wireframe {
             indices: Arc::new(indices),
             colors: Arc::new(colors),
             pipeline: Arc::new(pipeline),
+            layout: Arc::new(layout),
             num_indices,
         })
     }
 
-    fn create_pipeline(device: Device) -> Result<pipeline::Pipeline> {
-        let pipeline_layout = Arc::new(pipeline::PipelineLayout::new(
+    fn create_pipeline(device: Device) -> Result<(pipeline::Pipeline, pipeline::PipelineLayout)> {
+        let pipeline_layout = pipeline::PipelineLayout::new(
             device.clone(),
             pipeline::PipelineLayoutDesc {
                 descriptor_set_layouts: &[],
@@ -192,7 +194,7 @@ impl Wireframe {
                 }],
                 name: Some("wireframe-pipeline-layout".into()),
             },
-        )?);
+        )?;
 
         let shader = pipeline::ShaderModule::new_from_path(
             device.clone(),
@@ -219,7 +221,7 @@ impl Wireframe {
                     },
                 ],
                 render_pass: None,
-                layout: pipeline_layout,
+                layout: &pipeline_layout,
                 subpass: None,
                 base_pipeline: None,
                 vertex_input: Some(pipeline::VertexInputState {
@@ -299,7 +301,7 @@ impl Wireframe {
             },
         )?;
 
-        Ok(pipeline)
+        Ok((pipeline, pipeline_layout))
     }
 
     pub fn pass(&self, rg: &mut RenderGraph, target: GraphResourceId) -> Result<()> {
@@ -313,6 +315,7 @@ impl Wireframe {
             let num_indices = self.num_indices;
 
             let pipeline = self.pipeline.clone();
+            let layout = self.layout.clone();
 
             move |ctx: &RenderContext| -> Result<()> {
                 let target = ctx.get_image(target).unwrap();
@@ -358,7 +361,7 @@ impl Wireframe {
                 cmd.bind_indices(indices.raw(), 0, vk::IndexType::UINT32);
                 cmd.bind_vertex_buffers(&[positions.raw(), colors.raw()], &[0, 0]);
                 cmd.push_constants(
-                    &pipeline.layout(),
+                    &layout,
                     vk::ShaderStageFlags::VERTEX,
                     0,
                     bytemuck::cast_slice(&[to_clip]),