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