void SetOutputInformation(GUID asset, SceneDependencyInfo sceneInfo, BuildUsageTagSet usageTags, Hash128 prefabDependency)
{
// Add generated scene information to BuildDependencyData
m_DependencyData.SceneInfo.Add(asset, sceneInfo);
m_DependencyData.SceneUsage.Add(asset, usageTags);
m_DependencyData.DependencyHash.Add(asset, prefabDependency);
}
void PackSceneBundle(string bundleName, List <GUID> includedScenes, Dictionary <GUID, List <GUID> > assetToReferences)
{
if (includedScenes.IsNullOrEmpty())
{
return;
}
string firstFileName = "";
HashSet <ObjectIdentifier> previousSceneObjects = new HashSet <ObjectIdentifier>();
HashSet <GUID> previousSceneAssets = new HashSet <GUID>();
List <string> sceneInternalNames = new List <string>();
Dictionary <GUID, HashSet <ObjectIdentifier> > assetObjectIdentifierHashSets = new Dictionary <GUID, HashSet <ObjectIdentifier> >();
foreach (var scene in includedScenes)
{
var scenePath = AssetDatabase.GUIDToAssetPath(scene.ToString());
var internalSceneName = m_PackingMethod.GenerateInternalFileName(scenePath);
if (string.IsNullOrEmpty(firstFileName))
{
firstFileName = internalSceneName;
}
var internalName = string.Format(CommonStrings.SceneBundleNameFormat, firstFileName, internalSceneName);
SceneDependencyInfo sceneInfo = m_DependencyData.SceneInfo[scene];
var references = new List <ObjectIdentifier>();
references.AddRange(sceneInfo.referencedObjects);
assetToReferences[scene] = FilterReferencesForAsset(m_DependencyData, scene, references, previousSceneObjects, previousSceneAssets, assetObjectIdentifierHashSets);
previousSceneObjects.UnionWith(references);
previousSceneAssets.UnionWith(assetToReferences[scene]);
m_WriteData.FileToObjects.Add(internalName, references);
m_WriteData.FileToBundle.Add(internalName, bundleName);
var files = new List <string> {
internalName
};
files.AddRange(sceneInternalNames);
m_WriteData.AssetToFiles[scene] = files;
sceneInternalNames.Add(internalName);
}
}
// Create a populated 'SceneDependencyInfo' instance. Can set fields directly for 2019.4+ as internals are available but have to use reflection for 2018.4
static SceneDependencyInfo CreateSceneDependencyInfo(string scene, ObjectIdentifier[] objectIdentifiers, BuildUsageTagGlobal globalUsage, Type[] includedTypes)
{
SceneDependencyInfo sceneDependencyInfo = new SceneDependencyInfo();
#if UNITY_2019_4_OR_NEWER
sceneDependencyInfo.m_Scene = scene;
sceneDependencyInfo.m_ReferencedObjects = objectIdentifiers;
sceneDependencyInfo.m_GlobalUsage = globalUsage;
#if UNITY_2020_1_OR_NEWER
sceneDependencyInfo.m_IncludedTypes = includedTypes;
#endif
#else
sceneDependencyInfo.SetScene(scene);
sceneDependencyInfo.SetReferencedObjects(objectIdentifiers);
SetFieldValue(sceneDependencyInfo, "m_GlobalUsage", globalUsage);
#endif
return(sceneDependencyInfo);
}
/// <inheritdoc />
public ReturnCode Run()
{
IList <CachedInfo> cachedInfo = null;
IList <CachedInfo> uncachedInfo = null;
if (m_Parameters.UseCache && m_Cache != null)
{
IList <CacheEntry> entries = m_Content.Scenes.Select(x => m_Cache.GetCacheEntry(x, Version)).ToList();
m_Cache.LoadCachedData(entries, out cachedInfo);
uncachedInfo = new List <CachedInfo>();
}
for (int i = 0; i < m_Content.Scenes.Count; i++)
{
GUID scene = m_Content.Scenes[i];
string scenePath = AssetDatabase.GUIDToAssetPath(scene.ToString());
SceneDependencyInfo sceneInfo;
BuildUsageTagSet usageTags;
if (cachedInfo != null && cachedInfo[i] != null)
{
if (!m_Tracker.UpdateInfoUnchecked(string.Format("{0} (Cached)", scenePath)))
{
return(ReturnCode.Canceled);
}
sceneInfo = (SceneDependencyInfo)cachedInfo[i].Data[0];
usageTags = cachedInfo[i].Data[1] as BuildUsageTagSet;
}
else
{
if (!m_Tracker.UpdateInfoUnchecked(scenePath))
{
return(ReturnCode.Canceled);
}
var references = new HashSet <ObjectIdentifier>();
string[] dependencies = AssetDatabase.GetDependencies(scenePath);
foreach (var assetPath in dependencies)
{
var assetGuid = new GUID(AssetDatabase.AssetPathToGUID(assetPath));
if (ValidationMethods.ValidAsset(assetGuid) != ValidationMethods.Status.Asset)
{
continue;
}
// TODO: Use Cache to speed this up?
var assetIncludes = ContentBuildInterface.GetPlayerObjectIdentifiersInAsset(assetGuid, m_Parameters.Target);
var assetReferences = ContentBuildInterface.GetPlayerDependenciesForObjects(assetIncludes, m_Parameters.Target, m_Parameters.ScriptInfo);
references.UnionWith(assetIncludes);
references.UnionWith(assetReferences);
}
sceneInfo = new SceneDependencyInfo();
usageTags = new BuildUsageTagSet();
sceneInfo.SetScene(scenePath);
sceneInfo.SetProcessedScene(scenePath);
sceneInfo.SetReferencedObjects(references.ToArray());
if (uncachedInfo != null)
{
uncachedInfo.Add(GetCachedInfo(scene, sceneInfo.referencedObjects, sceneInfo, usageTags));
}
}
SetOutputInformation(scene, sceneInfo, usageTags);
}
if (m_Parameters.UseCache && m_Cache != null)
{
m_Cache.SaveCachedData(uncachedInfo);
}
return(ReturnCode.Success);
}
#pragma warning restore 649
CachedInfo GetCachedInfo(GUID scene, IEnumerable <ObjectIdentifier> references, SceneDependencyInfo sceneInfo, BuildUsageTagSet usageTags)
{
var info = new CachedInfo();
info.Asset = m_Cache.GetCacheEntry(scene, Version);
var dependencies = new HashSet <CacheEntry>();
foreach (ObjectIdentifier reference in references)
{
dependencies.Add(m_Cache.GetCacheEntry(reference));
}
info.Dependencies = dependencies.ToArray();
info.Data = new object[] { sceneInfo, usageTags };
return(info);
}
#pragma warning restore 649
CachedInfo GetCachedInfo(GUID scene, IEnumerable<ObjectIdentifier> references, SceneDependencyInfo sceneInfo, BuildUsageTagSet usageTags, IEnumerable<CacheEntry> prefabEntries, Hash128 prefabDependency)
{
var info = new CachedInfo();
info.Asset = m_Cache.GetCacheEntry(scene, Version);
var dependencies = new HashSet<CacheEntry>();
foreach (var reference in references)
dependencies.Add(m_Cache.GetCacheEntry(reference));
dependencies.UnionWith(prefabEntries);
info.Dependencies = dependencies.ToArray();
info.Data = new object[] { sceneInfo, usageTags, prefabDependency };
return info;
}
#pragma warning restore 649
CachedInfo GetCachedInfo(GUID scene, IEnumerable <ObjectIdentifier> references, SceneDependencyInfo sceneInfo, BuildUsageTagSet usageTags, IEnumerable <CacheEntry> prefabEntries, Hash128 prefabDependency)
{
var info = new CachedInfo();
info.Asset = m_Cache.GetCacheEntry(scene, Version);
#if ENABLE_TYPE_HASHING || UNITY_2020_1_OR_NEWER
var uniqueTypes = new HashSet <System.Type>(sceneInfo.includedTypes);
#else
var uniqueTypes = new HashSet <System.Type>();
#endif
var objectTypes = new List <KeyValuePair <ObjectIdentifier, System.Type[]> >();
var dependencies = new HashSet <CacheEntry>(prefabEntries);
ExtensionMethods.ExtractCommonCacheData(m_Cache, null, references, uniqueTypes, objectTypes, dependencies);
info.Dependencies = dependencies.ToArray();
info.Data = new object[] { sceneInfo, usageTags, prefabDependency, objectTypes };
return(info);
}
#pragma warning restore 649
CachedInfo GetCachedInfo(GUID scene, IEnumerable <ObjectIdentifier> references, SceneDependencyInfo sceneInfo, BuildUsageTagSet usageTags)
{
var info = new CachedInfo();
info.Asset = m_Cache.GetCacheEntry(scene, Version);
var dependencies = new HashSet <CacheEntry>();
foreach (var reference in references)
{
dependencies.Add(m_Cache.GetCacheEntry(reference));
}
var prefabEntries = AssetDatabase.GetDependencies(AssetDatabase.GUIDToAssetPath(scene.ToString())).Where(path => path.EndsWith(".prefab")).Select(m_Cache.GetCacheEntry);
dependencies.UnionWith(prefabEntries);
info.Dependencies = dependencies.ToArray();
info.Data = new object[] { sceneInfo, usageTags };
return(info);
}
internal virtual void BuiltInResourcesToDependenciesMap(string[] resourcePaths)
{
for (int sceneIndex = 0; sceneIndex < resourcePaths.Length; ++sceneIndex)
{
string path = resourcePaths[sceneIndex];
if (EditorUtility.DisplayCancelableProgressBar("Generating built-in resource dependency map",
"Checking " + path + " for duplicates with Addressables content.",
(float)sceneIndex / resourcePaths.Length))
{
m_ResourcesToDependencies.Clear();
EditorUtility.ClearProgressBar();
return;
}
string[] dependencies;
if (path.EndsWith(".unity"))
{
#if UNITY_2019_3_OR_NEWER
using (var w = new BuildInterfacesWrapper())
{
var usageTags = new BuildUsageTagSet();
BuildSettings settings = new BuildSettings
{
group = EditorUserBuildSettings.selectedBuildTargetGroup,
target = EditorUserBuildSettings.activeBuildTarget,
typeDB = null,
buildFlags = ContentBuildFlags.None
};
SceneDependencyInfo sceneInfo =
ContentBuildInterface.CalculatePlayerDependenciesForScene(path, settings, usageTags);
dependencies = new string[sceneInfo.referencedObjects.Count];
for (int i = 0; i < sceneInfo.referencedObjects.Count; ++i)
{
if (string.IsNullOrEmpty(sceneInfo.referencedObjects[i].filePath))
{
dependencies[i] = AssetDatabase.GUIDToAssetPath(sceneInfo.referencedObjects[i].guid.ToString());
}
else
{
dependencies[i] = sceneInfo.referencedObjects[i].filePath;
}
}
}
#else
HashSet <string> assetPaths = new HashSet <string>();
assetPaths.Add(path);
var s = EditorSceneManager.OpenScene(path, OpenSceneMode.Additive);
List <UnityEngine.Object> roots = new List <UnityEngine.Object>(s.GetRootGameObjects());
var sceneHierarchyStack = new Stack <GameObject>();
for (int i = roots.Count - 1; i >= 0; --i)
{
GameObject go = (GameObject)roots[i];
if (go.CompareTag("EditorOnly"))
{
UnityEngine.Object.DestroyImmediate(roots[i]);
roots.RemoveAt(i);
}
else
{
sceneHierarchyStack.Push(go);
}
}
while (sceneHierarchyStack.Count > 0)
{
var item = sceneHierarchyStack.Pop();
for (int i = 0; i < item.transform.childCount; ++i)
{
GameObject go = item.transform.GetChild(i).gameObject;
if (go.CompareTag("EditorOnly"))
{
UnityEngine.Object.DestroyImmediate(go);
}
else
{
sceneHierarchyStack.Push(go);
}
}
}
UnityEngine.Object[] deps = EditorUtility.CollectDependencies(roots.ToArray());
foreach (UnityEngine.Object o in deps)
{
string p = AssetDatabase.GetAssetPath(o.GetInstanceID());
if (!string.IsNullOrEmpty(p))
{
assetPaths.Add(p);
}
}
EditorSceneManager.CloseScene(s, true);
dependencies = assetPaths.ToArray();
#endif
}
else
{
dependencies = AssetDatabase.GetDependencies(path);
}
if (!m_ResourcesToDependencies.ContainsKey(path))
{
m_ResourcesToDependencies.Add(path, new List <GUID>(dependencies.Length));
}
else
{
m_ResourcesToDependencies[path].Capacity += dependencies.Length;
}
foreach (string dependency in dependencies)
{
if (dependency.EndsWith(".cs") || dependency.EndsWith(".dll"))
{
continue;
}
m_ResourcesToDependencies[path].Add(new GUID(AssetDatabase.AssetPathToGUID(dependency)));
}
}
EditorUtility.ClearProgressBar();
}
/// <summary>
/// Build map of resources to corresponding dependencies
/// </summary>
/// <param name="resourcePaths"> Array of resource paths</param>
protected internal virtual void BuiltInResourcesToDependenciesMap(string[] resourcePaths)
{
for (int sceneIndex = 0; sceneIndex < resourcePaths.Length; ++sceneIndex)
{
string path = resourcePaths[sceneIndex];
if (EditorUtility.DisplayCancelableProgressBar("Generating built-in resource dependency map",
"Checking " + path + " for duplicates with Addressables content.",
(float)sceneIndex / resourcePaths.Length))
{
m_ResourcesToDependencies.Clear();
EditorUtility.ClearProgressBar();
return;
}
string[] dependencies;
if (path.EndsWith(".unity"))
{
using (var w = new BuildInterfacesWrapper())
{
var usageTags = new BuildUsageTagSet();
BuildSettings settings = new BuildSettings
{
group = EditorUserBuildSettings.selectedBuildTargetGroup,
target = EditorUserBuildSettings.activeBuildTarget,
typeDB = null,
buildFlags = ContentBuildFlags.None
};
SceneDependencyInfo sceneInfo =
ContentBuildInterface.CalculatePlayerDependenciesForScene(path, settings, usageTags);
dependencies = new string[sceneInfo.referencedObjects.Count];
for (int i = 0; i < sceneInfo.referencedObjects.Count; ++i)
{
if (string.IsNullOrEmpty(sceneInfo.referencedObjects[i].filePath))
{
dependencies[i] = AssetDatabase.GUIDToAssetPath(sceneInfo.referencedObjects[i].guid.ToString());
}
else
{
dependencies[i] = sceneInfo.referencedObjects[i].filePath;
}
}
}
}
else
{
dependencies = AssetDatabase.GetDependencies(path);
}
if (!m_ResourcesToDependencies.ContainsKey(path))
{
m_ResourcesToDependencies.Add(path, new List <GUID>(dependencies.Length));
}
else
{
m_ResourcesToDependencies[path].Capacity += dependencies.Length;
}
foreach (string dependency in dependencies)
{
if (dependency.EndsWith(".cs") || dependency.EndsWith(".dll"))
{
continue;
}
m_ResourcesToDependencies[path].Add(new GUID(AssetDatabase.AssetPathToGUID(dependency)));
}
}
EditorUtility.ClearProgressBar();
}
