public void OneTimeSetup()
{
m_Resources = ScriptableObject.CreateInstance <TestResources>();
// gather clip dependencies
var allClips = typeof(TestResources).GetFields(BindingFlags.Instance | BindingFlags.Public)
.Where(f => f.FieldType == typeof(AnimationClip))
.Select(f => (ClipPath)(f.GetValue(m_Resources) as AnimationClip))
.ToArray();
var allPrefabs = typeof(TestResources).GetFields(BindingFlags.Instance | BindingFlags.Public)
.Where(f => f.FieldType == typeof(GameObject))
.Select(f => (PrefabPath)(f.GetValue(m_Resources) as GameObject))
.ToArray();
var allScenes = typeof(TestResources).GetFields(BindingFlags.Instance | BindingFlags.Public)
.Where(f => f.FieldType == typeof(SceneAsset))
.Select(f => (ScenePath)(f.GetValue(m_Resources) as SceneAsset))
.ToArray();
AnimationClipUpgrader.GetClipDependencyMappings(allClips, allPrefabs, out m_ClipsToPrefabDependents, out m_PrefabsToClipDependencies);
AnimationClipUpgrader.GetClipDependencyMappings(allClips, allScenes, out m_ClipsToSceneDependents, out m_ScenesToClipDependencies);
// sorting function to ease comparisons when actual/expected mismatch
int CompareKeyValuePair((IAssetPath, IAssetPath) a, (IAssetPath, IAssetPath) b) =>
string.Compare($"{a.Item1}{a.Item2}", $"{b.Item1}{b.Item2}", StringComparison.Ordinal);
// validate clip/prefab dependencies
GetExpectedPrefabDependencies(out var expectedClipToPrefabDependents, out var expectedPrefabsToClipDependencies);
var actualClipToPrefabs = m_ClipsToPrefabDependents.SelectMany(kv => kv.Value.Select(v => (kv.Key, v))).ToList();
var expectedClipToPrefabs = expectedClipToPrefabDependents.SelectMany(kv => kv.Value.Select(v => (kv.Key, v))).ToList();
actualClipToPrefabs.Sort((a, b) => CompareKeyValuePair(a, b));
expectedClipToPrefabs.Sort((a, b) => CompareKeyValuePair(a, b));
Assume.That(actualClipToPrefabs, Is.EquivalentTo(expectedClipToPrefabs));
var actualPrefabsToClips = m_PrefabsToClipDependencies.SelectMany(kv => kv.Value.Select(v => (kv.Key, v))).ToList();
var expectedPrefabsToClips = expectedPrefabsToClipDependencies.SelectMany(kv => kv.Value.Select(v => (kv.Key, v))).ToList();
actualPrefabsToClips.Sort((a, b) => CompareKeyValuePair(a, b));
expectedPrefabsToClips.Sort((a, b) => CompareKeyValuePair(a, b));
Assume.That(actualPrefabsToClips, Is.EquivalentTo(expectedPrefabsToClips));
// validate clip/scene dependencies
GetExpectedSceneDependencies(out var expectedClipToSceneDependents, out var expectedScenesToClipDependencies);
var actualClipsToScenes = m_ClipsToSceneDependents.SelectMany(kv => kv.Value.Select(v => (kv.Key, v))).ToList();
var expectedClipToScenes = expectedClipToSceneDependents.SelectMany(kv => kv.Value.Select(v => (kv.Key, v))).ToList();
actualClipsToScenes.Sort((a, b) => CompareKeyValuePair(a, b));
expectedClipToScenes.Sort((a, b) => CompareKeyValuePair(a, b));
Assume.That(actualClipsToScenes, Is.EquivalentTo(expectedClipToScenes));
var actualScenesToClips = m_ScenesToClipDependencies.SelectMany(kv => kv.Value.Select(v => (kv.Key, v))).ToList();
var expectedScenesToClips = expectedScenesToClipDependencies.SelectMany(kv => kv.Value.Select(v => (kv.Key, v))).ToList();
actualScenesToClips.Sort((a, b) => CompareKeyValuePair(a, b));
expectedScenesToClips.Sort((a, b) => CompareKeyValuePair(a, b));
Assume.That(actualScenesToClips, Is.EquivalentTo(expectedScenesToClips));
}
public void GetAssetDataForClipsFiltered_WhenClipPathContainsMultipleClips_ReturnsMultipleClips()
{
var childAnimationClip = m_Resources.Clip_ChildAsset_Animation_WithMaterialProperties as AnimationClip;
var childAnimatorClip = m_Resources.Clip_ChildAsset_Animator_WithMaterialProperties as AnimationClip;
var parentPath = new ClipPath {
Path = AssetDatabase.GetAssetPath(m_Resources.Clip_ParentAsset)
};
var result = AnimationClipUpgrader.GetAssetDataForClipsFiltered(new[] { parentPath });
var actualKeys = result.Keys.Select(k => k.Clip);
Assert.That(actualKeys, Is.EquivalentTo(new[] { childAnimationClip, childAnimatorClip }));
}
public void GetAssetDataForClipsFiltered_RemovesClipsWithoutMaterialAnimation()
{
var animationClip = m_Resources.Clip_Animation_WithMaterialProperties_PotentiallyUpgradable;
var animatorClip = m_Resources.Clip_Animator_WithMaterialProperties_PotentiallyUpgradable;
var timelineClip = m_Resources.Clip_Timeline_WithMaterialProperties_PotentiallyUpgradable;
var result = AnimationClipUpgrader.GetAssetDataForClipsFiltered(new ClipPath[]
{
m_Resources.Clip_Animation_WithMaterialProperties_PotentiallyUpgradable,
m_Resources.Clip_Animation_WithoutMaterialProperties,
m_Resources.Clip_Animator_WithMaterialProperties_PotentiallyUpgradable,
m_Resources.Clip_Animator_WithoutMaterialProperties,
m_Resources.Clip_Timeline_WithMaterialProperties_PotentiallyUpgradable,
m_Resources.Clip_Timeline_WithoutMaterialProperties
});
var actualKeys = result.Keys.Select(k => k.Clip);
Assert.That(actualKeys, Is.EquivalentTo(new[] { animationClip, animatorClip, timelineClip }));
}
public SerializedShaderPropertyUsage GatherClipsUsageInDependentPrefabs_WhenUsingSpecifiedClipProvider_ReturnsExpectedUsage(
string prefabName,
string clipName
)
{
var clipPath =
(ClipPath)(typeof(TestResources).GetField(clipName, BindingFlags.Public | BindingFlags.Instance)?.GetValue(m_Resources) as AnimationClip);
Assume.That(clipPath.Path, Is.Not.Null.And.Not.Empty);
var prefabPath =
(PrefabPath)(typeof(TestResources).GetField(prefabName, BindingFlags.Public | BindingFlags.Instance)?.GetValue(m_Resources) as GameObject);
Assume.That(prefabPath.Path, Is.Not.Null.And.Not.Empty);
var clipPaths = new[] { clipPath };
AnimationClipUpgrader.GetClipDependencyMappings(clipPaths, new[] { prefabPath }, out var clipDependents, out var prefabDependencies);
var materialUpgrader = new MaterialUpgrader();
materialUpgrader.RenameShader(
m_Resources.Material_Legacy_Upgradable.shader.name, m_Resources.Material_URP.shader.name
);
materialUpgrader.RenameColor("_Color", "_BaseColor");
materialUpgrader.RenameFloat("_MainTex_ST", "_BaseMap_ST");
var allUpgradePathsToNewShaders = new Dictionary <string, IReadOnlyList <MaterialUpgrader> >
{
{ m_Resources.Material_URP.shader.name, new[] { materialUpgrader } }
};
var clipData = AnimationClipUpgrader.GetAssetDataForClipsFiltered(clipPaths);
AnimationClipUpgrader.GatherClipsUsageInDependentPrefabs(
clipDependents,
prefabDependencies,
clipData,
allUpgradePathsToNewShaders,
upgradePathsUsedByMaterials: null
);
return(clipData.Values.Single().Usage);
}
