Switch WgpuWrapper to a macro and have it compute Send/Sync eagerly

_release-content/migration-guides/wgpu_wrapper.md

@@ -0,0 +1,8 @@
+---
+title: WgpuWrapper has been removed
+pull_requests: [25512]
+---
+
+`WgpuWrapper` has been removed, and its uses have been replaced with either new types (e.g. `WgpuErrorSource`) or removed from the public API (e.g. `RenderQueue`).
+
+For `RenderQueue`, `RenderAdapter`, `RenderInstance` and `RenderAdapterInfo` in particular their only field holding a `WgpuWrapper` is no longer public. However they still `Deref`/`DerefMut` to their `wgpu` type, and if you were constructing/deconstructing them directly you can instead call `new` and `into_inner` to do so.

crates/bevy_pbr/src/light_probe/mod.rs

@@ -22,7 +22,7 @@ use bevy_platform::collections::HashMap;
 use bevy_render::{
     render_asset::RenderAssets,
     render_resource::{DynamicUniformBuffer, Sampler, ShaderType, TextureView},
-    renderer::{RenderAdapter, RenderAdapterInfo, RenderDevice, RenderQueue, WgpuWrapper},
+    renderer::{RenderAdapter, RenderAdapterInfo, RenderDevice, RenderQueue},
     settings::WgpuFeatures,
     sync_world::{MainEntity, MainEntityHashMap, RenderEntity},
     texture::{FallbackImage, GpuImage},
@@ -776,7 +776,7 @@ pub(crate) fn binding_arrays_are_usable(
     render_device: &RenderDevice,
     render_adapter: &RenderAdapter,
 ) -> bool {
-    let adapter_info = RenderAdapterInfo(WgpuWrapper::new(render_adapter.get_info()));
+    let adapter_info = RenderAdapterInfo::new(render_adapter.get_info());
 
     bevy_render::get_adreno_model(&adapter_info).is_none_or(|model| model > 610)
         && render_device

crates/bevy_render/src/batching/gpu_preprocessing.rs

@@ -45,7 +45,7 @@ use crate::{
         PartialBufferVec, PipelineCache, RawBufferVec, SparseBufferUpdateBindGroups,
         SparseBufferUpdateJobs, SparseBufferUpdatePipelines, UninitBufferVec,
     },
-    renderer::{RenderAdapter, RenderAdapterInfo, RenderDevice, RenderQueue, WgpuWrapper},
+    renderer::{RenderAdapter, RenderAdapterInfo, RenderDevice, RenderQueue},
     sync_world::{MainEntity, MainEntityHashMap},
     view::{ExtractedView, NoIndirectDrawing, RetainedViewEntity},
     GpuResourceAppExt, Render, RenderApp, RenderDebugFlags, RenderSystems,
@@ -1578,7 +1578,7 @@ impl FromWorld for GpuPreprocessingSupport {
             .flags
             .contains(DownlevelFlags::COMPUTE_SHADERS);
 
-        let adapter_info = RenderAdapterInfo(WgpuWrapper::new(adapter.get_info()));
+        let adapter_info = RenderAdapterInfo::new(adapter.get_info());
 
         let max_supported_mode = if device.limits().max_compute_workgroup_size_x == 0
             || is_non_supported_android_device(&adapter_info)

crates/bevy_render/src/diagnostic/internal.rs

@@ -16,7 +16,7 @@ use wgpu::{
     RenderPass,
 };
 
-use crate::renderer::{RenderAdapterInfo, RenderDevice, RenderQueue, WgpuWrapper};
+use crate::renderer::{wgpu_wrapper, RenderAdapterInfo, RenderDevice, RenderQueue};
 
 use super::RecordDiagnostics;
 
@@ -37,10 +37,12 @@ struct DiagnosticsRecorderInternal {
     tracy_gpu_context: Option<tracy_client::GpuContext>,
 }
 
+wgpu_wrapper!(struct WgpuDiagnosticsRecorderInternal(DiagnosticsRecorderInternal));
+
 /// Records diagnostics into [`QuerySet`]'s keeping track of the mapping between
 /// spans and indices to the corresponding entries in the [`QuerySet`].
 #[derive(Resource)]
-pub struct DiagnosticsRecorder(WgpuWrapper<DiagnosticsRecorderInternal>);
+pub struct DiagnosticsRecorder(WgpuDiagnosticsRecorderInternal);
 
 impl DiagnosticsRecorder {
     /// Creates the new `DiagnosticsRecorder`.
@@ -56,20 +58,22 @@ impl DiagnosticsRecorder {
             super::tracy_gpu::new_tracy_gpu_context(adapter_info, device, queue);
         let _ = adapter_info; // Prevent unused variable warnings when tracing-tracy is not enabled
 
-        DiagnosticsRecorder(WgpuWrapper::new(DiagnosticsRecorderInternal {
-            timestamp_period_ns: queue.get_timestamp_period(),
-            features,
-            current_frame: Mutex::new(FrameData::new(
-                device,
+        DiagnosticsRecorder(WgpuDiagnosticsRecorderInternal::new(
+            DiagnosticsRecorderInternal {
+                timestamp_period_ns: queue.get_timestamp_period(),
                 features,
+                current_frame: Mutex::new(FrameData::new(
+                    device,
+                    features,
+                    #[cfg(feature = "tracing-tracy")]
+                    tracy_gpu_context.clone(),
+                )),
+                submitted_frames: Vec::new(),
+                finished_frames: Vec::new(),
                 #[cfg(feature = "tracing-tracy")]
-                tracy_gpu_context.clone(),
-            )),
-            submitted_frames: Vec::new(),
-            finished_frames: Vec::new(),
-            #[cfg(feature = "tracing-tracy")]
-            tracy_gpu_context,
-        }))
+                tracy_gpu_context,
+            },
+        ))
     }
 
     fn current_frame_mut(&mut self) -> &mut FrameData {

crates/bevy_render/src/error_handler.rs

@@ -11,7 +11,7 @@ pub use wgpu_types::error::ErrorType;
 use crate::{
     insert_future_resources,
     render_resource::PipelineCache,
-    renderer::{RenderDevice, WgpuWrapper},
+    renderer::{wgpu_wrapper, RenderDevice},
     settings::RenderCreation,
     FutureRenderResources, RenderStartup,
 };
@@ -83,13 +83,18 @@ impl Default for RenderErrorHandler {
     }
 }
 
+wgpu_wrapper! {
+    #[derive(Debug)]
+    pub struct WgpuErrorSource(ErrorSource);
+}
+
 /// An error encountered during rendering. These are errors reported by wgpu validation layers,
 /// and typically indicate problems in the way it is being used.
 #[derive(Debug)]
 pub struct RenderError {
     pub ty: ErrorType,
     pub description: String,
-    pub source: Option<WgpuWrapper<ErrorSource>>,
+    pub source: Option<WgpuErrorSource>,
 }
 
 /// The current state of the renderer.
@@ -105,11 +110,13 @@ pub(crate) enum RenderState {
     Reinitializing,
 }
 
+wgpu_wrapper!(struct WgpuError(wgpu::Error));
+
 /// Resource to allow polling wgpu error handlers.
 #[derive(Resource)]
 pub(crate) struct DeviceErrorHandler {
     device_lost: Arc<Mutex<Option<(wgpu::DeviceLostReason, String)>>>,
-    uncaptured: Arc<Mutex<Option<WgpuWrapper<wgpu::Error>>>>,
+    uncaptured: Arc<Mutex<Option<WgpuError>>>,
 }
 
 impl DeviceErrorHandler {
@@ -130,10 +137,7 @@ impl DeviceErrorHandler {
             });
             device.on_uncaptured_error(Arc::new(move |e| {
                 bevy_log::error!("Caught rendering error: {e}");
-                uncaptured
-                    .lock()
-                    .unwrap()
-                    .get_or_insert(WgpuWrapper::new(e));
+                uncaptured.lock().unwrap().get_or_insert(WgpuError::new(e));
             }));
         }
         Self {
@@ -169,7 +173,7 @@ impl DeviceErrorHandler {
             return Some(RenderError {
                 ty,
                 description,
-                source: Some(WgpuWrapper::new(source)),
+                source: Some(WgpuErrorSource::new(source)),
             });
         }
         None

crates/bevy_render/src/render_resource/bind_group.rs

@@ -2,7 +2,7 @@ use crate::{
     material_bind_groups::FallbackBuffer,
     render_asset::RenderAssets,
     render_resource::{BindGroupLayout, Buffer, PipelineCache, Sampler, TextureView},
-    renderer::{RenderDevice, WgpuWrapper},
+    renderer::{wgpu_wrapper, RenderDevice},
     storage::{GpuShaderBuffer, ShaderBuffer},
     texture::GpuImage,
 };
@@ -25,6 +25,11 @@ use super::{BindlessDescriptor, BindlessSlabResourceLimit};
 
 define_atomic_id!(BindGroupId);
 
+wgpu_wrapper! {
+    #[derive(Clone, Debug)]
+    struct WgpuBindGroup(wgpu::BindGroup);
+}
+
 /// Bind groups are responsible for binding render resources (e.g. buffers, textures, samplers)
 /// to a [`TrackedRenderPass`](crate::render_phase::TrackedRenderPass).
 /// This makes them accessible in the pipeline (shaders) as uniforms.
@@ -37,7 +42,7 @@ define_atomic_id!(BindGroupId);
 #[derive(Clone, Debug)]
 pub struct BindGroup {
     id: BindGroupId,
-    value: WgpuWrapper<wgpu::BindGroup>,
+    value: WgpuBindGroup,
 }
 
 impl BindGroup {
@@ -66,7 +71,7 @@ impl From<wgpu::BindGroup> for BindGroup {
     fn from(value: wgpu::BindGroup) -> Self {
         BindGroup {
             id: BindGroupId::new(),
-            value: WgpuWrapper::new(value),
+            value: WgpuBindGroup::new(value),
         }
     }
 }

crates/bevy_render/src/render_resource/bind_group_layout.rs

@@ -1,9 +1,14 @@
-use crate::renderer::WgpuWrapper;
+use crate::renderer::wgpu_wrapper;
 use bevy_utils::define_atomic_id;
 use core::ops::Deref;
 
 define_atomic_id!(BindGroupLayoutId);
 
+wgpu_wrapper! {
+    #[derive(Clone, Debug)]
+    struct WgpuBindGroupLayout(wgpu::BindGroupLayout);
+}
+
 /// Bind group layouts define the interface of resources (e.g. buffers, textures, samplers)
 /// for a shader. The actual resource binding is done via a [`BindGroup`](super::BindGroup).
 ///
@@ -15,7 +20,7 @@ define_atomic_id!(BindGroupLayoutId);
 #[derive(Clone, Debug)]
 pub struct BindGroupLayout {
     id: BindGroupLayoutId,
-    value: WgpuWrapper<wgpu::BindGroupLayout>,
+    value: WgpuBindGroupLayout,
 }
 
 impl PartialEq for BindGroupLayout {
@@ -49,7 +54,7 @@ impl From<wgpu::BindGroupLayout> for BindGroupLayout {
     fn from(value: wgpu::BindGroupLayout) -> Self {
         BindGroupLayout {
             id: BindGroupLayoutId::new(),
-            value: WgpuWrapper::new(value),
+            value: WgpuBindGroupLayout::new(value),
         }
     }
 }

crates/bevy_render/src/render_resource/buffer.rs

@@ -1,13 +1,18 @@
-use crate::renderer::WgpuWrapper;
+use crate::renderer::wgpu_wrapper;
 use bevy_utils::define_atomic_id;
 use core::ops::{Deref, RangeBounds};
 
 define_atomic_id!(BufferId);
 
+wgpu_wrapper! {
+    #[derive(Clone, Debug)]
+    struct WgpuBuffer(wgpu::Buffer);
+}
+
 #[derive(Clone, Debug)]
 pub struct Buffer {
     id: BufferId,
-    value: WgpuWrapper<wgpu::Buffer>,
+    value: WgpuBuffer,
 }
 
 impl Buffer {
@@ -33,7 +38,7 @@ impl From<wgpu::Buffer> for Buffer {
     fn from(value: wgpu::Buffer) -> Self {
         Buffer {
             id: BufferId::new(),
-            value: WgpuWrapper::new(value),
+            value: WgpuBuffer::new(value),
         }
     }
 }

crates/bevy_render/src/render_resource/pipeline.rs

@@ -1,17 +1,22 @@
-use crate::renderer::WgpuWrapper;
+use crate::renderer::wgpu_wrapper;
 use bevy_utils::define_atomic_id;
 use core::ops::Deref;
 
 define_atomic_id!(RenderPipelineId);
 
+wgpu_wrapper! {
+    #[derive(Clone, Debug)]
+    struct WgpuRenderPipeline(wgpu::RenderPipeline);
+}
+
 /// A [`RenderPipeline`] represents a graphics pipeline and its stages (shaders), bindings and vertex buffers.
 ///
 /// May be converted from and dereferences to a wgpu [`RenderPipeline`](wgpu::RenderPipeline).
 /// Can be created via [`RenderDevice::create_render_pipeline`](crate::renderer::RenderDevice::create_render_pipeline).
 #[derive(Clone, Debug)]
 pub struct RenderPipeline {
     id: RenderPipelineId,
-    value: WgpuWrapper<wgpu::RenderPipeline>,
+    value: WgpuRenderPipeline,
 }
 
 impl RenderPipeline {
@@ -25,7 +30,7 @@ impl From<wgpu::RenderPipeline> for RenderPipeline {
     fn from(value: wgpu::RenderPipeline) -> Self {
         RenderPipeline {
             id: RenderPipelineId::new(),
-            value: WgpuWrapper::new(value),
+            value: WgpuRenderPipeline::new(value),
         }
     }
 }
@@ -41,14 +46,19 @@ impl Deref for RenderPipeline {
 
 define_atomic_id!(ComputePipelineId);
 
+wgpu_wrapper! {
+    #[derive(Clone, Debug)]
+    struct WgpuComputePipeline(wgpu::ComputePipeline);
+}
+
 /// A [`ComputePipeline`] represents a compute pipeline and its single shader stage.
 ///
 /// May be converted from and dereferences to a wgpu [`ComputePipeline`](wgpu::ComputePipeline).
 /// Can be created via [`RenderDevice::create_compute_pipeline`](crate::renderer::RenderDevice::create_compute_pipeline).
 #[derive(Clone, Debug)]
 pub struct ComputePipeline {
     id: ComputePipelineId,
-    value: WgpuWrapper<wgpu::ComputePipeline>,
+    value: WgpuComputePipeline,
 }
 
 impl ComputePipeline {
@@ -63,7 +73,7 @@ impl From<wgpu::ComputePipeline> for ComputePipeline {
     fn from(value: wgpu::ComputePipeline) -> Self {
         ComputePipeline {
             id: ComputePipelineId::new(),
-            value: WgpuWrapper::new(value),
+            value: WgpuComputePipeline::new(value),
         }
     }
 }