Unload render assets from RAM

crates/bevy_asset/src/assets.rs

@@ -398,6 +398,15 @@ impl<A: Asset> Assets<A> {
         }
     }
 
+    /// Removes the [`Asset`] with the given `id`, if its exists. This always emits [`AssetEvent::Removed`], regardless
+    /// of whether or not the asset exists.
+    /// Note that this supports anything that implements `Into<AssetId<A>>`, which includes [`Handle`] and [`AssetId`].
+    fn remove_always_emit_event(&mut self, id: impl Into<AssetId<A>>) {
+        let id = id.into();
+        self.remove_untracked(id);
+        self.queued_events.push(AssetEvent::Removed { id });
+    }
+
     /// Returns `true` if there are no assets in this collection.
     pub fn is_empty(&self) -> bool {
         self.dense_storage.is_empty() && self.hash_map.is_empty()
@@ -466,18 +475,21 @@ impl<A: Asset> Assets<A> {
         let mut not_ready = Vec::new();
         while let Ok(drop_event) = assets.handle_provider.drop_receiver.try_recv() {
             let id = drop_event.id;
-            if !assets.contains(id.typed()) {
+
+            if !drop_event.last_strong_handle {
                 not_ready.push(drop_event);
                 continue;
             }
+
             if drop_event.asset_server_managed {
                 if infos.process_handle_drop(id.untyped(TypeId::of::<A>())) {
-                    assets.remove(id.typed());
+                    assets.remove_always_emit_event(id.typed());
                 }
             } else {
-                assets.remove(id.typed());
+                assets.remove_always_emit_event(id.typed());
             }
         }
+
         // TODO: this is _extremely_ inefficient find a better fix
         // This will also loop failed assets indefinitely. Is that ok?
         for event in not_ready {

crates/bevy_asset/src/handle.rs

@@ -25,6 +25,7 @@ pub struct AssetHandleProvider {
 
 pub(crate) struct DropEvent {
     pub(crate) id: InternalAssetId,
+    pub(crate) last_strong_handle: bool,
     pub(crate) asset_server_managed: bool,
 }
 
@@ -92,15 +93,6 @@ pub struct StrongHandle {
     pub(crate) drop_sender: Sender<DropEvent>,
 }
 
-impl Drop for StrongHandle {
-    fn drop(&mut self) {
-        let _ = self.drop_sender.send(DropEvent {
-            id: self.id.internal(),
-            asset_server_managed: self.asset_server_managed,
-        });
-    }
-}
-
 impl std::fmt::Debug for StrongHandle {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("StrongHandle")
@@ -124,7 +116,7 @@ impl std::fmt::Debug for StrongHandle {
 #[reflect(Component)]
 pub enum Handle<A: Asset> {
     /// A "strong" reference to a live (or loading) [`Asset`]. If a [`Handle`] is [`Handle::Strong`], the [`Asset`] will be kept
-    /// alive until the [`Handle`] is dropped. Strong handles also provide access to additional asset metadata.  
+    /// alive until the [`Handle`] is dropped. Strong handles also provide access to additional asset metadata.
     Strong(Arc<StrongHandle>),
     /// A "weak" reference to an [`Asset`]. If a [`Handle`] is [`Handle::Weak`], it does not necessarily reference a live [`Asset`],
     /// nor will it keep assets alive.
@@ -189,13 +181,25 @@ impl<A: Asset> Handle<A> {
 
     /// Converts this [`Handle`] to an "untyped" / "generic-less" [`UntypedHandle`], which stores the [`Asset`] type information
     /// _inside_ [`UntypedHandle`]. This will return [`UntypedHandle::Strong`] for [`Handle::Strong`] and [`UntypedHandle::Weak`] for
-    /// [`Handle::Weak`].  
+    /// [`Handle::Weak`].
     #[inline]
     pub fn untyped(self) -> UntypedHandle {
         self.into()
     }
 }
 
+impl<T: Asset> Drop for Handle<T> {
+    fn drop(&mut self) {
+        if let Self::Strong(strong_handle) = self {
+            let _ = strong_handle.drop_sender.send(DropEvent {
+                id: strong_handle.id.internal(),
+                last_strong_handle: Arc::strong_count(strong_handle) == 1,
+                asset_server_managed: strong_handle.asset_server_managed,
+            });
+        }
+    }
+}
+
 impl<A: Asset> Default for Handle<A> {
     fn default() -> Self {
         Handle::Weak(AssetId::default())

crates/bevy_core_pipeline/src/tonemapping/mod.rs

@@ -412,5 +412,6 @@ pub fn lut_placeholder() -> Image {
         },
         sampler: ImageSampler::Default,
         texture_view_descriptor: None,
+        cpu_persistent_access: false,
     }
 }

crates/bevy_gizmos/src/lib.rs

@@ -372,28 +372,25 @@ struct GpuLineGizmo {
 }
 
 impl RenderAsset for LineGizmo {
-    type ExtractedAsset = LineGizmo;
-
     type PreparedAsset = GpuLineGizmo;
-
     type Param = SRes<RenderDevice>;
 
-    fn extract_asset(&self) -> Self::ExtractedAsset {
-        self.clone()
+    fn unload_after_extract(&self) -> bool {
+        false
     }
 
     fn prepare_asset(
-        line_gizmo: Self::ExtractedAsset,
+        self,
         render_device: &mut SystemParamItem<Self::Param>,
-    ) -> Result<Self::PreparedAsset, PrepareAssetError<Self::ExtractedAsset>> {
-        let position_buffer_data = cast_slice(&line_gizmo.positions);
+    ) -> Result<Self::PreparedAsset, PrepareAssetError<Self>> {
+        let position_buffer_data = cast_slice(&self.positions);
         let position_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
             usage: BufferUsages::VERTEX,
             label: Some("LineGizmo Position Buffer"),
             contents: position_buffer_data,
         });
 
-        let color_buffer_data = cast_slice(&line_gizmo.colors);
+        let color_buffer_data = cast_slice(&self.colors);
         let color_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
             usage: BufferUsages::VERTEX,
             label: Some("LineGizmo Color Buffer"),
@@ -403,8 +400,8 @@ impl RenderAsset for LineGizmo {
         Ok(GpuLineGizmo {
             position_buffer,
             color_buffer,
-            vertex_count: line_gizmo.positions.len() as u32,
-            strip: line_gizmo.strip,
+            vertex_count: self.positions.len() as u32,
+            strip: self.strip,
         })
     }
 }

crates/bevy_gltf/src/loader.rs

@@ -352,7 +352,7 @@ async fn load_gltf<'a, 'b, 'c>(
             let primitive_label = primitive_label(&gltf_mesh, &primitive);
             let primitive_topology = get_primitive_topology(primitive.mode())?;
 
-            let mut mesh = Mesh::new(primitive_topology);
+            let mut mesh = Mesh::new(primitive_topology, false);
 
             // Read vertex attributes
             for (semantic, accessor) in primitive.attributes() {

crates/bevy_render/src/mesh/mesh/mod.rs

@@ -50,7 +50,7 @@ pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
 /// # use bevy_render::render_resource::PrimitiveTopology;
 /// fn create_simple_parallelogram() -> Mesh {
 ///     // Create a new mesh using a triangle list topology, where each set of 3 vertices composes a triangle.
-///     Mesh::new(PrimitiveTopology::TriangleList)
+///     Mesh::new(PrimitiveTopology::TriangleList, false)
 ///         // Add 4 vertices, each with its own position attribute (coordinate in
 ///         // 3D space), for each of the corners of the parallelogram.
 ///         .with_inserted_attribute(
@@ -108,8 +108,6 @@ pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
 /// - Vertex winding order: by default, `StandardMaterial.cull_mode` is [`Some(Face::Back)`](crate::render_resource::Face),
 /// which means that Bevy would *only* render the "front" of each triangle, which
 /// is the side of the triangle from where the vertices appear in a *counter-clockwise* order.
-///
-// TODO: allow values to be unloaded after been submitting to the GPU to conserve memory
 #[derive(Asset, Debug, Clone, Reflect)]
 pub struct Mesh {
     #[reflect(ignore)]
@@ -123,6 +121,17 @@ pub struct Mesh {
     indices: Option<Indices>,
     morph_targets: Option<Handle<Image>>,
     morph_target_names: Option<Vec<String>>,
+    /// If false, this asset will be unloaded from `Assets<Mesh>` via `remove_untracked()`
+    /// once it has been uploaded to the GPU.
+    ///
+    /// This saves on RAM usage by not keeping a redundant copy of the mesh in memory once
+    /// it's in the GPU's VRAM.
+    ///
+    /// The asset unloading will only take place once the asset has been added to `Assets<Mesh>`
+    /// and a frame has passed. You do not need to set this flag to true in order to build the
+    /// mesh initially. This flag only controls whether or not the asset is accessible via `Assets<Mesh>`
+    /// in future frames, once it's been added to `Assets<Mesh>`.
+    pub cpu_persistent_access: bool,
 }
 
 impl Mesh {
@@ -180,13 +189,14 @@ impl Mesh {
     /// Construct a new mesh. You need to provide a [`PrimitiveTopology`] so that the
     /// renderer knows how to treat the vertex data. Most of the time this will be
     /// [`PrimitiveTopology::TriangleList`].
-    pub fn new(primitive_topology: PrimitiveTopology) -> Self {
+    pub fn new(primitive_topology: PrimitiveTopology, cpu_persistent_access: bool) -> Self {
         Mesh {
             primitive_topology,
             attributes: Default::default(),
             indices: None,
             morph_targets: None,
             morph_target_names: None,
+            cpu_persistent_access,
         }
     }
 
@@ -1052,50 +1062,48 @@ pub enum GpuBufferInfo {
 }
 
 impl RenderAsset for Mesh {
-    type ExtractedAsset = Mesh;
     type PreparedAsset = GpuMesh;
     type Param = (SRes<RenderDevice>, SRes<RenderAssets<Image>>);
 
-    /// Clones the mesh.
-    fn extract_asset(&self) -> Self::ExtractedAsset {
-        self.clone()
+    fn unload_after_extract(&self) -> bool {
+        !self.cpu_persistent_access
     }
 
     /// Converts the extracted mesh a into [`GpuMesh`].
     fn prepare_asset(
-        mesh: Self::ExtractedAsset,
+        self,
         (render_device, images): &mut SystemParamItem<Self::Param>,
-    ) -> Result<Self::PreparedAsset, PrepareAssetError<Self::ExtractedAsset>> {
-        let vertex_buffer_data = mesh.get_vertex_buffer_data();
+    ) -> Result<Self::PreparedAsset, PrepareAssetError<Self>> {
+        let vertex_buffer_data = self.get_vertex_buffer_data();
         let vertex_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
             usage: BufferUsages::VERTEX,
             label: Some("Mesh Vertex Buffer"),
             contents: &vertex_buffer_data,
         });
 
-        let buffer_info = if let Some(data) = mesh.get_index_buffer_bytes() {
+        let buffer_info = if let Some(data) = self.get_index_buffer_bytes() {
             GpuBufferInfo::Indexed {
                 buffer: render_device.create_buffer_with_data(&BufferInitDescriptor {
                     usage: BufferUsages::INDEX,
                     contents: data,
                     label: Some("Mesh Index Buffer"),
                 }),
-                count: mesh.indices().unwrap().len() as u32,
-                index_format: mesh.indices().unwrap().into(),
+                count: self.indices().unwrap().len() as u32,
+                index_format: self.indices().unwrap().into(),
             }
         } else {
             GpuBufferInfo::NonIndexed
         };
 
-        let mesh_vertex_buffer_layout = mesh.get_mesh_vertex_buffer_layout();
+        let mesh_vertex_buffer_layout = self.get_mesh_vertex_buffer_layout();
 
         Ok(GpuMesh {
             vertex_buffer,
-            vertex_count: mesh.count_vertices() as u32,
+            vertex_count: self.count_vertices() as u32,
             buffer_info,
-            primitive_topology: mesh.primitive_topology(),
+            primitive_topology: self.primitive_topology(),
             layout: mesh_vertex_buffer_layout,
-            morph_targets: mesh
+            morph_targets: self
                 .morph_targets
                 .and_then(|mt| images.get(&mt).map(|i| i.texture_view.clone())),
         })
@@ -1237,7 +1245,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn panic_invalid_format() {
-        let _mesh = Mesh::new(PrimitiveTopology::TriangleList)
+        let _mesh = Mesh::new(PrimitiveTopology::TriangleList, false)
             .with_inserted_attribute(Mesh::ATTRIBUTE_UV_0, vec![[0.0, 0.0, 0.0]]);
     }
 }

crates/bevy_render/src/mesh/shape/capsule.rs

@@ -364,7 +364,7 @@ impl From<Capsule> for Mesh {
         assert_eq!(vs.len(), vert_len);
         assert_eq!(tris.len(), fs_len);
 
-        Mesh::new(PrimitiveTopology::TriangleList)
+        Mesh::new(PrimitiveTopology::TriangleList, false)
             .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, vs)
             .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, vns)
             .with_inserted_attribute(Mesh::ATTRIBUTE_UV_0, vts)

crates/bevy_render/src/mesh/shape/cylinder.rs

@@ -118,7 +118,7 @@ impl From<Cylinder> for Mesh {
         build_cap(true);
         build_cap(false);
 
-        Mesh::new(PrimitiveTopology::TriangleList)
+        Mesh::new(PrimitiveTopology::TriangleList, false)
             .with_indices(Some(Indices::U32(indices)))
             .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, positions)
             .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)

crates/bevy_render/src/mesh/shape/icosphere.rs

@@ -103,7 +103,7 @@ impl TryFrom<Icosphere> for Mesh {
 
         let indices = Indices::U32(indices);
 
-        Ok(Mesh::new(PrimitiveTopology::TriangleList)
+        Ok(Mesh::new(PrimitiveTopology::TriangleList, false)
             .with_indices(Some(indices))
             .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, points)
             .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)

crates/bevy_render/src/mesh/shape/mod.rs

@@ -120,7 +120,7 @@ impl From<Box> for Mesh {
             20, 21, 22, 22, 23, 20, // bottom
         ]);
 
-        Mesh::new(PrimitiveTopology::TriangleList)
+        Mesh::new(PrimitiveTopology::TriangleList, false)
             .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, positions)
             .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)
             .with_inserted_attribute(Mesh::ATTRIBUTE_UV_0, uvs)
@@ -172,7 +172,7 @@ impl From<Quad> for Mesh {
         let normals: Vec<_> = vertices.iter().map(|(_, n, _)| *n).collect();
         let uvs: Vec<_> = vertices.iter().map(|(_, _, uv)| *uv).collect();
 
-        Mesh::new(PrimitiveTopology::TriangleList)
+        Mesh::new(PrimitiveTopology::TriangleList, false)
             .with_indices(Some(indices))
             .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, positions)
             .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)
@@ -253,7 +253,7 @@ impl From<Plane> for Mesh {
             }
         }
 
-        Mesh::new(PrimitiveTopology::TriangleList)
+        Mesh::new(PrimitiveTopology::TriangleList, false)
             .with_indices(Some(Indices::U32(indices)))
             .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, positions)
             .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)

crates/bevy_render/src/mesh/shape/regular_polygon.rs

@@ -53,7 +53,7 @@ impl From<RegularPolygon> for Mesh {
             indices.extend_from_slice(&[0, i + 1, i]);
         }
 
-        Mesh::new(PrimitiveTopology::TriangleList)
+        Mesh::new(PrimitiveTopology::TriangleList, false)
             .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, positions)
             .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)
             .with_inserted_attribute(Mesh::ATTRIBUTE_UV_0, uvs)

crates/bevy_render/src/mesh/shape/torus.rs

@@ -84,7 +84,7 @@ impl From<Torus> for Mesh {
             }
         }
 
-        Mesh::new(PrimitiveTopology::TriangleList)
+        Mesh::new(PrimitiveTopology::TriangleList, false)
             .with_indices(Some(Indices::U32(indices)))
             .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, positions)
             .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)

crates/bevy_render/src/mesh/shape/uvsphere.rs

@@ -80,7 +80,7 @@ impl From<UVSphere> for Mesh {
             }
         }
 
-        Mesh::new(PrimitiveTopology::TriangleList)
+        Mesh::new(PrimitiveTopology::TriangleList, false)
             .with_indices(Some(Indices::U32(indices)))
             .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, vertices)
             .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, normals)