Asset loader

examples2d/src/elastic_cut2.rs

@@ -1,4 +1,5 @@
 use wgsparkl2d::rapier::prelude::{ColliderBuilder, RigidBodyBuilder};
+use wgsparkl_testbed2d::load_scene::Dependencies;
 use wgsparkl_testbed2d::{wgsparkl, Callbacks, RapierData};
 
 use bevy::render::renderer::RenderDevice;
@@ -16,6 +17,7 @@ pub fn elastic_cut_demo(
     device: RenderDevice,
     app_state: &mut AppState,
     _callbacks: &mut Callbacks,
+    _assets: &Dependencies,
 ) -> PhysicsContext {
     let mut rapier_data = RapierData::default();
     let device = device.wgpu_device();

examples2d/src/elasticity2.rs

@@ -1,4 +1,5 @@
 use wgsparkl2d::rapier::prelude::{ColliderBuilder, RigidBodyBuilder};
+use wgsparkl_testbed2d::load_scene::Dependencies;
 use wgsparkl_testbed2d::{wgsparkl, Callbacks, RapierData};
 
 use bevy::render::renderer::RenderDevice;
@@ -16,6 +17,7 @@ pub fn elastic_demo(
     device: RenderDevice,
     app_state: &mut AppState,
     _callbacks: &mut Callbacks,
+    _assets: &Dependencies,
 ) -> PhysicsContext {
     let device = device.wgpu_device();
     let mut rapier_data = RapierData::default();

examples2d/src/main.rs

@@ -1,5 +1,8 @@
 use bevy::prelude::*;
-use wgsparkl_testbed2d::{init_testbed, SceneInitFn, SceneInits};
+use wgsparkl_testbed2d::{
+    init_testbed,
+    load_scene::{SceneInitFn, SceneInits, SceneLoadFn},
+};
 
 mod elastic_cut2;
 mod elasticity2;
@@ -18,12 +21,17 @@ pub fn main() {
 }
 
 fn register_scenes(world: &mut World) {
-    let scenes: Vec<(String, SceneInitFn)> = vec![
-        ("sand".to_string(), Box::new(sand2::sand_demo)),
-        ("elastic".to_string(), Box::new(elasticity2::elastic_demo)),
+    let scenes: Vec<(String, SceneInitFn, Option<SceneLoadFn>)> = vec![
+        ("sand".to_string(), Box::new(sand2::sand_demo), None),
+        (
+            "elastic".to_string(),
+            Box::new(elasticity2::elastic_demo),
+            None,
+        ),
         (
             "elastic cut".to_string(),
             Box::new(elastic_cut2::elastic_cut_demo),
+            None,
         ),
     ];
     let mut inits = world.resource_mut::<SceneInits>();

examples2d/src/sand2.rs

@@ -1,4 +1,5 @@
 use wgsparkl2d::rapier::prelude::{ColliderBuilder, RigidBodyBuilder};
+use wgsparkl_testbed2d::load_scene::Dependencies;
 use wgsparkl_testbed2d::{wgsparkl, Callbacks, RapierData};
 
 use bevy::render::renderer::RenderDevice;
@@ -16,6 +17,7 @@ pub fn sand_demo(
     device: RenderDevice,
     app_state: &mut AppState,
     _callbacks: &mut Callbacks,
+    assets: &Dependencies,
 ) -> PhysicsContext {
     let mut rapier_data = RapierData::default();
     let device = device.wgpu_device();

examples3d/src/banana3.rs

@@ -1,31 +1,36 @@
-use std::fs::File;
-use std::io::Read;
-
 use crate::utils::default_scene::{self, SAMPLE_PER_UNIT};
 
 use bevy::color::palettes::css;
 use bevy::{prelude::*, render::renderer::RenderDevice};
-use nalgebra::{vector, Isometry3, Transform3, UnitQuaternion, Vector3};
+use nalgebra::{vector, Isometry3, Point3, Transform3, UnitQuaternion, Vector3};
 use rapier3d::prelude::RigidBodyHandle;
 use rapier3d::prelude::{ColliderBuilder, RigidBodyBuilder, SharedShape, TriMeshFlags};
 use wgsparkl3d::load_mesh3d::load_gltf::{load_model_trimeshes, load_model_with_colors};
 use wgsparkl3d::pipeline::MpmData;
 use wgsparkl3d::solver::SimulationParams;
+use wgsparkl_testbed3d::load_scene::{Dependencies, Loader};
 use wgsparkl_testbed3d::Callbacks;
 use wgsparkl_testbed3d::{AppState, PhysicsContext};
 use wgsparkl_testbed3d::{Callback, RapierData};
 
+pub fn load(loader: &mut Loader) {
+    // banana
+    loader.load_raw_file("banana.glb");
+
+    // slicer
+    loader.load_raw_file("chefs_knife_open_blade.glb");
+}
+
 pub fn demo(
     device: RenderDevice,
     app_state: &mut AppState,
     callbacks: &mut Callbacks,
+    assets: &Dependencies,
 ) -> PhysicsContext {
-    let mut file = File::open("assets/banana.glb").expect("Failed to open GLB file");
-    let mut buffer = Vec::new();
-    file.read_to_end(&mut buffer).expect("Failed to read file");
-
+    // banana
+    let buffer = &assets.get_data("banana.glb").unwrap().data;
     let pc_grid = load_model_with_colors(
-        &buffer,
+        buffer,
         Transform3::from_matrix_unchecked(
             Isometry3::from_parts(
                 Vector3::new(0.0, 2.4, 0.0).into(),
@@ -52,7 +57,7 @@ pub fn demo(
     };
     let mut rapier_data = RapierData::default();
     if !app_state.restarting {
-        app_state.num_substeps = 30;
+        app_state.num_substeps = 20;
         app_state.gravity_factor = 1.0;
     };
     default_scene::spawn_ground_and_walls(&mut rapier_data);
@@ -64,11 +69,8 @@ pub fn demo(
         particles.push(particle);
     }
     // Slicer
-    let mut file =
-        File::open("assets/chefs_knife_open_blade.glb").expect("Failed to open GLB file");
-    let mut buffer = Vec::new();
-    file.read_to_end(&mut buffer).expect("Failed to read file");
-    let mut slicer_trimeshes = load_model_trimeshes(&buffer);
+    let buffer = &assets.get_data("chefs_knife_open_blade.glb").unwrap().data;
+    let mut slicer_trimeshes: Vec<(Vec<Point3<f32>>, Vec<usize>)> = load_model_trimeshes(&buffer);
     slicer_trimeshes.iter_mut().for_each(|trimesh| {
         trimesh.0.iter_mut().for_each(|v| {
             *v *= 10f32;

examples3d/src/elastic_cut3.rs

@@ -1,3 +1,4 @@
+use wgsparkl_testbed3d::load_scene::Dependencies;
 use wgsparkl_testbed3d::{wgsparkl, Callbacks, RapierData};
 
 use bevy::render::renderer::RenderDevice;
@@ -15,6 +16,7 @@ pub fn elastic_cut_demo(
     device: RenderDevice,
     app_state: &mut AppState,
     _callbacks: &mut Callbacks,
+    _assets: &Dependencies,
 ) -> PhysicsContext {
     let mut rapier_data = RapierData::default();
     let device = device.wgpu_device();

examples3d/src/glb_to_point_cloud_color.rs

@@ -2,21 +2,24 @@ use crate::utils::default_scene::{self, SAMPLE_PER_UNIT};
 
 use bevy::{math::Vec3, prelude::*, render::renderer::RenderDevice};
 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, 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/heightfield3.rs

@@ -1,3 +1,4 @@
+use wgsparkl_testbed3d::load_scene::Dependencies;
 use wgsparkl_testbed3d::{wgsparkl, Callbacks, RapierData};
 
 use bevy::render::renderer::RenderDevice;
@@ -16,6 +17,7 @@ pub fn heightfield_demo(
     device: RenderDevice,
     app_state: &mut AppState,
     _callbacks: &mut Callbacks,
+    _assets: &Dependencies,
 ) -> PhysicsContext {
     let mut rapier_data = RapierData::default();
     let device = device.wgpu_device();

examples3d/src/main.rs

@@ -1,5 +1,8 @@
 use bevy::prelude::*;
-use wgsparkl_testbed3d::{init_testbed, SceneInitFn, SceneInits};
+use wgsparkl_testbed3d::{
+    init_testbed,
+    load_scene::{SceneInitFn, SceneInits, SceneLoadFn},
+};
 
 pub mod utils;
 
@@ -22,21 +25,28 @@ pub fn main() {
 }
 
 fn register_scenes(world: &mut World) {
-    let scenes: Vec<(String, SceneInitFn)> = vec![
-        ("sand".to_string(), Box::new(sand3::sand_demo)),
+    let scenes: Vec<(String, SceneInitFn, Option<SceneLoadFn>)> = vec![
+        ("sand".to_string(), Box::new(sand3::sand_demo), None),
         (
             "heightfield".to_string(),
             Box::new(heightfield3::heightfield_demo),
+            None,
         ),
         (
             "elastic_cut".to_string(),
             Box::new(elastic_cut3::elastic_cut_demo),
+            None,
         ),
         (
             "elastic_model_colors".to_string(),
             Box::new(glb_to_point_cloud_color::elastic_color_model_demo),
+            Some(Box::new(glb_to_point_cloud_color::load)),
+        ),
+        (
+            "taichi_banana".to_string(),
+            Box::new(banana3::demo),
+            Some(Box::new(banana3::load)),
         ),
-        ("taichi_banana".to_string(), Box::new(banana3::demo)),
     ];
     let mut inits = world.resource_mut::<SceneInits>();
     inits.scenes = scenes;

examples3d/src/sand3.rs

@@ -1,3 +1,4 @@
+use wgsparkl_testbed3d::load_scene::Dependencies;
 use wgsparkl_testbed3d::{wgsparkl, Callbacks, RapierData};
 
 use bevy::render::renderer::RenderDevice;
@@ -15,6 +16,7 @@ pub fn sand_demo(
     device: RenderDevice,
     app_state: &mut AppState,
     _callbacks: &mut Callbacks,
+    _assets: &Dependencies,
 ) -> PhysicsContext {
     let mut rapier_data = RapierData::default();
     let device = device.wgpu_device();

src_testbed/file_loader.rs

@@ -0,0 +1,54 @@
+use bevy::{
+    asset::{io::Reader, Asset, AssetLoader, LoadContext},
+    reflect::Reflect,
+};
+
+#[derive(Asset, Reflect, Debug, Default, Clone)]
+#[reflect(opaque)]
+#[reflect(Debug)]
+pub struct FileBytes {
+    pub data: Vec<u8>,
+}
+
+#[derive(Asset, Reflect, Debug, Default, Clone)]
+pub struct FileBytesLoader;
+
+#[non_exhaustive]
+#[derive(Debug)]
+pub enum FileBytesLoaderError {
+    Unknown,
+}
+
+impl core::fmt::Display for FileBytesLoaderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "FileBytesLoaderError")
+    }
+}
+
+impl core::error::Error for FileBytesLoaderError {}
+
+impl AssetLoader for FileBytesLoader {
+    type Asset = FileBytes;
+    type Settings = ();
+    type Error = FileBytesLoaderError;
+
+    async fn load(
+        &self,
+        reader: &mut dyn Reader,
+        _settings: &(),
+        _load_context: &mut LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let mut bytes = Vec::new();
+
+        reader
+            .read_to_end(&mut bytes)
+            .await
+            .map_err(|_| FileBytesLoaderError::Unknown)?;
+
+        Ok(FileBytes { data: bytes })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["gltf", "glb"]
+    }
+}