Struct bevy::prelude::TextureAtlasBuilder

pub struct TextureAtlasBuilder<'a> { /* private fields */ }

A builder which is used to create a texture atlas from many individual sprites.

Implementations

impl<'a> TextureAtlasBuilder<'a>

pub fn initial_size(self, size: UVec2) -> TextureAtlasBuilder<'a>

Sets the initial size of the atlas in pixels.

pub fn max_size(self, size: UVec2) -> TextureAtlasBuilder<'a>

Sets the max size of the atlas in pixels.

pub fn format(self, format: TextureFormat) -> TextureAtlasBuilder<'a>

Sets the texture format for textures in the atlas.

pub fn auto_format_conversion( self, auto_format_conversion: bool ) -> TextureAtlasBuilder<'a>

Control whether the added texture should be converted to the atlas format, if different.

pub fn add_texture( &mut self, image_id: Option<AssetId<Image>>, texture: &'a Image )

Adds a texture to be copied to the texture atlas.

Optionally an asset id can be passed that can later be used with the texture layout to retrieve the index of this texture. The insertion order will reflect the index of the added texture in the finished texture atlas.

Examples found in repository

examples/2d/texture_atlas.rs (line 222)

fn create_texture_atlas(
    folder: &LoadedFolder,
    padding: Option<UVec2>,
    sampling: Option<ImageSampler>,
    textures: &mut ResMut<Assets<Image>>,
) -> (TextureAtlasLayout, Handle<Image>) {
    // Build a texture atlas using the individual sprites
    let mut texture_atlas_builder =
        TextureAtlasBuilder::default().padding(padding.unwrap_or_default());
    for handle in folder.handles.iter() {
        let id = handle.id().typed_unchecked::<Image>();
        let Some(texture) = textures.get(id) else {
            warn!(
                "{:?} did not resolve to an `Image` asset.",
                handle.path().unwrap()
            );
            continue;
        };

        texture_atlas_builder.add_texture(Some(id), texture);
    }

    let (texture_atlas_layout, texture) = texture_atlas_builder.finish().unwrap();
    let texture = textures.add(texture);

    // Update the sampling settings of the texture atlas
    let image = textures.get_mut(&texture).unwrap();
    image.sampler = sampling.unwrap_or_default();

    (texture_atlas_layout, texture)
}

pub fn padding(self, padding: UVec2) -> TextureAtlasBuilder<'a>

Sets the amount of padding in pixels to add between the textures in the texture atlas.

The x value provide will be added to the right edge, while the y value will be added to the bottom edge.

Examples found in repository

examples/2d/texture_atlas.rs (line 211)

fn create_texture_atlas(
    folder: &LoadedFolder,
    padding: Option<UVec2>,
    sampling: Option<ImageSampler>,
    textures: &mut ResMut<Assets<Image>>,
) -> (TextureAtlasLayout, Handle<Image>) {
    // Build a texture atlas using the individual sprites
    let mut texture_atlas_builder =
        TextureAtlasBuilder::default().padding(padding.unwrap_or_default());
    for handle in folder.handles.iter() {
        let id = handle.id().typed_unchecked::<Image>();
        let Some(texture) = textures.get(id) else {
            warn!(
                "{:?} did not resolve to an `Image` asset.",
                handle.path().unwrap()
            );
            continue;
        };

        texture_atlas_builder.add_texture(Some(id), texture);
    }

    let (texture_atlas_layout, texture) = texture_atlas_builder.finish().unwrap();
    let texture = textures.add(texture);

    // Update the sampling settings of the texture atlas
    let image = textures.get_mut(&texture).unwrap();
    image.sampler = sampling.unwrap_or_default();

    (texture_atlas_layout, texture)
}

pub fn finish( self ) -> Result<(TextureAtlasLayout, Image), TextureAtlasBuilderError>

Consumes the builder, and returns the newly created texture atlas and the associated atlas layout.

Assigns indices to the textures based on the insertion order. Internally it copies all rectangles from the textures and copies them into a new texture.

Usage

fn my_system(mut commands: Commands, mut textures: ResMut<Assets<Image>>, mut layouts: ResMut<Assets<TextureAtlasLayout>>) {
    // Declare your builder
    let mut builder = TextureAtlasBuilder::default();
    // Customize it
    // ...
    // Build your texture and the atlas layout
    let (atlas_layout, texture) = builder.finish().unwrap();
    let texture = textures.add(texture);
    let layout = layouts.add(atlas_layout);
    // Spawn your sprite
    commands.spawn((
        SpriteBundle { texture, ..Default::default() },
        TextureAtlas::from(layout),
    ));
}

Errors

If there is not enough space in the atlas texture, an error will be returned. It is then recommended to make a larger sprite sheet.

Examples found in repository

examples/2d/texture_atlas.rs (line 225)

fn create_texture_atlas(
    folder: &LoadedFolder,
    padding: Option<UVec2>,
    sampling: Option<ImageSampler>,
    textures: &mut ResMut<Assets<Image>>,
) -> (TextureAtlasLayout, Handle<Image>) {
    // Build a texture atlas using the individual sprites
    let mut texture_atlas_builder =
        TextureAtlasBuilder::default().padding(padding.unwrap_or_default());
    for handle in folder.handles.iter() {
        let id = handle.id().typed_unchecked::<Image>();
        let Some(texture) = textures.get(id) else {
            warn!(
                "{:?} did not resolve to an `Image` asset.",
                handle.path().unwrap()
            );
            continue;
        };

        texture_atlas_builder.add_texture(Some(id), texture);
    }

    let (texture_atlas_layout, texture) = texture_atlas_builder.finish().unwrap();
    let texture = textures.add(texture);

    // Update the sampling settings of the texture atlas
    let image = textures.get_mut(&texture).unwrap();
    image.sampler = sampling.unwrap_or_default();

    (texture_atlas_layout, texture)
}

Trait Implementations

impl<'a> Debug for TextureAtlasBuilder<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for TextureAtlasBuilder<'_>

fn default() -> TextureAtlasBuilder<'_>

Returns the “default value” for a type.