Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

10.3 KB
Raw Blame
use crate::device::{Button, Capabilities, DeviceState, PortInput};
use crate::motion::GyroPointer;
use sdl3::GamepadSubsystem;
use sdl3::event::Event;
use sdl3::gamepad::{Axis, Button as SdlButton, Gamepad};
use sdl3::joystick::JoystickId;
use sdl3::sensor::SensorType;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use std::time::{Duration, Instant};

const STANDARD_GRAVITY: f32 = 9.80665;

#[derive(Clone, Copy)]
pub struct MotionSettings {
    pub sensitivity: f32,
    pub recenter: Button,
    pub invert: (bool, bool),
}

impl Default for MotionSettings {
    fn default() -> Self {
        Self {
            sensitivity: 1.0,
            recenter: Button::R3,
            invert: (false, false),
        }
    }
}

pub struct Service {
    pub shared: Arc<Mutex<Option<PortInput>>>,
    pub rumble: Arc<AtomicBool>,
    pub motion: Arc<Mutex<MotionSettings>>,
    pub device: Arc<Mutex<Option<String>>>,
}

static SERVICE: OnceLock<Service> = OnceLock::new();

pub fn service() -> &'static Service {
    SERVICE.get_or_init(|| {
        let shared = Arc::new(Mutex::new(None));
        let rumble = Arc::new(AtomicBool::new(false));
        let motion = Arc::new(Mutex::new(MotionSettings::default()));
        let device = Arc::new(Mutex::new(None));

        let thread_shared = shared.clone();
        let thread_rumble = rumble.clone();
        let thread_motion = motion.clone();
        let thread_device = device.clone();
        std::thread::Builder::new()
            .name("hostinput-sdl".into())
            .spawn(move || self::run(thread_shared, thread_rumble, thread_motion, thread_device))
            .expect("failed to spawn SDL input thread");

        Service {
            shared,
            rumble,
            motion,
            device,
        }
    })
}

struct Slot {
    pad: Gamepad,
    id: u32,
    caps: Capabilities,
    pointer: GyroPointer,
    accel: [f32; 3],
    touch: Option<(f32, f32)>,
    last_gyro_ts: Option<u64>,
    rumble_on: bool,
    rumble_refresh: Instant,
}

fn run(
    shared: Arc<Mutex<Option<PortInput>>>,
    rumble: Arc<AtomicBool>,
    motion: Arc<Mutex<MotionSettings>>,
    device: Arc<Mutex<Option<String>>>,
) {
    let sdl = match sdl3::init() {
        Ok(sdl) => sdl,
        Err(err) => {
            tracing::error!(%err, "SDL init failed, gamepads unavailable");
            return;
        }
    };

    let subsystem = match sdl.gamepad() {
        Ok(subsystem) => subsystem,
        Err(err) => {
            tracing::error!(%err, "SDL gamepad subsystem unavailable");
            return;
        }
    };

    let mut pump = match sdl.event_pump() {
        Ok(pump) => pump,
        Err(err) => {
            tracing::error!(%err, "SDL event pump unavailable");
            return;
        }
    };

    let mut slot: Option<Slot> = None;

    if let Ok(ids) = subsystem.gamepads() {
        for id in ids {
            self::add_device(&subsystem, &mut slot, &device, id);
        }
    }

    loop {
        let settings = *motion.lock().unwrap();

        let first = pump.wait_event_timeout(Duration::from_millis(4));

        for event in first.into_iter().chain(std::iter::from_fn(|| pump.poll_event())) {
            self::handle_event(&subsystem, &mut slot, &settings, &device, event);
        }

        let snapshot = slot.as_mut().map(|slot| {
            let mut state = self::read_state(&slot.pad);
            state.accel = slot.accel;

            if state.pressed(settings.recenter) {
                slot.pointer.recenter();
            }

            PortInput {
                state,
                caps: slot.caps,
                pointer: slot.caps.gyro.then(|| slot.pointer.ir()).flatten(),
                touch: slot.touch,
            }
        });

        *shared.lock().unwrap() = snapshot;

        if let Some(slot) = slot.as_mut()
            && slot.caps.rumble
        {
            let desired = rumble.load(Ordering::Relaxed);
            let refresh = desired && slot.rumble_refresh.elapsed() >= Duration::from_millis(200);

            if desired != slot.rumble_on || refresh {
                let (low, high) = if desired { (0xC000, 0xC000) } else { (0, 0) };
                if let Err(err) = slot.pad.set_rumble(low, high, 500) {
                    tracing::debug!(id = slot.id, %err, "rumble update failed");
                }

                slot.rumble_on = desired;
                slot.rumble_refresh = Instant::now();
            }
        }
    }
}

fn handle_event(
    subsystem: &GamepadSubsystem,
    slot: &mut Option<Slot>,
    settings: &MotionSettings,
    device: &Mutex<Option<String>>,
    event: Event,
) {
    match event {
        Event::ControllerDeviceAdded { which, .. } => {
            self::add_device(subsystem, slot, device, sdl3::sys::joystick::SDL_JoystickID(which))
        }
        Event::ControllerDeviceRemoved { which, .. } => self::remove_device(subsystem, slot, device, which),
        Event::ControllerSensorUpdated {
            timestamp,
            which,
            sensor,
            data,
        } => self::sensor_update(slot, settings, which, sensor, data, timestamp),
        Event::ControllerTouchpadDown {
            which, finger, x, y, ..
        }
        | Event::ControllerTouchpadMotion {
            which, finger, x, y, ..
        } => self::touch_update(slot, which, finger, Some((x, y))),
        Event::ControllerTouchpadUp { which, finger, .. } => self::touch_update(slot, which, finger, None),
        _ => {}
    }
}

fn touch_update(slot: &mut Option<Slot>, id: u32, finger: i32, touch: Option<(f32, f32)>) {
    if finger != 0 {
        return;
    }

    if let Some(slot) = slot.as_mut().filter(|slot| slot.id == id) {
        slot.touch = touch;
    }
}

fn sensor_update(
    slot: &mut Option<Slot>,
    settings: &MotionSettings,
    id: u32,
    sensor: SensorType,
    data: [f32; 3],
    timestamp: u64,
) {
    let Some(slot) = slot.as_mut().filter(|slot| slot.id == id) else {
        return;
    };

    match sensor {
        SensorType::Gyroscope => {
            let dt = match slot.last_gyro_ts {
                Some(prev) if timestamp > prev => ((timestamp - prev) as f32 / 1_000_000_000.0).min(0.05),
                _ => 0.0,
            };
            slot.last_gyro_ts = Some(timestamp);

            slot.pointer.integrate(data, dt, settings.sensitivity, settings.invert);
        }
        SensorType::Accelerometer => {
            slot.accel = [
                data[0] / STANDARD_GRAVITY,
                data[1] / STANDARD_GRAVITY,
                data[2] / STANDARD_GRAVITY,
            ];
        }
        _ => {}
    }
}

fn add_device(subsystem: &GamepadSubsystem, slot: &mut Option<Slot>, device: &Mutex<Option<String>>, id: JoystickId) {
    if slot.as_ref().is_some_and(|slot| slot.id == u32::from(id)) {
        return;
    }

    let pad = match subsystem.open(id) {
        Ok(pad) => pad,
        Err(err) => {
            tracing::warn!(id = u32::from(id), %err, "failed to open gamepad");
            return;
        }
    };

    let id = u32::from(id);
    let caps = self::query_caps(&pad);

    let replace = match slot.as_ref() {
        None => true,
        Some(current) => caps.gyro && !current.caps.gyro,
    };

    if !replace {
        tracing::info!(id, name = ?pad.name(), "gamepad ignored, slot occupied");
        return;
    }

    tracing::info!(id, name = ?pad.name(), ?caps, "gamepad connected");

    *device.lock().unwrap() = pad.name();

    if caps.gyro
        && let Err(err) = pad.sensor_set_enabled(SensorType::Gyroscope, true)
    {
        tracing::warn!(id, %err, "failed to enable gyroscope");
    }
    if caps.accel
        && let Err(err) = pad.sensor_set_enabled(SensorType::Accelerometer, true)
    {
        tracing::warn!(id, %err, "failed to enable accelerometer");
    }

    *slot = Some(Slot {
        pad,
        id,
        caps,
        pointer: GyroPointer::default(),
        accel: [0.0; 3],
        touch: None,
        last_gyro_ts: None,
        rumble_on: false,
        rumble_refresh: Instant::now(),
    });
}

fn remove_device(subsystem: &GamepadSubsystem, slot: &mut Option<Slot>, device: &Mutex<Option<String>>, id: u32) {
    if !slot.as_ref().is_some_and(|slot| slot.id == id) {
        return;
    }

    tracing::info!(id, "gamepad disconnected");
    *slot = None;
    *device.lock().unwrap() = None;

    if let Ok(ids) = subsystem.gamepads() {
        for id in ids {
            self::add_device(subsystem, slot, device, id);
        }
    }
}

fn query_caps(pad: &Gamepad) -> Capabilities {
    Capabilities {
        analog_sticks: pad.has_axis(Axis::LeftX),
        gyro: unsafe { pad.has_sensor(SensorType::Gyroscope) },
        accel: unsafe { pad.has_sensor(SensorType::Accelerometer) },
        rumble: unsafe { pad.has_rumble() },
    }
}

const BUTTON_MAP: [(SdlButton, Button); 16] = [
    (SdlButton::South, Button::South),
    (SdlButton::East, Button::East),
    (SdlButton::West, Button::West),
    (SdlButton::North, Button::North),
    (SdlButton::LeftShoulder, Button::L1),
    (SdlButton::RightShoulder, Button::R1),
    (SdlButton::LeftStick, Button::L3),
    (SdlButton::RightStick, Button::R3),
    (SdlButton::Start, Button::Start),
    (SdlButton::Back, Button::Select),
    (SdlButton::Guide, Button::Guide),
    (SdlButton::DPadUp, Button::DpadUp),
    (SdlButton::DPadDown, Button::DpadDown),
    (SdlButton::DPadLeft, Button::DpadLeft),
    (SdlButton::DPadRight, Button::DpadRight),
    (SdlButton::Touchpad, Button::TouchpadClick),
];

fn read_state(pad: &Gamepad) -> DeviceState {
    let mut buttons = 0u32;
    for (sdl, button) in BUTTON_MAP {
        if pad.button(sdl) {
            buttons |= button.mask();
        }
    }

    let l2 = self::trigger(pad, Axis::TriggerLeft);
    let r2 = self::trigger(pad, Axis::TriggerRight);

    if l2 >= 0.5 {
        buttons |= Button::L2.mask();
    }
    if r2 >= 0.5 {
        buttons |= Button::R2.mask();
    }

    DeviceState {
        buttons,
        left: (self::axis(pad, Axis::LeftX), -self::axis(pad, Axis::LeftY)),
        right: (self::axis(pad, Axis::RightX), -self::axis(pad, Axis::RightY)),
        l2,
        r2,
        accel: [0.0; 3],
    }
}

fn axis(pad: &Gamepad, axis: Axis) -> f32 {
    (pad.axis(axis) as f32 / 32767.0).clamp(-1.0, 1.0)
}

fn trigger(pad: &Gamepad, axis: Axis) -> f32 {
    (pad.axis(axis) as f32 / 32767.0).clamp(0.0, 1.0)
}