public void OnPreprocessBuild(BuildReport report)
{
// Assign each library a "ShouldIncludeInBuild" delegate to indicate whether the plugin
// should be placed in a build on a specific platform. As of right now it's only important
// for runtime on the device but that could change to have standalone include remoting libs
AssignNativePluginIncludeInBuildDelegates();
// 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();
MagicLeapSettings settings = null;
EditorBuildSettings.TryGetConfigObject(MagicLeapConstants.kSettingsKey, out settings);
if (settings == null)
{
return;
}
#if PLATFORM_LUMIN
MagicLeapImageDatabaseBuildProcessor.BuildImageTrackingAssets();
#endif
UnityEngine.Object[] preloadedAssets = PlayerSettings.GetPreloadedAssets();
if (!preloadedAssets.Contains(settings))
{
var assets = preloadedAssets.ToList();
assets.Add(settings);
PlayerSettings.SetPreloadedAssets(assets.ToArray());
}
}
private PlayerIdentityGeneralSettings GetPlayerIdentityGeneralSettings(BuildTargetGroup targetGroup)
{
PlayerIdentityGeneralSettingsPerBuildTarget buildTargetSettings = null;
EditorBuildSettings.TryGetConfigObject(PlayerIdentityGeneralSettings.k_SettingsKey, out buildTargetSettings);
return(buildTargetSettings == null ? null : buildTargetSettings.SettingsForBuildTarget(targetGroup));
}
private WindowsMRPackageSettings PackageSettingsForBuildTargetGroup(BuildTargetGroup buildTargetGroup)
{
if (!HasLoaderEnabledForTarget(buildTargetGroup))
{
return(null);
}
UnityEngine.Object settingsObj = null;
EditorBuildSettings.TryGetConfigObject(BuildSettingsKey, out settingsObj);
WindowsMRPackageSettings settings = settingsObj as WindowsMRPackageSettings;
if (settings == null)
{
var assets = AssetDatabase.FindAssets("t:WindowsMRPackageSettings");
if (assets.Length == 1)
{
string path = AssetDatabase.GUIDToAssetPath(assets[0]);
settings = AssetDatabase.LoadAssetAtPath(path, typeof(WindowsMRPackageSettings)) as WindowsMRPackageSettings;
if (settings != null)
{
EditorBuildSettings.AddConfigObject(BuildSettingsKey, settings, true);
}
}
}
return(settings);
}
public void AssetReferenceDrawer_SetMainAssets_CanSetMultipleAssets(int numAtlasObjects, int numReferences)
{
// Setup
var subAssets = new List <Object>();
var atlas = SetUpSpriteAtlas(numAtlasObjects, out subAssets);
var property = SetupForSetSubAssets(atlas, numReferences);
m_AssetReferenceDrawer.m_label = new GUIContent("testSpriteReference");
FieldInfo propertyFieldInfo = typeof(TestSubObjectsSpriteAtlas).GetField("testSpriteReference", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
var assetPath = AssetDatabase.GetAssetOrScenePath(atlas);
var atlasGuid = AssetDatabase.AssetPathToGUID(assetPath);
// Test
m_AssetReferenceDrawer.SetMainAssets(property, atlas, null, propertyFieldInfo);
foreach (var obj in property.serializedObject.targetObjects)
{
Assert.AreEqual(((TestSubObjectsSpriteAtlas)obj).testSpriteReference.AssetGUID, atlasGuid);
}
// Cleanup
if (Directory.Exists("Assets/AddressableAssetsData"))
{
AssetDatabase.DeleteAsset("Assets/AddressableAssetsData");
}
EditorBuildSettings.RemoveConfigObject("Assets/AddressableAssetsData");
}
public BuildSettingsExportCollection(IAssetExporter assetExporter, VirtualSerializedFile virtualFile, BuildSettings asset) :
base(assetExporter, asset)
{
EditorBuildSettings = EditorBuildSettings.CreateVirtualInstance(virtualFile);
EditorSettings = EditorSettings.CreateVirtualInstance(virtualFile);
if (!NavMeshProjectSettings.IsReadNavMeshProjectSettings(asset.File.Version))
{
NavMeshProjectSettings = NavMeshProjectSettings.CreateVirtualInstance(virtualFile);
}
if (!NetworkManager.IsReadNetworkManager(asset.File.Version))
{
NetworkManager = NetworkManager.CreateVirtualInstance(virtualFile);
}
if (!Physics2DSettings.IsReadPhysics2DSettings(asset.File.Version))
{
Physics2DSettings = Physics2DSettings.CreateVirtualInstance(virtualFile);
}
if (!UnityConnectSettings.IsReadUnityConnectSettings(asset.File.Version))
{
UnityConnectSettings = UnityConnectSettings.CreateVirtualInstance(virtualFile);
}
if (!QualitySettings.IsReadQualitySettings(asset.File.Version))
{
QualitySettings = QualitySettings.CreateVirtualInstance(virtualFile);
}
}
public void CheckEmptyXRGeneralAssetWillNotGetIncludedInAssets()
{
EditorBuildSettings.TryGetConfigObject(XRGeneralSettings.k_SettingsKey, out XRGeneralSettingsPerBuildTarget buildTargetSettings);
Assert.False(buildTargetSettings == null);
var settings = buildTargetSettings.SettingsForBuildTarget(m_BuildTargetGroup);
Assert.False(settings == null);
var preloadedAssets = PlayerSettings.GetPreloadedAssets();
var settingsIncludedInPreloadedAssets = preloadedAssets.Contains(settings);
// Use the logic in XRGeneralBuildProcessor.OnPreprocessBuild() to determine if the XR General Settings will
// be include or not.
if (!settingsIncludedInPreloadedAssets && settings.AssignedSettings.activeLoaders.Count > 0)
{
var assets = preloadedAssets.ToList();
assets.Add(settings);
PlayerSettings.SetPreloadedAssets(assets.ToArray());
}
else
{
CleanupOldSettings();
}
Assert.False(PlayerSettings.GetPreloadedAssets().Contains(settings));
}
public void OnPreprocessBuild(BuildReport report)
{
CheckInstalledProvider();
// Always remember to clean up 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();
AdaptivePerformanceGeneralSettingsPerBuildTarget buildTargetSettings = null;
EditorBuildSettings.TryGetConfigObject(AdaptivePerformanceGeneralSettings.k_SettingsKey, out buildTargetSettings);
if (buildTargetSettings == null)
{
return;
}
AdaptivePerformanceGeneralSettings settings = buildTargetSettings.SettingsForBuildTarget(report.summary.platformGroup);
if (settings == null)
{
return;
}
UnityEngine.Object[] preloadedAssets = PlayerSettings.GetPreloadedAssets();
if (!preloadedAssets.Contains(settings))
{
var assets = preloadedAssets.ToList();
assets.Add(settings);
PlayerSettings.SetPreloadedAssets(assets.ToArray());
}
}
public static GameBuildSettings GetDefault()
{
string objectName = "cl.munditodt.gamebuildsettings";
string path = "Assets/GameBuildSettings.asset";
GameBuildSettings data = null;
// Try to get it
if (EditorBuildSettings.TryGetConfigObject <GameBuildSettings>(objectName, out data))
{
return(data);
}
// If not, try to search the asset
if (File.Exists(path))
{
data = AssetDatabase.LoadAssetAtPath <GameBuildSettings>(path);
}
// Create new if nothing exists
if (data == null)
{
// Show dialog and save
path = EditorUtility.SaveFilePanelInProject("New Build Settings File", "GameBuildSettings", "asset", "Select Config File Asset", "Assets");
// Initialize
data = ScriptableObject.CreateInstance <GameBuildSettings>();
// Create and save
AssetDatabase.CreateAsset(data, path);
}
EditorBuildSettings.AddConfigObject(objectName, data, false);
return(data);
}
internal void InitializeWithCurrentSettings()
{
m_AvailableSettingsAssets = FindSettingsInProject();
m_Settings = MLAgentsSettingsManager.Settings;
var currentSettingsPath = AssetDatabase.GetAssetPath(m_Settings);
if (string.IsNullOrEmpty(currentSettingsPath))
{
if (m_AvailableSettingsAssets.Length > 0)
{
m_CurrentSelectedSettingsAsset = 0;
m_Settings = AssetDatabase.LoadAssetAtPath <MLAgentsSettings>(m_AvailableSettingsAssets[0]);
MLAgentsSettingsManager.Settings = m_Settings;
}
}
else
{
var settingsList = m_AvailableSettingsAssets.ToList();
m_CurrentSelectedSettingsAsset = settingsList.IndexOf(currentSettingsPath);
EditorBuildSettings.AddConfigObject(MLAgentsSettingsManager.EditorBuildSettingsConfigKey, m_Settings, true);
}
m_SettingsObject = new SerializedObject(m_Settings);
}
private bool LoadOpenXRSymbols()
{
string loaderPath = "openxr_loader";
#if UNITY_EDITOR_WIN
loaderPath = "..\\..\\..\\RuntimeLoaders\\windows\\x64\\openxr_loader";
#elif UNITY_EDITOR_OSX
// no loader for osx, use the mock by default
loaderPath = "../../../Tests/osx/x64/openxr_loader";
#endif
#if UNITY_EDITOR
// Pass down active loader path to plugin
EditorBuildSettings.TryGetConfigObject <UnityEngine.Object>(Constants.k_SettingsKey, out var obj);
if (obj != null && (obj is IPackageSettings packageSettings))
{
var extensionLoaderPath = packageSettings.GetActiveLoaderLibraryPath();
if (!String.IsNullOrEmpty(extensionLoaderPath))
{
loaderPath = extensionLoaderPath;
}
}
#endif
if (!Internal_LoadOpenXRLibrary(loaderPath))
{
return(false);
}
return(true);
}
protected void SetupLoaderAndSettings()
{
#if UNITY_EDITOR
// Setup Loader
var path = GetAssetPathForComponents(s_TempSettingsPath);
var loaderPath = Path.Combine(path, $"Test_{typeof(L).Name}.asset");
loader = GetOrCreateAsset <L>(loaderPath);
if (xrGeneralSettings == null)
{
xrGeneralSettings = XRGeneralSettings.Instance;
testManager = xrGeneralSettings?.Manager ?? null;
}
#pragma warning disable CS0618
xrGeneralSettings?.Manager.loaders.Clear();
xrGeneralSettings?.Manager.loaders.Add(loader);
#pragma warning restore CS0618
// Setup Settings
var settingsPath = Path.Combine(path, $"Test_{typeof(S).Name}.asset");
settings = GetOrCreateAsset <S>(settingsPath);
EditorBuildSettings.AddConfigObject(settingsKey, settings, true);
#endif
}
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 override bool Export(ProjectAssetContainer container, string dirPath)
{
string subPath = Path.Combine(dirPath, ProjectSettingsName);
string fileName = $"{EditorBuildSettings.ClassID.ToString()}.asset";
string filePath = Path.Combine(subPath, fileName);
if (!DirectoryUtils.Exists(subPath))
{
DirectoryUtils.CreateDirectory(subPath);
}
BuildSettings asset = (BuildSettings)Asset;
IEnumerable <Scene> scenes = asset.Scenes.Select(t => new Scene(t, container.SceneNameToGUID(t)));
EditorBuildSettings.Initialize(scenes);
AssetExporter.Export(container, EditorBuildSettings, filePath);
fileName = $"{EditorSettings.ClassID.ToString()}.asset";
filePath = Path.Combine(subPath, fileName);
AssetExporter.Export(container, EditorSettings, filePath);
fileName = $"ProjectVersion.txt";
filePath = Path.Combine(subPath, fileName);
using (FileStream file = FileUtils.Create(filePath))
{
using (StreamWriter writer = new StreamWriter(file))
{
writer.Write("m_EditorVersion: 2017.3.0f3");
}
}
return(true);
}
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();
MagicLeapSettings settings = null;
EditorBuildSettings.TryGetConfigObject(MagicLeapConstants.kSettingsKey, out settings);
if (settings == null)
{
return;
}
MagicLeapImageDatabaseBuildProcessor.BuildImageTrackingAssets();
UnityEngine.Object[] preloadedAssets = PlayerSettings.GetPreloadedAssets();
if (!preloadedAssets.Contains(settings))
{
var assets = preloadedAssets.ToList();
assets.Add(settings);
PlayerSettings.SetPreloadedAssets(assets.ToArray());
}
}
public static BuildData GetDefault()
{
string stringName = "com.myproject.myconfigdata";
string stringPath = "Assets/myconfigdata.asset";
BuildData data = null;
if (EditorBuildSettings.TryGetConfigObject <BuildData>(stringName, out data))
{
return(data);
}
if (File.Exists(stringPath))
{
data = AssetDatabase.LoadAssetAtPath <BuildData>(stringPath);
}
if (data == null)
{
stringPath = EditorUtility.SaveFilePanelInProject("New Config File", "myconfigdata", "asset", "Select Config File Asset", "Assets");
data = ScriptableObject.CreateInstance <BuildData>();
AssetDatabase.CreateAsset(data, stringPath);
}
EditorBuildSettings.AddConfigObject(stringName, data, false);
return(data);
}
static void TestEditorBuildSettings()
{
string[] arraies = EditorBuildSettings.GetConfigObjectNames();
foreach (var item in arraies)
{
Debug.Log(item);
}
}
public void Cleanup()
{
if (Directory.Exists(k_TestConfigFolder))
{
AssetDatabase.DeleteAsset(k_TestConfigFolder);
}
EditorBuildSettings.RemoveConfigObject(k_TestConfigName);
}
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 UnityEngine.Object SettingsForBuildTargetGroup(BuildTargetGroup buildTargetGroup)
{
EditorBuildSettings.TryGetConfigObject(Constants.k_SettingsKey, out OpenXRPackageSettings packageSettings);
if (packageSettings == null)
{
return(null);
}
return(packageSettings.GetSettingsForBuildTargetGroup(buildTargetGroup));
}
/// <summary>
/// Creates a new AddressableImportSettings and add it to the EditorBuildSettings.
/// </summary>
public void Create(AddressableImportSettings settings)
{
settings = CreateInstance <AddressableImportSettings>();
AssetDatabase.CreateAsset(settings, "Assets/AddressableAssetsData/AddressableImportSettings.asset");
AssetDatabase.SaveAssets();
EditorBuildSettings.AddConfigObject("AddressableImportSettings", settings, true);
settings.rules = new List <AddressableImportRule>();
}
public void Cleanup()
{
if (Directory.Exists(TestFolder))
{
Debug.Log($"{GetType()} - (cleanup) deleting {TestFolder}");
AssetDatabase.DeleteAsset(TestFolder);
}
EditorBuildSettings.RemoveConfigObject(k_TestConfigName);
}
internal static IPackageSettings GetPackageSettings()
{
if (EditorBuildSettings.TryGetConfigObject <UnityEngine.Object>(Constants.k_SettingsKey, out var obj) && (obj is IPackageSettings packageSettings))
{
return(packageSettings);
}
return(null);
}
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
}
public void TearDown()
{
if (storedConfigObject != null)
{
EditorBuildSettings.AddConfigObject(EditorBuildSettingsConfigKey, storedConfigObject, true);
storedConfigObject = null;
}
MLAgentsSettingsManager.Destroy();
ClearSettingsAssets();
}
static public void SetupLoader()
{
if (XRGraphicsAutomatedTests.enabled)
{
var xrGeneralSettings = AssetDatabase.LoadAssetAtPath(pathToSettings, typeof(XRGeneralSettingsPerBuildTarget));
Assert.NotNull(xrGeneralSettings, "Unable to load " + pathToSettings);
EditorBuildSettings.AddConfigObject(XRGeneralSettings.k_SettingsKey, xrGeneralSettings, true);
}
}
/// <summary>Helper function to return current settings for a specific build target.</summary>
///
/// <param name="buildTargetGroup">An enum that specifies which platform group this build is for.</param>
/// <returns>A Unity object that represents the settings instance data for that build target, or null if not found.</returns>
public virtual UnityEngine.Object SettingsForBuildTargetGroup(BuildTargetGroup buildTargetGroup)
{
UnityEngine.Object settingsObj = null;
EditorBuildSettings.TryGetConfigObject(BuildSettingsKey, out settingsObj);
if (settingsObj == null || !(settingsObj is T))
{
return(null);
}
return(settingsObj);
}
public static void GenerateFile()
{
var buildSettings = new EditorBuildSettings();
var root = buildSettings.GetScenesAndResolutions();
if (root != null)
{
var xmlFile = new XmlFile();
xmlFile.Save(root);
}
}
public void AddressableAssetSettings_MoveAssetsFromResources_AddressRespectFolderHierarchy()
{
// Setup
var guidsToPaths = new Dictionary <string, string>();
var obj = new GameObject("TestObjectMoveAssets");
var objFolder = ConfigFolder + "/Resources/subfolder/subsubfolder";
if (!Directory.Exists(objFolder))
{
Directory.CreateDirectory(objFolder);
}
var objPath = objFolder + "/testasset.prefab";
PrefabUtility.SaveAsPrefabAsset(obj, objPath);
var guid = AssetDatabase.AssetPathToGUID(objPath);
var playerDataGroup = Settings.FindGroup(AddressableAssetSettings.PlayerDataGroupName);
Settings.CreateOrMoveEntry(guid, playerDataGroup);
var destinationFolder = ConfigFolder + "/testMoveAssets";
guidsToPaths[guid] = destinationFolder + "/testasset.prefab";
// Test
var defaultLocalGroup = Settings.FindGroup(AddressableAssetSettings.DefaultLocalGroupName);
Settings.MoveAssetsFromResources(guidsToPaths, defaultLocalGroup);
var idx = objPath.ToLower().LastIndexOf("resources/");
var expectedAddress = objPath.Substring(idx + 10).Replace(Path.GetExtension(objPath), "");
var entry = Settings.FindAssetEntry(guid);
Assert.AreEqual(expectedAddress, entry.address);
Assert.AreEqual(guidsToPaths[guid], AssetDatabase.GUIDToAssetPath(guid));
Assert.AreEqual(defaultLocalGroup, entry.parentGroup);
//Cleanup
if (Directory.Exists(ConfigFolder + "/Resources"))
{
AssetDatabase.DeleteAsset(ConfigFolder + "/Resources");
}
EditorBuildSettings.RemoveConfigObject(ConfigFolder + "/Resources");
Settings.RemoveAssetEntry(guid);
AssetDatabase.DeleteAsset(guidsToPaths[guid]);
if (Directory.Exists(destinationFolder))
{
AssetDatabase.DeleteAsset(destinationFolder);
}
EditorBuildSettings.RemoveConfigObject(destinationFolder);
}
/// <summary>Given a build target, get the general settings container assigned to it.</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 static XRGeneralSettings XRGeneralSettingsForBuildTarget(BuildTargetGroup targetGroup)
{
XRGeneralSettingsPerBuildTarget buildTargetSettings = null;
EditorBuildSettings.TryGetConfigObject(XRGeneralSettings.k_SettingsKey, out buildTargetSettings);
if (buildTargetSettings == null)
{
return(null);
}
return(buildTargetSettings.SettingsForBuildTarget(targetGroup));
}
/// <summary>Given a build target, get the general settings container assigned to it.</summary>
/// <param name="targetGroup">An enum that specifies which platform group this build is for.</param>
/// <returns>The instance of <see cref="AdaptivePerformanceGeneralSettings"/> assigned to the key, or null if no instance is assigned.</returns>
public static AdaptivePerformanceGeneralSettings AdaptivePerformanceGeneralSettingsForBuildTarget(BuildTargetGroup targetGroup)
{
AdaptivePerformanceGeneralSettingsPerBuildTarget buildTargetSettings = null;
EditorBuildSettings.TryGetConfigObject(AdaptivePerformanceGeneralSettings.k_SettingsKey, out buildTargetSettings);
if (buildTargetSettings == null)
{
return(null);
}
return(buildTargetSettings.SettingsForBuildTarget(targetGroup));
}
