wgpu/api/render_pass.rs
1use core::ops::Range;
2
3use crate::*;
4pub use wgt::{LoadOp, Operations, StoreOp};
5
6/// In-progress recording of a render pass: a list of render commands in a [`CommandEncoder`].
7///
8/// It can be created with [`CommandEncoder::begin_render_pass()`], whose [`RenderPassDescriptor`]
9/// specifies the attachments (textures) that will be rendered to.
10///
11/// Most of the methods on `RenderPass` serve one of two purposes, identifiable by their names:
12///
13/// * `draw_*()`: Drawing (that is, encoding a render command, which, when executed by the GPU, will
14/// rasterize something and execute shaders).
15/// * `set_*()`: Setting part of the [render state](https://gpuweb.github.io/gpuweb/#renderstate)
16/// for future drawing commands.
17///
18/// A render pass may contain any number of drawing commands, and before/between each command the
19/// render state may be updated however you wish; each drawing command will be executed using the
20/// render state that has been set when the `draw_*()` function is called.
21///
22/// Corresponds to [WebGPU `GPURenderPassEncoder`](
23/// https://gpuweb.github.io/gpuweb/#render-pass-encoder).
24#[derive(Debug)]
25pub struct RenderPass<'encoder> {
26 pub(crate) inner: dispatch::DispatchRenderPass,
27
28 /// This lifetime is used to protect the [`CommandEncoder`] from being used
29 /// while the pass is alive. This needs to be PhantomDrop to prevent the lifetime
30 /// from being shortened.
31 pub(crate) _encoder_guard: PhantomDrop<&'encoder ()>,
32}
33
34#[cfg(send_sync)]
35static_assertions::assert_impl_all!(RenderPass<'_>: Send, Sync);
36
37crate::cmp::impl_eq_ord_hash_proxy!(RenderPass<'_> => .inner);
38
39impl RenderPass<'_> {
40 /// Drops the lifetime relationship to the parent command encoder, making usage of
41 /// the encoder while this pass is recorded a run-time error instead.
42 ///
43 /// Attention: As long as the render pass has not been ended, any mutating operation on the parent
44 /// command encoder will cause a run-time error and invalidate it!
45 /// By default, the lifetime constraint prevents this, but it can be useful
46 /// to handle this at run time, such as when storing the pass and encoder in the same
47 /// data structure.
48 ///
49 /// This operation has no effect on pass recording.
50 /// It's a safe operation, since [`CommandEncoder`] is in a locked state as long as the pass is active
51 /// regardless of the lifetime constraint or its absence.
52 pub fn forget_lifetime(self) -> RenderPass<'static> {
53 RenderPass {
54 inner: self.inner,
55 _encoder_guard: crate::api::PhantomDrop::default(),
56 }
57 }
58
59 /// Sets the active bind group for a given bind group index. The bind group layout
60 /// in the active pipeline when any `draw_*()` method is called must match the layout of
61 /// this bind group.
62 ///
63 /// If the bind group have dynamic offsets, provide them in binding order.
64 /// These offsets have to be aligned to [`Limits::min_uniform_buffer_offset_alignment`]
65 /// or [`Limits::min_storage_buffer_offset_alignment`] appropriately.
66 ///
67 /// Subsequent draw calls’ shader executions will be able to access data in these bind groups.
68 pub fn set_bind_group<'a, BG>(&mut self, index: u32, bind_group: BG, offsets: &[DynamicOffset])
69 where
70 Option<&'a BindGroup>: From<BG>,
71 {
72 let bg: Option<&'a BindGroup> = bind_group.into();
73 let bg = bg.map(|bg| &bg.inner);
74
75 self.inner.set_bind_group(index, bg, offsets);
76 }
77
78 /// Sets the active render pipeline.
79 ///
80 /// Subsequent draw calls will exhibit the behavior defined by `pipeline`.
81 pub fn set_pipeline(&mut self, pipeline: &RenderPipeline) {
82 self.inner.set_pipeline(&pipeline.inner);
83 }
84
85 /// Sets the blend color as used by some of the blending modes.
86 ///
87 /// Subsequent blending tests will test against this value.
88 /// If this method has not been called, the blend constant defaults to [`Color::TRANSPARENT`]
89 /// (all components zero).
90 pub fn set_blend_constant(&mut self, color: Color) {
91 self.inner.set_blend_constant(color);
92 }
93
94 /// Sets the active index buffer.
95 ///
96 /// Subsequent calls to [`draw_indexed`](RenderPass::draw_indexed) on this [`RenderPass`] will
97 /// use `buffer` as the source index buffer.
98 pub fn set_index_buffer(&mut self, buffer_slice: BufferSlice<'_>, index_format: IndexFormat) {
99 self.inner.set_index_buffer(
100 &buffer_slice.buffer.inner,
101 index_format,
102 buffer_slice.offset,
103 Some(buffer_slice.size),
104 );
105 }
106
107 /// Assign a vertex buffer to a slot.
108 ///
109 /// Subsequent calls to [`draw`] and [`draw_indexed`] on this
110 /// [`RenderPass`] will use `buffer` as one of the source vertex buffers.
111 /// The format of the data in the buffer is specified by the [`VertexBufferLayout`] in the
112 /// pipeline's [`VertexState`].
113 ///
114 /// The `slot` refers to the index of the matching descriptor in
115 /// [`VertexState::buffers`].
116 ///
117 /// [`draw`]: RenderPass::draw
118 /// [`draw_indexed`]: RenderPass::draw_indexed
119 pub fn set_vertex_buffer(&mut self, slot: u32, buffer_slice: BufferSlice<'_>) {
120 self.inner.set_vertex_buffer(
121 slot,
122 &buffer_slice.buffer.inner,
123 buffer_slice.offset,
124 Some(buffer_slice.size),
125 );
126 }
127
128 /// Sets the scissor rectangle used during the rasterization stage.
129 /// After transformation into [viewport coordinates](https://www.w3.org/TR/webgpu/#viewport-coordinates).
130 ///
131 /// Subsequent draw calls will discard any fragments which fall outside the scissor rectangle.
132 /// If this method has not been called, the scissor rectangle defaults to the entire bounds of
133 /// the render targets.
134 ///
135 /// The function of the scissor rectangle resembles [`set_viewport()`](Self::set_viewport),
136 /// but it does not affect the coordinate system, only which fragments are discarded.
137 pub fn set_scissor_rect(&mut self, x: u32, y: u32, width: u32, height: u32) {
138 self.inner.set_scissor_rect(x, y, width, height);
139 }
140
141 /// Sets the viewport used during the rasterization stage to linearly map
142 /// from [normalized device coordinates](https://www.w3.org/TR/webgpu/#ndc) to [viewport coordinates](https://www.w3.org/TR/webgpu/#viewport-coordinates).
143 ///
144 /// Subsequent draw calls will only draw within this region.
145 /// If this method has not been called, the viewport defaults to the entire bounds of the render
146 /// targets.
147 pub fn set_viewport(&mut self, x: f32, y: f32, w: f32, h: f32, min_depth: f32, max_depth: f32) {
148 self.inner.set_viewport(x, y, w, h, min_depth, max_depth);
149 }
150
151 /// Sets the stencil reference.
152 ///
153 /// Subsequent stencil tests will test against this value.
154 /// If this method has not been called, the stencil reference value defaults to `0`.
155 pub fn set_stencil_reference(&mut self, reference: u32) {
156 self.inner.set_stencil_reference(reference);
157 }
158
159 /// Inserts debug marker.
160 pub fn insert_debug_marker(&mut self, label: &str) {
161 self.inner.insert_debug_marker(label);
162 }
163
164 /// Start record commands and group it into debug marker group.
165 pub fn push_debug_group(&mut self, label: &str) {
166 self.inner.push_debug_group(label);
167 }
168
169 /// Stops command recording and creates debug group.
170 pub fn pop_debug_group(&mut self) {
171 self.inner.pop_debug_group();
172 }
173
174 /// Draws primitives from the active vertex buffer(s).
175 ///
176 /// The active vertex buffer(s) can be set with [`RenderPass::set_vertex_buffer`].
177 /// This does not use an index buffer. If you need indexed drawing, see [`RenderPass::draw_indexed`]
178 ///
179 /// Panics if `vertices` range is outside of the range of the vertices range of any set vertex buffer.
180 ///
181 /// - `vertices`: The range of vertices to draw.
182 /// - `instances`: Range of instances to draw. Use `0..1` if instance buffers are not used.
183 ///
184 /// E.g.of how its used internally
185 /// ```rust ignore
186 /// for instance_id in instance_range {
187 /// for vertex_id in vertex_range {
188 /// let vertex = vertex[vertex_id];
189 /// vertex_shader(vertex, vertex_id, instance_id);
190 /// }
191 /// }
192 /// ```
193 ///
194 /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
195 /// It is not affected by changes to the state that are performed after it is called.
196 pub fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
197 self.inner.draw(vertices, instances);
198 }
199
200 /// Draws indexed primitives using the active index buffer and the active vertex buffers.
201 ///
202 /// The active index buffer can be set with [`RenderPass::set_index_buffer`]
203 /// The active vertex buffers can be set with [`RenderPass::set_vertex_buffer`].
204 ///
205 /// Panics if `indices` range is outside of the range of the indices range of the set index buffer.
206 ///
207 /// - `indices`: The range of indices to draw.
208 /// - `base_vertex`: value added to each index value before indexing into the vertex buffers.
209 /// - `instances`: Range of instances to draw. Use `0..1` if instance buffers are not used.
210 ///
211 /// E.g.of how its used internally
212 /// ```rust ignore
213 /// for instance_id in instance_range {
214 /// for index_index in index_range {
215 /// let vertex_id = index_buffer[index_index];
216 /// let adjusted_vertex_id = vertex_id + base_vertex;
217 /// let vertex = vertex[adjusted_vertex_id];
218 /// vertex_shader(vertex, adjusted_vertex_id, instance_id);
219 /// }
220 /// }
221 /// ```
222 ///
223 /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
224 /// It is not affected by changes to the state that are performed after it is called.
225 pub fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>) {
226 self.inner.draw_indexed(indices, base_vertex, instances);
227 }
228
229 /// Draws primitives from the active vertex buffer(s) based on the contents of the `indirect_buffer`.
230 ///
231 /// This is like calling [`RenderPass::draw`] but the contents of the call are specified in the `indirect_buffer`.
232 /// The structure expected in `indirect_buffer` must conform to [`DrawIndirectArgs`](crate::util::DrawIndirectArgs).
233 pub fn draw_indirect(&mut self, indirect_buffer: &Buffer, indirect_offset: BufferAddress) {
234 self.inner
235 .draw_indirect(&indirect_buffer.inner, indirect_offset);
236 }
237
238 /// Draws indexed primitives using the active index buffer and the active vertex buffers,
239 /// based on the contents of the `indirect_buffer`.
240 ///
241 /// This is like calling [`RenderPass::draw_indexed`] but the contents of the call are specified in the `indirect_buffer`.
242 /// The structure expected in `indirect_buffer` must conform to [`DrawIndexedIndirectArgs`](crate::util::DrawIndexedIndirectArgs).
243 pub fn draw_indexed_indirect(
244 &mut self,
245 indirect_buffer: &Buffer,
246 indirect_offset: BufferAddress,
247 ) {
248 self.inner
249 .draw_indexed_indirect(&indirect_buffer.inner, indirect_offset);
250 }
251
252 /// Execute a [render bundle][RenderBundle], which is a set of pre-recorded commands
253 /// that can be run together.
254 ///
255 /// Commands in the bundle do not inherit this render pass's current render state, and after the
256 /// bundle has executed, the state is **cleared** (reset to defaults, not the previous state).
257 pub fn execute_bundles<'a, I: IntoIterator<Item = &'a RenderBundle>>(
258 &mut self,
259 render_bundles: I,
260 ) {
261 let mut render_bundles = render_bundles.into_iter().map(|rb| &rb.inner);
262
263 self.inner.execute_bundles(&mut render_bundles);
264 }
265}
266
267/// [`Features::MULTI_DRAW_INDIRECT`] must be enabled on the device in order to call these functions.
268impl RenderPass<'_> {
269 /// Dispatches multiple draw calls from the active vertex buffer(s) based on the contents of the `indirect_buffer`.
270 /// `count` draw calls are issued.
271 ///
272 /// The active vertex buffers can be set with [`RenderPass::set_vertex_buffer`].
273 ///
274 /// The structure expected in `indirect_buffer` must conform to [`DrawIndirectArgs`](crate::util::DrawIndirectArgs).
275 /// These draw structures are expected to be tightly packed.
276 ///
277 /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
278 /// It is not affected by changes to the state that are performed after it is called.
279 pub fn multi_draw_indirect(
280 &mut self,
281 indirect_buffer: &Buffer,
282 indirect_offset: BufferAddress,
283 count: u32,
284 ) {
285 self.inner
286 .multi_draw_indirect(&indirect_buffer.inner, indirect_offset, count);
287 }
288
289 /// Dispatches multiple draw calls from the active index buffer and the active vertex buffers,
290 /// based on the contents of the `indirect_buffer`. `count` draw calls are issued.
291 ///
292 /// The active index buffer can be set with [`RenderPass::set_index_buffer`], while the active
293 /// vertex buffers can be set with [`RenderPass::set_vertex_buffer`].
294 ///
295 /// The structure expected in `indirect_buffer` must conform to [`DrawIndexedIndirectArgs`](crate::util::DrawIndexedIndirectArgs).
296 /// These draw structures are expected to be tightly packed.
297 ///
298 /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
299 /// It is not affected by changes to the state that are performed after it is called.
300 pub fn multi_draw_indexed_indirect(
301 &mut self,
302 indirect_buffer: &Buffer,
303 indirect_offset: BufferAddress,
304 count: u32,
305 ) {
306 self.inner
307 .multi_draw_indexed_indirect(&indirect_buffer.inner, indirect_offset, count);
308 }
309
310 #[cfg(custom)]
311 /// Returns custom implementation of RenderPass (if custom backend and is internally T)
312 pub fn as_custom<T: custom::RenderPassInterface>(&self) -> Option<&T> {
313 self.inner.as_custom()
314 }
315}
316
317/// [`Features::MULTI_DRAW_INDIRECT_COUNT`] must be enabled on the device in order to call these functions.
318impl RenderPass<'_> {
319 /// Dispatches multiple draw calls from the active vertex buffer(s) based on the contents of the `indirect_buffer`.
320 /// The count buffer is read to determine how many draws to issue.
321 ///
322 /// The indirect buffer must be long enough to account for `max_count` draws, however only `count`
323 /// draws will be read. If `count` is greater than `max_count`, `max_count` will be used.
324 ///
325 /// The active vertex buffers can be set with [`RenderPass::set_vertex_buffer`].
326 ///
327 /// The structure expected in `indirect_buffer` must conform to [`DrawIndirectArgs`](crate::util::DrawIndirectArgs).
328 /// These draw structures are expected to be tightly packed.
329 ///
330 /// The structure expected in `count_buffer` is the following:
331 ///
332 /// ```rust
333 /// #[repr(C)]
334 /// struct DrawIndirectCount {
335 /// count: u32, // Number of draw calls to issue.
336 /// }
337 /// ```
338 ///
339 /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
340 /// It is not affected by changes to the state that are performed after it is called.
341 pub fn multi_draw_indirect_count(
342 &mut self,
343 indirect_buffer: &Buffer,
344 indirect_offset: BufferAddress,
345 count_buffer: &Buffer,
346 count_offset: BufferAddress,
347 max_count: u32,
348 ) {
349 self.inner.multi_draw_indirect_count(
350 &indirect_buffer.inner,
351 indirect_offset,
352 &count_buffer.inner,
353 count_offset,
354 max_count,
355 );
356 }
357
358 /// Dispatches multiple draw calls from the active index buffer and the active vertex buffers,
359 /// based on the contents of the `indirect_buffer`. The count buffer is read to determine how many draws to issue.
360 ///
361 /// The indirect buffer must be long enough to account for `max_count` draws, however only `count`
362 /// draws will be read. If `count` is greater than `max_count`, `max_count` will be used.
363 ///
364 /// The active index buffer can be set with [`RenderPass::set_index_buffer`], while the active
365 /// vertex buffers can be set with [`RenderPass::set_vertex_buffer`].
366 ///
367 /// The structure expected in `indirect_buffer` must conform to [`DrawIndexedIndirectArgs`](crate::util::DrawIndexedIndirectArgs).
368 ///
369 /// These draw structures are expected to be tightly packed.
370 ///
371 /// The structure expected in `count_buffer` is the following:
372 ///
373 /// ```rust
374 /// #[repr(C)]
375 /// struct DrawIndexedIndirectCount {
376 /// count: u32, // Number of draw calls to issue.
377 /// }
378 /// ```
379 ///
380 /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
381 /// It is not affected by changes to the state that are performed after it is called.
382 pub fn multi_draw_indexed_indirect_count(
383 &mut self,
384 indirect_buffer: &Buffer,
385 indirect_offset: BufferAddress,
386 count_buffer: &Buffer,
387 count_offset: BufferAddress,
388 max_count: u32,
389 ) {
390 self.inner.multi_draw_indexed_indirect_count(
391 &indirect_buffer.inner,
392 indirect_offset,
393 &count_buffer.inner,
394 count_offset,
395 max_count,
396 );
397 }
398}
399
400/// [`Features::PUSH_CONSTANTS`] must be enabled on the device in order to call these functions.
401impl RenderPass<'_> {
402 /// Set push constant data for subsequent draw calls.
403 ///
404 /// Write the bytes in `data` at offset `offset` within push constant
405 /// storage, all of which are accessible by all the pipeline stages in
406 /// `stages`, and no others. Both `offset` and the length of `data` must be
407 /// multiples of [`PUSH_CONSTANT_ALIGNMENT`], which is always 4.
408 ///
409 /// For example, if `offset` is `4` and `data` is eight bytes long, this
410 /// call will write `data` to bytes `4..12` of push constant storage.
411 ///
412 /// # Stage matching
413 ///
414 /// Every byte in the affected range of push constant storage must be
415 /// accessible to exactly the same set of pipeline stages, which must match
416 /// `stages`. If there are two bytes of storage that are accessible by
417 /// different sets of pipeline stages - say, one is accessible by fragment
418 /// shaders, and the other is accessible by both fragment shaders and vertex
419 /// shaders - then no single `set_push_constants` call may affect both of
420 /// them; to write both, you must make multiple calls, each with the
421 /// appropriate `stages` value.
422 ///
423 /// Which pipeline stages may access a given byte is determined by the
424 /// pipeline's [`PushConstant`] global variable and (if it is a struct) its
425 /// members' offsets.
426 ///
427 /// For example, suppose you have twelve bytes of push constant storage,
428 /// where bytes `0..8` are accessed by the vertex shader, and bytes `4..12`
429 /// are accessed by the fragment shader. This means there are three byte
430 /// ranges each accessed by a different set of stages:
431 ///
432 /// - Bytes `0..4` are accessed only by the fragment shader.
433 ///
434 /// - Bytes `4..8` are accessed by both the fragment shader and the vertex shader.
435 ///
436 /// - Bytes `8..12` are accessed only by the vertex shader.
437 ///
438 /// To write all twelve bytes requires three `set_push_constants` calls, one
439 /// for each range, each passing the matching `stages` mask.
440 ///
441 /// [`PushConstant`]: https://docs.rs/naga/latest/naga/enum.StorageClass.html#variant.PushConstant
442 pub fn set_push_constants(&mut self, stages: ShaderStages, offset: u32, data: &[u8]) {
443 self.inner.set_push_constants(stages, offset, data);
444 }
445}
446
447/// [`Features::TIMESTAMP_QUERY_INSIDE_PASSES`] must be enabled on the device in order to call these functions.
448impl RenderPass<'_> {
449 /// Issue a timestamp command at this point in the queue. The
450 /// timestamp will be written to the specified query set, at the specified index.
451 ///
452 /// Must be multiplied by [`Queue::get_timestamp_period`] to get
453 /// the value in nanoseconds. Absolute values have no meaning,
454 /// but timestamps can be subtracted to get the time it takes
455 /// for a string of operations to complete.
456 pub fn write_timestamp(&mut self, query_set: &QuerySet, query_index: u32) {
457 self.inner.write_timestamp(&query_set.inner, query_index);
458 }
459}
460
461impl RenderPass<'_> {
462 /// Start a occlusion query on this render pass. It can be ended with
463 /// [`end_occlusion_query`](Self::end_occlusion_query).
464 /// Occlusion queries may not be nested.
465 pub fn begin_occlusion_query(&mut self, query_index: u32) {
466 self.inner.begin_occlusion_query(query_index);
467 }
468
469 /// End the occlusion query on this render pass. It can be started with
470 /// [`begin_occlusion_query`](Self::begin_occlusion_query).
471 /// Occlusion queries may not be nested.
472 pub fn end_occlusion_query(&mut self) {
473 self.inner.end_occlusion_query();
474 }
475}
476
477/// [`Features::PIPELINE_STATISTICS_QUERY`] must be enabled on the device in order to call these functions.
478impl RenderPass<'_> {
479 /// Start a pipeline statistics query on this render pass. It can be ended with
480 /// [`end_pipeline_statistics_query`](Self::end_pipeline_statistics_query).
481 /// Pipeline statistics queries may not be nested.
482 pub fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, query_index: u32) {
483 self.inner
484 .begin_pipeline_statistics_query(&query_set.inner, query_index);
485 }
486
487 /// End the pipeline statistics query on this render pass. It can be started with
488 /// [`begin_pipeline_statistics_query`](Self::begin_pipeline_statistics_query).
489 /// Pipeline statistics queries may not be nested.
490 pub fn end_pipeline_statistics_query(&mut self) {
491 self.inner.end_pipeline_statistics_query();
492 }
493}
494
495/// Describes the timestamp writes of a render pass.
496///
497/// For use with [`RenderPassDescriptor`].
498/// At least one of [`Self::beginning_of_pass_write_index`] and [`Self::end_of_pass_write_index`]
499/// must be `Some`.
500///
501/// Corresponds to [WebGPU `GPURenderPassTimestampWrite`](
502/// https://gpuweb.github.io/gpuweb/#dictdef-gpurenderpasstimestampwrites).
503#[derive(Clone, Debug)]
504pub struct RenderPassTimestampWrites<'a> {
505 /// The query set to write to.
506 pub query_set: &'a QuerySet,
507 /// The index of the query set at which a start timestamp of this pass is written, if any.
508 pub beginning_of_pass_write_index: Option<u32>,
509 /// The index of the query set at which an end timestamp of this pass is written, if any.
510 pub end_of_pass_write_index: Option<u32>,
511}
512#[cfg(send_sync)]
513static_assertions::assert_impl_all!(RenderPassTimestampWrites<'_>: Send, Sync);
514
515/// Describes a color attachment to a [`RenderPass`].
516///
517/// For use with [`RenderPassDescriptor`].
518///
519/// Corresponds to [WebGPU `GPURenderPassColorAttachment`](
520/// https://gpuweb.github.io/gpuweb/#color-attachments).
521#[derive(Clone, Debug)]
522pub struct RenderPassColorAttachment<'tex> {
523 /// The view to use as an attachment.
524 pub view: &'tex TextureView,
525 /// The depth slice index of a 3D view. It must not be provided if the view is not 3D.
526 pub depth_slice: Option<u32>,
527 /// The view that will receive the resolved output if multisampling is used.
528 ///
529 /// If set, it is always written to, regardless of how [`Self::ops`] is configured.
530 pub resolve_target: Option<&'tex TextureView>,
531 /// What operations will be performed on this color attachment.
532 pub ops: Operations<Color>,
533}
534#[cfg(send_sync)]
535static_assertions::assert_impl_all!(RenderPassColorAttachment<'_>: Send, Sync);
536
537/// Describes a depth/stencil attachment to a [`RenderPass`].
538///
539/// For use with [`RenderPassDescriptor`].
540///
541/// Corresponds to [WebGPU `GPURenderPassDepthStencilAttachment`](
542/// https://gpuweb.github.io/gpuweb/#depth-stencil-attachments).
543#[derive(Clone, Debug)]
544pub struct RenderPassDepthStencilAttachment<'tex> {
545 /// The view to use as an attachment.
546 pub view: &'tex TextureView,
547 /// What operations will be performed on the depth part of the attachment.
548 pub depth_ops: Option<Operations<f32>>,
549 /// What operations will be performed on the stencil part of the attachment.
550 pub stencil_ops: Option<Operations<u32>>,
551}
552#[cfg(send_sync)]
553static_assertions::assert_impl_all!(RenderPassDepthStencilAttachment<'_>: Send, Sync);
554
555/// Describes the attachments of a render pass.
556///
557/// For use with [`CommandEncoder::begin_render_pass`].
558///
559/// Corresponds to [WebGPU `GPURenderPassDescriptor`](
560/// https://gpuweb.github.io/gpuweb/#dictdef-gpurenderpassdescriptor).
561#[derive(Clone, Debug, Default)]
562pub struct RenderPassDescriptor<'a> {
563 /// Debug label of the render pass. This will show up in graphics debuggers for easy identification.
564 pub label: Label<'a>,
565 /// The color attachments of the render pass.
566 pub color_attachments: &'a [Option<RenderPassColorAttachment<'a>>],
567 /// The depth and stencil attachment of the render pass, if any.
568 pub depth_stencil_attachment: Option<RenderPassDepthStencilAttachment<'a>>,
569 /// Defines which timestamp values will be written for this pass, and where to write them to.
570 ///
571 /// Requires [`Features::TIMESTAMP_QUERY`] to be enabled.
572 pub timestamp_writes: Option<RenderPassTimestampWrites<'a>>,
573 /// Defines where the occlusion query results will be stored for this pass.
574 pub occlusion_query_set: Option<&'a QuerySet>,
575}
576#[cfg(send_sync)]
577static_assertions::assert_impl_all!(RenderPassDescriptor<'_>: Send, Sync);