public static IEffectCompiler CreateEffectCompiler( IVirtualFileProvider fileProvider, EffectSystem effectSystem = null, string packageName = null, EffectCompilationMode effectCompilationMode = EffectCompilationMode.Local, bool recordEffectRequested = false, TaskSchedulerSelector taskSchedulerSelector = null, DatabaseFileProvider database = null) { EffectCompilerBase compiler = null; if ((effectCompilationMode & EffectCompilationMode.Local) != 0) { // Local allowed and available, let's use that compiler = new EffectCompiler(fileProvider) { SourceDirectories = { EffectCompilerBase.DefaultSourceShaderFolder }, }; } // Select database - needed for caching var selectedDatabase = database ?? fileProvider as DatabaseFileProvider; // Nothing to do remotely bool needRemoteCompiler = (compiler == null && (effectCompilationMode & EffectCompilationMode.Remote) != 0); if (needRemoteCompiler || recordEffectRequested) { // Create the object that handles the connection var shaderCompilerTarget = new RemoteEffectCompilerClient(packageName); if (recordEffectRequested) { // Let's notify effect compiler server for each new effect requested effectSystem.EffectUsed += shaderCompilerTarget.NotifyEffectUsed; } // Use remote only if nothing else was found before (i.e. a local compiler) if (needRemoteCompiler) { // Create a remote compiler compiler = new RemoteEffectCompiler(fileProvider, selectedDatabase, shaderCompilerTarget); } else { // Otherwise, EffectSystem takes ownership of shaderCompilerTarget shaderCompilerTarget.DisposeBy(effectSystem); } } // Local not possible or allowed, and remote not allowed either => switch back to null compiler if (compiler == null) { compiler = new NullEffectCompiler(fileProvider, selectedDatabase); } return(new EffectCompilerCache(compiler, selectedDatabase, taskSchedulerSelector)); }
public static IEffectCompiler CreateEffectCompiler(TaskSchedulerSelector taskSchedulerSelector = null) { // Create compiler #if SILICONSTUDIO_PARADOX_EFFECT_COMPILER var effectCompiler = new Shaders.Compiler.EffectCompiler(); effectCompiler.SourceDirectories.Add(EffectCompilerBase.DefaultSourceShaderFolder); #else var effectCompiler = new NullEffectCompiler(); #endif return(new EffectCompilerCache(effectCompiler, taskSchedulerSelector)); }
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(); }
public EffectCompilerCache(EffectCompilerBase compiler, TaskSchedulerSelector taskSchedulerSelector = null) : base(compiler) { CompileEffectAsynchronously = true; this.taskSchedulerSelector = taskSchedulerSelector; }
internal static IEffectCompiler CreateEffectCompiler(EffectSystem effectSystem, Guid?packageId, EffectCompilationMode effectCompilationMode, bool recordEffectRequested, TaskSchedulerSelector taskSchedulerSelector = null) { EffectCompilerBase compiler = null; #if SILICONSTUDIO_XENKO_EFFECT_COMPILER if ((effectCompilationMode & EffectCompilationMode.Local) != 0) { // Local allowed and available, let's use that compiler = new EffectCompiler { SourceDirectories = { EffectCompilerBase.DefaultSourceShaderFolder }, }; } #endif // Nothing to do remotely bool needRemoteCompiler = (compiler == null && (effectCompilationMode & EffectCompilationMode.Remote) != 0); if (needRemoteCompiler || recordEffectRequested) { // Create the object that handles the connection var shaderCompilerTarget = new RemoteEffectCompilerClient(packageId); if (recordEffectRequested) { // Let's notify effect compiler server for each new effect requested effectSystem.EffectUsed += shaderCompilerTarget.NotifyEffectUsed; } // Use remote only if nothing else was found before (i.e. a local compiler) if (needRemoteCompiler) { // Create a remote compiler compiler = new RemoteEffectCompiler(shaderCompilerTarget); } } // Local not possible or allowed, and remote not allowed either => switch back to null compiler if (compiler == null) { compiler = new NullEffectCompiler(); } return(new EffectCompilerCache(compiler, taskSchedulerSelector)); }
/// <summary> /// Creates an effect compiler, with either specificed <see cref="effectCompiler"/> or default one, wrapped in an <see cref="EffectCompilerCache"/>. /// </summary> /// <param name="effectCompiler">The effect compiler.</param> /// <param name="taskSchedulerSelector">The task scheduler selector.</param> /// <returns></returns> public static IEffectCompiler CreateEffectCompiler(TaskSchedulerSelector taskSchedulerSelector = null) { return(CreateEffectCompiler(null, null, EffectCompilationMode.Local, false, taskSchedulerSelector)); }
internal static IEffectCompiler CreateEffectCompiler(EffectSystem effectSystem, Guid? packageId, EffectCompilationMode effectCompilationMode, bool recordEffectRequested, TaskSchedulerSelector taskSchedulerSelector = null) { EffectCompilerBase compiler = null; #if SILICONSTUDIO_XENKO_EFFECT_COMPILER if ((effectCompilationMode & EffectCompilationMode.Local) != 0) { // Local allowed and available, let's use that compiler = new EffectCompiler { SourceDirectories = { EffectCompilerBase.DefaultSourceShaderFolder }, }; } #endif // Nothing to do remotely bool needRemoteCompiler = (compiler == null && (effectCompilationMode & EffectCompilationMode.Remote) != 0); if (needRemoteCompiler || recordEffectRequested) { // Create the object that handles the connection var shaderCompilerTarget = new RemoteEffectCompilerClient(packageId); if (recordEffectRequested) { // Let's notify effect compiler server for each new effect requested effectSystem.EffectUsed += shaderCompilerTarget.NotifyEffectUsed; } // Use remote only if nothing else was found before (i.e. a local compiler) if (needRemoteCompiler) { // Create a remote compiler compiler = new RemoteEffectCompiler(shaderCompilerTarget); } } // Local not possible or allowed, and remote not allowed either => switch back to null compiler if (compiler == null) { compiler = new NullEffectCompiler(); } return new EffectCompilerCache(compiler, taskSchedulerSelector); }
/// <summary> /// Creates an effect compiler, with either specificed <see cref="effectCompiler"/> or default one, wrapped in an <see cref="EffectCompilerCache"/>. /// </summary> /// <param name="effectCompiler">The effect compiler.</param> /// <param name="taskSchedulerSelector">The task scheduler selector.</param> /// <returns></returns> public static IEffectCompiler CreateEffectCompiler(TaskSchedulerSelector taskSchedulerSelector = null) { return CreateEffectCompiler(null, null, EffectCompilationMode.Local, false, taskSchedulerSelector); }
public static IEffectCompiler CreateEffectCompiler(IVirtualFileProvider fileProvider, EffectSystem effectSystem = null, string packageName = null, EffectCompilationMode effectCompilationMode = EffectCompilationMode.Local, TaskSchedulerSelector taskSchedulerSelector = null) { EffectCompilerBase compiler = null; #if XENKO_EFFECT_COMPILER if ((effectCompilationMode & EffectCompilationMode.Local) != 0) { // Local allowed and available, let's use that compiler = new EffectCompiler(fileProvider) { SourceDirectories = { EffectCompilerBase.DefaultSourceShaderFolder }, }; } #endif // Local not possible or allowed, and remote not allowed either => switch back to null compiler if (compiler == null) { compiler = new NullEffectCompiler(fileProvider); } return(new EffectCompilerCache(compiler, taskSchedulerSelector)); }
public EffectCompilerCache(EffectCompilerBase compiler, DatabaseFileProvider database, TaskSchedulerSelector taskSchedulerSelector = null) : base(compiler) { CompileEffectAsynchronously = true; this.database = database ?? throw new ArgumentNullException(nameof(database), "Using the cache requires a database."); this.taskSchedulerSelector = taskSchedulerSelector; }