Unload render assets from RAM

crates/bevy_core_pipeline/src/tonemapping/mod.rs

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

crates/bevy_gizmos/src/lib.rs

@@ -377,6 +377,10 @@ impl RenderAsset for LineGizmo {
         self.clone()
     }
 
+    fn unload_after_extract(_extracted_asset: &Self::ExtractedAsset) -> bool {
+        false
+    }
+
     fn prepare_asset(
         line_gizmo: Self::ExtractedAsset,
         render_device: &mut SystemParamItem<Self::Param>,

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

@@ -123,6 +123,7 @@ pub struct Mesh {
     indices: Option<Indices>,
     morph_targets: Option<Handle<Image>>,
     morph_target_names: Option<Vec<String>>,
+    pub mutable: bool,
 }
 
 impl Mesh {
@@ -180,13 +181,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, mutable: bool) -> Self {
         Mesh {
             primitive_topology,
             attributes: Default::default(),
             indices: None,
             morph_targets: None,
             morph_target_names: None,
+            mutable,
         }
     }
 
@@ -1061,6 +1063,10 @@ impl RenderAsset for Mesh {
         self.clone()
     }
 
+    fn unload_after_extract(extracted_asset: &Self::ExtractedAsset) -> bool {
+        !extracted_asset.mutable
+    }
+
     /// Converts the extracted mesh a into [`GpuMesh`].
     fn prepare_asset(
         mesh: Self::ExtractedAsset,
@@ -1237,7 +1243,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)

crates/bevy_render/src/render_asset.rs

@@ -1,10 +1,10 @@
-use crate::{Extract, ExtractSchedule, Render, RenderApp, RenderSet};
+use crate::{ExtractSchedule, MainWorld, Render, RenderApp, RenderSet};
 use bevy_app::{App, Plugin};
 use bevy_asset::{Asset, AssetEvent, AssetId, Assets};
 use bevy_ecs::{
-    prelude::*,
+    prelude::{Commands, EventReader, IntoSystemConfigs, ResMut, Resource},
     schedule::SystemConfigs,
-    system::{StaticSystemParam, SystemParam, SystemParamItem},
+    system::{StaticSystemParam, SystemParam, SystemParamItem, SystemState},
 };
 use bevy_utils::{thiserror::Error, HashMap, HashSet};
 use std::marker::PhantomData;
@@ -32,8 +32,18 @@ pub trait RenderAsset: Asset {
     /// Specifies all ECS data required by [`RenderAsset::prepare_asset`].
     /// For convenience use the [`lifetimeless`](bevy_ecs::system::lifetimeless) [`SystemParam`].
     type Param: SystemParam;
+
     /// Converts the asset into a [`RenderAsset::ExtractedAsset`].
     fn extract_asset(&self) -> Self::ExtractedAsset;
+
+    /// Whether or not to unload the asset after extracting.
+    ///
+    /// Unloading the asset saves on memory, as you no longer need to keep it in RAM once
+    /// it's been uploaded to the GPU's VRAM. However, you can no longer modify the asset
+    /// once unloaded (without re-loading it), making this a bad choice for frequently modified
+    /// assets.
+    fn unload_after_extract(extracted_asset: &Self::ExtractedAsset) -> bool;
+
     /// Prepares the `extracted asset` for the GPU by transforming it into
     /// a [`RenderAsset::PreparedAsset`]. Therefore ECS data may be accessed via the `param`.
     fn prepare_asset(
@@ -160,11 +170,11 @@ impl<A: RenderAsset> RenderAssets<A> {
 
 /// This system extracts all created or modified assets of the corresponding [`RenderAsset`] type
 /// into the "render world".
-fn extract_render_asset<A: RenderAsset>(
-    mut commands: Commands,
-    mut events: Extract<EventReader<AssetEvent<A>>>,
-    assets: Extract<Res<Assets<A>>>,
-) {
+fn extract_render_asset<A: RenderAsset>(mut commands: Commands, mut main_world: ResMut<MainWorld>) {
+    let mut system_state: SystemState<(EventReader<AssetEvent<A>>, ResMut<Assets<A>>)> =
+        SystemState::new(&mut main_world);
+    let (mut events, mut assets) = system_state.get_mut(&mut main_world);
+
     let mut changed_assets = HashSet::default();
     let mut removed = Vec::new();
     for event in events.read() {
@@ -185,7 +195,13 @@ fn extract_render_asset<A: RenderAsset>(
     let mut extracted_assets = Vec::new();
     for id in changed_assets.drain() {
         if let Some(asset) = assets.get(id) {
-            extracted_assets.push((id, asset.extract_asset()));
+            let extracted_asset = asset.extract_asset();
+
+            if A::unload_after_extract(&extracted_asset) {
+                assets.remove_untracked(id);
+            }
+
+            extracted_assets.push((id, extracted_asset));
         }
     }
 
@@ -212,16 +228,16 @@ impl<A: RenderAsset> Default for PrepareNextFrameAssets<A> {
 
 /// This system prepares all assets of the corresponding [`RenderAsset`] type
 /// which where extracted this frame for the GPU.
-pub fn prepare_assets<R: RenderAsset>(
-    mut extracted_assets: ResMut<ExtractedAssets<R>>,
-    mut render_assets: ResMut<RenderAssets<R>>,
-    mut prepare_next_frame: ResMut<PrepareNextFrameAssets<R>>,
-    param: StaticSystemParam<<R as RenderAsset>::Param>,
+pub fn prepare_assets<A: RenderAsset>(
+    mut extracted_assets: ResMut<ExtractedAssets<A>>,
+    mut render_assets: ResMut<RenderAssets<A>>,
+    mut prepare_next_frame: ResMut<PrepareNextFrameAssets<A>>,
+    param: StaticSystemParam<<A as RenderAsset>::Param>,
 ) {
     let mut param = param.into_inner();
     let queued_assets = std::mem::take(&mut prepare_next_frame.assets);
     for (id, extracted_asset) in queued_assets {
-        match R::prepare_asset(extracted_asset, &mut param) {
+        match A::prepare_asset(extracted_asset, &mut param) {
             Ok(prepared_asset) => {
                 render_assets.insert(id, prepared_asset);
             }
@@ -236,7 +252,7 @@ pub fn prepare_assets<R: RenderAsset>(
     }
 
     for (id, extracted_asset) in std::mem::take(&mut extracted_assets.extracted) {
-        match R::prepare_asset(extracted_asset, &mut param) {
+        match A::prepare_asset(extracted_asset, &mut param) {
             Ok(prepared_asset) => {
                 render_assets.insert(id, prepared_asset);
             }

crates/bevy_render/src/texture/image.rs

@@ -110,6 +110,7 @@ pub struct Image {
     /// The [`ImageSampler`] to use during rendering.
     pub sampler: ImageSampler,
     pub texture_view_descriptor: Option<wgpu::TextureViewDescriptor<'static>>,
+    pub mutable: bool,
 }
 
 /// Used in [`Image`], this determines what image sampler to use when rendering. The default setting,
@@ -464,6 +465,7 @@ impl Default for Image {
             },
             sampler: ImageSampler::Default,
             texture_view_descriptor: None,
+            mutable: false,
         }
     }
 }
@@ -813,6 +815,10 @@ impl RenderAsset for Image {
         self.clone()
     }
 
+    fn unload_after_extract(extracted_asset: &Self::ExtractedAsset) -> bool {
+        !extracted_asset.mutable
+    }
+
     /// Converts the extracted image into a [`GpuImage`].
     fn prepare_asset(
         image: Self::ExtractedAsset,