public IEnumerator AccessSettings()
{
int frameCount = 0;
string[] assets = new string[0] {
};
TestPackage pkg = new TestPackage();
XRPackageMetadataStore.AddPackage(pkg);
XRPackageInitializationBootstrap.InitPackage(pkg);
while (frameCount < 60)
{
yield return(null);
frameCount++;
}
yield return(null);
var metadata = XRPackageMetadataStore.GetMetadataForPackage("com.unity.xr.testpackage");
Assert.IsNotNull(metadata);
assets = AssetDatabase.FindAssets($"t:{metadata.settingsType}");
Assert.IsTrue(assets.Length == 1);
var assetPath = AssetDatabase.GUIDToAssetPath(assets[0]);
var instance = AssetDatabase.LoadAssetAtPath(assetPath, typeof(TestSettings));
Assert.IsNotNull(instance);
}
public IEnumerator TestLoaderAssignment()
{
Assert.IsNotNull(m_Settings);
string loaderTypeName = LoaderTypeNameForBuildTarget(BuildTargetGroup.Standalone);
Assert.IsFalse(String.IsNullOrEmpty(loaderTypeName));
bool wasFound = false;
foreach (var l in m_Settings.loaders)
{
if (String.Compare(l.GetType().FullName, loaderTypeName) == 0)
{
wasFound = true;
}
}
Assert.IsFalse(wasFound);
Assert.IsTrue(XRPackageMetadataStore.AssignLoader(m_Settings, loaderTypeName, BuildTargetGroup.Standalone));
yield return(null);
Assert.IsTrue(SettingsHasLoaderOfType(m_Settings, loaderTypeName));
Assert.IsTrue(TestLoaderBase.WasAssigned);
}
private bool SetEnableLoderForTarget(BuildTargetGroup buildTargetGroup, bool enable)
{
if (buildTargetGroup != BuildTargetGroup.Standalone && buildTargetGroup != BuildTargetGroup.WSA)
{
return(false);
}
XRGeneralSettings settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(buildTargetGroup);
if (settings == null)
{
return(false);
}
bool ret = false;
if (enable)
{
ret = XRPackageMetadataStore.AssignLoader(settings.Manager, typeof(WindowsMRLoader).Name, buildTargetGroup);
}
else
{
ret = XRPackageMetadataStore.RemoveLoader(settings.Manager, typeof(WindowsMRLoader).Name, buildTargetGroup);
}
return(ret);
}
internal void SetupXR()
{
#if UNITY_EDITOR
XRPackageMetadataStore.AssignLoader(XRGeneralSettings.Instance.Manager, typeof(WindowsMRLoader).Name, BuildTargetGroup.Standalone);
#endif
XRGeneralSettings.Instance.Manager.InitializeLoaderSync();
XRGeneralSettings.Instance.Manager.StartSubsystems();
}
internal void TeardownXR()
{
XRGeneralSettings.Instance.Manager.StopSubsystems();
XRGeneralSettings.Instance.Manager.DeinitializeLoader();
#if UNITY_EDITOR
XRPackageMetadataStore.RemoveLoader(XRGeneralSettings.Instance.Manager, typeof(WindowsMRLoader).Name, BuildTargetGroup.Standalone);
#endif
}
private bool AssignLoaderToSettings(XRManagerSettings settings, string loaderTypeName, BuildTargetGroup buildTargetGroup = BuildTargetGroup.Standalone)
{
if (String.IsNullOrEmpty(loaderTypeName))
{
return(false);
}
return(XRPackageMetadataStore.AssignLoader(m_Settings, loaderTypeName, buildTargetGroup));
}
public void Setup()
{
AssetDatabase.DeleteAsset("Assets/XR");
XRPackageInitializationBootstrap.BeginPackageInitialization();
TestPackage pkg = new TestPackage();
XRPackageMetadataStore.AddPackage(pkg);
XRPackageInitializationBootstrap.InitPackage(pkg);
}
/// <summary>See <see href="https://docs.unity3d.com/ScriptReference/SettingsProvider.html">SettingsProvider documentation</see>.</summary>
public override void OnGUI(string searchContext)
{
XRPackageMetadataStore.ReportProgressOnActiveWork();
EditorGUILayout.Space();
DisplayDocumentationLink();
DisplayLoadOrderUi();
DisplayXRTrackingDocumentationLink();
base.OnGUI(searchContext);
}
private string LoaderTypeNameForBuildTarget(BuildTargetGroup buildTargetGroup)
{
var loaders = XRPackageMetadataStore.GetLoadersForBuildTarget(buildTargetGroup);
var filteredLoaders = from l in loaders where String.Compare(l.loaderType, typeof(TestLoaderOne).FullName) == 0 select l;
if (filteredLoaders.Any())
{
var loaderInfo = filteredLoaders.First();
return(loaderInfo.loaderType);
}
return("");
}
void DrawElementCallback(Rect rect, int index, bool isActive, bool isFocused)
{
var li = m_LoaderMetadata[index];
li.toggled = XRPackageMetadataStore.IsLoaderAssigned(li.loaderType, CurrentBuildTargetGroup);
bool preToggledState = li.toggled;
li.toggled = EditorGUI.ToggleLeft(rect, li.loaderName, preToggledState);
if (li.toggled != preToggledState)
{
li.stateChanged = true;
m_LoaderMetadata[index] = li;
}
}
public IEnumerator TestNoPackageIdErrorsOut()
{
#if !UNITY_2020_2_OR_NEWER
XRPackageMetadataStore.InstallPackageAndAssignLoaderForBuildTarget("", String.Empty, BuildTargetGroup.Standalone);
LogAssert.Expect(LogType.Error, new Regex(@"no package id"));
while (XRPackageMetadataStore.isDoingQueueProcessing)
{
yield return(null);
}
#else
yield return(null);
#endif //UNITY_2020_2_OR_NEWER
}
public void UpdateConfig()
{
EditorUserBuildSettings.development = DevelopmentBuild;
AppConfig.IsDebug = DevelopmentBuild;
AppConfig.IsHotfix = IsHotfix;
AppConfig.IsLoadAB = IsLoadAB;
AppConfig.IsProServer = IsProServer;
AppConfig.RunXLua = RunXLuaScripts;
AppConfig.AppFrameRate = AppFrameRate;
AppConfig.TargetPackage = ApkTarget;
EditorUtility.SetDirty(AppConfig);
if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android)
{
EditorUserBuildSettings.exportAsGoogleAndroidProject = NativeApp;
XRGeneralSettings androidXRSettings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(BuildTargetGroup.Android);
if (androidXRSettings == null)
{
var assignedSettings = ScriptableObject.CreateInstance <XRManagerSettings>() as XRManagerSettings;
androidXRSettings.AssignedSettings = assignedSettings;
EditorUtility.SetDirty(androidXRSettings); // Make sure this gets picked up for serialization later.
}
//取消当前选择的
IReadOnlyList <XRLoader> list = androidXRSettings.Manager.activeLoaders;
int hasCount = list.Count;
//Debug.Log(hasCount);
for (int i = 0; i < hasCount; i++)
{
string nameTemp = list[0].GetType().FullName;
Debug.Log("disable xr plug:" + nameTemp);
XRPackageMetadataStore.RemoveLoader(androidXRSettings.Manager, nameTemp, BuildTargetGroup.Android);
}
androidXRSettings.InitManagerOnStart = false;
if (ApkTarget == TargetPackage.Pico)
{
androidXRSettings.InitManagerOnStart = true;
//启用
string loaderTypeName = "Unity.XR.PXR.PXR_Loader";
XRPackageMetadataStore.AssignLoader(androidXRSettings.Manager, loaderTypeName, BuildTargetGroup.Android);
}
EditorUtility.SetDirty(androidXRSettings); // Make sure this gets picked up for serialization later.
}
AssetDatabase.Refresh();
}
public void FilteringMetadataByBuildTargetGroup(
[Values(BuildTargetGroup.Standalone, BuildTargetGroup.Android, BuildTargetGroup.Unknown, BuildTargetGroup.WebGL)] BuildTargetGroup buildTargetGroup,
[Values("Test Loader One", "Test Loader Two", "Test Loader Three", "")] string expectedType)
{
var loaders = XRPackageMetadataStore.GetLoadersForBuildTarget(buildTargetGroup);
Assert.IsTrue((loaders.Count > 0 && !String.IsNullOrEmpty(expectedType)) ||
(loaders.Count <= 0 && String.IsNullOrEmpty(expectedType)));
if (!String.IsNullOrEmpty(expectedType))
{
var loaderNames = from lm in loaders where String.Compare(lm.loaderName, expectedType, false) == 0 select lm.loaderName;
Assert.IsTrue(loaderNames.Any());
Assert.IsTrue(loaderNames.Count() == 1);
}
}
private static void SetXRPluginsEnabled(bool enabled)
{
XRGeneralSettings SetForBuildTarget(XRGeneralSettingsPerBuildTarget bts, BuildTargetGroup btg, string btgName)
{
XRGeneralSettings btSettings = bts.SettingsForBuildTarget(btg);
if (btSettings == null)
{
btSettings = ScriptableObject.CreateInstance <XRGeneralSettings>();
btSettings.name = btgName + " Settings";
btSettings.Manager = ScriptableObject.CreateInstance <XRManagerSettings>();
btSettings.Manager.name = btgName + " Providers";
AssetDatabase.AddObjectToAsset(btSettings, bts);
AssetDatabase.AddObjectToAsset(btSettings.Manager, bts);
bts.SetSettingsForBuildTarget(btg, btSettings);
}
return(btSettings);
}
if (!EditorBuildSettings.TryGetConfigObject(XRGeneralSettings.k_SettingsKey, out XRGeneralSettingsPerBuildTarget buildTargetSettings))
{
if (!AssetDatabase.IsValidFolder("Assets/XR"))
{
AssetDatabase.CreateFolder("Assets", "XR");
}
buildTargetSettings = ScriptableObject.CreateInstance <XRGeneralSettingsPerBuildTarget>();
AssetDatabase.CreateAsset(buildTargetSettings, "Assets/XR/XRGeneralSettings.asset");
EditorBuildSettings.AddConfigObject(XRGeneralSettings.k_SettingsKey, buildTargetSettings, true);
}
XRGeneralSettings standaloneSettings = SetForBuildTarget(buildTargetSettings, BuildTargetGroup.Standalone, "Standalone");
XRGeneralSettings androidSettings = SetForBuildTarget(buildTargetSettings, BuildTargetGroup.Android, "Android");
// Enable Oculus XR plugin
if (enabled)
{
XRPackageMetadataStore.AssignLoader(standaloneSettings.Manager, "Unity.XR.Oculus.OculusLoader", BuildTargetGroup.Standalone);
XRPackageMetadataStore.AssignLoader(androidSettings.Manager, "Unity.XR.Oculus.OculusLoader", BuildTargetGroup.Android);
}
else
{
XRPackageMetadataStore.RemoveLoader(standaloneSettings.Manager, "Unity.XR.Oculus.OculusLoader", BuildTargetGroup.Standalone);
XRPackageMetadataStore.RemoveLoader(androidSettings.Manager, "Unity.XR.Oculus.OculusLoader", BuildTargetGroup.Android);
}
}
void DrawElementCallback(Rect rect, int index, bool isActive, bool isFocused)
{
var li = m_LoaderMetadata[index];
if (PackageNotificationUtils.registeredPackagesWithNotifications.TryGetValue(li.packageId, out var notificationInfo))
{
PackageNotificationUtils.DrawNotificationIconUI(notificationInfo, rect);
}
li.toggled = XRPackageMetadataStore.IsLoaderAssigned(li.loaderType, CurrentBuildTargetGroup);
var preToggledState = li.toggled;
EditorGUI.BeginDisabledGroup(li.disabled);
if (li.customLoaderUI != null)
{
li.customLoaderUI.OnGUI(rect);
li.toggled = li.customLoaderUI.IsLoaderEnabled;
}
else
{
string name = li.loaderName;
if (s_DeprecationInfo.ContainsKey(name))
{
var depInfo = s_DeprecationInfo[name];
var labelRect = rect;
var size = EditorStyles.label.CalcSize(depInfo.icon);
labelRect.width -= size.y + 1;
var imageRect = new Rect(rect);
imageRect.xMin = labelRect.xMax + 1;
imageRect.width = size.y;
li.toggled = EditorGUI.ToggleLeft(labelRect, li.loaderName, preToggledState);
EditorGUI.LabelField(imageRect, depInfo.renderContent);
}
else
{
li.toggled = EditorGUI.ToggleLeft(rect, li.loaderName, preToggledState);
}
}
li.stateChanged = (li.toggled != preToggledState);
m_LoaderMetadata[index] = li;
EditorGUI.EndDisabledGroup();
}
internal static void InitPackage(IXRPackage package)
{
var packageMetadata = package.metadata;
if (packageMetadata == null)
{
Debug.LogError($"Package {package.GetType().Name} has a package definition but has no metadata. Skipping initialization.");
return;
}
XRPackageMetadataStore.AddPluginPackage(package);
if (!InitializePackageFromMetadata(package, packageMetadata))
{
Debug.LogWarning(
String.Format("{0} package Initialization not completed. You will need to create any instances of the loaders and settings manually before you can use the intended XR Plug-in Package.", packageMetadata.packageName));
}
}
public void SetUp()
{
AssetDatabase.DeleteAsset("Assets/XR");
AssetDatabase.CreateFolder("Assets", "XR");
m_Settings = ScriptableObject.CreateInstance <XRManagerSettings>() as XRManagerSettings;
m_Settings.name = "Actual testable settings.";
m_TestSettings = ScriptableObject.CreateInstance <XRGeneralSettings>() as XRGeneralSettings;
m_TestSettings.Manager = m_Settings;
m_TestSettings.name = "Standalone Settings Container.";
m_TestSettingsPerBuildTarget = ScriptableObject.CreateInstance <XRGeneralSettingsPerBuildTarget>() as XRGeneralSettingsPerBuildTarget;
m_TestSettingsPerBuildTarget.SetSettingsForBuildTarget(BuildTargetGroup.Standalone, m_TestSettings);
var testPath = XRGeneralSettingsTests.GetAssetPathForComponents(s_TempSettingsPath);
if (!string.IsNullOrEmpty(testPath))
{
AssetDatabase.CreateAsset(m_TestSettingsPerBuildTarget, Path.Combine(testPath, "Test_XRGeneralSettings.asset"));
AssetDatabase.AddObjectToAsset(m_TestSettings, AssetDatabase.GetAssetOrScenePath(m_TestSettingsPerBuildTarget));
AssetDatabase.CreateFolder(testPath, "Settings");
testPath = Path.Combine(testPath, "Settings");
AssetDatabase.CreateAsset(m_Settings, Path.Combine(testPath, "Test_XRSettingsManager.asset"));
m_TestSettings.AssignedSettings = m_Settings;
AssetDatabase.SaveAssets();
}
EditorBuildSettings.AddConfigObject(XRGeneralSettings.k_SettingsKey, m_TestSettingsPerBuildTarget, true);
XRPackageInitializationBootstrap.BeginPackageInitialization();
TestPackage pkg = new TestPackage();
XRPackageMetadataStore.AddPluginPackage(pkg);
XRPackageInitializationBootstrap.InitPackage(pkg);
TestLoaderBase.WasAssigned = false;
TestLoaderBase.WasUnassigned = false;
}
public void TestLoaderRemoval()
{
Assert.IsNotNull(m_Settings);
string loaderTypeName = LoaderTypeNameForBuildTarget(BuildTargetGroup.Standalone);
Assert.IsFalse(String.IsNullOrEmpty(loaderTypeName));
AssignLoaderToSettings(m_Settings, loaderTypeName);
Assert.IsTrue(SettingsHasLoaderOfType(m_Settings, loaderTypeName));
Assert.IsTrue(XRPackageMetadataStore.RemoveLoader(m_Settings, loaderTypeName, BuildTargetGroup.Standalone));
m_Settings = null;
var settings = EditorUtilities.GetInstanceOfTypeFromAssetDatabase <XRManagerSettings>();
m_Settings = settings as XRManagerSettings;
Assert.IsNotNull(m_Settings);
Assert.IsFalse(SettingsHasLoaderOfType(m_Settings, loaderTypeName));
Assert.IsTrue(TestLoaderBase.WasUnassigned);
}
internal static bool ContainsLoaderForAnyBuildTarget(string loaderTypeName)
{
XRGeneralSettingsPerBuildTarget buildTargetSettings = null;
EditorBuildSettings.TryGetConfigObject(XRGeneralSettings.k_SettingsKey, out buildTargetSettings);
if (buildTargetSettings == null)
{
return(false);
}
foreach (var settings in buildTargetSettings.Settings.Values)
{
if (XRPackageMetadataStore.IsLoaderAssigned(settings.Manager, loaderTypeName))
{
return(true);
}
}
return(false);
}
ScriptableObject Create()
{
ScriptableObject settings = ScriptableObject.CreateInstance(m_BuildDataType) as ScriptableObject;
if (settings != null)
{
var package = XRPackageMetadataStore.GetPackageForSettingsTypeNamed(m_BuildDataType.FullName);
package?.PopulateNewSettingsInstance(settings);
string newAssetName = String.Format("{0}.asset", EditorUtilities.TypeNameToString(m_BuildDataType));
string assetPath = EditorUtilities.GetAssetPathForComponents(EditorUtilities.s_DefaultSettingsPath);
if (!string.IsNullOrEmpty(assetPath))
{
assetPath = Path.Combine(assetPath, newAssetName);
AssetDatabase.CreateAsset(settings, assetPath);
EditorBuildSettings.AddConfigObject(m_BuildSettingsKey, settings, true);
return(settings);
}
}
return(null);
}
internal static void BeginPackageInitialization()
{
EditorApplication.update -= BeginPackageInitialization;
foreach (var t in TypeLoaderExtensions.GetAllTypesWithInterface <IXRPackage>())
{
if (t.IsInterface || t.FullName.Contains("Unity.XR.Management.TestPackage") || t.FullName.Contains("UnityEditor.XR.Management.Metadata.KnownPackages"))
{
continue;
}
IXRPackage package = Activator.CreateInstance(t) as IXRPackage;
if (package == null)
{
Debug.LogError($"Unable to find an implementation for expected package type {t.FullName}.");
continue;
}
InitPackage(package);
}
foreach (var t in TypeLoaderExtensions.GetAllTypesWithInterface <XRPackageInitializationBase>())
{
if (t.IsInterface)
{
continue;
}
XRPackageInitializationBase packageInit = Activator.CreateInstance(t) as XRPackageInitializationBase;
if (packageInit == null)
{
Debug.LogError($"Unable to find an implementation for expected package type {t.FullName}.");
continue;
}
InitPackage(packageInit);
}
XRPackageMetadataStore.RebuildInstalledCache();
XRPackageMetadataStore.AssignAnyRequestedLoaders();
}
internal bool OnGUI(BuildTargetGroup buildTargetGroup)
{
var settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(buildTargetGroup);
if (buildTargetGroup != CurrentBuildTargetGroup || m_LoaderMetadata == null)
{
CurrentBuildTargetGroup = buildTargetGroup;
if (m_LoaderMetadata == null)
{
m_LoaderMetadata = new List <LoaderInformation>();
}
else
{
m_LoaderMetadata.Clear();
}
foreach (var pmd in XRPackageMetadataStore.GetLoadersForBuildTarget(buildTargetGroup))
{
var newLi = new LoaderInformation()
{
packageName = pmd.packageName,
packageId = pmd.packageId,
loaderName = pmd.loaderName,
loaderType = pmd.loaderType,
toggled = XRPackageMetadataStore.IsLoaderAssigned(pmd.loaderType, buildTargetGroup),
disabled = false,
customLoaderUI = XRCustomLoaderUIManager.GetCustomLoaderUI(pmd.loaderType, buildTargetGroup)
};
if (newLi.customLoaderUI != null)
{
newLi.customLoaderUI.IsLoaderEnabled = newLi.toggled;
newLi.customLoaderUI.ActiveBuildTargetGroup = CurrentBuildTargetGroup;
}
m_LoaderMetadata.Add(newLi);
}
if (settings != null)
{
List <LoaderInformation> loadersWantingToDisableOtherLoaders = new List <LoaderInformation>();
LoaderInformation li;
for (int i = 0; i < m_LoaderMetadata.Count; i++)
{
li = m_LoaderMetadata[i];
if (XRPackageMetadataStore.IsLoaderAssigned(settings.AssignedSettings, li.loaderType))
{
li.toggled = true;
m_LoaderMetadata[i] = li;
if (li.customLoaderUI != null)
{
loadersWantingToDisableOtherLoaders.Add(li);
}
break;
}
}
foreach (var loader in loadersWantingToDisableOtherLoaders)
{
SetDisablesStateOnLoadersFromLoader(loader);
}
}
m_OrderedList = new ReorderableList(m_LoaderMetadata, typeof(LoaderInformation), false, true, false, false);
m_OrderedList.drawHeaderCallback = (rect) =>
{
var labelSize = EditorStyles.label.CalcSize(Content.k_LoaderUITitle);
var labelRect = new Rect(rect);
labelRect.width = labelSize.x;
labelSize = EditorStyles.label.CalcSize(Content.k_HelpContent);
var imageRect = new Rect(rect);
imageRect.xMin = labelRect.xMax + 1;
imageRect.width = labelSize.x;
EditorGUI.LabelField(labelRect, Content.k_LoaderUITitle, EditorStyles.label);
if (GUI.Button(imageRect, Content.k_HelpContent, EditorStyles.label))
{
System.Diagnostics.Process.Start(Content.k_HelpUri);
}
};
m_OrderedList.drawElementCallback = (rect, index, isActive, isFocused) => DrawElementCallback(rect, index, isActive, isFocused);
m_OrderedList.drawElementBackgroundCallback = (rect, index, isActive, isFocused) =>
{
var tex = GUI.skin.label.normal.background;
if (tex == null && GUI.skin.label.normal.scaledBackgrounds.Length > 0)
{
tex = GUI.skin.label.normal.scaledBackgrounds[0];
}
if (tex == null)
{
return;
}
GUI.DrawTexture(rect, GUI.skin.label.normal.background);
};
m_OrderedList.drawFooterCallback = (rect) =>
{
var status = XRPackageMetadataStore.GetCurrentStatusDisplayText();
GUI.Label(rect, EditorGUIUtility.TrTextContent(status), EditorStyles.label);
};
m_OrderedList.elementHeightCallback = (index) => GetElementHeight(index);
}
if (m_LoaderMetadata == null || m_LoaderMetadata.Count == 0)
{
EditorGUILayout.HelpBox(k_AtNoLoaderInstance, MessageType.Info);
}
else
{
m_OrderedList.DoLayoutList();
if (settings != null)
{
LoaderInformation li;
for (int i = 0; i < m_LoaderMetadata.Count; i++)
{
li = m_LoaderMetadata[i];
if (li.stateChanged && li.customLoaderUI != null)
{
SetDisablesStateOnLoadersFromLoader(li);
}
}
for (int i = 0; i < m_LoaderMetadata.Count; i++)
{
li = m_LoaderMetadata[i];
if (li.stateChanged)
{
if (li.toggled)
{
XRPackageMetadataStore.InstallPackageAndAssignLoaderForBuildTarget(li.packageId, li.loaderType, buildTargetGroup);
}
else
{
XRPackageMetadataStore.RemoveLoader(settings.AssignedSettings, li.loaderType, buildTargetGroup);
}
li.stateChanged = false;
m_LoaderMetadata[i] = li;
}
}
}
}
return(false);
}
public static void EnableLoader()
{
if (skipEditorFrames > 0)
{
skipEditorFrames--;
return;
}
if (enabledLoaderKey == null)
{
enabledLoaderKey = string.Format(valveEnabledLoaderKeyTemplate, SteamVR_Settings.instance.editorAppKey);
}
if (EditorPrefs.HasKey(enabledLoaderKey) == false)
{
if (UnityEditor.PlayerSettings.virtualRealitySupported == true)
{
UnityEditor.PlayerSettings.virtualRealitySupported = false;
Debug.Log("<b>[SteamVR Setup]</b> Disabled virtual reality support in Player Settings. <b>Because you're using XR Manager. Make sure OpenVR Loader is enabled in XR Manager UI.</b> (you can disable this by unchecking Assets/SteamVR/SteamVR_Settings.autoEnableVR)");
}
var generalSettings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(BuildTargetGroup.Standalone);
if (generalSettings == null)
{
if (settingsWindow == null)
{
settingsWindow = SettingsService.OpenProjectSettings("Project/XR Plug-in Management");
settingsWindow.Repaint();
return;
}
if (settingsWindow == null || generalSettings == null)
{
Debug.LogWarning("<b>[SteamVR Setup]</b> Unable to access standalone xr settings while trying to enable OpenVR Loader. <b>You may need to manually enable OpenVR Loader in XR Plug-in Management (Project Settings).</b> (you can disable this by unchecking Assets/SteamVR/SteamVR_Settings.autoEnableVR)");
return;
}
}
if (generalSettings.AssignedSettings == null)
{
var assignedSettings = ScriptableObject.CreateInstance <XRManagerSettings>() as XRManagerSettings;
generalSettings.AssignedSettings = assignedSettings;
EditorUtility.SetDirty(generalSettings);
}
bool existing = generalSettings.AssignedSettings.loaders.Any(loader => loader.name == valveOpenVRLoaderType);
foreach (var loader in generalSettings.AssignedSettings.loaders)
{
Debug.Log("loader: " + loader.name);
}
if (!existing)
{
bool status = XRPackageMetadataStore.AssignLoader(generalSettings.AssignedSettings, valveOpenVRLoaderType, BuildTargetGroup.Standalone);
if (status)
{
Debug.Log("<b>[SteamVR Setup]</b> Enabled OpenVR Loader in XR Management");
}
else
{
Debug.LogError("<b>[SteamVR Setup]</b> Failed to enable enable OpenVR Loader in XR Management. You may need to manually open the XR Plug-in Management tab in project settings and check the OpenVR Loader box.");
}
}
EditorPrefs.SetBool(enabledLoaderKey, true);
}
End();
}
private static void DoBuildIOSInternal(iOSBuildType buildType, iOSSdkVersion sdkVersion)
{
Debug.Log("Building iOS...");
CurrentGroup = BuildTargetGroup.iOS;
var xrGeneralSettings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(BuildTargetGroup.iOS);
var prevCompilerConfiguration = PlayerSettings.GetIl2CppCompilerConfiguration(BuildTargetGroup.iOS);
var prevScriptingDefines = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS);
var prev_sdkVersion = PlayerSettings.iOS.sdkVersion;
var isDebug = !(buildType == iOSBuildType.Debug);
var disabledARKit = false;
using var revertSettings = new Disposable(() =>
{
CurrentGroup = null;
PlayerSettings.iOS.sdkVersion = prev_sdkVersion;
PlayerSettings.SetIl2CppCompilerConfiguration(BuildTargetGroup.iOS, prevCompilerConfiguration);
if (!Application.isBatchMode)
{
PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS, prevScriptingDefines);
}
if (disabledARKit)
{
XRPackageMetadataStore.AssignLoader(
xrGeneralSettings.AssignedSettings,
typeof(UnityEngine.XR.ARKit.ARKitLoader).FullName,
BuildTargetGroup.iOS);
}
});
var compilerConfiguration = isDebug ? Il2CppCompilerConfiguration.Debug : Il2CppCompilerConfiguration.Master;
PlayerSettings.SetIl2CppCompilerConfiguration(BuildTargetGroup.iOS, compilerConfiguration);
PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS, ProcessDefines(prevScriptingDefines, isDebug));
PlayerSettings.iOS.sdkVersion = sdkVersion;
if (sdkVersion == iOSSdkVersion.SimulatorSDK &&
xrGeneralSettings.AssignedSettings.activeLoaders.Any(m => m.GetType() == typeof(UnityEngine.XR.ARKit.ARKitLoader)))
{
// ARKit is not supported on iOS Simulator - disable it temporairly
XRPackageMetadataStore.RemoveLoader(
xrGeneralSettings.AssignedSettings,
typeof(UnityEngine.XR.ARKit.ARKitLoader).FullName,
BuildTargetGroup.iOS);
disabledARKit = true;
}
string exportPath = Path.GetFullPath(Path.Combine(ProjectPath, "../../ios/UnityExport"));
string buildPath = iosBuildPath;
if (Directory.Exists(buildPath))
{
Directory.Delete(buildPath, true);
}
EditorUserBuildSettings.iOSBuildConfigType = buildType;
try
{
var options = (buildType == iOSBuildType.Debug ? BuildOptions.AllowDebugging : BuildOptions.None);
var report = BuildPipeline.BuildPlayer(
GetEnabledScenes(),
buildPath,
BuildTarget.iOS,
options
);
if (report.summary.result != BuildResult.Succeeded)
{
throw new Exception("Build failed");
}
// Clear UnityExport
DeleteFolderContent(exportPath);
// Copy build output to UnityExport
Debug.Log("Copy to UnityExport");
CopyDirectory(
buildPath,
exportPath,
mergeDirectories: false,
overwriteFiles: true);
}
catch (Exception e)
{
Debug.Log("Export failed!");
if (Application.isBatchMode)
{
Debug.LogError(e);
EditorApplication.Exit(-1);
}
else
{
throw;
}
}
finally
{
Debug.Log("Export completed!");
if (Application.isBatchMode)
{
EditorApplication.Exit(0);
}
}
}
internal bool OnGUI(BuildTargetGroup buildTargetGroup)
{
var settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(buildTargetGroup);
if (buildTargetGroup != CurrentBuildTargetGroup || m_LoaderMetadata == null)
{
CurrentBuildTargetGroup = buildTargetGroup;
if (m_LoaderMetadata == null)
{
m_LoaderMetadata = new List <LoaderInformation>();
}
else
{
m_LoaderMetadata.Clear();
}
foreach (var pmd in XRPackageMetadataStore.GetLoadersForBuildTarget(buildTargetGroup))
{
m_LoaderMetadata.Add(new LoaderInformation()
{
packageName = pmd.packageName,
packageId = pmd.packageId,
loaderName = pmd.loaderName,
loaderType = pmd.loaderType,
toggled = XRPackageMetadataStore.IsLoaderAssigned(pmd.loaderType, buildTargetGroup)
});
}
if (settings != null)
{
LoaderInformation li;
for (int i = 0; i < m_LoaderMetadata.Count; i++)
{
li = m_LoaderMetadata[i];
if (XRPackageMetadataStore.IsLoaderAssigned(settings.AssignedSettings, li.loaderType))
{
li.toggled = true;
m_LoaderMetadata[i] = li;
break;
}
}
}
m_OrderedList = new ReorderableList(m_LoaderMetadata, typeof(LoaderInformation), false, true, false, false);
m_OrderedList.drawHeaderCallback = (rect) => GUI.Label(rect, EditorGUIUtility.TrTextContent("Plug-in Providers"), EditorStyles.label);
m_OrderedList.drawElementCallback = (rect, index, isActive, isFocused) => DrawElementCallback(rect, index, isActive, isFocused);
m_OrderedList.elementHeightCallback = (index) => GetElementHeight(index);
}
if (m_LoaderMetadata == null || m_LoaderMetadata.Count == 0)
{
EditorGUILayout.HelpBox(k_AtNoLoaderInstance, MessageType.Info);
}
else
{
m_OrderedList.DoLayoutList();
if (settings != null)
{
LoaderInformation li;
for (int i = 0; i < m_LoaderMetadata.Count; i++)
{
li = m_LoaderMetadata[i];
if (li.stateChanged)
{
if (li.toggled)
{
if (XRPackageMetadataStore.IsPackageInstalled(li.packageId))
{
XRPackageMetadataStore.AssignLoader(settings.AssignedSettings, li.loaderType, buildTargetGroup);
}
else
{
XRPackageMetadataStore.InstallPackageAndAssignLoaderForBuildTarget(li.packageId, li.loaderType, buildTargetGroup);
}
}
else
{
XRPackageMetadataStore.RemoveLoader(settings.AssignedSettings, li.loaderType, buildTargetGroup);
}
li.stateChanged = false;
m_LoaderMetadata[i] = li;
}
}
}
}
return(false);
}
