1576: Switch all bitflag names to plural r=cwfitzgerald a=kvark

**Connections**
#1471 added a lot of singular bitflag names. Previously, we weren't really consistent.

**Description**
This PR changes all of the names to be plural, except for a few that don't imply singularity, and are matching WebGPU upstream. Maybe we need to convert them too?

**Testing**
self-tested


Co-authored-by: Dzmitry Malyshau <kvarkus@gmail.com>
This commit is contained in:
bors[bot]andDzmitry Malyshau authored and GitHub committed 2021-06-30 19:02:07 +00:00
commit d8888ccaa5
74 files changed
+818 -819

No files matched your search

+2 -5
View File
@@ -41,11 +41,8 @@ fn main() {
.build(&event_loop)
.unwrap();
let global = wgc::hub::Global::new(
"player",
IdentityPassThroughFactory,
wgt::BackendBit::PRIMARY,
);
let global =
wgc::hub::Global::new("player", IdentityPassThroughFactory, wgt::Backends::PRIMARY);
let mut command_buffer_id_manager = wgc::hub::IdentityManager::default();
#[cfg(feature = "winit")]
+1 -1
View File
@@ -159,7 +159,7 @@ impl Test<'_> {
#[derive(serde::Deserialize)]
struct Corpus {
backends: wgt::BackendBit,
backends: wgt::Backends,
tests: Vec<String>,
}
+19 -19
View File
@@ -158,7 +158,7 @@ pub enum CreateBindGroupError {
#[derive(Clone, Debug, Error)]
pub enum BindingZone {
#[error("stage {0:?}")]
Stage(wgt::ShaderStage),
Stage(wgt::ShaderStages),
#[error("whole pipeline")]
Pipeline,
}
@@ -191,29 +191,29 @@ pub(crate) struct PerStageBindingTypeCounter {
}
impl PerStageBindingTypeCounter {
pub(crate) fn add(&mut self, stage: wgt::ShaderStage, count: u32) {
if stage.contains(wgt::ShaderStage::VERTEX) {
pub(crate) fn add(&mut self, stage: wgt::ShaderStages, count: u32) {
if stage.contains(wgt::ShaderStages::VERTEX) {
self.vertex += count;
}
if stage.contains(wgt::ShaderStage::FRAGMENT) {
if stage.contains(wgt::ShaderStages::FRAGMENT) {
self.fragment += count;
}
if stage.contains(wgt::ShaderStage::COMPUTE) {
if stage.contains(wgt::ShaderStages::COMPUTE) {
self.compute += count;
}
}
pub(crate) fn max(&self) -> (BindingZone, u32) {
let max_value = self.vertex.max(self.fragment.max(self.compute));
let mut stage = wgt::ShaderStage::NONE;
let mut stage = wgt::ShaderStages::NONE;
if max_value == self.vertex {
stage |= wgt::ShaderStage::VERTEX
stage |= wgt::ShaderStages::VERTEX
}
if max_value == self.fragment {
stage |= wgt::ShaderStage::FRAGMENT
stage |= wgt::ShaderStages::FRAGMENT
}
if max_value == self.compute {
stage |= wgt::ShaderStage::COMPUTE
stage |= wgt::ShaderStages::COMPUTE
}
(BindingZone::Stage(stage), max_value)
}
@@ -426,8 +426,8 @@ pub enum CreatePipelineLayoutError {
#[error("push constant range (index {index}) provides for stage(s) {provided:?} but there exists another range that provides stage(s) {intersected:?}. Each stage may only be provided by one range")]
MoreThanOnePushConstantRangePerStage {
index: usize,
provided: wgt::ShaderStage,
intersected: wgt::ShaderStage,
provided: wgt::ShaderStages,
intersected: wgt::ShaderStages,
},
#[error("push constant at index {index} has range {}..{} which exceeds device push constant size limit 0..{max}", range.start, range.end)]
PushConstantRangeTooLarge {
@@ -452,20 +452,20 @@ pub enum PushConstantUploadError {
},
#[error("provided push constant is for stage(s) {actual:?}, stage with a partial match found at index {idx} with stage(s) {matched:?}, however push constants must be complete matches")]
PartialRangeMatch {
actual: wgt::ShaderStage,
actual: wgt::ShaderStages,
idx: usize,
matched: wgt::ShaderStage,
matched: wgt::ShaderStages,
},
#[error("provided push constant is for stage(s) {actual:?}, but intersects a push constant range (at index {idx}) with stage(s) {missing:?}. Push constants must provide the stages for all ranges they intersect")]
MissingStages {
actual: wgt::ShaderStage,
actual: wgt::ShaderStages,
idx: usize,
missing: wgt::ShaderStage,
missing: wgt::ShaderStages,
},
#[error("provided push constant is for stage(s) {actual:?}, however the pipeline layout has no push constant range for the stage(s) {unmatched:?}")]
UnmatchedStages {
actual: wgt::ShaderStage,
unmatched: wgt::ShaderStage,
actual: wgt::ShaderStages,
unmatched: wgt::ShaderStages,
},
#[error("provided push constant offset {0} does not respect `PUSH_CONSTANT_ALIGNMENT`")]
Unaligned(u32),
@@ -504,7 +504,7 @@ impl<A: hal::Api> PipelineLayout<A> {
/// Validate push constants match up with expected ranges.
pub(crate) fn validate_push_constant_ranges(
&self,
stages: wgt::ShaderStage,
stages: wgt::ShaderStages,
offset: u32,
end_offset: u32,
) -> Result<(), PushConstantUploadError> {
@@ -535,7 +535,7 @@ impl<A: hal::Api> PipelineLayout<A> {
// when we check for 1, we can simply check that our entire updated range
// is within a push constant range. i.e. our range for a specific stage cannot
// intersect more than one push constant range.
let mut used_stages = wgt::ShaderStage::NONE;
let mut used_stages = wgt::ShaderStages::NONE;
for (idx, range) in self.push_constant_ranges.iter().enumerate() {
// contains not intersects due to 2
if stages.contains(range.stages) {
+2 -2
View File
@@ -218,7 +218,7 @@ impl Binder {
}
struct PushConstantChange {
stages: wgt::ShaderStage,
stages: wgt::ShaderStages,
offset: u32,
enable: bool,
}
@@ -251,7 +251,7 @@ pub fn compute_nonoverlapping_ranges(
let mut output_ranges = ArrayVec::new();
let mut position = 0_u32;
let mut stages = wgt::ShaderStage::NONE;
let mut stages = wgt::ShaderStages::NONE;
for bk in breaks {
if bk.offset - position > 0 && !stages.is_empty() {
+9 -9
View File
@@ -261,9 +261,9 @@ impl RenderBundleEncoder {
let buffer = state
.trackers
.buffers
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUse::INDEX)
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUses::INDEX)
.unwrap();
check_buffer_usage(buffer.usage, wgt::BufferUsage::INDEX)
check_buffer_usage(buffer.usage, wgt::BufferUsages::INDEX)
.map_pass_err(scope)?;
let end = match size {
@@ -288,9 +288,9 @@ impl RenderBundleEncoder {
let buffer = state
.trackers
.buffers
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUse::VERTEX)
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUses::VERTEX)
.unwrap();
check_buffer_usage(buffer.usage, wgt::BufferUsage::VERTEX)
check_buffer_usage(buffer.usage, wgt::BufferUsages::VERTEX)
.map_pass_err(scope)?;
let end = match size {
@@ -413,9 +413,9 @@ impl RenderBundleEncoder {
let buffer = state
.trackers
.buffers
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUse::INDIRECT)
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUses::INDIRECT)
.unwrap();
check_buffer_usage(buffer.usage, wgt::BufferUsage::INDIRECT)
check_buffer_usage(buffer.usage, wgt::BufferUsages::INDIRECT)
.map_pass_err(scope)?;
buffer_memory_init_actions.extend(
@@ -453,10 +453,10 @@ impl RenderBundleEncoder {
let buffer = state
.trackers
.buffers
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUse::INDIRECT)
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUses::INDIRECT)
.map_err(|err| RenderCommandError::Buffer(buffer_id, err))
.map_pass_err(scope)?;
check_buffer_usage(buffer.usage, wgt::BufferUsage::INDIRECT)
check_buffer_usage(buffer.usage, wgt::BufferUsages::INDIRECT)
.map_pass_err(scope)?;
buffer_memory_init_actions.extend(
@@ -1221,7 +1221,7 @@ pub mod bundle_ffi {
#[no_mangle]
pub unsafe extern "C" fn wgpu_render_bundle_set_push_constants(
pass: &mut RenderBundleEncoder,
stages: wgt::ShaderStage,
stages: wgt::ShaderStages,
offset: u32,
size_bytes: u32,
data: *const u8,
+7 -7
View File
@@ -13,7 +13,7 @@ use crate::{
use hal::CommandEncoder as _;
use thiserror::Error;
use wgt::{
BufferAddress, BufferSize, BufferUsage, ImageSubresourceRange, TextureAspect, TextureUsage,
BufferAddress, BufferSize, BufferUsages, ImageSubresourceRange, TextureAspect, TextureUsages,
};
/// Error encountered while attempting a clear.
@@ -89,13 +89,13 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let (dst_buffer, dst_pending) = cmd_buf
.trackers
.buffers
.use_replace(&*buffer_guard, dst, (), hal::BufferUse::COPY_DST)
.use_replace(&*buffer_guard, dst, (), hal::BufferUses::COPY_DST)
.map_err(ClearError::InvalidBuffer)?;
let dst_raw = dst_buffer
.raw
.as_ref()
.ok_or(ClearError::InvalidBuffer(dst))?;
if !dst_buffer.usage.contains(BufferUsage::COPY_DST) {
if !dst_buffer.usage.contains(BufferUsages::COPY_DST) {
return Err(ClearError::MissingCopyDstUsageFlag(Some(dst), None));
}
@@ -181,8 +181,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
.map_err(|_| ClearError::InvalidTexture(dst))?;
// Check if subresource aspects are valid.
let requested_aspects = hal::FormatAspect::from(subresource_range.aspect);
let clear_aspects = hal::FormatAspect::from(dst_texture.desc.format) & requested_aspects;
let requested_aspects = hal::FormatAspects::from(subresource_range.aspect);
let clear_aspects = hal::FormatAspects::from(dst_texture.desc.format) & requested_aspects;
if clear_aspects.is_empty() {
return Err(ClearError::MissingTextureAspect {
texture_format: dst_texture.desc.format,
@@ -229,14 +229,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
levels: subresource_range.base_mip_level..subresource_level_end,
layers: subresource_range.base_array_layer..subresource_layer_end,
},
hal::TextureUse::COPY_DST,
hal::TextureUses::COPY_DST,
)
.map_err(ClearError::InvalidTexture)?;
let _dst_raw = dst_texture
.raw
.as_ref()
.ok_or(ClearError::InvalidTexture(dst))?;
if !dst_texture.desc.usage.contains(TextureUsage::COPY_DST) {
if !dst_texture.desc.usage.contains(TextureUsages::COPY_DST) {
return Err(ClearError::MissingCopyDstUsageFlag(None, Some(dst)));
}
+6 -7
View File
@@ -17,7 +17,6 @@ use crate::{
use hal::CommandEncoder as _;
use thiserror::Error;
use wgt::{BufferAddress, BufferUsage, ShaderStage};
use std::{fmt, mem, str};
@@ -46,7 +45,7 @@ pub enum ComputeCommand {
Dispatch([u32; 3]),
DispatchIndirect {
buffer_id: id::BufferId,
offset: BufferAddress,
offset: wgt::BufferAddress,
},
PushDebugGroup {
color: u32,
@@ -430,7 +429,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
|clear_offset, clear_data| unsafe {
raw.set_push_constants(
&pipeline_layout.raw,
wgt::ShaderStage::COMPUTE,
wgt::ShaderStages::COMPUTE,
clear_offset,
clear_data,
);
@@ -464,7 +463,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
pipeline_layout
.validate_push_constant_ranges(
ShaderStage::COMPUTE,
wgt::ShaderStages::COMPUTE,
offset,
end_offset_bytes,
)
@@ -473,7 +472,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
unsafe {
raw.set_push_constants(
&pipeline_layout.raw,
wgt::ShaderStage::COMPUTE,
wgt::ShaderStages::COMPUTE,
offset,
data_slice,
);
@@ -514,10 +513,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let indirect_buffer = state
.trackers
.buffers
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUse::INDIRECT)
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUses::INDIRECT)
.map_err(|_| ComputePassErrorInner::InvalidIndirectBuffer(buffer_id))
.map_pass_err(scope)?;
check_buffer_usage(indirect_buffer.usage, BufferUsage::INDIRECT)
check_buffer_usage(indirect_buffer.usage, wgt::BufferUsages::INDIRECT)
.map_pass_err(scope)?;
let end_offset = offset + mem::size_of::<wgt::DispatchIndirectArgs>() as u64;
+2 -2
View File
@@ -12,7 +12,7 @@ use wgt::{BufferAddress, BufferSize, Color};
use std::num::NonZeroU32;
use thiserror::Error;
pub type BufferError = UseExtendError<hal::BufferUse>;
pub type BufferError = UseExtendError<hal::BufferUses>;
/// Error validating a draw call.
#[derive(Clone, Debug, Error, PartialEq)]
@@ -149,7 +149,7 @@ pub enum RenderCommand {
},
SetScissor(Rect<u32>),
SetPushConstant {
stages: wgt::ShaderStage,
stages: wgt::ShaderStages,
offset: u32,
size_bytes: u32,
/// None means there is no data and the data should be an array of zeros.
+2 -2
View File
@@ -351,11 +351,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let (dst_buffer, dst_pending) = cmd_buf
.trackers
.buffers
.use_replace(&*buffer_guard, destination, (), hal::BufferUse::COPY_DST)
.use_replace(&*buffer_guard, destination, (), hal::BufferUses::COPY_DST)
.map_err(QueryError::InvalidBuffer)?;
let dst_barrier = dst_pending.map(|pending| pending.into_hal(dst_buffer));
if !dst_buffer.usage.contains(wgt::BufferUsage::COPY_DST) {
if !dst_buffer.usage.contains(wgt::BufferUsages::COPY_DST) {
return Err(ResolveError::MissingBufferUsage.into());
}
+38 -33
View File
@@ -26,7 +26,7 @@ use arrayvec::ArrayVec;
use hal::CommandEncoder as _;
use thiserror::Error;
use wgt::{
BufferAddress, BufferSize, BufferUsage, Color, IndexFormat, InputStepMode, TextureUsage,
BufferAddress, BufferSize, BufferUsages, Color, IndexFormat, InputStepMode, TextureUsages,
};
#[cfg(any(feature = "serial-pass", feature = "replay"))]
@@ -80,14 +80,14 @@ pub struct PassChannel<V> {
}
impl<V> PassChannel<V> {
fn hal_ops(&self) -> hal::AttachmentOp {
let mut ops = hal::AttachmentOp::empty();
fn hal_ops(&self) -> hal::AttachmentOps {
let mut ops = hal::AttachmentOps::empty();
match self.load_op {
LoadOp::Load => ops |= hal::AttachmentOp::LOAD,
LoadOp::Load => ops |= hal::AttachmentOps::LOAD,
LoadOp::Clear => (),
};
match self.store_op {
StoreOp::Store => ops |= hal::AttachmentOp::STORE,
StoreOp::Store => ops |= hal::AttachmentOps::STORE,
StoreOp::Clear => (),
};
ops
@@ -123,14 +123,14 @@ pub struct RenderPassDepthStencilAttachment {
}
impl RenderPassDepthStencilAttachment {
fn is_read_only(&self, aspects: hal::FormatAspect) -> Result<bool, RenderPassErrorInner> {
if aspects.contains(hal::FormatAspect::DEPTH) && !self.depth.read_only {
fn is_read_only(&self, aspects: hal::FormatAspects) -> Result<bool, RenderPassErrorInner> {
if aspects.contains(hal::FormatAspects::DEPTH) && !self.depth.read_only {
return Ok(false);
}
if (self.depth.load_op, self.depth.store_op) != (LoadOp::Load, StoreOp::Store) {
return Err(RenderPassErrorInner::InvalidDepthOps);
}
if aspects.contains(hal::FormatAspect::STENCIL) && !self.stencil.read_only {
if aspects.contains(hal::FormatAspects::STENCIL) && !self.stencil.read_only {
return Ok(false);
}
if (self.stencil.load_op, self.stencil.store_op) != (LoadOp::Load, StoreOp::Store) {
@@ -491,8 +491,8 @@ where
struct RenderAttachment<'a> {
texture_id: &'a Stored<id::TextureId>,
selector: &'a TextureSelector,
previous_use: Option<hal::TextureUse>,
new_use: hal::TextureUse,
previous_use: Option<hal::TextureUses>,
new_use: hal::TextureUses,
}
type AttachmentDataVec<T> = ArrayVec<[T; hal::MAX_COLOR_TARGETS + hal::MAX_COLOR_TARGETS + 1]>;
@@ -564,7 +564,7 @@ impl<'a, A: HalApi> RenderPassInfo<'a, A> {
add_view(view, "depth")?;
let ds_aspects = view.desc.aspects();
if ds_aspects.contains(hal::FormatAspect::COLOR) {
if ds_aspects.contains(hal::FormatAspects::COLOR) {
return Err(RenderPassErrorInner::InvalidDepthStencilAttachmentFormat(
view.desc.format,
));
@@ -584,9 +584,9 @@ impl<'a, A: HalApi> RenderPassInfo<'a, A> {
.query(source_id.value, view.selector.clone());
let new_use = if at.is_read_only(ds_aspects)? {
is_ds_read_only = true;
hal::TextureUse::DEPTH_STENCIL_READ | hal::TextureUse::SAMPLED
hal::TextureUses::DEPTH_STENCIL_READ | hal::TextureUses::SAMPLED
} else {
hal::TextureUse::DEPTH_STENCIL_WRITE
hal::TextureUses::DEPTH_STENCIL_WRITE
};
render_attachments.push(RenderAttachment {
texture_id: source_id,
@@ -616,7 +616,11 @@ impl<'a, A: HalApi> RenderPassInfo<'a, A> {
.map_err(|_| RenderPassErrorInner::InvalidAttachment(at.view))?;
add_view(color_view, "color")?;
if !color_view.desc.aspects().contains(hal::FormatAspect::COLOR) {
if !color_view
.desc
.aspects()
.contains(hal::FormatAspects::COLOR)
{
return Err(RenderPassErrorInner::InvalidColorAttachmentFormat(
color_view.desc.format,
));
@@ -628,7 +632,7 @@ impl<'a, A: HalApi> RenderPassInfo<'a, A> {
.trackers
.textures
.query(source_id.value, color_view.selector.clone());
let new_use = hal::TextureUse::COLOR_TARGET;
let new_use = hal::TextureUses::COLOR_TARGET;
render_attachments.push(RenderAttachment {
texture_id: source_id,
selector: &color_view.selector,
@@ -643,9 +647,9 @@ impl<'a, A: HalApi> RenderPassInfo<'a, A> {
assert!(used_swap_chain.is_none());
used_swap_chain = Some(source_id.clone());
let end = hal::TextureUse::empty();
let end = hal::TextureUses::empty();
let start = match at.channel.load_op {
LoadOp::Clear => hal::TextureUse::UNINITIALIZED,
LoadOp::Clear => hal::TextureUses::UNINITIALIZED,
LoadOp::Load => end,
};
start..end
@@ -678,7 +682,7 @@ impl<'a, A: HalApi> RenderPassInfo<'a, A> {
.trackers
.textures
.query(source_id.value, resolve_view.selector.clone());
let new_use = hal::TextureUse::COLOR_TARGET;
let new_use = hal::TextureUses::COLOR_TARGET;
render_attachments.push(RenderAttachment {
texture_id: source_id,
selector: &resolve_view.selector,
@@ -692,13 +696,13 @@ impl<'a, A: HalApi> RenderPassInfo<'a, A> {
TextureViewSource::SwapChain(ref source_id) => {
assert!(used_swap_chain.is_none());
used_swap_chain = Some(source_id.clone());
hal::TextureUse::UNINITIALIZED..hal::TextureUse::empty()
hal::TextureUses::UNINITIALIZED..hal::TextureUses::empty()
}
};
hal_resolve_target = Some(hal::Attachment {
view: &resolve_view.raw,
usage: hal::TextureUse::COLOR_TARGET,
usage: hal::TextureUses::COLOR_TARGET,
boundary_usage,
});
}
@@ -706,7 +710,7 @@ impl<'a, A: HalApi> RenderPassInfo<'a, A> {
colors.push(hal::ColorAttachment {
target: hal::Attachment {
view: &color_view.raw,
usage: hal::TextureUse::COLOR_TARGET,
usage: hal::TextureUses::COLOR_TARGET,
boundary_usage,
},
resolve_target: hal_resolve_target,
@@ -769,7 +773,7 @@ impl<'a, A: HalApi> RenderPassInfo<'a, A> {
for ra in self.render_attachments {
let texture = &texture_guard[ra.texture_id.value];
check_texture_usage(texture.desc.usage, TextureUsage::RENDER_ATTACHMENT)?;
check_texture_usage(texture.desc.usage, TextureUsages::RENDER_ATTACHMENT)?;
// the tracker set of the pass is always in "extend" mode
self.trackers
@@ -1104,10 +1108,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let buffer = info
.trackers
.buffers
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUse::INDEX)
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUses::INDEX)
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))
.map_pass_err(scope)?;
check_buffer_usage(buffer.usage, BufferUsage::INDEX).map_pass_err(scope)?;
check_buffer_usage(buffer.usage, BufferUsages::INDEX)
.map_pass_err(scope)?;
let buf_raw = buffer
.raw
.as_ref()
@@ -1153,10 +1158,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let buffer = info
.trackers
.buffers
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUse::VERTEX)
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUses::VERTEX)
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))
.map_pass_err(scope)?;
check_buffer_usage(buffer.usage, BufferUsage::VERTEX)
check_buffer_usage(buffer.usage, BufferUsages::VERTEX)
.map_pass_err(scope)?;
let buf_raw = buffer
.raw
@@ -1408,10 +1413,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let indirect_buffer = info
.trackers
.buffers
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUse::INDIRECT)
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUses::INDIRECT)
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))
.map_pass_err(scope)?;
check_buffer_usage(indirect_buffer.usage, BufferUsage::INDIRECT)
check_buffer_usage(indirect_buffer.usage, BufferUsages::INDIRECT)
.map_pass_err(scope)?;
let indirect_raw = indirect_buffer
.raw
@@ -1482,10 +1487,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let indirect_buffer = info
.trackers
.buffers
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUse::INDIRECT)
.use_extend(&*buffer_guard, buffer_id, (), hal::BufferUses::INDIRECT)
.map_err(|e| RenderCommandError::Buffer(buffer_id, e))
.map_pass_err(scope)?;
check_buffer_usage(indirect_buffer.usage, BufferUsage::INDIRECT)
check_buffer_usage(indirect_buffer.usage, BufferUsages::INDIRECT)
.map_pass_err(scope)?;
let indirect_raw = indirect_buffer
.raw
@@ -1500,11 +1505,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
&*buffer_guard,
count_buffer_id,
(),
hal::BufferUse::INDIRECT,
hal::BufferUses::INDIRECT,
)
.map_err(|e| RenderCommandError::Buffer(count_buffer_id, e))
.map_pass_err(scope)?;
check_buffer_usage(count_buffer.usage, BufferUsage::INDIRECT)
check_buffer_usage(count_buffer.usage, BufferUsages::INDIRECT)
.map_pass_err(scope)?;
let count_raw = count_buffer
.raw
@@ -1889,7 +1894,7 @@ pub mod render_ffi {
#[no_mangle]
pub unsafe extern "C" fn wgpu_render_pass_set_push_constants(
pass: &mut RenderPass,
stages: wgt::ShaderStage,
stages: wgt::ShaderStages,
offset: u32,
size_bytes: u32,
data: *const u8,
+20 -20
View File
@@ -12,7 +12,7 @@ use crate::{
use hal::CommandEncoder as _;
use thiserror::Error;
use wgt::{BufferAddress, BufferUsage, Extent3d, TextureUsage};
use wgt::{BufferAddress, BufferUsages, Extent3d, TextureUsages};
use std::iter;
@@ -112,7 +112,7 @@ pub(crate) fn extract_texture_selector<A: hal::Api>(
let format = texture.desc.format;
let copy_aspect =
hal::FormatAspect::from(format) & hal::FormatAspect::from(copy_texture.aspect);
hal::FormatAspects::from(format) & hal::FormatAspects::from(copy_texture.aspect);
if copy_aspect.is_empty() {
return Err(TransferError::InvalidTextureAspect {
format,
@@ -334,13 +334,13 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let (src_buffer, src_pending) = cmd_buf
.trackers
.buffers
.use_replace(&*buffer_guard, source, (), hal::BufferUse::COPY_SRC)
.use_replace(&*buffer_guard, source, (), hal::BufferUses::COPY_SRC)
.map_err(TransferError::InvalidBuffer)?;
let src_raw = src_buffer
.raw
.as_ref()
.ok_or(TransferError::InvalidBuffer(source))?;
if !src_buffer.usage.contains(BufferUsage::COPY_SRC) {
if !src_buffer.usage.contains(BufferUsages::COPY_SRC) {
return Err(TransferError::MissingCopySrcUsageFlag.into());
}
// expecting only a single barrier
@@ -351,13 +351,13 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let (dst_buffer, dst_pending) = cmd_buf
.trackers
.buffers
.use_replace(&*buffer_guard, destination, (), hal::BufferUse::COPY_DST)
.use_replace(&*buffer_guard, destination, (), hal::BufferUses::COPY_DST)
.map_err(TransferError::InvalidBuffer)?;
let dst_raw = dst_buffer
.raw
.as_ref()
.ok_or(TransferError::InvalidBuffer(destination))?;
if !dst_buffer.usage.contains(BufferUsage::COPY_DST) {
if !dst_buffer.usage.contains(BufferUsages::COPY_DST) {
return Err(TransferError::MissingCopyDstUsageFlag(Some(destination), None).into());
}
let dst_barrier = dst_pending
@@ -472,13 +472,13 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let (src_buffer, src_pending) = cmd_buf
.trackers
.buffers
.use_replace(&*buffer_guard, source.buffer, (), hal::BufferUse::COPY_SRC)
.use_replace(&*buffer_guard, source.buffer, (), hal::BufferUses::COPY_SRC)
.map_err(TransferError::InvalidBuffer)?;
let src_raw = src_buffer
.raw
.as_ref()
.ok_or(TransferError::InvalidBuffer(source.buffer))?;
if !src_buffer.usage.contains(BufferUsage::COPY_SRC) {
if !src_buffer.usage.contains(BufferUsages::COPY_SRC) {
return Err(TransferError::MissingCopySrcUsageFlag.into());
}
let src_barriers = src_pending.map(|pending| pending.into_hal(src_buffer));
@@ -490,14 +490,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
&*texture_guard,
destination.texture,
dst_range,
hal::TextureUse::COPY_DST,
hal::TextureUses::COPY_DST,
)
.unwrap();
let dst_raw = dst_texture
.raw
.as_ref()
.ok_or(TransferError::InvalidTexture(destination.texture))?;
if !dst_texture.desc.usage.contains(TextureUsage::COPY_DST) {
if !dst_texture.desc.usage.contains(TextureUsages::COPY_DST) {
return Err(
TransferError::MissingCopyDstUsageFlag(None, Some(destination.texture)).into(),
);
@@ -601,14 +601,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
&*texture_guard,
source.texture,
src_range,
hal::TextureUse::COPY_SRC,
hal::TextureUses::COPY_SRC,
)
.unwrap();
let src_raw = src_texture
.raw
.as_ref()
.ok_or(TransferError::InvalidTexture(source.texture))?;
if !src_texture.desc.usage.contains(TextureUsage::COPY_SRC) {
if !src_texture.desc.usage.contains(TextureUsages::COPY_SRC) {
return Err(TransferError::MissingCopySrcUsageFlag.into());
}
let src_barriers = src_pending.map(|pending| pending.into_hal(src_texture));
@@ -620,14 +620,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
&*buffer_guard,
destination.buffer,
(),
hal::BufferUse::COPY_DST,
hal::BufferUses::COPY_DST,
)
.map_err(TransferError::InvalidBuffer)?;
let dst_raw = dst_buffer
.raw
.as_ref()
.ok_or(TransferError::InvalidBuffer(destination.buffer))?;
if !dst_buffer.usage.contains(BufferUsage::COPY_DST) {
if !dst_buffer.usage.contains(BufferUsages::COPY_DST) {
return Err(
TransferError::MissingCopyDstUsageFlag(Some(destination.buffer), None).into(),
);
@@ -686,7 +686,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
cmd_buf_raw.transition_textures(src_barriers);
cmd_buf_raw.copy_texture_to_buffer(
src_raw,
hal::TextureUse::COPY_SRC,
hal::TextureUses::COPY_SRC,
dst_raw,
iter::once(region),
);
@@ -740,14 +740,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
&*texture_guard,
source.texture,
src_range,
hal::TextureUse::COPY_SRC,
hal::TextureUses::COPY_SRC,
)
.unwrap();
let src_raw = src_texture
.raw
.as_ref()
.ok_or(TransferError::InvalidTexture(source.texture))?;
if !src_texture.desc.usage.contains(TextureUsage::COPY_SRC) {
if !src_texture.desc.usage.contains(TextureUsages::COPY_SRC) {
return Err(TransferError::MissingCopySrcUsageFlag.into());
}
//TODO: try to avoid this the collection. It's needed because both
@@ -763,14 +763,14 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
&*texture_guard,
destination.texture,
dst_range,
hal::TextureUse::COPY_DST,
hal::TextureUses::COPY_DST,
)
.unwrap();
let dst_raw = dst_texture
.raw
.as_ref()
.ok_or(TransferError::InvalidTexture(destination.texture))?;
if !dst_texture.desc.usage.contains(TextureUsage::COPY_DST) {
if !dst_texture.desc.usage.contains(TextureUsages::COPY_DST) {
return Err(
TransferError::MissingCopyDstUsageFlag(None, Some(destination.texture)).into(),
);
@@ -808,7 +808,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
cmd_buf_raw.transition_textures(barriers.into_iter());
cmd_buf_raw.copy_texture_to_texture(
src_raw,
hal::TextureUse::COPY_SRC,
hal::TextureUses::COPY_SRC,
dst_raw,
iter::once(region),
);
+38 -35
View File
@@ -20,73 +20,76 @@ pub fn is_valid_copy_dst_texture_format(format: wgt::TextureFormat) -> bool {
}
}
pub fn map_buffer_usage(usage: wgt::BufferUsage) -> hal::BufferUse {
let mut u = hal::BufferUse::empty();
pub fn map_buffer_usage(usage: wgt::BufferUsages) -> hal::BufferUses {
let mut u = hal::BufferUses::empty();
u.set(
hal::BufferUse::MAP_READ,
usage.contains(wgt::BufferUsage::MAP_READ),
hal::BufferUses::MAP_READ,
usage.contains(wgt::BufferUsages::MAP_READ),
);
u.set(
hal::BufferUse::MAP_WRITE,
usage.contains(wgt::BufferUsage::MAP_WRITE),
hal::BufferUses::MAP_WRITE,
usage.contains(wgt::BufferUsages::MAP_WRITE),
);
u.set(
hal::BufferUse::COPY_SRC,
usage.contains(wgt::BufferUsage::COPY_SRC),
hal::BufferUses::COPY_SRC,
usage.contains(wgt::BufferUsages::COPY_SRC),
);
u.set(
hal::BufferUse::COPY_DST,
usage.contains(wgt::BufferUsage::COPY_DST),
hal::BufferUses::COPY_DST,
usage.contains(wgt::BufferUsages::COPY_DST),
);
u.set(
hal::BufferUse::INDEX,
usage.contains(wgt::BufferUsage::INDEX),
hal::BufferUses::INDEX,
usage.contains(wgt::BufferUsages::INDEX),
);
u.set(
hal::BufferUse::VERTEX,
usage.contains(wgt::BufferUsage::VERTEX),
hal::BufferUses::VERTEX,
usage.contains(wgt::BufferUsages::VERTEX),
);
u.set(
hal::BufferUse::UNIFORM,
usage.contains(wgt::BufferUsage::UNIFORM),
hal::BufferUses::UNIFORM,
usage.contains(wgt::BufferUsages::UNIFORM),
);
u.set(
hal::BufferUse::STORAGE_LOAD | hal::BufferUse::STORAGE_STORE,
usage.contains(wgt::BufferUsage::STORAGE),
hal::BufferUses::STORAGE_LOAD | hal::BufferUses::STORAGE_STORE,
usage.contains(wgt::BufferUsages::STORAGE),
);
u.set(
hal::BufferUse::INDIRECT,
usage.contains(wgt::BufferUsage::INDIRECT),
hal::BufferUses::INDIRECT,
usage.contains(wgt::BufferUsages::INDIRECT),
);
u
}
pub fn map_texture_usage(usage: wgt::TextureUsage, aspect: hal::FormatAspect) -> hal::TextureUse {
let mut u = hal::TextureUse::empty();
pub fn map_texture_usage(
usage: wgt::TextureUsages,
aspect: hal::FormatAspects,
) -> hal::TextureUses {
let mut u = hal::TextureUses::empty();
u.set(
hal::TextureUse::COPY_SRC,
usage.contains(wgt::TextureUsage::COPY_SRC),
hal::TextureUses::COPY_SRC,
usage.contains(wgt::TextureUsages::COPY_SRC),
);
u.set(
hal::TextureUse::COPY_DST,
usage.contains(wgt::TextureUsage::COPY_DST),
hal::TextureUses::COPY_DST,
usage.contains(wgt::TextureUsages::COPY_DST),
);
u.set(
hal::TextureUse::SAMPLED,
usage.contains(wgt::TextureUsage::SAMPLED),
hal::TextureUses::SAMPLED,
usage.contains(wgt::TextureUsages::SAMPLED),
);
u.set(
hal::TextureUse::STORAGE_LOAD | hal::TextureUse::STORAGE_STORE,
usage.contains(wgt::TextureUsage::STORAGE),
hal::TextureUses::STORAGE_LOAD | hal::TextureUses::STORAGE_STORE,
usage.contains(wgt::TextureUsages::STORAGE),
);
let is_color = aspect.contains(hal::FormatAspect::COLOR);
let is_color = aspect.contains(hal::FormatAspects::COLOR);
u.set(
hal::TextureUse::COLOR_TARGET,
usage.contains(wgt::TextureUsage::RENDER_ATTACHMENT) && is_color,
hal::TextureUses::COLOR_TARGET,
usage.contains(wgt::TextureUsages::RENDER_ATTACHMENT) && is_color,
);
u.set(
hal::TextureUse::DEPTH_STENCIL_READ | hal::TextureUse::DEPTH_STENCIL_WRITE,
usage.contains(wgt::TextureUsage::RENDER_ATTACHMENT) && !is_color,
hal::TextureUses::DEPTH_STENCIL_READ | hal::TextureUses::DEPTH_STENCIL_WRITE,
usage.contains(wgt::TextureUsages::RENDER_ATTACHMENT) && !is_color,
);
u
}
+56 -56
View File
@@ -489,18 +489,18 @@ impl<A: HalApi> Device<A> {
if desc.size % wgt::COPY_BUFFER_ALIGNMENT != 0 {
return Err(resource::CreateBufferError::UnalignedSize);
}
if !desc.usage.contains(wgt::BufferUsage::MAP_WRITE) {
if !desc.usage.contains(wgt::BufferUsages::MAP_WRITE) {
// we are going to be copying into it, internally
usage |= hal::BufferUse::COPY_DST;
usage |= hal::BufferUses::COPY_DST;
}
} else {
// We are required to zero out (initialize) all memory.
// This is done on demand using fill_buffer which requires write transfer usage!
usage |= hal::BufferUse::COPY_DST;
usage |= hal::BufferUses::COPY_DST;
}
let mut memory_flags = hal::MemoryFlag::empty();
memory_flags.set(hal::MemoryFlag::TRANSIENT, transient);
let mut memory_flags = hal::MemoryFlags::empty();
memory_flags.set(hal::MemoryFlags::TRANSIENT, transient);
let hal_desc = hal::BufferDescriptor {
label: desc.label.borrow_option(),
@@ -542,7 +542,7 @@ impl<A: HalApi> Device<A> {
TextureFormat::Depth24Plus | TextureFormat::Depth24PlusStencil8 => {
if desc
.usage
.intersects(wgt::TextureUsage::COPY_SRC | wgt::TextureUsage::COPY_DST)
.intersects(wgt::TextureUsages::COPY_SRC | wgt::TextureUsages::COPY_DST)
{
return Err(resource::CreateTextureError::CannotCopyD24Plus);
}
@@ -583,7 +583,7 @@ impl<A: HalApi> Device<A> {
dimension: desc.dimension,
format: desc.format,
usage: hal_usage,
memory_flags: hal::MemoryFlag::empty(),
memory_flags: hal::MemoryFlags::empty(),
};
let raw = unsafe {
self.raw
@@ -683,8 +683,8 @@ impl<A: HalApi> Device<A> {
_ => {}
}
let full_aspect = hal::FormatAspect::from(texture.desc.format);
let select_aspect = hal::FormatAspect::from(desc.range.aspect);
let full_aspect = hal::FormatAspects::from(texture.desc.format);
let select_aspect = hal::FormatAspects::from(desc.range.aspect);
if (full_aspect & select_aspect).is_empty() {
return Err(resource::CreateTextureViewError::InvalidAspect {
texture_format: texture.desc.format,
@@ -765,10 +765,10 @@ impl<A: HalApi> Device<A> {
extent,
samples: texture.desc.sample_count,
// once a storage - forever a storage
sampled_internal_use: if texture.desc.usage.contains(wgt::TextureUsage::STORAGE) {
hal::TextureUse::SAMPLED | hal::TextureUse::STORAGE_LOAD
sampled_internal_use: if texture.desc.usage.contains(wgt::TextureUsages::STORAGE) {
hal::TextureUses::SAMPLED | hal::TextureUses::STORAGE_LOAD
} else {
hal::TextureUse::SAMPLED
hal::TextureUses::SAMPLED
},
selector,
life_guard: LifeGuard::new(desc.label.borrow_or_default()),
@@ -1037,10 +1037,10 @@ impl<A: HalApi> Device<A> {
error,
})?;
}
if is_writable_storage && entry.visibility.contains(wgt::ShaderStage::VERTEX) {
if is_writable_storage && entry.visibility.contains(wgt::ShaderStages::VERTEX) {
required_features |= wgt::Features::VERTEX_WRITABLE_STORAGE;
}
if is_writable_storage && entry.visibility.contains(wgt::ShaderStage::FRAGMENT) {
if is_writable_storage && entry.visibility.contains(wgt::ShaderStages::FRAGMENT) {
self.require_downlevel_flags(wgt::DownlevelFlags::FRAGMENT_WRITABLE_STORAGE)
.map_err(binding_model::BindGroupLayoutEntryError::MissingDownlevelFlags)
.map_err(|error| binding_model::CreateBindGroupLayoutError::Entry {
@@ -1126,16 +1126,16 @@ impl<A: HalApi> Device<A> {
};
let (pub_usage, internal_use, range_limit) = match binding_ty {
wgt::BufferBindingType::Uniform => (
wgt::BufferUsage::UNIFORM,
hal::BufferUse::UNIFORM,
wgt::BufferUsages::UNIFORM,
hal::BufferUses::UNIFORM,
limits.max_uniform_buffer_binding_size,
),
wgt::BufferBindingType::Storage { read_only } => (
wgt::BufferUsage::STORAGE,
wgt::BufferUsages::STORAGE,
if read_only {
hal::BufferUse::STORAGE_LOAD
hal::BufferUses::STORAGE_LOAD
} else {
hal::BufferUse::STORAGE_STORE
hal::BufferUses::STORAGE_STORE
},
limits.max_storage_buffer_binding_size,
),
@@ -1481,10 +1481,10 @@ impl<A: HalApi> Device<A> {
decl: &wgt::BindGroupLayoutEntry,
view: &crate::resource::TextureView<A>,
expected: &'static str,
) -> Result<(wgt::TextureUsage, hal::TextureUse), binding_model::CreateBindGroupError> {
) -> Result<(wgt::TextureUsages, hal::TextureUses), binding_model::CreateBindGroupError> {
use crate::binding_model::CreateBindGroupError as Error;
if hal::FormatAspect::from(view.desc.format)
.contains(hal::FormatAspect::DEPTH | hal::FormatAspect::STENCIL)
if hal::FormatAspects::from(view.desc.format)
.contains(hal::FormatAspects::DEPTH | hal::FormatAspects::STENCIL)
{
return Err(Error::DepthStencilAspect);
}
@@ -1531,7 +1531,7 @@ impl<A: HalApi> Device<A> {
view_dimension: view.desc.dimension,
});
}
Ok((wgt::TextureUsage::SAMPLED, view.sampled_internal_use))
Ok((wgt::TextureUsages::SAMPLED, view.sampled_internal_use))
}
wgt::BindingType::StorageTexture {
access,
@@ -1553,8 +1553,8 @@ impl<A: HalApi> Device<A> {
});
}
let internal_use = match access {
wgt::StorageTextureAccess::ReadOnly => hal::TextureUse::STORAGE_LOAD,
wgt::StorageTextureAccess::WriteOnly => hal::TextureUse::STORAGE_STORE,
wgt::StorageTextureAccess::ReadOnly => hal::TextureUses::STORAGE_LOAD,
wgt::StorageTextureAccess::WriteOnly => hal::TextureUses::STORAGE_STORE,
wgt::StorageTextureAccess::ReadWrite => {
if !view
.format_features
@@ -1564,10 +1564,10 @@ impl<A: HalApi> Device<A> {
return Err(Error::StorageReadWriteNotSupported(view.desc.format));
}
hal::TextureUse::STORAGE_STORE | hal::TextureUse::STORAGE_LOAD
hal::TextureUses::STORAGE_STORE | hal::TextureUses::STORAGE_LOAD
}
};
Ok((wgt::TextureUsage::STORAGE, internal_use))
Ok((wgt::TextureUsages::STORAGE, internal_use))
}
_ => Err(Error::WrongBindingType {
binding,
@@ -1598,7 +1598,7 @@ impl<A: HalApi> Device<A> {
self.require_features(wgt::Features::PUSH_CONSTANTS)?;
}
let mut used_stages = wgt::ShaderStage::empty();
let mut used_stages = wgt::ShaderStages::empty();
for (index, pc) in desc.push_constant_ranges.iter().enumerate() {
if pc.stages.intersects(used_stages) {
return Err(Error::MoreThanOnePushConstantRangePerStage {
@@ -1764,7 +1764,7 @@ impl<A: HalApi> Device<A> {
.map_err(|_| validation::StageError::InvalidModule)?;
{
let flag = wgt::ShaderStage::COMPUTE;
let flag = wgt::ShaderStages::COMPUTE;
let provided_layouts = match desc.layout {
Some(pipeline_layout_id) => Some(Device::get_introspection_bind_group_layouts(
pipeline_layout_guard
@@ -1885,7 +1885,7 @@ impl<A: HalApi> Device<A> {
}
let mut io = validation::StageIo::default();
let mut validated_stages = wgt::ShaderStage::empty();
let mut validated_stages = wgt::ShaderStages::empty();
let mut vertex_strides = Vec::with_capacity(desc.vertex.buffers.len());
let mut vertex_buffers = Vec::with_capacity(desc.vertex.buffers.len());
@@ -1988,14 +1988,14 @@ impl<A: HalApi> Device<A> {
let format_features = self.describe_format_features(adapter, cs.format)?;
if !format_features
.allowed_usages
.contains(wgt::TextureUsage::RENDER_ATTACHMENT)
.contains(wgt::TextureUsages::RENDER_ATTACHMENT)
{
break Some(pipeline::ColorStateError::FormatNotRenderable(cs.format));
}
if cs.blend.is_some() && !format_features.filterable {
break Some(pipeline::ColorStateError::FormatNotBlendable(cs.format));
}
if !hal::FormatAspect::from(cs.format).contains(hal::FormatAspect::COLOR) {
if !hal::FormatAspects::from(cs.format).contains(hal::FormatAspects::COLOR) {
break Some(pipeline::ColorStateError::FormatNotColor(cs.format));
}
@@ -2011,17 +2011,17 @@ impl<A: HalApi> Device<A> {
if !self
.describe_format_features(adapter, ds.format)?
.allowed_usages
.contains(wgt::TextureUsage::RENDER_ATTACHMENT)
.contains(wgt::TextureUsages::RENDER_ATTACHMENT)
{
break Some(pipeline::DepthStencilStateError::FormatNotRenderable(
ds.format,
));
}
let aspect = hal::FormatAspect::from(ds.format);
if ds.is_depth_enabled() && !aspect.contains(hal::FormatAspect::DEPTH) {
let aspect = hal::FormatAspects::from(ds.format);
if ds.is_depth_enabled() && !aspect.contains(hal::FormatAspects::DEPTH) {
break Some(pipeline::DepthStencilStateError::FormatNotDepth(ds.format));
}
if ds.stencil.is_enabled() && !aspect.contains(hal::FormatAspect::STENCIL) {
if ds.stencil.is_enabled() && !aspect.contains(hal::FormatAspects::STENCIL) {
break Some(pipeline::DepthStencilStateError::FormatNotStencil(
ds.format,
));
@@ -2051,7 +2051,7 @@ impl<A: HalApi> Device<A> {
let vertex_stage = {
let stage = &desc.vertex.stage;
let flag = wgt::ShaderStage::VERTEX;
let flag = wgt::ShaderStages::VERTEX;
let shader_module = shader_module_guard.get(stage.module).map_err(|_| {
pipeline::CreateRenderPipelineError::Stage {
@@ -2097,7 +2097,7 @@ impl<A: HalApi> Device<A> {
let fragment_stage = match desc.fragment {
Some(ref fragment) => {
let flag = wgt::ShaderStage::FRAGMENT;
let flag = wgt::ShaderStages::FRAGMENT;
let shader_module =
shader_module_guard
@@ -2117,7 +2117,7 @@ impl<A: HalApi> Device<A> {
None => None,
};
if validated_stages == wgt::ShaderStage::VERTEX {
if validated_stages == wgt::ShaderStages::VERTEX {
if let Some(ref interface) = shader_module.interface {
io = interface
.check_stage(
@@ -2143,7 +2143,7 @@ impl<A: HalApi> Device<A> {
None => None,
};
if validated_stages.contains(wgt::ShaderStage::FRAGMENT) {
if validated_stages.contains(wgt::ShaderStages::FRAGMENT) {
for (i, state) in color_targets.iter().enumerate() {
match io.get(&(i as wgt::ShaderLocation)) {
Some(ref output) => {
@@ -2171,8 +2171,8 @@ impl<A: HalApi> Device<A> {
}
}
let last_stage = match desc.fragment {
Some(_) => wgt::ShaderStage::FRAGMENT,
None => wgt::ShaderStage::VERTEX,
Some(_) => wgt::ShaderStages::FRAGMENT,
None => wgt::ShaderStages::VERTEX,
};
if desc.layout.is_none() && !validated_stages.contains(last_stage) {
return Err(pipeline::ImplicitLayoutError::ReflectionError(last_stage).into());
@@ -2543,8 +2543,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
if let Some(ref trace) = device.trace {
let mut desc = desc.clone();
let mapped_at_creation = mem::replace(&mut desc.mapped_at_creation, false);
if mapped_at_creation && !desc.usage.contains(wgt::BufferUsage::MAP_WRITE) {
desc.usage |= wgt::BufferUsage::COPY_DST;
if mapped_at_creation && !desc.usage.contains(wgt::BufferUsages::MAP_WRITE) {
desc.usage |= wgt::BufferUsages::COPY_DST;
}
trace
.lock()
@@ -2558,8 +2558,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let ref_count = buffer.life_guard.add_ref();
let buffer_use = if !desc.mapped_at_creation {
hal::BufferUse::empty()
} else if desc.usage.contains(wgt::BufferUsage::MAP_WRITE) {
hal::BufferUses::empty()
} else if desc.usage.contains(wgt::BufferUsages::MAP_WRITE) {
// buffer is mappable, so we are just doing that at start
let map_size = buffer.size;
let ptr = match map_buffer(&device.raw, &mut buffer, 0, map_size, HostMap::Write) {
@@ -2577,13 +2577,13 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
range: 0..map_size,
host: HostMap::Write,
};
hal::BufferUse::MAP_WRITE
hal::BufferUses::MAP_WRITE
} else {
// buffer needs staging area for initialization only
let stage_desc = wgt::BufferDescriptor {
label: Some(Cow::Borrowed("<init_buffer>")),
size: desc.size,
usage: wgt::BufferUsage::MAP_WRITE | wgt::BufferUsage::COPY_SRC,
usage: wgt::BufferUsages::MAP_WRITE | wgt::BufferUsages::COPY_SRC,
mapped_at_creation: false,
};
let mut stage = match device.create_buffer(device_id, &stage_desc, true) {
@@ -2623,7 +2623,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
needs_flush: !mapping.is_coherent,
stage_buffer,
};
hal::BufferUse::COPY_DST
hal::BufferUses::COPY_DST
};
let id = fid.assign(buffer, &mut token);
@@ -2686,7 +2686,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let buffer = buffer_guard
.get_mut(buffer_id)
.map_err(|_| resource::BufferAccessError::Invalid)?;
check_buffer_usage(buffer.usage, wgt::BufferUsage::MAP_WRITE)?;
check_buffer_usage(buffer.usage, wgt::BufferUsages::MAP_WRITE)?;
//assert!(buffer isn't used by the GPU);
#[cfg(feature = "trace")]
@@ -2743,7 +2743,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let buffer = buffer_guard
.get_mut(buffer_id)
.map_err(|_| resource::BufferAccessError::Invalid)?;
check_buffer_usage(buffer.usage, wgt::BufferUsage::MAP_READ)?;
check_buffer_usage(buffer.usage, wgt::BufferUsages::MAP_READ)?;
//assert!(buffer isn't used by the GPU);
let raw_buf = buffer.raw.as_ref().unwrap();
@@ -4221,7 +4221,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
height: desc.height,
depth_or_array_layers: 1,
},
usage: conv::map_texture_usage(desc.usage, hal::FormatAspect::COLOR),
usage: conv::map_texture_usage(desc.usage, hal::FormatAspects::COLOR),
};
if let Err(error) = validate_swap_chain_descriptor(&mut config, &caps) {
@@ -4409,8 +4409,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let mut token = Token::root();
let (device_guard, mut token) = hub.devices.read(&mut token);
let (pub_usage, internal_use) = match op.host {
HostMap::Read => (wgt::BufferUsage::MAP_READ, hal::BufferUse::MAP_READ),
HostMap::Write => (wgt::BufferUsage::MAP_WRITE, hal::BufferUse::MAP_WRITE),
HostMap::Read => (wgt::BufferUsages::MAP_READ, hal::BufferUses::MAP_READ),
HostMap::Write => (wgt::BufferUsages::MAP_WRITE, hal::BufferUses::MAP_WRITE),
};
if range.start % wgt::MAP_ALIGNMENT != 0 || range.end % wgt::COPY_BUFFER_ALIGNMENT != 0 {
@@ -4580,11 +4580,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
});
let transition_src = hal::BufferBarrier {
buffer: &stage_buffer,
usage: hal::BufferUse::MAP_WRITE..hal::BufferUse::COPY_SRC,
usage: hal::BufferUses::MAP_WRITE..hal::BufferUses::COPY_SRC,
};
let transition_dst = hal::BufferBarrier {
buffer: raw_buf,
usage: hal::BufferUse::empty()..hal::BufferUse::COPY_DST,
usage: hal::BufferUses::empty()..hal::BufferUses::COPY_DST,
};
let encoder = device.pending_writes.activate();
unsafe {
+9 -9
View File
@@ -207,8 +207,8 @@ impl<A: hal::Api> super::Device<A> {
let stage_desc = hal::BufferDescriptor {
label: Some("_Staging"),
size,
usage: hal::BufferUse::MAP_WRITE | hal::BufferUse::COPY_SRC,
memory_flags: hal::MemoryFlag::TRANSIENT,
usage: hal::BufferUses::MAP_WRITE | hal::BufferUses::COPY_SRC,
memory_flags: hal::MemoryFlags::TRANSIENT,
};
let buffer = unsafe { self.raw.create_buffer(&stage_desc)? };
Ok(StagingData { buffer })
@@ -242,7 +242,7 @@ impl<A: hal::Api> super::Device<A> {
let transition = trackers.buffers.change_replace_tracked(
id::Valid(buffer_id),
(),
hal::BufferUse::COPY_DST,
hal::BufferUses::COPY_DST,
);
let buffer = buffer_guard.get(buffer_id).unwrap();
let raw_buf = buffer
@@ -339,13 +339,13 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let mut trackers = device.trackers.lock();
let (dst, transition) = trackers
.buffers
.use_replace(&*buffer_guard, buffer_id, (), hal::BufferUse::COPY_DST)
.use_replace(&*buffer_guard, buffer_id, (), hal::BufferUses::COPY_DST)
.map_err(TransferError::InvalidBuffer)?;
let dst_raw = dst
.raw
.as_ref()
.ok_or(TransferError::InvalidBuffer(buffer_id))?;
if !dst.usage.contains(wgt::BufferUsage::COPY_DST) {
if !dst.usage.contains(wgt::BufferUsages::COPY_DST) {
return Err(TransferError::MissingCopyDstUsageFlag(Some(buffer_id), None).into());
}
dst.life_guard.use_at(device.active_submission_index + 1);
@@ -373,7 +373,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
});
let barriers = iter::once(hal::BufferBarrier {
buffer: &stage.buffer,
usage: hal::BufferUse::MAP_WRITE..hal::BufferUse::COPY_SRC,
usage: hal::BufferUses::MAP_WRITE..hal::BufferUses::COPY_SRC,
})
.chain(transition.map(|pending| pending.into_hal(dst)));
let encoder = device.pending_writes.activate();
@@ -482,7 +482,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
&*texture_guard,
destination.texture,
selector,
hal::TextureUse::COPY_DST,
hal::TextureUses::COPY_DST,
)
.unwrap();
let dst_raw = dst
@@ -490,7 +490,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
.as_ref()
.ok_or(TransferError::InvalidTexture(destination.texture))?;
if !dst.desc.usage.contains(wgt::TextureUsage::COPY_DST) {
if !dst.desc.usage.contains(wgt::TextureUsages::COPY_DST) {
return Err(
TransferError::MissingCopyDstUsageFlag(None, Some(destination.texture)).into(),
);
@@ -562,7 +562,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let barrier = hal::BufferBarrier {
buffer: &stage.buffer,
usage: hal::BufferUse::MAP_WRITE..hal::BufferUse::COPY_SRC,
usage: hal::BufferUses::MAP_WRITE..hal::BufferUses::COPY_SRC,
};
let encoder = device.pending_writes.activate();
unsafe {
+1 -1
View File
@@ -750,7 +750,7 @@ pub struct Global<G: GlobalIdentityHandlerFactory> {
}
impl<G: GlobalIdentityHandlerFactory> Global<G> {
pub fn new(name: &str, factory: G, backends: wgt::BackendBit) -> Self {
pub fn new(name: &str, factory: G, backends: wgt::Backends) -> Self {
profiling::scope!("new", "Global");
Self {
instance: Instance::new(name, backends),
+17 -17
View File
@@ -5,7 +5,7 @@ use crate::{
LabelHelpers, LifeGuard, Stored, DOWNLEVEL_WARNING_MESSAGE,
};
use wgt::{Backend, BackendBit, PowerPreference, BIND_BUFFER_ALIGNMENT};
use wgt::{Backend, Backends, PowerPreference, BIND_BUFFER_ALIGNMENT};
use hal::{Adapter as _, Instance as _};
use thiserror::Error;
@@ -30,13 +30,13 @@ pub struct Instance {
}
impl Instance {
pub fn new(name: &str, backends: BackendBit) -> Self {
fn init<A: HalApi>(mask: BackendBit) -> Option<A::Instance> {
pub fn new(name: &str, backends: Backends) -> Self {
fn init<A: HalApi>(mask: Backends) -> Option<A::Instance> {
if mask.contains(A::VARIANT.into()) {
let mut flags = hal::InstanceFlag::empty();
let mut flags = hal::InstanceFlags::empty();
if cfg!(debug_assertions) {
flags |= hal::InstanceFlag::VALIDATION;
flags |= hal::InstanceFlag::DEBUG;
flags |= hal::InstanceFlags::VALIDATION;
flags |= hal::InstanceFlags::DEBUG;
}
let hal_desc = hal::InstanceDescriptor {
name: "wgpu",
@@ -161,32 +161,32 @@ impl<A: HalApi> Adapter<A> {
let mut allowed_usages = format.describe().guaranteed_format_features.allowed_usages;
allowed_usages.set(
wgt::TextureUsage::SAMPLED,
caps.contains(hal::TextureFormatCapability::SAMPLED),
wgt::TextureUsages::SAMPLED,
caps.contains(hal::TextureFormatCapabilities::SAMPLED),
);
allowed_usages.set(
wgt::TextureUsage::STORAGE,
caps.contains(hal::TextureFormatCapability::STORAGE),
wgt::TextureUsages::STORAGE,
caps.contains(hal::TextureFormatCapabilities::STORAGE),
);
allowed_usages.set(
wgt::TextureUsage::RENDER_ATTACHMENT,
wgt::TextureUsages::RENDER_ATTACHMENT,
caps.intersects(
hal::TextureFormatCapability::COLOR_ATTACHMENT
| hal::TextureFormatCapability::DEPTH_STENCIL_ATTACHMENT,
hal::TextureFormatCapabilities::COLOR_ATTACHMENT
| hal::TextureFormatCapabilities::DEPTH_STENCIL_ATTACHMENT,
),
);
let mut flags = wgt::TextureFormatFeatureFlags::empty();
flags.set(
wgt::TextureFormatFeatureFlags::STORAGE_ATOMICS,
caps.contains(hal::TextureFormatCapability::STORAGE_ATOMIC),
caps.contains(hal::TextureFormatCapabilities::STORAGE_ATOMIC),
);
flags.set(
wgt::TextureFormatFeatureFlags::STORAGE_READ_WRITE,
caps.contains(hal::TextureFormatCapability::STORAGE_READ_WRITE),
caps.contains(hal::TextureFormatCapabilities::STORAGE_READ_WRITE),
);
let filterable = caps.contains(hal::TextureFormatCapability::SAMPLED_LINEAR);
let filterable = caps.contains(hal::TextureFormatCapabilities::SAMPLED_LINEAR);
wgt::TextureFormatFeatures {
allowed_usages,
@@ -307,7 +307,7 @@ pub enum RequestDeviceError {
pub enum AdapterInputs<'a, I> {
IdSet(&'a [I], fn(&I) -> Backend),
Mask(BackendBit, fn(Backend) -> I),
Mask(Backends, fn(Backend) -> I),
}
impl<I: Clone> AdapterInputs<'_, I> {
+3 -3
View File
@@ -78,7 +78,7 @@ pub enum ImplicitLayoutError {
#[error("missing IDs for deriving {0} bind groups")]
MissingIds(ImplicitBindGroupCount),
#[error("unable to reflect the shader {0:?} interface")]
ReflectionError(wgt::ShaderStage),
ReflectionError(wgt::ShaderStages),
#[error(transparent)]
BindGroup(#[from] CreateBindGroupLayoutError),
#[error(transparent)]
@@ -259,13 +259,13 @@ pub enum CreateRenderPipelineError {
MissingDownlevelFlags(#[from] MissingDownlevelFlags),
#[error("error matching {stage:?} shader requirements against the pipeline")]
Stage {
stage: wgt::ShaderStage,
stage: wgt::ShaderStages,
#[source]
error: validation::StageError,
},
#[error("Internal error in {stage:?} shader: {error}")]
Internal {
stage: wgt::ShaderStage,
stage: wgt::ShaderStages,
error: String,
},
}
+7 -7
View File
@@ -118,7 +118,7 @@ pub type BufferDescriptor<'a> = wgt::BufferDescriptor<Label<'a>>;
pub struct Buffer<A: hal::Api> {
pub(crate) raw: Option<A::Buffer>,
pub(crate) device_id: Stored<DeviceId>,
pub(crate) usage: wgt::BufferUsage,
pub(crate) usage: wgt::BufferUsages,
pub(crate) size: wgt::BufferAddress,
pub(crate) initialization_status: MemoryInitTracker,
pub(crate) sync_mapped_writes: Option<hal::MemoryRange>,
@@ -137,7 +137,7 @@ pub enum CreateBufferError {
#[error("Buffers cannot have empty usage flags")]
EmptyUsage,
#[error("`MAP` usage can only be combined with the opposite `COPY`, requested {0:?}")]
UsageMismatch(wgt::BufferUsage),
UsageMismatch(wgt::BufferUsages),
}
impl<A: hal::Api> Resource for Buffer<A> {
@@ -161,7 +161,7 @@ pub struct Texture<A: hal::Api> {
pub(crate) raw: Option<A::Texture>,
pub(crate) device_id: Stored<DeviceId>,
pub(crate) desc: wgt::TextureDescriptor<()>,
pub(crate) hal_usage: hal::TextureUse,
pub(crate) hal_usage: hal::TextureUses,
pub(crate) format_features: wgt::TextureFormatFeatures,
pub(crate) full_range: TextureSelector,
pub(crate) life_guard: LifeGuard,
@@ -201,7 +201,7 @@ pub enum CreateTextureError {
#[error("texture descriptor mip level count ({0}) is invalid")]
InvalidMipLevelCount(u32),
#[error("The texture usages {0:?} are not allowed on a texture of type {1:?}")]
InvalidUsages(wgt::TextureUsage, wgt::TextureFormat),
InvalidUsages(wgt::TextureUsages, wgt::TextureFormat),
#[error("Texture format {0:?} can't be used")]
MissingFeatures(wgt::TextureFormat, #[source] MissingFeatures),
}
@@ -251,8 +251,8 @@ pub(crate) struct HalTextureViewDescriptor {
}
impl HalTextureViewDescriptor {
pub fn aspects(&self) -> hal::FormatAspect {
hal::FormatAspect::from(self.format) & hal::FormatAspect::from(self.range.aspect)
pub fn aspects(&self) -> hal::FormatAspects {
hal::FormatAspects::from(self.format) & hal::FormatAspects::from(self.range.aspect)
}
}
@@ -266,7 +266,7 @@ pub struct TextureView<A: hal::Api> {
pub(crate) extent: wgt::Extent3d,
pub(crate) samples: u32,
/// Internal use of this texture view when used as `BindingType::Texture`.
pub(crate) sampled_internal_use: hal::TextureUse,
pub(crate) sampled_internal_use: hal::TextureUses,
pub(crate) selector: TextureSelector,
pub(crate) life_guard: LifeGuard,
}
+3 -3
View File
@@ -170,7 +170,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
label: Some("_Frame"),
format: sc.desc.format,
dimension: wgt::TextureViewDimension::D2,
usage: hal::TextureUse::COLOR_TARGET,
usage: hal::TextureUses::COLOR_TARGET,
range: wgt::ImageSubresourceRange::default(),
};
@@ -194,7 +194,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
range: wgt::ImageSubresourceRange::default(),
},
format_features: wgt::TextureFormatFeatures {
allowed_usages: wgt::TextureUsage::RENDER_ATTACHMENT,
allowed_usages: wgt::TextureUsages::RENDER_ATTACHMENT,
flags: wgt::TextureFormatFeatureFlags::empty(),
filterable: false,
},
@@ -204,7 +204,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
depth_or_array_layers: 1,
},
samples: 1,
sampled_internal_use: hal::TextureUse::empty(),
sampled_internal_use: hal::TextureUses::empty(),
selector: TextureSelector {
layers: 0..1,
levels: 0..1,
+31 -31
View File
@@ -1,14 +1,14 @@
use super::{PendingTransition, ResourceState, Unit};
use crate::id::{BufferId, Valid};
use hal::BufferUse;
use hal::BufferUses;
pub(crate) type BufferState = Unit<BufferUse>;
pub(crate) type BufferState = Unit<BufferUses>;
impl PendingTransition<BufferState> {
fn collapse(self) -> Result<BufferUse, Self> {
fn collapse(self) -> Result<BufferUses, Self> {
if self.usage.start.is_empty()
|| self.usage.start == self.usage.end
|| !BufferUse::WRITE_ALL.intersects(self.usage.start | self.usage.end)
|| !BufferUses::WRITE_ALL.intersects(self.usage.start | self.usage.end)
{
Ok(self.usage.start | self.usage.end)
} else {
@@ -21,13 +21,13 @@ impl Default for BufferState {
fn default() -> Self {
Self {
first: None,
last: BufferUse::empty(),
last: BufferUses::empty(),
}
}
}
impl BufferState {
pub fn with_usage(usage: BufferUse) -> Self {
pub fn with_usage(usage: BufferUses) -> Self {
Unit::new(usage)
}
}
@@ -35,7 +35,7 @@ impl BufferState {
impl ResourceState for BufferState {
type Id = BufferId;
type Selector = ();
type Usage = BufferUse;
type Usage = BufferUses;
fn query(&self, _selector: Self::Selector) -> Option<Self::Usage> {
Some(self.last)
@@ -49,7 +49,7 @@ impl ResourceState for BufferState {
output: Option<&mut Vec<PendingTransition<Self>>>,
) -> Result<(), PendingTransition<Self>> {
let old = self.last;
if old != usage || !BufferUse::ORDERED.contains(usage) {
if old != usage || !BufferUses::ORDERED.contains(usage) {
let pending = PendingTransition {
id,
selector: (),
@@ -102,7 +102,7 @@ impl ResourceState for BufferState {
) -> Result<(), PendingTransition<Self>> {
let old = self.last;
let new = other.port();
if old == new && BufferUse::ORDERED.contains(new) {
if old == new && BufferUses::ORDERED.contains(new) {
if output.is_some() && self.first.is_none() {
self.first = Some(old);
}
@@ -144,64 +144,64 @@ mod test {
fn change_extend() {
let mut bs = Unit {
first: None,
last: BufferUse::INDEX,
last: BufferUses::INDEX,
};
let id = Id::dummy();
assert_eq!(
bs.change(id, (), BufferUse::STORAGE_STORE, None),
bs.change(id, (), BufferUses::STORAGE_STORE, None),
Err(PendingTransition {
id,
selector: (),
usage: BufferUse::INDEX..BufferUse::STORAGE_STORE,
usage: BufferUses::INDEX..BufferUses::STORAGE_STORE,
}),
);
bs.change(id, (), BufferUse::VERTEX, None).unwrap();
bs.change(id, (), BufferUse::INDEX, None).unwrap();
assert_eq!(bs, Unit::new(BufferUse::VERTEX | BufferUse::INDEX));
bs.change(id, (), BufferUses::VERTEX, None).unwrap();
bs.change(id, (), BufferUses::INDEX, None).unwrap();
assert_eq!(bs, Unit::new(BufferUses::VERTEX | BufferUses::INDEX));
}
#[test]
fn change_replace() {
let mut bs = Unit {
first: None,
last: BufferUse::STORAGE_STORE,
last: BufferUses::STORAGE_STORE,
};
let id = Id::dummy();
let mut list = Vec::new();
bs.change(id, (), BufferUse::VERTEX, Some(&mut list))
bs.change(id, (), BufferUses::VERTEX, Some(&mut list))
.unwrap();
assert_eq!(
&list,
&[PendingTransition {
id,
selector: (),
usage: BufferUse::STORAGE_STORE..BufferUse::VERTEX,
usage: BufferUses::STORAGE_STORE..BufferUses::VERTEX,
}],
);
assert_eq!(
bs,
Unit {
first: Some(BufferUse::STORAGE_STORE),
last: BufferUse::VERTEX,
first: Some(BufferUses::STORAGE_STORE),
last: BufferUses::VERTEX,
}
);
list.clear();
bs.change(id, (), BufferUse::STORAGE_STORE, Some(&mut list))
bs.change(id, (), BufferUses::STORAGE_STORE, Some(&mut list))
.unwrap();
assert_eq!(
&list,
&[PendingTransition {
id,
selector: (),
usage: BufferUse::VERTEX..BufferUse::STORAGE_STORE,
usage: BufferUses::VERTEX..BufferUses::STORAGE_STORE,
}],
);
assert_eq!(
bs,
Unit {
first: Some(BufferUse::STORAGE_STORE),
last: BufferUse::STORAGE_STORE,
first: Some(BufferUses::STORAGE_STORE),
last: BufferUses::STORAGE_STORE,
}
);
}
@@ -210,24 +210,24 @@ mod test {
fn prepend() {
let mut bs = Unit {
first: None,
last: BufferUse::VERTEX,
last: BufferUses::VERTEX,
};
let id = Id::dummy();
bs.prepend(id, (), BufferUse::INDEX).unwrap();
bs.prepend(id, (), BufferUse::INDEX).unwrap();
bs.prepend(id, (), BufferUses::INDEX).unwrap();
bs.prepend(id, (), BufferUses::INDEX).unwrap();
assert_eq!(
bs.prepend(id, (), BufferUse::STORAGE_LOAD),
bs.prepend(id, (), BufferUses::STORAGE_LOAD),
Err(PendingTransition {
id,
selector: (),
usage: BufferUse::INDEX..BufferUse::STORAGE_LOAD,
usage: BufferUses::INDEX..BufferUses::STORAGE_LOAD,
})
);
assert_eq!(
bs,
Unit {
first: Some(BufferUse::INDEX),
last: BufferUse::VERTEX,
first: Some(BufferUses::INDEX),
last: BufferUses::VERTEX,
}
);
}
+2 -2
View File
@@ -558,14 +558,14 @@ pub enum UsageConflict {
)]
Buffer {
id: id::BufferId,
combined_use: hal::BufferUse,
combined_use: hal::BufferUses,
},
#[error("Attempted to use texture {id:?} mips {mip_levels:?} layers {array_layers:?} as a combination of {combined_use:?} within a usage scope.")]
Texture {
id: id::TextureId,
mip_levels: ops::Range<u32>,
array_layers: ops::Range<u32>,
combined_use: hal::TextureUse,
combined_use: hal::TextureUses,
},
}
+36 -36
View File
@@ -1,17 +1,17 @@
use super::{range::RangedStates, PendingTransition, ResourceState, Unit};
use crate::id::{TextureId, Valid};
use hal::TextureUse;
use hal::TextureUses;
use arrayvec::ArrayVec;
use std::{iter, ops::Range};
type PlaneStates = RangedStates<u32, Unit<TextureUse>>;
type PlaneStates = RangedStates<u32, Unit<TextureUses>>;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TextureSelector {
//TODO: rename to `mip_levels` and `array_layers` for consistency
//pub aspects: hal::FormatAspect,
//pub aspects: hal::FormatAspects,
pub levels: Range<u32>,
pub layers: Range<u32>,
}
@@ -24,10 +24,10 @@ pub(crate) struct TextureState {
}
impl PendingTransition<TextureState> {
fn collapse(self) -> Result<TextureUse, Self> {
fn collapse(self) -> Result<TextureUses, Self> {
if self.usage.start.is_empty()
|| self.usage.start == self.usage.end
|| !TextureUse::WRITE_ALL.intersects(self.usage.start | self.usage.end)
|| !TextureUses::WRITE_ALL.intersects(self.usage.start | self.usage.end)
{
Ok(self.usage.start | self.usage.end)
} else {
@@ -40,7 +40,7 @@ impl TextureState {
pub fn new(mip_level_count: u32, array_layer_count: u32) -> Self {
Self {
mips: iter::repeat_with(|| {
PlaneStates::from_range(0..array_layer_count, Unit::new(TextureUse::UNINITIALIZED))
PlaneStates::from_range(0..array_layer_count, Unit::new(TextureUses::UNINITIALIZED))
})
.take(mip_level_count as usize)
.collect(),
@@ -52,7 +52,7 @@ impl TextureState {
impl ResourceState for TextureState {
type Id = TextureId;
type Selector = TextureSelector;
type Usage = TextureUse;
type Usage = TextureUses;
fn query(&self, selector: Self::Selector) -> Option<Self::Usage> {
let mut result = None;
@@ -100,7 +100,7 @@ impl ResourceState for TextureState {
let level = selector.levels.start + mip_id as u32;
let layers = mip.isolate(&selector.layers, Unit::new(usage));
for &mut (ref range, ref mut unit) in layers {
if unit.last == usage && TextureUse::ORDERED.contains(usage) {
if unit.last == usage && TextureUses::ORDERED.contains(usage) {
continue;
}
// TODO: Can't satisfy clippy here unless we modify
@@ -209,7 +209,7 @@ impl ResourceState for TextureState {
end: Some(end),
} => {
let to_usage = end.port();
if start.last == to_usage && TextureUse::ORDERED.contains(to_usage) {
if start.last == to_usage && TextureUses::ORDERED.contains(to_usage) {
Unit {
first: match output {
None => start.first,
@@ -275,9 +275,9 @@ mod test {
let mut ts = TextureState::default();
ts.mips.push(PlaneStates::empty());
ts.mips.push(PlaneStates::from_slice(&[
(1..3, Unit::new(TextureUse::SAMPLED)),
(3..5, Unit::new(TextureUse::SAMPLED)),
(5..6, Unit::new(TextureUse::STORAGE_LOAD)),
(1..3, Unit::new(TextureUses::SAMPLED)),
(3..5, Unit::new(TextureUses::SAMPLED)),
(5..6, Unit::new(TextureUses::STORAGE_LOAD)),
]));
assert_eq!(
@@ -286,7 +286,7 @@ mod test {
layers: 2..5,
}),
// level 1 matches
Some(TextureUse::SAMPLED),
Some(TextureUses::SAMPLED),
);
assert_eq!(
ts.query(TextureSelector {
@@ -294,7 +294,7 @@ mod test {
layers: 2..5,
}),
// level 0 is empty, level 1 matches
Some(TextureUse::SAMPLED),
Some(TextureUses::SAMPLED),
);
assert_eq!(
ts.query(TextureSelector {
@@ -302,7 +302,7 @@ mod test {
layers: 1..5,
}),
// level 1 matches with gaps
Some(TextureUse::SAMPLED),
Some(TextureUses::SAMPLED),
);
assert_eq!(
ts.query(TextureSelector {
@@ -320,7 +320,7 @@ mod test {
let mut ts1 = TextureState::default();
ts1.mips.push(PlaneStates::from_slice(&[(
1..3,
Unit::new(TextureUse::SAMPLED),
Unit::new(TextureUses::SAMPLED),
)]));
let mut ts2 = TextureState::default();
assert_eq!(
@@ -331,7 +331,7 @@ mod test {
ts2.mips.push(PlaneStates::from_slice(&[(
1..2,
Unit::new(TextureUse::COPY_SRC),
Unit::new(TextureUses::COPY_SRC),
)]));
assert_eq!(
ts1.merge(Id::dummy(), &ts2, None),
@@ -342,12 +342,12 @@ mod test {
ts1.mips[0].query(&(1..2), |&v| v),
Some(Ok(Unit {
first: None,
last: TextureUse::SAMPLED | TextureUse::COPY_SRC,
last: TextureUses::SAMPLED | TextureUses::COPY_SRC,
})),
"wrong extension result"
);
ts2.mips[0] = PlaneStates::from_slice(&[(1..2, Unit::new(TextureUse::COPY_DST))]);
ts2.mips[0] = PlaneStates::from_slice(&[(1..2, Unit::new(TextureUses::COPY_DST))]);
assert_eq!(
ts1.clone().merge(Id::dummy(), &ts2, None),
Err(PendingTransition {
@@ -356,19 +356,19 @@ mod test {
levels: 0..1,
layers: 1..2,
},
usage: TextureUse::SAMPLED | TextureUse::COPY_SRC..TextureUse::COPY_DST,
usage: TextureUses::SAMPLED | TextureUses::COPY_SRC..TextureUses::COPY_DST,
}),
"wrong error on extending with incompatible state"
);
let mut list = Vec::new();
ts2.mips[0] = PlaneStates::from_slice(&[
(1..2, Unit::new(TextureUse::COPY_DST)),
(1..2, Unit::new(TextureUses::COPY_DST)),
(
2..3,
Unit {
first: Some(TextureUse::COPY_SRC),
last: TextureUse::COLOR_TARGET,
first: Some(TextureUses::COPY_SRC),
last: TextureUses::COLOR_TARGET,
},
),
]);
@@ -382,7 +382,7 @@ mod test {
levels: 0..1,
layers: 1..2,
},
usage: TextureUse::SAMPLED | TextureUse::COPY_SRC..TextureUse::COPY_DST,
usage: TextureUses::SAMPLED | TextureUses::COPY_SRC..TextureUses::COPY_DST,
},
PendingTransition {
id,
@@ -392,7 +392,7 @@ mod test {
},
// the transition links the end of the base rage (..SAMPLED)
// with the start of the next range (COPY_SRC..)
usage: TextureUse::SAMPLED..TextureUse::COPY_SRC,
usage: TextureUses::SAMPLED..TextureUses::COPY_SRC,
},
],
"replacing produced wrong transitions"
@@ -400,16 +400,16 @@ mod test {
assert_eq!(
ts1.mips[0].query(&(1..2), |&v| v),
Some(Ok(Unit {
first: Some(TextureUse::SAMPLED | TextureUse::COPY_SRC),
last: TextureUse::COPY_DST,
first: Some(TextureUses::SAMPLED | TextureUses::COPY_SRC),
last: TextureUses::COPY_DST,
})),
"wrong final layer 1 state"
);
assert_eq!(
ts1.mips[0].query(&(2..3), |&v| v),
Some(Ok(Unit {
first: Some(TextureUse::SAMPLED),
last: TextureUse::COLOR_TARGET,
first: Some(TextureUses::SAMPLED),
last: TextureUses::COLOR_TARGET,
})),
"wrong final layer 2 state"
);
@@ -418,8 +418,8 @@ mod test {
ts2.mips[0] = PlaneStates::from_slice(&[(
2..3,
Unit {
first: Some(TextureUse::COLOR_TARGET),
last: TextureUse::COPY_SRC,
first: Some(TextureUses::COLOR_TARGET),
last: TextureUses::COPY_SRC,
},
)]);
ts1.merge(Id::dummy(), &ts2, Some(&mut list)).unwrap();
@@ -429,8 +429,8 @@ mod test {
ts2.mips[0] = PlaneStates::from_slice(&[(
2..3,
Unit {
first: Some(TextureUse::COPY_DST),
last: TextureUse::COPY_DST,
first: Some(TextureUses::COPY_DST),
last: TextureUses::COPY_DST,
},
)]);
ts1.merge(Id::dummy(), &ts2, Some(&mut list)).unwrap();
@@ -442,7 +442,7 @@ mod test {
levels: 0..1,
layers: 2..3,
},
usage: TextureUse::COPY_SRC..TextureUse::COPY_DST,
usage: TextureUses::COPY_SRC..TextureUses::COPY_DST,
},],
"invalid replacing transition"
);
@@ -450,8 +450,8 @@ mod test {
ts1.mips[0].query(&(2..3), |&v| v),
Some(Ok(Unit {
// the initial state here is never expected to change
first: Some(TextureUse::SAMPLED),
last: TextureUse::COPY_DST,
first: Some(TextureUses::SAMPLED),
last: TextureUses::COPY_DST,
})),
"wrong final layer 2 state"
);
+12 -12
View File
@@ -114,15 +114,15 @@ pub struct Interface {
#[derive(Clone, Debug, Error)]
#[error("buffer usage is {actual:?} which does not contain required usage {expected:?}")]
pub struct MissingBufferUsageError {
pub(crate) actual: wgt::BufferUsage,
pub(crate) expected: wgt::BufferUsage,
pub(crate) actual: wgt::BufferUsages,
pub(crate) expected: wgt::BufferUsages,
}
/// Checks that the given buffer usage contains the required buffer usage,
/// returns an error otherwise.
pub fn check_buffer_usage(
actual: wgt::BufferUsage,
expected: wgt::BufferUsage,
actual: wgt::BufferUsages,
expected: wgt::BufferUsages,
) -> Result<(), MissingBufferUsageError> {
if !actual.contains(expected) {
Err(MissingBufferUsageError { actual, expected })
@@ -134,15 +134,15 @@ pub fn check_buffer_usage(
#[derive(Clone, Debug, Error)]
#[error("texture usage is {actual:?} which does not contain required usage {expected:?}")]
pub struct MissingTextureUsageError {
pub(crate) actual: wgt::TextureUsage,
pub(crate) expected: wgt::TextureUsage,
pub(crate) actual: wgt::TextureUsages,
pub(crate) expected: wgt::TextureUsages,
}
/// Checks that the given texture usage contains the required texture usage,
/// returns an error otherwise.
pub fn check_texture_usage(
actual: wgt::TextureUsage,
expected: wgt::TextureUsage,
actual: wgt::TextureUsages,
expected: wgt::TextureUsages,
) -> Result<(), MissingTextureUsageError> {
if !actual.contains(expected) {
Err(MissingTextureUsageError { actual, expected })
@@ -864,15 +864,15 @@ impl Interface {
given_layouts: Option<&[&BindEntryMap]>,
derived_layouts: &mut [BindEntryMap],
entry_point_name: &str,
stage_bit: wgt::ShaderStage,
stage_bit: wgt::ShaderStages,
inputs: StageIo,
) -> Result<StageIo, StageError> {
// Since a shader module can have multiple entry points with the same name,
// we need to look for one with the right execution model.
let shader_stage = match stage_bit {
wgt::ShaderStage::VERTEX => naga::ShaderStage::Vertex,
wgt::ShaderStage::FRAGMENT => naga::ShaderStage::Fragment,
wgt::ShaderStage::COMPUTE => naga::ShaderStage::Compute,
wgt::ShaderStages::VERTEX => naga::ShaderStage::Vertex,
wgt::ShaderStages::FRAGMENT => naga::ShaderStage::Fragment,
wgt::ShaderStages::COMPUTE => naga::ShaderStage::Compute,
_ => unreachable!(),
};
let pair = (shader_stage, entry_point_name.to_string());
+26 -26
View File
@@ -80,9 +80,9 @@ impl<A: hal::Api> Example<A> {
let instance_desc = hal::InstanceDescriptor {
name: "example",
flags: if cfg!(debug_assertions) {
hal::InstanceFlag::all()
hal::InstanceFlags::all()
} else {
hal::InstanceFlag::empty()
hal::InstanceFlags::empty()
},
};
let instance = unsafe { A::Instance::init(&instance_desc)? };
@@ -114,7 +114,7 @@ impl<A: hal::Api> Example<A> {
height: window_size.1,
depth_or_array_layers: 1,
},
usage: hal::TextureUse::COLOR_TARGET,
usage: hal::TextureUses::COLOR_TARGET,
};
unsafe {
surface.configure(&device, &surface_config).unwrap();
@@ -147,7 +147,7 @@ impl<A: hal::Api> Example<A> {
entries: &[
wgt::BindGroupLayoutEntry {
binding: 0,
visibility: wgt::ShaderStage::VERTEX,
visibility: wgt::ShaderStages::VERTEX,
ty: wgt::BindingType::Buffer {
ty: wgt::BufferBindingType::Uniform,
has_dynamic_offset: false,
@@ -157,7 +157,7 @@ impl<A: hal::Api> Example<A> {
},
wgt::BindGroupLayoutEntry {
binding: 1,
visibility: wgt::ShaderStage::FRAGMENT,
visibility: wgt::ShaderStages::FRAGMENT,
ty: wgt::BindingType::Texture {
sample_type: wgt::TextureSampleType::Float { filterable: true },
view_dimension: wgt::TextureViewDimension::D2,
@@ -167,7 +167,7 @@ impl<A: hal::Api> Example<A> {
},
wgt::BindGroupLayoutEntry {
binding: 2,
visibility: wgt::ShaderStage::FRAGMENT,
visibility: wgt::ShaderStages::FRAGMENT,
ty: wgt::BindingType::Sampler {
filtering: true,
comparison: false,
@@ -183,7 +183,7 @@ impl<A: hal::Api> Example<A> {
let local_bgl_desc = hal::BindGroupLayoutDescriptor {
entries: &[wgt::BindGroupLayoutEntry {
binding: 0,
visibility: wgt::ShaderStage::VERTEX,
visibility: wgt::ShaderStages::VERTEX,
ty: wgt::BindingType::Buffer {
ty: wgt::BufferBindingType::Uniform,
has_dynamic_offset: true,
@@ -228,7 +228,7 @@ impl<A: hal::Api> Example<A> {
color_targets: &[wgt::ColorTargetState {
format: surface_config.format,
blend: Some(wgt::BlendState::ALPHA_BLENDING),
write_mask: wgt::ColorWrite::default(),
write_mask: wgt::ColorWrites::default(),
}],
};
let pipeline = unsafe { device.create_render_pipeline(&pipeline_desc).unwrap() };
@@ -238,8 +238,8 @@ impl<A: hal::Api> Example<A> {
let staging_buffer_desc = hal::BufferDescriptor {
label: Some("stage"),
size: texture_data.len() as wgt::BufferAddress,
usage: hal::BufferUse::MAP_WRITE | hal::BufferUse::COPY_SRC,
memory_flags: hal::MemoryFlag::TRANSIENT | hal::MemoryFlag::PREFER_COHERENT,
usage: hal::BufferUses::MAP_WRITE | hal::BufferUses::COPY_SRC,
memory_flags: hal::MemoryFlags::TRANSIENT | hal::MemoryFlags::PREFER_COHERENT,
};
let staging_buffer = unsafe { device.create_buffer(&staging_buffer_desc).unwrap() };
unsafe {
@@ -266,8 +266,8 @@ impl<A: hal::Api> Example<A> {
sample_count: 1,
dimension: wgt::TextureDimension::D2,
format: wgt::TextureFormat::Rgba8UnormSrgb,
usage: hal::TextureUse::COPY_DST | hal::TextureUse::SAMPLED,
memory_flags: hal::MemoryFlag::empty(),
usage: hal::TextureUses::COPY_DST | hal::TextureUses::SAMPLED,
memory_flags: hal::MemoryFlags::empty(),
};
let texture = unsafe { device.create_texture(&texture_desc).unwrap() };
@@ -280,17 +280,17 @@ impl<A: hal::Api> Example<A> {
{
let buffer_barrier = hal::BufferBarrier {
buffer: &staging_buffer,
usage: hal::BufferUse::empty()..hal::BufferUse::COPY_SRC,
usage: hal::BufferUses::empty()..hal::BufferUses::COPY_SRC,
};
let texture_barrier1 = hal::TextureBarrier {
texture: &texture,
range: wgt::ImageSubresourceRange::default(),
usage: hal::TextureUse::UNINITIALIZED..hal::TextureUse::COPY_DST,
usage: hal::TextureUses::UNINITIALIZED..hal::TextureUses::COPY_DST,
};
let texture_barrier2 = hal::TextureBarrier {
texture: &texture,
range: wgt::ImageSubresourceRange::default(),
usage: hal::TextureUse::COPY_DST..hal::TextureUse::SAMPLED,
usage: hal::TextureUses::COPY_DST..hal::TextureUses::SAMPLED,
};
let copy = hal::BufferTextureCopy {
buffer_layout: wgt::ImageDataLayout {
@@ -301,7 +301,7 @@ impl<A: hal::Api> Example<A> {
texture_base: hal::TextureCopyBase {
origin: wgt::Origin3d::ZERO,
mip_level: 0,
aspect: hal::FormatAspect::COLOR,
aspect: hal::FormatAspects::COLOR,
},
size: texture_desc.size,
};
@@ -341,8 +341,8 @@ impl<A: hal::Api> Example<A> {
let global_buffer_desc = hal::BufferDescriptor {
label: Some("global"),
size: mem::size_of::<Globals>() as wgt::BufferAddress,
usage: hal::BufferUse::MAP_WRITE | hal::BufferUse::UNIFORM,
memory_flags: hal::MemoryFlag::PREFER_COHERENT,
usage: hal::BufferUses::MAP_WRITE | hal::BufferUses::UNIFORM,
memory_flags: hal::MemoryFlags::PREFER_COHERENT,
};
let global_buffer = unsafe {
let buffer = device.create_buffer(&global_buffer_desc).unwrap();
@@ -362,8 +362,8 @@ impl<A: hal::Api> Example<A> {
let local_buffer_desc = hal::BufferDescriptor {
label: Some("local"),
size: (MAX_BUNNIES as wgt::BufferAddress) * wgt::BIND_BUFFER_ALIGNMENT,
usage: hal::BufferUse::MAP_WRITE | hal::BufferUse::UNIFORM,
memory_flags: hal::MemoryFlag::PREFER_COHERENT,
usage: hal::BufferUses::MAP_WRITE | hal::BufferUses::UNIFORM,
memory_flags: hal::MemoryFlags::PREFER_COHERENT,
};
let local_buffer = unsafe { device.create_buffer(&local_buffer_desc).unwrap() };
@@ -371,7 +371,7 @@ impl<A: hal::Api> Example<A> {
label: None,
format: texture_desc.format,
dimension: wgt::TextureViewDimension::D2,
usage: hal::TextureUse::SAMPLED,
usage: hal::TextureUses::SAMPLED,
range: wgt::ImageSubresourceRange::default(),
};
let texture_view = unsafe { device.create_texture_view(&texture, &view_desc).unwrap() };
@@ -384,7 +384,7 @@ impl<A: hal::Api> Example<A> {
};
let texture_binding = hal::TextureBinding {
view: &texture_view,
usage: hal::TextureUse::SAMPLED,
usage: hal::TextureUses::SAMPLED,
};
let global_group_desc = hal::BindGroupDescriptor {
label: Some("global"),
@@ -591,7 +591,7 @@ impl<A: hal::Api> Example<A> {
label: None,
format: self.surface_format,
dimension: wgt::TextureViewDimension::D2,
usage: hal::TextureUse::COLOR_TARGET,
usage: hal::TextureUses::COLOR_TARGET,
range: wgt::ImageSubresourceRange::default(),
};
let surface_tex_view = unsafe {
@@ -610,11 +610,11 @@ impl<A: hal::Api> Example<A> {
color_attachments: &[hal::ColorAttachment {
target: hal::Attachment {
view: &surface_tex_view,
usage: hal::TextureUse::COLOR_TARGET,
boundary_usage: hal::TextureUse::UNINITIALIZED..hal::TextureUse::empty(),
usage: hal::TextureUses::COLOR_TARGET,
boundary_usage: hal::TextureUses::UNINITIALIZED..hal::TextureUses::empty(),
},
resolve_target: None,
ops: hal::AttachmentOp::STORE,
ops: hal::AttachmentOps::STORE,
clear_value: wgt::Color {
r: 0.1,
g: 0.2,
+5 -5
View File
@@ -80,8 +80,8 @@ impl crate::Adapter<Api> for Context {
unsafe fn texture_format_capabilities(
&self,
format: wgt::TextureFormat,
) -> crate::TextureFormatCapability {
crate::TextureFormatCapability::empty()
) -> crate::TextureFormatCapabilities {
crate::TextureFormatCapabilities::empty()
}
unsafe fn surface_capabilities(&self, surface: &Context) -> Option<crate::SurfaceCapabilities> {
None
@@ -252,7 +252,7 @@ impl crate::CommandEncoder<Api> for Encoder {
unsafe fn copy_texture_to_texture<T>(
&mut self,
src: &Resource,
src_usage: crate::TextureUse,
src_usage: crate::TextureUses,
dst: &Resource,
regions: T,
) {
@@ -263,7 +263,7 @@ impl crate::CommandEncoder<Api> for Encoder {
unsafe fn copy_texture_to_buffer<T>(
&mut self,
src: &Resource,
src_usage: crate::TextureUse,
src_usage: crate::TextureUses,
dst: &Resource,
regions: T,
) {
@@ -299,7 +299,7 @@ impl crate::CommandEncoder<Api> for Encoder {
unsafe fn set_push_constants(
&mut self,
layout: &Resource,
stages: wgt::ShaderStage,
stages: wgt::ShaderStages,
offset: u32,
data: &[u32],
) {
+8 -8
View File
@@ -251,18 +251,18 @@ impl super::Adapter {
max_push_constant_size: 0,
};
let mut private_caps = super::PrivateCapability::empty();
let mut private_caps = super::PrivateCapabilities::empty();
private_caps.set(
super::PrivateCapability::SHADER_BINDING_LAYOUT,
super::PrivateCapabilities::SHADER_BINDING_LAYOUT,
ver >= (3, 1),
);
private_caps.set(
super::PrivateCapability::SHADER_TEXTURE_SHADOW_LOD,
super::PrivateCapabilities::SHADER_TEXTURE_SHADOW_LOD,
extensions.contains("GL_EXT_texture_shadow_lod"),
);
private_caps.set(super::PrivateCapability::MEMORY_BARRIERS, ver >= (3, 1));
private_caps.set(super::PrivateCapabilities::MEMORY_BARRIERS, ver >= (3, 1));
private_caps.set(
super::PrivateCapability::VERTEX_BUFFER_LAYOUT,
super::PrivateCapabilities::VERTEX_BUFFER_LAYOUT,
ver >= (3, 1),
);
@@ -345,8 +345,8 @@ impl crate::Adapter<super::Api> for super::Adapter {
unsafe fn texture_format_capabilities(
&self,
format: wgt::TextureFormat,
) -> crate::TextureFormatCapability {
use crate::TextureFormatCapability as Tfc;
) -> crate::TextureFormatCapabilities {
use crate::TextureFormatCapabilities as Tfc;
use wgt::TextureFormat as Tf;
// The storage types are sprinkled based on section
// "TEXTURE IMAGE LOADS AND STORES" of GLES-3.2 spec.
@@ -450,7 +450,7 @@ impl crate::Adapter<super::Api> for super::Adapter {
height: 4096,
depth_or_array_layers: 1,
},
usage: crate::TextureUse::COLOR_TARGET,
usage: crate::TextureUses::COLOR_TARGET,
})
} else {
None
+23 -23
View File
@@ -72,7 +72,7 @@ impl super::CommandEncoder {
fn rebind_vertex_data(&mut self, first_instance: u32) {
if self
.private_caps
.contains(super::PrivateCapability::VERTEX_BUFFER_LAYOUT)
.contains(super::PrivateCapabilities::VERTEX_BUFFER_LAYOUT)
{
for (index, &(ref vb_desc, ref vb)) in self.state.vertex_buffers.iter().enumerate() {
if self.state.dirty_vbuf_mask & (1 << index) == 0 {
@@ -190,13 +190,13 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
{
if !self
.private_caps
.contains(super::PrivateCapability::MEMORY_BARRIERS)
.contains(super::PrivateCapabilities::MEMORY_BARRIERS)
{
return;
}
for bar in barriers {
// GLES only synchronizes storage -> anything explicitly
if !bar.usage.start.contains(crate::BufferUse::STORAGE_STORE) {
if !bar.usage.start.contains(crate::BufferUses::STORAGE_STORE) {
continue;
}
self.cmd_buffer
@@ -211,15 +211,15 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
{
if !self
.private_caps
.contains(super::PrivateCapability::MEMORY_BARRIERS)
.contains(super::PrivateCapabilities::MEMORY_BARRIERS)
{
return;
}
let mut combined_usage = crate::TextureUse::empty();
let mut combined_usage = crate::TextureUses::empty();
for bar in barriers {
// GLES only synchronizes storage -> anything explicitly
if !bar.usage.start.contains(crate::TextureUse::STORAGE_STORE) {
if !bar.usage.start.contains(crate::TextureUses::STORAGE_STORE) {
continue;
}
// unlike buffers, there is no need for a concrete texture
@@ -267,7 +267,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
unsafe fn copy_texture_to_texture<T>(
&mut self,
src: &super::Texture,
_src_usage: crate::TextureUse,
_src_usage: crate::TextureUses,
dst: &super::Texture,
regions: T,
) where
@@ -310,7 +310,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
unsafe fn copy_texture_to_buffer<T>(
&mut self,
src: &super::Texture,
_src_usage: crate::TextureUse,
_src_usage: crate::TextureUses,
dst: &super::Buffer,
regions: T,
) where
@@ -390,30 +390,30 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
.resolve_attachments
.push((attachment, rat.view.clone()));
}
if !cat.ops.contains(crate::AttachmentOp::STORE) {
if !cat.ops.contains(crate::AttachmentOps::STORE) {
self.state.invalidate_attachments.push(attachment);
}
}
if let Some(ref dsat) = desc.depth_stencil_attachment {
let aspects = dsat.target.view.aspects;
let attachment = match aspects {
crate::FormatAspect::DEPTH => glow::DEPTH_ATTACHMENT,
crate::FormatAspect::STENCIL => glow::STENCIL_ATTACHMENT,
crate::FormatAspects::DEPTH => glow::DEPTH_ATTACHMENT,
crate::FormatAspects::STENCIL => glow::STENCIL_ATTACHMENT,
_ => glow::DEPTH_STENCIL_ATTACHMENT,
};
self.cmd_buffer.commands.push(C::BindAttachment {
attachment,
view: dsat.target.view.clone(),
});
if aspects.contains(crate::FormatAspect::DEPTH)
&& !dsat.depth_ops.contains(crate::AttachmentOp::STORE)
if aspects.contains(crate::FormatAspects::DEPTH)
&& !dsat.depth_ops.contains(crate::AttachmentOps::STORE)
{
self.state
.invalidate_attachments
.push(glow::DEPTH_ATTACHMENT);
}
if aspects.contains(crate::FormatAspect::STENCIL)
&& !dsat.stencil_ops.contains(crate::AttachmentOp::STORE)
if aspects.contains(crate::FormatAspects::STENCIL)
&& !dsat.stencil_ops.contains(crate::AttachmentOps::STORE)
{
self.state
.invalidate_attachments
@@ -439,7 +439,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
// issue the clears
for (i, cat) in desc.color_attachments.iter().enumerate() {
if !cat.ops.contains(crate::AttachmentOp::LOAD) {
if !cat.ops.contains(crate::AttachmentOps::LOAD) {
let c = &cat.clear_value;
self.cmd_buffer
.commands
@@ -461,12 +461,12 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
}
}
if let Some(ref dsat) = desc.depth_stencil_attachment {
if !dsat.depth_ops.contains(crate::AttachmentOp::LOAD) {
if !dsat.depth_ops.contains(crate::AttachmentOps::LOAD) {
self.cmd_buffer
.commands
.push(C::ClearDepth(dsat.clear_value.0));
}
if !dsat.stencil_ops.contains(crate::AttachmentOp::LOAD) {
if !dsat.stencil_ops.contains(crate::AttachmentOps::LOAD) {
self.cmd_buffer
.commands
.push(C::ClearStencil(dsat.clear_value.1));
@@ -574,7 +574,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
unsafe fn set_push_constants(
&mut self,
_layout: &super::PipelineLayout,
_stages: wgt::ShaderStage,
_stages: wgt::ShaderStages,
_offset: u32,
_data: &[u32],
) {
@@ -604,7 +604,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
if self
.private_caps
.contains(super::PrivateCapability::VERTEX_BUFFER_LAYOUT)
.contains(super::PrivateCapabilities::VERTEX_BUFFER_LAYOUT)
{
for vat in pipeline.vertex_attributes.iter() {
let vb = &pipeline.vertex_buffers[vat.buffer_index as usize];
@@ -655,7 +655,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
}
// set depth/stencil states
let mut aspects = crate::FormatAspect::empty();
let mut aspects = crate::FormatAspects::empty();
if pipeline.depth_bias != self.state.depth_bias {
self.state.depth_bias = pipeline.depth_bias;
self.cmd_buffer
@@ -663,11 +663,11 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
.push(C::SetDepthBias(pipeline.depth_bias));
}
if let Some(ref depth) = pipeline.depth {
aspects |= crate::FormatAspect::DEPTH;
aspects |= crate::FormatAspects::DEPTH;
self.cmd_buffer.commands.push(C::SetDepth(depth.clone()));
}
if let Some(ref stencil) = pipeline.stencil {
aspects |= crate::FormatAspect::STENCIL;
aspects |= crate::FormatAspects::STENCIL;
self.state.stencil = stencil.clone();
self.rebind_stencil_func();
if stencil.front.ops == stencil.back.ops
+15 -15
View File
@@ -175,7 +175,7 @@ impl super::Device {
let mut name_binding_map = NameBindingMap::default();
let mut sampler_map = [None; super::MAX_TEXTURE_SLOTS];
let mut has_stages = wgt::ShaderStage::empty();
let mut has_stages = wgt::ShaderStages::empty();
let mut shaders_to_delete = arrayvec::ArrayVec::<[_; 3]>::new();
for (naga_stage, stage) in shaders {
@@ -191,7 +191,7 @@ impl super::Device {
}
// Create empty fragment shader if only vertex shader is present
if has_stages == wgt::ShaderStage::VERTEX {
if has_stages == wgt::ShaderStages::VERTEX {
let version = match self.shared.shading_language_version {
naga::back::glsl::Version::Embedded(v) => v,
naga::back::glsl::Version::Desktop(_) => unreachable!(),
@@ -226,7 +226,7 @@ impl super::Device {
if !self
.shared
.private_caps
.contains(super::PrivateCapability::SHADER_BINDING_LAYOUT)
.contains(super::PrivateCapabilities::SHADER_BINDING_LAYOUT)
{
// This remapping is only needed if we aren't able to put the binding layout
// in the shader. We can't remap storage buffers this way.
@@ -300,7 +300,7 @@ impl crate::Device<super::Api> for super::Device {
) -> Result<super::Buffer, crate::DeviceError> {
let gl = &self.shared.context;
let target = if desc.usage.contains(crate::BufferUse::INDEX) {
let target = if desc.usage.contains(crate::BufferUses::INDEX) {
glow::ELEMENT_ARRAY_BUFFER
} else {
glow::ARRAY_BUFFER
@@ -308,10 +308,10 @@ impl crate::Device<super::Api> for super::Device {
let is_host_visible = desc
.usage
.intersects(crate::BufferUse::MAP_READ | crate::BufferUse::MAP_WRITE);
.intersects(crate::BufferUses::MAP_READ | crate::BufferUses::MAP_WRITE);
let is_coherent = desc
.memory_flags
.contains(crate::MemoryFlag::PREFER_COHERENT);
.contains(crate::MemoryFlags::PREFER_COHERENT);
let mut map_flags = 0;
if is_host_visible {
@@ -320,10 +320,10 @@ impl crate::Device<super::Api> for super::Device {
map_flags |= glow::MAP_COHERENT_BIT;
}
}
if desc.usage.contains(crate::BufferUse::MAP_READ) {
if desc.usage.contains(crate::BufferUses::MAP_READ) {
map_flags |= glow::MAP_READ_BIT;
}
if desc.usage.contains(crate::BufferUse::MAP_WRITE) {
if desc.usage.contains(crate::BufferUses::MAP_WRITE) {
map_flags |= glow::MAP_WRITE_BIT;
}
@@ -336,7 +336,7 @@ impl crate::Device<super::Api> for super::Device {
gl.buffer_storage(target, raw_size, None, map_flags);
gl.bind_buffer(target, None);
if !is_coherent && desc.usage.contains(crate::BufferUse::MAP_WRITE) {
if !is_coherent && desc.usage.contains(crate::BufferUses::MAP_WRITE) {
map_flags |= glow::MAP_FLUSH_EXPLICIT_BIT;
}
//TODO: do we need `glow::MAP_UNSYNCHRONIZED_BIT`?
@@ -413,9 +413,9 @@ impl crate::Device<super::Api> for super::Device {
) -> Result<super::Texture, crate::DeviceError> {
let gl = &self.shared.context;
let render_usage = crate::TextureUse::COLOR_TARGET
| crate::TextureUse::DEPTH_STENCIL_WRITE
| crate::TextureUse::DEPTH_STENCIL_READ;
let render_usage = crate::TextureUses::COLOR_TARGET
| crate::TextureUses::DEPTH_STENCIL_WRITE
| crate::TextureUses::DEPTH_STENCIL_READ;
let format_desc = self.shared.describe_texture_format(desc.format);
let inner = if render_usage.contains(desc.usage)
@@ -582,8 +582,8 @@ impl crate::Device<super::Api> for super::Device {
//TODO: use `conv::map_view_dimension(desc.dimension)`?
inner: texture.inner.clone(),
sample_type: texture.format.describe().sample_type,
aspects: crate::FormatAspect::from(texture.format)
& crate::FormatAspect::from(desc.range.aspect),
aspects: crate::FormatAspects::from(texture.format)
& crate::FormatAspects::from(desc.range.aspect),
mip_levels: desc.range.base_mip_level..end_mip_level,
array_layers: desc.range.base_array_layer..end_array_layer,
})
@@ -705,7 +705,7 @@ impl crate::Device<super::Api> for super::Device {
glsl::WriterFlags::TEXTURE_SHADOW_LOD,
self.shared
.private_caps
.contains(super::PrivateCapability::SHADER_TEXTURE_SHADOW_LOD),
.contains(super::PrivateCapabilities::SHADER_TEXTURE_SHADOW_LOD),
);
let mut binding_map = glsl::BindingMap::default();
+6 -6
View File
@@ -226,7 +226,7 @@ struct Inner {
impl Inner {
fn create(
flags: crate::InstanceFlag,
flags: crate::InstanceFlags,
egl: Arc<egl::DynamicInstance<egl::EGL1_4>>,
display: egl::Display,
) -> Result<Self, crate::InstanceError> {
@@ -265,7 +265,7 @@ impl Inner {
egl::CONTEXT_CLIENT_VERSION,
3, // Request GLES 3.0 or higher
];
if flags.contains(crate::InstanceFlag::DEBUG) && !cfg!(target_os = "android") {
if flags.contains(crate::InstanceFlags::DEBUG) && !cfg!(target_os = "android") {
log::info!("\tEGL context: +debug");
//TODO: figure out why this is needed
context_attributes.push(egl::CONTEXT_OPENGL_DEBUG);
@@ -328,7 +328,7 @@ impl Drop for Inner {
pub struct Instance {
wsi_library: Option<libloading::Library>,
flags: crate::InstanceFlag,
flags: crate::InstanceFlags,
inner: Mutex<Inner>,
}
@@ -395,7 +395,7 @@ impl crate::Instance<super::Api> for Instance {
egl.get_display(egl::DEFAULT_DISPLAY).unwrap()
};
if desc.flags.contains(crate::InstanceFlag::VALIDATION)
if desc.flags.contains(crate::InstanceFlags::VALIDATION)
&& client_ext_str.contains(&"EGL_KHR_debug")
{
log::info!("Enabling EGL debug output");
@@ -606,14 +606,14 @@ impl crate::Instance<super::Api> for Instance {
.map_or(ptr::null(), |p| p as *const _)
});
if self.flags.contains(crate::InstanceFlag::DEBUG) && gl.supports_debug() {
if self.flags.contains(crate::InstanceFlags::DEBUG) && gl.supports_debug() {
log::info!(
"Max label length: {}",
gl.get_parameter_i32(glow::MAX_LABEL_LENGTH)
);
}
if self.flags.contains(crate::InstanceFlag::VALIDATION) && gl.supports_debug() {
if self.flags.contains(crate::InstanceFlags::VALIDATION) && gl.supports_debug() {
log::info!("Enabling GLES debug output");
gl.enable(glow::DEBUG_OUTPUT);
gl.debug_message_callback(gl_debug_message_callback);
+8 -8
View File
@@ -111,7 +111,7 @@ impl crate::Api for Api {
bitflags::bitflags! {
/// Flags that affect internal code paths but do not
/// change the exposed feature set.
struct PrivateCapability: u32 {
struct PrivateCapabilities: u32 {
/// Support explicit layouts in shader.
const SHADER_BINDING_LAYOUT = 0x0001;
/// Support extended shadow sampling instructions.
@@ -147,7 +147,7 @@ struct TextureFormatDesc {
struct AdapterShared {
context: glow::Context,
private_caps: PrivateCapability,
private_caps: PrivateCapabilities,
shading_language_version: naga::back::glsl::Version,
}
@@ -213,7 +213,7 @@ pub struct Texture {
pub struct TextureView {
inner: TextureInner,
sample_type: wgt::TextureSampleType,
aspects: crate::FormatAspect,
aspects: crate::FormatAspects,
mip_levels: Range<u32>,
array_layers: Range<u32>,
}
@@ -358,7 +358,7 @@ struct BlendDesc {
#[derive(Clone, Debug, Default, PartialEq)]
struct ColorTargetDesc {
mask: wgt::ColorWrite,
mask: wgt::ColorWrites,
blend: Option<BlendDesc>,
}
@@ -565,8 +565,8 @@ enum Command {
ClearColorI(u32, [i32; 4]),
ClearDepth(f32),
ClearStencil(u32),
BufferBarrier(glow::Buffer, crate::BufferUse),
TextureBarrier(crate::TextureUse),
BufferBarrier(glow::Buffer, crate::BufferUses),
TextureBarrier(crate::TextureUses),
SetViewport {
rect: crate::Rect<i32>,
depth: Range<f32>,
@@ -585,7 +585,7 @@ enum Command {
},
SetDepth(DepthState),
SetDepthBias(wgt::DepthBiasState),
ConfigureDepthStencil(crate::FormatAspect),
ConfigureDepthStencil(crate::FormatAspects),
SetVertexAttribute {
buffer: Option<glow::Buffer>,
buffer_desc: VertexBufferDesc,
@@ -641,5 +641,5 @@ pub struct CommandBuffer {
pub struct CommandEncoder {
cmd_buffer: CommandBuffer,
state: command::State,
private_caps: PrivateCapability,
private_caps: PrivateCapabilities,
}
+19 -19
View File
@@ -599,35 +599,35 @@ impl super::Queue {
}
C::BufferBarrier(raw, usage) => {
let mut flags = 0;
if usage.contains(crate::BufferUse::VERTEX) {
if usage.contains(crate::BufferUses::VERTEX) {
flags |= glow::VERTEX_ATTRIB_ARRAY_BARRIER_BIT;
gl.bind_buffer(glow::ARRAY_BUFFER, Some(raw));
gl.vertex_attrib_pointer_f32(0, 1, glow::BYTE, true, 0, 0);
}
if usage.contains(crate::BufferUse::INDEX) {
if usage.contains(crate::BufferUses::INDEX) {
flags |= glow::ELEMENT_ARRAY_BARRIER_BIT;
gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(raw));
}
if usage.contains(crate::BufferUse::UNIFORM) {
if usage.contains(crate::BufferUses::UNIFORM) {
flags |= glow::UNIFORM_BARRIER_BIT;
}
if usage.contains(crate::BufferUse::INDIRECT) {
if usage.contains(crate::BufferUses::INDIRECT) {
flags |= glow::COMMAND_BARRIER_BIT;
gl.bind_buffer(glow::DRAW_INDIRECT_BUFFER, Some(raw));
}
if usage.contains(crate::BufferUse::COPY_SRC) {
if usage.contains(crate::BufferUses::COPY_SRC) {
flags |= glow::PIXEL_BUFFER_BARRIER_BIT;
gl.bind_buffer(glow::PIXEL_UNPACK_BUFFER, Some(raw));
}
if usage.contains(crate::BufferUse::COPY_DST) {
if usage.contains(crate::BufferUses::COPY_DST) {
flags |= glow::PIXEL_BUFFER_BARRIER_BIT;
gl.bind_buffer(glow::PIXEL_PACK_BUFFER, Some(raw));
}
if usage.intersects(crate::BufferUse::MAP_READ | crate::BufferUse::MAP_WRITE) {
if usage.intersects(crate::BufferUses::MAP_READ | crate::BufferUses::MAP_WRITE) {
flags |= glow::BUFFER_UPDATE_BARRIER_BIT;
}
if usage
.intersects(crate::BufferUse::STORAGE_LOAD | crate::BufferUse::STORAGE_STORE)
.intersects(crate::BufferUses::STORAGE_LOAD | crate::BufferUses::STORAGE_STORE)
{
flags |= glow::SHADER_STORAGE_BARRIER_BIT;
}
@@ -635,21 +635,21 @@ impl super::Queue {
}
C::TextureBarrier(usage) => {
let mut flags = 0;
if usage.contains(crate::TextureUse::SAMPLED) {
if usage.contains(crate::TextureUses::SAMPLED) {
flags |= glow::TEXTURE_FETCH_BARRIER_BIT;
}
if usage
.intersects(crate::TextureUse::STORAGE_LOAD | crate::TextureUse::STORAGE_STORE)
{
if usage.intersects(
crate::TextureUses::STORAGE_LOAD | crate::TextureUses::STORAGE_STORE,
) {
flags |= glow::SHADER_IMAGE_ACCESS_BARRIER_BIT;
}
if usage.contains(crate::TextureUse::COPY_DST) {
if usage.contains(crate::TextureUses::COPY_DST) {
flags |= glow::TEXTURE_UPDATE_BARRIER_BIT;
}
if usage.intersects(
crate::TextureUse::COLOR_TARGET
| crate::TextureUse::DEPTH_STENCIL_READ
| crate::TextureUse::DEPTH_STENCIL_WRITE,
crate::TextureUses::COLOR_TARGET
| crate::TextureUses::DEPTH_STENCIL_READ
| crate::TextureUses::DEPTH_STENCIL_WRITE,
) {
flags |= glow::FRAMEBUFFER_BARRIER_BIT;
}
@@ -760,12 +760,12 @@ impl super::Queue {
}
}
C::ConfigureDepthStencil(aspects) => {
if aspects.contains(crate::FormatAspect::DEPTH) {
if aspects.contains(crate::FormatAspects::DEPTH) {
gl.enable(glow::DEPTH_TEST);
} else {
gl.disable(glow::DEPTH_TEST);
}
if aspects.contains(crate::FormatAspect::STENCIL) {
if aspects.contains(crate::FormatAspects::STENCIL) {
gl.enable(glow::STENCIL_TEST);
} else {
gl.disable(glow::STENCIL_TEST);
@@ -797,7 +797,7 @@ impl super::Queue {
draw_buffer_index,
desc: super::ColorTargetDesc { mask, ref blend },
} => {
use wgt::ColorWrite as Cw;
use wgt::ColorWrites as Cw;
if let Some(index) = draw_buffer_index {
gl.color_mask_draw_buffer(
index,
+38 -38
View File
@@ -105,7 +105,7 @@ pub enum ShaderError {
#[derive(Clone, Debug, PartialEq, Error)]
pub enum PipelineError {
#[error("linkage failed for stage {0:?}: {1}")]
Linkage(wgt::ShaderStage, String),
Linkage(wgt::ShaderStages, String),
#[error("entry point for stage {0:?} is invalid")]
EntryPoint(naga::ShaderStage),
#[error(transparent)]
@@ -188,7 +188,7 @@ pub trait Adapter<A: Api>: Send + Sync {
unsafe fn texture_format_capabilities(
&self,
format: wgt::TextureFormat,
) -> TextureFormatCapability;
) -> TextureFormatCapabilities;
/// Returns the capabilities of working with a specified surface.
///
@@ -201,7 +201,7 @@ pub trait Device<A: Api>: Send + Sync {
unsafe fn exit(self);
/// Creates a new buffer.
///
/// The initial usage is `BufferUse::empty()`.
/// The initial usage is `BufferUses::empty()`.
unsafe fn create_buffer(&self, desc: &BufferDescriptor) -> Result<A::Buffer, DeviceError>;
unsafe fn destroy_buffer(&self, buffer: A::Buffer);
//TODO: clarify if zero-sized mapping is allowed
@@ -220,7 +220,7 @@ pub trait Device<A: Api>: Send + Sync {
/// Creates a new texture.
///
/// The initial usage for all subresources is `TextureUse::UNINITIALIZED`.
/// The initial usage for all subresources is `TextureUses::UNINITIALIZED`.
unsafe fn create_texture(&self, desc: &TextureDescriptor) -> Result<A::Texture, DeviceError>;
unsafe fn destroy_texture(&self, texture: A::Texture);
unsafe fn create_texture_view(
@@ -345,17 +345,17 @@ pub trait CommandEncoder<A: Api>: Send + Sync {
where
T: Iterator<Item = BufferCopy>;
/// Note: `dst` current usage has to be `TextureUse::COPY_DST`.
/// Note: `dst` current usage has to be `TextureUses::COPY_DST`.
unsafe fn copy_texture_to_texture<T>(
&mut self,
src: &A::Texture,
src_usage: TextureUse,
src_usage: TextureUses,
dst: &A::Texture,
regions: T,
) where
T: Iterator<Item = TextureCopy>;
/// Note: `dst` current usage has to be `TextureUse::COPY_DST`.
/// Note: `dst` current usage has to be `TextureUses::COPY_DST`.
unsafe fn copy_buffer_to_texture<T>(&mut self, src: &A::Buffer, dst: &A::Texture, regions: T)
where
T: Iterator<Item = BufferTextureCopy>;
@@ -363,7 +363,7 @@ pub trait CommandEncoder<A: Api>: Send + Sync {
unsafe fn copy_texture_to_buffer<T>(
&mut self,
src: &A::Texture,
src_usage: TextureUse,
src_usage: TextureUses,
dst: &A::Buffer,
regions: T,
) where
@@ -384,7 +384,7 @@ pub trait CommandEncoder<A: Api>: Send + Sync {
unsafe fn set_push_constants(
&mut self,
layout: &A::PipelineLayout,
stages: wgt::ShaderStage,
stages: wgt::ShaderStages,
offset: u32,
data: &[u32],
);
@@ -485,7 +485,7 @@ pub trait CommandEncoder<A: Api>: Send + Sync {
bitflags!(
/// Instance initialization flags.
pub struct InstanceFlag: u32 {
pub struct InstanceFlags: u32 {
/// Generate debug information in shaders and objects.
const DEBUG = 0x1;
/// Enable validation, if possible.
@@ -495,7 +495,7 @@ bitflags!(
bitflags!(
/// Texture format capability flags.
pub struct TextureFormatCapability: u32 {
pub struct TextureFormatCapabilities: u32 {
/// Format can be sampled.
const SAMPLED = 0x1;
/// Format can be sampled with a linear sampler.
@@ -526,14 +526,14 @@ bitflags!(
bitflags!(
/// Texture format capability flags.
pub struct FormatAspect: u8 {
pub struct FormatAspects: u8 {
const COLOR = 1;
const DEPTH = 2;
const STENCIL = 4;
}
);
impl From<wgt::TextureAspect> for FormatAspect {
impl From<wgt::TextureAspect> for FormatAspects {
fn from(aspect: wgt::TextureAspect) -> Self {
match aspect {
wgt::TextureAspect::All => Self::all(),
@@ -543,7 +543,7 @@ impl From<wgt::TextureAspect> for FormatAspect {
}
}
impl From<wgt::TextureFormat> for FormatAspect {
impl From<wgt::TextureFormat> for FormatAspects {
fn from(format: wgt::TextureFormat) -> Self {
match format {
wgt::TextureFormat::Depth32Float | wgt::TextureFormat::Depth24Plus => Self::DEPTH,
@@ -554,7 +554,7 @@ impl From<wgt::TextureFormat> for FormatAspect {
}
bitflags!(
pub struct MemoryFlag: u32 {
pub struct MemoryFlags: u32 {
const TRANSIENT = 1;
const PREFER_COHERENT = 2;
}
@@ -563,15 +563,15 @@ bitflags!(
//TODO: it's not intuitive for the backends to consider `LOAD` being optional.
bitflags!(
pub struct AttachmentOp: u8 {
pub struct AttachmentOps: u8 {
const LOAD = 1;
const STORE = 2;
}
);
bitflags::bitflags! {
/// Similar to `wgt::BufferUsage` but for internal use.
pub struct BufferUse: u32 {
/// Similar to `wgt::BufferUsages` but for internal use.
pub struct BufferUses: u32 {
const MAP_READ = 1;
const MAP_WRITE = 2;
const COPY_SRC = 4;
@@ -596,8 +596,8 @@ bitflags::bitflags! {
}
bitflags::bitflags! {
/// Similar to `wgt::TextureUsage` but for internal use.
pub struct TextureUse: u32 {
/// Similar to `wgt::TextureUsages` but for internal use.
pub struct TextureUses: u32 {
const COPY_SRC = 1;
const COPY_DST = 2;
const SAMPLED = 4;
@@ -621,7 +621,7 @@ bitflags::bitflags! {
#[derive(Clone, Debug)]
pub struct InstanceDescriptor<'a> {
pub name: &'a str,
pub flags: InstanceFlag,
pub flags: InstanceFlags,
}
#[derive(Clone, Debug)]
@@ -675,8 +675,8 @@ pub struct SurfaceCapabilities {
/// Supported texture usage flags.
///
/// Must have at least `TextureUse::COLOR_TARGET`
pub usage: TextureUse,
/// Must have at least `TextureUses::COLOR_TARGET`
pub usage: TextureUses,
/// List of supported V-sync modes.
///
@@ -714,8 +714,8 @@ pub struct BufferMapping {
pub struct BufferDescriptor<'a> {
pub label: Label<'a>,
pub size: wgt::BufferAddress,
pub usage: BufferUse,
pub memory_flags: MemoryFlag,
pub usage: BufferUses,
pub memory_flags: MemoryFlags,
}
#[derive(Clone, Debug)]
@@ -726,8 +726,8 @@ pub struct TextureDescriptor<'a> {
pub sample_count: u32,
pub dimension: wgt::TextureDimension,
pub format: wgt::TextureFormat,
pub usage: TextureUse,
pub memory_flags: MemoryFlag,
pub usage: TextureUses,
pub memory_flags: MemoryFlags,
}
/// TextureView descriptor.
@@ -742,7 +742,7 @@ pub struct TextureViewDescriptor<'a> {
pub label: Label<'a>,
pub format: wgt::TextureFormat,
pub dimension: wgt::TextureViewDimension,
pub usage: TextureUse,
pub usage: TextureUses,
pub range: wgt::ImageSubresourceRange,
}
@@ -797,7 +797,7 @@ impl<A: Api> Clone for BufferBinding<'_, A> {
#[derive(Debug)]
pub struct TextureBinding<'a, A: Api> {
pub view: &'a A::TextureView,
pub usage: TextureUse,
pub usage: TextureUses,
}
// Rust gets confused about the impl requirements for `A`
@@ -966,7 +966,7 @@ pub struct SurfaceConfiguration {
/// `SurfaceCapabilities::extents` range.
pub extent: wgt::Extent3d,
/// Allowed usage of surface textures,
pub usage: TextureUse,
pub usage: TextureUses,
}
#[derive(Debug, Clone)]
@@ -980,14 +980,14 @@ pub struct Rect<T> {
#[derive(Debug, Clone)]
pub struct BufferBarrier<'a, A: Api> {
pub buffer: &'a A::Buffer,
pub usage: Range<BufferUse>,
pub usage: Range<BufferUses>,
}
#[derive(Debug, Clone)]
pub struct TextureBarrier<'a, A: Api> {
pub texture: &'a A::Texture,
pub range: wgt::ImageSubresourceRange,
pub usage: Range<TextureUse>,
pub usage: Range<TextureUses>,
}
#[derive(Clone, Copy, Debug)]
@@ -1001,7 +1001,7 @@ pub struct BufferCopy {
pub struct TextureCopyBase {
pub origin: wgt::Origin3d,
pub mip_level: u32,
pub aspect: FormatAspect,
pub aspect: FormatAspects,
}
#[derive(Clone, Debug)]
@@ -1023,11 +1023,11 @@ pub struct Attachment<'a, A: Api> {
pub view: &'a A::TextureView,
/// Contains either a single mutating usage as a target, or a valid combination
/// of read-only usages.
pub usage: TextureUse,
pub usage: TextureUses,
/// Defines the boundary usages for the attachment.
/// It is expected to begin a render pass with `boundary_usage.start` usage,
/// and will end it with `boundary_usage.end` usage.
pub boundary_usage: Range<TextureUse>,
pub boundary_usage: Range<TextureUses>,
}
// Rust gets confused about the impl requirements for `A`
@@ -1045,7 +1045,7 @@ impl<A: Api> Clone for Attachment<'_, A> {
pub struct ColorAttachment<'a, A: Api> {
pub target: Attachment<'a, A>,
pub resolve_target: Option<Attachment<'a, A>>,
pub ops: AttachmentOp,
pub ops: AttachmentOps,
pub clear_value: wgt::Color,
}
@@ -1064,8 +1064,8 @@ impl<A: Api> Clone for ColorAttachment<'_, A> {
#[derive(Clone, Debug)]
pub struct DepthStencilAttachment<'a, A: Api> {
pub target: Attachment<'a, A>,
pub depth_ops: AttachmentOp,
pub stencil_ops: AttachmentOp,
pub depth_ops: AttachmentOps,
pub stencil_ops: AttachmentOps,
pub clear_value: (f32, u32),
}
+3 -3
View File
@@ -33,8 +33,8 @@ impl crate::Adapter<super::Api> for super::Adapter {
unsafe fn texture_format_capabilities(
&self,
format: wgt::TextureFormat,
) -> crate::TextureFormatCapability {
use crate::TextureFormatCapability as Tfc;
) -> crate::TextureFormatCapabilities {
use crate::TextureFormatCapabilities as Tfc;
use wgt::TextureFormat as Tf;
let pc = &self.shared.private_caps;
@@ -309,7 +309,7 @@ impl crate::Adapter<super::Api> for super::Adapter {
height: 4096,
depth_or_array_layers: 1,
},
usage: crate::TextureUse::COLOR_TARGET, //TODO: expose more
usage: crate::TextureUses::COLOR_TARGET, //TODO: expose more
})
}
}
+11 -11
View File
@@ -148,7 +148,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
unsafe fn copy_texture_to_texture<T>(
&mut self,
src: &super::Texture,
_src_usage: crate::TextureUse,
_src_usage: crate::TextureUses,
dst: &super::Texture,
regions: T,
) where
@@ -216,7 +216,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
unsafe fn copy_texture_to_buffer<T>(
&mut self,
src: &super::Texture,
_src_usage: crate::TextureUse,
_src_usage: crate::TextureUses,
dst: &super::Buffer,
regions: T,
) where
@@ -323,14 +323,14 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
//Note: the selection of levels and slices is already handled by `TextureView`
at_descriptor.set_resolve_texture(Some(&resolve.view.raw));
}
let load_action = if at.ops.contains(crate::AttachmentOp::LOAD) {
let load_action = if at.ops.contains(crate::AttachmentOps::LOAD) {
mtl::MTLLoadAction::Load
} else {
at_descriptor.set_clear_color(conv::map_clear_color(&at.clear_value));
mtl::MTLLoadAction::Clear
};
let store_action = conv::map_store_action(
at.ops.contains(crate::AttachmentOp::STORE),
at.ops.contains(crate::AttachmentOps::STORE),
at.resolve_target.is_some(),
);
at_descriptor.set_load_action(load_action);
@@ -338,17 +338,17 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
}
if let Some(ref at) = desc.depth_stencil_attachment {
if at.target.view.aspects.contains(crate::FormatAspect::DEPTH) {
if at.target.view.aspects.contains(crate::FormatAspects::DEPTH) {
let at_descriptor = descriptor.depth_attachment().unwrap();
at_descriptor.set_texture(Some(&at.target.view.raw));
let load_action = if at.depth_ops.contains(crate::AttachmentOp::LOAD) {
let load_action = if at.depth_ops.contains(crate::AttachmentOps::LOAD) {
mtl::MTLLoadAction::Load
} else {
at_descriptor.set_clear_depth(at.clear_value.0 as f64);
mtl::MTLLoadAction::Clear
};
let store_action = if at.depth_ops.contains(crate::AttachmentOp::STORE) {
let store_action = if at.depth_ops.contains(crate::AttachmentOps::STORE) {
mtl::MTLStoreAction::Store
} else {
mtl::MTLStoreAction::DontCare
@@ -360,18 +360,18 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
.target
.view
.aspects
.contains(crate::FormatAspect::STENCIL)
.contains(crate::FormatAspects::STENCIL)
{
let at_descriptor = descriptor.stencil_attachment().unwrap();
at_descriptor.set_texture(Some(&at.target.view.raw));
let load_action = if at.depth_ops.contains(crate::AttachmentOp::LOAD) {
let load_action = if at.depth_ops.contains(crate::AttachmentOps::LOAD) {
mtl::MTLLoadAction::Load
} else {
at_descriptor.set_clear_stencil(at.clear_value.1);
mtl::MTLLoadAction::Clear
};
let store_action = if at.depth_ops.contains(crate::AttachmentOp::STORE) {
let store_action = if at.depth_ops.contains(crate::AttachmentOps::STORE) {
mtl::MTLStoreAction::Store
} else {
mtl::MTLStoreAction::DontCare
@@ -563,7 +563,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
unsafe fn set_push_constants(
&mut self,
_layout: &super::PipelineLayout,
_stages: wgt::ShaderStage,
_stages: wgt::ShaderStages,
_offset: u32,
_data: &[u32],
) {
+7 -7
View File
@@ -1,5 +1,5 @@
pub fn map_texture_usage(usage: crate::TextureUse) -> mtl::MTLTextureUsage {
use crate::TextureUse as Tu;
pub fn map_texture_usage(usage: crate::TextureUses) -> mtl::MTLTextureUsage {
use crate::TextureUses as Tu;
let mut mtl_usage = mtl::MTLTextureUsage::Unknown;
@@ -104,19 +104,19 @@ pub fn map_primitive_topology(
}
}
pub fn map_color_write(mask: wgt::ColorWrite) -> mtl::MTLColorWriteMask {
pub fn map_color_write(mask: wgt::ColorWrites) -> mtl::MTLColorWriteMask {
let mut raw_mask = mtl::MTLColorWriteMask::empty();
if mask.contains(wgt::ColorWrite::RED) {
if mask.contains(wgt::ColorWrites::RED) {
raw_mask |= mtl::MTLColorWriteMask::Red;
}
if mask.contains(wgt::ColorWrite::GREEN) {
if mask.contains(wgt::ColorWrites::GREEN) {
raw_mask |= mtl::MTLColorWriteMask::Green;
}
if mask.contains(wgt::ColorWrite::BLUE) {
if mask.contains(wgt::ColorWrites::BLUE) {
raw_mask |= mtl::MTLColorWriteMask::Blue;
}
if mask.contains(wgt::ColorWrite::ALPHA) {
if mask.contains(wgt::ColorWrites::ALPHA) {
raw_mask |= mtl::MTLColorWriteMask::Alpha;
}
+13 -10
View File
@@ -135,12 +135,12 @@ impl crate::Device<super::Api> for super::Device {
unsafe fn exit(self) {}
unsafe fn create_buffer(&self, desc: &crate::BufferDescriptor) -> DeviceResult<super::Buffer> {
let map_read = desc.usage.contains(crate::BufferUse::MAP_READ);
let map_write = desc.usage.contains(crate::BufferUse::MAP_WRITE);
let map_read = desc.usage.contains(crate::BufferUses::MAP_READ);
let map_write = desc.usage.contains(crate::BufferUses::MAP_WRITE);
let mut options = mtl::MTLResourceOptions::empty();
options |= if map_read || map_write {
// `crate::MemoryFlag::PREFER_COHERENT` is ignored here
// `crate::MemoryFlags::PREFER_COHERENT` is ignored here
mtl::MTLResourceOptions::StorageModeShared
} else {
mtl::MTLResourceOptions::StorageModePrivate
@@ -290,7 +290,7 @@ impl crate::Device<super::Api> for super::Device {
raw
};
let aspects = crate::FormatAspect::from(desc.format);
let aspects = crate::FormatAspects::from(desc.format);
Ok(super::TextureView { raw, aspects })
}
unsafe fn destroy_texture_view(&self, _view: super::TextureView) {}
@@ -717,11 +717,11 @@ impl crate::Device<super::Api> for super::Device {
let depth_stencil = match desc.depth_stencil {
Some(ref ds) => {
let raw_format = self.shared.private_caps.map_format(ds.format);
let aspects = crate::FormatAspect::from(ds.format);
if aspects.contains(crate::FormatAspect::DEPTH) {
let aspects = crate::FormatAspects::from(ds.format);
if aspects.contains(crate::FormatAspects::DEPTH) {
descriptor.set_depth_attachment_pixel_format(raw_format);
}
if aspects.contains(crate::FormatAspect::STENCIL) {
if aspects.contains(crate::FormatAspects::STENCIL) {
descriptor.set_stencil_attachment_pixel_format(raw_format);
}
@@ -744,7 +744,10 @@ impl crate::Device<super::Api> for super::Device {
desc.vertex_buffers.len(),
desc.layout.total_counters.vs.buffers
);
return Err(crate::PipelineError::Linkage(wgt::ShaderStage::VERTEX, msg));
return Err(crate::PipelineError::Linkage(
wgt::ShaderStages::VERTEX,
msg,
));
}
if !desc.vertex_buffers.is_empty() {
@@ -788,7 +791,7 @@ impl crate::Device<super::Api> for super::Device {
.new_render_pipeline_state(&descriptor)
.map_err(|e| {
crate::PipelineError::Linkage(
wgt::ShaderStage::VERTEX | wgt::ShaderStage::FRAGMENT,
wgt::ShaderStages::VERTEX | wgt::ShaderStages::FRAGMENT,
format!("new_render_pipeline_state: {:?}", e),
)
})?;
@@ -849,7 +852,7 @@ impl crate::Device<super::Api> for super::Device {
.new_compute_pipeline_state(&descriptor)
.map_err(|e| {
crate::PipelineError::Linkage(
wgt::ShaderStage::COMPUTE,
wgt::ShaderStages::COMPUTE,
format!("new_compute_pipeline_state: {:?}", e),
)
})?;
+1 -1
View File
@@ -398,7 +398,7 @@ unsafe impl Sync for Texture {}
#[derive(Debug)]
pub struct TextureView {
raw: mtl::Texture,
aspects: crate::FormatAspect,
aspects: crate::FormatAspects,
}
unsafe impl Send for TextureView {}
+1 -1
View File
@@ -172,7 +172,7 @@ impl crate::Surface<super::Api> for super::Surface {
self.raw_swapchain_format = caps.map_format(config.format);
let render_layer = self.render_layer.lock();
let framebuffer_only = config.usage == crate::TextureUse::COLOR_TARGET;
let framebuffer_only = config.usage == crate::TextureUses::COLOR_TARGET;
let display_sync = config.present_mode != wgt::PresentMode::Immediate;
let drawable_size = CGSize::new(config.extent.width as f64, config.extent.height as f64);
+4 -4
View File
@@ -6,10 +6,10 @@ pub mod db {
}
}
pub fn map_naga_stage(stage: naga::ShaderStage) -> wgt::ShaderStage {
pub fn map_naga_stage(stage: naga::ShaderStage) -> wgt::ShaderStages {
match stage {
naga::ShaderStage::Vertex => wgt::ShaderStage::VERTEX,
naga::ShaderStage::Fragment => wgt::ShaderStage::FRAGMENT,
naga::ShaderStage::Compute => wgt::ShaderStage::COMPUTE,
naga::ShaderStage::Vertex => wgt::ShaderStages::VERTEX,
naga::ShaderStage::Fragment => wgt::ShaderStages::FRAGMENT,
naga::ShaderStage::Compute => wgt::ShaderStages::COMPUTE,
}
}
+3 -3
View File
@@ -790,7 +790,7 @@ impl crate::Adapter<super::Api> for super::Adapter {
let mut flags = spv::WriterFlags::empty();
flags.set(
spv::WriterFlags::DEBUG,
self.instance.flags.contains(crate::InstanceFlag::DEBUG),
self.instance.flags.contains(crate::InstanceFlags::DEBUG),
);
spv::Options {
lang_version: (1, 0),
@@ -866,8 +866,8 @@ impl crate::Adapter<super::Api> for super::Adapter {
unsafe fn texture_format_capabilities(
&self,
format: wgt::TextureFormat,
) -> crate::TextureFormatCapability {
use crate::TextureFormatCapability as Tfc;
) -> crate::TextureFormatCapabilities {
use crate::TextureFormatCapabilities as Tfc;
let vk_format = self.private_caps.map_texture_format(format);
let properties = self
.instance
+5 -5
View File
@@ -219,7 +219,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
unsafe fn copy_texture_to_texture<T>(
&mut self,
src: &super::Texture,
src_usage: crate::TextureUse,
src_usage: crate::TextureUses,
dst: &super::Texture,
regions: T,
) where
@@ -278,7 +278,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
unsafe fn copy_texture_to_buffer<T>(
&mut self,
src: &super::Texture,
src_usage: crate::TextureUse,
src_usage: crate::TextureUses,
dst: &super::Buffer,
regions: T,
) where
@@ -368,7 +368,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
resolve: cat
.resolve_target
.as_ref()
.map(|target| target.make_attachment_key(crate::AttachmentOp::STORE, caps)),
.map(|target| target.make_attachment_key(crate::AttachmentOps::STORE, caps)),
});
fb_key.attachments.push(cat.target.view.attachment.clone());
if let Some(ref at) = cat.resolve_target {
@@ -469,7 +469,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
unsafe fn set_push_constants(
&mut self,
layout: &super::PipelineLayout,
stages: wgt::ShaderStage,
stages: wgt::ShaderStages,
offset: u32,
data: &[u32],
) {
@@ -746,7 +746,7 @@ impl crate::CommandEncoder<super::Api> for super::CommandEncoder {
#[test]
fn check_dst_image_layout() {
assert_eq!(
conv::derive_image_layout(crate::TextureUse::COPY_DST, crate::FormatAspect::empty()),
conv::derive_image_layout(crate::TextureUses::COPY_DST, crate::FormatAspects::empty()),
DST_IMAGE_LAYOUT
);
}
+72 -70
View File
@@ -113,7 +113,7 @@ impl super::PrivateCapabilities {
impl crate::Attachment<'_, super::Api> {
pub(super) fn make_attachment_key(
&self,
ops: crate::AttachmentOp,
ops: crate::AttachmentOps,
caps: &super::PrivateCapabilities,
) -> super::AttachmentKey {
let aspects = self.view.aspects();
@@ -154,18 +154,20 @@ impl crate::ColorAttachment<'_, super::Api> {
}
pub fn derive_image_layout(
usage: crate::TextureUse,
aspects: crate::FormatAspect,
usage: crate::TextureUses,
aspects: crate::FormatAspects,
) -> vk::ImageLayout {
//Note: depth textures are always sampled with RODS layout
let is_color = aspects.contains(crate::FormatAspect::COLOR);
let is_color = aspects.contains(crate::FormatAspects::COLOR);
match usage {
crate::TextureUse::UNINITIALIZED => vk::ImageLayout::UNDEFINED,
crate::TextureUse::COPY_SRC => vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
crate::TextureUse::COPY_DST => vk::ImageLayout::TRANSFER_DST_OPTIMAL,
crate::TextureUse::SAMPLED if is_color => vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
crate::TextureUse::COLOR_TARGET => vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
crate::TextureUse::DEPTH_STENCIL_WRITE => vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
crate::TextureUses::UNINITIALIZED => vk::ImageLayout::UNDEFINED,
crate::TextureUses::COPY_SRC => vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
crate::TextureUses::COPY_DST => vk::ImageLayout::TRANSFER_DST_OPTIMAL,
crate::TextureUses::SAMPLED if is_color => vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
crate::TextureUses::COLOR_TARGET => vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
crate::TextureUses::DEPTH_STENCIL_WRITE => {
vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL
}
_ => {
if usage.is_empty() {
vk::ImageLayout::PRESENT_SRC_KHR
@@ -178,33 +180,33 @@ pub fn derive_image_layout(
}
}
pub fn map_texture_usage(usage: crate::TextureUse) -> vk::ImageUsageFlags {
pub fn map_texture_usage(usage: crate::TextureUses) -> vk::ImageUsageFlags {
let mut flags = vk::ImageUsageFlags::empty();
if usage.contains(crate::TextureUse::COPY_SRC) {
if usage.contains(crate::TextureUses::COPY_SRC) {
flags |= vk::ImageUsageFlags::TRANSFER_SRC;
}
if usage.contains(crate::TextureUse::COPY_DST) {
if usage.contains(crate::TextureUses::COPY_DST) {
flags |= vk::ImageUsageFlags::TRANSFER_DST;
}
if usage.contains(crate::TextureUse::SAMPLED) {
if usage.contains(crate::TextureUses::SAMPLED) {
flags |= vk::ImageUsageFlags::SAMPLED;
}
if usage.contains(crate::TextureUse::COLOR_TARGET) {
if usage.contains(crate::TextureUses::COLOR_TARGET) {
flags |= vk::ImageUsageFlags::COLOR_ATTACHMENT;
}
if usage
.intersects(crate::TextureUse::DEPTH_STENCIL_READ | crate::TextureUse::DEPTH_STENCIL_WRITE)
{
if usage.intersects(
crate::TextureUses::DEPTH_STENCIL_READ | crate::TextureUses::DEPTH_STENCIL_WRITE,
) {
flags |= vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT;
}
if usage.intersects(crate::TextureUse::STORAGE_LOAD | crate::TextureUse::STORAGE_STORE) {
if usage.intersects(crate::TextureUses::STORAGE_LOAD | crate::TextureUses::STORAGE_STORE) {
flags |= vk::ImageUsageFlags::STORAGE;
}
flags
}
pub fn map_texture_usage_to_barrier(
usage: crate::TextureUse,
usage: crate::TextureUses,
) -> (vk::PipelineStageFlags, vk::AccessFlags) {
let mut stages = vk::PipelineStageFlags::empty();
let mut access = vk::AccessFlags::empty();
@@ -212,43 +214,43 @@ pub fn map_texture_usage_to_barrier(
| vk::PipelineStageFlags::FRAGMENT_SHADER
| vk::PipelineStageFlags::COMPUTE_SHADER;
if usage.contains(crate::TextureUse::COPY_SRC) {
if usage.contains(crate::TextureUses::COPY_SRC) {
stages |= vk::PipelineStageFlags::TRANSFER;
access |= vk::AccessFlags::TRANSFER_READ;
}
if usage.contains(crate::TextureUse::COPY_DST) {
if usage.contains(crate::TextureUses::COPY_DST) {
stages |= vk::PipelineStageFlags::TRANSFER;
access |= vk::AccessFlags::TRANSFER_WRITE;
}
if usage.contains(crate::TextureUse::SAMPLED) {
if usage.contains(crate::TextureUses::SAMPLED) {
stages |= shader_stages;
access |= vk::AccessFlags::SHADER_READ;
}
if usage.contains(crate::TextureUse::COLOR_TARGET) {
if usage.contains(crate::TextureUses::COLOR_TARGET) {
stages |= vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT;
access |= vk::AccessFlags::COLOR_ATTACHMENT_READ | vk::AccessFlags::COLOR_ATTACHMENT_WRITE;
}
if usage.intersects(crate::TextureUse::DEPTH_STENCIL_READ) {
if usage.intersects(crate::TextureUses::DEPTH_STENCIL_READ) {
stages |= vk::PipelineStageFlags::EARLY_FRAGMENT_TESTS
| vk::PipelineStageFlags::LATE_FRAGMENT_TESTS;
access |= vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ;
}
if usage.intersects(crate::TextureUse::DEPTH_STENCIL_WRITE) {
if usage.intersects(crate::TextureUses::DEPTH_STENCIL_WRITE) {
stages |= vk::PipelineStageFlags::EARLY_FRAGMENT_TESTS
| vk::PipelineStageFlags::LATE_FRAGMENT_TESTS;
access |= vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ
| vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE;
}
if usage.contains(crate::TextureUse::STORAGE_LOAD) {
if usage.contains(crate::TextureUses::STORAGE_LOAD) {
stages |= shader_stages;
access |= vk::AccessFlags::SHADER_READ;
}
if usage.contains(crate::TextureUse::STORAGE_STORE) {
if usage.contains(crate::TextureUses::STORAGE_STORE) {
stages |= shader_stages;
access |= vk::AccessFlags::SHADER_WRITE;
}
if usage == crate::TextureUse::UNINITIALIZED {
if usage == crate::TextureUses::UNINITIALIZED {
(
vk::PipelineStageFlags::TOP_OF_PIPE,
vk::AccessFlags::empty(),
@@ -258,25 +260,25 @@ pub fn map_texture_usage_to_barrier(
}
}
pub fn map_vk_image_usage(usage: vk::ImageUsageFlags) -> crate::TextureUse {
let mut bits = crate::TextureUse::empty();
pub fn map_vk_image_usage(usage: vk::ImageUsageFlags) -> crate::TextureUses {
let mut bits = crate::TextureUses::empty();
if usage.contains(vk::ImageUsageFlags::TRANSFER_SRC) {
bits |= crate::TextureUse::COPY_SRC;
bits |= crate::TextureUses::COPY_SRC;
}
if usage.contains(vk::ImageUsageFlags::TRANSFER_DST) {
bits |= crate::TextureUse::COPY_DST;
bits |= crate::TextureUses::COPY_DST;
}
if usage.contains(vk::ImageUsageFlags::SAMPLED) {
bits |= crate::TextureUse::SAMPLED;
bits |= crate::TextureUses::SAMPLED;
}
if usage.contains(vk::ImageUsageFlags::COLOR_ATTACHMENT) {
bits |= crate::TextureUse::COLOR_TARGET;
bits |= crate::TextureUses::COLOR_TARGET;
}
if usage.contains(vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT) {
bits |= crate::TextureUse::DEPTH_STENCIL_READ | crate::TextureUse::DEPTH_STENCIL_WRITE;
bits |= crate::TextureUses::DEPTH_STENCIL_READ | crate::TextureUses::DEPTH_STENCIL_WRITE;
}
if usage.contains(vk::ImageUsageFlags::STORAGE) {
bits |= crate::TextureUse::STORAGE_LOAD | crate::TextureUse::STORAGE_STORE;
bits |= crate::TextureUses::STORAGE_LOAD | crate::TextureUses::STORAGE_STORE;
}
bits
}
@@ -336,15 +338,15 @@ pub fn map_vertex_format(vertex_format: wgt::VertexFormat) -> vk::Format {
}
}
pub fn map_aspects(aspects: crate::FormatAspect) -> vk::ImageAspectFlags {
pub fn map_aspects(aspects: crate::FormatAspects) -> vk::ImageAspectFlags {
let mut flags = vk::ImageAspectFlags::empty();
if aspects.contains(crate::FormatAspect::COLOR) {
if aspects.contains(crate::FormatAspects::COLOR) {
flags |= vk::ImageAspectFlags::COLOR;
}
if aspects.contains(crate::FormatAspect::DEPTH) {
if aspects.contains(crate::FormatAspects::DEPTH) {
flags |= vk::ImageAspectFlags::DEPTH;
}
if aspects.contains(crate::FormatAspect::STENCIL) {
if aspects.contains(crate::FormatAspects::STENCIL) {
flags |= vk::ImageAspectFlags::STENCIL;
}
flags
@@ -387,14 +389,14 @@ pub fn map_extent(
}
pub fn map_attachment_ops(
op: crate::AttachmentOp,
op: crate::AttachmentOps,
) -> (vk::AttachmentLoadOp, vk::AttachmentStoreOp) {
let load_op = if op.contains(crate::AttachmentOp::LOAD) {
let load_op = if op.contains(crate::AttachmentOps::LOAD) {
vk::AttachmentLoadOp::LOAD
} else {
vk::AttachmentLoadOp::CLEAR
};
let store_op = if op.contains(crate::AttachmentOp::STORE) {
let store_op = if op.contains(crate::AttachmentOps::STORE) {
vk::AttachmentStoreOp::STORE
} else {
vk::AttachmentStoreOp::DONT_CARE
@@ -449,34 +451,34 @@ pub fn map_vk_composite_alpha(flags: vk::CompositeAlphaFlagsKHR) -> Vec<crate::C
modes
}
pub fn map_buffer_usage(usage: crate::BufferUse) -> vk::BufferUsageFlags {
pub fn map_buffer_usage(usage: crate::BufferUses) -> vk::BufferUsageFlags {
let mut flags = vk::BufferUsageFlags::empty();
if usage.contains(crate::BufferUse::COPY_SRC) {
if usage.contains(crate::BufferUses::COPY_SRC) {
flags |= vk::BufferUsageFlags::TRANSFER_SRC;
}
if usage.contains(crate::BufferUse::COPY_DST) {
if usage.contains(crate::BufferUses::COPY_DST) {
flags |= vk::BufferUsageFlags::TRANSFER_DST;
}
if usage.contains(crate::BufferUse::UNIFORM) {
if usage.contains(crate::BufferUses::UNIFORM) {
flags |= vk::BufferUsageFlags::UNIFORM_BUFFER;
}
if usage.intersects(crate::BufferUse::STORAGE_LOAD | crate::BufferUse::STORAGE_STORE) {
if usage.intersects(crate::BufferUses::STORAGE_LOAD | crate::BufferUses::STORAGE_STORE) {
flags |= vk::BufferUsageFlags::STORAGE_BUFFER;
}
if usage.contains(crate::BufferUse::INDEX) {
if usage.contains(crate::BufferUses::INDEX) {
flags |= vk::BufferUsageFlags::INDEX_BUFFER;
}
if usage.contains(crate::BufferUse::VERTEX) {
if usage.contains(crate::BufferUses::VERTEX) {
flags |= vk::BufferUsageFlags::VERTEX_BUFFER;
}
if usage.contains(crate::BufferUse::INDIRECT) {
if usage.contains(crate::BufferUses::INDIRECT) {
flags |= vk::BufferUsageFlags::INDIRECT_BUFFER;
}
flags
}
pub fn map_buffer_usage_to_barrier(
usage: crate::BufferUse,
usage: crate::BufferUses,
) -> (vk::PipelineStageFlags, vk::AccessFlags) {
let mut stages = vk::PipelineStageFlags::empty();
let mut access = vk::AccessFlags::empty();
@@ -484,43 +486,43 @@ pub fn map_buffer_usage_to_barrier(
| vk::PipelineStageFlags::FRAGMENT_SHADER
| vk::PipelineStageFlags::COMPUTE_SHADER;
if usage.contains(crate::BufferUse::MAP_READ) {
if usage.contains(crate::BufferUses::MAP_READ) {
stages |= vk::PipelineStageFlags::HOST;
access |= vk::AccessFlags::HOST_READ;
}
if usage.contains(crate::BufferUse::MAP_WRITE) {
if usage.contains(crate::BufferUses::MAP_WRITE) {
stages |= vk::PipelineStageFlags::HOST;
access |= vk::AccessFlags::HOST_WRITE;
}
if usage.contains(crate::BufferUse::COPY_SRC) {
if usage.contains(crate::BufferUses::COPY_SRC) {
stages |= vk::PipelineStageFlags::TRANSFER;
access |= vk::AccessFlags::TRANSFER_READ;
}
if usage.contains(crate::BufferUse::COPY_DST) {
if usage.contains(crate::BufferUses::COPY_DST) {
stages |= vk::PipelineStageFlags::TRANSFER;
access |= vk::AccessFlags::TRANSFER_WRITE;
}
if usage.contains(crate::BufferUse::UNIFORM) {
if usage.contains(crate::BufferUses::UNIFORM) {
stages |= shader_stages;
access |= vk::AccessFlags::UNIFORM_READ;
}
if usage.intersects(crate::BufferUse::STORAGE_LOAD) {
if usage.intersects(crate::BufferUses::STORAGE_LOAD) {
stages |= shader_stages;
access |= vk::AccessFlags::SHADER_READ;
}
if usage.intersects(crate::BufferUse::STORAGE_STORE) {
if usage.intersects(crate::BufferUses::STORAGE_STORE) {
stages |= shader_stages;
access |= vk::AccessFlags::SHADER_WRITE;
}
if usage.contains(crate::BufferUse::INDEX) {
if usage.contains(crate::BufferUses::INDEX) {
stages |= vk::PipelineStageFlags::VERTEX_INPUT;
access |= vk::AccessFlags::INDEX_READ;
}
if usage.contains(crate::BufferUse::VERTEX) {
if usage.contains(crate::BufferUses::VERTEX) {
stages |= vk::PipelineStageFlags::VERTEX_INPUT;
access |= vk::AccessFlags::VERTEX_ATTRIBUTE_READ;
}
if usage.contains(crate::BufferUse::INDIRECT) {
if usage.contains(crate::BufferUses::INDIRECT) {
stages |= vk::PipelineStageFlags::VERTEX_INPUT;
access |= vk::AccessFlags::INDIRECT_COMMAND_READ;
}
@@ -541,10 +543,10 @@ pub fn map_view_dimension(dim: wgt::TextureViewDimension) -> vk::ImageViewType {
pub fn map_subresource_range(
range: &wgt::ImageSubresourceRange,
texture_aspect: crate::FormatAspect,
texture_aspect: crate::FormatAspects,
) -> vk::ImageSubresourceRange {
vk::ImageSubresourceRange {
aspect_mask: map_aspects(crate::FormatAspect::from(range.aspect) & texture_aspect),
aspect_mask: map_aspects(crate::FormatAspects::from(range.aspect) & texture_aspect),
base_mip_level: range.base_mip_level,
level_count: range
.mip_level_count
@@ -559,7 +561,7 @@ pub fn map_subresource_range(
pub fn map_subresource_layers(
base: &crate::TextureCopyBase,
texture_dim: wgt::TextureDimension,
texture_aspect: crate::FormatAspect,
texture_aspect: crate::FormatAspects,
layer_count: u32,
) -> (vk::ImageSubresourceLayers, vk::Offset3D) {
let (base_array_layer, offset) = map_origin(base.origin, texture_dim);
@@ -618,15 +620,15 @@ pub fn map_comparison(fun: wgt::CompareFunction) -> vk::CompareOp {
}
}
pub fn map_shader_stage(stage: wgt::ShaderStage) -> vk::ShaderStageFlags {
pub fn map_shader_stage(stage: wgt::ShaderStages) -> vk::ShaderStageFlags {
let mut flags = vk::ShaderStageFlags::empty();
if stage.contains(wgt::ShaderStage::VERTEX) {
if stage.contains(wgt::ShaderStages::VERTEX) {
flags |= vk::ShaderStageFlags::VERTEX;
}
if stage.contains(wgt::ShaderStage::FRAGMENT) {
if stage.contains(wgt::ShaderStages::FRAGMENT) {
flags |= vk::ShaderStageFlags::FRAGMENT;
}
if stage.contains(wgt::ShaderStage::COMPUTE) {
if stage.contains(wgt::ShaderStages::COMPUTE) {
flags |= vk::ShaderStageFlags::COMPUTE;
}
flags
+7 -7
View File
@@ -554,17 +554,17 @@ impl crate::Device<super::Api> for super::Device {
let mut alloc_usage = if desc
.usage
.intersects(crate::BufferUse::MAP_READ | crate::BufferUse::MAP_WRITE)
.intersects(crate::BufferUses::MAP_READ | crate::BufferUses::MAP_WRITE)
{
let mut flags = gpu_alloc::UsageFlags::HOST_ACCESS;
//TODO: find a way to use `crate::MemoryFlag::PREFER_COHERENT`
//TODO: find a way to use `crate::MemoryFlags::PREFER_COHERENT`
flags.set(
gpu_alloc::UsageFlags::DOWNLOAD,
desc.usage.contains(crate::BufferUse::MAP_READ),
desc.usage.contains(crate::BufferUses::MAP_READ),
);
flags.set(
gpu_alloc::UsageFlags::UPLOAD,
desc.usage.contains(crate::BufferUse::MAP_WRITE),
desc.usage.contains(crate::BufferUses::MAP_WRITE),
);
flags
} else {
@@ -572,7 +572,7 @@ impl crate::Device<super::Api> for super::Device {
};
alloc_usage.set(
gpu_alloc::UsageFlags::TRANSIENT,
desc.memory_flags.contains(crate::MemoryFlag::TRANSIENT),
desc.memory_flags.contains(crate::MemoryFlags::TRANSIENT),
);
let block = self.mem_allocator.lock().alloc(
@@ -696,7 +696,7 @@ impl crate::Device<super::Api> for super::Device {
block: Some(block),
usage: desc.usage,
dim: desc.dimension,
aspects: crate::FormatAspect::from(desc.format),
aspects: crate::FormatAspects::from(desc.format),
format_info: desc.format.describe(),
raw_flags,
})
@@ -1198,7 +1198,7 @@ impl crate::Device<super::Api> for super::Device {
};
compatible_rp_key.depth_stencil = Some(super::DepthStencilAttachmentKey {
base: super::AttachmentKey::compatible(vk_format, vk_layout),
stencil_ops: crate::AttachmentOp::all(),
stencil_ops: crate::AttachmentOps::all(),
});
if ds.is_depth_enabled() {
+3 -3
View File
@@ -376,7 +376,7 @@ impl crate::Instance<super::Api> for super::Instance {
extensions.push(ext::MetalSurface::name());
}
if desc.flags.contains(crate::InstanceFlag::DEBUG) {
if desc.flags.contains(crate::InstanceFlags::DEBUG) {
extensions.push(ext::DebugUtils::name());
}
@@ -412,7 +412,7 @@ impl crate::Instance<super::Api> for super::Instance {
// Check requested layers against the available layers
let layers = {
let mut layers: Vec<&'static CStr> = Vec::new();
if desc.flags.contains(crate::InstanceFlag::VALIDATION) {
if desc.flags.contains(crate::InstanceFlags::VALIDATION) {
layers.push(CStr::from_bytes_with_nul(b"VK_LAYER_KHRONOS_validation\0").unwrap());
}
@@ -648,7 +648,7 @@ impl crate::Surface<super::Api> for super::Surface {
block: None,
usage: sc.config.usage,
dim: wgt::TextureDimension::D2,
aspects: crate::FormatAspect::COLOR,
aspects: crate::FormatAspects::COLOR,
format_info: sc.config.format.describe(),
raw_flags: vk::ImageCreateFlags::empty(),
},
+8 -8
View File
@@ -75,7 +75,7 @@ struct DebugUtils {
struct InstanceShared {
raw: ash::Instance,
flags: crate::InstanceFlag,
flags: crate::InstanceFlags,
debug_utils: Option<DebugUtils>,
get_physical_device_properties: Option<vk::KhrGetPhysicalDeviceProperties2Fn>,
}
@@ -158,7 +158,7 @@ struct AttachmentKey {
layout_pre: vk::ImageLayout,
layout_in: vk::ImageLayout,
layout_post: vk::ImageLayout,
ops: crate::AttachmentOp,
ops: crate::AttachmentOps,
}
impl AttachmentKey {
@@ -169,7 +169,7 @@ impl AttachmentKey {
layout_pre: vk::ImageLayout::GENERAL,
layout_in,
layout_post: vk::ImageLayout::GENERAL,
ops: crate::AttachmentOp::all(),
ops: crate::AttachmentOps::all(),
}
}
}
@@ -183,7 +183,7 @@ struct ColorAttachmentKey {
#[derive(Clone, Eq, Hash, PartialEq)]
struct DepthStencilAttachmentKey {
base: AttachmentKey,
stencil_ops: crate::AttachmentOp,
stencil_ops: crate::AttachmentOps,
}
#[derive(Clone, Eq, Default, Hash, PartialEq)]
@@ -197,7 +197,7 @@ struct RenderPassKey {
struct FramebufferAttachment {
/// Can be NULL if the framebuffer is image-less
raw: vk::ImageView,
texture_usage: crate::TextureUse,
texture_usage: crate::TextureUses,
raw_image_flags: vk::ImageCreateFlags,
view_format: wgt::TextureFormat,
}
@@ -247,9 +247,9 @@ pub struct Buffer {
pub struct Texture {
raw: vk::Image,
block: Option<gpu_alloc::MemoryBlock<vk::DeviceMemory>>,
usage: crate::TextureUse,
usage: crate::TextureUses,
dim: wgt::TextureDimension,
aspects: crate::FormatAspect,
aspects: crate::FormatAspects,
format_info: wgt::TextureFormatInfo,
raw_flags: vk::ImageCreateFlags,
}
@@ -261,7 +261,7 @@ pub struct TextureView {
}
impl TextureView {
fn aspects(&self) -> crate::FormatAspect {
fn aspects(&self) -> crate::FormatAspects {
self.attachment.view_format.into()
}
}
+2 -4
View File
@@ -87,10 +87,8 @@ fn print_info_from_adapter(adapter: &wgpu::Adapter, idx: usize) {
fn main() {
let args: Vec<_> = std::env::args().skip(1).collect();
let instance = wgpu::Instance::new(wgpu::BackendBit::all());
let adapters: Vec<_> = instance
.enumerate_adapters(wgpu::BackendBit::all())
.collect();
let instance = wgpu::Instance::new(wgpu::Backends::all());
let adapters: Vec<_> = instance.enumerate_adapters(wgpu::Backends::all()).collect();
let adapter_count = adapters.len();
if args.is_empty() {
+26 -26
View File
@@ -92,7 +92,7 @@ bitflags::bitflags! {
#[repr(transparent)]
#[cfg_attr(feature = "trace", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct BackendBit: u32 {
pub struct Backends: u32 {
/// Supported on Windows, Linux/Android, and macOS/iOS via Vulkan Portability (with the Vulkan feature enabled)
const VULKAN = 1 << Backend::Vulkan as u32;
/// Currently unsupported
@@ -120,7 +120,7 @@ bitflags::bitflags! {
}
}
impl From<Backend> for BackendBit {
impl From<Backend> for Backends {
fn from(backend: Backend) -> Self {
Self::from_bits(1 << backend as u32).unwrap()
}
@@ -182,7 +182,7 @@ bitflags::bitflags! {
/// Compressed textures sacrifice some quality in exchange for significantly reduced
/// bandwidth usage.
///
/// Support for this feature guarantees availability of [`TextureUsage::COPY_SRC | TextureUsage::COPY_DST | TextureUsage::SAMPLED`] for BCn formats.
/// Support for this feature guarantees availability of [`TextureUsages::COPY_SRC | TextureUsages::COPY_DST | TextureUsages::SAMPLED`] for BCn formats.
/// [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] may enable additional usages.
///
/// Supported Platforms:
@@ -388,7 +388,7 @@ bitflags::bitflags! {
/// Compressed textures sacrifice some quality in exchange for significantly reduced
/// bandwidth usage.
///
/// Support for this feature guarantees availability of [`TextureUsage::COPY_SRC | TextureUsage::COPY_DST | TextureUsage::SAMPLED`] for ETC2 formats.
/// Support for this feature guarantees availability of [`TextureUsages::COPY_SRC | TextureUsages::COPY_DST | TextureUsages::SAMPLED`] for ETC2 formats.
/// [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] may enable additional usages.
///
/// Supported Platforms:
@@ -403,7 +403,7 @@ bitflags::bitflags! {
/// Compressed textures sacrifice some quality in exchange for significantly reduced
/// bandwidth usage.
///
/// Support for this feature guarantees availability of [`TextureUsage::COPY_SRC | TextureUsage::COPY_DST | TextureUsage::SAMPLED`] for ASTC formats.
/// Support for this feature guarantees availability of [`TextureUsages::COPY_SRC | TextureUsages::COPY_DST | TextureUsages::SAMPLED`] for ASTC formats.
/// [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] may enable additional usages.
///
/// Supported Platforms:
@@ -741,10 +741,10 @@ bitflags::bitflags! {
///
/// These can be combined so something that is visible from both vertex and fragment shaders can be defined as:
///
/// `ShaderStage::VERTEX | ShaderStage::FRAGMENT`
/// `ShaderStages::VERTEX | ShaderStages::FRAGMENT`
#[repr(transparent)]
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
pub struct ShaderStage: u32 {
pub struct ShaderStages: u32 {
/// Binding is not visible from any shader stage.
const NONE = 0;
/// Binding is visible from the vertex shader of a render pipeline.
@@ -958,7 +958,7 @@ pub struct ColorTargetState {
pub blend: Option<BlendState>,
/// Mask which enables/disables writes to different color/alpha channel.
#[cfg_attr(any(feature = "trace", feature = "replay"), serde(default))]
pub write_mask: ColorWrite,
pub write_mask: ColorWrites,
}
impl From<TextureFormat> for ColorTargetState {
@@ -966,7 +966,7 @@ impl From<TextureFormat> for ColorTargetState {
Self {
format,
blend: None,
write_mask: ColorWrite::ALL,
write_mask: ColorWrites::ALL,
}
}
}
@@ -1152,7 +1152,7 @@ bitflags::bitflags! {
#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
pub struct TextureFormatFeatures {
/// Valid bits for `TextureDescriptor::Usage` provided for format creation.
pub allowed_usages: TextureUsage,
pub allowed_usages: TextureUsages,
/// Additional property flags for the format.
pub flags: TextureFormatFeatureFlags,
/// If `filterable` is false, the texture can't be sampled with a filtering sampler.
@@ -1585,10 +1585,10 @@ impl TextureFormat {
let srgb = true;
// Flags
let basic = TextureUsage::COPY_SRC | TextureUsage::COPY_DST | TextureUsage::SAMPLED;
let attachment = basic | TextureUsage::RENDER_ATTACHMENT;
let storage = basic | TextureUsage::STORAGE;
let all_flags = TextureUsage::all();
let basic = TextureUsages::COPY_SRC | TextureUsages::COPY_DST | TextureUsages::SAMPLED;
let attachment = basic | TextureUsages::RENDER_ATTACHMENT;
let storage = basic | TextureUsages::STORAGE;
let all_flags = TextureUsages::all();
// See <https://gpuweb.github.io/gpuweb/#texture-format-caps> for reference
let (required_features, sample_type, srgb, block_dimensions, block_size, allowed_usages) =
@@ -1724,7 +1724,7 @@ bitflags::bitflags! {
#[repr(transparent)]
#[cfg_attr(feature = "trace", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct ColorWrite: u32 {
pub struct ColorWrites: u32 {
/// Enable red channel writes
const RED = 1;
/// Enable green channel writes
@@ -1740,7 +1740,7 @@ bitflags::bitflags! {
}
}
impl Default for ColorWrite {
impl Default for ColorWrites {
fn default() -> Self {
Self::ALL
}
@@ -2106,7 +2106,7 @@ bitflags::bitflags! {
#[repr(transparent)]
#[cfg_attr(feature = "trace", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct BufferUsage: u32 {
pub struct BufferUsages: u32 {
/// Allow a buffer to be mapped for reading using [`Buffer::map_async`] + [`Buffer::get_mapped_range`].
/// This does not include creating a buffer with [`BufferDescriptor::mapped_at_creation`] set.
///
@@ -2150,9 +2150,9 @@ pub struct BufferDescriptor<L> {
pub size: BufferAddress,
/// Usages of a buffer. If the buffer is used in any way that isn't specified here, the operation
/// will panic.
pub usage: BufferUsage,
/// Allows a buffer to be mapped immediately after they are made. It does not have to be [`BufferUsage::MAP_READ`] or
/// [`BufferUsage::MAP_WRITE`], all buffers are allowed to be mapped at creation.
pub usage: BufferUsages,
/// Allows a buffer to be mapped immediately after they are made. It does not have to be [`BufferUsages::MAP_READ`] or
/// [`BufferUsages::MAP_WRITE`], all buffers are allowed to be mapped at creation.
pub mapped_at_creation: bool,
}
@@ -2223,7 +2223,7 @@ bitflags::bitflags! {
#[repr(transparent)]
#[cfg_attr(feature = "trace", derive(Serialize))]
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct TextureUsage: u32 {
pub struct TextureUsages: u32 {
/// Allows a texture to be the source in a [`CommandEncoder::copy_texture_to_buffer`] or
/// [`CommandEncoder::copy_texture_to_texture`] operation.
const COPY_SRC = 1;
@@ -2246,7 +2246,7 @@ bitflags::bitflags! {
#[cfg_attr(feature = "replay", derive(Deserialize))]
pub struct SwapChainDescriptor {
/// The usage of the swap chain. The only supported usage is `RENDER_ATTACHMENT`.
pub usage: TextureUsage,
pub usage: TextureUsages,
/// The texture format of the swap chain. The only formats that are guaranteed are
/// `Bgra8Unorm` and `Bgra8UnormSrgb`
pub format: TextureFormat,
@@ -2474,7 +2474,7 @@ pub struct TextureDescriptor<L> {
/// Format of the texture.
pub format: TextureFormat,
/// Allowed usages of the texture. If used in other ways, the operation will panic.
pub usage: TextureUsage,
pub usage: TextureUsages,
}
impl<L> TextureDescriptor<L> {
@@ -2507,7 +2507,7 @@ impl<L> TextureDescriptor<L> {
/// sample_count: 1,
/// dimension: wgpu::TextureDimension::D3,
/// format: wgpu::TextureFormat::Rgba8Sint,
/// usage: wgpu::TextureUsage::empty(),
/// usage: wgpu::TextureUsages::empty(),
/// };
///
/// assert_eq!(desc.mip_level_size(0), Some(wgpu::Extent3d { width: 100, height: 60, depth_or_array_layers: 1 }));
@@ -2627,7 +2627,7 @@ impl Default for FilterMode {
pub struct PushConstantRange {
/// Stage push constant range is visible from. Each stage can only be served by at most one range.
/// One range can serve multiple stages however.
pub stages: ShaderStage,
pub stages: ShaderStages,
/// Range in push constant memory to use for the stage. Must be less than [`Limits::max_push_constant_size`].
/// Start and end must be aligned to the 4s.
pub range: Range<u32>,
@@ -2928,7 +2928,7 @@ pub struct BindGroupLayoutEntry {
/// of index 1, would be described as `layout(set = 0, binding = 1) uniform` in shaders.
pub binding: u32,
/// Which shader stages can see this binding.
pub visibility: ShaderStage,
pub visibility: ShaderStages,
/// The type of the binding
pub ty: BindingType,
/// If this value is Some, indicates this entry is an array. Array size must be 1 or greater.
+8 -8
View File
@@ -62,7 +62,7 @@ impl framework::Example for Example {
let sim_param_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Simulation Parameter Buffer"),
contents: bytemuck::cast_slice(&sim_param_data),
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
// create compute bind layout group and compute pipeline layout
@@ -72,7 +72,7 @@ impl framework::Example for Example {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::COMPUTE,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
@@ -84,7 +84,7 @@ impl framework::Example for Example {
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::COMPUTE,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: true },
has_dynamic_offset: false,
@@ -94,7 +94,7 @@ impl framework::Example for Example {
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStage::COMPUTE,
visibility: wgpu::ShaderStages::COMPUTE,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: false },
has_dynamic_offset: false,
@@ -165,7 +165,7 @@ impl framework::Example for Example {
let vertices_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::bytes_of(&vertex_buffer_data),
usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
});
// buffer for all particles data of type [(posx,posy,velx,vely),...]
@@ -190,9 +190,9 @@ impl framework::Example for Example {
device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(&format!("Particle Buffer {}", i)),
contents: bytemuck::cast_slice(&initial_particle_data),
usage: wgpu::BufferUsage::VERTEX
| wgpu::BufferUsage::STORAGE
| wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::VERTEX
| wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_DST,
}),
);
}
+8 -8
View File
@@ -56,7 +56,7 @@ impl framework::Example for Example {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
@@ -66,7 +66,7 @@ impl framework::Example for Example {
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
@@ -76,7 +76,7 @@ impl framework::Example for Example {
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler {
filtering: true,
comparison: false,
@@ -90,7 +90,7 @@ impl framework::Example for Example {
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true,
@@ -120,7 +120,7 @@ impl framework::Example for Example {
targets: &[wgpu::ColorTargetState {
format: sc_desc.format,
blend: Some(wgpu::BlendState::ALPHA_BLENDING),
write_mask: wgpu::ColorWrite::default(),
write_mask: wgpu::ColorWrites::default(),
}],
}),
primitive: wgpu::PrimitiveState {
@@ -150,7 +150,7 @@ impl framework::Example for Example {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsage::COPY_DST | wgpu::TextureUsage::SAMPLED,
usage: wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::SAMPLED,
});
queue.write_texture(
texture.as_image_copy(),
@@ -192,12 +192,12 @@ impl framework::Example for Example {
let global_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("global"),
contents: bytemuck::bytes_of(&globals),
usage: wgpu::BufferUsage::COPY_DST | wgpu::BufferUsage::UNIFORM,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::UNIFORM,
});
let local_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("local"),
size: (MAX_BUNNIES as wgpu::BufferAddress) * wgpu::BIND_BUFFER_ALIGNMENT,
usage: wgpu::BufferUsage::COPY_DST | wgpu::BufferUsage::UNIFORM,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::UNIFORM,
mapped_at_creation: false,
});
+3 -3
View File
@@ -28,7 +28,7 @@ async fn create_red_image_with_dimensions(
width: usize,
height: usize,
) -> (Device, Buffer, BufferDimensions) {
let adapter = wgpu::Instance::new(wgpu::BackendBit::PRIMARY)
let adapter = wgpu::Instance::new(wgpu::Backends::PRIMARY)
.request_adapter(&wgpu::RequestAdapterOptions::default())
.await
.unwrap();
@@ -54,7 +54,7 @@ async fn create_red_image_with_dimensions(
let output_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size: (buffer_dimensions.padded_bytes_per_row * buffer_dimensions.height) as u64,
usage: wgpu::BufferUsage::MAP_READ | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
@@ -71,7 +71,7 @@ async fn create_red_image_with_dimensions(
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsage::RENDER_ATTACHMENT | wgpu::TextureUsage::COPY_SRC,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
label: None,
});
+3 -3
View File
@@ -34,7 +34,7 @@ impl Example {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: RENDER_TARGET_FORMAT,
usage: wgpu::TextureUsage::SAMPLED | wgpu::TextureUsage::RENDER_ATTACHMENT,
usage: wgpu::TextureUsages::SAMPLED | wgpu::TextureUsages::RENDER_ATTACHMENT,
})
.create_view(&Default::default());
@@ -171,7 +171,7 @@ impl framework::Example for Example {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: false },
view_dimension: wgpu::TextureViewDimension::D2,
@@ -181,7 +181,7 @@ impl framework::Example for Example {
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler {
filtering: false,
comparison: false,
+7 -7
View File
@@ -124,13 +124,13 @@ impl framework::Example for Example {
let vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&vertex_data),
usage: wgpu::BufferUsage::VERTEX,
usage: wgpu::BufferUsages::VERTEX,
});
let index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Index Buffer"),
contents: bytemuck::cast_slice(&index_data),
usage: wgpu::BufferUsage::INDEX,
usage: wgpu::BufferUsages::INDEX,
});
// Create pipeline layout
@@ -139,7 +139,7 @@ impl framework::Example for Example {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
@@ -149,7 +149,7 @@ impl framework::Example for Example {
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
multisampled: false,
sample_type: wgpu::TextureSampleType::Uint,
@@ -180,7 +180,7 @@ impl framework::Example for Example {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::R8Uint,
usage: wgpu::TextureUsage::SAMPLED | wgpu::TextureUsage::COPY_DST,
usage: wgpu::TextureUsages::SAMPLED | wgpu::TextureUsages::COPY_DST,
});
let texture_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
queue.write_texture(
@@ -200,7 +200,7 @@ impl framework::Example for Example {
let uniform_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Uniform Buffer"),
contents: bytemuck::cast_slice(mx_ref),
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
// Create bind group
@@ -287,7 +287,7 @@ impl framework::Example for Example {
},
alpha: wgpu::BlendComponent::REPLACE,
}),
write_mask: wgpu::ColorWrite::ALL,
write_mask: wgpu::ColorWrites::ALL,
}],
}),
primitive: wgpu::PrimitiveState {
+5 -5
View File
@@ -110,7 +110,7 @@ async fn setup<E: Example>(title: &str) -> Setup {
log::info!("Initializing the surface...");
let backend = wgpu::util::backend_bits_from_env().unwrap_or(wgpu::BackendBit::PRIMARY);
let backend = wgpu::util::backend_bits_from_env().unwrap_or(wgpu::Backends::PRIMARY);
let instance = wgpu::Instance::new(backend);
let (size, surface) = unsafe {
@@ -178,7 +178,7 @@ fn start<E: Example>(
) {
let spawner = Spawner::new();
let mut sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
width: size.width,
height: size.height,
@@ -407,7 +407,7 @@ pub fn test<E: Example>(mut params: FrameworkRefTest) {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsage::RENDER_ATTACHMENT | wgpu::TextureUsage::COPY_SRC,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
});
let dst_view = dst_texture.create_view(&wgpu::TextureViewDescriptor::default());
@@ -415,13 +415,13 @@ pub fn test<E: Example>(mut params: FrameworkRefTest) {
let dst_buffer = ctx.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("image map buffer"),
size: params.width as u64 * params.height as u64 * 4,
usage: wgpu::BufferUsage::COPY_DST | wgpu::BufferUsage::MAP_READ,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
let mut example = E::init(
&wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: wgpu::TextureFormat::Rgba8UnormSrgb,
width: params.width,
height: params.height,
+7 -7
View File
@@ -33,7 +33,7 @@ async fn run() {
async fn execute_gpu(numbers: &[u32]) -> Option<Vec<u32>> {
// Instantiates instance of WebGPU
let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
let instance = wgpu::Instance::new(wgpu::Backends::PRIMARY);
// `request_adapter` instantiates the general connection to the GPU
let adapter = instance
@@ -80,12 +80,12 @@ async fn execute_gpu_inner(
// Instantiates buffer without data.
// `usage` of buffer specifies how it can be used:
// `BufferUsage::MAP_READ` allows it to be read (outside the shader).
// `BufferUsage::COPY_DST` allows it to be the destination of the copy.
// `BufferUsages::MAP_READ` allows it to be read (outside the shader).
// `BufferUsages::COPY_DST` allows it to be the destination of the copy.
let staging_buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size,
usage: wgpu::BufferUsage::MAP_READ | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
@@ -97,9 +97,9 @@ async fn execute_gpu_inner(
let storage_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Storage Buffer"),
contents: bytemuck::cast_slice(numbers),
usage: wgpu::BufferUsage::STORAGE
| wgpu::BufferUsage::COPY_DST
| wgpu::BufferUsage::COPY_SRC,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_DST
| wgpu::BufferUsages::COPY_SRC,
});
// A bind group defines how buffers are accessed by shaders.
+2 -2
View File
@@ -7,7 +7,7 @@ use winit::{
async fn run(event_loop: EventLoop<()>, window: Window) {
let size = window.inner_size();
let instance = wgpu::Instance::new(wgpu::BackendBit::all());
let instance = wgpu::Instance::new(wgpu::Backends::all());
let surface = unsafe { instance.create_surface(&window) };
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
@@ -64,7 +64,7 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
});
let mut sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: swapchain_format,
width: size.width,
height: size.height,
+2 -2
View File
@@ -31,7 +31,7 @@ impl ViewportDesc {
let size = self.window.inner_size();
let sc_desc = wgpu::SwapChainDescriptor {
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: adapter
.get_swap_chain_preferred_format(&self.surface)
.unwrap(),
@@ -65,7 +65,7 @@ impl Viewport {
}
async fn run(event_loop: EventLoop<()>, viewports: Vec<(Window, wgpu::Color)>) {
let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
let instance = wgpu::Instance::new(wgpu::Backends::PRIMARY);
let viewports: Vec<_> = viewports
.into_iter()
.map(|(window, color)| ViewportDesc::new(window, color, &instance))
+1 -1
View File
@@ -1,7 +1,7 @@
/// This example shows how to describe the adapter in use.
async fn run() {
#[cfg_attr(target_arch = "wasm32", allow(unused_variables))]
let adapter = wgpu::Instance::new(wgpu::BackendBit::PRIMARY)
let adapter = wgpu::Instance::new(wgpu::Backends::PRIMARY)
.request_adapter(&wgpu::RequestAdapterOptions::default())
.await
.unwrap();
+7 -7
View File
@@ -225,9 +225,9 @@ impl framework::Example for Example {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: TEXTURE_FORMAT,
usage: wgpu::TextureUsage::SAMPLED
| wgpu::TextureUsage::RENDER_ATTACHMENT
| wgpu::TextureUsage::COPY_DST,
usage: wgpu::TextureUsages::SAMPLED
| wgpu::TextureUsages::RENDER_ATTACHMENT
| wgpu::TextureUsages::COPY_DST,
label: None,
});
let texture_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
@@ -236,7 +236,7 @@ impl framework::Example for Example {
let temp_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Temporary Buffer"),
contents: texels.as_slice(),
usage: wgpu::BufferUsage::COPY_SRC,
usage: wgpu::BufferUsages::COPY_SRC,
});
init_encoder.copy_buffer_to_texture(
wgpu::ImageCopyBuffer {
@@ -267,7 +267,7 @@ impl framework::Example for Example {
let uniform_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Uniform Buffer"),
contents: bytemuck::cast_slice(mx_ref),
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
// Create the render pipeline
@@ -355,7 +355,7 @@ impl framework::Example for Example {
size: mip_passes as wgpu::BufferAddress
* 3
* mem::size_of::<u64>() as wgpu::BufferAddress,
usage: wgpu::BufferUsage::COPY_DST | wgpu::BufferUsage::MAP_READ,
usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
@@ -483,7 +483,7 @@ fn mipmap() {
height: 768,
optional_features: wgpu::Features::default(),
base_test_parameters: framework::test_common::TestParameters::default()
.backend_failures(wgpu::BackendBit::VULKAN),
.backend_failures(wgpu::Backends::VULKAN),
tollerance: 25,
max_outliers: 3000, // Mipmap sampling is highly variant between impls. This is currently bounded by AMD on mac
});
+2 -2
View File
@@ -104,7 +104,7 @@ impl Example {
sample_count,
dimension: wgpu::TextureDimension::D2,
format: sc_desc.format,
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
label: None,
};
@@ -157,7 +157,7 @@ impl framework::Example for Example {
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&vertex_data),
usage: wgpu::BufferUsage::VERTEX,
usage: wgpu::BufferUsages::VERTEX,
});
let vertex_count = vertex_data.len() as u32;
+18 -18
View File
@@ -200,7 +200,7 @@ impl Example {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
label: None,
});
@@ -226,7 +226,7 @@ impl framework::Example for Example {
&wgpu::util::BufferInitDescriptor {
label: Some("Cubes Vertex Buffer"),
contents: bytemuck::cast_slice(&cube_vertex_data),
usage: wgpu::BufferUsage::VERTEX,
usage: wgpu::BufferUsages::VERTEX,
},
));
@@ -234,7 +234,7 @@ impl framework::Example for Example {
&wgpu::util::BufferInitDescriptor {
label: Some("Cubes Index Buffer"),
contents: bytemuck::cast_slice(&cube_index_data),
usage: wgpu::BufferUsage::INDEX,
usage: wgpu::BufferUsages::INDEX,
},
));
@@ -242,13 +242,13 @@ impl framework::Example for Example {
let plane_vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Plane Vertex Buffer"),
contents: bytemuck::cast_slice(&plane_vertex_data),
usage: wgpu::BufferUsage::VERTEX,
usage: wgpu::BufferUsages::VERTEX,
});
let plane_index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Plane Index Buffer"),
contents: bytemuck::cast_slice(&plane_index_data),
usage: wgpu::BufferUsage::INDEX,
usage: wgpu::BufferUsages::INDEX,
});
struct CubeDesc {
@@ -291,7 +291,7 @@ impl framework::Example for Example {
let entity_uniform_buf = device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size: num_entities * wgpu::BIND_BUFFER_ALIGNMENT,
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
@@ -335,7 +335,7 @@ impl framework::Example for Example {
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX | wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true,
@@ -377,7 +377,7 @@ impl framework::Example for Example {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: Self::SHADOW_FORMAT,
usage: wgpu::TextureUsage::RENDER_ATTACHMENT | wgpu::TextureUsage::SAMPLED,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::SAMPLED,
label: None,
});
let shadow_view = shadow_texture.create_view(&wgpu::TextureViewDescriptor::default());
@@ -427,9 +427,9 @@ impl framework::Example for Example {
let light_storage_buf = device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size: light_uniform_size,
usage: wgpu::BufferUsage::STORAGE
| wgpu::BufferUsage::COPY_SRC
| wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
@@ -453,7 +453,7 @@ impl framework::Example for Example {
label: None,
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0, // global
visibility: wgpu::ShaderStage::VERTEX,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
@@ -471,7 +471,7 @@ impl framework::Example for Example {
let uniform_buf = device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size: uniform_size,
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
@@ -530,7 +530,7 @@ impl framework::Example for Example {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0, // global
visibility: wgpu::ShaderStage::VERTEX | wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
@@ -542,7 +542,7 @@ impl framework::Example for Example {
},
wgpu::BindGroupLayoutEntry {
binding: 1, // lights
visibility: wgpu::ShaderStage::VERTEX | wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: true },
has_dynamic_offset: false,
@@ -552,7 +552,7 @@ impl framework::Example for Example {
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
multisampled: false,
sample_type: wgpu::TextureSampleType::Depth,
@@ -562,7 +562,7 @@ impl framework::Example for Example {
},
wgpu::BindGroupLayoutEntry {
binding: 3,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler {
comparison: true,
filtering: true,
@@ -586,7 +586,7 @@ impl framework::Example for Example {
let uniform_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Uniform Buffer"),
contents: bytemuck::bytes_of(&forward_uniforms),
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
// Create bind group
+8 -8
View File
@@ -86,7 +86,7 @@ impl Skybox {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: Self::DEPTH_FORMAT,
usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
label: None,
});
@@ -130,7 +130,7 @@ impl framework::Example for Skybox {
let vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex"),
contents: bytemuck::cast_slice(&vertices),
usage: wgpu::BufferUsage::VERTEX,
usage: wgpu::BufferUsages::VERTEX,
});
entities.push(Entity {
vertex_count: vertices.len() as u32,
@@ -145,7 +145,7 @@ impl framework::Example for Skybox {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX | wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
@@ -155,7 +155,7 @@ impl framework::Example for Skybox {
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
multisampled: false,
@@ -165,7 +165,7 @@ impl framework::Example for Skybox {
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler {
comparison: false,
filtering: true,
@@ -191,7 +191,7 @@ impl framework::Example for Skybox {
let uniform_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Buffer"),
contents: bytemuck::cast_slice(&raw_uniforms),
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
@@ -324,7 +324,7 @@ impl framework::Example for Skybox {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: skybox_format,
usage: wgpu::TextureUsage::SAMPLED | wgpu::TextureUsage::COPY_DST,
usage: wgpu::TextureUsages::SAMPLED | wgpu::TextureUsages::COPY_DST,
label: None,
},
&image.data,
@@ -472,7 +472,7 @@ fn skybox() {
height: 768,
optional_features: wgpu::Features::default(),
base_test_parameters: framework::test_common::TestParameters::default()
.backend_failures(wgpu::BackendBit::VULKAN),
.backend_failures(wgpu::Backends::VULKAN),
tollerance: 2,
max_outliers: 3,
});
+8 -8
View File
@@ -112,14 +112,14 @@ impl framework::Example for Example {
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&vertex_data),
usage: wgpu::BufferUsage::VERTEX,
usage: wgpu::BufferUsages::VERTEX,
});
let index_data = create_indices();
let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Index Buffer"),
contents: bytemuck::cast_slice(&index_data),
usage: wgpu::BufferUsage::INDEX,
usage: wgpu::BufferUsages::INDEX,
});
let red_texture_data = create_texture_data(Color::RED);
@@ -131,7 +131,7 @@ impl framework::Example for Example {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8UnormSrgb,
usage: wgpu::TextureUsage::SAMPLED | wgpu::TextureUsage::COPY_DST,
usage: wgpu::TextureUsages::SAMPLED | wgpu::TextureUsages::COPY_DST,
label: None,
};
let red_texture = device.create_texture(&wgpu::TextureDescriptor {
@@ -174,7 +174,7 @@ impl framework::Example for Example {
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
@@ -184,7 +184,7 @@ impl framework::Example for Example {
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler {
comparison: false,
filtering: true,
@@ -217,7 +217,7 @@ impl framework::Example for Example {
bind_group_layouts: &[&bind_group_layout],
push_constant_ranges: if uniform_workaround {
&[wgpu::PushConstantRange {
stages: wgpu::ShaderStage::FRAGMENT,
stages: wgpu::ShaderStages::FRAGMENT,
range: 0..4,
}]
} else {
@@ -301,9 +301,9 @@ impl framework::Example for Example {
rpass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
rpass.set_index_buffer(self.index_buffer.slice(..), self.index_format);
if self.uniform_workaround {
rpass.set_push_constants(wgpu::ShaderStage::FRAGMENT, 0, bytemuck::cast_slice(&[0]));
rpass.set_push_constants(wgpu::ShaderStages::FRAGMENT, 0, bytemuck::cast_slice(&[0]));
rpass.draw_indexed(0..6, 0, 0..1);
rpass.set_push_constants(wgpu::ShaderStage::FRAGMENT, 0, bytemuck::cast_slice(&[1]));
rpass.set_push_constants(wgpu::ShaderStages::FRAGMENT, 0, bytemuck::cast_slice(&[1]));
rpass.draw_indexed(6..12, 0, 0..1);
} else {
rpass.draw_indexed(0..12, 0, 0..1);
+17 -17
View File
@@ -198,9 +198,9 @@ impl Example {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: sc_desc.format,
usage: wgpu::TextureUsage::SAMPLED
| wgpu::TextureUsage::COPY_DST
| wgpu::TextureUsage::RENDER_ATTACHMENT,
usage: wgpu::TextureUsages::SAMPLED
| wgpu::TextureUsages::COPY_DST
| wgpu::TextureUsages::RENDER_ATTACHMENT,
});
let draw_depth_buffer = device.create_texture(&wgpu::TextureDescriptor {
@@ -210,9 +210,9 @@ impl Example {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Depth32Float,
usage: wgpu::TextureUsage::SAMPLED
| wgpu::TextureUsage::COPY_DST
| wgpu::TextureUsage::RENDER_ATTACHMENT,
usage: wgpu::TextureUsages::SAMPLED
| wgpu::TextureUsages::COPY_DST
| wgpu::TextureUsages::RENDER_ATTACHMENT,
});
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
@@ -338,13 +338,13 @@ impl framework::Example for Example {
let water_vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Water vertices"),
contents: bytemuck::cast_slice(&water_vertices),
usage: wgpu::BufferUsage::VERTEX,
usage: wgpu::BufferUsages::VERTEX,
});
let terrain_vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Terrain vertices"),
contents: bytemuck::cast_slice(&terrain_vertices),
usage: wgpu::BufferUsage::VERTEX,
usage: wgpu::BufferUsages::VERTEX,
});
// Create the bind group layout. This is what our uniforms will look like.
@@ -355,7 +355,7 @@ impl framework::Example for Example {
// Uniform variables such as projection/view.
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX | wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
@@ -368,7 +368,7 @@ impl framework::Example for Example {
// Reflection texture.
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
multisampled: false,
sample_type: wgpu::TextureSampleType::Float { filterable: true },
@@ -379,7 +379,7 @@ impl framework::Example for Example {
// Depth texture for terrain.
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
multisampled: false,
sample_type: wgpu::TextureSampleType::Float { filterable: true },
@@ -390,7 +390,7 @@ impl framework::Example for Example {
// Sampler to be able to sample the textures.
wgpu::BindGroupLayoutEntry {
binding: 3,
visibility: wgpu::ShaderStage::FRAGMENT,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler {
comparison: false,
filtering: true,
@@ -407,7 +407,7 @@ impl framework::Example for Example {
// Regular uniform variables like view/projection.
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStage::VERTEX,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
@@ -438,21 +438,21 @@ impl framework::Example for Example {
let water_uniform_buf = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Water Uniforms"),
size: mem::size_of::<WaterUniforms>() as _,
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let terrain_normal_uniform_buf = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Normal Terrain Uniforms"),
size: mem::size_of::<TerrainUniforms>() as _,
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let terrain_flipped_uniform_buf = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Flipped Terrain Uniforms"),
size: mem::size_of::<TerrainUniforms>() as _,
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
@@ -537,7 +537,7 @@ impl framework::Example for Example {
operation: wgpu::BlendOperation::Max,
},
}),
write_mask: wgpu::ColorWrite::ALL,
write_mask: wgpu::ColorWrites::ALL,
}],
}),
// How the triangles will be rasterized. This is more important
+6 -6
View File
@@ -43,7 +43,7 @@ impl Context {
&self.0
}
pub fn enumerate_adapters(&self, backends: wgt::BackendBit) -> Vec<wgc::id::AdapterId> {
pub fn enumerate_adapters(&self, backends: wgt::Backends) -> Vec<wgc::id::AdapterId> {
self.0
.enumerate_adapters(wgc::instance::AdapterInputs::Mask(backends, |_| {
PhantomData
@@ -235,7 +235,7 @@ mod pass_impl {
) {
wgpu_render_pass_set_vertex_buffer(self, slot, buffer.id, offset, size)
}
fn set_push_constants(&mut self, stages: wgt::ShaderStage, offset: u32, data: &[u8]) {
fn set_push_constants(&mut self, stages: wgt::ShaderStages, offset: u32, data: &[u8]) {
unsafe {
wgpu_render_pass_set_push_constants(
self,
@@ -446,7 +446,7 @@ mod pass_impl {
wgpu_render_bundle_set_vertex_buffer(self, slot, buffer.id, offset, size)
}
fn set_push_constants(&mut self, stages: wgt::ShaderStage, offset: u32, data: &[u8]) {
fn set_push_constants(&mut self, stages: wgt::ShaderStages, offset: u32, data: &[u8]) {
unsafe {
wgpu_render_bundle_set_push_constants(
self,
@@ -642,7 +642,7 @@ impl crate::Context for Context {
Ready<Result<(Self::DeviceId, Self::QueueId), crate::RequestDeviceError>>;
type MapAsyncFuture = native_gpu_future::GpuFuture<Result<(), crate::BufferAsyncError>>;
fn init(backends: wgt::BackendBit) -> Self {
fn init(backends: wgt::Backends) -> Self {
Self(wgc::hub::Global::new(
"wgpu",
wgc::hub::IdentityManagerFactory,
@@ -666,7 +666,7 @@ impl crate::Context for Context {
power_preference: options.power_preference,
compatible_surface: options.compatible_surface.map(|surface| surface.id),
},
wgc::instance::AdapterInputs::Mask(wgt::BackendBit::all(), |_| PhantomData),
wgc::instance::AdapterInputs::Mask(wgt::Backends::all(), |_| PhantomData),
);
ready(id.ok())
}
@@ -1127,7 +1127,7 @@ impl crate::Context for Context {
if let wgc::pipeline::CreateComputePipelineError::Internal(ref error) = cause {
log::warn!(
"Shader translation error for stage {:?}: {}",
wgt::ShaderStage::COMPUTE,
wgt::ShaderStages::COMPUTE,
error
);
log::warn!("Please report it to https://github.com/gfx-rs/naga");
+4 -4
View File
@@ -186,7 +186,7 @@ impl crate::RenderInner<Context> for RenderPass {
self.0
.set_vertex_buffer_with_f64_and_f64(slot, &buffer.0, offset as f64, mapped_size);
}
fn set_push_constants(&mut self, _stages: wgt::ShaderStage, _offset: u32, _data: &[u8]) {
fn set_push_constants(&mut self, _stages: wgt::ShaderStages, _offset: u32, _data: &[u8]) {
panic!("PUSH_CONSTANTS feature must be enabled to call multi_draw_indexed_indirect")
}
fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
@@ -315,7 +315,7 @@ impl crate::RenderInner<Context> for RenderBundleEncoder {
self.0
.set_vertex_buffer_with_f64_and_f64(slot, &buffer.0, offset as f64, mapped_size);
}
fn set_push_constants(&mut self, _stages: wgt::ShaderStage, _offset: u32, _data: &[u8]) {
fn set_push_constants(&mut self, _stages: wgt::ShaderStages, _offset: u32, _data: &[u8]) {
panic!("PUSH_CONSTANTS feature must be enabled to call multi_draw_indexed_indirect")
}
fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
@@ -924,7 +924,7 @@ impl crate::Context for Context {
fn(JsFutureResult) -> Result<(), crate::BufferAsyncError>,
>;
fn init(_backends: wgt::BackendBit) -> Self {
fn init(_backends: wgt::Backends) -> Self {
Context(web_sys::window().unwrap().navigator().gpu())
}
@@ -960,7 +960,7 @@ impl crate::Context for Context {
//TODO: support this check, return `None` if the flag is not set.
// It's not trivial, since we need the Future logic to have this check,
// and currently the Future here has no room for extra parameter `backends`.
//assert!(backends.contains(wgt::BackendBit::BROWSER_WEBGPU));
//assert!(backends.contains(wgt::Backends::BROWSER_WEBGPU));
let mut mapped_options = web_sys::GpuRequestAdapterOptions::new();
let mapped_power_preference = match options.power_preference {
wgt::PowerPreference::LowPower => web_sys::GpuPowerPreference::LowPower,
+24 -24
View File
@@ -25,20 +25,20 @@ use std::{
use parking_lot::Mutex;
pub use wgt::{
AdapterInfo, AddressMode, Backend, BackendBit, BindGroupLayoutEntry, BindingType,
BlendComponent, BlendFactor, BlendOperation, BlendState, BufferAddress, BufferBindingType,
BufferSize, BufferUsage, Color, ColorTargetState, ColorWrite, CommandBufferDescriptor,
CompareFunction, DepthBiasState, DepthStencilState, DeviceType, DownlevelCapabilities,
DownlevelFlags, DynamicOffset, Extent3d, Face, Features, FilterMode, FrontFace,
ImageDataLayout, IndexFormat, InputStepMode, Limits, MultisampleState, Origin3d,
PipelineStatisticsTypes, PolygonMode, PowerPreference, PresentMode, PrimitiveState,
PrimitiveTopology, PushConstantRange, QueryType, SamplerBorderColor, ShaderLocation,
ShaderModel, ShaderStage, StencilFaceState, StencilOperation, StencilState,
StorageTextureAccess, SwapChainDescriptor, SwapChainStatus, TextureAspect, TextureDimension,
TextureFormat, TextureFormatFeatureFlags, TextureFormatFeatures, TextureSampleType,
TextureUsage, TextureViewDimension, VertexAttribute, VertexFormat, BIND_BUFFER_ALIGNMENT,
COPY_BUFFER_ALIGNMENT, COPY_BYTES_PER_ROW_ALIGNMENT, MAP_ALIGNMENT, PUSH_CONSTANT_ALIGNMENT,
QUERY_SET_MAX_QUERIES, QUERY_SIZE, VERTEX_STRIDE_ALIGNMENT,
AdapterInfo, AddressMode, Backend, Backends, BindGroupLayoutEntry, BindingType, BlendComponent,
BlendFactor, BlendOperation, BlendState, BufferAddress, BufferBindingType, BufferSize,
BufferUsages, Color, ColorTargetState, ColorWrites, CommandBufferDescriptor, CompareFunction,
DepthBiasState, DepthStencilState, DeviceType, DownlevelCapabilities, DownlevelFlags,
DynamicOffset, Extent3d, Face, Features, FilterMode, FrontFace, ImageDataLayout, IndexFormat,
InputStepMode, Limits, MultisampleState, Origin3d, PipelineStatisticsTypes, PolygonMode,
PowerPreference, PresentMode, PrimitiveState, PrimitiveTopology, PushConstantRange, QueryType,
SamplerBorderColor, ShaderLocation, ShaderModel, ShaderStages, StencilFaceState,
StencilOperation, StencilState, StorageTextureAccess, SwapChainDescriptor, SwapChainStatus,
TextureAspect, TextureDimension, TextureFormat, TextureFormatFeatureFlags,
TextureFormatFeatures, TextureSampleType, TextureUsages, TextureViewDimension, VertexAttribute,
VertexFormat, BIND_BUFFER_ALIGNMENT, COPY_BUFFER_ALIGNMENT, COPY_BYTES_PER_ROW_ALIGNMENT,
MAP_ALIGNMENT, PUSH_CONSTANT_ALIGNMENT, QUERY_SET_MAX_QUERIES, QUERY_SIZE,
VERTEX_STRIDE_ALIGNMENT,
};
use backend::{BufferMappedRange, Context as C};
@@ -88,7 +88,7 @@ trait RenderInner<Ctx: Context> {
offset: BufferAddress,
size: Option<BufferSize>,
);
fn set_push_constants(&mut self, stages: wgt::ShaderStage, offset: u32, data: &[u8]);
fn set_push_constants(&mut self, stages: wgt::ShaderStages, offset: u32, data: &[u8]);
fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>);
fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>);
fn draw_indirect(&mut self, indirect_buffer: &Ctx::BufferId, indirect_offset: BufferAddress);
@@ -183,7 +183,7 @@ trait Context: Debug + Send + Sized + Sync {
+ Send;
type MapAsyncFuture: Future<Output = Result<(), BufferAsyncError>> + Send;
fn init(backends: BackendBit) -> Self;
fn init(backends: Backends) -> Self;
fn instance_create_surface(
&self,
handle: &impl raw_window_handle::HasRawWindowHandle,
@@ -591,7 +591,7 @@ pub struct Buffer {
context: Arc<C>,
id: <C as Context>::BufferId,
map_context: Mutex<MapContext>,
usage: BufferUsage,
usage: BufferUsages,
}
/// Slice into a [`Buffer`].
@@ -1380,21 +1380,21 @@ impl Instance {
///
/// # Arguments
///
/// - `backends` - Controls from which [backends][BackendBit] wgpu will choose
/// - `backends` - Controls from which [backends][Backends] wgpu will choose
/// during instantiation.
pub fn new(backends: BackendBit) -> Self {
pub fn new(backends: Backends) -> Self {
Instance {
context: Arc::new(C::init(backends)),
}
}
/// Retrieves all available [`Adapter`]s that match the given [`BackendBit`].
/// Retrieves all available [`Adapter`]s that match the given [`Backends`].
///
/// # Arguments
///
/// - `backends` - Backends from which to enumerate adapters.
#[cfg(not(target_arch = "wasm32"))]
pub fn enumerate_adapters(&self, backends: BackendBit) -> impl Iterator<Item = Adapter> {
pub fn enumerate_adapters(&self, backends: Backends) -> impl Iterator<Item = Adapter> {
let context = Arc::clone(&self.context);
self.context
.enumerate_adapters(backends)
@@ -1990,7 +1990,7 @@ impl<'a> BufferSlice<'a> {
BufferViewMut {
slice: *self,
data,
readable: self.buffer.usage.contains(BufferUsage::MAP_READ),
readable: self.buffer.usage.contains(BufferUsages::MAP_READ),
}
}
}
@@ -2635,7 +2635,7 @@ impl<'a> RenderPass<'a> {
///
/// You would need to upload this in three set_push_constants calls. First for the `Vertex` only range 0..4, second
/// for the `Vertex | Fragment` range 4..8, third for the `Fragment` range 8..12.
pub fn set_push_constants(&mut self, stages: wgt::ShaderStage, offset: u32, data: &[u8]) {
pub fn set_push_constants(&mut self, stages: wgt::ShaderStages, offset: u32, data: &[u8]) {
self.id.set_push_constants(stages, offset, data);
}
}
@@ -2942,7 +2942,7 @@ impl<'a> RenderBundleEncoder<'a> {
///
/// You would need to upload this in three set_push_constants calls. First for the `Vertex` only range 0..4, second
/// for the `Vertex | Fragment` range 4..8, third for the `Fragment` range 8..12.
pub fn set_push_constants(&mut self, stages: wgt::ShaderStage, offset: u32, data: &[u8]) {
pub fn set_push_constants(&mut self, stages: wgt::ShaderStages, offset: u32, data: &[u8]) {
self.id.set_push_constants(stages, offset, data);
}
}
+2 -2
View File
@@ -1,5 +1,5 @@
use crate::{
Buffer, BufferAddress, BufferDescriptor, BufferSize, BufferUsage, BufferViewMut,
Buffer, BufferAddress, BufferDescriptor, BufferSize, BufferUsages, BufferViewMut,
CommandEncoder, Device, MapMode,
};
use std::pin::Pin;
@@ -116,7 +116,7 @@ impl StagingBelt {
buffer: device.create_buffer(&BufferDescriptor {
label: Some("staging"),
size,
usage: BufferUsage::MAP_WRITE | BufferUsage::COPY_SRC,
usage: BufferUsages::MAP_WRITE | BufferUsages::COPY_SRC,
mapped_at_creation: true,
}),
size,
+1 -1
View File
@@ -9,7 +9,7 @@ pub struct BufferInitDescriptor<'a> {
pub contents: &'a [u8],
/// Usages of a buffer. If the buffer is used in any way that isn't specified here, the operation
/// will panic.
pub usage: crate::BufferUsage,
pub usage: crate::BufferUsages,
}
/// Utility methods not meant to be in the main API.
+3 -3
View File
@@ -117,7 +117,7 @@ pub trait RenderEncoder<'a> {
///
/// You would need to upload this in three set_push_constants calls. First for the `Vertex` only range 0..4, second
/// for the `Vertex | Fragment` range 4..8, third for the `Fragment` range 8..12.
fn set_push_constants(&mut self, stages: wgt::ShaderStage, offset: u32, data: &[u8]);
fn set_push_constants(&mut self, stages: wgt::ShaderStages, offset: u32, data: &[u8]);
}
impl<'a> RenderEncoder<'a> for RenderPass<'a> {
@@ -166,7 +166,7 @@ impl<'a> RenderEncoder<'a> for RenderPass<'a> {
}
#[inline(always)]
fn set_push_constants(&mut self, stages: wgt::ShaderStage, offset: u32, data: &[u8]) {
fn set_push_constants(&mut self, stages: wgt::ShaderStages, offset: u32, data: &[u8]) {
Self::set_push_constants(self, stages, offset, data);
}
}
@@ -217,7 +217,7 @@ impl<'a> RenderEncoder<'a> for RenderBundleEncoder<'a> {
}
#[inline(always)]
fn set_push_constants(&mut self, stages: wgt::ShaderStage, offset: u32, data: &[u8]) {
fn set_push_constants(&mut self, stages: wgt::ShaderStages, offset: u32, data: &[u8]) {
Self::set_push_constants(self, stages, offset, data);
}
}
+11 -14
View File
@@ -1,21 +1,21 @@
use wgt::{BackendBit, PowerPreference, RequestAdapterOptions};
use wgt::{Backends, PowerPreference, RequestAdapterOptions};
use crate::{Adapter, Instance};
/// Get a set of backend bits from the environment variable WGPU_BACKEND.
pub fn backend_bits_from_env() -> Option<BackendBit> {
pub fn backend_bits_from_env() -> Option<Backends> {
Some(
match std::env::var("WGPU_BACKEND")
.as_deref()
.map(str::to_lowercase)
.as_deref()
{
Ok("vulkan") => BackendBit::VULKAN,
Ok("dx12") => BackendBit::DX12,
Ok("dx11") => BackendBit::DX11,
Ok("metal") => BackendBit::METAL,
Ok("gl") => BackendBit::GL,
Ok("webgpu") => BackendBit::BROWSER_WEBGPU,
Ok("vulkan") => Backends::VULKAN,
Ok("dx12") => Backends::DX12,
Ok("dx11") => Backends::DX11,
Ok("metal") => Backends::METAL,
Ok("gl") => Backends::GL,
Ok("webgpu") => Backends::BROWSER_WEBGPU,
_ => return None,
},
)
@@ -38,10 +38,7 @@ pub fn power_preference_from_env() -> Option<PowerPreference> {
/// Initialize the adapter obeying the WGPU_ADAPTER_NAME environment variable.
#[cfg(not(target_arch = "wasm32"))]
pub fn initialize_adapter_from_env(
instance: &Instance,
backend_bits: BackendBit,
) -> Option<Adapter> {
pub fn initialize_adapter_from_env(instance: &Instance, backend_bits: Backends) -> Option<Adapter> {
let desired_adapter_name = std::env::var("WGPU_ADAPTER_NAME")
.as_deref()
.map(str::to_lowercase)
@@ -66,7 +63,7 @@ pub fn initialize_adapter_from_env(
#[cfg(target_arch = "wasm32")]
pub fn initialize_adapter_from_env(
_instance: &Instance,
_backend_bits: BackendBit,
_backend_bits: Backends,
) -> Option<Adapter> {
None
}
@@ -74,7 +71,7 @@ pub fn initialize_adapter_from_env(
/// Initialize the adapter obeying the WGPU_ADAPTER_NAME environment variable and if it doesn't exist fall back on a default adapter.
pub async fn initialize_adapter_from_env_or_default(
instance: &Instance,
backend_bits: wgt::BackendBit,
backend_bits: wgt::Backends,
) -> Option<Adapter> {
match initialize_adapter_from_env(&instance, backend_bits) {
Some(a) => Some(a),
+1 -1
View File
@@ -85,7 +85,7 @@ impl DownloadBuffer {
let download = device.create_buffer(&super::BufferDescriptor {
size,
usage: super::BufferUsage::COPY_DST | super::BufferUsage::MAP_READ,
usage: super::BufferUsages::COPY_DST | super::BufferUsages::MAP_READ,
mapped_at_creation: false,
label: None,
});
+13 -18
View File
@@ -3,7 +3,7 @@
use std::panic::{catch_unwind, AssertUnwindSafe};
use wgt::{BackendBit, DeviceDescriptor, DownlevelCapabilities, Features, Limits};
use wgt::{Backends, DeviceDescriptor, DownlevelCapabilities, Features, Limits};
use wgpu::{util, Adapter, Device, Instance, Queue};
@@ -77,12 +77,7 @@ pub struct TestParameters {
pub required_limits: Limits,
pub required_downlevel_properties: DownlevelCapabilities,
// Backends where test should fail.
pub failures: Vec<(
Option<wgpu::BackendBit>,
Option<usize>,
Option<String>,
bool,
)>,
pub failures: Vec<(Option<wgpu::Backends>, Option<usize>, Option<String>, bool)>,
}
impl Default for TestParameters {
@@ -97,7 +92,7 @@ impl Default for TestParameters {
}
bitflags::bitflags! {
pub struct FailureReason: u8 {
pub struct FailureReasons: u8 {
const BACKEND = 0x1;
const VENDOR = 0x2;
const ADAPTER = 0x4;
@@ -131,7 +126,7 @@ impl TestParameters {
}
/// Mark the test as always failing on a specific backend, equivilant to specific_failure(backend, None, None)
pub fn backend_failures(mut self, backends: wgpu::BackendBit) -> Self {
pub fn backend_failures(mut self, backends: wgpu::Backends) -> Self {
self.failures.push((Some(backends), None, None, false));
self
}
@@ -139,13 +134,13 @@ impl TestParameters {
/// Determines if a test should fail under a particular set of conditions. If any of these are None, that means that it will match anything in that field.
///
/// ex.
/// `specific_failure(Some(wgpu::BackendBit::DX11 | wgpu::BackendBit::DX12), None, Some("RTX"), false)`
/// `specific_failure(Some(wgpu::Backends::DX11 | wgpu::Backends::DX12), None, Some("RTX"), false)`
/// means that this test will fail on all cards with RTX in their name on either D3D backend, no matter the vendor ID.
///
/// If segfault is set to true, the test won't be run at all due to avoid segfaults.
pub fn specific_failure(
mut self,
backends: Option<BackendBit>,
backends: Option<Backends>,
vendor: Option<usize>,
device: Option<&'static str>,
segfault: bool,
@@ -164,7 +159,7 @@ pub fn initialize_test(parameters: TestParameters, test_function: impl FnOnce(Te
// We don't actually care if it fails
let _ = env_logger::try_init();
let backend_bits = util::backend_bits_from_env().unwrap_or_else(BackendBit::all);
let backend_bits = util::backend_bits_from_env().unwrap_or_else(Backends::all);
let instance = Instance::new(backend_bits);
let adapter = pollster::block_on(util::initialize_adapter_from_env_or_default(
&instance,
@@ -228,7 +223,7 @@ pub fn initialize_test(parameters: TestParameters, test_function: impl FnOnce(Te
backend_failure.is_none() && vendor_failure.is_none() && adapter_failure.is_none();
let expect_failure_backend = backend_failure
.map(|f| f.contains(wgpu::BackendBit::from(adapter_info.backend)))
.map(|f| f.contains(wgpu::Backends::from(adapter_info.backend)))
.unwrap_or(true);
let expect_failure_vendor = vendor_failure
.map(|v| v == adapter_info.vendor)
@@ -240,12 +235,12 @@ pub fn initialize_test(parameters: TestParameters, test_function: impl FnOnce(Te
if expect_failure_backend && expect_failure_vendor && expect_failure_adapter {
if always {
Some((FailureReason::ALWAYS, *segfault))
Some((FailureReasons::ALWAYS, *segfault))
} else {
let mut reason = FailureReason::empty();
reason.set(FailureReason::BACKEND, expect_failure_backend);
reason.set(FailureReason::VENDOR, expect_failure_vendor);
reason.set(FailureReason::ADAPTER, expect_failure_adapter);
let mut reason = FailureReasons::empty();
reason.set(FailureReasons::BACKEND, expect_failure_backend);
reason.set(FailureReasons::VENDOR, expect_failure_vendor);
reason.set(FailureReasons::ADAPTER, expect_failure_adapter);
Some((reason, *segfault))
}
} else {
+2 -2
View File
@@ -1,13 +1,13 @@
#[test]
fn initialize() {
let _ = wgpu::Instance::new(
wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::BackendBit::all),
wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all),
);
}
fn request_adapter_inner(power: wgt::PowerPreference) {
let instance = wgpu::Instance::new(
wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::BackendBit::all),
wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all),
);
let _adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
+8 -8
View File
@@ -24,7 +24,7 @@ fn pulling_common(
has_dynamic_offset: false,
min_binding_size: NonZeroU64::new(4),
},
visibility: wgpu::ShaderStage::VERTEX,
visibility: wgpu::ShaderStages::VERTEX,
count: None,
}],
});
@@ -32,9 +32,9 @@ fn pulling_common(
let buffer = ctx.device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size: 4 * expected.len() as u64,
usage: wgpu::BufferUsage::COPY_SRC
| wgpu::BufferUsage::STORAGE
| wgpu::BufferUsage::MAP_READ,
usage: wgpu::BufferUsages::COPY_SRC
| wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::MAP_READ,
mapped_at_creation: false,
});
@@ -74,7 +74,7 @@ fn pulling_common(
targets: &[wgpu::ColorTargetState {
format: wgpu::TextureFormat::Rgba8Unorm,
blend: None,
write_mask: wgpu::ColorWrite::ALL,
write_mask: wgpu::ColorWrites::ALL,
}],
}),
});
@@ -94,7 +94,7 @@ fn pulling_common(
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsage::RENDER_ATTACHMENT | wgpu::TextureUsage::COPY_DST,
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
},
&[0, 0, 0, 1],
)
@@ -143,7 +143,7 @@ fn draw_vertex_offset() {
initialize_test(
TestParameters::default()
.test_features()
.backend_failures(wgpu::BackendBit::DX12 | wgpu::BackendBit::DX11),
.backend_failures(wgpu::Backends::DX12 | wgpu::Backends::DX11),
|ctx| {
pulling_common(ctx, &[0, 1, 2, 3, 4, 5], |cmb| {
cmb.draw(0..3, 0..1);
@@ -167,7 +167,7 @@ fn draw_instanced_offset() {
initialize_test(
TestParameters::default()
.test_features()
.backend_failures(wgpu::BackendBit::DX12 | wgpu::BackendBit::DX11),
.backend_failures(wgpu::Backends::DX12 | wgpu::Backends::DX11),
|ctx| {
pulling_common(ctx, &[0, 1, 2, 3, 4, 5], |cmb| {
cmb.draw(0..3, 0..1);