
# Objective - No point in keeping Meshes/Images in RAM once they're going to be sent to the GPU, and kept in VRAM. This saves a _significant_ amount of memory (several GBs) on scenes like bistro. - References - https://github.com/bevyengine/bevy/pull/1782 - https://github.com/bevyengine/bevy/pull/8624 ## Solution - Augment RenderAsset with the capability to unload the underlying asset after extracting to the render world. - Mesh/Image now have a cpu_persistent_access field. If this field is RenderAssetPersistencePolicy::Unload, the asset will be unloaded from Assets<T>. - A new AssetEvent is sent upon dropping the last strong handle for the asset, which signals to the RenderAsset to remove the GPU version of the asset. --- ## Changelog - Added `AssetEvent::NoLongerUsed` and `AssetEvent::is_no_longer_used()`. This event is sent when the last strong handle of an asset is dropped. - Rewrote the API for `RenderAsset` to allow for unloading the asset data from the CPU. - Added `RenderAssetPersistencePolicy`. - Added `Mesh::cpu_persistent_access` for memory savings when the asset is not needed except for on the GPU. - Added `Image::cpu_persistent_access` for memory savings when the asset is not needed except for on the GPU. - Added `ImageLoaderSettings::cpu_persistent_access`. - Added `ExrTextureLoaderSettings`. - Added `HdrTextureLoaderSettings`. ## Migration Guide - Asset loaders (GLTF, etc) now load meshes and textures without `cpu_persistent_access`. These assets will be removed from `Assets<Mesh>` and `Assets<Image>` once `RenderAssets<Mesh>` and `RenderAssets<Image>` contain the GPU versions of these assets, in order to reduce memory usage. If you require access to the asset data from the CPU in future frames after the GLTF asset has been loaded, modify all dependent `Mesh` and `Image` assets and set `cpu_persistent_access` to `RenderAssetPersistencePolicy::Keep`. - `Mesh` now requires a new `cpu_persistent_access` field. Set it to `RenderAssetPersistencePolicy::Keep` to mimic the previous behavior. - `Image` now requires a new `cpu_persistent_access` field. Set it to `RenderAssetPersistencePolicy::Keep` to mimic the previous behavior. - `MorphTargetImage::new()` now requires a new `cpu_persistent_access` parameter. Set it to `RenderAssetPersistencePolicy::Keep` to mimic the previous behavior. - `DynamicTextureAtlasBuilder::add_texture()` now requires that the `TextureAtlas` you pass has an `Image` with `cpu_persistent_access: RenderAssetPersistencePolicy::Keep`. Ensure you construct the image properly for the texture atlas. - The `RenderAsset` trait has significantly changed, and requires adapting your existing implementations. - The trait now requires `Clone`. - The `ExtractedAsset` associated type has been removed (the type itself is now extracted). - The signature of `prepare_asset()` is slightly different - A new `persistence_policy()` method is now required (return RenderAssetPersistencePolicy::Unload to match the previous behavior). - Match on the new `NoLongerUsed` variant for exhaustive matches of `AssetEvent`.
127 lines
3.8 KiB
Rust
127 lines
3.8 KiB
Rust
//! Create a custom material to draw basic lines in 3D
|
|
|
|
use bevy::{
|
|
pbr::{MaterialPipeline, MaterialPipelineKey},
|
|
prelude::*,
|
|
reflect::TypePath,
|
|
render::{
|
|
mesh::{MeshVertexBufferLayout, PrimitiveTopology},
|
|
render_asset::RenderAssetPersistencePolicy,
|
|
render_resource::{
|
|
AsBindGroup, PolygonMode, RenderPipelineDescriptor, ShaderRef,
|
|
SpecializedMeshPipelineError,
|
|
},
|
|
},
|
|
};
|
|
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins((DefaultPlugins, MaterialPlugin::<LineMaterial>::default()))
|
|
.add_systems(Startup, setup)
|
|
.run();
|
|
}
|
|
|
|
fn setup(
|
|
mut commands: Commands,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<LineMaterial>>,
|
|
) {
|
|
// Spawn a list of lines with start and end points for each lines
|
|
commands.spawn(MaterialMeshBundle {
|
|
mesh: meshes.add(Mesh::from(LineList {
|
|
lines: vec![
|
|
(Vec3::ZERO, Vec3::new(1.0, 1.0, 0.0)),
|
|
(Vec3::new(1.0, 1.0, 0.0), Vec3::new(1.0, 0.0, 0.0)),
|
|
],
|
|
})),
|
|
transform: Transform::from_xyz(-1.5, 0.0, 0.0),
|
|
material: materials.add(LineMaterial {
|
|
color: Color::GREEN,
|
|
}),
|
|
..default()
|
|
});
|
|
|
|
// Spawn a line strip that goes from point to point
|
|
commands.spawn(MaterialMeshBundle {
|
|
mesh: meshes.add(Mesh::from(LineStrip {
|
|
points: vec![
|
|
Vec3::ZERO,
|
|
Vec3::new(1.0, 1.0, 0.0),
|
|
Vec3::new(1.0, 0.0, 0.0),
|
|
],
|
|
})),
|
|
transform: Transform::from_xyz(0.5, 0.0, 0.0),
|
|
material: materials.add(LineMaterial { color: Color::BLUE }),
|
|
..default()
|
|
});
|
|
|
|
// camera
|
|
commands.spawn(Camera3dBundle {
|
|
transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
|
|
..default()
|
|
});
|
|
}
|
|
|
|
#[derive(Asset, TypePath, Default, AsBindGroup, Debug, Clone)]
|
|
struct LineMaterial {
|
|
#[uniform(0)]
|
|
color: Color,
|
|
}
|
|
|
|
impl Material for LineMaterial {
|
|
fn fragment_shader() -> ShaderRef {
|
|
"shaders/line_material.wgsl".into()
|
|
}
|
|
|
|
fn specialize(
|
|
_pipeline: &MaterialPipeline<Self>,
|
|
descriptor: &mut RenderPipelineDescriptor,
|
|
_layout: &MeshVertexBufferLayout,
|
|
_key: MaterialPipelineKey<Self>,
|
|
) -> Result<(), SpecializedMeshPipelineError> {
|
|
// This is the important part to tell bevy to render this material as a line between vertices
|
|
descriptor.primitive.polygon_mode = PolygonMode::Line;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// A list of lines with a start and end position
|
|
#[derive(Debug, Clone)]
|
|
pub struct LineList {
|
|
pub lines: Vec<(Vec3, Vec3)>,
|
|
}
|
|
|
|
impl From<LineList> for Mesh {
|
|
fn from(line: LineList) -> Self {
|
|
let vertices: Vec<_> = line.lines.into_iter().flat_map(|(a, b)| [a, b]).collect();
|
|
|
|
Mesh::new(
|
|
// This tells wgpu that the positions are list of lines
|
|
// where every pair is a start and end point
|
|
PrimitiveTopology::LineList,
|
|
RenderAssetPersistencePolicy::Unload,
|
|
)
|
|
// Add the vertices positions as an attribute
|
|
.with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, vertices)
|
|
}
|
|
}
|
|
|
|
/// A list of points that will have a line drawn between each consecutive points
|
|
#[derive(Debug, Clone)]
|
|
pub struct LineStrip {
|
|
pub points: Vec<Vec3>,
|
|
}
|
|
|
|
impl From<LineStrip> for Mesh {
|
|
fn from(line: LineStrip) -> Self {
|
|
Mesh::new(
|
|
// This tells wgpu that the positions are a list of points
|
|
// where a line will be drawn between each consecutive point
|
|
PrimitiveTopology::LineStrip,
|
|
RenderAssetPersistencePolicy::Unload,
|
|
)
|
|
// Add the point positions as an attribute
|
|
.with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, line.points)
|
|
}
|
|
}
|