public static void Check(string path)
{
var guid = AssetDatabaseCompatibility.PathToGUID(path);
Assert.IsFalse(guid.Empty());
var configGUID = SceneWithBuildConfigurationGUIDs.EnsureExistsFor(guid, default, true, out var requireRefresh);
public NativeArray <Hash128> GetInitialScenes(int playerId, Allocator allocator)
{
var sceneList = _BuildConfiguration.GetComponent <SceneList>();
var nonEmbeddedStartupScenes = new List <string>();
foreach (var path in sceneList.GetScenePathsToLoad())
{
if (SceneImporterData.CanLiveLinkScene(path))
{
nonEmbeddedStartupScenes.Add(path);
}
}
if (nonEmbeddedStartupScenes.Count > 0)
{
var sceneIds = new NativeArray <Hash128>(nonEmbeddedStartupScenes.Count, allocator);
for (int i = 0; i < nonEmbeddedStartupScenes.Count; i++)
{
sceneIds[i] = AssetDatabaseCompatibility.PathToGUID(nonEmbeddedStartupScenes[i]);
}
return(sceneIds);
}
return(new NativeArray <Hash128>(0, allocator));
}
static void AddEntityBinaryFiles(Hash128 buildConfigurationGuid, string[] scenePathsForBuild, EntitySectionBundlesInBuild sectionBundlesInBuild)
{
var subSceneGuids = scenePathsForBuild.SelectMany(scenePath => EditorEntityScenes.GetSubScenes(AssetDatabaseCompatibility.PathToGUID(scenePath))).Distinct().ToList();
var requiresRefresh = false;
var sceneBuildConfigGuids = new NativeArray <GUID>(subSceneGuids.Count, Allocator.TempJob);
for (int i = 0; i != sceneBuildConfigGuids.Length; i++)
{
sceneBuildConfigGuids[i] = SceneWithBuildConfigurationGUIDs.EnsureExistsFor(subSceneGuids[i], buildConfigurationGuid, false, out var thisRequiresRefresh);
requiresRefresh |= thisRequiresRefresh;
sectionBundlesInBuild.Add(subSceneGuids[i], sceneBuildConfigGuids[i], typeof(SubSceneImporter));
}
if (requiresRefresh)
{
AssetDatabase.Refresh();
}
AssetDatabaseCompatibility.ProduceArtifactsAsync(sceneBuildConfigGuids, typeof(SubSceneImporter));
sceneBuildConfigGuids.Dispose();
}
public void Update(List <LiveLinkChangeSet> changeSets, NativeList <Hash128> loadScenes, NativeList <Hash128> unloadScenes, LiveLinkMode mode)
{
if (_LoadedScenes.Count == 0 && _SceneGUIDToLiveLink.Count == 0 && _RemovedScenes.Length == 0)
{
return;
}
// If build configuration changed, we need to trigger a full conversion
if (_BuildConfigurationGUID != default)
{
var buildConfigurationDependencyHash = AssetDatabaseCompatibility.GetAssetDependencyHash(_BuildConfigurationGUID);
if (_BuildConfigurationArtifactHash != buildConfigurationDependencyHash)
{
_BuildConfigurationArtifactHash = buildConfigurationDependencyHash;
RequestCleanConversion();
}
}
if (_PreviousGlobalDirtyID != GlobalDirtyID)
{
RequestCleanConversion();
_PreviousGlobalDirtyID = GlobalDirtyID;
}
// By default all scenes need to have m_GameObjectSceneCullingMask, otherwise they won't show up in game view
_GUIDToEditScene.Clear();
for (int i = 0; i != EditorSceneManager.sceneCount; i++)
{
var scene = EditorSceneManager.GetSceneAt(i);
var sceneGUID = AssetDatabaseCompatibility.PathToGUID(scene.path);
if (_LoadedScenes.Contains(sceneGUID))
{
if (scene.isLoaded && sceneGUID != default(GUID))
{
_GUIDToEditScene.Add(sceneGUID, scene);
}
}
}
foreach (var scene in _SceneGUIDToLiveLink)
{
if (!_GUIDToEditScene.ContainsKey(scene.Key))
{
unloadScenes.Add(scene.Key);
}
}
// Process scenes that are no longer loaded
foreach (var scene in unloadScenes)
{
var liveLink = _SceneGUIDToLiveLink[scene];
liveLink.Dispose();
_SceneGUIDToLiveLink.Remove(scene);
_SentLoadScenes.Remove(scene);
}
foreach (var scene in _RemovedScenes)
{
if (_SceneGUIDToLiveLink.TryGetValue(scene, out var liveLink))
{
liveLink.Dispose();
_SceneGUIDToLiveLink.Remove(scene);
}
unloadScenes.Add(scene);
_SentLoadScenes.Remove(scene);
}
_RemovedScenes.Clear();
_SentLoadScenes.RemoveWhere(scene => !_LoadedScenes.Contains(scene));
// Process all scenes that the player needs
var conversionMode = LiveConversionSettings.Mode;
foreach (var sceneGuid in _LoadedScenes)
{
var isLoaded = _GUIDToEditScene.TryGetValue(sceneGuid, out var scene);
// We are editing with live link. Ensure it is active & up to date
if (isLoaded)
{
var liveLink = GetLiveLink(sceneGuid);
if (liveLink == null || liveLink.DidRequestUpdate())
{
AddLiveLinkChangeSet(ref liveLink, sceneGuid, changeSets, mode);
}
#if !UNITY_2020_2_OR_NEWER
else if (liveLink.LiveLinkDirtyID != GetSceneDirtyID(scene))
{
AddLiveLinkChangeSet(ref liveLink, sceneGuid, changeSets, mode);
}
#endif
#if UNITY_2020_2_OR_NEWER
if (conversionMode == LiveConversionSettings.ConversionMode.IncrementalConversionWithDebug)
{
if (liveLink != null && liveLink.DidRequestDebugConversion())
{
if (IsHotControlActive())
{
EditorUpdateUtility.EditModeQueuePlayerLoopUpdate();
}
else
{
liveLink.DebugIncrementalConversion();
}
}
}
#endif
}
else
{
if (_SentLoadScenes.Add(sceneGuid))
{
loadScenes.Add(sceneGuid);
}
}
}
}
public override BuildResult Run(BuildContext context)
{
var manifest = context.BuildManifest;
var rootAssembly = context.GetComponentOrDefault <DotsRuntimeRootAssembly>();
var buildScenes = context.GetComponentOrDefault <SceneList>();
var targetName = rootAssembly.MakeBeeTargetName(context.BuildConfigurationName);
var scenePaths = buildScenes.GetScenePathsForBuild();
var buildConfigurationGuid = context.BuildConfigurationAssetGUID;
var dataDirectory = WorldExport.GetOrCreateDataDirectoryFrom(rootAssembly.StagingDirectory.Combine(targetName));
var logsDirectory = WorldExport.GetOrCreateLogDirectoryFrom(targetName);
var sceneGuids = scenePaths.SelectMany(scenePath =>
{
var guids = EditorEntityScenes.GetSubScenes(AssetDatabaseCompatibility.PathToGUID(scenePath)).ToList();
guids.Add(AssetDatabaseCompatibility.PathToGUID(scenePath));
return(guids);
}).Distinct().ToList();
//Save all unsaved scenes of the project first
foreach (var guid in sceneGuids)
{
string scenePath = AssetDatabase.GUIDToAssetPath(guid.ToString());
var scene = SceneManager.GetSceneByPath(scenePath);
EditorSceneManager.SaveScene(scene);
}
var requiresRefresh = false;
var sceneBuildConfigGuids = new NativeArray <GUID>(sceneGuids.Count, Allocator.TempJob);
for (int i = 0; i != sceneBuildConfigGuids.Length; i++)
{
sceneBuildConfigGuids[i] = SceneWithBuildConfigurationGUIDs.EnsureExistsFor(sceneGuids[i], new Hash128(buildConfigurationGuid), false, out var thisRequiresRefresh);
requiresRefresh |= thisRequiresRefresh;
}
if (requiresRefresh)
{
AssetDatabase.Refresh();
}
var artifactHashes = new NativeArray <UnityEngine.Hash128>(sceneGuids.Count, Allocator.TempJob);
AssetDatabaseCompatibility.ProduceArtifactsRefreshIfNecessary(sceneBuildConfigGuids, typeof(SubSceneImporter), artifactHashes);
bool succeeded = true;
for (int i = 0; i != sceneBuildConfigGuids.Length; i++)
{
var sceneGuid = sceneGuids[i];
var artifactHash = artifactHashes[i];
AssetDatabaseCompatibility.GetArtifactPaths(artifactHash, out var artifactPaths);
List <FileInfo> exportedFiles = new List <FileInfo>();
bool foundEntityHeader = false;
foreach (var artifactPath in artifactPaths)
{
var ext = Path.GetExtension(artifactPath).ToLower().Replace(".", "");
if (ext == EntityScenesPaths.GetExtension(EntityScenesPaths.PathType.EntitiesHeader))
{
foundEntityHeader = true;
var destinationFile = dataDirectory.FullName + Path.DirectorySeparatorChar + EntityScenesPaths.RelativePathFolderFor(sceneGuid, EntityScenesPaths.PathType.EntitiesHeader, -1);
new NPath(artifactPath).MakeAbsolute().Copy(new NPath(destinationFile).MakeAbsolute().EnsureParentDirectoryExists());
exportedFiles.Add(new FileInfo(destinationFile));
}
else if (ext == EntityScenesPaths.GetExtension(EntityScenesPaths.PathType.EntitiesBinary))
{
var destinationFile = dataDirectory.FullName + Path.DirectorySeparatorChar + EntityScenesPaths.RelativePathFolderFor(sceneGuid, EntityScenesPaths.PathType.EntitiesBinary, EntityScenesPaths.GetSectionIndexFromPath(artifactPath));
new NPath(artifactPath).MakeAbsolute().Copy(new NPath(destinationFile).MakeAbsolute().EnsureParentDirectoryExists());
exportedFiles.Add(new FileInfo(destinationFile));
}
else if (ext == EntityScenesPaths.GetExtension(EntityScenesPaths.PathType.EntitiesConversionLog))
{
var destinationFile = logsDirectory.FullName + Path.DirectorySeparatorChar + $"{sceneGuid}.{EntityScenesPaths.GetExtension(EntityScenesPaths.PathType.EntitiesConversionLog)}";
new NPath(artifactPath).MakeAbsolute().Copy(new NPath(destinationFile).MakeAbsolute().EnsureParentDirectoryExists());
var result = PrintConversionLogToUnityConsole(artifactPath);
if (result.HasError || result.HasException)
{
UnityEngine.Debug.LogError("Failed to export scene: " + Path.GetFileName(AssetDatabase.GUIDToAssetPath(sceneGuid.ToString())));
succeeded = false;
}
}
else if (new Hash128(ext).IsValid) //Asset files are exported as {artifactHash}.{assetguid}
{
var destinationFile = dataDirectory.FullName + Path.DirectorySeparatorChar + ext;
new NPath(artifactPath).MakeAbsolute().Copy(new NPath(destinationFile).MakeAbsolute().EnsureParentDirectoryExists());
exportedFiles.Add(new FileInfo(destinationFile));
}
}
if (!foundEntityHeader)
{
Debug.LogError($"Failed to build EntityScene for '{AssetDatabaseCompatibility.GuidToPath(sceneGuid)}'.");
succeeded = false;
}
//UpdateManifest
manifest.Add(new Guid(sceneGuid.ToString()), AssetDatabase.GUIDToAssetPath(sceneGuid.ToString()), exportedFiles);
}
var catalogPath = Path.Combine(dataDirectory.ToString(), SceneSystem.k_SceneInfoFileName);
WriteCatalogFile(catalogPath, buildScenes);
manifest.AddAdditionalFilesToDeploy(new FileInfo(catalogPath.ToString()));
sceneBuildConfigGuids.Dispose();
artifactHashes.Dispose();
if (succeeded)
{
return(context.Success());
}
return(context.Failure($"Failed to export scenes"));
}