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) { 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, Action <InputControl> consumeControl) { GrabbyLocomotion grabInput = (GrabbyLocomotion)input; if (grabInput.trigger2.wasJustPressed) { // engage grabby GameObject first = getFirstGameObject(rayOrigin); if (first != null) { DragStart(first.transform); m_GrabbyEngaged = true; } } else if (grabInput.trigger2.wasJustReleased) { // disengage grabby DragEnd(); } if (m_GrabbyEngaged) { Dragging(); } }
public static void CollectDeviceSlotsFromActionMapInput(ActionMapInput actionMapInput, ref HashSet <DeviceSlot> deviceSlots) { foreach (var deviceSlot in actionMapInput.controlScheme.deviceSlots) { deviceSlots.Add(deviceSlot); } }
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; } }
public void AddRaycastSource(IProxy proxy, Node node, ActionMapInput actionMapInput, Transform rayOrigin, Func <RaycastSource, bool> validationCallback = null) { UIActions actions = (UIActions)actionMapInput; actions.active = false; m_RaycastSources.Add(rayOrigin, new RaycastSource(proxy, rayOrigin, node, actions, validationCallback)); }
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 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); } }
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 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); } }
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); } } }
public void ProcessInput(ActionMapInput input, Action <InputControl> consumeControl) { if (m_State == CreateState.Start) { HandleStart((Standard)input, consumeControl); } else if (m_State == CreateState.Finish) { HandleFinish((Standard)input, consumeControl); } }
public void Initialize(ActionMapInput actionMapInput, PlayerHandle playerHandle) { m_ActionMapInput = actionMapInput; m_PlayerHandle = playerHandle; if (m_ActionMapInput == null || m_PlayerHandle == null) { return; } InitializeControlScheme(); ActivateUI(); }
GameObject GetDirectSelectionForRayOrigin(Transform rayOrigin, ActionMapInput input) { if (m_IntersectionModule) { var tester = rayOrigin.GetComponentInChildren <IntersectionTester>(); var renderer = m_IntersectionModule.GetIntersectedObjectForTester(tester); if (renderer) { return(renderer.gameObject); } } return(null); }
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; }
public void Assign(string name) { this.enabled = true; foreach (ActionMapSlot actionMapSlot in playerInput.actionMaps) { ActionMapInput actionMapInput = ActionMapInput.Create(actionMapSlot.actionMap); actionMapInput.TryInitializeWithDevices(playerInput.handle.GetApplicableDevices()); actionMapInput.active = actionMapSlot.active; actionMapInput.blockSubsequent = actionMapSlot.blockSubsequent; playerInput.handle.maps.Add(actionMapInput); } controlls = playerInput.GetActions <ChickenInput_Xbox>(); this.name += "(" + name + ")"; }
public void ProcessInput(ActionMapInput input, Action <InputControl> consumeControl) { var standardInput = (Standard)input; if (Selection.activeGameObject != null) { if (FindObjectOfType <HierarchyParent>() == null) { Selection.activeGameObject.AddComponent <HierarchyParent>(); } } HandleHover(); HandleObjectSelection(standardInput, consumeControl); }
public ActionMapInput CreateActionMapInput(ActionMap map, InputDevice device) { // Check for improper use of action maps first if (device != null && !IsValidActionMapForDevice(map, device)) { return(null); } var devices = device == null?GetSystemDevices() : new List <InputDevice> { device }; var actionMapInput = ActionMapInput.Create(map); // It's possible that there are no suitable control schemes for the device that is being initialized, // so ActionMapInput can't be marked active var successfulInitialization = false; if (actionMapInput.TryInitializeWithDevices(devices)) { successfulInitialization = true; } else { // For two-handed tools, the single device won't work, so collect the devices from the action map devices = InputUtils.CollectInputDevicesFromActionMaps(new List <ActionMap>() { map }); if (actionMapInput.TryInitializeWithDevices(devices)) { successfulInitialization = true; } } if (successfulInitialization) { actionMapInput.autoReinitialize = false; // Resetting AMIs cause all AMIs (active or not) that use the same sources to be reset, which causes // problems (e.g. dropping objects because wasJustPressed becomes true when reset) actionMapInput.resetOnActiveChanged = false; actionMapInput.active = true; } return(actionMapInput); }
internal static IToolsMenu SpawnToolsMenu(Type type, InputDevice device, out ActionMapInput input) { input = null; if (!typeof(IToolsMenu).IsAssignableFrom(type)) { return(null); } var menu = (IToolsMenu)ObjectUtils.AddComponent(type, evr.gameObject); input = evr.GetModule <DeviceInputModule>().CreateActionMapInputForObject(menu, device); evr.m_Interfaces.ConnectInterfaces(menu, device); return(menu); }
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); } }
IMainMenu SpawnMainMenu(Type type, InputDevice device, bool visible, out ActionMapInput input) { input = null; if (!typeof(IMainMenu).IsAssignableFrom(type)) { return(null); } var mainMenu = U.Object.AddComponent(type, gameObject) as IMainMenu; input = CreateActionMapInputForObject(mainMenu, device); ConnectInterfaces(mainMenu, device); mainMenu.visible = visible; return(mainMenu); }
IAlternateMenu SpawnAlternateMenu(Type type, InputDevice device, out ActionMapInput input) { input = null; if (!typeof(IAlternateMenu).IsAssignableFrom(type)) { return(null); } var alternateMenu = U.Object.AddComponent(type, gameObject) as IAlternateMenu; input = CreateActionMapInputForObject(alternateMenu, device); ConnectInterfaces(alternateMenu, device); alternateMenu.visible = false; return(alternateMenu); }
public void ProcessInput(ActionMapInput input, ConsumeControlDelegate consumeControl) { var standardAlt = (StandardAlt)input; if (standardAlt.action.wasJustPressed) { Transform sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere).transform; if (rayOrigin) { sphere.position = rayOrigin.position + rayOrigin.forward * 5f; } addToSpatialHash(sphere.gameObject); consumeControl(standardAlt.action); } }
public void ProcessInput(ActionMapInput input, Action <InputControl> 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; }
public void Start() { // Create a global player handle that listen to all relevant devices not already used // by other player handles. globalHandle = PlayerHandleManager.GetNewPlayerHandle(); globalHandle.global = true; List <ActionMapSlot> actionMaps = playerPrefab.GetComponent <PlayerInput>().actionMaps; foreach (ActionMapSlot actionMapSlot in actionMaps) { ActionMapInput actionMapInput = ActionMapInput.Create(actionMapSlot.actionMap); actionMapInput.TryInitializeWithDevices(globalHandle.GetApplicableDevices()); actionMapInput.active = actionMapSlot.active; actionMapInput.blockSubsequent = actionMapSlot.blockSubsequent; globalHandle.maps.Add(actionMapInput); } joinAction.Bind(globalHandle); leaveAction.Bind(globalHandle); }
/// <summary> /// Spawn a tool on a tool stack for a specific device (e.g. right hand). /// </summary> /// <param name="toolType">The tool to spawn</param> /// <param name="usedDevices">A list of the used devices coming from the action map</param> /// <param name="device">The input device whose tool stack the tool should be spawned on (optional). If not /// specified, then it uses the action map to determine which devices the tool should be spawned on.</param> /// <param name="rayOrigin">The ray origin on which to spawn th tool</param> /// <param name="deviceInputModule">The device input module, if it exists</param> /// <returns> Returns tool that was spawned or null if the spawn failed.</returns> ToolData SpawnTool(Type toolType, out HashSet <InputDevice> usedDevices, InputDevice device, Transform rayOrigin, DeviceInputModule deviceInputModule) { usedDevices = new HashSet <InputDevice>(); if (!typeof(ITool).IsAssignableFrom(toolType)) { Debug.LogWarningFormat("Cannot spawn {0} which is not an ITool", toolType.Name); return(null); } var deviceSlots = new HashSet <DeviceSlot>(); var tool = EditorXRUtils.AddComponent(toolType, gameObject) as ITool; ActionMapInput actionMapInput = null; if (deviceInputModule != null) { actionMapInput = deviceInputModule.CreateActionMapInputForObject(tool, device); if (actionMapInput != null) { usedDevices.UnionWith(actionMapInput.GetCurrentlyUsedDevices()); InputUtils.CollectDeviceSlotsFromActionMapInput(actionMapInput, ref deviceSlots); actionMapInput.Reset(false); } } if (usedDevices.Count == 0) { usedDevices.Add(device); } this.InjectFunctionalitySingle(tool); this.ConnectInterfaces(tool, rayOrigin); var icon = tool as IMenuIcon; return(new ToolData { tool = tool, input = actionMapInput, icon = icon != null ? icon.icon : null }); }