mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-19 14:01:08 +01:00
Support stencil-only views and copying to/from combined depth-stencil textures (#3436)
This commit is contained in:
1 parent
ee33f4d384
commit
c51edd36fd
40 files changed
+1902
-942
No files matched your search
@@ -42,6 +42,34 @@ Bottom level categories:
|
||||
|
||||
### Major changes
|
||||
|
||||
#### TextureFormat info API
|
||||
|
||||
The `describe` fn was removed in favor of separate functions: `block_dimensions`, `is_compressed`, `is_srgb`, `required_features`, `guaranteed_format_features`, `sample_type` and `block_size`.
|
||||
|
||||
```diff
|
||||
- let block_dimensions = format.describe().block_dimensions;
|
||||
+ let block_dimensions = format.block_dimensions();
|
||||
- let is_compressed = format.describe().is_compressed();
|
||||
+ let is_compressed = format.is_compressed();
|
||||
- let is_srgb = format.describe().srgb;
|
||||
+ let is_srgb = format.is_srgb();
|
||||
- let required_features = format.describe().required_features;
|
||||
+ let required_features = format.required_features();
|
||||
- let guaranteed_format_features = format.describe().guaranteed_format_features;
|
||||
+ let guaranteed_format_features = format.guaranteed_format_features();
|
||||
```
|
||||
|
||||
Additionally `sample_type` and `block_size` now take an optional `TextureAspect` and return `Option`s.
|
||||
|
||||
```diff
|
||||
- let sample_type = format.describe().sample_type;
|
||||
+ let sample_type = format.sample_type(None).expect("combined depth-stencil format requires specifying a TextureAspect");
|
||||
- let block_size = format.describe().block_size;
|
||||
+ let block_size = format.block_size(None).expect("combined depth-stencil format requires specifying a TextureAspect");
|
||||
```
|
||||
|
||||
By @teoxoy in [#3436](https://github.com/gfx-rs/wgpu/pull/3436)
|
||||
|
||||
#### General
|
||||
|
||||
- Change type of `mip_level_count` and `array_layer_count` (members of `TextureViewDescriptor` and `ImageSubresourceRange`) from `Option<NonZeroU32>` to `Option<u32>`. By @teoxoy in [#3445](https://github.com/gfx-rs/wgpu/pull/3445)
|
||||
@@ -51,6 +79,7 @@ Bottom level categories:
|
||||
#### General
|
||||
|
||||
- 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)
|
||||
|
||||
#### WebGPU
|
||||
|
||||
|
||||
@@ -178,8 +178,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
.map_err(|_| ClearError::InvalidTexture(dst))?;
|
||||
|
||||
// Check if subresource aspects are valid.
|
||||
let requested_aspects = hal::FormatAspects::from(subresource_range.aspect);
|
||||
let clear_aspects = hal::FormatAspects::from(dst_texture.desc.format) & requested_aspects;
|
||||
let clear_aspects =
|
||||
hal::FormatAspects::new(dst_texture.desc.format, subresource_range.aspect);
|
||||
if clear_aspects.is_empty() {
|
||||
return Err(ClearError::MissingTextureAspect {
|
||||
texture_format: dst_texture.desc.format,
|
||||
@@ -310,29 +310,33 @@ fn clear_texture_via_buffer_copies<A: hal::Api>(
|
||||
encoder: &mut A::CommandEncoder,
|
||||
dst_raw: &A::Texture,
|
||||
) {
|
||||
assert_eq!(
|
||||
hal::FormatAspects::from(texture_desc.format),
|
||||
hal::FormatAspects::COLOR
|
||||
);
|
||||
|
||||
// Gather list of zero_buffer copies and issue a single command then to perform them
|
||||
let mut zero_buffer_copy_regions = Vec::new();
|
||||
let buffer_copy_pitch = alignments.buffer_copy_pitch.get() as u32;
|
||||
let format_desc = texture_desc.format.describe();
|
||||
let (block_width, block_height) = texture_desc.format.block_dimensions();
|
||||
let block_size = texture_desc.format.block_size(None).unwrap();
|
||||
|
||||
let bytes_per_row_alignment =
|
||||
get_lowest_common_denom(buffer_copy_pitch, format_desc.block_size as u32);
|
||||
let bytes_per_row_alignment = get_lowest_common_denom(buffer_copy_pitch, block_size);
|
||||
|
||||
for mip_level in range.mip_range {
|
||||
let mut mip_size = texture_desc.mip_level_size(mip_level).unwrap();
|
||||
// Round to multiple of block size
|
||||
mip_size.width = align_to(mip_size.width, format_desc.block_dimensions.0 as u32);
|
||||
mip_size.height = align_to(mip_size.height, format_desc.block_dimensions.1 as u32);
|
||||
mip_size.width = align_to(mip_size.width, block_width);
|
||||
mip_size.height = align_to(mip_size.height, block_height);
|
||||
|
||||
let bytes_per_row = align_to(
|
||||
mip_size.width / format_desc.block_dimensions.0 as u32 * format_desc.block_size as u32,
|
||||
mip_size.width / block_width * block_size,
|
||||
bytes_per_row_alignment,
|
||||
);
|
||||
|
||||
let max_rows_per_copy = crate::device::ZERO_BUFFER_SIZE as u32 / bytes_per_row;
|
||||
// round down to a multiple of rows needed by the texture format
|
||||
let max_rows_per_copy = max_rows_per_copy / format_desc.block_dimensions.1 as u32
|
||||
* format_desc.block_dimensions.1 as u32;
|
||||
let max_rows_per_copy = max_rows_per_copy / block_height * block_height;
|
||||
assert!(
|
||||
max_rows_per_copy > 0,
|
||||
"Zero buffer size is too small to fill a single row \
|
||||
@@ -370,7 +374,7 @@ fn clear_texture_via_buffer_copies<A: hal::Api>(
|
||||
y: mip_size.height - num_rows_left,
|
||||
z,
|
||||
},
|
||||
aspect: hal::FormatAspects::all(),
|
||||
aspect: hal::FormatAspects::COLOR,
|
||||
},
|
||||
size: hal::CopyExtent {
|
||||
width: mip_size.width, // full row
|
||||
@@ -396,23 +400,17 @@ fn clear_texture_via_render_passes<A: hal::Api>(
|
||||
is_color: bool,
|
||||
encoder: &mut A::CommandEncoder,
|
||||
) -> Result<(), ClearError> {
|
||||
assert_eq!(dst_texture.desc.dimension, wgt::TextureDimension::D2);
|
||||
|
||||
let extent_base = wgt::Extent3d {
|
||||
width: dst_texture.desc.size.width,
|
||||
height: dst_texture.desc.size.height,
|
||||
depth_or_array_layers: 1, // Only one layer or slice is cleared at a time.
|
||||
depth_or_array_layers: 1, // Only one layer is cleared at a time.
|
||||
};
|
||||
|
||||
let sample_count = dst_texture.desc.sample_count;
|
||||
for mip_level in range.mip_range {
|
||||
let extent = extent_base.mip_level_size(mip_level, dst_texture.desc.dimension);
|
||||
let layer_or_depth_range = if dst_texture.desc.dimension == wgt::TextureDimension::D3 {
|
||||
// TODO: We assume that we're allowed to do clear operations on
|
||||
// volume texture slices, this is not properly specified.
|
||||
0..extent.depth_or_array_layers
|
||||
} else {
|
||||
range.layer_range.clone()
|
||||
};
|
||||
for depth_or_layer in layer_or_depth_range {
|
||||
for depth_or_layer in range.layer_range.clone() {
|
||||
let color_attachments_tmp;
|
||||
let (color_attachments, depth_stencil_attachment) = if is_color {
|
||||
color_attachments_tmp = [Some(hal::ColorAttachment {
|
||||
@@ -443,7 +441,7 @@ fn clear_texture_via_render_passes<A: hal::Api>(
|
||||
encoder.begin_render_pass(&hal::RenderPassDescriptor {
|
||||
label: Some("(wgpu internal) clear_texture clear pass"),
|
||||
extent,
|
||||
sample_count,
|
||||
sample_count: dst_texture.desc.sample_count,
|
||||
color_attachments,
|
||||
depth_stencil_attachment,
|
||||
multiview: None,
|
||||
|
||||
@@ -101,6 +101,8 @@ pub enum TransferError {
|
||||
"copy destination aspects must refer to all aspects of the destination texture format"
|
||||
)]
|
||||
CopyDstMissingAspects,
|
||||
#[error("copy aspect must refer to a single aspect of texture format")]
|
||||
CopyAspectNotOne,
|
||||
#[error("copying from textures with format {format:?} and aspect {aspect:?} is forbidden")]
|
||||
CopyFromForbiddenTextureFormat {
|
||||
format: wgt::TextureFormat,
|
||||
@@ -118,7 +120,7 @@ pub enum TransferError {
|
||||
#[error("the entire texture must be copied when copying from depth texture")]
|
||||
InvalidDepthTextureExtent,
|
||||
#[error(
|
||||
"source format ({src_format:?}) and destination format ({dst_format:?}) are different"
|
||||
"source format ({src_format:?}) and destination format ({dst_format:?}) are not copy-compatible"
|
||||
)]
|
||||
MismatchedTextureFormats {
|
||||
src_format: wgt::TextureFormat,
|
||||
@@ -181,8 +183,7 @@ pub(crate) fn extract_texture_selector<A: hal::Api>(
|
||||
texture: &Texture<A>,
|
||||
) -> Result<(TextureSelector, hal::TextureCopyBase), TransferError> {
|
||||
let format = texture.desc.format;
|
||||
let copy_aspect =
|
||||
hal::FormatAspects::from(format) & hal::FormatAspects::from(copy_texture.aspect);
|
||||
let copy_aspect = hal::FormatAspects::new(format, copy_texture.aspect);
|
||||
if copy_aspect.is_empty() {
|
||||
return Err(TransferError::InvalidTextureAspect {
|
||||
format,
|
||||
@@ -229,9 +230,9 @@ pub(crate) fn extract_texture_selector<A: hal::Api>(
|
||||
pub(crate) fn validate_linear_texture_data(
|
||||
layout: &wgt::ImageDataLayout,
|
||||
format: wgt::TextureFormat,
|
||||
aspect: wgt::TextureAspect,
|
||||
buffer_size: BufferAddress,
|
||||
buffer_side: CopySide,
|
||||
bytes_per_block: BufferAddress,
|
||||
copy_size: &Extent3d,
|
||||
need_copy_aligned_rows: bool,
|
||||
) -> Result<(BufferAddress, BufferAddress), TransferError> {
|
||||
@@ -245,31 +246,10 @@ pub(crate) fn validate_linear_texture_data(
|
||||
|
||||
let offset = layout.offset;
|
||||
|
||||
let (block_width, block_height) = format.describe().block_dimensions;
|
||||
let block_size = format.block_size(Some(aspect)).unwrap() as BufferAddress;
|
||||
let (block_width, block_height) = format.block_dimensions();
|
||||
let block_width = block_width as BufferAddress;
|
||||
let block_height = block_height as BufferAddress;
|
||||
let block_size = bytes_per_block;
|
||||
|
||||
let width_in_blocks = copy_width / block_width;
|
||||
let height_in_blocks = copy_height / block_height;
|
||||
|
||||
let bytes_per_row = if let Some(bytes_per_row) = layout.bytes_per_row {
|
||||
bytes_per_row.get() as BufferAddress
|
||||
} else {
|
||||
if copy_depth > 1 || height_in_blocks > 1 {
|
||||
return Err(TransferError::UnspecifiedBytesPerRow);
|
||||
}
|
||||
bytes_per_block * width_in_blocks
|
||||
};
|
||||
let block_rows_per_image = if let Some(rows_per_image) = layout.rows_per_image {
|
||||
rows_per_image.get() as BufferAddress
|
||||
} else {
|
||||
if copy_depth > 1 {
|
||||
return Err(TransferError::UnspecifiedRowsPerImage);
|
||||
}
|
||||
copy_height / block_height
|
||||
};
|
||||
let rows_per_image = block_rows_per_image * block_height;
|
||||
|
||||
if copy_width % block_width != 0 {
|
||||
return Err(TransferError::UnalignedCopyWidth);
|
||||
@@ -278,29 +258,64 @@ pub(crate) fn validate_linear_texture_data(
|
||||
return Err(TransferError::UnalignedCopyHeight);
|
||||
}
|
||||
|
||||
let width_in_blocks = copy_width / block_width;
|
||||
let height_in_blocks = copy_height / block_height;
|
||||
|
||||
let bytes_in_last_row = width_in_blocks * block_size;
|
||||
|
||||
let bytes_per_row = if let Some(bytes_per_row) = layout.bytes_per_row {
|
||||
let bytes_per_row = bytes_per_row.get() as BufferAddress;
|
||||
if bytes_per_row < bytes_in_last_row {
|
||||
return Err(TransferError::InvalidBytesPerRow);
|
||||
}
|
||||
bytes_per_row
|
||||
} else {
|
||||
if copy_depth > 1 || height_in_blocks > 1 {
|
||||
return Err(TransferError::UnspecifiedBytesPerRow);
|
||||
}
|
||||
0
|
||||
};
|
||||
let block_rows_per_image = if let Some(rows_per_image) = layout.rows_per_image {
|
||||
let rows_per_image = rows_per_image.get() as BufferAddress;
|
||||
if rows_per_image < height_in_blocks {
|
||||
return Err(TransferError::InvalidRowsPerImage);
|
||||
}
|
||||
rows_per_image
|
||||
} else {
|
||||
if copy_depth > 1 {
|
||||
return Err(TransferError::UnspecifiedRowsPerImage);
|
||||
}
|
||||
0
|
||||
};
|
||||
|
||||
if need_copy_aligned_rows {
|
||||
let bytes_per_row_alignment = wgt::COPY_BYTES_PER_ROW_ALIGNMENT as BufferAddress;
|
||||
|
||||
if bytes_per_row_alignment % bytes_per_block != 0 {
|
||||
return Err(TransferError::UnalignedBytesPerRow);
|
||||
let mut offset_alignment = block_size;
|
||||
if format.is_depth_stencil_format() {
|
||||
offset_alignment = 4
|
||||
}
|
||||
if offset % offset_alignment != 0 {
|
||||
return Err(TransferError::UnalignedBufferOffset(offset));
|
||||
}
|
||||
|
||||
if bytes_per_row % bytes_per_row_alignment != 0 {
|
||||
return Err(TransferError::UnalignedBytesPerRow);
|
||||
}
|
||||
}
|
||||
|
||||
let bytes_in_last_row = block_size * width_in_blocks;
|
||||
let bytes_per_image = bytes_per_row * block_rows_per_image;
|
||||
let required_bytes_in_copy = if copy_width == 0 || copy_height == 0 || copy_depth == 0 {
|
||||
|
||||
let required_bytes_in_copy = if copy_depth == 0 {
|
||||
0
|
||||
} else {
|
||||
let bytes_in_last_slice = bytes_per_row * (height_in_blocks - 1) + bytes_in_last_row;
|
||||
bytes_per_image * (copy_depth - 1) + bytes_in_last_slice
|
||||
let mut required_bytes_in_copy = bytes_per_image * (copy_depth - 1);
|
||||
if height_in_blocks > 0 {
|
||||
required_bytes_in_copy += bytes_per_row * (height_in_blocks - 1) + bytes_in_last_row;
|
||||
}
|
||||
required_bytes_in_copy
|
||||
};
|
||||
|
||||
if rows_per_image < copy_height {
|
||||
return Err(TransferError::InvalidRowsPerImage);
|
||||
}
|
||||
if offset + required_bytes_in_copy > buffer_size {
|
||||
return Err(TransferError::BufferOverrun {
|
||||
start_offset: offset,
|
||||
@@ -309,12 +324,7 @@ pub(crate) fn validate_linear_texture_data(
|
||||
side: buffer_side,
|
||||
});
|
||||
}
|
||||
if offset % block_size != 0 {
|
||||
return Err(TransferError::UnalignedBufferOffset(offset));
|
||||
}
|
||||
if copy_height > 1 && bytes_per_row < bytes_in_last_row {
|
||||
return Err(TransferError::InvalidBytesPerRow);
|
||||
}
|
||||
|
||||
Ok((required_bytes_in_copy, bytes_per_image))
|
||||
}
|
||||
|
||||
@@ -331,9 +341,7 @@ pub(crate) fn validate_texture_copy_range(
|
||||
texture_side: CopySide,
|
||||
copy_size: &Extent3d,
|
||||
) -> Result<(hal::CopyExtent, u32), TransferError> {
|
||||
let (block_width, block_height) = desc.format.describe().block_dimensions;
|
||||
let block_width = block_width as u32;
|
||||
let block_height = block_height as u32;
|
||||
let (block_width, block_height) = desc.format.block_dimensions();
|
||||
|
||||
let extent_virtual = desc.mip_level_size(texture_copy_view.mip_level).ok_or(
|
||||
TransferError::InvalidTextureMipLevel {
|
||||
@@ -344,18 +352,8 @@ pub(crate) fn validate_texture_copy_range(
|
||||
// physical size can be larger than the virtual
|
||||
let extent = extent_virtual.physical_size(desc.format);
|
||||
|
||||
match desc.format {
|
||||
wgt::TextureFormat::Stencil8
|
||||
| wgt::TextureFormat::Depth16Unorm
|
||||
| wgt::TextureFormat::Depth32Float
|
||||
| wgt::TextureFormat::Depth32FloatStencil8
|
||||
| wgt::TextureFormat::Depth24Plus
|
||||
| wgt::TextureFormat::Depth24PlusStencil8 => {
|
||||
if *copy_size != extent {
|
||||
return Err(TransferError::InvalidDepthTextureExtent);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
if desc.format.is_depth_stencil_format() && *copy_size != extent {
|
||||
return Err(TransferError::InvalidDepthTextureExtent);
|
||||
}
|
||||
|
||||
/// Return `Ok` if a run `size` texels long starting at `start_offset` falls
|
||||
@@ -778,16 +776,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
}
|
||||
let dst_barrier = dst_pending.map(|pending| pending.into_hal(dst_texture));
|
||||
|
||||
let format_desc = dst_texture.desc.format.describe();
|
||||
let (required_buffer_bytes_in_copy, bytes_per_array_layer) = validate_linear_texture_data(
|
||||
&source.layout,
|
||||
dst_texture.desc.format,
|
||||
src_buffer.size,
|
||||
CopySide::Source,
|
||||
format_desc.block_size as BufferAddress,
|
||||
copy_size,
|
||||
true,
|
||||
)?;
|
||||
if !dst_base.aspect.is_one() {
|
||||
return Err(TransferError::CopyAspectNotOne.into());
|
||||
}
|
||||
|
||||
if !conv::is_valid_copy_dst_texture_format(dst_texture.desc.format, destination.aspect) {
|
||||
return Err(TransferError::CopyToForbiddenTextureFormat {
|
||||
@@ -797,6 +788,22 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
.into());
|
||||
}
|
||||
|
||||
let (required_buffer_bytes_in_copy, bytes_per_array_layer) = validate_linear_texture_data(
|
||||
&source.layout,
|
||||
dst_texture.desc.format,
|
||||
destination.aspect,
|
||||
src_buffer.size,
|
||||
CopySide::Source,
|
||||
copy_size,
|
||||
true,
|
||||
)?;
|
||||
|
||||
if dst_texture.desc.format.is_depth_stencil_format() {
|
||||
device
|
||||
.require_downlevel_flags(wgt::DownlevelFlags::DEPTH_TEXTURE_AND_BUFFER_COPIES)
|
||||
.map_err(TransferError::from)?;
|
||||
}
|
||||
|
||||
cmd_buf
|
||||
.buffer_memory_init_actions
|
||||
.extend(src_buffer.initialization_status.create_action(
|
||||
@@ -926,16 +933,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
}
|
||||
let dst_barrier = dst_pending.map(|pending| pending.into_hal(dst_buffer));
|
||||
|
||||
let format_desc = src_texture.desc.format.describe();
|
||||
let (required_buffer_bytes_in_copy, bytes_per_array_layer) = validate_linear_texture_data(
|
||||
&destination.layout,
|
||||
src_texture.desc.format,
|
||||
dst_buffer.size,
|
||||
CopySide::Destination,
|
||||
format_desc.block_size as BufferAddress,
|
||||
copy_size,
|
||||
true,
|
||||
)?;
|
||||
if !src_base.aspect.is_one() {
|
||||
return Err(TransferError::CopyAspectNotOne.into());
|
||||
}
|
||||
|
||||
if !conv::is_valid_copy_src_texture_format(src_texture.desc.format, source.aspect) {
|
||||
return Err(TransferError::CopyFromForbiddenTextureFormat {
|
||||
@@ -945,16 +945,20 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
.into());
|
||||
}
|
||||
|
||||
if format_desc.sample_type == wgt::TextureSampleType::Depth
|
||||
&& !device
|
||||
.downlevel
|
||||
.flags
|
||||
.contains(wgt::DownlevelFlags::DEPTH_TEXTURE_AND_BUFFER_COPIES)
|
||||
{
|
||||
return Err(TransferError::MissingDownlevelFlags(MissingDownlevelFlags(
|
||||
wgt::DownlevelFlags::DEPTH_TEXTURE_AND_BUFFER_COPIES,
|
||||
))
|
||||
.into());
|
||||
let (required_buffer_bytes_in_copy, bytes_per_array_layer) = validate_linear_texture_data(
|
||||
&destination.layout,
|
||||
src_texture.desc.format,
|
||||
source.aspect,
|
||||
dst_buffer.size,
|
||||
CopySide::Destination,
|
||||
copy_size,
|
||||
true,
|
||||
)?;
|
||||
|
||||
if src_texture.desc.format.is_depth_stencil_format() {
|
||||
device
|
||||
.require_downlevel_flags(wgt::DownlevelFlags::DEPTH_TEXTURE_AND_BUFFER_COPIES)
|
||||
.map_err(TransferError::from)?;
|
||||
}
|
||||
|
||||
cmd_buf
|
||||
|
||||
+48
-33
@@ -728,11 +728,9 @@ impl<A: HalApi> Device<A> {
|
||||
&self.limits,
|
||||
)?;
|
||||
|
||||
let format_desc = desc.format.describe();
|
||||
|
||||
if desc.dimension != wgt::TextureDimension::D2 {
|
||||
// Depth textures can only be 2D
|
||||
if format_desc.sample_type == wgt::TextureSampleType::Depth {
|
||||
if desc.format.is_depth_stencil_format() {
|
||||
return Err(CreateTextureError::InvalidDepthDimension(
|
||||
desc.dimension,
|
||||
desc.format,
|
||||
@@ -747,7 +745,7 @@ impl<A: HalApi> Device<A> {
|
||||
}
|
||||
|
||||
// Compressed textures can only be 2D
|
||||
if format_desc.is_compressed() {
|
||||
if desc.format.is_compressed() {
|
||||
return Err(CreateTextureError::InvalidCompressedDimension(
|
||||
desc.dimension,
|
||||
desc.format,
|
||||
@@ -755,9 +753,8 @@ impl<A: HalApi> Device<A> {
|
||||
}
|
||||
}
|
||||
|
||||
if format_desc.is_compressed() {
|
||||
let block_width = format_desc.block_dimensions.0 as u32;
|
||||
let block_height = format_desc.block_dimensions.1 as u32;
|
||||
if desc.format.is_compressed() {
|
||||
let (block_width, block_height) = desc.format.block_dimensions();
|
||||
|
||||
if desc.size.width % block_width != 0 {
|
||||
return Err(CreateTextureError::InvalidDimension(
|
||||
@@ -840,11 +837,7 @@ impl<A: HalApi> Device<A> {
|
||||
let missing_allowed_usages = desc.usage - format_features.allowed_usages;
|
||||
if !missing_allowed_usages.is_empty() {
|
||||
// detect downlevel incompatibilities
|
||||
let wgpu_allowed_usages = desc
|
||||
.format
|
||||
.describe()
|
||||
.guaranteed_format_features
|
||||
.allowed_usages;
|
||||
let wgpu_allowed_usages = desc.format.guaranteed_format_features().allowed_usages;
|
||||
let wgpu_missing_usages = desc.usage - wgpu_allowed_usages;
|
||||
return Err(CreateTextureError::InvalidFormatUsages(
|
||||
missing_allowed_usages,
|
||||
@@ -867,10 +860,10 @@ impl<A: HalApi> Device<A> {
|
||||
self.require_downlevel_flags(wgt::DownlevelFlags::VIEW_FORMATS)?;
|
||||
}
|
||||
|
||||
// Enforce having COPY_DST/DEPTH_STENCIL_WRIT/COLOR_TARGET otherwise we
|
||||
// Enforce having COPY_DST/DEPTH_STENCIL_WRITE/COLOR_TARGET otherwise we
|
||||
// wouldn't be able to initialize the texture.
|
||||
let hal_usage = conv::map_texture_usage(desc.usage, desc.format.into())
|
||||
| if format_desc.sample_type == wgt::TextureSampleType::Depth {
|
||||
| if desc.format.is_depth_stencil_format() {
|
||||
hal::TextureUses::DEPTH_STENCIL_WRITE
|
||||
} else if desc.usage.contains(wgt::TextureUsages::COPY_DST) {
|
||||
hal::TextureUses::COPY_DST // (set already)
|
||||
@@ -909,12 +902,11 @@ impl<A: HalApi> Device<A> {
|
||||
let clear_mode = if hal_usage
|
||||
.intersects(hal::TextureUses::DEPTH_STENCIL_WRITE | hal::TextureUses::COLOR_TARGET)
|
||||
{
|
||||
let (is_color, usage) =
|
||||
if desc.format.describe().sample_type == wgt::TextureSampleType::Depth {
|
||||
(false, hal::TextureUses::DEPTH_STENCIL_WRITE)
|
||||
} else {
|
||||
(true, hal::TextureUses::COLOR_TARGET)
|
||||
};
|
||||
let (is_color, usage) = if desc.format.is_depth_stencil_format() {
|
||||
(false, hal::TextureUses::DEPTH_STENCIL_WRITE)
|
||||
} else {
|
||||
(true, hal::TextureUses::COLOR_TARGET)
|
||||
};
|
||||
let dimension = match desc.dimension {
|
||||
wgt::TextureDimension::D1 => wgt::TextureViewDimension::D1,
|
||||
wgt::TextureDimension::D2 => wgt::TextureViewDimension::D2,
|
||||
@@ -977,7 +969,13 @@ impl<A: HalApi> Device<A> {
|
||||
// resolve TextureViewDescriptor defaults
|
||||
// https://gpuweb.github.io/gpuweb/#abstract-opdef-resolving-gputextureviewdescriptor-defaults
|
||||
|
||||
let resolved_format = desc.format.unwrap_or(texture.desc.format);
|
||||
let resolved_format = desc.format.unwrap_or_else(|| {
|
||||
texture
|
||||
.desc
|
||||
.format
|
||||
.aspect_specific_format(desc.range.aspect)
|
||||
.unwrap_or(texture.desc.format)
|
||||
});
|
||||
|
||||
let resolved_dimension = desc
|
||||
.dimension
|
||||
@@ -1018,8 +1016,7 @@ impl<A: HalApi> Device<A> {
|
||||
|
||||
// validate TextureViewDescriptor
|
||||
|
||||
let aspects = hal::FormatAspects::from(texture.desc.format)
|
||||
& hal::FormatAspects::from(desc.range.aspect);
|
||||
let aspects = hal::FormatAspects::new(texture.desc.format, desc.range.aspect);
|
||||
if aspects.is_empty() {
|
||||
return Err(resource::CreateTextureViewError::InvalidAspect {
|
||||
texture_format: texture.desc.format,
|
||||
@@ -1027,9 +1024,17 @@ impl<A: HalApi> Device<A> {
|
||||
});
|
||||
}
|
||||
|
||||
if resolved_format != texture.desc.format
|
||||
&& !texture.desc.view_formats.contains(&resolved_format)
|
||||
{
|
||||
let format_is_good = if desc.range.aspect == wgt::TextureAspect::All {
|
||||
resolved_format == texture.desc.format
|
||||
|| texture.desc.view_formats.contains(&resolved_format)
|
||||
} else {
|
||||
Some(resolved_format)
|
||||
== texture
|
||||
.desc
|
||||
.format
|
||||
.aspect_specific_format(desc.range.aspect)
|
||||
};
|
||||
if !format_is_good {
|
||||
return Err(resource::CreateTextureViewError::FormatReinterpretation {
|
||||
texture: texture.desc.format,
|
||||
view: resolved_format,
|
||||
@@ -1172,6 +1177,13 @@ impl<A: HalApi> Device<A> {
|
||||
usage
|
||||
);
|
||||
|
||||
// use the combined depth-stencil format for the view
|
||||
let format = if resolved_format.is_depth_stencil_component(texture.desc.format) {
|
||||
texture.desc.format
|
||||
} else {
|
||||
resolved_format
|
||||
};
|
||||
|
||||
let resolved_range = wgt::ImageSubresourceRange {
|
||||
aspect: desc.range.aspect,
|
||||
base_mip_level: desc.range.base_mip_level,
|
||||
@@ -1182,7 +1194,7 @@ impl<A: HalApi> Device<A> {
|
||||
|
||||
let hal_desc = hal::TextureViewDescriptor {
|
||||
label: desc.label.borrow_option(),
|
||||
format: resolved_format,
|
||||
format,
|
||||
dimension: resolved_dimension,
|
||||
usage,
|
||||
range: resolved_range,
|
||||
@@ -2191,7 +2203,6 @@ impl<A: HalApi> Device<A> {
|
||||
{
|
||||
return Err(Error::DepthStencilAspect);
|
||||
}
|
||||
let format_info = view.desc.format.describe();
|
||||
match decl.ty {
|
||||
wgt::BindingType::Texture {
|
||||
sample_type,
|
||||
@@ -2206,7 +2217,12 @@ impl<A: HalApi> Device<A> {
|
||||
view_samples: view.samples,
|
||||
});
|
||||
}
|
||||
match (sample_type, format_info.sample_type) {
|
||||
let compat_sample_type = view
|
||||
.desc
|
||||
.format
|
||||
.sample_type(Some(view.desc.range.aspect))
|
||||
.unwrap();
|
||||
match (sample_type, compat_sample_type) {
|
||||
(Tst::Uint, Tst::Uint) |
|
||||
(Tst::Sint, Tst::Sint) |
|
||||
(Tst::Depth, Tst::Depth) |
|
||||
@@ -3101,8 +3117,7 @@ impl<A: HalApi> Device<A> {
|
||||
adapter: &Adapter<A>,
|
||||
format: TextureFormat,
|
||||
) -> Result<wgt::TextureFormatFeatures, MissingFeatures> {
|
||||
let format_desc = format.describe();
|
||||
self.require_features(format_desc.required_features)?;
|
||||
self.require_features(format.required_features())?;
|
||||
|
||||
let using_device_features = self
|
||||
.features
|
||||
@@ -3114,7 +3129,7 @@ impl<A: HalApi> Device<A> {
|
||||
if using_device_features || downlevel {
|
||||
Ok(adapter.get_texture_format_features(format))
|
||||
} else {
|
||||
Ok(format_desc.guaranteed_format_features)
|
||||
Ok(format.guaranteed_format_features())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3330,7 +3345,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
self.fetch_adapter_and_surface::<A, _, _>(surface_id, adapter_id, |adapter, surface| {
|
||||
let mut hal_caps = surface.get_capabilities(adapter)?;
|
||||
|
||||
hal_caps.formats.sort_by_key(|f| !f.describe().srgb);
|
||||
hal_caps.formats.sort_by_key(|f| !f.is_srgb());
|
||||
|
||||
Ok(wgt::SurfaceCapabilities {
|
||||
formats: hal_caps.formats,
|
||||
|
||||
@@ -602,8 +602,6 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
.get_mut(destination.texture)
|
||||
.map_err(|_| TransferError::InvalidTexture(destination.texture))?;
|
||||
|
||||
let format_desc = dst.desc.format.describe();
|
||||
|
||||
if !dst.desc.usage.contains(wgt::TextureUsages::COPY_DST) {
|
||||
return Err(
|
||||
TransferError::MissingCopyDstUsageFlag(None, Some(destination.texture)).into(),
|
||||
@@ -617,17 +615,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
|
||||
let (selector, dst_base) = extract_texture_selector(destination, size, dst)?;
|
||||
|
||||
// Note: `_source_bytes_per_array_layer` is ignored since we
|
||||
// have a staging copy, and it can have a different value.
|
||||
let (_, _source_bytes_per_array_layer) = validate_linear_texture_data(
|
||||
data_layout,
|
||||
dst.desc.format,
|
||||
data.len() as wgt::BufferAddress,
|
||||
CopySide::Source,
|
||||
format_desc.block_size as wgt::BufferAddress,
|
||||
size,
|
||||
false,
|
||||
)?;
|
||||
if !dst_base.aspect.is_one() {
|
||||
return Err(TransferError::CopyAspectNotOne.into());
|
||||
}
|
||||
|
||||
if !conv::is_valid_copy_dst_texture_format(dst.desc.format, destination.aspect) {
|
||||
return Err(TransferError::CopyToForbiddenTextureFormat {
|
||||
@@ -636,9 +626,28 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
}
|
||||
.into());
|
||||
}
|
||||
let (block_width, block_height) = format_desc.block_dimensions;
|
||||
let width_blocks = size.width / block_width as u32;
|
||||
let height_blocks = size.height / block_height as u32;
|
||||
|
||||
// Note: `_source_bytes_per_array_layer` is ignored since we
|
||||
// have a staging copy, and it can have a different value.
|
||||
let (_, _source_bytes_per_array_layer) = validate_linear_texture_data(
|
||||
data_layout,
|
||||
dst.desc.format,
|
||||
destination.aspect,
|
||||
data.len() as wgt::BufferAddress,
|
||||
CopySide::Source,
|
||||
size,
|
||||
false,
|
||||
)?;
|
||||
|
||||
if dst.desc.format.is_depth_stencil_format() {
|
||||
device
|
||||
.require_downlevel_flags(wgt::DownlevelFlags::DEPTH_TEXTURE_AND_BUFFER_COPIES)
|
||||
.map_err(TransferError::from)?;
|
||||
}
|
||||
|
||||
let (block_width, block_height) = dst.desc.format.block_dimensions();
|
||||
let width_blocks = size.width / block_width;
|
||||
let height_blocks = size.height / block_height;
|
||||
|
||||
let block_rows_per_image = match data_layout.rows_per_image {
|
||||
Some(rows_per_image) => rows_per_image.get(),
|
||||
@@ -650,14 +659,15 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
}
|
||||
};
|
||||
|
||||
let bytes_per_row_alignment = get_lowest_common_denom(
|
||||
device.alignments.buffer_copy_pitch.get() as u32,
|
||||
format_desc.block_size as u32,
|
||||
);
|
||||
let stage_bytes_per_row = hal::auxil::align_to(
|
||||
format_desc.block_size as u32 * width_blocks,
|
||||
bytes_per_row_alignment,
|
||||
);
|
||||
let block_size = dst
|
||||
.desc
|
||||
.format
|
||||
.block_size(Some(destination.aspect))
|
||||
.unwrap();
|
||||
let bytes_per_row_alignment =
|
||||
get_lowest_common_denom(device.alignments.buffer_copy_pitch.get() as u32, block_size);
|
||||
let stage_bytes_per_row =
|
||||
hal::auxil::align_to(block_size * width_blocks, bytes_per_row_alignment);
|
||||
|
||||
let block_rows_in_copy =
|
||||
(size.depth_or_array_layers - 1) * block_rows_per_image + height_blocks;
|
||||
@@ -731,7 +741,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|
||||
let bytes_per_row = if let Some(bytes_per_row) = data_layout.bytes_per_row {
|
||||
bytes_per_row.get()
|
||||
} else {
|
||||
width_blocks * format_desc.block_size as u32
|
||||
width_blocks * block_size
|
||||
};
|
||||
|
||||
// Platform validation requires that the staging buffer always be
|
||||
|
||||
@@ -572,7 +572,7 @@ pub(crate) struct HalTextureViewDescriptor {
|
||||
|
||||
impl HalTextureViewDescriptor {
|
||||
pub fn aspects(&self) -> hal::FormatAspects {
|
||||
hal::FormatAspects::from(self.format) & hal::FormatAspects::from(self.range.aspect)
|
||||
hal::FormatAspects::new(self.format, self.range.aspect)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -101,36 +101,78 @@ pub fn map_texture_format_nosrgb(format: wgt::TextureFormat) -> dxgiformat::DXGI
|
||||
}
|
||||
}
|
||||
|
||||
// Note: SRV and UAV can't use the depth formats directly
|
||||
pub fn map_texture_format_nodepth(format: wgt::TextureFormat) -> dxgiformat::DXGI_FORMAT {
|
||||
match format {
|
||||
wgt::TextureFormat::Depth16Unorm => dxgiformat::DXGI_FORMAT_R16_UNORM,
|
||||
wgt::TextureFormat::Depth32Float => dxgiformat::DXGI_FORMAT_R32_FLOAT,
|
||||
wgt::TextureFormat::Depth32FloatStencil8 => {
|
||||
// SRV and UAV can't use the depth or typeless formats
|
||||
// see https://microsoft.github.io/DirectX-Specs/d3d/PlanarDepthStencilDDISpec.html#view-creation
|
||||
pub fn map_texture_format_for_srv_uav(
|
||||
format: wgt::TextureFormat,
|
||||
aspect: crate::FormatAspects,
|
||||
) -> Option<dxgiformat::DXGI_FORMAT> {
|
||||
Some(match (format, aspect) {
|
||||
(wgt::TextureFormat::Depth16Unorm, crate::FormatAspects::DEPTH) => {
|
||||
dxgiformat::DXGI_FORMAT_R16_UNORM
|
||||
}
|
||||
(wgt::TextureFormat::Depth32Float, crate::FormatAspects::DEPTH) => {
|
||||
dxgiformat::DXGI_FORMAT_R32_FLOAT
|
||||
}
|
||||
(wgt::TextureFormat::Depth32FloatStencil8, crate::FormatAspects::DEPTH) => {
|
||||
dxgiformat::DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS
|
||||
}
|
||||
wgt::TextureFormat::Stencil8
|
||||
| wgt::TextureFormat::Depth24Plus
|
||||
| wgt::TextureFormat::Depth24PlusStencil8 => dxgiformat::DXGI_FORMAT_R24_UNORM_X8_TYPELESS,
|
||||
_ => {
|
||||
assert_eq!(
|
||||
crate::FormatAspects::from(format),
|
||||
crate::FormatAspects::COLOR
|
||||
);
|
||||
map_texture_format(format)
|
||||
(
|
||||
wgt::TextureFormat::Depth24Plus | wgt::TextureFormat::Depth24PlusStencil8,
|
||||
crate::FormatAspects::DEPTH,
|
||||
) => dxgiformat::DXGI_FORMAT_R24_UNORM_X8_TYPELESS,
|
||||
|
||||
(wgt::TextureFormat::Depth32FloatStencil8, crate::FormatAspects::STENCIL) => {
|
||||
dxgiformat::DXGI_FORMAT_X32_TYPELESS_G8X24_UINT
|
||||
}
|
||||
}
|
||||
(
|
||||
wgt::TextureFormat::Stencil8 | wgt::TextureFormat::Depth24PlusStencil8,
|
||||
crate::FormatAspects::STENCIL,
|
||||
) => dxgiformat::DXGI_FORMAT_X24_TYPELESS_G8_UINT,
|
||||
|
||||
(format, crate::FormatAspects::COLOR) => map_texture_format(format),
|
||||
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn map_texture_format_depth_typeless(format: wgt::TextureFormat) -> dxgiformat::DXGI_FORMAT {
|
||||
// see https://microsoft.github.io/DirectX-Specs/d3d/PlanarDepthStencilDDISpec.html#planar-layout-for-staging-from-buffer
|
||||
pub fn map_texture_format_for_copy(
|
||||
format: wgt::TextureFormat,
|
||||
aspect: crate::FormatAspects,
|
||||
) -> Option<dxgiformat::DXGI_FORMAT> {
|
||||
Some(match (format, aspect) {
|
||||
(wgt::TextureFormat::Depth16Unorm, crate::FormatAspects::DEPTH) => {
|
||||
dxgiformat::DXGI_FORMAT_R16_UNORM
|
||||
}
|
||||
(
|
||||
wgt::TextureFormat::Depth32Float | wgt::TextureFormat::Depth32FloatStencil8,
|
||||
crate::FormatAspects::DEPTH,
|
||||
) => dxgiformat::DXGI_FORMAT_R32_FLOAT,
|
||||
|
||||
(
|
||||
wgt::TextureFormat::Stencil8
|
||||
| wgt::TextureFormat::Depth24PlusStencil8
|
||||
| wgt::TextureFormat::Depth32FloatStencil8,
|
||||
crate::FormatAspects::STENCIL,
|
||||
) => dxgiformat::DXGI_FORMAT_R8_UINT,
|
||||
|
||||
(format, crate::FormatAspects::COLOR) => map_texture_format(format),
|
||||
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn map_texture_format_depth_stencil_typeless(
|
||||
format: wgt::TextureFormat,
|
||||
) -> dxgiformat::DXGI_FORMAT {
|
||||
match format {
|
||||
wgt::TextureFormat::Depth16Unorm => dxgiformat::DXGI_FORMAT_R16_TYPELESS,
|
||||
wgt::TextureFormat::Depth32Float => dxgiformat::DXGI_FORMAT_R32_TYPELESS,
|
||||
wgt::TextureFormat::Depth32FloatStencil8 => dxgiformat::DXGI_FORMAT_R32G8X24_TYPELESS,
|
||||
wgt::TextureFormat::Stencil8 => dxgiformat::DXGI_FORMAT_R24G8_TYPELESS,
|
||||
wgt::TextureFormat::Depth24Plus | wgt::TextureFormat::Depth24PlusStencil8 => {
|
||||
dxgiformat::DXGI_FORMAT_R24G8_TYPELESS
|
||||
}
|
||||
wgt::TextureFormat::Stencil8
|
||||
| wgt::TextureFormat::Depth24Plus
|
||||
| wgt::TextureFormat::Depth24PlusStencil8 => dxgiformat::DXGI_FORMAT_R24G8_TYPELESS,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -376,7 +376,19 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
Some(f) => f,
|
||||
None => return Tfc::empty(),
|
||||
};
|
||||
let no_depth_format = auxil::dxgi::conv::map_texture_format_nodepth(format);
|
||||
let srv_uav_format = if format.is_combined_depth_stencil_format() {
|
||||
auxil::dxgi::conv::map_texture_format_for_srv_uav(
|
||||
format,
|
||||
// use the depth aspect here as opposed to stencil since it has more capabilities
|
||||
crate::FormatAspects::DEPTH,
|
||||
)
|
||||
} else {
|
||||
auxil::dxgi::conv::map_texture_format_for_srv_uav(
|
||||
format,
|
||||
crate::FormatAspects::from(format),
|
||||
)
|
||||
}
|
||||
.unwrap();
|
||||
|
||||
let mut data = d3d12::D3D12_FEATURE_DATA_FORMAT_SUPPORT {
|
||||
Format: raw_format,
|
||||
@@ -393,24 +405,24 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
|
||||
// Because we use a different format for SRV and UAV views of depth textures, we need to check
|
||||
// the features that use SRV/UAVs using the no-depth format.
|
||||
let mut data_no_depth = d3d12::D3D12_FEATURE_DATA_FORMAT_SUPPORT {
|
||||
Format: no_depth_format,
|
||||
let mut data_srv_uav = d3d12::D3D12_FEATURE_DATA_FORMAT_SUPPORT {
|
||||
Format: srv_uav_format,
|
||||
Support1: d3d12::D3D12_FORMAT_SUPPORT1_NONE,
|
||||
Support2: d3d12::D3D12_FORMAT_SUPPORT2_NONE,
|
||||
};
|
||||
if raw_format != no_depth_format {
|
||||
if raw_format != srv_uav_format {
|
||||
// Only-recheck if we're using a different format
|
||||
assert_eq!(winerror::S_OK, unsafe {
|
||||
self.device.CheckFeatureSupport(
|
||||
d3d12::D3D12_FEATURE_FORMAT_SUPPORT,
|
||||
ptr::addr_of_mut!(data_no_depth).cast(),
|
||||
ptr::addr_of_mut!(data_srv_uav).cast(),
|
||||
DWORD::try_from(mem::size_of::<d3d12::D3D12_FEATURE_DATA_FORMAT_SUPPORT>())
|
||||
.unwrap(),
|
||||
)
|
||||
});
|
||||
} else {
|
||||
// Same format, just copy over.
|
||||
data_no_depth = data;
|
||||
data_srv_uav = data;
|
||||
}
|
||||
|
||||
let mut caps = Tfc::COPY_SRC | Tfc::COPY_DST;
|
||||
@@ -420,14 +432,14 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
| d3d12::D3D12_FORMAT_SUPPORT1_TEXTURE3D
|
||||
| d3d12::D3D12_FORMAT_SUPPORT1_TEXTURECUBE)
|
||||
!= 0;
|
||||
// SRVs use no-depth format
|
||||
// SRVs use srv_uav_format
|
||||
caps.set(
|
||||
Tfc::SAMPLED,
|
||||
is_texture && data_no_depth.Support1 & d3d12::D3D12_FORMAT_SUPPORT1_SHADER_LOAD != 0,
|
||||
is_texture && data_srv_uav.Support1 & d3d12::D3D12_FORMAT_SUPPORT1_SHADER_LOAD != 0,
|
||||
);
|
||||
caps.set(
|
||||
Tfc::SAMPLED_LINEAR,
|
||||
data_no_depth.Support1 & d3d12::D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE != 0,
|
||||
data_srv_uav.Support1 & d3d12::D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE != 0,
|
||||
);
|
||||
caps.set(
|
||||
Tfc::COLOR_ATTACHMENT,
|
||||
@@ -441,19 +453,19 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
Tfc::DEPTH_STENCIL_ATTACHMENT,
|
||||
data.Support1 & d3d12::D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL != 0,
|
||||
);
|
||||
// UAVs use no-depth format
|
||||
// UAVs use srv_uav_format
|
||||
caps.set(
|
||||
Tfc::STORAGE,
|
||||
data_no_depth.Support1 & d3d12::D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW != 0,
|
||||
data_srv_uav.Support1 & d3d12::D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW != 0,
|
||||
);
|
||||
caps.set(
|
||||
Tfc::STORAGE_READ_WRITE,
|
||||
data_no_depth.Support2 & d3d12::D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD != 0,
|
||||
data_srv_uav.Support2 & d3d12::D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD != 0,
|
||||
);
|
||||
|
||||
// We load via UAV/SRV so use no-depth
|
||||
// We load via UAV/SRV so use srv_uav_format
|
||||
let no_msaa_load = caps.contains(Tfc::SAMPLED)
|
||||
&& data_no_depth.Support1 & d3d12::D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD == 0;
|
||||
&& data_srv_uav.Support1 & d3d12::D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD == 0;
|
||||
|
||||
let no_msaa_target = data.Support1
|
||||
& (d3d12::D3D12_FORMAT_SUPPORT1_RENDER_TARGET
|
||||
|
||||
@@ -20,26 +20,30 @@ impl crate::BufferTextureCopy {
|
||||
&self,
|
||||
format: wgt::TextureFormat,
|
||||
) -> d3d12::D3D12_PLACED_SUBRESOURCE_FOOTPRINT {
|
||||
let desc = format.describe();
|
||||
let (block_width, block_height) = format.block_dimensions();
|
||||
d3d12::D3D12_PLACED_SUBRESOURCE_FOOTPRINT {
|
||||
Offset: self.buffer_layout.offset,
|
||||
Footprint: d3d12::D3D12_SUBRESOURCE_FOOTPRINT {
|
||||
Format: auxil::dxgi::conv::map_texture_format(format),
|
||||
Format: auxil::dxgi::conv::map_texture_format_for_copy(
|
||||
format,
|
||||
self.texture_base.aspect,
|
||||
)
|
||||
.unwrap(),
|
||||
Width: self.size.width,
|
||||
Height: self
|
||||
.buffer_layout
|
||||
.rows_per_image
|
||||
.map_or(self.size.height, |count| {
|
||||
count.get() * desc.block_dimensions.1 as u32
|
||||
}),
|
||||
.map_or(self.size.height, |count| count.get() * block_height),
|
||||
Depth: self.size.depth,
|
||||
RowPitch: {
|
||||
let actual = match self.buffer_layout.bytes_per_row {
|
||||
Some(count) => count.get(),
|
||||
// this may happen for single-line updates
|
||||
None => {
|
||||
(self.size.width / desc.block_dimensions.0 as u32)
|
||||
* desc.block_size as u32
|
||||
let block_size = format
|
||||
.block_size(Some(self.texture_base.aspect.map()))
|
||||
.unwrap();
|
||||
(self.size.width / block_width) * block_size
|
||||
}
|
||||
};
|
||||
crate::auxil::align_to(actual, d3d12::D3D12_TEXTURE_DATA_PITCH_ALIGNMENT)
|
||||
@@ -387,24 +391,27 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
let tex_mip_level_count = barrier.texture.mip_level_count;
|
||||
let tex_array_layer_count = barrier.texture.array_layer_count();
|
||||
|
||||
if barrier
|
||||
.range
|
||||
.is_full_resource(tex_mip_level_count, tex_array_layer_count)
|
||||
{
|
||||
if barrier.range.is_full_resource(
|
||||
barrier.texture.format,
|
||||
tex_mip_level_count,
|
||||
tex_array_layer_count,
|
||||
) {
|
||||
// Only one barrier if it affects the whole image.
|
||||
self.temp.barriers.push(raw);
|
||||
} else {
|
||||
// Selected texture aspect is relevant if the texture format has both depth _and_ stencil aspects.
|
||||
let planes = if crate::FormatAspects::from(barrier.texture.format)
|
||||
.contains(crate::FormatAspects::DEPTH | crate::FormatAspects::STENCIL)
|
||||
{
|
||||
let planes = if barrier.texture.format.is_combined_depth_stencil_format() {
|
||||
match barrier.range.aspect {
|
||||
wgt::TextureAspect::All => 0..2,
|
||||
wgt::TextureAspect::StencilOnly => 1..2,
|
||||
wgt::TextureAspect::DepthOnly => 0..1,
|
||||
wgt::TextureAspect::StencilOnly => 1..2,
|
||||
}
|
||||
} else {
|
||||
0..1
|
||||
match barrier.texture.format {
|
||||
wgt::TextureFormat::Stencil8 => 1..2,
|
||||
wgt::TextureFormat::Depth24Plus => 0..2, // TODO: investigate why tests fail if we set this to 0..1
|
||||
_ => 0..1,
|
||||
}
|
||||
};
|
||||
|
||||
for mip_level in barrier.range.mip_range(tex_mip_level_count) {
|
||||
@@ -705,7 +712,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
|
||||
if let Some(ref ds) = desc.depth_stencil_attachment {
|
||||
let mut flags = native::ClearFlags::empty();
|
||||
let aspects = ds.target.view.format_aspects;
|
||||
let aspects = ds.target.view.aspects;
|
||||
if !ds.depth_ops.contains(crate::AttachmentOps::LOAD)
|
||||
&& aspects.contains(crate::FormatAspects::DEPTH)
|
||||
{
|
||||
|
||||
+29
-28
@@ -1,7 +1,4 @@
|
||||
use crate::{
|
||||
auxil::{self, dxgi::result::HResult as _},
|
||||
FormatAspects,
|
||||
};
|
||||
use crate::auxil::{self, dxgi::result::HResult as _};
|
||||
|
||||
use super::{conv, descriptor, view};
|
||||
use parking_lot::Mutex;
|
||||
@@ -421,7 +418,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
// because then we'd create a non-depth format view of it.
|
||||
// Note: we can skip this branch if
|
||||
// `D3D12_FEATURE_D3D12_OPTIONS3::CastingFullyTypedFormatSupported`
|
||||
auxil::dxgi::conv::map_texture_format_depth_typeless(desc.format)
|
||||
auxil::dxgi::conv::map_texture_format_depth_stencil_typeless(desc.format)
|
||||
},
|
||||
SampleDesc: dxgitype::DXGI_SAMPLE_DESC {
|
||||
Count: desc.sample_count,
|
||||
@@ -469,23 +466,25 @@ impl crate::Device<super::Api> for super::Device {
|
||||
let view_desc = desc.to_internal(texture);
|
||||
|
||||
Ok(super::TextureView {
|
||||
raw_format: view_desc.format,
|
||||
format_aspects: FormatAspects::from(desc.format),
|
||||
raw_format: view_desc.rtv_dsv_format,
|
||||
aspects: view_desc.aspects,
|
||||
target_base: (
|
||||
texture.resource,
|
||||
texture.calc_subresource(desc.range.base_mip_level, desc.range.base_array_layer, 0),
|
||||
),
|
||||
handle_srv: if desc.usage.intersects(crate::TextureUses::RESOURCE) {
|
||||
let raw_desc = unsafe { view_desc.to_srv() };
|
||||
let handle = self.srv_uav_pool.lock().alloc_handle();
|
||||
unsafe {
|
||||
self.raw.CreateShaderResourceView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
)
|
||||
};
|
||||
Some(handle)
|
||||
raw_desc.map(|raw_desc| {
|
||||
let handle = self.srv_uav_pool.lock().alloc_handle();
|
||||
unsafe {
|
||||
self.raw.CreateShaderResourceView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
)
|
||||
};
|
||||
handle
|
||||
})
|
||||
} else {
|
||||
None
|
||||
},
|
||||
@@ -493,16 +492,18 @@ impl crate::Device<super::Api> for super::Device {
|
||||
crate::TextureUses::STORAGE_READ | crate::TextureUses::STORAGE_READ_WRITE,
|
||||
) {
|
||||
let raw_desc = unsafe { view_desc.to_uav() };
|
||||
let handle = self.srv_uav_pool.lock().alloc_handle();
|
||||
unsafe {
|
||||
self.raw.CreateUnorderedAccessView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
ptr::null_mut(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
)
|
||||
};
|
||||
Some(handle)
|
||||
raw_desc.map(|raw_desc| {
|
||||
let handle = self.srv_uav_pool.lock().alloc_handle();
|
||||
unsafe {
|
||||
self.raw.CreateUnorderedAccessView(
|
||||
texture.resource.as_mut_ptr(),
|
||||
ptr::null_mut(),
|
||||
&raw_desc,
|
||||
handle.raw,
|
||||
)
|
||||
};
|
||||
handle
|
||||
})
|
||||
} else {
|
||||
None
|
||||
},
|
||||
@@ -524,7 +525,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.usage
|
||||
.intersects(crate::TextureUses::DEPTH_STENCIL_READ)
|
||||
{
|
||||
let raw_desc = unsafe { view_desc.to_dsv(desc.format.into()) };
|
||||
let raw_desc = unsafe { view_desc.to_dsv(true) };
|
||||
let handle = self.dsv_pool.lock().alloc_handle();
|
||||
unsafe {
|
||||
self.raw.CreateDepthStencilView(
|
||||
@@ -541,7 +542,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
.usage
|
||||
.intersects(crate::TextureUses::DEPTH_STENCIL_WRITE)
|
||||
{
|
||||
let raw_desc = unsafe { view_desc.to_dsv(FormatAspects::empty()) };
|
||||
let raw_desc = unsafe { view_desc.to_dsv(false) };
|
||||
let handle = self.dsv_pool.lock().alloc_handle();
|
||||
unsafe {
|
||||
self.raw.CreateDepthStencilView(
|
||||
|
||||
@@ -439,19 +439,25 @@ impl Texture {
|
||||
}
|
||||
}
|
||||
|
||||
/// see https://learn.microsoft.com/en-us/windows/win32/direct3d12/subresources#plane-slice
|
||||
fn calc_subresource(&self, mip_level: u32, array_layer: u32, plane: u32) -> u32 {
|
||||
mip_level + (array_layer + plane * self.array_layer_count()) * self.mip_level_count
|
||||
}
|
||||
|
||||
fn calc_subresource_for_copy(&self, base: &crate::TextureCopyBase) -> u32 {
|
||||
self.calc_subresource(base.mip_level, base.array_layer, 0)
|
||||
let plane = match base.aspect {
|
||||
crate::FormatAspects::COLOR | crate::FormatAspects::DEPTH => 0,
|
||||
crate::FormatAspects::STENCIL => 1,
|
||||
_ => unreachable!(),
|
||||
};
|
||||
self.calc_subresource(base.mip_level, base.array_layer, plane)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct TextureView {
|
||||
raw_format: native::Format,
|
||||
format_aspects: crate::FormatAspects, // May explicitly ignore stencil aspect of raw_format!
|
||||
aspects: crate::FormatAspects,
|
||||
target_base: (native::Resource, u32),
|
||||
handle_srv: Option<descriptor::Handle>,
|
||||
handle_uav: Option<descriptor::Handle>,
|
||||
|
||||
+24
-21
@@ -6,8 +6,9 @@ pub(crate) const D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING: u32 = 0x1688;
|
||||
|
||||
pub(super) struct ViewDescriptor {
|
||||
dimension: wgt::TextureViewDimension,
|
||||
pub format: native::Format,
|
||||
format_nodepth: native::Format,
|
||||
pub aspects: crate::FormatAspects,
|
||||
pub rtv_dsv_format: native::Format,
|
||||
srv_uav_format: Option<native::Format>,
|
||||
multisampled: bool,
|
||||
array_layer_base: u32,
|
||||
array_layer_count: u32,
|
||||
@@ -17,10 +18,13 @@ pub(super) struct ViewDescriptor {
|
||||
|
||||
impl crate::TextureViewDescriptor<'_> {
|
||||
pub(super) fn to_internal(&self, texture: &super::Texture) -> ViewDescriptor {
|
||||
let aspects = crate::FormatAspects::new(self.format, self.range.aspect);
|
||||
|
||||
ViewDescriptor {
|
||||
dimension: self.dimension,
|
||||
format: auxil::dxgi::conv::map_texture_format(self.format),
|
||||
format_nodepth: auxil::dxgi::conv::map_texture_format_nodepth(self.format),
|
||||
aspects,
|
||||
rtv_dsv_format: auxil::dxgi::conv::map_texture_format(self.format),
|
||||
srv_uav_format: auxil::dxgi::conv::map_texture_format_for_srv_uav(self.format, aspects),
|
||||
multisampled: texture.sample_count > 1,
|
||||
mip_level_base: self.range.base_mip_level,
|
||||
mip_level_count: self.range.mip_level_count.unwrap_or(!0),
|
||||
@@ -31,9 +35,9 @@ impl crate::TextureViewDescriptor<'_> {
|
||||
}
|
||||
|
||||
impl ViewDescriptor {
|
||||
pub(crate) unsafe fn to_srv(&self) -> d3d12::D3D12_SHADER_RESOURCE_VIEW_DESC {
|
||||
pub(crate) unsafe fn to_srv(&self) -> Option<d3d12::D3D12_SHADER_RESOURCE_VIEW_DESC> {
|
||||
let mut desc = d3d12::D3D12_SHADER_RESOURCE_VIEW_DESC {
|
||||
Format: self.format_nodepth,
|
||||
Format: self.srv_uav_format?,
|
||||
ViewDimension: 0,
|
||||
Shader4ComponentMapping: D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING,
|
||||
u: unsafe { mem::zeroed() },
|
||||
@@ -142,12 +146,12 @@ impl ViewDescriptor {
|
||||
}
|
||||
}
|
||||
|
||||
desc
|
||||
Some(desc)
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn to_uav(&self) -> d3d12::D3D12_UNORDERED_ACCESS_VIEW_DESC {
|
||||
pub(crate) unsafe fn to_uav(&self) -> Option<d3d12::D3D12_UNORDERED_ACCESS_VIEW_DESC> {
|
||||
let mut desc = d3d12::D3D12_UNORDERED_ACCESS_VIEW_DESC {
|
||||
Format: self.format_nodepth,
|
||||
Format: self.srv_uav_format?,
|
||||
ViewDimension: 0,
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
@@ -205,12 +209,12 @@ impl ViewDescriptor {
|
||||
}
|
||||
}
|
||||
|
||||
desc
|
||||
Some(desc)
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn to_rtv(&self) -> d3d12::D3D12_RENDER_TARGET_VIEW_DESC {
|
||||
let mut desc = d3d12::D3D12_RENDER_TARGET_VIEW_DESC {
|
||||
Format: self.format,
|
||||
Format: self.rtv_dsv_format,
|
||||
ViewDimension: 0,
|
||||
u: unsafe { mem::zeroed() },
|
||||
};
|
||||
@@ -290,20 +294,19 @@ impl ViewDescriptor {
|
||||
desc
|
||||
}
|
||||
|
||||
pub(crate) unsafe fn to_dsv(
|
||||
&self,
|
||||
ro_aspects: crate::FormatAspects,
|
||||
) -> d3d12::D3D12_DEPTH_STENCIL_VIEW_DESC {
|
||||
pub(crate) unsafe fn to_dsv(&self, read_only: bool) -> d3d12::D3D12_DEPTH_STENCIL_VIEW_DESC {
|
||||
let mut desc = d3d12::D3D12_DEPTH_STENCIL_VIEW_DESC {
|
||||
Format: self.format,
|
||||
Format: self.rtv_dsv_format,
|
||||
ViewDimension: 0,
|
||||
Flags: {
|
||||
let mut flags = d3d12::D3D12_DSV_FLAG_NONE;
|
||||
if ro_aspects.contains(crate::FormatAspects::DEPTH) {
|
||||
flags |= d3d12::D3D12_DSV_FLAG_READ_ONLY_DEPTH;
|
||||
}
|
||||
if ro_aspects.contains(crate::FormatAspects::STENCIL) {
|
||||
flags |= d3d12::D3D12_DSV_FLAG_READ_ONLY_STENCIL;
|
||||
if read_only {
|
||||
if self.aspects.contains(crate::FormatAspects::DEPTH) {
|
||||
flags |= d3d12::D3D12_DSV_FLAG_READ_ONLY_DEPTH;
|
||||
}
|
||||
if self.aspects.contains(crate::FormatAspects::STENCIL) {
|
||||
flags |= d3d12::D3D12_DSV_FLAG_READ_ONLY_STENCIL;
|
||||
}
|
||||
}
|
||||
flags
|
||||
},
|
||||
|
||||
@@ -558,15 +558,13 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
{
|
||||
if !cat.ops.contains(crate::AttachmentOps::LOAD) {
|
||||
let c = &cat.clear_value;
|
||||
self.cmd_buffer
|
||||
.commands
|
||||
.push(match cat.target.view.sample_type {
|
||||
self.cmd_buffer.commands.push(
|
||||
match cat.target.view.format.sample_type(None).unwrap() {
|
||||
wgt::TextureSampleType::Float { .. } => C::ClearColorF {
|
||||
draw_buffer: i as u32,
|
||||
color: [c.r as f32, c.g as f32, c.b as f32, c.a as f32],
|
||||
is_srgb: cat.target.view.format.describe().srgb,
|
||||
is_srgb: cat.target.view.format.is_srgb(),
|
||||
},
|
||||
wgt::TextureSampleType::Depth => unreachable!(),
|
||||
wgt::TextureSampleType::Uint => C::ClearColorU(
|
||||
i as u32,
|
||||
[c.r as u32, c.g as u32, c.b as u32, c.a as u32],
|
||||
@@ -575,7 +573,9 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
i as u32,
|
||||
[c.r as i32, c.g as i32, c.b as i32, c.a as i32],
|
||||
),
|
||||
});
|
||||
wgt::TextureSampleType::Depth => unreachable!(),
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
if let Some(ref dsat) = desc.depth_stencil_attachment {
|
||||
@@ -681,13 +681,18 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
dirty_samplers |= 1 << slot;
|
||||
self.state.samplers[slot as usize] = Some(sampler);
|
||||
}
|
||||
super::RawBinding::Texture { raw, target } => {
|
||||
super::RawBinding::Texture {
|
||||
raw,
|
||||
target,
|
||||
aspects,
|
||||
} => {
|
||||
dirty_textures |= 1 << slot;
|
||||
self.state.texture_slots[slot as usize].tex_target = target;
|
||||
self.cmd_buffer.commands.push(C::BindTexture {
|
||||
slot,
|
||||
texture: raw,
|
||||
target,
|
||||
aspects,
|
||||
});
|
||||
}
|
||||
super::RawBinding::Image(ref binding) => {
|
||||
|
||||
@@ -58,7 +58,7 @@ impl super::AdapterShared {
|
||||
Tf::Rgba32Float => (glow::RGBA32F, glow::RGBA, glow::FLOAT),
|
||||
Tf::Stencil8 => (
|
||||
glow::STENCIL_INDEX8,
|
||||
glow::STENCIL_COMPONENTS,
|
||||
glow::STENCIL_INDEX,
|
||||
glow::UNSIGNED_BYTE,
|
||||
),
|
||||
Tf::Depth16Unorm => (
|
||||
@@ -67,18 +67,20 @@ impl super::AdapterShared {
|
||||
glow::UNSIGNED_SHORT,
|
||||
),
|
||||
Tf::Depth32Float => (glow::DEPTH_COMPONENT32F, glow::DEPTH_COMPONENT, glow::FLOAT),
|
||||
Tf::Depth32FloatStencil8 => {
|
||||
(glow::DEPTH32F_STENCIL8, glow::DEPTH_COMPONENT, glow::FLOAT)
|
||||
}
|
||||
Tf::Depth32FloatStencil8 => (
|
||||
glow::DEPTH32F_STENCIL8,
|
||||
glow::DEPTH_STENCIL,
|
||||
glow::FLOAT_32_UNSIGNED_INT_24_8_REV,
|
||||
),
|
||||
Tf::Depth24Plus => (
|
||||
glow::DEPTH_COMPONENT24,
|
||||
glow::DEPTH_COMPONENT,
|
||||
glow::UNSIGNED_NORMALIZED,
|
||||
glow::UNSIGNED_INT,
|
||||
),
|
||||
Tf::Depth24PlusStencil8 => (
|
||||
glow::DEPTH24_STENCIL8,
|
||||
glow::DEPTH_COMPONENT,
|
||||
glow::UNSIGNED_INT,
|
||||
glow::DEPTH_STENCIL,
|
||||
glow::UNSIGNED_INT_24_8,
|
||||
),
|
||||
Tf::Rgb9e5Ufloat => (glow::RGB9_E5, glow::RGB, glow::UNSIGNED_INT_5_9_9_9_REV),
|
||||
Tf::Bc1RgbaUnorm => (glow::COMPRESSED_RGBA_S3TC_DXT1_EXT, glow::RGBA, 0),
|
||||
|
||||
+13
-10
@@ -706,10 +706,12 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
unsafe { gl.bind_texture(target, Some(raw)) };
|
||||
//Note: this has to be done before defining the storage!
|
||||
match desc.format.describe().sample_type {
|
||||
wgt::TextureSampleType::Float { filterable: false }
|
||||
| wgt::TextureSampleType::Uint
|
||||
| wgt::TextureSampleType::Sint => {
|
||||
match desc.format.sample_type(None) {
|
||||
Some(
|
||||
wgt::TextureSampleType::Float { filterable: false }
|
||||
| wgt::TextureSampleType::Uint
|
||||
| wgt::TextureSampleType::Sint,
|
||||
) => {
|
||||
// reset default filtering mode
|
||||
unsafe {
|
||||
gl.tex_parameter_i32(target, glow::TEXTURE_MIN_FILTER, glow::NEAREST as i32)
|
||||
@@ -718,8 +720,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
gl.tex_parameter_i32(target, glow::TEXTURE_MAG_FILTER, glow::NEAREST as i32)
|
||||
};
|
||||
}
|
||||
wgt::TextureSampleType::Float { filterable: true }
|
||||
| wgt::TextureSampleType::Depth => {}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
if is_3d {
|
||||
@@ -808,9 +809,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
Ok(super::TextureView {
|
||||
//TODO: use `conv::map_view_dimension(desc.dimension)`?
|
||||
inner: texture.inner.clone(),
|
||||
sample_type: texture.format.describe().sample_type,
|
||||
aspects: crate::FormatAspects::from(texture.format)
|
||||
& crate::FormatAspects::from(desc.range.aspect),
|
||||
aspects: crate::FormatAspects::new(texture.format, desc.range.aspect),
|
||||
mip_levels: desc.range.mip_range(texture.mip_level_count),
|
||||
array_layers: desc.range.layer_range(texture.array_layer_count),
|
||||
format: texture.format,
|
||||
@@ -1040,7 +1039,11 @@ impl crate::Device<super::Api> for super::Device {
|
||||
"This is an implementation problem of wgpu-hal/gles backend.")
|
||||
}
|
||||
let (raw, target) = view.inner.as_native();
|
||||
super::RawBinding::Texture { raw, target }
|
||||
super::RawBinding::Texture {
|
||||
raw,
|
||||
target,
|
||||
aspects: view.aspects,
|
||||
}
|
||||
}
|
||||
wgt::BindingType::StorageTexture {
|
||||
access,
|
||||
|
||||
@@ -339,7 +339,6 @@ impl Texture {
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct TextureView {
|
||||
inner: TextureInner,
|
||||
sample_type: wgt::TextureSampleType,
|
||||
aspects: crate::FormatAspects,
|
||||
mip_levels: Range<u32>,
|
||||
array_layers: Range<u32>,
|
||||
@@ -395,6 +394,7 @@ enum RawBinding {
|
||||
Texture {
|
||||
raw: glow::Texture,
|
||||
target: BindTarget,
|
||||
aspects: crate::FormatAspects,
|
||||
//TODO: mip levels, array layers
|
||||
},
|
||||
Image(ImageBinding),
|
||||
@@ -804,6 +804,7 @@ enum Command {
|
||||
slot: u32,
|
||||
texture: glow::Texture,
|
||||
target: BindTarget,
|
||||
aspects: crate::FormatAspects,
|
||||
},
|
||||
BindImage {
|
||||
slot: u32,
|
||||
|
||||
+107
-62
@@ -591,22 +591,23 @@ impl super::Queue {
|
||||
dst_format,
|
||||
ref copy,
|
||||
} => {
|
||||
let format_info = dst_format.describe();
|
||||
let (block_width, block_height) = dst_format.block_dimensions();
|
||||
let block_size = dst_format.block_size(None).unwrap();
|
||||
let format_desc = self.shared.describe_texture_format(dst_format);
|
||||
let row_texels = copy.buffer_layout.bytes_per_row.map_or(0, |bpr| {
|
||||
format_info.block_dimensions.0 as u32 * bpr.get()
|
||||
/ format_info.block_size as u32
|
||||
});
|
||||
let row_texels = copy
|
||||
.buffer_layout
|
||||
.bytes_per_row
|
||||
.map_or(0, |bpr| block_width * bpr.get() / block_size);
|
||||
let column_texels = copy
|
||||
.buffer_layout
|
||||
.rows_per_image
|
||||
.map_or(0, |rpi| format_info.block_dimensions.1 as u32 * rpi.get());
|
||||
.map_or(0, |rpi| block_height * rpi.get());
|
||||
|
||||
unsafe { gl.bind_texture(dst_target, Some(dst)) };
|
||||
unsafe { gl.pixel_store_i32(glow::UNPACK_ROW_LENGTH, row_texels as i32) };
|
||||
unsafe { gl.pixel_store_i32(glow::UNPACK_IMAGE_HEIGHT, column_texels as i32) };
|
||||
let mut unbind_unpack_buffer = false;
|
||||
if !format_info.is_compressed() {
|
||||
if !dst_format.is_compressed() {
|
||||
let buffer_data;
|
||||
let unpack_data = match src.raw {
|
||||
Some(buffer) => {
|
||||
@@ -710,12 +711,9 @@ impl super::Queue {
|
||||
let bytes_per_row = copy
|
||||
.buffer_layout
|
||||
.bytes_per_row
|
||||
.map_or(copy.size.width * format_info.block_size as u32, |bpr| {
|
||||
bpr.get()
|
||||
});
|
||||
let block_height = format_info.block_dimensions.1 as u32;
|
||||
let minimum_rows_per_image = (copy.size.height + block_height - 1)
|
||||
/ format_info.block_dimensions.1 as u32;
|
||||
.map_or(copy.size.width * block_size, |bpr| bpr.get());
|
||||
let minimum_rows_per_image =
|
||||
(copy.size.height + block_height - 1) / block_height;
|
||||
let rows_per_image = copy
|
||||
.buffer_layout
|
||||
.rows_per_image
|
||||
@@ -806,8 +804,8 @@ impl super::Queue {
|
||||
dst_target: _,
|
||||
ref copy,
|
||||
} => {
|
||||
let format_info = src_format.describe();
|
||||
if format_info.is_compressed() {
|
||||
let block_size = src_format.block_size(None).unwrap();
|
||||
if src_format.is_compressed() {
|
||||
log::error!("Not implemented yet: compressed texture copy to buffer");
|
||||
return;
|
||||
}
|
||||
@@ -821,59 +819,85 @@ impl super::Queue {
|
||||
let row_texels = copy
|
||||
.buffer_layout
|
||||
.bytes_per_row
|
||||
.map_or(copy.size.width, |bpr| {
|
||||
bpr.get() / format_info.block_size as u32
|
||||
});
|
||||
.map_or(copy.size.width, |bpr| bpr.get() / block_size);
|
||||
let column_texels = copy
|
||||
.buffer_layout
|
||||
.rows_per_image
|
||||
.map_or(copy.size.height, |bpr| bpr.get());
|
||||
|
||||
unsafe { gl.bind_framebuffer(glow::READ_FRAMEBUFFER, Some(self.copy_fbo)) };
|
||||
//TODO: handle cubemap copies
|
||||
if is_layered_target(src_target) {
|
||||
//TODO: handle GLES without framebuffer_texture_3d
|
||||
|
||||
let read_pixels = |offset| {
|
||||
let mut buffer_data;
|
||||
let unpack_data = match dst.raw {
|
||||
Some(buffer) => {
|
||||
unsafe { gl.pixel_store_i32(glow::PACK_ROW_LENGTH, row_texels as i32) };
|
||||
unsafe { gl.bind_buffer(glow::PIXEL_PACK_BUFFER, Some(buffer)) };
|
||||
glow::PixelPackData::BufferOffset(offset as u32)
|
||||
}
|
||||
None => {
|
||||
buffer_data = dst.data.as_ref().unwrap().lock().unwrap();
|
||||
let dst_data = &mut buffer_data.as_mut_slice()[offset as usize..];
|
||||
glow::PixelPackData::Slice(dst_data)
|
||||
}
|
||||
};
|
||||
unsafe {
|
||||
gl.framebuffer_texture_layer(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
Some(src),
|
||||
copy.texture_base.mip_level as i32,
|
||||
copy.texture_base.array_layer as i32,
|
||||
)
|
||||
};
|
||||
} else {
|
||||
unsafe {
|
||||
gl.framebuffer_texture_2d(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
src_target,
|
||||
Some(src),
|
||||
copy.texture_base.mip_level as i32,
|
||||
gl.read_pixels(
|
||||
copy.texture_base.origin.x as i32,
|
||||
copy.texture_base.origin.y as i32,
|
||||
copy.size.width as i32,
|
||||
copy.size.height as i32,
|
||||
format_desc.external,
|
||||
format_desc.data_type,
|
||||
unpack_data,
|
||||
)
|
||||
};
|
||||
};
|
||||
|
||||
match src_target {
|
||||
glow::TEXTURE_2D => {
|
||||
unsafe {
|
||||
gl.framebuffer_texture_2d(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
src_target,
|
||||
Some(src),
|
||||
copy.texture_base.mip_level as i32,
|
||||
)
|
||||
};
|
||||
read_pixels(copy.buffer_layout.offset);
|
||||
}
|
||||
glow::TEXTURE_2D_ARRAY => {
|
||||
unsafe {
|
||||
gl.framebuffer_texture_layer(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
Some(src),
|
||||
copy.texture_base.mip_level as i32,
|
||||
copy.texture_base.array_layer as i32,
|
||||
)
|
||||
};
|
||||
read_pixels(copy.buffer_layout.offset);
|
||||
}
|
||||
glow::TEXTURE_3D => {
|
||||
for z in copy.texture_base.origin.z..copy.size.depth {
|
||||
unsafe {
|
||||
gl.framebuffer_texture_layer(
|
||||
glow::READ_FRAMEBUFFER,
|
||||
glow::COLOR_ATTACHMENT0,
|
||||
Some(src),
|
||||
copy.texture_base.mip_level as i32,
|
||||
z as i32,
|
||||
)
|
||||
};
|
||||
let offset = copy.buffer_layout.offset
|
||||
+ (z * block_size * row_texels * column_texels) as u64;
|
||||
read_pixels(offset);
|
||||
}
|
||||
}
|
||||
glow::TEXTURE_CUBE_MAP | glow::TEXTURE_CUBE_MAP_ARRAY => unimplemented!(),
|
||||
_ => unreachable!(),
|
||||
}
|
||||
let mut buffer_data;
|
||||
let unpack_data = match dst.raw {
|
||||
Some(buffer) => {
|
||||
unsafe { gl.pixel_store_i32(glow::PACK_ROW_LENGTH, row_texels as i32) };
|
||||
unsafe { gl.bind_buffer(glow::PIXEL_PACK_BUFFER, Some(buffer)) };
|
||||
glow::PixelPackData::BufferOffset(copy.buffer_layout.offset as u32)
|
||||
}
|
||||
None => {
|
||||
buffer_data = dst.data.as_ref().unwrap().lock().unwrap();
|
||||
let dst_data =
|
||||
&mut buffer_data.as_mut_slice()[copy.buffer_layout.offset as usize..];
|
||||
glow::PixelPackData::Slice(dst_data)
|
||||
}
|
||||
};
|
||||
unsafe {
|
||||
gl.read_pixels(
|
||||
copy.texture_base.origin.x as i32,
|
||||
copy.texture_base.origin.y as i32,
|
||||
copy.size.width as i32,
|
||||
copy.size.height as i32,
|
||||
format_desc.external,
|
||||
format_desc.data_type,
|
||||
unpack_data,
|
||||
)
|
||||
};
|
||||
}
|
||||
C::SetIndexBuffer(buffer) => {
|
||||
unsafe { gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(buffer)) };
|
||||
@@ -1354,9 +1378,30 @@ impl super::Queue {
|
||||
slot,
|
||||
texture,
|
||||
target,
|
||||
aspects,
|
||||
} => {
|
||||
unsafe { gl.active_texture(glow::TEXTURE0 + slot) };
|
||||
unsafe { gl.bind_texture(target, Some(texture)) };
|
||||
|
||||
let version = gl.version();
|
||||
let is_min_es_3_1 = version.is_embedded && (version.major, version.minor) >= (3, 1);
|
||||
let is_min_4_3 = !version.is_embedded && (version.major, version.minor) >= (4, 3);
|
||||
if is_min_es_3_1 || is_min_4_3 {
|
||||
let mode = match aspects {
|
||||
crate::FormatAspects::DEPTH => Some(glow::DEPTH_COMPONENT),
|
||||
crate::FormatAspects::STENCIL => Some(glow::STENCIL_INDEX),
|
||||
_ => None,
|
||||
};
|
||||
if let Some(mode) = mode {
|
||||
unsafe {
|
||||
gl.tex_parameter_i32(
|
||||
target,
|
||||
glow::DEPTH_STENCIL_TEXTURE_MODE,
|
||||
mode as _,
|
||||
)
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
C::BindImage { slot, ref binding } => {
|
||||
unsafe {
|
||||
|
||||
@@ -191,7 +191,7 @@ impl Surface {
|
||||
"need to configure surface before presenting",
|
||||
))?;
|
||||
|
||||
if swapchain.format.describe().srgb {
|
||||
if swapchain.format.is_srgb() {
|
||||
// Important to set the viewport since we don't know in what state the user left it.
|
||||
unsafe {
|
||||
gl.viewport(
|
||||
@@ -277,7 +277,7 @@ impl crate::Surface<super::Api> for Surface {
|
||||
unsafe { gl.delete_framebuffer(swapchain.framebuffer) };
|
||||
}
|
||||
|
||||
if self.srgb_present_program.is_none() && config.format.describe().srgb {
|
||||
if self.srgb_present_program.is_none() && config.format.is_srgb() {
|
||||
self.srgb_present_program = Some(unsafe { Self::create_srgb_present_program(gl) });
|
||||
}
|
||||
|
||||
|
||||
+21
-5
@@ -644,12 +644,27 @@ bitflags!(
|
||||
}
|
||||
);
|
||||
|
||||
impl From<wgt::TextureAspect> for FormatAspects {
|
||||
fn from(aspect: wgt::TextureAspect) -> Self {
|
||||
match aspect {
|
||||
impl FormatAspects {
|
||||
pub fn new(format: wgt::TextureFormat, aspect: wgt::TextureAspect) -> Self {
|
||||
let aspect_mask = match aspect {
|
||||
wgt::TextureAspect::All => Self::all(),
|
||||
wgt::TextureAspect::DepthOnly => Self::DEPTH,
|
||||
wgt::TextureAspect::StencilOnly => Self::STENCIL,
|
||||
};
|
||||
Self::from(format) & aspect_mask
|
||||
}
|
||||
|
||||
/// Returns `true` if only one flag is set
|
||||
pub fn is_one(&self) -> bool {
|
||||
self.bits().count_ones() == 1
|
||||
}
|
||||
|
||||
pub fn map(&self) -> wgt::TextureAspect {
|
||||
match *self {
|
||||
Self::COLOR => wgt::TextureAspect::All,
|
||||
Self::DEPTH => wgt::TextureAspect::DepthOnly,
|
||||
Self::STENCIL => wgt::TextureAspect::StencilOnly,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -658,8 +673,9 @@ impl From<wgt::TextureFormat> for FormatAspects {
|
||||
fn from(format: wgt::TextureFormat) -> Self {
|
||||
match format {
|
||||
wgt::TextureFormat::Stencil8 => Self::STENCIL,
|
||||
wgt::TextureFormat::Depth16Unorm => Self::DEPTH,
|
||||
wgt::TextureFormat::Depth32Float | wgt::TextureFormat::Depth24Plus => Self::DEPTH,
|
||||
wgt::TextureFormat::Depth16Unorm
|
||||
| wgt::TextureFormat::Depth32Float
|
||||
| wgt::TextureFormat::Depth24Plus => Self::DEPTH,
|
||||
wgt::TextureFormat::Depth32FloatStencil8 | wgt::TextureFormat::Depth24PlusStencil8 => {
|
||||
Self::DEPTH | Self::STENCIL
|
||||
}
|
||||
|
||||
@@ -1003,6 +1003,30 @@ impl super::PrivateCapabilities {
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
pub fn map_view_format(
|
||||
&self,
|
||||
format: wgt::TextureFormat,
|
||||
aspects: crate::FormatAspects,
|
||||
) -> mtl::MTLPixelFormat {
|
||||
use crate::FormatAspects as Fa;
|
||||
use mtl::MTLPixelFormat::*;
|
||||
use wgt::TextureFormat as Tf;
|
||||
match (format, aspects) {
|
||||
// map combined depth-stencil format to their stencil-only format
|
||||
// see https://developer.apple.com/library/archive/documentation/Miscellaneous/Conceptual/MetalProgrammingGuide/WhatsNewiniOS10tvOS10andOSX1012/WhatsNewiniOS10tvOS10andOSX1012.html#//apple_ref/doc/uid/TP40014221-CH14-DontLinkElementID_77
|
||||
(Tf::Depth24PlusStencil8, Fa::STENCIL) => {
|
||||
if self.format_depth24_stencil8 {
|
||||
X24_Stencil8
|
||||
} else {
|
||||
X32_Stencil8
|
||||
}
|
||||
}
|
||||
(Tf::Depth32FloatStencil8, Fa::STENCIL) => X32_Stencil8,
|
||||
|
||||
_ => self.map_format(format),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl super::PrivateDisabilities {
|
||||
|
||||
@@ -247,7 +247,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
copy.texture_base.array_layer as u64,
|
||||
copy.texture_base.mip_level as u64,
|
||||
dst_origin,
|
||||
mtl::MTLBlitOption::empty(),
|
||||
conv::get_blit_option(dst.format, copy.texture_base.aspect),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -287,7 +287,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
copy.buffer_layout.offset,
|
||||
bytes_per_row,
|
||||
bytes_per_image,
|
||||
mtl::MTLBlitOption::empty(),
|
||||
conv::get_blit_option(src.format, copy.texture_base.aspect),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
pub fn map_texture_usage(usage: crate::TextureUses) -> mtl::MTLTextureUsage {
|
||||
pub fn map_texture_usage(
|
||||
format: wgt::TextureFormat,
|
||||
usage: crate::TextureUses,
|
||||
) -> mtl::MTLTextureUsage {
|
||||
use crate::TextureUses as Tu;
|
||||
|
||||
let mut mtl_usage = mtl::MTLTextureUsage::Unknown;
|
||||
@@ -17,6 +20,12 @@ pub fn map_texture_usage(usage: crate::TextureUses) -> mtl::MTLTextureUsage {
|
||||
mtl::MTLTextureUsage::ShaderWrite,
|
||||
usage.intersects(Tu::STORAGE_READ_WRITE),
|
||||
);
|
||||
// needed for combined depth/stencil formats since we might
|
||||
// create a stencil-only view from them
|
||||
mtl_usage.set(
|
||||
mtl::MTLTextureUsage::PixelFormatView,
|
||||
format.is_combined_depth_stencil_format(),
|
||||
);
|
||||
|
||||
mtl_usage
|
||||
}
|
||||
@@ -298,3 +307,18 @@ pub fn map_clear_color(color: &wgt::Color) -> mtl::MTLClearColor {
|
||||
alpha: color.a,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_blit_option(
|
||||
format: wgt::TextureFormat,
|
||||
aspect: crate::FormatAspects,
|
||||
) -> mtl::MTLBlitOption {
|
||||
if format.is_combined_depth_stencil_format() {
|
||||
match aspect {
|
||||
crate::FormatAspects::DEPTH => mtl::MTLBlitOption::DepthFromDepthStencil,
|
||||
crate::FormatAspects::STENCIL => mtl::MTLBlitOption::StencilFromDepthStencil,
|
||||
_ => unreachable!(),
|
||||
}
|
||||
} else {
|
||||
mtl::MTLBlitOption::None
|
||||
}
|
||||
}
|
||||
@@ -203,7 +203,7 @@ impl super::Device {
|
||||
|
||||
pub unsafe fn texture_from_raw(
|
||||
raw: mtl::Texture,
|
||||
raw_format: mtl::MTLPixelFormat,
|
||||
format: wgt::TextureFormat,
|
||||
raw_type: mtl::MTLTextureType,
|
||||
array_layers: u32,
|
||||
mip_levels: u32,
|
||||
@@ -211,7 +211,7 @@ impl super::Device {
|
||||
) -> super::Texture {
|
||||
super::Texture {
|
||||
raw,
|
||||
raw_format,
|
||||
format,
|
||||
raw_type,
|
||||
array_layers,
|
||||
mip_levels,
|
||||
@@ -317,7 +317,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
descriptor.set_height(desc.size.height as u64);
|
||||
descriptor.set_mipmap_level_count(desc.mip_level_count as u64);
|
||||
descriptor.set_pixel_format(mtl_format);
|
||||
descriptor.set_usage(conv::map_texture_usage(desc.usage));
|
||||
descriptor.set_usage(conv::map_texture_usage(desc.format, desc.usage));
|
||||
descriptor.set_storage_mode(mtl::MTLStorageMode::Private);
|
||||
|
||||
let raw = self.shared.device.lock().new_texture(&descriptor);
|
||||
@@ -327,7 +327,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
|
||||
Ok(super::Texture {
|
||||
raw,
|
||||
raw_format: mtl_format,
|
||||
format: desc.format,
|
||||
raw_type: mtl_type,
|
||||
mip_levels: desc.mip_level_count,
|
||||
array_layers: desc.array_layer_count(),
|
||||
@@ -343,19 +343,24 @@ impl crate::Device<super::Api> for super::Device {
|
||||
texture: &super::Texture,
|
||||
desc: &crate::TextureViewDescriptor,
|
||||
) -> DeviceResult<super::TextureView> {
|
||||
let raw_format = self.shared.private_caps.map_format(desc.format);
|
||||
|
||||
let raw_type = if texture.raw_type == mtl::MTLTextureType::D2Multisample {
|
||||
texture.raw_type
|
||||
} else {
|
||||
conv::map_texture_view_dimension(desc.dimension)
|
||||
};
|
||||
|
||||
let format_equal = raw_format == texture.raw_format;
|
||||
let aspects = crate::FormatAspects::new(desc.format, desc.range.aspect);
|
||||
|
||||
let raw_format = self
|
||||
.shared
|
||||
.private_caps
|
||||
.map_view_format(desc.format, aspects);
|
||||
|
||||
let format_equal = raw_format == self.shared.private_caps.map_format(texture.format);
|
||||
let type_equal = raw_type == texture.raw_type;
|
||||
let range_full_resource = desc
|
||||
.range
|
||||
.is_full_resource(texture.mip_levels, texture.array_layers);
|
||||
let range_full_resource =
|
||||
desc.range
|
||||
.is_full_resource(desc.format, texture.mip_levels, texture.array_layers);
|
||||
|
||||
let raw = if format_equal && type_equal && range_full_resource {
|
||||
// Some images are marked as framebuffer-only, and we can't create aliases of them.
|
||||
@@ -391,7 +396,6 @@ impl crate::Device<super::Api> for super::Device {
|
||||
})
|
||||
};
|
||||
|
||||
let aspects = crate::FormatAspects::from(desc.format);
|
||||
Ok(super::TextureView { raw, aspects })
|
||||
}
|
||||
unsafe fn destroy_texture_view(&self, _view: super::TextureView) {}
|
||||
|
||||
@@ -301,7 +301,7 @@ pub struct Device {
|
||||
pub struct Surface {
|
||||
view: Option<NonNull<objc::runtime::Object>>,
|
||||
render_layer: Mutex<mtl::MetalLayer>,
|
||||
raw_swapchain_format: mtl::MTLPixelFormat,
|
||||
swapchain_format: Option<wgt::TextureFormat>,
|
||||
extent: wgt::Extent3d,
|
||||
main_thread_id: thread::ThreadId,
|
||||
// Useful for UI-intensive applications that are sensitive to
|
||||
@@ -425,7 +425,7 @@ impl Buffer {
|
||||
#[derive(Debug)]
|
||||
pub struct Texture {
|
||||
raw: mtl::Texture,
|
||||
raw_format: mtl::MTLPixelFormat,
|
||||
format: wgt::TextureFormat,
|
||||
raw_type: mtl::MTLTextureType,
|
||||
array_layers: u32,
|
||||
mip_levels: u32,
|
||||
|
||||
@@ -63,7 +63,7 @@ impl super::Surface {
|
||||
Self {
|
||||
view,
|
||||
render_layer: Mutex::new(layer),
|
||||
raw_swapchain_format: mtl::MTLPixelFormat::Invalid,
|
||||
swapchain_format: None,
|
||||
extent: wgt::Extent3d::default(),
|
||||
main_thread_id: thread::current().id(),
|
||||
present_with_transaction: false,
|
||||
@@ -178,7 +178,7 @@ impl crate::Surface<super::Api> for super::Surface {
|
||||
log::info!("build swapchain {:?}", config);
|
||||
|
||||
let caps = &device.shared.private_caps;
|
||||
self.raw_swapchain_format = caps.map_format(config.format);
|
||||
self.swapchain_format = Some(config.format);
|
||||
self.extent = config.extent;
|
||||
|
||||
let render_layer = self.render_layer.lock();
|
||||
@@ -210,12 +210,12 @@ impl crate::Surface<super::Api> for super::Surface {
|
||||
}
|
||||
}
|
||||
render_layer.set_device(&device_raw);
|
||||
render_layer.set_pixel_format(self.raw_swapchain_format);
|
||||
render_layer.set_pixel_format(caps.map_format(config.format));
|
||||
render_layer.set_framebuffer_only(framebuffer_only);
|
||||
render_layer.set_presents_with_transaction(self.present_with_transaction);
|
||||
// opt-in to Metal EDR
|
||||
// EDR potentially more power used in display and more bandwidth, memory footprint.
|
||||
let wants_edr = self.raw_swapchain_format == mtl::MTLPixelFormat::RGBA16Float;
|
||||
let wants_edr = config.format == wgt::TextureFormat::Rgba16Float;
|
||||
if wants_edr != render_layer.wants_extended_dynamic_range_content() {
|
||||
render_layer.set_wants_extended_dynamic_range_content(wants_edr);
|
||||
}
|
||||
@@ -234,7 +234,7 @@ impl crate::Surface<super::Api> for super::Surface {
|
||||
}
|
||||
|
||||
unsafe fn unconfigure(&mut self, _device: &super::Device) {
|
||||
self.raw_swapchain_format = mtl::MTLPixelFormat::Invalid;
|
||||
self.swapchain_format = None;
|
||||
}
|
||||
|
||||
unsafe fn acquire_texture(
|
||||
@@ -254,7 +254,7 @@ impl crate::Surface<super::Api> for super::Surface {
|
||||
let suf_texture = super::SurfaceTexture {
|
||||
texture: super::Texture {
|
||||
raw: texture,
|
||||
raw_format: self.raw_swapchain_format,
|
||||
format: self.swapchain_format.unwrap(),
|
||||
raw_type: mtl::MTLTextureType::D2,
|
||||
array_layers: 1,
|
||||
mip_levels: 1,
|
||||
|
||||
@@ -1487,7 +1487,7 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
features.intersects(vk::FormatFeatureFlags::TRANSFER_DST),
|
||||
);
|
||||
// Vulkan is very permissive about MSAA
|
||||
flags.set(Tfc::MULTISAMPLE_RESOLVE, !format.describe().is_compressed());
|
||||
flags.set(Tfc::MULTISAMPLE_RESOLVE, !format.is_compressed());
|
||||
|
||||
// get the supported sample counts
|
||||
let format_aspect = crate::FormatAspects::from(format);
|
||||
@@ -1502,7 +1502,7 @@ impl crate::Adapter<super::Api> for super::Adapter {
|
||||
.framebuffer_stencil_sample_counts
|
||||
.min(limits.sampled_image_stencil_sample_counts)
|
||||
} else {
|
||||
match format.describe().sample_type {
|
||||
match format.sample_type(None).unwrap() {
|
||||
wgt::TextureSampleType::Float { filterable: _ } => limits
|
||||
.framebuffer_color_sample_counts
|
||||
.min(limits.sampled_image_color_sample_counts),
|
||||
|
||||
@@ -13,22 +13,24 @@ impl super::Texture {
|
||||
where
|
||||
T: Iterator<Item = crate::BufferTextureCopy>,
|
||||
{
|
||||
let aspects = self.aspects;
|
||||
let fi = self.format_info;
|
||||
let (block_width, block_height) = self.format.block_dimensions();
|
||||
let format = self.format;
|
||||
let copy_size = self.copy_size;
|
||||
regions.map(move |r| {
|
||||
let extent = r.texture_base.max_copy_size(©_size).min(&r.size);
|
||||
let (image_subresource, image_offset) =
|
||||
conv::map_subresource_layers(&r.texture_base, aspects);
|
||||
let (image_subresource, image_offset) = conv::map_subresource_layers(&r.texture_base);
|
||||
vk::BufferImageCopy {
|
||||
buffer_offset: r.buffer_layout.offset,
|
||||
buffer_row_length: r.buffer_layout.bytes_per_row.map_or(0, |bpr| {
|
||||
fi.block_dimensions.0 as u32 * (bpr.get() / fi.block_size as u32)
|
||||
let block_size = format
|
||||
.block_size(Some(r.texture_base.aspect.map()))
|
||||
.unwrap();
|
||||
block_width * (bpr.get() / block_size)
|
||||
}),
|
||||
buffer_image_height: r
|
||||
.buffer_layout
|
||||
.rows_per_image
|
||||
.map_or(0, |rpi| rpi.get() * fi.block_dimensions.1 as u32),
|
||||
.map_or(0, |rpi| rpi.get() * block_height),
|
||||
image_subresource,
|
||||
image_offset,
|
||||
image_extent: conv::map_copy_extent(&extent),
|
||||
@@ -155,12 +157,12 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
vk_barriers.clear();
|
||||
|
||||
for bar in barriers {
|
||||
let range = conv::map_subresource_range(&bar.range, bar.texture.aspects);
|
||||
let range = conv::map_subresource_range(&bar.range, bar.texture.format);
|
||||
let (src_stage, src_access) = conv::map_texture_usage_to_barrier(bar.usage.start);
|
||||
let src_layout = conv::derive_image_layout(bar.usage.start, bar.texture.aspects);
|
||||
let src_layout = conv::derive_image_layout(bar.usage.start, bar.texture.format);
|
||||
src_stages |= src_stage;
|
||||
let (dst_stage, dst_access) = conv::map_texture_usage_to_barrier(bar.usage.end);
|
||||
let dst_layout = conv::derive_image_layout(bar.usage.end, bar.texture.aspects);
|
||||
let dst_layout = conv::derive_image_layout(bar.usage.end, bar.texture.format);
|
||||
dst_stages |= dst_stage;
|
||||
|
||||
vk_barriers.push(
|
||||
@@ -235,13 +237,11 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
) where
|
||||
T: Iterator<Item = crate::TextureCopy>,
|
||||
{
|
||||
let src_layout = conv::derive_image_layout(src_usage, src.aspects);
|
||||
let src_layout = conv::derive_image_layout(src_usage, src.format);
|
||||
|
||||
let vk_regions_iter = regions.map(|r| {
|
||||
let (src_subresource, src_offset) =
|
||||
conv::map_subresource_layers(&r.src_base, src.aspects);
|
||||
let (dst_subresource, dst_offset) =
|
||||
conv::map_subresource_layers(&r.dst_base, dst.aspects);
|
||||
let (src_subresource, src_offset) = conv::map_subresource_layers(&r.src_base);
|
||||
let (dst_subresource, dst_offset) = conv::map_subresource_layers(&r.dst_base);
|
||||
let extent = r
|
||||
.size
|
||||
.min(&r.src_base.max_copy_size(&src.copy_size))
|
||||
@@ -297,7 +297,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
) where
|
||||
T: Iterator<Item = crate::BufferTextureCopy>,
|
||||
{
|
||||
let src_layout = conv::derive_image_layout(src_usage, src.aspects);
|
||||
let src_layout = conv::derive_image_layout(src_usage, src.format);
|
||||
let vk_regions_iter = src.map_buffer_copies(regions);
|
||||
|
||||
unsafe {
|
||||
@@ -820,7 +820,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
|
||||
#[test]
|
||||
fn check_dst_image_layout() {
|
||||
assert_eq!(
|
||||
conv::derive_image_layout(crate::TextureUses::COPY_DST, crate::FormatAspects::empty()),
|
||||
conv::derive_image_layout(crate::TextureUses::COPY_DST, wgt::TextureFormat::Rgba8Unorm),
|
||||
DST_IMAGE_LAYOUT
|
||||
);
|
||||
}
|
||||
@@ -182,10 +182,9 @@ impl crate::Attachment<'_, super::Api> {
|
||||
ops: crate::AttachmentOps,
|
||||
caps: &super::PrivateCapabilities,
|
||||
) -> super::AttachmentKey {
|
||||
let aspects = self.view.aspects();
|
||||
super::AttachmentKey {
|
||||
format: caps.map_texture_format(self.view.attachment.view_format),
|
||||
layout: derive_image_layout(self.usage, aspects),
|
||||
layout: derive_image_layout(self.usage, self.view.attachment.view_format),
|
||||
ops,
|
||||
}
|
||||
}
|
||||
@@ -199,8 +198,8 @@ impl crate::ColorAttachment<'_, super::Api> {
|
||||
.view
|
||||
.attachment
|
||||
.view_format
|
||||
.describe()
|
||||
.sample_type
|
||||
.sample_type(None)
|
||||
.unwrap()
|
||||
{
|
||||
wgt::TextureSampleType::Float { .. } => vk::ClearColorValue {
|
||||
float32: [cv.r as f32, cv.g as f32, cv.b as f32, cv.a as f32],
|
||||
@@ -218,10 +217,10 @@ impl crate::ColorAttachment<'_, super::Api> {
|
||||
|
||||
pub fn derive_image_layout(
|
||||
usage: crate::TextureUses,
|
||||
aspects: crate::FormatAspects,
|
||||
format: wgt::TextureFormat,
|
||||
) -> vk::ImageLayout {
|
||||
//Note: depth textures are always sampled with RODS layout
|
||||
let is_color = aspects.contains(crate::FormatAspects::COLOR);
|
||||
// Note: depth textures are always sampled with RODS layout
|
||||
let is_color = crate::FormatAspects::from(format).contains(crate::FormatAspects::COLOR);
|
||||
match usage {
|
||||
crate::TextureUses::UNINITIALIZED => vk::ImageLayout::UNDEFINED,
|
||||
crate::TextureUses::COPY_SRC => vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
|
||||
@@ -586,10 +585,10 @@ pub fn map_copy_extent(extent: &crate::CopyExtent) -> vk::Extent3D {
|
||||
|
||||
pub fn map_subresource_range(
|
||||
range: &wgt::ImageSubresourceRange,
|
||||
texture_aspect: crate::FormatAspects,
|
||||
format: wgt::TextureFormat,
|
||||
) -> vk::ImageSubresourceRange {
|
||||
vk::ImageSubresourceRange {
|
||||
aspect_mask: map_aspects(crate::FormatAspects::from(range.aspect) & texture_aspect),
|
||||
aspect_mask: map_aspects(crate::FormatAspects::new(format, range.aspect)),
|
||||
base_mip_level: range.base_mip_level,
|
||||
level_count: range.mip_level_count.unwrap_or(vk::REMAINING_MIP_LEVELS),
|
||||
base_array_layer: range.base_array_layer,
|
||||
@@ -601,7 +600,6 @@ pub fn map_subresource_range(
|
||||
|
||||
pub fn map_subresource_layers(
|
||||
base: &crate::TextureCopyBase,
|
||||
texture_aspect: crate::FormatAspects,
|
||||
) -> (vk::ImageSubresourceLayers, vk::Offset3D) {
|
||||
let offset = vk::Offset3D {
|
||||
x: base.origin.x as i32,
|
||||
@@ -609,7 +607,7 @@ pub fn map_subresource_layers(
|
||||
z: base.origin.z as i32,
|
||||
};
|
||||
let subresource = vk::ImageSubresourceLayers {
|
||||
aspect_mask: map_aspects(base.aspect & texture_aspect),
|
||||
aspect_mask: map_aspects(base.aspect),
|
||||
mip_level: base.mip_level,
|
||||
base_array_layer: base.array_layer,
|
||||
layer_count: 1,
|
||||
|
||||
@@ -673,8 +673,7 @@ impl super::Device {
|
||||
drop_guard,
|
||||
block: None,
|
||||
usage: desc.usage,
|
||||
aspects: crate::FormatAspects::from(desc.format),
|
||||
format_info: desc.format.describe(),
|
||||
format: desc.format,
|
||||
raw_flags: vk::ImageCreateFlags::empty(),
|
||||
copy_size: desc.copy_extent(),
|
||||
view_formats,
|
||||
@@ -1015,8 +1014,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
drop_guard: None,
|
||||
block: Some(block),
|
||||
usage: desc.usage,
|
||||
aspects: crate::FormatAspects::from(desc.format),
|
||||
format_info: desc.format.describe(),
|
||||
format: desc.format,
|
||||
raw_flags,
|
||||
copy_size,
|
||||
view_formats: wgt_view_formats,
|
||||
@@ -1036,7 +1034,7 @@ impl crate::Device<super::Api> for super::Device {
|
||||
texture: &super::Texture,
|
||||
desc: &crate::TextureViewDescriptor,
|
||||
) -> Result<super::TextureView, crate::DeviceError> {
|
||||
let subresource_range = conv::map_subresource_range(&desc.range, texture.aspects);
|
||||
let subresource_range = conv::map_subresource_range(&desc.range, desc.format);
|
||||
let mut vk_info = vk::ImageViewCreateInfo::builder()
|
||||
.flags(vk::ImageViewCreateFlags::empty())
|
||||
.image(texture.raw)
|
||||
@@ -1444,8 +1442,10 @@ impl crate::Device<super::Api> for super::Device {
|
||||
let end = start + entry.count;
|
||||
image_infos.extend(desc.textures[start as usize..end as usize].iter().map(
|
||||
|binding| {
|
||||
let layout =
|
||||
conv::derive_image_layout(binding.usage, binding.view.aspects());
|
||||
let layout = conv::derive_image_layout(
|
||||
binding.usage,
|
||||
binding.view.attachment.view_format,
|
||||
);
|
||||
vk::DescriptorImageInfo::builder()
|
||||
.image_view(binding.view.raw)
|
||||
.image_layout(layout)
|
||||
|
||||
@@ -799,8 +799,7 @@ impl crate::Surface<super::Api> for super::Surface {
|
||||
drop_guard: None,
|
||||
block: None,
|
||||
usage: sc.config.usage,
|
||||
aspects: crate::FormatAspects::COLOR,
|
||||
format_info: sc.config.format.describe(),
|
||||
format: sc.config.format,
|
||||
raw_flags,
|
||||
copy_size: crate::CopyExtent {
|
||||
width: sc.config.extent.width,
|
||||
|
||||
@@ -293,8 +293,7 @@ pub struct Texture {
|
||||
drop_guard: Option<crate::DropGuard>,
|
||||
block: Option<gpu_alloc::MemoryBlock<vk::DeviceMemory>>,
|
||||
usage: crate::TextureUses,
|
||||
aspects: crate::FormatAspects,
|
||||
format_info: wgt::TextureFormatInfo,
|
||||
format: wgt::TextureFormat,
|
||||
raw_flags: vk::ImageCreateFlags,
|
||||
copy_size: crate::CopyExtent,
|
||||
view_formats: Vec<wgt::TextureFormat>,
|
||||
@@ -316,12 +315,6 @@ pub struct TextureView {
|
||||
attachment: FramebufferAttachment,
|
||||
}
|
||||
|
||||
impl TextureView {
|
||||
fn aspects(&self) -> crate::FormatAspects {
|
||||
self.attachment.view_format.into()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Sampler {
|
||||
raw: vk::Sampler,
|
||||
|
||||
+564
-197
@@ -1763,32 +1763,6 @@ pub struct TextureFormatFeatures {
|
||||
pub flags: TextureFormatFeatureFlags,
|
||||
}
|
||||
|
||||
/// Information about a texture format.
|
||||
#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
|
||||
pub struct TextureFormatInfo {
|
||||
/// Features required (if any) to use the texture.
|
||||
pub required_features: Features,
|
||||
/// Type of sampling that is valid for the texture.
|
||||
pub sample_type: TextureSampleType,
|
||||
/// Dimension of a "block" of texels. This is always (1, 1) on uncompressed textures.
|
||||
pub block_dimensions: (u8, u8),
|
||||
/// Size in bytes of a "block" of texels. This is the size per pixel on uncompressed textures.
|
||||
pub block_size: u8,
|
||||
/// Count of components in the texture. This determines which components there will be actual data in the shader for.
|
||||
pub components: u8,
|
||||
/// Format will have colors be converted from srgb to linear on read and from linear to srgb on write.
|
||||
pub srgb: bool,
|
||||
/// Format features guaranteed by the WebGPU spec. Additional features are available if `Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES` is enabled.
|
||||
pub guaranteed_format_features: TextureFormatFeatures,
|
||||
}
|
||||
|
||||
impl TextureFormatInfo {
|
||||
/// Return `true` for compressed formats.
|
||||
pub fn is_compressed(&self) -> bool {
|
||||
self.block_dimensions != (1, 1)
|
||||
}
|
||||
}
|
||||
|
||||
/// ASTC block dimensions
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
|
||||
@@ -2387,36 +2361,286 @@ impl Serialize for TextureFormat {
|
||||
}
|
||||
|
||||
impl TextureFormat {
|
||||
/// Get useful information about the texture format.
|
||||
pub fn describe(&self) -> TextureFormatInfo {
|
||||
// Features
|
||||
let native = Features::empty();
|
||||
let bc = Features::TEXTURE_COMPRESSION_BC;
|
||||
let etc2 = Features::TEXTURE_COMPRESSION_ETC2;
|
||||
let astc_ldr = Features::TEXTURE_COMPRESSION_ASTC_LDR;
|
||||
let astc_hdr = Features::TEXTURE_COMPRESSION_ASTC_HDR;
|
||||
let norm16bit = Features::TEXTURE_FORMAT_16BIT_NORM;
|
||||
let d32_s8 = Features::DEPTH32FLOAT_STENCIL8;
|
||||
|
||||
// Sample Types
|
||||
let uint = TextureSampleType::Uint;
|
||||
let sint = TextureSampleType::Sint;
|
||||
let nearest = TextureSampleType::Float { filterable: false };
|
||||
let float = TextureSampleType::Float { filterable: true };
|
||||
let depth = TextureSampleType::Depth;
|
||||
|
||||
enum ColorSpace {
|
||||
Linear,
|
||||
Corrected,
|
||||
/// Returns the aspect-specific format of the original format
|
||||
///
|
||||
/// see https://gpuweb.github.io/gpuweb/#abstract-opdef-resolving-gputextureaspect
|
||||
pub fn aspect_specific_format(&self, aspect: TextureAspect) -> Option<Self> {
|
||||
match (*self, aspect) {
|
||||
(Self::Stencil8, TextureAspect::StencilOnly) => Some(*self),
|
||||
(
|
||||
Self::Depth16Unorm | Self::Depth24Plus | Self::Depth32Float,
|
||||
TextureAspect::DepthOnly,
|
||||
) => Some(*self),
|
||||
(
|
||||
Self::Depth24PlusStencil8 | Self::Depth32FloatStencil8,
|
||||
TextureAspect::StencilOnly,
|
||||
) => Some(Self::Stencil8),
|
||||
(Self::Depth24PlusStencil8, TextureAspect::DepthOnly) => Some(Self::Depth24Plus),
|
||||
(Self::Depth32FloatStencil8, TextureAspect::DepthOnly) => Some(Self::Depth32Float),
|
||||
(format, TextureAspect::All) => Some(format),
|
||||
_ => None,
|
||||
}
|
||||
let linear = ColorSpace::Linear;
|
||||
let corrected = ColorSpace::Corrected;
|
||||
}
|
||||
|
||||
/// Returns `true` if `self` is a depth or stencil component of the given
|
||||
/// combined depth-stencil format
|
||||
pub fn is_depth_stencil_component(&self, combined_format: Self) -> bool {
|
||||
match (combined_format, *self) {
|
||||
(Self::Depth24PlusStencil8, Self::Depth24Plus | Self::Stencil8)
|
||||
| (Self::Depth32FloatStencil8, Self::Depth32Float | Self::Stencil8) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` if the format is a depth and/or stencil format
|
||||
///
|
||||
/// see https://gpuweb.github.io/gpuweb/#depth-formats
|
||||
pub fn is_depth_stencil_format(&self) -> bool {
|
||||
match *self {
|
||||
Self::Stencil8
|
||||
| Self::Depth16Unorm
|
||||
| Self::Depth24Plus
|
||||
| Self::Depth24PlusStencil8
|
||||
| Self::Depth32Float
|
||||
| Self::Depth32FloatStencil8 => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` if the format is a combined depth-stencil format
|
||||
///
|
||||
/// see https://gpuweb.github.io/gpuweb/#combined-depth-stencil-format
|
||||
pub fn is_combined_depth_stencil_format(&self) -> bool {
|
||||
match *self {
|
||||
Self::Depth24PlusStencil8 | Self::Depth32FloatStencil8 => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` if the format has a color aspect
|
||||
pub fn has_color_aspect(&self) -> bool {
|
||||
!self.is_depth_stencil_format()
|
||||
}
|
||||
|
||||
/// Returns `true` if the format has a depth aspect
|
||||
pub fn has_depth_aspect(&self) -> bool {
|
||||
match *self {
|
||||
Self::Depth16Unorm
|
||||
| Self::Depth24Plus
|
||||
| Self::Depth24PlusStencil8
|
||||
| Self::Depth32Float
|
||||
| Self::Depth32FloatStencil8 => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` if the format has a stencil aspect
|
||||
pub fn has_stencil_aspect(&self) -> bool {
|
||||
match *self {
|
||||
Self::Stencil8 | Self::Depth24PlusStencil8 | Self::Depth32FloatStencil8 => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the dimension of a block of texels.
|
||||
pub fn block_dimensions(&self) -> (u32, u32) {
|
||||
match *self {
|
||||
Self::R8Unorm
|
||||
| Self::R8Snorm
|
||||
| Self::R8Uint
|
||||
| Self::R8Sint
|
||||
| Self::R16Uint
|
||||
| Self::R16Sint
|
||||
| Self::R16Unorm
|
||||
| Self::R16Snorm
|
||||
| Self::R16Float
|
||||
| Self::Rg8Unorm
|
||||
| Self::Rg8Snorm
|
||||
| Self::Rg8Uint
|
||||
| Self::Rg8Sint
|
||||
| Self::R32Uint
|
||||
| Self::R32Sint
|
||||
| Self::R32Float
|
||||
| Self::Rg16Uint
|
||||
| Self::Rg16Sint
|
||||
| Self::Rg16Unorm
|
||||
| Self::Rg16Snorm
|
||||
| Self::Rg16Float
|
||||
| Self::Rgba8Unorm
|
||||
| Self::Rgba8UnormSrgb
|
||||
| Self::Rgba8Snorm
|
||||
| Self::Rgba8Uint
|
||||
| Self::Rgba8Sint
|
||||
| Self::Bgra8Unorm
|
||||
| Self::Bgra8UnormSrgb
|
||||
| Self::Rgb9e5Ufloat
|
||||
| Self::Rgb10a2Unorm
|
||||
| Self::Rg11b10Float
|
||||
| Self::Rg32Uint
|
||||
| Self::Rg32Sint
|
||||
| Self::Rg32Float
|
||||
| Self::Rgba16Uint
|
||||
| Self::Rgba16Sint
|
||||
| Self::Rgba16Unorm
|
||||
| Self::Rgba16Snorm
|
||||
| Self::Rgba16Float
|
||||
| Self::Rgba32Uint
|
||||
| Self::Rgba32Sint
|
||||
| Self::Rgba32Float
|
||||
| Self::Stencil8
|
||||
| Self::Depth16Unorm
|
||||
| Self::Depth24Plus
|
||||
| Self::Depth24PlusStencil8
|
||||
| Self::Depth32Float
|
||||
| Self::Depth32FloatStencil8 => (1, 1),
|
||||
|
||||
Self::Bc1RgbaUnorm
|
||||
| Self::Bc1RgbaUnormSrgb
|
||||
| Self::Bc2RgbaUnorm
|
||||
| Self::Bc2RgbaUnormSrgb
|
||||
| Self::Bc3RgbaUnorm
|
||||
| Self::Bc3RgbaUnormSrgb
|
||||
| Self::Bc4RUnorm
|
||||
| Self::Bc4RSnorm
|
||||
| Self::Bc5RgUnorm
|
||||
| Self::Bc5RgSnorm
|
||||
| Self::Bc6hRgbUfloat
|
||||
| Self::Bc6hRgbSfloat
|
||||
| Self::Bc7RgbaUnorm
|
||||
| Self::Bc7RgbaUnormSrgb => (4, 4),
|
||||
|
||||
Self::Etc2Rgb8Unorm
|
||||
| Self::Etc2Rgb8UnormSrgb
|
||||
| Self::Etc2Rgb8A1Unorm
|
||||
| Self::Etc2Rgb8A1UnormSrgb
|
||||
| Self::Etc2Rgba8Unorm
|
||||
| Self::Etc2Rgba8UnormSrgb
|
||||
| Self::EacR11Unorm
|
||||
| Self::EacR11Snorm
|
||||
| Self::EacRg11Unorm
|
||||
| Self::EacRg11Snorm => (4, 4),
|
||||
|
||||
Self::Astc { block, .. } => match block {
|
||||
AstcBlock::B4x4 => (4, 4),
|
||||
AstcBlock::B5x4 => (5, 4),
|
||||
AstcBlock::B5x5 => (5, 5),
|
||||
AstcBlock::B6x5 => (6, 5),
|
||||
AstcBlock::B6x6 => (6, 6),
|
||||
AstcBlock::B8x5 => (8, 5),
|
||||
AstcBlock::B8x6 => (8, 6),
|
||||
AstcBlock::B8x8 => (8, 8),
|
||||
AstcBlock::B10x5 => (10, 5),
|
||||
AstcBlock::B10x6 => (10, 6),
|
||||
AstcBlock::B10x8 => (10, 8),
|
||||
AstcBlock::B10x10 => (10, 10),
|
||||
AstcBlock::B12x10 => (12, 10),
|
||||
AstcBlock::B12x12 => (12, 12),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` for compressed formats.
|
||||
pub fn is_compressed(&self) -> bool {
|
||||
self.block_dimensions() != (1, 1)
|
||||
}
|
||||
|
||||
/// Returns the required features (if any) in order to use the texture.
|
||||
pub fn required_features(&self) -> Features {
|
||||
match *self {
|
||||
Self::R8Unorm
|
||||
| Self::R8Snorm
|
||||
| Self::R8Uint
|
||||
| Self::R8Sint
|
||||
| Self::R16Uint
|
||||
| Self::R16Sint
|
||||
| Self::R16Float
|
||||
| Self::Rg8Unorm
|
||||
| Self::Rg8Snorm
|
||||
| Self::Rg8Uint
|
||||
| Self::Rg8Sint
|
||||
| Self::R32Uint
|
||||
| Self::R32Sint
|
||||
| Self::R32Float
|
||||
| Self::Rg16Uint
|
||||
| Self::Rg16Sint
|
||||
| Self::Rg16Float
|
||||
| Self::Rgba8Unorm
|
||||
| Self::Rgba8UnormSrgb
|
||||
| Self::Rgba8Snorm
|
||||
| Self::Rgba8Uint
|
||||
| Self::Rgba8Sint
|
||||
| Self::Bgra8Unorm
|
||||
| Self::Bgra8UnormSrgb
|
||||
| Self::Rgb9e5Ufloat
|
||||
| Self::Rgb10a2Unorm
|
||||
| Self::Rg11b10Float
|
||||
| Self::Rg32Uint
|
||||
| Self::Rg32Sint
|
||||
| Self::Rg32Float
|
||||
| Self::Rgba16Uint
|
||||
| Self::Rgba16Sint
|
||||
| Self::Rgba16Float
|
||||
| Self::Rgba32Uint
|
||||
| Self::Rgba32Sint
|
||||
| Self::Rgba32Float
|
||||
| Self::Stencil8
|
||||
| Self::Depth16Unorm
|
||||
| Self::Depth24Plus
|
||||
| Self::Depth24PlusStencil8
|
||||
| Self::Depth32Float => Features::empty(),
|
||||
|
||||
Self::Depth32FloatStencil8 => Features::DEPTH32FLOAT_STENCIL8,
|
||||
|
||||
Self::R16Unorm
|
||||
| Self::R16Snorm
|
||||
| Self::Rg16Unorm
|
||||
| Self::Rg16Snorm
|
||||
| Self::Rgba16Unorm
|
||||
| Self::Rgba16Snorm => Features::TEXTURE_FORMAT_16BIT_NORM,
|
||||
|
||||
Self::Bc1RgbaUnorm
|
||||
| Self::Bc1RgbaUnormSrgb
|
||||
| Self::Bc2RgbaUnorm
|
||||
| Self::Bc2RgbaUnormSrgb
|
||||
| Self::Bc3RgbaUnorm
|
||||
| Self::Bc3RgbaUnormSrgb
|
||||
| Self::Bc4RUnorm
|
||||
| Self::Bc4RSnorm
|
||||
| Self::Bc5RgUnorm
|
||||
| Self::Bc5RgSnorm
|
||||
| Self::Bc6hRgbUfloat
|
||||
| Self::Bc6hRgbSfloat
|
||||
| Self::Bc7RgbaUnorm
|
||||
| Self::Bc7RgbaUnormSrgb => Features::TEXTURE_COMPRESSION_BC,
|
||||
|
||||
Self::Etc2Rgb8Unorm
|
||||
| Self::Etc2Rgb8UnormSrgb
|
||||
| Self::Etc2Rgb8A1Unorm
|
||||
| Self::Etc2Rgb8A1UnormSrgb
|
||||
| Self::Etc2Rgba8Unorm
|
||||
| Self::Etc2Rgba8UnormSrgb
|
||||
| Self::EacR11Unorm
|
||||
| Self::EacR11Snorm
|
||||
| Self::EacRg11Unorm
|
||||
| Self::EacRg11Snorm => Features::TEXTURE_COMPRESSION_ETC2,
|
||||
|
||||
Self::Astc { channel, .. } => match channel {
|
||||
AstcChannel::Hdr => Features::TEXTURE_COMPRESSION_ASTC_HDR,
|
||||
AstcChannel::Unorm | AstcChannel::UnormSrgb => {
|
||||
Features::TEXTURE_COMPRESSION_ASTC_LDR
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the format features guaranteed by the WebGPU spec.
|
||||
///
|
||||
/// Additional features are available if `Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES` is enabled.
|
||||
pub fn guaranteed_format_features(&self) -> TextureFormatFeatures {
|
||||
// Multisampling
|
||||
let noaa = TextureFormatFeatureFlags::empty();
|
||||
let msaa = TextureFormatFeatureFlags::MULTISAMPLE_X4;
|
||||
let msaa_resolve = TextureFormatFeatureFlags::MULTISAMPLE_X4
|
||||
| TextureFormatFeatureFlags::MULTISAMPLE_RESOLVE;
|
||||
let msaa_resolve = msaa | TextureFormatFeatureFlags::MULTISAMPLE_RESOLVE;
|
||||
|
||||
// Flags
|
||||
let basic =
|
||||
@@ -2425,150 +2649,280 @@ impl TextureFormat {
|
||||
let storage = basic | TextureUsages::STORAGE_BINDING;
|
||||
let all_flags = TextureUsages::all();
|
||||
|
||||
// See <https://gpuweb.github.io/gpuweb/#texture-format-caps> for reference
|
||||
#[rustfmt::skip] // lets make a nice table
|
||||
let (
|
||||
required_features,
|
||||
sample_type,
|
||||
color_space,
|
||||
msaa_flags,
|
||||
block_dimensions,
|
||||
block_size,
|
||||
mut flags,
|
||||
allowed_usages,
|
||||
components,
|
||||
) = match self {
|
||||
// Normal 8 bit textures
|
||||
Self::R8Unorm => ( native, float, linear, msaa_resolve, (1, 1), 1, attachment, 1),
|
||||
Self::R8Snorm => ( native, float, linear, noaa, (1, 1), 1, basic, 1),
|
||||
Self::R8Uint => ( native, uint, linear, msaa, (1, 1), 1, attachment, 1),
|
||||
Self::R8Sint => ( native, sint, linear, msaa, (1, 1), 1, attachment, 1),
|
||||
// Normal 16 bit textures
|
||||
Self::R16Uint => ( native, uint, linear, msaa, (1, 1), 2, attachment, 1),
|
||||
Self::R16Sint => ( native, sint, linear, msaa, (1, 1), 2, attachment, 1),
|
||||
Self::R16Float => ( native, float, linear, msaa_resolve, (1, 1), 2, attachment, 1),
|
||||
Self::Rg8Unorm => ( native, float, linear, msaa_resolve, (1, 1), 2, attachment, 2),
|
||||
Self::Rg8Snorm => ( native, float, linear, noaa, (1, 1), 2, basic, 2),
|
||||
Self::Rg8Uint => ( native, uint, linear, msaa, (1, 1), 2, attachment, 2),
|
||||
Self::Rg8Sint => ( native, sint, linear, msaa, (1, 1), 2, attachment, 2),
|
||||
// Normal 32 bit textures
|
||||
Self::R32Uint => ( native, uint, linear, noaa, (1, 1), 4, all_flags, 1),
|
||||
Self::R32Sint => ( native, sint, linear, noaa, (1, 1), 4, all_flags, 1),
|
||||
Self::R32Float => ( native, nearest, linear, msaa, (1, 1), 4, all_flags, 1),
|
||||
Self::Rg16Uint => ( native, uint, linear, msaa, (1, 1), 4, attachment, 2),
|
||||
Self::Rg16Sint => ( native, sint, linear, msaa, (1, 1), 4, attachment, 2),
|
||||
Self::Rg16Float => ( native, float, linear, msaa_resolve, (1, 1), 4, attachment, 2),
|
||||
Self::Rgba8Unorm => ( native, float, linear, msaa_resolve, (1, 1), 4, all_flags, 4),
|
||||
Self::Rgba8UnormSrgb => ( native, float, corrected, msaa_resolve, (1, 1), 4, attachment, 4),
|
||||
Self::Rgba8Snorm => ( native, float, linear, noaa, (1, 1), 4, storage, 4),
|
||||
Self::Rgba8Uint => ( native, uint, linear, msaa, (1, 1), 4, all_flags, 4),
|
||||
Self::Rgba8Sint => ( native, sint, linear, msaa, (1, 1), 4, all_flags, 4),
|
||||
Self::Bgra8Unorm => ( native, float, linear, msaa_resolve, (1, 1), 4, attachment, 4),
|
||||
Self::Bgra8UnormSrgb => ( native, float, corrected, msaa_resolve, (1, 1), 4, attachment, 4),
|
||||
// Packed 32 bit textures
|
||||
Self::Rgb10a2Unorm => ( native, float, linear, msaa_resolve, (1, 1), 4, attachment, 4),
|
||||
Self::Rg11b10Float => ( native, float, linear, msaa, (1, 1), 4, basic, 3),
|
||||
// Normal 64 bit textures
|
||||
Self::Rg32Uint => ( native, uint, linear, noaa, (1, 1), 8, all_flags, 2),
|
||||
Self::Rg32Sint => ( native, sint, linear, noaa, (1, 1), 8, all_flags, 2),
|
||||
Self::Rg32Float => ( native, nearest, linear, noaa, (1, 1), 8, all_flags, 2),
|
||||
Self::Rgba16Uint => ( native, uint, linear, msaa, (1, 1), 8, all_flags, 4),
|
||||
Self::Rgba16Sint => ( native, sint, linear, msaa, (1, 1), 8, all_flags, 4),
|
||||
Self::Rgba16Float => ( native, float, linear, msaa_resolve, (1, 1), 8, all_flags, 4),
|
||||
// Normal 128 bit textures
|
||||
Self::Rgba32Uint => ( native, uint, linear, noaa, (1, 1), 16, all_flags, 4),
|
||||
Self::Rgba32Sint => ( native, sint, linear, noaa, (1, 1), 16, all_flags, 4),
|
||||
Self::Rgba32Float => ( native, nearest, linear, noaa, (1, 1), 16, all_flags, 4),
|
||||
// Depth-stencil textures
|
||||
Self::Stencil8 => ( native, depth, linear, msaa, (1, 1), 2, attachment, 1),
|
||||
Self::Depth16Unorm => ( native, depth, linear, msaa, (1, 1), 2, attachment, 1),
|
||||
Self::Depth24Plus => ( native, depth, linear, msaa, (1, 1), 4, attachment, 1),
|
||||
Self::Depth24PlusStencil8 => ( native, depth, linear, msaa, (1, 1), 4, attachment, 2),
|
||||
Self::Depth32Float => ( native, depth, linear, msaa, (1, 1), 4, attachment, 1),
|
||||
Self::Depth32FloatStencil8 =>( d32_s8, depth, linear, msaa, (1, 1), 4, attachment, 2),
|
||||
// Packed uncompressed
|
||||
Self::Rgb9e5Ufloat => ( native, float, linear, noaa, (1, 1), 4, basic, 3),
|
||||
// Optional normalized 16-bit-per-channel formats
|
||||
Self::R16Unorm => (norm16bit, float, linear, msaa, (1, 1), 2, storage, 1),
|
||||
Self::R16Snorm => (norm16bit, float, linear, msaa, (1, 1), 2, storage, 1),
|
||||
Self::Rg16Unorm => (norm16bit, float, linear, msaa, (1, 1), 4, storage, 2),
|
||||
Self::Rg16Snorm => (norm16bit, float, linear, msaa, (1, 1), 4, storage, 2),
|
||||
Self::Rgba16Unorm => (norm16bit, float, linear, msaa, (1, 1), 8, storage, 4),
|
||||
Self::Rgba16Snorm => (norm16bit, float, linear, msaa, (1, 1), 8, storage, 4),
|
||||
// BCn compressed textures
|
||||
Self::Bc1RgbaUnorm => ( bc, float, linear, noaa, (4, 4), 8, basic, 4),
|
||||
Self::Bc1RgbaUnormSrgb => ( bc, float, corrected, noaa, (4, 4), 8, basic, 4),
|
||||
Self::Bc2RgbaUnorm => ( bc, float, linear, noaa, (4, 4), 16, basic, 4),
|
||||
Self::Bc2RgbaUnormSrgb => ( bc, float, corrected, noaa, (4, 4), 16, basic, 4),
|
||||
Self::Bc3RgbaUnorm => ( bc, float, linear, noaa, (4, 4), 16, basic, 4),
|
||||
Self::Bc3RgbaUnormSrgb => ( bc, float, corrected, noaa, (4, 4), 16, basic, 4),
|
||||
Self::Bc4RUnorm => ( bc, float, linear, noaa, (4, 4), 8, basic, 1),
|
||||
Self::Bc4RSnorm => ( bc, float, linear, noaa, (4, 4), 8, basic, 1),
|
||||
Self::Bc5RgUnorm => ( bc, float, linear, noaa, (4, 4), 16, basic, 2),
|
||||
Self::Bc5RgSnorm => ( bc, float, linear, noaa, (4, 4), 16, basic, 2),
|
||||
Self::Bc6hRgbUfloat => ( bc, float, linear, noaa, (4, 4), 16, basic, 3),
|
||||
Self::Bc6hRgbSfloat => ( bc, float, linear, noaa, (4, 4), 16, basic, 3),
|
||||
Self::Bc7RgbaUnorm => ( bc, float, linear, noaa, (4, 4), 16, basic, 4),
|
||||
Self::Bc7RgbaUnormSrgb => ( bc, float, corrected, noaa, (4, 4), 16, basic, 4),
|
||||
// ETC compressed textures
|
||||
Self::Etc2Rgb8Unorm => ( etc2, float, linear, noaa, (4, 4), 8, basic, 3),
|
||||
Self::Etc2Rgb8UnormSrgb => ( etc2, float, corrected, noaa, (4, 4), 8, basic, 3),
|
||||
Self::Etc2Rgb8A1Unorm => ( etc2, float, linear, noaa, (4, 4), 8, basic, 4),
|
||||
Self::Etc2Rgb8A1UnormSrgb => ( etc2, float, corrected, noaa, (4, 4), 8, basic, 4),
|
||||
Self::Etc2Rgba8Unorm => ( etc2, float, linear, noaa, (4, 4), 16, basic, 4),
|
||||
Self::Etc2Rgba8UnormSrgb => ( etc2, float, corrected, noaa, (4, 4), 16, basic, 4),
|
||||
Self::EacR11Unorm => ( etc2, float, linear, noaa, (4, 4), 8, basic, 1),
|
||||
Self::EacR11Snorm => ( etc2, float, linear, noaa, (4, 4), 8, basic, 1),
|
||||
Self::EacRg11Unorm => ( etc2, float, linear, noaa, (4, 4), 16, basic, 2),
|
||||
Self::EacRg11Snorm => ( etc2, float, linear, noaa, (4, 4), 16, basic, 2),
|
||||
// ASTC compressed textures
|
||||
Self::Astc { block, channel } => {
|
||||
let (feature, color_space) = match channel {
|
||||
AstcChannel::Hdr => (astc_hdr, linear),
|
||||
AstcChannel::Unorm => (astc_ldr, linear),
|
||||
AstcChannel::UnormSrgb => (astc_ldr, corrected),
|
||||
};
|
||||
let dimensions = match block {
|
||||
AstcBlock::B4x4 => (4, 4),
|
||||
AstcBlock::B5x4 => (5, 4),
|
||||
AstcBlock::B5x5 => (5, 5),
|
||||
AstcBlock::B6x5 => (6, 5),
|
||||
AstcBlock::B6x6 => (6, 6),
|
||||
AstcBlock::B8x5 => (8, 5),
|
||||
AstcBlock::B8x6 => (8, 6),
|
||||
AstcBlock::B8x8 => (8, 8),
|
||||
AstcBlock::B10x5 => (10, 5),
|
||||
AstcBlock::B10x6 => (10, 6),
|
||||
AstcBlock::B10x8 => (10, 8),
|
||||
AstcBlock::B10x10 => (10, 10),
|
||||
AstcBlock::B12x10 => (12, 10),
|
||||
AstcBlock::B12x12 => (12, 12),
|
||||
};
|
||||
(feature, float, color_space, noaa, dimensions, 16, basic, 4)
|
||||
}
|
||||
) = match *self {
|
||||
Self::R8Unorm => (msaa_resolve, attachment),
|
||||
Self::R8Snorm => ( noaa, basic),
|
||||
Self::R8Uint => ( msaa, attachment),
|
||||
Self::R8Sint => ( msaa, attachment),
|
||||
Self::R16Uint => ( msaa, attachment),
|
||||
Self::R16Sint => ( msaa, attachment),
|
||||
Self::R16Float => (msaa_resolve, attachment),
|
||||
Self::Rg8Unorm => (msaa_resolve, attachment),
|
||||
Self::Rg8Snorm => ( noaa, basic),
|
||||
Self::Rg8Uint => ( msaa, attachment),
|
||||
Self::Rg8Sint => ( msaa, attachment),
|
||||
Self::R32Uint => ( noaa, all_flags),
|
||||
Self::R32Sint => ( noaa, all_flags),
|
||||
Self::R32Float => ( msaa, all_flags),
|
||||
Self::Rg16Uint => ( msaa, attachment),
|
||||
Self::Rg16Sint => ( msaa, attachment),
|
||||
Self::Rg16Float => (msaa_resolve, attachment),
|
||||
Self::Rgba8Unorm => (msaa_resolve, all_flags),
|
||||
Self::Rgba8UnormSrgb => (msaa_resolve, attachment),
|
||||
Self::Rgba8Snorm => ( noaa, storage),
|
||||
Self::Rgba8Uint => ( msaa, all_flags),
|
||||
Self::Rgba8Sint => ( msaa, all_flags),
|
||||
Self::Bgra8Unorm => (msaa_resolve, attachment),
|
||||
Self::Bgra8UnormSrgb => (msaa_resolve, attachment),
|
||||
Self::Rgb10a2Unorm => (msaa_resolve, attachment),
|
||||
Self::Rg11b10Float => ( msaa, basic),
|
||||
Self::Rg32Uint => ( noaa, all_flags),
|
||||
Self::Rg32Sint => ( noaa, all_flags),
|
||||
Self::Rg32Float => ( noaa, all_flags),
|
||||
Self::Rgba16Uint => ( msaa, all_flags),
|
||||
Self::Rgba16Sint => ( msaa, all_flags),
|
||||
Self::Rgba16Float => (msaa_resolve, all_flags),
|
||||
Self::Rgba32Uint => ( noaa, all_flags),
|
||||
Self::Rgba32Sint => ( noaa, all_flags),
|
||||
Self::Rgba32Float => ( noaa, all_flags),
|
||||
|
||||
Self::Stencil8 => ( msaa, attachment),
|
||||
Self::Depth16Unorm => ( msaa, attachment),
|
||||
Self::Depth24Plus => ( msaa, attachment),
|
||||
Self::Depth24PlusStencil8 => ( msaa, attachment),
|
||||
Self::Depth32Float => ( msaa, attachment),
|
||||
Self::Depth32FloatStencil8 => ( msaa, attachment),
|
||||
|
||||
Self::R16Unorm => ( msaa, storage),
|
||||
Self::R16Snorm => ( msaa, storage),
|
||||
Self::Rg16Unorm => ( msaa, storage),
|
||||
Self::Rg16Snorm => ( msaa, storage),
|
||||
Self::Rgba16Unorm => ( msaa, storage),
|
||||
Self::Rgba16Snorm => ( msaa, storage),
|
||||
|
||||
Self::Rgb9e5Ufloat => ( noaa, basic),
|
||||
|
||||
Self::Bc1RgbaUnorm => ( noaa, basic),
|
||||
Self::Bc1RgbaUnormSrgb => ( noaa, basic),
|
||||
Self::Bc2RgbaUnorm => ( noaa, basic),
|
||||
Self::Bc2RgbaUnormSrgb => ( noaa, basic),
|
||||
Self::Bc3RgbaUnorm => ( noaa, basic),
|
||||
Self::Bc3RgbaUnormSrgb => ( noaa, basic),
|
||||
Self::Bc4RUnorm => ( noaa, basic),
|
||||
Self::Bc4RSnorm => ( noaa, basic),
|
||||
Self::Bc5RgUnorm => ( noaa, basic),
|
||||
Self::Bc5RgSnorm => ( noaa, basic),
|
||||
Self::Bc6hRgbUfloat => ( noaa, basic),
|
||||
Self::Bc6hRgbSfloat => ( noaa, basic),
|
||||
Self::Bc7RgbaUnorm => ( noaa, basic),
|
||||
Self::Bc7RgbaUnormSrgb => ( noaa, basic),
|
||||
|
||||
Self::Etc2Rgb8Unorm => ( noaa, basic),
|
||||
Self::Etc2Rgb8UnormSrgb => ( noaa, basic),
|
||||
Self::Etc2Rgb8A1Unorm => ( noaa, basic),
|
||||
Self::Etc2Rgb8A1UnormSrgb => ( noaa, basic),
|
||||
Self::Etc2Rgba8Unorm => ( noaa, basic),
|
||||
Self::Etc2Rgba8UnormSrgb => ( noaa, basic),
|
||||
Self::EacR11Unorm => ( noaa, basic),
|
||||
Self::EacR11Snorm => ( noaa, basic),
|
||||
Self::EacRg11Unorm => ( noaa, basic),
|
||||
Self::EacRg11Snorm => ( noaa, basic),
|
||||
|
||||
Self::Astc { .. } => ( noaa, basic),
|
||||
};
|
||||
|
||||
let mut flags = msaa_flags;
|
||||
let filterable_sample_type = sample_type == TextureSampleType::Float { filterable: true };
|
||||
flags.set(
|
||||
TextureFormatFeatureFlags::FILTERABLE,
|
||||
filterable_sample_type,
|
||||
);
|
||||
flags.set(TextureFormatFeatureFlags::BLENDABLE, filterable_sample_type);
|
||||
let is_filterable =
|
||||
self.sample_type(None) == Some(TextureSampleType::Float { filterable: true });
|
||||
flags.set(TextureFormatFeatureFlags::FILTERABLE, is_filterable);
|
||||
flags.set(TextureFormatFeatureFlags::BLENDABLE, is_filterable);
|
||||
|
||||
TextureFormatInfo {
|
||||
required_features,
|
||||
sample_type,
|
||||
block_dimensions,
|
||||
block_size,
|
||||
components,
|
||||
srgb: match color_space {
|
||||
ColorSpace::Linear => false,
|
||||
ColorSpace::Corrected => true,
|
||||
TextureFormatFeatures {
|
||||
allowed_usages,
|
||||
flags,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the sample type compatible with this format and aspect
|
||||
///
|
||||
/// Returns `None` only if the format is combined depth-stencil
|
||||
/// and `TextureAspect::All` or no `aspect` was provided
|
||||
pub fn sample_type(&self, aspect: Option<TextureAspect>) -> Option<TextureSampleType> {
|
||||
let float = TextureSampleType::Float { filterable: true };
|
||||
let unfilterable_float = TextureSampleType::Float { filterable: false };
|
||||
let depth = TextureSampleType::Depth;
|
||||
let uint = TextureSampleType::Uint;
|
||||
let sint = TextureSampleType::Sint;
|
||||
|
||||
match *self {
|
||||
Self::R8Unorm
|
||||
| Self::R8Snorm
|
||||
| Self::Rg8Unorm
|
||||
| Self::Rg8Snorm
|
||||
| Self::Rgba8Unorm
|
||||
| Self::Rgba8UnormSrgb
|
||||
| Self::Rgba8Snorm
|
||||
| Self::Bgra8Unorm
|
||||
| Self::Bgra8UnormSrgb
|
||||
| Self::R16Float
|
||||
| Self::Rg16Float
|
||||
| Self::Rgba16Float
|
||||
| Self::Rgb10a2Unorm
|
||||
| Self::Rg11b10Float => Some(float),
|
||||
|
||||
Self::R32Float | Self::Rg32Float | Self::Rgba32Float => Some(unfilterable_float),
|
||||
|
||||
Self::R8Uint
|
||||
| Self::Rg8Uint
|
||||
| Self::Rgba8Uint
|
||||
| Self::R16Uint
|
||||
| Self::Rg16Uint
|
||||
| Self::Rgba16Uint
|
||||
| Self::R32Uint
|
||||
| Self::Rg32Uint
|
||||
| Self::Rgba32Uint => Some(uint),
|
||||
|
||||
Self::R8Sint
|
||||
| Self::Rg8Sint
|
||||
| Self::Rgba8Sint
|
||||
| Self::R16Sint
|
||||
| Self::Rg16Sint
|
||||
| Self::Rgba16Sint
|
||||
| Self::R32Sint
|
||||
| Self::Rg32Sint
|
||||
| Self::Rgba32Sint => Some(sint),
|
||||
|
||||
Self::Stencil8 => Some(uint),
|
||||
Self::Depth16Unorm | Self::Depth24Plus | Self::Depth32Float => Some(depth),
|
||||
Self::Depth24PlusStencil8 | Self::Depth32FloatStencil8 => match aspect {
|
||||
None | Some(TextureAspect::All) => None,
|
||||
Some(TextureAspect::DepthOnly) => Some(depth),
|
||||
Some(TextureAspect::StencilOnly) => Some(uint),
|
||||
},
|
||||
guaranteed_format_features: TextureFormatFeatures {
|
||||
allowed_usages,
|
||||
flags,
|
||||
|
||||
Self::R16Unorm
|
||||
| Self::R16Snorm
|
||||
| Self::Rg16Unorm
|
||||
| Self::Rg16Snorm
|
||||
| Self::Rgba16Unorm
|
||||
| Self::Rgba16Snorm => Some(float),
|
||||
|
||||
Self::Rgb9e5Ufloat => Some(float),
|
||||
|
||||
Self::Bc1RgbaUnorm
|
||||
| Self::Bc1RgbaUnormSrgb
|
||||
| Self::Bc2RgbaUnorm
|
||||
| Self::Bc2RgbaUnormSrgb
|
||||
| Self::Bc3RgbaUnorm
|
||||
| Self::Bc3RgbaUnormSrgb
|
||||
| Self::Bc4RUnorm
|
||||
| Self::Bc4RSnorm
|
||||
| Self::Bc5RgUnorm
|
||||
| Self::Bc5RgSnorm
|
||||
| Self::Bc6hRgbUfloat
|
||||
| Self::Bc6hRgbSfloat
|
||||
| Self::Bc7RgbaUnorm
|
||||
| Self::Bc7RgbaUnormSrgb => Some(float),
|
||||
|
||||
Self::Etc2Rgb8Unorm
|
||||
| Self::Etc2Rgb8UnormSrgb
|
||||
| Self::Etc2Rgb8A1Unorm
|
||||
| Self::Etc2Rgb8A1UnormSrgb
|
||||
| Self::Etc2Rgba8Unorm
|
||||
| Self::Etc2Rgba8UnormSrgb
|
||||
| Self::EacR11Unorm
|
||||
| Self::EacR11Snorm
|
||||
| Self::EacRg11Unorm
|
||||
| Self::EacRg11Snorm => Some(float),
|
||||
|
||||
Self::Astc { .. } => Some(float),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the [texel block size](https://gpuweb.github.io/gpuweb/#texel-block-size)
|
||||
/// of this format.
|
||||
///
|
||||
/// Returns `None` if any of the following are true:
|
||||
/// - the format is combined depth-stencil and no `aspect` was provided
|
||||
/// - the format is `Depth24Plus`
|
||||
/// - the format is `Depth24PlusStencil8` and `aspect` is depth.
|
||||
pub fn block_size(&self, aspect: Option<TextureAspect>) -> Option<u32> {
|
||||
match *self {
|
||||
Self::R8Unorm | Self::R8Snorm | Self::R8Uint | Self::R8Sint => Some(1),
|
||||
|
||||
Self::Rg8Unorm | Self::Rg8Snorm | Self::Rg8Uint | Self::Rg8Sint => Some(2),
|
||||
Self::R16Unorm | Self::R16Snorm | Self::R16Uint | Self::R16Sint | Self::R16Float => {
|
||||
Some(2)
|
||||
}
|
||||
|
||||
Self::Rgba8Unorm
|
||||
| Self::Rgba8UnormSrgb
|
||||
| Self::Rgba8Snorm
|
||||
| Self::Rgba8Uint
|
||||
| Self::Rgba8Sint
|
||||
| Self::Bgra8Unorm
|
||||
| Self::Bgra8UnormSrgb => Some(4),
|
||||
Self::Rg16Unorm
|
||||
| Self::Rg16Snorm
|
||||
| Self::Rg16Uint
|
||||
| Self::Rg16Sint
|
||||
| Self::Rg16Float => Some(4),
|
||||
Self::R32Uint | Self::R32Sint | Self::R32Float => Some(4),
|
||||
Self::Rgb9e5Ufloat | Self::Rgb10a2Unorm | Self::Rg11b10Float => Some(4),
|
||||
|
||||
Self::Rgba16Unorm
|
||||
| Self::Rgba16Snorm
|
||||
| Self::Rgba16Uint
|
||||
| Self::Rgba16Sint
|
||||
| Self::Rgba16Float => Some(8),
|
||||
Self::Rg32Uint | Self::Rg32Sint | Self::Rg32Float => Some(8),
|
||||
|
||||
Self::Rgba32Uint | Self::Rgba32Sint | Self::Rgba32Float => Some(16),
|
||||
|
||||
Self::Stencil8 => Some(1),
|
||||
Self::Depth16Unorm => Some(2),
|
||||
Self::Depth32Float => Some(4),
|
||||
Self::Depth24Plus => None,
|
||||
Self::Depth24PlusStencil8 => match aspect {
|
||||
None | Some(TextureAspect::All) => None,
|
||||
Some(TextureAspect::DepthOnly) => None,
|
||||
Some(TextureAspect::StencilOnly) => Some(1),
|
||||
},
|
||||
Self::Depth32FloatStencil8 => match aspect {
|
||||
None | Some(TextureAspect::All) => None,
|
||||
Some(TextureAspect::DepthOnly) => Some(4),
|
||||
Some(TextureAspect::StencilOnly) => Some(1),
|
||||
},
|
||||
|
||||
Self::Bc1RgbaUnorm | Self::Bc1RgbaUnormSrgb | Self::Bc4RUnorm | Self::Bc4RSnorm => {
|
||||
Some(8)
|
||||
}
|
||||
Self::Bc2RgbaUnorm
|
||||
| Self::Bc2RgbaUnormSrgb
|
||||
| Self::Bc3RgbaUnorm
|
||||
| Self::Bc3RgbaUnormSrgb
|
||||
| Self::Bc5RgUnorm
|
||||
| Self::Bc5RgSnorm
|
||||
| Self::Bc6hRgbUfloat
|
||||
| Self::Bc6hRgbSfloat
|
||||
| Self::Bc7RgbaUnorm
|
||||
| Self::Bc7RgbaUnormSrgb => Some(16),
|
||||
|
||||
Self::Etc2Rgb8Unorm
|
||||
| Self::Etc2Rgb8UnormSrgb
|
||||
| Self::Etc2Rgb8A1Unorm
|
||||
| Self::Etc2Rgb8A1UnormSrgb
|
||||
| Self::EacR11Unorm
|
||||
| Self::EacR11Snorm => Some(8),
|
||||
Self::Etc2Rgba8Unorm
|
||||
| Self::Etc2Rgba8UnormSrgb
|
||||
| Self::EacRg11Unorm
|
||||
| Self::EacRg11Snorm => Some(16),
|
||||
|
||||
Self::Astc { .. } => Some(16),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2617,6 +2971,11 @@ impl TextureFormat {
|
||||
_ => *self,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` for srgb formats.
|
||||
pub fn is_srgb(&self) -> bool {
|
||||
*self != self.remove_srgb_suffix()
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -4321,9 +4680,7 @@ impl Extent3d {
|
||||
///
|
||||
/// [physical size]: https://gpuweb.github.io/gpuweb/#physical-miplevel-specific-texture-extent
|
||||
pub fn physical_size(&self, format: TextureFormat) -> Self {
|
||||
let (block_width, block_height) = format.describe().block_dimensions;
|
||||
let block_width = block_width as u32;
|
||||
let block_height = block_height as u32;
|
||||
let (block_width, block_height) = format.block_dimensions();
|
||||
|
||||
let width = ((self.width + block_width - 1) / block_width) * block_width;
|
||||
let height = ((self.height + block_height - 1) / block_height) * block_height;
|
||||
@@ -4899,12 +5256,17 @@ pub enum TextureSampleType {
|
||||
/// uniform texture2D t;
|
||||
/// ```
|
||||
Float {
|
||||
/// If `filterable` is false, the texture can't be sampled with
|
||||
/// If this is `false`, the texture can't be sampled with
|
||||
/// a filtering sampler.
|
||||
///
|
||||
/// Even if this is `true`, it's possible to sample with
|
||||
/// a **non-filtering** sampler.
|
||||
filterable: bool,
|
||||
},
|
||||
/// Sampling does the depth reference comparison.
|
||||
///
|
||||
/// This is also compatible with a non-filtering sampler.
|
||||
///
|
||||
/// Example WGSL syntax:
|
||||
/// ```rust,ignore
|
||||
/// @group(0) @binding(0)
|
||||
@@ -5404,7 +5766,7 @@ impl ImageSubresourceRange {
|
||||
/// base_array_layer: 0,
|
||||
/// array_layer_count: None,
|
||||
/// };
|
||||
/// assert_eq!(range_none.is_full_resource(5, 10), true);
|
||||
/// assert_eq!(range_none.is_full_resource(wgpu::TextureFormat::Stencil8, 5, 10), true);
|
||||
///
|
||||
/// let range_some = wgpu::ImageSubresourceRange {
|
||||
/// aspect: wgpu::TextureAspect::All,
|
||||
@@ -5413,24 +5775,29 @@ impl ImageSubresourceRange {
|
||||
/// base_array_layer: 0,
|
||||
/// array_layer_count: Some(10),
|
||||
/// };
|
||||
/// assert_eq!(range_some.is_full_resource(5, 10), true);
|
||||
/// assert_eq!(range_some.is_full_resource(wgpu::TextureFormat::Stencil8, 5, 10), true);
|
||||
///
|
||||
/// let range_mixed = wgpu::ImageSubresourceRange {
|
||||
/// aspect: wgpu::TextureAspect::All,
|
||||
/// aspect: wgpu::TextureAspect::StencilOnly,
|
||||
/// base_mip_level: 0,
|
||||
/// // Only partial resource
|
||||
/// mip_level_count: Some(3),
|
||||
/// base_array_layer: 0,
|
||||
/// array_layer_count: None,
|
||||
/// };
|
||||
/// assert_eq!(range_mixed.is_full_resource(5, 10), false);
|
||||
/// assert_eq!(range_mixed.is_full_resource(wgpu::TextureFormat::Stencil8, 5, 10), false);
|
||||
/// ```
|
||||
pub fn is_full_resource(&self, mip_levels: u32, array_layers: u32) -> bool {
|
||||
pub fn is_full_resource(
|
||||
&self,
|
||||
format: TextureFormat,
|
||||
mip_levels: u32,
|
||||
array_layers: u32,
|
||||
) -> bool {
|
||||
// Mip level count and array layer count need to deal with both the None and Some(count) case.
|
||||
let mip_level_count = self.mip_level_count.unwrap_or(mip_levels);
|
||||
let array_layer_count = self.array_layer_count.unwrap_or(array_layers);
|
||||
|
||||
let aspect_eq = self.aspect == TextureAspect::All;
|
||||
let aspect_eq = Some(format) == format.aspect_specific_format(self.aspect);
|
||||
|
||||
let base_mip_level_eq = self.base_mip_level == 0;
|
||||
let mip_level_count_eq = mip_level_count == mip_levels;
|
||||
|
||||
@@ -1008,7 +1008,7 @@ impl crate::context::Context for Context {
|
||||
_adapter_data: &Self::AdapterData,
|
||||
format: wgt::TextureFormat,
|
||||
) -> wgt::TextureFormatFeatures {
|
||||
format.describe().guaranteed_format_features
|
||||
format.guaranteed_format_features()
|
||||
}
|
||||
|
||||
fn adapter_get_presentation_timestamp(
|
||||
|
||||
@@ -2769,12 +2769,6 @@ impl CommandEncoder {
|
||||
}
|
||||
|
||||
/// Copy data from a buffer to a texture.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// - Copy would overrun buffer.
|
||||
/// - Copy would overrun texture.
|
||||
/// - `source.layout.bytes_per_row` isn't divisible by [`COPY_BYTES_PER_ROW_ALIGNMENT`].
|
||||
pub fn copy_buffer_to_texture(
|
||||
&mut self,
|
||||
source: ImageCopyBuffer,
|
||||
@@ -2792,12 +2786,6 @@ impl CommandEncoder {
|
||||
}
|
||||
|
||||
/// Copy data from a texture to a buffer.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// - Copy would overrun buffer.
|
||||
/// - Copy would overrun texture.
|
||||
/// - `source.layout.bytes_per_row` isn't divisible by [`COPY_BYTES_PER_ROW_ALIGNMENT`].
|
||||
pub fn copy_texture_to_buffer(
|
||||
&mut self,
|
||||
source: ImageCopyTexture,
|
||||
|
||||
@@ -87,7 +87,11 @@ impl DeviceExt for crate::Device {
|
||||
desc.usage |= crate::TextureUsages::COPY_DST;
|
||||
let texture = self.create_texture(&desc);
|
||||
|
||||
let format_info = desc.format.describe();
|
||||
// Will return None only if it's a combined depth-stencil format
|
||||
// If so, default to 4, validation will fail later anyway since the depth or stencil
|
||||
// aspect needs to be written to individually
|
||||
let block_size = desc.format.block_size(None).unwrap_or(4);
|
||||
let (block_width, block_height) = desc.format.block_dimensions();
|
||||
let layer_iterations = desc.array_layer_count();
|
||||
|
||||
let mut binary_offset = 0;
|
||||
@@ -106,10 +110,10 @@ impl DeviceExt for crate::Device {
|
||||
|
||||
// All these calculations are performed on the physical size as that's the
|
||||
// data that exists in the buffer.
|
||||
let width_blocks = mip_physical.width / format_info.block_dimensions.0 as u32;
|
||||
let height_blocks = mip_physical.height / format_info.block_dimensions.1 as u32;
|
||||
let width_blocks = mip_physical.width / block_width;
|
||||
let height_blocks = mip_physical.height / block_height;
|
||||
|
||||
let bytes_per_row = width_blocks * format_info.block_size as u32;
|
||||
let bytes_per_row = width_blocks * block_size;
|
||||
let data_size = bytes_per_row * height_blocks * mip_size.depth_or_array_layers;
|
||||
|
||||
let end_offset = binary_offset + data_size as usize;
|
||||
|
||||
+87
-38
@@ -1,8 +1,7 @@
|
||||
use crate::common::{initialize_test, TestParameters, TestingContext};
|
||||
use crate::common::{image::ReadbackBuffers, initialize_test, TestParameters, TestingContext};
|
||||
use wasm_bindgen_test::*;
|
||||
use wgpu::util::align_to;
|
||||
|
||||
static TEXTURE_FORMATS_UNCOMPRESSED: &[wgpu::TextureFormat] = &[
|
||||
static TEXTURE_FORMATS_UNCOMPRESSED_GLES_COMPAT: &[wgpu::TextureFormat] = &[
|
||||
wgpu::TextureFormat::R8Unorm,
|
||||
wgpu::TextureFormat::R8Snorm,
|
||||
wgpu::TextureFormat::R8Uint,
|
||||
@@ -10,10 +9,6 @@ static TEXTURE_FORMATS_UNCOMPRESSED: &[wgpu::TextureFormat] = &[
|
||||
wgpu::TextureFormat::R16Uint,
|
||||
wgpu::TextureFormat::R16Sint,
|
||||
wgpu::TextureFormat::R16Float,
|
||||
wgpu::TextureFormat::Rg8Unorm,
|
||||
wgpu::TextureFormat::Rg8Snorm,
|
||||
wgpu::TextureFormat::Rg8Uint,
|
||||
wgpu::TextureFormat::Rg8Sint,
|
||||
wgpu::TextureFormat::R32Uint,
|
||||
wgpu::TextureFormat::R32Sint,
|
||||
wgpu::TextureFormat::R32Float,
|
||||
@@ -38,6 +33,13 @@ static TEXTURE_FORMATS_UNCOMPRESSED: &[wgpu::TextureFormat] = &[
|
||||
wgpu::TextureFormat::Rgba32Uint,
|
||||
wgpu::TextureFormat::Rgba32Sint,
|
||||
wgpu::TextureFormat::Rgba32Float,
|
||||
];
|
||||
|
||||
static TEXTURE_FORMATS_UNCOMPRESSED: &[wgpu::TextureFormat] = &[
|
||||
wgpu::TextureFormat::Rg8Unorm,
|
||||
wgpu::TextureFormat::Rg8Snorm,
|
||||
wgpu::TextureFormat::Rg8Uint,
|
||||
wgpu::TextureFormat::Rg8Sint,
|
||||
wgpu::TextureFormat::Rgb9e5Ufloat,
|
||||
];
|
||||
|
||||
@@ -46,6 +48,7 @@ static TEXTURE_FORMATS_DEPTH: &[wgpu::TextureFormat] = &[
|
||||
wgpu::TextureFormat::Depth16Unorm,
|
||||
wgpu::TextureFormat::Depth24Plus,
|
||||
wgpu::TextureFormat::Depth24PlusStencil8,
|
||||
wgpu::TextureFormat::Depth32Float,
|
||||
];
|
||||
|
||||
// needs TEXTURE_COMPRESSION_BC
|
||||
@@ -210,6 +213,13 @@ fn single_texture_clear_test(
|
||||
size
|
||||
);
|
||||
|
||||
let extra_usages = match format {
|
||||
wgpu::TextureFormat::Depth24Plus | wgpu::TextureFormat::Depth24PlusStencil8 => {
|
||||
wgpu::TextureUsages::TEXTURE_BINDING
|
||||
}
|
||||
_ => wgpu::TextureUsages::empty(),
|
||||
};
|
||||
|
||||
let texture = ctx.device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: Some(&format!("texture {format:?}")),
|
||||
size,
|
||||
@@ -222,9 +232,7 @@ fn single_texture_clear_test(
|
||||
sample_count: 1, // multisampling is not supported for clear
|
||||
dimension,
|
||||
format,
|
||||
// Forces internally the required usages to be able to clear it.
|
||||
// This is not visible on the API level.
|
||||
usage: wgpu::TextureUsages::TEXTURE_BINDING,
|
||||
usage: wgpu::TextureUsages::COPY_SRC | extra_usages,
|
||||
view_formats: &[],
|
||||
});
|
||||
let mut encoder = ctx
|
||||
@@ -240,21 +248,29 @@ fn single_texture_clear_test(
|
||||
array_layer_count: None,
|
||||
},
|
||||
);
|
||||
|
||||
let readback_buffers = ReadbackBuffers::new(&ctx.device, &texture);
|
||||
|
||||
readback_buffers.copy_from(&ctx.device, &mut encoder, &texture);
|
||||
|
||||
ctx.queue.submit([encoder.finish()]);
|
||||
|
||||
// TODO: Read back and check zeroness?
|
||||
assert!(
|
||||
readback_buffers.are_zero(&ctx.device),
|
||||
"texture with format {format:?} was not fully cleared"
|
||||
);
|
||||
}
|
||||
|
||||
fn clear_texture_tests(
|
||||
ctx: &TestingContext,
|
||||
formats: &[wgpu::TextureFormat],
|
||||
supports_1d: bool,
|
||||
supports_3d: bool,
|
||||
) {
|
||||
fn clear_texture_tests(ctx: &TestingContext, formats: &[wgpu::TextureFormat]) {
|
||||
for &format in formats {
|
||||
let desc = format.describe();
|
||||
let rounded_width = align_to(64, desc.block_dimensions.0 as u32);
|
||||
let rounded_height = align_to(64, desc.block_dimensions.1 as u32);
|
||||
let (block_width, block_height) = format.block_dimensions();
|
||||
let rounded_width = block_width * wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;
|
||||
let rounded_height = block_height * wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;
|
||||
|
||||
let is_compressed_or_depth_stencil_format =
|
||||
format.is_compressed() || format.is_depth_stencil_format();
|
||||
let supports_1d = !is_compressed_or_depth_stencil_format;
|
||||
let supports_3d = !is_compressed_or_depth_stencil_format;
|
||||
|
||||
// 1D texture
|
||||
if supports_1d {
|
||||
@@ -309,14 +325,45 @@ fn clear_texture_tests(
|
||||
|
||||
#[test]
|
||||
#[wasm_bindgen_test]
|
||||
fn clear_texture_2d_uncompressed() {
|
||||
fn clear_texture_uncompressed_gles_compat() {
|
||||
initialize_test(
|
||||
TestParameters::default()
|
||||
.webgl2_failure()
|
||||
.features(wgpu::Features::CLEAR_TEXTURE),
|
||||
|ctx| {
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_UNCOMPRESSED, true, true);
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_DEPTH, false, false);
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_UNCOMPRESSED_GLES_COMPAT);
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[wasm_bindgen_test]
|
||||
fn clear_texture_uncompressed() {
|
||||
initialize_test(
|
||||
TestParameters::default()
|
||||
.webgl2_failure()
|
||||
.backend_failure(wgpu::Backends::GL)
|
||||
.features(wgpu::Features::CLEAR_TEXTURE),
|
||||
|ctx| {
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_UNCOMPRESSED);
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[wasm_bindgen_test]
|
||||
fn clear_texture_depth() {
|
||||
initialize_test(
|
||||
TestParameters::default()
|
||||
.webgl2_failure()
|
||||
.downlevel_flags(
|
||||
wgpu::DownlevelFlags::DEPTH_TEXTURE_AND_BUFFER_COPIES
|
||||
| wgpu::DownlevelFlags::COMPUTE_SHADERS,
|
||||
)
|
||||
.limits(wgpu::Limits::downlevel_defaults())
|
||||
.features(wgpu::Features::CLEAR_TEXTURE),
|
||||
|ctx| {
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_DEPTH);
|
||||
},
|
||||
)
|
||||
}
|
||||
@@ -328,48 +375,50 @@ fn clear_texture_d32_s8() {
|
||||
TestParameters::default()
|
||||
.features(wgpu::Features::CLEAR_TEXTURE | wgpu::Features::DEPTH32FLOAT_STENCIL8),
|
||||
|ctx| {
|
||||
clear_texture_tests(
|
||||
&ctx,
|
||||
&[wgpu::TextureFormat::Depth32FloatStencil8],
|
||||
false,
|
||||
false,
|
||||
);
|
||||
clear_texture_tests(&ctx, &[wgpu::TextureFormat::Depth32FloatStencil8]);
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clear_texture_2d_bc() {
|
||||
fn clear_texture_bc() {
|
||||
initialize_test(
|
||||
TestParameters::default()
|
||||
.features(wgpu::Features::CLEAR_TEXTURE | wgpu::Features::TEXTURE_COMPRESSION_BC)
|
||||
.specific_failure(Some(wgpu::Backends::GL), None, Some("ANGLE"), false), // https://bugs.chromium.org/p/angleproject/issues/detail?id=7056
|
||||
.specific_failure(Some(wgpu::Backends::GL), None, Some("ANGLE"), false) // https://bugs.chromium.org/p/angleproject/issues/detail?id=7056
|
||||
.backend_failure(wgpu::Backends::GL), // compressed texture copy to buffer not yet implemented
|
||||
|ctx| {
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_BC, false, false);
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_BC);
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clear_texture_2d_astc() {
|
||||
fn clear_texture_astc() {
|
||||
initialize_test(
|
||||
TestParameters::default()
|
||||
.features(wgpu::Features::CLEAR_TEXTURE | wgpu::Features::TEXTURE_COMPRESSION_ASTC_LDR)
|
||||
.specific_failure(Some(wgpu::Backends::GL), None, Some("ANGLE"), false), // https://bugs.chromium.org/p/angleproject/issues/detail?id=7056
|
||||
.limits(wgpu::Limits {
|
||||
max_texture_dimension_2d: wgpu::COPY_BYTES_PER_ROW_ALIGNMENT * 12,
|
||||
..wgpu::Limits::downlevel_defaults()
|
||||
})
|
||||
.specific_failure(Some(wgpu::Backends::GL), None, Some("ANGLE"), false) // https://bugs.chromium.org/p/angleproject/issues/detail?id=7056
|
||||
.backend_failure(wgpu::Backends::GL), // compressed texture copy to buffer not yet implemented
|
||||
|ctx| {
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_ASTC, false, false);
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_ASTC);
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clear_texture_2d_etc2() {
|
||||
fn clear_texture_etc2() {
|
||||
initialize_test(
|
||||
TestParameters::default()
|
||||
.features(wgpu::Features::CLEAR_TEXTURE | wgpu::Features::TEXTURE_COMPRESSION_ETC2)
|
||||
.specific_failure(Some(wgpu::Backends::GL), None, Some("ANGLE"), false), // https://bugs.chromium.org/p/angleproject/issues/detail?id=7056
|
||||
.specific_failure(Some(wgpu::Backends::GL), None, Some("ANGLE"), false) // https://bugs.chromium.org/p/angleproject/issues/detail?id=7056
|
||||
.backend_failure(wgpu::Backends::GL), // compressed texture copy to buffer not yet implemented
|
||||
|ctx| {
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_ETC2, false, false);
|
||||
clear_texture_tests(&ctx, TEXTURE_FORMATS_ETC2);
|
||||
},
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
@group(0) @binding(0)
|
||||
var texture: texture_2d_array<{{type}}>;
|
||||
|
||||
@group(0) @binding(1)
|
||||
var<storage, read_write> output: array<{{type}}>;
|
||||
|
||||
@compute @workgroup_size(1)
|
||||
fn copy_texture_to_buffer() {
|
||||
let layers = textureNumLayers(texture);
|
||||
let dim = textureDimensions(texture);
|
||||
for (var l = 0; l < layers; l++) {
|
||||
for (var y = 0; y < dim.y; y++) {
|
||||
for (var x = 0; x < dim.x; x++) {
|
||||
output[x + y * dim.x] = textureLoad(texture, vec2(x, y), l, 0).x;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,9 +1,13 @@
|
||||
use std::{
|
||||
borrow::Cow,
|
||||
ffi::{OsStr, OsString},
|
||||
io,
|
||||
num::NonZeroU32,
|
||||
path::Path,
|
||||
str::FromStr,
|
||||
};
|
||||
use wgpu::util::DeviceExt;
|
||||
use wgpu::*;
|
||||
|
||||
fn read_png(path: impl AsRef<Path>, width: u32, height: u32) -> Option<Vec<u8>> {
|
||||
let data = match std::fs::read(&path) {
|
||||
@@ -144,3 +148,283 @@ pub fn compare_image_output(
|
||||
write_png(&path, width, height, data, png::Compression::Best);
|
||||
}
|
||||
}
|
||||
|
||||
fn copy_via_compute(
|
||||
device: &Device,
|
||||
encoder: &mut CommandEncoder,
|
||||
texture: &Texture,
|
||||
buffer: &Buffer,
|
||||
aspect: TextureAspect,
|
||||
) {
|
||||
let bgl = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
|
||||
label: None,
|
||||
entries: &[
|
||||
BindGroupLayoutEntry {
|
||||
binding: 0,
|
||||
visibility: ShaderStages::COMPUTE,
|
||||
ty: BindingType::Texture {
|
||||
sample_type: match aspect {
|
||||
TextureAspect::DepthOnly => TextureSampleType::Float { filterable: false },
|
||||
TextureAspect::StencilOnly => TextureSampleType::Uint,
|
||||
_ => unreachable!(),
|
||||
},
|
||||
view_dimension: TextureViewDimension::D2Array,
|
||||
multisampled: false,
|
||||
},
|
||||
count: None,
|
||||
},
|
||||
BindGroupLayoutEntry {
|
||||
binding: 1,
|
||||
visibility: ShaderStages::COMPUTE,
|
||||
ty: BindingType::Buffer {
|
||||
ty: BufferBindingType::Storage { read_only: false },
|
||||
has_dynamic_offset: false,
|
||||
min_binding_size: None,
|
||||
},
|
||||
count: None,
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
let view = texture.create_view(&TextureViewDescriptor {
|
||||
aspect,
|
||||
dimension: Some(TextureViewDimension::D2Array),
|
||||
..Default::default()
|
||||
});
|
||||
|
||||
let output_buffer = device.create_buffer(&BufferDescriptor {
|
||||
label: Some("output buffer"),
|
||||
size: buffer.size(),
|
||||
usage: BufferUsages::COPY_SRC | BufferUsages::STORAGE,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
|
||||
let bg = device.create_bind_group(&BindGroupDescriptor {
|
||||
label: None,
|
||||
layout: &bgl,
|
||||
entries: &[
|
||||
BindGroupEntry {
|
||||
binding: 0,
|
||||
resource: BindingResource::TextureView(&view),
|
||||
},
|
||||
BindGroupEntry {
|
||||
binding: 1,
|
||||
resource: BindingResource::Buffer(BufferBinding {
|
||||
buffer: &output_buffer,
|
||||
offset: 0,
|
||||
size: None,
|
||||
}),
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
let pll = device.create_pipeline_layout(&PipelineLayoutDescriptor {
|
||||
label: None,
|
||||
bind_group_layouts: &[&bgl],
|
||||
push_constant_ranges: &[],
|
||||
});
|
||||
|
||||
let source = String::from(include_str!("copy_texture_to_buffer.wgsl"));
|
||||
|
||||
let processed_source = source.replace(
|
||||
"{{type}}",
|
||||
match aspect {
|
||||
TextureAspect::DepthOnly => "f32",
|
||||
TextureAspect::StencilOnly => "u32",
|
||||
_ => unreachable!(),
|
||||
},
|
||||
);
|
||||
|
||||
let sm = device.create_shader_module(ShaderModuleDescriptor {
|
||||
label: Some("shader copy_texture_to_buffer.wgsl"),
|
||||
source: ShaderSource::Wgsl(Cow::Borrowed(&processed_source)),
|
||||
});
|
||||
|
||||
let pipeline_copy = device.create_compute_pipeline(&ComputePipelineDescriptor {
|
||||
label: Some("pipeline read"),
|
||||
layout: Some(&pll),
|
||||
module: &sm,
|
||||
entry_point: "copy_texture_to_buffer",
|
||||
});
|
||||
|
||||
{
|
||||
let mut pass = encoder.begin_compute_pass(&ComputePassDescriptor::default());
|
||||
|
||||
pass.set_pipeline(&pipeline_copy);
|
||||
pass.set_bind_group(0, &bg, &[]);
|
||||
pass.dispatch_workgroups(1, 1, 1);
|
||||
}
|
||||
|
||||
encoder.copy_buffer_to_buffer(&output_buffer, 0, buffer, 0, buffer.size());
|
||||
}
|
||||
|
||||
fn copy_texture_to_buffer_with_aspect(
|
||||
encoder: &mut CommandEncoder,
|
||||
texture: &Texture,
|
||||
buffer: &Buffer,
|
||||
buffer_stencil: &Option<Buffer>,
|
||||
aspect: TextureAspect,
|
||||
) {
|
||||
let (block_width, block_height) = texture.format().block_dimensions();
|
||||
let block_size = texture.format().block_size(Some(aspect)).unwrap();
|
||||
let mip_level = 0;
|
||||
encoder.copy_texture_to_buffer(
|
||||
ImageCopyTexture {
|
||||
texture,
|
||||
mip_level,
|
||||
origin: Origin3d::ZERO,
|
||||
aspect,
|
||||
},
|
||||
ImageCopyBuffer {
|
||||
buffer: match aspect {
|
||||
TextureAspect::StencilOnly => buffer_stencil.as_ref().unwrap(),
|
||||
_ => buffer,
|
||||
},
|
||||
layout: ImageDataLayout {
|
||||
offset: 0,
|
||||
bytes_per_row: Some(
|
||||
NonZeroU32::new((texture.width() / block_width) * block_size).unwrap(),
|
||||
),
|
||||
rows_per_image: Some(NonZeroU32::new(texture.height() / block_height).unwrap()),
|
||||
},
|
||||
},
|
||||
texture
|
||||
.size()
|
||||
.mip_level_size(mip_level, texture.dimension()),
|
||||
);
|
||||
}
|
||||
|
||||
fn copy_texture_to_buffer(
|
||||
device: &Device,
|
||||
encoder: &mut CommandEncoder,
|
||||
texture: &Texture,
|
||||
buffer: &Buffer,
|
||||
buffer_stencil: &Option<Buffer>,
|
||||
) {
|
||||
match texture.format() {
|
||||
TextureFormat::Depth24Plus => {
|
||||
copy_via_compute(device, encoder, texture, buffer, TextureAspect::DepthOnly);
|
||||
}
|
||||
TextureFormat::Depth24PlusStencil8 => {
|
||||
copy_via_compute(device, encoder, texture, buffer, TextureAspect::DepthOnly);
|
||||
// copy_via_compute(
|
||||
// device,
|
||||
// encoder,
|
||||
// texture,
|
||||
// buffer_stencil.as_ref().unwrap(),
|
||||
// TextureAspect::StencilOnly,
|
||||
// );
|
||||
copy_texture_to_buffer_with_aspect(
|
||||
encoder,
|
||||
texture,
|
||||
buffer,
|
||||
buffer_stencil,
|
||||
TextureAspect::StencilOnly,
|
||||
);
|
||||
}
|
||||
TextureFormat::Depth32FloatStencil8 => {
|
||||
copy_texture_to_buffer_with_aspect(
|
||||
encoder,
|
||||
texture,
|
||||
buffer,
|
||||
buffer_stencil,
|
||||
TextureAspect::DepthOnly,
|
||||
);
|
||||
copy_texture_to_buffer_with_aspect(
|
||||
encoder,
|
||||
texture,
|
||||
buffer,
|
||||
buffer_stencil,
|
||||
TextureAspect::StencilOnly,
|
||||
);
|
||||
}
|
||||
_ => {
|
||||
copy_texture_to_buffer_with_aspect(
|
||||
encoder,
|
||||
texture,
|
||||
buffer,
|
||||
buffer_stencil,
|
||||
TextureAspect::All,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct ReadbackBuffers {
|
||||
/// buffer for color or depth aspects
|
||||
buffer: Buffer,
|
||||
/// buffer for stencil aspect
|
||||
buffer_stencil: Option<Buffer>,
|
||||
}
|
||||
|
||||
impl ReadbackBuffers {
|
||||
pub fn new(device: &Device, texture: &Texture) -> Self {
|
||||
let (block_width, block_height) = texture.format().block_dimensions();
|
||||
let base_size = (texture.width() / block_width)
|
||||
* (texture.height() / block_height)
|
||||
* texture.depth_or_array_layers();
|
||||
if texture.format().is_combined_depth_stencil_format() {
|
||||
let buffer_size = base_size
|
||||
* texture
|
||||
.format()
|
||||
.block_size(Some(TextureAspect::DepthOnly))
|
||||
.unwrap_or(4);
|
||||
let buffer_stencil_size = base_size
|
||||
* texture
|
||||
.format()
|
||||
.block_size(Some(TextureAspect::StencilOnly))
|
||||
.unwrap();
|
||||
let buffer = device.create_buffer_init(&util::BufferInitDescriptor {
|
||||
label: Some("Texture Readback"),
|
||||
usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
|
||||
contents: &vec![255; buffer_size as usize],
|
||||
});
|
||||
let buffer_stencil = device.create_buffer_init(&util::BufferInitDescriptor {
|
||||
label: Some("Texture Stencil-Aspect Readback"),
|
||||
usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
|
||||
contents: &vec![255; buffer_stencil_size as usize],
|
||||
});
|
||||
ReadbackBuffers {
|
||||
buffer,
|
||||
buffer_stencil: Some(buffer_stencil),
|
||||
}
|
||||
} else {
|
||||
let buffer_size = base_size * texture.format().block_size(None).unwrap_or(4);
|
||||
let buffer = device.create_buffer_init(&util::BufferInitDescriptor {
|
||||
label: Some("Texture Readback"),
|
||||
usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
|
||||
contents: &vec![255; buffer_size as usize],
|
||||
});
|
||||
ReadbackBuffers {
|
||||
buffer,
|
||||
buffer_stencil: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: also copy and check mips
|
||||
pub fn copy_from(&self, device: &Device, encoder: &mut CommandEncoder, texture: &Texture) {
|
||||
copy_texture_to_buffer(device, encoder, texture, &self.buffer, &self.buffer_stencil);
|
||||
}
|
||||
|
||||
pub fn are_zero(&self, device: &Device) -> bool {
|
||||
fn is_zero(device: &Device, buffer: &Buffer) -> bool {
|
||||
let is_zero = {
|
||||
let buffer_slice = buffer.slice(..);
|
||||
buffer_slice.map_async(MapMode::Read, |_| ());
|
||||
device.poll(Maintain::Wait);
|
||||
let buffer_view = buffer_slice.get_mapped_range();
|
||||
buffer_view.iter().all(|b| *b == 0)
|
||||
};
|
||||
buffer.unmap();
|
||||
is_zero
|
||||
}
|
||||
|
||||
is_zero(device, &self.buffer)
|
||||
&& self
|
||||
.buffer_stencil
|
||||
.as_ref()
|
||||
.map(|buffer_stencil| is_zero(device, buffer_stencil))
|
||||
.unwrap_or(true)
|
||||
}
|
||||
}
|
||||
@@ -109,7 +109,7 @@ fn write_texture_subset_3d() {
|
||||
initialize_test(parameters, |ctx| {
|
||||
let tex = ctx.device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: None,
|
||||
dimension: wgpu::TextureDimension::D2,
|
||||
dimension: wgpu::TextureDimension::D3,
|
||||
size: wgpu::Extent3d {
|
||||
width: size,
|
||||
height: size,
|
||||
|
||||
@@ -1,41 +1,24 @@
|
||||
use std::num::NonZeroU32;
|
||||
|
||||
use crate::common::{initialize_test, TestParameters};
|
||||
use crate::common::{image::ReadbackBuffers, initialize_test, TestParameters, TestingContext};
|
||||
use wasm_bindgen_test::*;
|
||||
use wgpu::*;
|
||||
|
||||
// Checks if discarding a color target resets its init state, causing a zero read of this texture when copied in after submit of the encoder.
|
||||
#[test]
|
||||
#[wasm_bindgen_test]
|
||||
fn discarding_color_target_resets_texture_init_state_check_visible_on_copy_after_submit() {
|
||||
initialize_test(TestParameters::default().webgl2_failure(), |ctx| {
|
||||
let (texture, readback_buffer) =
|
||||
create_white_texture_and_readback_buffer(&ctx, wgpu::TextureFormat::Rgba8UnormSrgb);
|
||||
{
|
||||
let mut encoder = ctx
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
|
||||
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: Some("Color Discard"),
|
||||
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||
view: &texture.create_view(&wgpu::TextureViewDescriptor::default()),
|
||||
resolve_target: None,
|
||||
ops: wgpu::Operations {
|
||||
load: wgpu::LoadOp::Load,
|
||||
store: false, // discard!
|
||||
},
|
||||
})],
|
||||
depth_stencil_attachment: None,
|
||||
});
|
||||
ctx.queue.submit([encoder.finish()]);
|
||||
}
|
||||
{
|
||||
let mut encoder = ctx
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
|
||||
copy_texture_to_buffer(&mut encoder, &texture, &readback_buffer);
|
||||
ctx.queue.submit([encoder.finish()]);
|
||||
}
|
||||
assert_buffer_is_zero(&readback_buffer, &ctx.device);
|
||||
initialize_test(TestParameters::default().webgl2_failure(), |mut ctx| {
|
||||
let mut case = TestCase::new(&mut ctx, TextureFormat::Rgba8UnormSrgb);
|
||||
case.create_command_encoder();
|
||||
case.discard();
|
||||
case.submit_command_encoder();
|
||||
|
||||
case.create_command_encoder();
|
||||
case.copy_texture_to_buffer();
|
||||
case.submit_command_encoder();
|
||||
|
||||
case.assert_buffers_are_zero();
|
||||
});
|
||||
}
|
||||
|
||||
@@ -43,70 +26,47 @@ fn discarding_color_target_resets_texture_init_state_check_visible_on_copy_after
|
||||
#[test]
|
||||
#[wasm_bindgen_test]
|
||||
fn discarding_color_target_resets_texture_init_state_check_visible_on_copy_in_same_encoder() {
|
||||
initialize_test(TestParameters::default().webgl2_failure(), |ctx| {
|
||||
let (texture, readback_buffer) =
|
||||
create_white_texture_and_readback_buffer(&ctx, wgpu::TextureFormat::Rgba8UnormSrgb);
|
||||
{
|
||||
let mut encoder = ctx
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
|
||||
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: Some("Color Discard"),
|
||||
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||
view: &texture.create_view(&wgpu::TextureViewDescriptor::default()),
|
||||
resolve_target: None,
|
||||
ops: wgpu::Operations {
|
||||
load: wgpu::LoadOp::Load,
|
||||
store: false, // discard!
|
||||
},
|
||||
})],
|
||||
depth_stencil_attachment: None,
|
||||
});
|
||||
copy_texture_to_buffer(&mut encoder, &texture, &readback_buffer);
|
||||
ctx.queue.submit([encoder.finish()]);
|
||||
}
|
||||
assert_buffer_is_zero(&readback_buffer, &ctx.device);
|
||||
initialize_test(TestParameters::default().webgl2_failure(), |mut ctx| {
|
||||
let mut case = TestCase::new(&mut ctx, TextureFormat::Rgba8UnormSrgb);
|
||||
case.create_command_encoder();
|
||||
case.discard();
|
||||
case.copy_texture_to_buffer();
|
||||
case.submit_command_encoder();
|
||||
|
||||
case.assert_buffers_are_zero();
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[wasm_bindgen_test]
|
||||
#[allow(clippy::single_element_loop)]
|
||||
fn discarding_depth_target_resets_texture_init_state_check_visible_on_copy_in_same_encoder() {
|
||||
initialize_test(
|
||||
TestParameters::default()
|
||||
.downlevel_flags(wgpu::DownlevelFlags::DEPTH_TEXTURE_AND_BUFFER_COPIES),
|
||||
|ctx| {
|
||||
.downlevel_flags(
|
||||
DownlevelFlags::DEPTH_TEXTURE_AND_BUFFER_COPIES | DownlevelFlags::COMPUTE_SHADERS,
|
||||
)
|
||||
.limits(Limits::downlevel_defaults())
|
||||
.specific_failure(
|
||||
Some(wgpu::Backends::DX12),
|
||||
Some(5140),
|
||||
Some("Microsoft Basic Render Driver"),
|
||||
false,
|
||||
),
|
||||
|mut ctx| {
|
||||
for format in [
|
||||
wgpu::TextureFormat::Depth32Float,
|
||||
//wgpu::TextureFormat::Depth24Plus, // Can't copy to or from buffer
|
||||
//wgpu::TextureFormat::Depth24PlusStencil8, // Can only copy stencil aspect to/from buffer
|
||||
TextureFormat::Stencil8,
|
||||
TextureFormat::Depth16Unorm,
|
||||
TextureFormat::Depth24Plus,
|
||||
TextureFormat::Depth24PlusStencil8,
|
||||
TextureFormat::Depth32Float,
|
||||
] {
|
||||
let (texture, readback_buffer) =
|
||||
create_white_texture_and_readback_buffer(&ctx, format);
|
||||
{
|
||||
let mut encoder = ctx
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
|
||||
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: Some("Depth Discard"),
|
||||
color_attachments: &[],
|
||||
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
|
||||
view: &texture.create_view(&wgpu::TextureViewDescriptor::default()),
|
||||
depth_ops: Some(wgpu::Operations {
|
||||
load: wgpu::LoadOp::Load,
|
||||
store: false, // discard!
|
||||
}),
|
||||
stencil_ops: Some(wgpu::Operations {
|
||||
load: wgpu::LoadOp::Load,
|
||||
store: false, // discard!
|
||||
}),
|
||||
}),
|
||||
});
|
||||
copy_texture_to_buffer(&mut encoder, &texture, &readback_buffer);
|
||||
ctx.queue.submit([encoder.finish()]);
|
||||
}
|
||||
assert_buffer_is_zero(&readback_buffer, &ctx.device);
|
||||
let mut case = TestCase::new(&mut ctx, format);
|
||||
case.create_command_encoder();
|
||||
case.discard();
|
||||
case.copy_texture_to_buffer();
|
||||
case.submit_command_encoder();
|
||||
|
||||
case.assert_buffers_are_zero();
|
||||
}
|
||||
},
|
||||
);
|
||||
@@ -115,188 +75,237 @@ fn discarding_depth_target_resets_texture_init_state_check_visible_on_copy_in_sa
|
||||
#[test]
|
||||
#[wasm_bindgen_test]
|
||||
fn discarding_either_depth_or_stencil_aspect() {
|
||||
initialize_test(TestParameters::default(), |ctx| {
|
||||
let (texture, _) = create_white_texture_and_readback_buffer(
|
||||
&ctx,
|
||||
wgpu::TextureFormat::Depth24PlusStencil8,
|
||||
);
|
||||
// TODO: How do we test this other than "doesn't crash"? We can't copy the texture to/from buffers, so we would need to do a copy in a shader
|
||||
{
|
||||
let mut encoder = ctx
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
|
||||
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: Some("Depth Discard, Stencil Load"),
|
||||
color_attachments: &[],
|
||||
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
|
||||
view: &texture.create_view(&wgpu::TextureViewDescriptor::default()),
|
||||
depth_ops: Some(wgpu::Operations {
|
||||
load: wgpu::LoadOp::Load,
|
||||
store: false, // discard!
|
||||
}),
|
||||
stencil_ops: Some(wgpu::Operations {
|
||||
load: wgpu::LoadOp::Clear(0),
|
||||
store: true,
|
||||
}),
|
||||
}),
|
||||
});
|
||||
ctx.queue.submit([encoder.finish()]);
|
||||
}
|
||||
{
|
||||
let mut encoder = ctx
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
|
||||
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: Some("Depth Load, Stencil Discard"),
|
||||
color_attachments: &[],
|
||||
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
|
||||
view: &texture.create_view(&wgpu::TextureViewDescriptor::default()),
|
||||
depth_ops: Some(wgpu::Operations {
|
||||
load: wgpu::LoadOp::Clear(0.0),
|
||||
store: true,
|
||||
}),
|
||||
stencil_ops: Some(wgpu::Operations {
|
||||
load: wgpu::LoadOp::Load,
|
||||
store: false, // discard!
|
||||
}),
|
||||
}),
|
||||
});
|
||||
ctx.queue.submit([encoder.finish()]);
|
||||
}
|
||||
});
|
||||
initialize_test(
|
||||
TestParameters::default()
|
||||
.downlevel_flags(
|
||||
DownlevelFlags::DEPTH_TEXTURE_AND_BUFFER_COPIES | DownlevelFlags::COMPUTE_SHADERS,
|
||||
)
|
||||
.limits(Limits::downlevel_defaults()),
|
||||
|mut ctx| {
|
||||
let mut case = TestCase::new(&mut ctx, TextureFormat::Depth24PlusStencil8);
|
||||
case.create_command_encoder();
|
||||
case.discard_depth();
|
||||
case.submit_command_encoder();
|
||||
|
||||
case.create_command_encoder();
|
||||
case.discard_stencil();
|
||||
case.submit_command_encoder();
|
||||
|
||||
case.create_command_encoder();
|
||||
case.copy_texture_to_buffer();
|
||||
case.submit_command_encoder();
|
||||
|
||||
case.assert_buffers_are_zero();
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
const TEXTURE_SIZE: wgpu::Extent3d = wgpu::Extent3d {
|
||||
width: 64,
|
||||
height: 64,
|
||||
depth_or_array_layers: 1,
|
||||
};
|
||||
const BYTES_PER_PIXEL: u32 = 4;
|
||||
const BUFFER_COPY_LAYOUT: wgpu::ImageDataLayout = wgpu::ImageDataLayout {
|
||||
offset: 0,
|
||||
bytes_per_row: NonZeroU32::new(TEXTURE_SIZE.width * BYTES_PER_PIXEL),
|
||||
rows_per_image: None,
|
||||
};
|
||||
struct TestCase<'ctx> {
|
||||
ctx: &'ctx mut TestingContext,
|
||||
format: TextureFormat,
|
||||
texture: Texture,
|
||||
readback_buffers: ReadbackBuffers,
|
||||
encoder: Option<CommandEncoder>,
|
||||
}
|
||||
|
||||
fn create_white_texture_and_readback_buffer(
|
||||
ctx: &crate::common::TestingContext,
|
||||
format: wgpu::TextureFormat,
|
||||
) -> (wgpu::Texture, wgpu::Buffer) {
|
||||
let format_desc = format.describe();
|
||||
impl<'ctx> TestCase<'ctx> {
|
||||
pub fn new(ctx: &'ctx mut TestingContext, format: TextureFormat) -> Self {
|
||||
let extra_usages = match format {
|
||||
TextureFormat::Depth24Plus | TextureFormat::Depth24PlusStencil8 => {
|
||||
TextureUsages::TEXTURE_BINDING
|
||||
}
|
||||
_ => TextureUsages::empty(),
|
||||
};
|
||||
|
||||
// Size for tests is chosen so that we don't need to care about buffer alignments.
|
||||
assert_eq!(format_desc.block_dimensions, (1, 1));
|
||||
assert_eq!(format_desc.block_size as u32, BYTES_PER_PIXEL);
|
||||
assert_eq!(
|
||||
(TEXTURE_SIZE.width * format_desc.block_size as u32) % wgpu::COPY_BYTES_PER_ROW_ALIGNMENT,
|
||||
0
|
||||
);
|
||||
let buffer_size = TEXTURE_SIZE.width * TEXTURE_SIZE.height * BYTES_PER_PIXEL;
|
||||
|
||||
let texture = ctx.device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: Some("RenderTarget"),
|
||||
size: TEXTURE_SIZE,
|
||||
mip_level_count: 1,
|
||||
sample_count: 1,
|
||||
dimension: wgpu::TextureDimension::D2,
|
||||
format,
|
||||
usage: if format == wgpu::TextureFormat::Depth24PlusStencil8 {
|
||||
// not allowed to have copy usages!
|
||||
wgpu::TextureUsages::RENDER_ATTACHMENT
|
||||
} else {
|
||||
wgpu::TextureUsages::COPY_DST
|
||||
| wgpu::TextureUsages::COPY_SRC
|
||||
| wgpu::TextureUsages::RENDER_ATTACHMENT
|
||||
},
|
||||
view_formats: &[],
|
||||
});
|
||||
|
||||
// Clear using a write_texture operation. We could also clear using a render_pass clear.
|
||||
// However, when making this test intentionally fail (by breaking wgpu impl), it shows that at least on the tested Vulkan driver,
|
||||
// the later following discard pass in the test (i.e. internally vk::AttachmentStoreOp::DONT_CARE) will yield different depending on the operation we take here:
|
||||
// * clearing white -> discard will cause it to become black!
|
||||
// * clearing red -> discard will keep it red
|
||||
// * write_texture -> discard will keep buffer
|
||||
// This behavior is curious, but does not violate any spec - it is wgpu's job to pass this test no matter what a render target discard does.
|
||||
|
||||
// ... but that said, for depth/stencil textures we need to do a clear.
|
||||
if format_desc.sample_type == wgpu::TextureSampleType::Depth {
|
||||
let mut encoder = ctx
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
|
||||
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: Some("Depth/Stencil setup"),
|
||||
color_attachments: &[],
|
||||
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
|
||||
view: &texture.create_view(&wgpu::TextureViewDescriptor::default()),
|
||||
depth_ops: Some(wgpu::Operations {
|
||||
load: wgpu::LoadOp::Clear(1.0),
|
||||
store: true,
|
||||
}),
|
||||
stencil_ops: Some(wgpu::Operations {
|
||||
load: wgpu::LoadOp::Clear(0xFFFFFFFF),
|
||||
store: true,
|
||||
}),
|
||||
}),
|
||||
});
|
||||
ctx.queue.submit([encoder.finish()]);
|
||||
} else {
|
||||
let data = vec![255; buffer_size as usize];
|
||||
ctx.queue.write_texture(
|
||||
wgpu::ImageCopyTexture {
|
||||
texture: &texture,
|
||||
mip_level: 0,
|
||||
origin: wgpu::Origin3d { x: 0, y: 0, z: 0 },
|
||||
aspect: wgpu::TextureAspect::All,
|
||||
let texture = ctx.device.create_texture(&TextureDescriptor {
|
||||
label: Some("RenderTarget"),
|
||||
size: Extent3d {
|
||||
width: COPY_BYTES_PER_ROW_ALIGNMENT,
|
||||
height: COPY_BYTES_PER_ROW_ALIGNMENT,
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
&data,
|
||||
BUFFER_COPY_LAYOUT,
|
||||
TEXTURE_SIZE,
|
||||
mip_level_count: 1,
|
||||
sample_count: 1,
|
||||
dimension: TextureDimension::D2,
|
||||
format,
|
||||
usage: TextureUsages::COPY_DST
|
||||
| TextureUsages::COPY_SRC
|
||||
| TextureUsages::RENDER_ATTACHMENT
|
||||
| extra_usages,
|
||||
view_formats: &[],
|
||||
});
|
||||
|
||||
// Clear using a write_texture operation. We could also clear using a render_pass clear.
|
||||
// However, when making this test intentionally fail (by breaking wgpu impl), it shows that at least on the tested Vulkan driver,
|
||||
// the later following discard pass in the test (i.e. internally vk::AttachmentStoreOp::DONT_CARE) will yield different depending on the operation we take here:
|
||||
// * clearing white -> discard will cause it to become black!
|
||||
// * clearing red -> discard will keep it red
|
||||
// * write_texture -> discard will keep buffer
|
||||
// This behavior is curious, but does not violate any spec - it is wgpu's job to pass this test no matter what a render target discard does.
|
||||
|
||||
// ... but that said, for depth/stencil textures we need to do a clear.
|
||||
if format.is_depth_stencil_format() {
|
||||
let mut encoder = ctx
|
||||
.device
|
||||
.create_command_encoder(&CommandEncoderDescriptor::default());
|
||||
encoder.begin_render_pass(&RenderPassDescriptor {
|
||||
label: Some("Depth/Stencil setup"),
|
||||
color_attachments: &[],
|
||||
depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
|
||||
view: &texture.create_view(&TextureViewDescriptor::default()),
|
||||
depth_ops: format.has_depth_aspect().then_some(Operations {
|
||||
load: LoadOp::Clear(1.0),
|
||||
store: true,
|
||||
}),
|
||||
stencil_ops: format.has_stencil_aspect().then_some(Operations {
|
||||
load: LoadOp::Clear(0xFFFFFFFF),
|
||||
store: true,
|
||||
}),
|
||||
}),
|
||||
});
|
||||
ctx.queue.submit([encoder.finish()]);
|
||||
} else {
|
||||
let block_size = format.block_size(None).unwrap();
|
||||
let bytes_per_row = texture.width() * block_size;
|
||||
|
||||
// Size for tests is chosen so that we don't need to care about buffer alignments.
|
||||
assert!(!format.is_compressed());
|
||||
assert_eq!(bytes_per_row % COPY_BYTES_PER_ROW_ALIGNMENT, 0);
|
||||
|
||||
let buffer_size = texture.height() * bytes_per_row;
|
||||
let data = vec![255; buffer_size as usize];
|
||||
ctx.queue.write_texture(
|
||||
ImageCopyTexture {
|
||||
texture: &texture,
|
||||
mip_level: 0,
|
||||
origin: Origin3d { x: 0, y: 0, z: 0 },
|
||||
aspect: TextureAspect::All,
|
||||
},
|
||||
&data,
|
||||
ImageDataLayout {
|
||||
offset: 0,
|
||||
bytes_per_row: NonZeroU32::new(bytes_per_row),
|
||||
rows_per_image: None,
|
||||
},
|
||||
texture.size(),
|
||||
);
|
||||
}
|
||||
|
||||
let readback_buffers = ReadbackBuffers::new(&ctx.device, &texture);
|
||||
|
||||
Self {
|
||||
ctx,
|
||||
format,
|
||||
texture,
|
||||
readback_buffers,
|
||||
encoder: None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn create_command_encoder(&mut self) {
|
||||
self.encoder = Some(
|
||||
self.ctx
|
||||
.device
|
||||
.create_command_encoder(&CommandEncoderDescriptor::default()),
|
||||
)
|
||||
}
|
||||
|
||||
pub fn submit_command_encoder(&mut self) {
|
||||
self.ctx
|
||||
.queue
|
||||
.submit([self.encoder.take().unwrap().finish()]);
|
||||
}
|
||||
|
||||
pub fn discard(&mut self) {
|
||||
self.encoder
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.begin_render_pass(&RenderPassDescriptor {
|
||||
label: Some("Discard"),
|
||||
color_attachments: &[self.format.has_color_aspect().then_some(
|
||||
RenderPassColorAttachment {
|
||||
view: &self.texture.create_view(&TextureViewDescriptor::default()),
|
||||
resolve_target: None,
|
||||
ops: Operations {
|
||||
load: LoadOp::Load,
|
||||
store: false, // discard!
|
||||
},
|
||||
},
|
||||
)],
|
||||
depth_stencil_attachment: self.format.is_depth_stencil_format().then_some(
|
||||
RenderPassDepthStencilAttachment {
|
||||
view: &self.texture.create_view(&TextureViewDescriptor::default()),
|
||||
depth_ops: self.format.has_depth_aspect().then_some(Operations {
|
||||
load: LoadOp::Load,
|
||||
store: false, // discard!
|
||||
}),
|
||||
stencil_ops: self.format.has_stencil_aspect().then_some(Operations {
|
||||
load: LoadOp::Load,
|
||||
store: false, // discard!
|
||||
}),
|
||||
},
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
pub fn discard_depth(&mut self) {
|
||||
self.encoder
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.begin_render_pass(&RenderPassDescriptor {
|
||||
label: Some("Discard Depth"),
|
||||
color_attachments: &[],
|
||||
depth_stencil_attachment: self.format.is_depth_stencil_format().then_some(
|
||||
RenderPassDepthStencilAttachment {
|
||||
view: &self.texture.create_view(&TextureViewDescriptor::default()),
|
||||
depth_ops: Some(Operations {
|
||||
load: LoadOp::Load,
|
||||
store: false, // discard!
|
||||
}),
|
||||
stencil_ops: self.format.has_stencil_aspect().then_some(Operations {
|
||||
load: LoadOp::Clear(0),
|
||||
store: true,
|
||||
}),
|
||||
},
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
pub fn discard_stencil(&mut self) {
|
||||
self.encoder
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.begin_render_pass(&RenderPassDescriptor {
|
||||
label: Some("Discard Stencil"),
|
||||
color_attachments: &[],
|
||||
depth_stencil_attachment: self.format.is_depth_stencil_format().then_some(
|
||||
RenderPassDepthStencilAttachment {
|
||||
view: &self.texture.create_view(&TextureViewDescriptor::default()),
|
||||
depth_ops: self.format.has_depth_aspect().then_some(Operations {
|
||||
load: LoadOp::Clear(0.0),
|
||||
store: true,
|
||||
}),
|
||||
stencil_ops: Some(Operations {
|
||||
load: LoadOp::Load,
|
||||
store: false, // discard!
|
||||
}),
|
||||
},
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
pub fn copy_texture_to_buffer(&mut self) {
|
||||
self.readback_buffers.copy_from(
|
||||
&self.ctx.device,
|
||||
self.encoder.as_mut().unwrap(),
|
||||
&self.texture,
|
||||
);
|
||||
}
|
||||
|
||||
(
|
||||
texture,
|
||||
ctx.device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: Some("Texture Readback"),
|
||||
size: buffer_size as u64,
|
||||
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
}),
|
||||
)
|
||||
}
|
||||
|
||||
fn copy_texture_to_buffer(
|
||||
encoder: &mut wgpu::CommandEncoder,
|
||||
texture: &wgpu::Texture,
|
||||
read_back: &wgpu::Buffer,
|
||||
) {
|
||||
encoder.copy_texture_to_buffer(
|
||||
wgpu::ImageCopyTexture {
|
||||
texture,
|
||||
mip_level: 0,
|
||||
origin: wgpu::Origin3d::ZERO,
|
||||
aspect: wgpu::TextureAspect::All,
|
||||
},
|
||||
wgpu::ImageCopyBuffer {
|
||||
buffer: read_back,
|
||||
layout: BUFFER_COPY_LAYOUT,
|
||||
},
|
||||
TEXTURE_SIZE,
|
||||
);
|
||||
}
|
||||
|
||||
fn assert_buffer_is_zero(readback_buffer: &wgpu::Buffer, device: &wgpu::Device) {
|
||||
{
|
||||
let buffer_slice = readback_buffer.slice(..);
|
||||
buffer_slice.map_async(wgpu::MapMode::Read, |_| ());
|
||||
device.poll(wgpu::Maintain::Wait);
|
||||
let buffer_view = buffer_slice.get_mapped_range();
|
||||
|
||||
pub fn assert_buffers_are_zero(&mut self) {
|
||||
assert!(
|
||||
buffer_view.iter().all(|b| *b == 0),
|
||||
self.readback_buffers.are_zero(&self.ctx.device),
|
||||
"texture was not fully cleared"
|
||||
);
|
||||
}
|
||||
readback_buffer.unmap();
|
||||
}
|
||||
Reference in new issue
Block a user