public static long RemapBuildInAssetPath(ref string assetPath)
{
var guid = new GUID(Path.GetFileNameWithoutExtension(assetPath));
TryRemapBuiltinExtraGuid(ref guid, out var ident);
// Update ADBv2 to allow extra artifacts to be generated for BuiltIn types
if (GUIDHelper.IsBuiltin(guid))
{
var newPath = AssetDatabase.GUIDToAssetPath(guid.ToString());
if (!string.IsNullOrEmpty(newPath))
{
assetPath = newPath;
}
}
return(ident);
}
public static void RemapBuildInAssetGuid(ref string assetGUID)
{
var guid = new GUID(assetGUID);
TryRemapBuiltinExtraGuid(ref guid, out _);
if (GUIDHelper.IsBuiltin(guid))
{
var tempPath = $"{SceneWithBuildConfigurationGUIDs.k_SceneDependencyCachePath}/{assetGUID}.txt";
if (!File.Exists(tempPath))
{
Directory.CreateDirectory(Path.GetDirectoryName(tempPath));
File.WriteAllText(tempPath, "");
AssetDatabase.ImportAsset(tempPath, ImportAssetOptions.ForceSynchronousImport);
}
assetGUID = AssetDatabase.AssetPathToGUID(tempPath);
}
}
static unsafe NativeList <Hash128> ReferencedUnityObjectsToGUIDs(ReferencedUnityObjects referencedUnityObjects, AssetImportContext ctx)
{
var globalObjectIds = new GlobalObjectId[referencedUnityObjects.Array.Length];
var guids = new NativeList <Hash128>(globalObjectIds.Length, Allocator.Temp);
GlobalObjectId.GetGlobalObjectIdsSlow(referencedUnityObjects.Array, globalObjectIds);
for (int i = 0; i != globalObjectIds.Length; i++)
{
var assetGUID = globalObjectIds[i].assetGUID;
// Skip most built-ins, except for BuiltInExtra which we need to depend on
if (GUIDHelper.IsBuiltin(assetGUID))
{
if (GUIDHelper.IsBuiltinExtraResources(assetGUID))
{
var objectIdentifiers = ContentBuildInterface.GetPlayerObjectIdentifiersInAsset(assetGUID, ctx.selectedBuildTarget);
foreach (var objectIdentifier in objectIdentifiers)
{
var packedGUID = assetGUID;
GUIDHelper.PackBuiltinExtraWithFileIdent(ref packedGUID, objectIdentifier.localIdentifierInFile);
guids.Add(packedGUID);
}
}
else if (GUIDHelper.IsBuiltinResources(assetGUID))
{
guids.Add(assetGUID);
}
}
else if (!assetGUID.Empty())
{
guids.Add(assetGUID);
}
}
return(guids);
}
public static bool BuildSceneBundle(GUID sceneGuid, string cacheFilePath, BuildTarget target, bool collectDependencies = false, HashSet <Entities.Hash128> dependencies = null, HashSet <System.Type> types = null)
{
using (new BuildInterfacesWrapper())
using (new SceneStateCleanup())
{
Directory.CreateDirectory(k_TempBuildPath);
var scene = sceneGuid.ToString();
var scenePath = AssetDatabase.GUIDToAssetPath(scene);
// Deterministic ID Generator
var generator = new Unity5PackedIdentifiers();
// Target platform settings & script information
var settings = new BuildSettings
{
buildFlags = ContentBuildFlags.None,
target = target,
group = BuildPipeline.GetBuildTargetGroup(target),
typeDB = null
};
// Inter-asset feature usage (shader features, used mesh channels)
var usageSet = new BuildUsageTagSet();
var dependencyResults = ContentBuildInterface.CalculatePlayerDependenciesForScene(scenePath, settings, usageSet);
// Bundle all the needed write parameters
var writeParams = new WriteSceneParameters
{
// Target platform settings & script information
settings = settings,
// Scene / Project lighting information
globalUsage = dependencyResults.globalUsage,
// Inter-asset feature usage (shader features, used mesh channels)
usageSet = usageSet,
// Scene being written out
scenePath = scenePath,
// Serialized File Layout
writeCommand = new WriteCommand
{
fileName = generator.GenerateSceneInternalFileName(scenePath),
internalName = generator.GenerateSceneBundleInternalFileName(scenePath),
serializeObjects = new List <SerializationInfo>() // Populated Below
},
// External object references
referenceMap = new BuildReferenceMap(), // Populated Below
// External object preload
preloadInfo = new PreloadInfo(), // Populated Below
sceneBundleInfo = new SceneBundleInfo
{
bundleName = scene,
bundleScenes = new List <SceneLoadInfo>
{
new SceneLoadInfo
{
asset = sceneGuid,
address = scenePath,
internalName = generator.GenerateInternalFileName(scenePath)
}
}
}
};
// The requirement is that a single asset bundle only contains the ObjectManifest and the objects that are directly part of the asset, objects for external assets will be in their own bundles. IE: 1 asset per bundle layout
// So this means we need to take manifestObjects & manifestDependencies and filter storing them into writeCommand.serializeObjects and/or referenceMap based on if they are this asset or other assets
foreach (var obj in dependencyResults.referencedObjects)
{
// MonoScripts need to live beside the MonoBehavior (in this case ScriptableObject) and loaded first. We could move it to it's own bundle, but this is safer and it's a lightweight object
var type = ContentBuildInterface.GetTypeForObject(obj);
if (obj.guid == GUIDHelper.UnityBuiltinResources)
{
// For Builtin Resources, we can reference them directly
// TODO: Once we switch to using GlobalObjectId for SBP, we will need a mapping for certain special cases of GUID <> FilePath for Builtin Resources
writeParams.referenceMap.AddMapping(obj.filePath, obj.localIdentifierInFile, obj);
}
else if (type == typeof(MonoScript))
{
writeParams.writeCommand.serializeObjects.Add(new SerializationInfo {
serializationObject = obj, serializationIndex = generator.SerializationIndexFromObjectIdentifier(obj)
});
writeParams.referenceMap.AddMapping(writeParams.writeCommand.internalName, generator.SerializationIndexFromObjectIdentifier(obj), obj);
}
else if (collectDependencies || obj.guid == sceneGuid)
{
writeParams.writeCommand.serializeObjects.Add(new SerializationInfo {
serializationObject = obj, serializationIndex = generator.SerializationIndexFromObjectIdentifier(obj)
});
writeParams.referenceMap.AddMapping(writeParams.writeCommand.internalName, generator.SerializationIndexFromObjectIdentifier(obj), obj);
}
else if (obj.guid == GUIDHelper.UnityBuiltinExtraResources)
{
var convGUID = obj.guid;
GUIDHelper.PackBuiltinExtraWithFileIdent(ref convGUID, obj.localIdentifierInFile);
writeParams.referenceMap.AddMapping(generator.GenerateAssetBundleInternalFileName(convGUID), generator.SerializationIndexFromObjectIdentifier(obj), obj);
dependencies?.Add(convGUID);
}
else if (!obj.guid.Empty())
{
writeParams.referenceMap.AddMapping(generator.GenerateAssetBundleInternalFileName(obj.guid), generator.SerializationIndexFromObjectIdentifier(obj), obj);
}
// This will be solvable after we move SBP into the asset pipeline as importers.
if (!obj.guid.Empty() && obj.guid != sceneGuid && type != typeof(MonoScript) && !GUIDHelper.IsBuiltin(obj.guid))
{
dependencies?.Add(obj.guid);
}
if (type != null)
{
types?.Add(type);
}
}
// Write the serialized file
var result = ContentBuildInterface.WriteSceneSerializedFile(k_TempBuildPath, writeParams);
// Archive and compress the serialized & resource files for the previous operation
var crc = ContentBuildInterface.ArchiveAndCompress(result.resourceFiles.ToArray(), cacheFilePath, UnityEngine.BuildCompression.Uncompressed);
// Because the shader compiler progress bar hooks are absolute shit
EditorUtility.ClearProgressBar();
//Debug.Log($"Wrote '{writeParams.writeCommand.fileName}' to '{k_TempBuildPath}/{writeParams.writeCommand.internalName}' resulting in {result.serializedObjects.Count} objects in the serialized file.");
//Debug.Log($"Archived '{k_TempBuildPath}/{writeParams.writeCommand.internalName}' to '{cacheFilePath}' resulting in {crc} CRC.");
return(crc != 0);
}
}
