public void Run(ShaderClassType shaderClassType)
{
Visit(shaderClassType);
}
public static void Instantiate(ShaderClassType classType, Dictionary <string, Expression> expressions, Dictionary <string, Identifier> identifiers, bool autoGenericInstances, LoggerResult log)
{
var instantiator = new ParadoxClassInstantiator(classType, expressions, identifiers, autoGenericInstances, log);
instantiator.Run();
}
public override void Visit(ShaderClassType shaderClassType)
{
// Check if there are any parameter keys in ShaderClassType and ConstantBuffer
CheckParameterKeys(shaderClassType.Members.OfType <Variable>());
CheckParameterKeys(shaderClassType.Members.OfType <ConstantBuffer>().SelectMany(cbuffer => cbuffer.Members).OfType <Variable>());
}
private static string GenerateGenericClassName(ShaderClassType shaderClassType)
{
// Generate class name
return(shaderClassType.Name.Text + (shaderClassType.GenericParameters == null ? string.Empty : "_" + string.Join("_", shaderClassType.GenericParameters.Select(x => x.ToString().Replace('.', '_')))));
}
public MethodDeclarationShaderCouple(MethodDeclaration method, ShaderClassType shader)
{
Method = method;
Shader = shader;
}
public VariableShaderCouple(Variable variable, ShaderClassType shader)
{
Variable = variable;
Shader = shader;
}
public void Run(ShaderClassType shaderClassType)
{
shaderName = shaderClassType.Name.Text;
Visit(shaderClassType);
}
/// <summary>
/// Load the shader and extract the information.
/// </summary>
public static void PrepareNode <T>(this ComputeShaderClassBase <T> _this, ConcurrentDictionary <string, string> projectShaders) where T : class, IComputeNode
{
// TODO: merge common keys between the previous dictionaries and the new one
_this.Generics.Clear();
_this.CompositionNodes.Clear();
if (string.IsNullOrEmpty(_this.MixinReference))
{
return;
}
var newGenerics = new ComputeColorParameters();
var newCompositionNodes = new Dictionary <string, T>();
var newMembers = new Dictionary <ParameterKey, object>();
var localMixinName = _this.MixinReference;
ShaderClassType shader = null;
string source;
if (projectShaders.TryGetValue(localMixinName, out source))
{
var logger = new LoggerResult();
try
{
shader = ShaderLoader.ParseSource(source, logger);
if (logger.HasErrors)
{
logger.Messages.Clear();
return;
}
}
catch
{
// TODO: output messages
return;
}
}
if (shader == null)
{
return;
}
var acceptLinkedVariable = true;
foreach (var generic in shader.ShaderGenerics)
{
if (generic.Type.Name.Text == "float4")
{
_this.AddKey <Vector4>(generic.Name.Text, newGenerics);
}
else if (generic.Type.Name.Text == "float3")
{
_this.AddKey <Vector3>(generic.Name.Text, newGenerics);
}
else if (generic.Type.Name.Text == "float2")
{
_this.AddKey <Vector2>(generic.Name.Text, newGenerics);
}
else if (generic.Type.Name.Text == "float")
{
_this.AddKey <float>(generic.Name.Text, newGenerics);
}
else if (generic.Type.Name.Text == "int")
{
_this.AddKey <int>(generic.Name.Text, newGenerics);
}
else if (generic.Type.Name.Text == "Texture2D")
{
_this.AddKey <Graphics.Texture>(generic.Name.Text, newGenerics);
}
else if (generic.Type.Name.Text == "SamplerState")
{
_this.AddKey <SamplerState>(generic.Name.Text, newGenerics);
}
else
{
_this.AddKey <string>(generic.Name.Text, newGenerics);
}
if (generic.Type is LinkType)
{
acceptLinkedVariable = false; // since the behavior is unpredictable, safely prevent addition of linked variable (= with Link annotation)
}
}
foreach (var member in shader.Members.OfType <Variable>())
{
// TODO: enough detect compositions?
if (member.Type is TypeName && (member.Type.TypeInference == null || member.Type.TypeInference.TargetType == null))
{
// ComputeColor only
if (member.Type.Name.Text == "ComputeColor")
{
if (_this.CompositionNodes.ContainsKey(member.Name.Text))
{
newCompositionNodes.Add(member.Name.Text, _this.CompositionNodes[member.Name.Text]);
}
else
{
newCompositionNodes.Add(member.Name.Text, null);
}
}
}
else
{
var isColor = false;
string linkName = null;
var isStage = member.Qualifiers.Contains(ParadoxStorageQualifier.Stage);
var isStream = member.Qualifiers.Contains(ParadoxStorageQualifier.Stream);
foreach (var annotation in member.Attributes.OfType <SiliconStudio.Shaders.Ast.Hlsl.AttributeDeclaration>())
{
if (annotation.Name == "Color")
{
isColor = true;
}
if (acceptLinkedVariable && annotation.Name == "Link" && annotation.Parameters.Count > 0)
{
linkName = (string)annotation.Parameters[0].Value;
}
}
if (!isStream && (isStage || !string.IsNullOrEmpty(linkName)))
{
if (linkName == null)
{
linkName = localMixinName + "." + member.Name.Text;
}
var memberType = member.Type.ResolveType();
if (isColor)
{
_this.AddMember <Color4>(linkName, newMembers);
}
else if (memberType == ScalarType.Float || memberType == ScalarType.Half)
{
_this.AddMember <float>(linkName, newMembers);
}
else if (memberType == ScalarType.Double)
{
_this.AddMember <double>(linkName, newMembers);
}
else if (memberType == ScalarType.Int)
{
_this.AddMember <int>(linkName, newMembers);
}
else if (memberType == ScalarType.UInt)
{
_this.AddMember <uint>(linkName, newMembers);
}
else if (memberType == ScalarType.Bool)
{
_this.AddMember <bool>(linkName, newMembers);
}
else if (memberType is VectorType)
{
switch (((VectorType)memberType).Dimension)
{
case 2:
_this.AddMember <Vector2>(linkName, newMembers);
break;
case 3:
_this.AddMember <Vector3>(linkName, newMembers);
break;
case 4:
_this.AddMember <Vector4>(linkName, newMembers);
break;
}
}
else if (member.Type.Name.Text == "Texture2D")
{
_this.AddMember <Graphics.Texture>(linkName, newMembers);
}
else if (member.Type.Name.Text == "SamplerState")
{
_this.AddMember <Graphics.SamplerState>(linkName, newMembers);
}
}
}
}
_this.Generics = newGenerics;
_this.CompositionNodes = newCompositionNodes;
_this.Members = newMembers;
}
internal static ShaderKeyClass GenerateShaderKeyClass(ShaderClassType shaderClassType)
{
ShaderKeyClass shaderKeyClass = null;
// Iterate over variables
foreach (var decl in shaderClassType.Members.OfType <Variable>())
{
if (decl.Qualifiers.Contains(SiliconStudio.Shaders.Ast.Hlsl.StorageQualifier.Extern) ||
decl.Qualifiers.Contains(SiliconStudio.Shaders.Ast.Hlsl.StorageQualifier.Const) ||
decl.Qualifiers.Contains(ParadoxStorageQualifier.Stream))
{
continue;
}
try
{
if (decl.Attributes.OfType <AttributeDeclaration>().Any(x => x.Name == "RenameLink"))
{
continue;
}
ShaderKeyVariable variable = null;
var type = decl.Type.ResolveType();
bool isArray = type is ArrayType;
bool processInitialValue = false;
bool isColor = decl.Attributes.OfType <AttributeDeclaration>().Any(x => x.Name == "Color");
if (isArray)
{
type = ((ArrayType)type).Type.ResolveType();
}
if (type is ScalarType)
{
processInitialValue = true;
variable = new ShaderKeyVariable(decl.Name, ((ScalarType)type).Type.FullName,
ShaderKeyVariableCategory.Value);
}
else if (type is VectorType)
{
processInitialValue = true;
var typeName = "Vector" + ((VectorType)type).Dimension;
if (isColor)
{
if (((VectorType)type).Dimension == 3)
{
typeName = "Color3";
}
else if (((VectorType)type).Dimension == 4)
{
typeName = "Color4";
}
else
{
throw new NotSupportedException("Color attribute is only valid for float3/float4.");
}
}
variable = new ShaderKeyVariable(decl.Name, typeName,
ShaderKeyVariableCategory.Value);
}
else if (type is MatrixType)
{
processInitialValue = true;
variable = new ShaderKeyVariable(decl.Name, "Matrix", ShaderKeyVariableCategory.Value);
}
else if (type is TextureType || IsStringInList(type.Name, "Texture1D", "RWTexture1D", "Texture2D", "RWTexture2D", "Texture3D", "RWTexture3D"))
{
variable = new ShaderKeyVariable(decl.Name, "Texture", ShaderKeyVariableCategory.Resource);
}
else if (type is StateType && type.Name == "SamplerState")
{
variable = new ShaderKeyVariable(decl.Name, "SamplerState", ShaderKeyVariableCategory.Resource);
}
else if (type is GenericType <ObjectType> &&
IsStringInList(type.Name, "StructuredBuffer", "RWStructuredBuffer", "ConsumeStructuredBuffer",
"AppendStructuredBuffer"))
{
variable = new ShaderKeyVariable(decl.Name, "Buffer", ShaderKeyVariableCategory.Resource);
}
if (isArray && variable != null && variable.Category == ShaderKeyVariableCategory.Value)
{
variable.Category = ShaderKeyVariableCategory.ArrayValue;
}
if (variable == null)
{
throw new NotSupportedException();
}
if (decl.InitialValue != null && processInitialValue)
{
variable.InitialValue = decl.InitialValue.ToString();
// Add new operator for array
if (isArray && variable.InitialValue.Contains("{"))
{
variable.InitialValue = "new " + variable.Type + "[] " + variable.InitialValue;
}
}
else if (isArray && processInitialValue)
{
// Default array initializer
var dimensions = ((ArrayType)decl.Type.ResolveType()).Dimensions;
if (dimensions.Count != 1)
{
throw new NotSupportedException();
}
var expressionEvaluator = new ExpressionEvaluator();
var expressionResult = expressionEvaluator.Evaluate(dimensions[0]);
if (expressionResult.HasErrors)
{
throw new InvalidOperationException();
}
variable.InitialValue = "new " + variable.Type + "[" + expressionResult.Value + "]";
variable.Type += "[]";
}
if (variable.InitialValue != null)
{
// Rename float2/3/4 to Vector2/3/4
if (variable.InitialValue.StartsWith("float2") ||
variable.InitialValue.StartsWith("float3") ||
variable.InitialValue.StartsWith("float4"))
{
variable.InitialValue = variable.InitialValue.Replace("float", "new Vector");
}
if (isColor)
{
variable.InitialValue = variable.InitialValue.Replace("Vector3", "Color3");
variable.InitialValue = variable.InitialValue.Replace("Vector4", "Color4");
}
}
var variableType = decl.Attributes.OfType <AttributeDeclaration>().Where(x => x.Name == "Type").Select(x => (string)x.Parameters[0].Value).FirstOrDefault();
if (variableType != null)
{
variable.Type = variableType;
}
variable.Map = decl.Attributes.OfType <AttributeDeclaration>().Where(x => x.Name == "Map").Select(x => (string)x.Parameters[0].Value).FirstOrDefault();
// First time initialization
if (shaderKeyClass == null)
{
shaderKeyClass = new ShaderKeyClass(shaderClassType.Name + "Keys");
}
shaderKeyClass.Variables.Add(variable);
}
catch (Exception)
{
Console.WriteLine("Could not process variable {0}.{1} of type {2}", shaderClassType.Name, decl.Name,
decl.Type);
}
}
return(shaderKeyClass);
}
