public GameStudioPreviewService(SessionViewModel session)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
this.session = session;
Dispatcher = session.Dispatcher;
AssetBuilderService = session.ServiceProvider.Get <GameStudioBuilderService>();
gameSettingsProvider = session.ServiceProvider.Get <GameSettingsProviderService>();
Logger = GlobalLogger.GetLogger("Preview");
loggerDebugPage = EditorDebugTools.CreateLogDebugPage(Logger, "Preview");
previewGameSettings = GameSettingsFactory.Create();
previewGameSettings.GetOrCreate <RenderingSettings>().DefaultGraphicsProfile = GraphicsProfile.Level_11_0;
UpdateGameSettings(gameSettingsProvider.CurrentGameSettings);
previewCompileContext.SetGameSettingsAsset(previewGameSettings);
previewCompileContext.CompilationContext = typeof(PreviewCompilationContext);
previewGameThread = new Thread(SafeAction.Wrap(StrideUIThread))
{
IsBackground = true, Name = "PreviewGame Thread"
};
previewGameThread.SetApartmentState(ApartmentState.STA);
previewGameThread.Start();
// Wait for the window handle to be generated on the proper thread
initializationSignal.WaitOne();
host = new GameEngineHost(windowHandle);
session.AssetPropertiesChanged += OnAssetPropertyChanged;
gameSettingsProvider.GameSettingsChanged += OnGameSettingsChanged;
}
public SceneRenderer(GameSettingsAsset gameSettings)
{
if (gameSettings == null) throw new ArgumentNullException(nameof(gameSettings));
// Initialize services
Services = new ServiceRegistry();
ContentManager = new ContentManager(Services);
var renderingSettings = gameSettings.Get<RenderingSettings>();
GraphicsDevice = GraphicsDevice.New(DeviceCreationFlags.None, new[] { renderingSettings.DefaultGraphicsProfile });
var graphicsDeviceService = new GraphicsDeviceServiceLocal(Services, GraphicsDevice);
EffectSystem = new EffectSystem(Services);
GraphicsContext = new GraphicsContext(GraphicsDevice);
Services.AddService(typeof(GraphicsContext), GraphicsContext);
SceneSystem = new SceneSystem(Services);
// Create game systems
GameSystems = new GameSystemCollection(Services);
GameSystems.Add(new GameFontSystem(Services));
GameSystems.Add(new UISystem(Services));
GameSystems.Add(EffectSystem);
GameSystems.Add(SceneSystem);
GameSystems.Initialize();
// Fake presenter
// TODO GRAPHICS REFACTOR: This is needed be for render stage setup
GraphicsDevice.Presenter = new RenderTargetGraphicsPresenter(GraphicsDevice,
Texture.New2D(GraphicsDevice, renderingSettings.DefaultBackBufferWidth, renderingSettings.DefaultBackBufferHeight,
renderingSettings.ColorSpace == ColorSpace.Linear ? PixelFormat.R8G8B8A8_UNorm_SRgb : PixelFormat.R8G8B8A8_UNorm, TextureFlags.ShaderResource | TextureFlags.RenderTarget),
PixelFormat.D24_UNorm_S8_UInt);
SceneSystem.MainRenderFrame = RenderFrame.FromTexture(GraphicsDevice.Presenter.BackBuffer, GraphicsDevice.Presenter.DepthStencilBuffer);
}
private void UpdateGameSettings(GameSettingsAsset currentGameSettings)
{
databaseGameSettings.GetOrCreate <EditorSettings>().RenderingMode = currentGameSettings.GetOrCreate <EditorSettings>().RenderingMode;
databaseGameSettings.GetOrCreate <RenderingSettings>().ColorSpace = currentGameSettings.GetOrCreate <RenderingSettings>().ColorSpace;
databaseGameSettings.GetOrCreate <Navigation.NavigationSettings>().Groups = currentGameSettings.GetOrCreate <Navigation.NavigationSettings>().Groups;
databaseGameSettings.GetOrCreate <RenderingSettings>().DefaultGraphicsProfile = currentGameSettings.GetOrCreate <RenderingSettings>().DefaultGraphicsProfile;
}
private void UpdateGameSettings(GameSettingsAsset gameSettings)
{
currentGameSettings = AssetCloner.Clone(gameSettings, AssetClonerFlags.RemoveUnloadableObjects);
bool shouldRefreshAllThumbnails = false;
if (renderingMode != gameSettings.GetOrCreate <EditorSettings>().RenderingMode)
{
renderingMode = gameSettings.GetOrCreate <EditorSettings>().RenderingMode;
shouldRefreshAllThumbnails = true;
}
if (colorSpace != gameSettings.GetOrCreate <RenderingSettings>().ColorSpace)
{
colorSpace = gameSettings.GetOrCreate <RenderingSettings>().ColorSpace;
shouldRefreshAllThumbnails = true;
}
if (graphicsProfile != gameSettings.GetOrCreate <RenderingSettings>().DefaultGraphicsProfile)
{
graphicsProfile = gameSettings.GetOrCreate <RenderingSettings>().DefaultGraphicsProfile;
shouldRefreshAllThumbnails = true;
}
if (shouldRefreshAllThumbnails)
{
var allAssets = session.AllAssets.Select(x => x.AssetItem).ToList();
Task.Run(() => AddThumbnailAssetItems(allAssets, QueuePosition.First));
}
}
protected override void ComputeParameterHash(BinarySerializationWriter writer)
{
base.ComputeParameterHash(writer);
if (IsDefaultScene())
{
var gameSettings = GameSettingsAsset.CreateFromPackage(package, context.Platform);
writer.Write(gameSettings);
}
}
public NavmeshBuildCommand(string url, AssetItem assetItem, NavigationMeshAsset value, AssetCompilerContext context)
: base(url, value, assetItem.Package)
{
gameSettingsAsset = context.GetGameSettingsAsset();
asset = value;
assetUrl = url;
Version = 1; // Removed separate debug model stored in the navigation mesh
}
private bool IsDefaultScene()
{
var defaultScene = GameSettingsAsset.GetDefaultScene(package);
if (defaultScene == null)
{
return(false);
}
return(defaultScene.Location == Url);
}
public ThumbnailAssetBuildUnit(AssetItem asset, GameSettingsAsset gameSettings, GameStudioThumbnailService thumbnailService, int priorityOrder)
: base(new AssetBuildUnitIdentifier(ThumbnailBuildUnitContextId, asset.Id))
{
this.asset = asset;
this.thumbnailService = thumbnailService;
this.gameSettings = gameSettings;
PriorityMajor = DefaultAssetBuilderPriorities.ThumbnailPriority;
PriorityMinor = priorityOrder;
}
protected override Task <ResultStatus> DoCommandOverride(ICommandContext commandContext)
{
var assetManager = new AssetManager();
var rootEntity = asset.Hierarchy.Entities[asset.Hierarchy.RootEntity];
assetManager.Save(Url, rootEntity);
// Save the default settings
if (IsDefaultScene())
{
assetManager.Save(GameSettings.AssetUrl, GameSettingsAsset.CreateFromPackage(package, context.Platform));
}
return(Task.FromResult(ResultStatus.Successful));
}
public ListBuildStep Compile(AssetItem asset, GameSettingsAsset gameSettings)
{
// Mark thumbnail as being compiled
lock (hashLock)
{
thumbnailQueueHash.Remove(asset);
if (thumbnailsInProgressAndContinuation.ContainsKey(asset.Id) && System.Diagnostics.Debugger.IsAttached)
{
// Virgile: This case should not happen, but it happened to me once and could not reproduce.
// Please let me know if it happens to you.
// Note: this is likely not critical and should work fine even if it happens.
System.Diagnostics.Debugger.Break();
}
thumbnailsInProgressAndContinuation[asset.Id] = null;
}
return(thumbnailCompiler.Compile(asset, gameSettings, HasStaticThumbnail(asset.Asset.GetType())));
}
public GameStudioDatabase(GameStudioBuilderService assetBuilderService, GameSettingsProviderService settingsProvider)
{
this.assetBuilderService = assetBuilderService;
this.settingsProvider = settingsProvider;
CompilerContext.Platform = PlatformType.Windows;
databaseGameSettings = GameSettingsFactory.Create();
//// TODO: get the best available between 10 and 11
//databaseGameSettings.GetOrCreate<RenderingSettings>().DefaultGraphicsProfile = GraphicsProfile.Level_11_0;
CompilerContext.SetGameSettingsAsset(databaseGameSettings);
CompilerContext.CompilationContext = typeof(EditorGameCompilationContext);
UpdateGameSettings(settingsProvider.CurrentGameSettings);
settingsProvider.GameSettingsChanged += OnGameSettingsChanged;
((AssetDependencyManager)assetBuilderService.SessionViewModel.DependencyManager).AssetChanged += OnAssetChanged;
}
/// <summary>
/// Generates a <see cref="ListBuildStep"/> to compile the thumbnail of the given asset.
/// </summary>
/// <param name="assetItem">The asset to compile.</param>
/// <param name="gameSettings">The current game settings</param>
/// <param name="staticThumbnail">If the asset has to be compiled as well in the case of non static thumbnail</param>
/// <returns>A <see cref="ListBuildStep"/> containing the build steps to generate the thumbnail of the given asset.</returns>
public ListBuildStep Compile(AssetItem assetItem, GameSettingsAsset gameSettings, bool staticThumbnail)
{
if (assetItem == null)
{
throw new ArgumentNullException(nameof(assetItem));
}
using (var context = new ThumbnailCompilerContext
{
Platform = PlatformType.Windows
})
{
context.SetGameSettingsAsset(gameSettings);
context.CompilationContext = typeof(PreviewCompilationContext);
context.Properties.Set(ThumbnailGenerator.Key, generator);
context.ThumbnailBuilt += builtAction;
var result = new AssetCompilerResult();
if (!staticThumbnail)
{
//compile the actual asset
result = dependenciesCompiler.Prepare(context, assetItem);
}
//compile the actual thumbnail
var thumbnailStep = CompileItem(context, result, assetItem);
foreach (var buildStep in result.BuildSteps)
{
BuildStep.LinkBuildSteps(buildStep, thumbnailStep);
}
result.BuildSteps.Add(thumbnailStep);
return(result.BuildSteps);
}
}
public static void SetGameSettingsAsset(this AssetCompilerContext context, GameSettingsAsset gameSettingsAsset)
{
context.Properties.Set(GameSettingsAssetKey, gameSettingsAsset);
}
/// <summary>
/// Initializes a new instance of the <see cref="GameSettingsChangedEventArgs"/> class.
/// </summary>
/// <param name="gameSettings">A copy of the current game settings asset.</param>
public GameSettingsChangedEventArgs(GameSettingsAsset gameSettings)
{
GameSettings = gameSettings;
}
/// <summary>
/// Checks if a default scene exists for this game package.
/// </summary>
/// <param name="log">The log to output the result of the validation.</param>
public override void Run(ILogger log)
{
if (log == null)
{
throw new ArgumentNullException("log");
}
foreach (var package in Session.Packages)
{
// Make sure package has its assets loaded
if (package.State < PackageState.AssetsReady)
{
continue;
}
var hasGameExecutable = package.Profiles.SelectMany(profile => profile.ProjectReferences).Any(projectRef => projectRef.Type == ProjectType.Executable);
if (!hasGameExecutable)
{
continue;
}
// Find game settings
var gameSettingsAssetItem = package.Assets.Find(GameSettingsAsset.GameSettingsLocation);
AssetItem defaultScene = null;
// If game settings is found, try to find default scene inside
if (gameSettingsAssetItem != null)
{
var defaultSceneRuntime = ((GameSettingsAsset)gameSettingsAssetItem.Asset).DefaultScene;
if (defaultSceneRuntime != null)
{
var defaultSceneReference = AttachedReferenceManager.GetAttachedReference(defaultSceneRuntime);
if (defaultSceneReference != null)
{
// Find it either by Url or Id
defaultScene = package.Assets.Find(defaultSceneReference.Id) ?? package.Assets.Find(defaultSceneReference.Url);
// Check it is actually a scene asset
if (defaultScene != null && !(defaultScene.Asset is SceneAsset))
{
defaultScene = null;
}
}
}
}
// Find or create default scene
if (defaultScene == null)
{
defaultScene = package.Assets.Find(GameSettingsAsset.DefaultSceneLocation);
if (defaultScene != null && !(defaultScene.Asset is SceneAsset))
{
defaultScene = null;
}
}
// Otherwise, try to find any scene
if (defaultScene == null)
{
defaultScene = package.Assets.FirstOrDefault(x => x.Asset is SceneAsset);
}
// Nothing found, let's create an empty one
if (defaultScene == null)
{
log.Error(package, null, AssetMessageCode.DefaultSceneNotFound, null);
var defaultSceneName = NamingHelper.ComputeNewName(GameSettingsAsset.DefaultSceneLocation, package.Assets, a => a.Location);
var defaultSceneAsset = SceneAsset.Create();
defaultScene = new AssetItem(defaultSceneName, defaultSceneAsset);
package.Assets.Add(defaultScene);
defaultScene.IsDirty = true;
}
// Create game settings if not done yet
if (gameSettingsAssetItem == null)
{
log.Error(package, null, AssetMessageCode.AssetNotFound, GameSettingsAsset.GameSettingsLocation);
var gameSettingsAsset = new GameSettingsAsset();
gameSettingsAsset.DefaultScene = AttachedReferenceManager.CreateSerializableVersion <Scene>(defaultScene.Id, defaultScene.Location);
gameSettingsAssetItem = new AssetItem(GameSettingsAsset.GameSettingsLocation, gameSettingsAsset);
package.Assets.Add(gameSettingsAssetItem);
gameSettingsAssetItem.IsDirty = true;
}
}
}
private void UpdateCurrentGameSettings()
{
currentPackage = session.CurrentProject?.Package;
CurrentGameSettings = currentPackage?.GetGameSettingsAssetOrDefault() ?? GameSettingsFactory.Create();
RaiseGameSettings(CurrentGameSettings);
}
private void RaiseGameSettings(GameSettingsAsset gameSettingsAsset)
{
GameSettingsChanged?.Invoke(this, new GameSettingsChangedEventArgs(AssetCloner.Clone(gameSettingsAsset)));
}
private BuildResultCode BuildMaster()
{
// Only querying graphics platform, let's load package, print it and exit
if (builderOptions.GetGraphicsPlatform)
{
return(BuildGetGraphicsPlatform());
}
assetLogger = new RemoteLogForwarder(builderOptions.Logger, builderOptions.LogPipeNames);
GlobalLogger.GlobalMessageLogged += assetLogger;
PackageSession projectSession = null;
try
{
// TODO handle solution file + package-id ?
// When the current platform is not on windows, we need to make sure that all plugins are build, so we
// setup auto-compile when loading the session
var sessionLoadParameters = new PackageLoadParameters
{
AutoCompileProjects = builderOptions.Platform != PlatformType.Windows || !builderOptions.DisableAutoCompileProjects,
ExtraCompileProperties = builderOptions.ExtraCompileProperties,
};
// Loads the root Package
var projectSessionResult = PackageSession.Load(builderOptions.PackageFile, sessionLoadParameters);
if (projectSessionResult.HasErrors)
{
projectSessionResult.CopyTo(builderOptions.Logger);
return(BuildResultCode.BuildError);
}
projectSession = projectSessionResult.Session;
// Check build configuration
var package = projectSession.LocalPackages.Last();
// Check build profile
var sharedProfile = package.Profiles.FindSharedProfile();
var buildProfile = package.Profiles.FirstOrDefault(pair => pair.Name == builderOptions.BuildProfile);
if (buildProfile == null)
{
builderOptions.Logger.Error("Unable to find profile [{0}] in package [{1}]", builderOptions.BuildProfile, package.FullPath);
return(BuildResultCode.BuildError);
}
// Setup variables
var buildDirectory = builderOptions.BuildDirectory;
var outputDirectory = builderOptions.OutputDirectory;
// Process game settings asset
var gameSettingsAsset = package.GetGameSettingsAsset();
if (gameSettingsAsset == null)
{
builderOptions.Logger.Warning("Could not find game settings asset at location [{0}]. Use a Default One", GameSettingsAsset.GameSettingsLocation);
gameSettingsAsset = new GameSettingsAsset();
}
// Create context
var context = new AssetCompilerContext
{
Profile = builderOptions.BuildProfile,
Platform = builderOptions.Platform
};
context.SetGameSettingsAsset(gameSettingsAsset);
// Copy properties from shared profiles to context properties
if (sharedProfile != null)
{
sharedProfile.Properties.CopyTo(context.PackageProperties, true);
}
// Copy properties from build profile
buildProfile.Properties.CopyTo(context.PackageProperties, true);
// Builds the project
var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package));
assetBuilder.AssetCompiled += RegisterBuildStepProcessedHandler;
var assetBuildResult = assetBuilder.Compile(context);
assetBuildResult.CopyTo(builderOptions.Logger);
if (assetBuildResult.HasErrors)
{
return(BuildResultCode.BuildError);
}
// Create the builder
var indexName = "index." + builderOptions.BuildProfile;
builder = new Builder(builderOptions.Logger, buildDirectory, builderOptions.BuildProfile, indexName)
{
ThreadCount = builderOptions.ThreadCount
};
builder.MonitorPipeNames.AddRange(builderOptions.MonitorPipeNames);
// Add build steps generated by AssetBuilder
builder.Root.Add(assetBuildResult.BuildSteps);
// Run builder
var result = builder.Run(Builder.Mode.Build);
builder.WriteIndexFile(false);
// Fill list of bundles
var bundlePacker = new BundlePacker();
bundlePacker.Build(builderOptions.Logger, projectSession, buildProfile, indexName, outputDirectory, builder.DisableCompressionIds);
return(result);
}
finally
{
if (builder != null)
{
builder.Dispose();
}
// Dispose the session (in order to unload assemblies)
if (projectSession != null)
{
projectSession.Dispose();
}
// Flush and close logger
GlobalLogger.GlobalMessageLogged -= assetLogger;
assetLogger.Dispose();
}
}
private void UpdateGameSettings(GameSettingsAsset currentGameSettings)
{
previewGameSettings.GetOrCreate <EditorSettings>().RenderingMode = currentGameSettings.GetOrCreate <EditorSettings>().RenderingMode;
previewGameSettings.GetOrCreate <RenderingSettings>().ColorSpace = currentGameSettings.GetOrCreate <RenderingSettings>().ColorSpace;
}
/// <summary>
/// Checks if a default scene exists for this game package.
/// </summary>
/// <param name="log">The log to output the result of the validation.</param>
public override void Run(ILogger log)
{
if (log == null) throw new ArgumentNullException("log");
foreach (var package in Session.Packages)
{
// Make sure package has its assets loaded
if (package.State < PackageState.AssetsReady)
continue;
var hasGameExecutable = package.Profiles.SelectMany(profile => profile.ProjectReferences).Any(projectRef => projectRef.Type == ProjectType.Executable);
if (!hasGameExecutable)
{
continue;
}
// Find game settings
var gameSettingsAssetItem = package.Assets.Find(GameSettingsAsset.GameSettingsLocation);
AssetItem defaultScene = null;
// If game settings is found, try to find default scene inside
if (gameSettingsAssetItem != null)
{
var defaultSceneRuntime = ((GameSettingsAsset)gameSettingsAssetItem.Asset).DefaultScene;
if (defaultSceneRuntime != null)
{
var defaultSceneReference = AttachedReferenceManager.GetAttachedReference(defaultSceneRuntime);
if (defaultSceneReference != null)
{
// Find it either by Url or Id
defaultScene = package.Assets.Find(defaultSceneReference.Id) ?? package.Assets.Find(defaultSceneReference.Url);
// Check it is actually a scene asset
if (defaultScene != null && !(defaultScene.Asset is SceneAsset))
defaultScene = null;
}
}
}
// Find or create default scene
if (defaultScene == null)
{
defaultScene = package.Assets.Find(GameSettingsAsset.DefaultSceneLocation);
if (defaultScene != null && !(defaultScene.Asset is SceneAsset))
defaultScene = null;
}
// Otherwise, try to find any scene
if (defaultScene == null)
defaultScene = package.Assets.FirstOrDefault(x => x.Asset is SceneAsset);
// Nothing found, let's create an empty one
if (defaultScene == null)
{
log.Error(package, null, AssetMessageCode.DefaultSceneNotFound, null);
var defaultSceneName = NamingHelper.ComputeNewName(GameSettingsAsset.DefaultSceneLocation, package.Assets, a => a.Location);
var defaultSceneAsset = SceneAsset.Create();
defaultScene = new AssetItem(defaultSceneName, defaultSceneAsset);
package.Assets.Add(defaultScene);
defaultScene.IsDirty = true;
}
// Create game settings if not done yet
if (gameSettingsAssetItem == null)
{
log.Error(package, null, AssetMessageCode.AssetNotFound, GameSettingsAsset.GameSettingsLocation);
var gameSettingsAsset = new GameSettingsAsset();
gameSettingsAsset.DefaultScene = AttachedReferenceManager.CreateSerializableVersion<Scene>(defaultScene.Id, defaultScene.Location);
gameSettingsAssetItem = new AssetItem(GameSettingsAsset.GameSettingsLocation, gameSettingsAsset);
package.Assets.Add(gameSettingsAssetItem);
gameSettingsAssetItem.IsDirty = true;
}
}
}
private BuildResultCode BuildMaster()
{
// Only querying graphics platform, let's load package, print it and exit
if (builderOptions.GetGraphicsPlatform)
{
return BuildGetGraphicsPlatform();
}
assetLogger = new RemoteLogForwarder(builderOptions.Logger, builderOptions.LogPipeNames);
GlobalLogger.GlobalMessageLogged += assetLogger;
PackageSession projectSession = null;
try
{
// TODO handle solution file + package-id ?
// When the current platform is not on windows, we need to make sure that all plugins are build, so we
// setup auto-compile when loading the session
var sessionLoadParameters = new PackageLoadParameters
{
AutoCompileProjects = builderOptions.Platform != PlatformType.Windows || !builderOptions.DisableAutoCompileProjects,
ExtraCompileProperties = builderOptions.ExtraCompileProperties,
};
// Loads the root Package
var projectSessionResult = PackageSession.Load(builderOptions.PackageFile, sessionLoadParameters);
if (projectSessionResult.HasErrors)
{
projectSessionResult.CopyTo(builderOptions.Logger);
return BuildResultCode.BuildError;
}
projectSession = projectSessionResult.Session;
// Check build configuration
var package = projectSession.LocalPackages.Last();
// Check build profile
var sharedProfile = package.Profiles.FindSharedProfile();
var buildProfile = package.Profiles.FirstOrDefault(pair => pair.Name == builderOptions.BuildProfile);
if (buildProfile == null)
{
builderOptions.Logger.Error("Unable to find profile [{0}] in package [{1}]", builderOptions.BuildProfile, package.FullPath);
return BuildResultCode.BuildError;
}
// Setup variables
var buildDirectory = builderOptions.BuildDirectory;
var outputDirectory = builderOptions.OutputDirectory;
// Process game settings asset
var gameSettingsAsset = package.GetGameSettingsAsset();
if (gameSettingsAsset == null)
{
builderOptions.Logger.Warning("Could not find game settings asset at location [{0}]. Use a Default One", GameSettingsAsset.GameSettingsLocation);
gameSettingsAsset = new GameSettingsAsset();
}
// Create context
var context = new AssetCompilerContext
{
Profile = builderOptions.BuildProfile,
Platform = builderOptions.Platform
};
context.SetGameSettingsAsset(gameSettingsAsset);
// Copy properties from shared profiles to context properties
if (sharedProfile != null)
{
sharedProfile.Properties.CopyTo(context.PackageProperties, true);
}
// Copy properties from build profile
buildProfile.Properties.CopyTo(context.PackageProperties, true);
// Builds the project
var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package));
assetBuilder.AssetCompiled += RegisterBuildStepProcessedHandler;
var assetBuildResult = assetBuilder.Compile(context);
assetBuildResult.CopyTo(builderOptions.Logger);
if (assetBuildResult.HasErrors)
return BuildResultCode.BuildError;
// Create the builder
var indexName = "index." + builderOptions.BuildProfile;
builder = new Builder(builderOptions.Logger, buildDirectory, builderOptions.BuildProfile, indexName) { ThreadCount = builderOptions.ThreadCount };
builder.MonitorPipeNames.AddRange(builderOptions.MonitorPipeNames);
// Add build steps generated by AssetBuilder
builder.Root.Add(assetBuildResult.BuildSteps);
// Run builder
var result = builder.Run(Builder.Mode.Build);
builder.WriteIndexFile(false);
// Fill list of bundles
var bundlePacker = new BundlePacker();
bundlePacker.Build(builderOptions.Logger, projectSession, buildProfile, indexName, outputDirectory, builder.DisableCompressionIds);
return result;
}
finally
{
if (builder != null)
{
builder.Dispose();
}
// Dispose the session (in order to unload assemblies)
if (projectSession != null)
{
projectSession.Dispose();
}
// Flush and close logger
GlobalLogger.GlobalMessageLogged -= assetLogger;
assetLogger.Dispose();
}
}
/// <summary>
/// Checks if a default scene exists for this game package.
/// </summary>
/// <param name="log">The log to output the result of the validation.</param>
public override void Run(ILogger log)
{
if (log == null)
{
throw new ArgumentNullException("log");
}
foreach (var package in Session.Packages)
{
var hasGameExecutable = package.Profiles.SelectMany(profile => profile.ProjectReferences).Any(projectRef => projectRef.Type == ProjectType.Executable);
if (!hasGameExecutable)
{
continue;
}
var sharedProfile = package.Profiles.FindSharedProfile();
if (sharedProfile == null)
{
continue;
}
var defaultScene = sharedProfile.Properties.Get(GameSettingsAsset.DefaultScene);
// If the pdxpkg does not reference any scene
if (defaultScene == null)
{
log.Error(package, null, AssetMessageCode.DefaultSceneNotFound, null);
// Creates a new default scene
// Checks we don't overwrite an existing asset
const string defaultSceneLocation = "MainScene";
var existingDefault = package.Assets.Find(defaultSceneLocation);
if (existingDefault != null && existingDefault.Asset is SceneAsset)
{
// A scene at the default location already exists among the assets, let's reference it as the default scene
var sceneAsset = new AssetReference <SceneAsset>(existingDefault.Id, existingDefault.Location);
GameSettingsAsset.SetDefaultScene(package, sceneAsset);
}
else if (existingDefault != null)
{
// Very rare case: the default scene location is occupied by another asset which is not a scene
// Compute a new default name to not overwrite the existing asset
var newName = NamingHelper.ComputeNewName(defaultSceneLocation, package.Assets, a => a.Location);
GameSettingsAsset.CreateAndSetDefaultScene(package, newName);
}
else
{
// Creates a new default scene asset
GameSettingsAsset.CreateAndSetDefaultScene(package, defaultSceneLocation);
}
continue;
}
// The pdxpkg references an asset
var defaultAsset = package.Assets.Find(defaultScene.Location);
if (defaultAsset != null)
{
continue; // Default scene exists and is referenced
}
// The asset referenced does not exist, create it
log.Error(package, defaultScene, AssetMessageCode.AssetNotFound, defaultScene);
GameSettingsAsset.CreateAndSetDefaultScene(package);
}
}
