vert 0.1.1

The 51th Rust Game Engine, to write the 6th Game in Rust
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

use glam::vec3;
use vert_framework::{
    app::App,
    flow::Flow,
    modules::{
        assets::fetchable_asset::{AssetSource, ImageAsset, LoadingAsset},
        graphics::elements::color_mesh::SingleColorMesh,
        Modules,
    },
    state::StateT,
};

pub enum MyImg {
    Loading(LoadingAsset<ImageAsset>),
    Loaded(ImageAsset),
    Error(anyhow::Error),
}

pub struct MyState {
    img: MyImg,
}

impl StateT for MyState {
    async fn initialize(modules: &mut Modules) -> anyhow::Result<Self> {
        // let system_id = modules.add_system();

        let source: AssetSource = "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQ6ttcadfmj7-DuD3JDobVHUXcGFNcreMPMjKm3nq-keA&s".into();
        dbg!(&source);
        let loading_asset = source.fetch_in_background();
        Ok(MyState {
            img: MyImg::Loading(loading_asset),
        })
    }

    fn update(&mut self, modules: &mut Modules) -> Flow {
        let label = match &self.img {
            MyImg::Loading(_) => "Loading".to_string(),
            MyImg::Loaded(img) => format!("Loaded, dims: {:?}", img.rgba.dimensions()),
            MyImg::Error(err) => format!("Error: {err}",),
        };

        egui::Window::new("Asset test").show(&mut modules.egui(), |ui| {
            ui.label(label);
        });

        match &mut self.img {
            MyImg::Loading(l) => {
                match l.get() {
                    Some(Ok(img)) => {
                        println!(
                            "Received image after {} seconds",
                            modules.time().total_secs()
                        );
                        self.img = MyImg::Loaded(img);
                    }
                    Some(Err(err)) => {
                        println!("Received error: {err}");
                        self.img = MyImg::Error(err);
                    }
                    None => {}
                };
            }
            _ => {}
        }

        Flow::Continue
    }

    fn prepare(&mut self, modules: &wgpu::Queue, encoder: &mut wgpu::CommandEncoder) {}
}

fn main() {
    App::<MyState>::run().unwrap();
}