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(); }