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;
}
}
}
//-----------------------------------------------------------
// ＸＲ用
private void ProcessForXR()
{
// 選択中のオブジェクトの状態を更新する
SendUpdateEventToSelectedObject(); // デフォルトのものを使用する
// レイキャストでヒットしたＵＩの情報を取得する(ＶＲ限定)
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)
{
// 選択中のＵＩを非選択状態にする
ClearSelection();
}
// ＵＩの領域に入ったまたは出た際の処理を実行する
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)
{
// ＵＩの上にある
//---------------------------------
if (tDown == true)
{
// 押された
// 選択中のＵＩの表示を非選択状態に戻す
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));
}
