Removed TOTU 103

Assets/Common/InputSystem/TouchManager.cs

@@ -0,0 +1,298 @@
+// Copyright 2022-2024 Niantic.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.InputSystem;
+using UnityEngine.InputSystem.Controls;
+using UnityEngine.InputSystem.LowLevel;
+using UnityEngine.UI;
+using Touch = UnityEngine.InputSystem.EnhancedTouch.Touch;
+using TouchPhase = UnityEngine.TouchPhase;
+
+
+public class TouchManager : MonoBehaviour
+{
+    
+    [Serializable]
+    public class FloatEvent : UnityEvent<float> { };
+    
+
+    [Serializable]
+    public class Vector2Event : UnityEvent<Vector2> { };
+
+    [SerializeField] private float _pinchScrollSpeed;
+    [SerializeField] private float _mouseScrollSpeed;
+    [SerializeField] private float _touchPanSpeed;
+    [SerializeField] private float _mousePanSpeed;
+    
+    private LightshipInput _lightshipInput;
+    private bool _isPointerDown;
+    private bool IsPointerDown
+    {
+        
+        get { return _isPointerDown; }
+        set
+        {
+            _isPointerDown = value;
+            if ((value == false) && (_IsPanActive))
+            {
+                _IsPanActive = false;
+                PanEnded?.Invoke();
+            }
+
+        }
+    }
+    private bool _IsPanActive = false;
+    private Dictionary<int, TouchState> _activeTouches = new Dictionary<int, TouchState>();
+    
+    
+    
+    private float _lastPinchDistance = 0f;
+    private bool _resetPinchDistance = false;
+    private Coroutine activePinchCoroutine = null;
+    
+    [SerializeField] public FloatEvent PinchEvent = new FloatEvent();
+    [SerializeField] public Vector2Event PanEvent = new Vector2Event();
+    [SerializeField] public UnityEvent PanEnded = new UnityEvent();
+    [SerializeField] public Vector2Event TouchUpEvent = new Vector2Event();
+
+    
+    private void Awake()
+    {
+        _lightshipInput = new LightshipInput();
+
+
+    }
+
+    private void OnEnable()
+    {
+        _lightshipInput.Enable();
+    }
+
+    private void OnDisable()
+    {
+        _lightshipInput.Disable();
+    }
+
+    private void Start()
+    {
+        _lightshipInput.Input.PrimaryTouch.performed += ctx => PrimaryTouchCallback(ctx);
+        _lightshipInput.Input.PrimaryTouch.started += ctx => PrimaryTouchCallback(ctx);
+        _lightshipInput.Input.PrimaryTouch.canceled += ctx => PrimaryTouchCallback(ctx);
+
+        _lightshipInput.Input.SecondaryTouch.performed += ctx => SecondaryTouchCallback(ctx);
+        _lightshipInput.Input.SecondaryTouch.started += ctx => SecondaryTouchCallback(ctx);
+        _lightshipInput.Input.SecondaryTouch.canceled += ctx => SecondaryTouchCallback(ctx);
+
+        _lightshipInput.Input.MouseScroll.performed += ctx => MouseScrollCallback(ctx);
+        _lightshipInput.Input.MousePan.performed += ctx => MousePanCallback(ctx);
+        _lightshipInput.Input.MousePan.canceled += ctx => MousePanCallback(ctx);
+
+        _lightshipInput.Input.MouseHold.started += ctx => MouseHoldCallback(ctx);
+        _lightshipInput.Input.MouseHold.performed += ctx => MouseHoldCallback(ctx);
+        _lightshipInput.Input.MouseHold.canceled += ctx => MouseHoldCallback(ctx);
+
+    }
+
+    private void MouseHoldCallback(InputAction.CallbackContext ctx)
+    {
+        switch (ctx.phase)
+        {
+            case InputActionPhase.Started :
+                IsPointerDown = true;
+                break;
+            case InputActionPhase.Canceled :
+                IsPointerDown = false;
+                if (!_IsPanActive)
+                {
+                    TouchUpEvent?.Invoke(Mouse.current.position.ReadValue());
+                }
+                break;
+            
+        }
+        
+    }
+    
+
+    private void MousePanCallback(InputAction.CallbackContext ctx)
+    {
+        var mousepan = ctx.ReadValue<Vector2>();
+        if (ctx.phase == InputActionPhase.Performed)
+        {
+            _IsPanActive = true;
+        }
+        ProcessPan(mousepan  * _mousePanSpeed);
+    }
+
+    private void MouseScrollCallback(InputAction.CallbackContext ctx)
+    {
+        
+        var mousecroll = ctx.ReadValue<Vector2>();
+        ProcessScrollZoom(mousecroll);
+        
+        
+    }
+
+    private void SecondaryTouchCallback(InputAction.CallbackContext ctx)
+    {
+        var touch = ctx.ReadValue<TouchState>();
+        PreprocessTouch(touch);
+        
+    }
+
+    private void PrimaryTouchCallback(InputAction.CallbackContext ctx)
+    {
+        var touch = ctx.ReadValue<TouchState>();
+        PreprocessTouch(touch);
+        
+    }
+
+    private void PreprocessTouch(TouchState touch)
+    {
+        
+        switch (touch.phase)
+        {
+            case UnityEngine.InputSystem.TouchPhase.Began :
+                
+                _activeTouches.TryAdd(touch.touchId, touch);
+                break;
+            case UnityEngine.InputSystem.TouchPhase.Ended :
+                _activeTouches.Remove(touch.touchId);
+                break;
+            case UnityEngine.InputSystem.TouchPhase.Canceled :
+                _activeTouches.Remove(touch.touchId);
+                break;
+            case UnityEngine.InputSystem.TouchPhase.None :
+                break;
+            default :
+                _activeTouches[touch.touchId] = touch;
+                break;
+        }
+        
+        if (_activeTouches.Count > 1)
+        {
+            if (activePinchCoroutine == null)
+            {
+                activePinchCoroutine = StartCoroutine(ProcessPinch());
+            }
+        } 
+        else
+        {
+            if (activePinchCoroutine != null)
+            {
+                StopCoroutine(activePinchCoroutine);
+                activePinchCoroutine = null;
+            }
+
+            if (_activeTouches.Count == 1)
+            {
+                ProcessTouch();
+            }
+            else
+            {
+                IsPointerDown = false;
+            }
+        }
+        
+        if (IsPointerDown == false) 
+            if (_IsPanActive)
+            {
+                _IsPanActive = false;
+                PanEnded?.Invoke();
+            }
+            else
+            {
+                TouchUpEvent?.Invoke(touch.position);
+            } 
+
+        
+    }
+
+
+
+    #region Process Gestures
+
+    private void ProcessPan(Vector2 delta)
+    {
+        
+        PanEvent?.Invoke(delta);
+    }
+    
+    
+
+    private IEnumerator ProcessPinch()
+    {
+        _resetPinchDistance = true;
+        while (true)
+        {
+
+            yield return null;
+            
+            var orderedTouches = _activeTouches.OrderBy(x => x.Key).ToArray();
+            
+            var touchOne = orderedTouches[0];
+            var touchTwo = orderedTouches[1];
+
+            var pinchDistance = Vector2.Distance(touchOne.Value.position, touchTwo.Value.position);
+            if (_resetPinchDistance)
+            {
+                _lastPinchDistance = pinchDistance;
+                _resetPinchDistance = false;
+            }
+            
+            float pinchDelta = (pinchDistance - _lastPinchDistance);
+            _lastPinchDistance = pinchDistance;
+            
+
+            PinchEvent?.Invoke(pinchDelta  * _pinchScrollSpeed);
+        }
+    }
+
+    private void ProcessScrollZoom(Vector2 MouseScrollDelta)
+    {
+        var yScrollDelta = MouseScrollDelta.y * _mouseScrollSpeed;
+        PinchEvent?.Invoke(yScrollDelta);
+    }
+
+    private void ProcessMouseMap()
+    {
+        
+    }
+
+    private void ProcessTouch()
+    {
+        var orderedTouches = _activeTouches.OrderBy(x => x.Key).ToArray();
+        var touch = orderedTouches[0].Value;
+        switch (touch.phase)
+        {
+            case UnityEngine.InputSystem.TouchPhase.Began :
+                IsPointerDown = true;
+                break;
+            case UnityEngine.InputSystem.TouchPhase.Ended :
+                break;
+            case UnityEngine.InputSystem.TouchPhase.Moved:
+                _IsPanActive = true;
+                var delta = touch.delta;
+                if (delta.x + delta.y != 0)
+                {
+                    ProcessPan(delta);
+                }
+                
+
+                break;
+        }
+    }
+    
+    
+    #endregion
+    
+    
+
+
+
+
+}