Enum AssetState 

#[repr(u8)]
pub enum AssetState {
    NotLoaded = 0,
    Loading {
        progress: f32,
    },
    Loaded = 2,
    Failed {
        error: String,
    },
    Unloaded = 4,
}

Loading state of an asset.

Tracks the lifecycle of an asset from initial request to loaded (or failed). Used by the asset server to report loading progress.

State Transitions

NotLoaded ──▶ Loading ──▶ Loaded
                 │
                 └──▶ Failed

FFI Safety

This enum is #[repr(u8)] for stable, FFI-compatible representation.

Example

use goud_engine::assets::AssetState;

let state = AssetState::Loading { progress: 0.5 };

match state {
    AssetState::Loading { progress } => {
        println!("Loading: {}%", progress * 100.0);
    }
    AssetState::Loaded => println!("Ready!"),
    AssetState::Failed { .. } => println!("Error!"),
    _ => {}
}

Variants

NotLoaded = 0

Asset has not been requested for loading.

Loading

Asset is currently being loaded.

Progress is a value from 0.0 to 1.0.

Fields

progress: f32

Loading progress (0.0 to 1.0).

Loaded = 2

Asset has been successfully loaded and is ready for use.

Failed

Asset loading failed.

Fields

error: String

Error message describing the failure.

Unloaded = 4

Asset was loaded but has been unloaded from memory.

Implementations

impl AssetState

pub fn is_ready(&self) -> bool

Returns true if the asset is ready for use.

Example

use goud_engine::assets::AssetState;

assert!(AssetState::Loaded.is_ready());
assert!(!AssetState::Loading { progress: 0.5 }.is_ready());

pub fn is_loading(&self) -> bool

Returns true if the asset is currently loading.

Example

use goud_engine::assets::AssetState;

assert!(AssetState::Loading { progress: 0.5 }.is_loading());
assert!(!AssetState::Loaded.is_loading());

pub fn is_failed(&self) -> bool

Returns true if asset loading failed.

Example

use goud_engine::assets::AssetState;

let state = AssetState::Failed { error: "File not found".to_string() };
assert!(state.is_failed());

pub fn progress(&self) -> Option<f32>

Returns the loading progress if currently loading.

Returns None for non-loading states.

Example

use goud_engine::assets::AssetState;

let state = AssetState::Loading { progress: 0.75 };
assert_eq!(state.progress(), Some(0.75));

assert_eq!(AssetState::Loaded.progress(), None);

pub fn error(&self) -> Option<&str>

Returns the error message if loading failed.

Returns None for non-failed states.

Example

use goud_engine::assets::AssetState;

let state = AssetState::Failed { error: "Invalid format".to_string() };
assert_eq!(state.error(), Some("Invalid format"));

assert_eq!(AssetState::Loaded.error(), None);

pub fn discriminant(&self) -> u8

Returns the discriminant as a u8 for FFI.

Example

use goud_engine::assets::AssetState;

assert_eq!(AssetState::NotLoaded.discriminant(), 0);
assert_eq!(AssetState::Loading { progress: 0.0 }.discriminant(), 1);
assert_eq!(AssetState::Loaded.discriminant(), 2);

Trait Implementations

impl Clone for AssetState

fn clone(&self) -> AssetState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AssetState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AssetState

fn default() -> AssetState

Returns the “default value” for a type.

impl Display for AssetState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for AssetState

fn eq(&self, other: &AssetState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for AssetState