internal static void WriteHashData(PreloadInfo info, BinaryWriter writer)
{
if (info != null)
{
WriteObjectIdentifiers(info.preloadObjects, writer);
}
}
/// <inheritdoc />
public Hash128 GetHash128(IBuildLogger log)
{
#if UNITY_2019_3_OR_NEWER
CacheEntry entry = BuildCacheUtility.GetCacheEntry(Scene);
#else
CacheEntry entry = BuildCacheUtility.GetCacheEntry(ProcessedScene);
#endif
HashSet <CacheEntry> hashObjects = new HashSet <CacheEntry>();
using (log.ScopedStep(LogLevel.Verbose, $"Gather Objects", Command.fileName))
Command.GatherSerializedObjectCacheEntries(hashObjects);
List <Hash128> hashes = new List <Hash128>();
using (log.ScopedStep(LogLevel.Verbose, $"Hashing Command", Command.fileName))
hashes.Add(Command.GetHash128());
using (log.ScopedStep(LogLevel.Verbose, $"Hashing UsageSet", Command.fileName))
hashes.Add(UsageSet.GetHash128());
using (log.ScopedStep(LogLevel.Verbose, $"Hashing ReferenceMap", Command.fileName))
hashes.Add(ReferenceMap.GetHash128());
using (log.ScopedStep(LogLevel.Verbose, $"Hashing PreloadInfo", Command.fileName))
hashes.Add(PreloadInfo.GetHash128());
using (log.ScopedStep(LogLevel.Verbose, $"Hashing Info", Command.fileName))
hashes.Add(Info.GetHash128());
using (log.ScopedStep(LogLevel.Verbose, $"Hashing Objects", Command.fileName))
hashes.Add(HashingMethods.Calculate(hashObjects).ToHash128());
hashes.Add(new Hash128(0, 0, 0, (uint)QualitySettingsApi.GetNumberOfLODsStripped()));
hashes.Add(DependencyHash);
return(HashingMethods.Calculate(hashes, Scene, entry).ToHash128());
}
public static Hash128 GetHash128(this PreloadInfo info)
{
StreamHasher hasher = new StreamHasher();
HashingHelpers.WriteHashData(info, hasher.Writer);
return(hasher.GetHash());
}
public static void PreloadInfo_WhenValueChanges_HashesChange()
{
ObjectIdentifier obj1 = new ObjectIdentifier();
obj1.SetFilePath("TestPath");
PreloadInfo[] infos = new PreloadInfo[]
{
new PreloadInfo()
{
preloadObjects = new List <ObjectIdentifier>()
},
new PreloadInfo()
{
preloadObjects = new List <ObjectIdentifier>()
{
new ObjectIdentifier()
}
},
new PreloadInfo()
{
preloadObjects = new List <ObjectIdentifier>()
{
obj1
}
},
};
HashSet <Hash128> set = new HashSet <Hash128>(infos.Select(x => HashingHelpers.GetHash128(x)));
Assert.AreEqual(infos.Length, set.Count);
}
public SceneDataWriteOperation(SceneDataWriteOperation other) : base(other)
{
// Notes: May want to switch to MemberwiseClone, for now those this is fine
scene = other.scene;
processedScene = other.processedScene;
preloadInfo = other.preloadInfo;
usageTags = other.usageTags;
}
/// <inheritdoc />
public Hash128 GetHash128()
{
var prefabHashes = AssetDatabase.GetDependencies(Scene).Where(path => path.EndsWith(".prefab")).Select(AssetDatabase.GetAssetDependencyHash);
#if UNITY_2019_3_OR_NEWER
CacheEntry entry = BuildCacheUtility.GetCacheEntry(Scene);
#else
CacheEntry entry = BuildCacheUtility.GetCacheEntry(ProcessedScene);
#endif
HashSet <CacheEntry> hashObjects = new HashSet <CacheEntry>();
if (Command.serializeObjects != null)
{
foreach (var serializeObject in Command.serializeObjects)
{
hashObjects.Add(BuildCacheUtility.GetCacheEntry(serializeObject.serializationObject));
}
}
return(HashingMethods.Calculate(Command.GetHash128(), UsageSet.GetHash128(), ReferenceMap.GetHash128(), Scene, PreloadInfo.GetHash128(), entry, Info, prefabHashes, hashObjects).ToHash128());
}
public static NPath BuildSlimGameManagers(BuildTarget target, string[] scenes, bool development, string typeDBDirectory)
{
NPath tempPath;
WriteManagerParameters mParams;
WriteParameters wParams;
WriteCommand[] writeCommands;
PreloadInfo preloadInfo;
// Setup
{
tempPath = TempDataPath;
tempPath.CreateDirectory();
tempPath.Combine("Resources").MakeAbsolute().CreateDirectory();
//work around bug in unity's TypeDBHelper where it assumes Library/Type will exist
new NPath("Library/Type").EnsureDirectoryExists();
mParams = new WriteManagerParameters
{
settings = new UnityEditor.Build.Content.BuildSettings
{
target = target,
group = UnityEditor.BuildPipeline.GetBuildTargetGroup(target),
buildFlags = development ? ContentBuildFlags.DevelopmentBuild : ContentBuildFlags.None,
typeDB = TypeDbHelper.GetForPlayer(typeDBDirectory)
},
globalUsage = ContentBuildInterface.GetGlobalUsageFromGraphicsSettings(),
referenceMap = new BuildReferenceMap()
};
wParams = new WriteParameters
{
settings = mParams.settings,
globalUsage = mParams.globalUsage,
referenceMap = mParams.referenceMap,
usageSet = new BuildUsageTagSet()
};
writeCommands = new[]
{
new WriteCommand
{
fileName = "unity_builtin_extra",
internalName = "Resources/unity_builtin_extra",
serializeObjects = new List <SerializationInfo>()
},
new WriteCommand
{
fileName = "globalgamemanagers.assets",
internalName = "globalgamemanagers.assets",
serializeObjects = new List <SerializationInfo>()
}
};
preloadInfo = new PreloadInfo
{
preloadObjects = new List <ObjectIdentifier>()
};
}
// Dependency Calculation
{
var dependencyResults = ContentBuildInterface.CalculatePlayerDependenciesForGameManagers(mParams.settings, mParams.globalUsage, wParams.usageSet);
var referencedObjects = dependencyResults.referencedObjects.ToArray();
var types = ContentBuildInterface.GetTypeForObjects(referencedObjects);
for (int i = 0; i < referencedObjects.Length; i++)
{
if (referencedObjects[i].guid == k_UnityBuiltinResources)
{
// unity default resources contain scripts that need to be preloaded
if (types[i] == typeof(MonoScript))
{
preloadInfo.preloadObjects.Add(referencedObjects[i]);
}
// Prebuild player specific default resources file, don't remap local identifiers
mParams.referenceMap.AddMapping("Library/unity default resources", referencedObjects[i].localIdentifierInFile, referencedObjects[i]);
}
else if (referencedObjects[i].guid == k_UnityBuiltinExtraResources)
{
if (types[i] == typeof(Shader))
{
var command = writeCommands[0];
// Resources/unity_builtin_extra
// Don't remap local identifiers
var info = new SerializationInfo
{
serializationObject = referencedObjects[i],
serializationIndex = referencedObjects[i].localIdentifierInFile
};
command.serializeObjects.Add(info);
mParams.referenceMap.AddMapping(command.internalName, info.serializationIndex, info.serializationObject);
}
else
{
var command = writeCommands[1];
// globalgamemanagers.assets
// Squash / Remap local identifiers, starting at 2 (PreloadData 1)
var info = new SerializationInfo
{
serializationObject = referencedObjects[i],
serializationIndex = command.serializeObjects.Count + 2
};
command.serializeObjects.Add(info);
mParams.referenceMap.AddMapping(command.internalName, info.serializationIndex, info.serializationObject);
}
}
else if (types[i] == typeof(MonoScript))
{
//globalgamemanagers.assets
//error because we can't support all the ggm features in slim builds
}
else
{
//globalgamemanagers.assets
//error because we can't support all the ggm features in slim builds
}
}
}
// Writing globalgamemanagers
{
var writeResults = ContentBuildInterface.WriteGameManagersSerializedFile(tempPath.ToString(), mParams);
EditorUtility.ClearProgressBar();
//if (writeResults.serializedObjects.Count == 0) return "FAIL";
}
// Writing globalgamemanagers.assets
{
wParams.writeCommand = writeCommands[1];
wParams.preloadInfo = preloadInfo;
var writeResults = ContentBuildInterface.WriteSerializedFile(tempPath.ToString(), wParams);
EditorUtility.ClearProgressBar();
//if (writeResults.serializedObjects.Count == 0) return "FAIL";
}
// Writing unity_builtin_extra"
{
wParams.writeCommand = writeCommands[0];
wParams.preloadInfo = null;
// unity_builtin_extras requires absolutepath writing, so fixup the internalName and referenceMap for this
wParams.writeCommand.internalName = tempPath.Combine(wParams.writeCommand.internalName).MakeAbsolute().ToString();
wParams.referenceMap.AddMappings(wParams.writeCommand.internalName, wParams.writeCommand.serializeObjects.ToArray(), true);
var writeResults = ContentBuildInterface.WriteSerializedFile(tempPath.Combine("Resources").ToString(), wParams);
EditorUtility.ClearProgressBar();
//if (writeResults.serializedObjects.Count == 0) return "FAIL";
}
{
var parameters = new BundleBuildParameters(mParams.settings.target, mParams.settings.group, TempStreamingAssetsPath.ToString());
parameters.BundleCompression = UnityEngine.BuildCompression.Uncompressed;
parameters.ScriptInfo = mParams.settings.typeDB;
// Writing scenes.bundle
{
WriteSceneBundles(parameters, scenes);
//if (???) return "FAIL";
}
// Writing resources.bundle
{
WriteResourcesBundles(parameters);
//if (???) return "FAIL";
}
{
WriteRenderPipelineBundles(parameters);
//if (???) return "FAIL";
}
}
return(tempPath);
}
