Struct agb::display::video::Video

#[non_exhaustive]
pub struct Video;

The video struct controls access to the video hardware. It ensures that only one video mode is active at a time.

Most games will use tiled modes, as bitmap modes are too slow to run at the full 60 FPS.

Implementations

impl Video

pub fn bitmap3(&mut self) -> Bitmap3<'_>

Bitmap mode that provides a 16-bit colour framebuffer

pub fn bitmap4(&mut self) -> Bitmap4<'_>

Bitmap 4 provides two 8-bit paletted framebuffers with page switching

pub fn tiled0(&mut self) -> (Tiled0<'_>, VRamManager)

Tiled 0 mode provides 4 regular, tiled backgrounds

Examples found in repository

examples/windows.rs (line 19)

fn main(mut gba: agb::Gba) -> ! {
    let (gfx, mut vram) = gba.display.video.tiled0();

    let mut map = gfx.background(
        agb::display::Priority::P0,
        RegularBackgroundSize::Background32x32,
        TileFormat::FourBpp,
    );
    let mut window = gba.display.window.get();
    window
        .win_in(WinIn::Win0)
        .set_background_enable(map.background(), true)
        .set_position(&Rect::new((10, 10).into(), (64, 64).into()))
        .enable();

    window
        .win_out()
        .enable()
        .set_background_enable(map.background(), true)
        .set_blend_enable(true);

    example_logo::display_logo(&mut map, &mut vram);

    let mut blend = gba.display.blend.get();

    blend
        .set_background_enable(Layer::Top, map.background(), true)
        .set_backdrop_enable(Layer::Bottom, true)
        .set_blend_mode(BlendMode::Normal);

    let mut pos: Vector2D<FNum> = (10, 10).into();
    let mut velocity: Vector2D<FNum> = Vector2D::new(1.into(), 1.into());

    let mut blend_amount: Num<i32, 8> = num!(0.5);
    let mut blend_velocity: Num<i32, 8> = Num::new(1) / 128;

    let vblank = VBlank::get();

    loop {
        pos += velocity;

        if pos.x.floor() > WIDTH - 64 || pos.x.floor() < 0 {
            velocity.x *= -1;
        }

        if pos.y.floor() > HEIGHT - 64 || pos.y.floor() < 0 {
            velocity.y *= -1;
        }

        blend_amount += blend_velocity;
        if blend_amount > num!(0.75) || blend_amount < num!(0.25) {
            blend_velocity *= -1;
        }

        blend_amount = blend_amount.clamp(0.into(), 1.into());

        blend.set_blend_weight(Layer::Top, blend_amount.try_change_base().unwrap());

        window
            .win_in(WinIn::Win0)
            .set_position(&Rect::new(pos.floor(), (64, 64).into()));

        vblank.wait_for_vblank();
        window.commit();
        blend.commit();
    }
}

pub fn tiled1(&mut self) -> (Tiled1<'_>, VRamManager)

Tiled 1 mode provides 2 regular tiled backgrounds and 1 affine tiled background

pub fn tiled2(&mut self) -> (Tiled2<'_>, VRamManager)

Tiled 2 mode provides 2 affine tiled backgrounds