agb 0.23.1

Library for Game Boy Advance Development
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use core::{alloc::Allocator, ptr::NonNull};

use crate::{
    ExternalAllocator,
    agb_alloc::{
        block_allocator::BlockAllocator, bump_allocator::StartEnd, impl_zst_allocator,
        single_allocator::create_allocator_arena,
    },
    display::object::{Size, Sprite, sprites::BYTES_PER_TILE_4BPP},
    refcount::{RefCount, RefCountInner},
};

use super::{LoaderError, palette::PaletteVram};

pub const TILE_SPRITE: usize = 0x06010000;

static SPRITE_ALLOCATOR: BlockAllocator = unsafe {
    BlockAllocator::new(StartEnd {
        start: || TILE_SPRITE,
        end: || TILE_SPRITE + 1024 * 8 * 4,
    })
};

pub struct SpriteAllocator;

impl_zst_allocator!(SpriteAllocator, SPRITE_ALLOCATOR);

create_allocator_arena!(
    SpriteArena,
    ExternalAllocator,
    RefCountInner<SpriteVramData>
);

/// A sprite that is currently loaded into vram.
///
/// This is referenced counted such that clones of this are cheap and can be
/// reused between objects. When nothing references the sprite it gets
/// deallocated from vram.
///
/// You can create one of these by:
/// * [DynamicSprite16][super::DynamicSprite16] or [DynamicSprite256][super::DynamicSprite256], which allows you to generate sprites at run time,
/// * The [From<&'static Sprite] implementation which deduplicates uses of the same sprite.
#[derive(Clone, Debug)]
pub struct SpriteVram {
    sprite: SpriteVramInner,
    palette: PaletteVram,
}

impl SpriteVram {
    #[must_use]
    pub(crate) fn new(sprite: SpriteVramInner, palette: PaletteVram) -> Self {
        Self { sprite, palette }
    }

    #[must_use]
    pub(crate) fn location(&self) -> SpriteLocation {
        self.sprite.0.sprite_index
    }

    #[must_use]
    pub(crate) fn size(&self) -> Size {
        self.sprite.0.size
    }

    #[must_use]
    pub(crate) fn single_palette_index(&self) -> Option<u8> {
        self.palette.single_palette_index()
    }
}

#[derive(Debug, Clone, Copy)]
pub struct SpriteLocation(u16);

impl SpriteLocation {
    pub fn from_ptr(ptr: NonNull<u8>) -> Self {
        Self((((ptr.as_ptr() as usize) - TILE_SPRITE) / BYTES_PER_TILE_4BPP) as u16)
    }

    pub fn to_ptr(self) -> NonNull<u8> {
        unsafe {
            NonNull::new_unchecked((self.0 as usize * BYTES_PER_TILE_4BPP + TILE_SPRITE) as *mut u8)
        }
    }

    pub(crate) fn idx(self) -> u16 {
        self.0
    }
}

#[derive(Debug)]
#[repr(align(4))]
struct SpriteVramData {
    sprite_index: SpriteLocation,
    size: Size,
    multi_palette: bool,
}

#[derive(Clone, Debug)]
pub struct SpriteVramInner(RefCount<SpriteVramData, SpriteArena>);

impl SpriteVramInner {
    pub fn strong_count(&self) -> usize {
        RefCount::count(&self.0)
    }

    pub fn new(data: &[u8], size: Size, multi: bool) -> Result<SpriteVramInner, LoaderError> {
        let allocated =
            unsafe { SPRITE_ALLOCATOR.alloc(size.layout(multi)) }.ok_or(LoaderError::SpriteFull)?;
        unsafe {
            allocated
                .as_ptr()
                .copy_from_nonoverlapping(data.as_ptr(), data.len());
        }

        Ok(SpriteVramInner(RefCount::new_in(
            SpriteVramData {
                sprite_index: SpriteLocation::from_ptr(allocated),
                multi_palette: multi,
                size,
            },
            SpriteArena,
        )))
    }

    pub fn new_from_sprite(sprite: &Sprite) -> Result<SpriteVramInner, LoaderError> {
        Self::new(sprite.data, sprite.size, sprite.palette.is_multi())
    }

    pub unsafe fn new_from_allocated(
        sprite_index: SpriteLocation,
        size: Size,
        multi_palette: bool,
    ) -> Self {
        SpriteVramInner(RefCount::new_in(
            SpriteVramData {
                sprite_index,
                size,
                multi_palette,
            },
            SpriteArena,
        ))
    }
}

impl Drop for SpriteVramData {
    fn drop(&mut self) {
        unsafe {
            SPRITE_ALLOCATOR.dealloc(
                self.sprite_index.to_ptr().as_ptr(),
                self.size.layout(self.multi_palette),
            );
        }
    }
}