public void DoRelease()
{
GameObject handler = ExecuteEvents.GetEventHandler <IPointerUpHandler>(pointerEvent.pointerEnter);
if (handler != null)
{
ExecuteEvents.ExecuteHierarchy(handler, pointerEvent, ExecuteEvents.pointerUpHandler);
}
handler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(pointerEvent.pointerEnter);
if (handler != null)
{
ExecuteEvents.ExecuteHierarchy(handler, pointerEvent, ExecuteEvents.pointerClickHandler);
}
if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
{
//ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
pointerEvent.dragging = false;
pointerEvent.pointerDrag = null;
}
pointerEvent.pointerPress = null;
}
void ProcessMouseEvent()
{
var mousePointerEventData = this.GetMousePointerEventData();
var pressed = mousePointerEventData.AnyPressesThisFrame();
var released = mousePointerEventData.AnyReleasesThisFrame();
var eventData = mousePointerEventData.GetButtonState(PointerEventData.InputButton.Left).eventData;
if (!UseMouse(pressed, released, eventData.buttonData))
{
return;
}
ProcessMousePress(eventData);
ProcessMove(eventData.buttonData);
ProcessDrag(eventData.buttonData);
ProcessMousePress(mousePointerEventData.GetButtonState(PointerEventData.InputButton.Right).eventData);
ProcessDrag(mousePointerEventData.GetButtonState(PointerEventData.InputButton.Right).eventData.buttonData);
ProcessMousePress(mousePointerEventData.GetButtonState(PointerEventData.InputButton.Middle).eventData);
ProcessDrag(mousePointerEventData.GetButtonState(PointerEventData.InputButton.Middle).eventData.buttonData);
if (!Mathf.Approximately(eventData.buttonData.scrollDelta.sqrMagnitude, 0))
{
var eventHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(eventData.buttonData.pointerCurrentRaycast.gameObject);
ExecuteEvents.ExecuteHierarchy <IScrollHandler>(eventHandler, eventData.buttonData, ExecuteEvents.scrollHandler);
}
}
/// <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);
}
}
private void HandleTrigger()
{
bool triggered = Cardboard.SDK.Triggered ||
!Cardboard.SDK.TapIsTrigger && Input.GetMouseButtonDown(0);
if (!triggered)
{
return;
}
var go = pointerData.pointerCurrentRaycast.gameObject;
// Send pointer down event.
pointerData.pressPosition = pointerData.position;
pointerData.pointerPressRaycast = pointerData.pointerCurrentRaycast;
pointerData.pointerPress =
ExecuteEvents.ExecuteHierarchy(go, pointerData, ExecuteEvents.pointerDownHandler)
?? ExecuteEvents.GetEventHandler <IPointerClickHandler>(go);
// Save the pending click state.
pointerData.rawPointerPress = go;
pointerData.eligibleForClick = true;
pointerData.clickCount = 1;
pointerData.clickTime = Time.unscaledTime;
}
void HandleSelection()
{
if (pointerEventData.pointerEnter != null)
{
// if the ui receiver has changed, reset the gaze delay timer
GameObject handler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(pointerEventData.pointerEnter);
if (currentLookAtHandler != handler)
{
currentLookAtHandler = handler;
currentLookAtHandlerClickTime = Time.realtimeSinceStartup + GazeTimeInSeconds;
}
// if we have a handler and it's time to click, do it now
if (currentLookAtHandler != null &&
(mode == Mode.Gaze && Time.realtimeSinceStartup > currentLookAtHandlerClickTime) ||
(mode == Mode.Click && Input.GetButtonDown(ClickInputName)))
{
if (EventSystem.current.currentSelectedGameObject != null)
{
Debug.Log("old" + EventSystem.current.currentSelectedGameObject.name);
// ExecuteEvents.ExecuteHierarchy(EventSystem.current.currentSelectedGameObject, pointerEventData, ExecuteEvents.deselectHandler);
}
EventSystem.current.SetSelectedGameObject(currentLookAtHandler);
ExecuteEvents.ExecuteHierarchy(currentLookAtHandler, pointerEventData, ExecuteEvents.pointerClickHandler);
currentLookAtHandlerClickTime = float.MaxValue;
ExecuteEvents.ExecuteHierarchy(EventSystem.current.currentSelectedGameObject, pointerEventData, ExecuteEvents.deselectHandler);
}
}
else
{
currentLookAtHandler = null;
}
}
void ProcessDrag(PointerInput input)
{
var eventData = input.eventData;
// Begin dragging if pointer down on an object that has drag handler
if (input.buttonDown && input.hitObject != null && eventData.pointerDrag == null)
{
// Obtain the drag handler if available
eventData.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(input.hitObject);
}
// Begin drag?
if (eventData.pointerDrag != null && !eventData.dragging && ShouldBeginDrag(input))
{
eventData.dragging = true;
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.beginDragHandler);
}
// End drag on pointer up
if (input.buttonUp && eventData.pointerDrag != null)
{
if (eventData.dragging)
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.endDragHandler);
eventData.dragging = false;
}
eventData.pointerDrag = null;
}
// Send drag event
if (eventData.dragging)
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.dragHandler);
}
}
/// <summary>
/// Process all mouse events.
/// </summary>
private void ProcessMouseEvent()
{
// Breaking change to UnityEngine.EventSystems.PointerInputModule.GetMousePointerEventData() in Unity 5.1.2p1. This code cannot compile in these patch releases because no defines exist for patch releases
#if !UNITY_5 || (UNITY_5 && (UNITY_5_0 || UNITY_5_1_0 || UNITY_5_1_1 || UNITY_5_1_2))
var mouseData = GetMousePointerEventData();
#else
var mouseData = GetMousePointerEventData(kMouseLeftId);
#endif
var pressed = mouseData.AnyPressesThisFrame();
var released = mouseData.AnyReleasesThisFrame();
var leftButtonData = mouseData.GetButtonState(PointerEventData.InputButton.Left).eventData;
if (!UseMouse(pressed, released, leftButtonData.buttonData))
{
return;
}
// 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);
}
}
private void UpdateReticle(GameObject preGazedObject, PointerEventData pointerEvent)
{
if (gazePointer == null)
{
return;
}
GameObject curGazeObject = GetCurrentGameObject(pointerEvent);
Vector3 intersectionPosition = GetIntersectionPosition(pointerEvent);
bool isInteractive = pointerEvent.pointerPress != null || ExecuteEvents.GetEventHandler <IPointerClickHandler>(curGazeObject) != null;
if (curGazeObject == preGazedObject)
{
if (curGazeObject != null)
{
gazePointer.OnGazeStay(pointerEvent.enterEventCamera, curGazeObject, intersectionPosition, isInteractive);
}
else
{
gazePointer.OnGazeExit(pointerEvent.enterEventCamera, preGazedObject);
return;
}
}
else
{
if (preGazedObject != null)
{
gazePointer.OnGazeExit(pointerEvent.enterEventCamera, preGazedObject);
}
if (curGazeObject != null)
{
gazePointer.OnGazeEnter(pointerEvent.enterEventCamera, curGazeObject, intersectionPosition, isInteractive);
}
}
UpdateProgressDistance(pointerEvent);
}
//Process is called by UI system to process events
public override void Process()
{
curFrame = LeapDataProvider.CurrentFrame.TransformedCopy(LeapTransform.Identity);
//Send update events if there is a selected object
//This is important for InputField to receive keyboard events
SendUpdateEventToSelectedObject();
//Begin Processing Each Hand
for (int whichHand = 0; whichHand < NumberOfHands; whichHand++)
{
//Move on if this hand isn't visible in the frame
if (curFrame.Hands.Count - 1 < whichHand)
{
if (Pointers[whichHand].gameObject.activeInHierarchy == true)
{
Pointers[whichHand].gameObject.SetActive(false);
}
continue;
}
//Calculate Shoulder Positions (for Projection)
Vector3 ProjectionOrigin = Vector3.zero;
if (Camera.main != null)
{
switch (curFrame.Hands[whichHand].IsRight)
{
case true:
ProjectionOrigin = Camera.main.transform.position + CurrentRotation * new Vector3(0.15f, -0.2f, 0f);
break;
case false:
ProjectionOrigin = Camera.main.transform.position + CurrentRotation * new Vector3(-0.15f, -0.2f, 0f);
break;
}
}
//Draw Shoulders as Spheres, and the Raycast as a Line
if (DrawDebug)
{
DebugSphereQueue.Enqueue(ProjectionOrigin);
Debug.DrawRay(ProjectionOrigin, CurrentRotation * Vector3.forward * 5f);
}
//Raycast from shoulder through tip of the index finger to the UI
bool TipRaycast = false;
if (InteractionMode != InteractionCapability.Projective)
{
TipRaycast = GetLookPointerEventData(whichHand, ProjectionOrigin, CurrentRotation * Vector3.forward, true);
PrevState[whichHand] = pointerState[whichHand]; //Store old state for sound transitionary purposes
UpdatePointer(whichHand, PointEvents[whichHand]);
ProcessState(whichHand, TipRaycast);
}
//If didn't hit anything near the fingertip, try doing it again, but through the knuckle this time
if (((pointerState[whichHand] == pointerStates.OffCanvas) && (InteractionMode != InteractionCapability.Tactile)) || (InteractionMode == InteractionCapability.Projective))
{
TipRaycast = GetLookPointerEventData(whichHand, ProjectionOrigin, CurrentRotation * Vector3.forward, false);
if ((InteractionMode == InteractionCapability.Projective))
{
PrevState[whichHand] = pointerState[whichHand]; //Store old state for sound transitionary purposes
}
UpdatePointer(whichHand, PointEvents[whichHand]);
ProcessState(whichHand, TipRaycast);
}
PrevScreenPosition[whichHand] = PointEvents[whichHand].position;
if (DrawDebug)
{
PointerLines[whichHand].SetPosition(0, EventCamera.transform.position);
PointerLines[whichHand].SetPosition(1, Pointers[whichHand].position);
}
//Trigger events that come from changing pointer state
ProcessStateEvents(whichHand);
if ((PointEvents[whichHand] != null))
{
//Tell Leap Buttons how far away the finger is
if ((PointEvents[whichHand].pointerCurrentRaycast.gameObject != null))
{
ILeapWidget comp = PointEvents[whichHand].pointerCurrentRaycast.gameObject.GetComponent <ILeapWidget>();
if (comp != null)
{
if (!isTriggeringInteraction(whichHand))
{
((ILeapWidget)comp).HoverDistance(distanceOfIndexTipToPointer(whichHand));
}
}
}
//If we hit something with our Raycast, let's see if we should interact with it
if (PointEvents[whichHand].pointerCurrentRaycast.gameObject != null && pointerState[whichHand] != pointerStates.OffCanvas)
{
prevOverGo[whichHand] = currentOverGo[whichHand];
currentOverGo[whichHand] = PointEvents[whichHand].pointerCurrentRaycast.gameObject;
//Trigger Enter or Exit Events on the UI Element (like highlighting)
base.HandlePointerExitAndEnter(PointEvents[whichHand], currentOverGo[whichHand]);
//If we weren't triggering an interaction last frame, but we are now...
if (!PrevTriggeringInteraction[whichHand] && isTriggeringInteraction(whichHand))
{
PrevTriggeringInteraction[whichHand] = true;
if ((Time.time - timeEnteredCanvas[whichHand] > ActivationTime))
{
//Deselect all objects
if (base.eventSystem.currentSelectedGameObject)
{
base.eventSystem.SetSelectedGameObject(null);
}
//Record pointer telemetry
PointEvents[whichHand].pressPosition = PointEvents[whichHand].position;
PointEvents[whichHand].pointerPressRaycast = PointEvents[whichHand].pointerCurrentRaycast;
PointEvents[whichHand].pointerPress = null; //Clear this for setting later
//If we hit something good, let's trigger it!
if (currentOverGo[whichHand] != null)
{
currentGo[whichHand] = currentOverGo[whichHand];
//See if this object, or one of its parents, has a pointerDownHandler
GameObject newPressed = ExecuteEvents.ExecuteHierarchy(currentGo[whichHand], PointEvents[whichHand], ExecuteEvents.pointerDownHandler);
//If not, see if one has a pointerClickHandler!
if (newPressed == null)
{
newPressed = ExecuteEvents.ExecuteHierarchy(currentGo[whichHand], PointEvents[whichHand], ExecuteEvents.pointerClickHandler);
if (newPressed != null)
{
currentGo[whichHand] = newPressed;
}
}
else
{
currentGo[whichHand] = newPressed;
//We want to do "click on button down" at same time, unlike regular mouse processing
//Which does click when mouse goes up over same object it went down on
//This improves the user's ability to select small menu items
ExecuteEvents.Execute(newPressed, PointEvents[whichHand], ExecuteEvents.pointerClickHandler);
}
if (newPressed != null)
{
PointEvents[whichHand].pointerPress = newPressed;
currentGo[whichHand] = newPressed;
//Select the currently pressed object
if (ExecuteEvents.GetEventHandler <ISelectHandler>(currentGo[whichHand]))
{
base.eventSystem.SetSelectedGameObject(currentGo[whichHand]);
}
}
ExecuteEvents.ExecuteHierarchy(currentGo[whichHand], PointEvents[whichHand], ExecuteEvents.beginDragHandler);
PointEvents[whichHand].pointerDrag = currentGo[whichHand];
PointEvents[whichHand].dragging = true;
currentGoing[whichHand] = currentGo[whichHand];
}
}
}
//If we WERE interacting last frame, but are not this frame...
if (PrevTriggeringInteraction[whichHand] && !isTriggeringInteraction(whichHand))
{
PrevTriggeringInteraction[whichHand] = false;
if (currentGoing[whichHand])
{
ExecuteEvents.Execute(currentGoing[whichHand], PointEvents[whichHand], ExecuteEvents.endDragHandler);
if (currentOverGo[whichHand] != null)
{
ExecuteEvents.ExecuteHierarchy(currentOverGo[whichHand], PointEvents[whichHand], ExecuteEvents.dropHandler);
}
PointEvents[whichHand].pointerDrag = null;
PointEvents[whichHand].dragging = false;
currentGoing[whichHand] = null;
}
if (currentGo[whichHand])
{
ExecuteEvents.Execute(currentGo[whichHand], PointEvents[whichHand], ExecuteEvents.pointerUpHandler);
PointEvents[whichHand].rawPointerPress = null;
PointEvents[whichHand].pointerPress = null;
currentGo[whichHand] = null;
}
}
//And for everything else, there is dragging.
if (currentGoing[whichHand] != null)
{
ExecuteEvents.Execute(currentGoing[whichHand], PointEvents[whichHand], ExecuteEvents.dragHandler);
}
}
updatePointerColor(whichHand);
}
//Make the special Leap Widget Buttons Pop Up and Flatten when Appropriate
if (PrevTouchingMode != getTouchingMode() && RetractUI)
{
PrevTouchingMode = getTouchingMode();
if (PrevTouchingMode)
{
foreach (Canvas canvas in canvases)
{
canvas.BroadcastMessage("Expand", SendMessageOptions.DontRequireReceiver);
}
}
else
{
foreach (Canvas canvas in canvases)
{
canvas.BroadcastMessage("Retract", SendMessageOptions.DontRequireReceiver);
}
}
}
}
}
private 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);
}
}
// 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;
if (pointerEvent.pointerDrag != null)
{
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
}
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;
}
}
private void ProcessTouchPress(PointerEventData pointerEvent, bool pressed, bool released)
{
RaycastResult pointerCurrentRaycast = pointerEvent.get_pointerCurrentRaycast();
// ISSUE: explicit reference operation
GameObject gameObject1 = ((RaycastResult)@pointerCurrentRaycast).get_gameObject();
if (pressed)
{
pointerEvent.set_eligibleForClick(true);
pointerEvent.set_delta(Vector2.get_zero());
pointerEvent.set_pressPosition(pointerEvent.get_position());
pointerEvent.set_pointerPressRaycast(pointerEvent.get_pointerCurrentRaycast());
if (Object.op_Inequality((Object)pointerEvent.get_pointerEnter(), (Object)gameObject1))
{
((BaseInputModule)this).HandlePointerExitAndEnter(pointerEvent, gameObject1);
pointerEvent.set_pointerEnter(gameObject1);
}
GameObject gameObject2 = ExecuteEvents.ExecuteHierarchy <IPointerDownHandler>(gameObject1, (BaseEventData)pointerEvent, (ExecuteEvents.EventFunction <M0>)ExecuteEvents.get_pointerDownHandler());
if (Object.op_Equality((Object)gameObject2, (Object)null))
{
gameObject2 = ExecuteEvents.GetEventHandler <IPointerClickHandler>(gameObject1);
}
if (Object.op_Inequality((Object)gameObject2, (Object)pointerEvent.get_pointerPress()))
{
pointerEvent.set_pointerPress(gameObject2);
pointerEvent.set_rawPointerPress(gameObject1);
pointerEvent.set_clickCount(0);
}
pointerEvent.set_pointerDrag(ExecuteEvents.GetEventHandler <IDragHandler>(gameObject1));
if (Object.op_Inequality((Object)pointerEvent.get_pointerDrag(), (Object)null))
{
ExecuteEvents.Execute <IBeginDragHandler>(pointerEvent.get_pointerDrag(), (BaseEventData)pointerEvent, (ExecuteEvents.EventFunction <M0>)ExecuteEvents.get_beginDragHandler());
}
((BaseInputModule)this).get_eventSystem().SetSelectedGameObject(ExecuteEvents.GetEventHandler <ISelectHandler>(gameObject1), (BaseEventData)pointerEvent);
}
if (!released)
{
return;
}
float unscaledTime1 = Time.get_unscaledTime();
if ((double)this.mDoubleTap1stReleasedTime < 0.0)
{
this.mDoubleTap1stReleasedTime = unscaledTime1;
}
else if ((double)unscaledTime1 - (double)this.mDoubleTap1stReleasedTime >= 0.300000011920929)
{
this.mDoubleTap1stReleasedTime = unscaledTime1;
}
else
{
this.OnDoubleTap(pointerEvent.get_position());
this.mDoubleTap1stReleasedTime = -1f;
}
ExecuteEvents.Execute <IPointerUpHandler>(pointerEvent.get_pointerPress(), (BaseEventData)pointerEvent, (ExecuteEvents.EventFunction <M0>)ExecuteEvents.get_pointerUpHandler());
GameObject eventHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(gameObject1);
if (Object.op_Equality((Object)pointerEvent.get_pointerPress(), (Object)eventHandler) && pointerEvent.get_eligibleForClick())
{
float unscaledTime2 = Time.get_unscaledTime();
if ((double)unscaledTime2 - (double)pointerEvent.get_clickTime() < 0.300000011920929)
{
PointerEventData pointerEventData = pointerEvent;
pointerEventData.set_clickCount(pointerEventData.get_clickCount() + 1);
}
else
{
pointerEvent.set_clickCount(1);
}
pointerEvent.set_clickTime(unscaledTime2);
ExecuteEvents.Execute <IPointerClickHandler>(pointerEvent.get_pointerPress(), (BaseEventData)pointerEvent, (ExecuteEvents.EventFunction <M0>)ExecuteEvents.get_pointerClickHandler());
this.SpawnTouchEffect(pointerEvent.get_position());
}
else if (Object.op_Inequality((Object)pointerEvent.get_pointerDrag(), (Object)null))
{
ExecuteEvents.ExecuteHierarchy <IDropHandler>(gameObject1, (BaseEventData)pointerEvent, (ExecuteEvents.EventFunction <M0>)ExecuteEvents.get_dropHandler());
}
pointerEvent.set_eligibleForClick(false);
pointerEvent.set_pointerPress((GameObject)null);
pointerEvent.set_rawPointerPress((GameObject)null);
if (Object.op_Inequality((Object)pointerEvent.get_pointerDrag(), (Object)null))
{
ExecuteEvents.Execute <IEndDragHandler>(pointerEvent.get_pointerDrag(), (BaseEventData)pointerEvent, (ExecuteEvents.EventFunction <M0>)ExecuteEvents.get_endDragHandler());
}
pointerEvent.set_pointerDrag((GameObject)null);
ExecuteEvents.ExecuteHierarchy <IPointerExitHandler>(pointerEvent.get_pointerEnter(), (BaseEventData)pointerEvent, (ExecuteEvents.EventFunction <M0>)ExecuteEvents.get_pointerExitHandler());
pointerEvent.set_pointerEnter((GameObject)null);
}
public GameObject GetEventHandler <T>(GameObject root)
where T : IEventSystemHandler
{
return(ExecuteEvents.GetEventHandler <T>(root));
}
/// <summary>
/// Handles focusing and submitting of the gaze
/// </summary>
private void HandleFocus()
{
_currentHit = _gaze.pointerEnter;
if (_clickableObject != null)
{
_loadBar.sprite = _loadingCircleSprite;
_loadBar.type = Image.Type.Filled;
_loadBar.fillMethod = Image.FillMethod.Radial360;
if (_currentHit != null)
{
_loadBarCanvas.transform.position = _currentHit.transform.position - Camera.main.transform.forward * _offset;
}
else
{
_loadBarCanvas.transform.position = Camera.main.transform.position + Camera.main.transform.forward * _range;
}
}
else
{
_loadBar.sprite = _gazeSprite;
_loadBar.type = Image.Type.Simple;
_loadBarCanvas.transform.position = Camera.main.transform.position + Camera.main.transform.forward * _range;
}
_loadBarCanvas.transform.forward = Camera.main.transform.forward;
if (_currentHit == _lastHit)
{
if (_clicked)
{
return;
}
var focusTime = Time.time - _time;
if (_focusGazeTime < focusTime)
{
_clicked = true;
if (_clickableObject != null)
{
try
{
_clickableObject = ExecuteEvents.ExecuteHierarchy(_clickableObject, _gaze, ExecuteEvents.pointerClickHandler);
}
catch
{
}
}
}
else
{
_loadBar.fillAmount = focusTime / _focusGazeTime;
}
}
else
{
_lastHit = _currentHit;
_clickableObject = ExecuteEvents.GetEventHandler <IPointerClickHandler>(_gaze.pointerEnter);
_time = Time.time;
_clicked = false;
}
}
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);
var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.pointerDownHandler);
// didnt find a press handler... search for a click handler
if ((object)newPressed == null)
{
newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler> (currentOverGo);
}
// Debug.Log("Pressed: " + newPressed);
var 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);
}
}
// PointerUp notification
if (data.ReleasedThisFrame())
{
// Debug.Log("Executing pressup on: " + pointer.pointerPress);
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler> (currentOverGo);
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;
if (currentOverGo != pointerEvent.pointerEnter)
{
HandlePointerExitAndEnter(pointerEvent, null);
HandlePointerExitAndEnter(pointerEvent, currentOverGo);
}
}
}
private void processMousePress(MouseButtonEventData data)
{
var pointerEvent = data.buttonData;
var currentOverGo = pointerEvent.pointerCurrentRaycast.gameObject;
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);
var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, pointerEvent, ExecuteEvents.pointerDownHandler);
if (newPressed == null)
{
newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
}
float time = Time.unscaledTime;
if (newPressed == pointerEvent.lastPress)
{
var diffTime = time - pointerEvent.clickTime;
if (diffTime < 0.3f)
{
pointerEvent.clickCount++;
}
else
{
pointerEvent.clickCount = 1;
}
}
else
{
pointerEvent.clickCount = 1;
}
pointerEvent.pointerPress = newPressed;
pointerEvent.rawPointerPress = currentOverGo;
pointerEvent.clickTime = time;
pointerEvent.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo);
if (pointerEvent.pointerDrag != null)
{
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.initializePotentialDrag);
}
}
if (data.ReleasedThisFrame())
{
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
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;
if (currentOverGo != pointerEvent.pointerEnter)
{
HandlePointerExitAndEnter(pointerEvent, null);
HandlePointerExitAndEnter(pointerEvent, currentOverGo);
}
}
}
protected void ProcessPressDown(Pointer3DEventData eventData)
{
var currentOverGo = eventData.pointerCurrentRaycast.gameObject;
eventData.pressPrecessed = true;
eventData.eligibleForClick = true;
eventData.delta = Vector2.zero;
eventData.dragging = false;
eventData.useDragThreshold = true;
eventData.pressPosition = eventData.position;
eventData.pressPosition3D = eventData.position3D;
eventData.pressRotation = eventData.rotation;
eventData.pressDistance = eventData.pointerCurrentRaycast.distance;
eventData.pointerPressRaycast = eventData.pointerCurrentRaycast;
DeselectIfSelectionChanged(currentOverGo, eventData);
// 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, eventData, ExecuteEvents.pointerDownHandler);
// didnt find a press handler... search for a click handler
if (newPressed == null)
{
newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
}
var time = Time.unscaledTime;
if (newPressed == eventData.lastPress)
{
if (eventData.raycaster != null && time < (eventData.clickTime + eventData.raycaster.clickInterval))
{
++eventData.clickCount;
}
else
{
eventData.clickCount = 1;
}
eventData.clickTime = time;
}
else
{
eventData.clickCount = 1;
}
eventData.pointerPress = newPressed;
eventData.rawPointerPress = currentOverGo;
eventData.clickTime = time;
// Save the drag handler as well
eventData.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo);
if (eventData.pointerDrag != null)
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.initializePotentialDrag);
}
}
protected virtual void ProcessCustomRayController()
{
var mouseData = GetMousePointerEventData(0);
PointerEventData eventData = mouseData.GetButtonState(PointerEventData.InputButton.Left).eventData.buttonData;
if (pressedDown && !pressedLastFrame) //pointer down interactions
{
GameObject currentOverGo = eventData.pointerCurrentRaycast.gameObject;
eventData.eligibleForClick = true;
eventData.delta = Vector2.zero;
eventData.dragging = false;
eventData.useDragThreshold = true;
eventData.pressPosition = eventData.position;
eventData.pointerPressRaycast = eventData.pointerCurrentRaycast;
DeselectIfSelectionChanged(currentOverGo, eventData);
if (eventData.pointerEnter != currentOverGo)
{
// send a pointer enter to the touched element if it isn't the one to select...
HandlePointerExitAndEnter(eventData, currentOverGo);
eventData.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, eventData, 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 == eventData.lastPress)
{
var diffTime = time - eventData.clickTime;
if (diffTime < 0.3f)
{
++eventData.clickCount;
}
else
{
eventData.clickCount = 1;
}
eventData.clickTime = time;
}
else
{
eventData.clickCount = 1;
}
eventData.pointerPress = newPressed;
eventData.rawPointerPress = currentOverGo;
eventData.clickTime = time;
// Save the drag handler as well
eventData.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo);
if (eventData.pointerDrag != null)
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.initializePotentialDrag);
}
}
else if (!pressedDown && pressedLastFrame) //pointer up interactions
//if we did not move the pointer since the begining, this is a click.
{
if (eventData.pointerPress == eventData.selectedObject /*Vector2.Distance (eventData.position, eventData.pressPosition) < dragThreshold*/)
{
ExecuteEvents.Execute(eventData.selectedObject, eventData, ExecuteEvents.pointerClickHandler);
}
//execute pointer up events
ExecuteEvents.Execute(eventData.selectedObject, eventData, ExecuteEvents.pointerUpHandler);
//process end drag
//if (eventData.pointerDrag != null && eventData.dragging) {
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.endDragHandler);
eventData.dragging = false;
eventData.pointerDrag = null;
//}
}
if (eventData.IsPointerMoving())
{
ProcessDrag(eventData);
ProcessMove(eventData);
}
//save button state for this frame
pressedLastFrame = pressedDown;
}
/*
* private float distance_default=1.5f;
* private void PlaceCursor()
* {
*
* if (cursor == null)
* {
* return;
* }
* var go = pointerData.pointerCurrentRaycast.gameObject;
*
* //cursor.SetActive(go != null);
* cursor.SetActive(true);
* if (cursor.activeInHierarchy)
* {
* Camera cam = pointerData.enterEventCamera;
* if (cam == null)
* {
* cam = Mojing.SDK.getMainCamera();
* }
* if (cam != null)
* { // Note: rays through screen start at near clipping plane.
* //float dist = cam.nearClipPlane;
* float dist=0;
* if (go != null)
* {//collider
* dist = pointerData.pointerCurrentRaycast.distance ;
* dist = dist / Mathf.Abs(Mathf.Cos(vrHead.transform.rotation.eulerAngles.y * Mathf.PI / 180));
* distance_default = dist;
* }
* else
* {//default
* //dist += 5;
* dist = distance_default;
* }
* cursor.transform.position = cam.transform.position + cam.transform.forward * dist ;
* //Debug.Log (dist.ToString ());
* }
* }
* }
*/
private void HandleClick()
{
if (IsKeyDown())
{
var go = pointerData.pointerCurrentRaycast.gameObject;
if (go != null)
{
// Send pointer down event.
pointerData.pressPosition = pointerData.position;
pointerData.pointerPressRaycast = pointerData.pointerCurrentRaycast;
pointerData.pointerPress = ExecuteEvents.ExecuteHierarchy(go, pointerData, ExecuteEvents.pointerDownHandler) ?? ExecuteEvents.GetEventHandler <IPointerClickHandler>(go);
// Save the pending click state.
pointerData.rawPointerPress = go;
pointerData.eligibleForClick = true;
pointerData.clickCount = 1;
pointerData.clickTime = Time.unscaledTime;
}
}
if (IsKeyUp())
{
if (!pointerData.eligibleForClick && (Time.unscaledTime - pointerData.clickTime < clickTime))
{
return;
}
// Send pointer up and click events.
ExecuteEvents.Execute(pointerData.pointerPress, pointerData, ExecuteEvents.pointerUpHandler);
ExecuteEvents.Execute(pointerData.pointerPress, pointerData, ExecuteEvents.pointerClickHandler);
DispatchTrigger();
// Clear the click state.
pointerData.pointerPress = null;
pointerData.rawPointerPress = null;
pointerData.eligibleForClick = false;
pointerData.clickCount = 0;
}
}
/// <summary>
/// Sends trigger down / trigger released events to gameobjects under the pointer.
/// </summary>
protected virtual void ProcessDownRelease(PointerEventData eventData, bool down, bool released)
{
var currentOverGo = eventData.pointerCurrentRaycast.gameObject;
// PointerDown notification
if (down)
{
eventData.eligibleForClick = true;
eventData.delta = Vector2.zero;
eventData.dragging = false;
eventData.useDragThreshold = true;
eventData.pressPosition = eventData.position;
eventData.pointerPressRaycast = eventData.pointerCurrentRaycast;
DeselectIfSelectionChanged(currentOverGo, eventData);
if (eventData.pointerEnter != currentOverGo)
{
// send a pointer enter to the touched element if it isn't the one to select...
HandlePointerExitAndEnter(eventData, currentOverGo);
eventData.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, eventData, ExecuteEvents.pointerDownHandler);
// didnt find a press handler... search for a click handler
if (newPressed == null)
{
newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
}
float time = Time.unscaledTime;
if (newPressed == eventData.lastPress)
{
var diffTime = time - eventData.clickTime;
if (diffTime < 0.3f)
{
++eventData.clickCount;
}
else
{
eventData.clickCount = 1;
}
eventData.clickTime = time;
}
else
{
eventData.clickCount = 1;
}
eventData.pointerPress = newPressed;
eventData.rawPointerPress = currentOverGo;
eventData.clickTime = time;
// Save the drag handler as well
eventData.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo);
if (eventData.pointerDrag != null)
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.initializePotentialDrag);
}
}
// PointerUp notification
if (released)
{
ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerUpHandler);
// see if we mouse up on the same element that we clicked on...
var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
// PointerClick and Drop events
if (eventData.pointerPress == pointerUpHandler && eventData.eligibleForClick)
{
ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerClickHandler);
//Debug.Log("click");
}
else if (eventData.pointerDrag != null && eventData.dragging)
{
ExecuteEvents.ExecuteHierarchy(currentOverGo, eventData, ExecuteEvents.dropHandler);
//Debug.Log("drop");
}
eventData.eligibleForClick = false;
eventData.pointerPress = null;
eventData.rawPointerPress = null;
if (eventData.pointerDrag != null && eventData.dragging)
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.endDragHandler);
//Debug.Log("end drag");
}
eventData.dragging = false;
eventData.pointerDrag = null;
// send exit events as we need to simulate this on touch up on touch device
ExecuteEvents.ExecuteHierarchy(eventData.pointerEnter, eventData, ExecuteEvents.pointerExitHandler);
eventData.pointerEnter = null;
}
}
void UpdateReticle(GameObject previousGazedObject)
{
if (pointerData == null)
{
return;
}
Camera camera = pointerData.enterEventCamera; // Get the camera
Vector3 intersectionPosition = GetIntersectionPosition();
GameObject gazeObject = GetCurrentGameObject(); // Get the gaze target
if (gazeObject != null && NxrOverrideSettings.OnGazeEvent != null)
{
NxrOverrideSettings.OnGazeEvent(gazeObject);
}
float gazeZ = NxrGlobal.defaultGazeDistance;
if (gazeObject != null)
{
gazeZ = intersectionPosition
.z; // && gazeObject.transform != null &&gazeObject.transform.position.z != 0gazeObject.transform.position.z;
}
if (lastGazeZ != gazeZ)
{
lastGazeZ = gazeZ;
// 点
NxrViewer.Instance.GazeApi(Nxr.Internal.GazeTag.Set_Distance, (-1 * gazeZ).ToString());
}
// Debug.Log("--------gaze object " + (gazeObject == null ? "" : gazeObject.name));
// 记录距离
NxrGlobal.focusObjectDistance = (int)(Mathf.Abs(gazeZ) * 100) / 100.0f;
if (gazePointer == null)
{
if (gazeObject != null)
{
INxrGazeResponder mGazeResponder = gazeObject.GetComponent <INxrGazeResponder>();
if (mGazeResponder != null)
{
mGazeResponder.OnUpdateIntersectionPosition(intersectionPosition);
}
}
else
{
// Debug.Log("--------------------------gazePointer && gazeObject is null !!!");
}
return;
}
bool isInteractive = pointerData.pointerPress == gazeObject ||
ExecuteEvents.GetEventHandler <ISelectHandler>(gazeObject) != null;
if (gazeObject != null && gazeObject != previousGazedObject)
{
// Debug.LogError("Enter GazeObject=" + gazeObject.name);
if (previousGazedObject != null)
{
// Debug.LogError("Exit GazeObject=" + previousGazedObject.name);
}
}
else if (gazeObject == null && previousGazedObject != null)
{
// Debug.LogError("Exit GazeObject=" + previousGazedObject.name);
}
if (gazeObject == previousGazedObject)
{
if (gazeObject != null && gazePointer != null)
{
gazePointer.OnGazeStay(camera, gazeObject, intersectionPosition, isInteractive);
INxrGazeResponder mGazeResponder = gazeObject.GetComponent <INxrGazeResponder>();
if (mGazeResponder != null)
{
mGazeResponder.OnUpdateIntersectionPosition(intersectionPosition);
}
}
}
else
{
if (previousGazedObject != null && gazePointer != null)
{
gazePointer.OnGazeExit(camera, previousGazedObject);
if (NxrViewer.Instance != null)
{
if (NxrViewer.Instance.HeadControl == HeadControl.Hover)
{
if (NxrHeadControl.baseEventData != null)
{
NxrHeadControl.baseEventData = null;
NxrHeadControl.eventGameObject = null;
}
}
}
}
if (gazeObject != null && gazePointer != null)
{
gazePointer.OnGazeStart(camera, gazeObject, intersectionPosition, isInteractive);
if (NxrViewer.Instance != null)
{
if (NxrViewer.Instance.HeadControl == HeadControl.Hover)
{
NxrHeadControl.baseEventData = pointerData;
}
}
}
}
}
// Start is called before the first frame update
void Start()
{
_eventHandler = ExecuteEvents.GetEventHandler <ITimeSliderEventHandler>(transform.gameObject);
_sliderTransform = transform.Find("Fill Area").GetComponent <RectTransform>();
}
void EndPointerDown(RayEventData rayEvent, GameObject currentOverGo)
{
if (pointerDown != null && currentOverGo != null)
{
pointerDown(currentOverGo, rayEvent);
}
// 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, rayEvent, ExecuteRayEvents.pointerDownHandler);
if (newPressed == null)
{
newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, rayEvent, ExecuteEvents.pointerDownHandler);
}
// didnt find a press handler... search for a click handler
if (newPressed == null)
{
newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
}
if (newPressed == null)
{
newPressed = ExecuteEvents.GetEventHandler <IRayClickHandler>(currentOverGo);
}
var time = Time.unscaledTime;
if (newPressed == rayEvent.lastPress)
{
var diffTime = time - rayEvent.clickTime;
if (diffTime < 0.3f)
{
++rayEvent.clickCount;
}
else
{
rayEvent.clickCount = 1;
}
}
else
{
rayEvent.clickCount = 1;
}
rayEvent.pointerPress = newPressed;
rayEvent.rawPointerPress = currentOverGo;
rayEvent.clickTime = time;
// Save the drag handler as well
var draggedObject = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo);
if (draggedObject == null)
{
draggedObject = ExecuteEvents.GetEventHandler <IRayDragHandler>(currentOverGo);
}
rayEvent.pointerDrag = draggedObject;
if (rayEvent.pointerDrag != null)
{
ExecuteEvents.Execute(draggedObject, rayEvent, ExecuteEvents.initializePotentialDrag);
}
m_InputPointerEvent = rayEvent;
}
private void ProcessMousePress(PointerInputModule.MouseButtonEventData data)
{
var buttonData = data.buttonData;
var gameObject = buttonData.pointerCurrentRaycast.gameObject;
if (data.PressedThisFrame())
{
buttonData.eligibleForClick = true;
buttonData.delta = Vector2.zero;
buttonData.dragging = false;
buttonData.useDragThreshold = true;
buttonData.pressPosition = buttonData.position;
buttonData.pointerPressRaycast = buttonData.pointerCurrentRaycast;
var gameObject2 = ExecuteEvents.ExecuteHierarchy <IPointerDownHandler>(gameObject, buttonData, ExecuteEvents.pointerDownHandler);
if (gameObject2 == null)
{
gameObject2 = ExecuteEvents.GetEventHandler <IPointerClickHandler>(gameObject);
}
float unscaledTime = Time.unscaledTime;
if (gameObject2 == buttonData.lastPress)
{
float num = unscaledTime - buttonData.clickTime;
if (num < 0.3f)
{
buttonData.clickCount++;
}
else
{
buttonData.clickCount = 1;
}
buttonData.clickTime = unscaledTime;
}
else
{
buttonData.clickCount = 1;
}
buttonData.pointerPress = gameObject2;
buttonData.rawPointerPress = gameObject;
buttonData.clickTime = unscaledTime;
buttonData.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(gameObject);
if (buttonData.pointerDrag != null)
{
ExecuteEvents.Execute <IInitializePotentialDragHandler>(buttonData.pointerDrag, buttonData, ExecuteEvents.initializePotentialDrag);
}
}
if (data.ReleasedThisFrame())
{
ExecuteEvents.Execute <IPointerUpHandler>(buttonData.pointerPress, buttonData, ExecuteEvents.pointerUpHandler);
var eventHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(gameObject);
if (buttonData.pointerPress == eventHandler && buttonData.eligibleForClick)
{
ExecuteEvents.Execute <IPointerClickHandler>(buttonData.pointerPress, buttonData, ExecuteEvents.pointerClickHandler);
}
else
{
if (buttonData.pointerDrag != null)
{
ExecuteEvents.ExecuteHierarchy <IDropHandler>(gameObject, buttonData, ExecuteEvents.dropHandler);
}
}
buttonData.eligibleForClick = false;
buttonData.pointerPress = null;
buttonData.rawPointerPress = null;
buttonData.dragging = false;
if (buttonData.pointerDrag != null)
{
ExecuteEvents.Execute <IEndDragHandler>(buttonData.pointerDrag, buttonData, ExecuteEvents.endDragHandler);
}
buttonData.pointerDrag = null;
if (gameObject != buttonData.pointerEnter)
{
base.HandlePointerExitAndEnter(buttonData, null);
base.HandlePointerExitAndEnter(buttonData, gameObject);
}
}
}
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl)
{
if (!(m_RayOrigin.gameObject.activeSelf || eventData.pointerDrag) || !m_Proxy.active)
{
return;
}
var preProcessRaycastSource = m_Owner.preProcessRaycastSource;
if (preProcessRaycastSource != null)
{
preProcessRaycastSource(m_RayOrigin);
}
if (eventData == null)
{
eventData = new RayEventData(m_Owner.eventSystem);
}
m_Owner.GetRayIntersection(this); // Check all currently running raycasters
var currentRaycast = eventData.pointerCurrentRaycast;
m_Owner.m_CurrentFocusedGameObject = currentRaycast.gameObject;
eventData.node = m_Node;
eventData.rayOrigin = m_RayOrigin;
eventData.pointerLength = m_Owner.GetPointerLength(m_RayOrigin);
var uiActions = (UIActions)input;
var select = uiActions.select;
if (m_IsValid != null && !m_IsValid(this))
{
currentRaycast.gameObject = null;
eventData.pointerCurrentRaycast = currentRaycast;
m_Owner.HandlePointerExitAndEnter(eventData, null, true); // Send only exit events
if (select.wasJustReleased)
{
m_Owner.OnSelectReleased(this);
}
HideScrollFeedback();
return;
}
if (currentRaycast.gameObject)
{
if (select.wasJustPressed)
{
m_Owner.OnSelectPressed(this);
consumeControl(select);
}
}
if (select.wasJustReleased)
{
m_Owner.OnSelectReleased(this);
}
m_Owner.ProcessMove(eventData);
m_Owner.ProcessDrag(eventData, true);
var verticalScroll = uiActions.verticalScroll;
var horizontalScroll = uiActions.horizontalScroll;
if (eventData.dragging)
{
consumeControl(verticalScroll);
consumeControl(horizontalScroll);
}
// Send scroll events
if (currentObject)
{
var hasScrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(currentObject);
if (hasScrollHandler)
{
var verticalScrollValue = verticalScroll.value;
var horizontalScrollValue = horizontalScroll.value;
if (!Mathf.Approximately(verticalScrollValue, 0f) || !Mathf.Approximately(horizontalScrollValue, 0f))
{
consumeControl(verticalScroll);
consumeControl(horizontalScroll);
eventData.scrollDelta = new Vector2(horizontalScrollValue, verticalScrollValue);
ExecuteEvents.ExecuteHierarchy(currentObject, eventData, ExecuteEvents.scrollHandler);
}
if (m_ScrollFeedback.Count == 0)
{
ShowScrollFeedback();
}
}
}
}
/// <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);
// 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 (data.ReleasedThisFrame())
{
ReleaseMouse(pointerEvent, currentOverGo);
}
}
// Process the press
private void ProcessPress(PointerEventData pointerEvent, bool pressedThisFrame, bool releasedThisFrame)
{
var currentOverGo = pointerEvent.pointerCurrentRaycast.gameObject;
// PointerDown/PointerClick event
if (pressedThisFrame)
{
pointerEvent.eligibleForClick = true;
pointerEvent.delta = Vector2.zero;
pointerEvent.dragging = false;
pointerEvent.useDragThreshold = true;
pointerEvent.pressPosition = pointerEvent.position;
pointerEvent.pointerPressRaycast = pointerEvent.pointerCurrentRaycast;
this.DeselectIfSelectionChanged(currentOverGo, pointerEvent);
// search for the control that will receive the press
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);
}
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);
}
}
// PointerUp notification
if (releasedThisFrame)
{
ExecuteEvents.Execute(pointerEvent.pointerPress, pointerEvent, ExecuteEvents.pointerUpHandler);
// see if we released on the same element that was clicked before
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);
}
// reset pressed state
pointerEvent.eligibleForClick = false;
pointerEvent.pointerPress = null;
pointerEvent.rawPointerPress = null;
// send endDrag event
if (pointerEvent.pointerDrag != null && pointerEvent.dragging)
{
ExecuteEvents.Execute(pointerEvent.pointerDrag, pointerEvent, ExecuteEvents.endDragHandler);
}
// reset dragging state
pointerEvent.dragging = false;
pointerEvent.pointerDrag = null;
// if the current object is not the previous entered object, then set that now
if (currentOverGo != pointerEvent.pointerEnter)
{
this.HandlePointerExitAndEnter(pointerEvent, null);
this.HandlePointerExitAndEnter(pointerEvent, currentOverGo);
}
}
}
/// <summary>
/// Process the current mouse press.
/// </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);
// 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);
}
}
// PointerUp notification
if (data.ReleasedThisFrame())
{
// 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;
// redo pointer enter / exit to refresh state
// so that if we moused over somethign 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);
}
}
}
/// <summary>
/// マウスの押下イベントを処理
/// </summary>
/// <param name="buttonEventData">マウスボタンのイベント情報</param>
void ProcessPress(PointerInputModule.MouseButtonEventData buttonEventData)
{
PointerEventData eventData = buttonEventData.buttonData;
GameObject rayTarget = eventData.pointerCurrentRaycast.gameObject;
// ボタンを押下した時
if (buttonEventData.PressedThisFrame())
{
GameObject eventTarget;
eventData.eligibleForClick = true;
eventData.delta = Vector2.zero;
eventData.dragging = false;
eventData.useDragThreshold = true;
eventData.pressPosition = eventData.position;
eventData.pointerPressRaycast = eventData.pointerCurrentRaycast;
DeselectIfSelectionChanged(rayTarget, eventData);
// 押下イベントを発行。対象となるオブジェクトを取得
eventTarget = ExecuteEvents.ExecuteHierarchy <IPointerDownHandler>(
rayTarget, eventData, ExecuteEvents.pointerDownHandler);
if (eventTarget == null)
{
eventTarget = ExecuteEvents.GetEventHandler <IPointerClickHandler>(rayTarget);
}
// 選択したオブジェクトが直前のものと同じ場合、クリック回数をカウント
float unscaledTime = Time.unscaledTime;
if (eventTarget == eventData.lastPress)
{
float deltaTime = unscaledTime - eventData.clickTime;
if (deltaTime < 0.3f)
{
eventData.clickCount++;
}
else
{
eventData.clickCount = 1;
}
}
else
{
eventData.clickCount = 1;
}
eventData.pointerPress = eventTarget;
eventData.rawPointerPress = rayTarget;
eventData.clickTime = unscaledTime;
// ドラッグ開始の直前イベント
eventData.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(rayTarget);
if (eventData.pointerDrag != null)
{
ExecuteEvents.Execute <IInitializePotentialDragHandler>(
eventData.pointerDrag, eventData, ExecuteEvents.initializePotentialDrag);
}
}
// ボタンを離上した時
if (buttonEventData.ReleasedThisFrame())
{
// 離上イベントを発行
ExecuteEvents.Execute <IPointerUpHandler>(
eventData.pointerPress, eventData, ExecuteEvents.pointerUpHandler);
// クリックイベント
GameObject eventHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(rayTarget);
if (eventData.pointerPress == eventHandler && eventData.eligibleForClick)
{
ExecuteEvents.Execute <IPointerClickHandler>(
eventData.pointerPress, eventData, ExecuteEvents.pointerClickHandler);
}
// ドロップイベント
else if (eventData.pointerDrag != null && eventData.dragging)
{
ExecuteEvents.ExecuteHierarchy <IDropHandler>(
rayTarget, eventData, ExecuteEvents.dropHandler);
}
eventData.eligibleForClick = false;
eventData.pointerPress = null;
eventData.rawPointerPress = null;
// ドラッグ終了
if (eventData.pointerDrag != null && eventData.dragging)
{
ExecuteEvents.Execute <IEndDragHandler>(
eventData.pointerDrag, eventData, ExecuteEvents.endDragHandler);
}
eventData.dragging = false;
eventData.pointerDrag = null;
// マウスオーバー更新
if (rayTarget != eventData.pointerEnter)
{
base.HandlePointerExitAndEnter(eventData, null);
base.HandlePointerExitAndEnter(eventData, rayTarget);
}
}
}
// modified StandaloneInputModule
private void ProcessPress(PointerEventData eventData)
{
var currentOverGo = eventData.pointerCurrentRaycast.gameObject;
// PointerDown notification
if (MyIsButtonPressedThisFrame())
{
eventData.eligibleForClick = true;
eventData.delta = Vector2.zero;
eventData.useDragThreshold = true;
eventData.pressPosition = eventData.position;
eventData.pointerPressRaycast = eventData.pointerCurrentRaycast;
DeselectIfSelectionChanged(currentOverGo, eventData);
var newPressed = ExecuteEvents.ExecuteHierarchy(currentOverGo, eventData, ExecuteEvents.pointerDownHandler);
// didnt find a press handler... search for a click handler
if (newPressed == null)
{
newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
}
eventData.pointerPress = newPressed; // TODO:remove?
m_pressedDistance = 0;
eventData.rawPointerPress = currentOverGo;
eventData.clickTime = Time.unscaledTime;
// Save the drag handler as well
eventData.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo);
if (eventData.pointerDrag != null)
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.initializePotentialDrag);
}
}
// PointerUp notification
if (MyIsButtonReleasedThisFrame())
{
ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerUpHandler);
// see if we button up on the same element that we clicked on...
var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo);
// PointerClick and Drop events
if (eventData.pointerPress == pointerUpHandler && eventData.eligibleForClick)
{
ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerClickHandler);
}
else if (eventData.pointerDrag != null && eventData.dragging)
{
ExecuteEvents.ExecuteHierarchy(currentOverGo, eventData, ExecuteEvents.dropHandler);
}
eventData.eligibleForClick = false;
eventData.pointerPress = null;
m_pressedDistance = 0; // just in case
eventData.rawPointerPress = null;
if (eventData.pointerDrag != null && eventData.dragging)
{
ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.endDragHandler);
}
eventData.dragging = false;
eventData.pointerDrag = null;
// redo pointer enter / exit to refresh state
// so that if we hovered over something that ignored it before
// due to having pressed on something else
// it now gets it.
if (currentOverGo != eventData.pointerEnter)
{
HandlePointerExitAndEnter(eventData, null);
HandlePointerExitAndEnter(eventData, currentOverGo);
}
}
}
protected virtual void ProcessRaycast()
{
if (m_processedFrame == Time.frameCount)
{
return;
}
m_processedFrame = Time.frameCount;
// use another list to iterate raycasters
// incase that raycasters may changed during this process cycle
for (int i = 0, imax = raycasters.Count; i < imax; ++i)
{
var r = raycasters[i];
if (r != null)
{
processingRaycasters.Add(r);
}
}
for (var i = processingRaycasters.Count - 1; i >= 0; --i)
{
var raycaster = processingRaycasters[i];
if (raycaster == null)
{
continue;
}
raycaster.Raycast();
var result = raycaster.FirstRaycastResult();
// prepare raycaster value
var scrollDelta = raycaster.GetScrollDelta();
var raycasterPos = raycaster.transform.position;
var raycasterRot = raycaster.transform.rotation;
var hoverEventData = raycaster.HoverEventData;
if (hoverEventData == null)
{
continue;
}
// gen shared data and put in hover event
hoverEventData.Reset();
hoverEventData.delta = Vector2.zero;
hoverEventData.scrollDelta = scrollDelta;
hoverEventData.position = ScreenCenterPoint;
hoverEventData.pointerCurrentRaycast = result;
hoverEventData.position3DDelta = raycasterPos - hoverEventData.position3D;
hoverEventData.position3D = raycasterPos;
hoverEventData.rotationDelta = Quaternion.Inverse(hoverEventData.rotation) * raycasterRot;
hoverEventData.rotation = raycasterRot;
// copy data to other button event
for (int j = 0, jmax = raycaster.ButtonEventDataList.Count; j < jmax; ++j)
{
var buttonEventData = raycaster.ButtonEventDataList[j];
if (buttonEventData == null || buttonEventData == hoverEventData)
{
continue;
}
buttonEventData.Reset();
buttonEventData.delta = Vector2.zero;
buttonEventData.scrollDelta = scrollDelta;
buttonEventData.position = ScreenCenterPoint;
buttonEventData.pointerCurrentRaycast = result;
buttonEventData.position3DDelta = hoverEventData.position3DDelta;
buttonEventData.position3D = hoverEventData.position3D;
buttonEventData.rotationDelta = hoverEventData.rotationDelta;
buttonEventData.rotation = hoverEventData.rotation;
}
ProcessPress(hoverEventData);
ProcessMove(hoverEventData);
ProcessDrag(hoverEventData);
// other buttons event
for (int j = 1, jmax = raycaster.ButtonEventDataList.Count; j < jmax; ++j)
{
var buttonEventData = raycaster.ButtonEventDataList[j];
if (buttonEventData == null || buttonEventData == hoverEventData)
{
continue;
}
buttonEventData.pointerEnter = hoverEventData.pointerEnter;
ProcessPress(buttonEventData);
ProcessDrag(buttonEventData);
}
// scroll event
if (result.isValid && !Mathf.Approximately(scrollDelta.sqrMagnitude, 0.0f))
{
var scrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(result.gameObject);
ExecuteEvents.ExecuteHierarchy(scrollHandler, hoverEventData, ExecuteEvents.scrollHandler);
}
}
if (isActiveAndEnabled)
{
for (var i = processingRaycasters.Count - 1; i >= 0; --i)
{
var r = processingRaycasters[i];
if (!raycasters.Contains(r))
{
CleanUpRaycaster(r);
}
}
}
else
{
for (var i = processingRaycasters.Count - 1; i >= 0; --i)
{
CleanUpRaycaster(processingRaycasters[i]);
}
}
processingRaycasters.Clear();
}
