/// <summary>
/// Iterate over the configured list of loaders and attempt to initialize each one. The first one
/// that succeeds is set as the active loader and initialization immediately terminates.
///
/// When complete <see cref="isInitializationComplete"> will be set to true. This will mark that it is safe to
/// call other parts of the API. This does not guarantee that init successfully created a loader. For that
/// you need to check that ActiveLoader is not null.
///
/// Note that there can only be one active loader. Any attempt to initialize a new active loader with one
/// already set will cause a warning to be logged and immediate exit of this function.
/// </summary>
///
/// <returns>Enumerator marking the next spot to continue execution at.</returns>
public IEnumerator InitializeLoader()
{
if (activeLoader != null)
{
Debug.LogWarning(
"XR Management has already initialized an active loader in this scene." +
"Please make sure to stop all subsystems and deinitialize the active loader before initializing a new one.");
yield break;
}
foreach (var loader in loaders)
{
if (loader != null)
{
if (loader.Initialize())
{
activeLoader = loader;
m_InitializationComplete = true;
yield break;
}
}
yield return(null);
}
activeLoader = null;
}
/// <summary>
/// Attempts to append the given loader to the list of loaders at the given index.
/// </summary>
/// <param name="loader">
/// The <see cref="XRLoader"/> to be added to this manager's instance of loaders.
/// </param>
/// <param name="index">
/// The index at which the given <see cref="XRLoader"/> should be added. If you set a negative or otherwise
/// invalid index, the loader will be appended to the end of the list.
/// </param>
/// <returns>
/// <c>true</c> if the loader is not a duplicate and was added to the list successfully, <c>false</c>
/// otherwise.
/// </returns>
/// <remarks>
/// This method behaves differently in the Editor and during runtime/Play mode. While your app runs in the Editor and not in
/// Play mode, attempting to add an <see cref="XRLoader"/> will always succeed and register that loader's type
/// internally. Attempting to add a loader during runtime/Play mode will trigger a check to see whether a loader of
/// that type was registered. If the check is successful, the loader is added. If not, the loader is not added and the method
/// returns <c>false</c>.
/// </remarks>
public bool TryAddLoader(XRLoader loader, int index = -1)
{
if (loader == null || currentLoaders.Contains(loader))
{
return(false);
}
#if UNITY_EDITOR
if (!EditorApplication.isPlaying && !m_RegisteredLoaders.Contains(loader))
{
m_RegisteredLoaders.Add(loader);
}
#endif
if (!m_RegisteredLoaders.Contains(loader))
{
return(false);
}
if (index < 0 || index >= currentLoaders.Count)
{
currentLoaders.Add(loader);
}
else
{
currentLoaders.Insert(index, loader);
}
return(true);
}
internal void InitializeLoaderSync()
{
if (activeLoader != null)
{
Debug.LogWarning(
"XR Management has already initialized an active loader in this scene." +
"Please make sure to stop all subsystems and deinitialize the active loader before initializing a new one.");
return;
}
foreach (var loader in loaders)
{
if (loader != null)
{
if (loader.Initialize())
{
activeLoader = loader;
m_InitializationComplete = true;
return;
}
}
}
activeLoader = null;
}
private bool CheckLoaderRegistration(XRLoader loader)
{
#if UNITY_EDITOR
// Need to check if the application is in play mode, if not then the set of registered loaders is mutable.
if (!Application.isPlaying)
{
return(!m_RegisteredLoaders.Contains(loader));
}
#endif
return(m_RegisteredLoaders.Contains(loader) && !currentLoaders.Contains(loader));
}
private bool CheckGraphicsAPICompatibility(XRLoader loader)
{
GraphicsDeviceType deviceType = SystemInfo.graphicsDeviceType;
List <GraphicsDeviceType> supportedDeviceTypes = loader.GetSupportedGraphicsDeviceTypes(false);
// To help with backward compatibility, if the compatibility list is empty we assume that it does not implement the GetSupportedGraphicsDeviceTypes method
// Therefore we revert to the previous behavior of building or starting the loader regardless of gfx api settings.
if (supportedDeviceTypes.Count > 0 && !supportedDeviceTypes.Contains(deviceType))
{
Debug.LogWarning(String.Format("The {0} does not support the initialized graphics device, {1}. Please change the preffered Graphics API in PlayerSettings. Attempting to start the next XR loader.", loader.name, deviceType.ToString()));
return(false);
}
return(true);
}
/// <summary>
/// Attempts to remove the first instance of a given loader from the list of loaders.
/// </summary>
/// <param name="loader">
/// The <see cref="XRLoader"/> to be removed from this manager's instance of loaders.
/// </param>
/// <returns>
/// <c>true</c> if the loader was successfully removed from the list, <c>false</c> otherwise.
/// </returns>
/// <remarks>
/// This method behaves differently in the Editor and during runtime/Play mode. During runtime/Play mode, the loader
/// will be removed with no additional side effects if it is in the list managed by this instance. While in the
/// Editor and not in Play mode, the loader will be removed if it exists and
/// it will be unregistered from this instance and any attempts to add it during
/// runtime/Play mode will fail. You can re-add the loader in the Editor while not in Play mode.
/// </remarks>
public bool TryRemoveLoader(XRLoader loader)
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
m_RegisteredLoaders.Remove(loader);
}
#endif
if (currentLoaders.Contains(loader))
{
return(currentLoaders.Remove(loader));
}
return(true);
}
/// <summary>
/// Attempts to remove the first instance of a given loader from the list of loaders.
/// </summary>
/// <param name="loader">
/// The <see cref="XRLoader"/> to be removed from this manager's instance of loaders.
/// </param>
/// <returns>
/// <c>true</c> if the loader was successfully removed from the list, <c>false</c> otherwise.
/// </returns>
/// <remarks>
/// This method behaves differently in the Editor and during runtime/Play mode. During runtime/Play mode, the loader
/// will be removed with no additional side effects if it is in the list managed by this instance. While in the
/// Editor and not in Play mode, the loader will be removed if it exists and
/// it will be unregistered from this instance and any attempts to add it during
/// runtime/Play mode will fail. You can re-add the loader in the Editor while not in Play mode.
/// </remarks>
public bool TryRemoveLoader(XRLoader loader)
{
var removedLoader = true;
if (currentLoaders.Contains(loader))
{
removedLoader = currentLoaders.Remove(loader);
}
#if UNITY_EDITOR
if (!EditorApplication.isPlaying && !currentLoaders.Contains(loader))
{
m_RegisteredLoaders.Remove(loader);
}
#endif
return(removedLoader);
}
/// <summary>
/// If there is an active loader, this function will deinitialize it and remove the active loader instance from
/// management. We will automatically call <see cref="StopSubsystems"/> prior to deinitialization to make sure
/// that things are cleaned up appropriately.
///
/// You must wait for <see cref="isInitializationComplete"> to be set to tru prior to calling this API.
///
/// Upon return <see cref="isInitializationComplete"> will be rest to false;
/// </summary>
public void DeinitializeLoader()
{
if (!m_InitializationComplete)
{
Debug.LogWarning(
"Call to DeinitializeLoader without an initialized manager." +
"Please make sure wait for initialization to complete before calling this API.");
return;
}
StopSubsystems();
if (activeLoader != null)
{
activeLoader.Deinitialize();
activeLoader = null;
}
m_InitializationComplete = false;
}
/// <summary>
/// Attempts to append the given loader to the list of loaders at the given index.
/// </summary>
/// <param name="loader">
/// The <see cref="XRLoader"/> to be added to this manager's instance of loaders.
/// </param>
/// <param name="index">
/// The index at which the given <see cref="XRLoader"/> should be added. If you set a negative or otherwise
/// invalid index, the loader will be appended to the end of the list.
/// </param>
/// <returns>
/// <c>true</c> if the loader is not a duplicate and was added to the list successfully, <c>false</c>
/// otherwise.
/// </returns>
/// <remarks>
/// This method behaves differently in the Editor and during runtime/Play mode. While your app runs in the Editor and not in
/// Play mode, attempting to add an <see cref="XRLoader"/> will always succeed and register that loader's type
/// internally. Attempting to add a loader during runtime/Play mode will trigger a check to see whether a loader of
/// that type was registered. If the check is successful, the loader is added. If not, the loader is not added and the method
/// returns <c>false</c>.
/// </remarks>
public bool TryAddLoader(XRLoader loader, int index = -1)
{
if (loader == null || !CheckLoaderRegistration(loader))
{
return(false);
}
#if UNITY_EDITOR
m_RegisteredLoaders.Add(loader);
#endif
if (index < 0 || index >= currentLoaders.Count)
{
currentLoaders.Add(loader);
}
else
{
currentLoaders.Insert(index, loader);
}
return(true);
}
