/// <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;
}
}
}
