Enhance many_cubes stress test use cases

Default to the sphere layout as it is more useful for benchmarking.

Add a benchmark mode that advances the camera by a fixed step to render the
same frames across runs.

Add an option to vary the material data per-instance. The color is randomized.

Add an option to generate a number of textures and randomly choose one per
instance.

Use seeded Xoshiro256StarStar for reproducible random numbers.

Author: superdump

Cargo.toml

@@ -254,13 +254,15 @@ bevy_internal = { path = "crates/bevy_internal", version = "0.12.0-dev", default
 
 [dev-dependencies]
 anyhow = "1.0.4"
-rand = "0.8.0"
+rand = { version = "0.8.0", features = ["small_rng"] }
 ron = "0.8.0"
 serde = { version = "1", features = ["derive"] }
 bytemuck = "1.7"
 # Needed to poll Task examples
 futures-lite = "1.11.3"
 crossbeam-channel = "0.5.0"
+clap = { version = "4.4.0", features = ["derive"] }
+rand_xoshiro = "0.6.0"
 
 [[example]]
 name = "hello_world"

examples/stress_tests/many_cubes.rs

@@ -18,8 +18,41 @@ use bevy::{
     prelude::*,
     window::{PresentMode, WindowPlugin},
 };
+use bevy_internal::render::render_resource::{Extent3d, TextureDimension, TextureFormat};
+use clap::{Parser, ValueEnum};
+use rand::{seq::SliceRandom, Rng, RngCore, SeedableRng};
+use rand_xoshiro::Xoshiro256StarStar;
+
+#[derive(Parser, Resource)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// How the cube instances should be positioned.
+    #[arg(short, long, value_enum, default_value_t=Layout::Sphere)]
+    layout: Layout,
+
+    /// Whether to step the camera animation by a fixed amount such that each frame is the same across runs.
+    #[arg(short, long, default_value_t = false)]
+    benchmark: bool,
+
+    /// Whether to vary the material data in each instance.
+    #[arg(short, long, default_value_t = false)]
+    vary_material_data: bool,
+
+    /// The number of different textures from which to randomly select the material base color. 0 means no textures.
+    #[arg(short, long, default_value_t = 0)]
+    material_texture_count: usize,
+}
+
+#[derive(Default, Clone, ValueEnum)]
+enum Layout {
+    Cube,
+    #[default]
+    Sphere,
+}
 
 fn main() {
+    let args = Args::parse();
+
     App::new()
         .add_plugins((
             DefaultPlugins.set(WindowPlugin {
@@ -32,28 +65,47 @@ fn main() {
             FrameTimeDiagnosticsPlugin,
             LogDiagnosticsPlugin::default(),
         ))
+        .insert_resource(args)
         .add_systems(Startup, setup)
         .add_systems(Update, (move_camera, print_mesh_count))
         .run();
 }
 
 fn setup(
     mut commands: Commands,
+    args: Res<Args>,
     mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
+    materials: ResMut<Assets<StandardMaterial>>,
+    images: ResMut<Assets<Image>>,
 ) {
     warn!(include_str!("warning_string.txt"));
 
+    let args = args.into_inner();
+    let images = images.into_inner();
+    let materials = materials.into_inner();
+
     const WIDTH: usize = 200;
     const HEIGHT: usize = 200;
+
     let mesh = meshes.add(Mesh::from(shape::Cube { size: 1.0 }));
-    let material = materials.add(StandardMaterial {
-        base_color: Color::PINK,
-        ..default()
-    });
 
-    match std::env::args().nth(1).as_deref() {
-        Some("sphere") => {
+    let material_textures = init_textures(args, images);
+
+    let material = materials.add(Color::PINK.into());
+    let mut texture_rng = Xoshiro256StarStar::seed_from_u64(42);
+    let texture_material = if args.material_texture_count == 1 {
+        Some(materials.add(StandardMaterial {
+            base_color: Color::WHITE,
+            base_color_texture: get_texture(args, &mut texture_rng, &material_textures),
+            ..default()
+        }))
+    } else {
+        None
+    };
+
+    let mut color_rng = Xoshiro256StarStar::seed_from_u64(42);
+    match args.layout {
+        Layout::Sphere => {
             // NOTE: This pattern is good for testing performance of culling as it provides roughly
             // the same number of visible meshes regardless of the viewing angle.
             const N_POINTS: usize = WIDTH * HEIGHT * 4;
@@ -66,7 +118,15 @@ fn setup(
                 let unit_sphere_p = spherical_polar_to_cartesian(spherical_polar_theta_phi);
                 commands.spawn(PbrBundle {
                     mesh: mesh.clone_weak(),
-                    material: material.clone_weak(),
+                    material: get_material(
+                        args,
+                        &material,
+                        texture_material.as_ref(),
+                        materials,
+                        &mut color_rng,
+                        &mut texture_rng,
+                        &material_textures,
+                    ),
                     transform: Transform::from_translation((radius * unit_sphere_p).as_vec3()),
                     ..default()
                 });
@@ -87,13 +147,29 @@ fn setup(
                     // cube
                     commands.spawn(PbrBundle {
                         mesh: mesh.clone_weak(),
-                        material: material.clone_weak(),
+                        material: get_material(
+                            args,
+                            &material,
+                            texture_material.as_ref(),
+                            materials,
+                            &mut color_rng,
+                            &mut texture_rng,
+                            &material_textures,
+                        ),
                         transform: Transform::from_xyz((x as f32) * 2.5, (y as f32) * 2.5, 0.0),
                         ..default()
                     });
                     commands.spawn(PbrBundle {
                         mesh: mesh.clone_weak(),
-                        material: material.clone_weak(),
+                        material: get_material(
+                            args,
+                            &material,
+                            texture_material.as_ref(),
+                            materials,
+                            &mut color_rng,
+                            &mut texture_rng,
+                            &material_textures,
+                        ),
                         transform: Transform::from_xyz(
                             (x as f32) * 2.5,
                             HEIGHT as f32 * 2.5,
@@ -103,13 +179,29 @@ fn setup(
                     });
                     commands.spawn(PbrBundle {
                         mesh: mesh.clone_weak(),
-                        material: material.clone_weak(),
+                        material: get_material(
+                            args,
+                            &material,
+                            texture_material.as_ref(),
+                            materials,
+                            &mut color_rng,
+                            &mut texture_rng,
+                            &material_textures,
+                        ),
                         transform: Transform::from_xyz((x as f32) * 2.5, 0.0, (y as f32) * 2.5),
                         ..default()
                     });
                     commands.spawn(PbrBundle {
                         mesh: mesh.clone_weak(),
-                        material: material.clone_weak(),
+                        material: get_material(
+                            args,
+                            &material,
+                            texture_material.as_ref(),
+                            materials,
+                            &mut color_rng,
+                            &mut texture_rng,
+                            &material_textures,
+                        ),
                         transform: Transform::from_xyz(0.0, (x as f32) * 2.5, (y as f32) * 2.5),
                         ..default()
                     });
@@ -139,6 +231,64 @@ fn setup(
     commands.spawn(DirectionalLightBundle { ..default() });
 }
 
+fn init_textures(args: &Args, images: &mut Assets<Image>) -> Vec<Handle<Image>> {
+    let mut color_bytes: Vec<u8> = vec![0u8; args.material_texture_count * 4];
+    Xoshiro256StarStar::seed_from_u64(42).fill_bytes(&mut color_bytes);
+    color_bytes
+        .chunks_mut(4)
+        .map(|p| {
+            p[3] = 255;
+            images.add(Image::new_fill(
+                Extent3d {
+                    width: 1,
+                    height: 1,
+                    depth_or_array_layers: 1,
+                },
+                TextureDimension::D2,
+                p,
+                TextureFormat::Rgba8UnormSrgb,
+            ))
+        })
+        .collect()
+}
+
+fn get_texture<R: Rng + ?Sized>(
+    args: &Args,
+    texture_rng: &mut R,
+    material_textures: &[Handle<Image>],
+) -> Option<Handle<Image>> {
+    match args.material_texture_count {
+        c if c == 0 => None,
+        c if c == 1 => Some(material_textures[0].clone_weak()),
+        _ => Some(material_textures.choose(texture_rng).unwrap().clone_weak()),
+    }
+}
+
+fn get_material<R: Rng + ?Sized>(
+    args: &Args,
+    material: &Handle<StandardMaterial>,
+    texture_material: Option<&Handle<StandardMaterial>>,
+    materials: &mut Assets<StandardMaterial>,
+    color_rng: &mut R,
+    texture_rng: &mut R,
+    material_textures: &[Handle<Image>],
+) -> Handle<StandardMaterial> {
+    match (args.vary_material_data, args.material_texture_count) {
+        (false, 0) => material.clone_weak(),
+        (false, 1) => texture_material.unwrap().clone_weak(),
+        (false, _) => materials.add(StandardMaterial {
+            base_color: Color::WHITE,
+            base_color_texture: get_texture(args, texture_rng, material_textures),
+            ..default()
+        }),
+        (true, _) => materials.add(StandardMaterial {
+            base_color: Color::rgb_u8(color_rng.gen(), color_rng.gen(), color_rng.gen()),
+            base_color_texture: get_texture(args, texture_rng, material_textures),
+            ..default()
+        }),
+    }
+}
+
 // NOTE: This epsilon value is apparently optimal for optimizing for the average
 // nearest-neighbor distance. See:
 // http://extremelearning.com.au/how-to-evenly-distribute-points-on-a-sphere-more-effectively-than-the-canonical-fibonacci-lattice/
@@ -159,9 +309,18 @@ fn spherical_polar_to_cartesian(p: DVec2) -> DVec3 {
 }
 
 // System for rotating the camera
-fn move_camera(time: Res<Time>, mut camera_query: Query<&mut Transform, With<Camera>>) {
+fn move_camera(
+    time: Res<Time>,
+    args: Res<Args>,
+    mut camera_query: Query<&mut Transform, With<Camera>>,
+) {
     let mut camera_transform = camera_query.single_mut();
-    let delta = time.delta_seconds() * 0.15;
+    let delta = 0.15
+        * if args.benchmark {
+            1.0 / 60.0
+        } else {
+            time.delta_seconds()
+        };
     camera_transform.rotate_z(delta);
     camera_transform.rotate_x(delta);
 }