void HandleFinishPoint(Standard standardInput, ConsumeControlDelegate consumeControl) { if (m_CurrentShape == null) { return; } Ray ray = new Ray(rayOrigin.position, rayForwardSmoothed.Add(rayOrigin.forward)); Vector3 planeIntersect = Vector3.zero; if (m_CurrentShape.HandleDrag(ray, ref planeIntersect)) { m_ProxyRay.SetLength(Vector3.Distance(planeIntersect, rayOrigin.position)); } m_ShapeBounds.SetHighlight(m_CurrentShape.pbObject, true); if (standardInput.action.wasJustReleased) { m_AudioModule.Play(m_TriggerReleased, true); if (!m_CurrentShape.HandleTriggerRelease(ray)) { m_State = ShapeCreationState.StartPoint; } m_ShapeBounds.SetHighlight(m_CurrentShape.pbObject, false); } consumeControl(standardInput.action); }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var standardInput = (Standard)input; switch (m_State) { case PrimitiveCreationStates.StartPoint: { HandleStartPoint(standardInput, consumeControl); break; } case PrimitiveCreationStates.EndPoint: { UpdatePositions(); SetScalingForObjectType(); CheckForTriggerRelease(standardInput, consumeControl); break; } case PrimitiveCreationStates.Freeform: { UpdatePositions(); UpdateFreeformScale(); CheckForTriggerRelease(standardInput, consumeControl); break; } } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { if (!m_MainMenuUI.visible) { return; } var mainMenuInput = (MainMenuInput)input; var rotationInput = -mainMenuInput.rotate.rawValue; consumeControl(mainMenuInput.rotate); consumeControl(mainMenuInput.blockY); const float kFlickDeltaThreshold = 0.5f; if ((this.GetDeviceType() != DeviceType.Vive && Mathf.Abs(rotationInput) >= kFlickDeltaThreshold && Mathf.Abs(m_LastRotationInput) < kFlickDeltaThreshold) || mainMenuInput.flickFace.wasJustReleased) { m_MainMenuUI.targetFaceIndex += (int)Mathf.Sign(rotationInput); this.Pulse(node, m_FaceRotationPulse); } if (m_MenuHideFlags == 0) { consumeControl(mainMenuInput.flickFace); } m_LastRotationInput = rotationInput; }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var hit = false; foreach (var vacuumable in vacuumables) { var vacuumableTransform = vacuumable.transform; var ray = new Ray(rayOrigin.position, rayOrigin.forward); ray.origin = vacuumableTransform.InverseTransformPoint(ray.origin); ray.direction = vacuumableTransform.InverseTransformDirection(ray.direction); if (vacuumable.vacuumBounds.IntersectRay(ray)) { hit = true; var vacuumInput = (VacuumInput)input; if (vacuumInput.vacuum.wasJustPressed) { var realTime = Time.realtimeSinceStartup; if (UIUtils.IsDoubleClick(realTime - m_LastClickTime)) { Coroutine coroutine; if (m_VacuumingCoroutines.TryGetValue(vacuumableTransform, out coroutine)) { StopCoroutine(coroutine); } m_VacuumingCoroutines[vacuumableTransform] = StartCoroutine(VacuumToViewer(vacuumable)); } m_LastClickTime = realTime; } if (m_Feedback.Count == 0) { foreach (var kvp in m_Controls) { foreach (var id in kvp.Value) { var request = (ProxyFeedbackRequest)this.GetFeedbackRequestObject(typeof(ProxyFeedbackRequest)); request.control = id; request.node = node; request.tooltipText = "Double-tap to summon workspace"; m_Feedback.Add(request); this.AddFeedbackRequest(request); } } } break; } } if (!hit) { foreach (var request in m_Feedback) { this.RemoveFeedbackRequest(request); } m_Feedback.Clear(); } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var vacuumInput = (VacuumInput)input; if (vacuumInput.vacuum.wasJustPressed) { var realTime = Time.realtimeSinceStartup; if (UIUtils.IsDoubleClick(realTime - m_LastClickTime)) { foreach (var vacuumable in vacuumables) { var vacuumableTransform = vacuumable.transform; var ray = new Ray(rayOrigin.position, rayOrigin.forward); ray.origin = vacuumableTransform.InverseTransformPoint(ray.origin); ray.direction = vacuumableTransform.InverseTransformDirection(ray.direction); if (vacuumable.vacuumBounds.IntersectRay(ray)) { Coroutine coroutine; if (m_VacuumingCoroutines.TryGetValue(vacuumableTransform, out coroutine)) { StopCoroutine(coroutine); } m_VacuumingCoroutines[vacuumableTransform] = StartCoroutine(VacuumToViewer(vacuumable)); } } consumeControl(vacuumInput.vacuum); } m_LastClickTime = realTime; } }
internal void ProcessInput(ConsumeControlDelegate consumeControl) { for (int i = 0; i < m_Workspaces.Count; i++) { m_Workspaces[i].ProcessInput(m_WorkspaceInputs[i], consumeControl); } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var miniWorldInput = (MiniWorldInput)input; if (miniWorld.Contains(leftRayOrigin.position) && miniWorldInput.leftGrab.wasJustPressed) { OnPanZoomDragStarted(leftRayOrigin); consumeControl(miniWorldInput.leftGrab); } if (miniWorld.Contains(rightRayOrigin.position) && miniWorldInput.rightGrab.wasJustPressed) { OnPanZoomDragStarted(rightRayOrigin); consumeControl(miniWorldInput.rightGrab); } if (miniWorldInput.leftGrab.isHeld || miniWorldInput.rightGrab.isHeld) { OnPanZoomDragging(); } if (miniWorldInput.leftGrab.wasJustReleased) { OnPanZoomDragEnded(leftRayOrigin); } if (miniWorldInput.rightGrab.wasJustReleased) { OnPanZoomDragEnded(rightRayOrigin); } }
void ProcessInput(HashSet<IProcessInput> processedInputs, ConsumeControlDelegate consumeControl) { GetModule<WorkspaceModule>().ProcessInput(consumeControl); GetNestedModule<MiniWorlds>().UpdateMiniWorlds(); GetModule<MultipleRayInputModule>().ProcessInput(null, consumeControl); foreach (var deviceData in m_DeviceData) { if (!deviceData.proxy.active) continue; var mainMenu = deviceData.mainMenu; var menuInput = mainMenu as IProcessInput; if (menuInput != null && mainMenu.visible) menuInput.ProcessInput(deviceData.mainMenuInput, consumeControl); var altMenu = deviceData.alternateMenu; var altMenuInput = altMenu as IProcessInput; if (altMenuInput != null && altMenu.visible) altMenuInput.ProcessInput(deviceData.alternateMenuInput, consumeControl); foreach (var toolData in deviceData.toolData) { var process = toolData.tool as IProcessInput; if (process != null && ((MonoBehaviour)toolData.tool).enabled && processedInputs.Add(process)) // Only process inputs for an instance of a tool once (e.g. two-handed tools) process.ProcessInput(toolData.input, consumeControl); } } }
bool DoBlink(ConsumeControlDelegate consumeControl) { if (m_LocomotionInput.blink.isHeld) { this.AddRayVisibilitySettings(rayOrigin, this, false, false); m_BlinkVisuals.extraSpeed = m_LocomotionInput.speed.value; m_BlinkVisuals.visible = true; consumeControl(m_LocomotionInput.blink); return(true); } if (m_LocomotionInput.blink.wasJustReleased) { this.RemoveRayVisibilitySettings(rayOrigin, this); m_BlinkVisuals.visible = false; if (m_BlinkVisuals.targetPosition.HasValue) { StartCoroutine(MoveTowardTarget(m_BlinkVisuals.targetPosition.Value)); } return(true); } this.RemoveRayVisibilitySettings(rayOrigin, this); return(m_BlinkMoving); }
bool DoFlying(ConsumeControlDelegate consumeControl) { var reverse = m_LocomotionInput.reverse.isHeld; var moving = m_LocomotionInput.forward.isHeld || reverse; if (moving) { var speed = k_SlowMoveSpeed; var speedControl = m_LocomotionInput.speed; var speedControlValue = speedControl.value; if (!Mathf.Approximately(speedControlValue, 0)) // Consume control to block selection { speed = k_SlowMoveSpeed + speedControlValue * (k_FastMoveSpeed - k_SlowMoveSpeed); consumeControl(speedControl); } speed *= this.GetViewerScale(); if (reverse) { speed *= -1; } m_Rotating = false; cameraRig.Translate(Quaternion.Inverse(cameraRig.rotation) * rayOrigin.forward * speed * Time.unscaledDeltaTime); consumeControl(m_LocomotionInput.forward); return(true); } return(false); }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { m_LocomotionInput = (LocomotionInput)input; this.SetUIBlockedForRayOrigin(rayOrigin, true); if (DoTwoHandedScaling(consumeControl)) { if (m_Preferences.blinkMode && m_LocomotionInput.blink.isHeld) m_BlinkVisuals.visible = false; return; } if (DoRotating(consumeControl)) return; if (m_Preferences.blinkMode) { if (DoBlink(consumeControl)) return; } else { if (DoFlying(consumeControl)) return; } if (DoCrawl(consumeControl)) return; this.SetUIBlockedForRayOrigin(rayOrigin, false); }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var action = ((Standard)input).action; if (m_State != State.MoveWorkspaces) { if (!this.IsAboveHead(rayOrigin)) { return; } if (action.wasJustPressed) { if (UIUtils.IsDoubleClick(Time.realtimeSinceStartup - m_TriggerPressedTimeStamp)) { this.ResetWorkspaceRotations(); m_State = State.WaitingForReset; } m_TriggerPressedTimeStamp = Time.realtimeSinceStartup; consumeControl(action); } else if (m_State == State.WaitingForInput && action.isHeld) { StartMove(); } else if (m_State == State.WaitingForReset && action.wasJustReleased) { m_State = State.WaitingForInput; } } else { consumeControl(action); var throwDownTriggered = false; if (ThrowingDown() && action.wasJustReleased) { foreach (var ws in m_Workspaces) { ws.Close(); } throwDownTriggered = true; } UpdateWorkspaceScales(); if (!throwDownTriggered && action.isHeld) { MoveWorkspaces(); } if (action.wasJustReleased) { EndMove(); } } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { if (!m_UndoMenuUI.visible) { return; } var undoMenuInput = (UndoMenuInput)input; if (undoMenuInput == null) { this.ClearFeedbackRequests(); return; } var engage = undoMenuInput.engage; if (engage.wasJustReleased && !m_TrackpadController) { this.RestartCoroutine(ref m_StillEngagedAfterStickReleasedCoroutine, AcceptInputAfterStickReleased()); } if (!(engage.wasJustPressed || !m_TrackpadController && (engage.isHeld || m_StillEngagedAfterStickRelease))) { return; } consumeControl(engage); m_UndoMenuUI.engaged = true; var navigateXControl = undoMenuInput.navigateX; var navigateX = navigateXControl.value; var undoRedoPerformed = false; if (navigateX < -k_UndoRedoThreshold && (m_TrackpadController || m_PrevNavigateX > -k_UndoRedoThreshold)) { Undo.PerformUndo(); m_UndoMenuUI.StartPerformedAnimation(true); ShowUndoPerformedFeedback(true); undoRedoPerformed = true; } else if (navigateX > k_UndoRedoThreshold && (m_TrackpadController || m_PrevNavigateX < k_UndoRedoThreshold)) { Undo.PerformRedo(); m_UndoMenuUI.StartPerformedAnimation(false); ShowUndoPerformedFeedback(false); undoRedoPerformed = true; } m_PrevNavigateX = navigateX; if (undoRedoPerformed) { consumeControl(navigateXControl); this.StopCoroutine(ref m_StillEngagedAfterStickReleasedCoroutine); this.Pulse(node, m_UndoPulse); } }
bool DoBlink(ConsumeControlDelegate consumeControl) { var blink = m_LocomotionInput.blink; if (blink.wasJustPressed) { HideMainButtonFeedback(); HideCrawlFeedback(); ShowRotateFeedback(); } if (blink.isHeld) { this.AddRayVisibilitySettings(rayOrigin, this, false, false); var speedControl = m_LocomotionInput.speed; var speed = speedControl.value; m_BlinkVisuals.extraSpeed = speed; if (speed < 0) { HideSpeedFeedback(); } else if (m_SpeedFeedback.Count == 0) { ShowSpeedFeedback(); } m_BlinkVisuals.visible = true; consumeControl(speedControl); // Consume trigger to block block-select consumeControl(blink); return(true); } if (blink.wasJustReleased) { this.RemoveRayVisibilitySettings(rayOrigin, this); HideRotateFeedback(); HideSpeedFeedback(); ShowMainButtonFeedback(); ShowCrawlFeedback(); m_BlinkVisuals.visible = false; if (m_BlinkVisuals.targetPosition.HasValue) { StartCoroutine(MoveTowardTarget(m_BlinkVisuals.targetPosition.Value)); } return(true); } this.RemoveRayVisibilitySettings(rayOrigin, this); return(m_BlinkMoving); }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var annotationInput = (AnnotationInput)input; var draw = annotationInput.draw; var isHeld = draw.isHeld; if (primary) { if (!Mathf.Approximately(annotationInput.changeBrushSize.value, 0)) { HandleBrushSize(annotationInput.changeBrushSize.value); consumeControl(annotationInput.changeBrushSize); consumeControl(annotationInput.vertical); } if (draw.wasJustPressed) { SetupAnnotation(); consumeControl(draw); } if (isHeld) { UpdateAnnotation(); consumeControl(draw); } if (draw.wasJustReleased) { FinalizeMesh(); consumeControl(draw); } } if (isHeld) { return; } var isOverUI = this.IsHoveringOverUI(rayOrigin); if (isOverUI != m_WasOverUI) { m_WasOverUI = isOverUI; this.RestartCoroutine(ref m_AnnotationPointerVisibilityCoroutine, SetAnnotationPointerVisibility(!isOverUI)); if (isOverUI) { this.RemoveRayVisibilitySettings(rayOrigin, this); } else { this.AddRayVisibilitySettings(rayOrigin, this, false, false); } } }
void CheckForTriggerRelease(Standard standardInput, ConsumeControlDelegate consumeControl) { // Ready for next object to be created if (standardInput.action.wasJustReleased) { m_State = PrimitiveCreationStates.StartPoint; consumeControl(standardInput.action); } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { if (m_State == CreateState.Start) { HandleStart((Standard)input, consumeControl); } else if (m_State == CreateState.Finish) { HandleFinish((Standard)input, consumeControl); } }
void CheckForTriggerRelease(Standard standardInput, ConsumeControlDelegate consumeControl) { // Ready for next object to be created if (standardInput.action.wasJustReleased) { m_State = PrimitiveCreationStates.StartPoint; #if UNITY_EDITOR UnityEditor.Undo.IncrementCurrentGroup(); #endif consumeControl(standardInput.action); } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { if (!m_MainMenuUI.visible) { return; } var mainMenuInput = (MainMenuInput)input; var rotationInput = -mainMenuInput.rotate.rawValue; const float kFlickDeltaThreshold = 0.5f; if (this.GetDeviceType() == DeviceType.Vive) { if (!Mathf.Approximately(rotationInput, 0f)) { var time = Time.time; if (Mathf.Approximately(m_LastRotationInput, 0f)) { // Touch began m_RotationInputStartValue = rotationInput; m_RotationInputStartTime = time; } else { // Touch held var distance = rotationInput - m_RotationInputStartValue; var lastDistance = m_LastRotationInput - m_RotationInputStartValue; if (Mathf.Abs(distance) >= kFlickDeltaThreshold && Mathf.Abs(lastDistance) < kFlickDeltaThreshold && time - m_RotationInputStartTime < k_MaxFlickDuration) { m_RotationInputStartValue = rotationInput; m_RotationInputStartTime = time; if (!m_MainMenuUI.rotating) { FlickMenu(distance); } } } } } else if (Mathf.Abs(rotationInput) >= kFlickDeltaThreshold && Mathf.Abs(m_LastRotationInput) < kFlickDeltaThreshold) { FlickMenu(rotationInput); } m_LastRotationInput = rotationInput; }
bool CancelWasJustPressedTest(ConsumeControlDelegate consumeControl) { var cancelJustPressed = false; if (m_CurrentSpatialActionMapInput.cancel.wasJustPressed || m_CurrentSpatialActionMapInput.grip.wasJustPressed) { cancelJustPressed = true; ConsumeControls(m_CurrentSpatialActionMapInput, consumeControl); m_HighlightedTopLevelMenuElementPosition = -1; s_ControllingSpatialMenu.ReturnToPreviousMenuLevel(); } return(cancelJustPressed); }
public void LoadModule() { m_ConsumeControl = ConsumeControl; m_ToolModule = ModuleLoaderCore.instance.GetModule <EditorXRToolModule>(); if (m_ToolModule != null) { inputDeviceForRayOrigin = rayOrigin => (from deviceData in m_ToolModule.deviceData where deviceData.rayOrigin == rayOrigin select deviceData.inputDevice).FirstOrDefault(); } m_MiniWorldModule = ModuleLoaderCore.instance.GetModule <EditorXRMiniWorldModule>(); }
void SelectJustPressedTest(ConsumeControlDelegate consumeControl, bool isNodeThatActivatedMenu = true) { if (m_CurrentSpatialActionMapInput.select.wasJustPressed) { if (s_SpatialMenuState == SpatialMenuState.NavigatingTopLevel) { s_SpatialMenuUI.SectionTitleButtonSelected(node); } else if (s_SpatialMenuState == SpatialMenuState.NavigatingSubMenuContent) { s_SpatialMenuUI.SelectCurrentlyHighlightedElement(node, isNodeThatActivatedMenu); } ConsumeControls(m_CurrentSpatialActionMapInput, consumeControl); } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var radialMenuInput = (RadialMenuInput)input; if (radialMenuInput == null || m_MenuHideFlags != 0) { this.ClearFeedbackRequests(); return; } var inputDirection = radialMenuInput.navigate.vector2; if (inputDirection.magnitude > k_ActivationThreshold) { // Composite controls need to be consumed separately consumeControl(radialMenuInput.navigateX); consumeControl(radialMenuInput.navigateY); m_RadialMenuUI.buttonInputDirection = inputDirection; } else { m_RadialMenuUI.buttonInputDirection = Vector2.zero; } var selectControl = radialMenuInput.selectItem; m_RadialMenuUI.pressedDown = selectControl.wasJustPressed; if (m_RadialMenuUI.pressedDown) { consumeControl(selectControl); } if (selectControl.wasJustReleased) { this.Pulse(node, m_ReleasePulse); m_RadialMenuUI.SelectionOccurred(); if (itemWasSelected != null) { itemWasSelected(rayOrigin); } consumeControl(selectControl); } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var standardInput = (Standard)input; if (standardInput.action.wasJustPressed) { var cube = GameObject.CreatePrimitive(PrimitiveType.Cube).transform; if (rayOrigin) { cube.position = rayOrigin.position + rayOrigin.forward * 5f; } addToSpatialHash(cube.gameObject); consumeControl(standardInput.action); } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var standardInput = (Standard)input; switch (m_State) { case ShapeCreationState.StartPoint: { HandleStartPoint(standardInput, consumeControl); break; } case ShapeCreationState.EndPoint: { HandleFinishPoint(standardInput, consumeControl); break; } } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { if (!IsActive()) { return; } var standardInput = (Standard)input; switch (m_State) { case PrimitiveCreationStates.StartPoint: { HandleStartPoint(standardInput, consumeControl); break; } case PrimitiveCreationStates.EndPoint: { UpdatePositions(); SetScalingForObjectType(); CheckForTriggerRelease(standardInput, consumeControl); break; } case PrimitiveCreationStates.Freeform: { UpdatePositions(); UpdateFreeformScale(); CheckForTriggerRelease(standardInput, consumeControl); break; } } if (m_State == PrimitiveCreationStates.StartPoint && this.IsHoveringOverUI(rayOrigin)) { this.RemoveRayVisibilitySettings(rayOrigin, this); } else { this.AddRayVisibilitySettings(rayOrigin, this, false, true); } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var mainMenuInput = (MainMenuInput)input; var rotationInput = -mainMenuInput.rotate.rawValue; consumeControl(mainMenuInput.rotate); consumeControl(mainMenuInput.blockY); const float kFlickDeltaThreshold = 0.5f; if ((proxyType != typeof(ViveProxy) && Mathf.Abs(rotationInput) >= kFlickDeltaThreshold && Mathf.Abs(m_LastRotationInput) < kFlickDeltaThreshold) || mainMenuInput.flickFace.wasJustReleased) { m_MainMenuUI.targetFaceIndex += (int)Mathf.Sign(rotationInput); consumeControl(mainMenuInput.flickFace); } m_LastRotationInput = rotationInput; }
void HandleStartPoint(Standard standardInput, ConsumeControlDelegate consumeControl) { if (standardInput.action.wasJustPressed) { m_CurrentGameObject = GameObject.CreatePrimitive(m_SelectedPrimitiveType); // Set starting minimum scale (don't allow zero scale object to be created) const float kMinScale = 0.0025f; var viewerScale = this.GetViewerScale(); m_CurrentGameObject.transform.localScale = Vector3.one * kMinScale * viewerScale; m_StartPoint = rayOrigin.position + rayOrigin.forward * k_DrawDistance * viewerScale; m_CurrentGameObject.transform.position = m_StartPoint; m_State = m_Freeform ? PrimitiveCreationStates.Freeform : PrimitiveCreationStates.EndPoint; this.AddToSpatialHash(m_CurrentGameObject); consumeControl(standardInput.action); Selection.activeGameObject = m_CurrentGameObject; } }
void ProcessInput(HashSet <IProcessInput> processedInputs, ConsumeControlDelegate consumeControl) { GetNestedModule <MiniWorlds>().UpdateMiniWorlds(); foreach (var deviceData in m_DeviceData) { if (!deviceData.proxy.active) { continue; } foreach (var toolData in deviceData.toolData) { var process = toolData.tool as IProcessInput; if (process != null && ((MonoBehaviour)toolData.tool).enabled && processedInputs.Add(process)) // Only process inputs for an instance of a tool once (e.g. two-handed tools) { process.ProcessInput(toolData.input, consumeControl); } } } }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var radialMenuInput = (RadialMenuInput)input; if (radialMenuInput == null || !visible) { return; } var inputDirection = radialMenuInput.navigate.vector2; m_RadialMenuUI.buttonInputDirection = inputDirection; if (inputDirection != Vector2.zero) { // Composite controls need to be consumed separately consumeControl(radialMenuInput.navigateX); consumeControl(radialMenuInput.navigateY); } m_RadialMenuUI.pressedDown = radialMenuInput.selectItem.wasJustPressed; if (m_RadialMenuUI.pressedDown) { consumeControl(radialMenuInput.selectItem); } if (radialMenuInput.selectItem.wasJustReleased) { m_RadialMenuUI.SelectionOccurred(); if (itemWasSelected != null) { itemWasSelected(rayOrigin); } consumeControl(radialMenuInput.selectItem); } }