Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

fix(deps): update rust crate wgpu to v23 #47

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

fix(deps): update rust crate wgpu to v23 #47

wants to merge 1 commit into from

Conversation

renovate[bot]
Copy link
Contributor

@renovate renovate bot commented Oct 30, 2024 •
edited
Loading

This PR contains the following updates:

Package Type Update Change
wgpu (source) dependencies major 0.19.3 -> 23.0.0

Release Notes

gfx-rs/wgpu (wgpu)

v23.0.0

Compare Source

Themes of this release

This release's theme is one that is likely to repeat for a few releases: convergence with the WebGPU specification! WGPU's design and base functionality are actually determined by two specifications: one for WebGPU, and one for the WebGPU Shading Language.

This may not sound exciting, but let us convince you otherwise! All major web browsers have committed to offering WebGPU in their environment. Even JS runtimes like Node and Deno have communities that are very interested in providing WebGPU! WebGPU is slowly eating the world, as it were. 😀 It's really important, then, that WebGPU implementations behave in ways that one would expect across all platforms. For example, if Firefox's WebGPU implementation were to break when running scripts and shaders that worked just fine in Chrome, that would mean sad users for both application authors and browser authors.

WGPU also benefits from standard, portable behavior in the same way as web browsers. Because of this behavior, it's generally fairly easy to port over usage of WebGPU in JavaScript to WGPU. It is also what lets WGPU go full circle: WGPU can be an implementation of WebGPU on native targets, but also it can use other implementations of WebGPU as a backend in JavaScript when compiled to WASM. Therefore, the same dynamic applies: if WGPU's own behavior were significantly different, then WGPU and end users would be sad, sad humans as soon as they discover places where their nice apps are breaking, right?

The answer is: yes, we do have sad, sad humans that really want their WGPU code to work everywhere. As Firefox and others use WGPU to implement WebGPU, the above example of Firefox diverging from standard is, unfortunately, today's reality. It mostly behaves the same as a standards-compliant WebGPU, but it still doesn't in many important ways. Of particular note is Naga, its implementation of the WebGPU Shader Language. Shaders are pretty much a black-and-white point of failure in GPU programming; if they don't compile, then you can't use the rest of the API! And yet, it's extremely easy to run into a case like that from #​4400:

fn gimme_a_float() -> f32 {
  return 42; // fails in Naga, but standard WGSL happily converts to `f32`
}

We intend to continue making visible strides in converging with specifications for WebGPU and WGSL, as this release has. This is, unfortunately, one of the major reasons that WGPU has no plans to work hard at keeping a SemVer-stable interface for the foreseeable future; we have an entire platform of GPU programming functionality we have to catch up with, and SemVer stability is unfortunately in tension with that. So, for now, you're going to keep seeing major releases and breaking changes. Where possible, we'll try to make that painless, but compromises to do so don't always make sense with our limited resources.

This is also the last planned major version release of 2024; the next milestone is set for January 1st, 2025, according to our regular 12-week cadence (offset from the originally planned date of 2024-10-09 for this release 😅). We'll see you next year!

Contributor spotlight: @​sagudev

This release, we'd like to spotlight the work of @​sagudev, who has made significant contributions to the WGPU ecosystem this release. Among other things, they contributed a particularly notable feature where runtime-known indices are finally allowed for use with const array values. For example, this WGSL shader previously wasn't allowed:

const arr: array<u32, 4> = array(1, 2, 3, 4);

fn what_number_should_i_use(idx: u32) -> u32 {
  return arr[idx];
}

…but now it works! This is significant because this sort of shader rejection was one of the most impactful issues we are aware of for converging with the WGSL specification. There are more still to go—some of which we expect to even more drastically change how folks author shaders—but we suspect that many more will come in the next few releases, including with @​sagudev's help.

We're excited for more of @​sagudev's contributions via the Servo community. Oh, did we forget to mention that these contributions were motivated by their work on Servo? That's right, a third well-known JavaScript runtime is now using WGPU to implement its WebGPU implementation. We're excited to support Servo to becoming another fully fledged browsing environment this way.

Major Changes

In addition to the above spotlight, we have the following particularly interesting items to call out for this release:

wgpu-core is no longer generic over wgpu-hal backends

Dynamic dispatch between different backends has been moved from the user facing wgpu crate, to a new dynamic dispatch mechanism inside the backend abstraction layer wgpu-hal.

Whenever targeting more than a single backend (default on Windows & Linux) this leads to faster compile times and smaller binaries! This also solves a long standing issue with cargo doc failing to run for wgpu-core.

Benchmarking indicated that compute pass recording is slower as a consequence, whereas on render passes speed improvements have been observed. However, this effort simplifies many of the internals of the wgpu family of crates which we're hoping to build performance improvements upon in the future.

By @​wumpf in #​6069, #​6099, #​6100.

wgpu's resources no longer have .global_id() getters

wgpu-core's internals no longer use nor need IDs and we are moving towards removing IDs completely. This is a step in that direction.

Current users of .global_id() are encouraged to make use of the PartialEq, Eq, Hash, PartialOrd and Ord traits that have now been implemented for wgpu resources.

By @​teoxoy in #​6134.

set_bind_group now takes an Option for the bind group argument.

https://gpuweb.github.io/gpuweb/#programmable-passes-bind-groups specifies that bindGroup is nullable. This change is the start of implementing this part of the spec. Callers that specify a Some() value should have unchanged behavior. Handling of None values still needs to be implemented by backends.

For convenience, the set_bind_group on compute/render passes & encoders takes impl Into<Option<&BindGroup>>, so most code should still work the same.

By @​bradwerth in #​6216.

entry_points are now Optional

One of the changes in the WebGPU spec. (from about this time last year 😅) was to allow optional entry points in GPUProgrammableStage. In wgpu, this corresponds to a subset of fields in FragmentState, VertexState, and ComputeState as the entry_point member:

let render_pipeline = device.createRenderPipeline(wgpu::RenderPipelineDescriptor {
    module,
    entry_point: Some("cs_main"), // This is now `Option`al.
    // …
});

let compute_pipeline = device.createComputePipeline(wgpu::ComputePipelineDescriptor {
    module,
    entry_point: None, // This is now `Option`al.
    // …
});

When set to None, it's assumed that the shader only has a single entry point associated with the pipeline stage (i.e., @compute, @fragment, or @vertex). If there is not one and only one candidate entry point, then a validation error is returned. To continue the example, we might have written the above API usage with the following shader module:

// We can't use `entry_point: None` for compute pipelines with this module,
// because there are two `@compute` entry points.

@&#8203;compute
fn cs_main() { /* … */ }

@&#8203;compute
fn other_cs_main() { /* … */ }

// The following entry points _can_ be inferred from `entry_point: None` in a
// render pipeline, because they're the only `@vertex` and `@fragment` entry
// points:

@&#8203;vertex
fn vs_main() { /* … */ }

@&#8203;fragment
fn fs_main() { /* … */ }
WGPU's DX12 backend is now based on the windows crate ecosystem, instead of the d3d12 crate

WGPU has retired the d3d12 crate (based on winapi), and now uses the windows crate for interfacing with Windows. For many, this may not be a change that affects day-to-day work. However, for users who need to vet their dependencies, or who may vendor in dependencies, this may be a nontrivial migration.

By @​MarijnS95 in #​6006.

New Features
Naga
General
  • Add VideoFrame to ExternalImageSource enum. By @​jprochazk in #​6170.
  • Add wgpu::util::new_instance_with_webgpu_detection & wgpu::util::is_browser_webgpu_supported to make it easier to support WebGPU & WebGL in the same binary. By @​wumpf in #​6371.
Vulkan
Metal
  • Implement atomicCompareExchangeWeak. By @​AsherJingkongChen in #​6265.
  • Unless an explicit CAMetalLayer is provided, surfaces now render to a sublayer. This improves resizing behavior, fixing glitches during on window resize. By @​madsmtm in #​6107.
Bug Fixes
Naga
General
  • If GL context creation fails retry with GLES. By @​Rapdorian in #​5996.
  • Fix profiling with tracy. By @​waywardmonkeys in #​5988.
  • As a workaround for issue #​4905, wgpu-core is undocumented unless --cfg wgpu_core_doc feature is enabled. By @​kpreid in #​5987.
  • Bump MSRV for d3d12/naga/wgpu-core/wgpu-hal/wgpu-types' to 1.76. By @​wumpf in #​6003.
  • Print requested and supported usages on UnsupportedUsage error. By @​VladasZ in #​6007.
  • Fix function for checking bind compatibility to error instead of panic. By @​sagudev #​6012.
  • Deduplicate bind group layouts that are created from pipelines with "auto" layouts. By @​teoxoy #​6049.
  • Fix crash when dropping the surface after the device. By @​wumpf in #​6052.
  • Fix error message that is thrown in create_render_pass to no longer say compute_pass. By @​matthew-wong1 #​6041.
  • Document wgpu_hal bounds-checking promises, and adapt wgpu_core's lazy initialization logic to the slightly weaker-than-expected guarantees. By @​jimblandy in #​6201.
  • Raise validation error instead of panicking in {Render,Compute}Pipeline::get_bind_group_layout on native / WebGL. By @​bgr360 in #​6280.
  • BREAKING: Remove the last exposed C symbols in project, located in wgpu_core::render::bundle::bundle_ffi, to allow multiple versions of WGPU to compile together. By @​ErichDonGubler in #​6272.
  • Call flush_mapped_ranges when unmapping write-mapped buffers. By @​teoxoy in #​6089.
  • When mapping buffers for reading, mark buffers as initialized only when they have MAP_WRITE usage. By @​teoxoy in #​6178.
  • Add a separate pipeline constants error. By @​teoxoy in #​6094.
  • Ensure safety of indirect dispatch by injecting a compute shader that validates the content of the indirect buffer. By @​teoxoy in #​5714.
GLES / OpenGL
  • Fix GL debug message callbacks not being properly cleaned up (causing UB). By @​Imberflur in #​6114.
  • Fix calling slice::from_raw_parts with unaligned pointers in push constant handling. By @​Imberflur in #​6341.
  • Optimise fence checking when Queue::submit is called many times per frame. By @​dinnerbone in #​6427.
WebGPU
  • Fix JS TypeError exception in Instance::request_adapter when browser doesn't support WebGPU but wgpu not compiled with webgl support. By @​bgr360 in #​6197.
Vulkan
  • Avoid undefined behaviour with adversarial debug label. By @​DJMcNab in #​6257.
  • Add .index_type(vk::IndexType::NONE_KHR) when creating AccelerationStructureGeometryTrianglesDataKHR in the raytraced triangle example to prevent a validation error. By @​Vecvec in #​6282.
Changes
  • wgpu_hal::gles::Adapter::new_external now requires the context to be current when dropping the adapter and related objects. By @​Imberflur in #​6114.
  • Reduce the amount of debug and trace logs emitted by wgpu-core and wgpu-hal. By @​nical in #​6065.
  • Rename Rg11b10Float to Rg11b10Ufloat. By @​sagudev in #​6108.
  • Invalidate the device when we encounter driver-induced device loss or on unexpected errors. By @​teoxoy in #​6229.
  • Make Vulkan error handling more robust. By @​teoxoy in #​6119.
  • Add bounds checking to Buffer slice method. By @​beholdnec in #​6432.
  • Replace impl From<StorageFormat> for ScalarKind with impl From<StorageFormat> for Scalar so that byte width is included. By @​atlv24 in #​6451.
Internal
HAL
  • Change the inconsistent DropGuard based API on Vulkan and GLES to a consistent, callback-based one. By @​jerzywilczek in #​6164.
Documentation
  • Removed some OpenGL and Vulkan references from wgpu-types documentation. Fixed Storage texel types in examples. By @​Nelarius in #​6271.
  • Used wgpu::include_wgsl!(…) more in examples and tests. By @​ErichDonGubler in #​6326.
Dependency Updates
GLES
DX12
HAL

v22.1.0

Compare Source

This release includes wgpu, wgpu-core and naga. All other crates remain at 22.0.0.

Added
Naga
Bug Fixes
General

v22.0.0

Compare Source

Overview
Our first major version release!

For the first time ever, WGPU is being released with a major version (i.e., 22.* instead of 0.22.*)! Maintainership has decided to fully adhere to Semantic Versioning's recommendations for versioning production software. According to SemVer 2.0.0's Q&A about when to use 1.0.0 versions (and beyond):

How do I know when to release 1.0.0?

If your software is being used in production, it should probably already be 1.0.0. If you have a stable API on which users have come to depend, you should be 1.0.0. If you’re worrying a lot about backward compatibility, you should probably already be 1.0.0.

It is a well-known fact that WGPU has been used for applications and platforms already in production for years, at this point. We are often concerned with tracking breaking changes, and affecting these consumers' ability to ship. By releasing our first major version, we publicly acknowledge that this is the case. We encourage other projects in the Rust ecosystem to follow suit.

Note that while we start to use the major version number, WGPU is not "going stable", as many Rust projects do. We anticipate many breaking changes before we fully comply with the WebGPU spec., which we expect to take a small number of years.

Overview

A major (pun intended) theme of this release is incremental improvement. Among the typically large set of bug fixes, new features, and other adjustments to WGPU by the many contributors listed below, @​wumpf and @​teoxoy have merged a series of many simplifications to WGPU's internals and, in one case, to the render and compute pass recording APIs. Many of these change WGPU to use atomically reference-counted resource tracking (i.e., Arc<…>), rather than using IDs to manage the lifetimes of platform-specific graphics resources in a registry of separate reference counts. This has led us to diagnose and fix many long-standing bugs, and net some neat performance improvements on the order of 40% or more of some workloads.

While the above is exciting, we acknowledge already finding and fixing some (easy-to-fix) regressions from the above work. If you migrate to WGPU 22 and encounter such bugs, please engage us in the issue tracker right away!

Major Changes
Lifetime bounds on wgpu::RenderPass & wgpu::ComputePass

wgpu::RenderPass & wgpu::ComputePass recording methods (e.g. wgpu::RenderPass:set_render_pipeline) no longer impose a lifetime constraint to objects passed to a pass (like pipelines/buffers/bindgroups/query-sets etc.).

This means the following pattern works now as expected:

let mut pipelines: Vec<wgpu::RenderPipeline> = ...;
// ...
let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor::default());
cpass.set_pipeline(&pipelines[123]);
// Change pipeline container - this requires mutable access to `pipelines` while one of the pipelines is in use.
pipelines.push(/* ... */);
// Continue pass recording.
cpass.set_bindgroup(...);

Previously, a set pipeline (or other resource) had to outlive pass recording which often affected wider systems,
meaning that users needed to prove to the borrow checker that Vec<wgpu::RenderPipeline> (or similar constructs)
aren't accessed mutably for the duration of pass recording.

Furthermore, you can now opt out of wgpu::RenderPass/wgpu::ComputePass's lifetime dependency on its parent wgpu::CommandEncoder using wgpu::RenderPass::forget_lifetime/wgpu::ComputePass::forget_lifetime:

fn independent_cpass<'enc>(encoder: &'enc mut wgpu::CommandEncoder) -> wgpu::ComputePass<'static> {
    let cpass: wgpu::ComputePass<'enc> = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor::default());
    cpass.forget_lifetime()
}

⚠️ As long as a wgpu::RenderPass/wgpu::ComputePass is pending for a given wgpu::CommandEncoder, creation of a compute or render pass is an error and invalidates the wgpu::CommandEncoder.
forget_lifetime can be very useful for library authors, but opens up an easy way for incorrect use, so use with care.
This method doesn't add any additional overhead and has no side effects on pass recording.

By @​wumpf in #​5569, #​5575, #​5620, #​5768 (together with @​kpreid), #​5671, #​5794, #​5884.

Querying shader compilation errors

Wgpu now supports querying shader compilation info.

This allows you to get more structured information about compilation errors, warnings and info:

...
let lighting_shader = ctx.device.create_shader_module(include_wgsl!("lighting.wgsl"));
let compilation_info = lighting_shader.get_compilation_info().await;
for message in compilation_info
    .messages
    .iter()
    .filter(|m| m.message_type == wgpu::CompilationMessageType::Error)
{
    let line = message.location.map(|l| l.line_number).unwrap_or(1);
    println!("Compile error at line {line}");
}

By @​stefnotch in #​5410

64 bit integer atomic support in shaders.

Add support for 64 bit integer atomic operations in shaders.

Add the following flags to wgpu_types::Features:

  • SHADER_INT64_ATOMIC_ALL_OPS enables all atomic operations on atomic<i64> and
    atomic<u64> values.

  • SHADER_INT64_ATOMIC_MIN_MAX is a subset of the above, enabling only
    AtomicFunction::Min and AtomicFunction::Max operations on atomic<i64> and
    atomic<u64> values in the Storage address space. These are the only 64-bit
    atomic operations available on Metal as of 3.1.

Add corresponding flags to naga::valid::Capabilities. These are supported by the
WGSL front end, and all Naga backends.

Platform support:

  • On Direct3d 12, in D3D12_FEATURE_DATA_D3D12_OPTIONS9, if
    AtomicInt64OnTypedResourceSupported and AtomicInt64OnGroupSharedSupported are
    both available, then both wgpu features described above are available.

  • On Metal, SHADER_INT64_ATOMIC_MIN_MAX is available on Apple9 hardware, and on
    hardware that advertises both Apple8 and Mac2 support. This also requires Metal
    Shading Language 2.4 or later. Metal does not yet support the more general
    SHADER_INT64_ATOMIC_ALL_OPS.

  • On Vulkan, if the VK_KHR_shader_atomic_int64 extension is available with both the
    shader_buffer_int64_atomics and shader_shared_int64_atomics features, then both
    wgpu features described above are available.

By @​atlv24 in #​5383

A compatible surface is now required for request_adapter() on WebGL2 + enumerate_adapters() is now native only.

When targeting WebGL2, it has always been the case that a surface had to be created before calling request_adapter().
We now make this requirement explicit.

Validation was also added to prevent configuring the surface with a device that doesn't share the same underlying
WebGL2 context since this has never worked.

Calling enumerate_adapters() when targeting WebGPU used to return an empty Vec and since we now require users
to pass a compatible surface when targeting WebGL2, having enumerate_adapters() doesn't make sense.

By @​teoxoy in #​5901

New features
General
  • Added as_hal for Buffer to access wgpu created buffers form wgpu-hal. By @​JasondeWolff in #​5724
  • include_wgsl! is now callable in const contexts by @​9SMTM6 in #​5872
  • Added memory allocation hints to DeviceDescriptor by @​nical in #​5875
    • MemoryHints::Performance, the default, favors performance over memory usage and will likely cause large amounts of VRAM to be allocated up-front. This hint is typically good for games.
    • MemoryHints::MemoryUsage favors memory usage over performance. This hint is typically useful for smaller applications or UI libraries.
    • MemoryHints::Manual allows the user to specify parameters for the underlying GPU memory allocator. These parameters are subject to change.
    • These hints may be ignored by some backends. Currently only the Vulkan and D3D12 backends take them into account.
  • Add HTMLImageElement and ImageData as external source for copying images. By @​Valaphee in #​5668
Naga

  • Added -D, --defines option to naga CLI to define preprocessor macros by @​theomonnom in #​5859

  • Added type upgrades to SPIR-V atomic support. Added related infrastructure. Tracking issue is here. By @​schell in #​5775.

  • Implement WGSL's unpack4xI8,unpack4xU8,pack4xI8 and pack4xU8. By @​VlaDexa in #​5424

  • Began work adding support for atomics to the SPIR-V frontend. Tracking issue is here. By @​schell in #​5702.

  • In hlsl-out, allow passing information about the fragment entry point to omit vertex outputs that are not in the fragment inputs. By @​Imberflur in #​5531

  • In spv-out, allow passing acceleration_structure as a function argument. By @​kvark in #​5961

    let writer: naga::back::hlsl::Writer = /* ... */;
-writer.write(&module, &module_info);
+writer.write(&module, &module_info, None);

  • HLSL & MSL output can now be added conditionally on the target via the msl-out-if-target-apple and hlsl-out-if-target-windows features. This is used in wgpu-hal to no longer compile with MSL output when metal is enabled & MacOS isn't targeted and no longer compile with HLSL output when dx12 is enabled & Windows isn't targeted. By @​wumpf in #​5919

Vulkan
  • Added a PipelineCache resource to allow using Vulkan pipeline caches. By @​DJMcNab in #​5319
WebGPU
Changes
General
Metal

  • Removed the link Cargo feature.

    This was used to allow weakly linking frameworks. This can be achieved with putting something like the following in your .cargo/config.toml instead:

    [target.'cfg(target_vendor = "apple")']
rustflags = ["-C", "link-args=-weak_framework Metal -weak_framework QuartzCore -weak_framework CoreGraphics"]

    By @​madsmtm in #​5752

Bug Fixes
General
  • Ensure render pipelines have at least 1 target. By @​ErichDonGubler in #​5715
  • wgpu::ComputePass now internally takes ownership of QuerySet for both wgpu::ComputePassTimestampWrites as well as timestamp writes and statistics query, fixing crashes when destroying QuerySet before ending the pass. By @​wumpf in #​5671
  • Validate resources passed during compute pass recording for mismatching device. By @​wumpf in #​5779
  • Fix staging buffers being destroyed too early. By @​teoxoy in #​5910
  • Fix attachment byte cost validation panicking with native only formats. By @​teoxoy in #​5934
  • [wgpu] Fix leaks from auto layout pipelines. By @​teoxoy in #​5971
  • [wgpu-core] Fix length of copy in queue_write_texture (causing UB). By @​teoxoy in #​5973
  • Add missing same device checks. By @​teoxoy in #​5980
GLES / OpenGL
  • Fix ClearColorF, ClearColorU and ClearColorI commands being issued before SetDrawColorBuffers #​5666
  • Replace glClear with glClearBufferF because glDrawBuffers requires that the ith buffer must be COLOR_ATTACHMENTi or NONE #​5666
  • Return the unmodified version in driver_info. By @​Valaphee in #​5753
Naga
  • In spv-out don't decorate a BindingArray's type with Block if the type is a struct with a runtime array by @​Vecvec in #​5776
  • Add packed as a keyword for GLSL by @​kjarosh in #​5855

v0.20.1

Compare Source

This release included v0.21.0 of wgpu-core and wgpu-hal, due to breaking changes needed to solve vulkan validation issues.

Bug Fixes

This release fixes the validation errors whenever a surface is used with the vulkan backend. By @​cwfitzgerald in #​5681.

General
Metal
Vulkan
  • Fix enablement of subgroup ops extension on Vulkan devices that don't support Vulkan 1.3. By @​cwfitzgerald in #​5624.
GLES / OpenGL
  • Fix regression on OpenGL (EGL) where non-sRGB still used sRGB #​5642
Naga
  • Work around shader consumers that have bugs handling switch statements with a single body for all cases. These are now written as do {} while(false); loops in hlsl-out and glsl-out. By @​Imberflur in #​5654
  • In hlsl-out, defer continue statements in switches by setting a flag and breaking from the switch. This allows such constructs to work with FXC which does not support continue within a switch. By @​Imberflur in #​5654

v0.20.0

Compare Source

Major Changes
Pipeline overridable constants

Wgpu supports now pipeline-overridable constants

This allows you to define constants in wgsl like this:

override some_factor: f32 = 42.1337; // Specifies a default of 42.1337 if it's not set.

And then set them at runtime like so on your pipeline consuming this shader:

// ...
fragment: Some(wgpu::FragmentState {
    compilation_options: wgpu::PipelineCompilationOptions {
        constants: &[("some_factor".to_owned(), 0.1234)].into(), // Sets `some_factor` to 0.1234.
        ..Default::default()
    },
    // ...
}),
// ...

By @​teoxoy & @​jimblandy in #​5500

Changed feature requirements for timestamps

Due to a specification change write_timestamp is no longer supported on WebGPU.
wgpu::CommandEncoder::write_timestamp requires now the new wgpu::Features::TIMESTAMP_QUERY_INSIDE_ENCODERS feature which is available on all native backends but not on WebGPU.

By @​wumpf in #​5188

Wgsl const evaluation for many more built-ins

Many numeric built-ins have had a constant evaluation implementation added for them, which allows them to be used in a const context:

abs, acos, acosh, asin, asinh, atan, atanh, cos, cosh, round, saturate, sin, sinh, sqrt, step, tan, tanh, ceil, countLeadingZeros, countOneBits, countTrailingZeros, degrees, exp, exp2, floor, fract, fma, inverseSqrt, log, log2, max, min, radians, reverseBits, sign, trunc

By @​ErichDonGubler in #​4879, #​5098

New native-only wgsl features
Subgroup operations

The following subgroup operations are available in wgsl now:

subgroupBallot, subgroupAll, subgroupAny, subgroupAdd, subgroupMul, subgroupMin, subgroupMax, subgroupAnd, subgroupOr, subgroupXor, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupBroadcastFirst, subgroupBroadcast, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor

Availability is governed by the following feature flags:

  • wgpu::Features::SUBGROUP for all operations except subgroupBarrier in fragment & compute, supported on Vulkan, DX12 and Metal.
  • wgpu::Features::SUBGROUP_VERTEX, for all operations except subgroupBarrier general operations in vertex shaders, supported on Vulkan
  • wgpu::Features::SUBGROUP_BARRIER, for support of the subgroupBarrier operation, supported on Vulkan & Metal

Note that there currently some differences between wgpu's native-only implementation and the open WebGPU proposal.

By @​exrook and @​lichtso in #​5301

Signed and unsigned 64 bit integer support in shaders.

wgpu::Features::SHADER_INT64 enables 64 bit integer signed and unsigned integer variables in wgsl (i64 and u64 respectively).
Supported on Vulkan, DX12 (requires DXC) and Metal (with MSL 2.3+ support).

By @​atlv24 and @​cwfitzgerald in #​5154

New features
General
  • Implemented the Unorm10_10_10_2 VertexFormat by @​McMackety in #​5477
  • wgpu-types's trace and replay features have been replaced by the serde feature. By @​KirmesBude in #​5149
  • wgpu-core's serial-pass feature has been removed. Use serde instead. By @​KirmesBude in #​5149
  • Added InstanceFlags::GPU_BASED_VALIDATION, which enables GPU-based validation for shaders. This is currently only supported on the DX12 and Vulkan backends; other platforms ignore this flag, for now. By @​ErichDonGubler in #​5146, #​5046.
    • When set, this flag implies InstanceFlags::VALIDATION.
    • This has been added to the set of flags set by InstanceFlags::advanced_debugging. Since the overhead is potentially very large, the flag is not enabled by default in debug builds when using InstanceFlags::from_build_config.
    • As with other instance flags, this flag can be changed in calls to InstanceFlags::with_env with the new WGPU_GPU_BASED_VALIDATION environment variable.
  • wgpu::Instance can now report which wgpu::Backends are available based on the build configuration. By @​wumpf #​5167 
    -wgpu::Instance::any_backend_feature_enabled()
+!wgpu::Instance::enabled_backend_features().is_empty()
  • Breaking change: wgpu_core::pipeline::ProgrammableStageDescriptor is now optional. By @​ErichDonGubler in #​5305.
  • Features::downlevel{_webgl2,}_features was made const by @​MultisampledNight in #​5343
  • Breaking change: wgpu_core::pipeline::ShaderError has been moved to naga. By @​stefnotch in #​5410
  • More as_hal methods and improvements by @​JMS55 in #​5452
    • Added wgpu::CommandEncoder::as_hal_mut
    • Added wgpu::TextureView::as_hal
    • wgpu::Texture::as_hal now returns a user-defined type to match the other as_hal functions
Naga
  • Allow user to select which MSL version to use via --metal-version with Naga CLI. By @​pcleavelin in #​5392
  • Support arrayLength for runtime-sized arrays inside binding arrays (for WGSL input and SPIR-V output). By @​kvark in #​5428
  • Added --shader-stage and --input-kind options to naga-cli for specifying vertex/fragment/compute shaders, and frontend. by @​ratmice in #​5411
  • Added a create_validator function to wgpu_core Device to create naga Validators. By @​atlv24 #​5606
WebGPU
GLES / OpenGL
Metal
DX12
Other performance improvements
  • Simplify and speed up the allocation of internal IDs. By @​nical in #​5229
  • Use memory pooling for UsageScopes to avoid frequent large allocations. by @​robtfm in #​5414
  • Eager release of GPU resources comes from device.trackers. By @​bradwerth in #​5075
  • Support disabling zero-initialization of workgroup local memory in compute shaders. By @​DJMcNab in #​5508
Documentation

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

  • If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers
No reviews
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
0 participants