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
});
}
