private XenkoStreamCreator(ShaderClassType shaderClassType, ModuleMixin mixin, List<ModuleMixin> mixins, LoggerResult errorLog) { shader = shaderClassType; mainModuleMixin = mixin; mixinInheritance = mixins; errorWarningLog = errorLog ?? new LoggerResult(); }
private XenkoClassInstantiator(ShaderClassType classType, Dictionary<string, Expression> expressions, Dictionary<string, Identifier> identifiers, bool autoGenericInstances, LoggerResult log) : base(false, false) { shaderClassType = classType; expressionGenerics = expressions; identifiersGenerics = identifiers; this.autoGenericInstances = autoGenericInstances; logger = log; variableGenerics = shaderClassType.ShaderGenerics.ToDictionary(x => x.Name.Text, x => x); }
protected static void ParseClassGenerics(Identifier input, ShaderClassType dest) { // Parse generic identifier and convert it to simple identifier by adding contraint to the class type var genericIdentifier = input as ClassIdentifierGeneric; if (genericIdentifier != null) { foreach (var genericIdentifierItem in genericIdentifier.Generics) { dest.ShaderGenerics.Add(genericIdentifierItem); } input = new Identifier(input.Text) { Span = genericIdentifier.Span }; } dest.Name = input; }
/// <summary> /// Creates a new AST with all the definitions /// </summary> private void GenerateShader() { MixedShader = new ShaderClassType(mainModuleMixin.MixinName); // add constants var constants = mainModuleMixin.ClassReferences.VariablesReferences.Select(x => x.Key).Where(x => x.Qualifiers.Contains(StorageQualifier.Const)).ToList(); MixedShader.Members.AddRange(constants); // Add structures, typedefs foreach (var mixin in MixinInheritance.Where(x => x.OccurenceId == 1)) MixedShader.Members.AddRange(mixin.ParsingInfo.Typedefs); foreach (var mixin in MixinInheritance.Where(x => x.OccurenceId == 1)) MixedShader.Members.AddRange(mixin.ParsingInfo.StructureDefinitions); var sortedNodes = SortNodes(MixedShader.Members); MixedShader.Members.Clear(); MixedShader.Members.AddRange(sortedNodes); // Create constant buffer GroupByConstantBuffer(); // add the methods MixedShader.Members.AddRange(mainModuleMixin.ClassReferences.MethodsReferences.Select(x => x.Key).Where(x => x is MethodDefinition)); // remove duplicates MixedShader.Members = MixedShader.Members.Distinct().ToList(); // Create streams XenkoStreamCreator.Run(MixedShader, mainModuleMixin, MixinInheritance, log); if (log.HasErrors) return; // deal with foreach statements ExpandForEachStatements(mainModuleMixin); foreach (var externMixList in CompositionsPerVariable.Values) { foreach (var externMix in externMixList) ExpandForEachStatements(externMix); } // remove useless variables RemoveUselessVariables(); }
public void Run(ShaderClassType shader) { Visit(shader); }
public void Run(ShaderClassType shaderClassType) { shaderName = shaderClassType.Name.Text; Visit(shaderClassType); }
private 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>()); }
protected virtual void Visit(ShaderClassType shader) { Write(shader.Qualifiers.Any(qualifier => qualifier == XenkoStorageQualifier.Internal) ? "internal " : "public "); Write("static partial class "); Write(shader.Name); Write("Keys"); { OpenBrace(); foreach (var decl in shader.Members) { if (decl is Variable) { VisitDynamic(decl); } else if (decl is ConstantBuffer) { foreach (var subDecl in ((ConstantBuffer)decl).Members.OfType<Variable>()) { VisitDynamic(subDecl); } } } CloseBrace(); } }
public MethodDeclarationShaderCouple(MethodDeclaration method, ShaderClassType shader) { Method = method; Shader = shader; }
public VariableShaderCouple(Variable variable, ShaderClassType shader) { Variable = variable; Shader = shader; }
public static void Instantiate(ShaderClassType classType, Dictionary<string, Expression> expressions, Dictionary<string, Identifier> identifiers, bool autoGenericInstances, LoggerResult log) { var instantiator = new XenkoClassInstantiator(classType, expressions, identifiers, autoGenericInstances, log); instantiator.Run(); }
public static void Run(ShaderClassType shaderClassType, ModuleMixin mixin, List<ModuleMixin> mixins, LoggerResult errorLog) { var streamCreator = new XenkoStreamCreator(shaderClassType, mixin, mixins, errorLog); streamCreator.Run(); }
public void Run(ShaderClassType shaderClassType) { var shader = new Shader(); shader.Declarations.Add(shaderClassType); Run(shader); }
/// <summary> /// Build the ModuleMixinInfo class /// </summary> /// <param name="shaderSource">the ShaderSource to load</param> /// <param name="macros">the macros applied on the source</param> /// <returns>the ModuleMixinInfo</returns> private ModuleMixinInfo BuildMixinInfo(ShaderSource shaderSource, SiliconStudio.Shaders.Parser.ShaderMacro[] macros) { ModuleMixinInfo mixinInfo = null; if (shaderSource is ShaderClassSource) { var shaderClassSource = shaderSource as ShaderClassSource; mixinInfo = new ModuleMixinInfo { ShaderSource = shaderClassSource, Macros = macros }; LoadMixinFromClassSource(mixinInfo); } else if (shaderSource is ShaderMixinSource) { var shaderMixinSource = shaderSource as ShaderMixinSource; var shaderName = "Mix" + lastMixIndex; ++lastMixIndex; var fakeAst = new ShaderClassType(shaderName); foreach (var classSource in shaderMixinSource.Mixins) { Identifier name; if (classSource.GenericArguments != null && classSource.GenericArguments.Length > 0) name = new IdentifierGeneric(classSource.ClassName, classSource.GenericArguments.Select(x => new Identifier(x.ToString())).ToArray()); else name = new Identifier(classSource.ClassName); fakeAst.BaseClasses.Add(new TypeName(name)); } mixinInfo = new ModuleMixinInfo { MixinGenericName = shaderName, Macros = macros, MixinAst = fakeAst, ShaderSource = shaderSource, SourceHash = ObjectId.FromBytes(Encoding.UTF8.GetBytes(shaderName)), Instanciated = true }; } return mixinInfo; }
private void Visit(ShaderClassType shaderClassType) { Visit((Node)shaderClassType); // Allow to navigate to base classes foreach (var baseClass in shaderClassType.BaseClasses) { var firstOrDefault = analyzedModuleMixin.InheritanceList.FirstOrDefault(moduleMixin => moduleMixin.Shader.Name.Text == baseClass.Name.Text); if (firstOrDefault != null) { var declaration = firstOrDefault.Shader; baseClass.TypeInference.Declaration = declaration; } parsingInfo.NavigableNodes.Add(baseClass); } }
/// <summary> /// Finds the member type reference. /// </summary> /// <param name="shaderDecl">Type of the shader</param> /// <param name="memberReference">The member reference.</param> protected void FindMemberTypeReference(ShaderClassType shaderDecl, MemberReferenceExpression memberReference) { var mixin = moduleMixins.FirstOrDefault(x => x.Shader == shaderDecl); if (mixin != null) { var shader = mixin.InheritanceList.FirstOrDefault(x => x.MixinName == memberReference.Member.Text); if (shader != null) { memberReference.TypeInference.Declaration = shader.Shader; memberReference.TypeInference.TargetType = shader.Shader; return; } var variableDecl = mixin.VirtualTable.Variables.FirstOrDefault(x => x.Variable.Name.Text == memberReference.Member.Text); if (variableDecl != null) { var isStream = IsStreamMember(memberReference); if (!isStream || variableDecl.Variable.Qualifiers.Contains(XenkoStorageQualifier.Stream)) { memberReference.TypeInference.Declaration = variableDecl.Variable; memberReference.TypeInference.TargetType = variableDecl.Variable.Type.ResolveType(); return; } } if (ParentNode is MethodInvocationExpression) { var invocationExpression = ParentNode as MethodInvocationExpression; if (ReferenceEquals(invocationExpression.Target, memberReference)) { var methodDecl = mixin.VirtualTable.Methods.Select(x => x.Method).FirstOrDefault(x => x.IsSameSignature(invocationExpression)); if (methodDecl != null) { memberReference.TypeInference.Declaration = methodDecl; invocationExpression.TypeInference.TargetType = methodDecl.ReturnType.ResolveType(); return; } } } } }
/// <summary> /// Constructor /// </summary> /// <param name="shader">the shader AST</param> public void SetShaderAst(ShaderClassType shader) { if (Shader != null) throw new Exception("[ModuleMixin.SetShaderAst] Shader has already been set"); Shader = shader; MixinName = shader.Name.Text; }