Determining the size of a sprite in Bevy 0.6+

[rparrett]

Is there a convenient way in Bevy 0.6+ to determine the size of a sprite after its creation? I'm using the term "sprite" generically here to refer to any SpriteBundle, textured or untextured, with or without custom_size.

Prior to Bevy 0.6, one would control the size of an untextured sprite through the sprite's size field, and this field was also updated automatically by sprite_system when textures were used.

The only collision detection we show in our examples uses "sprite size" and users are often learning by building up from our examples, and a common sticking point is colliding one "sprite type" with another. If a user also needs the size of a SpriteSheetBundle, that's another can of worms I'll skip over for now.

This is what is currently required to robustly determine the size of a SpriteBundle:

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_startup_system(setup)
        .add_system(print_size)
        .run();
}

fn print_size(
    query: Query<(&Sprite, &Transform, Option<&Handle<Image>>)>,
    images: Res<Assets<Image>>,
) {
    info!("sizes:");

    for (sprite, transform, maybe_handle) in query.iter() {
        let size = if let Some(custom_size) = sprite.custom_size {
            custom_size
        } else if let Some(image) = maybe_handle.and_then(|handle| images.get(handle)) {
            image.size()
        } else {
            Vec2::new(1.0, 1.0)
        };

        info!("{:?}", size * transform.scale.truncate());
    }
}

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn_bundle(Camera2dBundle::default());

    // A plain textured sprite as in the example
    // 2d/sprite.rs
    commands.spawn_bundle(SpriteBundle {
        texture: asset_server.load("branding/icon.png"),
        ..Default::default()
    });

    // A textured sprite with a custom_size as in the example
    // games/contributors.rs
    commands.spawn_bundle(SpriteBundle {
        transform: Transform::from_xyz(0.0, 150.0, 0.0),
        sprite: Sprite {
            custom_size: Some(Vec2::new(50.0, 50.0)),
            ..Default::default()
        },
        texture: asset_server.load("branding/icon.png"),
        ..Default::default()
    });

    // A textureless sprite with a `custom_size`, as in the example
    // 2d/rect.rs
    commands.spawn_bundle(SpriteBundle {
        transform: Transform::from_xyz(0.0, 225.0, 0.0),
        sprite: Sprite {
            color: Color::rgb(0.25, 0.25, 0.75),
            custom_size: Some(Vec2::new(50.0, 50.0)),
            ..Default::default()
        },
        ..Default::default()
    });

    // A scaled textureless sprite as in the example
    // game/breakout.rs
    commands.spawn_bundle(SpriteBundle {
        transform: Transform {
            translation: Vec3::new(0.0, 300.0, 0.0),
            scale: Vec3::new(50.0, 50.0, 0.0),
            ..Default::default()
        },
        sprite: Sprite {
            color: Color::rgb(0.5, 0.5, 1.0),
            ..Default::default()
        },
        ..Default::default()
    });
}

[PaperCow]

There is this comment on Image:
// TODO: this nesting makes accessing Image metadata verbose. Either flatten out descriptor or add accessors

Assuming there isn't an easier way we are just missing then at a minimum an accessor to get the size from Image would make this feel a lot less gross. I imagine that is going to be one of the most common reasons people are drilling down into texture_descriptor.