private void HideSameCards() { Destroy(firstCardRevealed); Destroy(secondCardRevealed); ExecuteEvents.Execute <IScoreEventHandler>(gameObject, null, (x, y) => x.Score(true)); }
void ExecuteGlobalButtonUp(int button) { if (buttonReceivers[button].Count == 0) { return; } switch (button) { case ButtonConstants.A: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteAPressUpHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalAPressUp(eventData)); } } break; case ButtonConstants.B: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteBPressUpHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalBPressUp(eventData)); } } break; case ButtonConstants.LEFT: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteLeftPressUpHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalLeftPressUp(eventData)); } } break; case ButtonConstants.RIGHT: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteRightPressUpHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalRightPressUp(eventData)); } } break; case ButtonConstants.UP: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteUpPressUpHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalUpPressUp(eventData)); } } break; case ButtonConstants.DOWN: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteDownPressUpHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalDownPressUp(eventData)); } } break; case ButtonConstants.PLUS: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMotePlusPressUpHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalPlusPressUp(eventData)); } } break; case ButtonConstants.MINUS: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteMinusPressUpHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalMinusPressUp(eventData)); } } break; case ButtonConstants.ONE: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteOnePressUpHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalOnePressUp(eventData)); } } break; } buttonReceivers[button].Clear(); }
private void ProcessHoverForPC(PointerEventData pointerEventData) { GameObject newEnterTarget = pointerEventData.pointerCurrentRaycast.gameObject; // if we have not changed hover target // if( pointerEventData.pointerEnter == newEnterTarget ) // { // return ; // } if (pointerEventData.pointerEnter == newEnterTarget) { if (newEnterTarget != null) { // 現在の Enter(同じであってもメッセージを送る) Transform t = newEnterTarget.transform; while (t != null) { // 中に入った事を通知する ExecuteEvents.Execute(t.gameObject, pointerEventData, ExecuteEvents.pointerEnterHandler); t = t.parent; } } return; // ここで終了 } //---------------------------------- GameObject commonRoot = FindCommonRoot(pointerEventData.pointerEnter, newEnterTarget); if (pointerEventData.pointerEnter != null) { // 古い Enter Transform t = pointerEventData.pointerEnter.transform; while (t != null) { if (commonRoot != null && commonRoot.transform == t) { break; } // 外に出た事を通知する ExecuteEvents.Execute(t.gameObject, pointerEventData, ExecuteEvents.pointerExitHandler); t = t.parent; } } if (newEnterTarget != null) { // 新しい Enter Transform t = newEnterTarget.transform; while (t != null && t.gameObject != commonRoot) { // 中に入った事を通知する ExecuteEvents.Execute(t.gameObject, pointerEventData, ExecuteEvents.pointerEnterHandler); t = t.parent; } } // 更新 pointerEventData.pointerEnter = newEnterTarget; }
private void OnTriggeGaze() { bool sendEvent = false; // The gameobject to which raycast positions var currentOverGO = pointerData.pointerCurrentRaycast.gameObject; // { ------- Reticle -------- if (progressText == null) { GameObject pt = GameObject.Find("ProgressText"); if (pt != null) { progressText = pt.GetComponent <Text>(); } } if (counterText == null) { GameObject ct = GameObject.Find("CounterText"); if (ct != null) { counterText = ct.GetComponent <Text>(); } } if (pointerData.pointerEnter == null && currentOverGO == null) { UpdateReticle(currentOverGO, pointerData); progressflag = true; if (progressText != null) { progressText.text = ""; } if (counterText != null) { counterText.text = ""; } if (gazePointer != null) { gazePointer.triggerProgressBar(false); } return; } if (!progressRate && !progressCounter) // if no counting, reset trigger flag { progressflag = true; } if (!progressRate || !progressCounter) // clear counting content { if (progressText != null && progressText.text != "") { progressText.text = ""; } if (counterText != null && counterText.text != "") { counterText.text = ""; } } // --------- Reticle -------- } if (pointerData.pointerEnter != currentOverGO) { #if UNITY_EDITOR PrintDebugLog("OnTriggeGaze() pointerEnter: " + pointerData.pointerEnter + ", currentOverGO: " + currentOverGO); #endif HandlePointerExitAndEnter(pointerData, currentOverGO); gazeTime = Time.unscaledTime; // { ------- Reticle -------- countingTime = Time.unscaledTime; UpdateReticle(currentOverGO, pointerData); // --------- Reticle -------- } } else { // { ------- Reticle -------- if (progressflag) // begin to count, do initialization { if (gazePointer != null) { gazePointer.triggerProgressBar(true); } if (progressRate && progressText != null) { progressText.text = "0%"; } if (progressCounter && counterText != null) { counterText.text = TimeToGaze.ToString(); } countingTime = Time.unscaledTime; progressflag = false; // counting the rate of waiting for clicking event } // --------- Reticle -------- } float elapsedTime = Time.unscaledTime; if (BtnControl && !WithTimeGaze) { UpdateBtnState(); if (btnPressDown) { sendEvent = true; } if (progressRate) { if (progressText != null) { progressText.text = ""; } } if (progressCounter) { if (counterText != null) { counterText.text = ""; } } if (gazePointer != null) { gazePointer.triggerProgressBar(false); } progressflag = false; } else { if (BtnControl && WithTimeGaze) { UpdateBtnState(); if (btnPressDown) { gazeTime = Time.unscaledTime - TimeToGaze; } } if (elapsedTime - gazeTime > TimeToGaze) { #if UNITY_EDITOR //PrintDebugLog ("OnTriggeGaze() Selected: {" + currentOverGO.name + "} over " + TimeToGaze + " seconds."); #endif sendEvent = true; gazeTime = Time.unscaledTime; // { ------- Reticle -------- if (progressRate) { if (progressText != null) { progressText.text = ""; } } if (progressCounter) { if (counterText != null) { counterText.text = ""; } } if (gazePointer != null) { gazePointer.triggerProgressBar(false); } progressflag = true; // reset trigger flag after each counting is done } else { float rate = ((Time.unscaledTime - gazeTime) / TimeToGaze) * 100; if (gazePointer != null) { gazePointer.setProgressBarTime(rate); } if (progressRate) { if (progressText != null) { progressText.text = Mathf.Floor(rate) + "%"; } } if (progressCounter) { if (counterText != null) { counterText.text = System.Math.Round(TimeToGaze - (Time.unscaledTime - countingTime), 2).ToString(); } } // --------- Reticle -------- } } } } // Standalone Input Module information pointerData.delta = Vector2.zero; pointerData.dragging = false; DeselectIfSelectionChanged(currentOverGO, pointerData); if (sendEvent) { if (InputEvent == EGazeInputEvent.PointerClick) { ExecuteEvents.ExecuteHierarchy(currentOverGO, pointerData, ExecuteEvents.pointerClickHandler); pointerData.clickTime = Time.unscaledTime; } else if (InputEvent == EGazeInputEvent.PointerDown) { // like "mouse" action, press->release soon, do NOT keep the pointerPressRaycast cause do NOT need to controll "down" object while not gazing. pointerData.pressPosition = pointerData.position; pointerData.pointerPressRaycast = pointerData.pointerCurrentRaycast; var _pointerDownGO = ExecuteEvents.ExecuteHierarchy(currentOverGO, pointerData, ExecuteEvents.pointerDownHandler); ExecuteEvents.ExecuteHierarchy(_pointerDownGO, pointerData, ExecuteEvents.pointerUpHandler); } else if (InputEvent == EGazeInputEvent.PointerSubmit) { ExecuteEvents.ExecuteHierarchy(currentOverGO, pointerData, ExecuteEvents.submitHandler); } } }
public override void Process() { foreach (var pair in _controllerData) { IUILaserPointer controller = pair.Key; ControllerData data = pair.Value; // Test if UICamera is looking at a GUI element UpdateCameraPosition(controller); if (data.pointerEvent == null) { data.pointerEvent = new PointerEventData(eventSystem); } else { data.pointerEvent.Reset(); } data.pointerEvent.delta = Vector2.zero; data.pointerEvent.position = new Vector2(Screen.width * 0.5f, Screen.height * 0.5f); data.pointerEvent.scrollDelta = Vector2.zero; // trigger a raycast eventSystem.RaycastAll(data.pointerEvent, m_RaycastResultCache); data.pointerEvent.pointerCurrentRaycast = FindFirstRaycast(m_RaycastResultCache); m_RaycastResultCache.Clear(); // make sure our controller knows about the raycast result // we add 0.01 because that is the near plane distance of our camera and we want the correct distance if (data.pointerEvent.pointerCurrentRaycast.distance > 0.0f) { controller.LimitLaserDistance(data.pointerEvent.pointerCurrentRaycast.distance + 0.01f); } // stop if no UI element was hit //if(pointerEvent.pointerCurrentRaycast.gameObject == null) //return; // Send control enter and exit events to our controller var hitControl = data.pointerEvent.pointerCurrentRaycast.gameObject; if (data.currentPoint != hitControl) { if (data.currentPoint != null) { controller.OnExitControl(data.currentPoint); } if (hitControl != null) { controller.OnEnterControl(hitControl); } } data.currentPoint = hitControl; // Handle enter and exit events on the GUI controlls that are hit base.HandlePointerExitAndEnter(data.pointerEvent, data.currentPoint); if (controller.ButtonDown()) { ClearSelection(); data.pointerEvent.pressPosition = data.pointerEvent.position; data.pointerEvent.pointerPressRaycast = data.pointerEvent.pointerCurrentRaycast; data.pointerEvent.pointerPress = null; // update current pressed if the curser is over an element if (data.currentPoint != null) { data.currentPressed = data.currentPoint; GameObject newPressed = ExecuteEvents.ExecuteHierarchy(data.currentPressed, data.pointerEvent, ExecuteEvents.pointerDownHandler); if (newPressed == null) { // some UI elements might only have click handler and not pointer down handler newPressed = ExecuteEvents.ExecuteHierarchy(data.currentPressed, data.pointerEvent, ExecuteEvents.pointerClickHandler); if (newPressed != null) { data.currentPressed = newPressed; } } else { data.currentPressed = 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 // reason to do this is head tracking might be jittery and this makes it easier to click buttons ExecuteEvents.Execute(newPressed, data.pointerEvent, ExecuteEvents.pointerClickHandler); } if (newPressed != null) { data.pointerEvent.pointerPress = newPressed; data.currentPressed = newPressed; Select(data.currentPressed); } ExecuteEvents.Execute(data.currentPressed, data.pointerEvent, ExecuteEvents.beginDragHandler); data.pointerEvent.pointerDrag = data.currentPressed; data.currentDragging = data.currentPressed; } }// button down end if (controller.ButtonUp()) { if (data.currentDragging != null) { ExecuteEvents.Execute(data.currentDragging, data.pointerEvent, ExecuteEvents.endDragHandler); if (data.currentPoint != null) { ExecuteEvents.ExecuteHierarchy(data.currentPoint, data.pointerEvent, ExecuteEvents.dropHandler); } data.pointerEvent.pointerDrag = null; data.currentDragging = null; } if (data.currentPressed) { ExecuteEvents.Execute(data.currentPressed, data.pointerEvent, ExecuteEvents.pointerUpHandler); data.pointerEvent.rawPointerPress = null; data.pointerEvent.pointerPress = null; data.currentPressed = null; } } // drag handling if (data.currentDragging != null) { ExecuteEvents.Execute(data.currentDragging, data.pointerEvent, ExecuteEvents.dragHandler); } } }
public GameObject GetEventHandler <T>(GameObject root) where T : IEventSystemHandler { return(ExecuteEvents.GetEventHandler <T>(root)); }
private static void Execute(IColliderEventAxisChangedHandler handler, BaseEventData eventData) { handler.OnColliderEventAxisChanged(ExecuteEvents.ValidateEventData <ColliderAxisEventData>(eventData)); }
public virtual void ProcessPressed(object sender, PointerEventArgs pointerEventArgs) { #if UNITY_5_6_OR_NEWER uiSampler.Begin(); #endif var pointers = pointerEventArgs.Pointers; var count = pointers.Count; for (var i = 0; i < count; i++) { var pointer = pointers[i]; var over = pointer.GetOverData(); // Don't update the pointer if it is not over an UI element if (over.Type != HitData.HitType.UI) { continue; } PointerEventData data; GetPointerData(pointer.Id, out data, true); var target = over.Target; var currentOverGo = target == null ? null : target.gameObject; data.eligibleForClick = true; data.delta = Vector2.zero; data.dragging = false; data.useDragThreshold = true; data.position = pointer.Position; data.pressPosition = pointer.Position; data.pointerPressRaycast = data.pointerCurrentRaycast; DeselectIfSelectionChanged(currentOverGo, data); if (data.pointerEnter != currentOverGo) { // send a pointer enter to the touched element if it isn't the one to select... input.HandlePointerExitAndEnter(data, currentOverGo); data.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, data, 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 == data.lastPress) // ? { var diffTime = time - data.clickTime; if (diffTime < 0.3f) { ++data.clickCount; } else { data.clickCount = 1; } data.clickTime = time; } else { data.clickCount = 1; } data.pointerPress = newPressed; data.rawPointerPress = currentOverGo; data.clickTime = time; // Save the drag handler as well data.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo); if (data.pointerDrag != null) { ExecuteEvents.Execute(data.pointerDrag, data, ExecuteEvents.initializePotentialDrag); } } #if UNITY_5_6_OR_NEWER uiSampler.End(); #endif }
public virtual void ProcessReleased(object sender, PointerEventArgs pointerEventArgs) { #if UNITY_5_6_OR_NEWER uiSampler.Begin(); #endif var pointers = pointerEventArgs.Pointers; var count = pointers.Count; for (var i = 0; i < count; i++) { var pointer = pointers[i]; var press = pointer.GetPressData(); // Don't update the pointer if it is was not pressed over an UI element if (press.Type != HitData.HitType.UI) { continue; } var over = pointer.GetOverData(); PointerEventData data; GetPointerData(pointer.Id, out data, true); var target = over.Target; var currentOverGo = target == null ? null : target.gameObject; ExecuteEvents.Execute(data.pointerPress, data, ExecuteEvents.pointerUpHandler); var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo); if (data.pointerPress == pointerUpHandler && data.eligibleForClick) { ExecuteEvents.Execute(data.pointerPress, data, ExecuteEvents.pointerClickHandler); } else if (data.pointerDrag != null && data.dragging) { ExecuteEvents.ExecuteHierarchy(currentOverGo, data, ExecuteEvents.dropHandler); } data.eligibleForClick = false; data.pointerPress = null; data.rawPointerPress = null; if (data.pointerDrag != null && data.dragging) { ExecuteEvents.Execute(data.pointerDrag, data, ExecuteEvents.endDragHandler); } data.dragging = false; data.pointerDrag = null; // send exit events as we need to simulate this on touch up on touch device ExecuteEvents.ExecuteHierarchy(data.pointerEnter, data, ExecuteEvents.pointerExitHandler); data.pointerEnter = 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 != data.pointerEnter) { input.HandlePointerExitAndEnter(data, null); input.HandlePointerExitAndEnter(data, currentOverGo); } } #if UNITY_5_6_OR_NEWER uiSampler.End(); #endif }
private void HandleButton(ButtonType buttonType, PointerEventData.FramePressState buttonState, CustomEventData eventData, bool allowDragging) { GameObject currentOverGo = activeGameObject; // PointerDown notification if (buttonState == PointerEventData.FramePressState.Pressed || buttonState == PointerEventData.FramePressState.PressedAndReleased) { eventData.eligibleForClick = true; eventData.delta = Vector2.zero; eventData.dragging = false; eventData.useDragThreshold = true; eventData.pressPosition = eventData.position; 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); } // 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); } } // PointerUp notification if (buttonState == PointerEventData.FramePressState.Released || buttonState == PointerEventData.FramePressState.PressedAndReleased) { // Debug.Log("Executing pressup on: " + pointer.pointerPress); ExecuteEvents.Execute(eventData.pointerPress, eventData, 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 (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; 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 moused over somethign 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); } } }
public virtual void ProcessUpdated(object sender, PointerEventArgs pointerEventArgs) { #if UNITY_5_6_OR_NEWER uiSampler.Begin(); #endif var pointers = pointerEventArgs.Pointers; var raycast = new RaycastResult(); var count = pointers.Count; for (var i = 0; i < count; i++) { var pointer = pointers[i]; var over = pointer.GetOverData(); // Don't update the pointer if it is pressed not over an UI element if ((pointer.Buttons & Pointer.PointerButtonState.AnyButtonPressed) > 0) { var press = pointer.GetPressData(); if (press.Type != HitData.HitType.UI) { continue; } } else { // Don't update the pointer if it is not over an UI element if (over.Type != HitData.HitType.UI) { continue; } } PointerEventData data; GetPointerData(pointer.Id, out data, true); data.Reset(); var target = over.Target; var currentOverGo = target == null ? null : target.gameObject; data.position = pointer.Position; data.delta = pointer.Position - pointer.PreviousPosition; convertRaycast(over.RaycastHitUI, ref raycast); raycast.screenPosition = data.position; data.pointerCurrentRaycast = raycast; input.HandlePointerExitAndEnter(data, currentOverGo); bool moving = data.IsPointerMoving(); if (moving && data.pointerDrag != null && !data.dragging && ShouldStartDrag(data.pressPosition, data.position, input.eventSystem.pixelDragThreshold, data.useDragThreshold)) { ExecuteEvents.Execute(data.pointerDrag, data, ExecuteEvents.beginDragHandler); data.dragging = true; } // Drag notification if (data.dragging && moving && data.pointerDrag != null) { // Before doing drag we should cancel any pointer down state // And clear selection! if (data.pointerPress != data.pointerDrag) { ExecuteEvents.Execute(data.pointerPress, data, ExecuteEvents.pointerUpHandler); data.eligibleForClick = false; data.pointerPress = null; data.rawPointerPress = null; } ExecuteEvents.Execute(data.pointerDrag, data, ExecuteEvents.dragHandler); } var mousePointer = pointer as MousePointer; if (mousePointer != null && !Mathf.Approximately(mousePointer.ScrollDelta.sqrMagnitude, 0.0f)) { data.scrollDelta = mousePointer.ScrollDelta; var scrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(currentOverGo); ExecuteEvents.ExecuteHierarchy(scrollHandler, data, ExecuteEvents.scrollHandler); } } #if UNITY_5_6_OR_NEWER uiSampler.End(); #endif }
//! Called every frame after UpdateModule (but only if this module is active!) public override void Process() { UI.Core.instance.setPointerIsOnUI(isPointerOverUI); UI.Core.instance.setPointerIsOnPlatformUI(isPointerOverPlatformUI); SendUpdateEventToSelectedObject(); InputDeviceManager idm = InputDeviceManager.instance; // Get a list of buttons from the input module, which tells me if buttons are pressed, released or not changed: ButtonInfo buttonInfo; if (idm.currentInputDevice != null) { buttonInfo = idm.currentInputDevice.updateButtonInfo(); } else { buttonInfo = new ButtonInfo(); } // ---------------------------------- // Fill the EventData with current information from the last hit: eventData.scrollDelta = idm.currentInputDevice.getScrollDelta(); if (InputDeviceManager.instance.currentInputDevice.getDeviceType() == InputDeviceManager.InputDeviceType.ViveController) { eventData.scrollDelta *= 100; } //eventData.position = fakeUIScreenPosition; // Because we're interested in the 3D positions only, copy it over to the 2D UI hit result: raycastResult.worldPosition = raycastHit.point; raycastResult.worldNormal = raycastHit.normal; eventData.pointerCurrentRaycast = raycastResult; eventData.position = raycastResult.screenPosition; HandlePointerExitAndEnter(eventData, activeGameObject); if (activeGameObject != null) { ExecuteEvents.ExecuteHierarchy(activeGameObject, eventData, CustomEvents.pointerHoverHandler); } CopyFromTo(eventData, leftData); CopyFromTo(eventData, rightData); CopyFromTo(eventData, middleData); CopyFromTo(eventData, triggerData); leftData.button = PointerEventData.InputButton.Left; rightData.button = PointerEventData.InputButton.Right; middleData.button = PointerEventData.InputButton.Middle; triggerData.button = PointerEventData.InputButton.Left; // Treat trigger like a left click! // Stop any selection if anything was pressed: //if( AnyPressed( buttonInfo ) ) //{ //EventSystem.current.SetSelectedGameObject( null, eventData ); //} // ---------------------------------- // Handle left click: //if (activeGameObject) { HandleButton(ButtonType.Left, buttonInfo.buttonStates [ButtonType.Left], leftData, true); ProcessDrag(leftData); //} // ---------------------------------- // Handle right click: //if (activeGameObject) { HandleButton(ButtonType.Right, buttonInfo.buttonStates [ButtonType.Right], rightData, false); ProcessDrag(rightData); //} // ---------------------------------- // Handle middle click: //if (activeGameObject) { HandleButton(ButtonType.Middle, buttonInfo.buttonStates [ButtonType.Middle], middleData, false); ProcessDrag(middleData); //} // ---------------------------------- // Handle trigger: //if (activeGameObject) { HandleButton(ButtonType.Trigger, buttonInfo.buttonStates [ButtonType.Trigger], triggerData, true); ProcessDrag(triggerData); //} // ---------------------------------- // Handle scroll: if (!Mathf.Approximately(eventData.scrollDelta.sqrMagnitude, 0.0f)) { //Debug.Log ("Scrolling: " + eventData.scrollDelta + " " + activeGameObject.name); //ExecuteEvents.ExecuteHierarchy(activeGameObject, eventData, ExecuteEvents.scrollHandler); var scrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler> (activeGameObject); ExecuteEvents.ExecuteHierarchy(scrollHandler, eventData, ExecuteEvents.scrollHandler); //ExecuteEvents.ExecuteHierarchy (activeGameObject, eventData, ExecuteEvents.scrollHandler); } }
/// <summary> /// Always route initialize potential drag event to parents /// </summary> public override void OnInitializePotentialDrag(PointerEventData eventData) { ExecuteEvents.ExecuteHierarchy(transform.parent.gameObject, eventData, ExecuteEvents.initializePotentialDrag); base.OnInitializePotentialDrag(eventData); }
public static void CallSubmit() { var pointer = new PointerEventData(EventSystem.current); ExecuteEvents.Execute(EventSystem.current.currentSelectedGameObject, pointer, ExecuteEvents.submitHandler); }
private void ProcessMouseButton(ButtonDeltaState mouseButtonChanges, PointerEventData eventData) { var currentOverGo = eventData.pointerCurrentRaycast.gameObject; if ((mouseButtonChanges & ButtonDeltaState.Pressed) != 0) { eventData.eligibleForClick = true; eventData.delta = Vector2.zero; eventData.dragging = false; eventData.pressPosition = eventData.position; eventData.pointerPressRaycast = eventData.pointerCurrentRaycast; var selectHandlerGO = ExecuteEvents.GetEventHandler <ISelectHandler>(currentOverGo); // If we have clicked something new, deselect the old thing // and leave 'selection handling' up to the press event. if (selectHandlerGO != eventSystem.currentSelectedGameObject) { eventSystem.SetSelectedGameObject(null, 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); // We didn't find a press handler, so we search for a click handler. if (newPressed == null) { newPressed = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo); } var time = Time.unscaledTime; if (newPressed == eventData.lastPress && ((time - eventData.clickTime) < clickSpeed)) { ++eventData.clickCount; } else { eventData.clickCount = 1; } eventData.clickTime = time; eventData.pointerPress = newPressed; eventData.rawPointerPress = currentOverGo; // Save the drag handler for drag events during this mouse down. eventData.pointerDrag = ExecuteEvents.GetEventHandler <IDragHandler>(currentOverGo); if (eventData.pointerDrag != null) { ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.initializePotentialDrag); } } if ((mouseButtonChanges & ButtonDeltaState.Released) != 0) { ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerUpHandler); var pointerUpHandler = ExecuteEvents.GetEventHandler <IPointerClickHandler>(currentOverGo); if (eventData.pointerPress == pointerUpHandler && eventData.eligibleForClick) { ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerClickHandler); } else if (eventData.dragging && eventData.pointerDrag != null) { ExecuteEvents.ExecuteHierarchy(currentOverGo, eventData, ExecuteEvents.dropHandler); ExecuteEvents.Execute(eventData.pointerDrag, eventData, ExecuteEvents.endDragHandler); } eventData.eligibleForClick = eventData.dragging = false; eventData.pointerPress = eventData.rawPointerPress = eventData.pointerDrag = null; } }
private static void Execute(IPointer3DPressEnterHandler handler, BaseEventData eventData) { handler.OnPointer3DPressEnter(ExecuteEvents.ValidateEventData <Pointer3DEventData>(eventData)); }
/// <summary> /// Takes an existing JoystickModel and dispatches all relevant changes through the event system. /// It also updates the internal data of the JoystickModel. /// </summary> /// <param name="joystickState">The joystick state you want to forward into the UI Event System</param> internal void ProcessJoystick(ref JoystickModel joystickState) { var internalJoystickState = joystickState.internalData; var usedSelectionChange = false; if (eventSystem.currentSelectedGameObject != null) { var data = GetBaseEventData(); ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.updateSelectedHandler); usedSelectionChange = data.used; } // Don't send move events if disabled in the EventSystem. if (!eventSystem.sendNavigationEvents) { return; } var movement = joystickState.move; if (!usedSelectionChange && (!Mathf.Approximately(movement.x, 0f) || !Mathf.Approximately(movement.y, 0f))) { float time = Time.unscaledTime; var moveVector = joystickState.move; var moveDirection = MoveDirection.None; if (moveVector.sqrMagnitude > moveDeadzone * moveDeadzone) { if (Mathf.Abs(moveVector.x) > Mathf.Abs(moveVector.y)) { moveDirection = (moveVector.x > 0) ? MoveDirection.Right : MoveDirection.Left; } else { moveDirection = (moveVector.y > 0) ? MoveDirection.Up : MoveDirection.Down; } } if (moveDirection != internalJoystickState.lastMoveDirection) { internalJoystickState.consecutiveMoveCount = 0; } if (moveDirection != MoveDirection.None) { bool allow = true; if (internalJoystickState.consecutiveMoveCount != 0) { if (internalJoystickState.consecutiveMoveCount > 1) { allow = (time > (internalJoystickState.lastMoveTime + repeatRate)); } else { allow = (time > (internalJoystickState.lastMoveTime + repeatDelay)); } } if (allow) { var eventData = GetOrCreateCachedAxisEvent(); eventData.Reset(); eventData.moveVector = moveVector; eventData.moveDir = moveDirection; ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, eventData, ExecuteEvents.moveHandler); usedSelectionChange = eventData.used; internalJoystickState.consecutiveMoveCount = internalJoystickState.consecutiveMoveCount + 1; internalJoystickState.lastMoveTime = time; internalJoystickState.lastMoveDirection = moveDirection; } } else { internalJoystickState.consecutiveMoveCount = 0; } } else { internalJoystickState.consecutiveMoveCount = 0; } if (!usedSelectionChange) { if (eventSystem.currentSelectedGameObject != null) { var data = GetBaseEventData(); if ((joystickState.submitButtonDelta & ButtonDeltaState.Pressed) != 0) { ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.submitHandler); } if (!data.used && (joystickState.cancelButtonDelta & ButtonDeltaState.Pressed) != 0) { ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, data, ExecuteEvents.cancelHandler); } } } joystickState.internalData = internalJoystickState; joystickState.OnFrameFinished(); }
// Update is called once per frame void Update() { var pointer = new PointerEventData(eventSystem); // pointer event for Execute // When TAB is pressed, we should select the next selectable UI element if (Input.GetKeyDown(KeyCode.Tab)) { Selectable next = null; Selectable current = null; // Figure out if we have a valid current selected gameobject if (eventSystem.currentSelectedGameObject != null) { // Unity doesn't seem to "deselect" an object that is made inactive if (eventSystem.currentSelectedGameObject.activeInHierarchy) { current = eventSystem.currentSelectedGameObject.GetComponent <Selectable>(); } } if (current != null) { // When SHIFT is held along with tab, go backwards instead of forwards if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift)) { next = current.FindSelectableOnLeft(); if (next == null) { next = current.FindSelectableOnUp(); } } else { next = current.FindSelectableOnRight(); if (next == null) { next = current.FindSelectableOnDown(); } } } else { // If there is no current selected gameobject, select the first one if (Selectable.allSelectables.Count > 0) { next = Selectable.allSelectables[0]; } } if (next != null) { next.Select(); } } if (Input.GetKeyDown(KeyCode.Return)) { string focusedControl = MessageText.gameObject.name; if (String.IsNullOrEmpty(eventSystem.currentSelectedGameObject.name)) { focusedControl = eventSystem.currentSelectedGameObject.name; } Debug.Log("Looking for RETURN Pressed on " + MessageText.name + "!"); Debug.Log("RETURN Pressed on " + focusedControl + "!"); if (focusedControl == MessageText.name) { Debug.Log(focusedControl + " matched " + MessageText.name + "!"); ExecuteEvents.Execute(MessageSend.gameObject, pointer, ExecuteEvents.submitHandler); // Return the selection to the chat window. eventSystem.SetSelectedGameObject(MessageText.gameObject, pointer); ExecuteEvents.Execute(MessageText.gameObject, pointer, ExecuteEvents.selectHandler); } } }
private static void Execute(IColliderEventDropHandler handler, BaseEventData eventData) { handler.OnColliderEventDrop(ExecuteEvents.ValidateEventData <ColliderButtonEventData>(eventData)); }
/// <summary> /// 点击引导对象 /// </summary> /// <param name="guide_step"></param> /// <param name="target">要引导的对象</param> public void GuideClick(Guide.Step guide_step, GameObject target) { CleanupLastGuide(); if (target == null) { return; } if (guide_step == null) { return; } m_GuideStep = guide_step; if (m_GuideObject != null) { m_GuideObject.Cleanup(); m_GuideObject = null; } var guide_obj = new GuideGameObject(this, target); m_GuideObject = guide_obj; if (!m_GuideStep.IsForcible) { // 非强制时监听其点击事件 SetupTargetClickEventListener(guide_obj.TargetObject, m_GuideStep.ClickAny, OnClickTarget); } else { guide_obj.CopyTargetObj(); if (target != null) { string hide_widget = m_GuideStep.HideWidget; if (string.IsNullOrEmpty(hide_widget) == false) { if (target.name == hide_widget) { mHideWidgetTransform = target.transform; } else { mHideWidgetTransform = UIHelper.FindChildInHierarchy(target.transform, hide_widget); } if (mHideWidgetTransform != null) { HideWidget(mHideWidgetTransform.gameObject, true); } } } GameObject listen_object = guide_obj.CopyObj != null ? guide_obj.CopyObj : guide_obj.TargetObject; SetupGenericEventListener(listen_object, (click_obj) => { if (m_GuideStep == null || mUIObject == null) { return; } if ((guide_obj.CopyObj != null && click_obj == guide_obj.CopyObj) || (guide_obj.CopyObj == null && click_obj == guide_obj.TargetObject)) { if (guide_obj.TargetObject == null) { Close(); return; } // 执行guide_obj.TargetObject的点击事件 if (guide_step.EventType == 1) { ExecuteEvents.Execute <IPointerClickHandler>(guide_obj.TargetObject, new PointerEventData(EventSystem.current), ExecuteEvents.pointerClickHandler); } else { ExecuteEvents.Execute <IPointerDownHandler>(guide_obj.TargetObject, new PointerEventData(EventSystem.current), ExecuteEvents.pointerDownHandler); ExecuteEvents.Execute <IPointerUpHandler>(guide_obj.TargetObject, new PointerEventData(EventSystem.current), ExecuteEvents.pointerUpHandler); } if (mHideWidgetTransform != null) { HideWidget(mHideWidgetTransform.gameObject, false); } if (click_obj != null) { var event_listen = EventTriggerListener.GetListener(click_obj); event_listen.onPointerClick -= OnClick; } if (m_GuideStep != null && m_GuideStep.TargetTrigger != null) { m_GuideStep.TargetTrigger.NotifyClick(); } else { Close(); } } }); } //Debug.Log("GuideClick" + guide_step.GuideId + " " + guide_step.StepId); SetupMask(); UpdateArrowTips(); StartUpdateTimer(); TryPlayVoice(); }
private static void Execute(IColliderEventHoverEnterHandler handler, BaseEventData eventData) { handler.OnColliderEventHoverEnter(ExecuteEvents.ValidateEventData <ColliderHoverEventData>(eventData)); }
protected bool CanExecute <Event>(GameObject go) where Event : IEventSystemHandler { return(ExecuteEvents.CanHandleEvent <Event>(go)); }
/// <inheritdoc /> public virtual void HandleEvent <T>(BaseEventData eventData, ExecuteEvents.EventFunction <T> eventHandler) where T : IEventSystemHandler { Debug.Assert(!eventData.used); eventExecutionDepth++; // This sends the event to every component that implements the corresponding event handling interface, // regardless of whether it was the one registering the object as global listener or not. // This behavior is kept for backwards compatibility. Will be removed together with the IMixedRealityEventSystem.Register(GameObject listener) interface. for (int i = EventListeners.Count - 1; i >= 0; i--) { // Ensure client code does not put the event dispatch system into a bad state. // Note that ExecuteEvents.Execute internally safeguards against exceptions, but // this is another layer to ensure that nothing below this layer can affect the state // of our eventExecutionDepth tracker. try { ExecuteEvents.Execute(EventListeners[i], eventData, eventHandler); } catch (Exception ex) { Debug.LogException(ex); } } // Send events to all handlers registered via RegisterHandler API. List <EventHandlerEntry> handlers; if (EventHandlersByType.TryGetValue(typeof(T), out handlers)) { for (int i = handlers.Count - 1; i >= 0; i--) { var handlerEntry = handlers[i]; // If handler's parent is in object collection (traversed above), it has already received an event. if (handlerEntry.parentObjectIsInObjectCollection) { continue; } // Ensure client code does not put the event dispatch system into a bad state. try { eventHandler.Invoke((T)handlerEntry.handler, eventData); } catch (Exception ex) { Debug.LogException(ex); } } } eventExecutionDepth--; if (eventExecutionDepth == 0 && (postponedActions.Count > 0 || postponedObjectActions.Count > 0)) { foreach (var handler in postponedActions) { if (handler.Item1 == Action.Add) { AddHandlerToMap(handler.Item2, handler.Item3); } else if (handler.Item1 == Action.Remove) { RemoveHandlerFromMap(handler.Item2, handler.Item3); } } foreach (var obj in postponedObjectActions) { if (obj.Item1 == Action.Add) { // Can call it here, because guaranteed that eventExecutionDepth is 0 Register(obj.Item2); } else if (obj.Item1 == Action.Remove) { Unregister(obj.Item2); } } postponedActions.Clear(); postponedObjectActions.Clear(); } }
protected void ExecuteEvent <T, EventData>(GameObject go, EventData baseEventData, ExecuteEvents.EventFunction <T> eventFunction) where T : IEventSystemHandler where EventData : BaseEventData { ExecuteEvents.ExecuteHierarchy(go, baseEventData, eventFunction); }
void ExecuteGlobalButtonDown(int button) { //Get a copied list of the global receivers, when the button is pressed. buttonReceivers[button] = GlobalReceiver.GetCopyOfInstances(); if (buttonReceivers[button].Count == 0) { return; } switch (button) { case ButtonConstants.A: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteAPressDownHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalAPressDown(eventData)); } } break; case ButtonConstants.B: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteBPressDownHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalBPressDown(eventData)); } } break; case ButtonConstants.LEFT: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteLeftPressDownHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalLeftPressDown(eventData)); } } break; case ButtonConstants.RIGHT: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteRightPressDownHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalRightPressDown(eventData)); } } break; case ButtonConstants.UP: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteUpPressDownHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalUpPressDown(eventData)); } } break; case ButtonConstants.DOWN: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteDownPressDownHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalDownPressDown(eventData)); } } break; case ButtonConstants.PLUS: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMotePlusPressDownHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalPlusPressDown(eventData)); } } break; case ButtonConstants.MINUS: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteMinusPressDownHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalMinusPressDown(eventData)); } } break; case ButtonConstants.ONE: foreach (GlobalReceiver w in buttonReceivers[button]) { if (!w.module || w.module.Equals(this)) { ExecuteEvents.Execute <IGlobalWiiMoteOnePressDownHandler>(w.gameObject, eventData, (x, y) => x.OnGlobalOnePressDown(eventData)); } } break; } }
void OnGUI() { // activate correct button when key is pressed Event e = Event.current; if (e.isKey && e.keyCode != KeyCode.None) { //Debug.Log("Key code: " + e.keyCode); if (keyCodeToKey.ContainsKey(e.keyCode)) { Key key = keyCodeToKey[e.keyCode]; GameObject b = key.button; //Debug.Log(b.name); //b.GetComponent<Button>().Select(); // send pointer down/up events to button var pointerEvent = new PointerEventData(EventSystem.current); #if UNITY_2017_2_OR_NEWER if (e.type == EventType.KeyDown) #else if (e.type == EventType.KeyDown) #endif { //Debug.Log("key down: " + e.keyCode); ExecuteEvents.Execute(b, pointerEvent, ExecuteEvents.pointerEnterHandler); ExecuteEvents.Execute(b, pointerEvent, ExecuteEvents.pointerDownHandler); ButtonPressed(key); if (!key.pressed) { // move key down b.transform.position += keyTranslation; key.pressed = true; } } #if UNITY_2017_2_OR_NEWER if (e.type == EventType.KeyUp) #else if (e.type == EventType.KeyUp) #endif { //Debug.Log("key up: " + e.keyCode); ExecuteEvents.Execute(b, pointerEvent, ExecuteEvents.pointerUpHandler); ExecuteEvents.Execute(b, pointerEvent, ExecuteEvents.pointerExitHandler); b.transform.position -= keyTranslation; key.pressed = false; } } } // caps lock is true while caps lock key is pressed if (e.capsLock && !prevCapsLock) { capsLock = !capsLock; //Debug.Log("capsLock = " + capsLock); SetCapsShift(capsLock); } prevCapsLock = e.capsLock; // handle shift key if (e.shift) { if (!capsShift) { capsShift = true; //Debug.Log("shift down"); SetCapsShift(capsLock ? false : true); } } else { if (capsShift) { capsShift = false; //Debug.Log("shift up"); SetCapsShift(capsLock ? true : false); } } }
private void ProcessMouseEventForPC() { if (m_Disable == true) { return; } //---------------------------------- MouseState mouseData = GetMousePointerEventData(); bool pressed = mouseData.AnyPressesThisFrame(); bool released = mouseData.AnyReleasesThisFrame(); MouseButtonEventData leftButtonData = mouseData.GetButtonState(PointerEventData.InputButton.Left).eventData; if (leftButtonData.PressedThisFrame() == true) { m_LastPress = leftButtonData.buttonData.pointerCurrentRaycast.gameObject; // Debug.LogWarning( "LastPress設定:" + m_LastPress ) ; } //レイキャスト消失により Relese 状態になった場合の対応 bool isPressed = Input.GetMouseButton(0); if (isPressed != m_IsPressed) { // if( isPressed == false ) // { // Debug.LogWarning( "直判定で離された:" + leftButtonData.buttonState ) ; // } if (released == false && isPressed == false) { released = true; if (leftButtonData.buttonState == PointerEventData.FramePressState.NotChanged) { leftButtonData.buttonState = PointerEventData.FramePressState.Released; // Debug.LogWarning( "LastPress:" + m_LastPress ) ; leftButtonData.buttonData.pointerPress = m_LastPress; m_LastPress = null; } } m_IsPressed = isPressed; } // マウスオーバーに関してはマウスが動いていなくても取りたい ProcessHoverForPC(leftButtonData.buttonData); if (UseMouseForPC(pressed, released, leftButtonData.buttonData) == false) { // 何のイベントも無い 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) == false) { GameObject scrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(leftButtonData.buttonData.pointerCurrentRaycast.gameObject); ExecuteEvents.ExecuteHierarchy(scrollHandler, leftButtonData.buttonData, ExecuteEvents.scrollHandler); } }
private void ProcessMouseMovement(PointerEventData eventData) { var currentPointerTarget = eventData.pointerCurrentRaycast.gameObject; // If we have no target or pointerEnter has been deleted, // we just send exit events to anything we are tracking // and then exit. if (currentPointerTarget == null || eventData.pointerEnter == null) { for (var i = 0; i < eventData.hovered.Count; ++i) { ExecuteEvents.Execute(eventData.hovered[i], eventData, ExecuteEvents.pointerExitHandler); } eventData.hovered.Clear(); if (currentPointerTarget == null) { eventData.pointerEnter = null; return; } } if (eventData.pointerEnter == currentPointerTarget && currentPointerTarget) { return; } var commonRoot = FindCommonRoot(eventData.pointerEnter, currentPointerTarget); // We walk up the tree until a common root and the last entered and current entered object is found. // Then send exit and enter events up to, but not including, the common root. if (eventData.pointerEnter != null) { var t = eventData.pointerEnter.transform; while (t != null) { if (commonRoot != null && commonRoot.transform == t) { break; } ExecuteEvents.Execute(t.gameObject, eventData, ExecuteEvents.pointerExitHandler); eventData.hovered.Remove(t.gameObject); t = t.parent; } } eventData.pointerEnter = currentPointerTarget; if (currentPointerTarget != null) { var t = currentPointerTarget.transform; while (t != null && t.gameObject != commonRoot) { ExecuteEvents.Execute(t.gameObject, eventData, ExecuteEvents.pointerEnterHandler); eventData.hovered.Add(t.gameObject); t = t.parent; } } }
//----------------------------------------------------------- // XR用 private void ProcessForXR() { // 選択中のオブジェクトの状態を更新する SendUpdateEventToSelectedObject(); // デフォルトのものを使用する // レイキャストでヒットしたUIの情報を取得する(VR限定) PointerEventData tLookData = GetLookPointerEventData(UnityEngine.XR.XRSettings.eyeTextureWidth / 2, UnityEngine.XR.XRSettings.eyeTextureHeight / 2); m_CurrentLook = tLookData.pointerCurrentRaycast.gameObject; // deselect when look away if (m_CurrentLook == null) { // 選択中のUIを非選択状態にする ClearSelection(); } // UIの領域に入ったまたは出た際の処理を実行する HandlePointerExitAndEnter(tLookData, m_CurrentLook); //---------------------------------- bool tIsPressAction = false; if (m_OnPressAction != null) { // アクションボタン指定あり tIsPressAction = m_OnPressAction(m_CurrentLook); } //---------------------------------- // 押された判定 bool tDown = false; if (m_OnPressAction == null) { if (Input.GetMouseButtonDown(0) == true) { tDown = true; } } else { if (m_IsPressAction == false && tIsPressAction == true) { m_IsPressAction = true; tDown = true; } } if (m_CurrentLook != null) { // UIの上にある //--------------------------------- if (tDown == true) { // 押された // 選択中のUIの表示を非選択状態に戻す ClearSelection(); tLookData.pressPosition = tLookData.position; tLookData.pointerPressRaycast = tLookData.pointerCurrentRaycast; tLookData.pointerPress = null; // プレス判定 m_CurrentPressed = ExecuteEvents.ExecuteHierarchy(m_CurrentLook, tLookData, ExecuteEvents.pointerDownHandler); if (m_CurrentPressed != null) { // 階層上にプレスに反応するものがある // 新規プレス tLookData.pointerPress = m_CurrentPressed; // 表示状態を変更する ClearSelection(); // 古い方の状態を解除 // フォーカスを当てられるか判定する if (ExecuteEvents.GetEventHandler <ISelectHandler>(m_CurrentPressed) != null) { // フォーカスをあてる eventSystem.SetSelectedGameObject(m_CurrentPressed); } } // ドラッグ開始 ExecuteEvents.Execute(m_CurrentPressed, tLookData, ExecuteEvents.beginDragHandler); tLookData.pointerDrag = m_CurrentPressed; m_CurrentDragging = m_CurrentPressed; } } //---------------------------------------------------------- // 離された判定 bool tUp = false; if (m_OnPressAction == null) { if (Input.GetMouseButtonUp(0) == true) { tUp = true; } } else { if (m_IsPressAction == true && tIsPressAction == false) { m_IsPressAction = false; tUp = true; } } //---------------------------------- if (tUp == true) { // 離された if (m_CurrentDragging != null) { // ドラッグ中ならドラッグを終了する // ドラッグ終了 ExecuteEvents.Execute(m_CurrentDragging, tLookData, ExecuteEvents.endDragHandler); if (m_CurrentLook != null) { // ドロップ実行 ExecuteEvents.ExecuteHierarchy(m_CurrentLook, tLookData, ExecuteEvents.dropHandler); } tLookData.pointerDrag = null; m_CurrentDragging = null; } if (m_CurrentPressed != null) { // プレス中ならプレスを終了する // プレス終了 ExecuteEvents.Execute(m_CurrentPressed, tLookData, ExecuteEvents.pointerUpHandler); tLookData.rawPointerPress = null; tLookData.pointerPress = null; if (m_CurrentLook != null) { // クリックを判定する if (ExecuteEvents.GetEventHandler <IPointerDownHandler>(m_CurrentLook) == m_CurrentPressed) { // クリックされた ExecuteEvents.Execute(m_CurrentPressed, tLookData, ExecuteEvents.pointerClickHandler); } } m_CurrentPressed = null; } } // drag handling if (m_CurrentDragging != null) { // ドラッグ実行 ExecuteEvents.Execute(m_CurrentDragging, tLookData, ExecuteEvents.dragHandler); } //---------------------------------------------------------- if (m_CurrentLook != null) { // 方向キー操作 if (eventSystem.currentSelectedGameObject != null && string.IsNullOrEmpty(horizontalAxis) == false) { float tNewValue = Input.GetAxis(horizontalAxis); if (tNewValue > 0.01f || tNewValue < -0.01f) { if (useSmoothAxis == true) { // スムース動作有効 Slider sl = eventSystem.currentSelectedGameObject.GetComponent <Slider>(); if (sl != null) { // 対象はスライダー float tMulti = sl.maxValue - sl.minValue; sl.value += tNewValue * smoothAxisMultiplier * tMulti; } else { Scrollbar sb = eventSystem.currentSelectedGameObject.GetComponent <Scrollbar>(); if (sb != null) { // 対象はスクロールバー sb.value += tNewValue * smoothAxisMultiplier; } ScrollbarWrapper sbw = eventSystem.currentSelectedGameObject.GetComponent <ScrollbarWrapper>(); if (sbw != null) { // 対象はスクロールバー sbw.value += tNewValue * smoothAxisMultiplier; } } } else { // スムース動作はしない float tTime = Time.unscaledTime; if (tTime > m_NextAxisActionTime) { m_NextAxisActionTime = tTime + (1f / inputActionsPerSecond); AxisEventData tAxisData = GetAxisEventData(tNewValue, 0.0f, 0.0f); if (ExecuteEvents.Execute(eventSystem.currentSelectedGameObject, tAxisData, ExecuteEvents.moveHandler) == false) { } } } } } } }
private void HideDifferentCards() { firstCardRevealed.GetComponent <CardBehaviour>().HideCard(); secondCardRevealed.GetComponent <CardBehaviour>().HideCard(); ExecuteEvents.Execute <IScoreEventHandler>(gameObject, null, (x, y) => x.Score(false)); }