while accum > LOGIC_DURATION {

            while accum >= LOGIC_DURATION {

            // Sync the physics system with the real world *now* (using the remainder of the accumuator as a delta)
            game.physics_sync(accum.as_secs_f32() / LOGIC_DURATION.as_secs_f32());

use self::scene::{Scene, SceneLibrary, SceneReference};

use self::{
    physics::{PhysicsState, PhysicsSystem},
    scene::{Scene, SceneLibrary, SceneReference},
};

    previous_state: PhysicsState,
    current_state: PhysicsState,

    // systems
    physics: PhysicsSystem,

            // initally empty states
            previous_state: PhysicsState::default(),
            current_state: PhysicsState::default(),
            // systems
            physics: PhysicsSystem::new(),

    }
    /// Syncs the physics system's results back into the world
    ///
    /// alpha is a % of the fixed timestep used by update that is unused in the frame,
    /// so this must be [0.0, 1.0)
    pub fn physics_sync(&mut self, delta: f32) {
        // sync the state that is lerped between the previous state and the current state by alpha
        let actual_state = self.current_state.lerp(&self.previous_state, delta);
        _ = actual_state;

/// The angle the physics system assumes the orthogonal view is looking at.
/// This is *not* used by the physics system for anything except
/// converting its internal position to a 2d position understandable by other systems.
// Valid angles are [0.0, pi/2).
// 0.0 means the viewer is looking straight at the ground, so z position has no effect.
// pi/2 means the view is looking *parallel* to the ground, which is not a valid angle for looking at objects
// (the orthogonal approximation only works when approximating an infinitely distant viewer, so looking at angle pi/2
// from the ground means that to see an object, its z must be at *least* infinity, which isn't possible)
pub const VIEW_ANGLE: f32 = std::f32::consts::FRAC_PI_4;

impl PhysicsSystem {
    pub fn new() -> Self {
        Self {}
    }
}

#[derive(Debug, Clone)]

#[derive(Debug, Clone, Default, PartialEq)]

    pub fn lerp(&self, to: &PhysicsState, alpha: f32) -> PhysicsState {

    ///
    /// `alpha` must be [0.0, 1.0] for the math to work out
    pub fn lerp(&self, from: &Self, delta: f32) -> Self {

            .filter_map(|(id, oobj)| to.objects.get(id).map(|obj| (id, oobj, obj)));

            .filter_map(|(id, oobj)| from.objects.get(id).map(|obj| (id, oobj, obj)));

            .filter(|(id, _)| !to.objects.contains_key(*id));

            .filter(|(id, _)| !from.objects.contains_key(*id));

            new_objects.insert(*id, oobj.lerp(obj, alpha));

            new_objects.insert(*id, oobj.lerp(obj, delta));

        // Copy objects that exist only in this state

        // Copy objects that exist in only the current (self) state

#[derive(Debug, Clone)]
pub struct PhysicsObject {}

#[derive(Debug, Clone, PartialEq)]
pub struct PhysicsObject {
    position: glam::Vec3,
}

    fn lerp(&self, to: &PhysicsObject, alpha: f32) -> PhysicsObject {
        Self {}

    fn lerp(&self, from: &Self, delta: f32) -> Self {
        let position = self.position * delta + from.position * (1.0 - delta);
        Self { position }
    }
    /// Get the position
    // Maps our internal 3d position into a 2d displayable position
    fn position(&self) -> glam::Vec2 {
        // Physics is a 3d system.
        // to get the display (x, y), use
        // (x, y - z * VIEW_ANGLE.tan())
        glam::Vec2::new(
            self.position.x,
            self.position.y - VIEW_ANGLE.tan() * self.position.z,
        )

#[cfg(test)]
mod tests;