public void HandReleaseDetected(long userId, int userIndex, bool isRightHand, bool isHandInteracting, Vector3 handScreenPos)
{
if (userIndex != playerIndex || !isHandInteracting)
{
return;
}
bool bHandValid = (leftHandInteraction && !isRightHand) || (rightHandInteraction && isRightHand);
if (!bHandValid)
{
return;
}
//Debug.Log("HandReleaseDetected");
m_framePressState = PointerEventData.FramePressState.Released;
//m_isLeftHand = !isRightHand;
m_handCursorPos = handScreenPos;
if (!isRightHand)
{
m_leftHandGrip = false;
}
else
{
m_rightHandGrip = false;
}
}
protected override MouseState GetMousePointerEventData(int id)
{
// Populate the left button...
PointerEventData leftData;
var created = GetPointerData(kMouseLeftId, out leftData, true);
leftData.Reset();
Vector2 handPos = new Vector2(m_screenNormalPos.x * Screen.width, m_screenNormalPos.y * Screen.height);
if (created)
{
leftData.position = handPos;
}
leftData.delta = handPos - leftData.position;
leftData.position = handPos;
//leftData.scrollDelta = 0f;
leftData.button = PointerEventData.InputButton.Left;
eventSystem.RaycastAll(leftData, m_RaycastResultCache);
var raycast = FindFirstRaycast(m_RaycastResultCache);
leftData.pointerCurrentRaycast = raycast;
m_RaycastResultCache.Clear();
m_MouseState.SetButtonState(PointerEventData.InputButton.Left, m_framePressState, leftData);
m_framePressState = PointerEventData.FramePressState.NotChanged;
return(m_MouseState);
}
public void SetButtonState(PointerEventData.InputButton button, PointerEventData.FramePressState stateForMouseButton, PointerEventData data)
{
var toModify = GetButtonState(button);
toModify.eventData.buttonState = stateForMouseButton;
toModify.eventData.buttonData = data;
}
public CursorInput Poll()
{
Ray ray;
if (!_controllerList || _controllerList.ControllerIndices.Count == 0 || _rig == null)
{
ray = new Ray(Vector3.zero, Vector3.down);
}
else
{
ray = new Ray();
}
PointerEventData.FramePressState submitEvent = PointerEventData.FramePressState.NotChanged;
var controllerIndices = _controllerList.ControllerIndices;
if (SteamVR_Controller.Input(controllerIndices[0]).GetPressDown(EVRButtonId.k_EButton_SteamVR_Trigger))
{
submitEvent = PointerEventData.FramePressState.Pressed;
}
else if (SteamVR_Controller.Input(controllerIndices[0]).GetPressUp(EVRButtonId.k_EButton_SteamVR_Trigger))
{
submitEvent = PointerEventData.FramePressState.Released;
}
Vector2 screenPosition = _rig.GetMainCamera().WorldToScreenPoint(ray.origin);
return(new CursorInput(
ray,
screenPosition,
submitEvent: submitEvent,
scrollDelta: Vector2.zero));
}
public void SetButtonState(PointerEventData.InputButton button, PointerEventData.FramePressState stateForMouseButton, PointerEventData data)
{
ButtonState buttonState = GetButtonState(button);
buttonState.eventData.buttonState = stateForMouseButton;
buttonState.eventData.buttonData = data;
}
public CursorInput(Ray ray, Vector2 screenPosition, PointerEventData.FramePressState submitEvent, Vector2 scrollDelta)
{
Ray = ray;
SubmitEvent = submitEvent;
ScrollDelta = scrollDelta;
ScreenPosition = screenPosition;
}
/// <summary>
/// UI专用
/// </summary>
/// <param name="buttonId"></param>
/// <returns></returns>
public static PointerEventData.FramePressState GetStateForMouseButton(int buttonId)
{
var pressed = Instance.InputData.GetMouseButtonDown(buttonId);
var released = Instance.InputData.GetMouseButtonUp(buttonId);
PointerEventData.FramePressState outState = PointerEventData.FramePressState.NotChanged;
if (pressed && released)
{
outState = PointerEventData.FramePressState.PressedAndReleased;
}
else if (pressed)
{
outState = PointerEventData.FramePressState.Pressed;
}
else if (released)
{
outState = PointerEventData.FramePressState.Released;
}
if (Instance.m_LogLevel <= Common.LogLevel.DEBUG)
{
Common.AppLog.AddFormat(Common.LogLevel.DEBUG, "GCInput.GetStateForMouseButton", $"outState={outState.ToString()} curFrameOriginType={Instance.m_curFrameOriginType.ToString()}");
}
return(outState);
}
public static void Postfix(ref PointerEventData.FramePressState __result)
{
if (IsMouseInWindow)
{
__result = PointerEventData.FramePressState.NotChanged;
}
}
public void SetButtonState(
int button,
PointerEventData.FramePressState stateForMouseButton,
PlayerPointerEventData data)
{
RewiredPointerInputModule.ButtonState buttonState = this.GetButtonState(button);
buttonState.eventData.buttonState = stateForMouseButton;
buttonState.eventData.buttonData = data;
}
protected PointerEventData.FramePressState StateForPointer(PointerData pointerData)
{
PointerEventData.FramePressState ret = pointerData.nextPressState;
// Reset state
pointerData.nextPressState = PointerEventData.FramePressState.NotChanged;
return(ret);
}
public void HandReleaseDetected(long userId, int userIndex, bool isRightHand, bool isHandInteracting, Vector3 handScreenPos)
{
if (!isHandInteracting)
{
return;
}
m_framePressState = PointerEventData.FramePressState.Released;
m_isLeftHandDrag = !isRightHand;
m_screenNormalPos = handScreenPos;
}
public void HandGripDetected(long userId, int userIndex, bool isRightHand, bool isHandInteracting, Vector3 handScreenPos)
{
if (userIndex != playerIndex || !isHandInteracting)
{
return;
}
//Debug.Log("HandGripDetected");
m_framePressState = PointerEventData.FramePressState.Pressed;
//m_isLeftHandDrag = !isRightHand;
m_screenNormalPos = handScreenPos;
}
private void SimulateButtonState(PointerEventData.FramePressState state, PointerEventData.InputButton button)
{
// Use the existing EventSystems input module input as the
// input for our custom input module.
m_InputOverride = EventSystem.current.currentInputModule.input;
MouseState mousePointerEventData = GetMousePointerEventData();
// Retrieve button state data for intended button
MouseButtonEventData buttonState = mousePointerEventData.GetButtonState(button).eventData;
// Set the mouse button state to required state
buttonState.buttonState = state;
ProcessMousePress(buttonState);
}
/// <summary>
/// overwritten from the base version so we can use our custom
/// </summary>
/// <returns></returns>
override protected MouseState GetGazePointerData()
{
MouseState state = base.GetGazePointerData();
var raycast = state.GetButtonState(PointerEventData.InputButton.Left).eventData.buttonData.pointerCurrentRaycast;
//get custom press state
PointerEventData.FramePressState pressState = GetGazeButtonState(raycast.gameObject);
//set it
state.SetButtonState(PointerEventData.InputButton.Left, pressState, state.GetButtonState(PointerEventData.InputButton.Left).eventData.buttonData);
return(state);
}
private IEnumerator EmulateMouseClick(bool isRightHand, Vector3 handScreenPos)
{
m_framePressState = PointerEventData.FramePressState.Pressed;
//m_isLeftHand = !isRightHand;
m_screenNormalPos = handScreenPos;
yield return(new WaitForSeconds(0.2f));
m_framePressState = PointerEventData.FramePressState.Released;
//m_isLeftHand = !isRightHand;
m_screenNormalPos = handScreenPos;
yield return(null);
}
private PointerEventData.FramePressState SwitchStateForMouseButton(int id)
{
PointerEventData.FramePressState buttonState = StateForMouseButton(id);
if (Switch.Phase[id] == 1)
{
buttonState = PointerEventData.FramePressState.Released;
Switch.Phase[id] = 2;
}
else if (Switch.Phase[id] == 2)
{
buttonState = PointerEventData.FramePressState.Pressed;
Switch.Phase[id] = 0;
}
return(buttonState);
}
public override void Process()
{
foreach (KeyValuePair <Pointer, MouseButtonEventData> pe in pointerEvents)
{
Pointer pointer = pe.Key;
MouseButtonEventData buttonEventData = pe.Value;
PointerEventData pointerEventData = buttonEventData.buttonData;
// Update position pointer
Vector2 pointOnScreenPosition = Camera.main.WorldToScreenPoint(pointer.Position);
pointerEventData.delta = pointOnScreenPosition - pointerEventData.position;
pointerEventData.position = pointOnScreenPosition;
// Update UI Raycast data
raycastResults.Clear();
eventSystem.RaycastAll(pointerEventData, raycastResults);
pointerEventData.pointerCurrentRaycast = FindFirstRaycast(raycastResults);
// Update press state
PointerEventData.FramePressState framePressState = PointerEventData.FramePressState.NotChanged;
if (pointer.Press && !lastPressState[pointer])
{
framePressState = PointerEventData.FramePressState.Pressed;
}
else if (!pointer.Press && lastPressState[pointer])
{
framePressState = PointerEventData.FramePressState.Released;
}
lastPressState[pointer] = pointer.Press;
buttonEventData.buttonState = framePressState;
// Call processes of parent class
ProcessMove(pointerEventData);
ProcessDrag(pointerEventData);
ProcessMousePress(buttonEventData);
// Zero the Delta after use, for correct Drag, because the number
// of UI event calls is equal to the number of controllers Pointer.
pointerEventData.delta = Vector2.zero;
}
base.Process();
}
private void CheckGrippedCursorPosition()
{
if (intManager)
{
bool bIsLeftHand = intManager.IsLeftHandPrimary();
// check for gripped hand
bool bHandGrip = bIsLeftHand ? m_leftHandGrip : m_rightHandGrip;
// check for cursor pos change
Vector2 cursorNormalPos = bIsLeftHand ? intManager.GetLeftHandScreenPos() : intManager.GetRightHandScreenPos();
if (bHandGrip && cursorNormalPos != (Vector2)m_screenNormalPos)
{
// emulate new press
m_framePressState = PointerEventData.FramePressState.Pressed;
m_screenNormalPos = cursorNormalPos;
}
}
}
/// <summary>
/// Given a mouse button return the current state for the frame.
/// </summary>
/// <remarks>
/// Copied from Unity UI's PointerInputModule.
/// </remarks>
protected new PointerEventData.FramePressState StateForMouseButton(int buttonId)
{
bool pressed = _inputWrapper.GetMouseButtonDown(buttonId);
bool released = _inputWrapper.GetMouseButtonUp(buttonId);
PointerEventData.FramePressState state = PointerEventData.FramePressState.NotChanged;
if (pressed && released)
{
state = PointerEventData.FramePressState.PressedAndReleased;
}
else if (pressed)
{
state = PointerEventData.FramePressState.Pressed;
}
else if (released)
{
state = PointerEventData.FramePressState.Released;
}
return(state);
}
public void HandGripDetected(long userId, int userIndex, bool isRightHand, bool isHandInteracting, Vector3 handScreenPos)
{
if (userIndex != playerIndex || !isHandInteracting)
{
return;
}
//Debug.Log("HandGripDetected");
m_framePressState = PointerEventData.FramePressState.Pressed;
//m_isLeftHand = !isRightHand;
m_handCursorPos = handScreenPos;
if (!isRightHand)
{
m_leftHandGrip = true;
}
else
{
m_rightHandGrip = true;
}
}
protected PointerEventData.FramePressState UpdateTouchpadButton()
{
if (controller == null)
{
return(m_touchpadButtonState);
}
if (controller.GetPressDown(Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad))
{
m_touchpadButtonState = PointerEventData.FramePressState.Pressed;
}
else if (controller.GetPressUp(Valve.VR.EVRButtonId.k_EButton_SteamVR_Touchpad))
{
m_touchpadButtonState = PointerEventData.FramePressState.Released;
}
else
{
m_touchpadButtonState = PointerEventData.FramePressState.NotChanged;
}
return(m_touchpadButtonState);
}
protected override MouseState GetMousePointerEventData(int id = 0)
{
if (KickStarter.settingsManager == null || KickStarter.settingsManager.inputMethod != InputMethod.KeyboardOrController)
{
return(base.GetMousePointerEventData(id));
}
PointerEventData leftData;
var created = GetPointerData(kMouseLeftId, out leftData, true);
leftData.Reset();
Vector2 pos = KickStarter.playerInput.GetMousePosition();
if (created)
{
leftData.position = pos;
}
leftData.delta = pos - leftData.position;
leftData.position = pos;
leftData.scrollDelta = Input.mouseScrollDelta;
leftData.button = PointerEventData.InputButton.Left;
eventSystem.RaycastAll(leftData, m_RaycastResultCache);
RaycastResult raycast = FindFirstRaycast(m_RaycastResultCache);
leftData.pointerCurrentRaycast = raycast;
m_RaycastResultCache.Clear();
if (raycast.isValid && KickStarter.menuManager.autoSelectValidRaycasts && !CanDirectlyControlMenus())
{
KickStarter.playerMenus.EventSystem.SetSelectedGameObject(raycast.gameObject);
}
PointerEventData rightData;
GetPointerData(kMouseRightId, out rightData, true);
CopyFromTo(leftData, rightData);
rightData.button = PointerEventData.InputButton.Right;
PointerEventData middleData;
GetPointerData(kMouseMiddleId, out middleData, true);
CopyFromTo(leftData, middleData);
middleData.button = PointerEventData.InputButton.Middle;
PointerEventData.FramePressState leftClickState = PointerEventData.FramePressState.NotChanged;
if (KickStarter.playerInput.InputGetButtonDown("InteractionA"))
{
leftClickState = PointerEventData.FramePressState.Pressed;
}
else if (KickStarter.playerInput.InputGetButtonUp("InteractionA"))
{
leftClickState = PointerEventData.FramePressState.Released;
}
PointerEventData.FramePressState rightClickState = PointerEventData.FramePressState.NotChanged;
if (KickStarter.playerInput.InputGetButtonDown("InteractionB"))
{
rightClickState = PointerEventData.FramePressState.Pressed;
}
else if (KickStarter.playerInput.InputGetButtonUp("InteractionB"))
{
rightClickState = PointerEventData.FramePressState.Released;
}
m_MouseState.SetButtonState(PointerEventData.InputButton.Left, leftClickState, leftData);
m_MouseState.SetButtonState(PointerEventData.InputButton.Right, rightClickState, rightData);
m_MouseState.SetButtonState(PointerEventData.InputButton.Middle, StateForMouseButton(2), middleData);
return(m_MouseState);
}
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);
}
}
}
/// <summary>
/// 指定されたボタンの状態を設定する
/// </summary>
/// <param name="buttonId">マウスのボタンId。左:0、右:1、中:2</param>
/// <param name="state">ボタンの入力状態</param>
public void SetButtonState(int buttonId, PointerEventData.FramePressState state)
{
PointerInputModule.MouseButtonEventData mouseEventData;
GetButtonEventData(buttonId, out mouseEventData);
mouseEventData.buttonState = state;
}
// Token: 0x06000245 RID: 581 RVA: 0x0001E8A0 File Offset: 0x0001CAA0
public void SetButtonState(PointerEventData.InputButton button, PointerEventData.FramePressState stateForMouseButton, PointerEventData data)
{
CusPointerInputModule.ButtonState buttonState = this.GetButtonState(button, 0);
buttonState.eventData.buttonState = stateForMouseButton;
buttonState.eventData.buttonData = data;
}
protected PointerEventData.FramePressState UpdateTriggerState()
{
switch (m_triggerButtonState)
{
case PointerEventData.FramePressState.NotChanged:
if (triggerPressed() && !triggerPressedDown)
{
m_triggerButtonState = PointerEventData.FramePressState.Pressed;
}
if (!triggerPressed() && triggerPressedDown)
{
if (helpState == false)
{
m_triggerButtonState = PointerEventData.FramePressState.Pressed;
helpState = true;
}
else
{
m_triggerButtonState = PointerEventData.FramePressState.Released;
}
}
break;
case PointerEventData.FramePressState.Pressed:
if (helpState)
{
helpState = false;
m_triggerButtonState = PointerEventData.FramePressState.Released;
}
else
{
triggerPressedDown = true;
if (triggerPressed() && triggerPressedDown)
{
m_triggerButtonState = PointerEventData.FramePressState.NotChanged;
}
else if (!triggerPressed() && triggerPressedDown)
{
m_triggerButtonState = PointerEventData.FramePressState.Released;
}
}
break;
//case PointerEventData.FramePressState.PressedAndReleased:
//break;
case PointerEventData.FramePressState.Released:
if (!triggerPressed())
{
m_triggerButtonState = PointerEventData.FramePressState.NotChanged;
}
else
{
m_triggerButtonState = PointerEventData.FramePressState.Pressed;
}
triggerPressedDown = false;
break;
}
return(m_triggerButtonState);
}
public NavigationInput(Vector2 movementDelta, PointerEventData.FramePressState submitEvent)
{
MovementDelta = movementDelta;
SubmitEvent = submitEvent;
}
