EngineInputSystems.cs

using Gondwana.Configuration;
using Gondwana.Input.Gamepad;
using Gondwana.Input.Keyboard;
using Gondwana.Input.Mouse;
using Gondwana.Input.Touch;
using Gondwana.Timers;
 
namespace Gondwana;

public sealed class EngineInputSystems
{
    internal EngineInputSystems() { }
 
    private IGamepadManager<IGamepadAdapter>? _gamepadManager = null;
    private long _lastGamepadConnectionUpdateTick;
    private long _lastGamepadPollTick;

    public IGamepadManager<IGamepadAdapter>? GamepadManager
    {
        get => _gamepadManager;
        set
        {
            _gamepadManager = value;
 
            if (value is null)
            {
                _lastGamepadConnectionUpdateTick = 0;
                _lastGamepadPollTick = 0;
                GamepadEventPoller.Initialize(null);
                return;
            }
 
            // Prime discovery and state once so platform host initialization hooks can immediately
            // observe controllers that were already connected when the manager was installed.
            value.UpdateConnections();
            value.Poll();
 
            long tick = HighResTimer.GetCurrentTick();
            _lastGamepadConnectionUpdateTick = tick;
            _lastGamepadPollTick = tick;
 
            GamepadEventPoller.Initialize(value.ConnectedAdapters);
        }
    }

    internal void RefreshGamepads(long tick, EngineConfiguration configuration)
    {
        ArgumentNullException.ThrowIfNull(configuration);
 
        var manager = _gamepadManager;
        if (manager is null)
            return;
 
        if (IsGamepadRefreshDue(
                tick,
                _lastGamepadConnectionUpdateTick,
                configuration.GamepadConnectionUpdateFrequencyHz))
        {
            manager.UpdateConnections();
            GamepadEventPoller.Instance?.RefreshAdapters(manager.ConnectedAdapters);
            _lastGamepadConnectionUpdateTick = tick;
        }
 
        if (IsGamepadRefreshDue(
                tick,
                _lastGamepadPollTick,
                configuration.GamepadPollFrequencyHz))
        {
            manager.Poll();
            _lastGamepadPollTick = tick;
        }
    }
 
    private static bool IsGamepadRefreshDue(long tick, long lastTick, double frequencyHz)
    {
        if (frequencyHz <= 0d)
            return false;
 
        long intervalTicks = Math.Max(
            1,
            (long)(HighResTimer.TicksPerSecond / frequencyHz));
 
        return tick - lastTick >= intervalTicks;
    }

    public GamepadEventPoller? GamepadEventPoller => GamepadEventPoller.Instance;

    public KeyboardEventPoller? KeyboardEventPoller => KeyboardEventPoller.Instance ?? null;

    public MouseEventPoller? MouseEventPoller => MouseEventPoller.Instance ?? null;

    public ITouchAdapter? TouchAdapter
    {
        get => TouchEventPoller.Instance?.Adapter;
        set
        {
            if (value is null)
                TouchEventPoller.Reset();
            else
                TouchEventPoller.Initialize(value);
        }
    }

    public TouchEventPoller? TouchEventPoller => TouchEventPoller.Instance;
}