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(AdaptivePerformancePackageMetadataStore.AssignLoader(m_Settings, loaderTypeName, BuildTargetGroup.Standalone));
yield return(null);
Assert.IsTrue(SettingsHasLoaderOfType(m_Settings, loaderTypeName));
Assert.IsTrue(TestLoaderBase.WasAssigned);
}
public IEnumerator AccessSettings()
{
int frameCount = 0;
string[] assets = new string[0] {
};
TestPackage.Editor.TestPackage pkg = new TestPackage.Editor.TestPackage();
AdaptivePerformancePackageMetadataStore.AddPluginPackage(pkg);
AdaptivePerformancePackageInitializationBootstrap.InitPackage(pkg);
while (frameCount < 60)
{
yield return(null);
frameCount++;
}
yield return(null);
var metadata = AdaptivePerformancePackageMetadataStore.GetMetadataForPackage("com.unity.adaptiveperformance.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);
}
private bool AssignLoaderToSettings(AdaptivePerformanceManagerSettings settings, string loaderTypeName, BuildTargetGroup buildTargetGroup = BuildTargetGroup.Standalone)
{
if (String.IsNullOrEmpty(loaderTypeName))
{
return(false);
}
return(AdaptivePerformancePackageMetadataStore.AssignLoader(m_Settings, loaderTypeName, buildTargetGroup));
}
public void Setup()
{
AssetDatabase.DeleteAsset("Assets/Adaptive Performance");
AdaptivePerformancePackageInitializationBootstrap.BeginPackageInitialization();
TestPackage.Editor.TestPackage pkg = new TestPackage.Editor.TestPackage();
AdaptivePerformancePackageMetadataStore.AddPluginPackage(pkg);
AdaptivePerformancePackageInitializationBootstrap.InitPackage(pkg);
}
private string LoaderTypeNameForBuildTarget(BuildTargetGroup buildTargetGroup)
{
var loaders = AdaptivePerformancePackageMetadataStore.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("");
}
public IEnumerator TestNoPackageIdErrorsOut()
{
#if !UNITY_2020_2_OR_NEWER
AdaptivePerformancePackageMetadataStore.InstallPackageAndAssignLoaderForBuildTarget("", String.Empty, BuildTargetGroup.Standalone);
LogAssert.Expect(LogType.Error, new Regex(@"no package id"));
while (AdaptivePerformancePackageMetadataStore.isDoingQueueProcessing)
{
yield return(null);
}
#else
yield return(null);
#endif //UNITY_2020_2_OR_NEWER
}
public static void SetupTest()
{
testManager = ScriptableObject.CreateInstance <AdaptivePerformanceManagerSettings>();
adaptivePerformanceGeneralSettings = ScriptableObject.CreateInstance <AdaptivePerformanceGeneralSettings>() as AdaptivePerformanceGeneralSettings;
adaptivePerformanceGeneralSettings.Manager = testManager;
testPathToSettings = GetAssetPathForComponents(s_TempSettingsPath);
testPathToSettings = Path.Combine(testPathToSettings, $"Test_{ typeof(AdaptivePerformanceGeneralSettings).Name}.asset");
if (!string.IsNullOrEmpty(testPathToSettings))
{
AssetDatabase.CreateAsset(adaptivePerformanceGeneralSettings, testPathToSettings);
AssetDatabase.AddObjectToAsset(testManager, adaptivePerformanceGeneralSettings);
AssetDatabase.SaveAssets();
}
testPathToGeneralSettings = GetAssetPathForComponents(s_TestGeneralSettings);
testPathToGeneralSettings = Path.Combine(testPathToGeneralSettings, $"Test_{typeof(AdaptivePerformanceGeneralSettingsPerBuildTarget).Name}.asset");
buildTargetSettings = ScriptableObject.CreateInstance <AdaptivePerformanceGeneralSettingsPerBuildTarget>();
buildTargetSettings.SetSettingsForBuildTarget(BuildTargetGroup.Standalone, adaptivePerformanceGeneralSettings);
if (!string.IsNullOrEmpty(testPathToSettings))
{
AssetDatabase.CreateAsset(buildTargetSettings, testPathToGeneralSettings);
AssetDatabase.SaveAssets();
EditorBuildSettings.TryGetConfigObject(AdaptivePerformanceGeneralSettings.k_SettingsKey, out currentSettings);
EditorBuildSettings.AddConfigObject(AdaptivePerformanceGeneralSettings.k_SettingsKey, buildTargetSettings, true);
}
testPathToLoader = GetAssetPathForComponents(s_TempSettingsPath);
// Setup Loader
loader = ScriptableObject.CreateInstance(typeof(SimulatorProviderLoader)) as SimulatorProviderLoader;
AssetDatabase.CreateAsset(loader, Path.Combine(testPathToLoader, $"Test_{typeof(SimulatorProviderLoader).Name}.asset"));
testManager.loaders.Add(loader);
// Setup Settings
settings = ScriptableObject.CreateInstance(typeof(SimulatorProviderSettings)) as SimulatorProviderSettings;
AssetDatabase.CreateAsset(settings, Path.Combine(testPathToLoader, $"Test_{typeof(SimulatorProviderSettings).Name}.asset"));
//settings.logging = false;
EditorBuildSettings.AddConfigObject(SimulatorProviderConstants.k_SettingsKey, settings, true);
// Due to the Settings menu, we have to manually assigned the Simulator loader in tests.
AdaptivePerformancePackageMetadataStore.AssignLoader(AdaptivePerformanceGeneralSettings.Instance.Manager, typeof(SimulatorProviderLoader).Name, BuildTargetGroup.Standalone);
}
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 = AdaptivePerformancePackageMetadataStore.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);
}
}
internal static void InitPackage(IAdaptivePerformancePackage 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;
}
AdaptivePerformancePackageMetadataStore.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 Adaptive Performance Provider Package.", packageMetadata.packageName));
}
}
public void SetUp()
{
AssetDatabase.DeleteAsset("Assets/Adaptive Performance");
AssetDatabase.CreateFolder("Assets", "Adaptive Performance");
m_Settings = ScriptableObject.CreateInstance <AdaptivePerformanceManagerSettings>() as AdaptivePerformanceManagerSettings;
m_Settings.name = "Actual testable settings.";
m_TestSettings = ScriptableObject.CreateInstance <AdaptivePerformanceGeneralSettings>() as AdaptivePerformanceGeneralSettings;
m_TestSettings.Manager = m_Settings;
m_TestSettings.name = "Standalone Settings Container.";
m_TestSettingsPerBuildTarget = ScriptableObject.CreateInstance <AdaptivePerformanceGeneralSettingsPerBuildTarget>() as AdaptivePerformanceGeneralSettingsPerBuildTarget;
m_TestSettingsPerBuildTarget.SetSettingsForBuildTarget(BuildTargetGroup.Standalone, m_TestSettings);
var testPath = AdaptivePerformanceGeneralSettingsTests.GetAssetPathForComponents(s_TempSettingsPath);
if (!string.IsNullOrEmpty(testPath))
{
AssetDatabase.CreateAsset(m_TestSettingsPerBuildTarget, Path.Combine(testPath, "Test_AdaptivePerformanceGeneralSettings.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_AdaptivePerformanceSettingsManager.asset"));
m_TestSettings.AssignedSettings = m_Settings;
AssetDatabase.SaveAssets();
}
EditorBuildSettings.AddConfigObject(AdaptivePerformanceGeneralSettings.k_SettingsKey, m_TestSettingsPerBuildTarget, true);
AdaptivePerformancePackageInitializationBootstrap.BeginPackageInitialization();
TestPackage.Editor.TestPackage pkg = new TestPackage.Editor.TestPackage();
AdaptivePerformancePackageMetadataStore.AddPluginPackage(pkg);
AdaptivePerformancePackageInitializationBootstrap.InitPackage(pkg);
TestLoaderBase.WasAssigned = false;
TestLoaderBase.WasUnassigned = false;
}
internal static bool ContainsLoaderForAnyBuildTarget(string loaderTypeName)
{
AdaptivePerformanceGeneralSettingsPerBuildTarget buildTargetSettings = null;
EditorBuildSettings.TryGetConfigObject(AdaptivePerformanceGeneralSettings.k_SettingsKey, out buildTargetSettings);
if (buildTargetSettings == null)
{
return(false);
}
foreach (var settings in buildTargetSettings.Settings.Values)
{
if (AdaptivePerformancePackageMetadataStore.IsLoaderAssigned(settings.Manager, loaderTypeName))
{
return(true);
}
}
return(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(AdaptivePerformancePackageMetadataStore.RemoveLoader(m_Settings, loaderTypeName, BuildTargetGroup.Standalone));
m_Settings = null;
var settings = EditorUtilities.GetInstanceOfTypeFromAssetDatabase <AdaptivePerformanceManagerSettings>();
m_Settings = settings as AdaptivePerformanceManagerSettings;
Assert.IsNotNull(m_Settings);
Assert.IsFalse(SettingsHasLoaderOfType(m_Settings, loaderTypeName));
Assert.IsTrue(TestLoaderBase.WasUnassigned);
}
void DrawElementCallback(Rect rect, int index, bool isActive, bool isFocused)
{
var li = m_LoaderMetadata[index];
li.toggled = AdaptivePerformancePackageMetadataStore.IsLoaderAssigned(li.loaderType, CurrentBuildTargetGroup);
bool preToggledState = li.toggled;
rect.width *= 0.51f;
EditorGUIUtility.labelWidth = 180;
li.toggled = EditorGUI.Toggle(rect, li.loaderName, preToggledState);
if (li.toggled != preToggledState)
{
li.stateChanged = true;
m_LoaderMetadata[index] = li;
}
if (li.licenseURL != null)
{
DisplayLink(Content.k_LicenseViewText, new Uri(li.licenseURL), 2, 80, rect);
}
}
ScriptableObject Create()
{
ScriptableObject settings = ScriptableObject.CreateInstance(m_BuildDataType) as ScriptableObject;
if (settings != null)
{
var package = AdaptivePerformancePackageMetadataStore.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);
settings.hideFlags = HideFlags.HideInInspector;
AssetDatabase.CreateAsset(settings, assetPath);
EditorBuildSettings.AddConfigObject(m_BuildSettingsKey, settings, true);
return(settings);
}
}
return(null);
}
internal bool OnGUI(BuildTargetGroup buildTargetGroup)
{
var settings = AdaptivePerformanceGeneralSettingsPerBuildTarget.AdaptivePerformanceGeneralSettingsForBuildTarget(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 AdaptivePerformancePackageMetadataStore.GetLoadersForBuildTarget(buildTargetGroup))
{
m_LoaderMetadata.Add(new LoaderInformation()
{
packageName = pmd.packageName,
packageId = pmd.packageId,
loaderName = pmd.loaderName,
loaderType = pmd.loaderType,
licenseURL = pmd.licenseURL,
toggled = AdaptivePerformancePackageMetadataStore.IsLoaderAssigned(pmd.loaderType, buildTargetGroup)
});
}
if (settings != null)
{
LoaderInformation li;
for (int i = 0; i < m_LoaderMetadata.Count; i++)
{
li = m_LoaderMetadata[i];
if (AdaptivePerformancePackageMetadataStore.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) =>
{
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);
EditorGUI.LabelField(imageRect, Content.k_HelpContent);
};
m_OrderedList.drawElementCallback = (rect, index, isActive, isFocused) => DrawElementCallback(rect, index, isActive, isFocused);
m_OrderedList.elementHeightCallback = (index) => GetElementHeight(index);
m_OrderedList.drawFooterCallback = (rect) =>
{
var status = AdaptivePerformancePackageMetadataStore.GetCurrentStatusDisplayText();
GUI.Label(rect, status, EditorStyles.label);
};
}
if (m_LoaderMetadata == null || m_LoaderMetadata.Count == 0)
{
EditorGUILayout.HelpBox(Content.k_AtNoLoaderInstance, MessageType.Info);
}
else
{
EditorGUILayout.HelpBox(Content.k_LicenseText, MessageType.Info);
EditorGUILayout.Space();
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)
{
AdaptivePerformancePackageMetadataStore.InstallPackageAndAssignLoaderForBuildTarget(li.packageId, li.loaderType, buildTargetGroup);
}
else
{
AdaptivePerformancePackageMetadataStore.RemoveLoader(settings.AssignedSettings, li.loaderType, buildTargetGroup);
}
li.stateChanged = false;
m_LoaderMetadata[i] = li;
}
}
}
}
return(false);
}
