Initial Commit
This commit is contained in:
parent
53eb92e9af
commit
270ab7d11f
15341 changed files with 700234 additions and 0 deletions
|
|
@ -0,0 +1,129 @@
|
|||
using UnityEngine.UI;
|
||||
|
||||
namespace UnityEngine.EventSystems
|
||||
{
|
||||
/// <summary>
|
||||
/// Interface to the Input system used by the BaseInputModule. With this it is possible to bypass the Input system with your own but still use the same InputModule. For example this can be used to feed fake input into the UI or interface with a different input system.
|
||||
/// </summary>
|
||||
public class BaseInput : UIBehaviour
|
||||
{
|
||||
/// <summary>
|
||||
/// Interface to Input.compositionString. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
public virtual string compositionString
|
||||
{
|
||||
get { return Input.compositionString; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.imeCompositionMode. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
public virtual IMECompositionMode imeCompositionMode
|
||||
{
|
||||
get { return Input.imeCompositionMode; }
|
||||
set { Input.imeCompositionMode = value; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.compositionCursorPos. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
public virtual Vector2 compositionCursorPos
|
||||
{
|
||||
get { return Input.compositionCursorPos; }
|
||||
set { Input.compositionCursorPos = value; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.mousePresent. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
public virtual bool mousePresent
|
||||
{
|
||||
get { return Input.mousePresent; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.GetMouseButtonDown. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
/// <param name="button"></param>
|
||||
/// <returns></returns>
|
||||
public virtual bool GetMouseButtonDown(int button)
|
||||
{
|
||||
return Input.GetMouseButtonDown(button);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.GetMouseButtonUp. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
public virtual bool GetMouseButtonUp(int button)
|
||||
{
|
||||
return Input.GetMouseButtonUp(button);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.GetMouseButton. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
public virtual bool GetMouseButton(int button)
|
||||
{
|
||||
return Input.GetMouseButton(button);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.mousePosition. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
public virtual Vector2 mousePosition
|
||||
{
|
||||
get { return MultipleDisplayUtilities.GetMousePositionRelativeToMainDisplayResolution(); }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.mouseScrollDelta. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
public virtual Vector2 mouseScrollDelta
|
||||
{
|
||||
get { return Input.mouseScrollDelta; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.touchSupported. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
public virtual bool touchSupported
|
||||
{
|
||||
get { return Input.touchSupported; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.touchCount. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
public virtual int touchCount
|
||||
{
|
||||
get { return Input.touchCount; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.GetTouch. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
/// <param name="index">Touch index to get</param>
|
||||
public virtual Touch GetTouch(int index)
|
||||
{
|
||||
return Input.GetTouch(index);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.GetAxisRaw. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
/// <param name="axisName">Axis name to check</param>
|
||||
public virtual float GetAxisRaw(string axisName)
|
||||
{
|
||||
return Input.GetAxisRaw(axisName);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Interface to Input.GetButtonDown. Can be overridden to provide custom input instead of using the Input class.
|
||||
/// </summary>
|
||||
/// <param name="buttonName">Button name to get</param>
|
||||
public virtual bool GetButtonDown(string buttonName)
|
||||
{
|
||||
return Input.GetButtonDown(buttonName);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
fileFormatVersion: 2
|
||||
guid: 1511ccae7919cfc46b603b9b337fdc94
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
|
|
@ -0,0 +1,355 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace UnityEngine.EventSystems
|
||||
{
|
||||
[RequireComponent(typeof(EventSystem))]
|
||||
/// <summary>
|
||||
/// A base module that raises events and sends them to GameObjects.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// An Input Module is a component of the EventSystem that is responsible for raising events and sending them to GameObjects for handling. The BaseInputModule is a class that all Input Modules in the EventSystem inherit from. Examples of provided modules are TouchInputModule and StandaloneInputModule, if these are inadequate for your project you can create your own by extending from the BaseInputModule.
|
||||
/// </remarks>
|
||||
/// <example>
|
||||
/// <code>
|
||||
/// <![CDATA[
|
||||
/// using UnityEngine;
|
||||
/// using UnityEngine.EventSystems;
|
||||
///
|
||||
/// /**
|
||||
/// * Create a module that every tick sends a 'Move' event to
|
||||
/// * the target object
|
||||
/// */
|
||||
/// public class MyInputModule : BaseInputModule
|
||||
/// {
|
||||
/// public GameObject m_TargetObject;
|
||||
///
|
||||
/// public override void Process()
|
||||
/// {
|
||||
/// if (m_TargetObject == null)
|
||||
/// return;
|
||||
/// ExecuteEvents.Execute (m_TargetObject, new BaseEventData (eventSystem), ExecuteEvents.moveHandler);
|
||||
/// }
|
||||
/// }
|
||||
/// ]]>
|
||||
///</code>
|
||||
/// </example>
|
||||
public abstract class BaseInputModule : UIBehaviour
|
||||
{
|
||||
[NonSerialized]
|
||||
protected List<RaycastResult> m_RaycastResultCache = new List<RaycastResult>();
|
||||
|
||||
private AxisEventData m_AxisEventData;
|
||||
|
||||
private EventSystem m_EventSystem;
|
||||
private BaseEventData m_BaseEventData;
|
||||
|
||||
protected BaseInput m_InputOverride;
|
||||
private BaseInput m_DefaultInput;
|
||||
|
||||
/// <summary>
|
||||
/// The current BaseInput being used by the input module.
|
||||
/// </summary>
|
||||
public BaseInput input
|
||||
{
|
||||
get
|
||||
{
|
||||
if (m_InputOverride != null)
|
||||
return m_InputOverride;
|
||||
|
||||
if (m_DefaultInput == null)
|
||||
{
|
||||
var inputs = GetComponents<BaseInput>();
|
||||
foreach (var baseInput in inputs)
|
||||
{
|
||||
// We dont want to use any classes that derrive from BaseInput for default.
|
||||
if (baseInput != null && baseInput.GetType() == typeof(BaseInput))
|
||||
{
|
||||
m_DefaultInput = baseInput;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (m_DefaultInput == null)
|
||||
m_DefaultInput = gameObject.AddComponent<BaseInput>();
|
||||
}
|
||||
|
||||
return m_DefaultInput;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Used to override the default BaseInput for the input module.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// With this it is possible to bypass the Input system with your own but still use the same InputModule. For example this can be used to feed fake input into the UI or interface with a different input system.
|
||||
/// </remarks>
|
||||
public BaseInput inputOverride
|
||||
{
|
||||
get { return m_InputOverride; }
|
||||
set { m_InputOverride = value; }
|
||||
}
|
||||
|
||||
protected EventSystem eventSystem
|
||||
{
|
||||
get { return m_EventSystem; }
|
||||
}
|
||||
|
||||
protected override void OnEnable()
|
||||
{
|
||||
base.OnEnable();
|
||||
m_EventSystem = GetComponent<EventSystem>();
|
||||
m_EventSystem.UpdateModules();
|
||||
}
|
||||
|
||||
protected override void OnDisable()
|
||||
{
|
||||
m_EventSystem.UpdateModules();
|
||||
base.OnDisable();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Process the current tick for the module.
|
||||
/// </summary>
|
||||
public abstract void Process();
|
||||
|
||||
/// <summary>
|
||||
/// Return the first valid RaycastResult.
|
||||
/// </summary>
|
||||
protected static RaycastResult FindFirstRaycast(List<RaycastResult> candidates)
|
||||
{
|
||||
var candidatesCount = candidates.Count;
|
||||
for (var i = 0; i < candidatesCount; ++i)
|
||||
{
|
||||
if (candidates[i].gameObject == null)
|
||||
continue;
|
||||
|
||||
return candidates[i];
|
||||
}
|
||||
return new RaycastResult();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Given an input movement, determine the best MoveDirection.
|
||||
/// </summary>
|
||||
/// <param name="x">X movement.</param>
|
||||
/// <param name="y">Y movement.</param>
|
||||
protected static MoveDirection DetermineMoveDirection(float x, float y)
|
||||
{
|
||||
return DetermineMoveDirection(x, y, 0.6f);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Given an input movement, determine the best MoveDirection.
|
||||
/// </summary>
|
||||
/// <param name="x">X movement.</param>
|
||||
/// <param name="y">Y movement.</param>
|
||||
/// <param name="deadZone">Dead zone.</param>
|
||||
protected static MoveDirection DetermineMoveDirection(float x, float y, float deadZone)
|
||||
{
|
||||
// if vector is too small... just return
|
||||
if (new Vector2(x, y).sqrMagnitude < deadZone * deadZone)
|
||||
return MoveDirection.None;
|
||||
|
||||
if (Mathf.Abs(x) > Mathf.Abs(y))
|
||||
{
|
||||
return x > 0 ? MoveDirection.Right : MoveDirection.Left;
|
||||
}
|
||||
|
||||
return y > 0 ? MoveDirection.Up : MoveDirection.Down;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Given 2 GameObjects, return a common root GameObject (or null).
|
||||
/// </summary>
|
||||
/// <param name="g1">GameObject to compare</param>
|
||||
/// <param name="g2">GameObject to compare</param>
|
||||
/// <returns></returns>
|
||||
protected static GameObject FindCommonRoot(GameObject g1, GameObject g2)
|
||||
{
|
||||
if (g1 == null || g2 == null)
|
||||
return null;
|
||||
|
||||
var t1 = g1.transform;
|
||||
while (t1 != null)
|
||||
{
|
||||
var t2 = g2.transform;
|
||||
while (t2 != null)
|
||||
{
|
||||
if (t1 == t2)
|
||||
return t1.gameObject;
|
||||
t2 = t2.parent;
|
||||
}
|
||||
t1 = t1.parent;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// walk up the tree till a common root between the last entered and the current entered is found
|
||||
// send exit events up to (but not inluding) the common root. Then send enter events up to
|
||||
// (but not including the common root).
|
||||
// Send move events before exit, after enter, and on hovered objects when pointer data has changed.
|
||||
protected void HandlePointerExitAndEnter(PointerEventData currentPointerData, GameObject newEnterTarget)
|
||||
{
|
||||
// if we have no target / pointerEnter has been deleted
|
||||
// just send exit events to anything we are tracking
|
||||
// then exit
|
||||
if (newEnterTarget == null || currentPointerData.pointerEnter == null)
|
||||
{
|
||||
var hoveredCount = currentPointerData.hovered.Count;
|
||||
for (var i = 0; i < hoveredCount; ++i)
|
||||
{
|
||||
ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerMoveHandler);
|
||||
ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerExitHandler);
|
||||
}
|
||||
|
||||
currentPointerData.hovered.Clear();
|
||||
|
||||
if (newEnterTarget == null)
|
||||
{
|
||||
currentPointerData.pointerEnter = null;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// if we have not changed hover target
|
||||
if (currentPointerData.pointerEnter == newEnterTarget && newEnterTarget)
|
||||
{
|
||||
if (currentPointerData.IsPointerMoving())
|
||||
{
|
||||
var hoveredCount = currentPointerData.hovered.Count;
|
||||
for (var i = 0; i < hoveredCount; ++i)
|
||||
ExecuteEvents.Execute(currentPointerData.hovered[i], currentPointerData, ExecuteEvents.pointerMoveHandler);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
GameObject commonRoot = FindCommonRoot(currentPointerData.pointerEnter, newEnterTarget);
|
||||
|
||||
// and we already an entered object from last time
|
||||
if (currentPointerData.pointerEnter != null)
|
||||
{
|
||||
// send exit handler call to all elements in the chain
|
||||
// until we reach the new target, or null!
|
||||
Transform t = currentPointerData.pointerEnter.transform;
|
||||
|
||||
while (t != null)
|
||||
{
|
||||
// if we reach the common root break out!
|
||||
if (commonRoot != null && commonRoot.transform == t)
|
||||
break;
|
||||
|
||||
ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerMoveHandler);
|
||||
ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerExitHandler);
|
||||
currentPointerData.hovered.Remove(t.gameObject);
|
||||
t = t.parent;
|
||||
}
|
||||
}
|
||||
|
||||
// now issue the enter call up to but not including the common root
|
||||
currentPointerData.pointerEnter = newEnterTarget;
|
||||
if (newEnterTarget != null)
|
||||
{
|
||||
Transform t = newEnterTarget.transform;
|
||||
|
||||
while (t != null && t.gameObject != commonRoot)
|
||||
{
|
||||
ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerEnterHandler);
|
||||
ExecuteEvents.Execute(t.gameObject, currentPointerData, ExecuteEvents.pointerMoveHandler);
|
||||
currentPointerData.hovered.Add(t.gameObject);
|
||||
t = t.parent;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Given some input data generate an AxisEventData that can be used by the event system.
|
||||
/// </summary>
|
||||
/// <param name="x">X movement.</param>
|
||||
/// <param name="y">Y movement.</param>
|
||||
/// <param name="deadZone">Dead zone.</param>
|
||||
protected virtual AxisEventData GetAxisEventData(float x, float y, float moveDeadZone)
|
||||
{
|
||||
if (m_AxisEventData == null)
|
||||
m_AxisEventData = new AxisEventData(eventSystem);
|
||||
|
||||
m_AxisEventData.Reset();
|
||||
m_AxisEventData.moveVector = new Vector2(x, y);
|
||||
m_AxisEventData.moveDir = DetermineMoveDirection(x, y, moveDeadZone);
|
||||
return m_AxisEventData;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generate a BaseEventData that can be used by the EventSystem.
|
||||
/// </summary>
|
||||
protected virtual BaseEventData GetBaseEventData()
|
||||
{
|
||||
if (m_BaseEventData == null)
|
||||
m_BaseEventData = new BaseEventData(eventSystem);
|
||||
|
||||
m_BaseEventData.Reset();
|
||||
return m_BaseEventData;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// If the module is pointer based, then override this to return true if the pointer is over an event system object.
|
||||
/// </summary>
|
||||
/// <param name="pointerId">Pointer ID</param>
|
||||
/// <returns>Is the given pointer over an event system object?</returns>
|
||||
public virtual bool IsPointerOverGameObject(int pointerId)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Should the module be activated.
|
||||
/// </summary>
|
||||
public virtual bool ShouldActivateModule()
|
||||
{
|
||||
return enabled && gameObject.activeInHierarchy;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Called when the module is deactivated. Override this if you want custom code to execute when you deactivate your module.
|
||||
/// </summary>
|
||||
public virtual void DeactivateModule()
|
||||
{}
|
||||
|
||||
/// <summary>
|
||||
/// Called when the module is activated. Override this if you want custom code to execute when you activate your module.
|
||||
/// </summary>
|
||||
public virtual void ActivateModule()
|
||||
{}
|
||||
|
||||
/// <summary>
|
||||
/// Update the internal state of the Module.
|
||||
/// </summary>
|
||||
public virtual void UpdateModule()
|
||||
{}
|
||||
|
||||
/// <summary>
|
||||
/// Check to see if the module is supported. Override this if you have a platform specific module (eg. TouchInputModule that you do not want to activate on standalone.)
|
||||
/// </summary>
|
||||
/// <returns>Is the module supported.</returns>
|
||||
public virtual bool IsModuleSupported()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns Id of the pointer following <see cref="UnityEngine.UIElements.PointerId"/> convention.
|
||||
/// </summary>
|
||||
/// <param name="sourcePointerData">PointerEventData whose pointerId will be converted to UI Toolkit pointer convention.</param>
|
||||
/// <seealso cref="UnityEngine.UIElements.IPointerEvent" />
|
||||
public virtual int ConvertUIToolkitPointerId(PointerEventData sourcePointerData)
|
||||
{
|
||||
#if PACKAGE_UITOOLKIT
|
||||
return sourcePointerData.pointerId < 0 ?
|
||||
UIElements.PointerId.mousePointerId :
|
||||
UIElements.PointerId.touchPointerIdBase + sourcePointerData.pointerId;
|
||||
#else
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
fileFormatVersion: 2
|
||||
guid: 1ea10891dd782154ca0fb67bce9e6f72
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
|
|
@ -0,0 +1,437 @@
|
|||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
using UnityEngine.UI;
|
||||
|
||||
namespace UnityEngine.EventSystems
|
||||
{
|
||||
/// <summary>
|
||||
/// A BaseInputModule for pointer input.
|
||||
/// </summary>
|
||||
public abstract class PointerInputModule : BaseInputModule
|
||||
{
|
||||
/// <summary>
|
||||
/// Id of the cached left mouse pointer event.
|
||||
/// </summary>
|
||||
public const int kMouseLeftId = -1;
|
||||
|
||||
/// <summary>
|
||||
/// Id of the cached right mouse pointer event.
|
||||
/// </summary>
|
||||
public const int kMouseRightId = -2;
|
||||
|
||||
/// <summary>
|
||||
/// Id of the cached middle mouse pointer event.
|
||||
/// </summary>
|
||||
public const int kMouseMiddleId = -3;
|
||||
|
||||
/// <summary>
|
||||
/// Touch id for when simulating touches on a non touch device.
|
||||
/// </summary>
|
||||
public const int kFakeTouchesId = -4;
|
||||
|
||||
protected Dictionary<int, PointerEventData> m_PointerData = new Dictionary<int, PointerEventData>();
|
||||
|
||||
/// <summary>
|
||||
/// Search the cache for currently active pointers, return true if found.
|
||||
/// </summary>
|
||||
/// <param name="id">Touch ID</param>
|
||||
/// <param name="data">Found data</param>
|
||||
/// <param name="create">If not found should it be created</param>
|
||||
/// <returns>True if pointer is found.</returns>
|
||||
protected bool GetPointerData(int id, out PointerEventData data, bool create)
|
||||
{
|
||||
if (!m_PointerData.TryGetValue(id, out data) && create)
|
||||
{
|
||||
data = new PointerEventData(eventSystem)
|
||||
{
|
||||
pointerId = id,
|
||||
};
|
||||
m_PointerData.Add(id, data);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Remove the PointerEventData from the cache.
|
||||
/// </summary>
|
||||
protected void RemovePointerData(PointerEventData data)
|
||||
{
|
||||
m_PointerData.Remove(data.pointerId);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Given a touch populate the PointerEventData and return if we are pressed or released.
|
||||
/// </summary>
|
||||
/// <param name="input">Touch being processed</param>
|
||||
/// <param name="pressed">Are we pressed this frame</param>
|
||||
/// <param name="released">Are we released this frame</param>
|
||||
/// <returns></returns>
|
||||
protected PointerEventData GetTouchPointerEventData(Touch input, out bool pressed, out bool released)
|
||||
{
|
||||
PointerEventData pointerData;
|
||||
var created = GetPointerData(input.fingerId, out pointerData, true);
|
||||
|
||||
pointerData.Reset();
|
||||
|
||||
pressed = created || (input.phase == TouchPhase.Began);
|
||||
released = (input.phase == TouchPhase.Canceled) || (input.phase == TouchPhase.Ended);
|
||||
|
||||
if (created)
|
||||
pointerData.position = input.position;
|
||||
|
||||
if (pressed)
|
||||
pointerData.delta = Vector2.zero;
|
||||
else
|
||||
pointerData.delta = input.position - pointerData.position;
|
||||
|
||||
pointerData.position = input.position;
|
||||
|
||||
pointerData.button = PointerEventData.InputButton.Left;
|
||||
|
||||
if (input.phase == TouchPhase.Canceled)
|
||||
{
|
||||
pointerData.pointerCurrentRaycast = new RaycastResult();
|
||||
}
|
||||
else
|
||||
{
|
||||
eventSystem.RaycastAll(pointerData, m_RaycastResultCache);
|
||||
|
||||
var raycast = FindFirstRaycast(m_RaycastResultCache);
|
||||
pointerData.pointerCurrentRaycast = raycast;
|
||||
m_RaycastResultCache.Clear();
|
||||
}
|
||||
|
||||
pointerData.pressure = input.pressure;
|
||||
pointerData.altitudeAngle = input.altitudeAngle;
|
||||
pointerData.azimuthAngle = input.azimuthAngle;
|
||||
pointerData.radius = Vector2.one * input.radius;
|
||||
pointerData.radiusVariance = Vector2.one * input.radiusVariance;
|
||||
|
||||
return pointerData;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Copy one PointerEventData to another.
|
||||
/// </summary>
|
||||
protected void CopyFromTo(PointerEventData @from, PointerEventData @to)
|
||||
{
|
||||
@to.position = @from.position;
|
||||
@to.delta = @from.delta;
|
||||
@to.scrollDelta = @from.scrollDelta;
|
||||
@to.pointerCurrentRaycast = @from.pointerCurrentRaycast;
|
||||
@to.pointerEnter = @from.pointerEnter;
|
||||
|
||||
@to.pressure = @from.pressure;
|
||||
@to.tangentialPressure = @from.tangentialPressure;
|
||||
@to.altitudeAngle = @from.altitudeAngle;
|
||||
@to.azimuthAngle = @from.azimuthAngle;
|
||||
@to.twist = @from.twist;
|
||||
@to.radius = @from.radius;
|
||||
@to.radiusVariance = @from.radiusVariance;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Given a mouse button return the current state for the frame.
|
||||
/// </summary>
|
||||
/// <param name="buttonId">Mouse button ID</param>
|
||||
protected PointerEventData.FramePressState StateForMouseButton(int buttonId)
|
||||
{
|
||||
var pressed = input.GetMouseButtonDown(buttonId);
|
||||
var released = input.GetMouseButtonUp(buttonId);
|
||||
if (pressed && released)
|
||||
return PointerEventData.FramePressState.PressedAndReleased;
|
||||
if (pressed)
|
||||
return PointerEventData.FramePressState.Pressed;
|
||||
if (released)
|
||||
return PointerEventData.FramePressState.Released;
|
||||
return PointerEventData.FramePressState.NotChanged;
|
||||
}
|
||||
|
||||
protected class ButtonState
|
||||
{
|
||||
private PointerEventData.InputButton m_Button = PointerEventData.InputButton.Left;
|
||||
|
||||
public MouseButtonEventData eventData
|
||||
{
|
||||
get { return m_EventData; }
|
||||
set { m_EventData = value; }
|
||||
}
|
||||
|
||||
public PointerEventData.InputButton button
|
||||
{
|
||||
get { return m_Button; }
|
||||
set { m_Button = value; }
|
||||
}
|
||||
|
||||
private MouseButtonEventData m_EventData;
|
||||
}
|
||||
|
||||
protected class MouseState
|
||||
{
|
||||
private List<ButtonState> m_TrackedButtons = new List<ButtonState>();
|
||||
|
||||
public bool AnyPressesThisFrame()
|
||||
{
|
||||
var trackedButtonsCount = m_TrackedButtons.Count;
|
||||
for (int i = 0; i < trackedButtonsCount; i++)
|
||||
{
|
||||
if (m_TrackedButtons[i].eventData.PressedThisFrame())
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public bool AnyReleasesThisFrame()
|
||||
{
|
||||
var trackedButtonsCount = m_TrackedButtons.Count;
|
||||
for (int i = 0; i < trackedButtonsCount; i++)
|
||||
{
|
||||
if (m_TrackedButtons[i].eventData.ReleasedThisFrame())
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public ButtonState GetButtonState(PointerEventData.InputButton button)
|
||||
{
|
||||
ButtonState tracked = null;
|
||||
var trackedButtonsCount = m_TrackedButtons.Count;
|
||||
for (int i = 0; i < trackedButtonsCount; i++)
|
||||
{
|
||||
if (m_TrackedButtons[i].button == button)
|
||||
{
|
||||
tracked = m_TrackedButtons[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (tracked == null)
|
||||
{
|
||||
tracked = new ButtonState { button = button, eventData = new MouseButtonEventData() };
|
||||
m_TrackedButtons.Add(tracked);
|
||||
}
|
||||
return tracked;
|
||||
}
|
||||
|
||||
public void SetButtonState(PointerEventData.InputButton button, PointerEventData.FramePressState stateForMouseButton, PointerEventData data)
|
||||
{
|
||||
var toModify = GetButtonState(button);
|
||||
toModify.eventData.buttonState = stateForMouseButton;
|
||||
toModify.eventData.buttonData = data;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Information about a mouse button event.
|
||||
/// </summary>
|
||||
public class MouseButtonEventData
|
||||
{
|
||||
/// <summary>
|
||||
/// The state of the button this frame.
|
||||
/// </summary>
|
||||
public PointerEventData.FramePressState buttonState;
|
||||
|
||||
/// <summary>
|
||||
/// Pointer data associated with the mouse event.
|
||||
/// </summary>
|
||||
public PointerEventData buttonData;
|
||||
|
||||
/// <summary>
|
||||
/// Was the button pressed this frame?
|
||||
/// </summary>
|
||||
public bool PressedThisFrame()
|
||||
{
|
||||
return buttonState == PointerEventData.FramePressState.Pressed || buttonState == PointerEventData.FramePressState.PressedAndReleased;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Was the button released this frame?
|
||||
/// </summary>
|
||||
public bool ReleasedThisFrame()
|
||||
{
|
||||
return buttonState == PointerEventData.FramePressState.Released || buttonState == PointerEventData.FramePressState.PressedAndReleased;
|
||||
}
|
||||
}
|
||||
|
||||
private readonly MouseState m_MouseState = new MouseState();
|
||||
|
||||
/// <summary>
|
||||
/// Return the current MouseState. Using the default pointer.
|
||||
/// </summary>
|
||||
protected virtual MouseState GetMousePointerEventData()
|
||||
{
|
||||
return GetMousePointerEventData(0);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Return the current MouseState.
|
||||
/// </summary>
|
||||
protected virtual MouseState GetMousePointerEventData(int id)
|
||||
{
|
||||
// Populate the left button...
|
||||
PointerEventData leftData;
|
||||
var created = GetPointerData(kMouseLeftId, out leftData, true);
|
||||
|
||||
leftData.Reset();
|
||||
|
||||
if (created)
|
||||
leftData.position = input.mousePosition;
|
||||
|
||||
Vector2 pos = input.mousePosition;
|
||||
if (Cursor.lockState == CursorLockMode.Locked)
|
||||
{
|
||||
// We don't want to do ANY cursor-based interaction when the mouse is locked
|
||||
leftData.position = new Vector2(-1.0f, -1.0f);
|
||||
leftData.delta = Vector2.zero;
|
||||
}
|
||||
else
|
||||
{
|
||||
leftData.delta = pos - leftData.position;
|
||||
leftData.position = pos;
|
||||
}
|
||||
leftData.scrollDelta = input.mouseScrollDelta;
|
||||
leftData.button = PointerEventData.InputButton.Left;
|
||||
eventSystem.RaycastAll(leftData, m_RaycastResultCache);
|
||||
var raycast = FindFirstRaycast(m_RaycastResultCache);
|
||||
leftData.pointerCurrentRaycast = raycast;
|
||||
m_RaycastResultCache.Clear();
|
||||
|
||||
// copy the apropriate data into right and middle slots
|
||||
PointerEventData rightData;
|
||||
GetPointerData(kMouseRightId, out rightData, true);
|
||||
rightData.Reset();
|
||||
|
||||
CopyFromTo(leftData, rightData);
|
||||
rightData.button = PointerEventData.InputButton.Right;
|
||||
|
||||
PointerEventData middleData;
|
||||
GetPointerData(kMouseMiddleId, out middleData, true);
|
||||
middleData.Reset();
|
||||
|
||||
CopyFromTo(leftData, middleData);
|
||||
middleData.button = PointerEventData.InputButton.Middle;
|
||||
|
||||
m_MouseState.SetButtonState(PointerEventData.InputButton.Left, StateForMouseButton(0), leftData);
|
||||
m_MouseState.SetButtonState(PointerEventData.InputButton.Right, StateForMouseButton(1), rightData);
|
||||
m_MouseState.SetButtonState(PointerEventData.InputButton.Middle, StateForMouseButton(2), middleData);
|
||||
|
||||
return m_MouseState;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Return the last PointerEventData for the given touch / mouse id.
|
||||
/// </summary>
|
||||
protected PointerEventData GetLastPointerEventData(int id)
|
||||
{
|
||||
PointerEventData data;
|
||||
GetPointerData(id, out data, false);
|
||||
return data;
|
||||
}
|
||||
|
||||
private static bool ShouldStartDrag(Vector2 pressPos, Vector2 currentPos, float threshold, bool useDragThreshold)
|
||||
{
|
||||
if (!useDragThreshold)
|
||||
return true;
|
||||
|
||||
return (pressPos - currentPos).sqrMagnitude >= threshold * threshold;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Process movement for the current frame with the given pointer event.
|
||||
/// </summary>
|
||||
protected virtual void ProcessMove(PointerEventData pointerEvent)
|
||||
{
|
||||
var targetGO = (Cursor.lockState == CursorLockMode.Locked ? null : pointerEvent.pointerCurrentRaycast.gameObject);
|
||||
HandlePointerExitAndEnter(pointerEvent, targetGO);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Process the drag for the current frame with the given pointer event.
|
||||
/// </summary>
|
||||
protected virtual void ProcessDrag(PointerEventData pointerEvent)
|
||||
{
|
||||
if (!pointerEvent.IsPointerMoving() ||
|
||||
Cursor.lockState == CursorLockMode.Locked ||
|
||||
pointerEvent.pointerDrag == null)
|
||||
return;
|
||||
|
||||
if (!pointerEvent.dragging
|
||||
&& ShouldStartDrag(pointerEvent.pressPosition, pointerEvent.position, eventSystem.pixelDragThreshold, pointerEvent.useDragThreshold))
|
||||
{
|
||||
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.beginDragHandler);
|
||||
pointerEvent.dragging = true;
|
||||
}
|
||||
|
||||
// Drag notification
|
||||
if (pointerEvent.dragging)
|
||||
{
|
||||
// Before doing drag we should cancel any pointer down state
|
||||
// And clear selection!
|
||||
if (pointerEvent.pointerPress != pointerEvent.pointerDrag)
|
||||
{
|
||||
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
|
||||
|
||||
pointerEvent.eligibleForClick = false;
|
||||
pointerEvent.pointerPress = null;
|
||||
pointerEvent.rawPointerPress = null;
|
||||
}
|
||||
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.dragHandler);
|
||||
}
|
||||
}
|
||||
|
||||
public override bool IsPointerOverGameObject(int pointerId)
|
||||
{
|
||||
var lastPointer = GetLastPointerEventData(pointerId);
|
||||
if (lastPointer != null)
|
||||
return lastPointer.pointerEnter != null;
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Clear all pointers and deselect any selected objects in the EventSystem.
|
||||
/// </summary>
|
||||
protected void ClearSelection()
|
||||
{
|
||||
var baseEventData = GetBaseEventData();
|
||||
|
||||
foreach (var pointer in m_PointerData.Values)
|
||||
{
|
||||
// clear all selection
|
||||
HandlePointerExitAndEnter(pointer, null);
|
||||
}
|
||||
|
||||
m_PointerData.Clear();
|
||||
eventSystem.SetSelectedGameObject(null, baseEventData);
|
||||
}
|
||||
|
||||
public override string ToString()
|
||||
{
|
||||
var sb = new StringBuilder("<b>Pointer Input Module of type: </b>" + GetType());
|
||||
sb.AppendLine();
|
||||
foreach (var pointer in m_PointerData)
|
||||
{
|
||||
if (pointer.Value == null)
|
||||
continue;
|
||||
sb.AppendLine("<B>Pointer:</b> " + pointer.Key);
|
||||
sb.AppendLine(pointer.Value.ToString());
|
||||
}
|
||||
return sb.ToString();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Deselect the current selected GameObject if the currently pointed-at GameObject is different.
|
||||
/// </summary>
|
||||
/// <param name="currentOverGo">The GameObject the pointer is currently over.</param>
|
||||
/// <param name="pointerEvent">Current event data.</param>
|
||||
protected void DeselectIfSelectionChanged(GameObject currentOverGo, BaseEventData pointerEvent)
|
||||
{
|
||||
// Selection tracking
|
||||
var selectHandlerGO = ExecuteEvents.GetEventHandler<ISelectHandler>(currentOverGo);
|
||||
// if we have clicked something new, deselect the old thing
|
||||
// leave 'selection handling' up to the press event though.
|
||||
if (selectHandlerGO != eventSystem.currentSelectedGameObject)
|
||||
eventSystem.SetSelectedGameObject(null, pointerEvent);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
fileFormatVersion: 2
|
||||
guid: cbab8835092323a4389f2dc7d8f6c781
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
|
|
@ -0,0 +1,649 @@
|
|||
using System;
|
||||
using UnityEngine;
|
||||
using UnityEngine.Serialization;
|
||||
|
||||
namespace UnityEngine.EventSystems
|
||||
{
|
||||
[AddComponentMenu("Event/Standalone Input Module")]
|
||||
/// <summary>
|
||||
/// A BaseInputModule designed for mouse / keyboard / controller input.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Input module for working with, mouse, keyboard, or controller.
|
||||
/// </remarks>
|
||||
public class StandaloneInputModule : PointerInputModule
|
||||
{
|
||||
private float m_PrevActionTime;
|
||||
private Vector2 m_LastMoveVector;
|
||||
private int m_ConsecutiveMoveCount = 0;
|
||||
|
||||
private Vector2 m_LastMousePosition;
|
||||
private Vector2 m_MousePosition;
|
||||
|
||||
private GameObject m_CurrentFocusedGameObject;
|
||||
|
||||
private PointerEventData m_InputPointerEvent;
|
||||
|
||||
protected StandaloneInputModule()
|
||||
{
|
||||
}
|
||||
|
||||
[Obsolete("Mode is no longer needed on input module as it handles both mouse and keyboard simultaneously.", false)]
|
||||
public enum InputMode
|
||||
{
|
||||
Mouse,
|
||||
Buttons
|
||||
}
|
||||
|
||||
[Obsolete("Mode is no longer needed on input module as it handles both mouse and keyboard simultaneously.", false)]
|
||||
public InputMode inputMode
|
||||
{
|
||||
get { return InputMode.Mouse; }
|
||||
}
|
||||
|
||||
[SerializeField]
|
||||
private string m_HorizontalAxis = "Horizontal";
|
||||
|
||||
/// <summary>
|
||||
/// Name of the vertical axis for movement (if axis events are used).
|
||||
/// </summary>
|
||||
[SerializeField]
|
||||
private string m_VerticalAxis = "Vertical";
|
||||
|
||||
/// <summary>
|
||||
/// Name of the submit button.
|
||||
/// </summary>
|
||||
[SerializeField]
|
||||
private string m_SubmitButton = "Submit";
|
||||
|
||||
/// <summary>
|
||||
/// Name of the submit button.
|
||||
/// </summary>
|
||||
[SerializeField]
|
||||
private string m_CancelButton = "Cancel";
|
||||
|
||||
[SerializeField]
|
||||
private float m_InputActionsPerSecond = 10;
|
||||
|
||||
[SerializeField]
|
||||
private float m_RepeatDelay = 0.5f;
|
||||
|
||||
[SerializeField]
|
||||
[FormerlySerializedAs("m_AllowActivationOnMobileDevice")]
|
||||
[HideInInspector]
|
||||
private bool m_ForceModuleActive;
|
||||
|
||||
[Obsolete("allowActivationOnMobileDevice has been deprecated. Use forceModuleActive instead (UnityUpgradable) -> forceModuleActive")]
|
||||
public bool allowActivationOnMobileDevice
|
||||
{
|
||||
get { return m_ForceModuleActive; }
|
||||
set { m_ForceModuleActive = value; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Force this module to be active.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// If there is no module active with higher priority (ordered in the inspector) this module will be forced active even if valid enabling conditions are not met.
|
||||
/// </remarks>
|
||||
|
||||
[Obsolete("forceModuleActive has been deprecated. There is no need to force the module awake as StandaloneInputModule works for all platforms")]
|
||||
public bool forceModuleActive
|
||||
{
|
||||
get { return m_ForceModuleActive; }
|
||||
set { m_ForceModuleActive = value; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Number of keyboard / controller inputs allowed per second.
|
||||
/// </summary>
|
||||
public float inputActionsPerSecond
|
||||
{
|
||||
get { return m_InputActionsPerSecond; }
|
||||
set { m_InputActionsPerSecond = value; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Delay in seconds before the input actions per second repeat rate takes effect.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// If the same direction is sustained, the inputActionsPerSecond property can be used to control the rate at which events are fired. However, it can be desirable that the first repetition is delayed, so the user doesn't get repeated actions by accident.
|
||||
/// </remarks>
|
||||
public float repeatDelay
|
||||
{
|
||||
get { return m_RepeatDelay; }
|
||||
set { m_RepeatDelay = value; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Name of the horizontal axis for movement (if axis events are used).
|
||||
/// </summary>
|
||||
public string horizontalAxis
|
||||
{
|
||||
get { return m_HorizontalAxis; }
|
||||
set { m_HorizontalAxis = value; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Name of the vertical axis for movement (if axis events are used).
|
||||
/// </summary>
|
||||
public string verticalAxis
|
||||
{
|
||||
get { return m_VerticalAxis; }
|
||||
set { m_VerticalAxis = value; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Maximum number of input events handled per second.
|
||||
/// </summary>
|
||||
public string submitButton
|
||||
{
|
||||
get { return m_SubmitButton; }
|
||||
set { m_SubmitButton = value; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Input manager name for the 'cancel' button.
|
||||
/// </summary>
|
||||
public string cancelButton
|
||||
{
|
||||
get { return m_CancelButton; }
|
||||
set { m_CancelButton = value; }
|
||||
}
|
||||
|
||||
private bool ShouldIgnoreEventsOnNoFocus()
|
||||
{
|
||||
#if UNITY_EDITOR
|
||||
return !UnityEditor.EditorApplication.isRemoteConnected;
|
||||
#else
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
|
||||
public override void UpdateModule()
|
||||
{
|
||||
if (!eventSystem.isFocused && ShouldIgnoreEventsOnNoFocus())
|
||||
{
|
||||
if (m_InputPointerEvent != null && m_InputPointerEvent.pointerDrag != null && m_InputPointerEvent.dragging)
|
||||
{
|
||||
ReleaseMouse(m_InputPointerEvent, m_InputPointerEvent.pointerCurrentRaycast.gameObject);
|
||||
}
|
||||
|
||||
m_InputPointerEvent = null;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
m_LastMousePosition = m_MousePosition;
|
||||
m_MousePosition = input.mousePosition;
|
||||
}
|
||||
|
||||
private void ReleaseMouse(PointerEventData pointerEvent, GameObject currentOverGo)
|
||||
{
|
||||
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
|
||||
|
||||
var pointerClickHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
|
||||
|
||||
// PointerClick and Drop events
|
||||
if (pointerEvent.pointerClick == pointerClickHandler && pointerEvent.eligibleForClick)
|
||||
{
|
||||
ExecuteEvents.Execute(pointerEvent.pointerClick, pointerEvent, ExecuteEvents.pointerClickHandler);
|
||||
}
|
||||
if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
|
||||
{
|
||||
ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.dropHandler);
|
||||
}
|
||||
|
||||
pointerEvent.eligibleForClick = false;
|
||||
pointerEvent.pointerPress = null;
|
||||
pointerEvent.rawPointerPress = null;
|
||||
pointerEvent.pointerClick = null;
|
||||
|
||||
if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
|
||||
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
|
||||
|
||||
pointerEvent.dragging = false;
|
||||
pointerEvent.pointerDrag = null;
|
||||
|
||||
// redo pointer enter / exit to refresh state
|
||||
// so that if we moused over something that ignored it before
|
||||
// due to having pressed on something else
|
||||
// it now gets it.
|
||||
if (currentOverGo != pointerEvent.pointerEnter)
|
||||
{
|
||||
HandlePointerExitAndEnter(pointerEvent, null);
|
||||
HandlePointerExitAndEnter(pointerEvent, currentOverGo);
|
||||
}
|
||||
|
||||
m_InputPointerEvent = pointerEvent;
|
||||
}
|
||||
|
||||
public override bool ShouldActivateModule()
|
||||
{
|
||||
if (!base.ShouldActivateModule())
|
||||
return false;
|
||||
|
||||
var shouldActivate = m_ForceModuleActive;
|
||||
shouldActivate |= input.GetButtonDown(m_SubmitButton);
|
||||
shouldActivate |= input.GetButtonDown(m_CancelButton);
|
||||
shouldActivate |= !Mathf.Approximately(input.GetAxisRaw(m_HorizontalAxis), 0.0f);
|
||||
shouldActivate |= !Mathf.Approximately(input.GetAxisRaw(m_VerticalAxis), 0.0f);
|
||||
shouldActivate |= (m_MousePosition - m_LastMousePosition).sqrMagnitude > 0.0f;
|
||||
shouldActivate |= input.GetMouseButtonDown(0);
|
||||
|
||||
if (input.touchCount > 0)
|
||||
shouldActivate = true;
|
||||
|
||||
return shouldActivate;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// See BaseInputModule.
|
||||
/// </summary>
|
||||
public override void ActivateModule()
|
||||
{
|
||||
if (!eventSystem.isFocused && ShouldIgnoreEventsOnNoFocus())
|
||||
return;
|
||||
|
||||
base.ActivateModule();
|
||||
m_MousePosition = input.mousePosition;
|
||||
m_LastMousePosition = input.mousePosition;
|
||||
|
||||
var toSelect = eventSystem.currentSelectedGameObject;
|
||||
if (toSelect == null)
|
||||
toSelect = eventSystem.firstSelectedGameObject;
|
||||
|
||||
eventSystem.SetSelectedGameObject(toSelect, GetBaseEventData());
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// See BaseInputModule.
|
||||
/// </summary>
|
||||
public override void DeactivateModule()
|
||||
{
|
||||
base.DeactivateModule();
|
||||
ClearSelection();
|
||||
}
|
||||
|
||||
public override void Process()
|
||||
{
|
||||
if (!eventSystem.isFocused && ShouldIgnoreEventsOnNoFocus())
|
||||
return;
|
||||
|
||||
bool usedEvent = SendUpdateEventToSelectedObject();
|
||||
|
||||
// case 1004066 - touch / mouse events should be processed before navigation events in case
|
||||
// they change the current selected gameobject and the submit button is a touch / mouse button.
|
||||
|
||||
// touch needs to take precedence because of the mouse emulation layer
|
||||
if (!ProcessTouchEvents() && input.mousePresent)
|
||||
ProcessMouseEvent();
|
||||
|
||||
if (eventSystem.sendNavigationEvents)
|
||||
{
|
||||
if (!usedEvent)
|
||||
usedEvent |= SendMoveEventToSelectedObject();
|
||||
|
||||
if (!usedEvent)
|
||||
SendSubmitEventToSelectedObject();
|
||||
}
|
||||
}
|
||||
|
||||
private bool ProcessTouchEvents()
|
||||
{
|
||||
for (int i = 0; i < input.touchCount; ++i)
|
||||
{
|
||||
Touch touch = input.GetTouch(i);
|
||||
|
||||
if (touch.type == TouchType.Indirect)
|
||||
continue;
|
||||
|
||||
bool released;
|
||||
bool pressed;
|
||||
var pointer = GetTouchPointerEventData(touch, out pressed, out released);
|
||||
|
||||
ProcessTouchPress(pointer, pressed, released);
|
||||
|
||||
if (!released)
|
||||
{
|
||||
ProcessMove(pointer);
|
||||
ProcessDrag(pointer);
|
||||
}
|
||||
else
|
||||
RemovePointerData(pointer);
|
||||
}
|
||||
return input.touchCount > 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// This method is called by Unity whenever a touch event is processed. Override this method with a custom implementation to process touch events yourself.
|
||||
/// </summary>
|
||||
/// <param name="pointerEvent">Event data relating to the touch event, such as position and ID to be passed to the touch event destination object.</param>
|
||||
/// <param name="pressed">This is true for the first frame of a touch event, and false thereafter. This can therefore be used to determine the instant a touch event occurred.</param>
|
||||
/// <param name="released">This is true only for the last frame of a touch event.</param>
|
||||
/// <remarks>
|
||||
/// This method can be overridden in derived classes to change how touch press events are handled.
|
||||
/// </remarks>
|
||||
protected void ProcessTouchPress(PointerEventData pointerEvent, bool pressed, bool released)
|
||||
{
|
||||
var currentOverGo = pointerEvent.pointerCurrentRaycast.gameObject;
|
||||
|
||||
// PointerDown notification
|
||||
if (pressed)
|
||||
{
|
||||
pointerEvent.eligibleForClick = true;
|
||||
pointerEvent.delta = Vector2.zero;
|
||||
pointerEvent.dragging = false;
|
||||
pointerEvent.useDragThreshold = true;
|
||||
pointerEvent.pressPosition = pointerEvent.position;
|
||||
pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast;
|
||||
|
||||
DeselectIfSelectionChanged(currentOverGo, pointerEvent);
|
||||
|
||||
if (pointerEvent.pointerEnter != currentOverGo)
|
||||
{
|
||||
// send a pointer enter to the touched element if it isn't the one to select...
|
||||
HandlePointerExitAndEnter(pointerEvent, currentOverGo);
|
||||
pointerEvent.pointerEnter = currentOverGo;
|
||||
}
|
||||
|
||||
// search for the control that will receive the press
|
||||
// if we can't find a press handler set the press
|
||||
// handler to be what would receive a click.
|
||||
var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.pointerDownHandler);
|
||||
|
||||
var newClick = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
|
||||
|
||||
// didnt find a press handler... search for a click handler
|
||||
if (newPressed == null)
|
||||
newPressed = newClick;
|
||||
|
||||
// Debug.Log("Pressed: " + newPressed);
|
||||
|
||||
float time = Time.unscaledTime;
|
||||
|
||||
if (newPressed == pointerEvent.lastPress)
|
||||
{
|
||||
var diffTime = time - pointerEvent.clickTime;
|
||||
if (diffTime < 0.3f)
|
||||
++pointerEvent.clickCount;
|
||||
else
|
||||
pointerEvent.clickCount = 1;
|
||||
|
||||
pointerEvent.clickTime = time;
|
||||
}
|
||||
else
|
||||
{
|
||||
pointerEvent.clickCount = 1;
|
||||
}
|
||||
|
||||
pointerEvent.pointerPress = newPressed;
|
||||
pointerEvent.rawPointerPress = currentOverGo;
|
||||
pointerEvent.pointerClick = newClick;
|
||||
|
||||
pointerEvent.clickTime = time;
|
||||
|
||||
// Save the drag handler as well
|
||||
pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(currentOverGo);
|
||||
|
||||
if (pointerEvent.pointerDrag != null)
|
||||
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag);
|
||||
}
|
||||
|
||||
// PointerUp notification
|
||||
if (released)
|
||||
{
|
||||
// Debug.Log("Executing pressup on: " + pointer.pointerPress);
|
||||
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
|
||||
|
||||
// Debug.Log("KeyCode: " + pointer.eventData.keyCode);
|
||||
|
||||
// see if we mouse up on the same element that we clicked on...
|
||||
var pointerClickHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
|
||||
|
||||
// PointerClick and Drop events
|
||||
if (pointerEvent.pointerClick == pointerClickHandler && pointerEvent.eligibleForClick)
|
||||
{
|
||||
ExecuteEvents.Execute(pointerEvent.pointerClick, pointerEvent, ExecuteEvents.pointerClickHandler);
|
||||
}
|
||||
|
||||
if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
|
||||
{
|
||||
ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.dropHandler);
|
||||
}
|
||||
|
||||
pointerEvent.eligibleForClick = false;
|
||||
pointerEvent.pointerPress = null;
|
||||
pointerEvent.rawPointerPress = null;
|
||||
pointerEvent.pointerClick = null;
|
||||
|
||||
if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
|
||||
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
|
||||
|
||||
pointerEvent.dragging = false;
|
||||
pointerEvent.pointerDrag = null;
|
||||
|
||||
// send exit events as we need to simulate this on touch up on touch device
|
||||
ExecuteEvents.ExecuteHierarchy(pointerEvent.pointerEnter, pointerEvent, ExecuteEvents.pointerExitHandler);
|
||||
pointerEvent.pointerEnter = null;
|
||||
}
|
||||
|
||||
m_InputPointerEvent = pointerEvent;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Calculate and send a submit event to the current selected object.
|
||||
/// </summary>
|
||||
/// <returns>If the submit event was used by the selected object.</returns>
|
||||
protected bool SendSubmitEventToSelectedObject()
|
||||
{
|
||||
if (eventSystem.currentSelectedGameObject == null)
|
||||
return false;
|
||||
|
||||
var data = GetBaseEventData();
|
||||
if (input.GetButtonDown(m_SubmitButton))
|
||||
ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.submitHandler);
|
||||
|
||||
if (input.GetButtonDown(m_CancelButton))
|
||||
ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.cancelHandler);
|
||||
return data.used;
|
||||
}
|
||||
|
||||
private Vector2 GetRawMoveVector()
|
||||
{
|
||||
Vector2 move = Vector2.zero;
|
||||
move.x = input.GetAxisRaw(m_HorizontalAxis);
|
||||
move.y = input.GetAxisRaw(m_VerticalAxis);
|
||||
|
||||
if (input.GetButtonDown(m_HorizontalAxis))
|
||||
{
|
||||
if (move.x < 0)
|
||||
move.x = -1f;
|
||||
if (move.x > 0)
|
||||
move.x = 1f;
|
||||
}
|
||||
if (input.GetButtonDown(m_VerticalAxis))
|
||||
{
|
||||
if (move.y < 0)
|
||||
move.y = -1f;
|
||||
if (move.y > 0)
|
||||
move.y = 1f;
|
||||
}
|
||||
return move;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Calculate and send a move event to the current selected object.
|
||||
/// </summary>
|
||||
/// <returns>If the move event was used by the selected object.</returns>
|
||||
protected bool SendMoveEventToSelectedObject()
|
||||
{
|
||||
float time = Time.unscaledTime;
|
||||
|
||||
Vector2 movement = GetRawMoveVector();
|
||||
if (Mathf.Approximately(movement.x, 0f) && Mathf.Approximately(movement.y, 0f))
|
||||
{
|
||||
m_ConsecutiveMoveCount = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool similarDir = (Vector2.Dot(movement, m_LastMoveVector) > 0);
|
||||
|
||||
// If direction didn't change at least 90 degrees, wait for delay before allowing consequtive event.
|
||||
if (similarDir && m_ConsecutiveMoveCount == 1)
|
||||
{
|
||||
if (time <= m_PrevActionTime + m_RepeatDelay)
|
||||
return false;
|
||||
}
|
||||
// If direction changed at least 90 degree, or we already had the delay, repeat at repeat rate.
|
||||
else
|
||||
{
|
||||
if (time <= m_PrevActionTime + 1f / m_InputActionsPerSecond)
|
||||
return false;
|
||||
}
|
||||
|
||||
var axisEventData = GetAxisEventData(movement.x, movement.y, 0.6f);
|
||||
|
||||
if (axisEventData.moveDir != MoveDirection.None)
|
||||
{
|
||||
ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, axisEventData, ExecuteEvents.moveHandler);
|
||||
if (!similarDir)
|
||||
m_ConsecutiveMoveCount = 0;
|
||||
m_ConsecutiveMoveCount++;
|
||||
m_PrevActionTime = time;
|
||||
m_LastMoveVector = movement;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_ConsecutiveMoveCount = 0;
|
||||
}
|
||||
|
||||
return axisEventData.used;
|
||||
}
|
||||
|
||||
protected void ProcessMouseEvent()
|
||||
{
|
||||
ProcessMouseEvent(0);
|
||||
}
|
||||
|
||||
[Obsolete("This method is no longer checked, overriding it with return true does nothing!")]
|
||||
protected virtual bool ForceAutoSelect()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Process all mouse events.
|
||||
/// </summary>
|
||||
protected void ProcessMouseEvent(int id)
|
||||
{
|
||||
var mouseData = GetMousePointerEventData(id);
|
||||
var leftButtonData = mouseData.GetButtonState(PointerEventData.InputButton.Left).eventData;
|
||||
|
||||
m_CurrentFocusedGameObject = leftButtonData.buttonData.pointerCurrentRaycast.gameObject;
|
||||
|
||||
// Process the first mouse button fully
|
||||
ProcessMousePress(leftButtonData);
|
||||
ProcessMove(leftButtonData.buttonData);
|
||||
ProcessDrag(leftButtonData.buttonData);
|
||||
|
||||
// Now process right / middle clicks
|
||||
ProcessMousePress(mouseData.GetButtonState(PointerEventData.InputButton.Right).eventData);
|
||||
ProcessDrag(mouseData.GetButtonState(PointerEventData.InputButton.Right).eventData.buttonData);
|
||||
ProcessMousePress(mouseData.GetButtonState(PointerEventData.InputButton.Middle).eventData);
|
||||
ProcessDrag(mouseData.GetButtonState(PointerEventData.InputButton.Middle).eventData.buttonData);
|
||||
|
||||
if (!Mathf.Approximately(leftButtonData.buttonData.scrollDelta.sqrMagnitude, 0.0f))
|
||||
{
|
||||
var scrollHandler = ExecuteEvents.GetEventHandler<IScrollHandler>(leftButtonData.buttonData.pointerCurrentRaycast.gameObject);
|
||||
ExecuteEvents.ExecuteHierarchy(scrollHandler, leftButtonData.buttonData, ExecuteEvents.scrollHandler);
|
||||
}
|
||||
}
|
||||
|
||||
protected bool SendUpdateEventToSelectedObject()
|
||||
{
|
||||
if (eventSystem.currentSelectedGameObject == null)
|
||||
return false;
|
||||
|
||||
var data = GetBaseEventData();
|
||||
ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.updateSelectedHandler);
|
||||
return data.used;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Calculate and process any mouse button state changes.
|
||||
/// </summary>
|
||||
protected void ProcessMousePress(MouseButtonEventData data)
|
||||
{
|
||||
var pointerEvent = data.buttonData;
|
||||
var currentOverGo = pointerEvent.pointerCurrentRaycast.gameObject;
|
||||
|
||||
// PointerDown notification
|
||||
if (data.PressedThisFrame())
|
||||
{
|
||||
pointerEvent.eligibleForClick = true;
|
||||
pointerEvent.delta = Vector2.zero;
|
||||
pointerEvent.dragging = false;
|
||||
pointerEvent.useDragThreshold = true;
|
||||
pointerEvent.pressPosition = pointerEvent.position;
|
||||
pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast;
|
||||
|
||||
DeselectIfSelectionChanged(currentOverGo, pointerEvent);
|
||||
|
||||
// search for the control that will receive the press
|
||||
// if we can't find a press handler set the press
|
||||
// handler to be what would receive a click.
|
||||
var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.pointerDownHandler);
|
||||
var newClick = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
|
||||
|
||||
// didnt find a press handler... search for a click handler
|
||||
if (newPressed == null)
|
||||
newPressed = newClick;
|
||||
|
||||
// Debug.Log("Pressed: " + newPressed);
|
||||
|
||||
float time = Time.unscaledTime;
|
||||
|
||||
if (newPressed == pointerEvent.lastPress)
|
||||
{
|
||||
var diffTime = time - pointerEvent.clickTime;
|
||||
if (diffTime < 0.3f)
|
||||
++pointerEvent.clickCount;
|
||||
else
|
||||
pointerEvent.clickCount = 1;
|
||||
|
||||
pointerEvent.clickTime = time;
|
||||
}
|
||||
else
|
||||
{
|
||||
pointerEvent.clickCount = 1;
|
||||
}
|
||||
|
||||
pointerEvent.pointerPress = newPressed;
|
||||
pointerEvent.rawPointerPress = currentOverGo;
|
||||
pointerEvent.pointerClick = newClick;
|
||||
|
||||
pointerEvent.clickTime = time;
|
||||
|
||||
// Save the drag handler as well
|
||||
pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(currentOverGo);
|
||||
|
||||
if (pointerEvent.pointerDrag != null)
|
||||
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag);
|
||||
|
||||
m_InputPointerEvent = pointerEvent;
|
||||
}
|
||||
|
||||
// PointerUp notification
|
||||
if (data.ReleasedThisFrame())
|
||||
{
|
||||
ReleaseMouse(pointerEvent, currentOverGo);
|
||||
}
|
||||
}
|
||||
|
||||
protected GameObject GetCurrentFocusedGameObject()
|
||||
{
|
||||
return m_CurrentFocusedGameObject;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
fileFormatVersion: 2
|
||||
guid: 4f231c4fb786f3946a6b90b886c48677
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
|
|
@ -0,0 +1,266 @@
|
|||
using System;
|
||||
using System.Text;
|
||||
using UnityEngine.Serialization;
|
||||
|
||||
namespace UnityEngine.EventSystems
|
||||
{
|
||||
[Obsolete("TouchInputModule is no longer required as Touch input is now handled in StandaloneInputModule.")]
|
||||
[AddComponentMenu("Event/Touch Input Module")]
|
||||
public class TouchInputModule : PointerInputModule
|
||||
{
|
||||
protected TouchInputModule()
|
||||
{}
|
||||
|
||||
private Vector2 m_LastMousePosition;
|
||||
private Vector2 m_MousePosition;
|
||||
|
||||
private PointerEventData m_InputPointerEvent;
|
||||
|
||||
[SerializeField]
|
||||
[FormerlySerializedAs("m_AllowActivationOnStandalone")]
|
||||
private bool m_ForceModuleActive;
|
||||
|
||||
[Obsolete("allowActivationOnStandalone has been deprecated. Use forceModuleActive instead (UnityUpgradable) -> forceModuleActive")]
|
||||
public bool allowActivationOnStandalone
|
||||
{
|
||||
get { return m_ForceModuleActive; }
|
||||
set { m_ForceModuleActive = value; }
|
||||
}
|
||||
|
||||
public bool forceModuleActive
|
||||
{
|
||||
get { return m_ForceModuleActive; }
|
||||
set { m_ForceModuleActive = value; }
|
||||
}
|
||||
|
||||
public override void UpdateModule()
|
||||
{
|
||||
if (!eventSystem.isFocused)
|
||||
{
|
||||
if (m_InputPointerEvent != null && m_InputPointerEvent.pointerDrag != null && m_InputPointerEvent.dragging)
|
||||
ExecuteEvents.Execute(m_InputPointerEvent.pointerDrag, m_InputPointerEvent, ExecuteEvents.endDragHandler);
|
||||
|
||||
m_InputPointerEvent = null;
|
||||
}
|
||||
|
||||
m_LastMousePosition = m_MousePosition;
|
||||
m_MousePosition = input.mousePosition;
|
||||
}
|
||||
|
||||
public override bool IsModuleSupported()
|
||||
{
|
||||
return forceModuleActive || input.touchSupported;
|
||||
}
|
||||
|
||||
public override bool ShouldActivateModule()
|
||||
{
|
||||
if (!base.ShouldActivateModule())
|
||||
return false;
|
||||
|
||||
if (m_ForceModuleActive)
|
||||
return true;
|
||||
|
||||
if (UseFakeInput())
|
||||
{
|
||||
bool wantsEnable = input.GetMouseButtonDown(0);
|
||||
|
||||
wantsEnable |= (m_MousePosition - m_LastMousePosition).sqrMagnitude > 0.0f;
|
||||
return wantsEnable;
|
||||
}
|
||||
|
||||
return input.touchCount > 0;
|
||||
}
|
||||
|
||||
private bool UseFakeInput()
|
||||
{
|
||||
return !input.touchSupported;
|
||||
}
|
||||
|
||||
public override void Process()
|
||||
{
|
||||
if (UseFakeInput())
|
||||
FakeTouches();
|
||||
else
|
||||
ProcessTouchEvents();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// For debugging touch-based devices using the mouse.
|
||||
/// </summary>
|
||||
private void FakeTouches()
|
||||
{
|
||||
var pointerData = GetMousePointerEventData(0);
|
||||
|
||||
var leftPressData = pointerData.GetButtonState(PointerEventData.InputButton.Left).eventData;
|
||||
|
||||
// fake touches... on press clear delta
|
||||
if (leftPressData.PressedThisFrame())
|
||||
leftPressData.buttonData.delta = Vector2.zero;
|
||||
|
||||
ProcessTouchPress(leftPressData.buttonData, leftPressData.PressedThisFrame(), leftPressData.ReleasedThisFrame());
|
||||
|
||||
// only process move if we are pressed...
|
||||
if (input.GetMouseButton(0))
|
||||
{
|
||||
ProcessMove(leftPressData.buttonData);
|
||||
ProcessDrag(leftPressData.buttonData);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Process all touch events.
|
||||
/// </summary>
|
||||
private void ProcessTouchEvents()
|
||||
{
|
||||
for (int i = 0; i < input.touchCount; ++i)
|
||||
{
|
||||
Touch touch = input.GetTouch(i);
|
||||
|
||||
if (touch.type == TouchType.Indirect)
|
||||
continue;
|
||||
|
||||
bool released;
|
||||
bool pressed;
|
||||
var pointer = GetTouchPointerEventData(touch, out pressed, out released);
|
||||
|
||||
ProcessTouchPress(pointer, pressed, released);
|
||||
|
||||
if (!released)
|
||||
{
|
||||
ProcessMove(pointer);
|
||||
ProcessDrag(pointer);
|
||||
}
|
||||
else
|
||||
RemovePointerData(pointer);
|
||||
}
|
||||
}
|
||||
|
||||
protected void ProcessTouchPress(PointerEventData pointerEvent, bool pressed, bool released)
|
||||
{
|
||||
var currentOverGo = pointerEvent.pointerCurrentRaycast.gameObject;
|
||||
|
||||
// PointerDown notification
|
||||
if (pressed)
|
||||
{
|
||||
pointerEvent.eligibleForClick = true;
|
||||
pointerEvent.delta = Vector2.zero;
|
||||
pointerEvent.dragging = false;
|
||||
pointerEvent.useDragThreshold = true;
|
||||
pointerEvent.pressPosition = pointerEvent.position;
|
||||
pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast;
|
||||
|
||||
DeselectIfSelectionChanged(currentOverGo, pointerEvent);
|
||||
|
||||
if (pointerEvent.pointerEnter != currentOverGo)
|
||||
{
|
||||
// send a pointer enter to the touched element if it isn't the one to select...
|
||||
HandlePointerExitAndEnter(pointerEvent, currentOverGo);
|
||||
pointerEvent.pointerEnter = currentOverGo;
|
||||
}
|
||||
|
||||
// search for the control that will receive the press
|
||||
// if we can't find a press handler set the press
|
||||
// handler to be what would receive a click.
|
||||
var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.pointerDownHandler);
|
||||
|
||||
// didnt find a press handler... search for a click handler
|
||||
if (newPressed == null)
|
||||
newPressed = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
|
||||
|
||||
// Debug.Log("Pressed: " + newPressed);
|
||||
|
||||
float time = Time.unscaledTime;
|
||||
|
||||
if (newPressed == pointerEvent.lastPress)
|
||||
{
|
||||
var diffTime = time - pointerEvent.clickTime;
|
||||
if (diffTime < 0.3f)
|
||||
++pointerEvent.clickCount;
|
||||
else
|
||||
pointerEvent.clickCount = 1;
|
||||
|
||||
pointerEvent.clickTime = time;
|
||||
}
|
||||
else
|
||||
{
|
||||
pointerEvent.clickCount = 1;
|
||||
}
|
||||
|
||||
pointerEvent.pointerPress = newPressed;
|
||||
pointerEvent.rawPointerPress = currentOverGo;
|
||||
|
||||
pointerEvent.clickTime = time;
|
||||
|
||||
// Save the drag handler as well
|
||||
pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(currentOverGo);
|
||||
|
||||
if (pointerEvent.pointerDrag != null)
|
||||
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag);
|
||||
|
||||
m_InputPointerEvent = pointerEvent;
|
||||
}
|
||||
|
||||
// PointerUp notification
|
||||
if (released)
|
||||
{
|
||||
// Debug.Log("Executing pressup on: " + pointer.pointerPress);
|
||||
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
|
||||
|
||||
// Debug.Log("KeyCode: " + pointer.eventData.keyCode);
|
||||
|
||||
// see if we mouse up on the same element that we clicked on...
|
||||
var pointerUpHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
|
||||
|
||||
// PointerClick and Drop events
|
||||
if (pointerEvent.pointerPress == pointerUpHandler && pointerEvent.eligibleForClick)
|
||||
{
|
||||
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerClickHandler);
|
||||
}
|
||||
else if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
|
||||
{
|
||||
ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.dropHandler);
|
||||
}
|
||||
|
||||
pointerEvent.eligibleForClick = false;
|
||||
pointerEvent.pointerPress = null;
|
||||
pointerEvent.rawPointerPress = null;
|
||||
|
||||
if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
|
||||
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
|
||||
|
||||
pointerEvent.dragging = false;
|
||||
pointerEvent.pointerDrag = null;
|
||||
|
||||
// send exit events as we need to simulate this on touch up on touch device
|
||||
ExecuteEvents.ExecuteHierarchy(pointerEvent.pointerEnter, pointerEvent, ExecuteEvents.pointerExitHandler);
|
||||
pointerEvent.pointerEnter = null;
|
||||
|
||||
m_InputPointerEvent = pointerEvent;
|
||||
}
|
||||
}
|
||||
|
||||
public override void DeactivateModule()
|
||||
{
|
||||
base.DeactivateModule();
|
||||
ClearSelection();
|
||||
}
|
||||
|
||||
public override string ToString()
|
||||
{
|
||||
var sb = new StringBuilder();
|
||||
sb.AppendLine(UseFakeInput() ? "Input: Faked" : "Input: Touch");
|
||||
if (UseFakeInput())
|
||||
{
|
||||
var pointerData = GetLastPointerEventData(kMouseLeftId);
|
||||
if (pointerData != null)
|
||||
sb.AppendLine(pointerData.ToString());
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (var pointerEventData in m_PointerData)
|
||||
sb.AppendLine(pointerEventData.ToString());
|
||||
}
|
||||
return sb.ToString();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
fileFormatVersion: 2
|
||||
guid: 2d49b7c1bcd2e07499844da127be038d
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
Loading…
Add table
Add a link
Reference in a new issue