nightshade-api 0.42.0

use nightshade_api::prelude::*;
use std::time::{Duration, Instant};

const CUBE_COUNT: usize = 500;
const PHASE_FRAMES: u32 = 300;

fn main() {
    let mut app = open();
    show_grid(&mut app.world, false);
    orbit_camera(&mut app.world, vec3(0.0, 0.5, 0.0), 45.0);

    let positions = grid_positions();
    let mut entities = spawn_objects(
        &mut app.world,
        Object {
            color: TEAL,
            ..Object::default()
        },
        &positions,
    );

    let label = spawn_text(
        &mut app.world,
        "phase 1: api spelling",
        ScreenAnchor::TopLeft,
    );

    let mut frame_index = 0u32;
    let mut api_total = Duration::ZERO;
    let mut api_frames = 0u32;
    let mut longhand_total = Duration::ZERO;
    let mut longhand_frames = 0u32;

    while frame(&mut app) {
        let step = delta_time(&app.world);
        if frame_index < PHASE_FRAMES {
            let start = Instant::now();
            for &entity in &entities {
                rotate(&mut app.world, entity, Vec3::y(), step);
            }
            api_total += start.elapsed();
            api_frames += 1;
            if frame_index + 1 == PHASE_FRAMES {
                for &entity in &entities {
                    despawn(&mut app.world, entity);
                }
                entities = longhand::spawn_grid(&mut app.world, &positions, ORANGE);
                app.world.resources.mesh_render_state.request_full_rebuild();
                set_text(&mut app.world, label, "phase 2: longhand spelling");
            }
        } else {
            let start = Instant::now();
            for &entity in &entities {
                longhand::rotate(&mut app.world, entity, Vec3::y(), step);
            }
            longhand_total += start.elapsed();
            longhand_frames += 1;
            if frame_index + 1 == PHASE_FRAMES * 2 {
                break;
            }
        }
        frame_index += 1;
    }

    report("api", api_total, api_frames);
    report("longhand", longhand_total, longhand_frames);
}

fn report(name: &str, total: Duration, frames: u32) {
    if frames == 0 {
        println!("{name}: no frames measured");
        return;
    }
    let milliseconds = total.as_secs_f64() * 1000.0 / frames as f64;
    println!(
        "{name}: {CUBE_COUNT} cubes rotated in {milliseconds:.4} ms per frame average over {frames} frames"
    );
}

fn grid_positions() -> Vec<Vec3> {
    let mut positions = Vec::with_capacity(CUBE_COUNT);
    for row in 0..20 {
        for column in 0..25 {
            positions.push(vec3(
                column as f32 * 2.0 - 24.0,
                0.5,
                row as f32 * 2.0 - 19.0,
            ));
        }
    }
    positions
}

mod longhand {
    use nightshade_api::nightshade;
    use nightshade_api::nightshade::prelude::*;

    pub fn spawn_grid(world: &mut World, positions: &[Vec3], color: [f32; 4]) -> Vec<Entity> {
        let material_name = nightshade::ecs::material::resources::material_registry_find_or_insert(
            &mut world.resources.assets.material_registry,
            "parity::longhand".to_string(),
            Material {
                base_color: color,
                ..Default::default()
            },
        );
        let mut entities = Vec::with_capacity(positions.len());
        for &position in positions {
            let entity = spawn_mesh_at(world, "Cube", position, Vec3::new(1.0, 1.0, 1.0));
            let previous = world
                .core
                .get_material_ref(entity)
                .map(|material_ref| material_ref.name.clone());
            if let Some(previous_name) = previous
                && let Some((index, _)) = registry_lookup_index(
                    &world.resources.assets.material_registry.registry,
                    &previous_name,
                )
            {
                registry_remove_reference(
                    &mut world.resources.assets.material_registry.registry,
                    index,
                );
            }
            if let Some((index, _)) = registry_lookup_index(
                &world.resources.assets.material_registry.registry,
                &material_name,
            ) {
                registry_add_reference(
                    &mut world.resources.assets.material_registry.registry,
                    index,
                );
            }
            world
                .core
                .set_material_ref(entity, MaterialRef::new(material_name.clone()));
            world.resources.mesh_render_state.mark_entity_added(entity);
            entities.push(entity);
        }
        entities
    }

    pub fn rotate(world: &mut World, entity: Entity, axis: Vec3, radians: f32) {
        if let Some(transform) = mutate_local_transform(world, entity) {
            transform.rotation =
                nalgebra_glm::quat_angle_axis(radians, &axis.normalize()) * transform.rotation;
        }
    }
}