feat: material shuffling /w dynamic material-grid

README.md

@@ -36,5 +36,6 @@ bevy zeroverse synthetic dataset generator plugin. view the [live demo](https://
 
 ## credits
 
+- [lgm](https://github.com/3DTopia/LGM)
 - [mat-synth](https://huggingface.co/datasets/gvecchio/MatSynth)
 - [zeroverse](https://github.com/desaixie/zeroverse)

src/material.rs

@@ -11,15 +11,24 @@ pub struct ZeroverseMaterials {
 }
 
 
+#[derive(Event)]
+pub struct ShuffleMaterialsEvent;
+
+#[derive(Event)]
+pub struct MaterialsLoadedEvent;
+
+
 pub struct ZeroverseMaterialPlugin;
 
 impl Plugin for ZeroverseMaterialPlugin {
     fn build(&self, app: &mut App) {
+        app.add_event::<MaterialsLoadedEvent>();
+        app.add_event::<ShuffleMaterialsEvent>();
+
         app.init_resource::<ZeroverseMaterials>();
 
         app.add_systems(PreStartup, load_materials);
-
-        // TODO: add event to load next material batch
+        app.add_systems(PostUpdate, reload_materials);
     }
 }
 
@@ -45,22 +54,29 @@ fn get_material_roots() -> Vec<PathBuf> {
     let asset_server_path = cwd.join("./assets");
     let pattern = format!("{}/**/**/basecolor.jpg", asset_server_path.to_string_lossy());
 
-    glob::glob(&pattern)
+    let available: Vec<PathBuf> = glob::glob(&pattern)
         .expect("failed to read glob pattern")
         .filter_map(Result::ok)
         .filter_map(|path| {
             path.parent()
                 .and_then(|parent| parent.strip_prefix(&asset_server_path).ok())
                 .map(std::path::Path::to_path_buf)
         })
+        .collect::<Vec<_>>();
+
+    info!("found {} materials", available.len());
+
+    available.into_iter()
         .choose_multiple(&mut rand::thread_rng(), 100)
 }
 
+
 // TODO: support batched loading to avoid GPU RAM exhaustion
 fn load_materials(
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut zeroverse_materials: ResMut<ZeroverseMaterials>,
+    mut load_event: EventWriter<MaterialsLoadedEvent>,
 ) {
     let rng = &mut rand::thread_rng();
 
@@ -97,4 +113,33 @@ fn load_materials(
     }
 
     info!("loaded {} materials", zeroverse_materials.materials.len());
+
+    load_event.send(MaterialsLoadedEvent);
+}
+
+
+fn reload_materials(
+    asset_server: Res<AssetServer>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+    mut zeroverse_materials: ResMut<ZeroverseMaterials>,
+    mut shuffle_events: EventReader<ShuffleMaterialsEvent>,
+    load_event: EventWriter<MaterialsLoadedEvent>,
+) {
+    if shuffle_events.is_empty() {
+        return;
+    }
+
+    shuffle_events.clear();
+
+    for material in zeroverse_materials.materials.iter() {
+        materials.remove(material);
+    }
+    zeroverse_materials.materials.clear();
+
+    load_materials(
+        asset_server,
+        materials,
+        zeroverse_materials,
+        load_event,
+    );
 }

tools/viewer.rs

@@ -32,7 +32,11 @@ use bevy::core_pipeline::experimental::taa::{
 
 use bevy_zeroverse::{
     BevyZeroversePlugin,
-    material::ZeroverseMaterials,
+    material::{
+        MaterialsLoadedEvent,
+        ShuffleMaterialsEvent,
+        ZeroverseMaterials,
+    },
     primitive::PrimitiveSettings,
 };
 
@@ -154,6 +158,9 @@ fn viewer_app() {
 
     app.add_systems(Startup, setup_camera);
     app.add_systems(Startup, setup_primitives);
+
+    app.add_systems(PreUpdate, press_m_shuffle_materials);
+    app.add_systems(PreUpdate, setup_material_grid);
     app.add_systems(PostUpdate, regenerate_scene_system);
 
     app.run();
@@ -162,9 +169,6 @@ fn viewer_app() {
 fn setup_camera(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
-    args: Res<BevyZeroverseViewer>,
-    standard_materials: Res<Assets<StandardMaterial>>,
-    zeroverse_materials: Res<ZeroverseMaterials>,
 ) {
     #[allow(unused_mut)]
     let mut camera = commands.spawn((
@@ -208,8 +212,6 @@ fn setup_camera(
         TemporalAntiAliasBundle::default(),
     ));
 
-    let camera = camera.id();
-
 
     // TODO: move lighting to procedural scene plugin
     commands.spawn(DirectionalLightBundle {
@@ -220,7 +222,28 @@ fn setup_camera(
         },
         ..default()
     });
+}
+
+
+#[derive(Component)]
+struct MaterialGrid;
+
+fn setup_material_grid(
+    mut commands: Commands,
+    args: Res<BevyZeroverseViewer>,
+    standard_materials: Res<Assets<StandardMaterial>>,
+    zeroverse_materials: Res<ZeroverseMaterials>,
+    material_grids: Query<Entity, With<MaterialGrid>>,
+    mut materials_loaded: EventReader<MaterialsLoadedEvent>,
+) {
+    if materials_loaded.is_empty() {
+        return;
+    }
+    materials_loaded.clear();
 
+    if !material_grids.is_empty() {
+        commands.entity(material_grids.single()).despawn_recursive();
+    }
 
     if args.material_grid {
         let material_count = zeroverse_materials.materials.len();
@@ -261,8 +284,7 @@ fn setup_camera(
                     ..default()
                 });
             }
-        })
-        .insert(TargetCamera(camera));
+        }).insert(MaterialGrid);
     }
 }
 
@@ -307,6 +329,16 @@ fn regenerate_scene_system(
 }
 
 
+fn press_m_shuffle_materials(
+    keys: Res<ButtonInput<KeyCode>>,
+    mut shuffle_events: EventWriter<ShuffleMaterialsEvent>,
+) {
+    if keys.just_pressed(KeyCode::KeyM) {
+        shuffle_events.send(ShuffleMaterialsEvent);
+    }
+}
+
+
 fn press_esc_close(
     keys: Res<ButtonInput<KeyCode>>,
     mut exit: EventWriter<AppExit>