ability to change example if loading is too long or failed

Author: ThierryBerger

examples3d/src/glb_to_point_cloud_color.rs

@@ -5,20 +5,22 @@ use nalgebra::{vector, Isometry3, Transform3, UnitQuaternion, Vector3};
 use std::{fs::File, io::Read};
 use wgsparkl3d::load_mesh3d::load_gltf::load_model_with_colors;
 use wgsparkl3d::{pipeline::MpmData, solver::SimulationParams};
-use wgsparkl_testbed3d::load_scene::Dependencies;
+use wgsparkl_testbed3d::load_scene::{Dependencies, Loader};
 use wgsparkl_testbed3d::{AppState, Callbacks, PhysicsContext, RapierData};
 
+pub fn load(loader: &mut Loader) {
+    loader.load_raw_file("shiba.glb");
+}
+
 pub fn elastic_color_model_demo(
     device: RenderDevice,
     app_state: &mut AppState,
     _callbacks: &mut Callbacks,
     assets: &Dependencies,
 ) -> PhysicsContext {
-    let mut file = File::open("assets/shiba.glb").expect("Failed to open GLB file");
-    let mut buffer = Vec::new();
-    file.read_to_end(&mut buffer).expect("Failed to read file");
+    let buffer = &assets.get_data("shiba.glb").unwrap().data;
     let pc_grid = load_model_with_colors(
-        &buffer,
+        buffer,
         Transform3::from_matrix_unchecked(
             Isometry3::from_parts(
                 Vector3::new(0.0, 6.0, 0.0).into(),

examples3d/src/main.rs

@@ -40,7 +40,7 @@ fn register_scenes(world: &mut World) {
         (
             "elastic_model_colors".to_string(),
             Box::new(glb_to_point_cloud_color::elastic_color_model_demo),
-            None,
+            Some(Box::new(glb_to_point_cloud_color::load)),
         ),
         (
             "taichi_banana".to_string(),

src_testbed/file_loader.rs

@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 use bevy::{
     asset::{io::Reader, Asset, AssetLoader, LoadContext},
     reflect::Reflect,

src_testbed/lib.rs

@@ -55,22 +55,21 @@ pub fn init_testbed(app: &mut App) {
         .add_plugins(bevy_egui::EguiPlugin)
         .init_resource::<Callbacks>()
         .add_systems(Startup, startup::setup_app)
-        .add_systems(
-            Update,
-            ui::update_ui_loading.run_if(not(in_state(SceneState::Loaded))),
-        )
         .add_systems(
             Update,
             (
                 ui::update_ui,
-                (step::step_simulation, step::callbacks)
+                (
+                    (step::step_simulation, step::callbacks)
+                        .chain()
+                        .run_if(|state: Res<AppState>| state.run_state != RunState::Paused),
+                    rigid_graphics::update_rigid_graphics,
+                    hot_reload::handle_hot_reloading,
+                )
                     .chain()
-                    .run_if(|state: Res<AppState>| state.run_state != RunState::Paused),
-                rigid_graphics::update_rigid_graphics,
-                hot_reload::handle_hot_reloading,
+                    .run_if(in_state(SceneState::Loaded)),
             )
-                .chain()
-                .run_if(in_state(SceneState::Loaded)),
+                .chain(),
         );
 
     #[cfg(not(target_arch = "wasm32"))]

src_testbed/ui.rs

@@ -1,4 +1,4 @@
-use crate::load_scene::SceneInits;
+use crate::load_scene::{SceneInits, SceneState};
 use crate::prep_vertex_buffer::RenderMode;
 use crate::startup::RigidParticlesTag;
 use crate::{AppState, PhysicsContext, RunState, Timestamps};
@@ -9,17 +9,13 @@ use bevy_egui::{egui, EguiContexts};
 use nalgebra::vector;
 use wgsparkl::solver::SimulationParams;
 
-pub fn update_ui_loading(mut ui_context: EguiContexts) {
-    egui::Window::new("Loading").show(ui_context.ctx_mut(), |ui| {
-        ui.label("Loading...");
-    });
-}
 #[allow(clippy::too_many_arguments)]
 pub fn update_ui(
     mut commands: Commands,
     mut ui_context: EguiContexts,
-    physics: ResMut<PhysicsContext>,
+    physics: Option<ResMut<PhysicsContext>>,
     mut app_state: ResMut<AppState>,
+    scene_state: Res<State<SceneState>>,
     scenes: Res<SceneInits>,
     timings: Res<Timestamps>,
     queue: Res<RenderQueue>,
@@ -42,127 +38,131 @@ pub fn update_ui(
             app_state.restarting = false;
         }
 
-        let mut changed = false;
-        egui::ComboBox::from_label("render mode")
-            .selected_text(RenderMode::from_u32(app_state.render_config.mode).text())
-            .show_ui(ui, |ui| {
-                for i in 0..6 {
-                    changed = ui
-                        .selectable_value(
-                            &mut app_state.render_config.mode,
-                            i,
-                            RenderMode::from_u32(i).text(),
-                        )
-                        .changed()
-                        || changed;
-                }
-            });
+        if scene_state.get() == &SceneState::Loading {
+            ui.label("Loading...");
+        } else if let Some(physics) = physics {
+            let mut changed = false;
+            egui::ComboBox::from_label("render mode")
+                .selected_text(RenderMode::from_u32(app_state.render_config.mode).text())
+                .show_ui(ui, |ui| {
+                    for i in 0..6 {
+                        changed = ui
+                            .selectable_value(
+                                &mut app_state.render_config.mode,
+                                i,
+                                RenderMode::from_u32(i).text(),
+                            )
+                            .changed()
+                            || changed;
+                    }
+                });
 
-        if changed {
-            queue.write_buffer(
-                app_state.gpu_render_config.buffer.buffer(),
-                0,
-                bytemuck::bytes_of(&app_state.render_config.mode),
-            );
-            queue.submit([]);
-        }
+            if changed {
+                queue.write_buffer(
+                    app_state.gpu_render_config.buffer.buffer(),
+                    0,
+                    bytemuck::bytes_of(&app_state.render_config.mode),
+                );
+                queue.submit([]);
+            }
 
-        let mut sim_params_changed = false;
-        sim_params_changed = ui
-            .add(Slider::new(&mut app_state.num_substeps, 1..=200).text("substeps"))
-            .changed()
-            || sim_params_changed;
-        sim_params_changed = ui
-            .add(Slider::new(&mut app_state.gravity_factor, 0.0..=10.0).text("gravity factor"))
-            .changed()
-            || sim_params_changed;
+            let mut sim_params_changed = false;
+            sim_params_changed = ui
+                .add(Slider::new(&mut app_state.num_substeps, 1..=200).text("substeps"))
+                .changed()
+                || sim_params_changed;
+            sim_params_changed = ui
+                .add(Slider::new(&mut app_state.gravity_factor, 0.0..=10.0).text("gravity factor"))
+                .changed()
+                || sim_params_changed;
 
-        if ui
-            .checkbox(&mut app_state.show_rigid_particles, "show rigid_particles")
-            .changed()
-        {
-            for mut visibility in rigid_particles.iter_mut() {
-                if app_state.show_rigid_particles {
-                    *visibility = Visibility::Inherited;
-                } else {
-                    *visibility = Visibility::Hidden;
+            if ui
+                .checkbox(&mut app_state.show_rigid_particles, "show rigid_particles")
+                .changed()
+            {
+                for mut visibility in rigid_particles.iter_mut() {
+                    if app_state.show_rigid_particles {
+                        *visibility = Visibility::Inherited;
+                    } else {
+                        *visibility = Visibility::Hidden;
+                    }
                 }
             }
-        }
 
-        #[cfg(feature = "dim2")]
-        let gravity = vector![0.0, -9.81];
-        #[cfg(feature = "dim3")]
-        let gravity = vector![0.0, -9.81, 0.0];
+            #[cfg(feature = "dim2")]
+            let gravity = vector![0.0, -9.81];
+            #[cfg(feature = "dim3")]
+            let gravity = vector![0.0, -9.81, 0.0];
 
-        if sim_params_changed {
-            let new_params = SimulationParams {
-                gravity: gravity * app_state.gravity_factor,
-                dt: (1.0 / 60.0) / (app_state.num_substeps as f32),
-                #[cfg(feature = "dim2")]
-                padding: 0.0,
-            };
-            queue.write_buffer(
-                physics.data.sim_params.params.buffer(),
-                0,
-                bytemuck::bytes_of(&new_params),
-            );
-            queue.submit([]);
-        }
+            if sim_params_changed {
+                let new_params = SimulationParams {
+                    gravity: gravity * app_state.gravity_factor,
+                    dt: (1.0 / 60.0) / (app_state.num_substeps as f32),
+                    #[cfg(feature = "dim2")]
+                    padding: 0.0,
+                };
+                queue.write_buffer(
+                    physics.data.sim_params.params.buffer(),
+                    0,
+                    bytemuck::bytes_of(&new_params),
+                );
+                queue.submit([]);
+            }
 
-        ui.label(format!("Particle count: {}", physics.particles.len()));
-        ui.label(format!(
-            "Rigid particle count: {}",
-            physics.data.rigid_particles.len()
-        ));
+            ui.label(format!("Particle count: {}", physics.particles.len()));
+            ui.label(format!(
+                "Rigid particle count: {}",
+                physics.data.rigid_particles.len()
+            ));
 
-        CollapsingHeader::new(format!("GPU runtime: {:.3}ms", timings.total_time()))
-            .id_salt("GPU runtimes")
-            .show(ui, |ui| {
-                ui.label(format!(
-                    "Rigid update: {:.3}ms",
-                    timings.update_rigid_particles
-                ));
-                ui.label(format!("Grid sort: {:.3}ms", timings.grid_sort));
-                ui.label(format!("CDF Grid update: {:.3}ms", timings.grid_update_cdf));
-                ui.label(format!("CDF P2G: {:.3}ms", timings.p2g_cdf));
-                ui.label(format!("CDF G2P: {:.3}ms", timings.g2p_cdf));
-                ui.label(format!("P2G: {:.3}ms", timings.p2g));
-                ui.label(format!("Grid update: {:.3}ms", timings.grid_update));
-                ui.label(format!("G2P: {:.3}ms", timings.g2p));
-                ui.label(format!(
-                    "Particles update: {:.3}ms",
-                    timings.particles_update
-                ));
-                ui.label(format!(
-                    "Integrate bodies: {:.3}ms",
-                    timings.integrate_bodies
-                ));
-            });
+            CollapsingHeader::new(format!("GPU runtime: {:.3}ms", timings.total_time()))
+                .id_salt("GPU runtimes")
+                .show(ui, |ui| {
+                    ui.label(format!(
+                        "Rigid update: {:.3}ms",
+                        timings.update_rigid_particles
+                    ));
+                    ui.label(format!("Grid sort: {:.3}ms", timings.grid_sort));
+                    ui.label(format!("CDF Grid update: {:.3}ms", timings.grid_update_cdf));
+                    ui.label(format!("CDF P2G: {:.3}ms", timings.p2g_cdf));
+                    ui.label(format!("CDF G2P: {:.3}ms", timings.g2p_cdf));
+                    ui.label(format!("P2G: {:.3}ms", timings.p2g));
+                    ui.label(format!("Grid update: {:.3}ms", timings.grid_update));
+                    ui.label(format!("G2P: {:.3}ms", timings.g2p));
+                    ui.label(format!(
+                        "Particles update: {:.3}ms",
+                        timings.particles_update
+                    ));
+                    ui.label(format!(
+                        "Integrate bodies: {:.3}ms",
+                        timings.integrate_bodies
+                    ));
+                });
 
-        ui.horizontal(|ui| {
-            let label = if app_state.run_state == RunState::Paused {
-                "Run"
-            } else {
-                "Pause"
-            };
-
-            if ui.button(label).clicked() {
-                if app_state.run_state == RunState::Paused {
-                    app_state.run_state = RunState::Running
+            ui.horizontal(|ui| {
+                let label = if app_state.run_state == RunState::Paused {
+                    "Run"
                 } else {
-                    app_state.run_state = RunState::Paused
+                    "Pause"
+                };
+
+                if ui.button(label).clicked() {
+                    if app_state.run_state == RunState::Paused {
+                        app_state.run_state = RunState::Running
+                    } else {
+                        app_state.run_state = RunState::Paused
+                    }
                 }
-            }
 
-            if ui.button("Step").clicked() {
-                app_state.run_state = RunState::Step;
-            }
+                if ui.button("Step").clicked() {
+                    app_state.run_state = RunState::Step;
+                }
 
-            if ui.button("Restart").clicked() {
-                scenes.init_scene(&mut commands, app_state.selected_scene);
-                app_state.restarting = true;
-            }
-        });
+                if ui.button("Restart").clicked() {
+                    scenes.init_scene(&mut commands, app_state.selected_scene);
+                    app_state.restarting = true;
+                }
+            });
+        }
     });
 }