bevy_assets_extensions 0.7.0

//! Define static modules.

use bevy::prelude::*;
pub use bevy_assets_extensions_macros::StaticAssetsBundle;

/// Base trait for static bundles.
pub trait StaticAssetsBundle: Asset {}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::prelude::*;
    use bevy::{asset::LoadState, text::FontLoader};
    use std::time::Duration;

    #[derive(StaticAssetsBundle, Asset, TypePath)]
    struct StaticAssetsBundleTest {
        hello: assets::Text,
        world: assets::Text,
        text: assets::Text,
    }

    #[derive(StaticAssetsBundle, Asset, TypePath)]
    struct StaticAssetsBundleBundleTest {
        hello: assets::Text,
        world: StaticAssetsBundleTest,
    }

    #[derive(StaticAssetsBundle, Asset, TypePath)]
    struct StaticAssetsBundleAssetsBundleTest {
        hello: assets::Text,
        world: assets::AssetsBundle,
    }

    #[derive(StaticAssetsBundle, Asset, TypePath)]
    struct StaticHashMapAssetsBundleTest {
        hello: assets::Text,
        world: std::collections::HashMap<String, assets::Text>,
    }
    #[derive(StaticAssetsBundle, Asset, TypePath)]
    struct StaticHashMapHandleAssetsBundleTest {
        hello: assets::Text,
        world: std::collections::HashMap<String, Handle<assets::Text>>,
    }
    #[cfg(feature = "atlas_layout")]
    #[derive(StaticAssetsBundle, Asset, TypePath)]
    struct StaticAssetsAtlasLayoutBundleTest {
        layout: Handle<TextureAtlasLayout>,
    }

    fn default_float() -> f32 {
        4.0
    }

    #[derive(StaticAssetsBundle, Asset, TypePath)]
    struct StaticAssetsAllTypesTest {
        #[asset(key = "float_point_32")]
        value: f32,
        #[asset(default = default_float())]
        value_default: f32,
        #[asset(key = "float_point_32_default", default)]
        value_default_value: f32,
        color: Color,
        font: Handle<Font>,
        rect: UiRect,
        layers: Vec<String>,
        texture_slicer: TextureSlicer,
    }

    fn is_loading(load_state: LoadState) -> bool {
        match load_state {
            LoadState::Loading => true,
            LoadState::Failed(e) => {
                panic!("Loading state is failed: {:?}", e);
            }
            _ => false,
        }
    }

    // Only used for testing compilation
    #[cfg(feature = "atlas_layout")]
    #[derive(Debug, StaticAssetsBundle, Asset, TypePath)]
    #[allow(dead_code)]
    pub struct LayersSource {
        #[asset(key = "layers")]
        _layers: std::collections::HashMap<String, Handle<Image>>,
        #[asset(key = "atlas_layout")]
        _atlas_layout: Handle<TextureAtlasLayout>,
    }

    #[test]
    fn test_static_asset_loading() {
        // Initialise test
        let mut app = App::new();
        app.add_plugins((MinimalPlugins, AssetPlugin::default()));
        app.init_asset::<StaticAssetsBundleTest>();
        app.init_asset_loader::<StaticAssetsBundleTestLoader>();
        app.init_asset_loader::<crate::assets::text::TextLoader>();

        // Start loading the test bundle
        let handle: Handle<StaticAssetsBundleTest> = app
            .world()
            .resource::<AssetServer>()
            .load("test_relative/test.bundle.ron");
        app.update();

        // Wait for the loading to happen
        while is_loading(
            app.world()
                .resource::<AssetServer>()
                .get_load_state(&handle)
                .unwrap(),
        ) {
            app.update();
            std::thread::sleep(Duration::from_secs(1));
        }

        // Get the test bundle
        let assets = app
            .world()
            .resource::<Assets<StaticAssetsBundleTest>>()
            .get(&handle)
            .unwrap();
        assert_eq!(assets.hello.text_ref(), "hello");
        assert_eq!(assets.world.text_ref(), "world");
        assert_eq!(assets.text.text_ref(), "Hello World!");
    }

    #[test]
    fn test_static_asset_bundle_loading() {
        // Initialise test
        let mut app = App::new();
        app.add_plugins((MinimalPlugins, AssetPlugin::default()));
        app.init_asset::<StaticAssetsBundleTest>();
        app.init_asset::<StaticAssetsBundleBundleTest>();
        app.init_asset_loader::<StaticAssetsBundleBundleTestLoader>();
        app.init_asset_loader::<crate::assets::text::TextLoader>();

        // Start loading the test bundle
        let handle: Handle<StaticAssetsBundleBundleTest> = app
            .world()
            .resource::<AssetServer>()
            .load("test_bundle.bundle.ron");
        app.update();

        // Wait for the loading to happen
        while is_loading(
            app.world()
                .resource::<AssetServer>()
                .get_load_state(&handle)
                .unwrap(),
        ) {
            app.update();
            std::thread::sleep(Duration::from_secs(1));
        }

        // Get the test bundle
        let assets = app
            .world()
            .resource::<Assets<StaticAssetsBundleBundleTest>>()
            .get(&handle)
            .unwrap();
        assert_eq!(assets.hello.text_ref(), "hello");
        assert_eq!(assets.world.hello.text_ref(), "hello");
        assert_eq!(assets.world.world.text_ref(), "world");
        assert_eq!(assets.world.text.text_ref(), "Hello World!");
    }

    #[test]
    fn test_static_asset_bundle_bundle_loading() {
        // Initialise test
        let mut app = App::new();
        app.add_plugins((MinimalPlugins, AssetPlugin::default()));
        app.init_asset::<StaticAssetsBundleTest>();
        app.init_asset::<StaticAssetsBundleAssetsBundleTest>();
        // app.init_asset_loader::<StaticAssetsBundleTestLoader>();
        app.init_asset_loader::<StaticAssetsBundleAssetsBundleTestLoader>();
        app.init_asset_loader::<crate::assets::text::TextLoader>();

        // Start loading the test bundle
        let handle: Handle<StaticAssetsBundleAssetsBundleTest> = app
            .world()
            .resource::<AssetServer>()
            .load("test_bundle.bundle.ron");
        app.update();

        // Wait for the loading to happen
        while is_loading(
            app.world()
                .resource::<AssetServer>()
                .get_load_state(&handle)
                .unwrap(),
        ) {
            app.update();
            std::thread::sleep(Duration::from_secs(1));
        }

        // Get the test bundle
        let assets = app
            .world()
            .resource::<Assets<StaticAssetsBundleAssetsBundleTest>>()
            .get(&handle)
            .unwrap();
        assert_eq!(assets.hello.text_ref(), "hello");
        assert_eq!(
            assets
                .world
                .get_asset::<assets::Text>("hello")
                .unwrap()
                .text_ref(),
            "hello"
        );
        assert_eq!(
            assets
                .world
                .get_asset::<assets::Text>("world")
                .unwrap()
                .text_ref(),
            "world"
        );
        assert_eq!(
            assets
                .world
                .get_asset::<assets::Text>("text")
                .unwrap()
                .text_ref(),
            "Hello World!"
        );
    }

    #[test]
    fn test_static_hash_map_asset_bundle_bundle_loading() {
        // Initialise test
        let mut app = App::new();
        app.add_plugins((MinimalPlugins, AssetPlugin::default()));
        app.init_asset::<StaticHashMapAssetsBundleTest>();
        app.init_asset::<crate::assets::text::Text>();
        app.init_asset_loader::<StaticHashMapAssetsBundleTestLoader>();
        app.init_asset_loader::<crate::assets::text::TextLoader>();

        // Start loading the test bundle
        let handle: Handle<StaticHashMapAssetsBundleTest> = app
            .world()
            .resource::<AssetServer>()
            .load("test_bundle.bundle.ron");
        app.update();

        // Wait for the loading to happen
        while is_loading(
            app.world()
                .resource::<AssetServer>()
                .get_load_state(&handle)
                .unwrap(),
        ) {
            app.update();
            std::thread::sleep(Duration::from_secs(1));
        }

        // Get the test bundle
        let assets = app
            .world()
            .resource::<Assets<StaticHashMapAssetsBundleTest>>()
            .get(&handle)
            .unwrap();

        assert_eq!(assets.hello.text_ref(), "hello");
        assert_eq!(assets.world.get("hello").unwrap().text_ref(), "hello");
        assert_eq!(assets.world.get("world").unwrap().text_ref(), "world");
        assert_eq!(assets.world.get("text").unwrap().text_ref(), "Hello World!");
    }

    #[test]
    fn test_static_hash_map_handle_asset_bundle_bundle_loading() {
        // Initialise test
        let mut app = App::new();
        app.add_plugins((MinimalPlugins, AssetPlugin::default()));
        app.init_asset::<StaticHashMapHandleAssetsBundleTest>();
        app.init_asset::<crate::assets::text::Text>();
        app.init_asset_loader::<StaticHashMapHandleAssetsBundleTestLoader>();
        app.init_asset_loader::<crate::assets::text::TextLoader>();

        // Start loading the test bundle
        let handle: Handle<StaticHashMapHandleAssetsBundleTest> = app
            .world()
            .resource::<AssetServer>()
            .load("test_bundle.bundle.ron");
        app.update();

        // Wait for the loading to happen
        while is_loading(
            app.world()
                .resource::<AssetServer>()
                .get_load_state(&handle)
                .unwrap(),
        ) {
            app.update();
            std::thread::sleep(Duration::from_secs(1));
        }

        // Get the test bundle
        let assets = app
            .world()
            .resource::<Assets<StaticHashMapHandleAssetsBundleTest>>()
            .get(&handle)
            .unwrap();

        assert_eq!(assets.hello.text_ref(), "hello");
        // hello
        let handle = assets.world.get("hello").unwrap();
        let hello_asset = app
            .world()
            .resource::<Assets<crate::assets::Text>>()
            .get(handle)
            .unwrap();
        assert_eq!(hello_asset.text_ref(), "hello");
        // world
        let handle = assets.world.get("world").unwrap();
        let hello_asset = app
            .world()
            .resource::<Assets<crate::assets::Text>>()
            .get(handle)
            .unwrap();
        assert_eq!(hello_asset.text_ref(), "world");
        // text
        let handle = assets.world.get("text").unwrap();
        let asset = app
            .world()
            .resource::<Assets<crate::assets::Text>>()
            .get(handle)
            .unwrap();
        assert_eq!(asset.text_ref(), "Hello World!");
    }

    #[cfg(feature = "atlas_layout")]
    #[test]
    fn test_static_asset_atlast_layout_loading() {
        // Initialise test

        let mut app = App::new();
        app.add_plugins((MinimalPlugins, AssetPlugin::default()));
        app.init_asset::<StaticAssetsAtlasLayoutBundleTest>();
        app.init_asset::<TextureAtlasLayout>();
        app.init_asset_loader::<StaticAssetsAtlasLayoutBundleTestLoader>();
        app.init_asset_loader::<crate::assets::atlas_layout::TextureAtlasLayoutLoader>();

        // Start loading the test bundle
        let handle: Handle<StaticAssetsAtlasLayoutBundleTest> = app
            .world()
            .resource::<AssetServer>()
            .load("with_atlas_layout.bundle.ron");
        app.update();

        // Wait for the loading to happen
        while is_loading(
            app.world()
                .resource::<AssetServer>()
                .get_load_state(&handle)
                .unwrap(),
        ) {
            app.update();
            std::thread::sleep(Duration::from_secs(1));
        }

        // Get the test bundle
        let assets = app
            .world()
            .resource::<Assets<StaticAssetsAtlasLayoutBundleTest>>()
            .get(&handle)
            .unwrap();
        let texture_atlas = app
            .world()
            .resource::<Assets<TextureAtlasLayout>>()
            .get(&assets.layout)
            .unwrap();
        assert_eq!(texture_atlas.size, UVec2::new(192, 297));
        assert_eq!(
            texture_atlas.textures,
            vec![
                URect::new(0, 0, 96, 99),
                URect::new(96, 0, 192, 99),
                URect::new(0, 99, 96, 198),
                URect::new(96, 99, 192, 198),
                URect::new(0, 198, 96, 297),
                URect::new(96, 198, 192, 297),
            ]
        );
    }

    #[test]
    fn test_static_assets_all_types_test() {
        // Initialise test
        let mut app = App::new();
        app.add_plugins((MinimalPlugins, AssetPlugin::default()));
        app.init_asset::<StaticAssetsAllTypesTest>();
        app.init_asset::<Font>();
        app.init_asset_loader::<StaticAssetsAllTypesTestLoader>();
        app.init_asset_loader::<FontLoader>();

        // Start loading the test bundle
        let handle: Handle<StaticAssetsAllTypesTest> = app
            .world()
            .resource::<AssetServer>()
            .load("static_assets_all_types.bundle.ron");
        app.update();

        // Wait for the loading to happen
        while is_loading(
            app.world()
                .resource::<AssetServer>()
                .get_load_state(&handle)
                .unwrap(),
        ) {
            app.update();
            std::thread::sleep(Duration::from_secs(1));
        }

        // Get the test bundle
        let font = {
            let assets = app
                .world()
                .resource::<Assets<StaticAssetsAllTypesTest>>()
                .get(&handle)
                .unwrap();

            assert_eq!(assets.value, 2.0);
            assert_eq!(assets.value_default, 4.0);
            assert_eq!(assets.value_default_value, 0.0);
            assert_eq!(assets.color, Color::Srgba(Srgba::new(1.0, 2.0, 3.0, 4.0)));
            assert_eq!(assets.rect, UiRect::new(px(1.0), px(4.0), px(2.0), px(3.0)));
            assert_eq!(
                assets.layers,
                vec![
                    "bodies/03".to_string(),
                    "outfits/19_01".to_string(),
                    "hairstyles/01_01".to_string()
                ]
            );
            assert_eq!(
                assets.texture_slicer,
                TextureSlicer {
                    border: BorderRect {
                        left: 4.0,
                        right: 4.0,
                        top: 4.0,
                        bottom: 4.0,
                    },
                    center_scale_mode: SliceScaleMode::Stretch,
                    sides_scale_mode: SliceScaleMode::Stretch,
                    max_corner_scale: 1.0,
                }
            );
            assets.font.clone()
        };
        // Font
        while is_loading(
            app.world()
                .resource::<AssetServer>()
                .get_load_state(&font)
                .unwrap(),
        ) {
            app.update();
            std::thread::sleep(Duration::from_secs(1));
        }
        assert!(matches!(
            app.world()
                .resource::<AssetServer>()
                .get_load_state(&font)
                .unwrap(),
            LoadState::Loaded
        ));
    }
}