linear-sim 0.7.0

//! Program state machine

use {glium, log, rand_xorshift};

use rand_xorshift::XorShiftRng;

use macro_machines::def_machine_nodefault;
use gl_utils::*;

use crate::{bounding_volume, penetration, simulation};

use simulation::Simulation;

def_machine_nodefault!{
  Testbed (
    render_context : Render <render::resource::Default>,
    rng            : XorShiftRng = rand::SeedableRng::seed_from_u64 (0),
    running        : bool = true
  ) @ testbed {
////////////////////////////////////////////////////////////////////////////////
//  states                                                                    //
////////////////////////////////////////////////////////////////////////////////
    STATES [

      //
      // Drop test demo: drops a dynamic object onto a static object
      //
      state SimulationDropTest (
        playback   : simulation::Playback,
        simulation : Simulation = simulation::init_drop_test (render_context)
      )

      //
      // Capsule v. capsule collision
      //
      state SimulationCollideCapsuleCapsule (
        playback              : simulation::Playback,
        simulation_generation : (Simulation, u64) = {
          let (simulation, generation) =
            simulation::init_collide_capsule_capsule (render_context, rng);
          log::info!("simulation collide capsule capsule generation [{generation}]");
          (simulation, generation)
        }
      )

      //
      // Stack test demo: stacks dynamic objects
      //
      state SimulationStackTest (
        playback   : simulation::Playback,
        simulation : Simulation = simulation::init_stack_test (render_context)
      )

      //
      // BallPit test demo: drop spheres into container
      //
      state SimulationBallPitTest (
        playback              : simulation::Playback,
        simulation_generation : (Simulation, u64) = {
          let (simulation, generation) =
            simulation::init_ball_pit_test (render_context, rng);
          log::info!("simulation ball pit generation [{generation}]");
          (simulation, generation)
        }
      )

      //
      // HullPit test demo: drop hulls into container
      //
      state SimulationHullPitTest (
        playback              : simulation::Playback,
        simulation_generation : (Simulation, u64) = {
          let (simulation, generation) =
            simulation::init_hull_pit_test (render_context, rng);
          log::info!("simulation hull pit generation [{generation}]");
          (simulation, generation)
        }
      )

      //
      // Resolve positions of intersecting capsules with mass
      //
      state PenetrationCapsuleCapsule (
        // lines to show delta position of resolved capsules
        center_indices_lines : glium::IndexBuffer <u32> = {
          use render::resource::draw3d::MeshId;
          let capsule_range = render_context.resource.draw3d.instanced_meshes()
            [MeshId::Capsule as usize].instances_range.clone();
          glium::IndexBuffer::new (
            &render_context.glium_display,
            glium::index::PrimitiveType::LinesList,
            &[capsule_range.start,     capsule_range.start + 2,
              capsule_range.start + 1, capsule_range.start + 3]
          ).unwrap()
        }
      )

      //
      // Resolve positions of intersecting cuboids with mass
      //
      state PenetrationCuboidCuboid (
        // lines to show delta position of resolved shapes
        center_indices_lines : glium::IndexBuffer <u32> = {
          let cuboid_range  = render_context.resource.draw3d
            .instanced_aabb_lines().clone();
          glium::IndexBuffer::new (
            &render_context.glium_display,
            glium::index::PrimitiveType::LinesList,
            &[cuboid_range.start,     cuboid_range.start + 2,
              cuboid_range.start + 1, cuboid_range.start + 3]
          ).unwrap()
        }
      )

      //
      // Resolve positions of intersecting capsule and cuboid
      //
      state PenetrationCapsuleCuboid (
        // lines to show delta position of resolved shapes
        center_indices_lines : glium::IndexBuffer <u32> = {
          use render::resource::draw3d::MeshId;
          let capsule_range = render_context.resource.draw3d.instanced_meshes()
            [MeshId::Capsule as usize].instances_range.clone();
          let cuboid_range  = render_context.resource.draw3d
            .instanced_aabb_lines().clone();
          glium::IndexBuffer::new (
            &render_context.glium_display,
            glium::index::PrimitiveType::LinesList,
            &[capsule_range.start, capsule_range.start + 1,
              cuboid_range.start,  cuboid_range.start  + 1]
          ).unwrap()
        }
      )

      //
      // Resolve positions of intersecting triangles
      //
      state PenetrationTriangleTriangle ()

      //
      // Resolve positions of intersecting convex hulls
      //
      state PenetrationHullHull ()

      //
      // Compute oriented bounding boxes
      //
      state BoundingVolumeObb ()

    ]
////////////////////////////////////////////////////////////////////////////////
//  events                                                                    //
////////////////////////////////////////////////////////////////////////////////
    EVENTS [

      //
      // SimulationDropTest events
      //
      // Transition from any state to simulation drop test
      event ToSimulationDropTest <*> => <SimulationDropTest> ()
      // Set the single step flag
      event StepSimulationDropTest <SimulationDropTest> ()
        { playback } => { playback.single_step = true; }
      // Set the single step reverse flag
      event StepReverseSimulationDropTest <SimulationDropTest> ()
        { playback } => { playback.single_step_reverse = true; }
      // Pause simulation
      event PauseSimulationDropTest <SimulationDropTest> ()
        { playback } => { playback.paused = true; }
      // Unpause simulation
      event ResumeSimulationDropTest <SimulationDropTest> ()
        { playback } => { playback.paused = false; }
      // Simulation update
      event UpdateSimulationDropTest <SimulationDropTest> () {
        simulation, playback
      } => {
        simulation::update (render_context, playback, simulation)
      }
      // Restart simulation
      event RestartSimulationDropTest <SimulationDropTest> () {
        simulation
      } => { simulation::restart_drop_test (render_context, simulation) }

      //
      // SimulationCollideCapsuleCapsule events
      //
      // Transition from any state to simulation capsule v. capsule collision
      event ToSimulationCollideCapsuleCapsule
        <*> => <SimulationCollideCapsuleCapsule> ()
      // Set the single step flag
      event StepSimulationCollideCapsuleCapsule
        <SimulationCollideCapsuleCapsule> ()
        { playback } => { playback.single_step = true; }
      // Set the single step reverse flag
      event StepReverseSimulationCollideCapsuleCapsule
        <SimulationCollideCapsuleCapsule> ()
        { playback } => { playback.single_step_reverse = true; }
      // Pause simulation
      event PauseSimulationCollideCapsuleCapsule
        <SimulationCollideCapsuleCapsule> ()
        { playback } => { playback.paused = true; }
      // Unpause simulation
      event ResumeSimulationCollideCapsuleCapsule
        <SimulationCollideCapsuleCapsule> ()
        { playback } => { playback.paused = false; }
      // Simulation update
      event UpdateSimulationCollideCapsuleCapsule
        <SimulationCollideCapsuleCapsule> ()
      { simulation_generation, playback } => {
        simulation::update (render_context, playback, &mut simulation_generation.0)
      }
      // Generate new random capsule collision
      event NextSimulationCollideCapsuleCapsule
        <SimulationCollideCapsuleCapsule> ()
      { simulation_generation } => {
        let (simulation, generation_counter) = simulation_generation;
        *simulation = Simulation::new_collide_capsule_capsule (rng);
        *generation_counter += 1;
        log::info!("simulation collide capsule capsule generation [{generation_counter}]");
      }
      // Restart simulation
      event RestartSimulationCollideCapsuleCapsule
        <SimulationCollideCapsuleCapsule> ()
      { simulation_generation } => {
        simulation::restart_collide_capsule_capsule (render_context,
          &mut simulation_generation.0)
      }

      //
      // SimulationStackTest events
      //
      // Transition from any state to simulation stack test
      event ToSimulationStackTest <*> => <SimulationStackTest> ()
      // Set the single step flag
      event StepSimulationStackTest <SimulationStackTest> ()
        { playback } => { playback.single_step = true; }
      // Set the single step reverse flag
      event StepReverseSimulationStackTest <SimulationStackTest> ()
        { playback } => { playback.single_step_reverse = true; }
      // Pause simulation
      event PauseSimulationStackTest <SimulationStackTest> ()
        { playback } => { playback.paused = true; }
      // Unpause simulation
      event ResumeSimulationStackTest <SimulationStackTest> ()
        { playback } => { playback.paused = false; }
      // Simulation update
      event UpdateSimulationStackTest <SimulationStackTest> () {
        simulation, playback
      } => {
        simulation::update (render_context, playback, simulation)
      }
      // Restart simulation
      event RestartSimulationStackTest <SimulationStackTest> () {
        simulation
      } => { simulation::restart_stack_test (render_context, simulation) }

      //
      // SimulationBallPitTest events
      //
      // Transition from any state to simulation ball_pit test
      event ToSimulationBallPitTest <*> => <SimulationBallPitTest> ()
      // Set the single step flag
      event StepSimulationBallPitTest <SimulationBallPitTest> ()
        { playback } => { playback.single_step = true; }
      // Set the single step reverse flag
      event StepReverseSimulationBallPitTest <SimulationBallPitTest> ()
        { playback } => { playback.single_step_reverse = true; }
      // Pause simulation
      event PauseSimulationBallPitTest <SimulationBallPitTest> ()
        { playback } => { playback.paused = true; }
      // Unpause simulation
      event ResumeSimulationBallPitTest <SimulationBallPitTest> ()
        { playback } => { playback.paused = false; }
      // Simulation update
      event UpdateSimulationBallPitTest <SimulationBallPitTest> () {
        simulation_generation, playback
      } => {
        simulation::update (render_context, playback, &mut simulation_generation.0)
      }
      // Restart simulation
      event RestartSimulationBallPitTest <SimulationBallPitTest> () {
        simulation_generation
      } => {
        simulation::restart_ball_pit_test (render_context, &mut simulation_generation.0)
      }
      // Generate new random ball pit test
      event NextSimulationBallPitTest
        <SimulationBallPitTest> ()
      { simulation_generation }  => {
        let (simulation, generation_counter) = simulation_generation;
        *simulation = Simulation::new_ball_pit_test (rng);
        *generation_counter += 1;
        log::info!("simulation ball pit test generation [{generation_counter}]");
      }

      //
      // SimulationHullPitTest events
      //
      // Transition from any state to simulation hull_pit test
      event ToSimulationHullPitTest <*> => <SimulationHullPitTest> ()
      // Set the single step flag
      event StepSimulationHullPitTest <SimulationHullPitTest> ()
        { playback } => { playback.single_step = true; }
      // Set the single step reverse flag
      event StepReverseSimulationHullPitTest <SimulationHullPitTest> ()
        { playback } => { playback.single_step_reverse = true; }
      // Pause simulation
      event PauseSimulationHullPitTest <SimulationHullPitTest> ()
        { playback } => { playback.paused = true; }
      // Unpause simulation
      event ResumeSimulationHullPitTest <SimulationHullPitTest> ()
        { playback } => { playback.paused = false; }
      // Simulation update
      event UpdateSimulationHullPitTest <SimulationHullPitTest> () {
        simulation_generation, playback
      } => {
        simulation::update (render_context, playback, &mut simulation_generation.0)
      }
      // Restart simulation
      event RestartSimulationHullPitTest <SimulationHullPitTest> () {
        simulation_generation
      } => {
        simulation::restart_hull_pit_test (render_context, &mut simulation_generation.0)
      }
      // Generate new random hull pit test
      event NextSimulationHullPitTest
        <SimulationHullPitTest> ()
      { simulation_generation }  => {
        let (simulation, generation_counter) = simulation_generation;
        *simulation = Simulation::new_hull_pit_test (rng);
        *generation_counter += 1;
        log::info!("simulation hull pit test generation [{generation_counter}]");
      }
      //
      // PenetrationCapsuleCapsule events
      //
      // Transition from any state to penetration resolve capsule/capsule state
      event ToPenetrationCapsuleCapsule <*> => <PenetrationCapsuleCapsule> ()
        {} => { penetration::init_capsule_capsule (render_context, rng) }
      // Generate and resolve the next random capsule pair
      event NextPenetrationCapsuleCapsule <PenetrationCapsuleCapsule> ()
        {} => { penetration::next_capsule_capsule (render_context, rng) }
      // Draw a penetration resolve capsule/capsule frame
      event DrawPenetrationCapsuleCapsule <PenetrationCapsuleCapsule>
        (glium_frame : &'event mut glium::Frame)
      { center_indices_lines } => {
        penetration::draw_capsule_capsule (
          render_context, glium_frame, center_indices_lines)
      }

      //
      // PenetrationCuboidCuboid events
      //
      // Transition from any state to penetration resolve cuboid/cuboid state
      event ToPenetrationCuboidCuboid <*> => <PenetrationCuboidCuboid> ()
        {} => { penetration::init_cuboid_cuboid (render_context, rng) }
      // Generate and resolve the next random cuboid pair
      event NextPenetrationCuboidCuboid <PenetrationCuboidCuboid> ()
        {} => { penetration::next_cuboid_cuboid (render_context, rng) }
      // Draw a penetration resolve cuboid/cuboid frame
      event DrawPenetrationCuboidCuboid <PenetrationCuboidCuboid>
        (glium_frame : &'event mut glium::Frame)
      { center_indices_lines } => {
        penetration::draw_cuboid_cuboid (
          render_context, glium_frame, center_indices_lines)
      }

      //
      // PenetrationCapsuleCuboid events
      //
      // Transition from any state to penetration resolve capsule/cuboid state
      event ToPenetrationCapsuleCuboid <*> => <PenetrationCapsuleCuboid> ()
        {} => { penetration::init_capsule_cuboid (render_context, rng) }
      // Generate and resolve the next random capsule/abb pair
      event NextPenetrationCapsuleCuboid <PenetrationCapsuleCuboid> ()
        {} => { penetration::next_capsule_cuboid (render_context, rng) }
      // Draw a penetration resolve capsule/cuboid frame
      event DrawPenetrationCapsuleCuboid <PenetrationCapsuleCuboid>
        (glium_frame : &'event mut glium::Frame)
      { center_indices_lines } => {
        penetration::draw_capsule_cuboid (
          render_context, glium_frame, center_indices_lines)
      }

      //
      // PenetrationTriangleTriangle events
      //
      // Transition from any state to penetration resolve triangle/triangle state
      event ToPenetrationTriangleTriangle <*> => <PenetrationTriangleTriangle> ()
        {} => { penetration::init_triangle_triangle (render_context, rng) }
      // Generate and resolve the next random triangle pair
      event NextPenetrationTriangleTriangle <PenetrationTriangleTriangle> ()
        {} => { penetration::next_triangle_triangle (render_context, rng) }

      //
      // PenetrationHullHull events
      //
      // Transition from any state to penetration resolve hull/hull state
      event ToPenetrationHullHull <*> => <PenetrationHullHull> ()
        {} => { penetration::init_hull_hull (render_context, rng) }
      // Generate and resolve the next random hull pair
      event NextPenetrationHullHull <PenetrationHullHull> ()
        {} => { penetration::next_hull_hull (render_context, rng) }

      //
      // BoundingVolumeObb events
      //
      // Transition from any state to bounding volume OBB state
      event ToBoundingVolumeObb <*> => <BoundingVolumeObb> ()
        {} => { bounding_volume::init_obb (render_context, rng) }
      // Generate and resolve the next random OBB
      event NextBoundingVolumeObb <BoundingVolumeObb> ()
        {} => { bounding_volume::next_obb (render_context, rng) }
      // Draw a penetration resolve capsule/capsule frame
      event DrawBoundingVolumeObb <BoundingVolumeObb>
        (glium_frame : &'event mut glium::Frame)
      {} => {
        bounding_volume::draw_obb (render_context, glium_frame)
      }

    ]
////////////////////////////////////////////////////////////////////////////////
//  initial state                                                             //
////////////////////////////////////////////////////////////////////////////////
    initial_state: SimulationDropTest
    //initial_state: SimulationCollideCapsuleCapsule
  }
}

pub (crate) fn print_testbed_modes_prompt() {
  println!(">>> linear-sim testbed modes of operation:");
  println!("  Press 'SHIFT+1' for simulation tests");
  println!("  Press 'SHIFT+2' for penetration resolution tests");
  println!("  Press 'SHIFT+3' for bouding volume tests");
}

pub (crate) fn reset_render_context (
  render : &mut Render <render::resource::Default>
) {
  use render::resource::*;
  use crate::{INITIAL_CLEAR_COLOR, INITIAL_2D_ZOOM, INITIAL_3D_POSITION};
  render.reset();
  render.clear_color = INITIAL_CLEAR_COLOR;
  render.camera3d_position_set (INITIAL_3D_POSITION.into());
  render.camera2d_zoom_set (INITIAL_2D_ZOOM);
  // set up FPS display
  let (width, height) = render.window.inner_size().into();
  let [_tile_width, tile_height] = render.resource
    .tile_dimensions (DefaultTilesetId::EasciiAcorn128);
  let fps_row = ((height / tile_height) - 1) as i32;
  let tile_2d_vertices = tile::vertices ("FPS: 0     ", (fps_row, 1));
  render.resource.draw2d.tile_2d_vertices = glium::VertexBuffer::dynamic (
    &render.glium_display, &tile_2d_vertices[..]
  ).unwrap();
  render.resource.draw2d.viewport_resources_set (OVERLAY_VIEWPORT,
    draw2d::ViewportResources {
      draw_indices: vec![draw2d::DrawIndices {
        draw_tiles: Some (draw2d::Tiles {
          vertex_range: 0..tile_2d_vertices.len() as u32,
          origin:       (0, 0).into(),
          tileset_id:   DefaultTilesetId::EasciiAcorn128
        }),
        .. draw2d::DrawIndices::default()
      }],
      draw_lineloop: false,
      draw_crosshair: false
    }
  );
  let overlay = render::viewport::Builder::new (glium::Rect {
    width,
    height,
    left:   0,
    bottom: 0
  }).with_camera_3d (false)
    .build();
  assert!(render.viewports_mut().insert (OVERLAY_VIEWPORT, overlay)
    .is_none());
}