Chainable RenderPass

[zahash]

let mut render_pass = encoder.begin_render_pass(&RenderPassDescriptor { ... });

render_pass.set_pipeline(&self.render_pipeline);
render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
render_pass.draw_indexed(0..INDICES.len() as u32, 0, 0..1);

drop(render_pass); // explicitly drop render_pass to release the &mut ref to CommandEncoder

self.queue.submit([encoder.finish()]);

why not make RenderPass methods chainable to avoid explicit drop?

encoder
    .begin_render_pass(&RenderPassDescriptor { ... })
    .set_pipeline(&self.render_pipeline)
    .set_vertex_buffer(0, self.vertex_buffer.slice(..))
    .set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16)
    .draw_indexed(0..INDICES.len() as u32, 0, 0..1);

self.queue.submit([encoder.finish()]);

by changing the signature to return &mut Self

pub fn set_pipeline(&mut self, pipeline: &'a RenderPipeline) -> &mut Self {
    DynContext::render_pass_set_pipeline(
        &*self.parent.context,
        &mut self.id,
        self.data.as_mut(),
        &pipeline.id,
        pipeline.data.as_ref(),
    );
    self
}

[solarretrace]

You can already avoid the explicit drop by creating your render pass in a scope:

{
    let mut render_pass = encoder.begin_render_pass(&RenderPassDescriptor { ... });

    render_pass.set_pipeline(&self.render_pipeline);
    render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
    render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
    render_pass.draw_indexed(0..INDICES.len() as u32, 0, 0..1);
}

self.queue.submit([encoder.finish()]);

Wouldn't you end up putting it behind a function call anyway? Especially if you have multiple render passes?