From fd460fa1e4512bd66294d134ceca885e44aac4e9 Mon Sep 17 00:00:00 2001 From: Zicklag Date: Tue, 27 Jul 2021 16:05:15 -0500 Subject: [PATCH] Use Bitshift Style for All Bitflag Consts This makes existing bitflags easier to read and makes it eaiser to add new flags later. --- wgpu-core/src/pipeline.rs | 6 +- wgpu-hal/src/dx12/mod.rs | 4 +- wgpu-hal/src/lib.rs | 78 +++++++++++----------- wgpu-types/src/lib.rs | 134 +++++++++++++++++++------------------- wgpu/tests/common/mod.rs | 8 +-- 5 files changed, 115 insertions(+), 115 deletions(-) diff --git a/wgpu-core/src/pipeline.rs b/wgpu-core/src/pipeline.rs index 14a7f6b01d..f090bffd8e 100644 --- a/wgpu-core/src/pipeline.rs +++ b/wgpu-core/src/pipeline.rs @@ -273,9 +273,9 @@ pub enum CreateRenderPipelineError { bitflags::bitflags! { #[repr(transparent)] pub struct PipelineFlags: u32 { - const BLEND_CONSTANT = 1; - const STENCIL_REFERENCE = 2; - const WRITES_DEPTH_STENCIL = 4; + const BLEND_CONSTANT = 1 << 0; + const STENCIL_REFERENCE = 1 << 1; + const WRITES_DEPTH_STENCIL = 1 << 2; } } diff --git a/wgpu-hal/src/dx12/mod.rs b/wgpu-hal/src/dx12/mod.rs index 7459603d7f..8b789a87e2 100644 --- a/wgpu-hal/src/dx12/mod.rs +++ b/wgpu-hal/src/dx12/mod.rs @@ -470,8 +470,8 @@ pub struct BindGroup { bitflags::bitflags! { struct TableTypes: u8 { - const SRV_CBV_UAV = 0x1; - const SAMPLERS = 0x2; + const SRV_CBV_UAV = 1 << 0; + const SAMPLERS = 1 << 1; } } diff --git a/wgpu-hal/src/lib.rs b/wgpu-hal/src/lib.rs index 38527772d3..aa9677ee10 100644 --- a/wgpu-hal/src/lib.rs +++ b/wgpu-hal/src/lib.rs @@ -499,9 +499,9 @@ bitflags!( /// Instance initialization flags. pub struct InstanceFlags: u32 { /// Generate debug information in shaders and objects. - const DEBUG = 0x1; + const DEBUG = 1 << 0; /// Enable validation, if possible. - const VALIDATION = 0x2; + const VALIDATION = 1 << 1; } ); @@ -509,7 +509,7 @@ bitflags!( /// Pipeline layout creation flags. pub struct PipelineLayoutFlags: u32 { /// Include support for base vertex/instance drawing. - const BASE_VERTEX_INSTANCE = 0x1; + const BASE_VERTEX_INSTANCE = 1 << 0; } ); @@ -517,39 +517,39 @@ bitflags!( /// Texture format capability flags. pub struct TextureFormatCapabilities: u32 { /// Format can be sampled. - const SAMPLED = 0x1; + const SAMPLED = 1 << 0; /// Format can be sampled with a linear sampler. - const SAMPLED_LINEAR = 0x2; + const SAMPLED_LINEAR = 1 << 1; /// Format can be sampled with a min/max reduction sampler. - const SAMPLED_MINMAX = 0x4; + const SAMPLED_MINMAX = 1 << 2; /// Format can be used as storage with write-only access. - const STORAGE = 0x10; + const STORAGE = 1 << 3; /// Format can be used as storage with read and read/write access. - const STORAGE_READ_WRITE = 0x20; + const STORAGE_READ_WRITE = 1 << 4; /// Format can be used as storage with atomics. - const STORAGE_ATOMIC = 0x40; + const STORAGE_ATOMIC = 1 << 5; /// Format can be used as color and input attachment. - const COLOR_ATTACHMENT = 0x100; + const COLOR_ATTACHMENT = 1 << 6; /// Format can be used as color (with blending) and input attachment. - const COLOR_ATTACHMENT_BLEND = 0x200; + const COLOR_ATTACHMENT_BLEND = 1 << 7; /// Format can be used as depth-stencil and input attachment. - const DEPTH_STENCIL_ATTACHMENT = 0x400; + const DEPTH_STENCIL_ATTACHMENT = 1 << 8; /// Format can be copied from. - const COPY_SRC = 0x1000; + const COPY_SRC = 1 << 9; /// Format can be copied to. - const COPY_DST = 0x2000; + const COPY_DST = 1 << 10; } ); bitflags!( /// Texture format capability flags. pub struct FormatAspects: u8 { - const COLOR = 1; - const DEPTH = 2; - const STENCIL = 4; + const COLOR = 1 << 0; + const DEPTH = 1 << 1; + const STENCIL = 1 << 2; } ); @@ -575,8 +575,8 @@ impl From for FormatAspects { bitflags!( pub struct MemoryFlags: u32 { - const TRANSIENT = 1; - const PREFER_COHERENT = 2; + const TRANSIENT = 1 << 0; + const PREFER_COHERENT = 1 << 1; } ); @@ -584,24 +584,24 @@ bitflags!( bitflags!( pub struct AttachmentOps: u8 { - const LOAD = 1; - const STORE = 2; + const LOAD = 1 << 0; + const STORE = 1 << 1; } ); bitflags::bitflags! { /// Similar to `wgt::BufferUsages` but for internal use. pub struct BufferUses: u32 { - const MAP_READ = 1; - const MAP_WRITE = 2; - const COPY_SRC = 4; - const COPY_DST = 8; - const INDEX = 16; - const VERTEX = 32; - const UNIFORM = 64; - const STORAGE_READ = 128; - const STORAGE_WRITE = 256; - const INDIRECT = 512; + const MAP_READ = 1 << 0; + const MAP_WRITE = 1 << 1; + const COPY_SRC = 1 << 2; + const COPY_DST = 1 << 3; + const INDEX = 1 << 4; + const VERTEX = 1 << 5; + const UNIFORM = 1 << 6; + const STORAGE_READ = 1 << 7; + const STORAGE_WRITE = 1 << 8; + const INDIRECT = 1 << 9; /// The combination of usages that can be used together (read-only). const INCLUSIVE = Self::MAP_READ.bits | Self::COPY_SRC.bits | Self::INDEX.bits | Self::VERTEX.bits | Self::UNIFORM.bits | @@ -618,14 +618,14 @@ bitflags::bitflags! { bitflags::bitflags! { /// Similar to `wgt::TextureUsages` but for internal use. pub struct TextureUses: u32 { - const COPY_SRC = 1; - const COPY_DST = 2; - const RESOURCE = 4; - const COLOR_TARGET = 8; - const DEPTH_STENCIL_READ = 16; - const DEPTH_STENCIL_WRITE = 32; - const STORAGE_READ = 64; - const STORAGE_WRITE = 128; + const COPY_SRC = 1 << 0; + const COPY_DST = 1 << 1; + const RESOURCE = 1 << 2; + const COLOR_TARGET = 1 << 3; + const DEPTH_STENCIL_READ = 1 << 4; + const DEPTH_STENCIL_WRITE = 1 << 5; + const STORAGE_READ = 1 << 6; + const STORAGE_WRITE = 1 << 7; /// The combination of usages that can be used together (read-only). const INCLUSIVE = Self::COPY_SRC.bits | Self::RESOURCE.bits | Self::DEPTH_STENCIL_READ.bits; /// The combination of exclusive usages (write-only and read-write). diff --git a/wgpu-types/src/lib.rs b/wgpu-types/src/lib.rs index a24fa03be2..55b9f5a32e 100644 --- a/wgpu-types/src/lib.rs +++ b/wgpu-types/src/lib.rs @@ -175,7 +175,7 @@ bitflags::bitflags! { /// - some mobile chips /// /// This is a web and native feature. - const DEPTH_CLAMPING = 0x0000_0000_0000_0001; + const DEPTH_CLAMPING = 1 << 0; /// Enables BCn family of compressed textures. All BCn textures use 4x4 pixel blocks /// with 8 or 16 bytes per block. /// @@ -189,7 +189,7 @@ bitflags::bitflags! { /// - desktops /// /// This is a web and native feature. - const TEXTURE_COMPRESSION_BC = 0x0000_0000_0000_0002; + const TEXTURE_COMPRESSION_BC = 1 << 1; /// Enables use of Timestamp Queries. These queries tell the current gpu timestamp when /// all work before the query is finished. Call [`CommandEncoder::write_timestamp`], /// [`RenderPassEncoder::write_timestamp`], or [`ComputePassEncoder::write_timestamp`] to @@ -207,7 +207,7 @@ bitflags::bitflags! { /// - DX12 (works) /// /// This is a web and native feature. - const TIMESTAMP_QUERY = 0x0000_0000_0000_0004; + const TIMESTAMP_QUERY = 1 << 2; /// Enables use of Pipeline Statistics Queries. These queries tell the count of various operations /// performed between the start and stop call. Call [`RenderPassEncoder::begin_pipeline_statistics_query`] to start /// a query, then call [`RenderPassEncoder::end_pipeline_statistics_query`] to stop one. @@ -222,7 +222,7 @@ bitflags::bitflags! { /// - DX12 (works) /// /// This is a web and native feature. - const PIPELINE_STATISTICS_QUERY = 0x0000_0000_0000_0008; + const PIPELINE_STATISTICS_QUERY = 1 << 3; /// Webgpu only allows the MAP_READ and MAP_WRITE buffer usage to be matched with /// COPY_DST and COPY_SRC respectively. This removes this requirement. /// @@ -234,7 +234,7 @@ bitflags::bitflags! { /// - All /// /// This is a native only feature. - const MAPPABLE_PRIMARY_BUFFERS = 0x0000_0000_0001_0000; + const MAPPABLE_PRIMARY_BUFFERS = 1 << 16; /// Allows the user to create uniform arrays of textures in shaders: /// /// eg. `uniform texture2D textures[10]`. @@ -253,7 +253,7 @@ bitflags::bitflags! { /// - Vulkan /// /// This is a native only feature. - const TEXTURE_BINDING_ARRAY = 0x0000_0000_0002_0000; + const TEXTURE_BINDING_ARRAY = 1 << 17; /// Allows the user to create arrays of buffers in shaders: /// /// eg. `uniform myBuffer { .... } buffer_array[10]`. @@ -271,7 +271,7 @@ bitflags::bitflags! { /// - Vulkan /// /// This is a native only feature. - const BUFFER_BINDING_ARRAY = 0x0000_0000_0004_0000; + const BUFFER_BINDING_ARRAY = 1 << 18; /// Allows the user to create uniform arrays of storage buffers or textures in shaders, /// if resp. [`Features::BUFFER_BINDING_ARRAY`] or [`Features::TEXTURE_BINDING_ARRAY`] /// is supported. @@ -284,7 +284,7 @@ bitflags::bitflags! { /// - Vulkan /// /// This is a native only feature. - const STORAGE_RESOURCE_BINDING_ARRAY = 0x0000_0000_0008_0000; + const STORAGE_RESOURCE_BINDING_ARRAY = 1 << 19; /// Allows shaders to index resource arrays with dynamically non-uniform values: /// /// eg. `texture_array[vertex_data]` @@ -309,7 +309,7 @@ bitflags::bitflags! { /// - Vulkan 1.2+ (or VK_EXT_descriptor_indexing)'s shaderSampledImageArrayNonUniformIndexing feature) /// /// This is a native only feature. - const RESOURCE_BINDING_ARRAY_NON_UNIFORM_INDEXING = 0x0000_0000_0010_0000; + const RESOURCE_BINDING_ARRAY_NON_UNIFORM_INDEXING = 1 << 20; /// Allows the user to create unsized uniform arrays of bindings: /// /// eg. `uniform texture2D textures[]`. @@ -322,7 +322,7 @@ bitflags::bitflags! { /// - Vulkan 1.2+ (or VK_EXT_descriptor_indexing)'s runtimeDescriptorArray feature /// /// This is a native only feature. - const UNSIZED_BINDING_ARRAY = 0x0000_0000_0020_0000; + const UNSIZED_BINDING_ARRAY = 1 << 21; /// Allows the user to call [`RenderPass::multi_draw_indirect`] and [`RenderPass::multi_draw_indexed_indirect`]. /// /// Allows multiple indirect calls to be dispatched from a single buffer. @@ -332,7 +332,7 @@ bitflags::bitflags! { /// - Vulkan /// /// This is a native only feature. - const MULTI_DRAW_INDIRECT = 0x0000_0000_0040_0000; + const MULTI_DRAW_INDIRECT = 1 << 22; /// Allows the user to call [`RenderPass::multi_draw_indirect_count`] and [`RenderPass::multi_draw_indexed_indirect_count`]. /// /// This allows the use of a buffer containing the actual number of draw calls. @@ -342,7 +342,7 @@ bitflags::bitflags! { /// - Vulkan 1.2+ (or VK_KHR_draw_indirect_count) /// /// This is a native only feature. - const MULTI_DRAW_INDIRECT_COUNT = 0x0000_0000_0080_0000; + const MULTI_DRAW_INDIRECT_COUNT = 1 << 23; /// Allows the use of push constants: small, fast bits of memory that can be updated /// inside a [`RenderPass`]. /// @@ -359,7 +359,7 @@ bitflags::bitflags! { /// - OpenGL (emulated with uniforms) /// /// This is a native only feature. - const PUSH_CONSTANTS = 0x0000_0000_0100_0000; + const PUSH_CONSTANTS = 1 << 24; /// Allows the use of [`AddressMode::ClampToBorder`]. /// /// Supported platforms: @@ -370,7 +370,7 @@ bitflags::bitflags! { /// - OpenGL /// /// This is a web and native feature. - const ADDRESS_MODE_CLAMP_TO_BORDER = 0x0000_0000_0200_0000; + const ADDRESS_MODE_CLAMP_TO_BORDER = 1 << 25; /// Allows the user to set a non-fill polygon mode in [`PrimitiveState::polygon_mode`] /// /// This allows drawing polygons/triangles as lines (wireframe) or points instead of filled @@ -380,7 +380,7 @@ bitflags::bitflags! { /// - Vulkan /// /// This is a native only feature. - const NON_FILL_POLYGON_MODE = 0x0000_0000_0400_0000; + const NON_FILL_POLYGON_MODE = 1 << 26; /// Enables ETC family of compressed textures. All ETC textures use 4x4 pixel blocks. /// ETC2 RGB and RGBA1 are 8 bytes per block. RTC2 RGBA8 and EAC are 16 bytes per block. /// @@ -395,7 +395,7 @@ bitflags::bitflags! { /// - Mobile (some) /// /// This is a native-only feature. - const TEXTURE_COMPRESSION_ETC2 = 0x0000_0000_0800_0000; + const TEXTURE_COMPRESSION_ETC2 = 1 << 27; /// Enables ASTC family of compressed textures. ASTC textures use pixel blocks varying from 4x4 to 12x12. /// Blocks are always 16 bytes. /// @@ -410,7 +410,7 @@ bitflags::bitflags! { /// - Mobile (some) /// /// This is a native-only feature. - const TEXTURE_COMPRESSION_ASTC_LDR = 0x0000_0000_1000_0000; + const TEXTURE_COMPRESSION_ASTC_LDR = 1 << 28; /// Enables device specific texture format features. /// /// See `TextureFormatFeatures` for a listing of the features in question. @@ -422,7 +422,7 @@ bitflags::bitflags! { /// This extension does not enable additional formats. /// /// This is a native-only feature. - const TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES = 0x0000_0000_2000_0000; + const TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES = 1 << 29; /// Enables 64-bit floating point types in SPIR-V shaders. /// /// Note: even when supported by GPU hardware, 64-bit floating point operations are @@ -432,7 +432,7 @@ bitflags::bitflags! { /// - Vulkan /// /// This is a native-only feature. - const SHADER_FLOAT64 = 0x0000_0000_4000_0000; + const SHADER_FLOAT64 = 1 << 30; /// Enables using 64-bit types for vertex attributes. /// /// Requires SHADER_FLOAT64. @@ -440,7 +440,7 @@ bitflags::bitflags! { /// Supported Platforms: N/A /// /// This is a native-only feature. - const VERTEX_ATTRIBUTE_64BIT = 0x0000_0000_8000_0000; + const VERTEX_ATTRIBUTE_64BIT = 1 << 31; /// Allows the user to set a overestimation-conservative-rasterization in [`PrimitiveState::conservative`] /// /// Processing of degenerate triangles/lines is hardware specific. @@ -450,7 +450,7 @@ bitflags::bitflags! { /// - Vulkan /// /// This is a native only feature. - const CONSERVATIVE_RASTERIZATION = 0x0000_0001_0000_0000; + const CONSERVATIVE_RASTERIZATION = 1 << 32; /// Enables bindings of writable storage buffers and textures visible to vertex shaders. /// /// Note: some (tiled-based) platforms do not support vertex shaders with any side-effects. @@ -459,14 +459,14 @@ bitflags::bitflags! { /// - All /// /// This is a native-only feature. - const VERTEX_WRITABLE_STORAGE = 0x0000_0002_0000_0000; + const VERTEX_WRITABLE_STORAGE = 1 << 33; /// Enables clear to zero for buffers & images. /// /// Supported platforms: /// - All /// /// This is a native only feature. - const CLEAR_COMMANDS = 0x0000_0400_0000_0000; + const CLEAR_COMMANDS = 1 << 34; /// Enables creating shader modules from SPIR-V binary data (unsafe). /// /// SPIR-V data is not parsed or interpreted in any way; you can use @@ -478,7 +478,7 @@ bitflags::bitflags! { /// Vulkan implementation. /// /// This is a native only feature. - const SPIRV_SHADER_PASSTHROUGH = 0x0000_0800_0000_0000; + const SPIRV_SHADER_PASSTHROUGH = 1 << 35; /// Enables `builtin(primitive_index)` in fragment shaders. /// /// Note: enables geometry processing for pipelines using the builtin. @@ -489,7 +489,7 @@ bitflags::bitflags! { /// - Vulkan /// /// This is a native only feature. - const SHADER_PRIMITIVE_INDEX = 0x0000_1000_0000_0000; + const SHADER_PRIMITIVE_INDEX = 1 << 36; } } @@ -705,33 +705,33 @@ bitflags::bitflags! { /// Binary flags listing various ways the underlying platform does not conform to the WebGPU standard. pub struct DownlevelFlags: u32 { /// The device supports compiling and using compute shaders. - const COMPUTE_SHADERS = 0x0000_0001; + const COMPUTE_SHADERS = 1 << 0; /// Supports binding storage buffers and textures to fragment shaders. - const FRAGMENT_WRITABLE_STORAGE = 0x0000_0002; + const FRAGMENT_WRITABLE_STORAGE = 1 << 1; /// Supports indirect drawing and dispatching. - const INDIRECT_EXECUTION = 0x0000_0004; + const INDIRECT_EXECUTION = 1 << 2; /// Supports non-zero `base_vertex` parameter to indexed draw calls. - const BASE_VERTEX = 0x0000_0008; + const BASE_VERTEX = 1 << 3; /// Supports reading from a depth/stencil buffer while using as a read-only depth/stencil attachment. - const READ_ONLY_DEPTH_STENCIL = 0x0000_0010; + const READ_ONLY_DEPTH_STENCIL = 1 << 4; /// Supports: /// - copy_image_to_image /// - copy_buffer_to_image and copy_image_to_buffer with a buffer without a MAP_* usage - const DEVICE_LOCAL_IMAGE_COPIES = 0x0000_0020; + const DEVICE_LOCAL_IMAGE_COPIES = 1 << 5; /// Supports textures with mipmaps which have a non power of two size. - const NON_POWER_OF_TWO_MIPMAPPED_TEXTURES = 0x0000_0040; + const NON_POWER_OF_TWO_MIPMAPPED_TEXTURES = 1 << 6; /// Supports textures that are cube arrays. - const CUBE_ARRAY_TEXTURES = 0x0000_0080; + const CUBE_ARRAY_TEXTURES = 1 << 7; /// Supports comparison samplers. - const COMPARISON_SAMPLERS = 0x0000_0100; + const COMPARISON_SAMPLERS = 1 << 8; /// Supports different blending modes per color target. - const INDEPENDENT_BLENDING = 0x0000_0200; + const INDEPENDENT_BLENDING = 1 << 9; /// Supports samplers with anisotropic filtering. Note this isn't actually required by WebGPU, /// the implementation is allowed to completely ignore aniso clamp. This flag is here for native backends /// so they can comunicate to the user of aniso is enabled. - const ANISOTROPIC_FILTERING = 0x8000_0000; + const ANISOTROPIC_FILTERING = 1 << 10; } } @@ -832,13 +832,13 @@ bitflags::bitflags! { /// Binding is not visible from any shader stage. const NONE = 0; /// Binding is visible from the vertex shader of a render pipeline. - const VERTEX = 1; + const VERTEX = 1 << 0; /// Binding is visible from the fragment shader of a render pipeline. - const FRAGMENT = 2; + const FRAGMENT = 1 << 1; + /// Binding is visible from the compute shader of a compute pipeline. + const COMPUTE = 1 << 2; /// Binding is visible from the vertex and fragment shaders of a render pipeline. const VERTEX_FRAGMENT = Self::VERTEX.bits | Self::FRAGMENT.bits; - /// Binding is visible from the compute shader of a compute pipeline. - const COMPUTE = 4; } } @@ -1225,10 +1225,10 @@ bitflags::bitflags! { pub struct TextureFormatFeatureFlags: u32 { /// When used as a STORAGE texture, then a texture with this format can be bound with /// [`StorageTextureAccess::ReadOnly`] or [`StorageTextureAccess::ReadWrite`]. - const STORAGE_READ_WRITE = 1; + const STORAGE_READ_WRITE = 1 << 0; /// When used as a STORAGE texture, then a texture with this format can be written to with atomics. // TODO: No access flag exposed as of writing - const STORAGE_ATOMICS = 2; + const STORAGE_ATOMICS = 1 << 1; } } @@ -1820,17 +1820,17 @@ bitflags::bitflags! { #[cfg_attr(feature = "replay", derive(Deserialize))] pub struct ColorWrites: u32 { /// Enable red channel writes - const RED = 1; + const RED = 1 << 0; /// Enable green channel writes - const GREEN = 2; + const GREEN = 1 << 1; /// Enable blue channel writes - const BLUE = 4; + const BLUE = 1 << 2; /// Enable alpha channel writes - const ALPHA = 8; + const ALPHA = 1 << 3; /// Enable red, green, and blue channel writes - const COLOR = 7; + const COLOR = Self::RED.bits | Self::GREEN.bits | Self::BLUE.bits; /// Enable writes to all channels. - const ALL = 15; + const ALL = Self::RED.bits | Self::GREEN.bits | Self::BLUE.bits | Self::ALPHA.bits; } } @@ -2206,29 +2206,29 @@ bitflags::bitflags! { /// /// If [`Features::MAPPABLE_PRIMARY_BUFFERS`] isn't enabled, the only other usage a buffer /// may have is COPY_DST. - const MAP_READ = 1; + const MAP_READ = 1 << 0; /// Allow a buffer to be mapped for writing using [`Buffer::map_async`] + [`Buffer::get_mapped_range_mut`]. /// This does not include creating a buffer with `mapped_at_creation` set. /// /// If [`Features::MAPPABLE_PRIMARY_BUFFERS`] feature isn't enabled, the only other usage a buffer /// may have is COPY_SRC. - const MAP_WRITE = 2; + const MAP_WRITE = 1 << 1; /// Allow a buffer to be the source buffer for a [`CommandEncoder::copy_buffer_to_buffer`] or [`CommandEncoder::copy_buffer_to_texture`] /// operation. - const COPY_SRC = 4; + const COPY_SRC = 1 << 2; /// Allow a buffer to be the destination buffer for a [`CommandEncoder::copy_buffer_to_buffer`], [`CommandEncoder::copy_texture_to_buffer`], /// [`CommandEncoder::fill_buffer`] or [`Queue::write_buffer`] operation. - const COPY_DST = 8; + const COPY_DST = 1 << 3; /// Allow a buffer to be the index buffer in a draw operation. - const INDEX = 16; + const INDEX = 1 << 4; /// Allow a buffer to be the vertex buffer in a draw operation. - const VERTEX = 32; + const VERTEX = 1 << 5; /// Allow a buffer to be a [`BufferBindingType::Uniform`] inside a bind group. - const UNIFORM = 64; + const UNIFORM = 1 << 6; /// Allow a buffer to be a [`BufferBindingType::Storage`] inside a bind group. - const STORAGE = 128; + const STORAGE = 1 << 7; /// Allow a buffer to be the indirect buffer in an indirect draw call. - const INDIRECT = 256; + const INDIRECT = 1 << 8; } } @@ -2320,16 +2320,16 @@ bitflags::bitflags! { 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; + const COPY_SRC = 1 << 0; /// Allows a texture to be the destination in a [`CommandEncoder::copy_texture_to_buffer`], /// [`CommandEncoder::copy_texture_to_texture`], or [`Queue::write_texture`] operation. - const COPY_DST = 2; + const COPY_DST = 1 << 1; /// Allows a texture to be a [`BindingType::Texture`] in a bind group. - const TEXTURE_BINDING = 4; + const TEXTURE_BINDING = 1 << 2; /// Allows a texture to be a [`BindingType::StorageTexture`] in a bind group. - const STORAGE_BINDING = 8; + const STORAGE_BINDING = 1 << 3; /// Allows a texture to be an output attachment of a renderpass. - const RENDER_ATTACHMENT = 16; + const RENDER_ATTACHMENT = 1 << 4; } } @@ -3204,21 +3204,21 @@ bitflags::bitflags! { pub struct PipelineStatisticsTypes : u8 { /// Amount of times the vertex shader is ran. Accounts for /// the vertex cache when doing indexed rendering. - const VERTEX_SHADER_INVOCATIONS = 0x01; + const VERTEX_SHADER_INVOCATIONS = 1 << 0; /// Amount of times the clipper is invoked. This /// is also the amount of triangles output by the vertex shader. - const CLIPPER_INVOCATIONS = 0x02; + const CLIPPER_INVOCATIONS = 1 << 1; /// Amount of primitives that are not culled by the clipper. /// This is the amount of triangles that are actually on screen /// and will be rasterized and rendered. - const CLIPPER_PRIMITIVES_OUT = 0x04; + const CLIPPER_PRIMITIVES_OUT = 1 << 2; /// Amount of times the fragment shader is ran. Accounts for /// fragment shaders running in 2x2 blocks in order to get /// derivatives. - const FRAGMENT_SHADER_INVOCATIONS = 0x08; + const FRAGMENT_SHADER_INVOCATIONS = 1 << 3; /// Amount of times a compute shader is invoked. This will /// be equivalent to the dispatch count times the workgroup size. - const COMPUTE_SHADER_INVOCATIONS = 0x10; + const COMPUTE_SHADER_INVOCATIONS = 1 << 4; } } diff --git a/wgpu/tests/common/mod.rs b/wgpu/tests/common/mod.rs index 90288d5a88..5c1b9c69c3 100644 --- a/wgpu/tests/common/mod.rs +++ b/wgpu/tests/common/mod.rs @@ -100,10 +100,10 @@ impl Default for TestParameters { bitflags::bitflags! { pub struct FailureReasons: u8 { - const BACKEND = 0x1; - const VENDOR = 0x2; - const ADAPTER = 0x4; - const ALWAYS = 0x8; + const BACKEND = 1 << 0; + const VENDOR = 1 << 1; + const ADAPTER = 1 << 2; + const ALWAYS = 1 << 3; } }