public override bool Equals(object obj)
{
BuildUsageTagSet other = obj as BuildUsageTagSet;
if (other == null)
{
return(false);
}
return(other.GetHash128() == GetHash128());
}
public extern void UnionWith(BuildUsageTagSet other);
static extern WriteResult WriteSceneSerializedFileRaw(string outputFolder, string scenePath, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap);
static extern WriteResult WriteSerializedFileAssetBundle(string outputFolder, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap, AssetBundleInfo bundleInfo);
public static WriteResult WriteSceneSerializedFile(string outputFolder, string scenePath, string processedScene, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap)
{
if (string.IsNullOrEmpty(outputFolder))
{
throw new ArgumentException("String is null or empty.", "outputFolder");
}
if (string.IsNullOrEmpty(scenePath))
{
throw new ArgumentException("String is null or empty.", "scenePath");
}
if (string.IsNullOrEmpty(processedScene))
{
throw new ArgumentException("String is null or empty.", "processedScene");
}
if (!File.Exists(processedScene))
{
throw new ArgumentException(string.Format("File '{0}' does not exist.", processedScene), "processedScene");
}
if (writeCommand == null)
{
throw new ArgumentNullException("writeCommand");
}
if (referenceMap == null)
{
throw new ArgumentNullException("referenceMap");
}
return(WriteSceneSerializedFileRaw(outputFolder, scenePath, processedScene, writeCommand, settings, globalUsage, usageSet, referenceMap));
}
public static GameManagerDependencyInfo CalculatePlayerDependenciesForGameManagers(BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildUsageCache usageCache, DependencyType mode)
{
if (IsBuildInProgress())
{
throw new InvalidOperationException("Cannot call CalculatePlayerDependenciesForGameManagers while a build is in progress");
}
return(CalculatePlayerDependenciesForGameManagersInternal(settings, globalUsage, usageSet, usageCache, mode));
}
public static SceneDependencyInfo CalculatePlayerDependenciesForScene(string scenePath, BuildSettings settings, BuildUsageTagSet usageSet, BuildUsageCache usageCache, DependencyType mode)
{
if (IsBuildInProgress())
{
throw new InvalidOperationException("Cannot call CalculatePlayerDependenciesForScene while a build is in progress");
}
return(CalculatePlayerDependenciesForSceneInternal(scenePath, settings, usageSet, usageCache, mode));
}
public static extern void CalculateBuildUsageTags(ObjectIdentifier[] objectIDs, ObjectIdentifier[] dependentObjectIDs, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildUsageCache usageCache);
public static WriteResult WriteSceneSerializedFile(string outputFolder, string scenePath, string processedScene, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap, PreloadInfo preloadInfo, SceneBundleInfo sceneBundleInfo)
{
if (IsBuildInProgress())
{
throw new InvalidOperationException("Cannot call WriteSceneSerializedFile while a build is in progress");
}
if (string.IsNullOrEmpty(outputFolder))
{
throw new ArgumentException("String is null or empty.", "outputFolder");
}
if (string.IsNullOrEmpty(scenePath))
{
throw new ArgumentException("String is null or empty.", "scenePath");
}
if (string.IsNullOrEmpty(processedScene))
{
throw new ArgumentException("String is null or empty.", "processedScene");
}
if (!File.Exists(processedScene))
{
throw new ArgumentException(string.Format("File '{0}' does not exist.", processedScene), "processedScene");
}
if (writeCommand == null)
{
throw new ArgumentNullException("writeCommand");
}
if (referenceMap == null)
{
throw new ArgumentNullException("referenceMap");
}
if (preloadInfo == null)
{
throw new ArgumentNullException("preloadInfo");
}
if (sceneBundleInfo == null)
{
throw new ArgumentNullException("sceneBundleInfo");
}
return(WriteSceneSerializedFileAssetBundle(outputFolder, scenePath, processedScene, writeCommand, settings, globalUsage, usageSet, referenceMap, preloadInfo, sceneBundleInfo));
}
public static WriteResult WriteSceneSerializedFile(string outputFolder, string scenePath, string processedScene, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap)
{
return(WriteSceneSerializedFile(outputFolder, new WriteSceneParameters
{
scenePath = scenePath,
writeCommand = writeCommand,
settings = settings,
globalUsage = globalUsage,
usageSet = usageSet,
referenceMap = referenceMap
}));
}
public static WriteResult WriteSerializedFile(string outputFolder, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap, AssetBundleInfo bundleInfo)
{
return(WriteSerializedFile(outputFolder, new WriteParameters
{
writeCommand = writeCommand,
settings = settings,
globalUsage = globalUsage,
usageSet = usageSet,
referenceMap = referenceMap,
bundleInfo = bundleInfo
}));
}
public static SceneDependencyInfo PrepareScene(string scenePath, BuildSettings settings, BuildUsageTagSet usageSet, BuildUsageCache usageCache, string outputFolder)
{
return(CalculatePlayerDependenciesForScene(scenePath, settings, usageSet, usageCache));
}
static extern WriteResult WriteSceneSerializedFilePlayerData(string outputFolder, string scenePath, string processedScene, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap, PreloadInfo preloadInfo);
public static WriteResult WriteSerializedFile(string outputFolder, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap)
{
if (string.IsNullOrEmpty(outputFolder))
{
throw new ArgumentException("String is null or empty.", "outputFolder");
}
if (writeCommand == null)
{
throw new ArgumentNullException("writeCommand");
}
if (referenceMap == null)
{
throw new ArgumentNullException("referenceMap");
}
return(WriteSerializedFileRaw(outputFolder, writeCommand, settings, globalUsage, usageSet, referenceMap));
}
extern public static SceneDependencyInfo PrepareScene(string scenePath, BuildSettings settings, BuildUsageTagSet usageSet, string outputFolder);
extern private static WriteResult WriteSceneSerializedFileAssetBundle(string outputFolder, string scenePath, string processedScene, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap, PreloadInfo preloadInfo, SceneBundleInfo sceneBundleInfo);
public static void CalculateBuildUsageTags(ObjectIdentifier[] objectIDs, ObjectIdentifier[] dependentObjectIDs, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet)
{
CalculateBuildUsageTags(objectIDs, dependentObjectIDs, globalUsage, usageSet, null);
}
public static SceneDependencyInfo PrepareScene(string scenePath, BuildSettings settings, BuildUsageTagSet usageSet, BuildUsageCache usageCache, string outputFolder)
{
if (IsBuildInProgress())
{
throw new InvalidOperationException("Cannot call PrepareScene while a build is in progress");
}
return(PrepareSceneInternal(scenePath, settings, usageSet, usageCache, outputFolder));
}
static extern WriteResult WriteSceneSerializedFile_Internal(string outputFolder, string scenePath, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap, PreloadInfo preloadInfo, SceneBundleInfo sceneBundleInfo);
extern private static SceneDependencyInfo PrepareSceneInternal(string scenePath, BuildSettings settings, BuildUsageTagSet usageSet, BuildUsageCache usageCache, string outputFolder);
static extern SceneDependencyInfo CalculatePlayerDependenciesForSceneInternal(string scenePath, BuildSettings settings, BuildUsageTagSet usageSet, BuildUsageCache usageCache, DependencyType mode);
public static WriteResult WriteSerializedFile(string outputFolder, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap, AssetBundleInfo bundleInfo)
{
if (IsBuildInProgress())
{
throw new InvalidOperationException("Cannot call WriteSerializedFile while a build is in progress");
}
if (string.IsNullOrEmpty(outputFolder))
{
throw new ArgumentException("String is null or empty.", "outputFolder");
}
if (writeCommand == null)
{
throw new ArgumentNullException("writeCommand");
}
if (referenceMap == null)
{
throw new ArgumentNullException("referenceMap");
}
if (bundleInfo == null)
{
throw new ArgumentNullException("bundleInfo");
}
return(WriteSerializedFileAssetBundle(outputFolder, writeCommand, settings, globalUsage, usageSet, referenceMap, bundleInfo));
}
static extern GameManagerDependencyInfo CalculatePlayerDependenciesForGameManagersInternal(BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildUsageCache usageCache, DependencyType mode);
public static WriteResult WriteSceneSerializedFile(string outputFolder, string scenePath, string processedScene, WriteCommand writeCommand, BuildSettings settings, BuildUsageTagGlobal globalUsage, BuildUsageTagSet usageSet, BuildReferenceMap referenceMap)
{
if (IsBuildInProgress())
{
throw new InvalidOperationException("Cannot call WriteSceneSerializedFile while a build is in progress");
}
if (string.IsNullOrEmpty(outputFolder))
{
throw new ArgumentException("String is null or empty.", "outputFolder");
}
if (string.IsNullOrEmpty(scenePath))
{
throw new ArgumentException("String is null or empty.", "scenePath");
}
if (writeCommand == null)
{
throw new ArgumentNullException("writeCommand");
}
if (referenceMap == null)
{
throw new ArgumentNullException("referenceMap");
}
return(WriteSceneSerializedFileRaw(outputFolder, scenePath, processedScene, writeCommand, settings, globalUsage, usageSet, referenceMap));
}
