[Merged by Bors] - improve compile time by type-erasing wgpu structs

crates/bevy_render/src/render_resource/bind_group.rs

@@ -9,9 +9,12 @@ use crate::{
     texture::FallbackImage,
 };
 use bevy_reflect::Uuid;
-use std::{ops::Deref, sync::Arc};
+use std::ops::Deref;
 use wgpu::BindingResource;
 
+use crate::render_resource::resource_macros::*;
+render_resource_wrapper!(ErasedBindGroup, wgpu::BindGroup);
+
 /// A [`BindGroup`] identifier.
 #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct BindGroupId(Uuid);
@@ -25,7 +28,7 @@ pub struct BindGroupId(Uuid);
 #[derive(Clone, Debug)]
 pub struct BindGroup {
     id: BindGroupId,
-    value: Arc<wgpu::BindGroup>,
+    value: ErasedBindGroup,
 }
 
 impl BindGroup {
@@ -40,7 +43,7 @@ impl From<wgpu::BindGroup> for BindGroup {
     fn from(value: wgpu::BindGroup) -> Self {
         BindGroup {
             id: BindGroupId(Uuid::new_v4()),
-            value: Arc::new(value),
+            value: ErasedBindGroup::new(value),
         }
     }
 }

crates/bevy_render/src/render_resource/bind_group_layout.rs

@@ -1,13 +1,16 @@
+use crate::render_resource::resource_macros::*;
 use bevy_reflect::Uuid;
-use std::{ops::Deref, sync::Arc};
+use std::ops::Deref;
 
 #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct BindGroupLayoutId(Uuid);
 
+render_resource_wrapper!(ErasedBindGroupLayout, wgpu::BindGroupLayout);
+
 #[derive(Clone, Debug)]
 pub struct BindGroupLayout {
     id: BindGroupLayoutId,
-    value: Arc<wgpu::BindGroupLayout>,
+    value: ErasedBindGroupLayout,
 }
 
 impl PartialEq for BindGroupLayout {
@@ -32,7 +35,7 @@ impl From<wgpu::BindGroupLayout> for BindGroupLayout {
     fn from(value: wgpu::BindGroupLayout) -> Self {
         BindGroupLayout {
             id: BindGroupLayoutId(Uuid::new_v4()),
-            value: Arc::new(value),
+            value: ErasedBindGroupLayout::new(value),
         }
     }
 }

crates/bevy_render/src/render_resource/buffer.rs

@@ -1,16 +1,17 @@
 use bevy_utils::Uuid;
-use std::{
-    ops::{Bound, Deref, RangeBounds},
-    sync::Arc,
-};
+use std::ops::{Bound, Deref, RangeBounds};
+
+use crate::render_resource::resource_macros::*;
 
 #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct BufferId(Uuid);
 
+render_resource_wrapper!(ErasedBuffer, wgpu::Buffer);
+
 #[derive(Clone, Debug)]
 pub struct Buffer {
     id: BufferId,
-    value: Arc<wgpu::Buffer>,
+    value: ErasedBuffer,
 }
 
 impl Buffer {
@@ -42,7 +43,7 @@ impl From<wgpu::Buffer> for Buffer {
     fn from(value: wgpu::Buffer) -> Self {
         Buffer {
             id: BufferId(Uuid::new_v4()),
-            value: Arc::new(value),
+            value: ErasedBuffer::new(value),
         }
     }
 }

crates/bevy_render/src/render_resource/mod.rs

@@ -5,6 +5,7 @@ mod buffer_vec;
 mod pipeline;
 mod pipeline_cache;
 mod pipeline_specializer;
+pub mod resource_macros;
 mod shader;
 mod storage_buffer;
 mod texture;

crates/bevy_render/src/render_resource/pipeline.rs

@@ -1,24 +1,28 @@
 use crate::render_resource::{BindGroupLayout, Shader};
 use bevy_asset::Handle;
 use bevy_reflect::Uuid;
-use std::{borrow::Cow, ops::Deref, sync::Arc};
+use std::{borrow::Cow, ops::Deref};
 use wgpu::{
     BufferAddress, ColorTargetState, DepthStencilState, MultisampleState, PrimitiveState,
     VertexAttribute, VertexFormat, VertexStepMode,
 };
 
+use crate::render_resource::resource_macros::*;
+
 /// A [`RenderPipeline`] identifier.
 #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct RenderPipelineId(Uuid);
 
+render_resource_wrapper!(ErasedRenderPipeline, 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: Arc<wgpu::RenderPipeline>,
+    value: ErasedRenderPipeline,
 }
 
 impl RenderPipeline {
@@ -32,7 +36,7 @@ impl From<wgpu::RenderPipeline> for RenderPipeline {
     fn from(value: wgpu::RenderPipeline) -> Self {
         RenderPipeline {
             id: RenderPipelineId(Uuid::new_v4()),
-            value: Arc::new(value),
+            value: ErasedRenderPipeline::new(value),
         }
     }
 }
@@ -50,14 +54,16 @@ impl Deref for RenderPipeline {
 #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct ComputePipelineId(Uuid);
 
+render_resource_wrapper!(ErasedComputePipeline, 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: Arc<wgpu::ComputePipeline>,
+    value: ErasedComputePipeline,
 }
 
 impl ComputePipeline {
@@ -72,7 +78,7 @@ impl From<wgpu::ComputePipeline> for ComputePipeline {
     fn from(value: wgpu::ComputePipeline) -> Self {
         ComputePipeline {
             id: ComputePipelineId(Uuid::new_v4()),
-            value: Arc::new(value),
+            value: ErasedComputePipeline::new(value),
         }
     }
 }

crates/bevy_render/src/render_resource/pipeline_cache.rs

@@ -17,13 +17,17 @@ use bevy_utils::{
     tracing::{debug, error},
     Entry, HashMap, HashSet,
 };
-use std::{hash::Hash, iter::FusedIterator, mem, ops::Deref, sync::Arc};
+use std::{hash::Hash, iter::FusedIterator, mem, ops::Deref};
 use thiserror::Error;
 use wgpu::{
-    BufferBindingType, PipelineLayoutDescriptor, ShaderModule,
-    VertexBufferLayout as RawVertexBufferLayout,
+    BufferBindingType, PipelineLayoutDescriptor, VertexBufferLayout as RawVertexBufferLayout,
 };
 
+use crate::render_resource::resource_macros::*;
+
+render_resource_wrapper!(ErasedShaderModule, wgpu::ShaderModule);
+render_resource_wrapper!(ErasedPipelineLayout, wgpu::PipelineLayout);
+
 /// A descriptor for a [`Pipeline`].
 ///
 /// Used to store an heterogenous collection of render and compute pipeline descriptors together.
@@ -103,7 +107,7 @@ impl CachedPipelineState {
 #[derive(Default)]
 struct ShaderData {
     pipelines: HashSet<CachedPipelineId>,
-    processed_shaders: HashMap<Vec<String>, Arc<ShaderModule>>,
+    processed_shaders: HashMap<Vec<String>, ErasedShaderModule>,
     resolved_imports: HashMap<ShaderImport, Handle<Shader>>,
     dependents: HashSet<Handle<Shader>>,
 }
@@ -124,7 +128,7 @@ impl ShaderCache {
         pipeline: CachedPipelineId,
         handle: &Handle<Shader>,
         shader_defs: &[String],
-    ) -> Result<Arc<ShaderModule>, PipelineCacheError> {
+    ) -> Result<ErasedShaderModule, PipelineCacheError> {
         let shader = self
             .shaders
             .get(handle)
@@ -201,7 +205,7 @@ impl ShaderCache {
                     return Err(PipelineCacheError::CreateShaderModule(description));
                 }
 
-                entry.insert(Arc::new(shader_module))
+                entry.insert(ErasedShaderModule::new(shader_module))
             }
         };
 
@@ -273,7 +277,7 @@ impl ShaderCache {
 
 #[derive(Default)]
 struct LayoutCache {
-    layouts: HashMap<Vec<BindGroupLayoutId>, wgpu::PipelineLayout>,
+    layouts: HashMap<Vec<BindGroupLayoutId>, ErasedPipelineLayout>,
 }
 
 impl LayoutCache {
@@ -288,10 +292,12 @@ impl LayoutCache {
                 .iter()
                 .map(|l| l.value())
                 .collect::<Vec<_>>();
-            render_device.create_pipeline_layout(&PipelineLayoutDescriptor {
-                bind_group_layouts: &bind_group_layouts,
-                ..default()
-            })
+            ErasedPipelineLayout::new(render_device.create_pipeline_layout(
+                &PipelineLayoutDescriptor {
+                    bind_group_layouts: &bind_group_layouts,
+                    ..default()
+                },
+            ))
         })
     }
 }

crates/bevy_render/src/render_resource/resource_macros.rs

@@ -0,0 +1,108 @@
+// structs containing wgpu types take a long time to compile. this is particularly bad for generic
+// structs containing wgpu structs. we avoid that in debug builds (and for cargo check and rust analyzer)
+// by boxing and type-erasing with the `render_resource_wrapper` macro.
+// analysis from https://github.com/bevyengine/bevy/pull/5950#issuecomment-1243473071 indicates this is
+// due to `evaluate_obligations`. we should check if this can be removed after a fix lands for
+// https://github.com/rust-lang/rust/issues/99188 (and after other `evaluate_obligations`-related changes).
+#[cfg(debug_assertions)]
+#[macro_export]
+macro_rules! render_resource_wrapper {
+    ($wrapper_type:ident, $wgpu_type:ty) => {
+        #[derive(Clone, Debug)]
+        pub struct $wrapper_type(Option<std::sync::Arc<Box<()>>>);
+
+        impl $wrapper_type {
+            pub fn new(value: $wgpu_type) -> Self {
+                unsafe {
+                    Self(Some(std::sync::Arc::new(std::mem::transmute(Box::new(
+                        value,
+                    )))))
+                }
+            }
+
+            pub fn try_unwrap(mut self) -> Option<$wgpu_type> {
+                let inner = self.0.take();
+                if let Some(inner) = inner {
+                    match std::sync::Arc::try_unwrap(inner) {
+                        Ok(untyped_box) => {
+                            let typed_box = unsafe {
+                                std::mem::transmute::<Box<()>, Box<$wgpu_type>>(untyped_box)
+                            };
+                            Some(*typed_box)
+                        }
+                        Err(inner) => {
+                            let _ = unsafe {
+                                std::mem::transmute::<
+                                    std::sync::Arc<Box<()>>,
+                                    std::sync::Arc<Box<$wgpu_type>>,
+                                >(inner)
+                            };
+                            None
+                        }
+                    }
+                } else {
+                    None
+                }
+            }
+        }
+
+        impl std::ops::Deref for $wrapper_type {
+            type Target = $wgpu_type;
+
+            fn deref(&self) -> &Self::Target {
+                let untyped_box = self
+                    .0
+                    .as_ref()
+                    .expect("render_resource_wrapper inner value has already been taken (via drop or try_unwrap")
+                    .as_ref();
+
+                let typed_box =
+                    unsafe { std::mem::transmute::<&Box<()>, &Box<$wgpu_type>>(untyped_box) };
+                typed_box.as_ref()
+            }
+        }
+
+        impl Drop for $wrapper_type {
+            fn drop(&mut self) {
+                let inner = self.0.take();
+                if let Some(inner) = inner {
+                    let _ = unsafe {
+                        std::mem::transmute::<
+                            std::sync::Arc<Box<()>>,
+                            std::sync::Arc<Box<$wgpu_type>>,
+                        >(inner)
+                    };
+                }
+            }
+        }
+    };
+}
+
+#[cfg(not(debug_assertions))]
+#[macro_export]
+macro_rules! render_resource_wrapper {
+    ($wrapper_type:ident, $wgpu_type:ty) => {
+        #[derive(Clone, Debug)]
+        pub struct $wrapper_type(std::sync::Arc<$wgpu_type>);
+
+        impl $wrapper_type {
+            pub fn new(value: $wgpu_type) -> Self {
+                Self(std::sync::Arc::new(value))
+            }
+
+            pub fn try_unwrap(self) -> Option<$wgpu_type> {
+                std::sync::Arc::try_unwrap(self.0).ok()
+            }
+        }
+
+        impl std::ops::Deref for $wrapper_type {
+            type Target = $wgpu_type;
+
+            fn deref(&self) -> &Self::Target {
+                self.0.as_ref()
+            }
+        }
+    };
+}
+
+pub use render_resource_wrapper;