public void OnPreprocessBuild(BuildReport report)
{
SetRuntimePluginCopyDelegate();
if (report.summary.platform != BuildTarget.Android)
{
// Sometimes (e.g., build failure), the shader can get "stuck" in the Preloaded Assets array.
// Make sure that if we are not building for Android, we remove that shader.
BuildHelper.RemoveShaderFromProject(ARCoreCameraSubsystem.backgroundShaderName);
return;
}
XRGeneralSettings generalSettings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget));
if (generalSettings == null)
{
return;
}
foreach (var loader in generalSettings.Manager.loaders)
{
if (loader is ARCoreLoader)
{
EnsureARCoreSupportedIsNotChecked();
EnsureGoogleARCoreIsNotPresent();
EnsureMinSdkVersion();
EnsureOnlyOpenGLES3IsUsed();
EnsureGradleIsUsed();
BuildImageTrackingAssets();
BuildHelper.AddBackgroundShaderToProject(ARCoreCameraSubsystem.backgroundShaderName);
break;
}
}
}
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>Get specific settings for a given build target.</summary>
/// <param name="targetGroup">An enum specifying which platform group this build is for.</param>
/// <returns>The instance of <see cref="XRGeneralSettings"/> assigned to the key, or null if not.</returns>
public XRGeneralSettings SettingsForBuildTarget(BuildTargetGroup targetGroup)
{
XRGeneralSettings ret = null;
Settings.TryGetValue(targetGroup, out ret);
return(ret);
}
public virtual void TearDownTest()
{
EditorBuildSettings.RemoveConfigObject(XRGeneralSettings.k_SettingsKey);
if (!string.IsNullOrEmpty(testPathToGeneralSettings))
{
AssetDatabase.DeleteAsset(testPathToGeneralSettings);
}
if (!string.IsNullOrEmpty(testPathToSettings))
{
AssetDatabase.DeleteAsset(testPathToSettings);
}
xrGeneralSettings.Manager = null;
UnityEngine.Object.DestroyImmediate(xrGeneralSettings);
xrGeneralSettings = null;
UnityEngine.Object.DestroyImmediate(testManager);
testManager = null;
UnityEngine.Object.DestroyImmediate(buildTargetSettings);
buildTargetSettings = null;
if (currentSettings != null)
{
EditorBuildSettings.AddConfigObject(XRGeneralSettings.k_SettingsKey, currentSettings, true);
}
else
{
EditorBuildSettings.RemoveConfigObject(XRGeneralSettings.k_SettingsKey);
}
AssetDatabase.DeleteAsset(Path.Combine("Assets", "Temp"));
}
public static bool UpgradeSettingsToPerBuildTarget(string path)
{
var generalSettings = GetXRGeneralSettingsInstance(path);
if (generalSettings == null)
{
return(false);
}
if (!AssetDatabase.IsMainAsset(generalSettings))
{
return(false);
}
XRGeneralSettings newSettings = ScriptableObject.CreateInstance <XRGeneralSettings>() as XRGeneralSettings;
newSettings.Manager = generalSettings.Manager;
generalSettings = null;
AssetDatabase.DeleteAsset(path);
XRGeneralSettingsPerBuildTarget buildTargetSettings = ScriptableObject.CreateInstance <XRGeneralSettingsPerBuildTarget>() as XRGeneralSettingsPerBuildTarget;
AssetDatabase.CreateAsset(buildTargetSettings, path);
buildTargetSettings.SetSettingsForBuildTarget(EditorUserBuildSettings.selectedBuildTargetGroup, newSettings);
AssetDatabase.AddObjectToAsset(newSettings, path);
AssetDatabase.SaveAssets();
Debug.LogWarningFormat("XR General Settings have been upgraded to be per-Build Target Group. Original settings were moved to Build Target Group {0}.", EditorUserBuildSettings.selectedBuildTargetGroup);
return(true);
}
private bool HasLoaderEnabledForTarget(BuildTargetGroup buildTargetGroup)
{
if (buildTargetGroup != BuildTargetGroup.Standalone && buildTargetGroup != BuildTargetGroup.Android)
{
return(false);
}
XRGeneralSettings settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(buildTargetGroup);
if (settings == null)
{
return(false);
}
bool loaderFound = false;
for (int i = 0; i < settings.Manager.activeLoaders.Count; ++i)
{
if (settings.Manager.activeLoaders[i] as OculusLoader != null)
{
loaderFound = true;
break;
}
}
return(loaderFound);
}
public void OnPreprocessBuild(BuildReport report)
{
SetRuntimePluginCopyDelegate();
if (report.summary.platform != BuildTarget.Android)
{
return;
}
XRGeneralSettings generalSettings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget));
if (generalSettings == null)
{
return;
}
foreach (var loader in generalSettings.Manager.loaders)
{
if (loader is ARCoreLoader)
{
EnsureARCoreSupportedIsNotChecked();
EnsureGoogleARCoreIsNotPresent();
EnsureMinSdkVersion();
EnsureOnlyOpenGLES3IsUsed();
EnsureGradleIsUsed();
BuildImageTrackingAssets();
BuildHelper.AddBackgroundShaderToProject(ARCoreCameraSubsystem.backgroundShaderName);
break;
}
}
}
public bool ShouldIncludeRemotingPluginsInBuild(string path)
{
XRGeneralSettings generalSettings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget));
if (generalSettings == null)
{
return(false);
}
bool loaderFound = false;
for (int i = 0; i < generalSettings.Manager.loaders.Count; ++i)
{
if (generalSettings.Manager.loaders[i] as WindowsMRLoader != null)
{
loaderFound = true;
break;
}
}
if (!loaderFound)
{
return(false);
}
WindowsMRBuildSettings buildSettings = BuildSettingsForBuildTargetGroup(BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget)) as WindowsMRBuildSettings;
if (buildSettings == null)
{
return(false);
}
return(buildSettings.HolographicRemoting);
}
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);
}
/// <summary>OnPostprocessBuild override to provide XR Plugin specific build actions.</summary>
/// <param name="report">The build report.</param>
public override void OnPostprocessBuild(BuildReport report)
{
base.OnPostprocessBuild(report);
XRGeneralSettings settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(report.summary.platformGroup);
if (settings == null)
{
return;
}
string bootConfigPath = report.summary.outputPath;
if (report.summary.platformGroup == BuildTargetGroup.WSA)
{
bool usePrimaryWindow = true;
WindowsMRBuildSettings buildSettings = BuildSettingsForBuildTargetGroup(report.summary.platformGroup);
if (buildSettings != null)
{
usePrimaryWindow = buildSettings.UsePrimaryWindowForDisplay;
}
// Boot Config data path is highly specific to the platform being built.
bootConfigPath = Path.Combine(bootConfigPath, PlayerSettings.productName);
bootConfigPath = Path.Combine(bootConfigPath, "Data");
bootConfigPath = Path.Combine(bootConfigPath, "boot.config");
using (StreamWriter sw = File.AppendText(bootConfigPath))
{
sw.WriteLine(String.Format("{0}={1}", k_ForcePrimaryWindowHolographic, usePrimaryWindow ? 1 : 0));
}
}
}
private static void SetUpAppRemoting(BuildTargetGroup targetGroup)
{
Debug.Log($"Setting up app remoting for {targetGroup}");
const string AppRemotingPlugin = "Microsoft.MixedReality.OpenXR.Remoting.AppRemotingPlugin";
Type appRemotingFeature = typeof(AppRemoting).Assembly.GetType(AppRemotingPlugin);
if (appRemotingFeature == null)
{
Debug.LogError($"Could not find {AppRemotingPlugin}. Has this class been removed or renamed?");
return;
}
FeatureHelpers.RefreshFeatures(targetGroup);
OpenXRFeature feature = OpenXRSettings.ActiveBuildTargetInstance.GetFeature(appRemotingFeature);
if (feature == null)
{
Debug.LogError($"Could not load {AppRemotingPlugin} as an OpenXR feature. Has this class been removed or renamed?");
return;
}
feature.enabled = true;
XRGeneralSettings settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(targetGroup);
if (settings != null)
{
settings.InitManagerOnStart = false;
}
}
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);
}
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, 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 void EnsureArgumentsNotNull(XRGeneralSettings xrGeneralSettings,
XRGeneralSettingsPerBuildTarget buildTargetSettings, XRManagerSettings managerSettings)
{
EnsureArgumentNotNull(xrGeneralSettings);
EnsureArgumentNotNull(buildTargetSettings);
EnsureArgumentNotNull(managerSettings);
}
private void SetupLoader <T>(XRGeneralSettings xrGeneralSettings,
XRGeneralSettingsPerBuildTarget buildTargetSettings,
XRManagerSettings managerSettings) where T : XRLoader
{
var loader = ScriptableObject.CreateInstance <T>();
if (loader == null)
{
throw new ArgumentNullException(
$"Tried to instantiate an instance of {typeof(T).Name}, but it is null.");
}
loader.name = loader.GetType().Name;
xrGeneralSettings.Manager.loaders.Add(loader);
buildTargetSettings.SetSettingsForBuildTarget(EditorUserBuildSettings.selectedBuildTargetGroup,
xrGeneralSettings);
EnsureXrGeneralSettingsPathExists(xrsdkTestXrSettingsPath);
AssetDatabase.CreateAsset(buildTargetSettings, xrsdkTestXrSettingsPath);
AssetDatabase.AddObjectToAsset(xrGeneralSettings, xrsdkTestXrSettingsPath);
AssetDatabase.AddObjectToAsset(managerSettings, xrsdkTestXrSettingsPath);
AssetDatabase.AddObjectToAsset(loader, xrsdkTestXrSettingsPath);
}
public static void SetXRLoaderEnabled(string loaderClassName, BuildTargetGroup buildTargetGroup, bool enabled)
{
#if VIU_XR_GENERAL_SETTINGS
MethodInfo method = Type.GetType("UnityEditor.XR.Management.XRSettingsManager, Unity.XR.Management.Editor")
.GetProperty("currentSettings", BindingFlags.NonPublic | BindingFlags.Static).GetGetMethod(true);
XRGeneralSettingsPerBuildTarget generalSettings = (XRGeneralSettingsPerBuildTarget)method.Invoke(null, new object[] {});
XRGeneralSettings xrSettings = generalSettings.SettingsForBuildTarget(buildTargetGroup);
if (xrSettings == null)
{
xrSettings = ScriptableObject.CreateInstance <XRGeneralSettings>() as XRGeneralSettings;
generalSettings.SetSettingsForBuildTarget(buildTargetGroup, xrSettings);
xrSettings.name = $"{buildTargetGroup.ToString()} Settings";
AssetDatabase.AddObjectToAsset(xrSettings, AssetDatabase.GetAssetOrScenePath(generalSettings));
}
var serializedSettingsObject = new SerializedObject(xrSettings);
SerializedProperty loaderProp = serializedSettingsObject.FindProperty("m_LoaderManagerInstance");
if (loaderProp.objectReferenceValue == null)
{
var xrManagerSettings = ScriptableObject.CreateInstance <XRManagerSettings>() as XRManagerSettings;
xrManagerSettings.name = $"{buildTargetGroup.ToString()} Providers";
AssetDatabase.AddObjectToAsset(xrManagerSettings, AssetDatabase.GetAssetOrScenePath(generalSettings));
loaderProp.objectReferenceValue = xrManagerSettings;
serializedSettingsObject.ApplyModifiedProperties();
}
if (enabled)
{
#if VIU_XR_PACKAGE_METADATA_STORE
if (!UnityEditor.XR.Management.Metadata.XRPackageMetadataStore.AssignLoader(xrSettings.AssignedSettings, loaderClassName, buildTargetGroup))
{
Debug.LogWarning("Failed to assign XR loader: " + loaderClassName);
}
#else
if (!AssignLoader(xrSettings.AssignedSettings, loaderClassName))
{
Debug.LogWarning("Failed to assign XR loader: " + loaderClassName);
}
#endif
}
else
{
#if VIU_XR_PACKAGE_METADATA_STORE
if (!UnityEditor.XR.Management.Metadata.XRPackageMetadataStore.RemoveLoader(xrSettings.AssignedSettings, loaderClassName, buildTargetGroup))
{
Debug.LogWarning("Failed to remove XR loader: " + loaderClassName);
}
#else
if (!RemoveLoader(xrSettings.AssignedSettings, loaderClassName))
{
Debug.LogWarning("Failed to remove XR loader: " + loaderClassName);
}
#endif
}
#endif
}
public void OnPreprocessBuild(BuildReport report)
{
// Always remember to cleanup preloaded assets after build to make sure we don't
// dirty later builds with assets that may not be needed or are out of date.
CleanOldSettings();
XRGeneralSettingsPerBuildTarget buildTargetSettings = null;
EditorBuildSettings.TryGetConfigObject(XRGeneralSettings.k_SettingsKey, out buildTargetSettings);
if (buildTargetSettings == null)
{
return;
}
XRGeneralSettings settings = buildTargetSettings.SettingsForBuildTarget(report.summary.platformGroup);
if (settings == null)
{
return;
}
// store off some info about the first loader in the list for PreInit boot.config purposes
preInitInfo = null;
XRManagerSettings loaderManager = settings.AssignedSettings;
if (loaderManager != null)
{
List <XRLoader> loaders = loaderManager.loaders;
if (loaders.Count >= 1)
{
preInitInfo = new PreInitInfo(loaders[0] as IXRLoaderPreInit, report.summary.platform, report.summary.platformGroup);
}
}
if (loaderManager != null)
{
// chances are that our devices won't fall back to graphics device types later in the list so it's better to assume the device will be created with the first gfx api in the list.
// furthermore, we have no way to influence falling back to other graphics API types unless we automatically change settings underneath the user which is no good!
GraphicsDeviceType[] deviceTypes = PlayerSettings.GetGraphicsAPIs(report.summary.platform);
if (deviceTypes.Length > 0)
{
VerifyGraphicsAPICompatibility(loaderManager, deviceTypes[0]);
}
else
{
Debug.LogWarning("No Graphics APIs have been configured in Player Settings.");
}
}
UnityEngine.Object[] preloadedAssets = PlayerSettings.GetPreloadedAssets();
if (!preloadedAssets.Contains(settings))
{
var assets = preloadedAssets.ToList();
assets.Add(settings);
PlayerSettings.SetPreloadedAssets(assets.ToArray());
}
}
public override void PerBuildExecute(BuildReleaseType releaseType, BuildPlatform platform, BuildArchitecture architecture, BuildDistribution distribution, DateTime buildTime, ref BuildOptions options, string configKey, string buildPath)
{
XRGeneralSettings generalSettings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(platform.targetGroup);
XRManagerSettings settingsManager = generalSettings.Manager;
generalSettings.InitManagerOnStart = InitializeXROnStartup;
settingsManager.loaders = XRPlugins;
}
/// <summary>Set specific settings for a given build target.</summary>
///
/// <param name="targetGroup">An enum specifying which platform group this build is for.</param>
/// <param name="settings">An instance of <see cref="XRGeneralSettings"/> to assign for the given key.</param>
public void SetSettingsForBuildTarget(BuildTargetGroup targetGroup, XRGeneralSettings settings)
{
// Ensures the editor's "runtime instance" is the most current for standalone settings
if (targetGroup == BuildTargetGroup.Standalone)
{
XRGeneralSettings.Instance = settings;
}
Settings[targetGroup] = settings;
}
public virtual void TearDownTest()
{
#if UNITY_EDITOR
EditorBuildSettings.RemoveConfigObject(XRGeneralSettings.k_SettingsKey);
buildTargetSettings = null;
testManager = null;
xrGeneralSettings = null;
AssetDatabase.DeleteAsset(Path.Combine("Assets", "Temp"));
#endif
}
private static XRGeneralSettings GetXRGeneralSettingsInstance(string pathToSettings)
{
XRGeneralSettings ret = null;
if (pathToSettings.Length > 0)
{
ret = AssetDatabase.LoadAssetAtPath(pathToSettings, typeof(XRGeneralSettings)) as XRGeneralSettings;
}
return(ret);
}
private static bool InitXRSDK()
{
XRGeneralSettings xrGeneralSettings = LoadXRSettingsFromAssetBundle();
if (xrGeneralSettings == null)
{
LogInfo("XRGeneralSettings Instance is null!");
return(false);
}
LogDebug("Loaded XRGeneralSettings!");
return(InitializeXRSDKLoaders(xrGeneralSettings.Manager));
}
public virtual void SetupTest()
{
#if UNITY_EDITOR
var windowTypes = TypeCache.GetTypesDerivedFrom(typeof(EditorWindow));
foreach (var wt in windowTypes)
{
if (wt.Name.Contains("ProjectSettingsWindow"))
{
var projectSettingsWindow = EditorWindow.GetWindow(wt);
if (projectSettingsWindow != null)
{
projectSettingsWindow.Close();
}
}
}
testPathToGeneralSettings = GetAssetPathForComponents(s_TestGeneralSettings);
testPathToGeneralSettings = Path.Combine(testPathToGeneralSettings, "Test_XRGeneralSettingsPerBuildTarget.asset");
if (File.Exists(testPathToGeneralSettings))
{
AssetDatabase.DeleteAsset(testPathToGeneralSettings);
}
buildTargetSettings = ScriptableObject.CreateInstance <XRGeneralSettingsPerBuildTarget>();
AssetDatabase.CreateAsset(buildTargetSettings, testPathToGeneralSettings);
testPathToSettings = GetAssetPathForComponents(s_TempSettingsPath);
testPathToSettings = Path.Combine(testPathToSettings, "Test_XRGeneralSettings.asset");
if (File.Exists(testPathToSettings))
{
AssetDatabase.DeleteAsset(testPathToSettings);
}
testManager = ScriptableObject.CreateInstance <XRManagerSettings>();
xrGeneralSettings = ScriptableObject.CreateInstance <XRGeneralSettings>() as XRGeneralSettings;
XRGeneralSettings.Instance = xrGeneralSettings;
xrGeneralSettings.Manager = testManager;
buildTargetSettings.SetSettingsForBuildTarget(BuildTargetGroup.Standalone, xrGeneralSettings);
AssetDatabase.CreateAsset(xrGeneralSettings, testPathToSettings);
AssetDatabase.AddObjectToAsset(testManager, xrGeneralSettings);
AssetDatabase.SaveAssets();
EditorBuildSettings.AddConfigObject(XRGeneralSettings.k_SettingsKey, buildTargetSettings, true);
#endif
}
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();
}
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);
}
}
public bool ShouldIncludeRuntimePluginsInBuild(string path)
{
XRGeneralSettings generalSettings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget));
if (generalSettings == null)
{
return(false);
}
foreach (var loader in generalSettings.Manager.loaders)
{
if (loader is OpenVRLoader)
{
return(true);
}
}
return(false);
}
public void SetupTest()
{
testManager = ScriptableObject.CreateInstance <XRManagerSettings>();
testSettings = ScriptableObject.CreateInstance <XRGeneralSettings>() as XRGeneralSettings;
testSettings.Manager = testManager;
testPathToSettings = XRGeneralSettingsTests.GetAssetPathForComponents(XRGeneralSettingsTests.s_TempSettingsPath);
if (!string.IsNullOrEmpty(testPathToSettings))
{
testPathToSettings = Path.Combine(testPathToSettings, "Test_XRGeneralSettings.asset");
AssetDatabase.CreateAsset(testSettings, testPathToSettings);
AssetDatabase.SaveAssets();
}
EditorBuildSettings.TryGetConfigObject(XRGeneralSettings.k_SettingsKey, out currentSettings);
EditorBuildSettings.AddConfigObject(XRGeneralSettings.k_SettingsKey, testSettings, true);
}
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;
}
