public void WhenSpriteWithAtlas_SpriteImportDataCreated(SpritePackerMode spriteMode, string spritePackingTag, bool hasReferencingSpriteAtlas, bool expectedPacked)
{
string sourceTexture = Path.Combine(kSourceTestAssetFolder, "SpriteTexture32x32.png");
string destTexture = Path.Combine(kTestAssetFolder, "SpriteTexture32x32.png");
AssetDatabase.CopyAsset(sourceTexture, destTexture);
TextureImporter importer = AssetImporter.GetAtPath(destTexture) as TextureImporter;
importer.spritePackingTag = spritePackingTag;
importer.SaveAndReimport();
if (hasReferencingSpriteAtlas)
{
var sa = new SpriteAtlas();
var targetObjects = new UnityEngine.Object[] { AssetDatabase.LoadAssetAtPath <Texture>(destTexture) };
sa.Add(targetObjects);
string saPath = Path.Combine(kTestAssetFolder, "sa.spriteAtlas");
AssetDatabase.CreateAsset(sa, saPath);
AssetDatabase.Refresh();
}
GUID.TryParse(AssetDatabase.AssetPathToGUID(destTexture), out GUID spriteGUID);
CalculateAssetDependencyData.TaskInput input = CreateDefaultInput();
EditorSettings.spritePackerMode = spriteMode;
SpriteAtlasUtility.PackAllAtlases(input.Target);
input.Assets = new List <GUID>()
{
spriteGUID
};
CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output);
Assert.AreEqual(expectedPacked, output.AssetResults[0].spriteData.PackedSprite);
}
public void WhenAssetDoesNotExist_AssetResultIsEmpty()
{
CalculateAssetDependencyData.TaskInput input = CreateDefaultInput();
input.Assets = new List <GUID>()
{
GUID.Generate()
};
CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output);
Assert.IsNull(output.AssetResults[0].extendedData);
Assert.AreEqual(0, output.AssetResults[0].assetInfo.includedObjects.Count);
}
public void WhenObjectInfluencesReferencedObjectBuildTags_BuildUsageTagsAreAdded()
{
string testShaderPath = Path.Combine(kTestAssetFolder, "TestShader.shader");
CreateTestShader(testShaderPath);
Shader shader = AssetDatabase.LoadAssetAtPath <Shader>(testShaderPath);
string shaderGUIDString = AssetDatabase.AssetPathToGUID(testShaderPath);
GUID.TryParse(shaderGUIDString, out GUID shaderGUID);
// Create a material that points to the test shader asset
Material mat = new Material(shader);
string matPath = Path.Combine(kTestAssetFolder, "testmat.mat");
AssetDatabase.CreateAsset(mat, matPath);
string guidMatString = AssetDatabase.AssetPathToGUID(matPath);
GUID.TryParse(guidMatString, out GUID matGUID);
CalculateAssetDependencyData.TaskInput input = CreateDefaultInput();
input.Assets = new List <GUID>()
{
matGUID
};
CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output);
// this define should get added to the shader build usage tags
mat.shaderKeywords = new string[] { "TEST_DEFINE" };
CalculateAssetDependencyData.TaskInput input2 = CreateDefaultInput();
input2.Assets = new List <GUID>()
{
matGUID
};
CalculateAssetDependencyData.RunInternal(input2, out CalculateAssetDependencyData.TaskOutput output2);
var ids = output2.AssetResults[0].usageTags.GetObjectIdentifiers();
Assert.IsTrue(ids.Count((x) => x.guid == shaderGUID) == 1, "Shader is not in build usage tags");
Assert.AreNotEqual(output.AssetResults[0].usageTags.GetHashCode(), output2.AssetResults[0].usageTags.GetHashCode(), "Build usage tags were not affected by material keywords");
}
public void WhenAssetHasNoDependencies()
{
// Create an asset
string assetPath = Path.Combine(kTestAssetFolder, "myPrefab.prefab");
GUID guid = CreateGameObject(assetPath);
CalculateAssetDependencyData.TaskInput input = CreateDefaultInput();
input.Assets = new List <GUID>()
{
guid
};
CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output);
Assert.AreEqual(1, output.AssetResults.Length);
Assert.AreEqual(guid, output.AssetResults[0].asset);
Assert.AreEqual(2, output.AssetResults[0].assetInfo.includedObjects.Count); // GameObject and Transform
Assert.AreEqual(0, output.AssetResults[0].assetInfo.referencedObjects.Count);
Assert.IsNull(output.AssetResults[0].spriteData);
Assert.IsNull(output.AssetResults[0].extendedData);
}
public void WhenAssetHasANullRepresentation_LogsWarning()
{
// Create an asset
string assetPath = Path.Combine(kTestAssetFolder, "myPrefab.prefab");
GUID guid = CreateGameObject(assetPath);
CalculateAssetDependencyData.TaskInput input = CreateDefaultInput();
input.Assets = new List <GUID>()
{
guid
};
input.EngineHooks = new NullLoadRepresentationFake();
LogAssert.Expect(LogType.Warning, new Regex(".+It will not be included in the build"));
CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output);
Assert.AreEqual(guid, output.AssetResults[0].asset);
Assert.AreEqual(2, output.AssetResults[0].assetInfo.includedObjects.Count); // GameObject and Transform
Assert.AreEqual(0, output.AssetResults[0].assetInfo.referencedObjects.Count);
}
public void WhenAssetHasMultipleRepresentations_ExtendedDataContainsAllButMainAsset()
{
const int kExtraRepresentations = 2;
string assetPath = Path.Combine(kTestAssetFolder, "myPrefab.asset");
Material mat = new Material(Shader.Find("Transparent/Diffuse"));
AssetDatabase.CreateAsset(mat, assetPath);
for (int i = 0; i < kExtraRepresentations; i++)
{
AssetDatabase.AddObjectToAsset(new Material(Shader.Find("Transparent/Diffuse")), assetPath);
}
AssetDatabase.SaveAssets();
GUID guid = new GUID(AssetDatabase.AssetPathToGUID(assetPath));
CalculateAssetDependencyData.TaskInput input = CreateDefaultInput();
input.Assets = new List <GUID>()
{
guid
};
CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output);
ObjectIdentifier[] allObjIDs = ContentBuildInterface.GetPlayerObjectIdentifiersInAsset(guid, EditorUserBuildSettings.activeBuildTarget);
HashSet <ObjectIdentifier> expectedReps = new HashSet <ObjectIdentifier>();
for (int i = 1; i < allObjIDs.Length; i++)
{
expectedReps.Add(allObjIDs[i]);
}
Assert.AreEqual(kExtraRepresentations, output.AssetResults[0].extendedData.Representations.Count);
Assert.AreEqual(kExtraRepresentations, expectedReps.Count);
foreach (var id in output.AssetResults[0].extendedData.Representations)
{
Assert.IsTrue(expectedReps.Contains(id));
}
}
public void WhenSomeAssetDataIsCached_CachedVersionIsUsed()
{
const int kCachedCount = 5;
// Create 10 assets, import half of them,
CalculateAssetDependencyData.TaskInput input = CreateDefaultInput();
string assetPath = Path.Combine(kTestAssetFolder, "myPrefab.prefab");
List <GUID> allGUIDs = new List <GUID>();
List <GUID> cachedGUIDs = new List <GUID>();
for (int i = 0; i < kCachedCount; i++)
{
GUID cachedGUID = CreateGameObject(Path.Combine(kTestAssetFolder, $"myPrefab{i * 2}.prefab"), $"go{i * 2}");
cachedGUIDs.Add(cachedGUID);
allGUIDs.Add(cachedGUID);
allGUIDs.Add(CreateGameObject(Path.Combine(kTestAssetFolder, $"myPrefab{i * 2 + 1}.prefab"), $"go{i * 2 + 1}"));
}
using (BuildCache cache = new BuildCache())
{
input.BuildCache = cache;
input.Assets = cachedGUIDs;
CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output);
cache.SyncPendingSaves();
input.Assets = allGUIDs;
CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output2);
Assert.AreEqual(output.AssetResults[0].assetInfo.includedObjects.Count, output2.AssetResults[0].assetInfo.includedObjects.Count); // GameObject and Transform
Assert.AreEqual(0, output.CachedAssetCount);
Assert.AreEqual(kCachedCount, output2.CachedAssetCount);
for (int i = 0; i < kCachedCount; i++)
{
bool seqEqual = Enumerable.SequenceEqual(output.AssetResults[i].assetInfo.includedObjects, output2.AssetResults[i * 2].assetInfo.includedObjects);
Assert.IsTrue(seqEqual);
}
}
}
CalculateAssetDependencyData.TaskInput CreateDefaultInput()
{
CalculateAssetDependencyData.TaskInput input = new CalculateAssetDependencyData.TaskInput();
input.Target = EditorUserBuildSettings.activeBuildTarget;
return(input);
}
