SolarEngine/simulator/src/main.rs

use cgmath::Rotation3;
use solar_engine::{Application, Body, Simulator};
use std::sync::{Arc, RwLock};
use std::thread;
use winit::event::ElementState;
use winit::event::WindowEvent::KeyboardInput;
use winit::event_loop::EventLoop;
use winit::keyboard::Key;
use winit::platform::modifier_supplement::KeyEventExtModifierSupplement;

pub async fn run() {
    let event_loop = EventLoop::new().unwrap();

    let simulator = Arc::new(RwLock::new(Simulator::new()));
    {
        let mut sim = simulator.write().unwrap();
        sim.add_body(Body {
            name: "Sun".into(),
            position: [0.0, 0.0],
            velocity: [0.0, 0.0],
            mass: 1.989e30,
        });
        sim.add_body(Body {
            name: "Earth".into(),
            position: [1.496e11, 0.0],
            velocity: [0.0, 29780.0],
            mass: 5.972e24,
        });
    }

    let sim_clone = simulator.clone();
    thread::spawn(move || {
        use std::time::{Duration, Instant};
        let mut last = Instant::now();
        loop {
            let now = Instant::now();
            let dt = now.duration_since(last).as_secs_f64();
            last = now;

            {
                let mut sim = sim_clone.write().unwrap();
                let timewarp = sim.get_timewarp();
                sim.step(dt * timewarp as f64);
            }

            thread::sleep(Duration::from_millis(1));
        }
    });

    let simulator_clone = simulator.clone();

    let mut window_state = Application::new().on_update(move |state| {
        let sim = simulator_clone.read().unwrap();
        let bodies = &sim.bodies;

        let instances = bodies
            .iter()
            .enumerate()
            .map(|(i, b)| {
                solar_engine::RenderInstance {
                    position: cgmath::Vector3::new(
                        (b.position[0] / 1.496e11) as f32,
                        (b.position[1] / 1.496e11) as f32,
                        0.0,
                    ),
                    rotation: cgmath::Quaternion::from_angle_z(cgmath::Deg(0.0)),
                    color: match i {
                        0 => [1.0, 1.0, 0.0], // Sun
                        1 => [0.0, 0.0, 1.0], // Earth
                        _ => [0.5, 0.5, 0.5],
                    },
                    scale: 0.05,
                    shape: solar_engine::Shape::Circle,
                }
            })
            .collect();

        state.set_instances(instances);
    }).on_input(move |_state, event| {
        if let KeyboardInput { event, .. } = event {
            if event.state == ElementState::Pressed {
                return match event.key_without_modifiers().as_ref() {
                    Key::Character(".") => {
                        let mut sim = simulator.write().unwrap();
                        sim.increase_timewarp();
                        println!("Timewarp: {}", sim.get_timewarp());
                    }
                    Key::Character(",") => {
                        let mut sim = simulator.write().unwrap();
                        sim.decrease_timewarp();
                        println!("Timewarp: {}", sim.get_timewarp());
                    }
                    Key::Character("-") => {
                        let mut sim = simulator.write().unwrap();
                        sim.reset_timewarp();
                        println!("Timewarp: {}", sim.get_timewarp());
                    }
                    _ => {}
                }
            }
        }
    });
    
    let _ = event_loop.run_app(&mut window_state);
}

fn main() {
    pollster::block_on(run());
}