Merge pull request #116 from corwinkuiper/nice-objects

Sane Objects!

agb/src/arena.rs

@@ -0,0 +1,117 @@
+use core::cell::RefCell;
+
+type Index = u8;
+
+pub struct Loan<'a, const S: usize> {
+    pub my_index: Index,
+    arena: &'a RefCell<ArenaInner<S>>,
+}
+
+#[derive(Debug)]
+struct ArenaInner<const S: usize> {
+    arena: [Index; S],
+    first: Index,
+}
+
+pub struct Arena<const S: usize> {
+    arena_inner: RefCell<ArenaInner<S>>,
+}
+
+impl<const S: usize> Arena<S> {
+    pub fn new() -> Arena<S> {
+        // we use the special value u8::MAX as a None
+        assert!(S < u8::MAX as usize - 1);
+
+        let mut arena: [u8; S] = [u8::MAX; S];
+        arena
+            .iter_mut()
+            .enumerate()
+            .for_each(|(idx, a)| *a = idx as Index + 1);
+
+        if let Some(a) = arena.last_mut() {
+            *a = u8::MAX;
+        }
+
+        Arena {
+            arena_inner: RefCell::new(ArenaInner { arena, first: 0 }),
+        }
+    }
+
+    pub fn get_next_free(&self) -> Option<Loan<S>> {
+        let mut arena = self.arena_inner.borrow_mut();
+        let i = arena.first;
+        if i == u8::MAX {
+            return None;
+        }
+        arena.first = arena.arena[i as usize];
+
+        arena.arena[i as usize] = 1;
+        Some(Loan {
+            my_index: i,
+            arena: &self.arena_inner,
+        })
+    }
+}
+
+impl<const S: usize> Drop for Loan<'_, S> {
+    fn drop(&mut self) {
+        let mut arena = self.arena.borrow_mut();
+        let mut me = arena.arena[self.my_index as usize];
+
+        me -= 1;
+        if me == 0 {
+            arena.arena[self.my_index as usize] = arena.first;
+            arena.first = self.my_index;
+        } else {
+            arena.arena[self.my_index as usize] = me;
+        }
+    }
+}
+
+impl<const S: usize> Clone for Loan<'_, S> {
+    fn clone(&self) -> Self {
+        self.arena.borrow_mut().arena[self.my_index as usize] += 1;
+
+        Loan {
+            my_index: self.my_index,
+            arena: self.arena,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test_case]
+    fn get_everything(_gba: &mut crate::Gba) {
+        let s: Arena<4> = Arena::new();
+        {
+            let c = alloc::vec![s.get_next_free(), s.get_next_free()];
+            c.iter()
+                .enumerate()
+                .for_each(|(i, a)| assert!(a.is_some(), "expected index {} is some", i));
+        }
+        {
+            let c = alloc::vec![
+                s.get_next_free(),
+                s.get_next_free(),
+                s.get_next_free(),
+                s.get_next_free()
+            ];
+            c.iter().for_each(|a| assert!(a.is_some()));
+            assert!(s.get_next_free().is_none());
+        }
+        {
+            let c = alloc::vec![
+                s.get_next_free(),
+                s.get_next_free(),
+                s.get_next_free(),
+                s.get_next_free()
+            ];
+            c.iter().for_each(|a| assert!(a.is_some()));
+            assert!(s.get_next_free().is_none());
+        }
+    }
+}

agb/src/display/object.rs

@@ -5,6 +5,9 @@ use crate::bitarray::Bitarray;
 use crate::memory_mapped::MemoryMapped1DArray;
 use crate::number::Vector2D;
 
+type AffineLoan<'a> = crate::arena::Loan<'a, 32>;
+type AffineArena = crate::arena::Arena<32>;
+
 const OBJECT_ATTRIBUTE_MEMORY: MemoryMapped1DArray<u16, 512> =
     unsafe { MemoryMapped1DArray::new(0x0700_0000) };
 const PALETTE_SPRITE: MemoryMapped1DArray<u16, 256> =
@@ -15,7 +18,7 @@ const TILE_SPRITE: MemoryMapped1DArray<u32, { 512 * 8 }> =
 /// Handles distributing objects and matricies along with operations that effect all objects.
 pub struct ObjectControl {
     objects: RefCell<Bitarray<4>>,
-    affines: RefCell<Bitarray<1>>,
+    affines: AffineArena,
 }
 
 struct ObjectLoan<'a> {
@@ -23,11 +26,6 @@ struct ObjectLoan<'a> {
     objects: &'a RefCell<Bitarray<4>>,
 }
 
-struct AffineLoan<'a> {
-    index: u8,
-    affines: &'a RefCell<Bitarray<1>>,
-}
-
 /// The standard object, without rotation.
 pub struct ObjectStandard<'a> {
     attributes: ObjectAttribute,
@@ -39,7 +37,7 @@ pub struct ObjectStandard<'a> {
 pub struct ObjectAffine<'a> {
     attributes: ObjectAttribute,
     loan: ObjectLoan<'a>,
-    aff_id: Option<u8>,
+    aff_loan: Option<AffineLoan<'a>>,
 }
 
 /// Refers to an affine matrix in the OAM. Includes both an index and the
@@ -161,7 +159,7 @@ impl<'a> ObjectAffine<'a> {
 
     /// Show the object on screen. Panics if affine matrix has not been set.
     pub fn show(&mut self) {
-        if self.aff_id.is_none() {
+        if self.aff_loan.is_none() {
             panic!("affine matrix should be set")
         }
         self.attributes.set_mode(Mode::Affine)
@@ -170,11 +168,12 @@ impl<'a> ObjectAffine<'a> {
     pub fn hide(&mut self) {
         self.attributes.set_mode(Mode::Hidden)
     }
+
     /// Sets the affine matrix to use. Changing the affine matrix will change
     /// how the sprite is rendered.
-    pub fn set_affine_mat(&mut self, aff: &AffineMatrix) {
-        self.attributes.set_affine(aff.loan.index);
-        self.aff_id = Some(aff.loan.index);
+    pub fn set_affine_mat(&mut self, aff: &AffineMatrix<'a>) {
+        self.attributes.set_affine(aff.loan.my_index);
+        self.aff_loan = Some(aff.loan.clone());
     }
 
     /// Sets the x and y position of the object, performing casts as nessesary
@@ -207,22 +206,6 @@ impl Drop for ObjectLoan<'_> {
     }
 }
 
-impl Drop for AffineLoan<'_> {
-    fn drop(&mut self) {
-        let attributes = AffineMatrixAttributes {
-            p_a: 0,
-            p_b: 0,
-            p_c: 0,
-            p_d: 0,
-        };
-        unsafe {
-            attributes.commit(self.index);
-        }
-        let mut affs = self.affines.borrow_mut();
-        affs.set(self.index as usize, false);
-    }
-}
-
 struct ObjectAttribute {
     a0: u16,
     a1: u16,
@@ -276,7 +259,7 @@ impl ObjectAttribute {
 impl AffineMatrix<'_> {
     /// Commits matrix to OAM, will cause any objects using this matrix to be updated.
     pub fn commit(&self) {
-        unsafe { self.attributes.commit(self.loan.index) };
+        unsafe { self.attributes.commit(self.loan.my_index) };
     }
 }
 
@@ -311,7 +294,7 @@ impl ObjectControl {
         }
         ObjectControl {
             objects: RefCell::new(Bitarray::new()),
-            affines: RefCell::new(Bitarray::new()),
+            affines: AffineArena::new(),
         }
     }
 
@@ -373,17 +356,6 @@ impl ObjectControl {
         panic!("object id must be less than 128");
     }
 
-    fn get_unused_affine_index(&self) -> u8 {
-        let mut affines = self.affines.borrow_mut();
-        for index in 0..32 {
-            if !affines.get(index).unwrap() {
-                affines.set(index, true);
-                return index as u8;
-            }
-        }
-        panic!("affine id must be less than 32");
-    }
-
     /// Get an unused standard object. Panics if more than 128 objects are
     /// obtained.
     pub fn get_object_standard(&self) -> ObjectStandard {
@@ -407,14 +379,13 @@ impl ObjectControl {
                 objects: &self.objects,
                 index: id,
             },
-            aff_id: None,
+            aff_loan: None,
         }
     }
 
     /// Get an unused affine matrix. Panics if more than 32 affine matricies are
     /// obtained.
     pub fn get_affine(&self) -> AffineMatrix {
-        let id = self.get_unused_affine_index();
         AffineMatrix {
             attributes: AffineMatrixAttributes {
                 p_a: 0,
@@ -422,10 +393,10 @@ impl ObjectControl {
                 p_c: 0,
                 p_d: 0,
             },
-            loan: AffineLoan {
-                affines: &self.affines,
-                index: id,
-            },
+            loan: self
+                .affines
+                .get_next_free()
+                .expect("there are no affines avaliable"),
         }
     }
 }
@@ -457,14 +428,14 @@ mod tests {
         let _a1 = {
             let a0 = objs.get_affine();
             let a1 = objs.get_affine();
-            assert_eq!(a0.loan.index, 0);
-            assert_eq!(a1.loan.index, 1);
+            assert_eq!(a0.loan.my_index, 0);
+            assert_eq!(a1.loan.my_index, 1);
             a1
         };
 
         let a0 = objs.get_affine();
-        assert_eq!(a0.loan.index, 0);
+        assert_eq!(a0.loan.my_index, 0);
         let a2 = objs.get_affine();
-        assert_eq!(a2.loan.index, 2);
+        assert_eq!(a2.loan.my_index, 2);
     }
 }

agb/src/lib.rs

@@ -14,31 +14,29 @@
 //! internal workings of the Game Boy Advance whilst still being high
 //! performance and memory efficient.
 
+pub use agb_image_converter::include_gfx;
+pub use agb_macros::entry;
+pub use agb_sound_converter::include_wav;
+
 #[cfg(feature = "alloc")]
 extern crate alloc;
 #[cfg(feature = "alloc")]
 mod agb_alloc;
 
+mod arena;
+mod bitarray;
 /// Implements everything relating to things that are displayed on screen.
 pub mod display;
 /// Button inputs to the system.
 pub mod input;
-/// Implements sound output.
-pub mod sound;
-
-pub use agb_image_converter::include_gfx;
-pub use agb_sound_converter::include_wav;
-
-pub use agb_macros::entry;
-
-mod bitarray;
 pub mod interrupt;
 mod memory_mapped;
 /// Implements logging to the mgba emulator.
 pub mod mgba;
 pub mod number;
 mod single;
-
+/// Implements sound output.
+pub mod sound;
 /// System BIOS calls / syscalls.
 pub mod syscall;