internal static async Task <bool> TryToEnableLoader(string loaderName)
{
EditorPrefs.SetBool(IsXRLoaderInitialized, true);
SettingsService.OpenProjectSettings("Project/XR Plug-in Management");
Stopwatch stopwatch = Stopwatch.StartNew();
while (XRGeneralSettings.Instance == null)
{
await Task.Delay(500);
if (stopwatch.ElapsedMilliseconds > 5000f)
{
EditorUtility.DisplayDialog($"The {loaderName} could not be enable!", $"The XR general settings file is missing. Enable {loaderName} manually here:\nEdit > Project Settings... > XR Plug-in Management.", "Continue");
return(false);
}
}
stopwatch.Stop();
if (XRGeneralSettings.Instance.Manager.activeLoaders.Any(xrLoader => xrLoader.GetType().Name == loaderName))
{
return(true);
}
XRLoader loader = ScriptableObject.CreateInstance(loaderName) as XRLoader;
return(XRGeneralSettings.Instance.Manager.TryAddLoader(loader));
}
private static XRInputSubsystem GetXRInputSubsystem()
{
XRGeneralSettings xrSettings = XRGeneralSettings.Instance;
if (xrSettings == null)
{
Debug.LogWarning($"GetXRInputSubsystem: XRGeneralSettings is null.");
return(null);
}
XRManagerSettings xrManager = xrSettings.Manager;
if (xrManager == null)
{
Debug.LogWarning($"GetXRInputSubsystem: XRManagerSettings is null.");
return(null);
}
XRLoader xrLoader = xrManager.activeLoader;
if (xrLoader == null)
{
Debug.LogWarning($"GetXRInputSubsystem: XRLoader is null.");
return(null);
}
XRInputSubsystem xrInputSubsystem = xrLoader.GetLoadedSubsystem <XRInputSubsystem>();
if (xrInputSubsystem == null)
{
Debug.LogWarning($"GetXRInputSubsystem: XRInputSubsystem is null.");
return(null);
}
return(xrInputSubsystem);
}
/// <summary>
/// Remove a previously assigned loader from settings. If the loader type is unknown or
/// an instance of the loader can't be found in the project folder no action is taken.
///
/// Removal will not delete the instance from the project folder.
/// </summary>
/// <param name="settings">An instance of <see cref="XRManagerSettings"/> to add the loader to.</param>
/// <param name="loaderTypeName">The full type name for the loader instance to remove from settings.</param>
/// <param name="buildTargetGroup">The build target group being removed from.</param>
/// <returns>True if removal succeeds, false if not.</returns>
public static bool RemoveLoader(XRManagerSettings settings, string loaderTypeName, BuildTargetGroup buildTargetGroup)
{
if (EditorApplication.isPlaying || EditorApplication.isPaused)
{
Debug.LogError($"Attempt to remove {loaderTypeName} for {buildTargetGroup} while in Play mode. XR Plug-in Management can not make changes to the loader list when running.");
return(false);
}
var instance = EditorUtilities.GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
return(false);
}
XRLoader loader = instance as XRLoader;
if (settings.TryRemoveLoader(loader))
{
EditorUtility.SetDirty(settings);
AssetDatabase.SaveAssets();
#if UNITY_EDITOR
var loaderHelper = loader as XRLoaderHelper;
loaderHelper?.WasUnassignedFromBuildTarget(buildTargetGroup);
#endif
return(true);
}
return(false);
}
void AddLoaderMenuSelected(object data)
{
int selected = (int)data;
LoaderInfo info = m_LoadersNotInUse[selected];
if (info.instance == null)
{
string newAssetName = String.Format("New {0}.asset", TypeNameToString(info.loaderType));
XRLoader loader = ScriptableObject.CreateInstance(info.loaderType) as XRLoader;
string assetPath = EditorUtility.SaveFilePanelInProject("Create new XR Loader asset",
newAssetName,
"asset",
"Please enter a name and location where the loader asset can be created at.");
if (string.IsNullOrEmpty(assetPath))
{
return;
}
info.instance = loader;
info.assetName = Path.GetFileNameWithoutExtension(assetPath);
AssetDatabase.CreateAsset(loader, assetPath);
m_ShouldReload = true;
}
m_LoadersNotInUse.Remove(info);
info.isUsed = true;
m_LoadersInUse.Add(info);
UpdateSerializedProperty();
}
protected bool EnableLoader(string loaderTypeName, bool enable)
{
XRGeneralSettings settings = XRGeneralSettings.Instance;
if (settings == null || settings.Manager == null)
{
return(false);
}
var instance = TestBaseSetup.GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
return(false);
}
XRLoader loader = instance as XRLoader;
bool ret = true;
#pragma warning disable CS0618
if (enable)
{
settings.Manager.loaders.Add(loader);
}
else
{
ret = settings.Manager.loaders.Remove(loader);
}
#pragma warning restore CS0618
return(ret);
}
protected bool EnableLoader(string loaderTypeName, bool enable)
{
XRGeneralSettings settings = XRGeneralSettings.Instance;
if (settings == null || settings.Manager == null)
{
return(false);
}
var instance = TestBaseSetup.GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
return(false);
}
XRLoader loader = instance as XRLoader;
bool ret = true;
if (enable)
{
List <XRLoader> loaders = new List <XRLoader> {
loader
};
settings.Manager.TrySetLoaders(loaders);
}
else
{
ret = settings.Manager.TryRemoveLoader(loader);
}
return(ret);
}
public IEnumerator InstantiateHuman(int numberOfLogins)
{
// Initialize XR System
XRManagerSettings xrManagerSettings = XRGeneralSettings.Instance.Manager;
if (xrManagerSettings == null)
{
SIGVerseLogger.Error("xrManagerSettings == null"); yield break;
}
if (xrManagerSettings.activeLoader == null)
{
yield return(xrManagerSettings.InitializeLoader());
}
this.activeLoader = xrManagerSettings.activeLoader;
if (this.activeLoader == null)
{
Debug.LogError("Initializing XR Failed.");
yield break;
}
xrManagerSettings.activeLoader.Start();
// Instantiate Human
PhotonNetwork.NickName = HumanNamePrefix + PhotonNetwork.LocalPlayer.ActorNumber;
ExitGames.Client.Photon.Hashtable customPropertie = new ExitGames.Client.Photon.Hashtable();
customPropertie.Add(AvatarNameKey, PhotonNetwork.NickName + "#" + this.humanPrefabName);
PhotonNetwork.LocalPlayer.SetCustomProperties(customPropertie);
GameObject player = PhotonNetwork.Instantiate(this.humanPrefabName, this.humanPositions[numberOfLogins], Quaternion.Euler(this.humanEulerAngles[numberOfLogins]));
}
public IEnumerator InitializeXR()
{
// Initialize XR System
XRManagerSettings xrManagerSettings = XRGeneralSettings.Instance.Manager;
if (xrManagerSettings == null)
{
SIGVerseLogger.Error("XR initialization failed. xrManagerSettings == null");
yield break;
}
if (xrManagerSettings.activeLoader == null)
{
yield return(xrManagerSettings.InitializeLoader());
}
this.activeLoader = xrManagerSettings.activeLoader;
if (this.activeLoader == null)
{
Debug.LogError("XR initialization failed. activeLoader == null");
yield break;
}
xrManagerSettings.activeLoader.Start();
}
protected bool EnableLoader(string loaderTypeName, bool enable, BuildTargetGroup buildTargetGroup = BuildTargetGroup.Standalone)
{
#if UNITY_EDITOR
XRGeneralSettings settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(buildTargetGroup);
#else
XRGeneralSettings settings = XRGeneralSettings.Instance;
#endif
if (settings == null || settings.Manager == null)
{
return(false);
}
var instance = TestBaseSetup.GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
return(false);
}
XRLoader loader = instance as XRLoader;
bool ret = false;
if (enable)
{
ret = settings.Manager.TryAddLoader(loader);
}
else
{
ret = settings.Manager.TryRemoveLoader(loader);
}
return(ret);
}
protected bool IsLoaderEnabledForTarget(BuildTargetGroup buildTargetGroup, string loaderTypeName)
{
if (buildTargetGroup != BuildTargetGroup.Standalone && buildTargetGroup != BuildTargetGroup.WSA)
{
return(false);
}
#if UNITY_EDITOR
XRGeneralSettings settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(buildTargetGroup);
#else
XRGeneralSettings settings = XRGeneralSettings.Instance;
#endif
if (settings == null || settings.Manager == null)
{
return(false);
}
var instance = TestBaseSetup.GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
return(false);
}
XRLoader loader = instance as XRLoader;
return(settings.Manager.activeLoaders.Contains(loader));
}
private IEnumerator InitializeXRForDataGeneration()
{
// Initialize XR System
XRManagerSettings xrManagerSettings = XRGeneralSettings.Instance.Manager;
if (xrManagerSettings == null)
{
SIGVerseLogger.Error("xrManagerSettings == null"); yield break;
}
if (xrManagerSettings.activeLoader == null)
{
yield return(xrManagerSettings.InitializeLoader());
}
this.activeLoader = xrManagerSettings.activeLoader;
if (this.activeLoader == null)
{
Debug.LogError("Initializing XR Failed.");
yield break;
}
xrManagerSettings.activeLoader.Start();
SteamVR_Actions.sigverse.Activate(SteamVR_Input_Sources.Any);
}
XRInputSubsystem GetActiveSubsystemInstance()
{
XRInputSubsystem activeSubsystem = null;
#if USE_XR_MANAGEMENT
// If the XR management package has been included, query the currently
// active loader for the created subsystem, if one exists.
if (XRGeneralSettings.Instance != null && XRGeneralSettings.Instance.Manager != null)
{
XRLoader loader = XRGeneralSettings.Instance.Manager.activeLoader;
if (loader != null)
{
activeSubsystem = loader.GetLoadedSubsystem <XRInputSubsystem>();
}
}
#endif
// If XR management is not used or no loader has been set, check for
// any active subsystem instances in the SubsystemManager.
if (activeSubsystem == null)
{
List <XRInputSubsystem> subsystemInstances = new List <XRInputSubsystem>();
SubsystemManager.GetInstances(subsystemInstances);
if (subsystemInstances.Count > 0)
{
activeSubsystem = subsystemInstances[0];
}
}
return(activeSubsystem);
}
private void StartUnityXR(XRLoader xrLoader)
{
#if USING_UNITY_XR
// Starting up the XR Manager if needed
if (xrLoader != XRLoader.None && xrLoader != XRLoader.Unknown && UnityEngine.XR.Management.XRGeneralSettings.Instance.InitManagerOnStart == false)
{
MoveLoaderToTop(xrLoader);
this.manuallyInitXRManager = true;
UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager.InitializeLoaderSync();
UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager.StartSubsystems();
}
void MoveLoaderToTop(XRLoader loader)
{
string loaderName = this.GetLoaderName(loader);
if (loaderName == null)
{
Debug.LogError($"Unkonwn XRLoader Type \"{xrLoader}\" encountered");
return;
}
var activeLoaders = UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager.activeLoaders;
var reorderedLoaders = new List <UnityEngine.XR.Management.XRLoader>(activeLoaders.Count);
var foundLoader = false;
foreach (var xrLoader in activeLoaders)
{
if (xrLoader.name == loaderName)
{
reorderedLoaders.Insert(0, xrLoader);
foundLoader = true;
}
else
{
reorderedLoaders.Add(xrLoader);
}
}
bool trySetSuccess = UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager.TrySetLoaders(reorderedLoaders);
if (trySetSuccess == false)
{
Debug.LogError($"Unable to set our new XR Laoder order!");
}
if (foundLoader == false)
{
Debug.LogError($"Unable to find XR Loader in the XR Settings {loaderName}");
}
}
#endif
}
/// <summary>
/// Assigns a loader of type loaderTypeName to the settings instance. Will instantiate an
/// instance if one can't be found in the users project folder before assigning it.
/// </summary>
/// <param name="settings">An instance of <see cref="XRManagerSettings"/> to add the loader to.</param>
/// <param name="loaderTypeName">The full type name for the loader instance to assign to settings.</param>
/// <param name="buildTargetGroup">The build target group being assigned to.</param>
/// <returns>True if assignment succeeds, false if not.</returns>
public static bool AssignLoader(XRManagerSettings settings, string loaderTypeName, BuildTargetGroup buildTargetGroup)
{
if (EditorApplication.isPlaying || EditorApplication.isPaused)
{
Debug.LogError($"Attempt to add {loaderTypeName} for {buildTargetGroup} while in Play mode. XR Plug-in Management can not make changes to the loader list when running.");
return(false);
}
var instance = EditorUtilities.GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
instance = EditorUtilities.CreateScriptableObjectInstance(loaderTypeName,
EditorUtilities.GetAssetPathForComponents(EditorUtilities.s_DefaultLoaderPath));
if (instance == null)
{
return(false);
}
}
XRLoader newLoader = instance as XRLoader;
if (settings.TryAddLoader(newLoader))
{
var assignedLoaders = settings.activeLoaders;
var orderedLoaders = new List <XRLoader>();
var allLoaders = GetAllLoadersForBuildTarget(buildTargetGroup);
foreach (var ldr in allLoaders)
{
var newInstance = EditorUtilities.GetInstanceOfTypeWithNameFromAssetDatabase(ldr.loaderType) as XRLoader;
if (newInstance != null && assignedLoaders.Contains(newInstance))
{
orderedLoaders.Add(newInstance);
#if UNITY_EDITOR
var loaderHelper = newLoader as XRLoaderHelper;
loaderHelper?.WasAssignedToBuildTarget(buildTargetGroup);
#endif
}
}
if (!settings.TrySetLoaders(orderedLoaders))
{
return(false);
}
EditorUtility.SetDirty(settings);
AssetDatabase.SaveAssets();
}
return(true);
}
/// <summary>
/// Assigns a loader of type loaderTypeName to the settings instance. Will instantiate an
/// instance if one can't be found in the users project folder before assigning it.
/// </summary>
/// <param name="settings">An instance of <see cref="XRManagerSettings"/> to add the loader to.</param>
/// <param name="loaderTypeName">The full type name for the loader instance to assign to settings.</param>
/// <param name="buildTargetGroup">The build target group being assigned to.</param>
/// <returns>True if assignment succeeds, false if not.</returns>
public static bool AssignLoader(XRManagerSettings settings, string loaderTypeName, BuildTargetGroup buildTargetGroup)
{
var instance = EditorUtilities.GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
instance = EditorUtilities.CreateScriptableObjectInstance(loaderTypeName,
EditorUtilities.GetAssetPathForComponents(EditorUtilities.s_DefaultLoaderPath));
if (instance == null)
{
return(false);
}
}
var assignedLoaders = settings.loaders;
XRLoader newLoader = instance as XRLoader;
if (!assignedLoaders.Contains(newLoader))
{
assignedLoaders.Add(newLoader);
settings.loaders = new List <XRLoader>();
var allLoaders = GetAllLoadersForBuildTarget(buildTargetGroup);
foreach (var ldr in allLoaders)
{
var newInstance = EditorUtilities.GetInstanceOfTypeWithNameFromAssetDatabase(ldr.loaderType) as XRLoader;
if (newInstance != null && assignedLoaders.Contains(newInstance))
{
settings.loaders.Add(newInstance);
#if UNITY_EDITOR
var loaderHelper = newLoader as XRLoaderHelper;
loaderHelper?.WasAssignedToBuildTarget(buildTargetGroup);
#endif
}
}
EditorUtility.SetDirty(settings);
AssetDatabase.SaveAssets();
}
return(true);
}
private XRLoader StartLoaders()
{
#if USING_UNITY_XR
var xrLoaders = UnityEngine.XR.Management.XRGeneralSettings.Instance.Manager.activeLoaders;
foreach (var loader in Enum.GetValues(typeof(XRLoader)))
{
XRLoader xrLoader = (XRLoader)loader;
if (xrLoader == XRLoader.None || xrLoader == XRLoader.Unknown)
{
continue;
}
var loaderName = this.GetLoaderName(xrLoader);
if (loaderName == null)
{
continue;
}
for (int i = 0; i < xrLoaders.Count; i++)
{
try
{
if (xrLoaders != null && xrLoaders[i].name == loaderName)
{
if (xrLoaders[i].Start())
{
return(xrLoader);
}
}
}
catch
{
}
}
}
#endif
return(XRLoader.None);
}
private static bool RemoveLoader(XRManagerSettings settings, string loaderTypeName)
{
var instance = GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
return(false);
}
XRLoader loader = instance as XRLoader;
if (settings.loaders.Contains(loader))
{
settings.loaders.Remove(loader);
EditorUtility.SetDirty(settings);
AssetDatabase.SaveAssets();
}
return(true);
}
// TODO: Move out to manager
void AddLoaderMenu(XRLoaderInfo info)
{
if (info.instance == null)
{
string newAssetName = String.Format("{0}.asset", EditorUtilities.TypeNameToString(info.loaderType));
XRLoader loader = ScriptableObject.CreateInstance(info.loaderType) as XRLoader;
string assetPath = EditorUtilities.GetAssetPathForComponents(EditorUtilities.s_DefaultLoaderPath);
if (string.IsNullOrEmpty(assetPath))
{
return;
}
assetPath = Path.Combine(assetPath, newAssetName);
info.instance = loader;
info.assetName = Path.GetFileNameWithoutExtension(assetPath);
AssetDatabase.CreateAsset(loader, assetPath);
}
m_Manager.AssignLoader(info);
}
protected bool IsLoaderEnabledForTarget(string loaderTypeName)
{
XRGeneralSettings settings = XRGeneralSettings.Instance;
if (settings == null || settings.Manager == null)
{
return(false);
}
var instance = TestBaseSetup.GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
return(false);
}
XRLoader loader = instance as XRLoader;
return(settings.Manager.activeLoaders.Contains(loader));
}
/// <summary>
/// Returns the active <c>TSubsystem</c> instance if present, otherwise returns null.
/// </summary>
protected TSubsystem GetActiveSubsystemInstance()
{
TSubsystem activeSubsystem = null;
#if USE_XR_MANAGEMENT
// If the XR management package has been included, query the currently
// active loader for the created subsystem, if one exists.
if (XRGeneralSettings.Instance != null && XRGeneralSettings.Instance.Manager != null)
{
XRLoader loader = XRGeneralSettings.Instance.Manager.activeLoader;
if (loader != null)
{
activeSubsystem = loader.GetLoadedSubsystem <TSubsystem>();
}
}
#endif
// If XR management is not used or no loader has been set, check for
// any active subsystem instances in the SubsystemManager.
if (activeSubsystem == null)
{
SubsystemManager.GetInstances(s_SubsystemInstances);
#if !UNITY_2019_3_OR_NEWER
foreach (var instance in s_SubsystemInstances)
{
if (!s_DestroyedSubsystemTypes.Contains(instance))
{
return(instance);
}
}
#else
if (s_SubsystemInstances.Count > 0)
{
activeSubsystem = s_SubsystemInstances[0];
}
#endif
}
return(activeSubsystem);
}
/// <inheritdoc/>
public override void Draw(Rect window)
{
wasApplied = false;
GUILayout.BeginArea(window);
{
GUILayout.Label("VR Hardware Setup", CreatorEditorStyles.Title);
GUILayout.Label("Select the VR hardware you are working with:", CreatorEditorStyles.Header);
selectedLoader = CreatorGUILayout.DrawToggleGroup(selectedLoader, options, nameplates);
if (selectedLoader == XRLoader.Other)
{
GUILayout.Label("The Creator does not provide an automated setup for your device. You need to refer to your device's vendor documentation in order to enable a compatible loader in the Unity's XR Plugin Management.", CreatorEditorStyles.Paragraph);
GUILayout.BeginHorizontal();
GUILayout.Label("Please tell us which VR Hardware you are using:", CreatorEditorStyles.Label);
otherHardwareText = CreatorGUILayout.DrawTextField(otherHardwareText, -1, GUILayout.Width(window.width * 0.4f));
GUILayout.EndHorizontal();
}
}
GUILayout.EndArea();
}
/// <summary>
/// Returns the active <c>TSubsystem</c> instance if present, otherwise returns null.
/// </summary>
/// <returns>The active subsystem instance, or `null` if there isn't one.</returns>
protected TSubsystem GetActiveSubsystemInstance()
{
TSubsystem activeSubsystem = null;
// Query the currently active loader for the created subsystem, if one exists.
if (XRGeneralSettings.Instance != null && XRGeneralSettings.Instance.Manager != null)
{
XRLoader loader = XRGeneralSettings.Instance.Manager.activeLoader;
if (loader != null)
{
activeSubsystem = loader.GetLoadedSubsystem <TSubsystem>();
}
}
if (activeSubsystem == null)
{
Debug.LogWarningFormat($"No active {typeof(TSubsystem).FullName} is available. Please ensure that a " +
"valid loader configuration exists in the XR project settings.");
}
return(activeSubsystem);
}
private static bool AssignLoader(XRManagerSettings settings, string loaderTypeName)
{
var instance = GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
instance = CreateScriptableObjectInstance(loaderTypeName, GetAssetPathForComponents(new string[] { "XR", "Loaders" }));
if (instance == null)
{
return(false);
}
}
List <XRLoader> assignedLoaders = new List <XRLoader>(settings.loaders);
XRLoader newLoader = instance as XRLoader;
if (!assignedLoaders.Contains(newLoader))
{
assignedLoaders.Add(newLoader);
settings.loaders.Clear();
List <string> allLoaderTypeNames = GetAllLoaderTypeNames();
foreach (var typeName in allLoaderTypeNames)
{
var newInstance = GetInstanceOfTypeWithNameFromAssetDatabase(typeName) as XRLoader;
if (newInstance != null && assignedLoaders.Contains(newInstance))
{
settings.loaders.Add(newInstance);
}
}
EditorUtility.SetDirty(settings);
AssetDatabase.SaveAssets();
}
return(true);
}
void AddLoaderMenu(LoaderInfo info)
{
if (info.instance == null)
{
string newAssetName = String.Format("{0}.asset", EditorUtilities.TypeNameToString(info.loaderType));
XRLoader loader = ScriptableObject.CreateInstance(info.loaderType) as XRLoader;
string assetPath = EditorUtilities.GetAssetPathForComponents(EditorUtilities.s_DefaultLoaderPath);
if (string.IsNullOrEmpty(assetPath))
{
return;
}
assetPath = Path.Combine(assetPath, newAssetName);
info.instance = loader;
info.assetName = Path.GetFileNameWithoutExtension(assetPath);
AssetDatabase.CreateAsset(loader, assetPath);
m_ShouldReload = true;
}
m_LoadersNotInUse.Remove(info);
m_LoadersInUse.Add(info);
UpdateSerializedProperty();
}
/// <summary>
/// Remove a previously assigned loader from settings. If the loader type is unknown or
/// an instance of the loader can't be found in the project folder no action is taken.
///
/// Removal will not delete the instance from the project folder.
/// </summary>
/// <param name="settings">An instance of <see cref="XRManagerSettings"/> to add the loader to.</param>
/// <param name="loaderTypeName">The full type name for the loader instance to remove from settings.</param>
/// <param name="buildTargetGroup">The build target group being removed from.</param>
/// <returns>True if removal succeeds, false if not.</returns>
public static bool RemoveLoader(XRManagerSettings settings, string loaderTypeName, BuildTargetGroup buildTargetGroup)
{
var instance = EditorUtilities.GetInstanceOfTypeWithNameFromAssetDatabase(loaderTypeName);
if (instance == null || !(instance is XRLoader))
{
return(false);
}
XRLoader loader = instance as XRLoader;
if (settings.loaders.Contains(loader))
{
settings.loaders.Remove(loader);
EditorUtility.SetDirty(settings);
AssetDatabase.SaveAssets();
#if UNITY_EDITOR
var loaderHelper = loader as XRLoaderHelper;
loaderHelper?.WasUnassignedFromBuildTarget(buildTargetGroup);
#endif
}
return(true);
}
private string GetLoaderName(XRLoader loader)
{
if (loader == XRLoader.None || loader == XRLoader.Unknown)
{
return(null);
}
else if (loader == XRLoader.Oculus)
{
return("Oculus Loader");
}
else if (loader == XRLoader.ARCore)
{
return("AR Core Loader");
}
else if (loader == XRLoader.ARKit)
{
return("AR Kit Loader");
}
else if (loader == XRLoader.MagicLeap)
{
return("Magic Leap Loader");
}
else if (loader == XRLoader.WindowsMixedReality)
{
return("Windows MR Loader");
}
else if (loader == XRLoader.SteamVR)
{
return(null); // "Steam VR Loader";
}
else
{
Debug.LogError($"Found Unknown XRLoader {loader}");
return(null);
}
}
private void ResetSettings()
{
CanProceed = false;
selectedLoader = XRLoader.None;
otherHardwareText = string.Empty;
}
internal static bool IsEnabledForPlatform(this XRLoader loader, BuildTargetGroup group)
{
var settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(group);
return(settings?.Manager?.loaders?.Contains(loader) ?? false);
}
private IEnumerator Start()
{
// only one can exist in scene at a time
if (singleton != null)
{
disposeAPI = false;// don't dispose apis if we're not the owner of possible native instances
Destroy(gameObject);
yield break;
}
DontDestroyOnLoad(gameObject);
singleton = this;
// print version
Debug.Log("XRInput version: 1.0.11");
// wait for XR loader
while (loader == null || !XRSettings.enabled)
{
try
{
if (loaderOverride != null)
{
loader = loaderOverride;
}
else
{
loader = XRGeneralSettings.Instance.Manager.activeLoader;
}
}
catch { }
yield return(new WaitForSeconds(1));
}
// give XR some time to start
var wait = new WaitForEndOfFrame();
yield return(wait);
yield return(wait);
yield return(wait);
yield return(wait);
yield return(wait);
yield return(new WaitForSeconds(1));
try
{
// init controller instance IDs
for (int i = 0; i != state_controllers.Length; ++i)
{
state_controllers[i].id = Guid.NewGuid();
}
// get loader type
var loaderType = loader.GetType();
string loaderTypeName = loaderType.Name;
Debug.Log($"XR-Loader: '{loader.name}' TYPE:{loaderType}");
// auto set rumble channel
if (autoSetRumbleChannel)
{
rumbleChannel = 0;
}
// auto detect
if (apiType == XRInputAPIType.AutoDetect)
{
#if UNITY_STANDALONE
if (loaderTypeName == "OpenVRLoader")
{
apiType = XRInputAPIType.OpenVR;
}
else
{
apiType = XRInputAPIType.UnityEngine_XR;
}
#else
apiType = XRInputAPIType.UnityEngine_XR;
#endif
}
// init api
disposeAPI = true;
switch (apiType)
{
case XRInputAPIType.UnityEngine_XR: api = new UnityEngine_XR(); break;
case XRInputAPIType.OpenVR: api = new OpenVR_New(); break;
case XRInputAPIType.OpenVR_Legacy: api = new OpenVR_Legacy(); break;
default: throw new NotImplementedException();
}
api.Init();
// ensure we dispose before stopping to avoid editor race-condition bugs
#if UNITY_EDITOR
UnityEditor.EditorApplication.playModeStateChanged += EditorApplication_playModeStateChanged;
#endif
apiInit = true;
}
catch (Exception e)
{
if (InitializedCallback != null)
{
InitializedCallback(false);
}
throw e;
}
if (InitializedCallback != null)
{
InitializedCallback(true);
}
}
internal static bool IsEnabledForPlatform(this XRLoader loader, BuildTarget target)
{
return(loader.IsEnabledForPlatform(BuildPipeline.GetBuildTargetGroup(target)));
}
