//! Memory bank access boundary. //! //! Render consumers must cross this boundary through small, read-only traits. //! Frame packets carry resource IDs; large resident resources stay in banks and //! are read in place through a narrow HAL callback contract. Installation and //! slot replacement remain separate owner-side operations and are not part of //! the render read surface. use prometeu_hal::glyph_bank::GlyphBank; use prometeu_hal::render_resources::RenderResourceAccess as HalRenderResourceAccess; use prometeu_hal::scene_bank::SceneBank; use prometeu_hal::sound_bank::SoundBank; use std::sync::{Arc, RwLock}; /// Non-generic interface for peripherals to access graphical glyph banks. pub trait GlyphBankPoolAccess: Send + Sync { /// Returns a reference to the resident GlyphBank in the specified slot, if any. fn glyph_bank_slot(&self, slot: usize) -> Option>; /// Returns the total number of slots available in this bank. fn glyph_bank_slot_count(&self) -> usize; } /// Non-generic interface for the AssetManager to install graphical glyph banks. pub trait GlyphBankPoolInstaller: Send + Sync { /// Atomically swaps the resident GlyphBank in the specified slot. fn install_glyph_bank(&self, slot: usize, bank: Arc); } /// Non-generic interface for peripherals to access sound banks. pub trait SoundBankPoolAccess: Send + Sync { /// Returns a reference to the resident SoundBank in the specified slot, if any. fn sound_bank_slot(&self, slot: usize) -> Option>; /// Returns the total number of slots available in this bank. fn sound_bank_slot_count(&self) -> usize; } /// Non-generic interface for the AssetManager to install sound banks. pub trait SoundBankPoolInstaller: Send + Sync { /// Atomically swaps the resident SoundBank in the specified slot. fn install_sound_bank(&self, slot: usize, bank: Arc); } /// Non-generic interface for peripherals to access scene banks. pub trait SceneBankPoolAccess: Send + Sync { /// Returns a reference to the resident SceneBank in the specified slot, if any. fn scene_bank_slot(&self, slot: usize) -> Option>; /// Returns the total number of slots available in this bank. fn scene_bank_slot_count(&self) -> usize; } /// Non-generic interface for the AssetManager to install scene banks. pub trait SceneBankPoolInstaller: Send + Sync { /// Atomically swaps the resident SceneBank in the specified slot. fn install_scene_bank(&self, slot: usize, bank: Arc); } /// Centralized container for all hardware memory banks. /// /// MemoryBanks represent the actual hardware slot state. /// Peripherals consume this state via narrow, non-generic traits. /// AssetManager coordinates residency and installs assets into these slots. pub struct MemoryBanks { glyph_bank_pool: Arc>; 16]>>, sound_bank_pool: Arc>; 16]>>, scene_bank_pool: Arc>; 16]>>, } impl Default for MemoryBanks { fn default() -> Self { Self::new() } } impl MemoryBanks { /// Creates a new set of memory banks with empty slots. pub fn new() -> Self { Self { glyph_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))), sound_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))), scene_bank_pool: Arc::new(RwLock::new(std::array::from_fn(|_| None))), } } } impl GlyphBankPoolAccess for MemoryBanks { fn glyph_bank_slot(&self, slot: usize) -> Option> { let pool = self.glyph_bank_pool.read().unwrap(); pool.get(slot).and_then(|s| s.as_ref().map(Arc::clone)) } fn glyph_bank_slot_count(&self) -> usize { 16 } } impl GlyphBankPoolInstaller for MemoryBanks { fn install_glyph_bank(&self, slot: usize, bank: Arc) { let mut pool = self.glyph_bank_pool.write().unwrap(); if slot < 16 { pool[slot] = Some(bank); } } } impl SoundBankPoolAccess for MemoryBanks { fn sound_bank_slot(&self, slot: usize) -> Option> { let pool = self.sound_bank_pool.read().unwrap(); pool.get(slot).and_then(|s| s.as_ref().map(Arc::clone)) } fn sound_bank_slot_count(&self) -> usize { 16 } } impl SoundBankPoolInstaller for MemoryBanks { fn install_sound_bank(&self, slot: usize, bank: Arc) { let mut pool = self.sound_bank_pool.write().unwrap(); if slot < 16 { pool[slot] = Some(bank); } } } impl SceneBankPoolAccess for MemoryBanks { fn scene_bank_slot(&self, slot: usize) -> Option> { let pool = self.scene_bank_pool.read().unwrap(); pool.get(slot).and_then(|s| s.as_ref().map(Arc::clone)) } fn scene_bank_slot_count(&self) -> usize { 16 } } impl SceneBankPoolInstaller for MemoryBanks { fn install_scene_bank(&self, slot: usize, bank: Arc) { let mut pool = self.scene_bank_pool.write().unwrap(); if slot < 16 { pool[slot] = Some(bank); } } } impl HalRenderResourceAccess for MemoryBanks { fn with_glyph_bank(&self, bank_id: usize, read: impl FnOnce(&GlyphBank) -> R) -> Option { let pool = self.glyph_bank_pool.read().unwrap(); let bank = pool.get(bank_id)?.as_deref()?; Some(read(bank)) } fn glyph_bank_count(&self) -> usize { 16 } fn with_scene_bank(&self, bank_id: usize, read: impl FnOnce(&SceneBank) -> R) -> Option { let pool = self.scene_bank_pool.read().unwrap(); let bank = pool.get(bank_id)?.as_deref()?; Some(read(bank)) } fn scene_bank_count(&self) -> usize { 16 } } #[cfg(test)] mod tests { use super::*; use prometeu_hal::color::Color; use prometeu_hal::glyph::Glyph; use prometeu_hal::glyph_bank::TileSize; use prometeu_hal::scene_layer::{ParallaxFactor, SceneLayer}; use prometeu_hal::tile::Tile; use prometeu_hal::tilemap::TileMap; fn assert_send_sync() {} fn make_glyph_bank() -> GlyphBank { let mut bank = GlyphBank::new(TileSize::Size8, 8, 8); bank.palettes[0][1] = Color::WHITE; bank } fn make_scene_bank() -> SceneBank { let layer = SceneLayer { active: true, glyph_asset_id: 0, tile_size: TileSize::Size8, parallax_factor: ParallaxFactor { x: 1.0, y: 1.0 }, tilemap: TileMap { width: 1, height: 1, tiles: vec![Tile { active: true, glyph: Glyph { glyph_id: 0, palette_id: 0 }, flip_x: false, flip_y: false, }], }, }; SceneBank { layers: std::array::from_fn(|_| layer.clone()) } } #[test] fn render_resource_access_traits_are_thread_safe() { assert_send_sync::(); assert_send_sync::>(); assert_send_sync::>(); } #[test] fn render_resource_access_exposes_read_only_glyph_and_scene_banks_without_arc_contract() { let banks = MemoryBanks::new(); banks.install_glyph_bank(0, Arc::new(make_glyph_bank())); banks.install_scene_bank(1, Arc::new(make_scene_bank())); let glyph_tile_size = HalRenderResourceAccess::with_glyph_bank(&banks, 0, |bank| bank.tile_size); let scene_tile_size = HalRenderResourceAccess::with_scene_bank(&banks, 1, |bank| bank.layers[0].tile_size); assert_eq!(glyph_tile_size, Some(TileSize::Size8)); assert_eq!(scene_tile_size, Some(TileSize::Size8)); assert_eq!(HalRenderResourceAccess::with_glyph_bank(&banks, 15, |_| ()), None); assert_eq!(HalRenderResourceAccess::with_scene_bank(&banks, 15, |_| ()), None); assert_eq!(HalRenderResourceAccess::glyph_bank_count(&banks), 16); assert_eq!(HalRenderResourceAccess::scene_bank_count(&banks), 16); } }