Improve RenderPass related errors

CHANGELOG.md

@@ -82,6 +82,8 @@ By @teoxoy in [#3436](https://github.com/gfx-rs/wgpu/pull/3436)
 - Added `TextureFormatFeatureFlags::MULTISAMPLE_X16`. By @Dinnerbone in [#3454](https://github.com/gfx-rs/wgpu/pull/3454)
 - Support stencil-only views and copying to/from combined depth-stencil textures. By @teoxoy in [#3436](https://github.com/gfx-rs/wgpu/pull/3436)
 - Added `Features::SHADER_EARLY_DEPTH_TEST`. By @teoxoy in [#3494](https://github.com/gfx-rs/wgpu/pull/3494)
+- Improve attachment related errors. By @cwfitzgerald in [#3549](https://github.com/gfx-rs/wgpu/pull/3549)
+- Make error descriptions all upper case. By @cwfitzgerald in [#3549](https://github.com/gfx-rs/wgpu/pull/3549)
 
 #### WebGPU
 

wgpu-core/src/binding_model.rs

@@ -22,11 +22,11 @@ use thiserror::Error;
 
 #[derive(Clone, Debug, Error)]
 pub enum BindGroupLayoutEntryError {
- #[error("cube dimension is not expected for texture storage")]
+ #[error("Cube dimension is not expected for texture storage")]
  StorageTextureCube,
  #[error("Read-write and read-only storage textures are not allowed by webgpu, they require the native only feature TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES")]
  StorageTextureReadWrite,
- #[error("arrays of bindings unsupported for this type of binding")]
+ #[error("Arrays of bindings unsupported for this type of binding")]
  ArrayUnsupported,
  #[error(transparent)]
  MissingFeatures(#[from] MissingFeatures),
@@ -38,9 +38,9 @@ pub enum BindGroupLayoutEntryError {
 pub enum CreateBindGroupLayoutError {
  #[error(transparent)]
  Device(#[from] DeviceError),
- #[error("conflicting binding at index {0}")]
+ #[error("Conflicting binding at index {0}")]
  ConflictBinding(u32),
- #[error("binding {binding} entry is invalid")]
+ #[error("Binding {binding} entry is invalid")]
  Entry {
  binding: u32,
  #[source]
@@ -60,63 +60,63 @@ pub enum CreateBindGroupLayoutError {
 pub enum CreateBindGroupError {
  #[error(transparent)]
  Device(#[from] DeviceError),
- #[error("bind group layout is invalid")]
+ #[error("Bind group layout is invalid")]
  InvalidLayout,
- #[error("buffer {0:?} is invalid or destroyed")]
+ #[error("Buffer {0:?} is invalid or destroyed")]
  InvalidBuffer(BufferId),
- #[error("texture view {0:?} is invalid")]
+ #[error("Texture view {0:?} is invalid")]
  InvalidTextureView(TextureViewId),
- #[error("texture {0:?} is invalid")]
+ #[error("Texture {0:?} is invalid")]
  InvalidTexture(TextureId),
- #[error("sampler {0:?} is invalid")]
+ #[error("Sampler {0:?} is invalid")]
  InvalidSampler(SamplerId),
  #[error(
- "binding count declared with at most {expected} items, but {actual} items were provided"
+ "Binding count declared with at most {expected} items, but {actual} items were provided"
  )]
  BindingArrayPartialLengthMismatch { actual: usize, expected: usize },
  #[error(
- "binding count declared with exactly {expected} items, but {actual} items were provided"
+ "Binding count declared with exactly {expected} items, but {actual} items were provided"
  )]
  BindingArrayLengthMismatch { actual: usize, expected: usize },
- #[error("array binding provided zero elements")]
+ #[error("Array binding provided zero elements")]
  BindingArrayZeroLength,
- #[error("bound buffer range {range:?} does not fit in buffer of size {size}")]
+ #[error("Bound buffer range {range:?} does not fit in buffer of size {size}")]
  BindingRangeTooLarge {
  buffer: BufferId,
  range: Range<wgt::BufferAddress>,
  size: u64,
  },
- #[error("buffer binding size {actual} is less than minimum {min}")]
+ #[error("Buffer binding size {actual} is less than minimum {min}")]
  BindingSizeTooSmall {
  buffer: BufferId,
  actual: u64,
  min: u64,
  },
- #[error("buffer binding size is zero")]
+ #[error("Buffer binding size is zero")]
  BindingZeroSize(BufferId),
- #[error("number of bindings in bind group descriptor ({actual}) does not match the number of bindings defined in the bind group layout ({expected})")]
+ #[error("Number of bindings in bind group descriptor ({actual}) does not match the number of bindings defined in the bind group layout ({expected})")]
  BindingsNumMismatch { actual: usize, expected: usize },
- #[error("binding {0} is used at least twice in the descriptor")]
+ #[error("Binding {0} is used at least twice in the descriptor")]
  DuplicateBinding(u32),
- #[error("unable to find a corresponding declaration for the given binding {0}")]
+ #[error("Unable to find a corresponding declaration for the given binding {0}")]
  MissingBindingDeclaration(u32),
  #[error(transparent)]
  MissingBufferUsage(#[from] MissingBufferUsageError),
  #[error(transparent)]
  MissingTextureUsage(#[from] MissingTextureUsageError),
- #[error("binding declared as a single item, but bind group is using it as an array")]
+ #[error("Binding declared as a single item, but bind group is using it as an array")]
  SingleBindingExpected,
- #[error("buffer offset {0} does not respect device's requested `{1}` limit {2}")]
+ #[error("Buffer offset {0} does not respect device's requested `{1}` limit {2}")]
  UnalignedBufferOffset(wgt::BufferAddress, &'static str, u32),
  #[error(
- "buffer binding {binding} range {given} exceeds `max_*_buffer_binding_size` limit {limit}"
+ "Buffer binding {binding} range {given} exceeds `max_*_buffer_binding_size` limit {limit}"
  )]
  BufferRangeTooLarge {
  binding: u32,
  given: u32,
  limit: u32,
  },
- #[error("binding {binding} has a different type ({actual:?}) than the one in the layout ({expected:?})")]
+ #[error("Binding {binding} has a different type ({actual:?}) than the one in the layout ({expected:?})")]
  WrongBindingType {
  // Index of the binding
  binding: u32,
@@ -125,47 +125,47 @@ pub enum CreateBindGroupError {
  // Human-readable description of expected types
  expected: &'static str,
  },
- #[error("texture binding {binding} expects multisampled = {layout_multisampled}, but given a view with samples = {view_samples}")]
+ #[error("Texture binding {binding} expects multisampled = {layout_multisampled}, but given a view with samples = {view_samples}")]
  InvalidTextureMultisample {
  binding: u32,
  layout_multisampled: bool,
  view_samples: u32,
  },
- #[error("texture binding {binding} expects sample type = {layout_sample_type:?}, but given a view with format = {view_format:?}")]
+ #[error("Texture binding {binding} expects sample type = {layout_sample_type:?}, but given a view with format = {view_format:?}")]
  InvalidTextureSampleType {
  binding: u32,
  layout_sample_type: wgt::TextureSampleType,
  view_format: wgt::TextureFormat,
  },
- #[error("texture binding {binding} expects dimension = {layout_dimension:?}, but given a view with dimension = {view_dimension:?}")]
+ #[error("Texture binding {binding} expects dimension = {layout_dimension:?}, but given a view with dimension = {view_dimension:?}")]
  InvalidTextureDimension {
  binding: u32,
  layout_dimension: wgt::TextureViewDimension,
  view_dimension: wgt::TextureViewDimension,
  },
- #[error("storage texture binding {binding} expects format = {layout_format:?}, but given a view with format = {view_format:?}")]
+ #[error("Storage texture binding {binding} expects format = {layout_format:?}, but given a view with format = {view_format:?}")]
  InvalidStorageTextureFormat {
  binding: u32,
  layout_format: wgt::TextureFormat,
  view_format: wgt::TextureFormat,
  },
- #[error("storage texture bindings must have a single mip level, but given a view with mip_level_count = {mip_level_count:?} at binding {binding}")]
+ #[error("Storage texture bindings must have a single mip level, but given a view with mip_level_count = {mip_level_count:?} at binding {binding}")]
  InvalidStorageTextureMipLevelCount { binding: u32, mip_level_count: u32 },
- #[error("sampler binding {binding} expects comparison = {layout_cmp}, but given a sampler with comparison = {sampler_cmp}")]
+ #[error("Sampler binding {binding} expects comparison = {layout_cmp}, but given a sampler with comparison = {sampler_cmp}")]
  WrongSamplerComparison {
  binding: u32,
  layout_cmp: bool,
  sampler_cmp: bool,
  },
- #[error("sampler binding {binding} expects filtering = {layout_flt}, but given a sampler with filtering = {sampler_flt}")]
+ #[error("Sampler binding {binding} expects filtering = {layout_flt}, but given a sampler with filtering = {sampler_flt}")]
  WrongSamplerFiltering {
  binding: u32,
  layout_flt: bool,
  sampler_flt: bool,
  },
- #[error("bound texture views can not have both depth and stencil aspects enabled")]
+ #[error("Bound texture views can not have both depth and stencil aspects enabled")]
  DepthStencilAspect,
- #[error("the adapter does not support read access for storages texture of format {0:?}")]
+ #[error("The adapter does not support read access for storages texture of format {0:?}")]
  StorageReadNotSupported(wgt::TextureFormat),
  #[error(transparent)]
  ResourceUsageConflict(#[from] UsageConflict),
@@ -200,14 +200,14 @@ impl PrettyError for CreateBindGroupError {
 
 #[derive(Clone, Debug, Error)]
 pub enum BindingZone {
- #[error("stage {0:?}")]
+ #[error("Stage {0:?}")]
  Stage(wgt::ShaderStages),
- #[error("whole pipeline")]
+ #[error("Whole pipeline")]
  Pipeline,
 }
 
 #[derive(Clone, Debug, Error)]
-#[error("too many bindings of type {kind:?} in {zone}, limit is {limit}, count was {count}")]
+#[error("Too many bindings of type {kind:?} in {zone}, limit is {limit}, count was {count}")]
 pub struct BindingTypeMaxCountError {
  pub kind: BindingTypeMaxCountErrorKind,
  pub zone: BindingZone,
@@ -470,30 +470,30 @@ impl<A: hal::Api> Resource for BindGroupLayout<A> {
 pub enum CreatePipelineLayoutError {
  #[error(transparent)]
  Device(#[from] DeviceError),
- #[error("bind group layout {0:?} is invalid")]
+ #[error("Bind group layout {0:?} is invalid")]
  InvalidBindGroupLayout(BindGroupLayoutId),
  #[error(
- "push constant at index {index} has range bound {bound} not aligned to {}",
+ "Push constant at index {index} has range bound {bound} not aligned to {}",
  wgt::PUSH_CONSTANT_ALIGNMENT
  )]
  MisalignedPushConstantRange { index: usize, bound: u32 },
  #[error(transparent)]
  MissingFeatures(#[from] MissingFeatures),
- #[error("push constant range (index {index}) provides for stage(s) {provided:?} but there exists another range that provides stage(s) {intersected:?}. Each stage may only be provided by one range")]
+ #[error("Push constant range (index {index}) provides for stage(s) {provided:?} but there exists another range that provides stage(s) {intersected:?}. Each stage may only be provided by one range")]
  MoreThanOnePushConstantRangePerStage {
  index: usize,
  provided: wgt::ShaderStages,
  intersected: wgt::ShaderStages,
  },
- #[error("push constant at index {index} has range {}..{} which exceeds device push constant size limit 0..{max}", range.start, range.end)]
+ #[error("Push constant at index {index} has range {}..{} which exceeds device push constant size limit 0..{max}", range.start, range.end)]
  PushConstantRangeTooLarge {
  index: usize,
  range: Range<u32>,
  max: u32,
  },
  #[error(transparent)]
  TooManyBindings(BindingTypeMaxCountError),
- #[error("bind group layout count {actual} exceeds device bind group limit {max}")]
+ #[error("Bind group layout count {actual} exceeds device bind group limit {max}")]
  TooManyGroups { actual: usize, max: usize },
 }
 
@@ -508,31 +508,31 @@ impl PrettyError for CreatePipelineLayoutError {
 
 #[derive(Clone, Debug, Error)]
 pub enum PushConstantUploadError {
- #[error("provided push constant with indices {offset}..{end_offset} overruns matching push constant range at index {idx}, with stage(s) {:?} and indices {:?}", range.stages, range.range)]
+ #[error("Provided push constant with indices {offset}..{end_offset} overruns matching push constant range at index {idx}, with stage(s) {:?} and indices {:?}", range.stages, range.range)]
  TooLarge {
  offset: u32,
  end_offset: u32,
  idx: usize,
  range: wgt::PushConstantRange,
  },
- #[error("provided push constant is for stage(s) {actual:?}, stage with a partial match found at index {idx} with stage(s) {matched:?}, however push constants must be complete matches")]
+ #[error("Provided push constant is for stage(s) {actual:?}, stage with a partial match found at index {idx} with stage(s) {matched:?}, however push constants must be complete matches")]
  PartialRangeMatch {
  actual: wgt::ShaderStages,
  idx: usize,
  matched: wgt::ShaderStages,
  },
- #[error("provided push constant is for stage(s) {actual:?}, but intersects a push constant range (at index {idx}) with stage(s) {missing:?}. Push constants must provide the stages for all ranges they intersect")]
+ #[error("Provided push constant is for stage(s) {actual:?}, but intersects a push constant range (at index {idx}) with stage(s) {missing:?}. Push constants must provide the stages for all ranges they intersect")]
  MissingStages {
  actual: wgt::ShaderStages,
  idx: usize,
  missing: wgt::ShaderStages,
  },
- #[error("provided push constant is for stage(s) {actual:?}, however the pipeline layout has no push constant range for the stage(s) {unmatched:?}")]
+ #[error("Provided push constant is for stage(s) {actual:?}, however the pipeline layout has no push constant range for the stage(s) {unmatched:?}")]
  UnmatchedStages {
  actual: wgt::ShaderStages,
  unmatched: wgt::ShaderStages,
  },
- #[error("provided push constant offset {0} does not respect `PUSH_CONSTANT_ALIGNMENT`")]
+ #[error("Provided push constant offset {0} does not respect `PUSH_CONSTANT_ALIGNMENT`")]
  Unaligned(u32),
 }
 
@@ -829,9 +829,9 @@ impl<A: HalApi> Resource for BindGroup<A> {
 
 #[derive(Clone, Debug, Error)]
 pub enum GetBindGroupLayoutError {
- #[error("pipeline is invalid")]
+ #[error("Pipeline is invalid")]
  InvalidPipeline,
- #[error("invalid group index {0}")]
+ #[error("Invalid group index {0}")]
  InvalidGroupIndex(u32),
 }
 

wgpu-core/src/command/bundle.rs

@@ -86,8 +86,8 @@ use crate::{
  },
  conv,
  device::{
- AttachmentData, Device, DeviceError, MissingDownlevelFlags, RenderPassContext,
- SHADER_STAGE_COUNT,
+ AttachmentData, Device, DeviceError, MissingDownlevelFlags,
+ RenderPassCompatibilityCheckType, RenderPassContext, SHADER_STAGE_COUNT,
  },
  error::{ErrorFormatter, PrettyError},
  hub::{GlobalIdentityHandlerFactory, HalApi, Hub, Resource, Storage, Token},
@@ -367,7 +367,7 @@ impl RenderBundleEncoder {
  .map_pass_err(scope)?;
 
  self.context
- .check_compatible(&pipeline.pass_context)
+ .check_compatible(&pipeline.pass_context, RenderPassCompatibilityCheckType::RenderPipeline)
  .map_err(RenderCommandError::IncompatiblePipelineTargets)
  .map_pass_err(scope)?;
 
@@ -698,16 +698,16 @@ impl RenderBundleEncoder {
 pub enum CreateRenderBundleError {
  #[error(transparent)]
  ColorAttachment(#[from] ColorAttachmentError),
- #[error("invalid number of samples {0}")]
+ #[error("Invalid number of samples {0}")]
  InvalidSampleCount(u32),
 }
 
 /// Error type returned from `RenderBundleEncoder::new` if the sample count is invalid.
 #[derive(Clone, Debug, Error)]
 pub enum ExecutionError {
- #[error("buffer {0:?} is destroyed")]
+ #[error("Buffer {0:?} is destroyed")]
  DestroyedBuffer(id::BufferId),
- #[error("using {0} in a render bundle is not implemented")]
+ #[error("Using {0} in a render bundle is not implemented")]
  Unimplemented(&'static str),
 }
 impl PrettyError for ExecutionError {
@@ -1377,7 +1377,7 @@ impl<A: HalApi> State<A> {
 /// Error encountered when finishing recording a render bundle.
 #[derive(Clone, Debug, Error)]
 pub(super) enum RenderBundleErrorInner {
- #[error("resource is not valid to use with this render bundle because the resource and the bundle come from different devices")]
+ #[error("Resource is not valid to use with this render bundle because the resource and the bundle come from different devices")]
  NotValidToUse,
  #[error(transparent)]
  Device(#[from] DeviceError),