private IEnumerator UpdateBinding()
{
if (null != _text)
{
_text.text = _actionReference.action.name;
}
while (isActiveAndEnabled)
{
if (_actionReference.action != null &&
_actionReference.action.controls.Count > 0 &&
_actionReference.action.controls[0].device != null &&
OpenXRInput.TryGetInputSourceName(_actionReference.action, 0, out var actionName, OpenXRInput.InputSourceNameFlags.Component, _actionReference.action.controls[0].device))
{
if (null != _text)
{
_text.text = actionName;
}
OnActionBound();
break;
}
yield return(new WaitForSeconds(1.0f));
}
}
/// <summary>
/// Add an action map to the Unity Input System.
///
/// This method must be called from within the RegisterActionMapsWithRuntime method.
/// </summary>
/// <param name="map">Action map to add</param>
protected void AddActionMap(ActionMapConfig map)
{
if (!m_AllowAddActionMap)
{
Debug.LogError("ActionMap must be added from within the RegisterActionMapsWithRuntime method");
return;
}
OpenXRInput.AddActionMap(map);
}
private IEnumerator UpdateVisibility()
{
while (isActiveAndEnabled)
{
if (_actionReference.action != null &&
_actionReference.action.controls.Count > 0 &&
_actionReference.action.controls[0].device != null &&
OpenXRInput.TryGetInputSourceName(_actionReference.action, 0, out var actionName, OpenXRInput.InputSourceNameFlags.Component, _actionReference.action.controls[0].device))
{
_target.SetActive(true);
break;
}
yield return(new WaitForSeconds(1.0f));
}
}
private void StopInternal()
{
OpenXRFeature.ReceiveLoaderEvent(this, OpenXRFeature.LoaderEvent.SubsystemStop);
if (inputSubsystem?.running ?? false)
{
StopSubsystem <XRInputSubsystem>();
}
if (displaySubsystem?.running ?? false)
{
StopSubsystem <XRDisplaySubsystem>();
}
OpenXRInput.Stop();
Internal_EndSession();
}
private void Start()
{
if (action == null || hapticAction == null)
{
return;
}
action.action.Enable();
hapticAction.action.Enable();
action.action.performed += (ctx) =>
{
var control = action.action.activeControl;
if (null == control)
{
return;
}
OpenXRInput.SendHapticImpulse(hapticAction.action, _amplitude, _frequency, _duration, control.device);
};
}
private bool StartInternal()
{
// In order to get XrReady, we have to at least attempt to create
// the session if it isn't already there.
if (!Internal_CreateSessionIfNeeded())
{
return(false);
}
if (currentOpenXRState != OpenXRFeature.NativeEvent.XrReady ||
(currentLoaderState != LoaderState.StartAttempted && currentLoaderState != LoaderState.Started))
{
return(true);
}
// calls xrBeginSession
Internal_BeginSession();
OpenXRInput.AttachActionSets();
// Note: Display has to be started before Input so that Input can have access to the Session object
StartSubsystem <XRDisplaySubsystem>();
if (!displaySubsystem?.running ?? false)
{
return(false);
}
StartSubsystem <XRInputSubsystem>();
if (!inputSubsystem?.running ?? false)
{
return(false);
}
OpenXRFeature.ReceiveLoaderEvent(this, OpenXRFeature.LoaderEvent.SubsystemStart);
return(true);
}
private static void ReceiveNativeEvent(OpenXRFeature.NativeEvent e, ulong payload)
{
var loader = Instance;
if (loader != null)
{
loader.currentOpenXRState = e;
}
switch (e)
{
case OpenXRFeature.NativeEvent.XrRestartRequested:
CreateRestarter(loader, true);
break;
case OpenXRFeature.NativeEvent.XrReady:
loader.StartInternal();
break;
case OpenXRFeature.NativeEvent.XrFocused:
DiagnosticReport.DumpReport("System Startup Completed");
break;
default:
break;
}
OpenXRFeature.ReceiveNativeEvent(e, payload);
if ((loader == null || !loader.isStarted) && e != OpenXRFeature.NativeEvent.XrInstanceChanged)
{
return;
}
switch (e)
{
case OpenXRFeature.NativeEvent.XrInstanceChanged:
OpenXRInput.InstanceHasChanged();
OpenXRInput.SendActionDataToProvider();
break;
case OpenXRFeature.NativeEvent.XrSessionChanged:
OpenXRInput.CreateActionsAndSuggestedBindings();
OpenXRInput.AttachActionSetsToSession();
break;
case OpenXRFeature.NativeEvent.XrStopping:
loader.StopInternal();
break;
case OpenXRFeature.NativeEvent.XrExiting:
CreateRestarter(loader, false);
break;
case OpenXRFeature.NativeEvent.XrLossPending:
CreateRestarter(loader, true);
break;
case OpenXRFeature.NativeEvent.XrInstanceLossPending:
OpenXRLoader.CreateRestarter(loader, false);
break;
default:
break;
}
}
private bool InitializeInternal()
{
Instance = this;
currentLoaderState = LoaderState.InitializeAttempted;
#if TEST_SUPPORT
if (ShouldExitEarly())
{
return(false);
}
#endif
#if UNITY_EDITOR
if (!DisableValidationChecksOnEnteringPlaymode)
{
if (OpenXRProjectValidation.LogPlaymodeValidationIssues())
{
return(false);
}
}
#endif
OpenXRFeature.Initialize();
if (!LoadOpenXRSymbols())
{
Debug.LogError("Failed to load openxr runtime loader.");
return(false);
}
// Sort the features array by priority in descending order (highest priority first)
OpenXRSettings.Instance.features = OpenXRSettings.Instance.features
.Where(f => f != null)
.OrderByDescending(f => f.priority)
.ThenBy(f => f.nameUi)
.ToArray();
OpenXRFeature.HookGetInstanceProcAddr();
if (!Internal_InitializeSession())
{
return(false);
}
SetApplicationInfo();
RequestOpenXRFeatures();
RegisterOpenXRCallbacks();
if (null != OpenXRSettings.Instance)
{
OpenXRSettings.Instance.ApplySettings();
}
if (!CreateSubsystems())
{
return(false);
}
if (OpenXRFeature.requiredFeatureFailed)
{
return(false);
}
OpenXRAnalytics.SendInitializeEvent(true);
OpenXRFeature.ReceiveLoaderEvent(this, OpenXRFeature.LoaderEvent.SubsystemCreate);
OpenXRInput.Initialize();
DebugLogEnabledSpecExtensions();
Application.onBeforeRender += ProcessOpenXRMessageLoop;
currentLoaderState = LoaderState.Initialized;
return(true);
}
public void OpenXRInput_AttachActionSets_BeforeInitializing()
{
Assert.IsFalse(OpenXRInput.Internal_AttachActionSets());
}
public void OpenXRInput_SuggestBindings_BeforeInitializing()
{
Assert.IsFalse(OpenXRInput.Internal_SuggestBindings("", null, 0));
}
public void OpenXRInput_TryGetInputSourceName_BeforeInitializing()
{
Assert.IsFalse(OpenXRInput.Internal_TryGetInputSourceName(0, 0, 0, 0, out var name));
}
