6b40b6749e
# Objective Right now, all assets in the main world get extracted and prepared in the render world (if the asset's using the RenderAssetPlugin). This is unfortunate for two cases: 1. **TextureAtlas** / **FontAtlas**: This one's huge. The individual `Image` assets that make up the atlas are cloned and prepared individually when there's no reason for them to be. The atlas textures are built on the CPU in the main world. *There can be hundreds of images that get prepared for rendering only not to be used.* 2. If one loads an Image and needs to transform it in a system before rendering it, kind of like the [decompression example](https://github.com/bevyengine/bevy/blob/main/examples/asset/asset_decompression.rs#L120), there's a price paid for extracting & preparing the asset that's not intended to be rendered yet. ------ * References #10520 * References #1782 ## Solution This changes the `RenderAssetPersistencePolicy` enum to bitflags. I felt that the objective with the parameter is so similar in nature to wgpu's [`TextureUsages`](https://docs.rs/wgpu/latest/wgpu/struct.TextureUsages.html) and [`BufferUsages`](https://docs.rs/wgpu/latest/wgpu/struct.BufferUsages.html), that it may as well be just like that. ```rust // This asset only needs to be in the main world. Don't extract and prepare it. RenderAssetUsages::MAIN_WORLD // Keep this asset in the main world and RenderAssetUsages::MAIN_WORLD | RenderAssetUsages::RENDER_WORLD // This asset is only needed in the render world. Remove it from the asset server once extracted. RenderAssetUsages::RENDER_WORLD ``` ### Alternate Solution I considered introducing a third field to `RenderAssetPersistencePolicy` enum: ```rust enum RenderAssetPersistencePolicy { /// Keep the asset in the main world after extracting to the render world. Keep, /// Remove the asset from the main world after extracting to the render world. Unload, /// This doesn't need to be in the render world at all. NoExtract, // <----- } ``` Functional, but this seemed like shoehorning. Another option is renaming the enum to something like: ```rust enum RenderAssetExtractionPolicy { /// Extract the asset and keep it in the main world. Extract, /// Remove the asset from the main world after extracting to the render world. ExtractAndUnload, /// This doesn't need to be in the render world at all. NoExtract, } ``` I think this last one could be a good option if the bitflags are too clunky. ## Migration Guide * `RenderAssetPersistencePolicy::Keep` → `RenderAssetUsage::MAIN_WORLD | RenderAssetUsage::RENDER_WORLD` (or `RenderAssetUsage::default()`) * `RenderAssetPersistencePolicy::Unload` → `RenderAssetUsage::RENDER_WORLD` * For types implementing the `RenderAsset` trait, change `fn persistence_policy(&self) -> RenderAssetPersistencePolicy` to `fn asset_usage(&self) -> RenderAssetUsages`. * Change any references to `cpu_persistent_access` (`RenderAssetPersistencePolicy`) to `asset_usage` (`RenderAssetUsage`). This applies to `Image`, `Mesh`, and a few other types.
115 lines
3.3 KiB
Rust
115 lines
3.3 KiB
Rust
use ab_glyph::{GlyphId, Point};
|
|
use bevy_asset::{Assets, Handle};
|
|
use bevy_math::Vec2;
|
|
use bevy_render::{
|
|
render_asset::RenderAssetUsages,
|
|
render_resource::{Extent3d, TextureDimension, TextureFormat},
|
|
texture::Image,
|
|
};
|
|
use bevy_sprite::{DynamicTextureAtlasBuilder, TextureAtlasLayout};
|
|
use bevy_utils::HashMap;
|
|
|
|
#[cfg(feature = "subpixel_glyph_atlas")]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
|
|
pub struct SubpixelOffset {
|
|
x: u16,
|
|
y: u16,
|
|
}
|
|
|
|
#[cfg(feature = "subpixel_glyph_atlas")]
|
|
impl From<Point> for SubpixelOffset {
|
|
fn from(p: Point) -> Self {
|
|
fn f(v: f32) -> u16 {
|
|
((v % 1.) * (u16::MAX as f32)) as u16
|
|
}
|
|
Self {
|
|
x: f(p.x),
|
|
y: f(p.y),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(not(feature = "subpixel_glyph_atlas"))]
|
|
#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
|
|
pub struct SubpixelOffset;
|
|
|
|
#[cfg(not(feature = "subpixel_glyph_atlas"))]
|
|
impl From<Point> for SubpixelOffset {
|
|
fn from(_: Point) -> Self {
|
|
Self
|
|
}
|
|
}
|
|
|
|
pub struct FontAtlas {
|
|
pub dynamic_texture_atlas_builder: DynamicTextureAtlasBuilder,
|
|
pub glyph_to_atlas_index: HashMap<(GlyphId, SubpixelOffset), usize>,
|
|
pub texture_atlas: Handle<TextureAtlasLayout>,
|
|
pub texture: Handle<Image>,
|
|
}
|
|
|
|
impl FontAtlas {
|
|
pub fn new(
|
|
textures: &mut Assets<Image>,
|
|
texture_atlases: &mut Assets<TextureAtlasLayout>,
|
|
size: Vec2,
|
|
) -> FontAtlas {
|
|
let texture = textures.add(Image::new_fill(
|
|
Extent3d {
|
|
width: size.x as u32,
|
|
height: size.y as u32,
|
|
depth_or_array_layers: 1,
|
|
},
|
|
TextureDimension::D2,
|
|
&[0, 0, 0, 0],
|
|
TextureFormat::Rgba8UnormSrgb,
|
|
// Need to keep this image CPU persistent in order to add additional glyphs later on
|
|
RenderAssetUsages::MAIN_WORLD | RenderAssetUsages::RENDER_WORLD,
|
|
));
|
|
let texture_atlas = TextureAtlasLayout::new_empty(size);
|
|
Self {
|
|
texture_atlas: texture_atlases.add(texture_atlas),
|
|
glyph_to_atlas_index: HashMap::default(),
|
|
dynamic_texture_atlas_builder: DynamicTextureAtlasBuilder::new(size, 0),
|
|
texture,
|
|
}
|
|
}
|
|
|
|
pub fn get_glyph_index(
|
|
&self,
|
|
glyph_id: GlyphId,
|
|
subpixel_offset: SubpixelOffset,
|
|
) -> Option<usize> {
|
|
self.glyph_to_atlas_index
|
|
.get(&(glyph_id, subpixel_offset))
|
|
.copied()
|
|
}
|
|
|
|
pub fn has_glyph(&self, glyph_id: GlyphId, subpixel_offset: SubpixelOffset) -> bool {
|
|
self.glyph_to_atlas_index
|
|
.contains_key(&(glyph_id, subpixel_offset))
|
|
}
|
|
|
|
pub fn add_glyph(
|
|
&mut self,
|
|
textures: &mut Assets<Image>,
|
|
texture_atlases: &mut Assets<TextureAtlasLayout>,
|
|
glyph_id: GlyphId,
|
|
subpixel_offset: SubpixelOffset,
|
|
texture: &Image,
|
|
) -> bool {
|
|
let texture_atlas = texture_atlases.get_mut(&self.texture_atlas).unwrap();
|
|
if let Some(index) = self.dynamic_texture_atlas_builder.add_texture(
|
|
texture_atlas,
|
|
textures,
|
|
texture,
|
|
&self.texture,
|
|
) {
|
|
self.glyph_to_atlas_index
|
|
.insert((glyph_id, subpixel_offset), index);
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
}
|