VirtualTouchscreenZone.cs

// VirtualTouchscreenZone.cs
// MIT-style utility: mirror *real* Touchscreen samples into a per-zone "virtual" Touchscreen.
// Primary use: single-device local multiplayer on one phone/tablet by spawning one Player per UI zone.
//
// What it gives you
// • A concrete InputSystem layout ("VirtualTouchscreen") that behaves like Touchscreen.
// • A MonoBehaviour you drop on a RectTransform; it hit-tests pointer begins to *claim* a finger.
// • It mirrors only the real Touchscreen into this zone’s VirtualTouchscreen (VTS) with same timestamps.
// • Optional auto-join: calls PlayerInputManager.JoinPlayer on first Began inside the zone.
// • Throttling, move-epsilon, and detailed logging so you don’t blow the per-frame event queue.
//
// Requirements
// • Project setting “Active Input Handling” = Input System (New).
// • Place this on a RectTransform under a Canvas (Overlay or Camera Space).
// • Do NOT enable Mouse→Touch simulation or EnhancedTouch while mirroring, or you’ll double-feed.
//
// Notes
// • Many simulators only update primaryTouch. Use `forceUsePrimaryTouch = true` if touches[] are unreliable.
// • This component ignores its own VTS events to prevent bounce.
// • Each zone owns exactly one VTS device. Pair that device to a Player to isolate inputs per zone.

using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.Layouts;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.InputSystem.Users;
using SysTouchPhase = UnityEngine.InputSystem.TouchPhase;

/// <summary>
/// Concrete layout identical to <see cref="Touchscreen"/> so control schemes can target it.
/// The layout name is "VirtualTouchscreen".
/// </summary>
[InputControlLayout(stateType = typeof(TouchState), displayName = "VirtualTouchscreen")]
public class VirtualTouchscreen : Touchscreen {}

/// <summary>
/// Drop this on a RectTransform to create a per-zone virtual Touchscreen (VTS) and mirror real Touchscreen samples
/// into it when a finger begins inside the zone. Designed for one-device local multiplayer with PlayerInputManager.
/// </summary>
[DisallowMultipleComponent]
[RequireComponent(typeof(RectTransform))]
public class VirtualTouchscreenZone : MonoBehaviour
{
    // ────────────────────────────────────────────────────────────────────────────
    // Layout bootstrap
    // Registers the "VirtualTouchscreen" layout before scene load so PlayerInput control schemes can reference it.
    // ────────────────────────────────────────────────────────────────────────────
    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
    private static void RegisterLayout()
    {
        const string layoutName = "VirtualTouchscreen";
        if (!InputSystem.ListLayouts().Contains(layoutName))
            InputSystem.RegisterLayout<VirtualTouchscreen>(layoutName);
    }

    // ────────────────────────────────────────────────────────────────────────────
    // Inspector configuration
    // ────────────────────────────────────────────────────────────────────────────

    [Header("Enable/Toggles")]
    [Tooltip("Master toggle for this component. When false, nothing is created or mirrored.")]
    [SerializeField] private bool behaviorEnabled = true;

    [Tooltip("When false, the device exists but no mirroring occurs.")]
    [SerializeField] private bool mirroringEnabled = true;

    [Header("Simulator quirks")]
    [Tooltip("Prefer primaryTouch over touches[]. Some simulators only update primaryTouch.")]
    [SerializeField] private bool forceUsePrimaryTouch = true; // do NOT mix with touches[]

    [Header("Throttle")]
    [Tooltip("Hard cap on samples queued by THIS zone per frame. Prevents queue overflow.")]
    [SerializeField] private int maxQueuedPerFrame = 64;

    [Tooltip("Minimum pixel delta to emit a Moved sample. 0 disables filtering.")]
    [SerializeField] private float moveEpsilonPixels = 1f;

    [Header("Zone (UI hit-test)")]
    [Tooltip("RectTransform that defines the touchable region for this zone. Defaults to this component's RectTransform.")]
    [SerializeField] private RectTransform zoneRect;
    private Camera _uiCamera; // set from Canvas (null for ScreenSpaceOverlay)

    [Header("Virtual device")]
    [Tooltip("Layout name for the virtual device. Default is \"VirtualTouchscreen\".")]
    [SerializeField] private string vtsLayoutName = "VirtualTouchscreen";

    [Tooltip("Optional device name override. If empty, an auto name is used.")]
    [SerializeField] private string deviceName = "";

    [Tooltip("Remove and destroy the VTS device when this component is disabled.")]
    [SerializeField] private bool removeDeviceOnDisable = true;

    [Header("Manual join (PlayerInputManager)")]
    [Tooltip("On first Began inside this zone, call PlayerInputManager.JoinPlayer paired to this VTS.")]
    [SerializeField] private bool autoJoinOnPress = true;

    [Tooltip("Optional control scheme to force during JoinPlayer. Leave empty for automatic.")]
    [SerializeField] private string joinControlScheme = "";

    [Tooltip("Only attempt join if this VTS is not already paired to a user.")]
    [SerializeField] private bool joinOnlyIfUnpaired = true;

    [Tooltip("Only attempt join once during this component's lifetime.")]
    [SerializeField] private bool joinOncePerZone = true;

    [Header("Logging (set either Instance or Global)")]
    [Tooltip("Enable logging for this instance. You can also flip GlobalLoggingEnabled at runtime.")]
    [SerializeField] private bool instanceLoggingEnabled = true;

    /// <summary>Set true at runtime to force logging from all zones regardless of instance toggle.</summary>
    public static bool GlobalLoggingEnabled = false;

    [SerializeField] private bool logLifecycleEvents = true;
    [SerializeField] private bool logInputEvents = true;
    [SerializeField] private bool logClaimsAndReleases = true;
    [SerializeField] private bool logQueuedSamples = true;
    [SerializeField] private bool logSkippedTouches = true;
    [SerializeField] private bool logWarnings = true;
    [SerializeField] private bool logThrottle = true;

    /// <summary>Access the virtual device owned by this zone. Null until <see cref="EnsureDevice"/> runs.</summary>
    public VirtualTouchscreen Device => _vtsDevice;

    // ────────────────────────────────────────────────────────────────────────────
    // Internal state
    // ────────────────────────────────────────────────────────────────────────────

    private VirtualTouchscreen _vtsDevice;
    private RectTransform _zoneRectCached;

    // Mapping real finger id -> virtual touch id, and claim set for routing.
    private readonly Dictionary<int, int> _realToVirtualTouchId = new(); // realPid -> vtsTid
    private readonly HashSet<int> _claimedRealTouchIds = new();

    // Per-finger last known values for epsilon filtering and bookkeeping.
    private readonly Dictionary<int, Vector2> _lastPosByPid = new();
    private readonly Dictionary<int, SysTouchPhase> _lastPhaseByPid = new();

    private int _nextVirtualTouchId = 1;
    private int _primaryRealPid = -1;

    private int _queuedThisFrame;
    private float _moveEpsSqr;

    // Keep a stable delegate so we can unsubscribe cleanly.
    private System.Action _beforeUpdateHandler;

    private PlayerInput _joinedPlayer;

    // ────────────────────────────────────────────────────────────────────────────
    // Unity lifecycle
    // ────────────────────────────────────────────────────────────────────────────

    private void Reset()
    {
        // Auto-wire the zone RectTransform for convenience.
        if (!zoneRect) zoneRect = GetComponent<RectTransform>();
    }

    private void Awake()
    {
        if (!behaviorEnabled) return;

        _zoneRectCached = zoneRect ? zoneRect : GetComponent<RectTransform>();
        _moveEpsSqr = Mathf.Max(0f, moveEpsilonPixels) * Mathf.Max(0f, moveEpsilonPixels);

        EnsureDevice();
        LogIf(logLifecycleEvents, $"Awake → device ensured; maxQueuedEventsPerUpdate={InputSystem.settings.maxQueuedEventsPerUpdate}");
    }

    private void OnEnable()
    {
        if (!behaviorEnabled) return;

        // Determine which camera to use for ScreenPointToLocalPointInRectangle.
        var canvas = _zoneRectCached.GetComponentInParent<Canvas>();
        _uiCamera = canvas && canvas.renderMode != RenderMode.ScreenSpaceOverlay ? Camera.main : null;

        EnsureDevice();

        if (_beforeUpdateHandler == null) _beforeUpdateHandler = OnBeforeUpdate;
        InputSystem.onBeforeUpdate += _beforeUpdateHandler; // resets per-frame counters
        InputSystem.onEvent += OnEvent;                      // mirrors source events

        LogIf(logLifecycleEvents, "OnEnable → subscribed onBeforeUpdate + onEvent");
    }

    private void OnDisable()
    {
        if (!behaviorEnabled) return;

        InputSystem.onEvent -= OnEvent;
        if (_beforeUpdateHandler != null) InputSystem.onBeforeUpdate -= _beforeUpdateHandler;

        CancelAll(); // emit Canceled for any active virtual touches, then reset device

        if (removeDeviceOnDisable && _vtsDevice != null && _vtsDevice.added)
        {
            LogIf(logLifecycleEvents, $"OnDisable → removing device {_vtsDevice}");
            InputSystem.RemoveDevice(_vtsDevice);
            _vtsDevice = null;
        }

        LogIf(logLifecycleEvents, "OnDisable → unsubscribed, canceled, cleaned");
    }

    private void OnDestroy()
    {
        if (!behaviorEnabled) return;
        InputSystem.onEvent -= OnEvent;
        if (_beforeUpdateHandler != null) InputSystem.onBeforeUpdate -= _beforeUpdateHandler;
    }

    /// <summary>
    /// Per-update reset of per-frame counters. Keeps throttling deterministic.
    /// </summary>
    private void OnBeforeUpdate()
    {
        if (_queuedThisFrame > 0)
            LogIf(logThrottle, $"Frame end: queued={_queuedThisFrame} (cap={maxQueuedPerFrame})");
        _queuedThisFrame = 0;
    }

    // ────────────────────────────────────────────────────────────────────────────
    // Device creation and reuse
    // ────────────────────────────────────────────────────────────────────────────

    /// <summary>
    /// Ensures this zone has a VirtualTouchscreen device. Reuses an existing device by name if present.
    /// </summary>
    private void EnsureDevice()
    {
        if (_vtsDevice != null && _vtsDevice.added) return;

        if (!InputSystem.ListLayouts().Contains(vtsLayoutName))
            InputSystem.RegisterLayout<VirtualTouchscreen>(vtsLayoutName);

        string resolvedName = string.IsNullOrEmpty(deviceName) ? $"{vtsLayoutName}-{GetInstanceID()}" : deviceName;

        // Find existing VTS with same name to avoid duplicates across domain reloads.
        _vtsDevice = InputSystem.devices
            .FirstOrDefault(d => d is VirtualTouchscreen && d.name == resolvedName) as VirtualTouchscreen;

        if (_vtsDevice == null)
            _vtsDevice = (VirtualTouchscreen)InputSystem.AddDevice(vtsLayoutName, resolvedName);
        else if (!_vtsDevice.added)
            InputSystem.AddDevice(_vtsDevice);

        LogIf(logLifecycleEvents, $"EnsureDevice → Using VTS: {_vtsDevice}");
    }

    // ────────────────────────────────────────────────────────────────────────────
    // Mirroring core
    // ────────────────────────────────────────────────────────────────────────────

    /// <summary>
    /// InputSystem global event hook. Mirrors *only* the real Touchscreen into this zone’s VTS.
    /// Ignores events from the VTS itself to prevent feedback.
    /// </summary>
    private void OnEvent(InputEventPtr evt, InputDevice src)
    {
        if (!behaviorEnabled || !mirroringEnabled) return;
        if (_vtsDevice == null || _zoneRectCached == null) { LogIf(logWarnings, "OnEvent: VTS/zone null"); return; }

        // Handle only the *real* Touchscreen. Ignore this zone's own VTS and any non-touch device.
        if (src is not Touchscreen real || ReferenceEquals(src, _vtsDevice)) return;

        bool isState = evt.IsA<StateEvent>();
        bool isDelta = evt.IsA<DeltaStateEvent>();
        if (!isState && !isDelta) return;

        LogIf(logInputEvents, $"OnEvent [{(isState ? "State" : "Delta")} @ {evt.time:F6}] dev={src.name} layout={src.layout}");

        int handled = 0;

        // Path 1: touches[] changes when available and enabled.
        if (!forceUsePrimaryTouch)
        {
            foreach (var control in evt.EnumerateChangedControls(src))
            {
                if (control is not TouchControl t) continue;
                handled += HandleTouchFromEvent(t, evt);
                if (_queuedThisFrame >= maxQueuedPerFrame)
                {
                    LogIf(logThrottle, $"Cap hit in touches[] path. queued={_queuedThisFrame}/{maxQueuedPerFrame}");
                    break;
                }
            }
        }

        // Path 2: primaryTouch fallback or explicit preference.
        if (forceUsePrimaryTouch || handled == 0)
        {
            var pt  = real.primaryTouch;
            var ph  = pt.phase.ReadValueFromEvent(evt);
            var pos = pt.position.ReadValueFromEvent(evt);
            var pid = pt.touchId.ReadValueFromEvent(evt);

            // Fallback to committed state when payload omits fields.
            if (ph == SysTouchPhase.None) ph  = pt.phase.ReadValue();
            if (pos == default)           pos = pt.position.ReadValue();
            if (pid == 0)                 pid = pt.touchId.ReadValue();

            if (ph != SysTouchPhase.None)
            {
                LogIf(logInputEvents, $"  primaryTouch pid={pid} phase={ph} pos={pos}");
                HandleTouchRecord(pid, ph, pos, evt.time, "primary");
                handled++;
            }
            else
            {
                LogIf(logSkippedTouches, "  primaryTouch has no phase in payload/committed state");
            }
        }

        if (handled == 0)
            LogIf(logSkippedTouches, "  no touch data handled this event");
    }

    /// <summary>
    /// Mirrors a single <see cref="TouchControl"/> sample from the event payload.
    /// </summary>
    private int HandleTouchFromEvent(TouchControl touch, InputEventPtr evt)
    {
        var ph  = touch.phase.ReadValueFromEvent(evt);
        var pos = touch.position.ReadValueFromEvent(evt);
        int pid = touch.touchId.ReadValueFromEvent(evt);

        if (ph == SysTouchPhase.None) ph  = touch.phase.ReadValue();
        if (pos == default)           pos = touch.position.ReadValue();
        if (pid == 0)                 pid = touch.touchId.ReadValue();

        string origin = touch.path; // e.g. "/Touchscreen/touch0"
        LogIf(logInputEvents, $"  changed {origin} pid={pid} phase={ph} pos={pos}");
        HandleTouchRecord(pid, ph, pos, evt.time, origin);
        return 1;
    }

    /// <summary>
    /// Core routing and queueing. Claims fingers on Began inside the zone. Applies move epsilon and frame cap.
    /// Writes a <see cref="TouchState"/> to the zone's VTS with the event timestamp.
    /// </summary>
    private void HandleTouchRecord(int realPid, SysTouchPhase phase, Vector2 pos, double time, string originTag)
    {
        // Per-frame cap to avoid "maxQueuedEventsPerUpdate" overflow.
        if (_queuedThisFrame >= maxQueuedPerFrame)
        {
            LogIf(logThrottle, $"SKIP [{originTag}] cap reached. pid={realPid} phase={phase} pos={pos}");
            return;
        }

        // Primary id tracking for isPrimaryTouch flag.
        if (phase == SysTouchPhase.Began && _primaryRealPid == -1) _primaryRealPid = realPid;
        if ((phase == SysTouchPhase.Ended || phase == SysTouchPhase.Canceled) && _primaryRealPid == realPid) _primaryRealPid = -1;

        // Only begin inside this zone.
        if (phase == SysTouchPhase.Began && !ScreenPointInZone(pos))
        {
            LogIf(logSkippedTouches, $"SKIP [{originTag}] Began outside zone. pid={realPid} pos={pos}");
            return;
        }

        // Non-begins must be previously claimed by this zone.
        if (phase != SysTouchPhase.Began && !_claimedRealTouchIds.Contains(realPid))
        {
            LogIf(logSkippedTouches, $"SKIP [{originTag}] Unclaimed pid on {phase}. pid={realPid}");
            return;
        }

        // Epsilon filter for Moved.
        if (phase == SysTouchPhase.Moved && _lastPosByPid.TryGetValue(realPid, out var lastPos))
        {
            if (_moveEpsSqr > 0f && (pos - lastPos).sqrMagnitude < _moveEpsSqr)
            {
                LogIf(logSkippedTouches, $"SKIP [{originTag}] Move < epsilon. pid={realPid} Δ={(pos-lastPos)}");
                _lastPhaseByPid[realPid] = SysTouchPhase.Moved;
                return;
            }
        }

        // Claim mapping and optional Player join on the first sample for this finger.
        _claimedRealTouchIds.Add(realPid);
        if (!_realToVirtualTouchId.ContainsKey(realPid))
        {
            TryManualJoinIfNeeded();
            _realToVirtualTouchId[realPid] = _nextVirtualTouchId++;
            LogIf(logClaimsAndReleases, $"Claim [{originTag}] realPid={realPid} → vtsTid={_realToVirtualTouchId[realPid]}");
        }

        _lastPosByPid[realPid] = pos;
        _lastPhaseByPid[realPid] = phase;

        var vtsSample = new TouchState
        {
            touchId         = _realToVirtualTouchId[realPid],
            phase           = phase,
            position        = pos,
            pressure        = (phase == SysTouchPhase.Ended || phase == SysTouchPhase.Canceled) ? 0f : 1f,
            displayIndex    = 0,
            isIndirectTouch = false,
            isPrimaryTouch  = (realPid == _primaryRealPid)
        };

        // Queue with the source event's timestamp to preserve order within the frame.
        InputSystem.QueueStateEvent(_vtsDevice, vtsSample, time);
        _queuedThisFrame++;

        LogIf(logQueuedSamples, $"  → QUEUE [{originTag}] tid={vtsSample.touchId} {phase} pos={pos} t={time:F6} queuedThisFrame={_queuedThisFrame}");

        // Release bookkeeping on End/Cancel.
        if (phase == SysTouchPhase.Ended || phase == SysTouchPhase.Canceled)
        {
            _claimedRealTouchIds.Remove(realPid);
            _lastPosByPid.Remove(realPid);
            _lastPhaseByPid.Remove(realPid);
            LogIf(logClaimsAndReleases, $"Release [{originTag}] realPid={realPid} tid={vtsSample.touchId}");
        }
    }

    // ────────────────────────────────────────────────────────────────────────────
    // Player join
    // ────────────────────────────────────────────────────────────────────────────

    /// <summary>
    /// Optionally call <see cref="PlayerInputManager.JoinPlayer"/> and pair it with this zone's VTS.
    /// Respects <see cref="joinOnlyIfUnpaired"/> and <see cref="joinOncePerZone"/>.
    /// </summary>
    private void TryManualJoinIfNeeded()
    {
        if (!autoJoinOnPress) return;

        if (joinOnlyIfUnpaired)
        {
            var user = InputUser.FindUserPairedToDevice(_vtsDevice);
            if (user.HasValue)
            {
                LogIf(logClaimsAndReleases, "Join skipped: VTS already paired");
                return;
            }
        }

        if (joinOncePerZone && _joinedPlayer != null)
        {
            LogIf(logClaimsAndReleases, "Join skipped: already joined once");
            return;
        }

        var pim = PlayerInputManager.instance;
        if (pim == null)
        {
            LogIf(logWarnings, "Join requested but no PlayerInputManager.instance");
            return;
        }

        string scheme = string.IsNullOrEmpty(joinControlScheme) ? null : joinControlScheme;

        try
        {
            var player = pim.JoinPlayer(-1, -1, scheme, _vtsDevice);
            _joinedPlayer = player;
            LogIf(logLifecycleEvents, $"Manual join → Player {player.playerIndex} device='{_vtsDevice.name}' scheme={(scheme ?? "<auto>")}");
        }
        catch (System.SystemException e)
        {
            LogIf(logWarnings, $"JoinPlayer failed: {e.Message}");
        }
    }

    // ────────────────────────────────────────────────────────────────────────────
    // Utilities
    // ────────────────────────────────────────────────────────────────────────────

    /// <summary>
    /// Rect hit-test in screen space. Began must be inside the zone. Movement is routed to the claiming zone.
    /// </summary>
    private bool ScreenPointInZone(Vector2 screenPoint)
    {
        RectTransformUtility.ScreenPointToLocalPointInRectangle(_zoneRectCached, screenPoint, _uiCamera, out var local);
        return _zoneRectCached.rect.Contains(local);
    }

    /// <summary>
    /// Emit Canceled for all active virtual touches and reset the device to a clean state.
    /// </summary>
    private void CancelAll()
    {
        if (_vtsDevice == null) return;

        foreach (var pair in _realToVirtualTouchId)
            InputSystem.QueueStateEvent(_vtsDevice, new TouchState { touchId = pair.Value, phase = SysTouchPhase.Canceled });

        _realToVirtualTouchId.Clear();
        _claimedRealTouchIds.Clear();
        _lastPosByPid.Clear();
        _lastPhaseByPid.Clear();

        InputSystem.ResetDevice(_vtsDevice);
        LogIf(logLifecycleEvents, "CancelAll → emitted Canceled and reset device");
    }

    /// <summary>
    /// Conditional logger honoring instance and global toggles.
    /// </summary>
    private void LogIf(bool categoryEnabled, string message)
    {
        if (!(categoryEnabled && (instanceLoggingEnabled || GlobalLoggingEnabled))) return;
        Debug.Log($"[VTSZone#{GetInstanceID()}] {message}", this);
    }
}