/// <summary> /// create the context for each composition by cloning their dependencies /// </summary> /// <param name="shaderSource">the entry ShaderSource (root)</param> /// <param name="dictionary">the ouputed compositions</param> /// <param name="compilationContext">the compilation context</param> /// <param name="cloneContext">The clone context.</param> /// <returns>a list of all the needed mixins</returns> private static List <ModuleMixin> BuildCompositionsDictionary(ShaderSource shaderSource, CompositionDictionary dictionary, ShaderCompilationContext compilationContext, CloneContext cloneContext, LoggerResult log) { if (shaderSource is ShaderMixinSource) { var shaderMixinSource = shaderSource as ShaderMixinSource; var finalModule = compilationContext.GetModuleMixinFromShaderSource(shaderSource); //PerformanceLogger.Start(PerformanceStage.DeepClone); finalModule = finalModule.DeepClone(new CloneContext(cloneContext)); //PerformanceLogger.Pause(PerformanceStage.DeepClone); foreach (var composition in shaderMixinSource.Compositions) { //look for the key var foundVars = finalModule.FindAllVariablesByName(composition.Key).Where(value => value.Variable.Qualifiers.Contains(StrideStorageQualifier.Compose)).ToList(); if (foundVars.Count > 1) { log.Error(StrideMessageCode.ErrorAmbiguousComposition, new SourceSpan(), composition.Key); } else if (foundVars.Count > 0) { Variable foundVar = foundVars[0].Variable; var moduleMixins = BuildCompositionsDictionary(composition.Value, dictionary, compilationContext, cloneContext, log); if (moduleMixins == null) { return(null); } dictionary.Add(foundVar, moduleMixins); } else { // No matching variable was found // TODO: log a message? } } return(new List <ModuleMixin> { finalModule }); } if (shaderSource is ShaderClassCode) { var finalModule = compilationContext.GetModuleMixinFromShaderSource(shaderSource); //PerformanceLogger.Start(PerformanceStage.DeepClone); finalModule = finalModule.DeepClone(new CloneContext(cloneContext)); //PerformanceLogger.Pause(PerformanceStage.DeepClone); return(new List <ModuleMixin> { finalModule }); } if (shaderSource is ShaderArraySource) { var shaderArraySource = shaderSource as ShaderArraySource; var compositionArray = new List <ModuleMixin>(); foreach (var shader in shaderArraySource.Values) { var mixin = BuildCompositionsDictionary(shader, dictionary, compilationContext, cloneContext, log); if (mixin == null) { return(null); } compositionArray.AddRange(mixin); } return(compositionArray); } return(null); }
/// <summary> /// Mixes shader parts to produces a single HLSL file shader. /// </summary> /// <param name="shaderMixinSource">The shader source.</param> /// <param name="macros">The shader perprocessor macros.</param> /// <param name="modifiedShaders">The list of modified shaders.</param> /// <returns>The combined shader in AST form.</returns> public ShaderMixinParsingResult Parse(ShaderMixinSource shaderMixinSource, Stride.Shaders.ShaderMacro[] macros = null) { // Make in-memory shader classes known to the source manager foreach (var x in shaderMixinSource.Mixins.OfType <ShaderClassString>()) { SourceManager.AddShaderSource(x.ClassName, x.ShaderSourceCode, x.ClassName); } // Creates a parsing result HashSet <ModuleMixinInfo> mixinsToAnalyze; ShaderMixinParsingResult parsingResult; var context = ParseAndAnalyze(shaderMixinSource, macros, out parsingResult, out mixinsToAnalyze); // Return directly if there was any errors if (parsingResult.HasErrors) { return(parsingResult); } // Update the clone context in case new instances of classes are created CloneContext mixCloneContext; lock (hlslCloneContextLock) { if (hlslCloneContext == null) { hlslCloneContext = new CloneContext(); // Create the clone context with the instances of Hlsl classes HlslSemanticAnalysis.FillCloneContext(hlslCloneContext); } HlslSemanticAnalysis.UpdateCloneContext(hlslCloneContext); mixCloneContext = new CloneContext(hlslCloneContext); } // only clone once the stage classes foreach (var mixinInfo in mixinsToAnalyze) { foreach (var mixin in mixinInfo.Mixin.MinimalContext.Where(x => x.StageOnlyClass)) { mixin.DeepClone(mixCloneContext); } } // ---------------------------------------------------------- // Perform Shader Mixer // ---------------------------------------------------------- var externDict = new CompositionDictionary(); var finalModuleList = BuildCompositionsDictionary(shaderMixinSource, externDict, context, mixCloneContext, parsingResult); //PerformanceLogger.Stop(PerformanceStage.DeepClone); if (parsingResult.HasErrors) { return(parsingResult); } // look for stage compositions and add the links between variables and compositions when necessary var extraExternDict = new Dictionary <Variable, List <ModuleMixin> >(); foreach (var item in externDict) { if (item.Key.Qualifiers.Contains(StrideStorageQualifier.Stage)) { FullLinkStageCompositions(item.Key, item.Value, externDict, extraExternDict, parsingResult); } } foreach (var item in extraExternDict) { externDict.Add(item.Key, item.Value); } var mixinDictionary = BuildMixinDictionary(finalModuleList); if (finalModuleList != null) { var finalModule = finalModuleList[0]; //PerformanceLogger.Start(PerformanceStage.Mix); parsingResult.Reflection = new EffectReflection(); var mixer = new StrideShaderMixer(finalModule, parsingResult, mixinDictionary, externDict, new CloneContext(mixCloneContext)); mixer.Mix(); //PerformanceLogger.Stop(PerformanceStage.Mix); // Return directly if there was any errors if (parsingResult.HasErrors) { return(parsingResult); } var finalShader = mixer.GetMixedShader(); // Simplifies the shader by removing dead code var simplifier = new ExpressionSimplifierVisitor(); simplifier.Run(finalShader); var sdShaderLinker = new ShaderLinker(parsingResult); sdShaderLinker.Run(finalShader); // Return directly if there was any errors if (parsingResult.HasErrors) { return(parsingResult); } // Find all entry points // TODO: make this configurable by CompileParameters foreach (var stage in new[] { ShaderStage.Compute, ShaderStage.Vertex, ShaderStage.Hull, ShaderStage.Domain, ShaderStage.Geometry, ShaderStage.Pixel }) { var entryPoint = finalShader.Declarations.OfType <MethodDefinition>().FirstOrDefault(f => f.Attributes.OfType <AttributeDeclaration>().Any(a => a.Name == "EntryPoint" && (string)a.Parameters[0].Value == stage.ToString())); if (entryPoint == null) { continue; } parsingResult.EntryPoints[stage] = entryPoint.Name.Text; // When this is a compute shader, there is no need to scan other stages if (stage == ShaderStage.Compute) { break; } } var typeCleaner = new StrideShaderCleaner(); typeCleaner.Run(finalShader); //PerformanceLogger.Stop(PerformanceStage.Global); //PerformanceLogger.PrintLastResult(); //SemanticPerformance.PrintResult(); //MixPerformance.PrintResult(); //GenerateShaderPerformance.PrintResult(); //StreamCreatorPerformance.PrintResult(); //ShaderLoader.PrintTime(); //PerformanceLogger.WriteOut(52); parsingResult.Shader = finalShader; } return(parsingResult); }
/// <summary> /// Mixes shader parts to produces a single HLSL file shader. /// </summary> /// <param name="shaderMixinSource">The shader source.</param> /// <param name="macros">The shader perprocessor macros.</param> /// <param name="modifiedShaders">The list of modified shaders.</param> /// <returns>The combined shader in AST form.</returns> public ShaderMixinParsingResult Parse(ShaderMixinSource shaderMixinSource, Paradox.Shaders.ShaderMacro[] macros = null) { // Creates a parsing result HashSet<ModuleMixinInfo> mixinsToAnalyze; ShaderMixinParsingResult parsingResult; var context = ParseAndAnalyze(shaderMixinSource, macros, out parsingResult, out mixinsToAnalyze); // Return directly if there was any errors if (parsingResult.HasErrors) return parsingResult; // Update the clone context in case new instances of classes are created lock (hlslCloneContext) { HlslSemanticAnalysis.UpdateCloneContext(hlslCloneContext); } // only clone once the stage classes var mixCloneContext = new CloneContext(hlslCloneContext); foreach (var mixinInfo in mixinsToAnalyze) { foreach (var mixin in mixinInfo.Mixin.MinimalContext.Where(x => x.StageOnlyClass)) { mixin.DeepClone(mixCloneContext); } } // ---------------------------------------------------------- // Perform Shader Mixer // ---------------------------------------------------------- var externDict = new CompositionDictionary(); var finalModuleList = BuildCompositionsDictionary(shaderMixinSource, externDict, context, mixCloneContext, parsingResult); //PerformanceLogger.Stop(PerformanceStage.DeepClone); if (parsingResult.HasErrors) return parsingResult; // look for stage compositions and add the links between variables and compositions when necessary var extraExternDict = new Dictionary<Variable, List<ModuleMixin>>(); foreach (var item in externDict) { if (item.Key.Qualifiers.Contains(ParadoxStorageQualifier.Stage)) FullLinkStageCompositions(item.Key, item.Value, externDict, extraExternDict, parsingResult); } foreach (var item in extraExternDict) externDict.Add(item.Key, item.Value); var mixinDictionary = BuildMixinDictionary(finalModuleList); if (finalModuleList != null) { var finalModule = finalModuleList[0]; //PerformanceLogger.Start(PerformanceStage.Mix); var mixer = new ParadoxShaderMixer(finalModule, parsingResult, mixinDictionary, externDict, new CloneContext(mixCloneContext)); mixer.Mix(); //PerformanceLogger.Stop(PerformanceStage.Mix); // Return directly if there was any errors if (parsingResult.HasErrors) return parsingResult; var finalShader = mixer.GetMixedShader(); // Simplifies the shader by removing dead code var simplifier = new ExpressionSimplifierVisitor(); simplifier.Run(finalShader); parsingResult.Reflection = new EffectReflection(); var pdxShaderLinker = new ShaderLinker(parsingResult); pdxShaderLinker.Run(finalShader); // Return directly if there was any errors if (parsingResult.HasErrors) return parsingResult; // Find all entry points // TODO: make this configurable by CompileParameters foreach (var stage in new[] {ShaderStage.Compute, ShaderStage.Vertex, ShaderStage.Hull, ShaderStage.Domain, ShaderStage.Geometry, ShaderStage.Pixel}) { var entryPoint = finalShader.Declarations.OfType<MethodDefinition>().FirstOrDefault(f => f.Attributes.OfType<AttributeDeclaration>().Any(a => a.Name == "EntryPoint" && (string)a.Parameters[0].Value == stage.ToString())); if (entryPoint == null) { continue; } parsingResult.EntryPoints[stage] = entryPoint.Name.Text; // When this is a compute shader, there is no need to scan other stages if (stage == ShaderStage.Compute) break; } var typeCleaner = new ParadoxShaderCleaner(); typeCleaner.Run(finalShader); //PerformanceLogger.Stop(PerformanceStage.Global); //PerformanceLogger.PrintLastResult(); //SemanticPerformance.PrintResult(); //MixPerformance.PrintResult(); //GenerateShaderPerformance.PrintResult(); //StreamCreatorPerformance.PrintResult(); //ShaderLoader.PrintTime(); //PerformanceLogger.WriteOut(52); parsingResult.Shader = finalShader; } return parsingResult; }
/// <summary> /// create the context for each composition by cloning their dependencies /// </summary> /// <param name="shaderSource">the entry ShaderSource (root)</param> /// <param name="dictionary">the ouputed compositions</param> /// <param name="compilationContext">the compilation context</param> /// <param name="cloneContext">The clone context.</param> /// <returns>a list of all the needed mixins</returns> private static List<ModuleMixin> BuildCompositionsDictionary(ShaderSource shaderSource, CompositionDictionary dictionary, ShaderCompilationContext compilationContext, CloneContext cloneContext, LoggerResult log) { if (shaderSource is ShaderMixinSource) { var shaderMixinSource = shaderSource as ShaderMixinSource; var finalModule = compilationContext.GetModuleMixinFromShaderSource(shaderSource); //PerformanceLogger.Start(PerformanceStage.DeepClone); finalModule = finalModule.DeepClone(new CloneContext(cloneContext)); //PerformanceLogger.Pause(PerformanceStage.DeepClone); foreach (var composition in shaderMixinSource.Compositions) { //look for the key var foundVars = finalModule.FindAllVariablesByName(composition.Key).Where(value => value.Variable.Qualifiers.Contains(ParadoxStorageQualifier.Compose)).ToList(); if (foundVars.Count > 1) { log.Error(ParadoxMessageCode.ErrorAmbiguousComposition, new SourceSpan(), composition.Key); } else if (foundVars.Count > 0) { Variable foundVar = foundVars[0].Variable; var moduleMixins = BuildCompositionsDictionary(composition.Value, dictionary, compilationContext, cloneContext, log); if (moduleMixins == null) return null; dictionary.Add(foundVar, moduleMixins); } else { // No matching variable was found // TODO: log a message? } } return new List<ModuleMixin> { finalModule }; } if (shaderSource is ShaderClassSource) { var finalModule = compilationContext.GetModuleMixinFromShaderSource(shaderSource); //PerformanceLogger.Start(PerformanceStage.DeepClone); finalModule = finalModule.DeepClone(new CloneContext(cloneContext)); //PerformanceLogger.Pause(PerformanceStage.DeepClone); return new List<ModuleMixin> { finalModule }; } if (shaderSource is ShaderArraySource) { var shaderArraySource = shaderSource as ShaderArraySource; var compositionArray = new List<ModuleMixin>(); foreach (var shader in shaderArraySource.Values) { var mixin = BuildCompositionsDictionary(shader, dictionary, compilationContext, cloneContext, log); if (mixin == null) return null; compositionArray.AddRange(mixin); } return compositionArray; } return null; }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { CheckInitialize(property, label); position.height = (Height.HasValue ? Height.Value : 17f); var foldoutRect = position; foldoutRect.width -= 2 * kButtonWidth; EditorGUI.BeginChangeCheck(); _Foldout = EditorGUI.Foldout(foldoutRect, _Foldout, label, true); if (EditorGUI.EndChangeCheck()) { EditorPrefs.SetBool(label.text, _Foldout); } var buttonRect = position; buttonRect.x = position.width - kButtonWidth + position.x; buttonRect.width = kButtonWidth + 2; if (GUI.Button(buttonRect, new GUIContent("+", "Add item"), EditorStyles.miniButton)) { AddNewItem(); } buttonRect.x -= kButtonWidth; if (GUI.Button(buttonRect, new GUIContent("x", "Clear dictionary"), EditorStyles.miniButtonRight)) { ClearDictionary(); } if (!_Foldout) { return; } foreach (var item in _Dictionary) { var key = item.Key; var value = item.Value; position.y += (Height.HasValue ? Height.Value : 17f); var keyRect = position; if (KeyWidth.HasValue) { keyRect.width = KeyWidth.Value; } else { keyRect.width /= 2; keyRect.width -= 4; } EditorGUI.BeginChangeCheck(); var newKey = DoField(keyRect, typeof(TK), key); if (EditorGUI.EndChangeCheck()) { try { _Dictionary.Remove(key); _Dictionary.Add(newKey, value); } catch (Exception e) { Debug.Log(e.Message); } break; } var valueRect = position; valueRect.x = keyRect.width + 15; valueRect.width = position.width - (keyRect.width + 15); EditorGUI.BeginChangeCheck(); value = DoField(valueRect, typeof(TV), value); if (EditorGUI.EndChangeCheck()) { _Dictionary[key] = value; break; } var removeRect = valueRect; removeRect.x = valueRect.xMax + 2; removeRect.width = kButtonWidth; if (GUI.Button(removeRect, new GUIContent("x", "Remove item"), EditorStyles.miniButtonRight)) { RemoveItem(key); break; } } }