GemBattle.git - Gitblit

			@@ -9,472 +9,473 @@

			namespace Core.Input
			{
			/// <summary>
			/// Class to manage tap/drag/pinch gestures and other controls
			/// </summary>
			public class InputController : Singleton<InputController>
			{
			/// <summary>
			/// How quickly flick velocity is accumulated with movements
			/// </summary>
			const float k_FlickAccumulationFactor = 0.8f;
			/// <summary>
			/// Class to manage tap/drag/pinch gestures and other controls
			/// </summary>
			public class InputController : Singleton<InputController>
			{
			/// <summary>
			/// How quickly flick velocity is accumulated with movements
			/// </summary>
			const float k_FlickAccumulationFactor = 0.8f;

			/// <summary>
			/// How far fingers must move before starting a drag
			/// </summary>
			public float dragThresholdTouch = 5;
			/// <summary>
			/// How far fingers must move before starting a drag
			/// </summary>
			public float dragThresholdTouch = 5;

			/// <summary>
			/// How far mouse must move before starting a drag
			/// </summary>
			public float dragThresholdMouse;
			/// <summary>
			/// How far mouse must move before starting a drag
			/// </summary>
			public float dragThresholdMouse;

			/// <summary>
			/// How long before a touch can no longer be considered a tap
			/// </summary>
			public float tapTime = 0.2f;
			/// <summary>
			/// How long before a touch can no longer be considered a tap
			/// </summary>
			public float tapTime = 0.2f;

			/// <summary>
			/// How long before a touch is considered a hold
			/// </summary>
			public float holdTime = 0.8f;
			/// <summary>
			/// How long before a touch is considered a hold
			/// </summary>
			public float holdTime = 0.8f;

			/// <summary>
			/// Sensitivity of mouse-wheel based zoom
			/// </summary>
			public float mouseWheelSensitivity = 1.0f;
			/// <summary>
			/// Sensitivity of mouse-wheel based zoom
			/// </summary>
			public float mouseWheelSensitivity = 1.0f;

			/// <summary>
			/// How many mouse buttons to track
			/// </summary>
			public int trackMouseButtons = 2;
			/// <summary>
			/// How many mouse buttons to track
			/// </summary>
			public int trackMouseButtons = 2;

			/// <summary>
			/// Flick movement threshold
			/// </summary>
			public float flickThreshold = 2f;
			/// <summary>
			/// Flick movement threshold
			/// </summary>
			public float flickThreshold = 2f;

			/// <summary>
			/// All the touches we're tracking
			/// </summary>
			List<TouchInfo> m_Touches;
			/// <summary>
			/// All the touches we're tracking
			/// </summary>
			List<TouchInfo> m_Touches;

			/// <summary>
			/// Mouse button info
			/// </summary>
			List<MouseButtonInfo> m_MouseInfo;
			/// <summary>
			/// Mouse button info
			/// </summary>
			List<MouseButtonInfo> m_MouseInfo;

			/// <summary>
			/// Gets the number of active touches
			/// </summary>
			public int activeTouchCount
			{
			get { return m_Touches.Count; }
			}
			/// <summary>
			/// Gets the number of active touches
			/// </summary>
			public int activeTouchCount
			{
			get { return m_Touches.Count; }
			}

			/// <summary>
			/// Tracks if any of the mouse buttons were pressed this frame
			/// </summary>
			public bool mouseButtonPressedThisFrame { get; private set; }
			/// <summary>
			/// Tracks if any of the mouse buttons were pressed this frame
			/// </summary>
			public bool mouseButtonPressedThisFrame { get; private set; }

			/// <summary>
			/// Tracks if the mouse moved this frame
			/// </summary>
			public bool mouseMovedOnThisFrame { get; private set; }
			/// <summary>
			/// Tracks if the mouse moved this frame
			/// </summary>
			public bool mouseMovedOnThisFrame { get; private set; }

			/// <summary>
			/// Tracks if a touch began this frame
			/// </summary>
			public bool touchPressedThisFrame { get; private set; }
			/// <summary>
			/// Tracks if a touch began this frame
			/// </summary>
			public bool touchPressedThisFrame { get; private set; }

			/// <summary>
			/// Current mouse pointer info
			/// </summary>
			public PointerInfo basicMouseInfo { get; private set; }
			/// <summary>
			/// Current mouse pointer info
			/// </summary>
			public PointerInfo basicMouseInfo { get; private set; }

			/// <summary>
			/// Event called when a pointer press is detected
			/// </summary>
			public event Action<PointerActionInfo> pressed;
			/// <summary>
			/// Event called when a pointer press is detected
			/// </summary>
			public event Action<PointerActionInfo> pressed;

			/// <summary>
			/// Event called when a pointer is released
			/// </summary>
			public event Action<PointerActionInfo> released;
			/// <summary>
			/// Event called when a pointer is released
			/// </summary>
			public event Action<PointerActionInfo> released;

			/// <summary>
			/// Event called when a pointer is tapped
			/// </summary>
			public event Action<PointerActionInfo> tapped;
			/// <summary>
			/// Event called when a pointer is tapped
			/// </summary>
			public event Action<PointerActionInfo> tapped;

			/// <summary>
			/// Event called when a drag starts
			/// </summary>
			public event Action<PointerActionInfo> startedDrag;
			/// <summary>
			/// Event called when a drag starts
			/// </summary>
			public event Action<PointerActionInfo> startedDrag;

			/// <summary>
			/// Event called when a pointer is dragged
			/// </summary>
			public event Action<PointerActionInfo> dragged;
			/// <summary>
			/// Event called when a pointer is dragged
			/// </summary>
			public event Action<PointerActionInfo> dragged;

			/// <summary>
			/// Event called when a pointer starts a hold
			/// </summary>
			public event Action<PointerActionInfo> startedHold;
			/// <summary>
			/// Event called when a pointer starts a hold
			/// </summary>
			public event Action<PointerActionInfo> startedHold;

			/// <summary>
			/// Event called when the user scrolls the mouse wheel
			/// </summary>
			public event Action<WheelInfo> spunWheel;
			/// <summary>
			/// Event called when the user scrolls the mouse wheel
			/// </summary>
			public event Action<WheelInfo> spunWheel;

			/// <summary>
			/// Event called when the user performs a pinch gesture
			/// </summary>
			public event Action<PinchInfo> pinched;
			/// <summary>
			/// Event called when the user performs a pinch gesture
			/// </summary>
			public event Action<PinchInfo> pinched;

			/// <summary>
			/// Event called whenever the mouse is moved
			/// </summary>
			public event Action<PointerInfo> mouseMoved;
			/// <summary>
			/// Event called whenever the mouse is moved
			/// </summary>
			public event Action<PointerInfo> mouseMoved;

			protected override void Awake()
			{
			base.Awake();
			m_Touches = new List<TouchInfo>();
			protected override void Awake()
			{
			base.Awake();
			m_Touches = new List<TouchInfo>();

			// Mouse specific initialization
			if (UnityInput.mousePresent)
			{
			m_MouseInfo = new List<MouseButtonInfo>();
			basicMouseInfo = new MouseCursorInfo {currentPosition = UnityInput.mousePosition};
			// Mouse specific initialization
			if (UnityInput.mousePresent)
			{
			m_MouseInfo = new List<MouseButtonInfo>();
			basicMouseInfo = new MouseCursorInfo { currentPosition = UnityInput.mousePosition };

			for (int i = 0; i < trackMouseButtons; ++i)
			{
			m_MouseInfo.Add(new MouseButtonInfo
			{
			currentPosition = UnityInput.mousePosition,
			mouseButtonId = i
			});
			}
			}
			for (int i = 0; i < trackMouseButtons; ++i)
			{
			m_MouseInfo.Add(new MouseButtonInfo
			{
			currentPosition = UnityInput.mousePosition,
			mouseButtonId = i
			});
			}
			}

			UnityInput.simulateMouseWithTouches = false;
			}
			UnityInput.simulateMouseWithTouches = false;
			}

			/// <summary>
			/// Update all input
			/// </summary>
			void Update()
			{
			if (basicMouseInfo != null)
			{
			// Mouse was detected as present
			UpdateMouse();
			}
			// Handle touches
			UpdateTouches();
			}
			/// <summary>
			/// Update all input
			/// </summary>
			void Update()
			{
			if (basicMouseInfo != null)
			{
			// Mouse was detected as present
			UpdateMouse();
			}
			// Handle touches
			UpdateTouches();
			}

			/// <summary>
			/// Perform logic to update mouse/pointing device
			/// </summary>
			void UpdateMouse()
			{
			basicMouseInfo.previousPosition = basicMouseInfo.currentPosition;
			basicMouseInfo.currentPosition = UnityInput.mousePosition;
			basicMouseInfo.delta = basicMouseInfo.currentPosition - basicMouseInfo.previousPosition;
			mouseMovedOnThisFrame = basicMouseInfo.delta.sqrMagnitude >= Mathf.Epsilon;
			mouseButtonPressedThisFrame = false;
			/// <summary>
			/// Perform logic to update mouse/pointing device
			/// </summary>
			void UpdateMouse()
			{
			basicMouseInfo.previousPosition = basicMouseInfo.currentPosition;
			basicMouseInfo.currentPosition = UnityInput.mousePosition;
			basicMouseInfo.delta = basicMouseInfo.currentPosition - basicMouseInfo.previousPosition;
			mouseMovedOnThisFrame = basicMouseInfo.delta.sqrMagnitude >= Mathf.Epsilon;
			mouseButtonPressedThisFrame = false;

			// Move event
			if (basicMouseInfo.delta.sqrMagnitude > Mathf.Epsilon)
			{
			if (mouseMoved != null)
			{
			mouseMoved(basicMouseInfo);
			}
			}
			// Button events
			for (int i = 0; i < trackMouseButtons; ++i)
			{
			MouseButtonInfo mouseButton = m_MouseInfo[i];
			mouseButton.delta = basicMouseInfo.delta;
			mouseButton.previousPosition = basicMouseInfo.previousPosition;
			mouseButton.currentPosition = basicMouseInfo.currentPosition;
			if (UnityInput.GetMouseButton(i))
			{
			if (!mouseButton.isDown)
			{
			// First press
			mouseButtonPressedThisFrame = true;
			mouseButton.isDown = true;
			mouseButton.startPosition = UnityInput.mousePosition;
			mouseButton.startTime = Time.realtimeSinceStartup;
			mouseButton.startedOverUI = EventSystem.current.IsPointerOverGameObject(-mouseButton.mouseButtonId - 1);
			// Move event
			if (basicMouseInfo.delta.sqrMagnitude > Mathf.Epsilon)
			{
			if (mouseMoved != null)
			{
			mouseMoved(basicMouseInfo);
			}
			}
			// Button events
			for (int i = 0; i < trackMouseButtons; ++i)
			{
			MouseButtonInfo mouseButton = m_MouseInfo[i];
			mouseButton.delta = basicMouseInfo.delta;
			mouseButton.previousPosition = basicMouseInfo.previousPosition;
			mouseButton.currentPosition = basicMouseInfo.currentPosition;
			if (UnityInput.GetMouseButton(i))
			{
			if (!mouseButton.isDown)
			{
			// First press
			mouseButtonPressedThisFrame = true;
			mouseButton.isDown = true;
			mouseButton.startPosition = UnityInput.mousePosition;
			mouseButton.startTime = Time.realtimeSinceStartup;
			mouseButton.startedOverUI = EventSystem.current.IsPointerOverGameObject(-mouseButton.mouseButtonId - 1);

			// Reset some stuff
			mouseButton.totalMovement = 0;
			mouseButton.isDrag = false;
			mouseButton.wasHold = false;
			mouseButton.isHold = false;
			mouseButton.flickVelocity = Vector2.zero;
			// Reset some stuff
			mouseButton.totalMovement = 0;
			mouseButton.isDrag = false;
			mouseButton.wasHold = false;
			mouseButton.isHold = false;
			mouseButton.flickVelocity = Vector2.zero;

			if (pressed != null)
			{
			pressed(mouseButton);
			}
			}
			else
			{
			float moveDist = mouseButton.delta.magnitude;
			// Dragging?
			mouseButton.totalMovement += moveDist;
			if (mouseButton.totalMovement > dragThresholdMouse)
			{
			bool wasDrag = mouseButton.isDrag;
			if (pressed != null)
			{
			pressed(mouseButton);
			}
			}
			else
			{
			float moveDist = mouseButton.delta.magnitude;
			// Dragging?
			mouseButton.totalMovement += moveDist;
			if (mouseButton.totalMovement > dragThresholdMouse)
			{
			bool wasDrag = mouseButton.isDrag;

			mouseButton.isDrag = true;
			if (mouseButton.isHold)
			{
			mouseButton.wasHold = mouseButton.isHold;
			mouseButton.isHold = false;
			}
			mouseButton.isDrag = true;
			if (mouseButton.isHold)
			{
			mouseButton.wasHold = mouseButton.isHold;
			mouseButton.isHold = false;
			}

			// Did it just start now?
			if (!wasDrag)
			{
			if (startedDrag != null)
			{
			startedDrag(mouseButton);
			}
			}
			if (dragged != null)
			{
			dragged(mouseButton);
			}
			// Did it just start now?
			if (!wasDrag)
			{
			if (startedDrag != null)
			{
			startedDrag(mouseButton);
			}
			}
			if (dragged != null)
			{
			dragged(mouseButton);
			}

			// Flick?
			if (moveDist > flickThreshold)
			{
			mouseButton.flickVelocity =
			(mouseButton.flickVelocity * (1 - k_FlickAccumulationFactor)) +
			(mouseButton.delta * k_FlickAccumulationFactor);
			}
			else
			{
			mouseButton.flickVelocity = Vector2.zero;
			}
			}
			else
			{
			// Stationary?
			if (!mouseButton.isHold &&
			!mouseButton.isDrag &&
			Time.realtimeSinceStartup - mouseButton.startTime >= holdTime)
			{
			mouseButton.isHold = true;
			if (startedHold != null)
			{
			startedHold(mouseButton);
			}
			}
			}
			}
			}
			else // Mouse button not up
			{
			if (mouseButton.isDown) // Released
			{
			mouseButton.isDown = false;
			// Quick enough (with no drift) to be a tap?
			if (!mouseButton.isDrag &&
			Time.realtimeSinceStartup - mouseButton.startTime < tapTime)
			{
			if (tapped != null)
			{
			tapped(mouseButton);
			}
			}
			if (released != null)
			{
			released(mouseButton);
			}
			}
			}
			}
			// Flick?
			if (moveDist > flickThreshold)
			{
			mouseButton.flickVelocity =
			(mouseButton.flickVelocity * (1 - k_FlickAccumulationFactor)) +
			(mouseButton.delta * k_FlickAccumulationFactor);
			}
			else
			{
			mouseButton.flickVelocity = Vector2.zero;
			}
			}
			else
			{
			// Stationary?
			if (!mouseButton.isHold &&
			!mouseButton.isDrag &&
			Time.realtimeSinceStartup - mouseButton.startTime >= holdTime)
			{
			mouseButton.isHold = true;
			if (startedHold != null)
			{
			startedHold(mouseButton);
			}
			}
			}
			}
			}
			else // Mouse button not up
			{
			if (mouseButton.isDown) // Released
			{
			mouseButton.isDown = false;
			// Quick enough (with no drift) to be a tap?
			if (!mouseButton.isDrag &&
			Time.realtimeSinceStartup - mouseButton.startTime < tapTime)
			{
			if (tapped != null)
			{
			tapped(mouseButton);
			}
			}
			if (released != null)
			{
			released(mouseButton);
			}
			}
			}
			}

			// Mouse wheel
			if (Mathf.Abs(UnityInput.GetAxis("Mouse ScrollWheel")) > Mathf.Epsilon)
			{
			if (spunWheel != null)
			{
			spunWheel(new WheelInfo
			{
			zoomAmount = UnityInput.GetAxis("Mouse ScrollWheel") * mouseWheelSensitivity
			});
			}
			}
			}
			// Mouse wheel
			if (Mathf.Abs(UnityInput.GetAxis("Mouse ScrollWheel")) > Mathf.Epsilon)
			{
			if (spunWheel != null)
			{
			spunWheel(new WheelInfo
			{
			zoomAmount = UnityInput.GetAxis("Mouse ScrollWheel") * mouseWheelSensitivity
			});
			}
			}
			}

			/// <summary>
			/// Update all touches
			/// </summary>
			void UpdateTouches()
			{
			touchPressedThisFrame = false;
			for (int i = 0; i < UnityInput.touchCount; ++i)
			{
			Touch touch = UnityInput.GetTouch(i);
			/// <summary>
			/// Update all touches
			/// </summary>
			void UpdateTouches()
			{
			touchPressedThisFrame = false;
			//for (int i = 0; i < UnityInput.touchCount; ++i)
			if (UnityInput.touchCount > 0)
			{
			Touch touch = UnityInput.GetTouch(0);

			// Find existing touch, or create new one
			TouchInfo existingTouch = m_Touches.FirstOrDefault(t => t.touchId == touch.fingerId);
			// Find existing touch, or create new one
			TouchInfo existingTouch = m_Touches.FirstOrDefault(t => t.touchId == touch.fingerId);

			if (existingTouch == null)
			{
			existingTouch = new TouchInfo
			{
			touchId = touch.fingerId,
			startPosition = touch.position,
			currentPosition = touch.position,
			previousPosition = touch.position,
			startTime = Time.realtimeSinceStartup,
			startedOverUI = EventSystem.current.IsPointerOverGameObject(touch.fingerId)
			};
			if (existingTouch == null)
			{
			existingTouch = new TouchInfo
			{
			touchId = touch.fingerId,
			startPosition = touch.position,
			currentPosition = touch.position,
			previousPosition = touch.position,
			startTime = Time.realtimeSinceStartup,
			startedOverUI = EventSystem.current.IsPointerOverGameObject(touch.fingerId)
			};

			m_Touches.Add(existingTouch);
			m_Touches.Add(existingTouch);

			// Sanity check
			Debug.Assert(touch.phase == TouchPhase.Began);
			}
			switch (touch.phase)
			{
			case TouchPhase.Began:
			touchPressedThisFrame = true;
			if (pressed != null)
			{
			pressed(existingTouch);
			}
			break;
			// Sanity check
			Debug.Assert(touch.phase == TouchPhase.Began);
			}
			switch (touch.phase)
			{
			case TouchPhase.Began:
			touchPressedThisFrame = true;
			if (pressed != null)
			{
			pressed(existingTouch);
			}
			break;

			case TouchPhase.Moved:
			bool wasDrag = existingTouch.isDrag;
			UpdateMovingFinger(touch, existingTouch);
			case TouchPhase.Moved:
			bool wasDrag = existingTouch.isDrag;
			UpdateMovingFinger(touch, existingTouch);

			// Is this a drag?
			existingTouch.isDrag = existingTouch.totalMovement >= dragThresholdTouch;
			// Is this a drag?
			existingTouch.isDrag = existingTouch.totalMovement >= dragThresholdTouch;

			if (existingTouch.isDrag)
			{
			if (existingTouch.isHold)
			{
			existingTouch.wasHold = existingTouch.isHold;
			existingTouch.isHold = false;
			}
			// Did it just start now?
			if (!wasDrag)
			{
			if (startedDrag != null)
			{
			startedDrag(existingTouch);
			}
			}
			if (dragged != null)
			{
			dragged(existingTouch);
			}
			if (existingTouch.isDrag)
			{
			if (existingTouch.isHold)
			{
			existingTouch.wasHold = existingTouch.isHold;
			existingTouch.isHold = false;
			}
			// Did it just start now?
			if (!wasDrag)
			{
			if (startedDrag != null)
			{
			startedDrag(existingTouch);
			}
			}
			if (dragged != null)
			{
			dragged(existingTouch);
			}

			if (existingTouch.delta.sqrMagnitude > flickThreshold * flickThreshold)
			{
			existingTouch.flickVelocity =
			(existingTouch.flickVelocity * (1 - k_FlickAccumulationFactor)) +
			(existingTouch.delta * k_FlickAccumulationFactor);
			}
			else
			{
			existingTouch.flickVelocity = Vector2.zero;
			}
			}
			else
			{
			UpdateHoldingFinger(existingTouch);
			}
			break;
			if (existingTouch.delta.sqrMagnitude > flickThreshold * flickThreshold)
			{
			existingTouch.flickVelocity =
			(existingTouch.flickVelocity * (1 - k_FlickAccumulationFactor)) +
			(existingTouch.delta * k_FlickAccumulationFactor);
			}
			else
			{
			existingTouch.flickVelocity = Vector2.zero;
			}
			}
			else
			{
			UpdateHoldingFinger(existingTouch);
			}
			break;

			case TouchPhase.Canceled:
			case TouchPhase.Ended:
			// Could have moved a bit
			UpdateMovingFinger(touch, existingTouch);
			// Quick enough (with no drift) to be a tap?
			if (!existingTouch.isDrag &&
			Time.realtimeSinceStartup - existingTouch.startTime < tapTime)
			{
			if (tapped != null)
			{
			tapped(existingTouch);
			}
			}
			if (released != null)
			{
			released(existingTouch);
			}
			case TouchPhase.Canceled:
			case TouchPhase.Ended:
			// Could have moved a bit
			UpdateMovingFinger(touch, existingTouch);
			// Quick enough (with no drift) to be a tap?
			if (!existingTouch.isDrag &&
			Time.realtimeSinceStartup - existingTouch.startTime < tapTime)
			{
			if (tapped != null)
			{
			tapped(existingTouch);
			}
			}
			if (released != null)
			{
			released(existingTouch);
			}

			// Remove from track list
			m_Touches.Remove(existingTouch);
			break;
			// Remove from track list
			m_Touches.Remove(existingTouch);
			break;

			case TouchPhase.Stationary:
			UpdateMovingFinger(touch, existingTouch);
			UpdateHoldingFinger(existingTouch);
			existingTouch.flickVelocity = Vector2.zero;
			break;
			}
			}
			case TouchPhase.Stationary:
			UpdateMovingFinger(touch, existingTouch);
			UpdateHoldingFinger(existingTouch);
			existingTouch.flickVelocity = Vector2.zero;
			break;
			}
			}

			if (activeTouchCount >= 2 && (m_Touches[0].isDrag \|\|
			m_Touches[1].isDrag))
			{
			if (pinched != null)
			{
			pinched(new PinchInfo
			{
			touch1 = m_Touches[0],
			touch2 = m_Touches[1]
			});
			}
			}
			}
			if (activeTouchCount >= 2 && (m_Touches[0].isDrag \|\|
			m_Touches[1].isDrag))
			{
			if (pinched != null)
			{
			pinched(new PinchInfo
			{
			touch1 = m_Touches[0],
			touch2 = m_Touches[1]
			});
			}
			}
			}

			/// <summary>
			/// Update a TouchInfo that might be holding
			/// </summary>
			/// <param name="existingTouch"></param>
			void UpdateHoldingFinger(PointerActionInfo existingTouch)
			{
			if (!existingTouch.isHold &&
			!existingTouch.isDrag &&
			Time.realtimeSinceStartup - existingTouch.startTime >= holdTime)
			{
			existingTouch.isHold = true;
			if (startedHold != null)
			{
			startedHold(existingTouch);
			}
			}
			}
			/// <summary>
			/// Update a TouchInfo that might be holding
			/// </summary>
			/// <param name="existingTouch"></param>
			void UpdateHoldingFinger(PointerActionInfo existingTouch)
			{
			if (!existingTouch.isHold &&
			!existingTouch.isDrag &&
			Time.realtimeSinceStartup - existingTouch.startTime >= holdTime)
			{
			existingTouch.isHold = true;
			if (startedHold != null)
			{
			startedHold(existingTouch);
			}
			}
			}

			/// <summary>
			/// Update a TouchInfo with movement
			/// </summary>
			/// <param name="touch">The Unity touch object</param>
			/// <param name="existingTouch">The object that's tracking Unity's touch</param>
			void UpdateMovingFinger(Touch touch, PointerActionInfo existingTouch)
			{
			float dragDist = touch.deltaPosition.magnitude;
			/// <summary>
			/// Update a TouchInfo with movement
			/// </summary>
			/// <param name="touch">The Unity touch object</param>
			/// <param name="existingTouch">The object that's tracking Unity's touch</param>
			void UpdateMovingFinger(Touch touch, PointerActionInfo existingTouch)
			{
			float dragDist = touch.deltaPosition.magnitude;

			existingTouch.previousPosition = existingTouch.currentPosition;
			existingTouch.currentPosition = touch.position;
			existingTouch.delta = touch.deltaPosition;
			existingTouch.totalMovement += dragDist;
			}
			}
			existingTouch.previousPosition = existingTouch.currentPosition;
			existingTouch.currentPosition = touch.position;
			existingTouch.delta = touch.deltaPosition;
			existingTouch.totalMovement += dragDist;
			}
			}
			}