How to assign sprites to custom game objects without messing up lifetimes?

[Mambouna]

Hi, since the introductions used meta sprites and the concept seemed useful, I thought it would be a good idea to create my own custom MetaSprite struct to make working with them more generic. I ran into issues with lifetimes however, when trying to save references to sprites in the struct members, finally using this which worked at first to satisfy the compiler:

pub struct MetaSprite<'a> {
    pos: Vector2D<Fixed>,
    hflip: bool,
    vflip: bool,
    priority: Priority,
    sprites: Vec<(&'a Sprite, Vector2D<i32>, (bool, bool))>,
    total_size: Vector2D<i32>,
}

The only problem now shows up when I try to show the MetaSprite:

    pub fn show(&self, frame: &mut GraphicsFrame) {
        for (sprite, offset, flip_bools) in &self.sprites {
            let sprite_size = sprite.size().to_width_height();
            let mut flip_offset: Vector2D<i32> = vec2(0, 0);
            if self.hflip { flip_offset.x = self.total_size.x - sprite_size.0 as i32 };
            if self.vflip { flip_offset.y = self.total_size.y - sprite_size.1 as i32 };
            Object::new(*sprite)     // <- error occurs here
                .set_pos(self.pos.round() + *offset - flip_offset)
                .set_hflip(flip_bools.0 != self.hflip)
                .set_vflip(flip_bools.1 != self.vflip)
                .set_priority(self.priority)
                .show(frame);
        }
    }

Here, I always get the following error: error[E0521]: borrowed data escapes outside of method with the following explanation: "self escapes the method body here, argument requires that 'a must outlive 'static".

I can somewhat follow the error, but I can't come up with a solution. If I don't dereference the sprite, then the argument throws an error on the new() function for objects, but if I do, I get the error about escaping the lifetime. I thought about trying to give more generous lifetimes for what I pass in, but I can't do that, since the sprites are defined by the include_aseprite macro which I don't control directly.

My understanding of lifetimes is admittedly not good, so maybe I'm missing something obvious. Should I go about this a whole different way? Did I just miss some detail of where else to annotate another lifetime or something like that? Any help or advice how to approach this differently would be appreciated.

EDIT: Just as an example of how the meta sprite is ultimately created:

    let mut sel_marker = MetaSprite::new(
        vec!(
            (sprites::MARKER.sprite(0), vec2(0, 0), (false, false)),
            (sprites::MARKER.sprite(0), vec2(32, 0), (false, false)),
            (sprites::MARKER.sprite(0), vec2(64, 0), (false, false)),
        ),
        vec2(96, 8)
    );

[corwinkuiper]

Clone the sprite. In your meta sprite, I would also avoid using sprite references and instead used owned sprites.

We reference count sprites, so cloning is cheap and doesn't use more vram.

[Mambouna]

Thanks for the reply! I was worried cloning would be resource intensive so didn't want to use it on the GBA. If I may ask, have you gone the same route for everything or are there any agb specific things I shouldn't clone because of the aforementioned worry.

[Mambouna]

Clone the sprite.

Okay I just tried this and I couldn't figure out how. Sprite doesn't seem to implement .clone() (it gave me an error and the crate documentation for agb doesn't list clone for Sprite either), so I thought maybe I have to directly use SpriteVram, which does, but that can't be passed to Object::new() as it gives an error too.

Which kind of sprite do you mean I should clone and how? I thought you meant this: sprites::MARKER.sprite(0).clone().

[corwinkuiper]

My apologies, I thought you had SpriteVrams for some reason.

You should be able to use 'static references to sprites. The sprite method you're using gives a Sprite with the static lifetime: https://docs.rs/agb/latest/agb/display/object/struct.Tag.html#method.sprite

You don't want to make copies of the Sprite data itself, which is why we don't let it happen.

Object::new accepts Into<SpriteVram>, which includes SpriteVram, but that's an aside.

[corwinkuiper]

You can if you want not use a Vec.

#![no_std]
#![no_main]

use agb::{
    display::{
        GraphicsFrame, Rgb15,
        object::{Object, Sprite},
        tiled::VRAM_MANAGER,
    },
    fixnum::{vec2, Vector2D},
    include_aseprite,
};

include_aseprite!(mod sprites,
    "examples/gfx/crab.aseprite",
);

struct MetaSpriteElement {
    offset: Vector2D<i32>,
    sprite: &'static Sprite,
}

const fn mse(sprite: &'static Sprite, offset: Vector2D<i32>) -> MetaSpriteElement {
    MetaSpriteElement {
        sprite,
        offset,
    }
}

struct MetaSprite {
    sprites: &'static [MetaSpriteElement],
    pos: Vector2D<i32>,
}

impl MetaSprite {
    fn show(&self, frame: &mut GraphicsFrame) {
        for &MetaSpriteElement { offset, sprite } in self.sprites {
            Object::new(sprite).set_pos(self.pos + offset).show(frame);
        }
    }
}

#[agb::entry]
fn main(mut gba: agb::Gba) -> ! {
    VRAM_MANAGER.set_background_palette_colour(0, 0, Rgb15::WHITE);
    
    let mut a = MetaSprite {
        pos: vec2(0, 0),
        sprites: const { &[mse(sprites::IDLE.sprite(0), vec2(0, 0))]}
    };

    let mut b = MetaSprite {
        pos: vec2(100, 0),
        sprites: const {&[
            mse(sprites::IDLE.sprite(0), vec2(0, 0)),
            mse(sprites::IDLE.sprite(0), vec2(0, 16)),
        ]},
    };

    let mut gfx = gba.graphics.get();

    loop {
        let mut frame = gfx.frame();
        a.show(&mut frame);
        b.show(&mut frame);

        frame.commit();
    }
}

[Mambouna]

You should be able to use 'static references to sprites. The sprite method you're using gives a Sprite with the static lifetime: https://docs.rs/agb/latest/agb/display/object/struct.Tag.html#method.sprite

Yes, this worked! I also took your advice and example and reworked the code not to use Vec but just for the purposes of answering the original question, I really just needed to pass the references with the 'static lifetime. Well, my weakpoint in rust is showing. Thanks for the in-depth help and the nice example as well.