chuot 0.3.2

AGPL licensed and opinionated game engine for pixel-art games
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

//! Asset loading and management.

#[cfg(not(target_arch = "wasm32"))]
pub(crate) mod hot_reload;
pub mod loadable;
pub mod loader;
#[doc(hidden)]
pub mod source;

use std::rc::Rc;

use hashbrown::HashMap;
use smol_str::SmolStr;

use self::loadable::Loadable;

/// Identifier for any loadable asset, can be assigned multiple times for different types.
///
/// When the string is smaller than 23 bytes this will be stored on the stack.
pub type Id = SmolStr;

/// Global asset manager for a single type known at compile time.
///
/// When hot-reloading is enabled all assets are loaded from disk, otherwise all assets are embedded in the binary.
///
/// Improves performance because the types don't need to be boxed inside the vector.
pub(crate) struct AssetManager<T: Loadable> {
    /// All loaded assets.
    assets: HashMap<Id, Rc<T>>,
}

impl<T: Loadable> AssetManager<T> {
    /// Return an asset if it exists.
    #[inline]
    pub(crate) fn get(&self, id: &Id) -> Option<Rc<T>> {
        self.assets.get(id).cloned()
    }

    /// Check if an asset exists.
    #[inline]
    pub(crate) fn contains(&self, id: &Id) -> bool {
        self.assets.contains_key(id)
    }

    /// Insert the loaded asset so it can be accessed.
    #[inline]
    pub(crate) fn insert(&mut self, id: Id, asset: T) -> Rc<T> {
        // Wrap the asset
        let asset = Rc::new(asset);

        // Store the asset so it can be accessed later again
        self.assets.insert(id, Rc::clone(&asset));

        asset
    }

    /// Remove a loaded asset, mainly used for hot-reloading.
    #[cfg(not(target_arch = "wasm32"))]
    #[inline]
    pub(crate) fn remove(&mut self, id: &Id) {
        self.assets.remove(id);
    }
}

impl<T: Loadable> Default for AssetManager<T> {
    fn default() -> Self {
        let assets = HashMap::new();

        Self { assets }
    }
}

/// Global asset manager for a any type not known at compile time.
///
/// When hot-reloading is enabled all assets are loaded from disk, otherwise all assets are embedded in the binary.
pub(crate) struct CustomAssetManager {
    /// All loaded assets.
    assets: HashMap<Id, Rc<dyn Loadable + 'static>>,
}

impl CustomAssetManager {
    /// Return an asset if it exists.
    #[inline]
    pub(crate) fn get<T>(&self, id: &str) -> Option<Rc<T>>
    where
        T: Loadable,
    {
        // Try to find the asset
        let dyn_asset = self.assets.get(id)?;

        // Try to downcast it to the requested type
        Rc::clone(dyn_asset)
            .downcast_rc::<T>()
            .map_or_else(|_| panic!("Could downcast asset with ID '{id}', loaded type is different from requested type"), Some)
    }

    /// Upload a new asset.
    #[inline]
    pub(crate) fn insert<T>(&mut self, id: Id, asset: T) -> Rc<T>
    where
        T: Loadable,
    {
        // Load the asset
        let asset: Rc<dyn Loadable> = Rc::new(asset);

        // Store the asset so it can be accessed later again
        self.assets.insert(id, Rc::clone(&asset));

        // Safe to unwrap because we created the type here
        asset
            .downcast_rc::<T>()
            .unwrap_or_else(|_| panic!("Error downcasting type"))
    }

    /// Remove a loaded asset, mainly used for hot-reloading.
    #[cfg(not(target_arch = "wasm32"))]
    #[inline]
    pub(crate) fn remove(&mut self, id: &Id) {
        self.assets.remove(id);
    }
}

impl Default for CustomAssetManager {
    fn default() -> Self {
        let assets = HashMap::new();

        Self { assets }
    }
}