public void Glsl450EndToEnd(string vsName, string fsName) { Compilation compilation = TestUtil.GetTestProjectCompilation(); LanguageBackend backend = new Glsl450Backend(compilation); ShaderGenerator sg = new ShaderGenerator( compilation, vsName, fsName, backend); ShaderGenerationResult result = sg.GenerateShaders(); IReadOnlyList <GeneratedShaderSet> sets = result.GetOutput(backend); Assert.Equal(1, sets.Count); GeneratedShaderSet set = sets[0]; ShaderModel shaderModel = set.Model; if (vsName != null) { ShaderFunction vsFunction = shaderModel.GetFunction(vsName); string vsCode = set.VertexShaderCode; GlsLangValidatorTool.AssertCompilesCode(vsCode, "vert", true); } if (fsName != null) { ShaderFunction fsFunction = shaderModel.GetFunction(fsName); string fsCode = set.FragmentShaderCode; GlsLangValidatorTool.AssertCompilesCode(fsCode, "frag", true); } }
private static List <GX2LoopVar> GetLoops(ShaderModel shaderModel, ResShaderProgram program) { //Todo figure these out List <GX2LoopVar> loops = new List <GX2LoopVar>(); return(loops); }
public static VariableBlob Parse(BytecodeReader reader, BytecodeReader dataReader) { var result = new VariableBlob(); result.Index = dataReader.ReadUInt32(); var blobSize = dataReader.ReadUInt32(); var paddedSize = blobSize + (blobSize % 4 == 0 ? 0 : 4 - blobSize % 4); var shaderReader = dataReader.CopyAtCurrentPosition(); var data = dataReader.ReadBytes((int)paddedSize); if (!_IsShader(data)) { if (blobSize == 0) { result.Value = ""; } else { result.Value = Encoding.UTF8.GetString(data, 0, (int)(blobSize - 1)); } } else { result.Shader = ShaderModel.Parse(shaderReader); } return(result); }
private string GenerateDefines(HeaderInfo header, ShaderModel shaderModel) { List <string> allDefines = new List <string>(); allDefines.AddRange(Config.GlobalDefines); switch (header.Type) { case ShaderType.VertexShader: allDefines.Add("VERTEX_SHADER"); break; case ShaderType.PixelShader: allDefines.Add("PIXEL_SHADER"); break; } allDefines.AddRange(header.Defines); allDefines.Add("SHADER_MODEL=" + ShaderModelMethods.ToInt(shaderModel)); allDefines.Add("LANGUAGE_HLSL"); allDefines.Add(GetCompilerDefine()); string defines = ""; foreach (string define in allDefines) { defines += CreateCommand("D", define.Trim()); } return(defines); }
internal virtual void WritePass(ShaderGenerationContext context, ShaderModel config, SourceMap.ShaderPassSource passSpecificCode) { var mode = GetShadowDepthMode(context); if (UsePassName != null) { if (mode == KeywordShadowDepthPass.ShadowDepthPassMode.DefaultPass) { new UsePass(UsePassName).WritePass(context, config, null); return; } if (mode == KeywordShadowDepthPass.ShadowDepthPassMode.Off) { return; } } context.LogShaderSection($"Shader Pass {GetType().Name}"); context.WriteLine("Pass{"); var shaderPassContext = context.CreatePassContext(context, this, config, passSpecificCode); shaderPassContext.WriteIndented(WriteInnerPass); context.WriteLine("}"); }
public void HlslEndToEnd(string vsName, string fsName) { Compilation compilation = TestUtil.GetTestProjectCompilation(); HlslBackend backend = new HlslBackend(compilation); ShaderGenerator sg = new ShaderGenerator( compilation, vsName, fsName, backend); ShaderGenerationResult result = sg.GenerateShaders(); IReadOnlyList <GeneratedShaderSet> sets = result.GetOutput(backend); Assert.Equal(1, sets.Count); GeneratedShaderSet set = sets[0]; ShaderModel shaderModel = set.Model; if (vsName != null) { ShaderFunction vsFunction = shaderModel.GetFunction(vsName); string vsCode = set.VertexShaderCode; FxcTool.AssertCompilesCode(vsCode, "vs_5_0", vsFunction.Name); } if (fsName != null) { ShaderFunction fsFunction = shaderModel.GetFunction(fsName); string fsCode = set.FragmentShaderCode; FxcTool.AssertCompilesCode(fsCode, "ps_5_0", fsFunction.Name); } }
public static TechniqueKey GenerateKeyPart(Shader shader) { VertexShaderFlags vsFlags = VertexShaderFlags.None; PixelShaderFlags psFlags = PixelShaderFlags.None; ShaderModel model = FromFeatureLevel(shader.FeatureLevel); foreach (var property in shader.Result.DescendantNodes .Select(node => node.GetType() .GetProperties(BindingFlags.Public | BindingFlags.Instance) .Where(p => p.PropertyType == typeof(INode))).SelectMany(properties => properties)) { switch (shader.Type) { case ShaderType.Vertex: vsFlags = property.GetCustomAttributes(true) .OfType <VertexShaderAttribute>() .Aggregate(vsFlags, (current, vsAttribute) => current | vsAttribute.Features); break; case ShaderType.Pixel: psFlags = property.GetCustomAttributes(true).OfType <PixelShaderAttribute>() .Aggregate(psFlags, (current, psAttribute) => current | psAttribute.Features); break; } } return(new TechniqueKey(vsFlags, psFlags, sm: model)); }
public void TestVertexShader_ShaderModel() { string functionName = "TestShaders.TestVertexShader.VS"; Compilation compilation = TestUtil.GetTestProjectCompilation(); HlslBackend backend = new HlslBackend(compilation); ShaderGenerator sg = new ShaderGenerator( compilation, functionName, null, backend); ShaderGenerationResult genResult = sg.GenerateShaders(); IReadOnlyList <GeneratedShaderSet> sets = genResult.GetOutput(backend); Assert.Equal(1, sets.Count); ShaderModel shaderModel = sets[0].Model; Assert.Equal(2, shaderModel.Structures.Length); Assert.Equal(3, shaderModel.AllResources.Length); ShaderFunction vsEntry = shaderModel.GetFunction(functionName); Assert.Equal("VS", vsEntry.Name); Assert.Single(vsEntry.Parameters); Assert.True(vsEntry.IsEntryPoint); Assert.Equal(ShaderFunctionType.VertexEntryPoint, vsEntry.Type); }
public void TestVertexShader_VertexSemantics() { string functionName = "TestShaders.TestVertexShader.VS"; Compilation compilation = TestUtil.GetTestProjectCompilation(); HlslBackend backend = new HlslBackend(compilation); ShaderGenerator sg = new ShaderGenerator( compilation, functionName, null, backend); ShaderGenerationResult genResult = sg.GenerateShaders(); IReadOnlyList <GeneratedShaderSet> sets = genResult.GetOutput(backend); Assert.Equal(1, sets.Count); ShaderModel shaderModel = sets[0].Model; StructureDefinition vsInput = shaderModel.GetStructureDefinition(nameof(TestShaders) + "." + nameof(PositionTexture)); Assert.Equal(SemanticType.Position, vsInput.Fields[0].SemanticType); Assert.Equal(SemanticType.TextureCoordinate, vsInput.Fields[1].SemanticType); StructureDefinition fsInput = shaderModel.GetStructureDefinition( nameof(TestShaders) + "." + nameof(TestVertexShader) + "+" + nameof(TestVertexShader.VertexOutput)); Assert.Equal(SemanticType.SystemPosition, fsInput.Fields[0].SemanticType); Assert.Equal(SemanticType.TextureCoordinate, fsInput.Fields[1].SemanticType); }
public static float ToInt(ShaderModel shaderModel) { switch (shaderModel) { case ShaderModel._5_0: return(50); case ShaderModel._5_1: return(51); case ShaderModel._6_0: return(60); case ShaderModel._6_1: return(61); case ShaderModel._6_2: return(62); case ShaderModel._6_3: return(63); default: throw new Exception("Invalid ShaderModel \"" + shaderModel + "\""); } }
private static CodeConstructor CreatePixelShaderConstructor(ShaderModel shaderModel) { // Create a constructor that takes a PixelShader as its only parameter. var constructor = new CodeConstructor { Attributes = MemberAttributes.Public, Parameters = { new CodeParameterDeclarationExpression("PixelShader", "shader") }, Statements = { new CodeAssignStatement { Left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "PixelShader"), Right = new CodeArgumentReferenceExpression("shader") }, CreateUpdateMethod("Input") } }; foreach (var register in shaderModel.Registers) { constructor.Statements.Add(CreateUpdateMethod(register.RegisterName)); } return(constructor); }
private static List <GX2SamplerVar> GetSamplers(ShaderModel shaderModel, ResShaderProgram program, bool isFragment) { List <GX2SamplerVar> samplers = new List <GX2SamplerVar>(); for (int i = 0; i < program.SamplerLocations.Length; i++) { int location = isFragment ? program.SamplerLocations[i].FragmentLocation : program.SamplerLocations[i].VertexLocation; Console.WriteLine($"{shaderModel.Samplers.GetKey(i)} SamplerVarType {(GX2SamplerVarType)shaderModel.Samplers[i].GX2Type}"); if (location != -1) { var type = (GX2SamplerVarType)shaderModel.Samplers[i].GX2Type; // if (type == GX2SamplerVarType.SAMPLER_CUBE || type == GX2SamplerVarType.SAMPLER_CUBE_ARRAY) // type = (GX2SamplerVarType)5; samplers.Add(new GX2SamplerVar() { Name = shaderModel.Samplers.GetKey(i), Location = (uint)location, Type = type, }); } } return(samplers); }
private static List <GX2UniformVar> GetUniforms(ShaderModel shaderModel, ResShaderProgram program, bool isFragment) { List <GX2UniformVar> uniforms = new List <GX2UniformVar>(); for (int i = 0; i < program.UniformBlockLocations.Length; i++) { int location = isFragment ? program.UniformBlockLocations[i].FragmentLocation : program.UniformBlockLocations[i].VertexLocation; if (location != -1) { foreach (var uniform in shaderModel.UniformBlocks[i].Uniforms) { uniforms.Add(new GX2UniformVar() { Name = uniform.Key, Offset = (uint)(uniform.Value.Offset - 1) / 4, BlockIndex = (uint)uniform.Value.BlockIndex, Count = uniform.Value.GX2Count, Type = (GX2ShaderVarType)uniform.Value.GX2Type, }); } } } return(uniforms); }
void generate(string[] args, ref string psPath, ref ShaderModel _shaderModel, ref string _csText) { string fxPath = args[0] + "\\" + args[1] + ".fx"; //@"C:\Users\wenyunchun\Desktop\WpfTPL\shader\ToonShader.fx"; psPath = args[0] + "\\" + args[1] + ".ps"; string GeneratedNamespace = args[2]; using (FileStream fs = new FileStream(fxPath, FileMode.Open, FileAccess.Read)) { using (StreamReader sr = new StreamReader(fs, Encoding.UTF8)) { CodeParser.GeneratedNamespace = !string.IsNullOrWhiteSpace(GeneratedNamespace) ? GeneratedNamespace : "Shaders"; // || 动态命名空间 || // _shaderModel = CodeParser.ParseShader(psPath, sr.ReadToEnd()); CreatePixelShaderClass.shaderPath = psPath; _csText = CreatePixelShaderClass.GetSourceText(CodeDomProvider.CreateProvider("CSharp"), _shaderModel, false); string topath = args[0] + "\\" + args[1] + "Effect.cs"; using (FileStream fs2 = new FileStream(topath, FileMode.OpenOrCreate, FileAccess.Write)) { using (StreamWriter sw = new StreamWriter(fs2, Encoding.UTF8)) { sw.Write(_csText); logText.Items.Insert(0, topath); } } } } }
public static Preshader Parse(BytecodeReader reader) { var result = new Preshader(); result.Shader = ShaderModel.Parse(reader); return(result); }
public ExpressionHLSLWriter(ShaderModel shader, string expressionName) { Shader = shader; ExpressionName = expressionName; Ctab = shader.ConstantTable; Cli = shader.Cli; }
public GeneratedShaderSet( string name, string vsCode, string gsCode, string fsCode, string csCode, ShaderFunction vertexfunction, ShaderFunction geometryFunction, ShaderFunction fragmentFunction, ShaderFunction computeFunction, ShaderModel model) { if (string.IsNullOrEmpty(vsCode) && string.IsNullOrEmpty(gsCode) && string.IsNullOrEmpty(fsCode) && string.IsNullOrEmpty(csCode)) { throw new ShaderGenerationException("At least one of vsCode, fsCode, or csCode must be non-empty"); } Name = name; VertexShaderCode = vsCode; GeometryShaderCode = gsCode; FragmentShaderCode = fsCode; ComputeShaderCode = csCode; VertexFunction = vertexfunction; GeometryFunction = geometryFunction; FragmentFunction = fragmentFunction; ComputeFunction = computeFunction; Model = model; }
private NodeBase LoadShaderModel(ShaderModel shaderModel) { var node = new NodeBase(shaderModel.Name); node.Tag = new ShaderModelWrapper(shaderModel); return(node); }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { ShaderModel shaderModel = value == null ? ShaderModel.SM_4_0_Level_9_1 : (ShaderModel)value; switch (shaderModel) { default: case ShaderModel.SM_2_0: return("2.0 (Direct3D 9)"); case ShaderModel.SM_2_A: return("2a (Direct3D 9)"); case ShaderModel.SM_2_B: return("2b (Direct3D 9)"); case ShaderModel.SM_3_0: return("3.0 (Direct3D 9)"); case ShaderModel.SM_4_0_Level_9_1: return("4.0 (Direct3D 9.1)"); case ShaderModel.SM_4_0_Level_9_3: return("4.0 (Direct3D 9.3)"); case ShaderModel.SM_4_0: return("4.0 (Direct3D 10.0)"); case ShaderModel.SM_4_1: return("4.1 (Direct3D 10.1)"); case ShaderModel.SM_5_0: return("5.0 (Direct3D 11.0)"); } }
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { ShaderModel shaderModel = value == null ? ShaderModel.SM_4_0_Level_9_1 : (ShaderModel)value; System.Console.WriteLine(shaderModel); return(shaderModel); }
public void ResourcesUsedInStages() { Compilation compilation = TestUtil.GetCompilation(); HlslBackend backend = new HlslBackend(compilation); ShaderGenerator sg = new ShaderGenerator( compilation, backend, "TestShaders.UsedResourcesShaders.VS", "TestShaders.UsedResourcesShaders.FS"); ShaderGenerationResult genResult = sg.GenerateShaders(); IReadOnlyList <GeneratedShaderSet> sets = genResult.GetOutput(backend); Assert.Equal(1, sets.Count); GeneratedShaderSet set = sets[0]; ShaderModel shaderModel = set.Model; Assert.Equal(4, shaderModel.VertexResources.Length); Assert.Contains(shaderModel.VertexResources, rd => rd.Name == "VS_M0"); Assert.Contains(shaderModel.VertexResources, rd => rd.Name == "VS_M1"); Assert.Contains(shaderModel.VertexResources, rd => rd.Name == "VS_T0"); Assert.Contains(shaderModel.VertexResources, rd => rd.Name == "VS_S0"); Assert.Equal(5, shaderModel.FragmentResources.Length); Assert.Contains(shaderModel.FragmentResources, rd => rd.Name == "FS_M0"); Assert.Contains(shaderModel.FragmentResources, rd => rd.Name == "FS_M1"); Assert.Contains(shaderModel.FragmentResources, rd => rd.Name == "FS_T0"); Assert.Contains(shaderModel.FragmentResources, rd => rd.Name == "FS_S0"); Assert.Contains(shaderModel.FragmentResources, rd => rd.Name == "FS_M2_Indirect"); }
internal static DxcShaderModel ToDxcShaderModel(ShaderModel shaderStage) { switch (shaderStage) { case ShaderModel.Model6_0: return(new DxcShaderModel(6, 0)); case ShaderModel.Model6_1: return(new DxcShaderModel(6, 1)); case ShaderModel.Model6_2: return(new DxcShaderModel(6, 2)); case ShaderModel.Model6_3: return(new DxcShaderModel(6, 3)); case ShaderModel.Model6_4: return(new DxcShaderModel(6, 4)); case ShaderModel.Model6_5: return(new DxcShaderModel(6, 5)); default: throw new ArgumentOutOfRangeException(nameof(shaderStage)); } }
public override void ReloadProgram(BfresMeshAsset mesh) { ProgramPasses.Clear(); var mat = mesh.Shape.Material; //Find index via option choices Dictionary <string, string> options = new Dictionary <string, string>(); foreach (var op in mat.Material.ShaderAssign.ShaderOptions) { options.Add(op.Key, op.Value); } //Update option from render state this.LoadRenderStateOptions(options, mat); //Dynamic options. options["cSkinWeightNum"] = mesh.Shape.VertexSkinCount.ToString(); options.Add("system_id", "0"); int programIndex = ShaderModel.GetProgramIndex(options); if (programIndex == -1) { return; } this.ProgramPasses.Add(ShaderModel.GetShaderProgram(programIndex)); }
public Dictionary <RegisterKey, HlslTreeNode> GroupOutputs(ShaderModel shader) { IEnumerable <KeyValuePair <RegisterComponentKey, HlslTreeNode> > outputsByRegister; if (shader.MajorVersion <= 3) { var registerType = shader.Type == ShaderType.Pixel ? RegisterType.ColorOut : RegisterType.Output; outputsByRegister = _activeOutputs.Where(o => o.Key.RegisterKey.Type == registerType); } else { var operandType = OperandType.Output; outputsByRegister = _activeOutputs.Where(o => o.Key.RegisterKey.OperandType == operandType); } var groupsByRegister = outputsByRegister .OrderBy(o => o.Key.ComponentIndex) .GroupBy(o => o.Key.RegisterKey) .ToDictionary( o => o.Key, o => (HlslTreeNode) new GroupNode(o.Select(o => o.Value).ToArray())); return(groupsByRegister); }
public static string ToShaderString(this ShaderModel shaderModel) { switch (shaderModel) { case ShaderModel.Target20: return("2.0"); case ShaderModel.Target25: return("2.5"); case ShaderModel.Target30: return("3.0"); case ShaderModel.Target35: return("3.5"); case ShaderModel.Target40: return("4.0"); case ShaderModel.Target45: return("4.5"); case ShaderModel.Target46: return("4.6"); case ShaderModel.Target50: return("5.0"); default: throw new ArgumentOutOfRangeException(); } }
public static string GetSourceText(CodeDomProvider currentProvider, ShaderModel shaderModel, bool includePixelShaderConstructor) { return(GenerateCode( currentProvider, BuildPixelShaderGraph(shaderModel, includePixelShaderConstructor), shaderModel)); }
/// <summary> /// 用于输出的着色器(C#、VB.Net等)代码。 /// </summary> /// <param name="shaderModel"></param> /// <returns></returns> private static CodeConstructor CreateDefaultConstructor(ShaderModel shaderModel) { // Create a default constructor. //??string shaderRelativeUri = String.Format("/{0};component/{1}.ps", shaderModel.GeneratedNamespace, shaderModel.GeneratedClassName); CodeConstructor constructor = new CodeConstructor { Attributes = MemberAttributes.Public, Statements = { new CodeVariableDeclarationStatement { Type = new CodeTypeReference("PixelShader"), Name = "pixelShader", InitExpression = new CodeObjectCreateExpression("PixelShader") }, new CodeAssignStatement { Left = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("pixelShader"), "UriSource"), Right = new CodeObjectCreateExpression { CreateType = new CodeTypeReference("Uri"), Parameters = { //??new CodePrimitiveExpression(shaderRelativeUri), //??new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("UriKind"), "Relative") new CodePrimitiveExpression(shaderPath), new CodeFieldReferenceExpression(new CodeTypeReferenceExpression("UriKind"), "Absolute") } } }, new CodeAssignStatement { Left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "PixelShader"), Right = new CodeArgumentReferenceExpression("pixelShader") }, new CodeSnippetStatement(""), CreateUpdateMethod("Input") } }; foreach (var register in shaderModel.Registers.Where(x => x.IsDdxUvDdyUv == true)) { constructor.Statements.Add(new CodeAssignStatement { Left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "DdxUvDdyUvRegisterIndex"), Right = new CodePrimitiveExpression(register.RegisterNumber) }); //不能用移除代替排除。因为会多个地方(预览和输出代码)、前后多个过程(输出多种代码)需要。 //shaderModel.Registers.Remove(register); } foreach (ShaderModelConstantRegister register in shaderModel.Registers.Where(x => x.IsDdxUvDdyUv == false)) { constructor.Statements.Add(CreateUpdateMethod(register.RegisterName)); } return(constructor); }
public override void SetTextureUniforms(GLContext control, ShaderProgram shader, STGenericMaterial mat) { var bfresMaterial = (FMAT)mat; GL.ActiveTexture(TextureUnit.Texture0 + 1); GL.BindTexture(TextureTarget.Texture2D, RenderTools.defaultTex.ID); List <string> shaderSamplers = new List <string>(); foreach (var sampler in ShaderModel.SamplerVariables.symbols) { if (bfresMaterial.Samplers.Contains(sampler.SymbolName)) { shaderSamplers.Add(sampler.SymbolName); } } int id = 1; for (int i = 0; i < bfresMaterial.TextureMaps?.Count; i++) { var name = mat.TextureMaps[i].Name; var sampler = mat.TextureMaps[i].Sampler; //Lookup samplers targeted via animations and use that texture instead if possible if (bfresMaterial.AnimatedSamplers.ContainsKey(sampler)) { name = bfresMaterial.AnimatedSamplers[sampler]; } var location = this.GetSamplerLocation(bfresMaterial.Samplers[i]); if (location == -1) { continue; } GL.ActiveTexture(TextureUnit.Texture0 + id); var tex = BindTexture(shader, GetTextures(), mat.TextureMaps[i], name, id); shader.SetInt(ConvertSamplerName(location), id++); GL.ActiveTexture(TextureUnit.Texture0 + id); tex.Bind(); shader.SetInt(ConvertSamplerFetchName(location), id++); } var pixelShader = ShaderModel.GetGX2PixelShader(this.BinaryIndex); foreach (var sampler in pixelShader.Samplers) { if (sampler.Name == "cShadowMap") { GL.ActiveTexture(TextureUnit.Texture0 + id); ShadowMapTexture.Bind(); shader.SetInt(ConvertSamplerName((int)sampler.Location), id++); } GL.ActiveTexture(TextureUnit.Texture0); GL.BindTexture(TextureTarget.Texture2D, 0); } }
public ShaderSetProcessorInput( string name, ShaderFunction vertexFunction, ShaderFunction fragmentFunction, ShaderModel model) : this(name, vertexFunction, null, fragmentFunction, model) { }
private static ResourceBinding CreateResourceBinding( ShaderModel model, ResourceDefinition resource) { var resourceBinding = new ResourceBinding { Name = resource.Name, Type = GetResourceKind(resource.ResourceKind) }; var shaderStages = ShaderStages.None; if (model.VertexResources.Contains(resource)) { shaderStages |= ShaderStages.Vertex; } if (model.FragmentResources.Contains(resource)) { shaderStages |= ShaderStages.Fragment; } resourceBinding.Stages = shaderStages; switch (resourceBinding.Type) { case ResourceKind.StructuredBufferReadOnly: resourceBinding.Size = (uint)model.GetTypeSize(resource.ValueType); break; case ResourceKind.UniformBuffer: resourceBinding.Fields = new List <UniformBufferField>(); resourceBinding.Size = (uint)model.GetTypeSize(resource.ValueType); var structureDefinition = model.GetStructureDefinition(resource.ValueType); if (structureDefinition != null) // Uniform buffers can be of built-in type { var offset = 0; foreach (var field in structureDefinition.Fields) { var uniformBufferField = new UniformBufferField(); resourceBinding.Fields.Add(uniformBufferField); uniformBufferField.Name = field.Name; uniformBufferField.Offset = offset; var fieldSize = model.GetTypeSize(field.Type); if (field.IsArray) { fieldSize *= field.ArrayElementCount; } uniformBufferField.Size = fieldSize; offset += uniformBufferField.Size; } } break; } return(resourceBinding); }