public static Logger CleanContext() { // delete previous build data if (Directory.Exists(BuildPath)) { Directory.Delete(BuildPath, true); } // Create database directory ((FileSystemProvider)VirtualFileSystem.ApplicationData).ChangeBasePath(BuildPath); VirtualFileSystem.CreateDirectory(VirtualFileSystem.ApplicationDatabasePath); // Delete source folder if exists if (Directory.Exists(FileSourceFolder)) { Directory.Delete(FileSourceFolder, true); } Builder.CloseObjectDatabase(); TestCommand.ResetCounter(); if (!loggerHandled) { GlobalLogger.GlobalMessageLogged += new ConsoleLogListener(); loggerHandled = true; } return(GlobalLogger.GetLogger("UnitTest")); }
/// <summary> /// Initializes a new instance of the <see cref="GraphViewModel"/> class. /// </summary> /// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="GraphViewModelService"/> to use for this view model.</param> /// <param name="type"></param> /// <param name="rootPresenters">The root <see cref="INodePresenter"/> instances.</param> private GraphViewModel([NotNull] IViewModelServiceProvider serviceProvider, [NotNull] Type type, [NotNull] IEnumerable <INodePresenter> rootPresenters) : base(serviceProvider) { if (serviceProvider == null) { throw new ArgumentNullException(nameof(serviceProvider)); } if (type == null) { throw new ArgumentNullException(nameof(type)); } if (rootPresenters == null) { throw new ArgumentNullException(nameof(rootPresenters)); } GraphViewModelService = serviceProvider.TryGet <GraphViewModelService>(); if (GraphViewModelService == null) { throw new InvalidOperationException($"{nameof(GraphViewModel)} requires a {nameof(GraphViewModelService)} in the service provider."); } Logger = GlobalLogger.GetLogger(DefaultLoggerName); if (rootPresenters == null) { throw new ArgumentNullException(nameof(rootNode)); } var viewModelFactory = serviceProvider.Get <GraphViewModelService>().NodeViewModelFactory; viewModelFactory.CreateGraph(this, type, rootPresenters); }
public override void Serialize(ContentSerializerContext context, SerializationStream stream, Texture texture) { if (context.Mode == ArchiveMode.Serialize) { throw new NotImplementedException(); } var assetManager = context.AssetManager; var url = context.Url; using (var textureData = Image.Load(stream.NativeStream)) { try { texture.InitializeFrom(textureData.Description, new TextureViewDescription(), textureData.ToDataBox()); // Setup reload callback (reload from asset manager) texture.Reload = (graphicsResource) => { // TODO: Avoid loading/unloading the same data var textureDataReloaded = assetManager.Load <Image>(url); ((Texture)graphicsResource).Recreate(textureDataReloaded.ToDataBox()); assetManager.Unload(textureDataReloaded); }; } catch (Exception ex) { GlobalLogger.GetLogger("GPUTexture").Error("Unable to load Texture {0}. See Debug for more information", ex, context.Url); } } }
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 GameEngineBase(ContentManager contentManager, IServiceRegistry services, GameSystemCollection gameSystems = null) { Logger = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name); GameClockManager = new GameClockManager(PhysicsGameTime); _targetTimeDriftAdjustmentThreshold = GameClockManager.SimulationDeltaTime.Ticks / 10; // 10% of a single sim step Services = (ServiceRegistry)services; Content = contentManager; GameSystems = gameSystems ?? new GameSystemCollection(Services); // Replacing existing IGameSystemCollection with our own var existingGameSystems = Services.GetService <IGameSystemCollection>(); if (existingGameSystems != null) { Services.RemoveService <IGameSystemCollection>(); } Services.AddOrOverwriteService <IGameSystemCollection>(GameSystems); var networkAssetDatabase = new NetworkAssetDatabase(Content, assetFolderUrls: new[] { "Prefabs", "Scenes" }); Services.AddOrOverwriteService(networkAssetDatabase); Services.AddOrOverwriteService(GameClockManager); var gameSettingsService = services.GetSafeServiceAs <IGameSettingsService>(); Settings = gameSettingsService.Settings; }
public void TestGlobalLogger() { var log = GlobalLogger.GetLogger("Module1"); var logbis = GlobalLogger.GetLogger("Module1"); var log1x = GlobalLogger.GetLogger("Module1x"); // Check that we get the same instance. Assert.That(log, Is.EqualTo(logbis)); // This should work but no handler is installed. log.Info("TEST"); // Instal a message handler. var messages = new List <ILogMessage>(); GlobalLogger.GlobalMessageLogged += messages.Add; // Log a simple message (disabled by default). log.Verbose("#0"); Assert.That(messages.Count, Is.EqualTo(0)); // Activate the log for all loggers starting from Info GlobalLogger.ActivateLog(".*", LogMessageType.Verbose); // Log a simple message log.Verbose("#0"); Assert.That(messages.Count, Is.EqualTo(1)); Assert.That(messages[0].Text, Is.EqualTo("#0")); // Activate the log for Module1x starting from Debug GlobalLogger.ActivateLog(".*x", LogMessageType.Debug); log1x.Debug("#1"); Assert.That(messages.Count, Is.EqualTo(2)); Assert.That(messages[1].Text, Is.EqualTo("#1")); }
public void TestBasicPackageCreateSaveLoad() { // Override search path since we are in a unit test directory DirectoryHelper.PackageDirectoryOverride = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\.."); var defaultPackage = PackageStore.Instance.DefaultPackage; PackageArchive.Build(GlobalLogger.GetLogger("PackageArchiveTest"), defaultPackage, AppDomain.CurrentDomain.BaseDirectory); }
public void TestRuntime() { var package = new Package(); // ReSharper disable once UnusedVariable - we need a package session to compile var packageSession = new PackageSession(package); var otherAssets = new List <AssetItem> { new AssetItem("asset11", new MyAsset11(), package), new AssetItem("asset12", new MyAsset12(), package), new AssetItem("asset13", new MyAsset13(), package), }; otherAssets.ForEach(x => package.Assets.Add(x)); var compileAssetReference = new MyAsset4 { CompileAssetReference = CreateRef <MyContent11>(otherAssets[0]), CompileContentReference = CreateRef <MyContent12>(otherAssets[1]), CompileRuntimeReference = CreateRef <MyContent13>(otherAssets[2]), }; var assetItem = new AssetItem("asset4", compileAssetReference, package); package.Assets.Add(assetItem); var asset = new MyAsset1 { CompileAssetReference = CreateRef <MyContent2>(assetItem) }; assetItem = new AssetItem("asset1", asset, package); package.Assets.Add(assetItem); package.RootAssets.Add(new AssetReference(assetItem.Id, assetItem.Location)); // Create context var context = new AssetCompilerContext { CompilationContext = typeof(AssetCompilationContext) }; // Builds the project Exception ex = null; MyAsset1Compiler.AssertFunc = (url, ass, pkg) => { AssertInThread(ref ex, () => Assert.AreEqual(1, TestCompilerBase.CompiledAssets.Count)); AssertInThread(ref ex, () => Assert.AreEqual(compileAssetReference.Id, TestCompilerBase.CompiledAssets.First().Id)); }; var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package)); var assetBuildResult = assetBuilder.Prepare(context); // Since MyAsset4 is a Runtime reference, it should be compiled, so we should have 2 asset (MyAsset1 and MyAsset4) to compile. Assert.AreEqual(2, assetBuildResult.BuildSteps.Count); var builder = new Builder(GlobalLogger.GetLogger("Test"), "", "", ""); builder.Root.Add(assetBuildResult.BuildSteps); builder.Run(Builder.Mode.Build, false); RethrowAssertsFromThread(ex); }
public void TestCompileAsset() { var package = new Package(); // ReSharper disable once UnusedVariable - we need a package session to compile var packageSession = new PackageSession(package); var otherAssets = new List <AssetItem> { new AssetItem("asset5", new MyAsset5(), package), new AssetItem("asset6", new MyAsset6(), package), new AssetItem("asset7", new MyAsset7(), package), }; otherAssets.ForEach(x => package.Assets.Add(x)); var compileAssetReference = new MyAsset2 { CompileAssetReference = CreateRef <MyContent5>(otherAssets[0]), CompileContentReference = CreateRef <MyContent6>(otherAssets[1]), CompileRuntimeReference = CreateRef <MyContent7>(otherAssets[2]), }; var assetItem = new AssetItem("asset2", compileAssetReference, package); package.Assets.Add(assetItem); var asset = new MyAsset1 { CompileAssetReference = CreateRef <MyContent2>(assetItem) }; assetItem = new AssetItem("asset1", asset, package); package.Assets.Add(assetItem); package.RootAssets.Add(new AssetReference(assetItem.Id, assetItem.Location)); // Create context var context = new AssetCompilerContext { CompilationContext = typeof(AssetCompilationContext) }; // Builds the project Exception ex = null; MyAsset1Compiler.AssertFunc = (url, ass, pkg) => { // Nothing must have been compiled before AssertInThread(ref ex, () => Assert.Empty(TestCompilerBase.CompiledAssets)); }; var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package)); var assetBuildResult = assetBuilder.Prepare(context); // Since MyAsset2 is a CompileAsset reference, it should not be compiled, so we should have only 1 asset (MyAsset1) to compile. Assert.Equal(1, assetBuildResult.BuildSteps.Count); var builder = new Builder(GlobalLogger.GetLogger("Test"), "", ""); builder.Root.Add(assetBuildResult.BuildSteps); builder.Run(Builder.Mode.Build, false); RethrowAssertsFromThread(ex); }
internal EventKeyBase(string category = "General", string eventName = "Event") { broadcastBlock = new BroadcastBlock <T>(null, new DataflowBlockOptions { TaskScheduler = EventTaskScheduler.Scheduler }); EventName = eventName; Logger = GlobalLogger.GetLogger($"Event - {category}"); broadcastDebug = $"Broadcasting '{eventName}' ({EventId})"; }
public GameAppServer() { _logger = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name); // Database file provider _services.AddService <IDatabaseFileProviderService>(new DatabaseFileProviderService(null)); _services.AddService(GameEngineServer.DefaultGraphicsDeviceService); // ContentManager requires a GraphicsDeviceService if graphical assets are loaded (eg. Textures) _services.AddService <IExitGameService>(this); }
/// <summary> /// Initializes a new instance of the <see cref="GraphViewModel"/> class. /// </summary> /// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="GraphViewModelService"/> to use for this view model.</param> private GraphViewModel(IViewModelServiceProvider serviceProvider) : base(serviceProvider) { GraphViewModelService = serviceProvider.TryGet <GraphViewModelService>(); if (GraphViewModelService == null) { throw new InvalidOperationException($"{nameof(GraphViewModel)} requires a {nameof(GraphViewModelService)} in the service provider."); } Logger = GlobalLogger.GetLogger(DefaultLoggerName); }
public Logger GetLogger(LogKey key, bool create = true) { Logger logger; if (!loggers.TryGetValue(key, out logger) && create) { logger = GlobalLogger.GetLogger(key.ToString()); loggers.Add(key, logger); } return(logger); }
/// <summary> /// Initializes a new instance of the <see cref="GameBase" /> class. /// </summary> protected GameBase() { // Internals Log = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name); updateTime = new GameTime(); drawTime = new GameTime(); playTimer = new TimerTick(); updateTimer = new TimerTick(); totalUpdateTime = new TimeSpan(); timer = new TimerTick(); IsFixedTimeStep = false; maximumElapsedTime = TimeSpan.FromMilliseconds(500.0); lastUpdateCount = new int[4]; nextLastUpdateCountIndex = 0; TargetElapsedTime = defaultTimeSpan; // default empty timespan, will be set on window create if not set elsewhere TreatNotFocusedLikeMinimized = true; DrawEvenMinimized = false; WindowMinimumUpdateRate = new ThreadThrottler(defaultTimeSpan); // will be set when window gets created with window's refresh rate MinimizedMinimumUpdateRate = new ThreadThrottler(TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 15)); // by default 15 updates per second while minimized // Calculate the updateCountAverageSlowLimit (assuming moving average is >=3 ) // Example for a moving average of 4: // updateCountAverageSlowLimit = (2 * 2 + (4 - 2)) / 4 = 1.5f const int BadUpdateCountTime = 2; // number of bad frame (a bad frame is a frame that has at least 2 updates) var maxLastCount = 2 * Math.Min(BadUpdateCountTime, lastUpdateCount.Length); updateCountAverageSlowLimit = (float)(maxLastCount + (lastUpdateCount.Length - maxLastCount)) / lastUpdateCount.Length; // Externals Services = new ServiceRegistry(true); // Database file provider Services.AddService <IDatabaseFileProviderService>(new DatabaseFileProviderService(null)); LaunchParameters = new LaunchParameters(); GameSystems = new GameSystemCollection(Services); Services.AddService <IGameSystemCollection>(GameSystems); // Create Platform gamePlatform = GamePlatform.Create(this); gamePlatform.Activated += GamePlatform_Activated; gamePlatform.Deactivated += GamePlatform_Deactivated; gamePlatform.Exiting += GamePlatform_Exiting; gamePlatform.WindowCreated += GamePlatformOnWindowCreated; // Setup registry Services.AddService <IGame>(this); Services.AddService <IGraphicsDeviceFactory>(gamePlatform); Services.AddService <IGamePlatform>(gamePlatform); IsActive = true; }
public static Builder CreateBuilder() { var logger = GlobalLogger.GetLogger("Builder"); logger.ActivateLog(LogMessageType.Debug); var builder = new Builder(BuildPath, "Windows", "index", "inputHashes", logger) { BuilderName = "TestBuilder", SlaveBuilderPath = @"SiliconStudio.BuildEngine.exe" }; return(builder); }
/// <summary> /// Initializes a new instance of the <see cref="GameBase" /> class. /// </summary> protected GameBase() { // Internals Log = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name); updateTime = new GameTime(); drawTime = new GameTime(); playTimer = new TimerTick(); updateTimer = new TimerTick(); totalUpdateTime = new TimeSpan(); timer = new TimerTick(); IsFixedTimeStep = false; maximumElapsedTime = TimeSpan.FromMilliseconds(500.0); TargetElapsedTime = TimeSpan.FromTicks(10000000 / 60); // target elapsed time is by default 60Hz lastUpdateCount = new int[4]; nextLastUpdateCountIndex = 0; // Calculate the updateCountAverageSlowLimit (assuming moving average is >=3 ) // Example for a moving average of 4: // updateCountAverageSlowLimit = (2 * 2 + (4 - 2)) / 4 = 1.5f const int BadUpdateCountTime = 2; // number of bad frame (a bad frame is a frame that has at least 2 updates) var maxLastCount = 2 * Math.Min(BadUpdateCountTime, lastUpdateCount.Length); updateCountAverageSlowLimit = (float)(maxLastCount + (lastUpdateCount.Length - maxLastCount)) / lastUpdateCount.Length; // Externals Services = new ServiceRegistry(); // Content manager Content = new ContentManager(Services); Services.AddService <IContentManager>(Content); Services.AddService(Content); LaunchParameters = new LaunchParameters(); GameSystems = new GameSystemCollection(Services); Services.AddService <IGameSystemCollection>(GameSystems); // Create Platform gamePlatform = GamePlatform.Create(this); gamePlatform.Activated += gamePlatform_Activated; gamePlatform.Deactivated += gamePlatform_Deactivated; gamePlatform.Exiting += gamePlatform_Exiting; gamePlatform.WindowCreated += GamePlatformOnWindowCreated; // Setup registry Services.AddService <IGame>(this); Services.AddService <IGraphicsDeviceFactory>(gamePlatform); Services.AddService <IGamePlatform>(gamePlatform); IsActive = true; }
/// <summary> /// Initializes a new instance of the <see cref="Game"/> class. /// </summary> public HeadlessGame() { // Internals Log = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name); UpdateTime = new GameTime(); autoTickTimer = new TimerTick(); IsFixedTimeStep = true; maximumElapsedTime = TimeSpan.FromMilliseconds(500.0); TargetElapsedTime = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 60); // target elapsed time is by default 60Hz // Externals Services = new ServiceRegistry(); GraphicsDevice = GraphicsDevice.New(DeviceCreationFlags.VideoSupport, new GraphicsProfile[] { GraphicsProfile.Level_11_0, GraphicsProfile.Level_11_1, GraphicsProfile.Level_11_2 }); Services.AddService <IGraphicsDeviceService>(new GraphicsDeviceServiceLocal(GraphicsDevice)); // Database file provider Services.AddService <IDatabaseFileProviderService>(new DatabaseFileProviderService(null)); GameSystems = new GameSystemCollection(Services); Services.AddService <IGameSystemCollection>(GameSystems); // Setup registry Services.AddService <IGame>(this); // Register the logger backend before anything else logListener = GetLogListener(); if (logListener != null) { GlobalLogger.GlobalMessageLogged += logListener; } // Create all core services, except Input which is created during `Initialize'. // Registration takes place in `Initialize'. Script = new ScriptSystem(Services); Services.AddService(Script); SceneSystem = new SceneSystem(Services); Services.AddService(SceneSystem); Streaming = new StreamingManager(Services); }
/// <summary> /// Initializes a new instance of the <see cref="ObservableViewModel"/> class. /// </summary> /// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="ObservableViewModelService"/> to use for this view model.</param> /// <param name="nodeContainer">A <see cref="NodeContainer"/> to use to build view model nodes.</param> /// <param name="dirtiables">The list of <see cref="IDirtiable"/> objects linked to this view model.</param> private ObservableViewModel(IViewModelServiceProvider serviceProvider, NodeContainer nodeContainer, IEnumerable <IDirtiable> dirtiables) : base(serviceProvider) { if (nodeContainer == null) { throw new ArgumentNullException(nameof(nodeContainer)); } if (dirtiables == null) { throw new ArgumentNullException(nameof(dirtiables)); } NodeContainer = nodeContainer; Dirtiables = dirtiables; ObservableViewModelService = serviceProvider.Get <ObservableViewModelService>(); Logger = GlobalLogger.GetLogger(DefaultLoggerName); }
/// <summary> /// Initializes a new instance of the <see cref="ObservableViewModel"/> class. /// </summary> /// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="ObservableViewModelService"/> to use for this view model.</param> /// <param name="modelContainer">A <see cref="ModelContainer"/> to use to build view model nodes.</param> /// <param name="dirtiables">The list of <see cref="IDirtiableViewModel"/> objects linked to this view model.</param> private ObservableViewModel(IViewModelServiceProvider serviceProvider, ModelContainer modelContainer, IEnumerable <IDirtiableViewModel> dirtiables) : base(serviceProvider) { if (modelContainer == null) { throw new ArgumentNullException("modelContainer"); } if (dirtiables == null) { throw new ArgumentNullException("dirtiables"); } this.modelContainer = modelContainer; this.dirtiables = dirtiables; this.dirtiables.ForEach(x => x.DirtinessUpdated += DirtinessUpdated); observableViewModelService = serviceProvider.Get <ObservableViewModelService>(); Logger = GlobalLogger.GetLogger(DefaultLoggerName); }
public SceneViewModel GetRoot() { var root = this; var hash = new HashSet <AssetId> { root.Id }; while (root.Parent != null) { if (!hash.Add(root.Parent.Id)) { GlobalLogger.GetLogger("Asset").Error($"Cyclic reference detected for scene {root.Name} (Id={root.Id})."); break; } root = root.Parent; } return(root); }
public int Run(string[] args) { clock = Stopwatch.StartNew(); // TODO: This is hardcoded. Check how to make this dynamic instead. RuntimeHelpers.RunModuleConstructor(typeof(IProceduralModel).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(MaterialKeys).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(SpriteFontAsset).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(ModelAsset).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(SpriteStudioAnimationAsset).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(ParticleSystem).Module.ModuleHandle); //var project = new Package(); //project.Save("test.sdpkg"); //Thread.Sleep(10000); //var spriteFontAsset = StaticFontAsset.New(); //Content.Save("test.sdfnt", spriteFontAsset); //project.Refresh(); //args = new string[] { "test.sdpkg", "-o:app_data", "-b:tmp", "-t:1" }; var exeName = Path.GetFileName(Assembly.GetExecutingAssembly().Location); var showHelp = false; var packMode = false; var updateGeneratedFilesMode = false; var buildEngineLogger = GlobalLogger.GetLogger("BuildEngine"); var options = new PackageBuilderOptions(new ForwardingLoggerResult(buildEngineLogger)); var p = new OptionSet { "Copyright (c) 2018-2021 Stride and its contributors (https://stride3d.net)", "Copyright (c) 2011-2018 Silicon Studio Corp. (https://www.siliconstudio.co.jp)", "Stride Package Build Tool - Version: " + Format("{0}.{1}.{2}", typeof(Program).Assembly.GetName().Version.Major, typeof(Program).Assembly.GetName().Version.Minor, typeof(Program).Assembly.GetName().Version.Build), Empty, Format("Usage: {0} inputPackageFile [options]* -b buildPath", exeName), Empty, "=== Options ===", Empty, { "h|help", "Show this message and exit", help => showHelp = help != null },
/// <summary> /// Initializes a new instance of the <see cref="GameBase" /> class. /// </summary> protected GameBase() { // Internals Log = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name); UpdateTime = new GameTime(); DrawTime = new GameTime(); autoTickTimer = new TimerTick(); IsFixedTimeStep = false; maximumElapsedTime = TimeSpan.FromMilliseconds(500.0); TargetElapsedTime = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 60); // target elapsed time is by default 60Hz TreatNotFocusedLikeMinimized = true; WindowMinimumUpdateRate = new ThreadThrottler(TimeSpan.FromSeconds(0d)); MinimizedMinimumUpdateRate = new ThreadThrottler(TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 15)); // by default 15 updates per second while minimized isMouseVisible = true; // Externals Services = new ServiceRegistry(); // Database file provider Services.AddService <IDatabaseFileProviderService>(new DatabaseFileProviderService(null)); LaunchParameters = new LaunchParameters(); GameSystems = new GameSystemCollection(Services); Services.AddService <IGameSystemCollection>(GameSystems); // Create Platform gamePlatform = GamePlatform.Create(this); gamePlatform.Activated += GamePlatform_Activated; gamePlatform.Deactivated += GamePlatform_Deactivated; gamePlatform.Exiting += GamePlatform_Exiting; gamePlatform.WindowCreated += GamePlatformOnWindowCreated; // Setup registry Services.AddService <IGame>(this); Services.AddService <IGraphicsDeviceFactory>(gamePlatform); Services.AddService <IGamePlatform>(gamePlatform); IsActive = true; }
public static async Task UnpackAPK() { // get the apk last update time var packageManager = PlatformAndroid.Context.PackageManager; var packageInfo = packageManager.GetPackageInfo(PlatformAndroid.Context.PackageName, PackageInfoFlags.Activities); var lastUpdateTime = packageInfo.LastUpdateTime; var sourceDir = PlatformAndroid.Context.ApplicationInfo.SourceDir; // evaluate if asset data should be extracted from apk file var shouldExtractAssets = true; if (ApplicationTemporary.FileExists(LastExtractedApkFileName)) { Int64 extractedLastUpdateTime = 0; using (var file = ApplicationTemporary.OpenStream(LastExtractedApkFileName, VirtualFileMode.Open, VirtualFileAccess.Read)) { var binaryReader = new BinarySerializationReader(file); binaryReader.Serialize(ref extractedLastUpdateTime, ArchiveMode.Deserialize); } shouldExtractAssets = extractedLastUpdateTime != lastUpdateTime; } // Copy assets if (shouldExtractAssets) { var assets = PlatformAndroid.Context.Assets; // Make sure assets exists var logger = GlobalLogger.GetLogger("VFS"); CopyFileOrDirectory(logger, sourceDir, "assets/data/", string.Empty); // update value of extracted last update time using (var stream = ApplicationTemporary.OpenStream(LastExtractedApkFileName, VirtualFileMode.Create, VirtualFileAccess.Write, VirtualFileShare.None)) { var binaryWriter = new BinarySerializationWriter(stream); binaryWriter.Write(lastUpdateTime); } } }
private static Process RunServiceProcessAndLog(string servicePath) { var process = ShellHelper.RunProcess(servicePath, string.Empty); // Create log and notify start var logModule = string.Format("{0}:{1}", Path.GetFileNameWithoutExtension(servicePath), process.Id); var logger = GlobalLogger.GetLogger(logModule); logger.Info("Process started"); process.OutputDataReceived += (_, args) => logger.Info(args.Data); process.ErrorDataReceived += (_, args) => logger.Error(args.Data); process.Exited += (_, args) => logger.Info("Process exited"); process.BeginOutputReadLine(); process.BeginErrorReadLine(); // Let's tie lifetime of spawned process to ours // TODO: Move that in a better namespace? (currently a shared file) new AttachedChildProcessJob(process); return(process); }
public GameStudioBuilderService(SessionViewModel sessionViewModel, GameSettingsProviderService settingsProvider, string buildDirectory, bool createDebugTools = true) : base(buildDirectory) { this.createDebugTools = createDebugTools; if (createDebugTools) { assetBuilderServiceDebugPage = EditorDebugTools.CreateLogDebugPage(GlobalLogger.GetLogger("AssetBuilderService"), "AssetBuilderService"); effectCompilerServiceDebugPage = EditorDebugTools.CreateLogDebugPage(GlobalLogger.GetLogger("EffectCompilerCache"), "EffectCompilerCache"); } SessionViewModel = sessionViewModel ?? throw new ArgumentNullException(nameof(sessionViewModel)); var shaderImporter = new StrideShaderImporter(); var shaderBuildSteps = shaderImporter.CreateSystemShaderBuildSteps(sessionViewModel); shaderBuildSteps.StepProcessed += ShaderBuildStepsStepProcessed; PushBuildUnit(new PrecompiledAssetBuildUnit(AssetBuildUnitIdentifier.Default, shaderBuildSteps, true)); Database = new GameStudioDatabase(this, settingsProvider); const string shaderBundleUrl = "/binary/editor/EditorShadersD3D11.bundle"; if (VirtualFileSystem.FileExists(shaderBundleUrl)) { Builder.ObjectDatabase.BundleBackend.LoadBundleFromUrl("EditorShadersD3D11", Builder.ObjectDatabase.ContentIndexMap, shaderBundleUrl, true).Wait(); } // Use a shared database for our shader system // TODO: Shaders compiled on main thread won't actually be visible to MicroThread build engine (contentIndexMap are separate). // It will still work and cache because EffectCompilerCache caches not only at the index map level, but also at the database level. // Later, we probably want to have a GetSharedDatabase() allowing us to mutate it (or merging our results back with IndexFileCommand.AddToSharedGroup()), // so that database created with MountDatabase also have all the newest shaders. taskScheduler = new EffectPriorityScheduler(ThreadPriority.BelowNormal, Math.Max(1, Environment.ProcessorCount / 2)); TaskSchedulerSelector taskSchedulerSelector = (mixinTree, compilerParameters) => taskScheduler.GetOrCreatePriorityGroup(compilerParameters?.TaskPriority ?? 0); effectCompiler = (EffectCompilerBase)EffectCompilerFactory.CreateEffectCompiler(MicrothreadLocalDatabases.GetSharedDatabase(), taskSchedulerSelector: taskSchedulerSelector); StartPushNotificationsTask(); }
private static StridePlatformOptions GetOptions() { try { var configuratorConstructor = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(a => a.GetCustomAttributes <AvaloniaConfiguratorAttribute>()) .Single().ConfiguratorType.GetTypeInfo().DeclaredConstructors .Where(c => c.GetParameters().Length == 0 && !c.IsStatic).Single(); var configuratorMethod = configuratorConstructor.DeclaringType.GetTypeInfo().DeclaredMethods .Single(m => m.GetParameters().Length == 0 && m.ReturnType == typeof(StridePlatformOptions)); var instance = configuratorConstructor.Invoke(Array.Empty <object>()); return((StridePlatformOptions)configuratorMethod.Invoke(instance, Array.Empty <object>())); } catch (InvalidOperationException) { var logger = GlobalLogger.GetLogger("Stridelonia"); logger.Debug("No Application configurator found"); return(null); } }
public AssetBuilderService([NotNull] string buildDirectory) { if (buildDirectory == null) { throw new ArgumentNullException(nameof(buildDirectory)); } // We want at least 2 threads, since one will be used for DynamicBuildStep (which is a special blocking step) var processorCount = Environment.ProcessorCount; var threadCount = MathUtil.Clamp(3 * processorCount / 4, 2, processorCount - 1); // Mount database (otherwise it will be mounted by DynamicBuilder thread, and it might happen too late) Builder.OpenObjectDatabase(buildDirectory, IndexName); var builderInstance = new Builder(GlobalLogger.GetLogger("AssetBuilderService"), buildDirectory, IndexName) { BuilderName = "AssetBuilderService Builder", ThreadCount = threadCount, }; builder = new DynamicBuilder(builderInstance, new AnonymousBuildStepProvider(GetNextBuildStep), "Asset Builder service thread."); builder.Start(); }
public static void Initialize(IGame game) { if (_isInitialize) { return; } if (game.GetType().Name.Contains("Editor")) { var logger = GlobalLogger.GetLogger("Stridelonia"); logger.Info("Stridelonia is disabled in GameStudio"); return; } if (Options == null) { return; } AvaloniaLocator.CurrentMutable.BindToSelf(game); var dispatcher = game.Services.GetService <StrideDispatcher>(); if (dispatcher == null) { dispatcher = new StrideDispatcher(game.Services); game.Services.AddService(dispatcher); game.GameSystems.Add(dispatcher); } if (Application.Current == null) { StartAvalonia(); } _isInitialize = true; }
private static void StartAvalonia() { if (Options.ConfigureApp == null || Options.ApplicationType == null) { var logger = GlobalLogger.GetLogger("Stridelonia"); logger.Debug("No Application in StridePlatformOptions"); return; } if (Options.UseMultiThreading) { _avaloniaThread = new Thread(AvaloniaThread) { Name = "Avalonia Thread" }; _avaloniaThread.Start(Options); _initedEvent.WaitOne(); _initedEvent.Dispose(); } else { CreateApplication(Options); } }
private EffectBytecodeCompilerResult CompileBytecode(ShaderMixinSource mixinTree, EffectCompilerParameters effectParameters, CompilerParameters compilerParameters, ObjectId mixinObjectId, DatabaseFileProvider database, string compiledUrl) { // Open the database for writing var log = new LoggerResult(); var effectLog = GlobalLogger.GetLogger("EffectCompilerCache"); if (CompileSynchronization.IsSet) { CompileSynchronization.Reset(1); } else { CompileSynchronization.AddCount(); } // Note: this compiler is expected to not be async and directly write stuff in localLogger var compiledShader = base.Compile(mixinTree, effectParameters, compilerParameters).WaitForResult(); compiledShader.CompilationLog.CopyTo(log); // If there are any errors, return immediately if (log.HasErrors) { lock (compilingShaders) { compilingShaders.Remove(mixinObjectId); } log.CopyTo(effectLog); return(new EffectBytecodeCompilerResult(null, log)); } // Compute the bytecodeId var newBytecodeId = compiledShader.Bytecode.ComputeId(); // Check if we really need to store the bytecode lock (bytecodes) { // Using custom serialization to the database to store an object with a custom id // TODO: Check if we really need to write the bytecode everytime even if id is not changed var memoryStream = new MemoryStream(); compiledShader.Bytecode.WriteTo(memoryStream); // Write current cache at the end (not part of the pure bytecode, but we use this as meta info) var writer = new BinarySerializationWriter(memoryStream); writer.Write(CurrentCache); memoryStream.Position = 0; database.ObjectDatabase.Write(memoryStream, newBytecodeId, true); database.ContentIndexMap[compiledUrl] = newBytecodeId; // Save bytecode Id to the database cache as well memoryStream.SetLength(0); memoryStream.Write((byte[])newBytecodeId, 0, ObjectId.HashSize); memoryStream.Position = 0; database.ObjectDatabase.Write(memoryStream, mixinObjectId, true); if (!bytecodes.ContainsKey(newBytecodeId)) { log.Verbose($"New effect compiled #{effectCompileCount} [{mixinObjectId}] (db: {newBytecodeId})\r\n{compilerParameters?.ToStringPermutationsDetailed()}"); Interlocked.Increment(ref effectCompileCount); // Replace or add new bytecode bytecodes[newBytecodeId] = new KeyValuePair <EffectBytecode, EffectBytecodeCacheLoadSource>(compiledShader.Bytecode, EffectBytecodeCacheLoadSource.JustCompiled); } } CompileSynchronization.Signal(); lock (compilingShaders) { compilingShaders.Remove(mixinObjectId); } log.CopyTo(effectLog); return(compiledShader); }