protected PointerEvent CreatePointerEvent(PointerState state, Vector2 position)
{
if (state == PointerState.Down)
{
lastTouchPosition = position;
}
var pointerEvent = new PointerEvent(0, position, position - lastTouchPosition, new TimeSpan(), state, PointerType.Touch, true);
lastTouchPosition = position;
return(pointerEvent);
}
void _routePointer(PointerEvent pEvent)
{
if (this.widget.maxSimultaneousDrags != null &&
this._activeCount >= this.widget.maxSimultaneousDrags)
{
return;
}
if (pEvent is PointerDownEvent)
{
this._recognizer.addPointer((PointerDownEvent)pEvent);
}
}
private void OnPointerReleased(PointerEvent ev)
{
if (isDragInProgress)
{
Cursor.Show();
Cursor.ClipDisable();
}
isButtonHeld = false;
isDragInProgress = false;
guiCurveEditor.OnPointerReleased(ev);
}
void _handlePointerEvent(PointerEvent pEvent)
{
D.assert(this._entry != null);
if (pEvent is PointerUpEvent || pEvent is PointerCancelEvent)
{
this._timer = this._timer ?? Window.instance.run(TooltipUtils._kShowDuration,
() => this._controller.reverse());
}
else if (pEvent is PointerDownEvent)
{
this._controller.reverse();
}
}
/// <summary>
/// Handles input. Should be called by the owning window whenever a pointer is released.
/// </summary>
/// <param name="ev">Object containing pointer release event information.</param>
internal void OnPointerReleased(PointerEvent ev)
{
if (isModifiedDuringDrag)
{
OnCurveModified?.Invoke();
}
isPointerHeld = false;
isDragInProgress = false;
isMousePressedOverKey = false;
isMousePressedOverTangent = false;
isModifiedDuringDrag = false;
}
void OnSelectionChanged(PointerEvent.OnSelectionChanged eventData)
{
// find selected color
if (eventData.isSelected) {
if (targetType == -1) {
targetType = eventData.targetObject.GetComponent<Selectable> ().type;
}
} else {
targetType = -1;
}
// check if tile has valid selection (wasn't already selected, is not being animated, has the same type as the others selected before, and is adjacent to the last selected)
if (eventData.targetObject) {
Selectable selectable = eventData.targetObject.GetComponent<Selectable> ();
if (eventData.isSelected) {
if (IsSelectionValid (eventData.targetObject)) {
selectable.isSelected = eventData.isSelected;
GameObject highlight = eventData.targetObject.transform.FindChild ("Selection").gameObject;
highlight.SetActive (selectable.isSelected);
selectedObjects.AddLast (eventData.targetObject);
lineRenderer.SetVertexCount(selectedObjects.Count);
lineRenderer.SetPosition (selectedObjects.Count - 1, selectedObjects.Last.Value.GetComponent<RectTransform> ().localPosition - new Vector3 (0, canvasSize.sizeDelta.y / 2, 0));
}
}
} else {
// deselect all tiles and check which need to be destroyed
foreach (GameObject selectedObject in selectedObjects) {
Selectable selectable = selectedObject.GetComponent<Selectable> ();
if (selectable.isSelected) {
selectable.isSelected = eventData.isSelected;
GameObject highlight = selectedObject.transform.FindChild ("Selection").gameObject;
highlight.SetActive (selectable.isSelected);
if (CanDestroy ()) {
selectable.MarkTileToDestroy ();
}
}
}
if (CanDestroy ()) {
eventBus.Publish(new PointerEvent.OnPointerFinished());
eventBus.Publish(new ScoreEvent.OnScoring(selectedObjects.Count));
}
selectedObjects.Clear ();
lineRenderer.SetVertexCount (0);
}
}
public void Init(JoyLandlordsCard joyLandlordsCard)
{
mJoyLandlordsCard = joyLandlordsCard;
mPointerEvent = mJoyLandlordsCard.gameObject.AddComponent <PointerEvent>();
//注册事件委托
mPointerEvent.OnPointerDownAction -= OnPointerDown;
mPointerEvent.OnPointerUpAction -= OnPointerUp;
mPointerEvent.OnPointerEnterAction -= OnPointerEnter;
mPointerEvent.OnPointerDownAction += OnPointerDown;
mPointerEvent.OnPointerUpAction += OnPointerUp;
mPointerEvent.OnPointerEnterAction += OnPointerEnter;
mPointerEvent.OnPointerExitAction -= OnPointerExit;
mPointerEvent.OnPointerExitAction += OnPointerExit;
}
void _onPointerHover(PointerEvent evt)
{
this._layoutTextWithConstraints(this.constraints);
Offset offset = this.globalToLocal(evt.position);
TextPosition position = this._textPainter.getPositionForOffset(offset);
TextSpan span = this._textPainter.text.getSpanForPosition(position);
if (this._previousHoverSpan != span)
{
this._previousHoverSpan?.hoverRecognizer?.OnPointerLeave?.Invoke();
span?.hoverRecognizer?.OnPointerEnter?.Invoke((PointerHoverEvent)evt);
this._previousHoverSpan = span;
}
}
public override void handleEvent(PointerEvent evt, HitTestEntry entry)
{
D.assert(this.debugHandleEvent(evt, entry));
if (!(evt is PointerDownEvent))
{
return;
}
this._layoutTextWithConstraints(this.constraints);
Offset offset = ((BoxHitTestEntry)entry).localPosition;
TextPosition position = this._textPainter.getPositionForOffset(offset);
TextSpan span = this._textPainter.text.getSpanForPosition(position);
span?.recognizer?.addPointer((PointerDownEvent)evt);
}
public UIEvents()
{
PointerEntered = new PointerEvent();
PointerExited = new PointerEvent();
PointerClicked = new PointerEvent();
PointerDown = new PointerEvent();
PointerOver = new PointerEvent();
PointerUp = new PointerEvent();
PointerDragged = new PointerEvent();
BeginDrag = new PointerEvent();
Drag = new PointerEvent();
EndDrag = new PointerEvent();
Drop = new PointerEvent();
}
public async ValueTask<PointerEvent> get_event()
{
if(__event == null)
{
__event = await EventHorizonBlazorInterop.GetClass<PointerEvent>(
this.___guid,
"event",
(entity) =>
{
return new PointerEvent() { ___guid = entity.___guid };
}
);
}
return __event;
}
void _handlePointerEvent(PointerEvent pEvent)
{
if (_entry == null)
{
return;
}
if (pEvent is PointerUpEvent || pEvent is PointerCancelEvent)
{
_hideTooltip();
}
else if (pEvent is PointerDownEvent)
{
_hideTooltip(immediately: true);
}
}
public override void handleEvent(PointerEvent evt, HitTestEntry entry)
{
if (this.ignorePointer)
{
return;
}
D.assert(this.debugHandleEvent(evt, entry));
if (evt is PointerDownEvent && this.onSelectionChanged != null)
{
this._tap.addPointer((PointerDownEvent)evt);
this._doubleTap.addPointer((PointerDownEvent)evt);
this._longPress.addPointer((PointerDownEvent)evt);
}
}
private void OnPointerPressed(PointerEvent ev)
{
guiCurveEditor.OnPointerPressed(ev);
if (ev.button == PointerButton.Middle)
{
Vector2I windowPos = ScreenToWindowPos(ev.ScreenPos);
Vector2 curvePos;
if (guiCurveEditor.WindowToCurveSpace(windowPos, out curvePos))
{
dragStartPos = windowPos;
isButtonHeld = true;
}
}
}
void _handlePointerScroll(PointerEvent e)
{
D.assert(e is PointerScrollEvent);
if (_physics != null && !_physics.shouldAcceptUserOffset(position))
{
return;
}
float targetScrollOffset = _targetScrollOffsetForPointerScroll(e as PointerScrollEvent);
if (targetScrollOffset != position.pixels)
{
position.jumpTo(targetScrollOffset);
}
}
//----------------------------------------------------------
#region プライベート関数
//----------------------------------------------------------
private static void createMouseEvent(out PointerEvent e, int button, int id, ref Vector2 mousePos, ref PointerEvent?prev)
{
var phase = PointerEvent.EPhase.Began;
if (prev.HasValue)
{
phase = (prev.Value.ScreenX == mousePos.x && prev.Value.ScreenY == mousePos.y)
? PointerEvent.EPhase.Stationary
: PointerEvent.EPhase.Moved;
}
if (Input.GetMouseButtonUp(button))
{
phase = PointerEvent.EPhase.Ended;
}
e = new PointerEvent(id, (int)mousePos.x, (int)mousePos.y, phase, PointerEvent.EType.Others);
}
private void Update()
{
if (pointer.highlightedObject != null && pointer.highlightedObject.GetComponent <PointerEvent>() != null)
{
pointerEvent = pointer.highlightedObject.GetComponent <PointerEvent>();
// Invoke alls the event function here
// Heck PointerEventSystem and PointerEvent for more information
pointerEvent.onHoverEvent.Invoke(pointer);
Animator anim = pointer.highlightedObject.GetComponent <Animator>();
if (_highlightedObject == null && anim.GetCurrentAnimatorStateInfo(0).normalizedTime > 1 && !anim.IsInTransition(0))
{
Transform highlightedTransform = pointer.highlightedObject.transform;
//setting up highlight object
_highlightedObject = Instantiate(pointer.highlightedObject, highlightedTransform.position, highlightedTransform.rotation);
Destroy(_highlightedObject.GetComponent <Animator>());
_highlightedObject.transform.parent = highlightedTransform;
_highlightedObject.layer = 2; //make it ignore uiipointer
_highlightedObject.GetComponent <MeshRenderer>().material = HoverMat;
}
if (activateAnimationButton.GetStateDown(hand))
{
pointerEvent.OnClickEvent.Invoke(pointer);
Destroy(_highlightedObject);
}
}
else
{
// resetting values
if (pointerEvent != null)
{
pointerEvent.OnExitEvent.Invoke(pointer);
pointerEvent = null;
}
if (_highlightedObject != null)
{
Destroy(_highlightedObject);
}
}
}
//----------------------------------------------------------
#region プライベート関数
//----------------------------------------------------------
private static void createMouseEvent(out PointerEvent e, int button, int id, ref Vector2 mousePos, ref PointerEvent?prev)
{
var phase = PointerEvent.EPhase.Began;
if (prev.HasValue)
{
var v = prev.Value;
phase = (v.Phase == PointerEvent.EPhase.Ended)
? PointerEvent.EPhase.Began : (Mathf.Approximately(v.ScreenX, mousePos.x) && Mathf.Approximately(v.ScreenY, mousePos.y))
? PointerEvent.EPhase.Stationary
: PointerEvent.EPhase.Moved;
}
if (Input.GetMouseButtonUp(button))
{
phase = PointerEvent.EPhase.Ended;
}
e = new PointerEvent(id, (int)mousePos.x, (int)mousePos.y, phase, PointerEvent.EType.Others);
}
internal override S find <S>(Offset regionOffset)
{
if (this._inverseDirty)
{
this._invertedTransform = Matrix4.tryInvert(
PointerEvent.removePerspectiveTransform(this.transform)
);
this._inverseDirty = false;
}
if (this._invertedTransform == null)
{
return(null);
}
Vector4 vector = new Vector4(regionOffset.dx, regionOffset.dy, 0, 1);
Vector4 result = this._invertedTransform.transform(vector);
return(base.find <S>(new Offset(result[0], result[1])));
}
// Clean up this event listener and detach events.
public void Dispose()
{
if (PointerDown != null)
{
PointerDown.RemoveAllListeners();
PointerDown = null;
}
if (PointerUp != null)
{
PointerUp.RemoveAllListeners();
PointerUp = null;
}
if (PointerClick != null)
{
PointerClick.RemoveAllListeners();
PointerClick = null;
}
if (Drag != null)
{
Drag.RemoveAllListeners();
Drag = null;
}
if (BeginDrag != null)
{
BeginDrag.RemoveAllListeners();
BeginDrag = null;
}
if (EndDrag != null)
{
EndDrag.RemoveAllListeners();
EndDrag = null;
}
if (Scroll != null)
{
Scroll.RemoveAllListeners();
Scroll = null;
}
if (Pinch != null)
{
Pinch.RemoveAllListeners();
Pinch = null;
}
}
/// <summary>
/// Triggered when the pointer moved.
/// </summary>
/// <param name="ev">Data about the pointer move event.</param>
void Input_OnPointerMoved(PointerEvent ev)
{
Vector2I currentWindowPos = parentWindow.ScreenToWindowPos(ev.ScreenPos);
if (isMouseDown && !isLocalDragInProgress)
{
Vector2I startWindowPos = parentWindow.ScreenToWindowPos(mouseDownScreenPos);
if (!Bounds.Contains(startWindowPos))
{
return;
}
int distance = Vector2I.Distance(startWindowPos, currentWindowPos);
if (distance >= DragStartDistancePx)
{
triggerStartLocalDrag = true;
}
}
}
/// <inheritdoc />
public void Log(Pointer pointer, PointerEvent evt)
{
var path = TransformUtils.GetHeirarchyPath(pointer.GetPressData().Target);
writer.Write((uint)pointer.Type);
writer.Write(eventCount);
writer.Write(DateTime.Now.Ticks);
writer.Write(pointer.Id);
writer.Write((uint)evt);
writer.Write((uint)pointer.Buttons);
writer.Write(pointer.Position.x);
writer.Write(pointer.Position.y);
writer.Write(pointer.PreviousPosition.x);
writer.Write(pointer.PreviousPosition.y);
writer.Write(pointer.Flags);
writer.Write(path ?? "");
eventCount++;
}
public void Update()
{
if (this.m_eventIndex < this.m_events.Count)
{
PointerEvent pointerEvent = this.m_events[this.m_eventIndex];
pointerEvent.Update();
if (pointerEvent.Finished())
{
this.m_eventIndex++;
if (this.m_eventIndex < this.m_events.Count)
{
this.m_events[this.m_eventIndex].Start();
}
else
{
this.m_finished = true;
}
}
}
this.m_pointer.Update();
}
/// <summary>
/// Determine input from a user from Pointer (Touch/Mouse).
/// It analyses the input from a user, and transform it to InputState using in the game, which is then returned.
/// </summary>
/// <returns></returns>
private InputState GetPointerInputState()
{
// Get new state of Pointer (Touch input)
if (Input.PointerEvents.Any())
{
var lastPointer = Input.PointerEvents.Last();
if (lastPointer.EventType == PointerEventType.Pressed)
{
isPointerDown = true;
}
else if (lastPointer.EventType == PointerEventType.Released)
{
isPointerDown = false;
}
pointerState = lastPointer;
}
// If a user does not touch the screen, there is not input
if (!isPointerDown)
{
return(InputState.None);
}
// Transform pointer's position from normorlize coordinate to virtual resolution coordinate
var resolution = new Vector2(GraphicsDevice.Presenter.BackBuffer.Width, GraphicsDevice.Presenter.BackBuffer.Height);
var virtualCoordinatePointerPositionA = resolution.X * (pointerState.Position.X + 0.05f);
var virtualCoordinatePointerPositionB = resolution.X * (pointerState.Position.X - 0.05f);
var virtualX = VirtualCoordToPixel(Entity.Transform.Position.X);
// Check if the touch position is in the x-axis region of the agent's sprite; if so, input is shoot
if (virtualX <= virtualCoordinatePointerPositionA && virtualCoordinatePointerPositionB <= virtualX)
{
return(InputState.Shoot);
}
// Check if a pointer falls left or right of the screen, which would correspond to Run to the left or right respectively
return(((pointerState.Position.X) <= virtualX / resolution.X) ? InputState.RunLeft : InputState.RunRight);
}
public void InitPanel(int clientSeat)
{
if (_HintPanel != null)
{
_HuCardHintPanel = _HintPanel.gameObject.AddItem <DownHuCardHintPanel>();
}
else if (_HintPanelPointGo != null)
{
GameObject hintPanelPrefab = ResourcesComponent.Ins.GetResoure(UIType.FiveStarMingPaiHintPanel, "OtherHintPanel") as GameObject;
GameObject hintPanel = GameObject.Instantiate(hintPanelPrefab, _HintPanelPointGo);
if (clientSeat == 1)
{
hintPanel.GetComponent <RectTransform>().pivot = Vector2.one;
}
_HuCardHintPanel = hintPanel.AddItem <HuCardHintPanel>();
}
PointerEvent _HintBtnPointerEvent = _HintBtn.gameObject.AddComponent <PointerEvent>();
_HintBtnPointerEvent.OnPointerDownAction -= _HuCardHintPanel.Show;
_HintBtnPointerEvent.OnPointerDownAction += _HuCardHintPanel.Show;
_HintBtnPointerEvent.OnPointerUpAction -= _HuCardHintPanel.Hide;
_HintBtnPointerEvent.OnPointerUpAction += _HuCardHintPanel.Hide;
}
void _handlePointerEvent(PointerEvent Event)
{
bool currentInteractionIsTouch = false;
switch (Event.kind)
{
case PointerDeviceKind.touch:
case PointerDeviceKind.stylus:
case PointerDeviceKind.invertedStylus:
currentInteractionIsTouch = true;
break;
case PointerDeviceKind.mouse:
case PointerDeviceKind.unknown:
currentInteractionIsTouch = false;
break;
}
if (_lastInteractionWasTouch != currentInteractionIsTouch)
{
_lastInteractionWasTouch = currentInteractionIsTouch;
_updateHighlightMode();
}
}
public override void handleEvent(PointerEvent evt, HitTestEntry entry)
{
D.assert(debugHandleEvent(evt, entry));
if (!(evt is PointerDownEvent))
{
return;
}
_layoutTextWithConstraints(constraints);
Offset offset = ((BoxHitTestEntry)entry).localPosition;
TextPosition position = _textPainter.getPositionForOffset(offset);
InlineSpan span = _textPainter.text.getSpanForPosition(position);
if (span == null)
{
return;
}
if (span is TextSpan)
{
TextSpan textSpan = (TextSpan)span;
textSpan.recognizer?.addPointer(evt as PointerDownEvent);
}
}
/// <summary>
/// Determine input from a user from Pointer (Touch/Mouse).
/// It analyses the input from a user, and transform it to InputState using in the game, which is then returned.
/// </summary>
/// <returns></returns>
private InputState GetPointerInputState()
{
// Get new state of Pointer (Touch input)
if (Input.PointerEvents.Any())
{
var lastPointer = Input.PointerEvents.Last();
isPointerDown = lastPointer.State != PointerState.Up;
pointerState = lastPointer;
}
// If a user does not touch the screen, there is not input
if (!isPointerDown)
{
return(InputState.None);
}
// Transform pointer's position from normorlize coordinate to virtual resolution coordinate
var resolution = new Vector2(GraphicsDevice.Presenter.BackBuffer.Width, GraphicsDevice.Presenter.BackBuffer.Height);
var virtualCoordinatePointerPosition = resolution * pointerState.Position;
// Get current position of the agent, since the origin of the sprite is at the center, region needs to be shifted to top-left
var agentSize = spriteSheet["idle0"].SizeInPixels;
var agentSpriteRegion = new RectangleF
{
X = (int)VirtualCoordToPixel(Entity.Transform.Position.X) - agentSize.X / 2, Y = (int)VirtualCoordToPixel(Entity.Transform.Position.Y) - agentSize.Y / 2, Width = agentSize.X, Height = agentSize.Y
};
// Check if the touch position is in the x-axis region of the agent's sprite; if so, input is shoot
if (agentSpriteRegion.Left <= virtualCoordinatePointerPosition.X && virtualCoordinatePointerPosition.X <= agentSpriteRegion.Right)
{
return(InputState.Shoot);
}
// Check if a pointer falls left or right of the screen, which would correspond to Run to the left or right respectively
return(((pointerState.Position.X) <= agentSpriteRegion.Center.X / resolution.X) ? InputState.RunLeft : InputState.RunRight);
}
public void SetEvent(PointerEvent ev)
{
this.Event = ev;
}
public void OnBeforeUpdate()
{
if (cIsTouchSupported)
{
mEventNum = Mathf.Min(Input.touchCount, cEventNumMax);
for (var i = 0; i < mEventNum; ++i)
{
var touch = Input.GetTouch(i);
cEvents[i] = new PointerEvent(ref touch);
if (cIsTouchPressureSupported)
{
mPressureMax = Mathf.Max(mPressureMax, touch.maximumPossiblePressure);
}
}
}
else
{
mEventNum = 0;
Vector2 mousePos = Input.mousePosition;
if (Input.GetMouseButton(0) || Input.GetMouseButtonUp(0))
{
var prevEvent = (cPrevEvents[0].Id == cIdMouseButton0)
? (PointerEvent?)cPrevEvents[0]
: null;
createMouseEvent(out cEvents[mEventNum++], 0, cIdMouseButton0, ref mousePos, ref prevEvent);
}
if (Input.GetMouseButton(1) || Input.GetMouseButtonUp(1))
{
var prevEvent = (cPrevEvents[0].Id == cIdMouseButton1)
? (PointerEvent?)cPrevEvents[0] : (cPrevEvents[1].Id == cIdMouseButton1)
? (PointerEvent?)cPrevEvents[1]
: null;
createMouseEvent(out cEvents[mEventNum++], 1, cIdMouseButton1, ref mousePos, ref prevEvent);
}
if (Input.GetMouseButton(2) || Input.GetMouseButtonUp(2))
{
var prevEvent = (cPrevEvents[0].Id == cIdMouseButton2)
? (PointerEvent?)cPrevEvents[0] : (cPrevEvents[1].Id == cIdMouseButton2)
? (PointerEvent?)cPrevEvents[1] : (cPrevEvents[2].Id == cIdMouseButton2)
? (PointerEvent?)cPrevEvents[2]
: null;
createMouseEvent(out cEvents[mEventNum++], 2, cIdMouseButton2, ref mousePos, ref prevEvent);
}
}
if (mEventNum > 0)
{
mLastX = cGraphic.ScreenToCanvasX(cEvents[0].ScreenX);
mLastY = cGraphic.ScreenToCanvasY(cEvents[0].ScreenY);
var currentFrame = UnityEngine.Time.frameCount;
var currentTime = UnityEngine.Time.unscaledTime;
for (var i = 0; i < mEventNum; ++i)
{
var id = cEvents[i].Id;
if (cEvents[i].Phase == PointerEvent.EPhase.Began)
{
cEventFrameCounts[i] = 1;
cEventDulations[i] = 0;
cBeganEventDict.Add(id, cEvents[i]);
continue;
}
if (!cBeganEventDict.ContainsKey(id))
{
Debug.LogWarningFormat("[Pointer] {0} is unknown pointer. phase: {1}", id, cEvents[i].Phase);
continue;
}
cEventFrameCounts[i] = currentFrame - cBeganEventDict[id].Frame + 1;
cEventDulations[i] = currentTime - cBeganEventDict[id].Time;
if (cEvents[i].Phase == PointerEvent.EPhase.Ended)
{
cBeganEventDict.Remove(id);
}
}
}
for (var i = mEventNum; i < cEventNumMax; ++i)
{
cEvents[i] = default(PointerEvent);
}
for (var i = 0; i < cEvents.Length; ++i)
{
cPrevEvents[i] = cEvents[i];
}
}
public void SetEventValue(PointerEvent evt, bool value)
{
pointerEvents[(int)evt] = value;
}
public PointerMessage(int x, int y, PointerEvent msg)
{
X = x;
Y = y;
Message = msg;
}
