Vendor dependencies for 0.3.0 release

vendor/wgpu/src/api/adapter.rs

@@ -0,0 +1,196 @@
+use std::future::Future;
+
+use crate::*;
+
+/// Handle to a physical graphics and/or compute device.
+///
+/// Adapters can be created using [`Instance::request_adapter`]
+/// or other [`Instance`] methods.
+///
+/// Adapters can be used to open a connection to the corresponding [`Device`]
+/// on the host system by using [`Adapter::request_device`].
+///
+/// Does not have to be kept alive.
+///
+/// Corresponds to [WebGPU `GPUAdapter`](https://gpuweb.github.io/gpuweb/#gpu-adapter).
+#[derive(Debug, Clone)]
+pub struct Adapter {
+    pub(crate) inner: dispatch::DispatchAdapter,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(Adapter: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(Adapter => .inner);
+
+pub use wgt::RequestAdapterOptions as RequestAdapterOptionsBase;
+/// Additional information required when requesting an adapter.
+///
+/// For use with [`Instance::request_adapter`].
+///
+/// Corresponds to [WebGPU `GPURequestAdapterOptions`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpurequestadapteroptions).
+pub type RequestAdapterOptions<'a, 'b> = RequestAdapterOptionsBase<&'a Surface<'b>>;
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(RequestAdapterOptions<'_, '_>: Send, Sync);
+
+impl Adapter {
+    /// Requests a connection to a physical device, creating a logical device.
+    ///
+    /// Returns the [`Device`] together with a [`Queue`] that executes command buffers.
+    ///
+    /// [Per the WebGPU specification], an [`Adapter`] may only be used once to create a device.
+    /// If another device is wanted, call [`Instance::request_adapter()`] again to get a fresh
+    /// [`Adapter`].
+    /// However, `wgpu` does not currently enforce this restriction.
+    ///
+    /// # Arguments
+    ///
+    /// - `desc` - Description of the features and limits requested from the given device.
+    /// - `trace_path` - Can be used for API call tracing, if that feature is
+    ///   enabled in `wgpu-core`.
+    ///
+    /// # Panics
+    ///
+    /// - `request_device()` was already called on this `Adapter`.
+    /// - Features specified by `desc` are not supported by this adapter.
+    /// - Unsafe features were requested but not enabled when requesting the adapter.
+    /// - Limits requested exceed the values provided by the adapter.
+    /// - Adapter does not support all features wgpu requires to safely operate.
+    ///
+    /// [Per the WebGPU specification]: https://www.w3.org/TR/webgpu/#dom-gpuadapter-requestdevice
+    pub fn request_device(
+        &self,
+        desc: &DeviceDescriptor<'_>,
+        trace_path: Option<&std::path::Path>,
+    ) -> impl Future<Output = Result<(Device, Queue), RequestDeviceError>> + WasmNotSend {
+        let device = self.inner.request_device(desc, trace_path);
+        async move {
+            device
+                .await
+                .map(|(device, queue)| (Device { inner: device }, Queue { inner: queue }))
+        }
+    }
+
+    /// Create a wgpu [`Device`] and [`Queue`] from a wgpu-hal `OpenDevice`
+    ///
+    /// # Safety
+    ///
+    /// - `hal_device` must be created from this adapter internal handle.
+    /// - `desc.features` must be a subset of `hal_device` features.
+    #[cfg(wgpu_core)]
+    pub unsafe fn create_device_from_hal<A: wgc::hal_api::HalApi>(
+        &self,
+        hal_device: hal::OpenDevice<A>,
+        desc: &DeviceDescriptor<'_>,
+        trace_path: Option<&std::path::Path>,
+    ) -> Result<(Device, Queue), RequestDeviceError> {
+        let core_adapter = self.inner.as_core();
+        let (device, queue) = unsafe {
+            core_adapter
+                .context
+                .create_device_from_hal(core_adapter, hal_device, desc, trace_path)
+        }?;
+
+        Ok((
+            Device {
+                inner: device.into(),
+            },
+            Queue {
+                inner: queue.into(),
+            },
+        ))
+    }
+
+    /// Apply a callback to this `Adapter`'s underlying backend adapter.
+    ///
+    /// If this `Adapter` is implemented by the backend API given by `A` (Vulkan,
+    /// Dx12, etc.), then apply `hal_adapter_callback` to `Some(&adapter)`, where
+    /// `adapter` is the underlying backend adapter type, [`A::Adapter`].
+    ///
+    /// If this `Adapter` uses a different backend, apply `hal_adapter_callback`
+    /// to `None`.
+    ///
+    /// The adapter is locked for reading while `hal_adapter_callback` runs. If
+    /// the callback attempts to perform any `wgpu` operations that require
+    /// write access to the adapter, deadlock will occur. The locks are
+    /// automatically released when the callback returns.
+    ///
+    /// # Safety
+    ///
+    /// - The raw handle passed to the callback must not be manually destroyed.
+    ///
+    /// [`A::Adapter`]: hal::Api::Adapter
+    #[cfg(wgpu_core)]
+    pub unsafe fn as_hal<A: wgc::hal_api::HalApi, F: FnOnce(Option<&A::Adapter>) -> R, R>(
+        &self,
+        hal_adapter_callback: F,
+    ) -> R {
+        if let Some(adapter) = self.inner.as_core_opt() {
+            unsafe {
+                adapter
+                    .context
+                    .adapter_as_hal::<A, F, R>(adapter, hal_adapter_callback)
+            }
+        } else {
+            hal_adapter_callback(None)
+        }
+    }
+
+    /// Returns whether this adapter may present to the passed surface.
+    pub fn is_surface_supported(&self, surface: &Surface<'_>) -> bool {
+        self.inner.is_surface_supported(&surface.inner)
+    }
+
+    /// The features which can be used to create devices on this adapter.
+    pub fn features(&self) -> Features {
+        self.inner.features()
+    }
+
+    /// The best limits which can be used to create devices on this adapter.
+    pub fn limits(&self) -> Limits {
+        self.inner.limits()
+    }
+
+    /// Get info about the adapter itself.
+    pub fn get_info(&self) -> AdapterInfo {
+        self.inner.get_info()
+    }
+
+    /// Get info about the adapter itself.
+    pub fn get_downlevel_capabilities(&self) -> DownlevelCapabilities {
+        self.inner.downlevel_capabilities()
+    }
+
+    /// Returns the features supported for a given texture format by this adapter.
+    ///
+    /// Note that the WebGPU spec further restricts the available usages/features.
+    /// To disable these restrictions on a device, request the [`Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES`] feature.
+    pub fn get_texture_format_features(&self, format: TextureFormat) -> TextureFormatFeatures {
+        self.inner.get_texture_format_features(format)
+    }
+
+    /// Generates a timestamp using the clock used by the presentation engine.
+    ///
+    /// When comparing completely opaque timestamp systems, we need a way of generating timestamps that signal
+    /// the exact same time. You can do this by calling your own timestamp function immediately after a call to
+    /// this function. This should result in timestamps that are 0.5 to 5 microseconds apart. There are locks
+    /// that must be taken during the call, so don't call your function before.
+    ///
+    /// ```no_run
+    /// # let adapter: wgpu::Adapter = panic!();
+    /// # let some_code = || wgpu::PresentationTimestamp::INVALID_TIMESTAMP;
+    /// use std::time::{Duration, Instant};
+    /// let presentation = adapter.get_presentation_timestamp();
+    /// let instant = Instant::now();
+    ///
+    /// // We can now turn a new presentation timestamp into an Instant.
+    /// let some_pres_timestamp = some_code();
+    /// let duration = Duration::from_nanos((some_pres_timestamp.0 - presentation.0) as u64);
+    /// let new_instant: Instant = instant + duration;
+    /// ```
+    //
+    /// [Instant]: std::time::Instant
+    pub fn get_presentation_timestamp(&self) -> PresentationTimestamp {
+        self.inner.get_presentation_timestamp()
+    }
+}

vendor/wgpu/src/api/bind_group.rs

@@ -0,0 +1,142 @@
+use crate::*;
+
+/// Handle to a binding group.
+///
+/// A `BindGroup` represents the set of resources bound to the bindings described by a
+/// [`BindGroupLayout`]. It can be created with [`Device::create_bind_group`]. A `BindGroup` can
+/// be bound to a particular [`RenderPass`] with [`RenderPass::set_bind_group`], or to a
+/// [`ComputePass`] with [`ComputePass::set_bind_group`].
+///
+/// Corresponds to [WebGPU `GPUBindGroup`](https://gpuweb.github.io/gpuweb/#gpubindgroup).
+#[derive(Debug, Clone)]
+pub struct BindGroup {
+    pub(crate) inner: dispatch::DispatchBindGroup,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(BindGroup: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(BindGroup => .inner);
+
+/// Resource that can be bound to a pipeline.
+///
+/// Corresponds to [WebGPU `GPUBindingResource`](
+/// https://gpuweb.github.io/gpuweb/#typedefdef-gpubindingresource).
+#[non_exhaustive]
+#[derive(Clone, Debug)]
+pub enum BindingResource<'a> {
+    /// Binding is backed by a buffer.
+    ///
+    /// Corresponds to [`wgt::BufferBindingType::Uniform`] and [`wgt::BufferBindingType::Storage`]
+    /// with [`BindGroupLayoutEntry::count`] set to None.
+    Buffer(BufferBinding<'a>),
+    /// Binding is backed by an array of buffers.
+    ///
+    /// [`Features::BUFFER_BINDING_ARRAY`] must be supported to use this feature.
+    ///
+    /// Corresponds to [`wgt::BufferBindingType::Uniform`] and [`wgt::BufferBindingType::Storage`]
+    /// with [`BindGroupLayoutEntry::count`] set to Some.
+    BufferArray(&'a [BufferBinding<'a>]),
+    /// Binding is a sampler.
+    ///
+    /// Corresponds to [`wgt::BindingType::Sampler`] with [`BindGroupLayoutEntry::count`] set to None.
+    Sampler(&'a Sampler),
+    /// Binding is backed by an array of samplers.
+    ///
+    /// [`Features::TEXTURE_BINDING_ARRAY`] must be supported to use this feature.
+    ///
+    /// Corresponds to [`wgt::BindingType::Sampler`] with [`BindGroupLayoutEntry::count`] set
+    /// to Some.
+    SamplerArray(&'a [&'a Sampler]),
+    /// Binding is backed by a texture.
+    ///
+    /// Corresponds to [`wgt::BindingType::Texture`] and [`wgt::BindingType::StorageTexture`] with
+    /// [`BindGroupLayoutEntry::count`] set to None.
+    TextureView(&'a TextureView),
+    /// Binding is backed by an array of textures.
+    ///
+    /// [`Features::TEXTURE_BINDING_ARRAY`] must be supported to use this feature.
+    ///
+    /// Corresponds to [`wgt::BindingType::Texture`] and [`wgt::BindingType::StorageTexture`] with
+    /// [`BindGroupLayoutEntry::count`] set to Some.
+    TextureViewArray(&'a [&'a TextureView]),
+    /// Binding is backed by a top level acceleration structure
+    ///
+    /// Corresponds to [`wgt::BindingType::AccelerationStructure`] with [`BindGroupLayoutEntry::count`] set to None.
+    ///
+    /// # Validation
+    /// When using (e.g. with `set_bind_group`) a bind group that has been created with one or more of this binding
+    /// resource certain checks take place.
+    /// - TLAS must have been built, if not a validation error is generated
+    /// - All BLASes that were built into the TLAS must be built before the TLAS, if this was not satisfied and TLAS was
+    ///   built using `build_acceleration_structures` a validation error is generated otherwise this is a part of the
+    ///   safety section of `build_acceleration_structures_unsafe_tlas` and so undefined behavior occurs.
+    AccelerationStructure(&'a Tlas),
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(BindingResource<'_>: Send, Sync);
+
+/// Describes the segment of a buffer to bind.
+///
+/// Corresponds to [WebGPU `GPUBufferBinding`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpubufferbinding).
+#[derive(Clone, Debug)]
+pub struct BufferBinding<'a> {
+    /// The buffer to bind.
+    pub buffer: &'a Buffer,
+
+    /// Base offset of the buffer, in bytes.
+    ///
+    /// If the [`has_dynamic_offset`] field of this buffer's layout entry is
+    /// `true`, the offset here will be added to the dynamic offset passed to
+    /// [`RenderPass::set_bind_group`] or [`ComputePass::set_bind_group`].
+    ///
+    /// If the buffer was created with [`BufferUsages::UNIFORM`], then this
+    /// offset must be a multiple of
+    /// [`Limits::min_uniform_buffer_offset_alignment`].
+    ///
+    /// If the buffer was created with [`BufferUsages::STORAGE`], then this
+    /// offset must be a multiple of
+    /// [`Limits::min_storage_buffer_offset_alignment`].
+    ///
+    /// [`has_dynamic_offset`]: BindingType::Buffer::has_dynamic_offset
+    pub offset: BufferAddress,
+
+    /// Size of the binding in bytes, or `None` for using the rest of the buffer.
+    pub size: Option<BufferSize>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(BufferBinding<'_>: Send, Sync);
+
+/// An element of a [`BindGroupDescriptor`], consisting of a bindable resource
+/// and the slot to bind it to.
+///
+/// Corresponds to [WebGPU `GPUBindGroupEntry`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpubindgroupentry).
+#[derive(Clone, Debug)]
+pub struct BindGroupEntry<'a> {
+    /// Slot for which binding provides resource. Corresponds to an entry of the same
+    /// binding index in the [`BindGroupLayoutDescriptor`].
+    pub binding: u32,
+    /// Resource to attach to the binding
+    pub resource: BindingResource<'a>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(BindGroupEntry<'_>: Send, Sync);
+
+/// Describes a group of bindings and the resources to be bound.
+///
+/// For use with [`Device::create_bind_group`].
+///
+/// Corresponds to [WebGPU `GPUBindGroupDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpubindgroupdescriptor).
+#[derive(Clone, Debug)]
+pub struct BindGroupDescriptor<'a> {
+    /// Debug label of the bind group. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// The [`BindGroupLayout`] that corresponds to this bind group.
+    pub layout: &'a BindGroupLayout,
+    /// The resources to bind to this bind group.
+    pub entries: &'a [BindGroupEntry<'a>],
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(BindGroupDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/bind_group_layout.rs

@@ -0,0 +1,37 @@
+use crate::*;
+
+/// Handle to a binding group layout.
+///
+/// A `BindGroupLayout` is a handle to the GPU-side layout of a binding group. It can be used to
+/// create a [`BindGroupDescriptor`] object, which in turn can be used to create a [`BindGroup`]
+/// object with [`Device::create_bind_group`]. A series of `BindGroupLayout`s can also be used to
+/// create a [`PipelineLayoutDescriptor`], which can be used to create a [`PipelineLayout`].
+///
+/// It can be created with [`Device::create_bind_group_layout`].
+///
+/// Corresponds to [WebGPU `GPUBindGroupLayout`](
+/// https://gpuweb.github.io/gpuweb/#gpubindgrouplayout).
+#[derive(Debug, Clone)]
+pub struct BindGroupLayout {
+    pub(crate) inner: dispatch::DispatchBindGroupLayout,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(BindGroupLayout: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(BindGroupLayout => .inner);
+
+/// Describes a [`BindGroupLayout`].
+///
+/// For use with [`Device::create_bind_group_layout`].
+///
+/// Corresponds to [WebGPU `GPUBindGroupLayoutDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpubindgrouplayoutdescriptor).
+#[derive(Clone, Debug)]
+pub struct BindGroupLayoutDescriptor<'a> {
+    /// Debug label of the bind group layout. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+
+    /// Array of entries in this BindGroupLayout
+    pub entries: &'a [BindGroupLayoutEntry],
+}
+static_assertions::assert_impl_all!(BindGroupLayoutDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/blas.rs

@@ -0,0 +1,184 @@
+use crate::dispatch;
+use crate::{Buffer, Label};
+use wgt::WasmNotSendSync;
+
+/// Descriptor for the size defining attributes of a triangle geometry, for a bottom level acceleration structure.
+pub type BlasTriangleGeometrySizeDescriptor = wgt::BlasTriangleGeometrySizeDescriptor;
+static_assertions::assert_impl_all!(BlasTriangleGeometrySizeDescriptor: Send, Sync);
+
+/// Descriptor for the size defining attributes, for a bottom level acceleration structure.
+pub type BlasGeometrySizeDescriptors = wgt::BlasGeometrySizeDescriptors;
+static_assertions::assert_impl_all!(BlasGeometrySizeDescriptors: Send, Sync);
+
+/// Flags for an acceleration structure.
+pub type AccelerationStructureFlags = wgt::AccelerationStructureFlags;
+static_assertions::assert_impl_all!(AccelerationStructureFlags: Send, Sync);
+
+/// Flags for a geometry inside a bottom level acceleration structure.
+pub type AccelerationStructureGeometryFlags = wgt::AccelerationStructureGeometryFlags;
+static_assertions::assert_impl_all!(AccelerationStructureGeometryFlags: Send, Sync);
+
+/// Update mode for acceleration structure builds.
+pub type AccelerationStructureUpdateMode = wgt::AccelerationStructureUpdateMode;
+static_assertions::assert_impl_all!(AccelerationStructureUpdateMode: Send, Sync);
+
+/// Descriptor to create bottom level acceleration structures.
+pub type CreateBlasDescriptor<'a> = wgt::CreateBlasDescriptor<Label<'a>>;
+static_assertions::assert_impl_all!(CreateBlasDescriptor<'_>: Send, Sync);
+
+/// Safe instance for a [Tlas].
+///
+/// A TlasInstance may be made invalid, if a TlasInstance is invalid, any attempt to build a [TlasPackage] containing an
+/// invalid TlasInstance will generate a validation error
+///
+/// Each one contains:
+/// - A reference to a BLAS, this ***must*** be interacted with using [TlasInstance::new] or [TlasInstance::set_blas], a
+///   TlasInstance that references a BLAS keeps that BLAS from being dropped
+/// - A user accessible transformation matrix
+/// - A user accessible mask
+/// - A user accessible custom index
+///
+/// [Tlas]: crate::Tlas
+/// [TlasPackage]: crate::TlasPackage
+#[derive(Debug, Clone)]
+pub struct TlasInstance {
+    pub(crate) blas: dispatch::DispatchBlas,
+    /// Affine transform matrix 3x4 (rows x columns, row major order).
+    pub transform: [f32; 12],
+    /// Custom index for the instance used inside the shader.
+    ///
+    /// This must only use the lower 24 bits, if any bits are outside that range (byte 4 does not equal 0) the TlasInstance becomes
+    /// invalid and generates a validation error when built
+    pub custom_index: u32,
+    /// Mask for the instance used inside the shader to filter instances.
+    /// Reports hit only if `(shader_cull_mask & tlas_instance.mask) != 0u`.
+    pub mask: u8,
+}
+
+impl TlasInstance {
+    /// Construct TlasInstance.
+    /// - blas: Reference to the bottom level acceleration structure
+    /// - transform: Transform buffer offset in bytes (optional, required if transform buffer is present)
+    /// - custom_index: Custom index for the instance used inside the shader (max 24 bits)
+    /// - mask: Mask for the instance used inside the shader to filter instances
+    ///
+    /// Note: while one of these contains a reference to a BLAS that BLAS will not be dropped,
+    /// but it can still be destroyed. Destroying a BLAS that is referenced by one or more
+    /// TlasInstance(s) will immediately make them invalid. If one or more of those invalid
+    /// TlasInstances is inside a TlasPackage that is attempted to be built, the build will
+    /// generate a validation error.
+    pub fn new(blas: &Blas, transform: [f32; 12], custom_index: u32, mask: u8) -> Self {
+        Self {
+            blas: blas.inner.clone(),
+            transform,
+            custom_index,
+            mask,
+        }
+    }
+
+    /// Set the bottom level acceleration structure.
+    ///
+    /// See the note on [TlasInstance] about the
+    /// guarantees of keeping a BLAS alive.
+    pub fn set_blas(&mut self, blas: &Blas) {
+        self.blas = blas.inner.clone();
+    }
+}
+
+#[derive(Debug)]
+/// Definition for a triangle geometry for a Bottom Level Acceleration Structure (BLAS).
+///
+/// The size must match the rest of the structures fields, otherwise the build will fail.
+/// (e.g. if index count is present in the size, the index buffer must be present as well.)
+pub struct BlasTriangleGeometry<'a> {
+    /// Sub descriptor for the size defining attributes of a triangle geometry.
+    pub size: &'a BlasTriangleGeometrySizeDescriptor,
+    /// Vertex buffer.
+    pub vertex_buffer: &'a Buffer,
+    /// Offset into the vertex buffer as a factor of the vertex stride.
+    pub first_vertex: u32,
+    /// Vertex stride.
+    pub vertex_stride: wgt::BufferAddress,
+    /// Index buffer (optional).
+    pub index_buffer: Option<&'a Buffer>,
+    /// Number of indexes to skip in the index buffer (optional, required if index buffer is present).
+    pub first_index: Option<u32>,
+    /// Transform buffer containing 3x4 (rows x columns, row major) affine transform matrices `[f32; 12]` (optional).
+    pub transform_buffer: Option<&'a Buffer>,
+    /// Transform buffer offset in bytes (optional, required if transform buffer is present).
+    pub transform_buffer_offset: Option<wgt::BufferAddress>,
+}
+static_assertions::assert_impl_all!(BlasTriangleGeometry<'_>: WasmNotSendSync);
+
+/// Contains the sets of geometry that go into a [Blas].
+pub enum BlasGeometries<'a> {
+    /// Triangle geometry variant.
+    TriangleGeometries(Vec<BlasTriangleGeometry<'a>>),
+}
+static_assertions::assert_impl_all!(BlasGeometries<'_>: WasmNotSendSync);
+
+/// Builds the given sets of geometry into the given [Blas].
+pub struct BlasBuildEntry<'a> {
+    /// Reference to the acceleration structure.
+    pub blas: &'a Blas,
+    /// Geometries.
+    pub geometry: BlasGeometries<'a>,
+}
+static_assertions::assert_impl_all!(BlasBuildEntry<'_>: WasmNotSendSync);
+
+#[derive(Debug, Clone)]
+/// Bottom Level Acceleration Structure (BLAS).
+///
+/// A BLAS is a device-specific raytracing acceleration structure that contains geometry data.
+///
+/// These BLASes are combined with transform in a [TlasInstance] to create a [Tlas].
+///
+/// [Tlas]: crate::Tlas
+pub struct Blas {
+    pub(crate) handle: Option<u64>,
+    pub(crate) inner: dispatch::DispatchBlas,
+}
+static_assertions::assert_impl_all!(Blas: WasmNotSendSync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(Blas => .inner);
+
+impl Blas {
+    /// Raw handle to the acceleration structure, used inside raw instance buffers.
+    pub fn handle(&self) -> Option<u64> {
+        self.handle
+    }
+}
+
+/// Context version of [BlasTriangleGeometry].
+pub struct ContextBlasTriangleGeometry<'a> {
+    #[expect(dead_code)]
+    pub(crate) size: &'a BlasTriangleGeometrySizeDescriptor,
+    #[expect(dead_code)]
+    pub(crate) vertex_buffer: &'a dispatch::DispatchBuffer,
+    #[expect(dead_code)]
+    pub(crate) index_buffer: Option<&'a dispatch::DispatchBuffer>,
+    #[expect(dead_code)]
+    pub(crate) transform_buffer: Option<&'a dispatch::DispatchBuffer>,
+    #[expect(dead_code)]
+    pub(crate) first_vertex: u32,
+    #[expect(dead_code)]
+    pub(crate) vertex_stride: wgt::BufferAddress,
+    #[expect(dead_code)]
+    pub(crate) index_buffer_offset: Option<wgt::BufferAddress>,
+    #[expect(dead_code)]
+    pub(crate) transform_buffer_offset: Option<wgt::BufferAddress>,
+}
+
+/// Context version of [BlasGeometries].
+pub enum ContextBlasGeometries<'a> {
+    /// Triangle geometries.
+    TriangleGeometries(Box<dyn Iterator<Item = ContextBlasTriangleGeometry<'a>> + 'a>),
+}
+
+/// Context version see [BlasBuildEntry].
+pub struct ContextBlasBuildEntry<'a> {
+    #[expect(dead_code)]
+    pub(crate) blas: &'a dispatch::DispatchBlas,
+    #[expect(dead_code)]
+    pub(crate) geometries: ContextBlasGeometries<'a>,
+}

vendor/wgpu/src/api/buffer.rs

@@ -0,0 +1,743 @@
+use std::{
+    error, fmt,
+    ops::{Bound, Deref, DerefMut, Range, RangeBounds},
+    sync::Arc,
+};
+
+use parking_lot::Mutex;
+
+use crate::*;
+
+/// Handle to a GPU-accessible buffer.
+///
+/// Created with [`Device::create_buffer`] or
+/// [`DeviceExt::create_buffer_init`](util::DeviceExt::create_buffer_init).
+///
+/// Corresponds to [WebGPU `GPUBuffer`](https://gpuweb.github.io/gpuweb/#buffer-interface).
+///
+/// A `Buffer`'s bytes have "interior mutability": functions like
+/// [`Queue::write_buffer`] or [mapping] a buffer for writing only require a
+/// `&Buffer`, not a `&mut Buffer`, even though they modify its contents. `wgpu`
+/// prevents simultaneous reads and writes of buffer contents using run-time
+/// checks.
+///
+/// [mapping]: Buffer#mapping-buffers
+///
+/// # Mapping buffers
+///
+/// If a `Buffer` is created with the appropriate [`usage`], it can be *mapped*:
+/// you can make its contents accessible to the CPU as an ordinary `&[u8]` or
+/// `&mut [u8]` slice of bytes. Buffers created with the
+/// [`mapped_at_creation`][mac] flag set are also mapped initially.
+///
+/// Depending on the hardware, the buffer could be memory shared between CPU and
+/// GPU, so that the CPU has direct access to the same bytes the GPU will
+/// consult; or it may be ordinary CPU memory, whose contents the system must
+/// copy to/from the GPU as needed. This crate's API is designed to work the
+/// same way in either case: at any given time, a buffer is either mapped and
+/// available to the CPU, or unmapped and ready for use by the GPU, but never
+/// both. This makes it impossible for either side to observe changes by the
+/// other immediately, and any necessary transfers can be carried out when the
+/// buffer transitions from one state to the other.
+///
+/// There are two ways to map a buffer:
+///
+/// - If [`BufferDescriptor::mapped_at_creation`] is `true`, then the entire
+///   buffer is mapped when it is created. This is the easiest way to initialize
+///   a new buffer. You can set `mapped_at_creation` on any kind of buffer,
+///   regardless of its [`usage`] flags.
+///
+/// - If the buffer's [`usage`] includes the [`MAP_READ`] or [`MAP_WRITE`]
+///   flags, then you can call `buffer.slice(range).map_async(mode, callback)`
+///   to map the portion of `buffer` given by `range`. This waits for the GPU to
+///   finish using the buffer, and invokes `callback` as soon as the buffer is
+///   safe for the CPU to access.
+///
+/// Once a buffer is mapped:
+///
+/// - You can call `buffer.slice(range).get_mapped_range()` to obtain a
+///   [`BufferView`], which dereferences to a `&[u8]` that you can use to read
+///   the buffer's contents.
+///
+/// - Or, you can call `buffer.slice(range).get_mapped_range_mut()` to obtain a
+///   [`BufferViewMut`], which dereferences to a `&mut [u8]` that you can use to
+///   read and write the buffer's contents.
+///
+/// The given `range` must fall within the mapped portion of the buffer. If you
+/// attempt to access overlapping ranges, even for shared access only, these
+/// methods panic.
+///
+/// While a buffer is mapped, you may not submit any commands to the GPU that
+/// access it. You may record command buffers that use the buffer, but if you
+/// submit them while the buffer is mapped, submission will panic.
+///
+/// When you are done using the buffer on the CPU, you must call
+/// [`Buffer::unmap`] to make it available for use by the GPU again. All
+/// [`BufferView`] and [`BufferViewMut`] views referring to the buffer must be
+/// dropped before you unmap it; otherwise, [`Buffer::unmap`] will panic.
+///
+/// # Example
+///
+/// If `buffer` was created with [`BufferUsages::MAP_WRITE`], we could fill it
+/// with `f32` values like this:
+///
+/// ```no_run
+/// # mod bytemuck {
+/// #     pub fn cast_slice_mut(bytes: &mut [u8]) -> &mut [f32] { todo!() }
+/// # }
+/// # let device: wgpu::Device = todo!();
+/// # let buffer: wgpu::Buffer = todo!();
+/// let buffer = std::sync::Arc::new(buffer);
+/// let capturable = buffer.clone();
+/// buffer.slice(..).map_async(wgpu::MapMode::Write, move |result| {
+///     if result.is_ok() {
+///         let mut view = capturable.slice(..).get_mapped_range_mut();
+///         let floats: &mut [f32] = bytemuck::cast_slice_mut(&mut view);
+///         floats.fill(42.0);
+///         drop(view);
+///         capturable.unmap();
+///     }
+/// });
+/// ```
+///
+/// This code takes the following steps:
+///
+/// - First, it moves `buffer` into an [`Arc`], and makes a clone for capture by
+///   the callback passed to [`map_async`]. Since a [`map_async`] callback may be
+///   invoked from another thread, interaction between the callback and the
+///   thread calling [`map_async`] generally requires some sort of shared heap
+///   data like this. In real code, the [`Arc`] would probably own some larger
+///   structure that itself owns `buffer`.
+///
+/// - Then, it calls [`Buffer::slice`] to make a [`BufferSlice`] referring to
+///   the buffer's entire contents.
+///
+/// - Next, it calls [`BufferSlice::map_async`] to request that the bytes to
+///   which the slice refers be made accessible to the CPU ("mapped"). This may
+///   entail waiting for previously enqueued operations on `buffer` to finish.
+///   Although [`map_async`] itself always returns immediately, it saves the
+///   callback function to be invoked later.
+///
+/// - When some later call to [`Device::poll`] or [`Instance::poll_all`] (not
+///   shown in this example) determines that the buffer is mapped and ready for
+///   the CPU to use, it invokes the callback function.
+///
+/// - The callback function calls [`Buffer::slice`] and then
+///   [`BufferSlice::get_mapped_range_mut`] to obtain a [`BufferViewMut`], which
+///   dereferences to a `&mut [u8]` slice referring to the buffer's bytes.
+///
+/// - It then uses the [`bytemuck`] crate to turn the `&mut [u8]` into a `&mut
+///   [f32]`, and calls the slice [`fill`] method to fill the buffer with a
+///   useful value.
+///
+/// - Finally, the callback drops the view and calls [`Buffer::unmap`] to unmap
+///   the buffer. In real code, the callback would also need to do some sort of
+///   synchronization to let the rest of the program know that it has completed
+///   its work.
+///
+/// If using [`map_async`] directly is awkward, you may find it more convenient to
+/// use [`Queue::write_buffer`] and [`util::DownloadBuffer::read_buffer`].
+/// However, those each have their own tradeoffs; the asynchronous nature of GPU
+/// execution makes it hard to avoid friction altogether.
+///
+/// [`Arc`]: std::sync::Arc
+/// [`map_async`]: BufferSlice::map_async
+/// [`bytemuck`]: https://crates.io/crates/bytemuck
+/// [`fill`]: slice::fill
+///
+/// ## Mapping buffers on the web
+///
+/// When compiled to WebAssembly and running in a browser content process,
+/// `wgpu` implements its API in terms of the browser's WebGPU implementation.
+/// In this context, `wgpu` is further isolated from the GPU:
+///
+/// - Depending on the browser's WebGPU implementation, mapping and unmapping
+///   buffers probably entails copies between WebAssembly linear memory and the
+///   graphics driver's buffers.
+///
+/// - All modern web browsers isolate web content in its own sandboxed process,
+///   which can only interact with the GPU via interprocess communication (IPC).
+///   Although most browsers' IPC systems use shared memory for large data
+///   transfers, there will still probably need to be copies into and out of the
+///   shared memory buffers.
+///
+/// All of these copies contribute to the cost of buffer mapping in this
+/// configuration.
+///
+/// [`usage`]: BufferDescriptor::usage
+/// [mac]: BufferDescriptor::mapped_at_creation
+/// [`MAP_READ`]: BufferUsages::MAP_READ
+/// [`MAP_WRITE`]: BufferUsages::MAP_WRITE
+#[derive(Debug, Clone)]
+pub struct Buffer {
+    pub(crate) inner: dispatch::DispatchBuffer,
+    pub(crate) map_context: Arc<Mutex<MapContext>>,
+    pub(crate) size: wgt::BufferAddress,
+    pub(crate) usage: BufferUsages,
+    // Todo: missing map_state https://www.w3.org/TR/webgpu/#dom-gpubuffer-mapstate
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(Buffer: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(Buffer => .inner);
+
+impl Buffer {
+    /// Return the binding view of the entire buffer.
+    pub fn as_entire_binding(&self) -> BindingResource<'_> {
+        BindingResource::Buffer(self.as_entire_buffer_binding())
+    }
+
+    /// Return the binding view of the entire buffer.
+    pub fn as_entire_buffer_binding(&self) -> BufferBinding<'_> {
+        BufferBinding {
+            buffer: self,
+            offset: 0,
+            size: None,
+        }
+    }
+
+    /// Returns the inner hal Buffer using a callback. The hal buffer will be `None` if the
+    /// backend type argument does not match with this wgpu Buffer
+    ///
+    /// # Safety
+    ///
+    /// - The raw handle obtained from the hal Buffer must not be manually destroyed
+    #[cfg(wgpu_core)]
+    pub unsafe fn as_hal<A: wgc::hal_api::HalApi, F: FnOnce(Option<&A::Buffer>) -> R, R>(
+        &self,
+        hal_buffer_callback: F,
+    ) -> R {
+        if let Some(buffer) = self.inner.as_core_opt() {
+            unsafe {
+                buffer
+                    .context
+                    .buffer_as_hal::<A, F, R>(buffer, hal_buffer_callback)
+            }
+        } else {
+            hal_buffer_callback(None)
+        }
+    }
+
+    /// Return a slice of a [`Buffer`]'s bytes.
+    ///
+    /// Return a [`BufferSlice`] referring to the portion of `self`'s contents
+    /// indicated by `bounds`. Regardless of what sort of data `self` stores,
+    /// `bounds` start and end are given in bytes.
+    ///
+    /// A [`BufferSlice`] can be used to supply vertex and index data, or to map
+    /// buffer contents for access from the CPU. See the [`BufferSlice`]
+    /// documentation for details.
+    ///
+    /// The `range` argument can be half or fully unbounded: for example,
+    /// `buffer.slice(..)` refers to the entire buffer, and `buffer.slice(n..)`
+    /// refers to the portion starting at the `n`th byte and extending to the
+    /// end of the buffer.
+    pub fn slice<S: RangeBounds<BufferAddress>>(&self, bounds: S) -> BufferSlice<'_> {
+        let (offset, size) = range_to_offset_size(bounds);
+        check_buffer_bounds(self.size, offset, size);
+        BufferSlice {
+            buffer: self,
+            offset,
+            size,
+        }
+    }
+
+    /// Flushes any pending write operations and unmaps the buffer from host memory.
+    pub fn unmap(&self) {
+        self.map_context.lock().reset();
+        self.inner.unmap();
+    }
+
+    /// Destroy the associated native resources as soon as possible.
+    pub fn destroy(&self) {
+        self.inner.destroy();
+    }
+
+    /// Returns the length of the buffer allocation in bytes.
+    ///
+    /// This is always equal to the `size` that was specified when creating the buffer.
+    pub fn size(&self) -> BufferAddress {
+        self.size
+    }
+
+    /// Returns the allowed usages for this `Buffer`.
+    ///
+    /// This is always equal to the `usage` that was specified when creating the buffer.
+    pub fn usage(&self) -> BufferUsages {
+        self.usage
+    }
+}
+
+/// A slice of a [`Buffer`], to be mapped, used for vertex or index data, or the like.
+///
+/// You can create a `BufferSlice` by calling [`Buffer::slice`]:
+///
+/// ```no_run
+/// # let buffer: wgpu::Buffer = todo!();
+/// let slice = buffer.slice(10..20);
+/// ```
+///
+/// This returns a slice referring to the second ten bytes of `buffer`. To get a
+/// slice of the entire `Buffer`:
+///
+/// ```no_run
+/// # let buffer: wgpu::Buffer = todo!();
+/// let whole_buffer_slice = buffer.slice(..);
+/// ```
+///
+/// You can pass buffer slices to methods like [`RenderPass::set_vertex_buffer`]
+/// and [`RenderPass::set_index_buffer`] to indicate which portion of the buffer
+/// a draw call should consult.
+///
+/// To access the slice's contents on the CPU, you must first [map] the buffer,
+/// and then call [`BufferSlice::get_mapped_range`] or
+/// [`BufferSlice::get_mapped_range_mut`] to obtain a view of the slice's
+/// contents. See the documentation on [mapping][map] for more details,
+/// including example code.
+///
+/// Unlike a Rust shared slice `&[T]`, whose existence guarantees that
+/// nobody else is modifying the `T` values to which it refers, a
+/// [`BufferSlice`] doesn't guarantee that the buffer's contents aren't
+/// changing. You can still record and submit commands operating on the
+/// buffer while holding a [`BufferSlice`]. A [`BufferSlice`] simply
+/// represents a certain range of the buffer's bytes.
+///
+/// The `BufferSlice` type is unique to the Rust API of `wgpu`. In the WebGPU
+/// specification, an offset and size are specified as arguments to each call
+/// working with the [`Buffer`], instead.
+///
+/// [map]: Buffer#mapping-buffers
+#[derive(Copy, Clone, Debug)]
+pub struct BufferSlice<'a> {
+    pub(crate) buffer: &'a Buffer,
+    pub(crate) offset: BufferAddress,
+    pub(crate) size: Option<BufferSize>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(BufferSlice<'_>: Send, Sync);
+
+impl<'a> BufferSlice<'a> {
+    /// Map the buffer. Buffer is ready to map once the callback is called.
+    ///
+    /// For the callback to complete, either `queue.submit(..)`, `instance.poll_all(..)`, or `device.poll(..)`
+    /// must be called elsewhere in the runtime, possibly integrated into an event loop or run on a separate thread.
+    ///
+    /// The callback will be called on the thread that first calls the above functions after the gpu work
+    /// has completed. There are no restrictions on the code you can run in the callback, however on native the
+    /// call to the function will not complete until the callback returns, so prefer keeping callbacks short
+    /// and used to set flags, send messages, etc.
+    pub fn map_async(
+        &self,
+        mode: MapMode,
+        callback: impl FnOnce(Result<(), BufferAsyncError>) + WasmNotSend + 'static,
+    ) {
+        let mut mc = self.buffer.map_context.lock();
+        assert_eq!(mc.initial_range, 0..0, "Buffer is already mapped");
+        let end = match self.size {
+            Some(s) => self.offset + s.get(),
+            None => mc.total_size,
+        };
+        mc.initial_range = self.offset..end;
+
+        self.buffer
+            .inner
+            .map_async(mode, self.offset..end, Box::new(callback));
+    }
+
+    /// Gain read-only access to the bytes of a [mapped] [`Buffer`].
+    ///
+    /// Return a [`BufferView`] referring to the buffer range represented by
+    /// `self`. See the documentation for [`BufferView`] for details.
+    ///
+    /// # Panics
+    ///
+    /// - This panics if the buffer to which `self` refers is not currently
+    ///   [mapped].
+    ///
+    /// - If you try to create overlapping views of a buffer, mutable or
+    ///   otherwise, `get_mapped_range` will panic.
+    ///
+    /// [mapped]: Buffer#mapping-buffers
+    pub fn get_mapped_range(&self) -> BufferView<'a> {
+        let end = self.buffer.map_context.lock().add(self.offset, self.size);
+        let range = self.buffer.inner.get_mapped_range(self.offset..end);
+        BufferView {
+            slice: *self,
+            inner: range,
+        }
+    }
+
+    /// Synchronously and immediately map a buffer for reading. If the buffer is not immediately mappable
+    /// through [`BufferDescriptor::mapped_at_creation`] or [`BufferSlice::map_async`], will fail.
+    ///
+    /// This is useful when targeting WebGPU and you want to pass mapped data directly to js.
+    /// Unlike `get_mapped_range` which unconditionally copies mapped data into the wasm heap,
+    /// this function directly hands you the ArrayBuffer that we mapped the data into in js.
+    ///
+    /// This is only available on WebGPU, on any other backends this will return `None`.
+    #[cfg(webgpu)]
+    pub fn get_mapped_range_as_array_buffer(&self) -> Option<js_sys::ArrayBuffer> {
+        let end = self.buffer.map_context.lock().add(self.offset, self.size);
+
+        self.buffer
+            .inner
+            .get_mapped_range_as_array_buffer(self.offset..end)
+    }
+
+    /// Gain write access to the bytes of a [mapped] [`Buffer`].
+    ///
+    /// Return a [`BufferViewMut`] referring to the buffer range represented by
+    /// `self`. See the documentation for [`BufferViewMut`] for more details.
+    ///
+    /// # Panics
+    ///
+    /// - This panics if the buffer to which `self` refers is not currently
+    ///   [mapped].
+    ///
+    /// - If you try to create overlapping views of a buffer, mutable or
+    ///   otherwise, `get_mapped_range_mut` will panic.
+    ///
+    /// [mapped]: Buffer#mapping-buffers
+    pub fn get_mapped_range_mut(&self) -> BufferViewMut<'a> {
+        let end = self.buffer.map_context.lock().add(self.offset, self.size);
+        let range = self.buffer.inner.get_mapped_range(self.offset..end);
+        BufferViewMut {
+            slice: *self,
+            inner: range,
+            readable: self.buffer.usage.contains(BufferUsages::MAP_READ),
+        }
+    }
+}
+
+/// The mapped portion of a buffer, if any, and its outstanding views.
+///
+/// This ensures that views fall within the mapped range and don't overlap, and
+/// also takes care of turning `Option<BufferSize>` sizes into actual buffer
+/// offsets.
+#[derive(Debug)]
+pub(crate) struct MapContext {
+    /// The overall size of the buffer.
+    ///
+    /// This is just a convenient copy of [`Buffer::size`].
+    pub(crate) total_size: BufferAddress,
+
+    /// The range of the buffer that is mapped.
+    ///
+    /// This is `0..0` if the buffer is not mapped. This becomes non-empty when
+    /// the buffer is mapped at creation time, and when you call `map_async` on
+    /// some [`BufferSlice`] (so technically, it indicates the portion that is
+    /// *or has been requested to be* mapped.)
+    ///
+    /// All [`BufferView`]s and [`BufferViewMut`]s must fall within this range.
+    pub(crate) initial_range: Range<BufferAddress>,
+
+    /// The ranges covered by all outstanding [`BufferView`]s and
+    /// [`BufferViewMut`]s. These are non-overlapping, and are all contained
+    /// within `initial_range`.
+    sub_ranges: Vec<Range<BufferAddress>>,
+}
+
+impl MapContext {
+    pub(crate) fn new(total_size: BufferAddress) -> Self {
+        Self {
+            total_size,
+            initial_range: 0..0,
+            sub_ranges: Vec::new(),
+        }
+    }
+
+    /// Record that the buffer is no longer mapped.
+    fn reset(&mut self) {
+        self.initial_range = 0..0;
+
+        assert!(
+            self.sub_ranges.is_empty(),
+            "You cannot unmap a buffer that still has accessible mapped views"
+        );
+    }
+
+    /// Record that the `size` bytes of the buffer at `offset` are now viewed.
+    ///
+    /// Return the byte offset within the buffer of the end of the viewed range.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the given range overlaps with any existing range.
+    fn add(&mut self, offset: BufferAddress, size: Option<BufferSize>) -> BufferAddress {
+        let end = match size {
+            Some(s) => offset + s.get(),
+            None => self.initial_range.end,
+        };
+        assert!(self.initial_range.start <= offset && end <= self.initial_range.end);
+        // This check is essential for avoiding undefined behavior: it is the
+        // only thing that ensures that `&mut` references to the buffer's
+        // contents don't alias anything else.
+        for sub in self.sub_ranges.iter() {
+            assert!(
+                end <= sub.start || offset >= sub.end,
+                "Intersecting map range with {sub:?}"
+            );
+        }
+        self.sub_ranges.push(offset..end);
+        end
+    }
+
+    /// Record that the `size` bytes of the buffer at `offset` are no longer viewed.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the given range does not exactly match one previously
+    /// passed to [`add`].
+    ///
+    /// [`add]`: MapContext::add
+    fn remove(&mut self, offset: BufferAddress, size: Option<BufferSize>) {
+        let end = match size {
+            Some(s) => offset + s.get(),
+            None => self.initial_range.end,
+        };
+
+        let index = self
+            .sub_ranges
+            .iter()
+            .position(|r| *r == (offset..end))
+            .expect("unable to remove range from map context");
+        self.sub_ranges.swap_remove(index);
+    }
+}
+
+/// Describes a [`Buffer`].
+///
+/// For use with [`Device::create_buffer`].
+///
+/// Corresponds to [WebGPU `GPUBufferDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpubufferdescriptor).
+pub type BufferDescriptor<'a> = wgt::BufferDescriptor<Label<'a>>;
+static_assertions::assert_impl_all!(BufferDescriptor<'_>: Send, Sync);
+
+/// Error occurred when trying to async map a buffer.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct BufferAsyncError;
+static_assertions::assert_impl_all!(BufferAsyncError: Send, Sync);
+
+impl fmt::Display for BufferAsyncError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Error occurred when trying to async map a buffer")
+    }
+}
+
+impl error::Error for BufferAsyncError {}
+
+/// Type of buffer mapping.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum MapMode {
+    /// Map only for reading
+    Read,
+    /// Map only for writing
+    Write,
+}
+static_assertions::assert_impl_all!(MapMode: Send, Sync);
+
+/// A read-only view of a mapped buffer's bytes.
+///
+/// To get a `BufferView`, first [map] the buffer, and then
+/// call `buffer.slice(range).get_mapped_range()`.
+///
+/// `BufferView` dereferences to `&[u8]`, so you can use all the usual Rust
+/// slice methods to access the buffer's contents. It also implements
+/// `AsRef<[u8]>`, if that's more convenient.
+///
+/// Before the buffer can be unmapped, all `BufferView`s observing it
+/// must be dropped. Otherwise, the call to [`Buffer::unmap`] will panic.
+///
+/// For example code, see the documentation on [mapping buffers][map].
+///
+/// [map]: Buffer#mapping-buffers
+/// [`map_async`]: BufferSlice::map_async
+#[derive(Debug)]
+pub struct BufferView<'a> {
+    slice: BufferSlice<'a>,
+    inner: dispatch::DispatchBufferMappedRange,
+}
+
+impl std::ops::Deref for BufferView<'_> {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &[u8] {
+        self.inner.slice()
+    }
+}
+
+impl AsRef<[u8]> for BufferView<'_> {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.inner.slice()
+    }
+}
+
+/// A write-only view of a mapped buffer's bytes.
+///
+/// To get a `BufferViewMut`, first [map] the buffer, and then
+/// call `buffer.slice(range).get_mapped_range_mut()`.
+///
+/// `BufferViewMut` dereferences to `&mut [u8]`, so you can use all the usual
+/// Rust slice methods to access the buffer's contents. It also implements
+/// `AsMut<[u8]>`, if that's more convenient.
+///
+/// It is possible to read the buffer using this view, but doing so is not
+/// recommended, as it is likely to be slow.
+///
+/// Before the buffer can be unmapped, all `BufferViewMut`s observing it
+/// must be dropped. Otherwise, the call to [`Buffer::unmap`] will panic.
+///
+/// For example code, see the documentation on [mapping buffers][map].
+///
+/// [map]: Buffer#mapping-buffers
+#[derive(Debug)]
+pub struct BufferViewMut<'a> {
+    slice: BufferSlice<'a>,
+    inner: dispatch::DispatchBufferMappedRange,
+    readable: bool,
+}
+
+impl AsMut<[u8]> for BufferViewMut<'_> {
+    #[inline]
+    fn as_mut(&mut self) -> &mut [u8] {
+        self.inner.slice_mut()
+    }
+}
+
+impl Deref for BufferViewMut<'_> {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        if !self.readable {
+            log::warn!("Reading from a BufferViewMut is slow and not recommended.");
+        }
+
+        self.inner.slice()
+    }
+}
+
+impl DerefMut for BufferViewMut<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.inner.slice_mut()
+    }
+}
+
+impl Drop for BufferView<'_> {
+    fn drop(&mut self) {
+        self.slice
+            .buffer
+            .map_context
+            .lock()
+            .remove(self.slice.offset, self.slice.size);
+    }
+}
+
+impl Drop for BufferViewMut<'_> {
+    fn drop(&mut self) {
+        self.slice
+            .buffer
+            .map_context
+            .lock()
+            .remove(self.slice.offset, self.slice.size);
+    }
+}
+
+fn check_buffer_bounds(
+    buffer_size: BufferAddress,
+    offset: BufferAddress,
+    size: Option<BufferSize>,
+) {
+    // A slice of length 0 is invalid, so the offset must not be equal to or greater than the buffer size.
+    if offset >= buffer_size {
+        panic!(
+            "slice offset {} is out of range for buffer of size {}",
+            offset, buffer_size
+        );
+    }
+
+    if let Some(size) = size {
+        // Detect integer overflow.
+        let end = offset.checked_add(size.get());
+        if end.map_or(true, |end| end > buffer_size) {
+            panic!(
+                "slice offset {} size {} is out of range for buffer of size {}",
+                offset, size, buffer_size
+            );
+        }
+    }
+}
+
+fn range_to_offset_size<S: RangeBounds<BufferAddress>>(
+    bounds: S,
+) -> (BufferAddress, Option<BufferSize>) {
+    let offset = match bounds.start_bound() {
+        Bound::Included(&bound) => bound,
+        Bound::Excluded(&bound) => bound + 1,
+        Bound::Unbounded => 0,
+    };
+    let size = match bounds.end_bound() {
+        Bound::Included(&bound) => Some(bound + 1 - offset),
+        Bound::Excluded(&bound) => Some(bound - offset),
+        Bound::Unbounded => None,
+    }
+    .map(|size| BufferSize::new(size).expect("Buffer slices can not be empty"));
+
+    (offset, size)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{check_buffer_bounds, range_to_offset_size, BufferSize};
+
+    #[test]
+    fn range_to_offset_size_works() {
+        assert_eq!(range_to_offset_size(0..2), (0, BufferSize::new(2)));
+        assert_eq!(range_to_offset_size(2..5), (2, BufferSize::new(3)));
+        assert_eq!(range_to_offset_size(..), (0, None));
+        assert_eq!(range_to_offset_size(21..), (21, None));
+        assert_eq!(range_to_offset_size(0..), (0, None));
+        assert_eq!(range_to_offset_size(..21), (0, BufferSize::new(21)));
+    }
+
+    #[test]
+    #[should_panic]
+    fn range_to_offset_size_panics_for_empty_range() {
+        range_to_offset_size(123..123);
+    }
+
+    #[test]
+    #[should_panic]
+    fn range_to_offset_size_panics_for_unbounded_empty_range() {
+        range_to_offset_size(..0);
+    }
+
+    #[test]
+    #[should_panic]
+    fn check_buffer_bounds_panics_for_offset_at_size() {
+        check_buffer_bounds(100, 100, None);
+    }
+
+    #[test]
+    fn check_buffer_bounds_works_for_end_in_range() {
+        check_buffer_bounds(200, 100, BufferSize::new(50));
+        check_buffer_bounds(200, 100, BufferSize::new(100));
+        check_buffer_bounds(u64::MAX, u64::MAX - 100, BufferSize::new(100));
+        check_buffer_bounds(u64::MAX, 0, BufferSize::new(u64::MAX));
+        check_buffer_bounds(u64::MAX, 1, BufferSize::new(u64::MAX - 1));
+    }
+
+    #[test]
+    #[should_panic]
+    fn check_buffer_bounds_panics_for_end_over_size() {
+        check_buffer_bounds(200, 100, BufferSize::new(101));
+    }
+
+    #[test]
+    #[should_panic]
+    fn check_buffer_bounds_panics_for_end_wraparound() {
+        check_buffer_bounds(u64::MAX, 1, BufferSize::new(u64::MAX));
+    }
+}

vendor/wgpu/src/api/command_buffer.rs

@@ -0,0 +1,21 @@
+use std::sync::Arc;
+
+use parking_lot::Mutex;
+
+use crate::*;
+
+/// Handle to a command buffer on the GPU.
+///
+/// A `CommandBuffer` represents a complete sequence of commands that may be submitted to a command
+/// queue with [`Queue::submit`]. A `CommandBuffer` is obtained by recording a series of commands to
+/// a [`CommandEncoder`] and then calling [`CommandEncoder::finish`].
+///
+/// Corresponds to [WebGPU `GPUCommandBuffer`](https://gpuweb.github.io/gpuweb/#command-buffer).
+#[derive(Debug, Clone)]
+pub struct CommandBuffer {
+    pub(crate) inner: Arc<Mutex<Option<dispatch::DispatchCommandBuffer>>>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(CommandBuffer: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_arc_address!(CommandBuffer => .inner);

vendor/wgpu/src/api/command_encoder.rs

@@ -0,0 +1,350 @@
+use std::{ops::Range, sync::Arc};
+
+use crate::{
+    api::{
+        blas::BlasBuildEntry,
+        tlas::{TlasBuildEntry, TlasPackage},
+    },
+    *,
+};
+
+/// Encodes a series of GPU operations.
+///
+/// A command encoder can record [`RenderPass`]es, [`ComputePass`]es,
+/// and transfer operations between driver-managed resources like [`Buffer`]s and [`Texture`]s.
+///
+/// When finished recording, call [`CommandEncoder::finish`] to obtain a [`CommandBuffer`] which may
+/// be submitted for execution.
+///
+/// Corresponds to [WebGPU `GPUCommandEncoder`](https://gpuweb.github.io/gpuweb/#command-encoder).
+#[derive(Debug)]
+pub struct CommandEncoder {
+    pub(crate) inner: dispatch::DispatchCommandEncoder,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(CommandEncoder: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(CommandEncoder => .inner);
+
+/// Describes a [`CommandEncoder`].
+///
+/// For use with [`Device::create_command_encoder`].
+///
+/// Corresponds to [WebGPU `GPUCommandEncoderDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpucommandencoderdescriptor).
+pub type CommandEncoderDescriptor<'a> = wgt::CommandEncoderDescriptor<Label<'a>>;
+static_assertions::assert_impl_all!(CommandEncoderDescriptor<'_>: Send, Sync);
+
+use parking_lot::Mutex;
+pub use wgt::TexelCopyBufferInfo as TexelCopyBufferInfoBase;
+/// View of a buffer which can be used to copy to/from a texture.
+///
+/// Corresponds to [WebGPU `GPUTexelCopyBufferInfo`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpuimagecopybuffer).
+pub type TexelCopyBufferInfo<'a> = TexelCopyBufferInfoBase<&'a Buffer>;
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(TexelCopyBufferInfo<'_>: Send, Sync);
+
+pub use wgt::TexelCopyTextureInfo as TexelCopyTextureInfoBase;
+/// View of a texture which can be used to copy to/from a buffer/texture.
+///
+/// Corresponds to [WebGPU `GPUTexelCopyTextureInfo`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpuimagecopytexture).
+pub type TexelCopyTextureInfo<'a> = TexelCopyTextureInfoBase<&'a Texture>;
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(TexelCopyTextureInfo<'_>: Send, Sync);
+
+impl CommandEncoder {
+    /// Finishes recording and returns a [`CommandBuffer`] that can be submitted for execution.
+    pub fn finish(mut self) -> CommandBuffer {
+        let buffer = self.inner.finish();
+
+        CommandBuffer {
+            inner: Arc::new(Mutex::new(Some(buffer))),
+        }
+    }
+
+    /// Begins recording of a render pass.
+    ///
+    /// This function returns a [`RenderPass`] object which records a single render pass.
+    ///
+    /// As long as the returned  [`RenderPass`] has not ended,
+    /// any mutating operation on this command encoder causes an error and invalidates it.
+    /// Note that the `'encoder` lifetime relationship protects against this,
+    /// but it is possible to opt out of it by calling [`RenderPass::forget_lifetime`].
+    /// This can be useful for runtime handling of the encoder->pass
+    /// dependency e.g. when pass and encoder are stored in the same data structure.
+    pub fn begin_render_pass<'encoder>(
+        &'encoder mut self,
+        desc: &RenderPassDescriptor<'_>,
+    ) -> RenderPass<'encoder> {
+        let rpass = self.inner.begin_render_pass(desc);
+        RenderPass {
+            inner: rpass,
+            _encoder_guard: api::PhantomDrop::default(),
+        }
+    }
+
+    /// Begins recording of a compute pass.
+    ///
+    /// This function returns a [`ComputePass`] object which records a single compute pass.
+    ///
+    /// As long as the returned  [`ComputePass`] has not ended,
+    /// any mutating operation on this command encoder causes an error and invalidates it.
+    /// Note that the `'encoder` lifetime relationship protects against this,
+    /// but it is possible to opt out of it by calling [`ComputePass::forget_lifetime`].
+    /// This can be useful for runtime handling of the encoder->pass
+    /// dependency e.g. when pass and encoder are stored in the same data structure.
+    pub fn begin_compute_pass<'encoder>(
+        &'encoder mut self,
+        desc: &ComputePassDescriptor<'_>,
+    ) -> ComputePass<'encoder> {
+        let cpass = self.inner.begin_compute_pass(desc);
+        ComputePass {
+            inner: cpass,
+            _encoder_guard: api::PhantomDrop::default(),
+        }
+    }
+
+    /// Copy data from one buffer to another.
+    ///
+    /// # Panics
+    ///
+    /// - Buffer offsets or copy size not a multiple of [`COPY_BUFFER_ALIGNMENT`].
+    /// - Copy would overrun buffer.
+    /// - Copy within the same buffer.
+    pub fn copy_buffer_to_buffer(
+        &mut self,
+        source: &Buffer,
+        source_offset: BufferAddress,
+        destination: &Buffer,
+        destination_offset: BufferAddress,
+        copy_size: BufferAddress,
+    ) {
+        self.inner.copy_buffer_to_buffer(
+            &source.inner,
+            source_offset,
+            &destination.inner,
+            destination_offset,
+            copy_size,
+        );
+    }
+
+    /// Copy data from a buffer to a texture.
+    pub fn copy_buffer_to_texture(
+        &mut self,
+        source: TexelCopyBufferInfo<'_>,
+        destination: TexelCopyTextureInfo<'_>,
+        copy_size: Extent3d,
+    ) {
+        self.inner
+            .copy_buffer_to_texture(source, destination, copy_size);
+    }
+
+    /// Copy data from a texture to a buffer.
+    pub fn copy_texture_to_buffer(
+        &mut self,
+        source: TexelCopyTextureInfo<'_>,
+        destination: TexelCopyBufferInfo<'_>,
+        copy_size: Extent3d,
+    ) {
+        self.inner
+            .copy_texture_to_buffer(source, destination, copy_size);
+    }
+
+    /// Copy data from one texture to another.
+    ///
+    /// # Panics
+    ///
+    /// - Textures are not the same type
+    /// - If a depth texture, or a multisampled texture, the entire texture must be copied
+    /// - Copy would overrun either texture
+    pub fn copy_texture_to_texture(
+        &mut self,
+        source: TexelCopyTextureInfo<'_>,
+        destination: TexelCopyTextureInfo<'_>,
+        copy_size: Extent3d,
+    ) {
+        self.inner
+            .copy_texture_to_texture(source, destination, copy_size);
+    }
+
+    /// Clears texture to zero.
+    ///
+    /// Note that unlike with clear_buffer, `COPY_DST` usage is not required.
+    ///
+    /// # Implementation notes
+    ///
+    /// - implemented either via buffer copies and render/depth target clear, path depends on texture usages
+    /// - behaves like texture zero init, but is performed immediately (clearing is *not* delayed via marking it as uninitialized)
+    ///
+    /// # Panics
+    ///
+    /// - `CLEAR_TEXTURE` extension not enabled
+    /// - Range is out of bounds
+    pub fn clear_texture(&mut self, texture: &Texture, subresource_range: &ImageSubresourceRange) {
+        self.inner.clear_texture(&texture.inner, subresource_range);
+    }
+
+    /// Clears buffer to zero.
+    ///
+    /// # Panics
+    ///
+    /// - Buffer does not have `COPY_DST` usage.
+    /// - Range is out of bounds
+    pub fn clear_buffer(
+        &mut self,
+        buffer: &Buffer,
+        offset: BufferAddress,
+        size: Option<BufferAddress>,
+    ) {
+        self.inner.clear_buffer(&buffer.inner, offset, size);
+    }
+
+    /// Inserts debug marker.
+    pub fn insert_debug_marker(&mut self, label: &str) {
+        self.inner.insert_debug_marker(label);
+    }
+
+    /// Start record commands and group it into debug marker group.
+    pub fn push_debug_group(&mut self, label: &str) {
+        self.inner.push_debug_group(label);
+    }
+
+    /// Stops command recording and creates debug group.
+    pub fn pop_debug_group(&mut self) {
+        self.inner.pop_debug_group();
+    }
+
+    /// Resolves a query set, writing the results into the supplied destination buffer.
+    ///
+    /// Occlusion and timestamp queries are 8 bytes each (see [`crate::QUERY_SIZE`]). For pipeline statistics queries,
+    /// see [`PipelineStatisticsTypes`] for more information.
+    pub fn resolve_query_set(
+        &mut self,
+        query_set: &QuerySet,
+        query_range: Range<u32>,
+        destination: &Buffer,
+        destination_offset: BufferAddress,
+    ) {
+        self.inner.resolve_query_set(
+            &query_set.inner,
+            query_range.start,
+            query_range.end - query_range.start,
+            &destination.inner,
+            destination_offset,
+        );
+    }
+
+    /// Returns the inner hal CommandEncoder using a callback. The hal command encoder will be `None` if the
+    /// backend type argument does not match with this wgpu CommandEncoder
+    ///
+    /// This method will start the wgpu_core level command recording.
+    ///
+    /// # Safety
+    ///
+    /// - The raw handle obtained from the hal CommandEncoder must not be manually destroyed
+    #[cfg(wgpu_core)]
+    pub unsafe fn as_hal_mut<
+        A: wgc::hal_api::HalApi,
+        F: FnOnce(Option<&mut A::CommandEncoder>) -> R,
+        R,
+    >(
+        &mut self,
+        hal_command_encoder_callback: F,
+    ) -> R {
+        if let Some(encoder) = self.inner.as_core_mut_opt() {
+            unsafe {
+                encoder
+                    .context
+                    .command_encoder_as_hal_mut::<A, F, R>(encoder, hal_command_encoder_callback)
+            }
+        } else {
+            hal_command_encoder_callback(None)
+        }
+    }
+}
+
+/// [`Features::TIMESTAMP_QUERY_INSIDE_ENCODERS`] must be enabled on the device in order to call these functions.
+impl CommandEncoder {
+    /// Issue a timestamp command at this point in the queue.
+    /// The timestamp will be written to the specified query set, at the specified index.
+    ///
+    /// Must be multiplied by [`Queue::get_timestamp_period`] to get
+    /// the value in nanoseconds. Absolute values have no meaning,
+    /// but timestamps can be subtracted to get the time it takes
+    /// for a string of operations to complete.
+    ///
+    /// Attention: Since commands within a command recorder may be reordered,
+    /// there is no strict guarantee that timestamps are taken after all commands
+    /// recorded so far and all before all commands recorded after.
+    /// This may depend both on the backend and the driver.
+    pub fn write_timestamp(&mut self, query_set: &QuerySet, query_index: u32) {
+        self.inner.write_timestamp(&query_set.inner, query_index);
+    }
+}
+
+/// [`Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE`] must be enabled on the device in order to call these functions.
+impl CommandEncoder {
+    /// Build bottom and top level acceleration structures.
+    ///
+    /// Builds the BLASes then the TLASes, but does ***not*** build the BLASes into the TLASes,
+    /// that must be done by setting a TLAS instance in the TLAS package to one that contains the BLAS (and with an appropriate transform)
+    ///
+    /// # Validation
+    ///
+    /// - blas: Iterator of bottom level acceleration structure entries to build.
+    ///     For each entry, the provided size descriptor must be strictly smaller or equal to the descriptor given at BLAS creation, this means:
+    ///     - Less or equal number of geometries
+    ///     - Same kind of geometry (with index buffer or without) (same vertex/index format)
+    ///     - Same flags
+    ///     - Less or equal number of vertices
+    ///     - Less or equal number of indices (if applicable)
+    /// - tlas: iterator of top level acceleration structure packages to build
+    ///     For each entry:
+    ///     - Each BLAS in each TLAS instance must have been being built in the current call or in a previous call to `build_acceleration_structures` or `build_acceleration_structures_unsafe_tlas`
+    ///     - The number of TLAS instances must be less than or equal to the max number of tlas instances when creating (if creating a package with `TlasPackage::new()` this is already satisfied)
+    ///
+    /// If the device the command encoder is created from does not have [Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE] enabled then a validation error is generated
+    ///
+    /// A bottom level acceleration structure may be build and used as a reference in a top level acceleration structure in the same invocation of this function.
+    ///
+    /// # Bind group usage
+    ///
+    /// When a top level acceleration structure is used in a bind group, some validation takes place:
+    ///    - The top level acceleration structure is valid and has been built.
+    ///    - All the bottom level acceleration structures referenced by the top level acceleration structure are valid and have been built prior,
+    ///      or at same time as the containing top level acceleration structure.
+    ///
+    /// [Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE]: wgt::Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE
+    pub fn build_acceleration_structures<'a>(
+        &mut self,
+        blas: impl IntoIterator<Item = &'a BlasBuildEntry<'a>>,
+        tlas: impl IntoIterator<Item = &'a TlasPackage>,
+    ) {
+        self.inner
+            .build_acceleration_structures(&mut blas.into_iter(), &mut tlas.into_iter());
+    }
+
+    /// Build bottom and top level acceleration structures.
+    /// See [`CommandEncoder::build_acceleration_structures`] for the safe version and more details. All validation in [`CommandEncoder::build_acceleration_structures`] except that
+    /// listed under tlas applies here as well.
+    ///
+    /// # Safety
+    ///
+    ///    - The contents of the raw instance buffer must be valid for the underling api.
+    ///    - All bottom level acceleration structures, referenced in the raw instance buffer must be valid and built,
+    ///       when the corresponding top level acceleration structure is built. (builds may happen in the same invocation of this function).
+    ///    - At the time when the top level acceleration structure is used in a bind group, all associated bottom level acceleration structures must be valid,
+    ///      and built (no later than the time when the top level acceleration structure was built).
+    pub unsafe fn build_acceleration_structures_unsafe_tlas<'a>(
+        &mut self,
+        blas: impl IntoIterator<Item = &'a BlasBuildEntry<'a>>,
+        tlas: impl IntoIterator<Item = &'a TlasBuildEntry<'a>>,
+    ) {
+        self.inner.build_acceleration_structures_unsafe_tlas(
+            &mut blas.into_iter(),
+            &mut tlas.into_iter(),
+        );
+    }
+}

vendor/wgpu/src/api/common_pipeline.rs

@@ -0,0 +1,64 @@
+use std::collections::HashMap;
+
+use crate::*;
+
+#[derive(Clone, Debug)]
+/// Advanced options for use when a pipeline is compiled
+///
+/// This implements `Default`, and for most users can be set to `Default::default()`
+pub struct PipelineCompilationOptions<'a> {
+    /// Specifies the values of pipeline-overridable constants in the shader module.
+    ///
+    /// If an `@id` attribute was specified on the declaration,
+    /// the key must be the pipeline constant ID as a decimal ASCII number; if not,
+    /// the key must be the constant's identifier name.
+    ///
+    /// The value may represent any of WGSL's concrete scalar types.
+    pub constants: &'a HashMap<String, f64>,
+    /// Whether workgroup scoped memory will be initialized with zero values for this stage.
+    ///
+    /// This is required by the WebGPU spec, but may have overhead which can be avoided
+    /// for cross-platform applications
+    pub zero_initialize_workgroup_memory: bool,
+}
+
+impl Default for PipelineCompilationOptions<'_> {
+    fn default() -> Self {
+        // HashMap doesn't have a const constructor, due to the use of RandomState
+        // This does introduce some synchronisation costs, but these should be minor,
+        // and might be cheaper than the alternative of getting new random state
+        static DEFAULT_CONSTANTS: std::sync::OnceLock<HashMap<String, f64>> =
+            std::sync::OnceLock::new();
+        let constants = DEFAULT_CONSTANTS.get_or_init(Default::default);
+        Self {
+            constants,
+            zero_initialize_workgroup_memory: true,
+        }
+    }
+}
+
+/// Describes a pipeline cache, which allows reusing compilation work
+/// between program runs.
+///
+/// For use with [`Device::create_pipeline_cache`]
+///
+/// This type is unique to the Rust API of `wgpu`.
+#[derive(Clone, Debug)]
+pub struct PipelineCacheDescriptor<'a> {
+    /// Debug label of the pipeline cache. This might show up in some logs from `wgpu`
+    pub label: Label<'a>,
+    /// The data used to initialise the cache initialise
+    ///
+    /// # Safety
+    ///
+    /// This data must have been provided from a previous call to
+    /// [`PipelineCache::get_data`], if not `None`
+    pub data: Option<&'a [u8]>,
+    /// Whether to create a cache without data when the provided data
+    /// is invalid.
+    ///
+    /// Recommended to set to true
+    pub fallback: bool,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(PipelineCacheDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/compute_pass.rs

@@ -0,0 +1,178 @@
+use crate::*;
+
+/// In-progress recording of a compute pass.
+///
+/// It can be created with [`CommandEncoder::begin_compute_pass`].
+///
+/// Corresponds to [WebGPU `GPUComputePassEncoder`](
+/// https://gpuweb.github.io/gpuweb/#compute-pass-encoder).
+#[derive(Debug)]
+pub struct ComputePass<'encoder> {
+    pub(crate) inner: dispatch::DispatchComputePass,
+
+    /// This lifetime is used to protect the [`CommandEncoder`] from being used
+    /// while the pass is alive. This needs to be PhantomDrop to prevent the lifetime
+    /// from being shortened.
+    pub(crate) _encoder_guard: crate::api::PhantomDrop<&'encoder ()>,
+}
+
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(ComputePass<'_>: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(ComputePass<'_> => .inner);
+
+impl ComputePass<'_> {
+    /// Drops the lifetime relationship to the parent command encoder, making usage of
+    /// the encoder while this pass is recorded a run-time error instead.
+    ///
+    /// Attention: As long as the compute pass has not been ended, any mutating operation on the parent
+    /// command encoder will cause a run-time error and invalidate it!
+    /// By default, the lifetime constraint prevents this, but it can be useful
+    /// to handle this at run time, such as when storing the pass and encoder in the same
+    /// data structure.
+    ///
+    /// This operation has no effect on pass recording.
+    /// It's a safe operation, since [`CommandEncoder`] is in a locked state as long as the pass is active
+    /// regardless of the lifetime constraint or its absence.
+    pub fn forget_lifetime(self) -> ComputePass<'static> {
+        ComputePass {
+            inner: self.inner,
+            _encoder_guard: crate::api::PhantomDrop::default(),
+        }
+    }
+
+    /// Sets the active bind group for a given bind group index. The bind group layout
+    /// in the active pipeline when the `dispatch()` function is called must match the layout of this bind group.
+    ///
+    /// If the bind group have dynamic offsets, provide them in the binding order.
+    /// These offsets have to be aligned to [`Limits::min_uniform_buffer_offset_alignment`]
+    /// or [`Limits::min_storage_buffer_offset_alignment`] appropriately.
+    pub fn set_bind_group<'a, BG>(&mut self, index: u32, bind_group: BG, offsets: &[DynamicOffset])
+    where
+        Option<&'a BindGroup>: From<BG>,
+    {
+        let bg: Option<&BindGroup> = bind_group.into();
+        let bg = bg.map(|bg| &bg.inner);
+        self.inner.set_bind_group(index, bg, offsets);
+    }
+
+    /// Sets the active compute pipeline.
+    pub fn set_pipeline(&mut self, pipeline: &ComputePipeline) {
+        self.inner.set_pipeline(&pipeline.inner);
+    }
+
+    /// Inserts debug marker.
+    pub fn insert_debug_marker(&mut self, label: &str) {
+        self.inner.insert_debug_marker(label);
+    }
+
+    /// Start record commands and group it into debug marker group.
+    pub fn push_debug_group(&mut self, label: &str) {
+        self.inner.push_debug_group(label);
+    }
+
+    /// Stops command recording and creates debug group.
+    pub fn pop_debug_group(&mut self) {
+        self.inner.pop_debug_group();
+    }
+
+    /// Dispatches compute work operations.
+    ///
+    /// `x`, `y` and `z` denote the number of work groups to dispatch in each dimension.
+    pub fn dispatch_workgroups(&mut self, x: u32, y: u32, z: u32) {
+        self.inner.dispatch_workgroups(x, y, z);
+    }
+
+    /// Dispatches compute work operations, based on the contents of the `indirect_buffer`.
+    ///
+    /// The structure expected in `indirect_buffer` must conform to [`DispatchIndirectArgs`](crate::util::DispatchIndirectArgs).
+    pub fn dispatch_workgroups_indirect(
+        &mut self,
+        indirect_buffer: &Buffer,
+        indirect_offset: BufferAddress,
+    ) {
+        self.inner
+            .dispatch_workgroups_indirect(&indirect_buffer.inner, indirect_offset);
+    }
+}
+
+/// [`Features::PUSH_CONSTANTS`] must be enabled on the device in order to call these functions.
+impl ComputePass<'_> {
+    /// Set push constant data for subsequent dispatch calls.
+    ///
+    /// Write the bytes in `data` at offset `offset` within push constant
+    /// storage.  Both `offset` and the length of `data` must be
+    /// multiples of [`PUSH_CONSTANT_ALIGNMENT`], which is always 4.
+    ///
+    /// For example, if `offset` is `4` and `data` is eight bytes long, this
+    /// call will write `data` to bytes `4..12` of push constant storage.
+    pub fn set_push_constants(&mut self, offset: u32, data: &[u8]) {
+        self.inner.set_push_constants(offset, data);
+    }
+}
+
+/// [`Features::TIMESTAMP_QUERY_INSIDE_PASSES`] must be enabled on the device in order to call these functions.
+impl ComputePass<'_> {
+    /// Issue a timestamp command at this point in the queue. The timestamp will be written to the specified query set, at the specified index.
+    ///
+    /// Must be multiplied by [`Queue::get_timestamp_period`] to get
+    /// the value in nanoseconds. Absolute values have no meaning,
+    /// but timestamps can be subtracted to get the time it takes
+    /// for a string of operations to complete.
+    pub fn write_timestamp(&mut self, query_set: &QuerySet, query_index: u32) {
+        self.inner.write_timestamp(&query_set.inner, query_index);
+    }
+}
+
+/// [`Features::PIPELINE_STATISTICS_QUERY`] must be enabled on the device in order to call these functions.
+impl ComputePass<'_> {
+    /// Start a pipeline statistics query on this compute pass. It can be ended with
+    /// `end_pipeline_statistics_query`. Pipeline statistics queries may not be nested.
+    pub fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, query_index: u32) {
+        self.inner
+            .begin_pipeline_statistics_query(&query_set.inner, query_index);
+    }
+
+    /// End the pipeline statistics query on this compute pass. It can be started with
+    /// `begin_pipeline_statistics_query`. Pipeline statistics queries may not be nested.
+    pub fn end_pipeline_statistics_query(&mut self) {
+        self.inner.end_pipeline_statistics_query();
+    }
+}
+
+/// Describes the timestamp writes of a compute pass.
+///
+/// For use with [`ComputePassDescriptor`].
+/// At least one of `beginning_of_pass_write_index` and `end_of_pass_write_index` must be `Some`.
+///
+/// Corresponds to [WebGPU `GPUComputePassTimestampWrites`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpucomputepasstimestampwrites).
+#[derive(Clone, Debug)]
+pub struct ComputePassTimestampWrites<'a> {
+    /// The query set to write to.
+    pub query_set: &'a QuerySet,
+    /// The index of the query set at which a start timestamp of this pass is written, if any.
+    pub beginning_of_pass_write_index: Option<u32>,
+    /// The index of the query set at which an end timestamp of this pass is written, if any.
+    pub end_of_pass_write_index: Option<u32>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(ComputePassTimestampWrites<'_>: Send, Sync);
+
+/// Describes the attachments of a compute pass.
+///
+/// For use with [`CommandEncoder::begin_compute_pass`].
+///
+/// Corresponds to [WebGPU `GPUComputePassDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpucomputepassdescriptor).
+#[derive(Clone, Default, Debug)]
+pub struct ComputePassDescriptor<'a> {
+    /// Debug label of the compute pass. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// Defines which timestamp values will be written for this pass, and where to write them to.
+    ///
+    /// Requires [`Features::TIMESTAMP_QUERY`] to be enabled.
+    pub timestamp_writes: Option<ComputePassTimestampWrites<'a>>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(ComputePassDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/compute_pipeline.rs

@@ -0,0 +1,81 @@
+use crate::*;
+
+/// Handle to a compute pipeline.
+///
+/// A `ComputePipeline` object represents a compute pipeline and its single shader stage.
+/// It can be created with [`Device::create_compute_pipeline`].
+///
+/// Corresponds to [WebGPU `GPUComputePipeline`](https://gpuweb.github.io/gpuweb/#compute-pipeline).
+#[derive(Debug, Clone)]
+pub struct ComputePipeline {
+    pub(crate) inner: dispatch::DispatchComputePipeline,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(ComputePipeline: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(ComputePipeline => .inner);
+
+impl ComputePipeline {
+    /// Get an object representing the bind group layout at a given index.
+    ///
+    /// If this pipeline was created with a [default layout][ComputePipelineDescriptor::layout],
+    /// then bind groups created with the returned `BindGroupLayout` can only be used with this
+    /// pipeline.
+    ///
+    /// This method will raise a validation error if there is no bind group layout at `index`.
+    pub fn get_bind_group_layout(&self, index: u32) -> BindGroupLayout {
+        let bind_group = self.inner.get_bind_group_layout(index);
+        BindGroupLayout { inner: bind_group }
+    }
+}
+
+/// Describes a compute pipeline.
+///
+/// For use with [`Device::create_compute_pipeline`].
+///
+/// Corresponds to [WebGPU `GPUComputePipelineDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpucomputepipelinedescriptor).
+#[derive(Clone, Debug)]
+pub struct ComputePipelineDescriptor<'a> {
+    /// Debug label of the pipeline. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// The layout of bind groups for this pipeline.
+    ///
+    /// If this is set, then [`Device::create_compute_pipeline`] will raise a validation error if
+    /// the layout doesn't match what the shader module(s) expect.
+    ///
+    /// Using the same [`PipelineLayout`] for many [`RenderPipeline`] or [`ComputePipeline`]
+    /// pipelines guarantees that you don't have to rebind any resources when switching between
+    /// those pipelines.
+    ///
+    /// ## Default pipeline layout
+    ///
+    /// If `layout` is `None`, then the pipeline has a [default layout] created and used instead.
+    /// The default layout is deduced from the shader modules.
+    ///
+    /// You can use [`ComputePipeline::get_bind_group_layout`] to create bind groups for use with
+    /// the default layout. However, these bind groups cannot be used with any other pipelines. This
+    /// is convenient for simple pipelines, but using an explicit layout is recommended in most
+    /// cases.
+    ///
+    /// [default layout]: https://www.w3.org/TR/webgpu/#default-pipeline-layout
+    pub layout: Option<&'a PipelineLayout>,
+    /// The compiled shader module for this stage.
+    pub module: &'a ShaderModule,
+    /// The name of the entry point in the compiled shader to use.
+    ///
+    /// If [`Some`], there must be a compute shader entry point with this name in `module`.
+    /// Otherwise, expect exactly one compute shader entry point in `module`, which will be
+    /// selected.
+    // NOTE: keep phrasing in sync. with `FragmentState::entry_point`
+    // NOTE: keep phrasing in sync. with `VertexState::entry_point`
+    pub entry_point: Option<&'a str>,
+    /// Advanced options for when this pipeline is compiled
+    ///
+    /// This implements `Default`, and for most users can be set to `Default::default()`
+    pub compilation_options: PipelineCompilationOptions<'a>,
+    /// The pipeline cache to use when creating this pipeline.
+    pub cache: Option<&'a PipelineCache>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(ComputePipelineDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/device.rs

@@ -0,0 +1,657 @@
+use std::{error, fmt, future::Future, sync::Arc};
+
+use parking_lot::Mutex;
+
+use crate::api::blas::{Blas, BlasGeometrySizeDescriptors, CreateBlasDescriptor};
+use crate::api::tlas::{CreateTlasDescriptor, Tlas};
+use crate::*;
+
+/// Open connection to a graphics and/or compute device.
+///
+/// Responsible for the creation of most rendering and compute resources.
+/// These are then used in commands, which are submitted to a [`Queue`].
+///
+/// A device may be requested from an adapter with [`Adapter::request_device`].
+///
+/// Corresponds to [WebGPU `GPUDevice`](https://gpuweb.github.io/gpuweb/#gpu-device).
+#[derive(Debug, Clone)]
+pub struct Device {
+    pub(crate) inner: dispatch::DispatchDevice,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(Device: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(Device => .inner);
+
+/// Describes a [`Device`].
+///
+/// For use with [`Adapter::request_device`].
+///
+/// Corresponds to [WebGPU `GPUDeviceDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpudevicedescriptor).
+pub type DeviceDescriptor<'a> = wgt::DeviceDescriptor<Label<'a>>;
+static_assertions::assert_impl_all!(DeviceDescriptor<'_>: Send, Sync);
+
+impl Device {
+    /// Check for resource cleanups and mapping callbacks. Will block if [`Maintain::Wait`] is passed.
+    ///
+    /// Return `true` if the queue is empty, or `false` if there are more queue
+    /// submissions still in flight. (Note that, unless access to the [`Queue`] is
+    /// coordinated somehow, this information could be out of date by the time
+    /// the caller receives it. `Queue`s can be shared between threads, so
+    /// other threads could submit new work at any time.)
+    ///
+    /// When running on WebGPU, this is a no-op. `Device`s are automatically polled.
+    pub fn poll(&self, maintain: Maintain) -> MaintainResult {
+        self.inner.poll(maintain)
+    }
+
+    /// The features which can be used on this device.
+    ///
+    /// No additional features can be used, even if the underlying adapter can support them.
+    #[must_use]
+    pub fn features(&self) -> Features {
+        self.inner.features()
+    }
+
+    /// The limits which can be used on this device.
+    ///
+    /// No better limits can be used, even if the underlying adapter can support them.
+    #[must_use]
+    pub fn limits(&self) -> Limits {
+        self.inner.limits()
+    }
+
+    /// Creates a shader module.
+    ///
+    /// <div class="warning">
+    // NOTE: Keep this in sync with `naga::front::wgsl::parse_str`!
+    // NOTE: Keep this in sync with `wgpu_core::Global::device_create_shader_module`!
+    ///
+    /// This function may consume a lot of stack space. Compiler-enforced limits for parsing
+    /// recursion exist; if shader compilation runs into them, it will return an error gracefully.
+    /// However, on some build profiles and platforms, the default stack size for a thread may be
+    /// exceeded before this limit is reached during parsing. Callers should ensure that there is
+    /// enough stack space for this, particularly if calls to this method are exposed to user
+    /// input.
+    ///
+    /// </div>
+    #[must_use]
+    pub fn create_shader_module(&self, desc: ShaderModuleDescriptor<'_>) -> ShaderModule {
+        let module = self
+            .inner
+            .create_shader_module(desc, wgt::ShaderRuntimeChecks::checked());
+        ShaderModule { inner: module }
+    }
+
+    /// Deprecated: Use [`create_shader_module_trusted`][csmt] instead.
+    ///
+    /// # Safety
+    ///
+    /// See [`create_shader_module_trusted`][csmt].
+    ///
+    /// [csmt]: Self::create_shader_module_trusted
+    #[deprecated(
+        since = "24.0.0",
+        note = "Use `Device::create_shader_module_trusted(desc, wgpu::ShaderRuntimeChecks::unchecked())` instead."
+    )]
+    #[must_use]
+    pub unsafe fn create_shader_module_unchecked(
+        &self,
+        desc: ShaderModuleDescriptor<'_>,
+    ) -> ShaderModule {
+        unsafe { self.create_shader_module_trusted(desc, crate::ShaderRuntimeChecks::unchecked()) }
+    }
+
+    /// Creates a shader module with flags to dictate runtime checks.
+    ///
+    /// When running on WebGPU, this will merely call [`create_shader_module`][csm].
+    ///
+    /// # Safety
+    ///
+    /// In contrast with [`create_shader_module`][csm] this function
+    /// creates a shader module with user-customizable runtime checks which allows shaders to
+    /// perform operations which can lead to undefined behavior like indexing out of bounds,
+    /// thus it's the caller responsibility to pass a shader which doesn't perform any of this
+    /// operations.
+    ///
+    /// See the documentation for [`ShaderRuntimeChecks`][src] for more information about specific checks.
+    ///
+    /// [csm]: Self::create_shader_module
+    /// [src]: crate::ShaderRuntimeChecks
+    #[must_use]
+    pub unsafe fn create_shader_module_trusted(
+        &self,
+        desc: ShaderModuleDescriptor<'_>,
+        runtime_checks: crate::ShaderRuntimeChecks,
+    ) -> ShaderModule {
+        let module = self.inner.create_shader_module(desc, runtime_checks);
+        ShaderModule { inner: module }
+    }
+
+    /// Creates a shader module from SPIR-V binary directly.
+    ///
+    /// # Safety
+    ///
+    /// This function passes binary data to the backend as-is and can potentially result in a
+    /// driver crash or bogus behaviour. No attempt is made to ensure that data is valid SPIR-V.
+    ///
+    /// See also [`include_spirv_raw!`] and [`util::make_spirv_raw`].
+    #[must_use]
+    pub unsafe fn create_shader_module_spirv(
+        &self,
+        desc: &ShaderModuleDescriptorSpirV<'_>,
+    ) -> ShaderModule {
+        let module = unsafe { self.inner.create_shader_module_spirv(desc) };
+        ShaderModule { inner: module }
+    }
+
+    /// Creates an empty [`CommandEncoder`].
+    #[must_use]
+    pub fn create_command_encoder(&self, desc: &CommandEncoderDescriptor<'_>) -> CommandEncoder {
+        let encoder = self.inner.create_command_encoder(desc);
+        CommandEncoder { inner: encoder }
+    }
+
+    /// Creates an empty [`RenderBundleEncoder`].
+    #[must_use]
+    pub fn create_render_bundle_encoder<'a>(
+        &self,
+        desc: &RenderBundleEncoderDescriptor<'_>,
+    ) -> RenderBundleEncoder<'a> {
+        let encoder = self.inner.create_render_bundle_encoder(desc);
+        RenderBundleEncoder {
+            inner: encoder,
+            _p: std::marker::PhantomData,
+        }
+    }
+
+    /// Creates a new [`BindGroup`].
+    #[must_use]
+    pub fn create_bind_group(&self, desc: &BindGroupDescriptor<'_>) -> BindGroup {
+        let group = self.inner.create_bind_group(desc);
+        BindGroup { inner: group }
+    }
+
+    /// Creates a [`BindGroupLayout`].
+    #[must_use]
+    pub fn create_bind_group_layout(
+        &self,
+        desc: &BindGroupLayoutDescriptor<'_>,
+    ) -> BindGroupLayout {
+        let layout = self.inner.create_bind_group_layout(desc);
+        BindGroupLayout { inner: layout }
+    }
+
+    /// Creates a [`PipelineLayout`].
+    #[must_use]
+    pub fn create_pipeline_layout(&self, desc: &PipelineLayoutDescriptor<'_>) -> PipelineLayout {
+        let layout = self.inner.create_pipeline_layout(desc);
+        PipelineLayout { inner: layout }
+    }
+
+    /// Creates a [`RenderPipeline`].
+    #[must_use]
+    pub fn create_render_pipeline(&self, desc: &RenderPipelineDescriptor<'_>) -> RenderPipeline {
+        let pipeline = self.inner.create_render_pipeline(desc);
+        RenderPipeline { inner: pipeline }
+    }
+
+    /// Creates a [`ComputePipeline`].
+    #[must_use]
+    pub fn create_compute_pipeline(&self, desc: &ComputePipelineDescriptor<'_>) -> ComputePipeline {
+        let pipeline = self.inner.create_compute_pipeline(desc);
+        ComputePipeline { inner: pipeline }
+    }
+
+    /// Creates a [`Buffer`].
+    #[must_use]
+    pub fn create_buffer(&self, desc: &BufferDescriptor<'_>) -> Buffer {
+        let mut map_context = MapContext::new(desc.size);
+        if desc.mapped_at_creation {
+            map_context.initial_range = 0..desc.size;
+        }
+
+        let buffer = self.inner.create_buffer(desc);
+
+        Buffer {
+            inner: buffer,
+            map_context: Arc::new(Mutex::new(map_context)),
+            size: desc.size,
+            usage: desc.usage,
+        }
+    }
+
+    /// Creates a new [`Texture`].
+    ///
+    /// `desc` specifies the general format of the texture.
+    #[must_use]
+    pub fn create_texture(&self, desc: &TextureDescriptor<'_>) -> Texture {
+        let texture = self.inner.create_texture(desc);
+
+        Texture {
+            inner: texture,
+            descriptor: TextureDescriptor {
+                label: None,
+                view_formats: &[],
+                ..desc.clone()
+            },
+        }
+    }
+
+    /// Creates a [`Texture`] from a wgpu-hal Texture.
+    ///
+    /// # Safety
+    ///
+    /// - `hal_texture` must be created from this device internal handle
+    /// - `hal_texture` must be created respecting `desc`
+    /// - `hal_texture` must be initialized
+    #[cfg(wgpu_core)]
+    #[must_use]
+    pub unsafe fn create_texture_from_hal<A: wgc::hal_api::HalApi>(
+        &self,
+        hal_texture: A::Texture,
+        desc: &TextureDescriptor<'_>,
+    ) -> Texture {
+        let texture = unsafe {
+            let core_device = self.inner.as_core();
+            core_device
+                .context
+                .create_texture_from_hal::<A>(hal_texture, core_device, desc)
+        };
+        Texture {
+            inner: texture.into(),
+            descriptor: TextureDescriptor {
+                label: None,
+                view_formats: &[],
+                ..desc.clone()
+            },
+        }
+    }
+
+    /// Creates a [`Buffer`] from a wgpu-hal Buffer.
+    ///
+    /// # Safety
+    ///
+    /// - `hal_buffer` must be created from this device internal handle
+    /// - `hal_buffer` must be created respecting `desc`
+    /// - `hal_buffer` must be initialized
+    #[cfg(wgpu_core)]
+    #[must_use]
+    pub unsafe fn create_buffer_from_hal<A: wgc::hal_api::HalApi>(
+        &self,
+        hal_buffer: A::Buffer,
+        desc: &BufferDescriptor<'_>,
+    ) -> Buffer {
+        let mut map_context = MapContext::new(desc.size);
+        if desc.mapped_at_creation {
+            map_context.initial_range = 0..desc.size;
+        }
+
+        let buffer = unsafe {
+            let core_device = self.inner.as_core();
+            core_device
+                .context
+                .create_buffer_from_hal::<A>(hal_buffer, core_device, desc)
+        };
+
+        Buffer {
+            inner: buffer.into(),
+            map_context: Arc::new(Mutex::new(map_context)),
+            size: desc.size,
+            usage: desc.usage,
+        }
+    }
+
+    /// Creates a new [`Sampler`].
+    ///
+    /// `desc` specifies the behavior of the sampler.
+    #[must_use]
+    pub fn create_sampler(&self, desc: &SamplerDescriptor<'_>) -> Sampler {
+        let sampler = self.inner.create_sampler(desc);
+        Sampler { inner: sampler }
+    }
+
+    /// Creates a new [`QuerySet`].
+    #[must_use]
+    pub fn create_query_set(&self, desc: &QuerySetDescriptor<'_>) -> QuerySet {
+        let query_set = self.inner.create_query_set(desc);
+        QuerySet { inner: query_set }
+    }
+
+    /// Set a callback for errors that are not handled in error scopes.
+    pub fn on_uncaptured_error(&self, handler: Box<dyn UncapturedErrorHandler>) {
+        self.inner.on_uncaptured_error(handler)
+    }
+
+    /// Push an error scope.
+    pub fn push_error_scope(&self, filter: ErrorFilter) {
+        self.inner.push_error_scope(filter)
+    }
+
+    /// Pop an error scope.
+    pub fn pop_error_scope(&self) -> impl Future<Output = Option<Error>> + WasmNotSend {
+        self.inner.pop_error_scope()
+    }
+
+    /// Starts frame capture.
+    pub fn start_capture(&self) {
+        self.inner.start_capture()
+    }
+
+    /// Stops frame capture.
+    pub fn stop_capture(&self) {
+        self.inner.stop_capture()
+    }
+
+    /// Query internal counters from the native backend for debugging purposes.
+    ///
+    /// Some backends may not set all counters, or may not set any counter at all.
+    /// The `counters` cargo feature must be enabled for any counter to be set.
+    ///
+    /// If a counter is not set, its contains its default value (zero).
+    #[must_use]
+    pub fn get_internal_counters(&self) -> wgt::InternalCounters {
+        self.inner.get_internal_counters()
+    }
+
+    /// Generate an GPU memory allocation report if the underlying backend supports it.
+    ///
+    /// Backends that do not support producing these reports return `None`. A backend may
+    /// Support it and still return `None` if it is not using performing sub-allocation,
+    /// for example as a workaround for driver issues.
+    #[must_use]
+    pub fn generate_allocator_report(&self) -> Option<wgt::AllocatorReport> {
+        self.inner.generate_allocator_report()
+    }
+
+    /// Apply a callback to this `Device`'s underlying backend device.
+    ///
+    /// If this `Device` is implemented by the backend API given by `A` (Vulkan,
+    /// Dx12, etc.), then apply `hal_device_callback` to `Some(&device)`, where
+    /// `device` is the underlying backend device type, [`A::Device`].
+    ///
+    /// If this `Device` uses a different backend, apply `hal_device_callback`
+    /// to `None`.
+    ///
+    /// The device is locked for reading while `hal_device_callback` runs. If
+    /// the callback attempts to perform any `wgpu` operations that require
+    /// write access to the device (destroying a buffer, say), deadlock will
+    /// occur. The locks are automatically released when the callback returns.
+    ///
+    /// # Safety
+    ///
+    /// - The raw handle passed to the callback must not be manually destroyed.
+    ///
+    /// [`A::Device`]: hal::Api::Device
+    #[cfg(wgpu_core)]
+    pub unsafe fn as_hal<A: wgc::hal_api::HalApi, F: FnOnce(Option<&A::Device>) -> R, R>(
+        &self,
+        hal_device_callback: F,
+    ) -> R {
+        if let Some(core_device) = self.inner.as_core_opt() {
+            unsafe {
+                core_device
+                    .context
+                    .device_as_hal::<A, F, R>(core_device, hal_device_callback)
+            }
+        } else {
+            hal_device_callback(None)
+        }
+    }
+
+    /// Destroy this device.
+    pub fn destroy(&self) {
+        self.inner.destroy()
+    }
+
+    /// Set a DeviceLostCallback on this device.
+    pub fn set_device_lost_callback(
+        &self,
+        callback: impl Fn(DeviceLostReason, String) + Send + 'static,
+    ) {
+        self.inner.set_device_lost_callback(Box::new(callback))
+    }
+
+    /// Create a [`PipelineCache`] with initial data
+    ///
+    /// This can be passed to [`Device::create_compute_pipeline`]
+    /// and [`Device::create_render_pipeline`] to either accelerate these
+    /// or add the cache results from those.
+    ///
+    /// # Safety
+    ///
+    /// If the `data` field of `desc` is set, it must have previously been returned from a call
+    /// to [`PipelineCache::get_data`][^saving]. This `data` will only be used if it came
+    /// from an adapter with the same [`util::pipeline_cache_key`].
+    /// This *is* compatible across wgpu versions, as any data format change will
+    /// be accounted for.
+    ///
+    /// It is *not* supported to bring caches from previous direct uses of backend APIs
+    /// into this method.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error value if:
+    ///  * the [`PIPELINE_CACHE`](wgt::Features::PIPELINE_CACHE) feature is not enabled
+    ///  * this device is invalid; or
+    ///  * the device is out of memory
+    ///
+    /// This method also returns an error value if:
+    ///  * The `fallback` field on `desc` is false; and
+    ///  * the `data` provided would not be used[^data_not_used]
+    ///
+    /// If an error value is used in subsequent calls, default caching will be used.
+    ///
+    /// [^saving]: We do recognise that saving this data to disk means this condition
+    /// is impossible to fully prove. Consider the risks for your own application in this case.
+    ///
+    /// [^data_not_used]: This data may be not used if: the data was produced by a prior
+    /// version of wgpu; or was created for an incompatible adapter, or there was a GPU driver
+    /// update. In some cases, the data might not be used and a real value is returned,
+    /// this is left to the discretion of GPU drivers.
+    #[must_use]
+    pub unsafe fn create_pipeline_cache(
+        &self,
+        desc: &PipelineCacheDescriptor<'_>,
+    ) -> PipelineCache {
+        let cache = unsafe { self.inner.create_pipeline_cache(desc) };
+        PipelineCache { inner: cache }
+    }
+}
+
+/// [`Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE`] must be enabled on the device in order to call these functions.
+impl Device {
+    /// Create a bottom level acceleration structure, used inside a top level acceleration structure for ray tracing.
+    /// - `desc`: The descriptor of the acceleration structure.
+    /// - `sizes`: Size descriptor limiting what can be built into the acceleration structure.
+    ///
+    /// # Validation
+    /// If any of the following is not satisfied a validation error is generated
+    ///
+    /// The device ***must*** have [Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE] enabled.
+    /// if `sizes` is [BlasGeometrySizeDescriptors::Triangles] then the following must be satisfied
+    /// - For every geometry descriptor (for the purposes this is called `geo_desc`) of `sizes.descriptors` the following must be satisfied:
+    ///     - `geo_desc.vertex_format` must be within allowed formats (allowed formats for a given feature set
+    ///       may be queried with [Features::allowed_vertex_formats_for_blas]).
+    ///     - Both or neither of `geo_desc.index_format` and `geo_desc.index_count` must be provided.
+    ///
+    /// [Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE]: wgt::Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE
+    /// [Features::allowed_vertex_formats_for_blas]: wgt::Features::allowed_vertex_formats_for_blas
+    #[must_use]
+    pub fn create_blas(
+        &self,
+        desc: &CreateBlasDescriptor<'_>,
+        sizes: BlasGeometrySizeDescriptors,
+    ) -> Blas {
+        let (handle, blas) = self.inner.create_blas(desc, sizes);
+
+        Blas {
+            inner: blas,
+            handle,
+        }
+    }
+
+    /// Create a top level acceleration structure, used for ray tracing.
+    /// - `desc`: The descriptor of the acceleration structure.
+    ///
+    /// # Validation
+    /// If any of the following is not satisfied a validation error is generated
+    ///
+    /// The device ***must*** have [Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE] enabled.
+    ///
+    /// [Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE]: wgt::Features::EXPERIMENTAL_RAY_TRACING_ACCELERATION_STRUCTURE
+    #[must_use]
+    pub fn create_tlas(&self, desc: &CreateTlasDescriptor<'_>) -> Tlas {
+        let tlas = self.inner.create_tlas(desc);
+
+        Tlas {
+            shared: Arc::new(TlasShared {
+                inner: tlas,
+                max_instances: desc.max_instances,
+            }),
+        }
+    }
+}
+
+/// Requesting a device from an [`Adapter`] failed.
+#[derive(Clone, Debug)]
+pub struct RequestDeviceError {
+    pub(crate) inner: RequestDeviceErrorKind,
+}
+#[derive(Clone, Debug)]
+pub(crate) enum RequestDeviceErrorKind {
+    /// Error from [`wgpu_core`].
+    // must match dependency cfg
+    #[cfg(wgpu_core)]
+    Core(wgc::instance::RequestDeviceError),
+
+    /// Error from web API that was called by `wgpu` to request a device.
+    ///
+    /// (This is currently never used by the webgl backend, but it could be.)
+    #[cfg(webgpu)]
+    WebGpu(wasm_bindgen::JsValue),
+}
+
+#[cfg(send_sync)]
+unsafe impl Send for RequestDeviceErrorKind {}
+#[cfg(send_sync)]
+unsafe impl Sync for RequestDeviceErrorKind {}
+
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(RequestDeviceError: Send, Sync);
+
+impl fmt::Display for RequestDeviceError {
+    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.inner {
+            #[cfg(wgpu_core)]
+            RequestDeviceErrorKind::Core(error) => error.fmt(_f),
+            #[cfg(webgpu)]
+            RequestDeviceErrorKind::WebGpu(error_js_value) => {
+                // wasm-bindgen provides a reasonable error stringification via `Debug` impl
+                write!(_f, "{error_js_value:?}")
+            }
+            #[cfg(not(any(webgpu, wgpu_core)))]
+            _ => unimplemented!("unknown `RequestDeviceErrorKind`"),
+        }
+    }
+}
+
+impl error::Error for RequestDeviceError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match &self.inner {
+            #[cfg(wgpu_core)]
+            RequestDeviceErrorKind::Core(error) => error.source(),
+            #[cfg(webgpu)]
+            RequestDeviceErrorKind::WebGpu(_) => None,
+            #[cfg(not(any(webgpu, wgpu_core)))]
+            _ => unimplemented!("unknown `RequestDeviceErrorKind`"),
+        }
+    }
+}
+
+#[cfg(wgpu_core)]
+impl From<wgc::instance::RequestDeviceError> for RequestDeviceError {
+    fn from(error: wgc::instance::RequestDeviceError) -> Self {
+        Self {
+            inner: RequestDeviceErrorKind::Core(error),
+        }
+    }
+}
+
+/// Type for the callback of uncaptured error handler
+pub trait UncapturedErrorHandler: Fn(Error) + Send + 'static {}
+impl<T> UncapturedErrorHandler for T where T: Fn(Error) + Send + 'static {}
+
+/// Filter for error scopes.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd)]
+pub enum ErrorFilter {
+    /// Catch only out-of-memory errors.
+    OutOfMemory,
+    /// Catch only validation errors.
+    Validation,
+    /// Catch only internal errors.
+    Internal,
+}
+static_assertions::assert_impl_all!(ErrorFilter: Send, Sync);
+
+/// Lower level source of the error.
+///
+/// `Send + Sync` varies depending on configuration.
+#[cfg(send_sync)]
+#[cfg_attr(docsrs, doc(cfg(all())))]
+pub type ErrorSource = Box<dyn error::Error + Send + Sync + 'static>;
+/// Lower level source of the error.
+///
+/// `Send + Sync` varies depending on configuration.
+#[cfg(not(send_sync))]
+#[cfg_attr(docsrs, doc(cfg(all())))]
+pub type ErrorSource = Box<dyn error::Error + 'static>;
+
+/// Error type
+#[derive(Debug)]
+pub enum Error {
+    /// Out of memory error
+    OutOfMemory {
+        /// Lower level source of the error.
+        source: ErrorSource,
+    },
+    /// Validation error, signifying a bug in code or data
+    Validation {
+        /// Lower level source of the error.
+        source: ErrorSource,
+        /// Description of the validation error.
+        description: String,
+    },
+    /// Internal error. Used for signalling any failures not explicitly expected by WebGPU.
+    ///
+    /// These could be due to internal implementation or system limits being reached.
+    Internal {
+        /// Lower level source of the error.
+        source: ErrorSource,
+        /// Description of the internal GPU error.
+        description: String,
+    },
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(Error: Send, Sync);
+
+impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self {
+            Error::OutOfMemory { source } => Some(source.as_ref()),
+            Error::Validation { source, .. } => Some(source.as_ref()),
+            Error::Internal { source, .. } => Some(source.as_ref()),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::OutOfMemory { .. } => f.write_str("Out of Memory"),
+            Error::Validation { description, .. } => f.write_str(description),
+            Error::Internal { description, .. } => f.write_str(description),
+        }
+    }
+}

vendor/wgpu/src/api/instance.rs

@@ -0,0 +1,411 @@
+use parking_lot::Mutex;
+
+use crate::{dispatch::InstanceInterface, *};
+
+use std::future::Future;
+
+bitflags::bitflags! {
+    /// WGSL language extensions.
+    ///
+    /// WGSL spec.: <https://www.w3.org/TR/WGSL/#language-extensions-sec>
+    #[derive(Debug, Clone, PartialEq, PartialOrd, Ord, Eq, Hash)]
+    pub struct WgslLanguageFeatures: u32 {
+        /// <https://www.w3.org/TR/WGSL/#language_extension-readonly_and_readwrite_storage_textures>
+        const ReadOnlyAndReadWriteStorageTextures = 1 << 0;
+        /// <https://www.w3.org/TR/WGSL/#language_extension-packed_4x8_integer_dot_product>
+        const Packed4x8IntegerDotProduct = 1 << 1;
+        /// <https://www.w3.org/TR/WGSL/#language_extension-unrestricted_pointer_parameters>
+        const UnrestrictedPointerParameters = 1 << 2;
+        /// <https://www.w3.org/TR/WGSL/#language_extension-pointer_composite_access>
+        const PointerCompositeAccess = 1 << 3;
+    }
+}
+
+/// Context for all other wgpu objects. Instance of wgpu.
+///
+/// This is the first thing you create when using wgpu.
+/// Its primary use is to create [`Adapter`]s and [`Surface`]s.
+///
+/// Does not have to be kept alive.
+///
+/// Corresponds to [WebGPU `GPU`](https://gpuweb.github.io/gpuweb/#gpu-interface).
+#[derive(Debug, Clone)]
+pub struct Instance {
+    inner: dispatch::DispatchInstance,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(Instance: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(Instance => .inner);
+
+impl Default for Instance {
+    /// Creates a new instance of wgpu with default options.
+    ///
+    /// Backends are set to `Backends::all()`, and FXC is chosen as the `dx12_shader_compiler`.
+    ///
+    /// # Panics
+    ///
+    /// If no backend feature for the active target platform is enabled,
+    /// this method will panic, see [`Instance::enabled_backend_features()`].
+    fn default() -> Self {
+        Self::new(&InstanceDescriptor::default())
+    }
+}
+
+impl Instance {
+    /// Returns which backends can be picked for the current build configuration.
+    ///
+    /// The returned set depends on a combination of target platform and enabled features.
+    /// This does *not* do any runtime checks and is exclusively based on compile time information.
+    ///
+    /// `InstanceDescriptor::backends` does not need to be a subset of this,
+    /// but any backend that is not in this set, will not be picked.
+    ///
+    /// TODO: Right now it's otherwise not possible yet to opt-out of all features on some platforms.
+    /// See <https://github.com/gfx-rs/wgpu/issues/3514>
+    /// * Windows/Linux/Android: always enables Vulkan and GLES with no way to opt out
+    pub const fn enabled_backend_features() -> Backends {
+        let mut backends = Backends::empty();
+
+        if cfg!(native) {
+            if cfg!(metal) {
+                backends = backends.union(Backends::METAL);
+            }
+            if cfg!(dx12) {
+                backends = backends.union(Backends::DX12);
+            }
+
+            // Windows, Android, Linux currently always enable Vulkan and OpenGL.
+            // See <https://github.com/gfx-rs/wgpu/issues/3514>
+            if cfg!(target_os = "windows") || cfg!(unix) {
+                backends = backends.union(Backends::VULKAN).union(Backends::GL);
+            }
+
+            // Vulkan on Mac/iOS is only available through vulkan-portability.
+            if cfg!(target_vendor = "apple") && cfg!(feature = "vulkan-portability") {
+                backends = backends.union(Backends::VULKAN);
+            }
+
+            // GL on Mac is only available through angle.
+            if cfg!(target_os = "macos") && cfg!(feature = "angle") {
+                backends = backends.union(Backends::GL);
+            }
+        } else {
+            if cfg!(webgpu) {
+                backends = backends.union(Backends::BROWSER_WEBGPU);
+            }
+            if cfg!(webgl) {
+                backends = backends.union(Backends::GL);
+            }
+        }
+
+        backends
+    }
+
+    /// Create an new instance of wgpu.
+    ///
+    /// # Arguments
+    ///
+    /// - `instance_desc` - Has fields for which [backends][Backends] wgpu will choose
+    ///   during instantiation, and which [DX12 shader compiler][Dx12Compiler] wgpu will use.
+    ///
+    ///   [`Backends::BROWSER_WEBGPU`] takes a special role:
+    ///   If it is set and a [`navigator.gpu`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/gpu)
+    ///   object is present, this instance will *only* be able to create WebGPU adapters.
+    ///
+    ///   ⚠️ On some browsers this check is insufficient to determine whether WebGPU is supported,
+    ///   as the browser may define the `navigator.gpu` object, but be unable to create any WebGPU adapters.
+    ///   For targeting _both_ WebGPU & WebGL is recommended to use [`crate::util::new_instance_with_webgpu_detection`].
+    ///
+    ///   If you instead want to force use of WebGL, either disable the `webgpu` compile-time feature
+    ///   or don't add the [`Backends::BROWSER_WEBGPU`] flag to the the `instance_desc`'s `backends` field.
+    ///   If it is set and WebGPU support is *not* detected, the instance will use wgpu-core
+    ///   to create adapters. Meaning that if the `webgl` feature is enabled, it is able to create
+    ///   a WebGL adapter.
+    ///
+    /// # Panics
+    ///
+    /// If no backend feature for the active target platform is enabled,
+    /// this method will panic, see [`Instance::enabled_backend_features()`].
+    #[allow(clippy::allow_attributes, unreachable_code)]
+    pub fn new(_instance_desc: &InstanceDescriptor) -> Self {
+        if Self::enabled_backend_features().is_empty() {
+            panic!(
+                "No wgpu backend feature that is implemented for the target platform was enabled. \
+                 See `wgpu::Instance::enabled_backend_features()` for more information."
+            );
+        }
+
+        #[cfg(webgpu)]
+        {
+            let is_only_available_backend = !cfg!(wgpu_core);
+            let requested_webgpu = _instance_desc.backends.contains(Backends::BROWSER_WEBGPU);
+            let support_webgpu = crate::backend::get_browser_gpu_property()
+                .map(|maybe_gpu| maybe_gpu.is_some())
+                .unwrap_or(false);
+
+            if is_only_available_backend || (requested_webgpu && support_webgpu) {
+                return Self {
+                    inner: crate::backend::ContextWebGpu::new(_instance_desc).into(),
+                };
+            }
+        }
+
+        #[cfg(wgpu_core)]
+        {
+            return Self {
+                inner: crate::backend::ContextWgpuCore::new(_instance_desc).into(),
+            };
+        }
+
+        unreachable!(
+            "Earlier check of `enabled_backend_features` should have prevented getting here!"
+        );
+    }
+
+    /// Create an new instance of wgpu from a wgpu-hal instance.
+    ///
+    /// # Arguments
+    ///
+    /// - `hal_instance` - wgpu-hal instance.
+    ///
+    /// # Safety
+    ///
+    /// Refer to the creation of wgpu-hal Instance for every backend.
+    #[cfg(wgpu_core)]
+    pub unsafe fn from_hal<A: wgc::hal_api::HalApi>(hal_instance: A::Instance) -> Self {
+        Self {
+            inner: unsafe {
+                crate::backend::ContextWgpuCore::from_hal_instance::<A>(hal_instance).into()
+            },
+        }
+    }
+
+    /// Return a reference to a specific backend instance, if available.
+    ///
+    /// If this `Instance` has a wgpu-hal [`Instance`] for backend
+    /// `A`, return a reference to it. Otherwise, return `None`.
+    ///
+    /// # Safety
+    ///
+    /// - The raw instance handle returned must not be manually destroyed.
+    ///
+    /// [`Instance`]: hal::Api::Instance
+    #[cfg(wgpu_core)]
+    pub unsafe fn as_hal<A: wgc::hal_api::HalApi>(&self) -> Option<&A::Instance> {
+        self.inner
+            .as_core_opt()
+            .and_then(|ctx| unsafe { ctx.instance_as_hal::<A>() })
+    }
+
+    /// Create an new instance of wgpu from a wgpu-core instance.
+    ///
+    /// # Arguments
+    ///
+    /// - `core_instance` - wgpu-core instance.
+    ///
+    /// # Safety
+    ///
+    /// Refer to the creation of wgpu-core Instance.
+    #[cfg(wgpu_core)]
+    pub unsafe fn from_core(core_instance: wgc::instance::Instance) -> Self {
+        Self {
+            inner: unsafe {
+                crate::backend::ContextWgpuCore::from_core_instance(core_instance).into()
+            },
+        }
+    }
+
+    /// Retrieves all available [`Adapter`]s that match the given [`Backends`].
+    ///
+    /// # Arguments
+    ///
+    /// - `backends` - Backends from which to enumerate adapters.
+    #[cfg(native)]
+    pub fn enumerate_adapters(&self, backends: Backends) -> Vec<Adapter> {
+        let Some(core_instance) = self.inner.as_core_opt() else {
+            return Vec::new();
+        };
+
+        core_instance
+            .enumerate_adapters(backends)
+            .into_iter()
+            .map(|adapter| {
+                let core = backend::wgpu_core::CoreAdapter {
+                    context: core_instance.clone(),
+                    id: adapter,
+                };
+                crate::Adapter { inner: core.into() }
+            })
+            .collect()
+    }
+
+    /// Retrieves an [`Adapter`] which matches the given [`RequestAdapterOptions`].
+    ///
+    /// Some options are "soft", so treated as non-mandatory. Others are "hard".
+    ///
+    /// If no adapters are found that suffice all the "hard" options, `None` is returned.
+    ///
+    /// A `compatible_surface` is required when targeting WebGL2.
+    pub fn request_adapter(
+        &self,
+        options: &RequestAdapterOptions<'_, '_>,
+    ) -> impl Future<Output = Option<Adapter>> + WasmNotSend {
+        let future = self.inner.request_adapter(options);
+        async move { future.await.map(|adapter| Adapter { inner: adapter }) }
+    }
+
+    /// Converts a wgpu-hal `ExposedAdapter` to a wgpu [`Adapter`].
+    ///
+    /// # Safety
+    ///
+    /// `hal_adapter` must be created from this instance internal handle.
+    #[cfg(wgpu_core)]
+    pub unsafe fn create_adapter_from_hal<A: wgc::hal_api::HalApi>(
+        &self,
+        hal_adapter: hal::ExposedAdapter<A>,
+    ) -> Adapter {
+        let core_instance = self.inner.as_core();
+        let adapter = unsafe { core_instance.create_adapter_from_hal(hal_adapter) };
+        let core = backend::wgpu_core::CoreAdapter {
+            context: core_instance.clone(),
+            id: adapter,
+        };
+
+        Adapter { inner: core.into() }
+    }
+
+    /// Creates a new surface targeting a given window/canvas/surface/etc..
+    ///
+    /// Internally, this creates surfaces for all backends that are enabled for this instance.
+    ///
+    /// See [`SurfaceTarget`] for what targets are supported.
+    /// See [`Instance::create_surface_unsafe`] for surface creation with unsafe target variants.
+    ///
+    /// Most commonly used are window handles (or provider of windows handles)
+    /// which can be passed directly as they're automatically converted to [`SurfaceTarget`].
+    pub fn create_surface<'window>(
+        &self,
+        target: impl Into<SurfaceTarget<'window>>,
+    ) -> Result<Surface<'window>, CreateSurfaceError> {
+        // Handle origin (i.e. window) to optionally take ownership of to make the surface outlast the window.
+        let handle_source;
+
+        let target = target.into();
+        let mut surface = match target {
+            SurfaceTarget::Window(window) => unsafe {
+                let surface = self.create_surface_unsafe(
+                    SurfaceTargetUnsafe::from_window(&window).map_err(|e| CreateSurfaceError {
+                        inner: CreateSurfaceErrorKind::RawHandle(e),
+                    })?,
+                );
+                handle_source = Some(window);
+
+                surface
+            }?,
+
+            #[cfg(any(webgpu, webgl))]
+            SurfaceTarget::Canvas(canvas) => {
+                handle_source = None;
+
+                let value: &wasm_bindgen::JsValue = &canvas;
+                let obj = std::ptr::NonNull::from(value).cast();
+                let raw_window_handle = raw_window_handle::WebCanvasWindowHandle::new(obj).into();
+                let raw_display_handle = raw_window_handle::WebDisplayHandle::new().into();
+
+                // Note that we need to call this while we still have `value` around.
+                // This is safe without storing canvas to `handle_origin` since the surface will create a copy internally.
+                unsafe {
+                    self.create_surface_unsafe(SurfaceTargetUnsafe::RawHandle {
+                        raw_display_handle,
+                        raw_window_handle,
+                    })
+                }?
+            }
+
+            #[cfg(any(webgpu, webgl))]
+            SurfaceTarget::OffscreenCanvas(canvas) => {
+                handle_source = None;
+
+                let value: &wasm_bindgen::JsValue = &canvas;
+                let obj = std::ptr::NonNull::from(value).cast();
+                let raw_window_handle =
+                    raw_window_handle::WebOffscreenCanvasWindowHandle::new(obj).into();
+                let raw_display_handle = raw_window_handle::WebDisplayHandle::new().into();
+
+                // Note that we need to call this while we still have `value` around.
+                // This is safe without storing canvas to `handle_origin` since the surface will create a copy internally.
+                unsafe {
+                    self.create_surface_unsafe(SurfaceTargetUnsafe::RawHandle {
+                        raw_display_handle,
+                        raw_window_handle,
+                    })
+                }?
+            }
+        };
+
+        surface._handle_source = handle_source;
+
+        Ok(surface)
+    }
+
+    /// Creates a new surface targeting a given window/canvas/surface/etc. using an unsafe target.
+    ///
+    /// Internally, this creates surfaces for all backends that are enabled for this instance.
+    ///
+    /// See [`SurfaceTargetUnsafe`] for what targets are supported.
+    /// See [`Instance::create_surface`] for surface creation with safe target variants.
+    ///
+    /// # Safety
+    ///
+    /// - See respective [`SurfaceTargetUnsafe`] variants for safety requirements.
+    pub unsafe fn create_surface_unsafe<'window>(
+        &self,
+        target: SurfaceTargetUnsafe,
+    ) -> Result<Surface<'window>, CreateSurfaceError> {
+        let surface = unsafe { self.inner.create_surface(target)? };
+
+        Ok(Surface {
+            _handle_source: None,
+            inner: surface,
+            config: Mutex::new(None),
+        })
+    }
+
+    /// Polls all devices.
+    ///
+    /// If `force_wait` is true and this is not running on the web, then this
+    /// function will block until all in-flight buffers have been mapped and
+    /// all submitted commands have finished execution.
+    ///
+    /// Return `true` if all devices' queues are empty, or `false` if there are
+    /// queue submissions still in flight. (Note that, unless access to all
+    /// [`Queue`s] associated with this [`Instance`] is coordinated somehow,
+    /// this information could be out of date by the time the caller receives
+    /// it. `Queue`s can be shared between threads, and other threads could
+    /// submit new work at any time.)
+    ///
+    /// On the web, this is a no-op. `Device`s are automatically polled.
+    ///
+    /// [`Queue`s]: Queue
+    pub fn poll_all(&self, force_wait: bool) -> bool {
+        self.inner.poll_all_devices(force_wait)
+    }
+
+    /// Generates memory report.
+    ///
+    /// Returns `None` if the feature is not supported by the backend
+    /// which happens only when WebGPU is pre-selected by the instance creation.
+    #[cfg(wgpu_core)]
+    pub fn generate_report(&self) -> Option<wgc::global::GlobalReport> {
+        self.inner.as_core_opt().map(|ctx| ctx.generate_report())
+    }
+
+    /// Returns set of supported WGSL language extensions supported by this instance.
+    ///
+    /// <https://www.w3.org/TR/webgpu/#gpuwgsllanguagefeatures>
+    #[cfg(feature = "wgsl")]
+    pub fn wgsl_language_features(&self) -> WgslLanguageFeatures {
+        self.inner.wgsl_language_features()
+    }
+}

vendor/wgpu/src/api/mod.rs

@@ -0,0 +1,98 @@
+//! Types and functions which define our public api and their
+//! helper functionality.
+//!
+//! # Conventions
+//!
+//! Each major type gets its own module. The module is laid out as follows:
+//!
+//! - The type itself
+//! - `impl` block for the type
+//! - `Drop` implementation for the type (if needed)
+//! - Descriptor types and their subtypes.
+//! - Any non-public helper types or functions.
+//!
+//! # Imports
+//!
+//! Because our public api is "flat" (i.e. all types are directly under the `wgpu` module),
+//! we use a single `crate::*` import at the top of each module to bring in all the types in
+//! the public api. This is done to:
+//! - Avoid having to write out a long list of imports for each module.
+//! - Allow docs to be written naturally, without needing to worry about needing dedicated doc imports.
+//! - Treat wgpu-types types and wgpu-core types as a single set.
+
+mod adapter;
+mod bind_group;
+mod bind_group_layout;
+mod blas;
+mod buffer;
+mod command_buffer;
+mod command_encoder;
+// Not a root type, but common descriptor types for pipelines.
+mod common_pipeline;
+mod compute_pass;
+mod compute_pipeline;
+mod device;
+mod instance;
+mod pipeline_cache;
+mod pipeline_layout;
+mod query_set;
+mod queue;
+mod render_bundle;
+mod render_bundle_encoder;
+mod render_pass;
+mod render_pipeline;
+mod sampler;
+mod shader_module;
+mod surface;
+mod surface_texture;
+mod texture;
+mod texture_view;
+mod tlas;
+
+pub use adapter::*;
+pub use bind_group::*;
+pub use bind_group_layout::*;
+pub use blas::*;
+pub use buffer::*;
+pub use command_buffer::*;
+pub use command_encoder::*;
+pub use common_pipeline::*;
+pub use compute_pass::*;
+pub use compute_pipeline::*;
+pub use device::*;
+pub use instance::*;
+pub use pipeline_cache::*;
+pub use pipeline_layout::*;
+pub use query_set::*;
+pub use queue::*;
+pub use render_bundle::*;
+pub use render_bundle_encoder::*;
+pub use render_pass::*;
+pub use render_pipeline::*;
+pub use sampler::*;
+pub use shader_module::*;
+pub use surface::*;
+pub use surface_texture::*;
+pub use texture::*;
+pub use texture_view::*;
+pub use tlas::*;
+
+/// Object debugging label.
+pub type Label<'a> = Option<&'a str>;
+
+/// A cute utility type that works just like PhantomData, but also
+/// implements Drop. This forces any lifetimes that are associated
+/// with the type to be used until the Drop impl is ran. This prevents
+/// lifetimes from being shortened.
+#[derive(Debug)]
+pub(crate) struct PhantomDrop<T>(std::marker::PhantomData<T>);
+
+impl<T> Default for PhantomDrop<T> {
+    fn default() -> Self {
+        Self(std::marker::PhantomData)
+    }
+}
+
+impl<T> Drop for PhantomDrop<T> {
+    fn drop(&mut self) {}
+}

vendor/wgpu/src/api/pipeline_cache.rs

@@ -0,0 +1,85 @@
+use crate::*;
+
+/// Handle to a pipeline cache, which is used to accelerate
+/// creating [`RenderPipeline`]s and [`ComputePipeline`]s
+/// in subsequent executions
+///
+/// This reuse is only applicable for the same or similar devices.
+/// See [`util::pipeline_cache_key`] for some details.
+///
+/// # Background
+///
+/// In most GPU drivers, shader code must be converted into a machine code
+/// which can be executed on the GPU.
+/// Generating this machine code can require a lot of computation.
+/// Pipeline caches allow this computation to be reused between executions
+/// of the program.
+/// This can be very useful for reducing program startup time.
+///
+/// Note that most desktop GPU drivers will manage their own caches,
+/// meaning that little advantage can be gained from this on those platforms.
+/// However, on some platforms, especially Android, drivers leave this to the
+/// application to implement.
+///
+/// Unfortunately, drivers do not expose whether they manage their own caches.
+/// Some reasonable policies for applications to use are:
+/// - Manage their own pipeline cache on all platforms
+/// - Only manage pipeline caches on Android
+///
+/// # Usage
+///
+/// It is valid to use this resource when creating multiple pipelines, in
+/// which case it will likely cache each of those pipelines.
+/// It is also valid to create a new cache for each pipeline.
+///
+/// This resource is most useful when the data produced from it (using
+/// [`PipelineCache::get_data`]) is persisted.
+/// Care should be taken that pipeline caches are only used for the same device,
+/// as pipeline caches from compatible devices are unlikely to provide any advantage.
+/// `util::pipeline_cache_key` can be used as a file/directory name to help ensure that.
+///
+/// It is recommended to store pipeline caches atomically. If persisting to disk,
+/// this can usually be achieved by creating a temporary file, then moving/[renaming]
+/// the temporary file over the existing cache
+///
+/// # Storage Usage
+///
+/// There is not currently an API available to reduce the size of a cache.
+/// This is due to limitations in the underlying graphics APIs used.
+/// This is especially impactful if your application is being updated, so
+/// previous caches are no longer being used.
+///
+/// One option to work around this is to regenerate the cache.
+/// That is, creating the pipelines which your program runs using
+/// with the stored cached data, then recreating the *same* pipelines
+/// using a new cache, which your application then store.
+///
+/// # Implementations
+///
+/// This resource currently only works on the following backends:
+///  - Vulkan
+///
+/// This type is unique to the Rust API of `wgpu`.
+///
+/// [renaming]: std::fs::rename
+#[derive(Debug, Clone)]
+pub struct PipelineCache {
+    pub(crate) inner: dispatch::DispatchPipelineCache,
+}
+
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(PipelineCache: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(PipelineCache => .inner);
+
+impl PipelineCache {
+    /// Get the data associated with this pipeline cache.
+    /// The data format is an implementation detail of `wgpu`.
+    /// The only defined operation on this data setting it as the `data` field
+    /// on [`PipelineCacheDescriptor`], then to [`Device::create_pipeline_cache`].
+    ///
+    /// This function is unique to the Rust API of `wgpu`.
+    pub fn get_data(&self) -> Option<Vec<u8>> {
+        self.inner.get_data()
+    }
+}

vendor/wgpu/src/api/pipeline_layout.rs

@@ -0,0 +1,39 @@
+use crate::*;
+
+/// Handle to a pipeline layout.
+///
+/// A `PipelineLayout` object describes the available binding groups of a pipeline.
+/// It can be created with [`Device::create_pipeline_layout`].
+///
+/// Corresponds to [WebGPU `GPUPipelineLayout`](https://gpuweb.github.io/gpuweb/#gpupipelinelayout).
+#[derive(Debug, Clone)]
+pub struct PipelineLayout {
+    pub(crate) inner: dispatch::DispatchPipelineLayout,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(PipelineLayout: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(PipelineLayout => .inner);
+
+/// Describes a [`PipelineLayout`].
+///
+/// For use with [`Device::create_pipeline_layout`].
+///
+/// Corresponds to [WebGPU `GPUPipelineLayoutDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpupipelinelayoutdescriptor).
+#[derive(Clone, Debug, Default)]
+pub struct PipelineLayoutDescriptor<'a> {
+    /// Debug label of the pipeline layout. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// Bind groups that this pipeline uses. The first entry will provide all the bindings for
+    /// "set = 0", second entry will provide all the bindings for "set = 1" etc.
+    pub bind_group_layouts: &'a [&'a BindGroupLayout],
+    /// Set of push constant ranges this pipeline uses. Each shader stage that uses push constants
+    /// must define the range in push constant memory that corresponds to its single `var<push_constant>`
+    /// buffer.
+    ///
+    /// If this array is non-empty, the [`Features::PUSH_CONSTANTS`] must be enabled.
+    pub push_constant_ranges: &'a [PushConstantRange],
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(PipelineLayoutDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/query_set.rs

@@ -0,0 +1,25 @@
+use crate::*;
+
+/// Handle to a query set.
+///
+/// It can be created with [`Device::create_query_set`].
+///
+/// Corresponds to [WebGPU `GPUQuerySet`](https://gpuweb.github.io/gpuweb/#queryset).
+#[derive(Debug, Clone)]
+pub struct QuerySet {
+    pub(crate) inner: dispatch::DispatchQuerySet,
+}
+#[cfg(send_sync)]
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(QuerySet: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(QuerySet => .inner);
+
+/// Describes a [`QuerySet`].
+///
+/// For use with [`Device::create_query_set`].
+///
+/// Corresponds to [WebGPU `GPUQuerySetDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpuquerysetdescriptor).
+pub type QuerySetDescriptor<'a> = wgt::QuerySetDescriptor<Label<'a>>;
+static_assertions::assert_impl_all!(QuerySetDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/queue.rs

@@ -0,0 +1,250 @@
+use std::ops::{Deref, DerefMut};
+
+use crate::*;
+
+/// Handle to a command queue on a device.
+///
+/// A `Queue` executes recorded [`CommandBuffer`] objects and provides convenience methods
+/// for writing to [buffers](Queue::write_buffer) and [textures](Queue::write_texture).
+/// It can be created along with a [`Device`] by calling [`Adapter::request_device`].
+///
+/// Corresponds to [WebGPU `GPUQueue`](https://gpuweb.github.io/gpuweb/#gpu-queue).
+#[derive(Debug, Clone)]
+pub struct Queue {
+    pub(crate) inner: dispatch::DispatchQueue,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(Queue: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(Queue => .inner);
+
+/// Identifier for a particular call to [`Queue::submit`]. Can be used
+/// as part of an argument to [`Device::poll`] to block for a particular
+/// submission to finish.
+///
+/// This type is unique to the Rust API of `wgpu`.
+/// There is no analogue in the WebGPU specification.
+#[derive(Debug, Clone)]
+pub struct SubmissionIndex {
+    #[cfg_attr(
+        all(
+            target_arch = "wasm32",
+            not(target_os = "emscripten"),
+            not(feature = "webgl"),
+        ),
+        expect(dead_code)
+    )]
+    pub(crate) index: u64,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(SubmissionIndex: Send, Sync);
+
+pub use wgt::Maintain as MaintainBase;
+/// Passed to [`Device::poll`] to control how and if it should block.
+pub type Maintain = wgt::Maintain<SubmissionIndex>;
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(Maintain: Send, Sync);
+
+/// A write-only view into a staging buffer.
+///
+/// Reading into this buffer won't yield the contents of the buffer from the
+/// GPU and is likely to be slow. Because of this, although [`AsMut`] is
+/// implemented for this type, [`AsRef`] is not.
+pub struct QueueWriteBufferView<'a> {
+    queue: &'a Queue,
+    buffer: &'a Buffer,
+    offset: BufferAddress,
+    inner: dispatch::DispatchQueueWriteBuffer,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(QueueWriteBufferView<'_>: Send, Sync);
+
+impl Deref for QueueWriteBufferView<'_> {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        log::warn!("Reading from a QueueWriteBufferView won't yield the contents of the buffer and may be slow.");
+        self.inner.slice()
+    }
+}
+
+impl DerefMut for QueueWriteBufferView<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.inner.slice_mut()
+    }
+}
+
+impl AsMut<[u8]> for QueueWriteBufferView<'_> {
+    fn as_mut(&mut self) -> &mut [u8] {
+        self.inner.slice_mut()
+    }
+}
+
+impl Drop for QueueWriteBufferView<'_> {
+    fn drop(&mut self) {
+        self.queue
+            .inner
+            .write_staging_buffer(&self.buffer.inner, self.offset, &self.inner);
+    }
+}
+
+impl Queue {
+    /// Schedule a data write into `buffer` starting at `offset`.
+    ///
+    /// This method fails if `data` overruns the size of `buffer` starting at `offset`.
+    ///
+    /// This does *not* submit the transfer to the GPU immediately. Calls to
+    /// `write_buffer` begin execution only on the next call to
+    /// [`Queue::submit`]. To get a set of scheduled transfers started
+    /// immediately, it's fine to call `submit` with no command buffers at all:
+    ///
+    /// ```no_run
+    /// # let queue: wgpu::Queue = todo!();
+    /// queue.submit([]);
+    /// ```
+    ///
+    /// However, `data` will be immediately copied into staging memory, so the
+    /// caller may discard it any time after this call completes.
+    ///
+    /// If possible, consider using [`Queue::write_buffer_with`] instead. That
+    /// method avoids an intermediate copy and is often able to transfer data
+    /// more efficiently than this one.
+    pub fn write_buffer(&self, buffer: &Buffer, offset: BufferAddress, data: &[u8]) {
+        self.inner.write_buffer(&buffer.inner, offset, data);
+    }
+
+    /// Write to a buffer via a directly mapped staging buffer.
+    ///
+    /// Return a [`QueueWriteBufferView`] which, when dropped, schedules a copy
+    /// of its contents into `buffer` at `offset`. The returned view
+    /// dereferences to a `size`-byte long `&mut [u8]`, in which you should
+    /// store the data you would like written to `buffer`.
+    ///
+    /// This method may perform transfers faster than [`Queue::write_buffer`],
+    /// because the returned [`QueueWriteBufferView`] is actually the staging
+    /// buffer for the write, mapped into the caller's address space. Writing
+    /// your data directly into this staging buffer avoids the temporary
+    /// CPU-side buffer needed by `write_buffer`.
+    ///
+    /// Reading from the returned view is slow, and will not yield the current
+    /// contents of `buffer`.
+    ///
+    /// Note that dropping the [`QueueWriteBufferView`] does *not* submit the
+    /// transfer to the GPU immediately. The transfer begins only on the next
+    /// call to [`Queue::submit`] after the view is dropped. To get a set of
+    /// scheduled transfers started immediately, it's fine to call `submit` with
+    /// no command buffers at all:
+    ///
+    /// ```no_run
+    /// # let queue: wgpu::Queue = todo!();
+    /// queue.submit([]);
+    /// ```
+    ///
+    /// This method fails if `size` is greater than the size of `buffer` starting at `offset`.
+    #[must_use]
+    pub fn write_buffer_with<'a>(
+        &'a self,
+        buffer: &'a Buffer,
+        offset: BufferAddress,
+        size: BufferSize,
+    ) -> Option<QueueWriteBufferView<'a>> {
+        profiling::scope!("Queue::write_buffer_with");
+        self.inner
+            .validate_write_buffer(&buffer.inner, offset, size)?;
+        let staging_buffer = self.inner.create_staging_buffer(size)?;
+        Some(QueueWriteBufferView {
+            queue: self,
+            buffer,
+            offset,
+            inner: staging_buffer,
+        })
+    }
+
+    /// Schedule a write of some data into a texture.
+    ///
+    /// * `data` contains the texels to be written, which must be in
+    ///   [the same format as the texture](TextureFormat).
+    /// * `data_layout` describes the memory layout of `data`, which does not necessarily
+    ///   have to have tightly packed rows.
+    /// * `texture` specifies the texture to write into, and the location within the
+    ///   texture (coordinate offset, mip level) that will be overwritten.
+    /// * `size` is the size, in texels, of the region to be written.
+    ///
+    /// This method fails if `size` overruns the size of `texture`, or if `data` is too short.
+    ///
+    /// This does *not* submit the transfer to the GPU immediately. Calls to
+    /// `write_texture` begin execution only on the next call to
+    /// [`Queue::submit`]. To get a set of scheduled transfers started
+    /// immediately, it's fine to call `submit` with no command buffers at all:
+    ///
+    /// ```no_run
+    /// # let queue: wgpu::Queue = todo!();
+    /// queue.submit([]);
+    /// ```
+    ///
+    /// However, `data` will be immediately copied into staging memory, so the
+    /// caller may discard it any time after this call completes.
+    pub fn write_texture(
+        &self,
+        texture: TexelCopyTextureInfo<'_>,
+        data: &[u8],
+        data_layout: TexelCopyBufferLayout,
+        size: Extent3d,
+    ) {
+        self.inner.write_texture(texture, data, data_layout, size);
+    }
+
+    /// Schedule a copy of data from `image` into `texture`.
+    #[cfg(any(webgpu, webgl))]
+    pub fn copy_external_image_to_texture(
+        &self,
+        source: &wgt::CopyExternalImageSourceInfo,
+        dest: wgt::CopyExternalImageDestInfo<&api::Texture>,
+        size: Extent3d,
+    ) {
+        self.inner
+            .copy_external_image_to_texture(source, dest, size);
+    }
+
+    /// Submits a series of finished command buffers for execution.
+    pub fn submit<I: IntoIterator<Item = CommandBuffer>>(
+        &self,
+        command_buffers: I,
+    ) -> SubmissionIndex {
+        let mut command_buffers = command_buffers.into_iter().map(|comb| {
+            comb.inner
+                .lock()
+                .take()
+                .expect("Command buffer already submitted")
+        });
+
+        let index = self.inner.submit(&mut command_buffers);
+
+        SubmissionIndex { index }
+    }
+
+    /// Gets the amount of nanoseconds each tick of a timestamp query represents.
+    ///
+    /// Returns zero if timestamp queries are unsupported.
+    ///
+    /// Timestamp values are represented in nanosecond values on WebGPU, see `<https://gpuweb.github.io/gpuweb/#timestamp>`
+    /// Therefore, this is always 1.0 on the web, but on wgpu-core a manual conversion is required.
+    pub fn get_timestamp_period(&self) -> f32 {
+        self.inner.get_timestamp_period()
+    }
+
+    /// Registers a callback when the previous call to submit finishes running on the gpu. This callback
+    /// being called implies that all mapped buffer callbacks which were registered before this call will
+    /// have been called.
+    ///
+    /// For the callback to complete, either `queue.submit(..)`, `instance.poll_all(..)`, or `device.poll(..)`
+    /// must be called elsewhere in the runtime, possibly integrated into an event loop or run on a separate thread.
+    ///
+    /// The callback will be called on the thread that first calls the above functions after the gpu work
+    /// has completed. There are no restrictions on the code you can run in the callback, however on native the
+    /// call to the function will not complete until the callback returns, so prefer keeping callbacks short
+    /// and used to set flags, send messages, etc.
+    pub fn on_submitted_work_done(&self, callback: impl FnOnce() + Send + 'static) {
+        self.inner.on_submitted_work_done(Box::new(callback));
+    }
+}

vendor/wgpu/src/api/render_bundle.rs

@@ -0,0 +1,28 @@
+use crate::*;
+
+/// Pre-prepared reusable bundle of GPU operations.
+///
+/// It only supports a handful of render commands, but it makes them reusable. Executing a
+/// [`RenderBundle`] is often more efficient than issuing the underlying commands manually.
+///
+/// It can be created by use of a [`RenderBundleEncoder`], and executed onto a [`CommandEncoder`]
+/// using [`RenderPass::execute_bundles`].
+///
+/// Corresponds to [WebGPU `GPURenderBundle`](https://gpuweb.github.io/gpuweb/#render-bundle).
+#[derive(Debug, Clone)]
+pub struct RenderBundle {
+    pub(crate) inner: dispatch::DispatchRenderBundle,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(RenderBundle: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(RenderBundle => .inner);
+
+/// Describes a [`RenderBundle`].
+///
+/// For use with [`RenderBundleEncoder::finish`].
+///
+/// Corresponds to [WebGPU `GPURenderBundleDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpurenderbundledescriptor).
+pub type RenderBundleDescriptor<'a> = wgt::RenderBundleDescriptor<Label<'a>>;
+static_assertions::assert_impl_all!(RenderBundleDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/render_bundle_encoder.rs

@@ -0,0 +1,224 @@
+use std::{marker::PhantomData, num::NonZeroU32, ops::Range};
+
+use crate::dispatch::RenderBundleEncoderInterface;
+use crate::*;
+
+/// Encodes a series of GPU operations into a reusable "render bundle".
+///
+/// It only supports a handful of render commands, but it makes them reusable.
+/// It can be created with [`Device::create_render_bundle_encoder`].
+/// It can be executed onto a [`CommandEncoder`] using [`RenderPass::execute_bundles`].
+///
+/// Executing a [`RenderBundle`] is often more efficient than issuing the underlying commands
+/// manually.
+///
+/// Corresponds to [WebGPU `GPURenderBundleEncoder`](
+/// https://gpuweb.github.io/gpuweb/#gpurenderbundleencoder).
+#[derive(Debug)]
+pub struct RenderBundleEncoder<'a> {
+    pub(crate) inner: dispatch::DispatchRenderBundleEncoder,
+    /// This type should be !Send !Sync, because it represents an allocation on this thread's
+    /// command buffer.
+    pub(crate) _p: PhantomData<(*const u8, &'a ())>,
+}
+static_assertions::assert_not_impl_any!(RenderBundleEncoder<'_>: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(RenderBundleEncoder<'_> => .inner);
+
+/// Describes a [`RenderBundleEncoder`].
+///
+/// For use with [`Device::create_render_bundle_encoder`].
+///
+/// Corresponds to [WebGPU `GPURenderBundleEncoderDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpurenderbundleencoderdescriptor).
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct RenderBundleEncoderDescriptor<'a> {
+    /// Debug label of the render bundle encoder. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// The formats of the color attachments that this render bundle is capable to rendering to. This
+    /// must match the formats of the color attachments in the render pass this render bundle is executed in.
+    pub color_formats: &'a [Option<TextureFormat>],
+    /// Information about the depth attachment that this render bundle is capable to rendering to. This
+    /// must match the format of the depth attachments in the render pass this render bundle is executed in.
+    pub depth_stencil: Option<RenderBundleDepthStencil>,
+    /// Sample count this render bundle is capable of rendering to. This must match the pipelines and
+    /// the render passes it is used in.
+    pub sample_count: u32,
+    /// If this render bundle will rendering to multiple array layers in the attachments at the same time.
+    pub multiview: Option<NonZeroU32>,
+}
+static_assertions::assert_impl_all!(RenderBundleEncoderDescriptor<'_>: Send, Sync);
+
+impl<'a> RenderBundleEncoder<'a> {
+    /// Finishes recording and returns a [`RenderBundle`] that can be executed in other render passes.
+    pub fn finish(self, desc: &RenderBundleDescriptor<'_>) -> RenderBundle {
+        let bundle = match self.inner {
+            #[cfg(wgpu_core)]
+            dispatch::DispatchRenderBundleEncoder::Core(b) => b.finish(desc),
+            #[cfg(webgpu)]
+            dispatch::DispatchRenderBundleEncoder::WebGPU(b) => b.finish(desc),
+        };
+
+        RenderBundle { inner: bundle }
+    }
+
+    /// Sets the active bind group for a given bind group index. The bind group layout
+    /// in the active pipeline when any `draw()` function is called must match the layout of this bind group.
+    ///
+    /// If the bind group have dynamic offsets, provide them in the binding order.
+    pub fn set_bind_group<'b, BG>(&mut self, index: u32, bind_group: BG, offsets: &[DynamicOffset])
+    where
+        Option<&'b BindGroup>: From<BG>,
+    {
+        let bg: Option<&'b BindGroup> = bind_group.into();
+        let bg = bg.map(|x| &x.inner);
+        self.inner.set_bind_group(index, bg, offsets);
+    }
+
+    /// Sets the active render pipeline.
+    ///
+    /// Subsequent draw calls will exhibit the behavior defined by `pipeline`.
+    pub fn set_pipeline(&mut self, pipeline: &'a RenderPipeline) {
+        self.inner.set_pipeline(&pipeline.inner);
+    }
+
+    /// Sets the active index buffer.
+    ///
+    /// Subsequent calls to [`draw_indexed`](RenderBundleEncoder::draw_indexed) on this [`RenderBundleEncoder`] will
+    /// use `buffer` as the source index buffer.
+    pub fn set_index_buffer(&mut self, buffer_slice: BufferSlice<'a>, index_format: IndexFormat) {
+        self.inner.set_index_buffer(
+            &buffer_slice.buffer.inner,
+            index_format,
+            buffer_slice.offset,
+            buffer_slice.size,
+        );
+    }
+
+    /// Assign a vertex buffer to a slot.
+    ///
+    /// Subsequent calls to [`draw`] and [`draw_indexed`] on this
+    /// [`RenderBundleEncoder`] will use `buffer` as one of the source vertex buffers.
+    ///
+    /// The `slot` refers to the index of the matching descriptor in
+    /// [`VertexState::buffers`].
+    ///
+    /// [`draw`]: RenderBundleEncoder::draw
+    /// [`draw_indexed`]: RenderBundleEncoder::draw_indexed
+    pub fn set_vertex_buffer(&mut self, slot: u32, buffer_slice: BufferSlice<'a>) {
+        self.inner.set_vertex_buffer(
+            slot,
+            &buffer_slice.buffer.inner,
+            buffer_slice.offset,
+            buffer_slice.size,
+        );
+    }
+
+    /// Draws primitives from the active vertex buffer(s).
+    ///
+    /// The active vertex buffers can be set with [`RenderBundleEncoder::set_vertex_buffer`].
+    /// Does not use an Index Buffer. If you need this see [`RenderBundleEncoder::draw_indexed`]
+    ///
+    /// Panics if vertices Range is outside of the range of the vertices range of any set vertex buffer.
+    ///
+    /// vertices: The range of vertices to draw.
+    /// instances: Range of Instances to draw. Use 0..1 if instance buffers are not used.
+    /// E.g.of how its used internally
+    /// ```rust ignore
+    /// for instance_id in instance_range {
+    ///     for vertex_id in vertex_range {
+    ///         let vertex = vertex[vertex_id];
+    ///         vertex_shader(vertex, vertex_id, instance_id);
+    ///     }
+    /// }
+    /// ```
+    pub fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
+        self.inner.draw(vertices, instances);
+    }
+
+    /// Draws indexed primitives using the active index buffer and the active vertex buffer(s).
+    ///
+    /// The active index buffer can be set with [`RenderBundleEncoder::set_index_buffer`].
+    /// The active vertex buffer(s) can be set with [`RenderBundleEncoder::set_vertex_buffer`].
+    ///
+    /// Panics if indices Range is outside of the range of the indices range of any set index buffer.
+    ///
+    /// indices: The range of indices to draw.
+    /// base_vertex: value added to each index value before indexing into the vertex buffers.
+    /// instances: Range of Instances to draw. Use 0..1 if instance buffers are not used.
+    /// E.g.of how its used internally
+    /// ```rust ignore
+    /// for instance_id in instance_range {
+    ///     for index_index in index_range {
+    ///         let vertex_id = index_buffer[index_index];
+    ///         let adjusted_vertex_id = vertex_id + base_vertex;
+    ///         let vertex = vertex[adjusted_vertex_id];
+    ///         vertex_shader(vertex, adjusted_vertex_id, instance_id);
+    ///     }
+    /// }
+    /// ```
+    pub fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>) {
+        self.inner.draw_indexed(indices, base_vertex, instances);
+    }
+
+    /// Draws primitives from the active vertex buffer(s) based on the contents of the `indirect_buffer`.
+    ///
+    /// The active vertex buffers can be set with [`RenderBundleEncoder::set_vertex_buffer`].
+    ///
+    /// The structure expected in `indirect_buffer` must conform to [`DrawIndirectArgs`](crate::util::DrawIndirectArgs).
+    pub fn draw_indirect(&mut self, indirect_buffer: &'a Buffer, indirect_offset: BufferAddress) {
+        self.inner
+            .draw_indirect(&indirect_buffer.inner, indirect_offset);
+    }
+
+    /// Draws indexed primitives using the active index buffer and the active vertex buffers,
+    /// based on the contents of the `indirect_buffer`.
+    ///
+    /// The active index buffer can be set with [`RenderBundleEncoder::set_index_buffer`], while the active
+    /// vertex buffers can be set with [`RenderBundleEncoder::set_vertex_buffer`].
+    ///
+    /// The structure expected in `indirect_buffer` must conform to [`DrawIndexedIndirectArgs`](crate::util::DrawIndexedIndirectArgs).
+    pub fn draw_indexed_indirect(
+        &mut self,
+        indirect_buffer: &'a Buffer,
+        indirect_offset: BufferAddress,
+    ) {
+        self.inner
+            .draw_indexed_indirect(&indirect_buffer.inner, indirect_offset);
+    }
+}
+
+/// [`Features::PUSH_CONSTANTS`] must be enabled on the device in order to call these functions.
+impl RenderBundleEncoder<'_> {
+    /// Set push constant data.
+    ///
+    /// Offset is measured in bytes, but must be a multiple of [`PUSH_CONSTANT_ALIGNMENT`].
+    ///
+    /// Data size must be a multiple of 4 and must have an alignment of 4.
+    /// For example, with an offset of 4 and an array of `[u8; 8]`, that will write to the range
+    /// of 4..12.
+    ///
+    /// For each byte in the range of push constant data written, the union of the stages of all push constant
+    /// ranges that covers that byte must be exactly `stages`. There's no good way of explaining this simply,
+    /// so here are some examples:
+    ///
+    /// ```text
+    /// For the given ranges:
+    /// - 0..4 Vertex
+    /// - 4..8 Fragment
+    /// ```
+    ///
+    /// You would need to upload this in two set_push_constants calls. First for the `Vertex` range, second for the `Fragment` range.
+    ///
+    /// ```text
+    /// For the given ranges:
+    /// - 0..8  Vertex
+    /// - 4..12 Fragment
+    /// ```
+    ///
+    /// 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: ShaderStages, offset: u32, data: &[u8]) {
+        self.inner.set_push_constants(stages, offset, data);
+    }
+}

vendor/wgpu/src/api/render_pass.rs

@@ -0,0 +1,579 @@
+use std::ops::Range;
+
+use crate::*;
+pub use wgt::{LoadOp, Operations, StoreOp};
+
+/// In-progress recording of a render pass: a list of render commands in a [`CommandEncoder`].
+///
+/// It can be created with [`CommandEncoder::begin_render_pass()`], whose [`RenderPassDescriptor`]
+/// specifies the attachments (textures) that will be rendered to.
+///
+/// Most of the methods on `RenderPass` serve one of two purposes, identifiable by their names:
+///
+/// * `draw_*()`: Drawing (that is, encoding a render command, which, when executed by the GPU, will
+///   rasterize something and execute shaders).
+/// * `set_*()`: Setting part of the [render state](https://gpuweb.github.io/gpuweb/#renderstate)
+///   for future drawing commands.
+///
+/// A render pass may contain any number of drawing commands, and before/between each command the
+/// render state may be updated however you wish; each drawing command will be executed using the
+/// render state that has been set when the `draw_*()` function is called.
+///
+/// Corresponds to [WebGPU `GPURenderPassEncoder`](
+/// https://gpuweb.github.io/gpuweb/#render-pass-encoder).
+#[derive(Debug)]
+pub struct RenderPass<'encoder> {
+    pub(crate) inner: dispatch::DispatchRenderPass,
+
+    /// This lifetime is used to protect the [`CommandEncoder`] from being used
+    /// while the pass is alive. This needs to be PhantomDrop to prevent the lifetime
+    /// from being shortened.
+    pub(crate) _encoder_guard: PhantomDrop<&'encoder ()>,
+}
+
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(RenderPass<'_>: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(RenderPass<'_> => .inner);
+
+impl RenderPass<'_> {
+    /// Drops the lifetime relationship to the parent command encoder, making usage of
+    /// the encoder while this pass is recorded a run-time error instead.
+    ///
+    /// Attention: As long as the render pass has not been ended, any mutating operation on the parent
+    /// command encoder will cause a run-time error and invalidate it!
+    /// By default, the lifetime constraint prevents this, but it can be useful
+    /// to handle this at run time, such as when storing the pass and encoder in the same
+    /// data structure.
+    ///
+    /// This operation has no effect on pass recording.
+    /// It's a safe operation, since [`CommandEncoder`] is in a locked state as long as the pass is active
+    /// regardless of the lifetime constraint or its absence.
+    pub fn forget_lifetime(self) -> RenderPass<'static> {
+        RenderPass {
+            inner: self.inner,
+            _encoder_guard: crate::api::PhantomDrop::default(),
+        }
+    }
+
+    /// Sets the active bind group for a given bind group index. The bind group layout
+    /// in the active pipeline when any `draw_*()` method is called must match the layout of
+    /// this bind group.
+    ///
+    /// If the bind group have dynamic offsets, provide them in binding order.
+    /// These offsets have to be aligned to [`Limits::min_uniform_buffer_offset_alignment`]
+    /// or [`Limits::min_storage_buffer_offset_alignment`] appropriately.
+    ///
+    /// Subsequent draw calls’ shader executions will be able to access data in these bind groups.
+    pub fn set_bind_group<'a, BG>(&mut self, index: u32, bind_group: BG, offsets: &[DynamicOffset])
+    where
+        Option<&'a BindGroup>: From<BG>,
+    {
+        let bg: Option<&'a BindGroup> = bind_group.into();
+        let bg = bg.map(|bg| &bg.inner);
+
+        self.inner.set_bind_group(index, bg, offsets);
+    }
+
+    /// Sets the active render pipeline.
+    ///
+    /// Subsequent draw calls will exhibit the behavior defined by `pipeline`.
+    pub fn set_pipeline(&mut self, pipeline: &RenderPipeline) {
+        self.inner.set_pipeline(&pipeline.inner);
+    }
+
+    /// Sets the blend color as used by some of the blending modes.
+    ///
+    /// Subsequent blending tests will test against this value.
+    /// If this method has not been called, the blend constant defaults to [`Color::TRANSPARENT`]
+    /// (all components zero).
+    pub fn set_blend_constant(&mut self, color: Color) {
+        self.inner.set_blend_constant(color);
+    }
+
+    /// Sets the active index buffer.
+    ///
+    /// Subsequent calls to [`draw_indexed`](RenderPass::draw_indexed) on this [`RenderPass`] will
+    /// use `buffer` as the source index buffer.
+    pub fn set_index_buffer(&mut self, buffer_slice: BufferSlice<'_>, index_format: IndexFormat) {
+        self.inner.set_index_buffer(
+            &buffer_slice.buffer.inner,
+            index_format,
+            buffer_slice.offset,
+            buffer_slice.size,
+        );
+    }
+
+    /// Assign a vertex buffer to a slot.
+    ///
+    /// Subsequent calls to [`draw`] and [`draw_indexed`] on this
+    /// [`RenderPass`] will use `buffer` as one of the source vertex buffers.
+    ///
+    /// The `slot` refers to the index of the matching descriptor in
+    /// [`VertexState::buffers`].
+    ///
+    /// [`draw`]: RenderPass::draw
+    /// [`draw_indexed`]: RenderPass::draw_indexed
+    pub fn set_vertex_buffer(&mut self, slot: u32, buffer_slice: BufferSlice<'_>) {
+        self.inner.set_vertex_buffer(
+            slot,
+            &buffer_slice.buffer.inner,
+            buffer_slice.offset,
+            buffer_slice.size,
+        );
+    }
+
+    /// Sets the scissor rectangle used during the rasterization stage.
+    /// After transformation into [viewport coordinates](https://www.w3.org/TR/webgpu/#viewport-coordinates).
+    ///
+    /// Subsequent draw calls will discard any fragments which fall outside the scissor rectangle.
+    /// If this method has not been called, the scissor rectangle defaults to the entire bounds of
+    /// the render targets.
+    ///
+    /// The function of the scissor rectangle resembles [`set_viewport()`](Self::set_viewport),
+    /// but it does not affect the coordinate system, only which fragments are discarded.
+    pub fn set_scissor_rect(&mut self, x: u32, y: u32, width: u32, height: u32) {
+        self.inner.set_scissor_rect(x, y, width, height);
+    }
+
+    /// Sets the viewport used during the rasterization stage to linearly map
+    /// from [normalized device coordinates](https://www.w3.org/TR/webgpu/#ndc) to [viewport coordinates](https://www.w3.org/TR/webgpu/#viewport-coordinates).
+    ///
+    /// Subsequent draw calls will only draw within this region.
+    /// If this method has not been called, the viewport defaults to the entire bounds of the render
+    /// targets.
+    pub fn set_viewport(&mut self, x: f32, y: f32, w: f32, h: f32, min_depth: f32, max_depth: f32) {
+        self.inner.set_viewport(x, y, w, h, min_depth, max_depth);
+    }
+
+    /// Sets the stencil reference.
+    ///
+    /// Subsequent stencil tests will test against this value.
+    /// If this method has not been called, the stencil reference value defaults to `0`.
+    pub fn set_stencil_reference(&mut self, reference: u32) {
+        self.inner.set_stencil_reference(reference);
+    }
+
+    /// Inserts debug marker.
+    pub fn insert_debug_marker(&mut self, label: &str) {
+        self.inner.insert_debug_marker(label);
+    }
+
+    /// Start record commands and group it into debug marker group.
+    pub fn push_debug_group(&mut self, label: &str) {
+        self.inner.push_debug_group(label);
+    }
+
+    /// Stops command recording and creates debug group.
+    pub fn pop_debug_group(&mut self) {
+        self.inner.pop_debug_group();
+    }
+
+    /// Draws primitives from the active vertex buffer(s).
+    ///
+    /// The active vertex buffer(s) can be set with [`RenderPass::set_vertex_buffer`].
+    /// Does not use an Index Buffer. If you need this see [`RenderPass::draw_indexed`]
+    ///
+    /// Panics if vertices Range is outside of the range of the vertices range of any set vertex buffer.
+    ///
+    /// vertices: The range of vertices to draw.
+    /// instances: Range of Instances to draw. Use 0..1 if instance buffers are not used.
+    /// E.g.of how its used internally
+    /// ```rust ignore
+    /// for instance_id in instance_range {
+    ///     for vertex_id in vertex_range {
+    ///         let vertex = vertex[vertex_id];
+    ///         vertex_shader(vertex, vertex_id, instance_id);
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
+    /// It is not affected by changes to the state that are performed after it is called.
+    pub fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
+        self.inner.draw(vertices, instances);
+    }
+
+    /// Draws indexed primitives using the active index buffer and the active vertex buffers.
+    ///
+    /// The active index buffer can be set with [`RenderPass::set_index_buffer`]
+    /// The active vertex buffers can be set with [`RenderPass::set_vertex_buffer`].
+    ///
+    /// Panics if indices Range is outside of the range of the indices range of any set index buffer.
+    ///
+    /// indices: The range of indices to draw.
+    /// base_vertex: value added to each index value before indexing into the vertex buffers.
+    /// instances: Range of Instances to draw. Use 0..1 if instance buffers are not used.
+    /// E.g.of how its used internally
+    /// ```rust ignore
+    /// for instance_id in instance_range {
+    ///     for index_index in index_range {
+    ///         let vertex_id = index_buffer[index_index];
+    ///         let adjusted_vertex_id = vertex_id + base_vertex;
+    ///         let vertex = vertex[adjusted_vertex_id];
+    ///         vertex_shader(vertex, adjusted_vertex_id, instance_id);
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
+    /// It is not affected by changes to the state that are performed after it is called.
+    pub fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>) {
+        self.inner.draw_indexed(indices, base_vertex, instances);
+    }
+
+    /// Draws primitives from the active vertex buffer(s) based on the contents of the `indirect_buffer`.
+    ///
+    /// This is like calling [`RenderPass::draw`] but the contents of the call are specified in the `indirect_buffer`.
+    /// The structure expected in `indirect_buffer` must conform to [`DrawIndirectArgs`](crate::util::DrawIndirectArgs).
+    ///
+    /// Indirect drawing has some caveats depending on the features available. We are not currently able to validate
+    /// these and issue an error.
+    /// - If [`Features::INDIRECT_FIRST_INSTANCE`] is not present on the adapter,
+    ///   [`DrawIndirect::first_instance`](crate::util::DrawIndirectArgs::first_instance) will be ignored.
+    /// - If [`DownlevelFlags::VERTEX_AND_INSTANCE_INDEX_RESPECTS_RESPECTIVE_FIRST_VALUE_IN_INDIRECT_DRAW`] is not present on the adapter,
+    ///   any use of `@builtin(vertex_index)` or `@builtin(instance_index)` in the vertex shader will have different values.
+    ///
+    /// See details on the individual flags for more information.
+    pub fn draw_indirect(&mut self, indirect_buffer: &Buffer, indirect_offset: BufferAddress) {
+        self.inner
+            .draw_indirect(&indirect_buffer.inner, indirect_offset);
+    }
+
+    /// Draws indexed primitives using the active index buffer and the active vertex buffers,
+    /// based on the contents of the `indirect_buffer`.
+    ///
+    /// This is like calling [`RenderPass::draw_indexed`] but the contents of the call are specified in the `indirect_buffer`.
+    /// The structure expected in `indirect_buffer` must conform to [`DrawIndexedIndirectArgs`](crate::util::DrawIndexedIndirectArgs).
+    ///
+    /// Indirect drawing has some caveats depending on the features available. We are not currently able to validate
+    /// these and issue an error.
+    /// - If [`Features::INDIRECT_FIRST_INSTANCE`] is not present on the adapter,
+    ///   [`DrawIndexedIndirect::first_instance`](crate::util::DrawIndexedIndirectArgs::first_instance) will be ignored.
+    /// - If [`DownlevelFlags::VERTEX_AND_INSTANCE_INDEX_RESPECTS_RESPECTIVE_FIRST_VALUE_IN_INDIRECT_DRAW`] is not present on the adapter,
+    ///   any use of `@builtin(vertex_index)` or `@builtin(instance_index)` in the vertex shader will have different values.
+    ///
+    /// See details on the individual flags for more information.
+    pub fn draw_indexed_indirect(
+        &mut self,
+        indirect_buffer: &Buffer,
+        indirect_offset: BufferAddress,
+    ) {
+        self.inner
+            .draw_indexed_indirect(&indirect_buffer.inner, indirect_offset);
+    }
+
+    /// Execute a [render bundle][RenderBundle], which is a set of pre-recorded commands
+    /// that can be run together.
+    ///
+    /// Commands in the bundle do not inherit this render pass's current render state, and after the
+    /// bundle has executed, the state is **cleared** (reset to defaults, not the previous state).
+    pub fn execute_bundles<'a, I: IntoIterator<Item = &'a RenderBundle>>(
+        &mut self,
+        render_bundles: I,
+    ) {
+        let mut render_bundles = render_bundles.into_iter().map(|rb| &rb.inner);
+
+        self.inner.execute_bundles(&mut render_bundles);
+    }
+}
+
+/// [`Features::MULTI_DRAW_INDIRECT`] must be enabled on the device in order to call these functions.
+impl RenderPass<'_> {
+    /// Dispatches multiple draw calls from the active vertex buffer(s) based on the contents of the `indirect_buffer`.
+    /// `count` draw calls are issued.
+    ///
+    /// The active vertex buffers can be set with [`RenderPass::set_vertex_buffer`].
+    ///
+    /// The structure expected in `indirect_buffer` must conform to [`DrawIndirectArgs`](crate::util::DrawIndirectArgs).
+    /// These draw structures are expected to be tightly packed.
+    ///
+    /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
+    /// It is not affected by changes to the state that are performed after it is called.
+    pub fn multi_draw_indirect(
+        &mut self,
+        indirect_buffer: &Buffer,
+        indirect_offset: BufferAddress,
+        count: u32,
+    ) {
+        self.inner
+            .multi_draw_indirect(&indirect_buffer.inner, indirect_offset, count);
+    }
+
+    /// Dispatches multiple draw calls from the active index buffer and the active vertex buffers,
+    /// based on the contents of the `indirect_buffer`. `count` draw calls are issued.
+    ///
+    /// The active index buffer can be set with [`RenderPass::set_index_buffer`], while the active
+    /// vertex buffers can be set with [`RenderPass::set_vertex_buffer`].
+    ///
+    /// The structure expected in `indirect_buffer` must conform to [`DrawIndexedIndirectArgs`](crate::util::DrawIndexedIndirectArgs).
+    /// These draw structures are expected to be tightly packed.
+    ///
+    /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
+    /// It is not affected by changes to the state that are performed after it is called.
+    pub fn multi_draw_indexed_indirect(
+        &mut self,
+        indirect_buffer: &Buffer,
+        indirect_offset: BufferAddress,
+        count: u32,
+    ) {
+        self.inner
+            .multi_draw_indexed_indirect(&indirect_buffer.inner, indirect_offset, count);
+    }
+}
+
+/// [`Features::MULTI_DRAW_INDIRECT_COUNT`] must be enabled on the device in order to call these functions.
+impl RenderPass<'_> {
+    /// Dispatches multiple draw calls from the active vertex buffer(s) based on the contents of the `indirect_buffer`.
+    /// The count buffer is read to determine how many draws to issue.
+    ///
+    /// The indirect buffer must be long enough to account for `max_count` draws, however only `count`
+    /// draws will be read. If `count` is greater than `max_count`, `max_count` will be used.
+    ///
+    /// The active vertex buffers can be set with [`RenderPass::set_vertex_buffer`].
+    ///
+    /// The structure expected in `indirect_buffer` must conform to [`DrawIndirectArgs`](crate::util::DrawIndirectArgs).
+    /// These draw structures are expected to be tightly packed.
+    ///
+    /// The structure expected in `count_buffer` is the following:
+    ///
+    /// ```rust
+    /// #[repr(C)]
+    /// struct DrawIndirectCount {
+    ///     count: u32, // Number of draw calls to issue.
+    /// }
+    /// ```
+    ///
+    /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
+    /// It is not affected by changes to the state that are performed after it is called.
+    pub fn multi_draw_indirect_count(
+        &mut self,
+        indirect_buffer: &Buffer,
+        indirect_offset: BufferAddress,
+        count_buffer: &Buffer,
+        count_offset: BufferAddress,
+        max_count: u32,
+    ) {
+        self.inner.multi_draw_indirect_count(
+            &indirect_buffer.inner,
+            indirect_offset,
+            &count_buffer.inner,
+            count_offset,
+            max_count,
+        );
+    }
+
+    /// Dispatches multiple draw calls from the active index buffer and the active vertex buffers,
+    /// based on the contents of the `indirect_buffer`. The count buffer is read to determine how many draws to issue.
+    ///
+    /// The indirect buffer must be long enough to account for `max_count` draws, however only `count`
+    /// draws will be read. If `count` is greater than `max_count`, `max_count` will be used.
+    ///
+    /// The active index buffer can be set with [`RenderPass::set_index_buffer`], while the active
+    /// vertex buffers can be set with [`RenderPass::set_vertex_buffer`].
+    ///
+    ///
+    /// The structure expected in `indirect_buffer` must conform to [`DrawIndexedIndirectArgs`](crate::util::DrawIndexedIndirectArgs).
+    ///
+    /// These draw structures are expected to be tightly packed.
+    ///
+    /// The structure expected in `count_buffer` is the following:
+    ///
+    /// ```rust
+    /// #[repr(C)]
+    /// struct DrawIndexedIndirectCount {
+    ///     count: u32, // Number of draw calls to issue.
+    /// }
+    /// ```
+    ///
+    /// This drawing command uses the current render state, as set by preceding `set_*()` methods.
+    /// It is not affected by changes to the state that are performed after it is called.
+    pub fn multi_draw_indexed_indirect_count(
+        &mut self,
+        indirect_buffer: &Buffer,
+        indirect_offset: BufferAddress,
+        count_buffer: &Buffer,
+        count_offset: BufferAddress,
+        max_count: u32,
+    ) {
+        self.inner.multi_draw_indexed_indirect_count(
+            &indirect_buffer.inner,
+            indirect_offset,
+            &count_buffer.inner,
+            count_offset,
+            max_count,
+        );
+    }
+}
+
+/// [`Features::PUSH_CONSTANTS`] must be enabled on the device in order to call these functions.
+impl RenderPass<'_> {
+    /// Set push constant data for subsequent draw calls.
+    ///
+    /// Write the bytes in `data` at offset `offset` within push constant
+    /// storage, all of which are accessible by all the pipeline stages in
+    /// `stages`, and no others.  Both `offset` and the length of `data` must be
+    /// multiples of [`PUSH_CONSTANT_ALIGNMENT`], which is always 4.
+    ///
+    /// For example, if `offset` is `4` and `data` is eight bytes long, this
+    /// call will write `data` to bytes `4..12` of push constant storage.
+    ///
+    /// # Stage matching
+    ///
+    /// Every byte in the affected range of push constant storage must be
+    /// accessible to exactly the same set of pipeline stages, which must match
+    /// `stages`. If there are two bytes of storage that are accessible by
+    /// different sets of pipeline stages - say, one is accessible by fragment
+    /// shaders, and the other is accessible by both fragment shaders and vertex
+    /// shaders - then no single `set_push_constants` call may affect both of
+    /// them; to write both, you must make multiple calls, each with the
+    /// appropriate `stages` value.
+    ///
+    /// Which pipeline stages may access a given byte is determined by the
+    /// pipeline's [`PushConstant`] global variable and (if it is a struct) its
+    /// members' offsets.
+    ///
+    /// For example, suppose you have twelve bytes of push constant storage,
+    /// where bytes `0..8` are accessed by the vertex shader, and bytes `4..12`
+    /// are accessed by the fragment shader. This means there are three byte
+    /// ranges each accessed by a different set of stages:
+    ///
+    /// - Bytes `0..4` are accessed only by the fragment shader.
+    ///
+    /// - Bytes `4..8` are accessed by both the fragment shader and the vertex shader.
+    ///
+    /// - Bytes `8..12` are accessed only by the vertex shader.
+    ///
+    /// To write all twelve bytes requires three `set_push_constants` calls, one
+    /// for each range, each passing the matching `stages` mask.
+    ///
+    /// [`PushConstant`]: https://docs.rs/naga/latest/naga/enum.StorageClass.html#variant.PushConstant
+    pub fn set_push_constants(&mut self, stages: ShaderStages, offset: u32, data: &[u8]) {
+        self.inner.set_push_constants(stages, offset, data);
+    }
+}
+
+/// [`Features::TIMESTAMP_QUERY_INSIDE_PASSES`] must be enabled on the device in order to call these functions.
+impl RenderPass<'_> {
+    /// Issue a timestamp command at this point in the queue. The
+    /// timestamp will be written to the specified query set, at the specified index.
+    ///
+    /// Must be multiplied by [`Queue::get_timestamp_period`] to get
+    /// the value in nanoseconds. Absolute values have no meaning,
+    /// but timestamps can be subtracted to get the time it takes
+    /// for a string of operations to complete.
+    pub fn write_timestamp(&mut self, query_set: &QuerySet, query_index: u32) {
+        self.inner.write_timestamp(&query_set.inner, query_index);
+    }
+}
+
+impl RenderPass<'_> {
+    /// Start a occlusion query on this render pass. It can be ended with
+    /// `end_occlusion_query`. Occlusion queries may not be nested.
+    pub fn begin_occlusion_query(&mut self, query_index: u32) {
+        self.inner.begin_occlusion_query(query_index);
+    }
+
+    /// End the occlusion query on this render pass. It can be started with
+    /// `begin_occlusion_query`. Occlusion queries may not be nested.
+    pub fn end_occlusion_query(&mut self) {
+        self.inner.end_occlusion_query();
+    }
+}
+
+/// [`Features::PIPELINE_STATISTICS_QUERY`] must be enabled on the device in order to call these functions.
+impl RenderPass<'_> {
+    /// Start a pipeline statistics query on this render pass. It can be ended with
+    /// `end_pipeline_statistics_query`. Pipeline statistics queries may not be nested.
+    pub fn begin_pipeline_statistics_query(&mut self, query_set: &QuerySet, query_index: u32) {
+        self.inner
+            .begin_pipeline_statistics_query(&query_set.inner, query_index);
+    }
+
+    /// End the pipeline statistics query on this render pass. It can be started with
+    /// `begin_pipeline_statistics_query`. Pipeline statistics queries may not be nested.
+    pub fn end_pipeline_statistics_query(&mut self) {
+        self.inner.end_pipeline_statistics_query();
+    }
+}
+
+/// Describes the timestamp writes of a render pass.
+///
+/// For use with [`RenderPassDescriptor`].
+/// At least one of `beginning_of_pass_write_index` and `end_of_pass_write_index` must be `Some`.
+///
+/// Corresponds to [WebGPU `GPURenderPassTimestampWrite`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpurenderpasstimestampwrites).
+#[derive(Clone, Debug)]
+pub struct RenderPassTimestampWrites<'a> {
+    /// The query set to write to.
+    pub query_set: &'a QuerySet,
+    /// The index of the query set at which a start timestamp of this pass is written, if any.
+    pub beginning_of_pass_write_index: Option<u32>,
+    /// The index of the query set at which an end timestamp of this pass is written, if any.
+    pub end_of_pass_write_index: Option<u32>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(RenderPassTimestampWrites<'_>: Send, Sync);
+
+/// Describes a color attachment to a [`RenderPass`].
+///
+/// For use with [`RenderPassDescriptor`].
+///
+/// Corresponds to [WebGPU `GPURenderPassColorAttachment`](
+/// https://gpuweb.github.io/gpuweb/#color-attachments).
+#[derive(Clone, Debug)]
+pub struct RenderPassColorAttachment<'tex> {
+    /// The view to use as an attachment.
+    pub view: &'tex TextureView,
+    /// The view that will receive the resolved output if multisampling is used.
+    ///
+    /// If set, it is always written to, regardless of how [`Self::ops`] is configured.
+    pub resolve_target: Option<&'tex TextureView>,
+    /// What operations will be performed on this color attachment.
+    pub ops: Operations<Color>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(RenderPassColorAttachment<'_>: Send, Sync);
+
+/// Describes a depth/stencil attachment to a [`RenderPass`].
+///
+/// For use with [`RenderPassDescriptor`].
+///
+/// Corresponds to [WebGPU `GPURenderPassDepthStencilAttachment`](
+/// https://gpuweb.github.io/gpuweb/#depth-stencil-attachments).
+#[derive(Clone, Debug)]
+pub struct RenderPassDepthStencilAttachment<'tex> {
+    /// The view to use as an attachment.
+    pub view: &'tex TextureView,
+    /// What operations will be performed on the depth part of the attachment.
+    pub depth_ops: Option<Operations<f32>>,
+    /// What operations will be performed on the stencil part of the attachment.
+    pub stencil_ops: Option<Operations<u32>>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(RenderPassDepthStencilAttachment<'_>: Send, Sync);
+
+/// Describes the attachments of a render pass.
+///
+/// For use with [`CommandEncoder::begin_render_pass`].
+///
+/// Corresponds to [WebGPU `GPURenderPassDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpurenderpassdescriptor).
+#[derive(Clone, Debug, Default)]
+pub struct RenderPassDescriptor<'a> {
+    /// Debug label of the render pass. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// The color attachments of the render pass.
+    pub color_attachments: &'a [Option<RenderPassColorAttachment<'a>>],
+    /// The depth and stencil attachment of the render pass, if any.
+    pub depth_stencil_attachment: Option<RenderPassDepthStencilAttachment<'a>>,
+    /// Defines which timestamp values will be written for this pass, and where to write them to.
+    ///
+    /// Requires [`Features::TIMESTAMP_QUERY`] to be enabled.
+    pub timestamp_writes: Option<RenderPassTimestampWrites<'a>>,
+    /// Defines where the occlusion query results will be stored for this pass.
+    pub occlusion_query_set: Option<&'a QuerySet>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(RenderPassDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/render_pipeline.rs

@@ -0,0 +1,153 @@
+use std::num::NonZeroU32;
+
+use crate::*;
+
+/// Handle to a rendering (graphics) pipeline.
+///
+/// A `RenderPipeline` object represents a graphics pipeline and its stages, bindings, vertex
+/// buffers and targets. It can be created with [`Device::create_render_pipeline`].
+///
+/// Corresponds to [WebGPU `GPURenderPipeline`](https://gpuweb.github.io/gpuweb/#render-pipeline).
+#[derive(Debug, Clone)]
+pub struct RenderPipeline {
+    pub(crate) inner: dispatch::DispatchRenderPipeline,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(RenderPipeline: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(RenderPipeline => .inner);
+
+impl RenderPipeline {
+    /// Get an object representing the bind group layout at a given index.
+    ///
+    /// If this pipeline was created with a [default layout][RenderPipelineDescriptor::layout], then
+    /// bind groups created with the returned `BindGroupLayout` can only be used with this pipeline.
+    ///
+    /// This method will raise a validation error if there is no bind group layout at `index`.
+    pub fn get_bind_group_layout(&self, index: u32) -> BindGroupLayout {
+        let layout = self.inner.get_bind_group_layout(index);
+        BindGroupLayout { inner: layout }
+    }
+}
+
+/// Describes how the vertex buffer is interpreted.
+///
+/// For use in [`VertexState`].
+///
+/// Corresponds to [WebGPU `GPUVertexBufferLayout`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpuvertexbufferlayout).
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub struct VertexBufferLayout<'a> {
+    /// The stride, in bytes, between elements of this buffer.
+    pub array_stride: BufferAddress,
+    /// How often this vertex buffer is "stepped" forward.
+    pub step_mode: VertexStepMode,
+    /// The list of attributes which comprise a single vertex.
+    pub attributes: &'a [VertexAttribute],
+}
+static_assertions::assert_impl_all!(VertexBufferLayout<'_>: Send, Sync);
+
+/// Describes the vertex processing in a render pipeline.
+///
+/// For use in [`RenderPipelineDescriptor`].
+///
+/// Corresponds to [WebGPU `GPUVertexState`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpuvertexstate).
+#[derive(Clone, Debug)]
+pub struct VertexState<'a> {
+    /// The compiled shader module for this stage.
+    pub module: &'a ShaderModule,
+    /// The name of the entry point in the compiled shader to use.
+    ///
+    /// If [`Some`], there must be a vertex-stage shader entry point with this name in `module`.
+    /// Otherwise, expect exactly one vertex-stage entry point in `module`, which will be
+    /// selected.
+    // NOTE: keep phrasing in sync. with `ComputePipelineDescriptor::entry_point`
+    // NOTE: keep phrasing in sync. with `FragmentState::entry_point`
+    pub entry_point: Option<&'a str>,
+    /// Advanced options for when this pipeline is compiled
+    ///
+    /// This implements `Default`, and for most users can be set to `Default::default()`
+    pub compilation_options: PipelineCompilationOptions<'a>,
+    /// The format of any vertex buffers used with this pipeline.
+    pub buffers: &'a [VertexBufferLayout<'a>],
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(VertexState<'_>: Send, Sync);
+
+/// Describes the fragment processing in a render pipeline.
+///
+/// For use in [`RenderPipelineDescriptor`].
+///
+/// Corresponds to [WebGPU `GPUFragmentState`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpufragmentstate).
+#[derive(Clone, Debug)]
+pub struct FragmentState<'a> {
+    /// The compiled shader module for this stage.
+    pub module: &'a ShaderModule,
+    /// The name of the entry point in the compiled shader to use.
+    ///
+    /// If [`Some`], there must be a `@fragment` shader entry point with this name in `module`.
+    /// Otherwise, expect exactly one fragment-stage entry point in `module`, which will be
+    /// selected.
+    // NOTE: keep phrasing in sync. with `ComputePipelineDescriptor::entry_point`
+    // NOTE: keep phrasing in sync. with `VertexState::entry_point`
+    pub entry_point: Option<&'a str>,
+    /// Advanced options for when this pipeline is compiled
+    ///
+    /// This implements `Default`, and for most users can be set to `Default::default()`
+    pub compilation_options: PipelineCompilationOptions<'a>,
+    /// The color state of the render targets.
+    pub targets: &'a [Option<ColorTargetState>],
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(FragmentState<'_>: Send, Sync);
+
+/// Describes a render (graphics) pipeline.
+///
+/// For use with [`Device::create_render_pipeline`].
+///
+/// Corresponds to [WebGPU `GPURenderPipelineDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpurenderpipelinedescriptor).
+#[derive(Clone, Debug)]
+pub struct RenderPipelineDescriptor<'a> {
+    /// Debug label of the pipeline. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// The layout of bind groups for this pipeline.
+    ///
+    /// If this is set, then [`Device::create_render_pipeline`] will raise a validation error if
+    /// the layout doesn't match what the shader module(s) expect.
+    ///
+    /// Using the same [`PipelineLayout`] for many [`RenderPipeline`] or [`ComputePipeline`]
+    /// pipelines guarantees that you don't have to rebind any resources when switching between
+    /// those pipelines.
+    ///
+    /// ## Default pipeline layout
+    ///
+    /// If `layout` is `None`, then the pipeline has a [default layout] created and used instead.
+    /// The default layout is deduced from the shader modules.
+    ///
+    /// You can use [`RenderPipeline::get_bind_group_layout`] to create bind groups for use with the
+    /// default layout. However, these bind groups cannot be used with any other pipelines. This is
+    /// convenient for simple pipelines, but using an explicit layout is recommended in most cases.
+    ///
+    /// [default layout]: https://www.w3.org/TR/webgpu/#default-pipeline-layout
+    pub layout: Option<&'a PipelineLayout>,
+    /// The compiled vertex stage, its entry point, and the input buffers layout.
+    pub vertex: VertexState<'a>,
+    /// The properties of the pipeline at the primitive assembly and rasterization level.
+    pub primitive: PrimitiveState,
+    /// The effect of draw calls on the depth and stencil aspects of the output target, if any.
+    pub depth_stencil: Option<DepthStencilState>,
+    /// The multi-sampling properties of the pipeline.
+    pub multisample: MultisampleState,
+    /// The compiled fragment stage, its entry point, and the color targets.
+    pub fragment: Option<FragmentState<'a>>,
+    /// If the pipeline will be used with a multiview render pass, this indicates how many array
+    /// layers the attachments will have.
+    pub multiview: Option<NonZeroU32>,
+    /// The pipeline cache to use when creating this pipeline.
+    pub cache: Option<&'a PipelineCache>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(RenderPipelineDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/sampler.rs

@@ -0,0 +1,28 @@
+use crate::*;
+
+/// Handle to a sampler.
+///
+/// A `Sampler` object defines how a pipeline will sample from a [`TextureView`]. Samplers define
+/// image filters (including anisotropy) and address (wrapping) modes, among other things. See
+/// the documentation for [`SamplerDescriptor`] for more information.
+///
+/// It can be created with [`Device::create_sampler`].
+///
+/// Corresponds to [WebGPU `GPUSampler`](https://gpuweb.github.io/gpuweb/#sampler-interface).
+#[derive(Debug, Clone)]
+pub struct Sampler {
+    pub(crate) inner: dispatch::DispatchSampler,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(Sampler: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(Sampler => .inner);
+
+/// Describes a [`Sampler`].
+///
+/// For use with [`Device::create_sampler`].
+///
+/// Corresponds to [WebGPU `GPUSamplerDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpusamplerdescriptor).
+pub type SamplerDescriptor<'a> = wgt::SamplerDescriptor<Label<'a>>;
+static_assertions::assert_impl_all!(SamplerDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/shader_module.rs

@@ -0,0 +1,230 @@
+use std::{borrow::Cow, future::Future, marker::PhantomData};
+
+use crate::*;
+
+/// Handle to a compiled shader module.
+///
+/// A `ShaderModule` represents a compiled shader module on the GPU. It can be created by passing
+/// source code to [`Device::create_shader_module`] or valid SPIR-V binary to
+/// [`Device::create_shader_module_spirv`]. Shader modules are used to define programmable stages
+/// of a pipeline.
+///
+/// Corresponds to [WebGPU `GPUShaderModule`](https://gpuweb.github.io/gpuweb/#shader-module).
+#[derive(Debug, Clone)]
+pub struct ShaderModule {
+    pub(crate) inner: dispatch::DispatchShaderModule,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(ShaderModule: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(ShaderModule => .inner);
+
+impl ShaderModule {
+    /// Get the compilation info for the shader module.
+    pub fn get_compilation_info(&self) -> impl Future<Output = CompilationInfo> + WasmNotSend {
+        self.inner.get_compilation_info()
+    }
+}
+
+/// Compilation information for a shader module.
+///
+/// Corresponds to [WebGPU `GPUCompilationInfo`](https://gpuweb.github.io/gpuweb/#gpucompilationinfo).
+/// The source locations use bytes, and index a UTF-8 encoded string.
+#[derive(Debug, Clone)]
+pub struct CompilationInfo {
+    /// The messages from the shader compilation process.
+    pub messages: Vec<CompilationMessage>,
+}
+
+/// A single message from the shader compilation process.
+///
+/// Roughly corresponds to [`GPUCompilationMessage`](https://www.w3.org/TR/webgpu/#gpucompilationmessage),
+/// except that the location uses UTF-8 for all positions.
+#[derive(Debug, Clone)]
+pub struct CompilationMessage {
+    /// The text of the message.
+    pub message: String,
+    /// The type of the message.
+    pub message_type: CompilationMessageType,
+    /// Where in the source code the message points at.
+    pub location: Option<SourceLocation>,
+}
+
+/// The type of a compilation message.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CompilationMessageType {
+    /// An error message.
+    Error,
+    /// A warning message.
+    Warning,
+    /// An informational message.
+    Info,
+}
+
+/// A human-readable representation for a span, tailored for text source.
+///
+/// Roughly corresponds to the positional members of [`GPUCompilationMessage`][gcm] from
+/// the WebGPU specification, except
+/// - `offset` and `length` are in bytes (UTF-8 code units), instead of UTF-16 code units.
+/// - `line_position` is in bytes (UTF-8 code units), and is usually not directly intended for humans.
+///
+/// [gcm]: https://www.w3.org/TR/webgpu/#gpucompilationmessage
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct SourceLocation {
+    /// 1-based line number.
+    pub line_number: u32,
+    /// 1-based column in code units (in bytes) of the start of the span.
+    /// Remember to convert accordingly when displaying to the user.
+    pub line_position: u32,
+    /// 0-based Offset in code units (in bytes) of the start of the span.
+    pub offset: u32,
+    /// Length in code units (in bytes) of the span.
+    pub length: u32,
+}
+
+#[cfg(all(feature = "wgsl", wgpu_core))]
+impl From<crate::naga::error::ShaderError<crate::naga::front::wgsl::ParseError>>
+    for CompilationInfo
+{
+    fn from(value: crate::naga::error::ShaderError<crate::naga::front::wgsl::ParseError>) -> Self {
+        CompilationInfo {
+            messages: vec![CompilationMessage {
+                message: value.to_string(),
+                message_type: CompilationMessageType::Error,
+                location: value.inner.location(&value.source).map(Into::into),
+            }],
+        }
+    }
+}
+#[cfg(feature = "glsl")]
+impl From<naga::error::ShaderError<naga::front::glsl::ParseErrors>> for CompilationInfo {
+    fn from(value: naga::error::ShaderError<naga::front::glsl::ParseErrors>) -> Self {
+        let messages = value
+            .inner
+            .errors
+            .into_iter()
+            .map(|err| CompilationMessage {
+                message: err.to_string(),
+                message_type: CompilationMessageType::Error,
+                location: err.location(&value.source).map(Into::into),
+            })
+            .collect();
+        CompilationInfo { messages }
+    }
+}
+
+#[cfg(feature = "spirv")]
+impl From<naga::error::ShaderError<naga::front::spv::Error>> for CompilationInfo {
+    fn from(value: naga::error::ShaderError<naga::front::spv::Error>) -> Self {
+        CompilationInfo {
+            messages: vec![CompilationMessage {
+                message: value.to_string(),
+                message_type: CompilationMessageType::Error,
+                location: None,
+            }],
+        }
+    }
+}
+
+#[cfg(any(wgpu_core, naga))]
+impl
+    From<
+        crate::naga::error::ShaderError<crate::naga::WithSpan<crate::naga::valid::ValidationError>>,
+    > for CompilationInfo
+{
+    fn from(
+        value: crate::naga::error::ShaderError<
+            crate::naga::WithSpan<crate::naga::valid::ValidationError>,
+        >,
+    ) -> Self {
+        CompilationInfo {
+            messages: vec![CompilationMessage {
+                message: value.to_string(),
+                message_type: CompilationMessageType::Error,
+                location: value.inner.location(&value.source).map(Into::into),
+            }],
+        }
+    }
+}
+
+#[cfg(any(wgpu_core, naga))]
+impl From<crate::naga::SourceLocation> for SourceLocation {
+    fn from(value: crate::naga::SourceLocation) -> Self {
+        SourceLocation {
+            length: value.length,
+            offset: value.offset,
+            line_number: value.line_number,
+            line_position: value.line_position,
+        }
+    }
+}
+
+/// Source of a shader module.
+///
+/// The source will be parsed and validated.
+///
+/// Any necessary shader translation (e.g. from WGSL to SPIR-V or vice versa)
+/// will be done internally by wgpu.
+///
+/// This type is unique to the Rust API of `wgpu`. In the WebGPU specification,
+/// only WGSL source code strings are accepted.
+#[cfg_attr(feature = "naga-ir", expect(clippy::large_enum_variant))]
+#[derive(Clone, Debug)]
+#[non_exhaustive]
+pub enum ShaderSource<'a> {
+    /// SPIR-V module represented as a slice of words.
+    ///
+    /// See also: [`util::make_spirv`], [`include_spirv`]
+    #[cfg(feature = "spirv")]
+    SpirV(Cow<'a, [u32]>),
+    /// GLSL module as a string slice.
+    ///
+    /// Note: GLSL is not yet fully supported and must be a specific ShaderStage.
+    #[cfg(feature = "glsl")]
+    Glsl {
+        /// The source code of the shader.
+        shader: Cow<'a, str>,
+        /// The shader stage that the shader targets. For example, `naga::ShaderStage::Vertex`
+        stage: naga::ShaderStage,
+        /// Defines to unlock configured shader features.
+        defines: naga::FastHashMap<String, String>,
+    },
+    /// WGSL module as a string slice.
+    #[cfg(feature = "wgsl")]
+    Wgsl(Cow<'a, str>),
+    /// Naga module.
+    #[cfg(feature = "naga-ir")]
+    Naga(Cow<'static, naga::Module>),
+    /// Dummy variant because `Naga` doesn't have a lifetime and without enough active features it
+    /// could be the last one active.
+    #[doc(hidden)]
+    Dummy(PhantomData<&'a ()>),
+}
+static_assertions::assert_impl_all!(ShaderSource<'_>: Send, Sync);
+
+/// Descriptor for use with [`Device::create_shader_module`].
+///
+/// Corresponds to [WebGPU `GPUShaderModuleDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gpushadermoduledescriptor).
+#[derive(Clone, Debug)]
+pub struct ShaderModuleDescriptor<'a> {
+    /// Debug label of the shader module. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// Source code for the shader.
+    pub source: ShaderSource<'a>,
+}
+static_assertions::assert_impl_all!(ShaderModuleDescriptor<'_>: Send, Sync);
+
+/// Descriptor for a shader module given by SPIR-V binary, for use with
+/// [`Device::create_shader_module_spirv`].
+///
+/// This type is unique to the Rust API of `wgpu`. In the WebGPU specification,
+/// only WGSL source code strings are accepted.
+#[derive(Debug)]
+pub struct ShaderModuleDescriptorSpirV<'a> {
+    /// Debug label of the shader module. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// Binary SPIR-V data, in 4-byte words.
+    pub source: Cow<'a, [u32]>,
+}
+static_assertions::assert_impl_all!(ShaderModuleDescriptorSpirV<'_>: Send, Sync);

vendor/wgpu/src/api/surface.rs

@@ -0,0 +1,389 @@
+use std::{error, fmt};
+
+use parking_lot::Mutex;
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
+
+use crate::*;
+
+/// Describes a [`Surface`].
+///
+/// For use with [`Surface::configure`].
+///
+/// Corresponds to [WebGPU `GPUCanvasConfiguration`](
+/// https://gpuweb.github.io/gpuweb/#canvas-configuration).
+pub type SurfaceConfiguration = wgt::SurfaceConfiguration<Vec<TextureFormat>>;
+static_assertions::assert_impl_all!(SurfaceConfiguration: Send, Sync);
+
+/// Handle to a presentable surface.
+///
+/// A `Surface` represents a platform-specific surface (e.g. a window) onto which rendered images may
+/// be presented. A `Surface` may be created with the function [`Instance::create_surface`].
+///
+/// This type is unique to the Rust API of `wgpu`. In the WebGPU specification,
+/// [`GPUCanvasContext`](https://gpuweb.github.io/gpuweb/#canvas-context)
+/// serves a similar role.
+pub struct Surface<'window> {
+    /// Additional surface data returned by [`DynContext::instance_create_surface`].
+    pub(crate) inner: dispatch::DispatchSurface,
+
+    // Stores the latest `SurfaceConfiguration` that was set using `Surface::configure`.
+    // It is required to set the attributes of the `SurfaceTexture` in the
+    // `Surface::get_current_texture` method.
+    // Because the `Surface::configure` method operates on an immutable reference this type has to
+    // be wrapped in a mutex and since the configuration is only supplied after the surface has
+    // been created is is additionally wrapped in an option.
+    pub(crate) config: Mutex<Option<SurfaceConfiguration>>,
+
+    /// Optionally, keep the source of the handle used for the surface alive.
+    ///
+    /// This is useful for platforms where the surface is created from a window and the surface
+    /// would become invalid when the window is dropped.
+    ///
+    /// SAFETY: This field must be dropped *after* all other fields to ensure proper cleanup.
+    pub(crate) _handle_source: Option<Box<dyn WindowHandle + 'window>>,
+}
+
+impl Surface<'_> {
+    /// Returns the capabilities of the surface when used with the given adapter.
+    ///
+    /// Returns specified values (see [`SurfaceCapabilities`]) if surface is incompatible with the adapter.
+    pub fn get_capabilities(&self, adapter: &Adapter) -> SurfaceCapabilities {
+        self.inner.get_capabilities(&adapter.inner)
+    }
+
+    /// Return a default `SurfaceConfiguration` from width and height to use for the [`Surface`] with this adapter.
+    ///
+    /// Returns None if the surface isn't supported by this adapter
+    pub fn get_default_config(
+        &self,
+        adapter: &Adapter,
+        width: u32,
+        height: u32,
+    ) -> Option<SurfaceConfiguration> {
+        let caps = self.get_capabilities(adapter);
+        Some(SurfaceConfiguration {
+            usage: wgt::TextureUsages::RENDER_ATTACHMENT,
+            format: *caps.formats.first()?,
+            width,
+            height,
+            desired_maximum_frame_latency: 2,
+            present_mode: *caps.present_modes.first()?,
+            alpha_mode: wgt::CompositeAlphaMode::Auto,
+            view_formats: vec![],
+        })
+    }
+
+    /// Initializes [`Surface`] for presentation.
+    ///
+    /// # Panics
+    ///
+    /// - A old [`SurfaceTexture`] is still alive referencing an old surface.
+    /// - Texture format requested is unsupported on the surface.
+    /// - `config.width` or `config.height` is zero.
+    pub fn configure(&self, device: &Device, config: &SurfaceConfiguration) {
+        self.inner.configure(&device.inner, config);
+
+        let mut conf = self.config.lock();
+        *conf = Some(config.clone());
+    }
+
+    /// Returns the next texture to be presented by the swapchain for drawing.
+    ///
+    /// In order to present the [`SurfaceTexture`] returned by this method,
+    /// first a [`Queue::submit`] needs to be done with some work rendering to this texture.
+    /// Then [`SurfaceTexture::present`] needs to be called.
+    ///
+    /// If a SurfaceTexture referencing this surface is alive when the swapchain is recreated,
+    /// recreating the swapchain will panic.
+    pub fn get_current_texture(&self) -> Result<SurfaceTexture, SurfaceError> {
+        let (texture, status, detail) = self.inner.get_current_texture();
+
+        let suboptimal = match status {
+            SurfaceStatus::Good => false,
+            SurfaceStatus::Suboptimal => true,
+            SurfaceStatus::Timeout => return Err(SurfaceError::Timeout),
+            SurfaceStatus::Outdated => return Err(SurfaceError::Outdated),
+            SurfaceStatus::Lost => return Err(SurfaceError::Lost),
+            SurfaceStatus::Unknown => return Err(SurfaceError::Other),
+        };
+
+        let guard = self.config.lock();
+        let config = guard
+            .as_ref()
+            .expect("This surface has not been configured yet.");
+
+        let descriptor = TextureDescriptor {
+            label: None,
+            size: Extent3d {
+                width: config.width,
+                height: config.height,
+                depth_or_array_layers: 1,
+            },
+            format: config.format,
+            usage: config.usage,
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: TextureDimension::D2,
+            view_formats: &[],
+        };
+
+        texture
+            .map(|texture| SurfaceTexture {
+                texture: Texture {
+                    inner: texture,
+                    descriptor,
+                },
+                suboptimal,
+                presented: false,
+                detail,
+            })
+            .ok_or(SurfaceError::Lost)
+    }
+
+    /// Returns the inner hal Surface using a callback. The hal surface will be `None` if the
+    /// backend type argument does not match with this wgpu Surface
+    ///
+    /// # Safety
+    ///
+    /// - The raw handle obtained from the hal Surface must not be manually destroyed
+    #[cfg(wgpu_core)]
+    pub unsafe fn as_hal<A: wgc::hal_api::HalApi, F: FnOnce(Option<&A::Surface>) -> R, R>(
+        &self,
+        hal_surface_callback: F,
+    ) -> R {
+        let core_surface = self.inner.as_core_opt();
+
+        if let Some(core_surface) = core_surface {
+            unsafe {
+                core_surface
+                    .context
+                    .surface_as_hal::<A, F, R>(core_surface, hal_surface_callback)
+            }
+        } else {
+            hal_surface_callback(None)
+        }
+    }
+}
+
+// This custom implementation is required because [`Surface::_surface`] doesn't
+// require [`Debug`](fmt::Debug), which we should not require from the user.
+impl fmt::Debug for Surface<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Surface")
+            .field(
+                "_handle_source",
+                &if self._handle_source.is_some() {
+                    "Some"
+                } else {
+                    "None"
+                },
+            )
+            .field("inner", &self.inner)
+            .field("config", &self.config)
+            .finish()
+    }
+}
+
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(Surface<'_>: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(Surface<'_> => .inner);
+
+/// Super trait for window handles as used in [`SurfaceTarget`].
+pub trait WindowHandle: HasWindowHandle + HasDisplayHandle + WasmNotSendSync {}
+
+impl<T> WindowHandle for T where T: HasWindowHandle + HasDisplayHandle + WasmNotSendSync {}
+
+/// The window/canvas/surface/swap-chain/etc. a surface is attached to, for use with safe surface creation.
+///
+/// This is either a window or an actual web canvas depending on the platform and
+/// enabled features.
+/// Refer to the individual variants for more information.
+///
+/// See also [`SurfaceTargetUnsafe`] for unsafe variants.
+#[non_exhaustive]
+pub enum SurfaceTarget<'window> {
+    /// Window handle producer.
+    ///
+    /// If the specified display and window handle are not supported by any of the backends, then the surface
+    /// will not be supported by any adapters.
+    ///
+    /// # Errors
+    ///
+    /// - On WebGL2: surface creation returns an error if the browser does not support WebGL2,
+    ///   or declines to provide GPU access (such as due to a resource shortage).
+    ///
+    /// # Panics
+    ///
+    /// - On macOS/Metal: will panic if not called on the main thread.
+    /// - On web: will panic if the `raw_window_handle` does not properly refer to a
+    ///   canvas element.
+    Window(Box<dyn WindowHandle + 'window>),
+
+    /// Surface from a `web_sys::HtmlCanvasElement`.
+    ///
+    /// The `canvas` argument must be a valid `<canvas>` element to
+    /// create a surface upon.
+    ///
+    /// # Errors
+    ///
+    /// - On WebGL2: surface creation will return an error if the browser does not support WebGL2,
+    ///   or declines to provide GPU access (such as due to a resource shortage).
+    #[cfg(any(webgpu, webgl))]
+    Canvas(web_sys::HtmlCanvasElement),
+
+    /// Surface from a `web_sys::OffscreenCanvas`.
+    ///
+    /// The `canvas` argument must be a valid `OffscreenCanvas` object
+    /// to create a surface upon.
+    ///
+    /// # Errors
+    ///
+    /// - On WebGL2: surface creation will return an error if the browser does not support WebGL2,
+    ///   or declines to provide GPU access (such as due to a resource shortage).
+    #[cfg(any(webgpu, webgl))]
+    OffscreenCanvas(web_sys::OffscreenCanvas),
+}
+
+impl<'a, T> From<T> for SurfaceTarget<'a>
+where
+    T: WindowHandle + 'a,
+{
+    fn from(window: T) -> Self {
+        Self::Window(Box::new(window))
+    }
+}
+
+/// The window/canvas/surface/swap-chain/etc. a surface is attached to, for use with unsafe surface creation.
+///
+/// This is either a window or an actual web canvas depending on the platform and
+/// enabled features.
+/// Refer to the individual variants for more information.
+///
+/// See also [`SurfaceTarget`] for safe variants.
+#[non_exhaustive]
+pub enum SurfaceTargetUnsafe {
+    /// Raw window & display handle.
+    ///
+    /// If the specified display and window handle are not supported by any of the backends, then the surface
+    /// will not be supported by any adapters.
+    ///
+    /// # Safety
+    ///
+    /// - `raw_window_handle` & `raw_display_handle` must be valid objects to create a surface upon.
+    /// - `raw_window_handle` & `raw_display_handle` must remain valid until after the returned
+    ///    [`Surface`] is  dropped.
+    RawHandle {
+        /// Raw display handle, underlying display must outlive the surface created from this.
+        raw_display_handle: raw_window_handle::RawDisplayHandle,
+
+        /// Raw display handle, underlying window must outlive the surface created from this.
+        raw_window_handle: raw_window_handle::RawWindowHandle,
+    },
+
+    /// Surface from `CoreAnimationLayer`.
+    ///
+    /// # Safety
+    ///
+    /// - layer must be a valid object to create a surface upon.
+    #[cfg(metal)]
+    CoreAnimationLayer(*mut std::ffi::c_void),
+
+    /// Surface from `IDCompositionVisual`.
+    ///
+    /// # Safety
+    ///
+    /// - visual must be a valid `IDCompositionVisual` to create a surface upon.  Its refcount will be incremented internally and kept live as long as the resulting [`Surface`] is live.
+    #[cfg(dx12)]
+    CompositionVisual(*mut std::ffi::c_void),
+
+    /// Surface from DX12 `DirectComposition` handle.
+    ///
+    /// <https://learn.microsoft.com/en-us/windows/win32/api/dxgi1_3/nf-dxgi1_3-idxgifactorymedia-createswapchainforcompositionsurfacehandle>
+    ///
+    /// # Safety
+    ///
+    /// - surface_handle must be a valid `DirectComposition` handle to create a surface upon.   Its lifetime **will not** be internally managed: this handle **should not** be freed before
+    ///   the resulting [`Surface`] is destroyed.
+    #[cfg(dx12)]
+    SurfaceHandle(*mut std::ffi::c_void),
+
+    /// Surface from DX12 `SwapChainPanel`.
+    ///
+    /// # Safety
+    ///
+    /// - visual must be a valid SwapChainPanel to create a surface upon.  Its refcount will be incremented internally and kept live as long as the resulting [`Surface`] is live.
+    #[cfg(dx12)]
+    SwapChainPanel(*mut std::ffi::c_void),
+}
+
+impl SurfaceTargetUnsafe {
+    /// Creates a [`SurfaceTargetUnsafe::RawHandle`] from a window.
+    ///
+    /// # Safety
+    ///
+    /// - `window` must outlive the resulting surface target
+    ///   (and subsequently the surface created for this target).
+    pub unsafe fn from_window<T>(window: &T) -> Result<Self, raw_window_handle::HandleError>
+    where
+        T: HasDisplayHandle + HasWindowHandle,
+    {
+        Ok(Self::RawHandle {
+            raw_display_handle: window.display_handle()?.as_raw(),
+            raw_window_handle: window.window_handle()?.as_raw(),
+        })
+    }
+}
+
+/// [`Instance::create_surface()`] or a related function failed.
+#[derive(Clone, Debug)]
+#[non_exhaustive]
+pub struct CreateSurfaceError {
+    pub(crate) inner: CreateSurfaceErrorKind,
+}
+#[derive(Clone, Debug)]
+pub(crate) enum CreateSurfaceErrorKind {
+    /// Error from [`wgpu_hal`].
+    #[cfg(wgpu_core)]
+    Hal(wgc::instance::CreateSurfaceError),
+
+    /// Error from WebGPU surface creation.
+    #[cfg_attr(not(webgpu), expect(dead_code))]
+    Web(String),
+
+    /// Error when trying to get a [`DisplayHandle`] or a [`WindowHandle`] from
+    /// `raw_window_handle`.
+    RawHandle(raw_window_handle::HandleError),
+}
+static_assertions::assert_impl_all!(CreateSurfaceError: Send, Sync);
+
+impl fmt::Display for CreateSurfaceError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.inner {
+            #[cfg(wgpu_core)]
+            CreateSurfaceErrorKind::Hal(e) => e.fmt(f),
+            CreateSurfaceErrorKind::Web(e) => e.fmt(f),
+            CreateSurfaceErrorKind::RawHandle(e) => e.fmt(f),
+        }
+    }
+}
+
+impl error::Error for CreateSurfaceError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match &self.inner {
+            #[cfg(wgpu_core)]
+            CreateSurfaceErrorKind::Hal(e) => e.source(),
+            CreateSurfaceErrorKind::Web(_) => None,
+            CreateSurfaceErrorKind::RawHandle(e) => e.source(),
+        }
+    }
+}
+
+#[cfg(wgpu_core)]
+impl From<wgc::instance::CreateSurfaceError> for CreateSurfaceError {
+    fn from(e: wgc::instance::CreateSurfaceError) -> Self {
+        Self {
+            inner: CreateSurfaceErrorKind::Hal(e),
+        }
+    }
+}

vendor/wgpu/src/api/surface_texture.rs

@@ -0,0 +1,78 @@
+use std::{error, fmt, thread};
+
+use crate::*;
+
+/// Surface texture that can be rendered to.
+/// Result of a successful call to [`Surface::get_current_texture`].
+///
+/// This type is unique to the Rust API of `wgpu`. In the WebGPU specification,
+/// the [`GPUCanvasContext`](https://gpuweb.github.io/gpuweb/#canvas-context) provides
+/// a texture without any additional information.
+#[derive(Debug, Clone)]
+pub struct SurfaceTexture {
+    /// Accessible view of the frame.
+    pub texture: Texture,
+    /// `true` if the acquired buffer can still be used for rendering,
+    /// but should be recreated for maximum performance.
+    pub suboptimal: bool,
+    pub(crate) presented: bool,
+    pub(crate) detail: dispatch::DispatchSurfaceOutputDetail,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(SurfaceTexture: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(SurfaceTexture => .texture.inner);
+
+impl SurfaceTexture {
+    /// Schedule this texture to be presented on the owning surface.
+    ///
+    /// Needs to be called after any work on the texture is scheduled via [`Queue::submit`].
+    ///
+    /// # Platform dependent behavior
+    ///
+    /// On Wayland, `present` will attach a `wl_buffer` to the underlying `wl_surface` and commit the new surface
+    /// state. If it is desired to do things such as request a frame callback, scale the surface using the viewporter
+    /// or synchronize other double buffered state, then these operations should be done before the call to `present`.
+    pub fn present(mut self) {
+        self.presented = true;
+        self.detail.present();
+    }
+}
+
+impl Drop for SurfaceTexture {
+    fn drop(&mut self) {
+        if !self.presented && !thread::panicking() {
+            self.detail.texture_discard();
+        }
+    }
+}
+
+/// Result of an unsuccessful call to [`Surface::get_current_texture`].
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum SurfaceError {
+    /// A timeout was encountered while trying to acquire the next frame.
+    Timeout,
+    /// The underlying surface has changed, and therefore the swap chain must be updated.
+    Outdated,
+    /// The swap chain has been lost and needs to be recreated.
+    Lost,
+    /// There is no more memory left to allocate a new frame.
+    OutOfMemory,
+    /// Acquiring a texture failed with a generic error. Check error callbacks for more information.
+    Other,
+}
+static_assertions::assert_impl_all!(SurfaceError: Send, Sync);
+
+impl fmt::Display for SurfaceError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", match self {
+            Self::Timeout => "A timeout was encountered while trying to acquire the next frame",
+            Self::Outdated => "The underlying surface has changed, and therefore the swap chain must be updated",
+            Self::Lost =>  "The swap chain has been lost and needs to be recreated",
+            Self::OutOfMemory => "There is no more memory left to allocate a new frame",
+            Self::Other => "Acquiring a texture failed with a generic error. Check error callbacks for more information",
+        })
+    }
+}
+
+impl error::Error for SurfaceError {}

vendor/wgpu/src/api/texture.rs

@@ -0,0 +1,133 @@
+use crate::*;
+
+/// Handle to a texture on the GPU.
+///
+/// It can be created with [`Device::create_texture`].
+///
+/// Corresponds to [WebGPU `GPUTexture`](https://gpuweb.github.io/gpuweb/#texture-interface).
+#[derive(Debug, Clone)]
+pub struct Texture {
+    pub(crate) inner: dispatch::DispatchTexture,
+    pub(crate) descriptor: TextureDescriptor<'static>,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(Texture: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(Texture => .inner);
+
+impl Texture {
+    /// Returns the inner hal Texture using a callback. The hal texture will be `None` if the
+    /// backend type argument does not match with this wgpu Texture
+    ///
+    /// # Safety
+    ///
+    /// - The raw handle obtained from the hal Texture must not be manually destroyed
+    #[cfg(wgpu_core)]
+    pub unsafe fn as_hal<A: wgc::hal_api::HalApi, F: FnOnce(Option<&A::Texture>) -> R, R>(
+        &self,
+        hal_texture_callback: F,
+    ) -> R {
+        if let Some(tex) = self.inner.as_core_opt() {
+            unsafe {
+                tex.context
+                    .texture_as_hal::<A, F, R>(tex, hal_texture_callback)
+            }
+        } else {
+            hal_texture_callback(None)
+        }
+    }
+
+    /// Creates a view of this texture.
+    pub fn create_view(&self, desc: &TextureViewDescriptor<'_>) -> TextureView {
+        let view = self.inner.create_view(desc);
+
+        TextureView { inner: view }
+    }
+
+    /// Destroy the associated native resources as soon as possible.
+    pub fn destroy(&self) {
+        self.inner.destroy();
+    }
+
+    /// Make an `TexelCopyTextureInfo` representing the whole texture.
+    pub fn as_image_copy(&self) -> TexelCopyTextureInfo<'_> {
+        TexelCopyTextureInfo {
+            texture: self,
+            mip_level: 0,
+            origin: Origin3d::ZERO,
+            aspect: TextureAspect::All,
+        }
+    }
+
+    /// Returns the size of this `Texture`.
+    ///
+    /// This is always equal to the `size` that was specified when creating the texture.
+    pub fn size(&self) -> Extent3d {
+        self.descriptor.size
+    }
+
+    /// Returns the width of this `Texture`.
+    ///
+    /// This is always equal to the `size.width` that was specified when creating the texture.
+    pub fn width(&self) -> u32 {
+        self.descriptor.size.width
+    }
+
+    /// Returns the height of this `Texture`.
+    ///
+    /// This is always equal to the `size.height` that was specified when creating the texture.
+    pub fn height(&self) -> u32 {
+        self.descriptor.size.height
+    }
+
+    /// Returns the depth or layer count of this `Texture`.
+    ///
+    /// This is always equal to the `size.depth_or_array_layers` that was specified when creating the texture.
+    pub fn depth_or_array_layers(&self) -> u32 {
+        self.descriptor.size.depth_or_array_layers
+    }
+
+    /// Returns the mip_level_count of this `Texture`.
+    ///
+    /// This is always equal to the `mip_level_count` that was specified when creating the texture.
+    pub fn mip_level_count(&self) -> u32 {
+        self.descriptor.mip_level_count
+    }
+
+    /// Returns the sample_count of this `Texture`.
+    ///
+    /// This is always equal to the `sample_count` that was specified when creating the texture.
+    pub fn sample_count(&self) -> u32 {
+        self.descriptor.sample_count
+    }
+
+    /// Returns the dimension of this `Texture`.
+    ///
+    /// This is always equal to the `dimension` that was specified when creating the texture.
+    pub fn dimension(&self) -> TextureDimension {
+        self.descriptor.dimension
+    }
+
+    /// Returns the format of this `Texture`.
+    ///
+    /// This is always equal to the `format` that was specified when creating the texture.
+    pub fn format(&self) -> TextureFormat {
+        self.descriptor.format
+    }
+
+    /// Returns the allowed usages of this `Texture`.
+    ///
+    /// This is always equal to the `usage` that was specified when creating the texture.
+    pub fn usage(&self) -> TextureUsages {
+        self.descriptor.usage
+    }
+}
+
+/// Describes a [`Texture`].
+///
+/// For use with [`Device::create_texture`].
+///
+/// Corresponds to [WebGPU `GPUTextureDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gputexturedescriptor).
+pub type TextureDescriptor<'a> = wgt::TextureDescriptor<Label<'a>, &'a [TextureFormat]>;
+static_assertions::assert_impl_all!(TextureDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/texture_view.rs

@@ -0,0 +1,49 @@
+use crate::*;
+
+/// Handle to a texture view.
+///
+/// A `TextureView` object describes a texture and associated metadata needed by a
+/// [`RenderPipeline`] or [`BindGroup`].
+///
+/// Corresponds to [WebGPU `GPUTextureView`](https://gpuweb.github.io/gpuweb/#gputextureview).
+#[derive(Debug, Clone)]
+pub struct TextureView {
+    pub(crate) inner: dispatch::DispatchTextureView,
+}
+#[cfg(send_sync)]
+static_assertions::assert_impl_all!(TextureView: Send, Sync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(TextureView => .inner);
+
+impl TextureView {
+    /// Returns the inner hal TextureView using a callback. The hal texture will be `None` if the
+    /// backend type argument does not match with this wgpu Texture
+    ///
+    /// # Safety
+    ///
+    /// - The raw handle obtained from the hal TextureView must not be manually destroyed
+    #[cfg(wgpu_core)]
+    pub unsafe fn as_hal<A: wgc::hal_api::HalApi, F: FnOnce(Option<&A::TextureView>) -> R, R>(
+        &self,
+        hal_texture_view_callback: F,
+    ) -> R {
+        if let Some(core_view) = self.inner.as_core_opt() {
+            unsafe {
+                core_view
+                    .context
+                    .texture_view_as_hal::<A, F, R>(core_view, hal_texture_view_callback)
+            }
+        } else {
+            hal_texture_view_callback(None)
+        }
+    }
+}
+
+/// Describes a [`TextureView`].
+///
+/// For use with [`Texture::create_view`].
+///
+/// Corresponds to [WebGPU `GPUTextureViewDescriptor`](
+/// https://gpuweb.github.io/gpuweb/#dictdef-gputextureviewdescriptor).
+pub type TextureViewDescriptor<'a> = wgt::TextureViewDescriptor<Label<'a>>;
+static_assertions::assert_impl_all!(TextureViewDescriptor<'_>: Send, Sync);

vendor/wgpu/src/api/tlas.rs

@@ -0,0 +1,159 @@
+use crate::{api::blas::TlasInstance, dispatch};
+use crate::{BindingResource, Buffer, Label};
+use std::ops::{Index, IndexMut, Range};
+use std::sync::Arc;
+use wgt::WasmNotSendSync;
+
+/// Descriptor to create top level acceleration structures.
+pub type CreateTlasDescriptor<'a> = wgt::CreateTlasDescriptor<Label<'a>>;
+static_assertions::assert_impl_all!(CreateTlasDescriptor<'_>: Send, Sync);
+
+#[derive(Debug)]
+pub(crate) struct TlasShared {
+    pub(crate) inner: dispatch::DispatchTlas,
+    pub(crate) max_instances: u32,
+}
+
+#[derive(Debug, Clone)]
+/// Top Level Acceleration Structure (TLAS).
+///
+/// A TLAS contains a series of [TLAS instances], which are a reference to
+/// a BLAS and a transformation matrix placing the geometry in the world.
+///
+/// A TLAS contains TLAS instances in a device readable form, you cant interact
+/// directly with these, instead you have to build the TLAS with [TLAS instances].
+///
+/// [TLAS instances]: TlasInstance
+pub struct Tlas {
+    pub(crate) shared: Arc<TlasShared>,
+}
+static_assertions::assert_impl_all!(Tlas: WasmNotSendSync);
+
+crate::cmp::impl_eq_ord_hash_proxy!(Tlas => .shared.inner);
+
+/// Entry for a top level acceleration structure build.
+/// Used with raw instance buffers for an unvalidated builds.
+/// See [TlasPackage] for the safe version.
+pub struct TlasBuildEntry<'a> {
+    /// Reference to the acceleration structure.
+    pub tlas: &'a Tlas,
+    /// Reference to the raw instance buffer, each instance is similar to [TlasInstance] but contains a handle to the BLAS.
+    pub instance_buffer: &'a Buffer,
+    /// Number of instances in the instance buffer.
+    pub instance_count: u32,
+}
+static_assertions::assert_impl_all!(TlasBuildEntry<'_>: WasmNotSendSync);
+
+/// The safe version of TlasEntry, containing TlasInstances instead of a raw buffer.
+pub struct TlasPackage {
+    pub(crate) tlas: Tlas,
+    pub(crate) instances: Vec<Option<TlasInstance>>,
+    pub(crate) lowest_unmodified: u32,
+}
+static_assertions::assert_impl_all!(TlasPackage: WasmNotSendSync);
+
+impl TlasPackage {
+    /// Construct [TlasPackage] consuming the [Tlas] (prevents modification of the [Tlas] without using this package).
+    pub fn new(tlas: Tlas) -> Self {
+        let max_instances = tlas.shared.max_instances;
+        Self::new_with_instances(tlas, vec![None; max_instances as usize])
+    }
+
+    /// Construct [TlasPackage] consuming the [Tlas] (prevents modification of the Tlas without using this package).
+    /// This constructor moves the instances into the package (the number of instances needs to fit into tlas,
+    /// otherwise when building a validation error will be raised).
+    pub fn new_with_instances(tlas: Tlas, instances: Vec<Option<TlasInstance>>) -> Self {
+        Self {
+            tlas,
+            lowest_unmodified: instances.len() as u32,
+            instances,
+        }
+    }
+
+    /// Get a reference to all instances.
+    pub fn get(&self) -> &[Option<TlasInstance>] {
+        &self.instances
+    }
+
+    /// Get a mutable slice to a range of instances.
+    /// Returns None if the range is out of bounds.
+    /// All elements from the lowest accessed index up are marked as modified.
+    // this recommendation is not useful yet, but is likely to be when ability to update arrives or possible optimisations for building get implemented.
+    /// For best performance it is recommended to prefer access to low elements and modify higher elements as little as possible.
+    /// This can be done by ordering instances from the most to the least used. It is recommended
+    /// to use [Self::index_mut] unless the option if out of bounds is required
+    pub fn get_mut_slice(&mut self, range: Range<usize>) -> Option<&mut [Option<TlasInstance>]> {
+        if range.end > self.instances.len() {
+            return None;
+        }
+        if range.end as u32 > self.lowest_unmodified {
+            self.lowest_unmodified = range.end as u32;
+        }
+        Some(&mut self.instances[range])
+    }
+
+    /// Get a single mutable reference to an instance.
+    /// Returns None if the range is out of bounds.
+    /// All elements from the lowest accessed index up are marked as modified.
+    // this recommendation is not useful yet, but is likely to be when ability to update arrives or possible optimisations for building get implemented.
+    /// For best performance it is recommended to prefer access to low elements and modify higher elements as little as possible.
+    /// This can be done by ordering instances from the most to the least used. It is recommended
+    /// to use [Self::index_mut] unless the option if out of bounds is required
+    pub fn get_mut_single(&mut self, index: usize) -> Option<&mut Option<TlasInstance>> {
+        if index >= self.instances.len() {
+            return None;
+        }
+        if index as u32 + 1 > self.lowest_unmodified {
+            self.lowest_unmodified = index as u32 + 1;
+        }
+        Some(&mut self.instances[index])
+    }
+
+    /// Get the binding resource for the underling acceleration structure, to be used when creating a [BindGroup]
+    ///
+    /// [BindGroup]: super::BindGroup
+    pub fn as_binding(&self) -> BindingResource<'_> {
+        BindingResource::AccelerationStructure(&self.tlas)
+    }
+
+    /// Get a reference to the underling [Tlas].
+    pub fn tlas(&self) -> &Tlas {
+        &self.tlas
+    }
+}
+
+impl Index<usize> for TlasPackage {
+    type Output = Option<TlasInstance>;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        self.instances.index(index)
+    }
+}
+
+impl Index<Range<usize>> for TlasPackage {
+    type Output = [Option<TlasInstance>];
+
+    fn index(&self, index: Range<usize>) -> &Self::Output {
+        self.instances.index(index)
+    }
+}
+
+impl IndexMut<usize> for TlasPackage {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        let idx = self.instances.index_mut(index);
+        if index as u32 + 1 > self.lowest_unmodified {
+            self.lowest_unmodified = index as u32 + 1;
+        }
+        idx
+    }
+}
+
+impl IndexMut<Range<usize>> for TlasPackage {
+    fn index_mut(&mut self, index: Range<usize>) -> &mut Self::Output {
+        let idx = self.instances.index_mut(index.clone());
+        if index.end > self.lowest_unmodified as usize {
+            self.lowest_unmodified = index.end as u32;
+        }
+        idx
+    }
+}

vendor/wgpu/src/backend/mod.rs

@@ -0,0 +1,10 @@
+#[cfg(webgpu)]
+pub mod webgpu;
+#[cfg(webgpu)]
+pub(crate) use webgpu::{get_browser_gpu_property, ContextWebGpu};
+
+#[cfg(wgpu_core)]
+pub mod wgpu_core;
+
+#[cfg(wgpu_core)]
+pub(crate) use wgpu_core::ContextWgpuCore;

vendor/wgpu/src/backend/webgpu/defined_non_null_js_value.rs

@@ -0,0 +1,46 @@
+use std::ops::{Deref, DerefMut};
+
+use wasm_bindgen::JsValue;
+
+/// Derefs to a [`JsValue`] that's known not to be `undefined` or `null`.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct DefinedNonNullJsValue<T>(T);
+
+impl<T> DefinedNonNullJsValue<T>
+where
+    T: AsRef<JsValue>,
+{
+    pub fn new(value: T) -> Option<Self> {
+        if value.as_ref().is_undefined() || value.as_ref().is_null() {
+            None
+        } else {
+            Some(Self(value))
+        }
+    }
+}
+
+impl<T> Deref for DefinedNonNullJsValue<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for DefinedNonNullJsValue<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T> AsRef<T> for DefinedNonNullJsValue<T> {
+    fn as_ref(&self) -> &T {
+        &self.0
+    }
+}
+
+impl<T> AsMut<T> for DefinedNonNullJsValue<T> {
+    fn as_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+}

vendor/wgpu/src/backend/webgpu/ext_bindings.rs

@@ -0,0 +1,45 @@
+//! Extension bindings for WebGPU.
+//!
+//! These contain ideomatic Rust extension traits for various parts of the WebGPU
+//! bindings that are missing, need to be improved, or otherwise need to be different
+//! from the generated web_sys bindings.
+
+use crate::backend::webgpu::webgpu_sys;
+use wasm_bindgen::prelude::*;
+
+/// Extension trait for [`web_sys::Navigator`] and [`web_sys::WorkerNavigator`] to
+/// access the `gpu` property.
+pub trait NavigatorGpu {
+    /// Get the `gpu` property.
+    ///
+    /// This is intentionally a free function, to prevent overload conflicts with
+    /// the method if it is enabled in web-sys itself.
+    fn gpu(navigator: &Self) -> webgpu_sys::Gpu;
+}
+
+// --- Bindings for `Navigator` ---
+#[wasm_bindgen]
+extern "C" {
+    /// Create a fake class which we tell wasm-bindgen has access to the `gpu` property.
+    #[wasm_bindgen]
+    type NavigatorWithGpu;
+
+    #[wasm_bindgen(method, getter)]
+    fn gpu(ext: &NavigatorWithGpu) -> webgpu_sys::Gpu;
+}
+
+impl NavigatorGpu for web_sys::Navigator {
+    fn gpu(navigator: &Self) -> webgpu_sys::Gpu {
+        // Must be an unchecked ref as this class does not exist at runtime.
+        let extension: &NavigatorWithGpu = navigator.unchecked_ref();
+        extension.gpu()
+    }
+}
+
+impl NavigatorGpu for web_sys::WorkerNavigator {
+    fn gpu(navigator: &Self) -> webgpu_sys::Gpu {
+        // Must be an unchecked ref as this class does not exist at runtime.
+        let extension: &NavigatorWithGpu = navigator.unchecked_ref();
+        extension.gpu()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_Gpu.rs

@@ -0,0 +1,87 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPU , typescript_type = "GPU")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `Gpu` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPU)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `Gpu`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type Gpu;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPU" , js_name = wgslLanguageFeatures)]
+    #[doc = "Getter for the `wgslLanguageFeatures` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPU/wgslLanguageFeatures)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `Gpu`, `WgslLanguageFeatures`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn wgsl_language_features(this: &Gpu) -> WgslLanguageFeatures;
+
+    # [wasm_bindgen (method , structural , js_class = "GPU" , js_name = getPreferredCanvasFormat)]
+    #[doc = "The `getPreferredCanvasFormat()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPU/getPreferredCanvasFormat)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `Gpu`, `GpuTextureFormat`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_preferred_canvas_format(this: &Gpu) -> GpuTextureFormat;
+
+    # [wasm_bindgen (method , structural , js_class = "GPU" , js_name = requestAdapter)]
+    #[doc = "The `requestAdapter()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPU/requestAdapter)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `Gpu`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn request_adapter(this: &Gpu) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPU" , js_name = requestAdapter)]
+    #[doc = "The `requestAdapter()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPU/requestAdapter)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `Gpu`, `GpuRequestAdapterOptions`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn request_adapter_with_options(
+        this: &Gpu,
+        options: &GpuRequestAdapterOptions,
+    ) -> ::js_sys::Promise;
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuAdapter.rs

@@ -0,0 +1,109 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUAdapter , typescript_type = "GPUAdapter")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuAdapter` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapter)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapter`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuAdapter;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUAdapter" , js_name = features)]
+    #[doc = "Getter for the `features` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapter/features)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapter`, `GpuSupportedFeatures`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn features(this: &GpuAdapter) -> GpuSupportedFeatures;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUAdapter" , js_name = limits)]
+    #[doc = "Getter for the `limits` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapter/limits)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapter`, `GpuSupportedLimits`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn limits(this: &GpuAdapter) -> GpuSupportedLimits;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUAdapter" , js_name = info)]
+    #[doc = "Getter for the `info` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapter/info)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapter`, `GpuAdapterInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn info(this: &GpuAdapter) -> GpuAdapterInfo;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUAdapter" , js_name = isFallbackAdapter)]
+    #[doc = "Getter for the `isFallbackAdapter` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapter/isFallbackAdapter)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapter`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn is_fallback_adapter(this: &GpuAdapter) -> bool;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUAdapter" , js_name = requestDevice)]
+    #[doc = "The `requestDevice()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapter/requestDevice)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapter`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn request_device(this: &GpuAdapter) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUAdapter" , js_name = requestDevice)]
+    #[doc = "The `requestDevice()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapter/requestDevice)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapter`, `GpuDeviceDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn request_device_with_descriptor(
+        this: &GpuAdapter,
+        descriptor: &GpuDeviceDescriptor,
+    ) -> ::js_sys::Promise;
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuAdapterInfo.rs

@@ -0,0 +1,84 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUAdapterInfo , typescript_type = "GPUAdapterInfo")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuAdapterInfo` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapterInfo)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapterInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuAdapterInfo;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUAdapterInfo" , js_name = vendor)]
+    #[doc = "Getter for the `vendor` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapterInfo/vendor)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapterInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn vendor(this: &GpuAdapterInfo) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUAdapterInfo" , js_name = architecture)]
+    #[doc = "Getter for the `architecture` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapterInfo/architecture)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapterInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn architecture(this: &GpuAdapterInfo) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUAdapterInfo" , js_name = device)]
+    #[doc = "Getter for the `device` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapterInfo/device)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapterInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn device(this: &GpuAdapterInfo) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUAdapterInfo" , js_name = description)]
+    #[doc = "Getter for the `description` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUAdapterInfo/description)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapterInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn description(this: &GpuAdapterInfo) -> ::alloc::string::String;
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuAddressMode.rs

@@ -0,0 +1,38 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuAddressMode` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuAddressMode`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuAddressMode {
+    ClampToEdge = "clamp-to-edge",
+    Repeat = "repeat",
+    MirrorRepeat = "mirror-repeat",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuAutoLayoutMode.rs

@@ -0,0 +1,36 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuAutoLayoutMode` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuAutoLayoutMode`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuAutoLayoutMode {
+    Auto = "auto",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBindGroup.rs

@@ -0,0 +1,62 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBindGroup , typescript_type = "GPUBindGroup")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBindGroup` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBindGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroup`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBindGroup;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUBindGroup" , js_name = label)]
+    #[doc = "Getter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBindGroup/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroup`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn label(this: &GpuBindGroup) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , setter , js_class = "GPUBindGroup" , js_name = label)]
+    #[doc = "Setter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBindGroup/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroup`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_label(this: &GpuBindGroup, value: &str);
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBindGroupDescriptor.rs

@@ -0,0 +1,126 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBindGroupDescriptor)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBindGroupDescriptor` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBindGroupDescriptor;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuBindGroupDescriptor) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuBindGroupDescriptor, val: &str);
+
+    #[doc = "Get the `entries` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "entries")]
+    pub fn get_entries(this: &GpuBindGroupDescriptor) -> ::js_sys::Array;
+
+    #[doc = "Change the `entries` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "entries")]
+    pub fn set_entries(this: &GpuBindGroupDescriptor, val: &::wasm_bindgen::JsValue);
+
+    #[doc = "Get the `layout` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupDescriptor`, `GpuBindGroupLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "layout")]
+    pub fn get_layout(this: &GpuBindGroupDescriptor) -> GpuBindGroupLayout;
+
+    #[doc = "Change the `layout` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupDescriptor`, `GpuBindGroupLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "layout")]
+    pub fn set_layout(this: &GpuBindGroupDescriptor, val: &GpuBindGroupLayout);
+}
+
+impl GpuBindGroupDescriptor {
+    #[doc = "Construct a new `GpuBindGroupDescriptor`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupDescriptor`, `GpuBindGroupLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(entries: &::wasm_bindgen::JsValue, layout: &GpuBindGroupLayout) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_entries(entries);
+        ret.set_layout(layout);
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+
+    #[deprecated = "Use `set_entries()` instead."]
+    pub fn entries(&mut self, val: &::wasm_bindgen::JsValue) -> &mut Self {
+        self.set_entries(val);
+        self
+    }
+
+    #[deprecated = "Use `set_layout()` instead."]
+    pub fn layout(&mut self, val: &GpuBindGroupLayout) -> &mut Self {
+        self.set_layout(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBindGroupEntry.rs

@@ -0,0 +1,102 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBindGroupEntry)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBindGroupEntry` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBindGroupEntry;
+
+    #[doc = "Get the `binding` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "binding")]
+    pub fn get_binding(this: &GpuBindGroupEntry) -> u32;
+
+    #[doc = "Change the `binding` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "binding")]
+    pub fn set_binding(this: &GpuBindGroupEntry, val: u32);
+
+    #[doc = "Get the `resource` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "resource")]
+    pub fn get_resource(this: &GpuBindGroupEntry) -> ::wasm_bindgen::JsValue;
+
+    #[doc = "Change the `resource` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "resource")]
+    pub fn set_resource(this: &GpuBindGroupEntry, val: &::wasm_bindgen::JsValue);
+}
+
+impl GpuBindGroupEntry {
+    #[doc = "Construct a new `GpuBindGroupEntry`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(binding: u32, resource: &::wasm_bindgen::JsValue) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_binding(binding);
+        ret.set_resource(resource);
+        ret
+    }
+
+    #[deprecated = "Use `set_binding()` instead."]
+    pub fn binding(&mut self, val: u32) -> &mut Self {
+        self.set_binding(val);
+        self
+    }
+
+    #[deprecated = "Use `set_resource()` instead."]
+    pub fn resource(&mut self, val: &::wasm_bindgen::JsValue) -> &mut Self {
+        self.set_resource(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBindGroupLayout.rs

@@ -0,0 +1,62 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBindGroupLayout , typescript_type = "GPUBindGroupLayout")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBindGroupLayout` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBindGroupLayout)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBindGroupLayout;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUBindGroupLayout" , js_name = label)]
+    #[doc = "Getter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBindGroupLayout/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn label(this: &GpuBindGroupLayout) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , setter , js_class = "GPUBindGroupLayout" , js_name = label)]
+    #[doc = "Setter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBindGroupLayout/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_label(this: &GpuBindGroupLayout, value: &str);
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBindGroupLayoutDescriptor.rs

@@ -0,0 +1,101 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBindGroupLayoutDescriptor)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBindGroupLayoutDescriptor` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBindGroupLayoutDescriptor;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuBindGroupLayoutDescriptor) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuBindGroupLayoutDescriptor, val: &str);
+
+    #[doc = "Get the `entries` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "entries")]
+    pub fn get_entries(this: &GpuBindGroupLayoutDescriptor) -> ::js_sys::Array;
+
+    #[doc = "Change the `entries` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "entries")]
+    pub fn set_entries(this: &GpuBindGroupLayoutDescriptor, val: &::wasm_bindgen::JsValue);
+}
+
+impl GpuBindGroupLayoutDescriptor {
+    #[doc = "Construct a new `GpuBindGroupLayoutDescriptor`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(entries: &::wasm_bindgen::JsValue) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_entries(entries);
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+
+    #[deprecated = "Use `set_entries()` instead."]
+    pub fn entries(&mut self, val: &::wasm_bindgen::JsValue) -> &mut Self {
+        self.set_entries(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBindGroupLayoutEntry.rs

@@ -0,0 +1,232 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBindGroupLayoutEntry)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBindGroupLayoutEntry` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBindGroupLayoutEntry;
+
+    #[doc = "Get the `binding` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "binding")]
+    pub fn get_binding(this: &GpuBindGroupLayoutEntry) -> u32;
+
+    #[doc = "Change the `binding` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "binding")]
+    pub fn set_binding(this: &GpuBindGroupLayoutEntry, val: u32);
+
+    #[doc = "Get the `buffer` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`, `GpuBufferBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "buffer")]
+    pub fn get_buffer(this: &GpuBindGroupLayoutEntry) -> Option<GpuBufferBindingLayout>;
+
+    #[doc = "Change the `buffer` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`, `GpuBufferBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "buffer")]
+    pub fn set_buffer(this: &GpuBindGroupLayoutEntry, val: &GpuBufferBindingLayout);
+
+    #[doc = "Get the `externalTexture` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`, `GpuExternalTextureBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "externalTexture")]
+    pub fn get_external_texture(
+        this: &GpuBindGroupLayoutEntry,
+    ) -> Option<GpuExternalTextureBindingLayout>;
+
+    #[doc = "Change the `externalTexture` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`, `GpuExternalTextureBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "externalTexture")]
+    pub fn set_external_texture(
+        this: &GpuBindGroupLayoutEntry,
+        val: &GpuExternalTextureBindingLayout,
+    );
+
+    #[doc = "Get the `sampler` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`, `GpuSamplerBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "sampler")]
+    pub fn get_sampler(this: &GpuBindGroupLayoutEntry) -> Option<GpuSamplerBindingLayout>;
+
+    #[doc = "Change the `sampler` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`, `GpuSamplerBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "sampler")]
+    pub fn set_sampler(this: &GpuBindGroupLayoutEntry, val: &GpuSamplerBindingLayout);
+
+    #[doc = "Get the `storageTexture` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`, `GpuStorageTextureBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "storageTexture")]
+    pub fn get_storage_texture(
+        this: &GpuBindGroupLayoutEntry,
+    ) -> Option<GpuStorageTextureBindingLayout>;
+
+    #[doc = "Change the `storageTexture` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`, `GpuStorageTextureBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "storageTexture")]
+    pub fn set_storage_texture(
+        this: &GpuBindGroupLayoutEntry,
+        val: &GpuStorageTextureBindingLayout,
+    );
+
+    #[doc = "Get the `texture` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`, `GpuTextureBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "texture")]
+    pub fn get_texture(this: &GpuBindGroupLayoutEntry) -> Option<GpuTextureBindingLayout>;
+
+    #[doc = "Change the `texture` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`, `GpuTextureBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "texture")]
+    pub fn set_texture(this: &GpuBindGroupLayoutEntry, val: &GpuTextureBindingLayout);
+
+    #[doc = "Get the `visibility` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "visibility")]
+    pub fn get_visibility(this: &GpuBindGroupLayoutEntry) -> u32;
+
+    #[doc = "Change the `visibility` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "visibility")]
+    pub fn set_visibility(this: &GpuBindGroupLayoutEntry, val: u32);
+}
+
+impl GpuBindGroupLayoutEntry {
+    #[doc = "Construct a new `GpuBindGroupLayoutEntry`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayoutEntry`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(binding: u32, visibility: u32) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_binding(binding);
+        ret.set_visibility(visibility);
+        ret
+    }
+
+    #[deprecated = "Use `set_binding()` instead."]
+    pub fn binding(&mut self, val: u32) -> &mut Self {
+        self.set_binding(val);
+        self
+    }
+
+    #[deprecated = "Use `set_buffer()` instead."]
+    pub fn buffer(&mut self, val: &GpuBufferBindingLayout) -> &mut Self {
+        self.set_buffer(val);
+        self
+    }
+
+    #[deprecated = "Use `set_external_texture()` instead."]
+    pub fn external_texture(&mut self, val: &GpuExternalTextureBindingLayout) -> &mut Self {
+        self.set_external_texture(val);
+        self
+    }
+
+    #[deprecated = "Use `set_sampler()` instead."]
+    pub fn sampler(&mut self, val: &GpuSamplerBindingLayout) -> &mut Self {
+        self.set_sampler(val);
+        self
+    }
+
+    #[deprecated = "Use `set_storage_texture()` instead."]
+    pub fn storage_texture(&mut self, val: &GpuStorageTextureBindingLayout) -> &mut Self {
+        self.set_storage_texture(val);
+        self
+    }
+
+    #[deprecated = "Use `set_texture()` instead."]
+    pub fn texture(&mut self, val: &GpuTextureBindingLayout) -> &mut Self {
+        self.set_texture(val);
+        self
+    }
+
+    #[deprecated = "Use `set_visibility()` instead."]
+    pub fn visibility(&mut self, val: u32) -> &mut Self {
+        self.set_visibility(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBlendComponent.rs

@@ -0,0 +1,130 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBlendComponent)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBlendComponent` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBlendComponent;
+
+    #[doc = "Get the `dstFactor` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendFactor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "dstFactor")]
+    pub fn get_dst_factor(this: &GpuBlendComponent) -> Option<GpuBlendFactor>;
+
+    #[doc = "Change the `dstFactor` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendFactor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "dstFactor")]
+    pub fn set_dst_factor(this: &GpuBlendComponent, val: GpuBlendFactor);
+
+    #[doc = "Get the `operation` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendOperation`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "operation")]
+    pub fn get_operation(this: &GpuBlendComponent) -> Option<GpuBlendOperation>;
+
+    #[doc = "Change the `operation` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendOperation`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "operation")]
+    pub fn set_operation(this: &GpuBlendComponent, val: GpuBlendOperation);
+
+    #[doc = "Get the `srcFactor` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendFactor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "srcFactor")]
+    pub fn get_src_factor(this: &GpuBlendComponent) -> Option<GpuBlendFactor>;
+
+    #[doc = "Change the `srcFactor` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendFactor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "srcFactor")]
+    pub fn set_src_factor(this: &GpuBlendComponent, val: GpuBlendFactor);
+}
+
+impl GpuBlendComponent {
+    #[doc = "Construct a new `GpuBlendComponent`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_dst_factor()` instead."]
+    pub fn dst_factor(&mut self, val: GpuBlendFactor) -> &mut Self {
+        self.set_dst_factor(val);
+        self
+    }
+
+    #[deprecated = "Use `set_operation()` instead."]
+    pub fn operation(&mut self, val: GpuBlendOperation) -> &mut Self {
+        self.set_operation(val);
+        self
+    }
+
+    #[deprecated = "Use `set_src_factor()` instead."]
+    pub fn src_factor(&mut self, val: GpuBlendFactor) -> &mut Self {
+        self.set_src_factor(val);
+        self
+    }
+}
+
+impl Default for GpuBlendComponent {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBlendFactor.rs

@@ -0,0 +1,52 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuBlendFactor` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuBlendFactor`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuBlendFactor {
+    Zero = "zero",
+    One = "one",
+    Src = "src",
+    OneMinusSrc = "one-minus-src",
+    SrcAlpha = "src-alpha",
+    OneMinusSrcAlpha = "one-minus-src-alpha",
+    Dst = "dst",
+    OneMinusDst = "one-minus-dst",
+    DstAlpha = "dst-alpha",
+    OneMinusDstAlpha = "one-minus-dst-alpha",
+    SrcAlphaSaturated = "src-alpha-saturated",
+    Constant = "constant",
+    OneMinusConstant = "one-minus-constant",
+    Src1 = "src1",
+    OneMinusSrc1 = "one-minus-src1",
+    Src1Alpha = "src1-alpha",
+    OneMinusSrc1Alpha = "one-minus-src1-alpha",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBlendOperation.rs

@@ -0,0 +1,40 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuBlendOperation` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuBlendOperation`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuBlendOperation {
+    Add = "add",
+    Subtract = "subtract",
+    ReverseSubtract = "reverse-subtract",
+    Min = "min",
+    Max = "max",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBlendState.rs

@@ -0,0 +1,102 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBlendState)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBlendState` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBlendState;
+
+    #[doc = "Get the `alpha` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "alpha")]
+    pub fn get_alpha(this: &GpuBlendState) -> GpuBlendComponent;
+
+    #[doc = "Change the `alpha` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "alpha")]
+    pub fn set_alpha(this: &GpuBlendState, val: &GpuBlendComponent);
+
+    #[doc = "Get the `color` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "color")]
+    pub fn get_color(this: &GpuBlendState) -> GpuBlendComponent;
+
+    #[doc = "Change the `color` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "color")]
+    pub fn set_color(this: &GpuBlendState, val: &GpuBlendComponent);
+}
+
+impl GpuBlendState {
+    #[doc = "Construct a new `GpuBlendState`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendComponent`, `GpuBlendState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(alpha: &GpuBlendComponent, color: &GpuBlendComponent) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_alpha(alpha);
+        ret.set_color(color);
+        ret
+    }
+
+    #[deprecated = "Use `set_alpha()` instead."]
+    pub fn alpha(&mut self, val: &GpuBlendComponent) -> &mut Self {
+        self.set_alpha(val);
+        self
+    }
+
+    #[deprecated = "Use `set_color()` instead."]
+    pub fn color(&mut self, val: &GpuBlendComponent) -> &mut Self {
+        self.set_color(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBuffer.rs

@@ -0,0 +1,313 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBuffer , typescript_type = "GPUBuffer")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBuffer` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBuffer;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUBuffer" , js_name = size)]
+    #[doc = "Getter for the `size` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/size)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn size(this: &GpuBuffer) -> f64;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUBuffer" , js_name = usage)]
+    #[doc = "Getter for the `usage` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/usage)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn usage(this: &GpuBuffer) -> u32;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUBuffer" , js_name = mapState)]
+    #[doc = "Getter for the `mapState` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/mapState)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuBufferMapState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn map_state(this: &GpuBuffer) -> GpuBufferMapState;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUBuffer" , js_name = label)]
+    #[doc = "Getter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn label(this: &GpuBuffer) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , setter , js_class = "GPUBuffer" , js_name = label)]
+    #[doc = "Setter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_label(this: &GpuBuffer, value: &str);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUBuffer" , js_name = destroy)]
+    #[doc = "The `destroy()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/destroy)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn destroy(this: &GpuBuffer);
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUBuffer" , js_name = getMappedRange)]
+    #[doc = "The `getMappedRange()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/getMappedRange)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_mapped_range(this: &GpuBuffer) -> Result<::js_sys::ArrayBuffer, JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUBuffer" , js_name = getMappedRange)]
+    #[doc = "The `getMappedRange()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/getMappedRange)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_mapped_range_with_u32(
+        this: &GpuBuffer,
+        offset: u32,
+    ) -> Result<::js_sys::ArrayBuffer, JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUBuffer" , js_name = getMappedRange)]
+    #[doc = "The `getMappedRange()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/getMappedRange)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_mapped_range_with_f64(
+        this: &GpuBuffer,
+        offset: f64,
+    ) -> Result<::js_sys::ArrayBuffer, JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUBuffer" , js_name = getMappedRange)]
+    #[doc = "The `getMappedRange()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/getMappedRange)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_mapped_range_with_u32_and_u32(
+        this: &GpuBuffer,
+        offset: u32,
+        size: u32,
+    ) -> Result<::js_sys::ArrayBuffer, JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUBuffer" , js_name = getMappedRange)]
+    #[doc = "The `getMappedRange()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/getMappedRange)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_mapped_range_with_f64_and_u32(
+        this: &GpuBuffer,
+        offset: f64,
+        size: u32,
+    ) -> Result<::js_sys::ArrayBuffer, JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUBuffer" , js_name = getMappedRange)]
+    #[doc = "The `getMappedRange()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/getMappedRange)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_mapped_range_with_u32_and_f64(
+        this: &GpuBuffer,
+        offset: u32,
+        size: f64,
+    ) -> Result<::js_sys::ArrayBuffer, JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUBuffer" , js_name = getMappedRange)]
+    #[doc = "The `getMappedRange()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/getMappedRange)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_mapped_range_with_f64_and_f64(
+        this: &GpuBuffer,
+        offset: f64,
+        size: f64,
+    ) -> Result<::js_sys::ArrayBuffer, JsValue>;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUBuffer" , js_name = mapAsync)]
+    #[doc = "The `mapAsync()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/mapAsync)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn map_async(this: &GpuBuffer, mode: u32) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUBuffer" , js_name = mapAsync)]
+    #[doc = "The `mapAsync()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/mapAsync)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn map_async_with_u32(this: &GpuBuffer, mode: u32, offset: u32) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUBuffer" , js_name = mapAsync)]
+    #[doc = "The `mapAsync()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/mapAsync)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn map_async_with_f64(this: &GpuBuffer, mode: u32, offset: f64) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUBuffer" , js_name = mapAsync)]
+    #[doc = "The `mapAsync()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/mapAsync)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn map_async_with_u32_and_u32(
+        this: &GpuBuffer,
+        mode: u32,
+        offset: u32,
+        size: u32,
+    ) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUBuffer" , js_name = mapAsync)]
+    #[doc = "The `mapAsync()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/mapAsync)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn map_async_with_f64_and_u32(
+        this: &GpuBuffer,
+        mode: u32,
+        offset: f64,
+        size: u32,
+    ) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUBuffer" , js_name = mapAsync)]
+    #[doc = "The `mapAsync()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/mapAsync)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn map_async_with_u32_and_f64(
+        this: &GpuBuffer,
+        mode: u32,
+        offset: u32,
+        size: f64,
+    ) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUBuffer" , js_name = mapAsync)]
+    #[doc = "The `mapAsync()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/mapAsync)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn map_async_with_f64_and_f64(
+        this: &GpuBuffer,
+        mode: u32,
+        offset: f64,
+        size: f64,
+    ) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUBuffer" , js_name = unmap)]
+    #[doc = "The `unmap()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUBuffer/unmap)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn unmap(this: &GpuBuffer);
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBufferBinding.rs

@@ -0,0 +1,125 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBufferBinding)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBufferBinding` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBinding`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBufferBinding;
+
+    #[doc = "Get the `buffer` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuBufferBinding`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "buffer")]
+    pub fn get_buffer(this: &GpuBufferBinding) -> GpuBuffer;
+
+    #[doc = "Change the `buffer` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuBufferBinding`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "buffer")]
+    pub fn set_buffer(this: &GpuBufferBinding, val: &GpuBuffer);
+
+    #[doc = "Get the `offset` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBinding`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "offset")]
+    pub fn get_offset(this: &GpuBufferBinding) -> Option<f64>;
+
+    #[doc = "Change the `offset` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBinding`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "offset")]
+    pub fn set_offset(this: &GpuBufferBinding, val: f64);
+
+    #[doc = "Get the `size` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBinding`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "size")]
+    pub fn get_size(this: &GpuBufferBinding) -> Option<f64>;
+
+    #[doc = "Change the `size` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBinding`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "size")]
+    pub fn set_size(this: &GpuBufferBinding, val: f64);
+}
+
+impl GpuBufferBinding {
+    #[doc = "Construct a new `GpuBufferBinding`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuBufferBinding`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(buffer: &GpuBuffer) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_buffer(buffer);
+        ret
+    }
+
+    #[deprecated = "Use `set_buffer()` instead."]
+    pub fn buffer(&mut self, val: &GpuBuffer) -> &mut Self {
+        self.set_buffer(val);
+        self
+    }
+
+    #[deprecated = "Use `set_offset()` instead."]
+    pub fn offset(&mut self, val: f64) -> &mut Self {
+        self.set_offset(val);
+        self
+    }
+
+    #[deprecated = "Use `set_size()` instead."]
+    pub fn size(&mut self, val: f64) -> &mut Self {
+        self.set_size(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBufferBindingLayout.rs

@@ -0,0 +1,130 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBufferBindingLayout)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBufferBindingLayout` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBufferBindingLayout;
+
+    #[doc = "Get the `hasDynamicOffset` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "hasDynamicOffset")]
+    pub fn get_has_dynamic_offset(this: &GpuBufferBindingLayout) -> Option<bool>;
+
+    #[doc = "Change the `hasDynamicOffset` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "hasDynamicOffset")]
+    pub fn set_has_dynamic_offset(this: &GpuBufferBindingLayout, val: bool);
+
+    #[doc = "Get the `minBindingSize` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "minBindingSize")]
+    pub fn get_min_binding_size(this: &GpuBufferBindingLayout) -> Option<f64>;
+
+    #[doc = "Change the `minBindingSize` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "minBindingSize")]
+    pub fn set_min_binding_size(this: &GpuBufferBindingLayout, val: f64);
+
+    #[doc = "Get the `type` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBindingLayout`, `GpuBufferBindingType`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "type")]
+    pub fn get_type(this: &GpuBufferBindingLayout) -> Option<GpuBufferBindingType>;
+
+    #[doc = "Change the `type` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBindingLayout`, `GpuBufferBindingType`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "type")]
+    pub fn set_type(this: &GpuBufferBindingLayout, val: GpuBufferBindingType);
+}
+
+impl GpuBufferBindingLayout {
+    #[doc = "Construct a new `GpuBufferBindingLayout`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_has_dynamic_offset()` instead."]
+    pub fn has_dynamic_offset(&mut self, val: bool) -> &mut Self {
+        self.set_has_dynamic_offset(val);
+        self
+    }
+
+    #[deprecated = "Use `set_min_binding_size()` instead."]
+    pub fn min_binding_size(&mut self, val: f64) -> &mut Self {
+        self.set_min_binding_size(val);
+        self
+    }
+
+    #[deprecated = "Use `set_type()` instead."]
+    pub fn type_(&mut self, val: GpuBufferBindingType) -> &mut Self {
+        self.set_type(val);
+        self
+    }
+}
+
+impl Default for GpuBufferBindingLayout {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBufferBindingType.rs

@@ -0,0 +1,38 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuBufferBindingType` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuBufferBindingType`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuBufferBindingType {
+    Uniform = "uniform",
+    Storage = "storage",
+    ReadOnlyStorage = "read-only-storage",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBufferDescriptor.rs

@@ -0,0 +1,150 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUBufferDescriptor)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuBufferDescriptor` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuBufferDescriptor;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuBufferDescriptor) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuBufferDescriptor, val: &str);
+
+    #[doc = "Get the `mappedAtCreation` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "mappedAtCreation")]
+    pub fn get_mapped_at_creation(this: &GpuBufferDescriptor) -> Option<bool>;
+
+    #[doc = "Change the `mappedAtCreation` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "mappedAtCreation")]
+    pub fn set_mapped_at_creation(this: &GpuBufferDescriptor, val: bool);
+
+    #[doc = "Get the `size` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "size")]
+    pub fn get_size(this: &GpuBufferDescriptor) -> f64;
+
+    #[doc = "Change the `size` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "size")]
+    pub fn set_size(this: &GpuBufferDescriptor, val: f64);
+
+    #[doc = "Get the `usage` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "usage")]
+    pub fn get_usage(this: &GpuBufferDescriptor) -> u32;
+
+    #[doc = "Change the `usage` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "usage")]
+    pub fn set_usage(this: &GpuBufferDescriptor, val: u32);
+}
+
+impl GpuBufferDescriptor {
+    #[doc = "Construct a new `GpuBufferDescriptor`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(size: f64, usage: u32) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_size(size);
+        ret.set_usage(usage);
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+
+    #[deprecated = "Use `set_mapped_at_creation()` instead."]
+    pub fn mapped_at_creation(&mut self, val: bool) -> &mut Self {
+        self.set_mapped_at_creation(val);
+        self
+    }
+
+    #[deprecated = "Use `set_size()` instead."]
+    pub fn size(&mut self, val: f64) -> &mut Self {
+        self.set_size(val);
+        self
+    }
+
+    #[deprecated = "Use `set_usage()` instead."]
+    pub fn usage(&mut self, val: u32) -> &mut Self {
+        self.set_usage(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuBufferMapState.rs

@@ -0,0 +1,38 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuBufferMapState` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuBufferMapState`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuBufferMapState {
+    Unmapped = "unmapped",
+    Pending = "pending",
+    Mapped = "mapped",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCanvasAlphaMode.rs

@@ -0,0 +1,37 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuCanvasAlphaMode` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuCanvasAlphaMode`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuCanvasAlphaMode {
+    Opaque = "opaque",
+    Premultiplied = "premultiplied",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCanvasConfiguration.rs

@@ -0,0 +1,198 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCanvasConfiguration)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCanvasConfiguration` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCanvasConfiguration;
+
+    #[doc = "Get the `alphaMode` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasAlphaMode`, `GpuCanvasConfiguration`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "alphaMode")]
+    pub fn get_alpha_mode(this: &GpuCanvasConfiguration) -> Option<GpuCanvasAlphaMode>;
+
+    #[doc = "Change the `alphaMode` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasAlphaMode`, `GpuCanvasConfiguration`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "alphaMode")]
+    pub fn set_alpha_mode(this: &GpuCanvasConfiguration, val: GpuCanvasAlphaMode);
+
+    #[doc = "Get the `device` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`, `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "device")]
+    pub fn get_device(this: &GpuCanvasConfiguration) -> GpuDevice;
+
+    #[doc = "Change the `device` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`, `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "device")]
+    pub fn set_device(this: &GpuCanvasConfiguration, val: &GpuDevice);
+
+    #[doc = "Get the `format` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`, `GpuTextureFormat`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "format")]
+    pub fn get_format(this: &GpuCanvasConfiguration) -> GpuTextureFormat;
+
+    #[doc = "Change the `format` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`, `GpuTextureFormat`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "format")]
+    pub fn set_format(this: &GpuCanvasConfiguration, val: GpuTextureFormat);
+
+    #[doc = "Get the `toneMapping` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`, `GpuCanvasToneMapping`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "toneMapping")]
+    pub fn get_tone_mapping(this: &GpuCanvasConfiguration) -> Option<GpuCanvasToneMapping>;
+
+    #[doc = "Change the `toneMapping` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`, `GpuCanvasToneMapping`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "toneMapping")]
+    pub fn set_tone_mapping(this: &GpuCanvasConfiguration, val: &GpuCanvasToneMapping);
+
+    #[doc = "Get the `usage` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "usage")]
+    pub fn get_usage(this: &GpuCanvasConfiguration) -> Option<u32>;
+
+    #[doc = "Change the `usage` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "usage")]
+    pub fn set_usage(this: &GpuCanvasConfiguration, val: u32);
+
+    #[doc = "Get the `viewFormats` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "viewFormats")]
+    pub fn get_view_formats(this: &GpuCanvasConfiguration) -> Option<::js_sys::Array>;
+
+    #[doc = "Change the `viewFormats` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "viewFormats")]
+    pub fn set_view_formats(this: &GpuCanvasConfiguration, val: &::wasm_bindgen::JsValue);
+}
+
+impl GpuCanvasConfiguration {
+    #[doc = "Construct a new `GpuCanvasConfiguration`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`, `GpuDevice`, `GpuTextureFormat`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(device: &GpuDevice, format: GpuTextureFormat) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_device(device);
+        ret.set_format(format);
+        ret
+    }
+
+    #[deprecated = "Use `set_alpha_mode()` instead."]
+    pub fn alpha_mode(&mut self, val: GpuCanvasAlphaMode) -> &mut Self {
+        self.set_alpha_mode(val);
+        self
+    }
+
+    #[deprecated = "Use `set_device()` instead."]
+    pub fn device(&mut self, val: &GpuDevice) -> &mut Self {
+        self.set_device(val);
+        self
+    }
+
+    #[deprecated = "Use `set_format()` instead."]
+    pub fn format(&mut self, val: GpuTextureFormat) -> &mut Self {
+        self.set_format(val);
+        self
+    }
+
+    #[deprecated = "Use `set_tone_mapping()` instead."]
+    pub fn tone_mapping(&mut self, val: &GpuCanvasToneMapping) -> &mut Self {
+        self.set_tone_mapping(val);
+        self
+    }
+
+    #[deprecated = "Use `set_usage()` instead."]
+    pub fn usage(&mut self, val: u32) -> &mut Self {
+        self.set_usage(val);
+        self
+    }
+
+    #[deprecated = "Use `set_view_formats()` instead."]
+    pub fn view_formats(&mut self, val: &::wasm_bindgen::JsValue) -> &mut Self {
+        self.set_view_formats(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCanvasContext.rs

@@ -0,0 +1,98 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCanvasContext , typescript_type = "GPUCanvasContext")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCanvasContext` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCanvasContext)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasContext`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCanvasContext;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUCanvasContext" , js_name = canvas)]
+    #[doc = "Getter for the `canvas` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCanvasContext/canvas)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasContext`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn canvas(this: &GpuCanvasContext) -> ::js_sys::Object;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCanvasContext" , js_name = configure)]
+    #[doc = "The `configure()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCanvasContext/configure)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`, `GpuCanvasContext`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn configure(
+        this: &GpuCanvasContext,
+        configuration: &GpuCanvasConfiguration,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCanvasContext" , js_name = getConfiguration)]
+    #[doc = "The `getConfiguration()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCanvasContext/getConfiguration)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasConfiguration`, `GpuCanvasContext`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_configuration(this: &GpuCanvasContext) -> Option<GpuCanvasConfiguration>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCanvasContext" , js_name = getCurrentTexture)]
+    #[doc = "The `getCurrentTexture()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCanvasContext/getCurrentTexture)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasContext`, `GpuTexture`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_current_texture(this: &GpuCanvasContext) -> Result<GpuTexture, JsValue>;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCanvasContext" , js_name = unconfigure)]
+    #[doc = "The `unconfigure()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCanvasContext/unconfigure)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasContext`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn unconfigure(this: &GpuCanvasContext);
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCanvasToneMapping.rs

@@ -0,0 +1,82 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCanvasToneMapping)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCanvasToneMapping` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasToneMapping`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCanvasToneMapping;
+
+    #[doc = "Get the `mode` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasToneMapping`, `GpuCanvasToneMappingMode`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "mode")]
+    pub fn get_mode(this: &GpuCanvasToneMapping) -> Option<GpuCanvasToneMappingMode>;
+
+    #[doc = "Change the `mode` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasToneMapping`, `GpuCanvasToneMappingMode`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "mode")]
+    pub fn set_mode(this: &GpuCanvasToneMapping, val: GpuCanvasToneMappingMode);
+}
+
+impl GpuCanvasToneMapping {
+    #[doc = "Construct a new `GpuCanvasToneMapping`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCanvasToneMapping`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_mode()` instead."]
+    pub fn mode(&mut self, val: GpuCanvasToneMappingMode) -> &mut Self {
+        self.set_mode(val);
+        self
+    }
+}
+
+impl Default for GpuCanvasToneMapping {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCanvasToneMappingMode.rs

@@ -0,0 +1,37 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuCanvasToneMappingMode` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuCanvasToneMappingMode`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuCanvasToneMappingMode {
+    Standard = "standard",
+    Extended = "extended",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuColorDict.rs

@@ -0,0 +1,152 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUColorDict)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuColorDict` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuColorDict;
+
+    #[doc = "Get the `a` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "a")]
+    pub fn get_a(this: &GpuColorDict) -> f64;
+
+    #[doc = "Change the `a` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "a")]
+    pub fn set_a(this: &GpuColorDict, val: f64);
+
+    #[doc = "Get the `b` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "b")]
+    pub fn get_b(this: &GpuColorDict) -> f64;
+
+    #[doc = "Change the `b` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "b")]
+    pub fn set_b(this: &GpuColorDict, val: f64);
+
+    #[doc = "Get the `g` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "g")]
+    pub fn get_g(this: &GpuColorDict) -> f64;
+
+    #[doc = "Change the `g` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "g")]
+    pub fn set_g(this: &GpuColorDict, val: f64);
+
+    #[doc = "Get the `r` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "r")]
+    pub fn get_r(this: &GpuColorDict) -> f64;
+
+    #[doc = "Change the `r` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "r")]
+    pub fn set_r(this: &GpuColorDict, val: f64);
+}
+
+impl GpuColorDict {
+    #[doc = "Construct a new `GpuColorDict`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(a: f64, b: f64, g: f64, r: f64) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_a(a);
+        ret.set_b(b);
+        ret.set_g(g);
+        ret.set_r(r);
+        ret
+    }
+
+    #[deprecated = "Use `set_a()` instead."]
+    pub fn a(&mut self, val: f64) -> &mut Self {
+        self.set_a(val);
+        self
+    }
+
+    #[deprecated = "Use `set_b()` instead."]
+    pub fn b(&mut self, val: f64) -> &mut Self {
+        self.set_b(val);
+        self
+    }
+
+    #[deprecated = "Use `set_g()` instead."]
+    pub fn g(&mut self, val: f64) -> &mut Self {
+        self.set_g(val);
+        self
+    }
+
+    #[deprecated = "Use `set_r()` instead."]
+    pub fn r(&mut self, val: f64) -> &mut Self {
+        self.set_r(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuColorTargetState.rs

@@ -0,0 +1,125 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUColorTargetState)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuColorTargetState` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorTargetState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuColorTargetState;
+
+    #[doc = "Get the `blend` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendState`, `GpuColorTargetState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "blend")]
+    pub fn get_blend(this: &GpuColorTargetState) -> Option<GpuBlendState>;
+
+    #[doc = "Change the `blend` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBlendState`, `GpuColorTargetState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "blend")]
+    pub fn set_blend(this: &GpuColorTargetState, val: &GpuBlendState);
+
+    #[doc = "Get the `format` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorTargetState`, `GpuTextureFormat`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "format")]
+    pub fn get_format(this: &GpuColorTargetState) -> GpuTextureFormat;
+
+    #[doc = "Change the `format` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorTargetState`, `GpuTextureFormat`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "format")]
+    pub fn set_format(this: &GpuColorTargetState, val: GpuTextureFormat);
+
+    #[doc = "Get the `writeMask` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorTargetState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "writeMask")]
+    pub fn get_write_mask(this: &GpuColorTargetState) -> Option<u32>;
+
+    #[doc = "Change the `writeMask` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorTargetState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "writeMask")]
+    pub fn set_write_mask(this: &GpuColorTargetState, val: u32);
+}
+
+impl GpuColorTargetState {
+    #[doc = "Construct a new `GpuColorTargetState`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuColorTargetState`, `GpuTextureFormat`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(format: GpuTextureFormat) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_format(format);
+        ret
+    }
+
+    #[deprecated = "Use `set_blend()` instead."]
+    pub fn blend(&mut self, val: &GpuBlendState) -> &mut Self {
+        self.set_blend(val);
+        self
+    }
+
+    #[deprecated = "Use `set_format()` instead."]
+    pub fn format(&mut self, val: GpuTextureFormat) -> &mut Self {
+        self.set_format(val);
+        self
+    }
+
+    #[deprecated = "Use `set_write_mask()` instead."]
+    pub fn write_mask(&mut self, val: u32) -> &mut Self {
+        self.set_write_mask(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCommandBuffer.rs

@@ -0,0 +1,62 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCommandBuffer , typescript_type = "GPUCommandBuffer")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCommandBuffer` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCommandBuffer;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUCommandBuffer" , js_name = label)]
+    #[doc = "Getter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandBuffer/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn label(this: &GpuCommandBuffer) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , setter , js_class = "GPUCommandBuffer" , js_name = label)]
+    #[doc = "Setter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandBuffer/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandBuffer`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_label(this: &GpuCommandBuffer, value: &str);
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCommandBufferDescriptor.rs

@@ -0,0 +1,82 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCommandBufferDescriptor)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCommandBufferDescriptor` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCommandBufferDescriptor;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuCommandBufferDescriptor) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuCommandBufferDescriptor, val: &str);
+}
+
+impl GpuCommandBufferDescriptor {
+    #[doc = "Construct a new `GpuCommandBufferDescriptor`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandBufferDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+}
+
+impl Default for GpuCommandBufferDescriptor {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCommandEncoder.rs

@@ -0,0 +1,532 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCommandEncoder , typescript_type = "GPUCommandEncoder")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCommandEncoder` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCommandEncoder;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUCommandEncoder" , js_name = label)]
+    #[doc = "Getter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn label(this: &GpuCommandEncoder) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , setter , js_class = "GPUCommandEncoder" , js_name = label)]
+    #[doc = "Setter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_label(this: &GpuCommandEncoder, value: &str);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = beginComputePass)]
+    #[doc = "The `beginComputePass()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/beginComputePass)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn begin_compute_pass(this: &GpuCommandEncoder) -> GpuComputePassEncoder;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = beginComputePass)]
+    #[doc = "The `beginComputePass()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/beginComputePass)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuComputePassDescriptor`, `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn begin_compute_pass_with_descriptor(
+        this: &GpuCommandEncoder,
+        descriptor: &GpuComputePassDescriptor,
+    ) -> GpuComputePassEncoder;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = beginRenderPass)]
+    #[doc = "The `beginRenderPass()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/beginRenderPass)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuRenderPassDescriptor`, `GpuRenderPassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn begin_render_pass(
+        this: &GpuCommandEncoder,
+        descriptor: &GpuRenderPassDescriptor,
+    ) -> Result<GpuRenderPassEncoder, JsValue>;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = clearBuffer)]
+    #[doc = "The `clearBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/clearBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn clear_buffer(this: &GpuCommandEncoder, buffer: &GpuBuffer);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = clearBuffer)]
+    #[doc = "The `clearBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/clearBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn clear_buffer_with_u32(this: &GpuCommandEncoder, buffer: &GpuBuffer, offset: u32);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = clearBuffer)]
+    #[doc = "The `clearBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/clearBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn clear_buffer_with_f64(this: &GpuCommandEncoder, buffer: &GpuBuffer, offset: f64);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = clearBuffer)]
+    #[doc = "The `clearBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/clearBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn clear_buffer_with_u32_and_u32(
+        this: &GpuCommandEncoder,
+        buffer: &GpuBuffer,
+        offset: u32,
+        size: u32,
+    );
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = clearBuffer)]
+    #[doc = "The `clearBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/clearBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn clear_buffer_with_f64_and_u32(
+        this: &GpuCommandEncoder,
+        buffer: &GpuBuffer,
+        offset: f64,
+        size: u32,
+    );
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = clearBuffer)]
+    #[doc = "The `clearBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/clearBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn clear_buffer_with_u32_and_f64(
+        this: &GpuCommandEncoder,
+        buffer: &GpuBuffer,
+        offset: u32,
+        size: f64,
+    );
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = clearBuffer)]
+    #[doc = "The `clearBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/clearBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn clear_buffer_with_f64_and_f64(
+        this: &GpuCommandEncoder,
+        buffer: &GpuBuffer,
+        offset: f64,
+        size: f64,
+    );
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyBufferToBuffer)]
+    #[doc = "The `copyBufferToBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyBufferToBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_buffer_to_buffer_with_u32_and_u32_and_u32(
+        this: &GpuCommandEncoder,
+        source: &GpuBuffer,
+        source_offset: u32,
+        destination: &GpuBuffer,
+        destination_offset: u32,
+        size: u32,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyBufferToBuffer)]
+    #[doc = "The `copyBufferToBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyBufferToBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_buffer_to_buffer_with_f64_and_u32_and_u32(
+        this: &GpuCommandEncoder,
+        source: &GpuBuffer,
+        source_offset: f64,
+        destination: &GpuBuffer,
+        destination_offset: u32,
+        size: u32,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyBufferToBuffer)]
+    #[doc = "The `copyBufferToBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyBufferToBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_buffer_to_buffer_with_u32_and_f64_and_u32(
+        this: &GpuCommandEncoder,
+        source: &GpuBuffer,
+        source_offset: u32,
+        destination: &GpuBuffer,
+        destination_offset: f64,
+        size: u32,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyBufferToBuffer)]
+    #[doc = "The `copyBufferToBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyBufferToBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_buffer_to_buffer_with_f64_and_f64_and_u32(
+        this: &GpuCommandEncoder,
+        source: &GpuBuffer,
+        source_offset: f64,
+        destination: &GpuBuffer,
+        destination_offset: f64,
+        size: u32,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyBufferToBuffer)]
+    #[doc = "The `copyBufferToBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyBufferToBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_buffer_to_buffer_with_u32_and_u32_and_f64(
+        this: &GpuCommandEncoder,
+        source: &GpuBuffer,
+        source_offset: u32,
+        destination: &GpuBuffer,
+        destination_offset: u32,
+        size: f64,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyBufferToBuffer)]
+    #[doc = "The `copyBufferToBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyBufferToBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_buffer_to_buffer_with_f64_and_u32_and_f64(
+        this: &GpuCommandEncoder,
+        source: &GpuBuffer,
+        source_offset: f64,
+        destination: &GpuBuffer,
+        destination_offset: u32,
+        size: f64,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyBufferToBuffer)]
+    #[doc = "The `copyBufferToBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyBufferToBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_buffer_to_buffer_with_u32_and_f64_and_f64(
+        this: &GpuCommandEncoder,
+        source: &GpuBuffer,
+        source_offset: u32,
+        destination: &GpuBuffer,
+        destination_offset: f64,
+        size: f64,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyBufferToBuffer)]
+    #[doc = "The `copyBufferToBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyBufferToBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_buffer_to_buffer_with_f64_and_f64_and_f64(
+        this: &GpuCommandEncoder,
+        source: &GpuBuffer,
+        source_offset: f64,
+        destination: &GpuBuffer,
+        destination_offset: f64,
+        size: f64,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyBufferToTexture)]
+    #[doc = "The `copyBufferToTexture()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyBufferToTexture)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuTexelCopyBufferInfo`, `GpuTexelCopyTextureInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_buffer_to_texture_with_u32_sequence(
+        this: &GpuCommandEncoder,
+        source: &GpuTexelCopyBufferInfo,
+        destination: &GpuTexelCopyTextureInfo,
+        copy_size: &::wasm_bindgen::JsValue,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyBufferToTexture)]
+    #[doc = "The `copyBufferToTexture()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyBufferToTexture)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuExtent3dDict`, `GpuTexelCopyBufferInfo`, `GpuTexelCopyTextureInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_buffer_to_texture_with_gpu_extent_3d_dict(
+        this: &GpuCommandEncoder,
+        source: &GpuTexelCopyBufferInfo,
+        destination: &GpuTexelCopyTextureInfo,
+        copy_size: &GpuExtent3dDict,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyTextureToBuffer)]
+    #[doc = "The `copyTextureToBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyTextureToBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuTexelCopyBufferInfo`, `GpuTexelCopyTextureInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_texture_to_buffer_with_u32_sequence(
+        this: &GpuCommandEncoder,
+        source: &GpuTexelCopyTextureInfo,
+        destination: &GpuTexelCopyBufferInfo,
+        copy_size: &::wasm_bindgen::JsValue,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyTextureToBuffer)]
+    #[doc = "The `copyTextureToBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyTextureToBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuExtent3dDict`, `GpuTexelCopyBufferInfo`, `GpuTexelCopyTextureInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_texture_to_buffer_with_gpu_extent_3d_dict(
+        this: &GpuCommandEncoder,
+        source: &GpuTexelCopyTextureInfo,
+        destination: &GpuTexelCopyBufferInfo,
+        copy_size: &GpuExtent3dDict,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyTextureToTexture)]
+    #[doc = "The `copyTextureToTexture()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyTextureToTexture)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuTexelCopyTextureInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_texture_to_texture_with_u32_sequence(
+        this: &GpuCommandEncoder,
+        source: &GpuTexelCopyTextureInfo,
+        destination: &GpuTexelCopyTextureInfo,
+        copy_size: &::wasm_bindgen::JsValue,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUCommandEncoder" , js_name = copyTextureToTexture)]
+    #[doc = "The `copyTextureToTexture()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/copyTextureToTexture)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuExtent3dDict`, `GpuTexelCopyTextureInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn copy_texture_to_texture_with_gpu_extent_3d_dict(
+        this: &GpuCommandEncoder,
+        source: &GpuTexelCopyTextureInfo,
+        destination: &GpuTexelCopyTextureInfo,
+        copy_size: &GpuExtent3dDict,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = finish)]
+    #[doc = "The `finish()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/finish)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandBuffer`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn finish(this: &GpuCommandEncoder) -> GpuCommandBuffer;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = finish)]
+    #[doc = "The `finish()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/finish)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandBuffer`, `GpuCommandBufferDescriptor`, `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn finish_with_descriptor(
+        this: &GpuCommandEncoder,
+        descriptor: &GpuCommandBufferDescriptor,
+    ) -> GpuCommandBuffer;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = resolveQuerySet)]
+    #[doc = "The `resolveQuerySet()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/resolveQuerySet)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`, `GpuQuerySet`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn resolve_query_set_with_u32(
+        this: &GpuCommandEncoder,
+        query_set: &GpuQuerySet,
+        first_query: u32,
+        query_count: u32,
+        destination: &GpuBuffer,
+        destination_offset: u32,
+    );
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = resolveQuerySet)]
+    #[doc = "The `resolveQuerySet()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/resolveQuerySet)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuCommandEncoder`, `GpuQuerySet`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn resolve_query_set_with_f64(
+        this: &GpuCommandEncoder,
+        query_set: &GpuQuerySet,
+        first_query: u32,
+        query_count: u32,
+        destination: &GpuBuffer,
+        destination_offset: f64,
+    );
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = insertDebugMarker)]
+    #[doc = "The `insertDebugMarker()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/insertDebugMarker)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn insert_debug_marker(this: &GpuCommandEncoder, marker_label: &str);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = popDebugGroup)]
+    #[doc = "The `popDebugGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/popDebugGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn pop_debug_group(this: &GpuCommandEncoder);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUCommandEncoder" , js_name = pushDebugGroup)]
+    #[doc = "The `pushDebugGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCommandEncoder/pushDebugGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn push_debug_group(this: &GpuCommandEncoder, group_label: &str);
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCommandEncoderDescriptor.rs

@@ -0,0 +1,82 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCommandEncoderDescriptor)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCommandEncoderDescriptor` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoderDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCommandEncoderDescriptor;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoderDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuCommandEncoderDescriptor) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoderDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuCommandEncoderDescriptor, val: &str);
+}
+
+impl GpuCommandEncoderDescriptor {
+    #[doc = "Construct a new `GpuCommandEncoderDescriptor`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoderDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+}
+
+impl Default for GpuCommandEncoderDescriptor {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCompareFunction.rs

@@ -0,0 +1,43 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuCompareFunction` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuCompareFunction`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuCompareFunction {
+    Never = "never",
+    Less = "less",
+    Equal = "equal",
+    LessEqual = "less-equal",
+    Greater = "greater",
+    NotEqual = "not-equal",
+    GreaterEqual = "greater-equal",
+    Always = "always",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCompilationInfo.rs

@@ -0,0 +1,51 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCompilationInfo , typescript_type = "GPUCompilationInfo")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCompilationInfo` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCompilationInfo)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompilationInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCompilationInfo;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUCompilationInfo" , js_name = messages)]
+    #[doc = "Getter for the `messages` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCompilationInfo/messages)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompilationInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn messages(this: &GpuCompilationInfo) -> ::js_sys::Array;
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCompilationMessage.rs

@@ -0,0 +1,106 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCompilationMessage , typescript_type = "GPUCompilationMessage")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCompilationMessage` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCompilationMessage)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompilationMessage`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCompilationMessage;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUCompilationMessage" , js_name = message)]
+    #[doc = "Getter for the `message` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCompilationMessage/message)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompilationMessage`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn message(this: &GpuCompilationMessage) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUCompilationMessage" , js_name = type)]
+    #[doc = "Getter for the `type` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCompilationMessage/type)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompilationMessage`, `GpuCompilationMessageType`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn type_(this: &GpuCompilationMessage) -> GpuCompilationMessageType;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUCompilationMessage" , js_name = lineNum)]
+    #[doc = "Getter for the `lineNum` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCompilationMessage/lineNum)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompilationMessage`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn line_num(this: &GpuCompilationMessage) -> f64;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUCompilationMessage" , js_name = linePos)]
+    #[doc = "Getter for the `linePos` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCompilationMessage/linePos)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompilationMessage`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn line_pos(this: &GpuCompilationMessage) -> f64;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUCompilationMessage" , js_name = offset)]
+    #[doc = "Getter for the `offset` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCompilationMessage/offset)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompilationMessage`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn offset(this: &GpuCompilationMessage) -> f64;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUCompilationMessage" , js_name = length)]
+    #[doc = "Getter for the `length` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUCompilationMessage/length)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompilationMessage`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn length(this: &GpuCompilationMessage) -> f64;
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCompilationMessageType.rs

@@ -0,0 +1,38 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuCompilationMessageType` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuCompilationMessageType`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuCompilationMessageType {
+    Error = "error",
+    Warning = "warning",
+    Info = "info",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuComputePassDescriptor.rs

@@ -0,0 +1,111 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUComputePassDescriptor)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuComputePassDescriptor` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuComputePassDescriptor;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuComputePassDescriptor) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuComputePassDescriptor, val: &str);
+
+    #[doc = "Get the `timestampWrites` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassDescriptor`, `GpuComputePassTimestampWrites`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "timestampWrites")]
+    pub fn get_timestamp_writes(
+        this: &GpuComputePassDescriptor,
+    ) -> Option<GpuComputePassTimestampWrites>;
+
+    #[doc = "Change the `timestampWrites` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassDescriptor`, `GpuComputePassTimestampWrites`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "timestampWrites")]
+    pub fn set_timestamp_writes(
+        this: &GpuComputePassDescriptor,
+        val: &GpuComputePassTimestampWrites,
+    );
+}
+
+impl GpuComputePassDescriptor {
+    #[doc = "Construct a new `GpuComputePassDescriptor`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+
+    #[deprecated = "Use `set_timestamp_writes()` instead."]
+    pub fn timestamp_writes(&mut self, val: &GpuComputePassTimestampWrites) -> &mut Self {
+        self.set_timestamp_writes(val);
+        self
+    }
+}
+
+impl Default for GpuComputePassDescriptor {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuComputePassEncoder.rs

@@ -0,0 +1,292 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUComputePassEncoder , typescript_type = "GPUComputePassEncoder")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuComputePassEncoder` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuComputePassEncoder;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUComputePassEncoder" , js_name = label)]
+    #[doc = "Getter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn label(this: &GpuComputePassEncoder) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , setter , js_class = "GPUComputePassEncoder" , js_name = label)]
+    #[doc = "Setter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_label(this: &GpuComputePassEncoder, value: &str);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = dispatchWorkgroups)]
+    #[doc = "The `dispatchWorkgroups()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn dispatch_workgroups(this: &GpuComputePassEncoder, workgroup_count_x: u32);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = dispatchWorkgroups)]
+    #[doc = "The `dispatchWorkgroups()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn dispatch_workgroups_with_workgroup_count_y(
+        this: &GpuComputePassEncoder,
+        workgroup_count_x: u32,
+        workgroup_count_y: u32,
+    );
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = dispatchWorkgroups)]
+    #[doc = "The `dispatchWorkgroups()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroups)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn dispatch_workgroups_with_workgroup_count_y_and_workgroup_count_z(
+        this: &GpuComputePassEncoder,
+        workgroup_count_x: u32,
+        workgroup_count_y: u32,
+        workgroup_count_z: u32,
+    );
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = dispatchWorkgroupsIndirect)]
+    #[doc = "The `dispatchWorkgroupsIndirect()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn dispatch_workgroups_indirect_with_u32(
+        this: &GpuComputePassEncoder,
+        indirect_buffer: &GpuBuffer,
+        indirect_offset: u32,
+    );
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = dispatchWorkgroupsIndirect)]
+    #[doc = "The `dispatchWorkgroupsIndirect()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/dispatchWorkgroupsIndirect)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn dispatch_workgroups_indirect_with_f64(
+        this: &GpuComputePassEncoder,
+        indirect_buffer: &GpuBuffer,
+        indirect_offset: f64,
+    );
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = end)]
+    #[doc = "The `end()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/end)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn end(this: &GpuComputePassEncoder);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = setPipeline)]
+    #[doc = "The `setPipeline()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/setPipeline)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`, `GpuComputePipeline`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_pipeline(this: &GpuComputePassEncoder, pipeline: &GpuComputePipeline);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = setBindGroup)]
+    #[doc = "The `setBindGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/setBindGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroup`, `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_bind_group(
+        this: &GpuComputePassEncoder,
+        index: u32,
+        bind_group: Option<&GpuBindGroup>,
+    );
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = setBindGroup)]
+    #[doc = "The `setBindGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/setBindGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroup`, `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_bind_group_with_u32_sequence(
+        this: &GpuComputePassEncoder,
+        index: u32,
+        bind_group: Option<&GpuBindGroup>,
+        dynamic_offsets: &::wasm_bindgen::JsValue,
+    );
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUComputePassEncoder" , js_name = setBindGroup)]
+    #[doc = "The `setBindGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/setBindGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroup`, `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_bind_group_with_u32_slice_and_u32_and_dynamic_offsets_data_length(
+        this: &GpuComputePassEncoder,
+        index: u32,
+        bind_group: Option<&GpuBindGroup>,
+        dynamic_offsets_data: &[u32],
+        dynamic_offsets_data_start: u32,
+        dynamic_offsets_data_length: u32,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUComputePassEncoder" , js_name = setBindGroup)]
+    #[doc = "The `setBindGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/setBindGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroup`, `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_bind_group_with_u32_array_and_u32_and_dynamic_offsets_data_length(
+        this: &GpuComputePassEncoder,
+        index: u32,
+        bind_group: Option<&GpuBindGroup>,
+        dynamic_offsets_data: &::js_sys::Uint32Array,
+        dynamic_offsets_data_start: u32,
+        dynamic_offsets_data_length: u32,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUComputePassEncoder" , js_name = setBindGroup)]
+    #[doc = "The `setBindGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/setBindGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroup`, `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_bind_group_with_u32_slice_and_f64_and_dynamic_offsets_data_length(
+        this: &GpuComputePassEncoder,
+        index: u32,
+        bind_group: Option<&GpuBindGroup>,
+        dynamic_offsets_data: &[u32],
+        dynamic_offsets_data_start: f64,
+        dynamic_offsets_data_length: u32,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUComputePassEncoder" , js_name = setBindGroup)]
+    #[doc = "The `setBindGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/setBindGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroup`, `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_bind_group_with_u32_array_and_f64_and_dynamic_offsets_data_length(
+        this: &GpuComputePassEncoder,
+        index: u32,
+        bind_group: Option<&GpuBindGroup>,
+        dynamic_offsets_data: &::js_sys::Uint32Array,
+        dynamic_offsets_data_start: f64,
+        dynamic_offsets_data_length: u32,
+    ) -> Result<(), JsValue>;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = insertDebugMarker)]
+    #[doc = "The `insertDebugMarker()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/insertDebugMarker)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn insert_debug_marker(this: &GpuComputePassEncoder, marker_label: &str);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = popDebugGroup)]
+    #[doc = "The `popDebugGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/popDebugGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn pop_debug_group(this: &GpuComputePassEncoder);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePassEncoder" , js_name = pushDebugGroup)]
+    #[doc = "The `pushDebugGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePassEncoder/pushDebugGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassEncoder`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn push_debug_group(this: &GpuComputePassEncoder, group_label: &str);
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuComputePassTimestampWrites.rs

@@ -0,0 +1,125 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUComputePassTimestampWrites)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuComputePassTimestampWrites` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassTimestampWrites`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuComputePassTimestampWrites;
+
+    #[doc = "Get the `beginningOfPassWriteIndex` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassTimestampWrites`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "beginningOfPassWriteIndex")]
+    pub fn get_beginning_of_pass_write_index(this: &GpuComputePassTimestampWrites) -> Option<u32>;
+
+    #[doc = "Change the `beginningOfPassWriteIndex` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassTimestampWrites`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "beginningOfPassWriteIndex")]
+    pub fn set_beginning_of_pass_write_index(this: &GpuComputePassTimestampWrites, val: u32);
+
+    #[doc = "Get the `endOfPassWriteIndex` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassTimestampWrites`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "endOfPassWriteIndex")]
+    pub fn get_end_of_pass_write_index(this: &GpuComputePassTimestampWrites) -> Option<u32>;
+
+    #[doc = "Change the `endOfPassWriteIndex` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassTimestampWrites`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "endOfPassWriteIndex")]
+    pub fn set_end_of_pass_write_index(this: &GpuComputePassTimestampWrites, val: u32);
+
+    #[doc = "Get the `querySet` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassTimestampWrites`, `GpuQuerySet`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "querySet")]
+    pub fn get_query_set(this: &GpuComputePassTimestampWrites) -> GpuQuerySet;
+
+    #[doc = "Change the `querySet` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassTimestampWrites`, `GpuQuerySet`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "querySet")]
+    pub fn set_query_set(this: &GpuComputePassTimestampWrites, val: &GpuQuerySet);
+}
+
+impl GpuComputePassTimestampWrites {
+    #[doc = "Construct a new `GpuComputePassTimestampWrites`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePassTimestampWrites`, `GpuQuerySet`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(query_set: &GpuQuerySet) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_query_set(query_set);
+        ret
+    }
+
+    #[deprecated = "Use `set_beginning_of_pass_write_index()` instead."]
+    pub fn beginning_of_pass_write_index(&mut self, val: u32) -> &mut Self {
+        self.set_beginning_of_pass_write_index(val);
+        self
+    }
+
+    #[deprecated = "Use `set_end_of_pass_write_index()` instead."]
+    pub fn end_of_pass_write_index(&mut self, val: u32) -> &mut Self {
+        self.set_end_of_pass_write_index(val);
+        self
+    }
+
+    #[deprecated = "Use `set_query_set()` instead."]
+    pub fn query_set(&mut self, val: &GpuQuerySet) -> &mut Self {
+        self.set_query_set(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuComputePipeline.rs

@@ -0,0 +1,73 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUComputePipeline , typescript_type = "GPUComputePipeline")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuComputePipeline` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePipeline)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipeline`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuComputePipeline;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUComputePipeline" , js_name = label)]
+    #[doc = "Getter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePipeline/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipeline`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn label(this: &GpuComputePipeline) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , setter , js_class = "GPUComputePipeline" , js_name = label)]
+    #[doc = "Setter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePipeline/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipeline`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_label(this: &GpuComputePipeline, value: &str);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUComputePipeline" , js_name = getBindGroupLayout)]
+    #[doc = "The `getBindGroupLayout()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUComputePipeline/getBindGroupLayout)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayout`, `GpuComputePipeline`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn get_bind_group_layout(this: &GpuComputePipeline, index: u32) -> GpuBindGroupLayout;
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuComputePipelineDescriptor.rs

@@ -0,0 +1,126 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUComputePipelineDescriptor)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuComputePipelineDescriptor` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipelineDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuComputePipelineDescriptor;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipelineDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuComputePipelineDescriptor) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipelineDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuComputePipelineDescriptor, val: &str);
+
+    #[doc = "Get the `layout` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipelineDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "layout")]
+    pub fn get_layout(this: &GpuComputePipelineDescriptor) -> ::wasm_bindgen::JsValue;
+
+    #[doc = "Change the `layout` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipelineDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "layout")]
+    pub fn set_layout(this: &GpuComputePipelineDescriptor, val: &::wasm_bindgen::JsValue);
+
+    #[doc = "Get the `compute` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipelineDescriptor`, `GpuProgrammableStage`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "compute")]
+    pub fn get_compute(this: &GpuComputePipelineDescriptor) -> GpuProgrammableStage;
+
+    #[doc = "Change the `compute` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipelineDescriptor`, `GpuProgrammableStage`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "compute")]
+    pub fn set_compute(this: &GpuComputePipelineDescriptor, val: &GpuProgrammableStage);
+}
+
+impl GpuComputePipelineDescriptor {
+    #[doc = "Construct a new `GpuComputePipelineDescriptor`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipelineDescriptor`, `GpuProgrammableStage`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(layout: &::wasm_bindgen::JsValue, compute: &GpuProgrammableStage) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_layout(layout);
+        ret.set_compute(compute);
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+
+    #[deprecated = "Use `set_layout()` instead."]
+    pub fn layout(&mut self, val: &::wasm_bindgen::JsValue) -> &mut Self {
+        self.set_layout(val);
+        self
+    }
+
+    #[deprecated = "Use `set_compute()` instead."]
+    pub fn compute(&mut self, val: &GpuProgrammableStage) -> &mut Self {
+        self.set_compute(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCopyExternalImageDestInfo.rs

@@ -0,0 +1,173 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCopyExternalImageDestInfo)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCopyExternalImageDestInfo` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCopyExternalImageDestInfo;
+
+    #[doc = "Get the `aspect` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`, `GpuTextureAspect`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "aspect")]
+    pub fn get_aspect(this: &GpuCopyExternalImageDestInfo) -> Option<GpuTextureAspect>;
+
+    #[doc = "Change the `aspect` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`, `GpuTextureAspect`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "aspect")]
+    pub fn set_aspect(this: &GpuCopyExternalImageDestInfo, val: GpuTextureAspect);
+
+    #[doc = "Get the `mipLevel` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "mipLevel")]
+    pub fn get_mip_level(this: &GpuCopyExternalImageDestInfo) -> Option<u32>;
+
+    #[doc = "Change the `mipLevel` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "mipLevel")]
+    pub fn set_mip_level(this: &GpuCopyExternalImageDestInfo, val: u32);
+
+    #[doc = "Get the `origin` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "origin")]
+    pub fn get_origin(this: &GpuCopyExternalImageDestInfo) -> ::wasm_bindgen::JsValue;
+
+    #[doc = "Change the `origin` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "origin")]
+    pub fn set_origin(this: &GpuCopyExternalImageDestInfo, val: &::wasm_bindgen::JsValue);
+
+    #[doc = "Get the `texture` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`, `GpuTexture`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "texture")]
+    pub fn get_texture(this: &GpuCopyExternalImageDestInfo) -> GpuTexture;
+
+    #[doc = "Change the `texture` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`, `GpuTexture`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "texture")]
+    pub fn set_texture(this: &GpuCopyExternalImageDestInfo, val: &GpuTexture);
+
+    #[doc = "Get the `premultipliedAlpha` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "premultipliedAlpha")]
+    pub fn get_premultiplied_alpha(this: &GpuCopyExternalImageDestInfo) -> Option<bool>;
+
+    #[doc = "Change the `premultipliedAlpha` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "premultipliedAlpha")]
+    pub fn set_premultiplied_alpha(this: &GpuCopyExternalImageDestInfo, val: bool);
+}
+
+impl GpuCopyExternalImageDestInfo {
+    #[doc = "Construct a new `GpuCopyExternalImageDestInfo`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageDestInfo`, `GpuTexture`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(texture: &GpuTexture) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_texture(texture);
+        ret
+    }
+
+    #[deprecated = "Use `set_aspect()` instead."]
+    pub fn aspect(&mut self, val: GpuTextureAspect) -> &mut Self {
+        self.set_aspect(val);
+        self
+    }
+
+    #[deprecated = "Use `set_mip_level()` instead."]
+    pub fn mip_level(&mut self, val: u32) -> &mut Self {
+        self.set_mip_level(val);
+        self
+    }
+
+    #[deprecated = "Use `set_origin()` instead."]
+    pub fn origin(&mut self, val: &::wasm_bindgen::JsValue) -> &mut Self {
+        self.set_origin(val);
+        self
+    }
+
+    #[deprecated = "Use `set_texture()` instead."]
+    pub fn texture(&mut self, val: &GpuTexture) -> &mut Self {
+        self.set_texture(val);
+        self
+    }
+
+    #[deprecated = "Use `set_premultiplied_alpha()` instead."]
+    pub fn premultiplied_alpha(&mut self, val: bool) -> &mut Self {
+        self.set_premultiplied_alpha(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCopyExternalImageSourceInfo.rs

@@ -0,0 +1,125 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUCopyExternalImageSourceInfo)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuCopyExternalImageSourceInfo` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageSourceInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuCopyExternalImageSourceInfo;
+
+    #[doc = "Get the `flipY` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageSourceInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "flipY")]
+    pub fn get_flip_y(this: &GpuCopyExternalImageSourceInfo) -> Option<bool>;
+
+    #[doc = "Change the `flipY` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageSourceInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "flipY")]
+    pub fn set_flip_y(this: &GpuCopyExternalImageSourceInfo, val: bool);
+
+    #[doc = "Get the `origin` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageSourceInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "origin")]
+    pub fn get_origin(this: &GpuCopyExternalImageSourceInfo) -> ::wasm_bindgen::JsValue;
+
+    #[doc = "Change the `origin` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageSourceInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "origin")]
+    pub fn set_origin(this: &GpuCopyExternalImageSourceInfo, val: &::wasm_bindgen::JsValue);
+
+    #[doc = "Get the `source` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageSourceInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "source")]
+    pub fn get_source(this: &GpuCopyExternalImageSourceInfo) -> ::js_sys::Object;
+
+    #[doc = "Change the `source` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageSourceInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "source")]
+    pub fn set_source(this: &GpuCopyExternalImageSourceInfo, val: &::js_sys::Object);
+}
+
+impl GpuCopyExternalImageSourceInfo {
+    #[doc = "Construct a new `GpuCopyExternalImageSourceInfo`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCopyExternalImageSourceInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(source: &::js_sys::Object) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_source(source);
+        ret
+    }
+
+    #[deprecated = "Use `set_flip_y()` instead."]
+    pub fn flip_y(&mut self, val: bool) -> &mut Self {
+        self.set_flip_y(val);
+        self
+    }
+
+    #[deprecated = "Use `set_origin()` instead."]
+    pub fn origin(&mut self, val: &::wasm_bindgen::JsValue) -> &mut Self {
+        self.set_origin(val);
+        self
+    }
+
+    #[deprecated = "Use `set_source()` instead."]
+    pub fn source(&mut self, val: &::js_sys::Object) -> &mut Self {
+        self.set_source(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuCullMode.rs

@@ -0,0 +1,38 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuCullMode` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuCullMode`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuCullMode {
+    None = "none",
+    Front = "front",
+    Back = "back",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuDepthStencilState.rs

@@ -0,0 +1,293 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUDepthStencilState)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuDepthStencilState` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuDepthStencilState;
+
+    #[doc = "Get the `depthBias` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "depthBias")]
+    pub fn get_depth_bias(this: &GpuDepthStencilState) -> Option<i32>;
+
+    #[doc = "Change the `depthBias` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "depthBias")]
+    pub fn set_depth_bias(this: &GpuDepthStencilState, val: i32);
+
+    #[doc = "Get the `depthBiasClamp` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "depthBiasClamp")]
+    pub fn get_depth_bias_clamp(this: &GpuDepthStencilState) -> Option<f32>;
+
+    #[doc = "Change the `depthBiasClamp` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "depthBiasClamp")]
+    pub fn set_depth_bias_clamp(this: &GpuDepthStencilState, val: f32);
+
+    #[doc = "Get the `depthBiasSlopeScale` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "depthBiasSlopeScale")]
+    pub fn get_depth_bias_slope_scale(this: &GpuDepthStencilState) -> Option<f32>;
+
+    #[doc = "Change the `depthBiasSlopeScale` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "depthBiasSlopeScale")]
+    pub fn set_depth_bias_slope_scale(this: &GpuDepthStencilState, val: f32);
+
+    #[doc = "Get the `depthCompare` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompareFunction`, `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "depthCompare")]
+    pub fn get_depth_compare(this: &GpuDepthStencilState) -> Option<GpuCompareFunction>;
+
+    #[doc = "Change the `depthCompare` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCompareFunction`, `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "depthCompare")]
+    pub fn set_depth_compare(this: &GpuDepthStencilState, val: GpuCompareFunction);
+
+    #[doc = "Get the `depthWriteEnabled` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "depthWriteEnabled")]
+    pub fn get_depth_write_enabled(this: &GpuDepthStencilState) -> Option<bool>;
+
+    #[doc = "Change the `depthWriteEnabled` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "depthWriteEnabled")]
+    pub fn set_depth_write_enabled(this: &GpuDepthStencilState, val: bool);
+
+    #[doc = "Get the `format` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`, `GpuTextureFormat`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "format")]
+    pub fn get_format(this: &GpuDepthStencilState) -> GpuTextureFormat;
+
+    #[doc = "Change the `format` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`, `GpuTextureFormat`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "format")]
+    pub fn set_format(this: &GpuDepthStencilState, val: GpuTextureFormat);
+
+    #[doc = "Get the `stencilBack` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`, `GpuStencilFaceState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "stencilBack")]
+    pub fn get_stencil_back(this: &GpuDepthStencilState) -> Option<GpuStencilFaceState>;
+
+    #[doc = "Change the `stencilBack` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`, `GpuStencilFaceState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "stencilBack")]
+    pub fn set_stencil_back(this: &GpuDepthStencilState, val: &GpuStencilFaceState);
+
+    #[doc = "Get the `stencilFront` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`, `GpuStencilFaceState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "stencilFront")]
+    pub fn get_stencil_front(this: &GpuDepthStencilState) -> Option<GpuStencilFaceState>;
+
+    #[doc = "Change the `stencilFront` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`, `GpuStencilFaceState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "stencilFront")]
+    pub fn set_stencil_front(this: &GpuDepthStencilState, val: &GpuStencilFaceState);
+
+    #[doc = "Get the `stencilReadMask` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "stencilReadMask")]
+    pub fn get_stencil_read_mask(this: &GpuDepthStencilState) -> Option<u32>;
+
+    #[doc = "Change the `stencilReadMask` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "stencilReadMask")]
+    pub fn set_stencil_read_mask(this: &GpuDepthStencilState, val: u32);
+
+    #[doc = "Get the `stencilWriteMask` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "stencilWriteMask")]
+    pub fn get_stencil_write_mask(this: &GpuDepthStencilState) -> Option<u32>;
+
+    #[doc = "Change the `stencilWriteMask` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "stencilWriteMask")]
+    pub fn set_stencil_write_mask(this: &GpuDepthStencilState, val: u32);
+}
+
+impl GpuDepthStencilState {
+    #[doc = "Construct a new `GpuDepthStencilState`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDepthStencilState`, `GpuTextureFormat`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(format: GpuTextureFormat) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_format(format);
+        ret
+    }
+
+    #[deprecated = "Use `set_depth_bias()` instead."]
+    pub fn depth_bias(&mut self, val: i32) -> &mut Self {
+        self.set_depth_bias(val);
+        self
+    }
+
+    #[deprecated = "Use `set_depth_bias_clamp()` instead."]
+    pub fn depth_bias_clamp(&mut self, val: f32) -> &mut Self {
+        self.set_depth_bias_clamp(val);
+        self
+    }
+
+    #[deprecated = "Use `set_depth_bias_slope_scale()` instead."]
+    pub fn depth_bias_slope_scale(&mut self, val: f32) -> &mut Self {
+        self.set_depth_bias_slope_scale(val);
+        self
+    }
+
+    #[deprecated = "Use `set_depth_compare()` instead."]
+    pub fn depth_compare(&mut self, val: GpuCompareFunction) -> &mut Self {
+        self.set_depth_compare(val);
+        self
+    }
+
+    #[deprecated = "Use `set_depth_write_enabled()` instead."]
+    pub fn depth_write_enabled(&mut self, val: bool) -> &mut Self {
+        self.set_depth_write_enabled(val);
+        self
+    }
+
+    #[deprecated = "Use `set_format()` instead."]
+    pub fn format(&mut self, val: GpuTextureFormat) -> &mut Self {
+        self.set_format(val);
+        self
+    }
+
+    #[deprecated = "Use `set_stencil_back()` instead."]
+    pub fn stencil_back(&mut self, val: &GpuStencilFaceState) -> &mut Self {
+        self.set_stencil_back(val);
+        self
+    }
+
+    #[deprecated = "Use `set_stencil_front()` instead."]
+    pub fn stencil_front(&mut self, val: &GpuStencilFaceState) -> &mut Self {
+        self.set_stencil_front(val);
+        self
+    }
+
+    #[deprecated = "Use `set_stencil_read_mask()` instead."]
+    pub fn stencil_read_mask(&mut self, val: u32) -> &mut Self {
+        self.set_stencil_read_mask(val);
+        self
+    }
+
+    #[deprecated = "Use `set_stencil_write_mask()` instead."]
+    pub fn stencil_write_mask(&mut self, val: u32) -> &mut Self {
+        self.set_stencil_write_mask(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuDevice.rs

@@ -0,0 +1,402 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = EventTarget , extends = :: js_sys :: Object , js_name = GPUDevice , typescript_type = "GPUDevice")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuDevice` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuDevice;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUDevice" , js_name = features)]
+    #[doc = "Getter for the `features` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/features)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuSupportedFeatures`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn features(this: &GpuDevice) -> GpuSupportedFeatures;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUDevice" , js_name = limits)]
+    #[doc = "Getter for the `limits` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/limits)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuSupportedLimits`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn limits(this: &GpuDevice) -> GpuSupportedLimits;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUDevice" , js_name = adapterInfo)]
+    #[doc = "Getter for the `adapterInfo` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/adapterInfo)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuAdapterInfo`, `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn adapter_info(this: &GpuDevice) -> GpuAdapterInfo;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUDevice" , js_name = queue)]
+    #[doc = "Getter for the `queue` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/queue)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuQueue`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn queue(this: &GpuDevice) -> GpuQueue;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUDevice" , js_name = lost)]
+    #[doc = "Getter for the `lost` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/lost)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn lost(this: &GpuDevice) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUDevice" , js_name = onuncapturederror)]
+    #[doc = "Getter for the `onuncapturederror` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/onuncapturederror)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn onuncapturederror(this: &GpuDevice) -> Option<::js_sys::Function>;
+
+    # [wasm_bindgen (structural , method , setter , js_class = "GPUDevice" , js_name = onuncapturederror)]
+    #[doc = "Setter for the `onuncapturederror` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/onuncapturederror)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_onuncapturederror(this: &GpuDevice, value: Option<&::js_sys::Function>);
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUDevice" , js_name = label)]
+    #[doc = "Getter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn label(this: &GpuDevice) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , setter , js_class = "GPUDevice" , js_name = label)]
+    #[doc = "Setter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_label(this: &GpuDevice, value: &str);
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = createBindGroup)]
+    #[doc = "The `createBindGroup()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createBindGroup)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroup`, `GpuBindGroupDescriptor`, `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_bind_group(this: &GpuDevice, descriptor: &GpuBindGroupDescriptor)
+        -> GpuBindGroup;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUDevice" , js_name = createBindGroupLayout)]
+    #[doc = "The `createBindGroupLayout()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createBindGroupLayout)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBindGroupLayout`, `GpuBindGroupLayoutDescriptor`, `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_bind_group_layout(
+        this: &GpuDevice,
+        descriptor: &GpuBindGroupLayoutDescriptor,
+    ) -> Result<GpuBindGroupLayout, JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUDevice" , js_name = createBuffer)]
+    #[doc = "The `createBuffer()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createBuffer)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuBuffer`, `GpuBufferDescriptor`, `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_buffer(
+        this: &GpuDevice,
+        descriptor: &GpuBufferDescriptor,
+    ) -> Result<GpuBuffer, JsValue>;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = createCommandEncoder)]
+    #[doc = "The `createCommandEncoder()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createCommandEncoder)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_command_encoder(this: &GpuDevice) -> GpuCommandEncoder;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = createCommandEncoder)]
+    #[doc = "The `createCommandEncoder()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createCommandEncoder)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuCommandEncoder`, `GpuCommandEncoderDescriptor`, `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_command_encoder_with_descriptor(
+        this: &GpuDevice,
+        descriptor: &GpuCommandEncoderDescriptor,
+    ) -> GpuCommandEncoder;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = createComputePipeline)]
+    #[doc = "The `createComputePipeline()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createComputePipeline)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipeline`, `GpuComputePipelineDescriptor`, `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_compute_pipeline(
+        this: &GpuDevice,
+        descriptor: &GpuComputePipelineDescriptor,
+    ) -> GpuComputePipeline;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = createComputePipelineAsync)]
+    #[doc = "The `createComputePipelineAsync()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createComputePipelineAsync)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuComputePipelineDescriptor`, `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_compute_pipeline_async(
+        this: &GpuDevice,
+        descriptor: &GpuComputePipelineDescriptor,
+    ) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = createPipelineLayout)]
+    #[doc = "The `createPipelineLayout()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createPipelineLayout)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuPipelineLayout`, `GpuPipelineLayoutDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_pipeline_layout(
+        this: &GpuDevice,
+        descriptor: &GpuPipelineLayoutDescriptor,
+    ) -> GpuPipelineLayout;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUDevice" , js_name = createQuerySet)]
+    #[doc = "The `createQuerySet()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createQuerySet)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuQuerySet`, `GpuQuerySetDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_query_set(
+        this: &GpuDevice,
+        descriptor: &GpuQuerySetDescriptor,
+    ) -> Result<GpuQuerySet, JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUDevice" , js_name = createRenderBundleEncoder)]
+    #[doc = "The `createRenderBundleEncoder()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createRenderBundleEncoder)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuRenderBundleEncoder`, `GpuRenderBundleEncoderDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_render_bundle_encoder(
+        this: &GpuDevice,
+        descriptor: &GpuRenderBundleEncoderDescriptor,
+    ) -> Result<GpuRenderBundleEncoder, JsValue>;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUDevice" , js_name = createRenderPipeline)]
+    #[doc = "The `createRenderPipeline()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createRenderPipeline)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuRenderPipeline`, `GpuRenderPipelineDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_render_pipeline(
+        this: &GpuDevice,
+        descriptor: &GpuRenderPipelineDescriptor,
+    ) -> Result<GpuRenderPipeline, JsValue>;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = createRenderPipelineAsync)]
+    #[doc = "The `createRenderPipelineAsync()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createRenderPipelineAsync)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuRenderPipelineDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_render_pipeline_async(
+        this: &GpuDevice,
+        descriptor: &GpuRenderPipelineDescriptor,
+    ) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = createSampler)]
+    #[doc = "The `createSampler()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createSampler)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuSampler`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_sampler(this: &GpuDevice) -> GpuSampler;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = createSampler)]
+    #[doc = "The `createSampler()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createSampler)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuSampler`, `GpuSamplerDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_sampler_with_descriptor(
+        this: &GpuDevice,
+        descriptor: &GpuSamplerDescriptor,
+    ) -> GpuSampler;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = createShaderModule)]
+    #[doc = "The `createShaderModule()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createShaderModule)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuShaderModule`, `GpuShaderModuleDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_shader_module(
+        this: &GpuDevice,
+        descriptor: &GpuShaderModuleDescriptor,
+    ) -> GpuShaderModule;
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUDevice" , js_name = createTexture)]
+    #[doc = "The `createTexture()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/createTexture)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuTexture`, `GpuTextureDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn create_texture(
+        this: &GpuDevice,
+        descriptor: &GpuTextureDescriptor,
+    ) -> Result<GpuTexture, JsValue>;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = destroy)]
+    #[doc = "The `destroy()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/destroy)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn destroy(this: &GpuDevice);
+
+    # [wasm_bindgen (catch , method , structural , js_class = "GPUDevice" , js_name = importExternalTexture)]
+    #[doc = "The `importExternalTexture()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/importExternalTexture)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuExternalTexture`, `GpuExternalTextureDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn import_external_texture(
+        this: &GpuDevice,
+        descriptor: &GpuExternalTextureDescriptor,
+    ) -> Result<GpuExternalTexture, JsValue>;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = popErrorScope)]
+    #[doc = "The `popErrorScope()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/popErrorScope)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn pop_error_scope(this: &GpuDevice) -> ::js_sys::Promise;
+
+    # [wasm_bindgen (method , structural , js_class = "GPUDevice" , js_name = pushErrorScope)]
+    #[doc = "The `pushErrorScope()` method."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDevice/pushErrorScope)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDevice`, `GpuErrorFilter`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn push_error_scope(this: &GpuDevice, filter: GpuErrorFilter);
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuDeviceDescriptor.rs

@@ -0,0 +1,154 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUDeviceDescriptor)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuDeviceDescriptor` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuDeviceDescriptor;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuDeviceDescriptor) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuDeviceDescriptor, val: &str);
+
+    #[doc = "Get the `defaultQueue` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceDescriptor`, `GpuQueueDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "defaultQueue")]
+    pub fn get_default_queue(this: &GpuDeviceDescriptor) -> Option<GpuQueueDescriptor>;
+
+    #[doc = "Change the `defaultQueue` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceDescriptor`, `GpuQueueDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "defaultQueue")]
+    pub fn set_default_queue(this: &GpuDeviceDescriptor, val: &GpuQueueDescriptor);
+
+    #[doc = "Get the `requiredFeatures` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "requiredFeatures")]
+    pub fn get_required_features(this: &GpuDeviceDescriptor) -> Option<::js_sys::Array>;
+
+    #[doc = "Change the `requiredFeatures` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "requiredFeatures")]
+    pub fn set_required_features(this: &GpuDeviceDescriptor, val: &::wasm_bindgen::JsValue);
+
+    #[doc = "Get the `requiredLimits` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "requiredLimits")]
+    pub fn get_required_limits(this: &GpuDeviceDescriptor) -> Option<::js_sys::Object>;
+
+    #[doc = "Change the `requiredLimits` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "requiredLimits")]
+    pub fn set_required_limits(this: &GpuDeviceDescriptor, val: &::js_sys::Object);
+}
+
+impl GpuDeviceDescriptor {
+    #[doc = "Construct a new `GpuDeviceDescriptor`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+
+    #[deprecated = "Use `set_default_queue()` instead."]
+    pub fn default_queue(&mut self, val: &GpuQueueDescriptor) -> &mut Self {
+        self.set_default_queue(val);
+        self
+    }
+
+    #[deprecated = "Use `set_required_features()` instead."]
+    pub fn required_features(&mut self, val: &::wasm_bindgen::JsValue) -> &mut Self {
+        self.set_required_features(val);
+        self
+    }
+
+    #[deprecated = "Use `set_required_limits()` instead."]
+    pub fn required_limits(&mut self, val: &::js_sys::Object) -> &mut Self {
+        self.set_required_limits(val);
+        self
+    }
+}
+
+impl Default for GpuDeviceDescriptor {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuDeviceLostInfo.rs

@@ -0,0 +1,62 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUDeviceLostInfo , typescript_type = "GPUDeviceLostInfo")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuDeviceLostInfo` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDeviceLostInfo)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceLostInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuDeviceLostInfo;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUDeviceLostInfo" , js_name = reason)]
+    #[doc = "Getter for the `reason` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDeviceLostInfo/reason)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceLostInfo`, `GpuDeviceLostReason`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn reason(this: &GpuDeviceLostInfo) -> GpuDeviceLostReason;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUDeviceLostInfo" , js_name = message)]
+    #[doc = "Getter for the `message` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUDeviceLostInfo/message)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuDeviceLostInfo`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn message(this: &GpuDeviceLostInfo) -> ::alloc::string::String;
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuDeviceLostReason.rs

@@ -0,0 +1,37 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuDeviceLostReason` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuDeviceLostReason`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuDeviceLostReason {
+    Unknown = "unknown",
+    Destroyed = "destroyed",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuError.rs

@@ -0,0 +1,51 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUError , typescript_type = "GPUError")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuError` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUError)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuError`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuError;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUError" , js_name = message)]
+    #[doc = "Getter for the `message` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUError/message)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuError`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn message(this: &GpuError) -> ::alloc::string::String;
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuErrorFilter.rs

@@ -0,0 +1,38 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuErrorFilter` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuErrorFilter`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuErrorFilter {
+    Validation = "validation",
+    OutOfMemory = "out-of-memory",
+    Internal = "internal",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuExtent3dDict.rs

@@ -0,0 +1,125 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUExtent3DDict)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuExtent3dDict` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExtent3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuExtent3dDict;
+
+    #[doc = "Get the `depthOrArrayLayers` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExtent3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "depthOrArrayLayers")]
+    pub fn get_depth_or_array_layers(this: &GpuExtent3dDict) -> Option<u32>;
+
+    #[doc = "Change the `depthOrArrayLayers` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExtent3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "depthOrArrayLayers")]
+    pub fn set_depth_or_array_layers(this: &GpuExtent3dDict, val: u32);
+
+    #[doc = "Get the `height` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExtent3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "height")]
+    pub fn get_height(this: &GpuExtent3dDict) -> Option<u32>;
+
+    #[doc = "Change the `height` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExtent3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "height")]
+    pub fn set_height(this: &GpuExtent3dDict, val: u32);
+
+    #[doc = "Get the `width` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExtent3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "width")]
+    pub fn get_width(this: &GpuExtent3dDict) -> u32;
+
+    #[doc = "Change the `width` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExtent3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "width")]
+    pub fn set_width(this: &GpuExtent3dDict, val: u32);
+}
+
+impl GpuExtent3dDict {
+    #[doc = "Construct a new `GpuExtent3dDict`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExtent3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(width: u32) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_width(width);
+        ret
+    }
+
+    #[deprecated = "Use `set_depth_or_array_layers()` instead."]
+    pub fn depth_or_array_layers(&mut self, val: u32) -> &mut Self {
+        self.set_depth_or_array_layers(val);
+        self
+    }
+
+    #[deprecated = "Use `set_height()` instead."]
+    pub fn height(&mut self, val: u32) -> &mut Self {
+        self.set_height(val);
+        self
+    }
+
+    #[deprecated = "Use `set_width()` instead."]
+    pub fn width(&mut self, val: u32) -> &mut Self {
+        self.set_width(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuExternalTexture.rs

@@ -0,0 +1,62 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUExternalTexture , typescript_type = "GPUExternalTexture")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuExternalTexture` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUExternalTexture)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTexture`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuExternalTexture;
+
+    # [wasm_bindgen (structural , method , getter , js_class = "GPUExternalTexture" , js_name = label)]
+    #[doc = "Getter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUExternalTexture/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTexture`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn label(this: &GpuExternalTexture) -> ::alloc::string::String;
+
+    # [wasm_bindgen (structural , method , setter , js_class = "GPUExternalTexture" , js_name = label)]
+    #[doc = "Setter for the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUExternalTexture/label)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTexture`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn set_label(this: &GpuExternalTexture, value: &str);
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuExternalTextureBindingLayout.rs

@@ -0,0 +1,58 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUExternalTextureBindingLayout)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuExternalTextureBindingLayout` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTextureBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuExternalTextureBindingLayout;
+}
+
+impl GpuExternalTextureBindingLayout {
+    #[doc = "Construct a new `GpuExternalTextureBindingLayout`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTextureBindingLayout`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+}
+
+impl Default for GpuExternalTextureBindingLayout {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuExternalTextureDescriptor.rs

@@ -0,0 +1,101 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUExternalTextureDescriptor)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuExternalTextureDescriptor` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTextureDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuExternalTextureDescriptor;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTextureDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuExternalTextureDescriptor) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTextureDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuExternalTextureDescriptor, val: &str);
+
+    #[doc = "Get the `source` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTextureDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "source")]
+    pub fn get_source(this: &GpuExternalTextureDescriptor) -> ::js_sys::Object;
+
+    #[doc = "Change the `source` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTextureDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "source")]
+    pub fn set_source(this: &GpuExternalTextureDescriptor, val: &::js_sys::Object);
+}
+
+impl GpuExternalTextureDescriptor {
+    #[doc = "Construct a new `GpuExternalTextureDescriptor`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuExternalTextureDescriptor`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(source: &::js_sys::Object) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_source(source);
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+
+    #[deprecated = "Use `set_source()` instead."]
+    pub fn source(&mut self, val: &::js_sys::Object) -> &mut Self {
+        self.set_source(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuFeatureName.rs

@@ -0,0 +1,51 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuFeatureName` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuFeatureName`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuFeatureName {
+    DepthClipControl = "depth-clip-control",
+    Depth32floatStencil8 = "depth32float-stencil8",
+    TextureCompressionBc = "texture-compression-bc",
+    TextureCompressionBcSliced3d = "texture-compression-bc-sliced-3d",
+    TextureCompressionEtc2 = "texture-compression-etc2",
+    TextureCompressionAstc = "texture-compression-astc",
+    TextureCompressionAstcSliced3d = "texture-compression-astc-sliced-3d",
+    TimestampQuery = "timestamp-query",
+    IndirectFirstInstance = "indirect-first-instance",
+    ShaderF16 = "shader-f16",
+    Rg11b10ufloatRenderable = "rg11b10ufloat-renderable",
+    Bgra8unormStorage = "bgra8unorm-storage",
+    Float32Filterable = "float32-filterable",
+    Float32Blendable = "float32-blendable",
+    ClipDistances = "clip-distances",
+    DualSourceBlending = "dual-source-blending",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuFilterMode.rs

@@ -0,0 +1,37 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuFilterMode` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuFilterMode`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuFilterMode {
+    Nearest = "nearest",
+    Linear = "linear",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuFragmentState.rs

@@ -0,0 +1,150 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUFragmentState)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuFragmentState` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuFragmentState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuFragmentState;
+
+    #[doc = "Get the `constants` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuFragmentState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "constants")]
+    pub fn get_constants(this: &GpuFragmentState) -> Option<::js_sys::Object>;
+
+    #[doc = "Change the `constants` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuFragmentState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "constants")]
+    pub fn set_constants(this: &GpuFragmentState, val: &::js_sys::Object);
+
+    #[doc = "Get the `entryPoint` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuFragmentState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "entryPoint")]
+    pub fn get_entry_point(this: &GpuFragmentState) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `entryPoint` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuFragmentState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "entryPoint")]
+    pub fn set_entry_point(this: &GpuFragmentState, val: &str);
+
+    #[doc = "Get the `module` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuFragmentState`, `GpuShaderModule`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "module")]
+    pub fn get_module(this: &GpuFragmentState) -> GpuShaderModule;
+
+    #[doc = "Change the `module` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuFragmentState`, `GpuShaderModule`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "module")]
+    pub fn set_module(this: &GpuFragmentState, val: &GpuShaderModule);
+
+    #[doc = "Get the `targets` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuFragmentState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "targets")]
+    pub fn get_targets(this: &GpuFragmentState) -> ::js_sys::Array;
+
+    #[doc = "Change the `targets` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuFragmentState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "targets")]
+    pub fn set_targets(this: &GpuFragmentState, val: &::wasm_bindgen::JsValue);
+}
+
+impl GpuFragmentState {
+    #[doc = "Construct a new `GpuFragmentState`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuFragmentState`, `GpuShaderModule`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(module: &GpuShaderModule, targets: &::wasm_bindgen::JsValue) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_module(module);
+        ret.set_targets(targets);
+        ret
+    }
+
+    #[deprecated = "Use `set_constants()` instead."]
+    pub fn constants(&mut self, val: &::js_sys::Object) -> &mut Self {
+        self.set_constants(val);
+        self
+    }
+
+    #[deprecated = "Use `set_entry_point()` instead."]
+    pub fn entry_point(&mut self, val: &str) -> &mut Self {
+        self.set_entry_point(val);
+        self
+    }
+
+    #[deprecated = "Use `set_module()` instead."]
+    pub fn module(&mut self, val: &GpuShaderModule) -> &mut Self {
+        self.set_module(val);
+        self
+    }
+
+    #[deprecated = "Use `set_targets()` instead."]
+    pub fn targets(&mut self, val: &::wasm_bindgen::JsValue) -> &mut Self {
+        self.set_targets(val);
+        self
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuFrontFace.rs

@@ -0,0 +1,37 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuFrontFace` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuFrontFace`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuFrontFace {
+    Ccw = "ccw",
+    Cw = "cw",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuIndexFormat.rs

@@ -0,0 +1,37 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuIndexFormat` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuIndexFormat`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuIndexFormat {
+    Uint16 = "uint16",
+    Uint32 = "uint32",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuLoadOp.rs

@@ -0,0 +1,37 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuLoadOp` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuLoadOp`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuLoadOp {
+    Load = "load",
+    Clear = "clear",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuMipmapFilterMode.rs

@@ -0,0 +1,37 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[doc = "The `GpuMipmapFilterMode` enum."]
+#[doc = ""]
+#[doc = "*This API requires the following crate features to be activated: `GpuMipmapFilterMode`*"]
+#[doc = ""]
+#[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+#[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GpuMipmapFilterMode {
+    Nearest = "nearest",
+    Linear = "linear",
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuMultisampleState.rs

@@ -0,0 +1,130 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUMultisampleState)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuMultisampleState` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuMultisampleState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuMultisampleState;
+
+    #[doc = "Get the `alphaToCoverageEnabled` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuMultisampleState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "alphaToCoverageEnabled")]
+    pub fn get_alpha_to_coverage_enabled(this: &GpuMultisampleState) -> Option<bool>;
+
+    #[doc = "Change the `alphaToCoverageEnabled` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuMultisampleState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "alphaToCoverageEnabled")]
+    pub fn set_alpha_to_coverage_enabled(this: &GpuMultisampleState, val: bool);
+
+    #[doc = "Get the `count` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuMultisampleState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "count")]
+    pub fn get_count(this: &GpuMultisampleState) -> Option<u32>;
+
+    #[doc = "Change the `count` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuMultisampleState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "count")]
+    pub fn set_count(this: &GpuMultisampleState, val: u32);
+
+    #[doc = "Get the `mask` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuMultisampleState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "mask")]
+    pub fn get_mask(this: &GpuMultisampleState) -> Option<u32>;
+
+    #[doc = "Change the `mask` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuMultisampleState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "mask")]
+    pub fn set_mask(this: &GpuMultisampleState, val: u32);
+}
+
+impl GpuMultisampleState {
+    #[doc = "Construct a new `GpuMultisampleState`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuMultisampleState`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_alpha_to_coverage_enabled()` instead."]
+    pub fn alpha_to_coverage_enabled(&mut self, val: bool) -> &mut Self {
+        self.set_alpha_to_coverage_enabled(val);
+        self
+    }
+
+    #[deprecated = "Use `set_count()` instead."]
+    pub fn count(&mut self, val: u32) -> &mut Self {
+        self.set_count(val);
+        self
+    }
+
+    #[deprecated = "Use `set_mask()` instead."]
+    pub fn mask(&mut self, val: u32) -> &mut Self {
+        self.set_mask(val);
+        self
+    }
+}
+
+impl Default for GpuMultisampleState {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuObjectDescriptorBase.rs

@@ -0,0 +1,82 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUObjectDescriptorBase)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuObjectDescriptorBase` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuObjectDescriptorBase`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuObjectDescriptorBase;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuObjectDescriptorBase`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuObjectDescriptorBase) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuObjectDescriptorBase`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuObjectDescriptorBase, val: &str);
+}
+
+impl GpuObjectDescriptorBase {
+    #[doc = "Construct a new `GpuObjectDescriptorBase`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuObjectDescriptorBase`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+}
+
+impl Default for GpuObjectDescriptorBase {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuOrigin2dDict.rs

@@ -0,0 +1,106 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUOrigin2DDict)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuOrigin2dDict` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin2dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuOrigin2dDict;
+
+    #[doc = "Get the `x` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin2dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "x")]
+    pub fn get_x(this: &GpuOrigin2dDict) -> Option<u32>;
+
+    #[doc = "Change the `x` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin2dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "x")]
+    pub fn set_x(this: &GpuOrigin2dDict, val: u32);
+
+    #[doc = "Get the `y` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin2dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "y")]
+    pub fn get_y(this: &GpuOrigin2dDict) -> Option<u32>;
+
+    #[doc = "Change the `y` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin2dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "y")]
+    pub fn set_y(this: &GpuOrigin2dDict, val: u32);
+}
+
+impl GpuOrigin2dDict {
+    #[doc = "Construct a new `GpuOrigin2dDict`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin2dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_x()` instead."]
+    pub fn x(&mut self, val: u32) -> &mut Self {
+        self.set_x(val);
+        self
+    }
+
+    #[deprecated = "Use `set_y()` instead."]
+    pub fn y(&mut self, val: u32) -> &mut Self {
+        self.set_y(val);
+        self
+    }
+}
+
+impl Default for GpuOrigin2dDict {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuOrigin3dDict.rs

@@ -0,0 +1,130 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUOrigin3DDict)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuOrigin3dDict` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuOrigin3dDict;
+
+    #[doc = "Get the `x` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "x")]
+    pub fn get_x(this: &GpuOrigin3dDict) -> Option<u32>;
+
+    #[doc = "Change the `x` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "x")]
+    pub fn set_x(this: &GpuOrigin3dDict, val: u32);
+
+    #[doc = "Get the `y` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "y")]
+    pub fn get_y(this: &GpuOrigin3dDict) -> Option<u32>;
+
+    #[doc = "Change the `y` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "y")]
+    pub fn set_y(this: &GpuOrigin3dDict, val: u32);
+
+    #[doc = "Get the `z` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "z")]
+    pub fn get_z(this: &GpuOrigin3dDict) -> Option<u32>;
+
+    #[doc = "Change the `z` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "z")]
+    pub fn set_z(this: &GpuOrigin3dDict, val: u32);
+}
+
+impl GpuOrigin3dDict {
+    #[doc = "Construct a new `GpuOrigin3dDict`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOrigin3dDict`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new() -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret
+    }
+
+    #[deprecated = "Use `set_x()` instead."]
+    pub fn x(&mut self, val: u32) -> &mut Self {
+        self.set_x(val);
+        self
+    }
+
+    #[deprecated = "Use `set_y()` instead."]
+    pub fn y(&mut self, val: u32) -> &mut Self {
+        self.set_y(val);
+        self
+    }
+
+    #[deprecated = "Use `set_z()` instead."]
+    pub fn z(&mut self, val: u32) -> &mut Self {
+        self.set_z(val);
+        self
+    }
+}
+
+impl Default for GpuOrigin3dDict {
+    fn default() -> Self {
+        Self::new()
+    }
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuOutOfMemoryError.rs

@@ -0,0 +1,51 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = GpuError , extends = :: js_sys :: Object , js_name = GPUOutOfMemoryError , typescript_type = "GPUOutOfMemoryError")]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuOutOfMemoryError` class."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUOutOfMemoryError)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOutOfMemoryError`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuOutOfMemoryError;
+
+    #[wasm_bindgen(catch, constructor, js_class = "GPUOutOfMemoryError")]
+    #[doc = "The `new GpuOutOfMemoryError(..)` constructor, creating a new instance of `GpuOutOfMemoryError`."]
+    #[doc = ""]
+    #[doc = "[MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/API/GPUOutOfMemoryError/GPUOutOfMemoryError)"]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuOutOfMemoryError`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(message: &str) -> Result<GpuOutOfMemoryError, JsValue>;
+}

vendor/wgpu/src/backend/webgpu/webgpu_sys/gen_GpuPipelineDescriptorBase.rs

@@ -0,0 +1,101 @@
+// DO NOT EDIT THIS FILE!
+//
+// This module part of a subset of web-sys that is used by wgpu's webgpu backend.
+//
+// These bindings are vendored into wgpu for the sole purpose of letting
+// us pin the WebGPU backend to a specific version of the bindings, not
+// to enable local changes. There are no provisions to preserve changes
+// you make here the next time we re-vendor the bindings.
+//
+// The `web-sys` crate does not treat breaking changes to the WebGPU API
+// as semver breaking changes, as WebGPU is "unstable". This means Cargo
+// will not let us mix versions of `web-sys`, pinning WebGPU bindings to
+// a specific version, while letting other bindings like WebGL get
+// updated. Vendoring WebGPU was the workaround we chose.
+//
+// Vendoring also allows us to avoid building `web-sys` with
+// `--cfg=web_sys_unstable_apis`, needed to get the WebGPU bindings.
+//
+// If you want to improve the generated code, please submit a PR to the https://github.com/rustwasm/wasm-bindgen repository.
+//
+// This file was generated by the `cargo xtask vendor-web-sys --version 0.2.97` command.
+#![allow(unused_imports)]
+#![allow(clippy::all)]
+use super::*;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    # [wasm_bindgen (extends = :: js_sys :: Object , js_name = GPUPipelineDescriptorBase)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[doc = "The `GpuPipelineDescriptorBase` dictionary."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuPipelineDescriptorBase`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub type GpuPipelineDescriptorBase;
+
+    #[doc = "Get the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuPipelineDescriptorBase`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "label")]
+    pub fn get_label(this: &GpuPipelineDescriptorBase) -> Option<::alloc::string::String>;
+
+    #[doc = "Change the `label` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuPipelineDescriptorBase`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "label")]
+    pub fn set_label(this: &GpuPipelineDescriptorBase, val: &str);
+
+    #[doc = "Get the `layout` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuPipelineDescriptorBase`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, getter = "layout")]
+    pub fn get_layout(this: &GpuPipelineDescriptorBase) -> ::wasm_bindgen::JsValue;
+
+    #[doc = "Change the `layout` field of this object."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuPipelineDescriptorBase`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    #[wasm_bindgen(method, setter = "layout")]
+    pub fn set_layout(this: &GpuPipelineDescriptorBase, val: &::wasm_bindgen::JsValue);
+}
+
+impl GpuPipelineDescriptorBase {
+    #[doc = "Construct a new `GpuPipelineDescriptorBase`."]
+    #[doc = ""]
+    #[doc = "*This API requires the following crate features to be activated: `GpuPipelineDescriptorBase`*"]
+    #[doc = ""]
+    #[doc = "*This API is unstable and requires `--cfg=web_sys_unstable_apis` to be activated, as"]
+    #[doc = "[described in the `wasm-bindgen` guide](https://rustwasm.github.io/docs/wasm-bindgen/web-sys/unstable-apis.html)*"]
+    pub fn new(layout: &::wasm_bindgen::JsValue) -> Self {
+        #[allow(unused_mut)]
+        let mut ret: Self = ::wasm_bindgen::JsCast::unchecked_into(::js_sys::Object::new());
+        ret.set_layout(layout);
+        ret
+    }
+
+    #[deprecated = "Use `set_label()` instead."]
+    pub fn label(&mut self, val: &str) -> &mut Self {
+        self.set_label(val);
+        self
+    }
+
+    #[deprecated = "Use `set_layout()` instead."]
+    pub fn layout(&mut self, val: &::wasm_bindgen::JsValue) -> &mut Self {
+        self.set_layout(val);
+        self
+    }
+}