Ran out of video RAM for tiles

[Drako]

So I am not sure, if this is a bug in agb or if I'm doing something wrong.

so right now I basically have a game scene, where I load my map at the beginning in tiled0. I'm using the background P3 and P2. both layers share the same tileset, but use different tiles of it.
so far this works. but when that scene finishes (right now that happens immediatly, but would usually happen when the player dies)
I loop back into the main menu.

my main menu has this special thing, that it doesn't do anything with background at all.
when first run, you still see the background that was previously set by the title screen.
and after looping back from the actual game, you still see the map in the background.

so far as expected.

now comes the funny thing: if I choose "new game" again, again the expected stuff happens. the game starts, does some stuff, and loops back to the main menu.
BUT: after doing that several times (choosing new game, watching it do its thing, and coming back to the main menu), at some point MGBA crashes with the message, that VRAM ran out of memory for tiles.

when I checked the tile window of mgba during a test run, I noticed, that it would add another full set of tiles to the vram on every run of the game scene function.
this kinda confuses me. I would expect one of two things to happen:
1.: because I reset the background at the start of the main game, I would expect the tiles to be cleared and reloaded
2.: because I actually keep using the same tiles, I would expect agbrs to just not load them again

in both cases the error I'm seeing would not happen. so I'm a bit confused, what's going on

[Drako]

Code for context:

/// Display the game.
/// Returns how the game ended and the duration this scene took in number of frames (useful for seeding random numbers).
pub fn game_scene(ctx: Context) -> (GameResult, usize) {
    let (video, mut vram) = ctx.gba.display.video.tiled0();
    let mut frame: usize = 0;

    let mut palettes = [
        DEFAULT_BACKGROUND.palettes[0].clone(),
        DEFAULT_BACKGROUND.palettes[0].clone(),
    ];
    for c in 1..10 {
        palettes[0].update_colour(c, GRASS_GREEN.to_u16());
    }

    let format = DEFAULT_BACKGROUND.tileset.tiles.format();
    let mut bg = [
        video.background(Priority::P3, RegularBackgroundSize::Background64x64, format),
        video.background(Priority::P2, RegularBackgroundSize::Background64x64, format),
    ];
    for y in 0..64 {
        for x in 0..64 {
            let position = Vector2D::new(x, y);
            let index = (y * 64 + x) as usize;
            for layer in 0..2 {
                let tile = DEFAULT_BACKGROUND.layers[layer][index];
                if tile > 0 {
                    bg[layer].set_tile(
                        &mut vram,
                        position,
                        &DEFAULT_BACKGROUND.tileset.tiles,
                        DEFAULT_BACKGROUND.tileset.tile_settings[(tile - 1) as usize],
                    );
                }
            }
        }
    }

    ctx.vblank.wait_for_vblank();
    frame = frame.wrapping_add(1);
    vram.set_background_palettes(&palettes);
    for layer in 0..2 {
        bg[layer].set_scroll_pos(map_to_scroll(Vector2D::new(32 * 8, 32 * 8)));
        bg[layer].set_visible(true);
        bg[layer].commit(&mut vram);
    }

    // fade from menu green to actual palette
    for n in 1..64 {
        for c in 1..10 {
            palettes[0].update_colour(c, Colour::interpolate(GRASS_GREEN, Colour::from(palettes[1].colour(c)), (n * 4 - 1) as u8).to_u16());
        }
        ctx.vblank.wait_for_vblank();
        frame = frame.wrapping_add(1);
        vram.set_background_palettes(&palettes);
    }

    (GameResult::GameOver { points: 0 }, frame)
}

[Drako]

Hello and thanks for the quick response.

I was actually looking for something like the .clear function on the backgrounds, but didn't find it.
(to be fair, I was looking for something like vram.clear() which seems more intuitive, but does not exist,
but I also understand why that would clash with other things)
But I was actually also expecting MapLoan to automatically do something like that, which it apparently doesn't.

anyway, I applied your first suggestion and called .clear on every single background I created before leaving each scope,
but the behaviour stays exactly the same as before. (see Video)
As can be seen in the video, not even the initial logo is removed from vram.

As for reusing the backgrounds and adding them to the context:
This comes with its own theoretical issues, I don't have right now, but which others might face.
Basically if you have different parts of the game, where the format for the background changes,
or where you switch between modes (tiled0, tiled1, ...) you'd still run into this problem.
But actually in these cases the problem might not exist, as switching parameters of the backgrounds might actually wipe the memory, I don't know.

Anyway trying to apply your second suggestion I run into a lot of

cannot borrow gba as mutable more than once at a time

which I still need to figure out how to work around.

Like to be honest, I occasionally really struggle with Rust's lifetime and borrow checking specifically with agb,

[Drako]

For me the only way to not run into the mutable borrow issue seems, to not have the Gba reference in the context,
but to only put the inherited things into it.
This yields other problems though, as I use OamManaged for most things right now,
but as I want to use the ObjectTextRenderer in the actual game for dialogs, and that one requires OamUnmanaged, I am not sure, if I can provide both at the same time. I don't think so.

[Drako]

In a past version of my game, I was actually trying to have something like

// simplified example
pub struct Engine {
  gba: Gba,
  bg: MapLoan<RegularMap>,
}

impl Engine {
  pub fn new(mut gba: Gba) -> Self {
   // ...
  }
}

This does not work, because the MapLoan still wants some kind of lifetime. But which one?

This does also not work, because Rust complains, that Engine might not live long enough:

// simplified example
pub struct Engine<'gba> {
  gba: &'gba mut Gba,
  bg: MapLoan<'gba, RegularMap>,
}

impl<'gba> Engine<'gba> {
  pub fn new(gba: &'gba mut Gba) -> Self {
   // ...
  }
}

And this was even worse:

// simplified example
pub struct Engine<'gba, 'engine> {
  gba: &'gba mut Gba,
  bg: MapLoan<'engine, RegularMap>,
}

impl<'gba, 'engine> Engine<'gba, 'engine> {
  pub fn new(gba: &'gba mut Gba) -> Self {
   // ...
  }
}

So I just found no way to have both in the same structure, which led me to recreate the backgrounds in every function in the first place.
I am facing the same difficulties with Context again now.

[Drako]

I also don't see how RefCell could help here, because while the MapLoans are alive, the ref cell would be constantly in borrowed state,
and so calling borrow_mut later to do something directly with gba would just result in runtime errors.

[Drako]

On a side note I also find the current agb API nedlessly restrictive in certain areas.
Why is it, that I can't ask a TileSetting for its tile id, palette id or whether it is flipped or not?
Why is it "write-only" and the only getters are internal?

It is written in a way, that it seems very much intentional, but I don't understand why one would restrict it like that.