Get sprite sizes

[HotSammiches]

What is the best way to get the size of a sprite once it's been loaded? For example, once I have a sprite_bundle with a given transform how can I get the sprite's x and y sizes? Sorry if this is a silly question - I haven't been able to figure it out and I really don't want to have to manually enter the size of every sprite (which would be necessary for things like collision detection).

[hymm]

you can get it from the Sprite Component https://docs.rs/bevy/0.5.0/bevy/prelude/struct.Sprite.html

[HotSammiches]

I tried that, but when I did both the x and y came back as 0. Does it have to be after spawn_bundle is called?

[hymm]

yeah. Some system fills in the values after the bundle is spawned.

[SecretPocketCat]

I believe you should be able to get the size from the texture (well, the texture handle) after it's been loaded.

[The-DevBlog]

Can you provide some code for what you are trying to accomplish?

[The-DevBlog]

And if you would like to get the info from an individual frame, you could create a struct that holds the amount of columns and rows for a spritesheet, and then insert that to any entity you need to be able to get the single frame size.

struct SpriteSheetGrid 
{
    rows: u32,
    columns: u32
}

From here it would be some simple math to get a single frame.

[HotSammiches]

Yeah, I figured I could get it from a query after it was spawned but I was wondering if there was a way to do it in the same function where the sprite was spawned. I'm super new to Bevy and new to Rust so I'm still trying to learn the right mindset to make the best use of them both.

[The-DevBlog]

In that case, maybe create a struct to store the sprite sizes in and then insert that component/struct into your newly created entity and then you can query for that entity's component anywhere.

eg:

struct SpriteSize 
{
    height: f32,
    width: f32,
}

struct Player;

fn spawn_player(mut commands: Commands)
{
    let sprite_bundle = SpriteBundle {
        sprite: Sprite::new(Vec2::new(10.0, 10.0)),
        ..Default::default()
    };

    let sprite_size = SpriteSize {
        height: sprite_bundle.sprite.size.x,
        width: sprite_bundle.sprite.size.y  
    };

    commands.spawn_bundle(sprite_bundle).insert(Player).insert(sprite_size);
}
    

This way would make it easier to just query for the new struct SpriteSize like so:

fn my_function(
    mut query: Query<(&SpriteSize, With<Player>)>
) 
{
    if let Ok((sprite_size, _player)) = query.single_mut() {
        let sprite_width = sprite_size.width;
        let sprite_height = sprite_size.height;

        // do something
    }
}

Either way you are still querying. I'm not aware of another way you would retrieve that kind of info.

[hymm]

The problem in the first snippet @HotSammiches posted is that assets are loaded asynchronously.
So when you run let texture_handle = asset_server.load(PLAYER_SPRITE);. This is just telling the asset server to start loading the asset. I think if you waited for the asset to be loaded, before running your spawning code you'd be able to get the sprite size.

For reference see https://bevy-cheatbook.github.io/cookbook/assets-ready.html

[HotSammiches]

I found another wrinkle here as I'm working on this problem. I call the startup_systems which load the assets and spawn the bundles and then call another system in StartupStage::PostStartup to update the global vector of collision boxes. I can't seem to figure out how to get the components which contain both a sprite and a CollisionBox component (one of my custom component types). Here's an example with the player sprite. First I call the routine which spawns the player bundle and inserts the collision box.

fn setup_player(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
) {
    let texture_handle = asset_server.load(PLAYER_SPRITE);
    let texture_atlas = TextureAtlas::from_grid(
        texture_handle,
        Vec2::new(PLAYER_SPRITE_TILE_SIZE_X, PLAYER_SPRITE_TILE_SIZE_Y),
        PLAYER_SPRITE_TILE_COLS,
        PLAYER_SPRITE_TILE_ROWS,
    );
    let texture_atlas_handle = texture_atlases.add(texture_atlas);

    commands
        .spawn_bundle(SpriteSheetBundle {
            texture_atlas: texture_atlas_handle,
            transform: Transform {
                scale: Vec3::splat(6.),
                rotation: Quat::from_rotation_x(0.),
                translation: Vec3::new(0., 0., 1.),
            },
            ..Default::default()
        })
        .insert(CollisionBox {
            ..Default::default()
        });
}

Then in the PostStartup function I run a query to find components with both a CollisionBox and a Transform. That function looks like this:

fn find_collision_boxen_with_transform(query: Query<(&CollisionBox, &Transform)>) {
    for (cb, sp) in query.iter() {
        println!("Found it!");
    }
}

This yields what I want - I get two lines printed since there are two entities with collision boxes I spawn right now. This is all fine. The problem is if I run a query on Sprite instead of Transform like this:

fn find_collision_boxen_with_sprite(query: Query<(&CollisionBox, &Sprite)>) {
    for (cb, sp) in query.iter() {
        println!("Found it!");
    }
}

This doesn't print anything. What am I missing?