mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-19 14:01:08 +01:00
4989 lines
173 KiB
Rust
4989 lines
173 KiB
Rust
use alloc::{borrow::Cow, boxed::Box, sync::Arc, vec::Vec};
|
|
use core::{convert::Infallible, fmt, num::NonZeroU32, ops::Range, str};
|
|
use parking_lot::Mutex;
|
|
use smallvec::SmallVec;
|
|
|
|
use arrayvec::ArrayVec;
|
|
use thiserror::Error;
|
|
use wgt::{
|
|
error::{ErrorType, WebGpuError},
|
|
BufferAddress, BufferSize, BufferUsages, Color, DynamicOffset, IndexFormat, InstanceFlags,
|
|
TextureSelector, TextureUsages, TextureViewDimension, VertexStepMode,
|
|
};
|
|
|
|
use crate::{
|
|
api_log,
|
|
binding_model::{BindError, BindGroup, ImmediateUploadError},
|
|
command::{
|
|
bind::Binder,
|
|
memory_init::{fixup_discarded_surfaces, SurfacesInDiscardState, TextureSurfaceDiscard},
|
|
pass::{self, flush_bindings_helper, ImmediateState},
|
|
pass_base, pass_try,
|
|
query::{
|
|
end_occlusion_query, end_pipeline_statistics_query, record_pass_timestamp_writes,
|
|
validate_and_begin_occlusion_query, validate_and_begin_pipeline_statistics_query,
|
|
QueryResetMap, QuerySetWrites,
|
|
},
|
|
render_command::ArcRenderCommand,
|
|
ArcCommand, ArcPassTimestampWrites, BasePass, BindGroupStateChange,
|
|
CommandBufferTextureMemoryActions, CommandEncoder, CommandEncoderError, DebugGroupError,
|
|
DrawCommandFamily, DrawError, DrawKind, EncoderStateError, EncodingState, ExecutionError,
|
|
InnerCommandEncoder, MapPassErr, PassErrorScope, PassStateError, PassTimestampWrites,
|
|
QueryUseError, Rect, RenderBundle, RenderCommandError, StateChange, TimestampWritesError,
|
|
},
|
|
device::{
|
|
AttachmentData, Device, DeviceError, MissingDownlevelFlags, MissingFeatures,
|
|
RenderPassCompatibilityError, RenderPassContext,
|
|
},
|
|
global::Global,
|
|
hal_label, id, impl_resource_type,
|
|
init_tracker::{MemoryInitKind, TextureInitRange, TextureInitTrackerAction},
|
|
pipeline::{PipelineFlags, RenderPipeline, VertexStep},
|
|
resource::{
|
|
Buffer, DestroyedResourceError, InvalidOrDestroyedResourceError, InvalidResourceError,
|
|
Labeled, MissingBufferUsageError, MissingTextureUsageError, ParentDevice, QuerySet,
|
|
RawResourceAccess, ResourceErrorIdent, Texture, TextureView,
|
|
TextureViewNotRenderableReason,
|
|
},
|
|
snatch::SnatchGuard,
|
|
track::{ResourceUsageCompatibilityError, Tracker, UsageScope},
|
|
validation::{self, WorkgroupSizeCheck},
|
|
Label,
|
|
};
|
|
|
|
#[cfg(feature = "serde")]
|
|
use serde::Deserialize;
|
|
#[cfg(feature = "serde")]
|
|
use serde::Serialize;
|
|
|
|
pub use wgt::{LoadOp, StoreOp};
|
|
|
|
fn load_hal_ops<V>(load: LoadOp<V>) -> hal::AttachmentOps {
|
|
match load {
|
|
LoadOp::Load => hal::AttachmentOps::LOAD,
|
|
LoadOp::Clear(_) => hal::AttachmentOps::LOAD_CLEAR,
|
|
LoadOp::DontCare(_) => hal::AttachmentOps::LOAD_DONT_CARE,
|
|
}
|
|
}
|
|
|
|
fn store_hal_ops(store: StoreOp) -> hal::AttachmentOps {
|
|
match store {
|
|
StoreOp::Store => hal::AttachmentOps::STORE,
|
|
StoreOp::Discard => hal::AttachmentOps::STORE_DISCARD,
|
|
}
|
|
}
|
|
|
|
// Stencil clear and reference value should take the LSBs.
|
|
fn convert_stencil_value(value: u32, format: Option<wgt::TextureFormat>) -> u32 {
|
|
let Some(format) = format else {
|
|
return value;
|
|
};
|
|
let Some(stencil_format) = format.aspect_specific_format(wgt::TextureAspect::StencilOnly)
|
|
else {
|
|
return value;
|
|
};
|
|
// Currently only 8-bit stencil formats are supported
|
|
assert_eq!(stencil_format, wgt::TextureFormat::Stencil8);
|
|
value & 255
|
|
}
|
|
|
|
/// Describes an individual channel within a render pass, such as color, depth, or stencil.
|
|
///
|
|
/// A channel must either be read-only, or it must specify both load and store
|
|
/// operations. See [`ResolvedPassChannel`] for a validated version.
|
|
#[repr(C)]
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub struct PassChannel<V> {
|
|
/// Operation to perform to the output attachment at the start of a
|
|
/// renderpass.
|
|
///
|
|
/// This must be clear if it is the first renderpass rendering to a swap
|
|
/// chain image.
|
|
pub load_op: Option<LoadOp<V>>,
|
|
/// Operation to perform to the output attachment at the end of a renderpass.
|
|
pub store_op: Option<StoreOp>,
|
|
/// If true, the relevant channel is not changed by a renderpass, and the
|
|
/// corresponding attachment can be used inside the pass by other read-only
|
|
/// usages.
|
|
pub read_only: bool,
|
|
}
|
|
|
|
impl<V: Copy + Default> PassChannel<Option<V>> {
|
|
fn resolve(
|
|
&self,
|
|
instance_flags: InstanceFlags,
|
|
handle_clear: impl Fn(Option<V>) -> Result<V, AttachmentError>,
|
|
) -> Result<ResolvedPassChannel<V>, AttachmentError> {
|
|
if self.read_only {
|
|
if self.load_op.is_some() {
|
|
return Err(AttachmentError::ReadOnlyWithLoad);
|
|
}
|
|
if self.store_op.is_some() {
|
|
return Err(AttachmentError::ReadOnlyWithStore);
|
|
}
|
|
Ok(ResolvedPassChannel::ReadOnly)
|
|
} else {
|
|
Ok(ResolvedPassChannel::Operational(wgt::Operations {
|
|
load: match self.load_op.ok_or(AttachmentError::NoLoad)? {
|
|
LoadOp::Clear(clear_value) => LoadOp::Clear(handle_clear(clear_value)?),
|
|
LoadOp::DontCare(token) => {
|
|
if instance_flags.contains(InstanceFlags::STRICT_WEBGPU_COMPLIANCE) {
|
|
return Err(AttachmentError::LoadOpDontCareUnderStrictWebgpuCompliance);
|
|
}
|
|
LoadOp::DontCare(token)
|
|
}
|
|
LoadOp::Load => LoadOp::Load,
|
|
},
|
|
store: self.store_op.ok_or(AttachmentError::NoStore)?,
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Describes an individual channel within a render pass, such as color, depth, or stencil.
|
|
///
|
|
/// Unlike [`PassChannel`], this version uses the Rust type system to guarantee
|
|
/// a valid specification.
|
|
#[derive(Clone, Debug)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub enum ResolvedPassChannel<V> {
|
|
ReadOnly,
|
|
Operational(wgt::Operations<V>),
|
|
}
|
|
|
|
impl<V: Copy + Default> ResolvedPassChannel<V> {
|
|
fn load_op(&self) -> LoadOp<V> {
|
|
match self {
|
|
ResolvedPassChannel::ReadOnly => LoadOp::Load,
|
|
ResolvedPassChannel::Operational(wgt::Operations { load, .. }) => *load,
|
|
}
|
|
}
|
|
|
|
fn store_op(&self) -> StoreOp {
|
|
match self {
|
|
ResolvedPassChannel::ReadOnly => StoreOp::Store,
|
|
ResolvedPassChannel::Operational(wgt::Operations { store, .. }) => *store,
|
|
}
|
|
}
|
|
|
|
fn clear_value(&self) -> V {
|
|
match self {
|
|
Self::Operational(wgt::Operations {
|
|
load: LoadOp::Clear(clear_value),
|
|
..
|
|
}) => *clear_value,
|
|
_ => Default::default(),
|
|
}
|
|
}
|
|
|
|
fn is_readonly(&self) -> bool {
|
|
matches!(self, Self::ReadOnly)
|
|
}
|
|
|
|
fn hal_ops(&self) -> hal::AttachmentOps {
|
|
load_hal_ops(self.load_op()) | store_hal_ops(self.store_op())
|
|
}
|
|
}
|
|
|
|
/// Describes a color attachment to a render pass.
|
|
#[repr(C)]
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub struct RenderPassColorAttachment<TV = id::TextureViewId> {
|
|
/// The view to use as an attachment.
|
|
pub view: TV,
|
|
/// The depth slice index of a 3D view. It must not be provided if the view is not 3D.
|
|
pub depth_slice: Option<u32>,
|
|
/// The view that will receive the resolved output if multisampling is used.
|
|
pub resolve_target: Option<TV>,
|
|
/// Operation to perform to the output attachment at the start of a
|
|
/// renderpass.
|
|
///
|
|
/// This must be clear if it is the first renderpass rendering to a swap
|
|
/// chain image.
|
|
pub load_op: LoadOp<Color>,
|
|
/// Operation to perform to the output attachment at the end of a renderpass.
|
|
pub store_op: StoreOp,
|
|
}
|
|
|
|
pub type ArcRenderPassColorAttachment = RenderPassColorAttachment<Arc<TextureView>>;
|
|
|
|
// Avoid allocation in the common case that there is only one color attachment,
|
|
// but don't bloat `ArcCommand::RunRenderPass` excessively.
|
|
pub type ColorAttachments<TV = Arc<TextureView>> =
|
|
SmallVec<[Option<RenderPassColorAttachment<TV>>; 1]>;
|
|
|
|
impl ArcRenderPassColorAttachment {
|
|
fn hal_ops(&self) -> hal::AttachmentOps {
|
|
load_hal_ops(self.load_op) | store_hal_ops(self.store_op)
|
|
}
|
|
|
|
fn clear_value(&self) -> Color {
|
|
match self.load_op {
|
|
LoadOp::Clear(clear_value) => clear_value,
|
|
LoadOp::DontCare(_) | LoadOp::Load => Color::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Describes a depth/stencil attachment to a render pass.
|
|
///
|
|
/// This version uses the unvalidated [`PassChannel`].
|
|
#[repr(C)]
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub struct RenderPassDepthStencilAttachment<TV> {
|
|
/// The view to use as an attachment.
|
|
pub view: TV,
|
|
/// What operations will be performed on the depth part of the attachment.
|
|
pub depth: PassChannel<Option<f32>>,
|
|
/// What operations will be performed on the stencil part of the attachment.
|
|
pub stencil: PassChannel<Option<u32>>,
|
|
}
|
|
|
|
/// Describes a depth/stencil attachment to a render pass.
|
|
///
|
|
/// This version uses the validated [`ResolvedPassChannel`].
|
|
#[derive(Clone, Debug)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub struct ResolvedRenderPassDepthStencilAttachment<TV> {
|
|
/// The view to use as an attachment.
|
|
pub view: TV,
|
|
/// What operations will be performed on the depth part of the attachment.
|
|
pub depth: ResolvedPassChannel<f32>,
|
|
/// What operations will be performed on the stencil part of the attachment.
|
|
pub stencil: ResolvedPassChannel<u32>,
|
|
}
|
|
|
|
/// Describes the attachments of a render pass.
|
|
#[derive(Clone, Debug, Default, PartialEq)]
|
|
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
|
pub struct RenderPassDescriptor<'a> {
|
|
pub label: Label<'a>,
|
|
/// The color attachments of the render pass.
|
|
pub color_attachments: Cow<'a, [Option<RenderPassColorAttachment>]>,
|
|
/// The depth and stencil attachment of the render pass, if any.
|
|
pub depth_stencil_attachment: Option<RenderPassDepthStencilAttachment<id::TextureViewId>>,
|
|
/// Defines where and when timestamp values will be written for this pass.
|
|
pub timestamp_writes: Option<PassTimestampWrites>,
|
|
/// Defines where the occlusion query results will be stored for this pass.
|
|
pub occlusion_query_set: Option<id::QuerySetId>,
|
|
/// The multiview array layers that will be used
|
|
pub multiview_mask: Option<NonZeroU32>,
|
|
}
|
|
|
|
/// Describes the attachments of a render pass.
|
|
#[derive(Clone, Default)]
|
|
pub struct ResolvedRenderPassDescriptor<'a> {
|
|
pub label: Label<'a>,
|
|
/// The color attachments of the render pass.
|
|
pub color_attachments: Cow<'a, [Option<RenderPassColorAttachment<Arc<TextureView>>>]>,
|
|
/// The depth and stencil attachment of the render pass, if any.
|
|
pub depth_stencil_attachment: Option<RenderPassDepthStencilAttachment<Arc<TextureView>>>,
|
|
/// Defines where and when timestamp values will be written for this pass.
|
|
pub timestamp_writes: Option<PassTimestampWrites<Arc<QuerySet>>>,
|
|
/// Defines where the occlusion query results will be stored for this pass.
|
|
pub occlusion_query_set: Option<Arc<QuerySet>>,
|
|
/// The multiview array layers that will be used
|
|
pub multiview_mask: Option<NonZeroU32>,
|
|
}
|
|
|
|
/// Describes the attachments of a render pass.
|
|
struct ArcRenderPassDescriptor<'a> {
|
|
pub label: &'a Label<'a>,
|
|
/// The color attachments of the render pass.
|
|
pub color_attachments:
|
|
ArrayVec<Option<ArcRenderPassColorAttachment>, { hal::MAX_COLOR_ATTACHMENTS }>,
|
|
/// The depth and stencil attachment of the render pass, if any.
|
|
pub depth_stencil_attachment:
|
|
Option<ResolvedRenderPassDepthStencilAttachment<Arc<TextureView>>>,
|
|
/// Defines where and when timestamp values will be written for this pass.
|
|
pub timestamp_writes: Option<ArcPassTimestampWrites>,
|
|
/// Defines where the occlusion query results will be stored for this pass.
|
|
pub occlusion_query_set: Option<Arc<QuerySet>>,
|
|
/// The multiview array layers that will be used
|
|
pub multiview_mask: Option<NonZeroU32>,
|
|
}
|
|
|
|
pub type RenderBasePass = BasePass<ArcRenderCommand, RenderPassError>;
|
|
|
|
/// A pass's [encoder state](https://www.w3.org/TR/webgpu/#encoder-state) and
|
|
/// its validity are two distinct conditions, i.e., the full matrix of
|
|
/// (open, ended) x (valid, invalid) is possible.
|
|
///
|
|
/// The presence or absence of the `parent` `Option` indicates the pass's state.
|
|
/// The presence or absence of an error in `base.error` indicates the pass's
|
|
/// validity.
|
|
pub struct RenderPass {
|
|
/// All pass data & records is stored here.
|
|
base: BasePass<ArcRenderCommand, RenderPassError>,
|
|
|
|
/// Parent command encoder that this pass records commands into.
|
|
///
|
|
/// If this is `Some`, then the pass is in WebGPU's "open" state. If it is
|
|
/// `None`, then the pass is in the "ended" state.
|
|
/// See <https://www.w3.org/TR/webgpu/#encoder-state>
|
|
parent: Option<Arc<CommandEncoder>>,
|
|
|
|
color_attachments:
|
|
ArrayVec<Option<ArcRenderPassColorAttachment>, { hal::MAX_COLOR_ATTACHMENTS }>,
|
|
depth_stencil_attachment: Option<ResolvedRenderPassDepthStencilAttachment<Arc<TextureView>>>,
|
|
timestamp_writes: Option<ArcPassTimestampWrites>,
|
|
occlusion_query_set: Option<Arc<QuerySet>>,
|
|
multiview_mask: Option<NonZeroU32>,
|
|
|
|
// Resource binding dedupe state.
|
|
current_bind_groups: BindGroupStateChange<Arc<BindGroup>>,
|
|
current_pipeline: StateChange<Arc<RenderPipeline>>,
|
|
}
|
|
|
|
impl_resource_type!(RenderPass);
|
|
|
|
impl crate::storage::StorageItem for RenderPass {
|
|
type Marker = id::markers::RenderPassEncoder;
|
|
}
|
|
|
|
impl RenderPass {
|
|
/// If the parent command encoder is invalid, the returned pass will be invalid.
|
|
fn new(parent: Arc<CommandEncoder>, desc: ArcRenderPassDescriptor) -> Self {
|
|
let ArcRenderPassDescriptor {
|
|
label,
|
|
timestamp_writes,
|
|
color_attachments,
|
|
depth_stencil_attachment,
|
|
occlusion_query_set,
|
|
multiview_mask,
|
|
} = desc;
|
|
|
|
Self {
|
|
base: BasePass::new(label),
|
|
parent: Some(parent),
|
|
color_attachments,
|
|
depth_stencil_attachment,
|
|
timestamp_writes,
|
|
occlusion_query_set,
|
|
multiview_mask,
|
|
|
|
current_bind_groups: BindGroupStateChange::new(),
|
|
current_pipeline: StateChange::new(),
|
|
}
|
|
}
|
|
|
|
fn new_invalid(parent: Arc<CommandEncoder>, label: &Label, err: RenderPassError) -> Self {
|
|
Self {
|
|
base: BasePass::new_invalid(label, err),
|
|
parent: Some(parent),
|
|
color_attachments: ArrayVec::new(),
|
|
depth_stencil_attachment: None,
|
|
timestamp_writes: None,
|
|
occlusion_query_set: None,
|
|
multiview_mask: None,
|
|
current_bind_groups: BindGroupStateChange::new(),
|
|
current_pipeline: StateChange::new(),
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn label(&self) -> Option<&str> {
|
|
self.base.label.as_deref()
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for RenderPass {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_struct("RenderPass")
|
|
.field("label", &self.label())
|
|
.field("color_attachments", &self.color_attachments)
|
|
.field("depth_stencil_target", &self.depth_stencil_attachment)
|
|
.field("command count", &self.base.commands.len())
|
|
.field("dynamic offset count", &self.base.dynamic_offsets.len())
|
|
.field("multiview mask", &self.multiview_mask)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
enum OptionalState {
|
|
Unused,
|
|
Required,
|
|
Set,
|
|
}
|
|
|
|
impl OptionalState {
|
|
fn require(&mut self, require: bool) {
|
|
if require && *self == Self::Unused {
|
|
*self = Self::Required;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
struct IndexState {
|
|
buffer_format: Option<IndexFormat>,
|
|
limit: u64,
|
|
}
|
|
|
|
impl IndexState {
|
|
fn update_buffer(&mut self, range: Range<BufferAddress>, format: IndexFormat) {
|
|
self.buffer_format = Some(format);
|
|
let shift = match format {
|
|
IndexFormat::Uint16 => 1,
|
|
IndexFormat::Uint32 => 2,
|
|
};
|
|
self.limit = (range.end - range.start) >> shift;
|
|
}
|
|
|
|
fn reset(&mut self) {
|
|
self.buffer_format = None;
|
|
self.limit = 0;
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
pub(crate) struct VertexLimits {
|
|
/// Length of the shortest vertex rate vertex buffer
|
|
pub(crate) vertex_limit: u64,
|
|
/// Buffer slot which the shortest vertex rate vertex buffer is bound to
|
|
vertex_limit_slot: u32,
|
|
/// Length of the shortest instance rate vertex buffer
|
|
pub(crate) instance_limit: u64,
|
|
/// Buffer slot which the shortest instance rate vertex buffer is bound to
|
|
instance_limit_slot: u32,
|
|
}
|
|
|
|
impl VertexLimits {
|
|
pub(crate) fn new(
|
|
buffer_sizes: impl ExactSizeIterator<Item = Option<BufferAddress>>,
|
|
pipeline_steps: &[Option<VertexStep>],
|
|
) -> Self {
|
|
// Implements the validation from https://gpuweb.github.io/gpuweb/#dom-gpurendercommandsmixin-draw
|
|
// Except that the formula is shuffled to extract the number of vertices in order
|
|
// to carry the bulk of the computation when changing states instead of when producing
|
|
// draws. Draw calls tend to happen at a higher frequency. Here we determine vertex
|
|
// limits that can be cheaply checked for each draw call.
|
|
|
|
let mut vertex_limit = u64::MAX;
|
|
let mut vertex_limit_slot = 0;
|
|
let mut instance_limit = u64::MAX;
|
|
let mut instance_limit_slot = 0;
|
|
|
|
for (idx, (buffer_size, step)) in buffer_sizes.zip(pipeline_steps).enumerate() {
|
|
let Some(step) = step else {
|
|
continue;
|
|
};
|
|
|
|
let Some(buffer_size) = buffer_size else {
|
|
// Missing required vertex buffer
|
|
return Self::default();
|
|
};
|
|
|
|
let limit = if buffer_size < step.last_stride {
|
|
// The buffer cannot fit the last vertex.
|
|
0
|
|
} else {
|
|
if step.stride == 0 {
|
|
// We already checked that the last stride fits, the same
|
|
// vertex will be repeated so this slot can accommodate any number of
|
|
// vertices.
|
|
continue;
|
|
}
|
|
|
|
// The general case.
|
|
(buffer_size - step.last_stride) / step.stride + 1
|
|
};
|
|
|
|
match step.mode {
|
|
VertexStepMode::Vertex => {
|
|
if limit < vertex_limit {
|
|
vertex_limit = limit;
|
|
vertex_limit_slot = idx as _;
|
|
}
|
|
}
|
|
VertexStepMode::Instance => {
|
|
if limit < instance_limit {
|
|
instance_limit = limit;
|
|
instance_limit_slot = idx as _;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Self {
|
|
vertex_limit,
|
|
vertex_limit_slot,
|
|
instance_limit,
|
|
instance_limit_slot,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn validate_vertex_limit(
|
|
&self,
|
|
first_vertex: u32,
|
|
vertex_count: u32,
|
|
) -> Result<(), DrawError> {
|
|
let last_vertex = first_vertex as u64 + vertex_count as u64;
|
|
let vertex_limit = self.vertex_limit;
|
|
if last_vertex > vertex_limit {
|
|
return Err(DrawError::VertexBeyondLimit {
|
|
last_vertex,
|
|
vertex_limit,
|
|
slot: self.vertex_limit_slot,
|
|
});
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub(crate) fn validate_instance_limit(
|
|
&self,
|
|
first_instance: u32,
|
|
instance_count: u32,
|
|
) -> Result<(), DrawError> {
|
|
let last_instance = first_instance as u64 + instance_count as u64;
|
|
let instance_limit = self.instance_limit;
|
|
if last_instance > instance_limit {
|
|
return Err(DrawError::InstanceBeyondLimit {
|
|
last_instance,
|
|
instance_limit,
|
|
slot: self.instance_limit_slot,
|
|
});
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// State of a single vertex buffer slot.
|
|
#[derive(Debug)]
|
|
pub(crate) struct VertexSlot {
|
|
pub(crate) buffer: Arc<Buffer>,
|
|
pub(crate) range: Range<BufferAddress>,
|
|
pub(crate) is_dirty: bool,
|
|
}
|
|
|
|
/// Vertex buffer tracking state, shared between render passes and render bundles.
|
|
///
|
|
/// Tracks which vertex buffer slots are set, and caches the vertex and instance limits
|
|
/// derived from those buffers and the current pipeline, avoiding recomputation on each draw.
|
|
#[derive(Debug, Default)]
|
|
pub(crate) struct VertexState {
|
|
slots: [Option<VertexSlot>; hal::MAX_VERTEX_BUFFERS],
|
|
pub(crate) limits: VertexLimits,
|
|
}
|
|
|
|
impl VertexState {
|
|
/// Set a vertex buffer slot, marking it dirty.
|
|
pub(crate) fn set_buffer(
|
|
&mut self,
|
|
slot: usize,
|
|
buffer: Arc<Buffer>,
|
|
range: Range<BufferAddress>,
|
|
) {
|
|
self.slots[slot] = Some(VertexSlot {
|
|
buffer,
|
|
range,
|
|
is_dirty: true,
|
|
});
|
|
}
|
|
|
|
/// Clear a vertex buffer slot.
|
|
pub(crate) fn clear_buffer(&mut self, slot: usize) {
|
|
self.slots[slot] = None;
|
|
}
|
|
|
|
/// Recompute the cached vertex and instance limits based on the current slots and pipeline.
|
|
pub(crate) fn update_limits(&mut self, pipeline_steps: &[Option<VertexStep>]) {
|
|
self.limits = VertexLimits::new(
|
|
self.slots
|
|
.iter()
|
|
.map(|s| s.as_ref().map(|s| s.range.end - s.range.start)),
|
|
pipeline_steps,
|
|
);
|
|
}
|
|
|
|
fn last_assigned_index(&self) -> Option<usize> {
|
|
self.slots
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(i, s)| s.as_ref().map(|_| i))
|
|
.next_back()
|
|
}
|
|
|
|
pub(super) fn validate(
|
|
&self,
|
|
pipeline: &RenderPipeline,
|
|
binder: &Binder,
|
|
) -> Result<(), DrawError> {
|
|
// Check all needed vertex buffers have been bound
|
|
for index in pipeline
|
|
.vertex_steps
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(index, step)| step.map(|_| index))
|
|
{
|
|
if self.slots[index].is_none() {
|
|
return Err(DrawError::MissingVertexBuffer {
|
|
pipeline: pipeline.error_ident(),
|
|
index,
|
|
});
|
|
}
|
|
}
|
|
|
|
let bind_group_space_used = binder.last_assigned_index().map_or(0, |i| i + 1);
|
|
let vertex_buffer_space_used = self.last_assigned_index().map_or(0, |i| i + 1);
|
|
|
|
let bind_groups_plus_vertex_buffers =
|
|
u32::try_from(bind_group_space_used + vertex_buffer_space_used).unwrap();
|
|
if bind_groups_plus_vertex_buffers
|
|
> pipeline.device.limits.max_bind_groups_plus_vertex_buffers
|
|
{
|
|
return Err(DrawError::TooManyBindGroupsPlusVertexBuffers {
|
|
given: bind_groups_plus_vertex_buffers,
|
|
limit: pipeline.device.limits.max_bind_groups_plus_vertex_buffers,
|
|
});
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Call `f` for each dirty slot with `(slot_index, buffer, offset, size)` and mark them clean.
|
|
pub(crate) fn flush<F>(&mut self, mut f: F)
|
|
where
|
|
F: FnMut(u32, &Arc<Buffer>, BufferAddress, Option<BufferSize>),
|
|
{
|
|
for (i, slot) in self.slots.iter_mut().enumerate() {
|
|
let Some(slot) = slot.as_mut() else { continue };
|
|
if !slot.is_dirty {
|
|
continue;
|
|
}
|
|
slot.is_dirty = false;
|
|
let size = slot.range.end - slot.range.start;
|
|
f(
|
|
i as u32,
|
|
&slot.buffer,
|
|
slot.range.start,
|
|
BufferSize::new(size),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct State<'scope, 'snatch_guard, 'cmd_enc> {
|
|
pipeline_flags: PipelineFlags,
|
|
blend_constant: OptionalState,
|
|
stencil_reference: u32,
|
|
pipeline: Option<Arc<RenderPipeline>>,
|
|
index: IndexState,
|
|
vertex: VertexState,
|
|
|
|
info: RenderPassInfo,
|
|
|
|
pass: pass::PassState<'scope, 'snatch_guard, 'cmd_enc>,
|
|
|
|
active_occlusion_query: Option<(Arc<QuerySet>, u32)>,
|
|
active_pipeline_statistics_query: Option<(Arc<QuerySet>, u32)>,
|
|
}
|
|
|
|
impl<'scope, 'snatch_guard, 'cmd_enc> State<'scope, 'snatch_guard, 'cmd_enc> {
|
|
fn is_ready(&self, family: DrawCommandFamily) -> Result<(), DrawError> {
|
|
if let Some(pipeline) = self.pipeline.as_ref() {
|
|
self.pass.binder.check_compatibility(pipeline.as_ref())?;
|
|
self.pass.binder.check_late_buffer_bindings()?;
|
|
|
|
if self.blend_constant == OptionalState::Required {
|
|
return Err(DrawError::MissingBlendConstant);
|
|
}
|
|
|
|
self.vertex.validate(pipeline.as_ref(), &self.pass.binder)?;
|
|
|
|
if family == DrawCommandFamily::DrawIndexed {
|
|
// Pipeline expects an index buffer
|
|
// We have a buffer bound
|
|
let buffer_index_format = self
|
|
.index
|
|
.buffer_format
|
|
.ok_or(DrawError::MissingIndexBuffer)?;
|
|
|
|
if pipeline.topology.is_strip()
|
|
&& pipeline.strip_index_format != Some(buffer_index_format)
|
|
{
|
|
return Err(DrawError::UnmatchedStripIndexFormat {
|
|
pipeline: pipeline.error_ident(),
|
|
strip_index_format: pipeline.strip_index_format,
|
|
buffer_format: buffer_index_format,
|
|
});
|
|
}
|
|
}
|
|
if (family == DrawCommandFamily::DrawMeshTasks) != pipeline.is_mesh {
|
|
return Err(DrawError::WrongPipelineType {
|
|
wanted_mesh_pipeline: !pipeline.is_mesh,
|
|
});
|
|
}
|
|
if !self
|
|
.pass
|
|
.immediate_state
|
|
.immediate_slots_set
|
|
.contains(pipeline.immediate_slots_required)
|
|
{
|
|
return Err(DrawError::MissingImmediateData {
|
|
missing: pipeline
|
|
.immediate_slots_required
|
|
.difference(self.pass.immediate_state.immediate_slots_set),
|
|
});
|
|
}
|
|
Ok(())
|
|
} else {
|
|
Err(DrawError::MissingPipeline(pass::MissingPipeline))
|
|
}
|
|
}
|
|
|
|
fn flush_immediates(&mut self) {
|
|
let pipeline = self.pipeline.as_ref().unwrap();
|
|
let layout = pipeline.layout().unwrap();
|
|
self.pass
|
|
.immediate_state
|
|
.flush_immediates(layout, self.pass.base.raw_encoder);
|
|
}
|
|
|
|
/// Flush binding state in preparation for a draw call.
|
|
///
|
|
/// See the compute pass version for an explanation of some ways that
|
|
/// `flush_bindings` differs between the two types of passes.
|
|
fn flush_bindings(&mut self) -> Result<(), RenderPassErrorInner> {
|
|
flush_bindings_helper(&mut self.pass)?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Reset the `RenderBundle`-related states.
|
|
fn reset_bundle(&mut self) {
|
|
self.pass.binder.reset();
|
|
self.pipeline = None;
|
|
self.index.reset();
|
|
self.vertex = Default::default();
|
|
self.pass.immediate_state.immediate_slots_set = Default::default();
|
|
}
|
|
|
|
/// Flush dirty vertex buffer slots to the HAL encoder in preparation for a draw call.
|
|
fn flush_vertex_buffers(&mut self) -> Result<(), RenderPassErrorInner> {
|
|
let vertex = &mut self.vertex;
|
|
let raw_encoder: &mut dyn hal::DynCommandEncoder = self.pass.base.raw_encoder;
|
|
let snatch_guard = self.pass.base.snatch_guard;
|
|
let mut result = Ok(());
|
|
vertex.flush(|slot, buffer, offset, size| {
|
|
if result.is_err() {
|
|
return;
|
|
}
|
|
match buffer.try_raw(snatch_guard) {
|
|
Ok(raw) => unsafe {
|
|
// SAFETY: The offset and size were validated in set_vertex_buffer.
|
|
raw_encoder.set_vertex_buffer(
|
|
slot,
|
|
hal::BufferBinding::new_unchecked(raw, offset, size),
|
|
);
|
|
},
|
|
Err(e) => result = Err(e.into()),
|
|
}
|
|
});
|
|
result
|
|
}
|
|
}
|
|
|
|
/// Describes an attachment location in words.
|
|
///
|
|
/// Can be used as "the {loc} has..." or "{loc} has..."
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub enum AttachmentErrorLocation {
|
|
Color { index: usize, resolve: bool },
|
|
Depth,
|
|
}
|
|
|
|
impl fmt::Display for AttachmentErrorLocation {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match *self {
|
|
AttachmentErrorLocation::Color {
|
|
index,
|
|
resolve: false,
|
|
} => write!(f, "color attachment at index {index}'s texture view"),
|
|
AttachmentErrorLocation::Color {
|
|
index,
|
|
resolve: true,
|
|
} => write!(
|
|
f,
|
|
"color attachment at index {index}'s resolve texture view"
|
|
),
|
|
AttachmentErrorLocation::Depth => write!(f, "depth attachment's texture view"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Error)]
|
|
#[non_exhaustive]
|
|
pub enum ColorAttachmentError {
|
|
#[error("Attachment format {0:?} is not a color format")]
|
|
InvalidFormat(wgt::TextureFormat),
|
|
#[error("The number of color attachments {given} exceeds the limit {limit}")]
|
|
TooMany { given: usize, limit: usize },
|
|
#[error("The total number of bytes per sample in color attachments {total} exceeds the limit {limit}")]
|
|
TooManyBytesPerSample { total: u32, limit: u32 },
|
|
#[error("Depth slice must be less than {limit} but is {given}")]
|
|
DepthSliceLimit { given: u32, limit: u32 },
|
|
#[error("Color attachment's view is 3D and requires depth slice to be provided")]
|
|
MissingDepthSlice,
|
|
#[error("Depth slice was provided but the color attachment's view is not 3D")]
|
|
UnneededDepthSlice,
|
|
#[error("{view}'s subresource at mip {mip_level} and depth/array layer {depth_or_array_layer} is already attached to this render pass")]
|
|
SubresourceOverlap {
|
|
view: ResourceErrorIdent,
|
|
mip_level: u32,
|
|
depth_or_array_layer: u32,
|
|
},
|
|
#[error(
|
|
"Color attachment with `TRANSIENT_ATTACHMENT` usage can only be used with \
|
|
`LoadOp::Clear` or `LoadOp::DontCare` (if it is available) and `StoreOp::Discard`. Operations `{0:?}` were provided"
|
|
)]
|
|
InvalidTransientAttachmentOp((LoadOp<Color>, StoreOp)),
|
|
#[error("Color attachment's load op is `LoadOp::DontCare` but `InstanceFlags::STRICT_WEBGPU_COMPLIANCE` is set")]
|
|
LoadOpDontCareUnderStrictWebgpuCompliance,
|
|
}
|
|
|
|
impl WebGpuError for ColorAttachmentError {
|
|
fn webgpu_error_type(&self) -> ErrorType {
|
|
ErrorType::Validation
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Error)]
|
|
#[non_exhaustive]
|
|
pub enum AttachmentError {
|
|
#[error("The format of the depth-stencil attachment ({0:?}) is not a depth-or-stencil format")]
|
|
InvalidDepthStencilAttachmentFormat(wgt::TextureFormat),
|
|
#[error(
|
|
"Depth attachment with `TRANSIENT_ATTACHMENT` usage can only be used with \
|
|
`LoadOp::Clear` or `LoadOp::DontCare` (if it is available) and `StoreOp::Discard`. Operations `{0:?}` were provided"
|
|
)]
|
|
InvalidTransientDepthAttachmentOps((LoadOp<Option<f32>>, StoreOp)),
|
|
#[error("Depth attachment with `TRANSIENT_ATTACHMENT` usage cannot be read-only")]
|
|
ReadOnlyTransientDepthAttachment,
|
|
#[error(
|
|
"Stencil attachment with `TRANSIENT_ATTACHMENT` usage can only be used with \
|
|
`LoadOp::Clear` or `LoadOp::DontCare` (if it is available) and `StoreOp::Discard`. Operations `{0:?}` were provided"
|
|
)]
|
|
InvalidTransientStencilAttachmentOps((LoadOp<Option<u32>>, StoreOp)),
|
|
#[error("Stencil attachment with `TRANSIENT_ATTACHMENT` usage cannot be read-only")]
|
|
ReadOnlyTransientStencilAttachment,
|
|
#[error("LoadOp must be None for read-only attachments")]
|
|
ReadOnlyWithLoad,
|
|
#[error("StoreOp must be None for read-only attachments")]
|
|
ReadOnlyWithStore,
|
|
#[error("Depth `LoadOp` and `StoreOp` (`{ops:?}`) must be `None` for attachments (`{format:?}`) without depth aspect")]
|
|
DepthOpsWithoutAspect {
|
|
format: wgt::TextureFormat,
|
|
ops: (Option<LoadOp<Option<f32>>>, Option<StoreOp>),
|
|
},
|
|
#[error("Stencil `LoadOp` and `StoreOp` (`{ops:?}`) must be `None` for attachments (`{format:?}`) without stencil aspect")]
|
|
StencilOpsWithoutAspect {
|
|
format: wgt::TextureFormat,
|
|
ops: (Option<LoadOp<Option<u32>>>, Option<StoreOp>),
|
|
},
|
|
#[error("Attachment without load")]
|
|
NoLoad,
|
|
#[error("Attachment without store")]
|
|
NoStore,
|
|
#[error("LoadOp is `Clear` but no clear value was provided")]
|
|
NoClearValue,
|
|
#[error("Clear value ({0}) must be between 0.0 and 1.0, inclusive")]
|
|
ClearValueOutOfRange(f32),
|
|
#[error("Load op is `DontCare` but `InstanceFlags::STRICT_WEBGPU_COMPLIANCE` is set")]
|
|
LoadOpDontCareUnderStrictWebgpuCompliance,
|
|
}
|
|
|
|
impl WebGpuError for AttachmentError {
|
|
fn webgpu_error_type(&self) -> ErrorType {
|
|
ErrorType::Validation
|
|
}
|
|
}
|
|
|
|
/// Error encountered when performing a render pass.
|
|
#[derive(Clone, Debug, Error)]
|
|
pub enum RenderPassErrorInner {
|
|
#[error(transparent)]
|
|
Device(#[from] DeviceError),
|
|
#[error(transparent)]
|
|
ColorAttachment(#[from] ColorAttachmentError),
|
|
#[error(transparent)]
|
|
InvalidAttachment(#[from] AttachmentError),
|
|
#[error(transparent)]
|
|
EncoderState(#[from] EncoderStateError),
|
|
#[error("Parent encoder is invalid")]
|
|
InvalidParentEncoder,
|
|
#[error(transparent)]
|
|
DebugGroupError(#[from] DebugGroupError),
|
|
#[error("The format of the {location} ({format:?}) is not resolvable")]
|
|
UnsupportedResolveTargetFormat {
|
|
location: AttachmentErrorLocation,
|
|
format: wgt::TextureFormat,
|
|
},
|
|
#[error("The {location} is not valid, because the texture has `TRANSIENT_ATTACHMENT` usage")]
|
|
InvalidTransientResolveTarget { location: AttachmentErrorLocation },
|
|
#[error("No color attachments or depth attachments were provided, at least one attachment of any kind must be provided")]
|
|
MissingAttachments,
|
|
#[error("The {location} is not renderable:")]
|
|
TextureViewIsNotRenderable {
|
|
location: AttachmentErrorLocation,
|
|
#[source]
|
|
reason: TextureViewNotRenderableReason,
|
|
},
|
|
#[error("Attachments have differing sizes: the {expected_location} has extent {expected_extent:?} but is followed by the {actual_location} which has {actual_extent:?}")]
|
|
AttachmentsDimensionMismatch {
|
|
expected_location: AttachmentErrorLocation,
|
|
expected_extent: wgt::Extent3d,
|
|
actual_location: AttachmentErrorLocation,
|
|
actual_extent: wgt::Extent3d,
|
|
},
|
|
#[error("Attachments have differing sample counts: the {expected_location} has count {expected_samples:?} but is followed by the {actual_location} which has count {actual_samples:?}")]
|
|
AttachmentSampleCountMismatch {
|
|
expected_location: AttachmentErrorLocation,
|
|
expected_samples: u32,
|
|
actual_location: AttachmentErrorLocation,
|
|
actual_samples: u32,
|
|
},
|
|
#[error("The resolve source, {location}, must be multi-sampled (has {src} samples) while the resolve destination must not be multisampled (has {dst} samples)")]
|
|
InvalidResolveSampleCounts {
|
|
location: AttachmentErrorLocation,
|
|
src: u32,
|
|
dst: u32,
|
|
},
|
|
#[error(
|
|
"Resource source, {location}, format ({src:?}) must match the resolve destination format ({dst:?})"
|
|
)]
|
|
MismatchedResolveTextureFormat {
|
|
location: AttachmentErrorLocation,
|
|
src: wgt::TextureFormat,
|
|
dst: wgt::TextureFormat,
|
|
},
|
|
#[error("Unable to clear non-present/read-only depth")]
|
|
InvalidDepthOps,
|
|
#[error("Unable to clear non-present/read-only stencil")]
|
|
InvalidStencilOps,
|
|
#[error(transparent)]
|
|
MissingFeatures(#[from] MissingFeatures),
|
|
#[error(transparent)]
|
|
MissingDownlevelFlags(#[from] MissingDownlevelFlags),
|
|
#[error("Indirect draw count of {count_bytes} bytes starting at {begin_count_offset} would overrun buffer of size {count_buffer_size}")]
|
|
IndirectCountBufferOverrun {
|
|
count_bytes: u64,
|
|
begin_count_offset: u64,
|
|
count_buffer_size: u64,
|
|
},
|
|
#[error(transparent)]
|
|
ResourceUsageCompatibility(#[from] ResourceUsageCompatibilityError),
|
|
#[error("Render bundle has incompatible targets, {0}")]
|
|
IncompatibleBundleTargets(#[from] RenderPassCompatibilityError),
|
|
#[error(
|
|
"Render bundle has incompatible read-only flags: \
|
|
bundle has flags depth = {bundle_depth} and stencil = {bundle_stencil}, \
|
|
while the pass has flags depth = {pass_depth} and stencil = {pass_stencil}. \
|
|
Read-only renderpasses are only compatible with read-only bundles for that aspect."
|
|
)]
|
|
IncompatibleBundleReadOnlyDepthStencil {
|
|
pass_depth: bool,
|
|
pass_stencil: bool,
|
|
bundle_depth: bool,
|
|
bundle_stencil: bool,
|
|
},
|
|
#[error(transparent)]
|
|
RenderCommand(#[from] RenderCommandError),
|
|
#[error(transparent)]
|
|
Draw(#[from] DrawError),
|
|
#[error(transparent)]
|
|
Bind(#[from] BindError),
|
|
#[error(transparent)]
|
|
QueryUse(#[from] QueryUseError),
|
|
#[error("Multiview layer count must match")]
|
|
MultiViewMismatch,
|
|
#[error(
|
|
"Multiview pass texture views with more than one array layer must have D2Array dimension"
|
|
)]
|
|
MultiViewDimensionMismatch,
|
|
#[error("Multiview view count limit violated")]
|
|
TooManyMultiviewViews,
|
|
#[error("missing occlusion query set")]
|
|
MissingOcclusionQuerySet,
|
|
#[error(transparent)]
|
|
DestroyedResource(#[from] DestroyedResourceError),
|
|
#[error("The compute pass has already been ended and no further commands can be recorded")]
|
|
PassEnded,
|
|
#[error(transparent)]
|
|
InvalidResource(#[from] InvalidResourceError),
|
|
#[error(transparent)]
|
|
TimestampWrites(#[from] TimestampWritesError),
|
|
}
|
|
|
|
impl From<InvalidOrDestroyedResourceError> for RenderPassErrorInner {
|
|
fn from(error: InvalidOrDestroyedResourceError) -> Self {
|
|
match error {
|
|
InvalidOrDestroyedResourceError::InvalidResource(e) => Self::InvalidResource(e),
|
|
InvalidOrDestroyedResourceError::DestroyedResource(e) => Self::DestroyedResource(e),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<MissingBufferUsageError> for RenderPassErrorInner {
|
|
fn from(error: MissingBufferUsageError) -> Self {
|
|
Self::RenderCommand(error.into())
|
|
}
|
|
}
|
|
|
|
impl From<MissingTextureUsageError> for RenderPassErrorInner {
|
|
fn from(error: MissingTextureUsageError) -> Self {
|
|
Self::RenderCommand(error.into())
|
|
}
|
|
}
|
|
|
|
impl From<pass::BindGroupIndexOutOfRange> for RenderPassErrorInner {
|
|
fn from(error: pass::BindGroupIndexOutOfRange) -> Self {
|
|
Self::RenderCommand(RenderCommandError::BindGroupIndexOutOfRange(error))
|
|
}
|
|
}
|
|
|
|
impl From<pass::MissingPipeline> for RenderPassErrorInner {
|
|
fn from(error: pass::MissingPipeline) -> Self {
|
|
Self::Draw(DrawError::MissingPipeline(error))
|
|
}
|
|
}
|
|
|
|
impl From<ImmediateUploadError> for RenderPassErrorInner {
|
|
fn from(error: ImmediateUploadError) -> Self {
|
|
Self::RenderCommand(error.into())
|
|
}
|
|
}
|
|
|
|
/// Error encountered when performing a render pass.
|
|
#[derive(Clone, Debug, Error)]
|
|
#[error("{scope}")]
|
|
pub struct RenderPassError {
|
|
pub scope: PassErrorScope,
|
|
#[source]
|
|
pub(super) inner: Box<RenderPassErrorInner>,
|
|
}
|
|
|
|
impl<E: Into<RenderPassErrorInner>> MapPassErr<RenderPassError> for E {
|
|
fn map_pass_err(self, scope: PassErrorScope) -> RenderPassError {
|
|
RenderPassError {
|
|
scope,
|
|
inner: Box::new(self.into()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl WebGpuError for RenderPassError {
|
|
fn webgpu_error_type(&self) -> ErrorType {
|
|
match self.inner.as_ref() {
|
|
RenderPassErrorInner::Device(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::ColorAttachment(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::EncoderState(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::DebugGroupError(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::MissingFeatures(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::MissingDownlevelFlags(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::RenderCommand(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::Draw(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::Bind(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::QueryUse(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::DestroyedResource(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::InvalidResource(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::IncompatibleBundleTargets(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::InvalidAttachment(e) => e.webgpu_error_type(),
|
|
RenderPassErrorInner::TimestampWrites(e) => e.webgpu_error_type(),
|
|
|
|
RenderPassErrorInner::InvalidParentEncoder
|
|
| RenderPassErrorInner::UnsupportedResolveTargetFormat { .. }
|
|
| RenderPassErrorInner::InvalidTransientResolveTarget { .. }
|
|
| RenderPassErrorInner::MissingAttachments
|
|
| RenderPassErrorInner::TextureViewIsNotRenderable { .. }
|
|
| RenderPassErrorInner::AttachmentsDimensionMismatch { .. }
|
|
| RenderPassErrorInner::AttachmentSampleCountMismatch { .. }
|
|
| RenderPassErrorInner::InvalidResolveSampleCounts { .. }
|
|
| RenderPassErrorInner::MismatchedResolveTextureFormat { .. }
|
|
| RenderPassErrorInner::InvalidDepthOps
|
|
| RenderPassErrorInner::InvalidStencilOps
|
|
| RenderPassErrorInner::IndirectCountBufferOverrun { .. }
|
|
| RenderPassErrorInner::ResourceUsageCompatibility(..)
|
|
| RenderPassErrorInner::IncompatibleBundleReadOnlyDepthStencil { .. }
|
|
| RenderPassErrorInner::MultiViewMismatch
|
|
| RenderPassErrorInner::MultiViewDimensionMismatch
|
|
| RenderPassErrorInner::TooManyMultiviewViews
|
|
| RenderPassErrorInner::MissingOcclusionQuerySet
|
|
| RenderPassErrorInner::PassEnded => ErrorType::Validation,
|
|
}
|
|
}
|
|
}
|
|
|
|
struct RenderAttachment {
|
|
texture: Arc<Texture>,
|
|
selector: TextureSelector,
|
|
usage: wgt::TextureUses,
|
|
}
|
|
|
|
impl TextureView {
|
|
fn to_render_attachment(&self, usage: wgt::TextureUses) -> RenderAttachment {
|
|
RenderAttachment {
|
|
texture: self.parent.clone(),
|
|
selector: self.selector.clone(),
|
|
usage,
|
|
}
|
|
}
|
|
}
|
|
|
|
const MAX_TOTAL_ATTACHMENTS: usize = hal::MAX_COLOR_ATTACHMENTS + hal::MAX_COLOR_ATTACHMENTS + 1;
|
|
type AttachmentDataVec<T> = ArrayVec<T, MAX_TOTAL_ATTACHMENTS>;
|
|
|
|
struct RenderPassInfo {
|
|
context: RenderPassContext,
|
|
/// All render attachments, including depth/stencil
|
|
render_attachments: AttachmentDataVec<RenderAttachment>,
|
|
is_depth_read_only: bool,
|
|
is_stencil_read_only: bool,
|
|
extent: wgt::Extent3d,
|
|
|
|
divergent_discarded_depth_stencil_aspect: Option<(wgt::TextureAspect, Arc<TextureView>)>,
|
|
multiview_mask: Option<NonZeroU32>,
|
|
}
|
|
|
|
impl RenderPassInfo {
|
|
fn add_pass_texture_init_actions<V>(
|
|
load_op: LoadOp<V>,
|
|
store_op: StoreOp,
|
|
texture_memory_actions: &mut CommandBufferTextureMemoryActions,
|
|
view: &TextureView,
|
|
pending_discard_init_fixups: &mut SurfacesInDiscardState,
|
|
) {
|
|
if matches!(load_op, LoadOp::Load) {
|
|
pending_discard_init_fixups.extend(texture_memory_actions.register_init_action(
|
|
&TextureInitTrackerAction {
|
|
texture: view.parent.clone(),
|
|
range: TextureInitRange::from(view.selector.clone()),
|
|
// Note that this is needed even if the target is discarded,
|
|
kind: MemoryInitKind::NeedsInitializedMemory,
|
|
},
|
|
));
|
|
} else if store_op == StoreOp::Store {
|
|
// Clear + Store
|
|
texture_memory_actions.register_implicit_init(
|
|
&view.parent,
|
|
TextureInitRange::from(view.selector.clone()),
|
|
);
|
|
}
|
|
if store_op == StoreOp::Discard {
|
|
// the discard happens at the *end* of a pass, but recording the
|
|
// discard right away be alright since the texture can't be used
|
|
// during the pass anyways
|
|
texture_memory_actions.discard(TextureSurfaceDiscard {
|
|
texture: view.parent.clone(),
|
|
mip_level: view.selector.mips.start,
|
|
layer: view.selector.layers.start,
|
|
});
|
|
}
|
|
}
|
|
|
|
fn start(
|
|
device: &Arc<Device>,
|
|
hal_label: Option<&str>,
|
|
color_attachments: &[Option<ArcRenderPassColorAttachment>],
|
|
mut depth_stencil_attachment: Option<
|
|
ResolvedRenderPassDepthStencilAttachment<Arc<TextureView>>,
|
|
>,
|
|
mut timestamp_writes: Option<ArcPassTimestampWrites>,
|
|
mut occlusion_query_set: Option<Arc<QuerySet>>,
|
|
encoder: &mut dyn hal::DynCommandEncoder,
|
|
trackers: &mut Tracker,
|
|
texture_memory_actions: &mut CommandBufferTextureMemoryActions,
|
|
pending_query_resets: &mut QueryResetMap,
|
|
pending_discard_init_fixups: &mut SurfacesInDiscardState,
|
|
snatch_guard: &SnatchGuard<'_>,
|
|
query_set_writes: &mut QuerySetWrites,
|
|
multiview_mask: Option<NonZeroU32>,
|
|
) -> Result<Self, RenderPassErrorInner> {
|
|
profiling::scope!("RenderPassInfo::start");
|
|
|
|
// We default to false intentionally, even if depth-stencil isn't used at all.
|
|
// This allows us to use the primary raw pipeline in `RenderPipeline`,
|
|
// instead of the special read-only one, which would be `None`.
|
|
let mut is_depth_read_only = false;
|
|
let mut is_stencil_read_only = false;
|
|
|
|
let mut render_attachments = AttachmentDataVec::<RenderAttachment>::new();
|
|
let mut discarded_surfaces = AttachmentDataVec::new();
|
|
let mut divergent_discarded_depth_stencil_aspect = None;
|
|
|
|
let mut attachment_location = AttachmentErrorLocation::Color {
|
|
index: usize::MAX,
|
|
resolve: false,
|
|
};
|
|
let mut extent = None;
|
|
let mut sample_count = 0;
|
|
|
|
let mut detected_multiview: Option<Option<NonZeroU32>> = None;
|
|
|
|
let mut check_multiview = |view: &TextureView| {
|
|
// Get the multiview configuration for this texture view
|
|
let layers = view.selector.layers.end - view.selector.layers.start;
|
|
let this_multiview = if layers >= 2 {
|
|
// Trivially proven by the if above
|
|
Some(unsafe { NonZeroU32::new_unchecked(layers) })
|
|
} else {
|
|
None
|
|
};
|
|
|
|
// Make sure that if this view is a multiview, it is set to be an array
|
|
if this_multiview.is_some() && view.desc.dimension != TextureViewDimension::D2Array {
|
|
return Err(RenderPassErrorInner::MultiViewDimensionMismatch);
|
|
}
|
|
|
|
// Validate matching first, or store the first one
|
|
if let Some(multiview) = detected_multiview {
|
|
if multiview != this_multiview {
|
|
return Err(RenderPassErrorInner::MultiViewMismatch);
|
|
}
|
|
} else {
|
|
// Multiview is only supported if the feature is enabled
|
|
if let Some(this_multiview) = this_multiview {
|
|
device.require_features(wgt::Features::MULTIVIEW)?;
|
|
if this_multiview.get() > device.limits.max_multiview_view_count {
|
|
return Err(RenderPassErrorInner::TooManyMultiviewViews);
|
|
}
|
|
}
|
|
|
|
detected_multiview = Some(this_multiview);
|
|
}
|
|
|
|
Ok(())
|
|
};
|
|
let mut add_view = |view: &TextureView, location| {
|
|
let render_extent = view.state()?.render_extent.map_err(|reason| {
|
|
RenderPassErrorInner::TextureViewIsNotRenderable { location, reason }
|
|
})?;
|
|
if let Some(ex) = extent {
|
|
if ex != render_extent {
|
|
return Err(RenderPassErrorInner::AttachmentsDimensionMismatch {
|
|
expected_location: attachment_location,
|
|
expected_extent: ex,
|
|
actual_location: location,
|
|
actual_extent: render_extent,
|
|
});
|
|
}
|
|
} else {
|
|
extent = Some(render_extent);
|
|
}
|
|
if sample_count == 0 {
|
|
sample_count = view.samples;
|
|
} else if sample_count != view.samples {
|
|
return Err(RenderPassErrorInner::AttachmentSampleCountMismatch {
|
|
expected_location: attachment_location,
|
|
expected_samples: sample_count,
|
|
actual_location: location,
|
|
actual_samples: view.samples,
|
|
});
|
|
}
|
|
attachment_location = location;
|
|
Ok(())
|
|
};
|
|
|
|
let mut depth_stencil = None;
|
|
|
|
if let Some(at) = depth_stencil_attachment.as_ref() {
|
|
let view = &at.view;
|
|
check_multiview(view)?;
|
|
add_view(view, AttachmentErrorLocation::Depth)?;
|
|
|
|
let ds_aspects = view.desc.aspects();
|
|
|
|
if !ds_aspects.contains(hal::FormatAspects::STENCIL)
|
|
|| (at.stencil.load_op().eq_variant(at.depth.load_op())
|
|
&& at.stencil.store_op() == at.depth.store_op())
|
|
{
|
|
Self::add_pass_texture_init_actions(
|
|
at.depth.load_op(),
|
|
at.depth.store_op(),
|
|
texture_memory_actions,
|
|
view,
|
|
pending_discard_init_fixups,
|
|
);
|
|
} else if !ds_aspects.contains(hal::FormatAspects::DEPTH) {
|
|
Self::add_pass_texture_init_actions(
|
|
at.stencil.load_op(),
|
|
at.stencil.store_op(),
|
|
texture_memory_actions,
|
|
view,
|
|
pending_discard_init_fixups,
|
|
);
|
|
} else {
|
|
// This is the only place (anywhere in wgpu) where Stencil &
|
|
// Depth init state can diverge.
|
|
//
|
|
// To safe us the overhead of tracking init state of texture
|
|
// aspects everywhere, we're going to cheat a little bit in
|
|
// order to keep the init state of both Stencil and Depth
|
|
// aspects in sync. The expectation is that we hit this path
|
|
// extremely rarely!
|
|
//
|
|
// Diverging LoadOp, i.e. Load + Clear:
|
|
//
|
|
// Record MemoryInitKind::NeedsInitializedMemory for the entire
|
|
// surface, a bit wasteful on unit but no negative effect!
|
|
//
|
|
// Rationale: If the loaded channel is uninitialized it needs
|
|
// clearing, the cleared channel doesn't care. (If everything is
|
|
// already initialized nothing special happens)
|
|
//
|
|
// (possible minor optimization: Clear caused by
|
|
// NeedsInitializedMemory should know that it doesn't need to
|
|
// clear the aspect that was set to C)
|
|
let need_init_beforehand =
|
|
at.depth.load_op() == LoadOp::Load || at.stencil.load_op() == LoadOp::Load;
|
|
if need_init_beforehand {
|
|
pending_discard_init_fixups.extend(
|
|
texture_memory_actions.register_init_action(&TextureInitTrackerAction {
|
|
texture: view.parent.clone(),
|
|
range: TextureInitRange::from(view.selector.clone()),
|
|
kind: MemoryInitKind::NeedsInitializedMemory,
|
|
}),
|
|
);
|
|
}
|
|
|
|
// Diverging Store, i.e. Discard + Store:
|
|
//
|
|
// Immediately zero out channel that is set to discard after
|
|
// we're done with the render pass. This allows us to set the
|
|
// entire surface to MemoryInitKind::ImplicitlyInitialized (if
|
|
// it isn't already set to NeedsInitializedMemory).
|
|
//
|
|
// (possible optimization: Delay and potentially drop this zeroing)
|
|
if at.depth.store_op() != at.stencil.store_op() {
|
|
if !need_init_beforehand {
|
|
texture_memory_actions.register_implicit_init(
|
|
&view.parent,
|
|
TextureInitRange::from(view.selector.clone()),
|
|
);
|
|
}
|
|
divergent_discarded_depth_stencil_aspect = Some((
|
|
if at.depth.store_op() == StoreOp::Discard {
|
|
wgt::TextureAspect::DepthOnly
|
|
} else {
|
|
wgt::TextureAspect::StencilOnly
|
|
},
|
|
view.clone(),
|
|
));
|
|
} else if at.depth.store_op() == StoreOp::Discard {
|
|
// Both are discarded using the regular path.
|
|
discarded_surfaces.push(TextureSurfaceDiscard {
|
|
texture: view.parent.clone(),
|
|
mip_level: view.selector.mips.start,
|
|
layer: view.selector.layers.start,
|
|
});
|
|
}
|
|
}
|
|
|
|
is_depth_read_only = at.depth.is_readonly();
|
|
is_stencil_read_only = at.stencil.is_readonly();
|
|
|
|
let usage = if is_depth_read_only
|
|
&& is_stencil_read_only
|
|
&& device
|
|
.downlevel
|
|
.flags
|
|
.contains(wgt::DownlevelFlags::READ_ONLY_DEPTH_STENCIL)
|
|
{
|
|
// If the texture supports TEXTURE_BINDING, it can be used as a shader
|
|
// resource and a read-only depth attachment simultaneously. But if it
|
|
// doesn't support TEXTURE_BINDING, don't attempt to transition it to a
|
|
// shader resource state, because DX12 will raise an error.
|
|
if view.desc.usage.contains(TextureUsages::TEXTURE_BINDING) {
|
|
wgt::TextureUses::DEPTH_STENCIL_READ | wgt::TextureUses::RESOURCE
|
|
} else {
|
|
wgt::TextureUses::DEPTH_STENCIL_READ
|
|
}
|
|
} else {
|
|
wgt::TextureUses::DEPTH_STENCIL_WRITE
|
|
};
|
|
render_attachments.push(view.to_render_attachment(usage));
|
|
|
|
depth_stencil = Some(hal::DepthStencilAttachment {
|
|
target: hal::Attachment {
|
|
view: view.try_raw(snatch_guard)?,
|
|
usage,
|
|
},
|
|
depth_ops: at.depth.hal_ops(),
|
|
stencil_ops: at.stencil.hal_ops(),
|
|
clear_value: (at.depth.clear_value(), at.stencil.clear_value()),
|
|
});
|
|
}
|
|
|
|
let mut attachment_set = crate::FastHashSet::default();
|
|
|
|
let mut color_attachments_hal =
|
|
ArrayVec::<Option<hal::ColorAttachment<_>>, { hal::MAX_COLOR_ATTACHMENTS }>::new();
|
|
for (index, attachment) in color_attachments.iter().enumerate() {
|
|
let at = if let Some(attachment) = attachment.as_ref() {
|
|
attachment
|
|
} else {
|
|
color_attachments_hal.push(None);
|
|
continue;
|
|
};
|
|
let color_view: &TextureView = &at.view;
|
|
color_view.same_device(device)?;
|
|
check_multiview(color_view)?;
|
|
add_view(
|
|
color_view,
|
|
AttachmentErrorLocation::Color {
|
|
index,
|
|
resolve: false,
|
|
},
|
|
)?;
|
|
|
|
if !color_view.desc.aspects().intersects(
|
|
hal::FormatAspects::COLOR
|
|
| hal::FormatAspects::PLANE_0
|
|
| hal::FormatAspects::PLANE_1
|
|
| hal::FormatAspects::PLANE_2,
|
|
) {
|
|
return Err(RenderPassErrorInner::ColorAttachment(
|
|
ColorAttachmentError::InvalidFormat(color_view.desc.format),
|
|
));
|
|
}
|
|
|
|
if color_view.desc.dimension == TextureViewDimension::D3 {
|
|
if let Some(depth_slice) = at.depth_slice {
|
|
let mip = color_view.desc.range.base_mip_level;
|
|
let mip_size = color_view
|
|
.parent
|
|
.desc
|
|
.size
|
|
.mip_level_size(mip, color_view.parent.desc.dimension);
|
|
let limit = mip_size.depth_or_array_layers;
|
|
if depth_slice >= limit {
|
|
return Err(RenderPassErrorInner::ColorAttachment(
|
|
ColorAttachmentError::DepthSliceLimit {
|
|
given: depth_slice,
|
|
limit,
|
|
},
|
|
));
|
|
}
|
|
} else {
|
|
return Err(RenderPassErrorInner::ColorAttachment(
|
|
ColorAttachmentError::MissingDepthSlice,
|
|
));
|
|
}
|
|
} else if at.depth_slice.is_some() {
|
|
return Err(RenderPassErrorInner::ColorAttachment(
|
|
ColorAttachmentError::UnneededDepthSlice,
|
|
));
|
|
}
|
|
|
|
validation::validate_color_attachment_bytes_per_sample(
|
|
color_attachments
|
|
.iter()
|
|
.flatten()
|
|
.map(|at| at.view.desc.format),
|
|
device.limits.max_color_attachment_bytes_per_sample,
|
|
)
|
|
.map_err(RenderPassErrorInner::ColorAttachment)?;
|
|
|
|
fn check_attachment_overlap(
|
|
attachment_set: &mut crate::FastHashSet<(crate::track::TrackerIndex, u32, u32)>,
|
|
view: &TextureView,
|
|
depth_slice: Option<u32>,
|
|
) -> Result<(), ColorAttachmentError> {
|
|
let mut insert = |slice| {
|
|
let mip_level = view.desc.range.base_mip_level;
|
|
if attachment_set.insert((
|
|
view.parent.tracking_data.tracker_index(),
|
|
mip_level,
|
|
slice,
|
|
)) {
|
|
Ok(())
|
|
} else {
|
|
Err(ColorAttachmentError::SubresourceOverlap {
|
|
view: view.error_ident(),
|
|
mip_level,
|
|
depth_or_array_layer: slice,
|
|
})
|
|
}
|
|
};
|
|
match view.desc.dimension {
|
|
TextureViewDimension::D2 => {
|
|
insert(view.desc.range.base_array_layer)?;
|
|
}
|
|
TextureViewDimension::D2Array => {
|
|
for layer in view.selector.layers.clone() {
|
|
insert(layer)?;
|
|
}
|
|
}
|
|
TextureViewDimension::D3 => {
|
|
insert(depth_slice.unwrap())?;
|
|
}
|
|
_ => unreachable!(),
|
|
};
|
|
Ok(())
|
|
}
|
|
|
|
check_attachment_overlap(&mut attachment_set, color_view, at.depth_slice)?;
|
|
|
|
Self::add_pass_texture_init_actions(
|
|
at.load_op,
|
|
at.store_op,
|
|
texture_memory_actions,
|
|
color_view,
|
|
pending_discard_init_fixups,
|
|
);
|
|
render_attachments
|
|
.push(color_view.to_render_attachment(wgt::TextureUses::COLOR_TARGET));
|
|
|
|
let mut hal_resolve_target = None;
|
|
if let Some(resolve_view) = &at.resolve_target {
|
|
resolve_view.same_device(device)?;
|
|
check_multiview(resolve_view)?;
|
|
|
|
check_attachment_overlap(&mut attachment_set, resolve_view, None)?;
|
|
|
|
let resolve_location = AttachmentErrorLocation::Color {
|
|
index,
|
|
resolve: true,
|
|
};
|
|
|
|
let render_extent = resolve_view.state()?.render_extent.map_err(|reason| {
|
|
RenderPassErrorInner::TextureViewIsNotRenderable {
|
|
location: resolve_location,
|
|
reason,
|
|
}
|
|
})?;
|
|
if color_view.state()?.render_extent.unwrap() != render_extent {
|
|
return Err(RenderPassErrorInner::AttachmentsDimensionMismatch {
|
|
expected_location: attachment_location,
|
|
expected_extent: extent.unwrap_or_default(),
|
|
actual_location: resolve_location,
|
|
actual_extent: render_extent,
|
|
});
|
|
}
|
|
if color_view.samples == 1 || resolve_view.samples != 1 {
|
|
return Err(RenderPassErrorInner::InvalidResolveSampleCounts {
|
|
location: resolve_location,
|
|
src: color_view.samples,
|
|
dst: resolve_view.samples,
|
|
});
|
|
}
|
|
if color_view.desc.format != resolve_view.desc.format {
|
|
return Err(RenderPassErrorInner::MismatchedResolveTextureFormat {
|
|
location: resolve_location,
|
|
src: color_view.desc.format,
|
|
dst: resolve_view.desc.format,
|
|
});
|
|
}
|
|
if !resolve_view
|
|
.format_features
|
|
.flags
|
|
.contains(wgt::TextureFormatFeatureFlags::MULTISAMPLE_RESOLVE)
|
|
{
|
|
return Err(RenderPassErrorInner::UnsupportedResolveTargetFormat {
|
|
location: resolve_location,
|
|
format: resolve_view.desc.format,
|
|
});
|
|
}
|
|
if resolve_view
|
|
.desc
|
|
.usage
|
|
.contains(TextureUsages::TRANSIENT_ATTACHMENT)
|
|
{
|
|
return Err(RenderPassErrorInner::InvalidTransientResolveTarget {
|
|
location: resolve_location,
|
|
});
|
|
}
|
|
|
|
texture_memory_actions.register_implicit_init(
|
|
&resolve_view.parent,
|
|
TextureInitRange::from(resolve_view.selector.clone()),
|
|
);
|
|
render_attachments
|
|
.push(resolve_view.to_render_attachment(wgt::TextureUses::COLOR_TARGET));
|
|
|
|
hal_resolve_target = Some(hal::Attachment {
|
|
view: resolve_view.try_raw(snatch_guard)?,
|
|
usage: wgt::TextureUses::COLOR_TARGET,
|
|
});
|
|
}
|
|
|
|
color_attachments_hal.push(Some(hal::ColorAttachment {
|
|
target: hal::Attachment {
|
|
view: color_view.try_raw(snatch_guard)?,
|
|
usage: wgt::TextureUses::COLOR_TARGET,
|
|
},
|
|
depth_slice: at.depth_slice,
|
|
resolve_target: hal_resolve_target,
|
|
ops: at.hal_ops(),
|
|
clear_value: at.clear_value(),
|
|
}));
|
|
}
|
|
|
|
let extent = extent.ok_or(RenderPassErrorInner::MissingAttachments)?;
|
|
|
|
let detected_multiview =
|
|
detected_multiview.expect("Multiview was not detected, no attachments");
|
|
if let Some(mask) = multiview_mask {
|
|
// 0x01 will have msb 0
|
|
let mask_msb = 31 - mask.leading_zeros();
|
|
let detected_mv = detected_multiview.map(NonZeroU32::get).unwrap_or(1);
|
|
if mask_msb >= detected_mv {
|
|
return Err(RenderPassErrorInner::MultiViewMismatch);
|
|
}
|
|
if mask.get() != (1 << detected_mv) - 1 {
|
|
device.require_features(wgt::Features::SELECTIVE_MULTIVIEW)?;
|
|
}
|
|
}
|
|
|
|
let attachment_formats = AttachmentData {
|
|
colors: color_attachments
|
|
.iter()
|
|
.map(|at| at.as_ref().map(|at| at.view.desc.format))
|
|
.collect(),
|
|
resolves: color_attachments
|
|
.iter()
|
|
.filter_map(|at| {
|
|
at.as_ref().and_then(|at| {
|
|
at.resolve_target
|
|
.as_ref()
|
|
.map(|resolve| resolve.desc.format)
|
|
})
|
|
})
|
|
.collect(),
|
|
depth_stencil: depth_stencil_attachment
|
|
.as_ref()
|
|
.map(|at| at.view.desc.format),
|
|
};
|
|
|
|
let context = RenderPassContext {
|
|
attachments: attachment_formats,
|
|
sample_count,
|
|
multiview_mask,
|
|
};
|
|
|
|
let timestamp_writes_hal = if let Some(tw) = timestamp_writes.as_ref() {
|
|
let query_set = &tw.query_set;
|
|
query_set.same_device(device)?;
|
|
|
|
if let Some(index) = tw.beginning_of_pass_write_index {
|
|
pending_query_resets.use_query_set(query_set, index);
|
|
}
|
|
if let Some(index) = tw.end_of_pass_write_index {
|
|
pending_query_resets.use_query_set(query_set, index);
|
|
}
|
|
|
|
record_pass_timestamp_writes(tw, query_set_writes);
|
|
|
|
Some(hal::PassTimestampWrites {
|
|
query_set: query_set.try_raw(snatch_guard)?,
|
|
beginning_of_pass_write_index: tw.beginning_of_pass_write_index,
|
|
end_of_pass_write_index: tw.end_of_pass_write_index,
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let occlusion_query_set_hal = if let Some(query_set) = occlusion_query_set.as_ref() {
|
|
query_set.same_device(device)?;
|
|
Some(query_set.try_raw(snatch_guard)?)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let hal_desc = hal::RenderPassDescriptor {
|
|
label: hal_label,
|
|
extent,
|
|
sample_count,
|
|
color_attachments: &color_attachments_hal,
|
|
depth_stencil_attachment: depth_stencil,
|
|
multiview_mask,
|
|
timestamp_writes: timestamp_writes_hal,
|
|
occlusion_query_set: occlusion_query_set_hal,
|
|
};
|
|
unsafe {
|
|
encoder
|
|
.begin_render_pass(&hal_desc)
|
|
.map_err(|e| device.handle_hal_error(e))?;
|
|
};
|
|
drop(color_attachments_hal); // Drop, so we can consume `color_attachments` for the tracker.
|
|
|
|
// Can't borrow the tracker more than once, so have to add to the tracker after the `begin_render_pass` hal call.
|
|
if let Some(tw) = timestamp_writes.take() {
|
|
trackers.query_sets.insert_single(tw.query_set);
|
|
};
|
|
if let Some(occlusion_query_set) = occlusion_query_set.take() {
|
|
trackers.query_sets.insert_single(occlusion_query_set);
|
|
};
|
|
if let Some(at) = depth_stencil_attachment.take() {
|
|
trackers.views.insert_single(at.view.clone());
|
|
}
|
|
for at in color_attachments.iter().flatten() {
|
|
trackers.views.insert_single(at.view.clone());
|
|
if let Some(resolve_target) = at.resolve_target.clone() {
|
|
trackers.views.insert_single(resolve_target);
|
|
}
|
|
}
|
|
|
|
Ok(Self {
|
|
context,
|
|
render_attachments,
|
|
is_depth_read_only,
|
|
is_stencil_read_only,
|
|
extent,
|
|
divergent_discarded_depth_stencil_aspect,
|
|
multiview_mask,
|
|
})
|
|
}
|
|
|
|
fn finish(
|
|
self,
|
|
device: &Device,
|
|
raw: &mut dyn hal::DynCommandEncoder,
|
|
snatch_guard: &SnatchGuard,
|
|
scope: &mut UsageScope<'_>,
|
|
instance_flags: InstanceFlags,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
profiling::scope!("RenderPassInfo::finish");
|
|
unsafe {
|
|
raw.end_render_pass();
|
|
}
|
|
|
|
for ra in self.render_attachments {
|
|
let texture = &ra.texture;
|
|
texture.check_usage(TextureUsages::RENDER_ATTACHMENT)?;
|
|
|
|
// the tracker set of the pass is always in "extend" mode
|
|
unsafe {
|
|
scope
|
|
.textures
|
|
.merge_single(texture, Some(ra.selector.clone()), ra.usage)?
|
|
};
|
|
}
|
|
|
|
// If either only stencil or depth was discarded, we put in a special
|
|
// clear pass to keep the init status of the aspects in sync. We do this
|
|
// so we don't need to track init state for depth/stencil aspects
|
|
// individually.
|
|
//
|
|
// Note that we don't go the usual route of "brute force" initializing
|
|
// the texture when need arises here, since this path is actually
|
|
// something a user may genuinely want (where as the other cases are
|
|
// more seen along the lines as gracefully handling a user error).
|
|
if let Some((aspect, view)) = self.divergent_discarded_depth_stencil_aspect {
|
|
let (depth_ops, stencil_ops) = if aspect == wgt::TextureAspect::DepthOnly {
|
|
(
|
|
hal::AttachmentOps::LOAD_CLEAR | hal::AttachmentOps::STORE, // clear depth
|
|
hal::AttachmentOps::LOAD | hal::AttachmentOps::STORE, // unchanged stencil
|
|
)
|
|
} else {
|
|
(
|
|
hal::AttachmentOps::LOAD | hal::AttachmentOps::STORE, // unchanged stencil
|
|
hal::AttachmentOps::LOAD_CLEAR | hal::AttachmentOps::STORE, // clear depth
|
|
)
|
|
};
|
|
let desc = hal::RenderPassDescriptor::<'_, _, dyn hal::DynTextureView> {
|
|
label: hal_label(
|
|
Some("(wgpu internal) Zero init discarded depth/stencil aspect"),
|
|
instance_flags,
|
|
),
|
|
extent: view.state()?.render_extent.unwrap(),
|
|
sample_count: view.samples,
|
|
color_attachments: &[],
|
|
depth_stencil_attachment: Some(hal::DepthStencilAttachment {
|
|
target: hal::Attachment {
|
|
view: view.try_raw(snatch_guard)?,
|
|
usage: wgt::TextureUses::DEPTH_STENCIL_WRITE,
|
|
},
|
|
depth_ops,
|
|
stencil_ops,
|
|
clear_value: (0.0, 0),
|
|
}),
|
|
multiview_mask: self.multiview_mask,
|
|
timestamp_writes: None,
|
|
occlusion_query_set: None,
|
|
};
|
|
unsafe {
|
|
raw.begin_render_pass(&desc)
|
|
.map_err(|e| device.handle_hal_error(e))?;
|
|
raw.end_render_pass();
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn check_transient_attachment_ops<V>(load_op: LoadOp<V>, store_op: StoreOp) -> bool {
|
|
matches!(
|
|
(load_op, store_op),
|
|
(LoadOp::Clear(_) | LoadOp::DontCare(_), StoreOp::Discard)
|
|
)
|
|
}
|
|
|
|
impl CommandEncoder {
|
|
pub fn begin_render_pass(
|
|
self: &Arc<Self>,
|
|
desc: ResolvedRenderPassDescriptor<'_>,
|
|
) -> (RenderPass, Option<CommandEncoderError>) {
|
|
use EncoderStateError as SErr;
|
|
|
|
fn fill_arc_desc(
|
|
desc: ResolvedRenderPassDescriptor<'_>,
|
|
arc_desc: &mut ArcRenderPassDescriptor,
|
|
device: &Device,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
device.check_is_valid()?;
|
|
|
|
let max_color_attachments = device.limits.max_color_attachments as usize;
|
|
if desc.color_attachments.len() > max_color_attachments {
|
|
return Err(RenderPassErrorInner::ColorAttachment(
|
|
ColorAttachmentError::TooMany {
|
|
given: desc.color_attachments.len(),
|
|
limit: max_color_attachments,
|
|
},
|
|
));
|
|
}
|
|
|
|
for color_attachment in desc.color_attachments.iter() {
|
|
if let Some(RenderPassColorAttachment {
|
|
view,
|
|
depth_slice,
|
|
resolve_target,
|
|
load_op,
|
|
store_op,
|
|
}) = color_attachment
|
|
{
|
|
view.check_valid()?;
|
|
view.same_device(device)?;
|
|
if matches!(*load_op, LoadOp::DontCare(..))
|
|
&& device
|
|
.instance_flags
|
|
.contains(InstanceFlags::STRICT_WEBGPU_COMPLIANCE)
|
|
{
|
|
return Err(RenderPassErrorInner::ColorAttachment(
|
|
ColorAttachmentError::LoadOpDontCareUnderStrictWebgpuCompliance,
|
|
));
|
|
}
|
|
|
|
if view
|
|
.desc
|
|
.usage
|
|
.contains(TextureUsages::TRANSIENT_ATTACHMENT)
|
|
&& !check_transient_attachment_ops(*load_op, *store_op)
|
|
{
|
|
return Err(RenderPassErrorInner::ColorAttachment(
|
|
ColorAttachmentError::InvalidTransientAttachmentOp((
|
|
*load_op, *store_op,
|
|
)),
|
|
));
|
|
}
|
|
|
|
let resolve_target = if let Some(resolve_target) = resolve_target {
|
|
resolve_target.check_valid()?;
|
|
resolve_target.same_device(device)?;
|
|
|
|
Some(resolve_target)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
arc_desc
|
|
.color_attachments
|
|
.push(Some(ArcRenderPassColorAttachment {
|
|
view: Arc::clone(view),
|
|
depth_slice: *depth_slice,
|
|
resolve_target: resolve_target.map(Arc::clone),
|
|
load_op: *load_op,
|
|
store_op: *store_op,
|
|
}));
|
|
} else {
|
|
arc_desc.color_attachments.push(None);
|
|
}
|
|
}
|
|
|
|
// https://gpuweb.github.io/gpuweb/#abstract-opdef-gpurenderpassdepthstencilattachment-gpurenderpassdepthstencilattachment-valid-usage
|
|
arc_desc.depth_stencil_attachment = if let Some(depth_stencil_attachment) =
|
|
desc.depth_stencil_attachment
|
|
{
|
|
let view = depth_stencil_attachment.view;
|
|
view.check_valid()?;
|
|
view.same_device(device)?;
|
|
|
|
let format = view.desc.format;
|
|
if !format.is_depth_stencil_format() {
|
|
return Err(RenderPassErrorInner::InvalidAttachment(
|
|
AttachmentError::InvalidDepthStencilAttachmentFormat(view.desc.format),
|
|
));
|
|
}
|
|
|
|
if view
|
|
.desc
|
|
.usage
|
|
.contains(TextureUsages::TRANSIENT_ATTACHMENT)
|
|
{
|
|
// We raise errors here for transient depth/stencil attachments if they
|
|
// are read only, or use unsupported ops. `resolve` (called below)
|
|
// validates that operations are specified iff the attachment is not
|
|
// read-only.
|
|
if format.has_depth_aspect() {
|
|
match depth_stencil_attachment.depth {
|
|
PassChannel {
|
|
load_op: Some(load_op),
|
|
store_op: Some(store_op),
|
|
read_only: _,
|
|
} => {
|
|
if !check_transient_attachment_ops(load_op, store_op) {
|
|
return Err(RenderPassErrorInner::InvalidAttachment(
|
|
AttachmentError::InvalidTransientDepthAttachmentOps((
|
|
load_op, store_op,
|
|
)),
|
|
));
|
|
}
|
|
}
|
|
PassChannel {
|
|
read_only: true, ..
|
|
} => {
|
|
return Err(RenderPassErrorInner::InvalidAttachment(
|
|
AttachmentError::ReadOnlyTransientDepthAttachment,
|
|
))
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
if format.has_stencil_aspect() {
|
|
match depth_stencil_attachment.stencil {
|
|
PassChannel {
|
|
load_op: Some(load_op),
|
|
store_op: Some(store_op),
|
|
read_only: _,
|
|
} => {
|
|
if !check_transient_attachment_ops(load_op, store_op) {
|
|
return Err(RenderPassErrorInner::InvalidAttachment(
|
|
AttachmentError::InvalidTransientStencilAttachmentOps((
|
|
load_op, store_op,
|
|
)),
|
|
));
|
|
}
|
|
}
|
|
PassChannel {
|
|
read_only: true, ..
|
|
} => {
|
|
return Err(RenderPassErrorInner::InvalidAttachment(
|
|
AttachmentError::ReadOnlyTransientStencilAttachment,
|
|
))
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
Some(ResolvedRenderPassDepthStencilAttachment {
|
|
view,
|
|
depth: if format.has_depth_aspect() {
|
|
depth_stencil_attachment
|
|
.depth
|
|
.resolve(device.instance_flags, |clear| {
|
|
if let Some(clear) = clear {
|
|
// If this.depthLoadOp is "clear", this.depthClearValue must be provided and must be between 0.0 and 1.0, inclusive.
|
|
if !(0.0..=1.0).contains(&clear) {
|
|
Err(AttachmentError::ClearValueOutOfRange(clear))
|
|
} else {
|
|
Ok(clear)
|
|
}
|
|
} else {
|
|
Err(AttachmentError::NoClearValue)
|
|
}
|
|
})?
|
|
} else {
|
|
if depth_stencil_attachment.depth.load_op.is_some()
|
|
|| depth_stencil_attachment.depth.store_op.is_some()
|
|
{
|
|
return Err(RenderPassErrorInner::InvalidAttachment(
|
|
AttachmentError::DepthOpsWithoutAspect {
|
|
format,
|
|
ops: (
|
|
depth_stencil_attachment.depth.load_op,
|
|
depth_stencil_attachment.depth.store_op,
|
|
),
|
|
},
|
|
));
|
|
}
|
|
ResolvedPassChannel::ReadOnly
|
|
},
|
|
stencil: if format.has_stencil_aspect() {
|
|
depth_stencil_attachment.stencil.resolve(
|
|
device.instance_flags,
|
|
|clear| {
|
|
Ok(convert_stencil_value(
|
|
clear.unwrap_or_default(),
|
|
Some(format),
|
|
))
|
|
},
|
|
)?
|
|
} else {
|
|
if depth_stencil_attachment.stencil.load_op.is_some()
|
|
|| depth_stencil_attachment.stencil.store_op.is_some()
|
|
{
|
|
return Err(RenderPassErrorInner::InvalidAttachment(
|
|
AttachmentError::StencilOpsWithoutAspect {
|
|
format,
|
|
ops: (
|
|
depth_stencil_attachment.stencil.load_op,
|
|
depth_stencil_attachment.stencil.store_op,
|
|
),
|
|
},
|
|
));
|
|
}
|
|
ResolvedPassChannel::ReadOnly
|
|
},
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
|
|
arc_desc.timestamp_writes = desc
|
|
.timestamp_writes
|
|
.map(|tw| {
|
|
CommandEncoder::validate_pass_timestamp_writes::<RenderPassErrorInner>(
|
|
device, &tw,
|
|
)
|
|
})
|
|
.transpose()?;
|
|
|
|
arc_desc.occlusion_query_set =
|
|
if let Some(occlusion_query_set) = desc.occlusion_query_set {
|
|
occlusion_query_set.check_is_valid()?;
|
|
occlusion_query_set.same_device(device)?;
|
|
|
|
if !matches!(occlusion_query_set.desc.ty, wgt::QueryType::Occlusion) {
|
|
return Err(QueryUseError::IncompatibleType {
|
|
set_type: occlusion_query_set.desc.ty.into(),
|
|
query_type: super::SimplifiedQueryType::Occlusion,
|
|
}
|
|
.into());
|
|
}
|
|
|
|
Some(occlusion_query_set)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
arc_desc.multiview_mask = desc.multiview_mask;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
let scope = PassErrorScope::Pass;
|
|
let mut cmd_buf_data = self.data.lock();
|
|
|
|
match cmd_buf_data.lock_encoder() {
|
|
Ok(()) => {
|
|
drop(cmd_buf_data);
|
|
let label = desc.label.clone();
|
|
let mut arc_desc = ArcRenderPassDescriptor {
|
|
label: &label,
|
|
timestamp_writes: None,
|
|
color_attachments: ArrayVec::new(),
|
|
depth_stencil_attachment: None,
|
|
occlusion_query_set: None,
|
|
multiview_mask: None,
|
|
};
|
|
match fill_arc_desc(desc, &mut arc_desc, &self.device) {
|
|
Ok(()) => (RenderPass::new(self.clone(), arc_desc), None),
|
|
Err(err) => (
|
|
RenderPass::new_invalid(self.clone(), &label, err.map_pass_err(scope)),
|
|
None,
|
|
),
|
|
}
|
|
}
|
|
Err(err @ SErr::Locked) => {
|
|
// Attempting to open a new pass while the encoder is locked
|
|
// invalidates the encoder, but does not generate a validation
|
|
// error.
|
|
cmd_buf_data.invalidate(err.clone());
|
|
drop(cmd_buf_data);
|
|
(
|
|
RenderPass::new_invalid(self.clone(), &desc.label, err.map_pass_err(scope)),
|
|
None,
|
|
)
|
|
}
|
|
Err(err @ (SErr::Ended | SErr::Submitted)) => {
|
|
// Attempting to open a new pass after the encode has ended
|
|
// generates an immediate validation error.
|
|
drop(cmd_buf_data);
|
|
(
|
|
RenderPass::new_invalid(
|
|
self.clone(),
|
|
&desc.label,
|
|
err.clone().map_pass_err(scope),
|
|
),
|
|
Some(err.into()),
|
|
)
|
|
}
|
|
Err(err @ SErr::Invalid) => {
|
|
// Passes can be opened even on an invalid encoder. Such passes
|
|
// are even valid, but since there's no visible side-effect of
|
|
// the pass being valid and there's no point in storing recorded
|
|
// commands that will ultimately be discarded, we open an
|
|
// invalid pass to save that work.
|
|
drop(cmd_buf_data);
|
|
(
|
|
RenderPass::new_invalid(self.clone(), &desc.label, err.map_pass_err(scope)),
|
|
None,
|
|
)
|
|
}
|
|
Err(SErr::Unlocked) => {
|
|
unreachable!("lock_encoder cannot fail due to the encoder being unlocked")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl RenderPass {
|
|
pub fn end(&mut self) -> Result<(), EncoderStateError> {
|
|
profiling::scope!(
|
|
"CommandEncoder::run_render_pass {}",
|
|
self.base.label.as_deref().unwrap_or("")
|
|
);
|
|
|
|
let cmd_enc = self.parent.take().ok_or(EncoderStateError::Ended)?;
|
|
let mut cmd_buf_data = cmd_enc.data.lock();
|
|
|
|
cmd_buf_data.unlock_encoder()?;
|
|
|
|
let base = self.base.take();
|
|
|
|
if let Err(RenderPassError { inner, scope: _ }) = &base {
|
|
if let RenderPassErrorInner::EncoderState(
|
|
err @ (EncoderStateError::Locked | EncoderStateError::Ended),
|
|
) = inner.as_ref()
|
|
{
|
|
// Most encoding errors are detected and raised within `finish()`.
|
|
//
|
|
// However, we raise a validation error here if the pass was opened
|
|
// within another pass, or on a finished encoder. The latter is
|
|
// particularly important, because in that case reporting errors via
|
|
// `CommandEncoder::finish` is not possible.
|
|
return Err(err.clone());
|
|
}
|
|
}
|
|
|
|
cmd_buf_data.push_with(|| -> Result<_, RenderPassError> {
|
|
Ok(ArcCommand::RunRenderPass {
|
|
pass: base?,
|
|
color_attachments: SmallVec::from(self.color_attachments.as_slice()),
|
|
depth_stencil_attachment: self.depth_stencil_attachment.take(),
|
|
timestamp_writes: self.timestamp_writes.take(),
|
|
occlusion_query_set: self.occlusion_query_set.take(),
|
|
multiview_mask: self.multiview_mask,
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Global {
|
|
/// Creates a render pass.
|
|
///
|
|
/// If creation fails, an invalid pass is returned. Attempting to record
|
|
/// commands into an invalid pass is permitted, but a validation error will
|
|
/// ultimately be generated when the parent encoder is finished, and it is
|
|
/// not possible to run any commands from the invalid pass.
|
|
///
|
|
/// If successful, puts the encoder into the [`Locked`] state.
|
|
///
|
|
/// [`Locked`]: crate::command::CommandEncoderStatus::Locked
|
|
pub fn command_encoder_begin_render_pass(
|
|
&self,
|
|
encoder_id: id::CommandEncoderId,
|
|
desc: &RenderPassDescriptor<'_>,
|
|
) -> (RenderPass, Option<CommandEncoderError>) {
|
|
let hub = &self.hub;
|
|
|
|
let cmd_enc = hub.command_encoders.get(encoder_id);
|
|
|
|
let texture_views = hub.texture_views.read();
|
|
let query_sets = hub.query_sets.read();
|
|
|
|
let desc = ResolvedRenderPassDescriptor {
|
|
label: desc.label.as_deref().map(Cow::Borrowed),
|
|
color_attachments: Cow::Owned(
|
|
desc.color_attachments
|
|
.iter()
|
|
.map(|at| {
|
|
at.as_ref().map(|at| RenderPassColorAttachment {
|
|
view: texture_views.get(at.view),
|
|
depth_slice: at.depth_slice,
|
|
resolve_target: at
|
|
.resolve_target
|
|
.as_ref()
|
|
.map(|rt| texture_views.get(*rt)),
|
|
load_op: at.load_op,
|
|
store_op: at.store_op,
|
|
})
|
|
})
|
|
.collect(),
|
|
),
|
|
depth_stencil_attachment: desc.depth_stencil_attachment.as_ref().map(|at| {
|
|
RenderPassDepthStencilAttachment {
|
|
view: texture_views.get(at.view),
|
|
depth: at.depth.clone(),
|
|
stencil: at.stencil.clone(),
|
|
}
|
|
}),
|
|
timestamp_writes: desc
|
|
.timestamp_writes
|
|
.as_ref()
|
|
.map(|tw| PassTimestampWrites {
|
|
query_set: query_sets.get(tw.query_set),
|
|
beginning_of_pass_write_index: tw.beginning_of_pass_write_index,
|
|
end_of_pass_write_index: tw.end_of_pass_write_index,
|
|
}),
|
|
occlusion_query_set: desc
|
|
.occlusion_query_set
|
|
.as_ref()
|
|
.map(|query_set| query_sets.get(*query_set)),
|
|
multiview_mask: desc.multiview_mask,
|
|
};
|
|
|
|
drop(texture_views);
|
|
drop(query_sets);
|
|
|
|
cmd_enc.begin_render_pass(desc)
|
|
}
|
|
|
|
pub fn command_encoder_begin_render_pass_with_id(
|
|
&self,
|
|
encoder_id: id::CommandEncoderId,
|
|
desc: &RenderPassDescriptor<'_>,
|
|
id_in: Option<id::RenderPassEncoderId>,
|
|
) -> (id::RenderPassEncoderId, Option<CommandEncoderError>) {
|
|
let hub = &self.hub;
|
|
let fid = hub.render_passes.prepare(id_in);
|
|
let (render_pass, error) = self.command_encoder_begin_render_pass(encoder_id, desc);
|
|
// no lock rank here because only one thread should be using renderpass
|
|
// and it's only used by id variants of render pass methods on global
|
|
// so no deadlock (or concurrent lock) should happen in practise
|
|
let id = fid.assign(Arc::new(Mutex::new(render_pass)));
|
|
(id, error)
|
|
}
|
|
|
|
pub fn render_pass_end(&self, pass: &mut RenderPass) -> Result<(), EncoderStateError> {
|
|
profiling::scope!(
|
|
"CommandEncoder::run_render_pass {}",
|
|
pass.base.label.as_deref().unwrap_or("")
|
|
);
|
|
|
|
let cmd_enc = pass.parent.take().ok_or(EncoderStateError::Ended)?;
|
|
let mut cmd_buf_data = cmd_enc.data.lock();
|
|
|
|
cmd_buf_data.unlock_encoder()?;
|
|
|
|
let base = pass.base.take();
|
|
|
|
if let Err(RenderPassError { inner, scope: _ }) = &base {
|
|
if let RenderPassErrorInner::EncoderState(
|
|
err @ (EncoderStateError::Locked | EncoderStateError::Ended),
|
|
) = inner.as_ref()
|
|
{
|
|
// Most encoding errors are detected and raised within `finish()`.
|
|
//
|
|
// However, we raise a validation error here if the pass was opened
|
|
// within another pass, or on a finished encoder. The latter is
|
|
// particularly important, because in that case reporting errors via
|
|
// `CommandEncoder::finish` is not possible.
|
|
return Err(err.clone());
|
|
}
|
|
}
|
|
|
|
cmd_buf_data.push_with(|| -> Result<_, RenderPassError> {
|
|
Ok(ArcCommand::RunRenderPass {
|
|
pass: base?,
|
|
color_attachments: SmallVec::from(pass.color_attachments.as_slice()),
|
|
depth_stencil_attachment: pass.depth_stencil_attachment.take(),
|
|
timestamp_writes: pass.timestamp_writes.take(),
|
|
occlusion_query_set: pass.occlusion_query_set.take(),
|
|
multiview_mask: pass.multiview_mask,
|
|
})
|
|
})
|
|
}
|
|
|
|
pub fn render_pass_end_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
) -> Result<(), EncoderStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be accessed concurrently");
|
|
self.render_pass_end(&mut pass)
|
|
}
|
|
|
|
pub fn render_pass_drop(&self, pass: id::RenderPassEncoderId) {
|
|
self.hub.render_passes.remove(pass);
|
|
}
|
|
}
|
|
|
|
pub(super) fn encode_render_pass(
|
|
parent_state: &mut EncodingState<InnerCommandEncoder>,
|
|
mut base: BasePass<ArcRenderCommand, Infallible>,
|
|
color_attachments: ColorAttachments<Arc<TextureView>>,
|
|
mut depth_stencil_attachment: Option<
|
|
ResolvedRenderPassDepthStencilAttachment<Arc<TextureView>>,
|
|
>,
|
|
mut timestamp_writes: Option<ArcPassTimestampWrites>,
|
|
occlusion_query_set: Option<Arc<QuerySet>>,
|
|
multiview_mask: Option<NonZeroU32>,
|
|
) -> Result<(), RenderPassError> {
|
|
let pass_scope = PassErrorScope::Pass;
|
|
|
|
let device = parent_state.device;
|
|
|
|
let mut indirect_draw_validation_batcher = crate::indirect_validation::DrawBatcher::new();
|
|
|
|
// We automatically keep extending command buffers over time, and because
|
|
// we want to insert a command buffer _before_ what we're about to record,
|
|
// we need to make sure to close the previous one.
|
|
parent_state
|
|
.raw_encoder
|
|
.close_if_open()
|
|
.map_pass_err(pass_scope)?;
|
|
let raw_encoder = parent_state
|
|
.raw_encoder
|
|
.open_pass(base.label.as_deref())
|
|
.map_pass_err(pass_scope)?;
|
|
|
|
let (scope, pending_discard_init_fixups, mut pending_query_resets) = {
|
|
let mut pending_query_resets = QueryResetMap::new();
|
|
let mut pending_discard_init_fixups = SurfacesInDiscardState::new();
|
|
|
|
let info = RenderPassInfo::start(
|
|
device,
|
|
hal_label(base.label.as_deref(), device.instance_flags),
|
|
&color_attachments,
|
|
depth_stencil_attachment.take(),
|
|
timestamp_writes.take(),
|
|
// Still needed down the line.
|
|
// TODO(wumpf): by restructuring the code, we could get rid of some of this Arc clone.
|
|
occlusion_query_set.clone(),
|
|
raw_encoder,
|
|
parent_state.tracker,
|
|
parent_state.texture_memory_actions,
|
|
&mut pending_query_resets,
|
|
&mut pending_discard_init_fixups,
|
|
parent_state.snatch_guard,
|
|
parent_state.query_set_writes,
|
|
multiview_mask,
|
|
)
|
|
.map_pass_err(pass_scope)?;
|
|
|
|
let indices = &device.tracker_indices;
|
|
parent_state
|
|
.tracker
|
|
.buffers
|
|
.set_size(indices.buffers.size());
|
|
parent_state
|
|
.tracker
|
|
.textures
|
|
.set_size(indices.textures.size());
|
|
|
|
let mut debug_scope_depth = 0;
|
|
|
|
let mut state = State {
|
|
pipeline_flags: PipelineFlags::empty(),
|
|
blend_constant: OptionalState::Unused,
|
|
stencil_reference: 0,
|
|
pipeline: None,
|
|
index: IndexState::default(),
|
|
vertex: VertexState::default(),
|
|
|
|
info,
|
|
|
|
pass: pass::PassState {
|
|
base: EncodingState {
|
|
device,
|
|
raw_encoder,
|
|
tracker: parent_state.tracker,
|
|
buffer_memory_init_actions: parent_state.buffer_memory_init_actions,
|
|
texture_memory_actions: parent_state.texture_memory_actions,
|
|
as_actions: parent_state.as_actions,
|
|
temp_resources: parent_state.temp_resources,
|
|
indirect_draw_validation_resources: parent_state
|
|
.indirect_draw_validation_resources,
|
|
snatch_guard: parent_state.snatch_guard,
|
|
debug_scope_depth: &mut debug_scope_depth,
|
|
query_set_writes: parent_state.query_set_writes,
|
|
deferred_query_set_resolves: parent_state.deferred_query_set_resolves,
|
|
},
|
|
pending_discard_init_fixups,
|
|
scope: device.new_usage_scope(),
|
|
binder: Binder::new(),
|
|
|
|
temp_offsets: Vec::new(),
|
|
dynamic_offset_count: 0,
|
|
|
|
string_offset: 0,
|
|
|
|
immediate_state: ImmediateState::default(),
|
|
},
|
|
|
|
active_occlusion_query: None,
|
|
active_pipeline_statistics_query: None,
|
|
};
|
|
|
|
for command in base.commands.drain(..) {
|
|
match command {
|
|
ArcRenderCommand::SetBindGroup {
|
|
index,
|
|
num_dynamic_offsets,
|
|
bind_group,
|
|
} => {
|
|
let scope = PassErrorScope::SetBindGroup;
|
|
pass::set_bind_group::<RenderPassErrorInner>(
|
|
&mut state.pass,
|
|
device,
|
|
&base.dynamic_offsets,
|
|
index,
|
|
num_dynamic_offsets,
|
|
bind_group,
|
|
true,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::SetPipeline(pipeline) => {
|
|
let scope = PassErrorScope::SetPipelineRender;
|
|
set_pipeline(&mut state, device, pipeline).map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::SetIndexBuffer {
|
|
buffer,
|
|
index_format,
|
|
offset,
|
|
size,
|
|
} => {
|
|
let scope = PassErrorScope::SetIndexBuffer;
|
|
set_index_buffer(&mut state, device, buffer, index_format, offset, size)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::SetVertexBuffer {
|
|
slot,
|
|
buffer,
|
|
offset,
|
|
size,
|
|
} => {
|
|
let scope = PassErrorScope::SetVertexBuffer;
|
|
set_vertex_buffer(&mut state, device, slot, buffer, offset, size)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::SetBlendConstant(ref color) => {
|
|
set_blend_constant(&mut state, color);
|
|
}
|
|
ArcRenderCommand::SetStencilReference(value) => {
|
|
set_stencil_reference(&mut state, value);
|
|
}
|
|
ArcRenderCommand::SetViewport {
|
|
rect,
|
|
depth_min,
|
|
depth_max,
|
|
} => {
|
|
let scope = PassErrorScope::SetViewport;
|
|
set_viewport(&mut state, rect, depth_min, depth_max).map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::SetImmediate { offset, data } => {
|
|
let scope = PassErrorScope::SetImmediate;
|
|
state
|
|
.pass
|
|
.immediate_state
|
|
.set_immediates::<RenderPassErrorInner>(
|
|
&state.pass.base.device.limits,
|
|
offset,
|
|
&data,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::SetScissor(rect) => {
|
|
let scope = PassErrorScope::SetScissorRect;
|
|
set_scissor(&mut state, rect).map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::Draw {
|
|
vertex_count,
|
|
instance_count,
|
|
first_vertex,
|
|
first_instance,
|
|
} => {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::Draw,
|
|
family: DrawCommandFamily::Draw,
|
|
};
|
|
draw(
|
|
&mut state,
|
|
vertex_count,
|
|
instance_count,
|
|
first_vertex,
|
|
first_instance,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::DrawIndexed {
|
|
index_count,
|
|
instance_count,
|
|
first_index,
|
|
base_vertex,
|
|
first_instance,
|
|
} => {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::Draw,
|
|
family: DrawCommandFamily::DrawIndexed,
|
|
};
|
|
draw_indexed(
|
|
&mut state,
|
|
index_count,
|
|
instance_count,
|
|
first_index,
|
|
base_vertex,
|
|
first_instance,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::DrawMeshTasks {
|
|
group_count_x,
|
|
group_count_y,
|
|
group_count_z,
|
|
} => {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::Draw,
|
|
family: DrawCommandFamily::DrawMeshTasks,
|
|
};
|
|
draw_mesh_tasks(&mut state, group_count_x, group_count_y, group_count_z)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::DrawIndirect {
|
|
buffer,
|
|
offset,
|
|
count,
|
|
family,
|
|
|
|
vertex_or_index_limit: _,
|
|
instance_limit: _,
|
|
} => {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: if count != 1 {
|
|
DrawKind::MultiDrawIndirect
|
|
} else {
|
|
DrawKind::DrawIndirect
|
|
},
|
|
family,
|
|
};
|
|
multi_draw_indirect(
|
|
&mut state,
|
|
&mut indirect_draw_validation_batcher,
|
|
device,
|
|
buffer,
|
|
offset,
|
|
count,
|
|
family,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::MultiDrawIndirectCount {
|
|
buffer,
|
|
offset,
|
|
count_buffer,
|
|
count_buffer_offset,
|
|
max_count,
|
|
family,
|
|
} => {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::MultiDrawIndirectCount,
|
|
family,
|
|
};
|
|
multi_draw_indirect_count(
|
|
&mut state,
|
|
device,
|
|
buffer,
|
|
offset,
|
|
count_buffer,
|
|
count_buffer_offset,
|
|
max_count,
|
|
family,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::PushDebugGroup { color: _, len } => {
|
|
pass::push_debug_group(&mut state.pass, &base.string_data, len);
|
|
}
|
|
ArcRenderCommand::PopDebugGroup => {
|
|
let scope = PassErrorScope::PopDebugGroup;
|
|
pass::pop_debug_group::<RenderPassErrorInner>(&mut state.pass)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::InsertDebugMarker { color: _, len } => {
|
|
pass::insert_debug_marker(&mut state.pass, &base.string_data, len);
|
|
}
|
|
ArcRenderCommand::WriteTimestamp {
|
|
query_set,
|
|
query_index,
|
|
} => {
|
|
let scope = PassErrorScope::WriteTimestamp;
|
|
pass::write_timestamp::<RenderPassErrorInner>(
|
|
&mut state.pass,
|
|
device,
|
|
Some(&mut pending_query_resets),
|
|
query_set,
|
|
query_index,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::BeginOcclusionQuery { query_index } => {
|
|
api_log!("RenderPass::begin_occlusion_query {query_index}");
|
|
let scope = PassErrorScope::BeginOcclusionQuery;
|
|
|
|
let query_set = occlusion_query_set
|
|
.clone()
|
|
.ok_or(RenderPassErrorInner::MissingOcclusionQuerySet)
|
|
.map_pass_err(scope)?;
|
|
|
|
validate_and_begin_occlusion_query(
|
|
query_set,
|
|
state.pass.base.raw_encoder,
|
|
&mut state.pass.base.tracker.query_sets,
|
|
query_index,
|
|
Some(&mut pending_query_resets),
|
|
&mut state.active_occlusion_query,
|
|
state.pass.base.snatch_guard,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::EndOcclusionQuery => {
|
|
api_log!("RenderPass::end_occlusion_query");
|
|
let scope = PassErrorScope::EndOcclusionQuery;
|
|
|
|
end_occlusion_query(
|
|
state.pass.base.raw_encoder,
|
|
&mut state.active_occlusion_query,
|
|
state.pass.base.snatch_guard,
|
|
state.pass.base.query_set_writes,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::BeginPipelineStatisticsQuery {
|
|
query_set,
|
|
query_index,
|
|
} => {
|
|
api_log!(
|
|
"RenderPass::begin_pipeline_statistics_query {query_index} {}",
|
|
query_set.error_ident()
|
|
);
|
|
let scope = PassErrorScope::BeginPipelineStatisticsQuery;
|
|
|
|
validate_and_begin_pipeline_statistics_query(
|
|
query_set,
|
|
state.pass.base.raw_encoder,
|
|
&mut state.pass.base.tracker.query_sets,
|
|
device,
|
|
query_index,
|
|
Some(&mut pending_query_resets),
|
|
&mut state.active_pipeline_statistics_query,
|
|
state.pass.base.snatch_guard,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::EndPipelineStatisticsQuery => {
|
|
api_log!("RenderPass::end_pipeline_statistics_query");
|
|
let scope = PassErrorScope::EndPipelineStatisticsQuery;
|
|
|
|
end_pipeline_statistics_query(
|
|
state.pass.base.raw_encoder,
|
|
&mut state.active_pipeline_statistics_query,
|
|
state.pass.base.snatch_guard,
|
|
state.pass.base.query_set_writes,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
ArcRenderCommand::ExecuteBundle(bundle) => {
|
|
let scope = PassErrorScope::ExecuteBundle;
|
|
execute_bundle(
|
|
&mut state,
|
|
&mut indirect_draw_validation_batcher,
|
|
device,
|
|
bundle,
|
|
)
|
|
.map_pass_err(scope)?;
|
|
}
|
|
}
|
|
}
|
|
|
|
if *state.pass.base.debug_scope_depth > 0 {
|
|
Err(
|
|
RenderPassErrorInner::DebugGroupError(DebugGroupError::MissingPop)
|
|
.map_pass_err(pass_scope),
|
|
)?;
|
|
}
|
|
if state.active_occlusion_query.is_some() {
|
|
Err(RenderPassErrorInner::QueryUse(QueryUseError::MissingEnd {
|
|
query_type: super::SimplifiedQueryType::Occlusion,
|
|
})
|
|
.map_pass_err(pass_scope))?;
|
|
}
|
|
if state.active_pipeline_statistics_query.is_some() {
|
|
Err(RenderPassErrorInner::QueryUse(QueryUseError::MissingEnd {
|
|
query_type: super::SimplifiedQueryType::PipelineStatistics,
|
|
})
|
|
.map_pass_err(pass_scope))?;
|
|
}
|
|
|
|
state
|
|
.info
|
|
.finish(
|
|
device,
|
|
state.pass.base.raw_encoder,
|
|
state.pass.base.snatch_guard,
|
|
&mut state.pass.scope,
|
|
device.instance_flags,
|
|
)
|
|
.map_pass_err(pass_scope)?;
|
|
|
|
let trackers = state.pass.scope;
|
|
|
|
let pending_discard_init_fixups = state.pass.pending_discard_init_fixups;
|
|
|
|
parent_state.raw_encoder.close().map_pass_err(pass_scope)?;
|
|
(trackers, pending_discard_init_fixups, pending_query_resets)
|
|
};
|
|
|
|
let encoder = &mut parent_state.raw_encoder;
|
|
let tracker = &mut parent_state.tracker;
|
|
|
|
{
|
|
let transit = encoder
|
|
.open_pass(hal_label(
|
|
Some("(wgpu internal) Pre Pass"),
|
|
device.instance_flags,
|
|
))
|
|
.map_pass_err(pass_scope)?;
|
|
|
|
fixup_discarded_surfaces(
|
|
pending_discard_init_fixups.into_iter(),
|
|
transit,
|
|
&mut tracker.textures,
|
|
device,
|
|
parent_state.snatch_guard,
|
|
);
|
|
|
|
pending_query_resets
|
|
.reset_queries(transit, parent_state.snatch_guard)
|
|
.map_pass_err(pass_scope)?;
|
|
|
|
CommandEncoder::insert_barriers_from_scope(
|
|
transit,
|
|
tracker,
|
|
&scope,
|
|
parent_state.snatch_guard,
|
|
);
|
|
|
|
if let Some(ref indirect_validation) = device.indirect_validation {
|
|
indirect_validation
|
|
.draw
|
|
.inject_validation_pass(
|
|
device,
|
|
parent_state.snatch_guard,
|
|
parent_state.indirect_draw_validation_resources,
|
|
parent_state.temp_resources,
|
|
transit,
|
|
indirect_draw_validation_batcher,
|
|
)
|
|
.map_pass_err(pass_scope)?;
|
|
}
|
|
}
|
|
|
|
encoder.close_and_swap().map_pass_err(pass_scope)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn set_pipeline(
|
|
state: &mut State,
|
|
device: &Arc<Device>,
|
|
pipeline: Arc<RenderPipeline>,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
api_log!("RenderPass::set_pipeline {}", pipeline.error_ident());
|
|
|
|
state.pipeline = Some(pipeline.clone());
|
|
|
|
let pipeline = state
|
|
.pass
|
|
.base
|
|
.tracker
|
|
.render_pipelines
|
|
.insert_single(pipeline)
|
|
.clone();
|
|
|
|
pipeline.same_device(device)?;
|
|
|
|
state
|
|
.info
|
|
.context
|
|
.check_compatible(&pipeline.pass_context, pipeline.as_ref())
|
|
.map_err(RenderCommandError::IncompatiblePipelineTargets)?;
|
|
|
|
state.pipeline_flags = pipeline.flags;
|
|
|
|
if pipeline.flags.contains(PipelineFlags::WRITES_DEPTH) && state.info.is_depth_read_only {
|
|
return Err(RenderCommandError::IncompatibleDepthAccess(pipeline.error_ident()).into());
|
|
}
|
|
if pipeline.flags.contains(PipelineFlags::WRITES_STENCIL) && state.info.is_stencil_read_only {
|
|
return Err(RenderCommandError::IncompatibleStencilAccess(pipeline.error_ident()).into());
|
|
}
|
|
|
|
state
|
|
.blend_constant
|
|
.require(pipeline.flags.contains(PipelineFlags::BLEND_CONSTANT));
|
|
|
|
unsafe {
|
|
state
|
|
.pass
|
|
.base
|
|
.raw_encoder
|
|
.set_render_pipeline(pipeline.raw()?);
|
|
}
|
|
|
|
if pipeline.flags.contains(PipelineFlags::STENCIL_REFERENCE) {
|
|
unsafe {
|
|
state
|
|
.pass
|
|
.base
|
|
.raw_encoder
|
|
.set_stencil_reference(state.stencil_reference);
|
|
}
|
|
}
|
|
|
|
// Rebind resource
|
|
pass::change_pipeline_layout::<RenderPassErrorInner>(
|
|
&mut state.pass,
|
|
pipeline.layout()?,
|
|
&pipeline.late_sized_buffer_groups,
|
|
)?;
|
|
|
|
// Update vertex buffer limits.
|
|
state.vertex.update_limits(&pipeline.vertex_steps);
|
|
Ok(())
|
|
}
|
|
|
|
// This function is duplicative of `bundle::set_index_buffer`.
|
|
fn set_index_buffer(
|
|
state: &mut State,
|
|
device: &Arc<Device>,
|
|
buffer: Arc<Buffer>,
|
|
index_format: IndexFormat,
|
|
offset: u64,
|
|
size: Option<BufferSize>,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
api_log!("RenderPass::set_index_buffer {}", buffer.error_ident());
|
|
|
|
state
|
|
.pass
|
|
.scope
|
|
.buffers
|
|
.merge_single(&buffer, wgt::BufferUses::INDEX)?;
|
|
|
|
buffer.same_device(device)?;
|
|
|
|
buffer.check_usage(BufferUsages::INDEX)?;
|
|
|
|
if !offset.is_multiple_of(u64::from(index_format.byte_size())) {
|
|
return Err(RenderCommandError::UnalignedIndexBuffer {
|
|
offset,
|
|
alignment: index_format.byte_size() as usize,
|
|
}
|
|
.into());
|
|
}
|
|
let (binding, resolved_size) = buffer
|
|
.binding(offset, size, state.pass.base.snatch_guard)
|
|
.map_err(RenderCommandError::from)?;
|
|
let end = offset + resolved_size;
|
|
state.index.update_buffer(offset..end, index_format);
|
|
|
|
state.pass.base.buffer_memory_init_actions.extend(
|
|
buffer.initialization_status.read().create_action(
|
|
&buffer,
|
|
offset..end,
|
|
MemoryInitKind::NeedsInitializedMemory,
|
|
),
|
|
);
|
|
|
|
unsafe {
|
|
hal::DynCommandEncoder::set_index_buffer(
|
|
state.pass.base.raw_encoder,
|
|
binding,
|
|
index_format,
|
|
);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
// This function is duplicative of `render::set_vertex_buffer`.
|
|
fn set_vertex_buffer(
|
|
state: &mut State,
|
|
device: &Arc<Device>,
|
|
slot: u32,
|
|
buffer: Option<Arc<Buffer>>,
|
|
offset: u64,
|
|
size: Option<BufferSize>,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
if let Some(ref buffer) = buffer {
|
|
api_log!(
|
|
"RenderPass::set_vertex_buffer {slot} {}",
|
|
buffer.error_ident()
|
|
);
|
|
} else {
|
|
api_log!("RenderPass::set_vertex_buffer {slot} None");
|
|
}
|
|
|
|
let max_vertex_buffers = state.pass.base.device.limits.max_vertex_buffers;
|
|
if slot >= max_vertex_buffers {
|
|
return Err(RenderCommandError::VertexBufferIndexOutOfRange {
|
|
index: slot,
|
|
max: max_vertex_buffers,
|
|
}
|
|
.into());
|
|
}
|
|
|
|
if let Some(buffer) = buffer {
|
|
buffer.same_device(device)?;
|
|
buffer.check_usage(BufferUsages::VERTEX)?;
|
|
|
|
if !offset.is_multiple_of(wgt::VERTEX_ALIGNMENT) {
|
|
return Err(RenderCommandError::UnalignedVertexBuffer { slot, offset }.into());
|
|
}
|
|
let binding_size = buffer
|
|
.resolve_binding_size(offset, size)
|
|
.map_err(RenderCommandError::from)?;
|
|
let buffer_range = offset..(offset + binding_size);
|
|
|
|
state
|
|
.pass
|
|
.scope
|
|
.buffers
|
|
.merge_single(&buffer, wgt::BufferUses::VERTEX)?;
|
|
|
|
state.pass.base.buffer_memory_init_actions.extend(
|
|
buffer.initialization_status.read().create_action(
|
|
&buffer,
|
|
buffer_range.clone(),
|
|
MemoryInitKind::NeedsInitializedMemory,
|
|
),
|
|
);
|
|
|
|
state
|
|
.vertex
|
|
.set_buffer(slot as usize, buffer, buffer_range.clone());
|
|
if let Some(pipeline) = state.pipeline.as_ref() {
|
|
state.vertex.update_limits(&pipeline.vertex_steps);
|
|
}
|
|
} else {
|
|
if offset != 0 {
|
|
return Err(RenderCommandError::from(
|
|
crate::binding_model::BindingError::UnbindingVertexBufferOffsetNotZero {
|
|
slot,
|
|
offset,
|
|
},
|
|
)
|
|
.into());
|
|
}
|
|
if let Some(size) = size {
|
|
return Err(RenderCommandError::from(
|
|
crate::binding_model::BindingError::UnbindingVertexBufferSizeNotZero {
|
|
slot,
|
|
size: size.get(),
|
|
},
|
|
)
|
|
.into());
|
|
}
|
|
|
|
state.vertex.clear_buffer(slot as usize);
|
|
if let Some(pipeline) = state.pipeline.as_ref() {
|
|
state.vertex.update_limits(&pipeline.vertex_steps);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn set_blend_constant(state: &mut State, color: &Color) {
|
|
api_log!("RenderPass::set_blend_constant");
|
|
|
|
state.blend_constant = OptionalState::Set;
|
|
let array = [
|
|
color.r as f32,
|
|
color.g as f32,
|
|
color.b as f32,
|
|
color.a as f32,
|
|
];
|
|
unsafe {
|
|
state.pass.base.raw_encoder.set_blend_constants(&array);
|
|
}
|
|
}
|
|
|
|
fn set_stencil_reference(state: &mut State, value: u32) {
|
|
api_log!("RenderPass::set_stencil_reference {value}");
|
|
|
|
state.stencil_reference = value;
|
|
if state
|
|
.pipeline_flags
|
|
.contains(PipelineFlags::STENCIL_REFERENCE)
|
|
{
|
|
unsafe {
|
|
state.pass.base.raw_encoder.set_stencil_reference(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn set_viewport(
|
|
state: &mut State,
|
|
rect: Rect<f32>,
|
|
depth_min: f32,
|
|
depth_max: f32,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
api_log!("RenderPass::set_viewport {rect:?}");
|
|
|
|
if rect.w < 0.0
|
|
|| rect.h < 0.0
|
|
|| rect.w > state.pass.base.device.limits.max_texture_dimension_2d as f32
|
|
|| rect.h > state.pass.base.device.limits.max_texture_dimension_2d as f32
|
|
{
|
|
return Err(RenderCommandError::InvalidViewportRectSize {
|
|
w: rect.w,
|
|
h: rect.h,
|
|
max: state.pass.base.device.limits.max_texture_dimension_2d,
|
|
}
|
|
.into());
|
|
}
|
|
|
|
let max_viewport_range = state.pass.base.device.limits.max_texture_dimension_2d as f32 * 2.0;
|
|
|
|
if rect.x < -max_viewport_range
|
|
|| rect.y < -max_viewport_range
|
|
|| rect.x + rect.w > max_viewport_range - 1.0
|
|
|| rect.y + rect.h > max_viewport_range - 1.0
|
|
{
|
|
return Err(RenderCommandError::InvalidViewportRectPosition {
|
|
rect,
|
|
min: -max_viewport_range,
|
|
max: max_viewport_range - 1.0,
|
|
}
|
|
.into());
|
|
}
|
|
if !(0.0..=1.0).contains(&depth_min)
|
|
|| !(0.0..=1.0).contains(&depth_max)
|
|
|| depth_min > depth_max
|
|
{
|
|
return Err(RenderCommandError::InvalidViewportDepth(depth_min, depth_max).into());
|
|
}
|
|
let r = hal::Rect {
|
|
x: rect.x,
|
|
y: rect.y,
|
|
w: rect.w,
|
|
h: rect.h,
|
|
};
|
|
unsafe {
|
|
state
|
|
.pass
|
|
.base
|
|
.raw_encoder
|
|
.set_viewport(&r, depth_min..depth_max);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn set_scissor(state: &mut State, rect: Rect<u32>) -> Result<(), RenderPassErrorInner> {
|
|
api_log!("RenderPass::set_scissor_rect {rect:?}");
|
|
|
|
if rect.x.saturating_add(rect.w) > state.info.extent.width
|
|
|| rect.y.saturating_add(rect.h) > state.info.extent.height
|
|
{
|
|
return Err(RenderCommandError::InvalidScissorRect(rect, state.info.extent).into());
|
|
}
|
|
let r = hal::Rect {
|
|
x: rect.x,
|
|
y: rect.y,
|
|
w: rect.w,
|
|
h: rect.h,
|
|
};
|
|
unsafe {
|
|
state.pass.base.raw_encoder.set_scissor_rect(&r);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn validate_mesh_draw_multiview(state: &State) -> Result<(), RenderPassErrorInner> {
|
|
if let Some(mv) = state.info.multiview_mask {
|
|
let highest_bit = 31 - mv.leading_zeros();
|
|
|
|
let features = state.pass.base.device.features;
|
|
|
|
if !features.contains(wgt::Features::EXPERIMENTAL_MESH_SHADER_MULTIVIEW)
|
|
|| highest_bit > state.pass.base.device.limits.max_mesh_multiview_view_count
|
|
{
|
|
return Err(RenderPassErrorInner::Draw(
|
|
DrawError::MeshPipelineMultiviewLimitsViolated {
|
|
highest_view_index: highest_bit,
|
|
max_multiviews: state.pass.base.device.limits.max_mesh_multiview_view_count,
|
|
},
|
|
));
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn draw(
|
|
state: &mut State,
|
|
vertex_count: u32,
|
|
instance_count: u32,
|
|
first_vertex: u32,
|
|
first_instance: u32,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
api_log!("RenderPass::draw {vertex_count} {instance_count} {first_vertex} {first_instance}");
|
|
|
|
state.is_ready(DrawCommandFamily::Draw)?;
|
|
state.flush_vertex_buffers()?;
|
|
state.flush_bindings()?;
|
|
state.flush_immediates();
|
|
|
|
state
|
|
.vertex
|
|
.limits
|
|
.validate_vertex_limit(first_vertex, vertex_count)?;
|
|
state
|
|
.vertex
|
|
.limits
|
|
.validate_instance_limit(first_instance, instance_count)?;
|
|
|
|
unsafe {
|
|
if instance_count > 0 && vertex_count > 0 {
|
|
state.pass.base.raw_encoder.draw(
|
|
first_vertex,
|
|
vertex_count,
|
|
first_instance,
|
|
instance_count,
|
|
);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn draw_indexed(
|
|
state: &mut State,
|
|
index_count: u32,
|
|
instance_count: u32,
|
|
first_index: u32,
|
|
base_vertex: i32,
|
|
first_instance: u32,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
api_log!("RenderPass::draw_indexed {index_count} {instance_count} {first_index} {base_vertex} {first_instance}");
|
|
|
|
state.is_ready(DrawCommandFamily::DrawIndexed)?;
|
|
state.flush_vertex_buffers()?;
|
|
state.flush_bindings()?;
|
|
state.flush_immediates();
|
|
|
|
let last_index = first_index as u64 + index_count as u64;
|
|
let index_limit = state.index.limit;
|
|
if last_index > index_limit {
|
|
return Err(DrawError::IndexBeyondLimit {
|
|
last_index,
|
|
index_limit,
|
|
}
|
|
.into());
|
|
}
|
|
state
|
|
.vertex
|
|
.limits
|
|
.validate_instance_limit(first_instance, instance_count)?;
|
|
|
|
unsafe {
|
|
if instance_count > 0 && index_count > 0 {
|
|
state.pass.base.raw_encoder.draw_indexed(
|
|
first_index,
|
|
index_count,
|
|
base_vertex,
|
|
first_instance,
|
|
instance_count,
|
|
);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn draw_mesh_tasks(
|
|
state: &mut State,
|
|
group_count_x: u32,
|
|
group_count_y: u32,
|
|
group_count_z: u32,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
api_log!("RenderPass::draw_mesh_tasks {group_count_x} {group_count_y} {group_count_z}");
|
|
|
|
state.is_ready(DrawCommandFamily::DrawMeshTasks)?;
|
|
|
|
state.flush_bindings()?;
|
|
state.flush_immediates();
|
|
validate_mesh_draw_multiview(state)?;
|
|
|
|
let limits = &state.pass.base.device.limits;
|
|
let (groups_size_limit, max_groups) = if state.pipeline.as_ref().unwrap().has_task_shader {
|
|
(
|
|
limits.max_task_workgroups_per_dimension,
|
|
limits.max_task_workgroup_total_count,
|
|
)
|
|
} else {
|
|
(
|
|
limits.max_mesh_workgroups_per_dimension,
|
|
limits.max_mesh_workgroup_total_count,
|
|
)
|
|
};
|
|
|
|
let total_count = WorkgroupSizeCheck {
|
|
dimensions: &[group_count_x, group_count_y, group_count_z],
|
|
per_dimension_limits: &[groups_size_limit, groups_size_limit, groups_size_limit],
|
|
per_dimension_limits_desc: "max_task_mesh_workgroups_per_dimension",
|
|
|
|
total_limit: max_groups,
|
|
total_limit_desc: "max_task_mesh_workgroup_total_count",
|
|
}
|
|
.check_and_compute_total_invocations()
|
|
.map_err(|err| RenderPassErrorInner::Draw(err.into()))?;
|
|
|
|
unsafe {
|
|
if total_count > 0 {
|
|
state.pass.base.raw_encoder.draw_mesh_tasks(
|
|
group_count_x,
|
|
group_count_y,
|
|
group_count_z,
|
|
);
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn multi_draw_indirect(
|
|
state: &mut State,
|
|
indirect_draw_validation_batcher: &mut crate::indirect_validation::DrawBatcher,
|
|
device: &Arc<Device>,
|
|
indirect_buffer: Arc<Buffer>,
|
|
offset: u64,
|
|
count: u32,
|
|
family: DrawCommandFamily,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
api_log!(
|
|
"RenderPass::draw_indirect (family:{family:?}) {} {offset} {count:?}",
|
|
indirect_buffer.error_ident()
|
|
);
|
|
|
|
state.is_ready(family)?;
|
|
state.flush_vertex_buffers()?;
|
|
state.flush_bindings()?;
|
|
state.flush_immediates();
|
|
|
|
if family == DrawCommandFamily::DrawMeshTasks {
|
|
validate_mesh_draw_multiview(state)?;
|
|
}
|
|
|
|
state
|
|
.pass
|
|
.base
|
|
.device
|
|
.require_downlevel_flags(wgt::DownlevelFlags::INDIRECT_EXECUTION)?;
|
|
|
|
indirect_buffer.same_device(device)?;
|
|
indirect_buffer.check_usage(BufferUsages::INDIRECT)?;
|
|
indirect_buffer.check_destroyed(state.pass.base.snatch_guard)?;
|
|
|
|
if !offset.is_multiple_of(4) {
|
|
return Err(RenderCommandError::UnalignedIndirectBufferOffset(offset).into());
|
|
}
|
|
|
|
let stride = get_src_stride_of_indirect_args(family);
|
|
let args_size = match stride.checked_mul(u64::from(count)) {
|
|
Some(sz) if sz <= indirect_buffer.size && indirect_buffer.size - sz >= offset => sz,
|
|
args_size => {
|
|
return Err(RenderCommandError::IndirectBufferOverrun {
|
|
count,
|
|
offset,
|
|
args_size: args_size.unwrap_or(u64::MAX),
|
|
buffer_size: indirect_buffer.size,
|
|
}
|
|
.into());
|
|
}
|
|
};
|
|
|
|
state.pass.base.buffer_memory_init_actions.extend(
|
|
indirect_buffer.initialization_status.read().create_action(
|
|
&indirect_buffer,
|
|
offset..offset + args_size,
|
|
MemoryInitKind::NeedsInitializedMemory,
|
|
),
|
|
);
|
|
|
|
fn draw(
|
|
raw_encoder: &mut dyn hal::DynCommandEncoder,
|
|
family: DrawCommandFamily,
|
|
indirect_buffer: &dyn hal::DynBuffer,
|
|
offset: u64,
|
|
count: u32,
|
|
) {
|
|
match family {
|
|
DrawCommandFamily::Draw => unsafe {
|
|
raw_encoder.draw_indirect(indirect_buffer, offset, count);
|
|
},
|
|
DrawCommandFamily::DrawIndexed => unsafe {
|
|
raw_encoder.draw_indexed_indirect(indirect_buffer, offset, count);
|
|
},
|
|
DrawCommandFamily::DrawMeshTasks => unsafe {
|
|
raw_encoder.draw_mesh_tasks_indirect(indirect_buffer, offset, count);
|
|
},
|
|
}
|
|
}
|
|
|
|
if state.pass.base.device.indirect_validation.is_some()
|
|
&& family != DrawCommandFamily::DrawMeshTasks
|
|
{
|
|
state
|
|
.pass
|
|
.scope
|
|
.buffers
|
|
.merge_single(&indirect_buffer, wgt::BufferUses::STORAGE_READ_ONLY)?;
|
|
|
|
struct DrawData {
|
|
buffer_index: usize,
|
|
offset: u64,
|
|
count: u32,
|
|
}
|
|
|
|
struct DrawContext<'a> {
|
|
raw_encoder: &'a mut dyn hal::DynCommandEncoder,
|
|
device: &'a Device,
|
|
|
|
indirect_draw_validation_resources: &'a mut crate::indirect_validation::DrawResources,
|
|
indirect_draw_validation_batcher: &'a mut crate::indirect_validation::DrawBatcher,
|
|
|
|
indirect_buffer: Arc<Buffer>,
|
|
family: DrawCommandFamily,
|
|
vertex_or_index_limit: u64,
|
|
instance_limit: u64,
|
|
}
|
|
|
|
impl<'a> DrawContext<'a> {
|
|
fn add(&mut self, offset: u64) -> Result<DrawData, DeviceError> {
|
|
let (dst_resource_index, dst_offset) = self.indirect_draw_validation_batcher.add(
|
|
self.indirect_draw_validation_resources,
|
|
self.device,
|
|
&self.indirect_buffer,
|
|
offset,
|
|
self.family,
|
|
self.vertex_or_index_limit,
|
|
self.instance_limit,
|
|
)?;
|
|
Ok(DrawData {
|
|
buffer_index: dst_resource_index,
|
|
offset: dst_offset,
|
|
count: 1,
|
|
})
|
|
}
|
|
fn draw(&mut self, draw_data: DrawData) {
|
|
let dst_buffer = self
|
|
.indirect_draw_validation_resources
|
|
.get_dst_buffer(draw_data.buffer_index);
|
|
draw(
|
|
self.raw_encoder,
|
|
self.family,
|
|
dst_buffer,
|
|
draw_data.offset,
|
|
draw_data.count,
|
|
);
|
|
}
|
|
}
|
|
|
|
let mut draw_ctx = DrawContext {
|
|
raw_encoder: state.pass.base.raw_encoder,
|
|
device: state.pass.base.device,
|
|
indirect_draw_validation_resources: state.pass.base.indirect_draw_validation_resources,
|
|
indirect_draw_validation_batcher,
|
|
indirect_buffer,
|
|
family,
|
|
vertex_or_index_limit: if family == DrawCommandFamily::DrawIndexed {
|
|
state.index.limit
|
|
} else {
|
|
state.vertex.limits.vertex_limit
|
|
},
|
|
instance_limit: state.vertex.limits.instance_limit,
|
|
};
|
|
|
|
let mut current_draw_data = draw_ctx.add(offset)?;
|
|
|
|
for i in 1..count {
|
|
let draw_data = draw_ctx.add(offset + stride * i as u64)?;
|
|
|
|
if draw_data.buffer_index == current_draw_data.buffer_index {
|
|
#[cfg(debug_assertions)]
|
|
{
|
|
let dst_stride =
|
|
get_dst_stride_of_indirect_args(state.pass.base.device.backend(), family);
|
|
debug_assert_eq!(
|
|
draw_data.offset,
|
|
current_draw_data.offset + dst_stride * current_draw_data.count as u64
|
|
);
|
|
}
|
|
current_draw_data.count += 1;
|
|
} else {
|
|
draw_ctx.draw(current_draw_data);
|
|
current_draw_data = draw_data;
|
|
}
|
|
}
|
|
|
|
draw_ctx.draw(current_draw_data);
|
|
} else {
|
|
state
|
|
.pass
|
|
.scope
|
|
.buffers
|
|
.merge_single(&indirect_buffer, wgt::BufferUses::INDIRECT)?;
|
|
|
|
draw(
|
|
state.pass.base.raw_encoder,
|
|
family,
|
|
indirect_buffer.try_raw(state.pass.base.snatch_guard)?,
|
|
offset,
|
|
count,
|
|
);
|
|
};
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn multi_draw_indirect_count(
|
|
state: &mut State,
|
|
device: &Arc<Device>,
|
|
indirect_buffer: Arc<Buffer>,
|
|
offset: u64,
|
|
count_buffer: Arc<Buffer>,
|
|
count_buffer_offset: u64,
|
|
max_count: u32,
|
|
family: DrawCommandFamily,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
api_log!(
|
|
"RenderPass::multi_draw_indirect_count (family:{family:?}) {} {offset} {} {count_buffer_offset:?} {max_count:?}",
|
|
indirect_buffer.error_ident(),
|
|
count_buffer.error_ident()
|
|
);
|
|
|
|
state.is_ready(family)?;
|
|
state.flush_vertex_buffers()?;
|
|
state.flush_bindings()?;
|
|
state.flush_immediates();
|
|
|
|
if family == DrawCommandFamily::DrawMeshTasks {
|
|
validate_mesh_draw_multiview(state)?;
|
|
}
|
|
|
|
let stride = get_src_stride_of_indirect_args(family);
|
|
|
|
state
|
|
.pass
|
|
.base
|
|
.device
|
|
.require_features(wgt::Features::MULTI_DRAW_INDIRECT_COUNT)?;
|
|
state
|
|
.pass
|
|
.base
|
|
.device
|
|
.require_downlevel_flags(wgt::DownlevelFlags::INDIRECT_EXECUTION)?;
|
|
|
|
indirect_buffer.same_device(device)?;
|
|
count_buffer.same_device(device)?;
|
|
|
|
state
|
|
.pass
|
|
.scope
|
|
.buffers
|
|
.merge_single(&indirect_buffer, wgt::BufferUses::INDIRECT)?;
|
|
|
|
indirect_buffer.check_usage(BufferUsages::INDIRECT)?;
|
|
let indirect_raw = indirect_buffer.try_raw(state.pass.base.snatch_guard)?;
|
|
|
|
state
|
|
.pass
|
|
.scope
|
|
.buffers
|
|
.merge_single(&count_buffer, wgt::BufferUses::INDIRECT)?;
|
|
|
|
count_buffer.check_usage(BufferUsages::INDIRECT)?;
|
|
let count_raw = count_buffer.try_raw(state.pass.base.snatch_guard)?;
|
|
|
|
if !offset.is_multiple_of(4) {
|
|
return Err(RenderCommandError::UnalignedIndirectBufferOffset(offset).into());
|
|
}
|
|
|
|
let args_size = match stride.checked_mul(u64::from(max_count)) {
|
|
Some(sz) if sz <= indirect_buffer.size && indirect_buffer.size - sz >= offset => sz,
|
|
args_size => {
|
|
return Err(RenderCommandError::IndirectBufferOverrun {
|
|
count: 1,
|
|
offset,
|
|
args_size: args_size.unwrap_or(u64::MAX),
|
|
buffer_size: indirect_buffer.size,
|
|
}
|
|
.into());
|
|
}
|
|
};
|
|
|
|
state.pass.base.buffer_memory_init_actions.extend(
|
|
indirect_buffer.initialization_status.read().create_action(
|
|
&indirect_buffer,
|
|
offset..offset + args_size,
|
|
MemoryInitKind::NeedsInitializedMemory,
|
|
),
|
|
);
|
|
|
|
let begin_count_offset = count_buffer_offset;
|
|
let count_bytes = 4;
|
|
if count_buffer.size < count_bytes || count_buffer.size - count_bytes < count_buffer_offset {
|
|
return Err(RenderPassErrorInner::IndirectCountBufferOverrun {
|
|
begin_count_offset,
|
|
count_bytes: 4,
|
|
count_buffer_size: count_buffer.size,
|
|
});
|
|
}
|
|
state.pass.base.buffer_memory_init_actions.extend(
|
|
count_buffer.initialization_status.read().create_action(
|
|
&count_buffer,
|
|
count_buffer_offset..count_buffer_offset + count_bytes,
|
|
MemoryInitKind::NeedsInitializedMemory,
|
|
),
|
|
);
|
|
|
|
match family {
|
|
DrawCommandFamily::Draw => unsafe {
|
|
state.pass.base.raw_encoder.draw_indirect_count(
|
|
indirect_raw,
|
|
offset,
|
|
count_raw,
|
|
count_buffer_offset,
|
|
max_count,
|
|
);
|
|
},
|
|
DrawCommandFamily::DrawIndexed => unsafe {
|
|
state.pass.base.raw_encoder.draw_indexed_indirect_count(
|
|
indirect_raw,
|
|
offset,
|
|
count_raw,
|
|
count_buffer_offset,
|
|
max_count,
|
|
);
|
|
},
|
|
DrawCommandFamily::DrawMeshTasks => unsafe {
|
|
state.pass.base.raw_encoder.draw_mesh_tasks_indirect_count(
|
|
indirect_raw,
|
|
offset,
|
|
count_raw,
|
|
count_buffer_offset,
|
|
max_count,
|
|
);
|
|
},
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn execute_bundle(
|
|
state: &mut State,
|
|
indirect_draw_validation_batcher: &mut crate::indirect_validation::DrawBatcher,
|
|
device: &Arc<Device>,
|
|
bundle: Arc<RenderBundle>,
|
|
) -> Result<(), RenderPassErrorInner> {
|
|
api_log!("RenderPass::execute_bundle {}", bundle.error_ident());
|
|
|
|
let bundle = state.pass.base.tracker.bundles.insert_single(bundle);
|
|
|
|
let bundle_state = bundle.state()?;
|
|
bundle.same_device(device)?;
|
|
|
|
state
|
|
.info
|
|
.context
|
|
.check_compatible(&bundle_state.context, bundle.as_ref())
|
|
.map_err(RenderPassErrorInner::IncompatibleBundleTargets)?;
|
|
|
|
if (state.info.is_depth_read_only && !bundle.is_depth_read_only)
|
|
|| (state.info.is_stencil_read_only && !bundle.is_stencil_read_only)
|
|
{
|
|
return Err(
|
|
RenderPassErrorInner::IncompatibleBundleReadOnlyDepthStencil {
|
|
pass_depth: state.info.is_depth_read_only,
|
|
pass_stencil: state.info.is_stencil_read_only,
|
|
bundle_depth: bundle.is_depth_read_only,
|
|
bundle_stencil: bundle.is_stencil_read_only,
|
|
},
|
|
);
|
|
}
|
|
|
|
state.pass.base.buffer_memory_init_actions.extend(
|
|
bundle
|
|
.buffer_memory_init_actions
|
|
.iter()
|
|
.filter_map(|action| {
|
|
action
|
|
.buffer
|
|
.initialization_status
|
|
.read()
|
|
.check_action(action)
|
|
}),
|
|
);
|
|
for action in bundle.texture_memory_init_actions.iter() {
|
|
state.pass.pending_discard_init_fixups.extend(
|
|
state
|
|
.pass
|
|
.base
|
|
.texture_memory_actions
|
|
.register_init_action(action),
|
|
);
|
|
}
|
|
|
|
unsafe {
|
|
bundle.execute(
|
|
state.pass.base.raw_encoder,
|
|
state.pass.base.indirect_draw_validation_resources,
|
|
indirect_draw_validation_batcher,
|
|
state.pass.base.snatch_guard,
|
|
)
|
|
}
|
|
.map_err(|e| match e {
|
|
ExecutionError::Device(e) => RenderPassErrorInner::Device(e),
|
|
ExecutionError::DestroyedResource(e) => {
|
|
RenderPassErrorInner::RenderCommand(RenderCommandError::DestroyedResource(e))
|
|
}
|
|
ExecutionError::InvalidResource(e) => {
|
|
RenderPassErrorInner::RenderCommand(RenderCommandError::InvalidResource(e))
|
|
}
|
|
ExecutionError::Unimplemented(what) => {
|
|
RenderPassErrorInner::RenderCommand(RenderCommandError::Unimplemented(what))
|
|
}
|
|
})?;
|
|
|
|
unsafe {
|
|
state.pass.scope.merge_render_bundle(&bundle_state.used)?;
|
|
};
|
|
state.reset_bundle();
|
|
Ok(())
|
|
}
|
|
|
|
// Recording a render pass.
|
|
//
|
|
// The only error that should be returned from these methods is
|
|
// `EncoderStateError::Ended`, when the pass has already ended and an immediate
|
|
// validation error is raised.
|
|
//
|
|
// All other errors should be stored in the pass for later reporting when
|
|
// `CommandEncoder.finish()` is called.
|
|
//
|
|
// The `pass_try!` macro should be used to handle errors appropriately. Note
|
|
// that the `pass_try!` and `pass_base!` macros may return early from the
|
|
// function that invokes them, like the `?` operator.
|
|
impl RenderPass {
|
|
pub fn set_bind_group(
|
|
&mut self,
|
|
index: u32,
|
|
bind_group: Option<Arc<BindGroup>>,
|
|
offsets: &[DynamicOffset],
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::SetBindGroup;
|
|
|
|
// This statement will return an error if the pass is ended. It's
|
|
// important the error check comes before the early-out for
|
|
// `set_and_check_redundant`.
|
|
let base = pass_base!(self, scope);
|
|
|
|
if self.current_bind_groups.set_and_check_redundant(
|
|
&bind_group,
|
|
index,
|
|
&mut base.dynamic_offsets,
|
|
offsets,
|
|
) {
|
|
return Ok(());
|
|
}
|
|
|
|
let bind_group = if let Some(bind_group) = bind_group {
|
|
pass_try!(base, scope, bind_group.check_is_valid());
|
|
Some(bind_group)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
base.commands.push(ArcRenderCommand::SetBindGroup {
|
|
index,
|
|
num_dynamic_offsets: offsets.len(),
|
|
bind_group,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn set_pipeline(&mut self, pipeline: Arc<RenderPipeline>) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::SetPipelineRender;
|
|
|
|
let redundant = self.current_pipeline.set_and_check_redundant(&pipeline);
|
|
|
|
// This statement will return an error if the pass is ended.
|
|
// Its important the error check comes before the early-out for `redundant`.
|
|
let base = pass_base!(self, scope);
|
|
|
|
if redundant {
|
|
return Ok(());
|
|
}
|
|
|
|
pass_try!(base, scope, pipeline.check_valid());
|
|
|
|
base.commands.push(ArcRenderCommand::SetPipeline(pipeline));
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn set_index_buffer(
|
|
&mut self,
|
|
buffer: Arc<Buffer>,
|
|
index_format: IndexFormat,
|
|
offset: BufferAddress,
|
|
size: Option<BufferSize>,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::SetIndexBuffer;
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
|
|
base.commands.push(ArcRenderCommand::SetIndexBuffer {
|
|
buffer,
|
|
index_format,
|
|
offset,
|
|
size,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn set_vertex_buffer(
|
|
&mut self,
|
|
slot: u32,
|
|
buffer: Option<Arc<Buffer>>,
|
|
offset: BufferAddress,
|
|
size: Option<BufferSize>,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::SetVertexBuffer;
|
|
let base = pass_base!(self, scope);
|
|
|
|
let buffer = if let Some(buffer) = buffer {
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
Some(buffer)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
base.commands.push(ArcRenderCommand::SetVertexBuffer {
|
|
slot,
|
|
buffer,
|
|
offset,
|
|
size,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn set_blend_constant(&mut self, color: Color) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::SetBlendConstant;
|
|
let base = pass_base!(self, scope);
|
|
|
|
base.commands
|
|
.push(ArcRenderCommand::SetBlendConstant(color));
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn set_stencil_reference(&mut self, value: u32) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::SetStencilReference;
|
|
let base = pass_base!(self, scope);
|
|
let value = convert_stencil_value(
|
|
value,
|
|
self.depth_stencil_attachment
|
|
.as_ref()
|
|
.map(|at| at.view.desc.format),
|
|
);
|
|
base.commands
|
|
.push(ArcRenderCommand::SetStencilReference(value));
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn set_viewport(
|
|
&mut self,
|
|
x: f32,
|
|
y: f32,
|
|
w: f32,
|
|
h: f32,
|
|
depth_min: f32,
|
|
depth_max: f32,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::SetViewport;
|
|
let base = pass_base!(self, scope);
|
|
|
|
base.commands.push(ArcRenderCommand::SetViewport {
|
|
rect: Rect { x, y, w, h },
|
|
depth_min,
|
|
depth_max,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn set_scissor_rect(
|
|
&mut self,
|
|
x: u32,
|
|
y: u32,
|
|
w: u32,
|
|
h: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::SetScissorRect;
|
|
let base = pass_base!(self, scope);
|
|
|
|
base.commands
|
|
.push(ArcRenderCommand::SetScissor(Rect { x, y, w, h }));
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn set_immediates(&mut self, offset: u32, data: &[u8]) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::SetImmediate;
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(
|
|
base,
|
|
scope,
|
|
pass::validate_immediates_alignment(offset, data.len())
|
|
);
|
|
|
|
base.commands.push(ArcRenderCommand::SetImmediate {
|
|
offset,
|
|
data: data
|
|
.chunks_exact(size_of::<u32>())
|
|
.map(|ck| u32::from_le_bytes(ck.try_into().unwrap()))
|
|
.collect(),
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn draw(
|
|
&mut self,
|
|
vertex_count: u32,
|
|
instance_count: u32,
|
|
first_vertex: u32,
|
|
first_instance: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::Draw,
|
|
family: DrawCommandFamily::Draw,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
base.commands.push(ArcRenderCommand::Draw {
|
|
vertex_count,
|
|
instance_count,
|
|
first_vertex,
|
|
first_instance,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn draw_indexed(
|
|
&mut self,
|
|
index_count: u32,
|
|
instance_count: u32,
|
|
first_index: u32,
|
|
base_vertex: i32,
|
|
first_instance: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::Draw,
|
|
family: DrawCommandFamily::DrawIndexed,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
base.commands.push(ArcRenderCommand::DrawIndexed {
|
|
index_count,
|
|
instance_count,
|
|
first_index,
|
|
base_vertex,
|
|
first_instance,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn draw_mesh_tasks(
|
|
&mut self,
|
|
group_count_x: u32,
|
|
group_count_y: u32,
|
|
group_count_z: u32,
|
|
) -> Result<(), RenderPassError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::Draw,
|
|
family: DrawCommandFamily::DrawMeshTasks,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
base.commands.push(ArcRenderCommand::DrawMeshTasks {
|
|
group_count_x,
|
|
group_count_y,
|
|
group_count_z,
|
|
});
|
|
Ok(())
|
|
}
|
|
|
|
pub fn draw_indirect(
|
|
&mut self,
|
|
buffer: Arc<Buffer>,
|
|
offset: BufferAddress,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::DrawIndirect,
|
|
family: DrawCommandFamily::Draw,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
|
|
base.commands.push(ArcRenderCommand::DrawIndirect {
|
|
buffer,
|
|
offset,
|
|
count: 1,
|
|
family: DrawCommandFamily::Draw,
|
|
|
|
vertex_or_index_limit: None,
|
|
instance_limit: None,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn draw_indexed_indirect(
|
|
&mut self,
|
|
buffer: Arc<Buffer>,
|
|
offset: BufferAddress,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::DrawIndirect,
|
|
family: DrawCommandFamily::DrawIndexed,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
|
|
base.commands.push(ArcRenderCommand::DrawIndirect {
|
|
buffer,
|
|
offset,
|
|
count: 1,
|
|
family: DrawCommandFamily::DrawIndexed,
|
|
|
|
vertex_or_index_limit: None,
|
|
instance_limit: None,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn draw_mesh_tasks_indirect(
|
|
&mut self,
|
|
buffer: Arc<Buffer>,
|
|
offset: BufferAddress,
|
|
) -> Result<(), RenderPassError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::DrawIndirect,
|
|
family: DrawCommandFamily::DrawMeshTasks,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
|
|
base.commands.push(ArcRenderCommand::DrawIndirect {
|
|
buffer,
|
|
offset,
|
|
count: 1,
|
|
family: DrawCommandFamily::DrawMeshTasks,
|
|
|
|
vertex_or_index_limit: None,
|
|
instance_limit: None,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn multi_draw_indirect(
|
|
&mut self,
|
|
buffer: Arc<Buffer>,
|
|
offset: BufferAddress,
|
|
count: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::MultiDrawIndirect,
|
|
family: DrawCommandFamily::Draw,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
|
|
base.commands.push(ArcRenderCommand::DrawIndirect {
|
|
buffer,
|
|
offset,
|
|
count,
|
|
family: DrawCommandFamily::Draw,
|
|
|
|
vertex_or_index_limit: None,
|
|
instance_limit: None,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn multi_draw_indexed_indirect(
|
|
&mut self,
|
|
buffer: Arc<Buffer>,
|
|
offset: BufferAddress,
|
|
count: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::MultiDrawIndirect,
|
|
family: DrawCommandFamily::DrawIndexed,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
|
|
base.commands.push(ArcRenderCommand::DrawIndirect {
|
|
buffer,
|
|
offset,
|
|
count,
|
|
family: DrawCommandFamily::DrawIndexed,
|
|
|
|
vertex_or_index_limit: None,
|
|
instance_limit: None,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn multi_draw_mesh_tasks_indirect(
|
|
&mut self,
|
|
buffer: Arc<Buffer>,
|
|
offset: BufferAddress,
|
|
count: u32,
|
|
) -> Result<(), RenderPassError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::MultiDrawIndirect,
|
|
family: DrawCommandFamily::DrawMeshTasks,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
|
|
base.commands.push(ArcRenderCommand::DrawIndirect {
|
|
buffer,
|
|
offset,
|
|
count,
|
|
family: DrawCommandFamily::DrawMeshTasks,
|
|
|
|
vertex_or_index_limit: None,
|
|
instance_limit: None,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn multi_draw_indirect_count(
|
|
&mut self,
|
|
buffer: Arc<Buffer>,
|
|
offset: BufferAddress,
|
|
count_buffer: Arc<Buffer>,
|
|
count_buffer_offset: BufferAddress,
|
|
max_count: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::MultiDrawIndirectCount,
|
|
family: DrawCommandFamily::Draw,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
pass_try!(base, scope, count_buffer.check_is_valid());
|
|
|
|
base.commands
|
|
.push(ArcRenderCommand::MultiDrawIndirectCount {
|
|
buffer,
|
|
offset,
|
|
count_buffer,
|
|
count_buffer_offset,
|
|
max_count,
|
|
family: DrawCommandFamily::Draw,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn multi_draw_indexed_indirect_count(
|
|
&mut self,
|
|
buffer: Arc<Buffer>,
|
|
offset: BufferAddress,
|
|
count_buffer: Arc<Buffer>,
|
|
count_buffer_offset: BufferAddress,
|
|
max_count: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::MultiDrawIndirectCount,
|
|
family: DrawCommandFamily::DrawIndexed,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
pass_try!(base, scope, count_buffer.check_is_valid());
|
|
|
|
base.commands
|
|
.push(ArcRenderCommand::MultiDrawIndirectCount {
|
|
buffer,
|
|
offset,
|
|
count_buffer,
|
|
count_buffer_offset,
|
|
max_count,
|
|
family: DrawCommandFamily::DrawIndexed,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn multi_draw_mesh_tasks_indirect_count(
|
|
&mut self,
|
|
buffer: Arc<Buffer>,
|
|
offset: BufferAddress,
|
|
count_buffer: Arc<Buffer>,
|
|
count_buffer_offset: BufferAddress,
|
|
max_count: u32,
|
|
) -> Result<(), RenderPassError> {
|
|
let scope = PassErrorScope::Draw {
|
|
kind: DrawKind::MultiDrawIndirectCount,
|
|
family: DrawCommandFamily::DrawMeshTasks,
|
|
};
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, buffer.check_is_valid());
|
|
pass_try!(base, scope, count_buffer.check_is_valid());
|
|
|
|
base.commands
|
|
.push(ArcRenderCommand::MultiDrawIndirectCount {
|
|
buffer,
|
|
offset,
|
|
count_buffer,
|
|
count_buffer_offset,
|
|
max_count,
|
|
family: DrawCommandFamily::DrawMeshTasks,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn push_debug_group(&mut self, label: &str, color: u32) -> Result<(), PassStateError> {
|
|
let base = pass_base!(self, PassErrorScope::PushDebugGroup);
|
|
|
|
let bytes = label.as_bytes();
|
|
base.string_data.extend_from_slice(bytes);
|
|
|
|
base.commands.push(ArcRenderCommand::PushDebugGroup {
|
|
color,
|
|
len: bytes.len(),
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn pop_debug_group(&mut self) -> Result<(), PassStateError> {
|
|
let base = pass_base!(self, PassErrorScope::PopDebugGroup);
|
|
|
|
base.commands.push(ArcRenderCommand::PopDebugGroup);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn insert_debug_marker(&mut self, label: &str, color: u32) -> Result<(), PassStateError> {
|
|
let base = pass_base!(self, PassErrorScope::InsertDebugMarker);
|
|
|
|
let bytes = label.as_bytes();
|
|
base.string_data.extend_from_slice(bytes);
|
|
|
|
base.commands.push(ArcRenderCommand::InsertDebugMarker {
|
|
color,
|
|
len: bytes.len(),
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn write_timestamp(
|
|
&mut self,
|
|
query_set: Arc<QuerySet>,
|
|
query_index: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::WriteTimestamp;
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, query_set.check_is_valid());
|
|
base.commands.push(ArcRenderCommand::WriteTimestamp {
|
|
query_set,
|
|
query_index,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn begin_occlusion_query(&mut self, query_index: u32) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::BeginOcclusionQuery;
|
|
let base = pass_base!(self, scope);
|
|
|
|
base.commands
|
|
.push(ArcRenderCommand::BeginOcclusionQuery { query_index });
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn end_occlusion_query(&mut self) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::EndOcclusionQuery;
|
|
let base = pass_base!(self, scope);
|
|
|
|
base.commands.push(ArcRenderCommand::EndOcclusionQuery);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn begin_pipeline_statistics_query(
|
|
&mut self,
|
|
query_set: Arc<QuerySet>,
|
|
query_index: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::BeginPipelineStatisticsQuery;
|
|
let base = pass_base!(self, scope);
|
|
|
|
pass_try!(base, scope, query_set.check_is_valid());
|
|
base.commands
|
|
.push(ArcRenderCommand::BeginPipelineStatisticsQuery {
|
|
query_set,
|
|
query_index,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn end_pipeline_statistics_query(&mut self) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::EndPipelineStatisticsQuery;
|
|
let base = pass_base!(self, scope);
|
|
|
|
base.commands
|
|
.push(ArcRenderCommand::EndPipelineStatisticsQuery);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn execute_bundles(
|
|
&mut self,
|
|
render_bundles: &[Arc<RenderBundle>],
|
|
) -> Result<(), PassStateError> {
|
|
let scope = PassErrorScope::ExecuteBundle;
|
|
let base = pass_base!(self, scope);
|
|
|
|
for bundle in render_bundles {
|
|
pass_try!(base, scope, bundle.check_is_valid());
|
|
|
|
base.commands
|
|
.push(ArcRenderCommand::ExecuteBundle(bundle.clone()));
|
|
}
|
|
self.current_pipeline.reset();
|
|
self.current_bind_groups.reset();
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub(crate) const fn get_src_stride_of_indirect_args(family: DrawCommandFamily) -> u64 {
|
|
match family {
|
|
DrawCommandFamily::Draw => size_of::<wgt::DrawIndirectArgs>() as u64,
|
|
DrawCommandFamily::DrawIndexed => size_of::<wgt::DrawIndexedIndirectArgs>() as u64,
|
|
DrawCommandFamily::DrawMeshTasks => size_of::<wgt::DispatchIndirectArgs>() as u64,
|
|
}
|
|
}
|
|
|
|
pub(crate) const fn get_dst_stride_of_indirect_args(
|
|
backend: wgt::Backend,
|
|
family: DrawCommandFamily,
|
|
) -> u64 {
|
|
// space for D3D12 special constants
|
|
let extra = if matches!(backend, wgt::Backend::Dx12) {
|
|
3 * size_of::<u32>() as u64
|
|
} else {
|
|
0
|
|
};
|
|
extra + get_src_stride_of_indirect_args(family)
|
|
}
|
|
|
|
// Recording a render pass.
|
|
//
|
|
// The only error that should be returned from these methods is
|
|
// `EncoderStateError::Ended`, when the pass has already ended and an immediate
|
|
// validation error is raised.
|
|
//
|
|
// All other errors should be stored in the pass for later reporting when
|
|
// `CommandEncoder.finish()` is called.
|
|
//
|
|
// The `pass_try!` macro should be used to handle errors appropriately. Note
|
|
// that the `pass_try!` and `pass_base!` macros may return early from the
|
|
// function that invokes them, like the `?` operator.
|
|
impl Global {
|
|
pub fn render_pass_set_bind_group(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
index: u32,
|
|
bind_group_id: Option<id::BindGroupId>,
|
|
offsets: &[DynamicOffset],
|
|
) -> Result<(), PassStateError> {
|
|
pass.set_bind_group(
|
|
index,
|
|
bind_group_id.map(|id| self.hub.bind_groups.get(id)),
|
|
offsets,
|
|
)
|
|
}
|
|
|
|
pub fn render_pass_set_bind_group_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
index: u32,
|
|
bind_group_id: Option<id::BindGroupId>,
|
|
offsets: &[DynamicOffset],
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_set_bind_group(&mut pass, index, bind_group_id, offsets)
|
|
}
|
|
|
|
pub fn render_pass_set_pipeline(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
pipeline_id: id::RenderPipelineId,
|
|
) -> Result<(), PassStateError> {
|
|
let pipeline = self.resolve_render_pipeline_id(pipeline_id);
|
|
pass.set_pipeline(pipeline)
|
|
}
|
|
|
|
pub fn render_pass_set_pipeline_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
pipeline_id: id::RenderPipelineId,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_set_pipeline(&mut pass, pipeline_id)
|
|
}
|
|
|
|
pub fn render_pass_set_index_buffer(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
buffer_id: id::BufferId,
|
|
index_format: IndexFormat,
|
|
offset: BufferAddress,
|
|
size: Option<BufferSize>,
|
|
) -> Result<(), PassStateError> {
|
|
pass.set_index_buffer(
|
|
self.resolve_buffer_id(buffer_id),
|
|
index_format,
|
|
offset,
|
|
size,
|
|
)
|
|
}
|
|
|
|
pub fn render_pass_set_index_buffer_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
buffer_id: id::BufferId,
|
|
index_format: IndexFormat,
|
|
offset: BufferAddress,
|
|
size: Option<BufferSize>,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_set_index_buffer(&mut pass, buffer_id, index_format, offset, size)
|
|
}
|
|
|
|
pub fn render_pass_set_vertex_buffer(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
slot: u32,
|
|
buffer_id: Option<id::BufferId>,
|
|
offset: BufferAddress,
|
|
size: Option<BufferSize>,
|
|
) -> Result<(), PassStateError> {
|
|
pass.set_vertex_buffer(
|
|
slot,
|
|
buffer_id.map(|id| self.resolve_buffer_id(id)),
|
|
offset,
|
|
size,
|
|
)
|
|
}
|
|
|
|
pub fn render_pass_set_vertex_buffer_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
slot: u32,
|
|
buffer_id: Option<id::BufferId>,
|
|
offset: BufferAddress,
|
|
size: Option<BufferSize>,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_set_vertex_buffer(&mut pass, slot, buffer_id, offset, size)
|
|
}
|
|
|
|
pub fn render_pass_set_blend_constant(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
color: Color,
|
|
) -> Result<(), PassStateError> {
|
|
pass.set_blend_constant(color)
|
|
}
|
|
|
|
pub fn render_pass_set_blend_constant_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
color: Color,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_set_blend_constant(&mut pass, color)
|
|
}
|
|
|
|
pub fn render_pass_set_stencil_reference(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
value: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.set_stencil_reference(value)
|
|
}
|
|
|
|
pub fn render_pass_set_stencil_reference_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
value: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_set_stencil_reference(&mut pass, value)
|
|
}
|
|
|
|
pub fn render_pass_set_viewport(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
x: f32,
|
|
y: f32,
|
|
w: f32,
|
|
h: f32,
|
|
depth_min: f32,
|
|
depth_max: f32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.set_viewport(x, y, w, h, depth_min, depth_max)
|
|
}
|
|
|
|
pub fn render_pass_set_viewport_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
x: f32,
|
|
y: f32,
|
|
w: f32,
|
|
h: f32,
|
|
depth_min: f32,
|
|
depth_max: f32,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_set_viewport(&mut pass, x, y, w, h, depth_min, depth_max)
|
|
}
|
|
|
|
pub fn render_pass_set_scissor_rect(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
x: u32,
|
|
y: u32,
|
|
w: u32,
|
|
h: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.set_scissor_rect(x, y, w, h)
|
|
}
|
|
|
|
pub fn render_pass_set_scissor_rect_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
x: u32,
|
|
y: u32,
|
|
w: u32,
|
|
h: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_set_scissor_rect(&mut pass, x, y, w, h)
|
|
}
|
|
|
|
pub fn render_pass_set_immediates(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
offset: u32,
|
|
data: &[u8],
|
|
) -> Result<(), PassStateError> {
|
|
pass.set_immediates(offset, data)
|
|
}
|
|
|
|
pub fn render_pass_set_immediates_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
offset: u32,
|
|
data: &[u8],
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_set_immediates(&mut pass, offset, data)
|
|
}
|
|
|
|
pub fn render_pass_draw(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
vertex_count: u32,
|
|
instance_count: u32,
|
|
first_vertex: u32,
|
|
first_instance: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.draw(vertex_count, instance_count, first_vertex, first_instance)
|
|
}
|
|
|
|
pub fn render_pass_draw_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
vertex_count: u32,
|
|
instance_count: u32,
|
|
first_vertex: u32,
|
|
first_instance: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_draw(
|
|
&mut pass,
|
|
vertex_count,
|
|
instance_count,
|
|
first_vertex,
|
|
first_instance,
|
|
)
|
|
}
|
|
|
|
pub fn render_pass_draw_indexed(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
index_count: u32,
|
|
instance_count: u32,
|
|
first_index: u32,
|
|
base_vertex: i32,
|
|
first_instance: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.draw_indexed(
|
|
index_count,
|
|
instance_count,
|
|
first_index,
|
|
base_vertex,
|
|
first_instance,
|
|
)
|
|
}
|
|
|
|
pub fn render_pass_draw_indexed_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
index_count: u32,
|
|
instance_count: u32,
|
|
first_index: u32,
|
|
base_vertex: i32,
|
|
first_instance: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_draw_indexed(
|
|
&mut pass,
|
|
index_count,
|
|
instance_count,
|
|
first_index,
|
|
base_vertex,
|
|
first_instance,
|
|
)
|
|
}
|
|
|
|
pub fn render_pass_draw_mesh_tasks(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
group_count_x: u32,
|
|
group_count_y: u32,
|
|
group_count_z: u32,
|
|
) -> Result<(), RenderPassError> {
|
|
pass.draw_mesh_tasks(group_count_x, group_count_y, group_count_z)
|
|
}
|
|
|
|
pub fn render_pass_draw_indirect(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
) -> Result<(), PassStateError> {
|
|
pass.draw_indirect(self.resolve_buffer_id(buffer_id), offset)
|
|
}
|
|
|
|
pub fn render_pass_draw_indirect_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_draw_indirect(&mut pass, buffer_id, offset)
|
|
}
|
|
|
|
pub fn render_pass_draw_indexed_indirect(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
) -> Result<(), PassStateError> {
|
|
pass.draw_indexed_indirect(self.resolve_buffer_id(buffer_id), offset)
|
|
}
|
|
|
|
pub fn render_pass_draw_indexed_indirect_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_draw_indexed_indirect(&mut pass, buffer_id, offset)
|
|
}
|
|
|
|
pub fn render_pass_draw_mesh_tasks_indirect(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
) -> Result<(), RenderPassError> {
|
|
pass.draw_mesh_tasks_indirect(self.resolve_buffer_id(buffer_id), offset)
|
|
}
|
|
|
|
pub fn render_pass_multi_draw_indirect(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
count: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.multi_draw_indirect(self.resolve_buffer_id(buffer_id), offset, count)
|
|
}
|
|
|
|
pub fn render_pass_multi_draw_indexed_indirect(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
count: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.multi_draw_indexed_indirect(self.resolve_buffer_id(buffer_id), offset, count)
|
|
}
|
|
|
|
pub fn render_pass_multi_draw_mesh_tasks_indirect(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
count: u32,
|
|
) -> Result<(), RenderPassError> {
|
|
pass.multi_draw_mesh_tasks_indirect(self.resolve_buffer_id(buffer_id), offset, count)
|
|
}
|
|
|
|
pub fn render_pass_multi_draw_indirect_count(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
count_buffer_id: id::BufferId,
|
|
count_buffer_offset: BufferAddress,
|
|
max_count: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.multi_draw_indirect_count(
|
|
self.resolve_buffer_id(buffer_id),
|
|
offset,
|
|
self.resolve_buffer_id(count_buffer_id),
|
|
count_buffer_offset,
|
|
max_count,
|
|
)
|
|
}
|
|
|
|
pub fn render_pass_multi_draw_indexed_indirect_count(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
count_buffer_id: id::BufferId,
|
|
count_buffer_offset: BufferAddress,
|
|
max_count: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.multi_draw_indexed_indirect_count(
|
|
self.resolve_buffer_id(buffer_id),
|
|
offset,
|
|
self.resolve_buffer_id(count_buffer_id),
|
|
count_buffer_offset,
|
|
max_count,
|
|
)
|
|
}
|
|
|
|
pub fn render_pass_multi_draw_mesh_tasks_indirect_count(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
buffer_id: id::BufferId,
|
|
offset: BufferAddress,
|
|
count_buffer_id: id::BufferId,
|
|
count_buffer_offset: BufferAddress,
|
|
max_count: u32,
|
|
) -> Result<(), RenderPassError> {
|
|
pass.multi_draw_mesh_tasks_indirect_count(
|
|
self.resolve_buffer_id(buffer_id),
|
|
offset,
|
|
self.resolve_buffer_id(count_buffer_id),
|
|
count_buffer_offset,
|
|
max_count,
|
|
)
|
|
}
|
|
|
|
pub fn render_pass_push_debug_group(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
label: &str,
|
|
color: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.push_debug_group(label, color)
|
|
}
|
|
|
|
pub fn render_pass_push_debug_group_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
label: &str,
|
|
color: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_push_debug_group(&mut pass, label, color)
|
|
}
|
|
|
|
pub fn render_pass_pop_debug_group(&self, pass: &mut RenderPass) -> Result<(), PassStateError> {
|
|
pass.pop_debug_group()
|
|
}
|
|
|
|
pub fn render_pass_pop_debug_group_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_pop_debug_group(&mut pass)
|
|
}
|
|
|
|
pub fn render_pass_insert_debug_marker(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
label: &str,
|
|
color: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.insert_debug_marker(label, color)
|
|
}
|
|
|
|
pub fn render_pass_insert_debug_marker_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
label: &str,
|
|
color: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_insert_debug_marker(&mut pass, label, color)
|
|
}
|
|
|
|
pub fn render_pass_write_timestamp(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
query_set_id: id::QuerySetId,
|
|
query_index: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.write_timestamp(self.resolve_query_set_id(query_set_id), query_index)
|
|
}
|
|
|
|
pub fn render_pass_write_timestamp_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
query_set_id: id::QuerySetId,
|
|
query_index: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_write_timestamp(&mut pass, query_set_id, query_index)
|
|
}
|
|
|
|
pub fn render_pass_begin_occlusion_query(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
query_index: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.begin_occlusion_query(query_index)
|
|
}
|
|
|
|
pub fn render_pass_begin_occlusion_query_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
query_index: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_begin_occlusion_query(&mut pass, query_index)
|
|
}
|
|
|
|
pub fn render_pass_end_occlusion_query(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
) -> Result<(), PassStateError> {
|
|
pass.end_occlusion_query()
|
|
}
|
|
|
|
pub fn render_pass_end_occlusion_query_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_end_occlusion_query(&mut pass)
|
|
}
|
|
|
|
pub fn render_pass_begin_pipeline_statistics_query(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
query_set_id: id::QuerySetId,
|
|
query_index: u32,
|
|
) -> Result<(), PassStateError> {
|
|
pass.begin_pipeline_statistics_query(self.resolve_query_set_id(query_set_id), query_index)
|
|
}
|
|
|
|
pub fn render_pass_begin_pipeline_statistics_query_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
query_set_id: id::QuerySetId,
|
|
query_index: u32,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_begin_pipeline_statistics_query(&mut pass, query_set_id, query_index)
|
|
}
|
|
|
|
pub fn render_pass_end_pipeline_statistics_query(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
) -> Result<(), PassStateError> {
|
|
pass.end_pipeline_statistics_query()
|
|
}
|
|
|
|
pub fn render_pass_end_pipeline_statistics_query_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_end_pipeline_statistics_query(&mut pass)
|
|
}
|
|
|
|
pub fn render_pass_execute_bundles(
|
|
&self,
|
|
pass: &mut RenderPass,
|
|
render_bundle_ids: &[id::RenderBundleId],
|
|
) -> Result<(), PassStateError> {
|
|
let hub = &self.hub;
|
|
let bundles = hub.render_bundles.read();
|
|
let render_bundles = render_bundle_ids
|
|
.iter()
|
|
.map(|&id| bundles.get(id))
|
|
.collect::<Vec<_>>();
|
|
|
|
pass.execute_bundles(&render_bundles)
|
|
}
|
|
|
|
pub fn render_pass_execute_bundles_with_id(
|
|
&self,
|
|
pass: id::RenderPassEncoderId,
|
|
render_bundle_ids: &[id::RenderBundleId],
|
|
) -> Result<(), PassStateError> {
|
|
let pass = self.hub.render_passes.get(pass);
|
|
let mut pass = pass
|
|
.try_lock()
|
|
.expect("RenderPasses should not be used concurrently");
|
|
self.render_pass_execute_bundles(&mut pass, render_bundle_ids)
|
|
}
|
|
}
|