path: root/engine/src/input.rs

use std::collections::HashMap;

use ecs::extension::Collector as ExtensionCollector;
use ecs::sole::Single;
use ecs::Sole;

use crate::event::{
    PostPresent as PostPresentEvent,
    PreUpdate as PreUpdateEvent,
    Start as StartEvent,
};
use crate::vector::Vec2;
use crate::window::Window;

mod reexports
{
    pub use crate::window::{Key, KeyState};
}

pub use reexports::*;

#[derive(Debug, Sole)]
pub struct Keys
{
    map: HashMap<Key, KeyData>,
}

impl Keys
{
    #[must_use]
    pub fn new() -> Self
    {
        Self {
            map: Key::KEYS
                .iter()
                .map(|key| {
                    (
                        *key,
                        KeyData {
                            state: KeyState::Released,
                            prev_tick_state: KeyState::Released,
                        },
                    )
                })
                .collect(),
        }
    }

    #[must_use]
    pub fn get_key_state(&self, key: Key) -> KeyState
    {
        self.map.get(&key).expect("Key not in key map").state
    }

    #[must_use]
    pub fn get_prev_key_state(&self, key: Key) -> KeyState
    {
        self.map
            .get(&key)
            .expect("Key not in key map")
            .prev_tick_state
    }

    pub fn set_key_state(&mut self, key: Key, new_key_state: KeyState)
    {
        if matches!(new_key_state, KeyState::Repeat) {
            return;
        }

        let key_data = self.map.get_mut(&key).expect("Key not in key map");

        key_data.state = new_key_state;
    }

    #[must_use]
    pub fn is_anything_pressed(&self) -> bool
    {
        self.map
            .values()
            .any(|key_data| matches!(key_data.state, KeyState::Pressed))
    }
}

impl Default for Keys
{
    fn default() -> Self
    {
        Self::new()
    }
}

#[derive(Debug, Default, Clone, Sole)]
pub struct Cursor
{
    pub position: Vec2<f64>,
    pub has_moved: bool,
}

#[derive(Debug, Clone, Sole)]
pub struct CursorFlags
{
    /// This flag is set in two situations:
    /// A: The window has just started
    /// B: The window has gained focus again after losing focus.
    ///
    /// This flag only lasts a single tick then it is cleared (at the beginning of the
    /// next tick).
    pub is_first_move: CursorFlag,
}

impl Default for CursorFlags
{
    fn default() -> Self
    {
        Self {
            is_first_move: CursorFlag { flag: true, ..Default::default() },
        }
    }
}

#[derive(Debug, Default, Clone)]
pub struct CursorFlag
{
    pub flag: bool,
    pub pending_clear: bool,
}

impl CursorFlag
{
    pub fn clear(&mut self)
    {
        self.flag = false;
        self.pending_clear = false;
    }
}

/// Input extension.
#[derive(Debug, Default)]
pub struct Extension {}

impl ecs::extension::Extension for Extension
{
    fn collect(self, mut collector: ExtensionCollector<'_>)
    {
        collector.add_system(StartEvent, initialize);
        collector.add_system(PreUpdateEvent, maybe_clear_cursor_is_first_move);
        collector.add_system(PostPresentEvent, set_keys_prev_tick_state);

        collector.add_sole(Keys::default()).ok();
        collector.add_sole(Cursor::default()).ok();
        collector.add_sole(CursorFlags::default()).ok();
    }
}

fn initialize(
    keys: Single<Keys>,
    cursor: Single<Cursor>,
    cursor_flags: Single<CursorFlags>,
    window: Single<Window>,
)
{
    let keys_weak_ref = keys.to_weak_ref();

    window.set_key_callback(move |key, _scancode, key_state, _modifiers| {
        let keys_ref = keys_weak_ref.access().expect("No world");

        let mut keys = keys_ref.to_single();

        keys.set_key_state(key, key_state);
    });

    let cursor_weak_ref = cursor.to_weak_ref();

    window.set_cursor_pos_callback(move |cursor_position| {
        let cursor_ref = cursor_weak_ref.access().expect("No world");

        let mut cursor = cursor_ref.to_single();

        cursor.position = Vec2 {
            x: cursor_position.x,
            y: cursor_position.y,
        };

        cursor.has_moved = true;
    });

    let cursor_flags_weak_ref = cursor_flags.to_weak_ref();

    window.set_focus_callback(move |is_focused| {
        #[cfg(feature = "debug")]
        tracing::trace!("Window is focused: {is_focused}");

        let cursor_flags_ref = cursor_flags_weak_ref.access().expect("No world");

        cursor_flags_ref.to_single().is_first_move.flag = is_focused;
    });
}

fn maybe_clear_cursor_is_first_move(
    cursor: Single<Cursor>,
    mut cursor_flags: Single<CursorFlags>,
)
{
    if cursor_flags.is_first_move.pending_clear {
        #[cfg(feature = "debug")]
        tracing::trace!("Clearing is_first_move");

        // This flag was set for the whole previous tick so it can be cleared now
        cursor_flags.is_first_move.clear();

        return;
    }

    if cursor.has_moved && cursor_flags.is_first_move.flag {
        #[cfg(feature = "debug")]
        tracing::trace!("Setting flag to clear is_first_move next tick");

        // Make this system clear is_first_move the next time it runs
        cursor_flags.is_first_move.pending_clear = true;
    }
}

fn set_keys_prev_tick_state(mut keys: Single<Keys>)
{
    for key_data in keys.map.values_mut() {
        key_data.prev_tick_state = key_data.state;
    }
}

#[derive(Debug)]
struct KeyData
{
    state: KeyState,
    prev_tick_state: KeyState,
}