public override void ProcessInteractor(XRInteractionUpdateOrder.UpdatePhase updatePhase)
{
base.ProcessInteractor(updatePhase);
if (updatePhase == XRInteractionUpdateOrder.UpdatePhase.Dynamic)
{
// check to see if we have a new hover object
GetValidTargets(m_ValidTargets);
var nearestObject = m_ValidTargets.FirstOrDefault();
if (nearestObject != m_CurrentNearestObject)
{
m_CurrentNearestObject = nearestObject;
m_LastTimeHoveredObjectChanged = Time.time;
m_PassedHoverTimeToSelect = false;
}
else if (nearestObject && !m_PassedHoverTimeToSelect)
{
float progressToHoverSelect = Mathf.Clamp01((Time.time - m_LastTimeHoveredObjectChanged) / m_HoverTimeToSelect);
if (progressToHoverSelect >= 1.0f)
{
m_PassedHoverTimeToSelect = true;
}
}
}
}
void SelectEnter(XRBaseInteractor interactor, XRBaseInteractable interactable)
{
// If Exclusive Selection, is this the only interactor trying to interact?
if (interactor.requireSelectExclusive)
{
for (int i = 0; i < m_Interactors.Count; i++)
{
if (m_Interactors[i] != interactor &&
m_Interactors[i].selectTarget == interactable)
{
return;
}
}
}
else
{
for (int i = 0; i < m_Interactors.Count; i++)
{
if (m_Interactors[i].selectTarget == interactable)
{
SelectExit(m_Interactors[i], interactable);
}
}
}
interactor.OnSelectEnter(interactable);
interactable.OnSelectEnter(interactor);
}
void OnContactAdded(XRBaseInteractable interactable)
{
if (!m_ValidTargets.Contains(interactable))
{
m_ValidTargets.Add(interactable);
}
}
public virtual void UnregisterInteractable(XRBaseInteractable interactable)
{
if (m_Interactables.Contains(interactable))
{
// Cancel select states for interactors that are selecting this interactable.
foreach (var interactor in m_Interactors)
{
if (interactor.selectTarget == interactable)
{
SelectCancel(interactor, interactable);
}
}
m_Interactables.Remove(interactable);
foreach (var interactableCollider in interactable.colliders)
{
if (interactableCollider != null && m_ColliderToInteractableMap.ContainsKey(interactableCollider))
{
m_ColliderToInteractableMap.Remove(interactableCollider);
}
}
#if AR_FOUNDATION_PRESENT
if (interactable is ARBaseGestureInteractable gestureInteractable)
{
gestureInteractable.DisconnectGestureInteractor();
m_GestureInteractablesNeedReconnect = true;
}
#endif
}
}
/// <summary>
/// Automatically called when an Interactable is unregistered to cancel the selection of the Interactable if necessary.
/// </summary>
/// <param name="interactable">The Interactable to potentially exit its selection state due to cancellation.</param>
public virtual void CancelInteractableSelection(XRBaseInteractable interactable)
{
if (interactable.selectingInteractor != null)
{
SelectCancel(interactable.selectingInteractor, interactable);
}
}
public virtual void HoverExit(XRBaseInteractor interactor, XRBaseInteractable interactable)
{
interactor.OnHoverExiting(interactable);
interactable.OnHoverExiting(interactor);
interactor.OnHoverExited(interactable);
interactable.OnHoverExited(interactor);
}
public virtual void SelectExit(XRBaseInteractor interactor, XRBaseInteractable interactable)
{
interactor.OnSelectExiting(interactable);
interactable.OnSelectExiting(interactor);
interactor.OnSelectExited(interactable);
interactable.OnSelectExited(interactor);
}
/// <summary>
/// Unregister an Interactable so it is no longer processed.
/// </summary>
/// <param name="interactable">The Interactable to be unregistered.</param>
public virtual void UnregisterInteractable(XRBaseInteractable interactable)
{
if (!IsRegistered(interactable))
{
return;
}
CancelInteractableSelection(interactable);
CancelInteractableHover(interactable);
if (m_Interactables.Unregister(interactable))
{
foreach (var interactableCollider in interactable.colliders)
{
if (interactableCollider != null)
{
m_ColliderToInteractableMap.Remove(interactableCollider);
}
}
m_InteractableUnregisteredEventArgs.manager = this;
m_InteractableUnregisteredEventArgs.interactable = interactable;
OnUnregistered(m_InteractableUnregisteredEventArgs);
}
}
/// <summary>This method is called when the interactor ends selection of an interactable.</summary>
/// <param name="interactable">Interactable that is no longer selected.</param>
protected internal override void OnSelectExit(XRBaseInteractable interactable)
{
base.OnSelectExit(interactable);
// If another interactable takes this one, make sure toggle select state is set false
m_ToggleSelectActive = false;
m_WaitingForSecondDeactivate = false;
if (m_Controller)
{
m_Controller.hideControllerModel = false;
}
if (m_PlayHapticsOnSelectExit && m_Controller)
{
SendHapticImpulse(m_HapticSelectExitIntensity, m_HapticSelectExitDuration);
}
if (playAudioClipOnSelectExit && AudioClipForOnSelectExit != null)
{
if (m_EffectsAudioSource == null)
{
CreateEffectsAudioSource();
}
m_EffectsAudioSource.PlayOneShot(AudioClipForOnSelectExit);
}
}
protected internal override void OnHoverEnter(XRBaseInteractable interactable)
{
base.OnHoverEnter(interactable);
MeshFilter[] interactableMeshFilters = interactable.GetComponentsInChildren <MeshFilter>();
if (interactableMeshFilters.Length > 0)
{
m_MeshFilterCache.Add(interactable, interactableMeshFilters);
}
}
/// <summary>
/// Initiates ending hovering of an Interactable by an Interactor, passing the given <paramref name="args"/>.
/// </summary>
/// <param name="interactor">The Interactor that is no longer hovering.</param>
/// <param name="interactable">The Interactable that is no longer being hovered over.</param>
/// <param name="args">Event data containing the Interactor and Interactable involved in the event.</param>
protected virtual void HoverExit(XRBaseInteractor interactor, XRBaseInteractable interactable, HoverExitEventArgs args)
{
Debug.Assert(args.interactor == interactor, this);
Debug.Assert(args.interactable == interactable, this);
interactor.OnHoverExiting(args);
interactable.OnHoverExiting(args);
interactor.OnHoverExited(args);
interactable.OnHoverExited(args);
}
/// <summary>
/// Initiates selection of an Interactable by an Interactor, passing the given <paramref name="args"/>.
/// </summary>
/// <param name="interactor">The Interactor that is selecting.</param>
/// <param name="interactable">The Interactable being selected.</param>
/// <param name="args">Event data containing the Interactor and Interactable involved in the event.</param>
protected virtual void SelectEnter(XRBaseInteractor interactor, XRBaseInteractable interactable, SelectEnterEventArgs args)
{
Debug.Assert(args.interactor == interactor, this);
Debug.Assert(args.interactable == interactable, this);
interactor.OnSelectEntering(args);
interactable.OnSelectEntering(args);
interactor.OnSelectEntered(args);
interactable.OnSelectEntered(args);
}
/// <summary>This method is called by the interaction manager
/// when the interactor ends selection of an interactable.</summary>
/// <param name="interactable">Interactable that is no longer selected.</param>
protected internal virtual void OnSelectExit(XRBaseInteractable interactable)
{
Debug.Assert(m_SelectTarget == interactable);
if (m_SelectTarget == interactable)
{
m_SelectTarget = null;
}
m_OnSelectExit?.Invoke(interactable);
}
public virtual void SelectCancel(XRBaseInteractor interactor, XRBaseInteractable interactable)
{
// TODO Add an OnSelectCancel function to XRBaseInteractor?
interactor.OnSelectExiting(interactable);
interactor.OnSelectExited(interactable);
if (interactable != null)
{
interactable.OnSelectCanceling(interactor);
interactable.OnSelectCanceled(interactor);
}
}
//when you hit the pause button
protected override void OnSelectEnter(XRBaseInteractable interactable)
{
//prevents flashing of pause menu by ignoring after a button press and before release
if (!pauseButtonStillHeld)
{
//press was just initiated, so anything after before release is ignored
pauseButtonStillHeld = true;
base.OnSelectEnter(GameManager.Instance.GetComponent <XRBaseInteractable>());
//checks if it's paused or unpause currently (menu grouping is invisible but parent to the other menus and used to check pause state)
bool pauseActive = MenuGrouping.activeSelf;
//if pausing, menu always starts on basic pause menu
if (!pauseActive)
{
//turn the grouping on, though this does not visibly change anything (so the children can be visible and for tracking purposes)
MenuGrouping.gameObject.SetActive(true);
//have GameManager calculate the menu position and player rotation (updates GameManager public variables), then use those values to put menu in correct place
GameManager.Instance.CalculateMenuPosition();
//this will move the whole stack of menus into position for when they need to appear
MenuGrouping.transform.SetPositionAndRotation(GameManager.Instance.menuPosition, GameManager.Instance.playerRotation);
//Vector3 testVector = new Vector3(0, 1.5f, 0);
//PauseMenuObject.transform.SetPositionAndRotation(testVector, GameManager.Instance.playerRotation);
//PauseMenuObject.transform.SetPositionAndRotation(GameManager.Instance.menuPosition, GameManager.Instance.playerRotation);
//now that position is set, activate the base pause menu
PauseMenuObject.gameObject.SetActive(true);
}
//if unpausing
else
{
//set all of the menus in menu grouping to inactive
for (int i = 0; i < MenuGrouping.transform.childCount; i++)
{
MenuGrouping.transform.GetChild(i).gameObject.SetActive(false);
}
//now deactivate the group
MenuGrouping.gameObject.SetActive(false);
//unpause time/reactivate ability to move/etc
}
//activate or deactivate the raycasters accordingly
LeftUIRaycaster.SetActive(!pauseActive);
RightUIRaycaster.SetActive(!pauseActive);
}
}
/// <summary>
/// Initiates selection of an Interactable by an Interactor. This method may cause the Interactable to first exit being selected.
/// </summary>
/// <param name="interactor">The Interactor that is selecting.</param>
/// <param name="interactable">The Interactable being selected.</param>
/// <remarks>
/// This attempt will be ignored if the Interactor requires exclusive selection of an Interactable and that
/// Interactable is already selected by another Interactor.
/// </remarks>
public virtual void SelectEnter(XRBaseInteractor interactor, XRBaseInteractable interactable)
{
if (interactable.isSelected && interactable.selectingInteractor != interactor)
{
if (interactor.requireSelectExclusive)
{
return;
}
SelectExit(interactable.selectingInteractor, interactable);
}
m_SelectEnterEventArgs.interactor = interactor;
m_SelectEnterEventArgs.interactable = interactable;
SelectEnter(interactor, interactable, m_SelectEnterEventArgs);
}
static int InteractableDistanceComparison(XRBaseInteractable x, XRBaseInteractable y)
{
var xDistance = s_InteractableDistanceSqrMap[x];
var yDistance = s_InteractableDistanceSqrMap[y];
if (xDistance > yDistance)
{
return(1);
}
if (xDistance < yDistance)
{
return(-1);
}
return(0);
}
void SelectEnter(XRBaseInteractor interactor, XRBaseInteractable interactable)
{
// allow new exclusive selection to take precedence over previous non-exclusive selection (useful Interactors like Sockets)
if (interactor.isSelectExclusive)
{
for (int i = 0; i < m_Interactors.Count; i++)
{
if (m_Interactors[i].selectTarget == interactable && !m_Interactors[i].isSelectExclusive)
{
SelectExit(m_Interactors[i], interactable);
}
}
}
interactor.OnSelectEnter(interactable);
interactable.OnSelectEnter(interactor);
}
/// <summary>
/// Register a new Interactable to be processed.
/// </summary>
/// <param name="interactable">The Interactable to be registered.</param>
public virtual void RegisterInteractable(XRBaseInteractable interactable)
{
if (m_Interactables.Register(interactable))
{
foreach (var interactableCollider in interactable.colliders)
{
if (interactableCollider != null && !m_ColliderToInteractableMap.ContainsKey(interactableCollider))
{
m_ColliderToInteractableMap.Add(interactableCollider, interactable);
}
}
m_InteractableRegisteredEventArgs.manager = this;
m_InteractableRegisteredEventArgs.interactable = interactable;
OnRegistered(m_InteractableRegisteredEventArgs);
}
}
int InteractableSortComparison(XRBaseInteractable x, XRBaseInteractable y)
{
float xDistance = m_InteractableDistanceSqrMap[x];
float yDistance = m_InteractableDistanceSqrMap[y];
if (xDistance > yDistance)
{
return(1);
}
if (xDistance < yDistance)
{
return(-1);
}
else
{
return(0);
}
}
/// <summary>This method is called when the interactor first initiates hover of an interactable.</summary>
/// <param name="interactable">Interactable that is being hovered.</param>
protected internal override void OnHoverEnter(XRBaseInteractable interactable)
{
base.OnHoverEnter(interactable);
if (m_PlayHapticsOnHoverEnter && m_Controller)
{
SendHapticImpulse(m_HapticHoverEnterIntensity, m_HapticHoverEnterDuration);
}
if (playAudioClipOnHoverEnter && AudioClipForOnHoverEnter != null)
{
if (m_EffectsAudioSource == null)
{
CreateEffectsAudioSource();
}
m_EffectsAudioSource.PlayOneShot(AudioClipForOnHoverEnter);
}
}
public virtual void RegisterInteractable(XRBaseInteractable interactable)
{
if (!m_Interactables.Contains(interactable))
{
m_Interactables.Add(interactable);
foreach (var interactableCollider in interactable.colliders)
{
if (interactableCollider != null && !m_ColliderToInteractableMap.ContainsKey(interactableCollider))
{
m_ColliderToInteractableMap.Add(interactableCollider, interactable);
}
}
#if AR_FOUNDATION_PRESENT
if (interactable is ARBaseGestureInteractable)
{
m_GestureInteractablesNeedReconnect = true;
}
#endif
}
}
internal void UnregisterInteractable(XRBaseInteractable interactable)
{
if (m_Interactables.Contains(interactable))
{
m_Interactables.Remove(interactable);
foreach (var collider in interactable.colliders)
{
if (collider != null && m_ColliderToInteractableMap.ContainsKey(collider))
{
m_ColliderToInteractableMap.Remove(collider);
}
}
#if AR_FOUNDATION_PRESENT
if (interactable is ARBaseGestureInteractable)
{
m_GestureInteractablesNeedReconnect = true;
}
#endif
}
}
public override void GetValidTargets(List <XRBaseInteractable> validTargets)
{
base.GetValidTargets(validTargets);
float minDistance = float.MaxValue;
XRBaseInteractable minBaseInteractable = null;
// Calculate distance squared to interactor's attach transform and add to validTargets (which is sorted before returning)
foreach (var interactable in validTargets)
{
float dist = interactable.GetDistanceSqrToInteractor(this);
if (dist < minDistance)
{
minDistance = dist;
minBaseInteractable = interactable;
}
}
if (minBaseInteractable != null)
{
validTargets = new List <XRBaseInteractable>();
validTargets.Add(minBaseInteractable);
}
}
internal void RegisterInteractable(XRBaseInteractable interactable)
{
if (!m_Interactables.Contains(interactable))
{
m_Interactables.Add(interactable);
foreach (var collider in interactable.colliders)
{
if (collider != null && !m_ColliderToInteractableMap.ContainsKey(collider))
{
m_ColliderToInteractableMap.Add(collider, interactable);
}
}
#if AR_FOUNDATION_PRESENT
if (interactable is ARBaseGestureInteractable)
{
var arb = interactable as ARBaseGestureInteractable;
arb.DisconnectGestureInteractor();
m_GestureInteractablesNeedReconnect = true;
}
#endif
}
}
/// <summary>This method is called when the interactor ends selection of an interactable.</summary>
/// <param name="interactable">Interactable that is no longer selected.</param>
protected internal override void OnSelectExit(XRBaseInteractable interactable)
{
base.OnSelectExit(interactable);
if (m_Controller)
{
m_Controller.hideControllerModel = false;
}
if (m_PlayHapticsOnSelectExit && m_Controller)
{
SendHapticImpulse(m_HapticSelectExitIntensity, m_HapticSelectExitDuration);
}
if (playAudioClipOnSelectExit && AudioClipForOnSelectExit != null)
{
if (m_EffectsAudioSource == null)
{
CreateEffectsAudioSource();
}
m_EffectsAudioSource.PlayOneShot(AudioClipForOnSelectExit);
}
}
void Awake()
{
m_Interactable = GetComponent <XRBaseInteractable>();
if (m_Interactable)
{
m_Interactable.onHoverEnter.AddListener(OnFirstHoverEnter);
m_Interactable.onLastHoverExit.AddListener(OnLastHoverExit);
m_Interactable.onSelectEnter.AddListener(OnSelectEnter);
m_Interactable.onSelectExit.AddListener(OnSelectExit);
}
else
{
Debug.LogWarning("Could not find interactable for helper.", this);
}
if (m_TintRenderers.Count == 0)
{
m_TintRenderers = new List <Renderer>(GetComponents <Renderer>());
if (m_TintRenderers.Count == 0)
{
Debug.LogWarning("Could not find required Renderer component.", this);
}
}
}
void HoverExit(XRBaseInteractor interactor, XRBaseInteractable interactable)
{
interactor.OnHoverExit(interactable);
interactable.OnHoverExit(interactor);
}
void SelectExit(XRBaseInteractor interactor, XRBaseInteractable interactable)
{
interactor.OnSelectExit(interactable);
interactable.OnSelectExit(interactor);
}
internal void ForceSelect(XRBaseInteractor interactor, XRBaseInteractable interactable)
{
SelectEnter(interactor, interactable);
}
