prometeu-runtime/crates/console/prometeu-hal/src/asset.rs

use serde::{Deserialize, Serialize};

pub type HandleId = u32;
pub type AssetId = i32;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize, Serialize)]
#[allow(non_camel_case_types)]
pub enum BankType {
    GLYPH,
    SOUNDS,
    SCENE,
    // TILEMAPS,
    // BLOBS,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize, Serialize)]
pub enum AssetCodec {
    #[serde(rename = "NONE")]
    None,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct AssetEntry {
    pub asset_id: AssetId,
    pub asset_name: String,
    pub bank_type: BankType,
    pub offset: u64,
    pub size: u64,
    pub decoded_size: u64,
    pub codec: AssetCodec,
    pub metadata: serde_json::Value,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GlyphBankMetadata {
    pub tile_size: u32,
    pub width: u32,
    pub height: u32,
    pub palette_count: u32,
    pub palette_authored: u32,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SoundBankMetadata {
    pub sample_rate: u32,
    pub channels: u32,
}

#[derive(Debug, Clone, Default, Deserialize, Serialize)]
pub struct SceneBankMetadata {}

pub const SCENE_PAYLOAD_MAGIC_V1: [u8; 4] = *b"SCNE";
pub const SCENE_PAYLOAD_VERSION_V1: u16 = 1;
pub const SCENE_LAYER_COUNT_V1: usize = 4;
pub const SCENE_HEADER_BYTES_V1: usize = 12;
// Per-layer header:
// flags:u8 + glyph_asset_id:i32 + tile_size:u8 + reserved:u16
// + parallax_x:f32 + parallax_y:f32 + width:u32 + height:u32
// + tile_count:u32 + reserved:u32
pub const SCENE_LAYER_HEADER_BYTES_V1: usize = 32;
pub const SCENE_TILE_RECORD_BYTES_V1: usize = 4;
pub const SCENE_DECODED_LAYER_OVERHEAD_BYTES_V1: usize = 16;

impl AssetEntry {
    pub fn metadata_as_glyph_bank(&self) -> Result<GlyphBankMetadata, String> {
        if self.bank_type != BankType::GLYPH {
            return Err(format!(
                "Asset {} is not a GLYPH bank (type: {:?})",
                self.asset_id, self.bank_type
            ));
        }
        serde_json::from_value(self.metadata.clone())
            .map_err(|e| format!("Invalid GLYPH metadata for asset {}: {}", self.asset_id, e))
    }

    pub fn metadata_as_sound_bank(&self) -> Result<SoundBankMetadata, String> {
        if self.bank_type != BankType::SOUNDS {
            return Err(format!(
                "Asset {} is not a SOUNDS bank (type: {:?})",
                self.asset_id, self.bank_type
            ));
        }
        serde_json::from_value(self.metadata.clone())
            .map_err(|e| format!("Invalid SOUNDS metadata for asset {}: {}", self.asset_id, e))
    }

    pub fn metadata_as_scene_bank(&self) -> Result<SceneBankMetadata, String> {
        if self.bank_type != BankType::SCENE {
            return Err(format!(
                "Asset {} is not a SCENE bank (type: {:?})",
                self.asset_id, self.bank_type
            ));
        }
        serde_json::from_value(self.metadata.clone())
            .map_err(|e| format!("Invalid SCENE metadata for asset {}: {}", self.asset_id, e))
    }
}

#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PreloadEntry {
    pub asset_id: AssetId,
    pub slot: usize,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[repr(i32)]
pub enum LoadStatus {
    PENDING = 0,
    LOADING = 1,
    READY = 2,
    COMMITTED = 3,
    CANCELED = 4,
    ERROR = 5,
    UnknownHandle = 6,
    QUEUED = 7,
    ACTIVE = 8,
    SUPERSEDED = 9,
    EMPTY = 10,
    INVALID = 11,
    BackendUnavailable = 12,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(i32)]
pub enum AssetLoadError {
    AssetNotFound = 3,
    SlotKindMismatch = 4,
    SlotIndexInvalid = 5,
    BackendError = 6,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(i32)]
pub enum AssetOpStatus {
    Ok = 0,
    UnknownHandle = 1,
    InvalidState = 2,
    Superseded = 3,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AssetBacklogInfo {
    pub status: AssetOpStatus,
    pub pending_count: u32,
    pub active_handle: HandleId,
    pub active_asset_id: Option<AssetId>,
    pub active_bank_type: Option<BankType>,
    pub active_slot: Option<usize>,
    pub active_progress: u16,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AssetBacklogPosition {
    pub status: AssetOpStatus,
    pub state: LoadStatus,
    pub position: u32,
    pub progress: u16,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AssetTargetStatus {
    pub status: AssetOpStatus,
    pub asset_id: Option<AssetId>,
    pub handle: HandleId,
    pub state: LoadStatus,
    pub position: u32,
    pub progress: u16,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BankTelemetry {
    pub bank_type: BankType,
    pub used_slots: usize,
    pub total_slots: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SlotStats {
    pub asset_id: Option<AssetId>,
    pub asset_name: Option<String>,
    pub generation: u32,
    pub resident_bytes: usize,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct SlotRef {
    pub asset_type: BankType,
    pub index: usize,
}

impl SlotRef {
    pub fn gfx(index: usize) -> Self {
        Self { asset_type: BankType::GLYPH, index }
    }

    pub fn audio(index: usize) -> Self {
        Self { asset_type: BankType::SOUNDS, index }
    }

    pub fn scene(index: usize) -> Self {
        Self { asset_type: BankType::SCENE, index }
    }
}