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