protected override async Task <bool> Initialize(EditorServiceGame editorGame)
{
if (editorGame == null)
{
throw new ArgumentNullException(nameof(editorGame));
}
game = editorGame as SceneEditorGame;
if (game == null)
{
throw new ArgumentException($"{nameof(game)} is not of type {nameof(EntityHierarchyEditorGame)}");
}
sceneEditorController = editor.Controller as SceneEditorController;
if (sceneEditorController == null)
{
throw new ArgumentNullException(nameof(sceneEditorController));
}
gameSettingsProviderService = editor.ServiceProvider.Get <GameSettingsProviderService>();
gameSettingsProviderService.GameSettingsChanged += GameSettingsProviderServiceOnGameSettingsChanged;
await navigationMeshManager.Initialize();
game.SceneAdded += GameOnSceneAdded;
game.SceneRemoved += GameOnSceneRemoved;
// Add debug entity
rootDebugEntity = new Entity("Navigation debug entity");
game.EditorScene.Entities.Add(rootDebugEntity);
// Handle added/updated navigation meshes so that they can be made visible when this scene is shown
editor.Session.AssetPropertiesChanged += OnAssetPropertiesChanged;
editor.Session.DeletedAssetsChanged += OnDeletedAssetsChanged;
editorGame.Script.AddTask(async() =>
{
while (editorGame.IsRunning)
{
Update();
await editorGame.Script.NextFrame();
}
});
// Initial update
foreach (var asset in editor.Session.AllAssets)
{
if (asset.AssetType == typeof(NavigationMeshAsset))
{
await UpdateNavigationMeshLink(asset);
}
}
// Update linked navigation meshes when loaded content has changed
// this happens when a navigation mesh gets recompiled by changes in the scene or navigation mesh asset
navigationMeshManager.Changed += NavigationMeshManagerOnChanged;
SetDynamicNavigationSystem(game.GameSystems.OfType <DynamicNavigationMeshSystem>().FirstOrDefault());
game.GameSystems.CollectionChanged += GameSystemsOnCollectionChanged;
return(true);
}
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 EditorGameGraphicsCompositorService([NotNull] IEditorGameController controller, [NotNull] GameEditorViewModel editor)
{
if (controller == null)
{
throw new ArgumentNullException(nameof(controller));
}
if (editor == null)
{
throw new ArgumentNullException(nameof(editor));
}
this.controller = controller;
this.editor = editor;
settingsProvider = editor.ServiceProvider.Get <GameSettingsProviderService>();
}
public GameStudioThumbnailService(SessionViewModel session, GameSettingsProviderService settingsProvider, GameStudioBuilderService assetBuilderService)
{
this.session = session;
this.assetBuilderService = assetBuilderService;
generator = new ThumbnailGenerator((EffectCompilerBase)assetBuilderService.EffectCompiler);
compilerRegistry = new AssetCompilerRegistry {
DefaultCompiler = new CustomAssetThumbnailCompiler()
};
thumbnailCompiler = new ThumbnailListCompiler(generator, ThumbnailBuilt, compilerRegistry);
gameSettingsProviderService = settingsProvider;
gameSettingsProviderService.GameSettingsChanged += GameSettingsChanged;
UpdateGameSettings(settingsProvider.CurrentGameSettings);
StartPushNotificationsTask();
}
/// <summary>
/// Initializes a new instance of the <see cref="EditorContentLoader"/> class
/// </summary>
/// <param name="gameDispatcher">The dispatcher to the game thread.</param>
/// <param name="logger">The logger to use to log operations.</param>
/// <param name="asset">The asset associated with this instance.</param>
/// <param name="game">The editor game associated with this instance.</param>
public EditorContentLoader(IDispatcherService gameDispatcher, ILogger logger, AssetViewModel asset, EditorServiceGame game)
{
if (asset == null)
{
throw new ArgumentNullException(nameof(asset));
}
GameDispatcher = gameDispatcher ?? throw new ArgumentNullException(nameof(gameDispatcher));
Session = asset.Session;
Session.AssetPropertiesChanged += AssetPropertiesChanged;
Game = game ?? throw new ArgumentNullException(nameof(game));
Asset = asset;
Manager = new LoaderReferenceManager(GameDispatcher, this);
this.logger = logger;
database = asset.ServiceProvider.Get <GameStudioDatabase>();
settingsProvider = asset.ServiceProvider.Get <GameSettingsProviderService>();
settingsProvider.GameSettingsChanged += GameSettingsChanged;
currentRenderingMode = settingsProvider.CurrentGameSettings.GetOrCreate <EditorSettings>().RenderingMode;
currentColorSpace = settingsProvider.CurrentGameSettings.GetOrCreate <RenderingSettings>().ColorSpace;
currentNavigationGroupsHash = settingsProvider.CurrentGameSettings.GetOrCreate <NavigationSettings>().ComputeGroupsHash();
}
public override void InitializeSession(SessionViewModel session)
{
var fallbackDirectory = UPath.Combine(EditorSettings.FallbackBuildCacheDirectory, new UDirectory(XenkoGameStudio.EditorName));
var buildDirectory = fallbackDirectory;
try
{
var package = session.CurrentProject ?? session.LocalPackages.First();
if (package != null)
{
// In package, we override editor build directory to be per-project and be shared with game build directory
buildDirectory = $"{package.PackagePath.GetFullDirectory().ToWindowsPath()}\\obj\\xenko\\assetbuild\\data";
}
// Attempt to create the directory to ensure it is valid.
if (!Directory.Exists(buildDirectory))
{
Directory.CreateDirectory(buildDirectory);
}
}
catch (Exception)
{
buildDirectory = fallbackDirectory;
}
var pluginService = session.ServiceProvider.Get <IAssetsPluginService>();
var previewFactories = new Dictionary <Type, AssetPreviewFactory>();
foreach (var xenkoPlugin in pluginService.Plugins.OfType <XenkoAssetsPlugin>())
{
var pluginTypes = xenkoPlugin.GetType().Assembly.GetTypes();
foreach (var type in pluginTypes)
{
var localType = type;
if (typeof(IAssetPreview).IsAssignableFrom(type))
{
var previewAttribute = type.GetCustomAttribute <AssetPreviewAttribute>();
if (previewAttribute != null)
{
previewFactories.Add(previewAttribute.AssetType, (builder, game, asset) => (IAssetPreview)Activator.CreateInstance(localType));
}
}
}
}
var settingsProvider = new GameSettingsProviderService(session);
session.ServiceProvider.RegisterService(settingsProvider);
var builderService = new GameStudioBuilderService(session, settingsProvider, buildDirectory);
session.ServiceProvider.RegisterService(builderService);
session.ServiceProvider.RegisterService(builderService.Database); // TODO: this should be removed, the AssetBuilderService is reachable from anywhere now
var previewService = new GameStudioPreviewService(session);
previewService.RegisterAssetPreviewFactories(previewFactories);
session.ServiceProvider.RegisterService(previewService);
var thumbnailService = new GameStudioThumbnailService(session, settingsProvider, builderService);
session.ServiceProvider.RegisterService(thumbnailService);
var xenkoDebugService = new XenkoDebugService(session.ServiceProvider);
session.ServiceProvider.RegisterService(xenkoDebugService);
GameStudioViewModel.GameStudio.Preview = new PreviewViewModel(session);
GameStudioViewModel.GameStudio.Debugging = new DebuggingViewModel(GameStudioViewModel.GameStudio, xenkoDebugService);
}
