Deploying to master from @ gfx-rs/wgpu@03ab3a2 🚀

Author: ErichDonGubler

doc/search-index.js

@@ -956,7 +956,12 @@
 <a href="#955" id="955">955</a>
 <a href="#956" id="956">956</a>
 <a href="#957" id="957">957</a>
-<a href="#958" id="958">958</a></pre></div><pre class="rust"><code><span class="kw">use </span>alloc::{boxed::Box, sync::Arc, vec::Vec};
+<a href="#958" id="958">958</a>
+<a href="#959" id="959">959</a>
+<a href="#960" id="960">960</a>
+<a href="#961" id="961">961</a>
+<a href="#962" id="962">962</a>
+<a href="#963" id="963">963</a></pre></div><pre class="rust"><code><span class="kw">use </span>alloc::{boxed::Box, sync::Arc, vec::Vec};
 <span class="kw">use </span>core::{
     error, fmt,
     ops::{Bound, Deref, DerefMut, Range, RangeBounds},
@@ -1039,17 +1044,22 @@
 /// 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: &amp;mut [u8]) -&gt; &amp;mut [f32] { todo!() }
-/// # }
-/// # let device: wgpu::Device = todo!();
-/// # let buffer: wgpu::Buffer = todo!();
-/// let buffer = std::sync::Arc::new(buffer);
+/// ```
+/// # #[cfg(feature = "noop")]
+/// # let (device, _queue) = wgpu::Device::noop(&amp;wgpu::DeviceDescriptor::default());
+/// # #[cfg(not(feature = "noop"))]
+/// # let device: wgpu::Device = { return; };
+/// #
+/// # let buffer = device.create_buffer(&amp;wgpu::BufferDescriptor {
+/// #     label: None,
+/// #     size: 400,
+/// #     usage: wgpu::BufferUsages::MAP_WRITE,
+/// #     mapped_at_creation: false,
+/// # });
 /// let capturable = buffer.clone();
-/// buffer.slice(..).map_async(wgpu::MapMode::Write, move |result| {
+/// buffer.map_async(wgpu::MapMode::Write, .., move |result| {
 ///     if result.is_ok() {
-///         let mut view = capturable.slice(..).get_mapped_range_mut();
+///         let mut view = capturable.get_mapped_range_mut(..);
 ///         let floats: &amp;mut [f32] = bytemuck::cast_slice_mut(&amp;mut view);
 ///         floats.fill(42.0);
 ///         drop(view);
@@ -1060,11 +1070,11 @@
 ///
 /// This code takes the following steps:
 ///
-/// - First, it moves `buffer` into an [`Arc`], and makes a clone for capture by
+/// - First, it makes a cloned handle to the buffer 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
+///   data like this. In real code, there might be an [`Arc`] to some larger
 ///   structure that itself owns `buffer`.
 ///
 /// - Then, it calls [`Buffer::slice`] to make a [`BufferSlice`] referring to

doc/search.desc/wgpu/wgpu-desc-0-.js

@@ -661,7 +661,41 @@
 <a href="#660" id="660">660</a>
 <a href="#661" id="661">661</a>
 <a href="#662" id="662">662</a>
-<a href="#663" id="663">663</a></pre></div><pre class="rust"><code><span class="kw">use </span>alloc::{boxed::Box, string::String, sync::Arc};
+<a href="#663" id="663">663</a>
+<a href="#664" id="664">664</a>
+<a href="#665" id="665">665</a>
+<a href="#666" id="666">666</a>
+<a href="#667" id="667">667</a>
+<a href="#668" id="668">668</a>
+<a href="#669" id="669">669</a>
+<a href="#670" id="670">670</a>
+<a href="#671" id="671">671</a>
+<a href="#672" id="672">672</a>
+<a href="#673" id="673">673</a>
+<a href="#674" id="674">674</a>
+<a href="#675" id="675">675</a>
+<a href="#676" id="676">676</a>
+<a href="#677" id="677">677</a>
+<a href="#678" id="678">678</a>
+<a href="#679" id="679">679</a>
+<a href="#680" id="680">680</a>
+<a href="#681" id="681">681</a>
+<a href="#682" id="682">682</a>
+<a href="#683" id="683">683</a>
+<a href="#684" id="684">684</a>
+<a href="#685" id="685">685</a>
+<a href="#686" id="686">686</a>
+<a href="#687" id="687">687</a>
+<a href="#688" id="688">688</a>
+<a href="#689" id="689">689</a>
+<a href="#690" id="690">690</a>
+<a href="#691" id="691">691</a>
+<a href="#692" id="692">692</a>
+<a href="#693" id="693">693</a>
+<a href="#694" id="694">694</a>
+<a href="#695" id="695">695</a>
+<a href="#696" id="696">696</a>
+<a href="#697" id="697">697</a></pre></div><pre class="rust"><code><span class="kw">use </span>alloc::{boxed::Box, string::String, sync::Arc};
 <span class="kw">use </span>core::{error, fmt, future::Future};
 
 <span class="kw">use </span>parking_lot::Mutex;
@@ -705,6 +739,40 @@
         }
     }
 
+    <span class="doccomment">/// Constructs a stub device for testing using [`Backend::Noop`].
+    ///
+    /// This is a convenience function which avoids the configuration, `async`, and fallibility
+    /// aspects of constructing a device through `Instance`.
+    </span><span class="attr">#[cfg(feature = <span class="string">"noop"</span>)]
+    </span><span class="kw">pub fn </span>noop(desc: <span class="kw-2">&amp;</span>DeviceDescriptor&lt;<span class="lifetime">'_</span>&gt;) -&gt; (Device, Queue) {
+        <span class="kw">use </span>core::future::Future <span class="kw">as _</span>;
+        <span class="kw">use </span>core::pin::pin;
+        <span class="kw">use </span>core::task;
+        <span class="kw">let </span>ctx = <span class="kw-2">&amp;mut </span>task::Context::from_waker(task::Waker::noop());
+
+        <span class="kw">let </span>instance = Instance::new(<span class="kw-2">&amp;</span>InstanceDescriptor {
+            backends: Backends::NOOP,
+            backend_options: BackendOptions {
+                noop: NoopBackendOptions { enable: <span class="bool-val">true </span>},
+                ..Default::default()
+            },
+            ..Default::default()
+        });
+
+        <span class="comment">// Both of these futures are trivial and should complete instantaneously,
+        // so we do not need an executor and can just poll them once.
+        </span><span class="kw">let </span>task::Poll::Ready(<span class="prelude-val">Ok</span>(adapter)) =
+            <span class="macro">pin!</span>(instance.request_adapter(<span class="kw-2">&amp;</span>RequestAdapterOptions::default())).poll(ctx)
+        <span class="kw">else </span>{
+            <span class="macro">unreachable!</span>()
+        };
+        <span class="kw">let </span>task::Poll::Ready(<span class="prelude-val">Ok</span>(device_and_queue)) = <span class="macro">pin!</span>(adapter.request_device(desc)).poll(ctx)
+        <span class="kw">else </span>{
+            <span class="macro">unreachable!</span>()
+        };
+        device_and_queue
+    }
+
     <span class="doccomment">/// Check for resource cleanups and mapping callbacks. Will block if [`PollType::Wait`] is passed.
     ///
     /// Return `true` if the queue is empty, or `false` if there are more queue