Merge remote-tracking branch 'upstream/trunk' into hal-acceleration-s…

…tructures

CHANGELOG.md

@@ -31,7 +31,6 @@ Bottom level categories:
 - DX12
 - Vulkan
 - Metal
-- DX11
 - GLES
 - WebGPU
 - Emscripten
@@ -40,6 +39,10 @@ Bottom level categories:
 
 ## Unreleased
 
+### Direct3D 11 backend removal
+
+This backend had no functionality, and with the recent support for GL on Desktop, which allows wgpu to run on older devices, there is no need to keep the backend.
+
 ### `WGPU_ALLOW_UNDERLYING_NONCOMPLIANT_ADAPTER` environment variable
 
 This adds a way to allow a Vulkan driver which is non-compliant per VK_KHR_driver_properties to be enumerated. This is intended for testing new Vulkan drivers which are not Vulkan compliant yet.
@@ -53,6 +56,7 @@ Previously, `DeviceExt::create_texture_with_data` only allowed data to be provid
 #### General
 - Added `DownlevelFlags::VERTEX_AND_INSTANCE_INDEX_RESPECTS_RESPECTIVE_FIRST_VALUE_IN_INDIRECT_DRAW` to know if `@builtin(vertex_index)` and `@builtin(instance_index)` will respect the `first_vertex` / `first_instance` in indirect calls. If this is not present, both will always start counting from 0. Currently enabled on all backends except DX12. By @cwfitzgerald in [#4722](https://github.com/gfx-rs/wgpu/pull/4722)
 - No longer validate surfaces against their allowed extent range on configure. This caused warnings that were almost impossible to avoid. As before, the resulting behavior depends on the compositor. By @wumpf in [#????](https://github.com/gfx-rs/wgpu/pull/????)
+- Added support for the float32-filterable feature. By @almarklein in [#4759](https://github.com/gfx-rs/wgpu/pull/4759)
 
 #### OpenGL
 - `@builtin(instance_index)` now properly reflects the range provided in the draw call instead of always counting from 0. By @cwfitzgerald in [#4722](https://github.com/gfx-rs/wgpu/pull/4722).
@@ -103,7 +107,7 @@ Passing an owned value `window` to `Surface` will return a `Surface<'static>`. S
 - Introduce a new `Scalar` struct type for use in Naga's IR, and update all frontend, middle, and backend code appropriately. By @jimblandy in [#4673](https://github.com/gfx-rs/wgpu/pull/4673).
 - Add more metal keywords. By @fornwall in [#4707](https://github.com/gfx-rs/wgpu/pull/4707).
 
--   Add partial support for WGSL abstract types (@jimblandy in [#4743](https://github.com/gfx-rs/wgpu/pull/4743)).
+-   Add partial support for WGSL abstract types (@jimblandy in [#4743](https://github.com/gfx-rs/wgpu/pull/4743), [#4755](https://github.com/gfx-rs/wgpu/pull/4755)).
 
     Abstract types make numeric literals easier to use, by
     automatically converting literals and other constant expressions
@@ -120,9 +124,10 @@ Passing an owned value `window` to `Surface` will return a `Surface<'static>`. S
     Even though the literals are abstract integers, Naga recognizes
     that it is safe and necessary to convert them to `f32` values in
     order to build the vector. You can also use abstract values as
-    initializers for global constants, like this:
+    initializers for global constants and global and local variables,
+    like this:
 
-        const unit_x: vec2<f32> = vec2(1, 0);
+        var unit_x: vec2<f32> = vec2(1, 0);
 
     The literals `1` and `0` are abstract integers, and the expression
     `vec2(1, 0)` is an abstract vector. However, Naga recognizes that

README.md

@@ -8,9 +8,9 @@
 [![Build Status](https://github.com/gfx-rs/wgpu/workflows/CI/badge.svg)](https://github.com/gfx-rs/wgpu/actions)
 [![codecov.io](https://codecov.io/gh/gfx-rs/wgpu/branch/trunk/graph/badge.svg?token=84qJTesmeS)](https://codecov.io/gh/gfx-rs/wgpu)
 
-`wgpu` is a cross-platform, safe, pure-rust graphics api. It runs natively on Vulkan, Metal, D3D12, and OpenGL; and on top of WebGL2 and WebGPU on wasm.
+`wgpu` is a cross-platform, safe, pure-rust graphics API. It runs natively on Vulkan, Metal, D3D12, and OpenGL; and on top of WebGL2 and WebGPU on wasm.
 
-The api is based on the [WebGPU standard](https://gpuweb.github.io/gpuweb/). It serves as the core of the WebGPU integration in Firefox and Deno.
+The API is based on the [WebGPU standard](https://gpuweb.github.io/gpuweb/). It serves as the core of the WebGPU integration in Firefox and Deno.
 
 ## Repo Overview
 
@@ -26,7 +26,7 @@ The repository hosts the following libraries:
 
 The following binaries:
 
-- [![Crates.io](https://img.shields.io/crates/v/naga-cli.svg?label=naga-cli)](https://crates.io/crates/naga-cli) - Tool for translating shaders between different languages using naga.
+- [![Crates.io](https://img.shields.io/crates/v/naga-cli.svg?label=naga-cli)](https://crates.io/crates/naga-cli) - Tool for translating shaders between different languages using `naga`.
 - [![Crates.io](https://img.shields.io/crates/v/wgpu-info.svg?label=wgpu-info)](https://crates.io/crates/wgpu-info) - Tool for getting information on GPUs in the system.
 - `cts_runner` - WebGPU Conformance Test Suite runner using `deno_webgpu`.
 - `player` - standalone application for replaying the API traces.
@@ -39,9 +39,9 @@ For an overview of all the components in the gfx-rs ecosystem, see [the big pict
 
 Rust examples can be found at [wgpu/examples](examples). You can run the examples on native with `cargo run --bin wgpu-examples <example>`. See the [list of examples](examples).
 
-To run the examples on WebGPU on wasm, run `cargo xtask run-wasm --bin wgpu-example`. Then connect to `http://localhost:8000` in your WebGPU enabled browser, and you can choose an example to run.
+To run the examples on WebGPU on wasm, run `cargo xtask run-wasm --bin wgpu-example`. Then connect to `http://localhost:8000` in your WebGPU-enabled browser, and you can choose an example to run.
 
-To run the examples on WebGL on wasm, run `cargo xtask run-wasm --bin wgpu-example --features webgl`. Then connect to `http://localhost:8000` in your WebGL enabled browser, and you can choose an example to run.
+To run the examples on WebGL on wasm, run `cargo xtask run-wasm --bin wgpu-example --features webgl`. Then connect to `http://localhost:8000` in your WebGL-enabled browser, and you can choose an example to run.
 
 If you are looking for a wgpu tutorial, look at the following:
 
@@ -78,8 +78,7 @@ We have a [wiki](https://github.com/gfx-rs/wgpu/wiki) that serves as a knowledge
 | ----------- | ------------------------------ | ------------------ | ------------------------- | ------------------------- |
 | Vulkan      | :white_check_mark:             | :white_check_mark: | :volcano:                 |                           |
 | Metal       |                                |                    | :white_check_mark:        |                           |
-| DX12        | :white_check_mark:             |                    |                           |                           | 
-| DX11        | :hammer_and_wrench:            |                    |                           |                           |
+| DX12        | :white_check_mark:             |                    |                           |                           |
 | OpenGL      | :ok: (GL 3.3+)                 | :ok: (GL ES 3.0+)  | :triangular_ruler:        | :ok: (WebGL2)             | 
 | WebGPU      |                                |                    |                           | :white_check_mark:        |
 
@@ -93,8 +92,7 @@ We have a [wiki](https://github.com/gfx-rs/wgpu/wiki) that serves as a knowledge
 
 wgpu supports shaders in [WGSL](https://gpuweb.github.io/gpuweb/wgsl/), SPIR-V, and GLSL.
 Both [HLSL](https://github.com/Microsoft/DirectXShaderCompiler) and [GLSL](https://github.com/KhronosGroup/glslang)
-have compilers to target SPIR-V. All of these shader languages can be used with any backend, we
-will handle all of the conversion. Additionally, support for these shader inputs is not going away.
+have compilers to target SPIR-V. All of these shader languages can be used with any backend as we handle all of the conversions. Additionally, support for these shader inputs is not going away.
 
 While WebGPU does not support any shading language other than WGSL, we will automatically convert your
 non-WGSL shaders if you're running on WebGPU.
@@ -110,9 +108,9 @@ To enable GLSL shaders, enable the `glsl` feature of wgpu.
 
 ### Angle
 
-[Angle](http://angleproject.org) is a translation layer from GLES to other backends, developed by Google.
+[Angle](http://angleproject.org) is a translation layer from GLES to other backends developed by Google.
 We support running our GLES3 backend over it in order to reach platforms DX11 support, which aren't accessible otherwise.
-In order to run with Angle, "angle" feature has to be enabled, and Angle libraries placed in a location visible to the application.
+In order to run with Angle, the "angle" feature has to be enabled, and Angle libraries placed in a location visible to the application.
 These binaries can be downloaded from [gfbuild-angle](https://github.com/DileSoft/gfbuild-angle) artifacts, [manual compilation](https://github.com/google/angle/blob/main/doc/DevSetup.md) may be required on Macs with Apple silicon.
 
 On Windows, you generally need to copy them into the working directory, in the same directory as the executable, or somewhere in your path.
@@ -122,10 +120,10 @@ On Linux, you can point to them using `LD_LIBRARY_PATH` environment.
 
 Due to complex dependants, we have two MSRV policies:
  - `d3d12`, `naga`, `wgpu-core`, `wgpu-hal`, and `wgpu-types`'s MSRV is **1.65**.
- - The rest of the workspace has the MSRV of **1.71**.
+ - The rest of the workspace has an MSRV of **1.71**.
 
-It is enforced on CI (in "/.github/workflows/ci.yml") with `CORE_MSRV` and `REPO_MSRV` variable.
-This version can only be upgraded in breaking releases, though we release a breaking version every 3 months.
+It is enforced on CI (in "/.github/workflows/ci.yml") with the `CORE_MSRV` and `REPO_MSRV` variables.
+This version can only be upgraded in breaking releases, though we release a breaking version every three months.
 
 The `naga`, `wgpu-core`, `wgpu-hal`, and `wgpu-types` crates should never
 require an MSRV ahead of Firefox's MSRV for nightly builds, as
@@ -136,10 +134,10 @@ determined by the value of `MINIMUM_RUST_VERSION` in
 
 ## Environment Variables
 
-All testing and example infrastructure shares the same set of environment variables that determine which Backend/GPU it will run on.
+All testing and example infrastructure share the same set of environment variables that determine which Backend/GPU it will run on.
 
 - `WGPU_ADAPTER_NAME` with a substring of the name of the adapter you want to use (ex. `1080` will match `NVIDIA GeForce 1080ti`).
-- `WGPU_BACKEND` with a comma separated list of the backends you want to use (`vulkan`, `metal`, `dx12`, `dx11`, or `gl`).
+- `WGPU_BACKEND` with a comma-separated list of the backends you want to use (`vulkan`, `metal`, `dx12`, or `gl`).
 - `WGPU_POWER_PREF` with the power preference to choose when a specific adapter name isn't specified (`high`, `low` or `none`)
 - `WGPU_DX12_COMPILER` with the DX12 shader compiler you wish to use (`dxc` or `fxc`, note that `dxc` requires `dxil.dll` and `dxcompiler.dll` to be in the working directory otherwise it will fall back to `fxc`)
 - `WGPU_GLES_MINOR_VERSION` with the minor OpenGL ES 3 version number to request (`0`, `1`, `2` or `automatic`).
@@ -187,7 +185,7 @@ If you are a user and want a way to help contribute to wgpu, we always need more
 
 WebGPU includes a Conformance Test Suite to validate that implementations are working correctly. We can run this CTS against wgpu.
 
-To run the CTS, first you need to check it out:
+To run the CTS, first, you need to check it out:
 
 ```
 git clone https://github.com/gpuweb/cts.git
@@ -199,7 +197,7 @@ git checkout $(cat ../cts_runner/revision.txt)
 To run a given set of tests:
 
 ```
-# Must be inside the cts folder we just checked out, else this will fail
+# Must be inside the `cts` folder we just checked out, else this will fail
 cargo run --manifest-path ../Cargo.toml --bin cts_runner -- ./tools/run_deno --verbose "<test string>"
 ```
 
@@ -224,7 +222,7 @@ Exactly which WGSL features `wgpu` supports depends on how you are using it:
   to translate WGSL code into the shading language of your platform's native GPU API.
   Naga has [a milestone][naga wgsl milestone]
   for catching up to the WGSL specification,
-  but in general there is no up-to-date summary
+  but in general, there is no up-to-date summary
   of the differences between Naga and the WGSL spec.
 
 - When running in a web browser (by compilation to WebAssembly)

deno_webgpu/01_webgpu.js

@@ -4980,6 +4980,7 @@ webidl.converters["GPUFeatureName"] = webidl.createEnumConverter(
     "texture-compression-astc",
     "rg11b10ufloat-renderable",
     "bgra8unorm-storage",
+    "float32-filterable",
 
     // extended from spec
 

deno_webgpu/Cargo.toml

@@ -34,10 +34,10 @@ features = ["trace", "replay", "serde", "strict_asserts", "wgsl", "gles"]
 workspace = true
 features = ["metal"]
 
-# We want the wgpu-core Direct3D backends on Windows.
+# We want the wgpu-core Direct3D backend on Windows.
 [target.'cfg(windows)'.dependencies.wgpu-core]
 workspace = true
-features = ["dx11", "dx12"]
+features = ["dx12"]
 
 [target.'cfg(windows)'.dependencies.wgpu-hal]
 version = "0.18.0"

deno_webgpu/README.md

@@ -19,7 +19,7 @@ running through our WPT runner. This will be used to validate implementation
 conformance.
 
 GitHub CI doesn't run with GPUs, so testing relies on software like DX WARP &
-Vulkan lavapipe. Currently only using DX WARP works, so tests are only run on
+Vulkan lavapipe. Currently, only using DX WARP works, so tests are only run on
 Windows.
 
 ## Links

deno_webgpu/lib.rs

@@ -33,8 +33,6 @@ mod macros {
         wgpu_types::Backend::Metal => $global.$method::<wgpu_core::api::Metal>( $($param),* ),
         #[cfg(all(not(target_arch = "wasm32"), windows))]
         wgpu_types::Backend::Dx12 => $global.$method::<wgpu_core::api::Dx12>( $($param),* ),
-        #[cfg(all(not(target_arch = "wasm32"), windows))]
-        wgpu_types::Backend::Dx11 => $global.$method::<wgpu_core::api::Dx11>( $($param),* ),
         #[cfg(any(
             all(unix, not(target_os = "macos"), not(target_os = "ios")),
             feature = "angle",
@@ -266,6 +264,9 @@ fn deserialize_features(features: &wgpu_types::Features) -> Vec<&'static str> {
     if features.contains(wgpu_types::Features::BGRA8UNORM_STORAGE) {
         return_features.push("bgra8unorm-storage");
     }
+    if features.contains(wgpu_types::Features::FLOAT32_FILTERABLE) {
+        return_features.push("float32-filterable");
+    }
 
     // extended from spec
 
@@ -498,6 +499,10 @@ impl From<GpuRequiredFeatures> for wgpu_types::Features {
             wgpu_types::Features::BGRA8UNORM_STORAGE,
             required_features.0.contains("bgra8unorm-storage"),
         );
+        features.set(
+            wgpu_types::Features::FLOAT32_FILTERABLE,
+            required_features.0.contains("float32-filterable"),
+        );
 
         // extended from spec
 

deno_webgpu/webgpu.idl

@@ -103,6 +103,7 @@ enum GPUFeatureName {
     "shader-f16",
     "rg11b10ufloat-renderable",
     "bgra8unorm-storage",
+    "float32-filterable",
 
     // extended from spec