protected override OpTypeStruct VisitTypeStruct(TypeStruct node)
{
var visitTypeStruct = base.VisitTypeStruct(node);
visitTypeStruct.MemberTypes = new PrintableList <IdRef>(node.Fields.Select(_ => (IdRef)Visit(_.Type)));
return(Register(visitTypeStruct, _typeInstructions));
}
/*
* DynamicStruct ConvertDynamic(DynamicObject dyn)
* {
* Type t = dyn.GetType();
* DynamicStruct ret = new DynamicStruct();
* ret.Type = GetTypeRef(t);
* TypeStruct ts = types.GetValue(ret.Type);
* ret.MemberValues = new ValueStruct[ts.Members.Length];
* int slot = 0;
* foreach (var member in ts.Members)
* {
* string name = strings.GetValue(member);
* var p = t.GetProperty(name);
* if (p != null)
* {
* ret.MemberValues[slot] = Convert(p.GetValue(dyn));
* }
* else
* ret.MemberValues[slot] = Convert(t.GetField(name).GetValue(dyn));
* slot++;
* }
* string[] dynnames=dyn.GetDynamicMemberNames().ToArray();
* ret.DynamicMembers = new ushort[dynnames.Length];
* ret.DynamicMemberValues = new ValueStruct[dynnames.Length];
* for(int i=0;i<dynnames.Length;i++)
* {
* ret.DynamicMembers[i] = GetStringRef(dynnames[i]);
*
* object obj;
*
* }
* return ret;
* }
*/
ObjectStruct ConvertObject(object dyn)
{
Type t = dyn.GetType();
ObjectStruct ret = new ObjectStruct();
ret.Type = GetTypeRef(t);
TypeStruct ts = types.GetValue(ret.Type);
ret.Values = new ValueStruct[ts.Members.Length];
int slot = 0;
foreach (var member in ts.Members)
{
string name = strings.GetValue(member);
var p = t.GetProperty(name);
if (p != null)
{
ret.Values[slot] = Convert(p.GetValue(dyn));
}
else
{
ret.Values[slot] = Convert(t.GetField(name).GetValue(dyn));
}
slot++;
}
return(ret);
}
DictionaryStruct ConvertDictionary(object obj)
{
DictionaryStruct dict = new DictionaryStruct();
Type t = obj.GetType();
dict.Type = GetTypeRef(t);
ICollection keys = ((ICollection)t.GetProperty("Keys").GetValue(obj));
PropertyInfo indexer = t.GetProperty("Item");
//sometimes the indexer is not named "Item", we need to find it manually in that case
if (indexer == null)
{
foreach (var property in t.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (property.GetIndexParameters().Length == 1)
{
indexer = property;
break;
}
}
}
dict.Keys = new ValueStruct[keys.Count];
dict.Values = new ValueStruct[keys.Count];
int i = 0;
foreach (var key in keys)
{
dict.Keys[i] = Convert(key);
dict.Values[i] = Convert(indexer.GetValue(obj, new[] { key }));
i++;
}
TypeStruct ts = types.GetValue(dict.Type);
dict.MemberValues = new ValueStruct[ts.Members.Length];
int slot = 0;
foreach (var member in ts.Members)
{
string name = strings.GetValue(member);
var p = t.GetProperty(name);
if (p != null)
{
dict.MemberValues[slot] = Convert(p.GetValue(obj));
}
else
{
dict.MemberValues[slot] = Convert(t.GetField(name).GetValue(obj));
}
slot++;
}
return(dict);
}
void WriteType(TypeStruct type)
{
WriteVInt(type.TypeName);
WriteVInt(type.AssemblyName);
writer.Write(type.IsValueType);
WriteVInt((uint)type.Members.Length);
foreach (var x in type.Members)
{
WriteVInt(x);
}
}
private static TypeStruct BuildStructure(params int[] indices)
{
var fields = indices.Select(index => new TypeStructureField(WellKnownTypes[index].Type,
WellKnownTypes[index].Name)).ToArray();
var structure = new TypeStruct("testStruct", fields);
var spirvStructureField = new TypeStructureField(structure,
string.Join("_", structure.Fields.Select(_ => _.Name)));
var endMarker = new TypeStructureField(SpirvTypeBase.Float, "endMarker");
var modelStruct = new TypeStruct("test_" + spirvStructureField.Name, marker,
spirvStructureField, endMarker);
return(modelStruct);
}
private void CompareStructureLayout(TypeStruct expected, TypeStruct actual)
{
Assert.AreEqual(expected.Fields.Count, actual.Fields.Count);
for (var index = 0; index < expected.Fields.Count; index++)
{
var actualField = actual.Fields[index];
var expectedField = expected.Fields[index];
Assert.AreEqual(expectedField.ByteOffset, actualField.ByteOffset);
if (expectedField.Type.TypeCategory == SpirvTypeCategory.Struct)
{
CompareStructureLayout((TypeStruct)expectedField.Type, (TypeStruct)actualField.Type);
}
}
}
TypeStruct ReadTypeStruct()
{
TypeStruct t = new TypeStruct();
t.TypeName = (uint)ReadVInt();
t.AssemblyName = (uint)ReadVInt();
t.IsValueType = reader.ReadBoolean();
t.Members = new uint[(int)ReadVInt()];
for (int i = 0; i < t.Members.Length; i++)
{
t.Members[i] = (uint)ReadVInt();
}
return(t);
}
void WriteArray(ArrayStruct array)
{
TypeStruct ts = types.GetValue(array.ElementType);
writer.Write((byte)array.NativeElementType);
WriteVInt(array.ElementType);
WriteVInt((uint)array.Values.Length);
bool b = !TypeMarkerUtil.IsFinal(array.NativeElementType);
foreach (var x in array.Values)
{
WriteValue(x, b);
}
}
protected virtual void WriteStruct(TypeStruct structure)
{
var fields = structure.Fields;
WriteLine("[StructLayout(LayoutKind.Explicit)]");
WriteLine("public partial struct " + structure.DebugName);
WriteLine("{");
for (var memberIndex = 0; memberIndex < fields.Count; memberIndex++)
{
var field = fields[memberIndex];
WriteStructField(field.Name, field.ByteOffset.Value, field.Type);
if (memberIndex != fields.Count - 1)
{
WriteLine();
}
}
WriteLine("}");
}
private (Shader, Veldrid.Shader[]) CompileShaderForFieldSet(TypeStruct fieldSet)
{
var vertexShaderText = new VertexShaderTemplate(fieldSet).TransformText();
var(vertexBytes, shaderInstructions) = CompileToBytecode(vertexShaderText);
var fragmentShaderText = new FragmentShaderTemplate().TransformText();
var fragment = SpirvCompilation.CompileGlslToSpirv(fragmentShaderText, "fragment.glsl",
ShaderStages.Fragment, new GlslCompileOptions {
Debug = true
});
var shaders = ResourceFactory.CreateFromSpirv(
new ShaderDescription(ShaderStages.Vertex, vertexBytes, "main"),
new ShaderDescription(ShaderStages.Fragment, fragment.SpirvBytes, "main"));
foreach (var shader in shaders)
{
Disposables.Add(shader);
}
return(shaderInstructions, shaders);
}
uint GetTypeRef(Type t)
{
TypeStruct ts = new TypeStruct();
ts.AssemblyName = GetStringRef(t.Assembly.FullName);
ts.TypeName = GetStringRef(t.FullName);
ts.IsValueType = t.IsValueType;
int id = types.GetReferenceIdIfAvailable(ts);
List <string> names = new List <string>();
if (id < 0)
{
foreach (var pi in t.GetProperties(BindingFlags.Instance | BindingFlags.Public))
{
if (pi.CanRead && pi.CanWrite && !pi.IsDefined(typeof(NonSerializedAttribute)) && pi.GetIndexParameters().Length == 0)
{
names.Add(pi.Name);
}
}
foreach (var fi in t.GetFields(BindingFlags.Instance | BindingFlags.Public))
{
if (!fi.IsInitOnly && !fi.IsNotSerialized && !fi.IsPinvokeImpl && !fi.IsLiteral)
{
names.Add(fi.Name);
}
}
ts.Members = new uint[names.Count];
for (int i = 0; i < names.Count; i++)
{
ts.Members[i] = GetStringRef(names[i]);
}
id = types.GetReferenceId(ts);
}
checked
{
return((uint)id);
}
}
object ReadObject()
{
int typeref = (int)ReadVInt();
TypeStruct ts = typeStructs[typeref];
Type t = types[typeref];
object obj = Activator.CreateInstance(t);
foreach (var x in ts.Members)
{
var name = strings[(int)x];
var prop = t.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
if (prop != null)
{
prop.SetValue(obj, ReadValue());
}
else
{
t.GetField(name, BindingFlags.Public | BindingFlags.Instance).SetValue(obj, ReadValue());
}
}
return(obj);
}
ListStruct ConvertList(IEnumerable obj)
{
Type t = obj.GetType();
List <object> elements = obj.Cast <object>().ToList();
ListStruct list = new ListStruct();
list.Type = GetTypeRef(t);
list.ElementType = GetTypeMarker(obj);
list.Values = new ValueStruct[elements.Count];
for (int i = 0; i < elements.Count; i++)
{
list.Values[i] = Convert(elements[i]);
}
TypeStruct ts = types.GetValue(list.Type);
list.MemberValues = new ValueStruct[ts.Members.Length];
int slot = 0;
foreach (var member in ts.Members)
{
string name = strings.GetValue(member);
var p = t.GetProperty(name);
if (p != null)
{
list.MemberValues[slot] = Convert(p.GetValue(obj));
}
else
{
list.MemberValues[slot] = Convert(t.GetField(name).GetValue(obj));
}
slot++;
}
return(list);
}
internal object Read()
{
byte[] magic = reader.ReadBytes(4);
for (int i = 0; i < magic.Length; i++)
{
if (magic[i] != CbfConstants.MagicNumber[i])
{
throw new NotSupportedException("File format not supported.");
}
}
byte version = reader.ReadByte();
if (version != CbfConstants.Version)
{
throw new NotSupportedException("File version <" + version + "> is not supported. (Supported version: " + CbfConstants.Version + ")");
}
PoolFlags flags = (PoolFlags)reader.ReadByte();
bool hasStrings, hasFloats, hasDoubles, hasDecimals, hasDates, hasTypes;
hasStrings = flags.HasFlag(PoolFlags.HasStrings);
hasFloats = flags.HasFlag(PoolFlags.HasFloats);
hasDoubles = flags.HasFlag(PoolFlags.HasDoubles);
hasDecimals = flags.HasFlag(PoolFlags.HasDecimals);
hasDates = flags.HasFlag(PoolFlags.HasDates);
hasTypes = flags.HasFlag(PoolFlags.HasTypes);
if (hasStrings)
{
strings = new List <string>((int)ReadVInt());
}
if (hasFloats)
{
floats = new List <float>((int)ReadVInt());
}
if (hasDoubles)
{
doubles = new List <double>((int)ReadVInt());
}
if (hasDecimals)
{
decimals = new List <decimal>((int)ReadVInt());
}
if (hasDates)
{
dates = new List <DateTime>((int)ReadVInt());
}
if (hasTypes)
{
int typelen = (int)ReadVInt();
typeStructs = new List <TypeStruct>(typelen);
types = new List <Type>(typelen);
}
if (hasStrings)
{
for (int i = 0; i < strings.Capacity; i++)
{
strings.Add(ReadString());
}
}
if (hasFloats)
{
for (int i = 0; i < floats.Capacity; i++)
{
floats.Add(reader.ReadSingle());
}
}
if (hasDoubles)
{
for (int i = 0; i < doubles.Capacity; i++)
{
doubles.Add(reader.ReadDouble());
}
}
if (hasDecimals)
{
for (int i = 0; i < decimals.Capacity; i++)
{
decimals.Add(reader.ReadDecimal());
}
}
if (hasDates)
{
for (int i = 0; i < dates.Capacity; i++)
{
dates.Add(new DateTime(ReadVSInt()));
}
}
if (hasTypes)
{
for (int i = 0; i < types.Capacity; i++)
{
TypeStruct t = ReadTypeStruct();
typeStructs.Add(t);
types.Add(GetTypeByName(strings[(int)t.TypeName], strings[(int)t.AssemblyName]));
}
}
return(ReadValue());
}
/// <summary>
/// Разделяет строку на массив переменных, определённых структорой TypeStruct
/// </summary>
/// <param name="type">Строка, содержащая код блока VAR</param>
/// <returns>Массив переменных</returns>
private TypeStruct[] GetTypeStructFromField(string var)
{
TypeStruct[] vars = new TypeStruct[0];
int dp = 0, i = 1, var_declarate = 0;
bool is_name = true,
is_type = false;
string name = var[0].ToString(), type = "";
while (i < var.Length)
{
if (var[i] == ':')
dp++;
else if (var[i] == ';')
dp--;
if (dp == 0 && char.IsLetter(var[i]) && var[i - 1] == ' ')
is_name = true;
else if (dp == 1 && var[i - 1] == ':')
is_type = true;
else if (dp == 1 && var[i] == ':')
{
is_name = false;
string[] names = name.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
var_declarate = names.Length;
Array.Resize(ref vars, vars.Length + var_declarate);
for (int j = 0; j < var_declarate; j++)
{
vars[vars.Length - var_declarate + j] = new TypeStruct();
vars[vars.Length - var_declarate + j].name = names[j].Trim();
}
name = "";
}
else if (dp == 0 && var[i] == ';')
{
is_type = false;
for (int j = 0; j < var_declarate; j++)
vars[vars.Length - var_declarate + j].type = type.Trim();
type = "";
}
if (is_name)
name += var[i];
if (is_type)
type += var[i];
i++;
}
return vars;
}
public static TypeStruct Of(int structIndex)
{
var st = new TypeStruct();
st.structIndex = structIndex;
return st;
}
public void GreenQuadReflectionTest()
{
byte[] vertexByteCode;
byte[] framentByteCode;
{
var const_1f = new Constant(-1.0f);
var const1f = new Constant(1.0f);
var const0f = new Constant(0.0f);
var const0i = new Constant(0);
var arrayType = new TypeArray(SpirvTypeBase.Vec4, 4);
var a = new ConstantComposite(SpirvTypeBase.Vec4, const_1f, const1f, const0f, const1f);
var b = new ConstantComposite(SpirvTypeBase.Vec4, const1f, const1f, const1f, const1f);
var c = new ConstantComposite(SpirvTypeBase.Vec4, const_1f, const_1f, const0f, const1f);
var d = new ConstantComposite(SpirvTypeBase.Vec4, const1f, const_1f, const1f, const1f);
var positions = new ConstantComposite(arrayType, a, b, c, d);
var clipArrayType = new TypeArray(SpirvTypeBase.Float, 1);
var gl_PerVertex = new TypeStruct("gl_PerVertex",
new TypeStructureField(SpirvTypeBase.Vec4, "gl_Position")
.WithDecoration(Decoration.BuiltIn(BuiltIn.Position())),
new TypeStructureField(SpirvTypeBase.Float, "gl_PointSize")
.WithDecoration(Decoration.BuiltIn(BuiltIn.PointSize())),
new TypeStructureField(clipArrayType, "gl_ClipDistance")
.WithDecoration(Decoration.BuiltIn(BuiltIn.ClipDistance())),
new TypeStructureField(clipArrayType, "gl_CullDistance")
.WithDecoration(Decoration.BuiltIn(BuiltIn.CullDistance()))
).WithDecoration(Decoration.Block());
var outputVar = new Variable(gl_PerVertex.MakePointer(StorageClass.Output()), StorageClass.Output(), null, "");
var localVar = new Variable(
arrayType.MakePointer(StorageClass.Function()),
StorageClass.Function(), null, "indexable");
Node positionPointer = new AccessChain(SpirvTypeBase.Vec4.MakePointer(StorageClass.Output()), outputVar, new[] { const0i });
var glVertexIndex = Variable.gl_VertexIndex();
Node position = new Load(SpirvTypeBase.Vec4,
new AccessChain(SpirvTypeBase.Vec4.MakePointer(StorageClass.Function()), localVar, new Node[]
{
new Load(SpirvTypeBase.Int, glVertexIndex, null)
}), null);
var vertexShaderMain = new Function(Spv.FunctionControl.Enumerant.None, new TypeFunction()
{
ReturnType = SpirvTypeBase.Void
}, "main")
.SetUp(_ => _
.ThenLabel()
.ThenStore(localVar, positions, null)
.ThenStore(positionPointer, position, null)
.ThenReturn()
);
var reflection = new ShaderReflection()
.WithCapability(Capability.Shader())
.WithExtInstImport("GLSL.std.450")
.WithMemoryModel(AddressingModel.Logical(), MemoryModel.GLSL450())
.WithEntryPoint(ExecutionModel.Vertex(), vertexShaderMain, "main");
var shader = reflection
.BuildShader();
vertexByteCode = shader.Build();
Console.WriteLine("-----------------------");
Node node = reflection.EntryPointInstructions.First().Value;
while (node != null)
{
Console.WriteLine($".Then(new {node})");
node = node.GetNext();
}
//var vertexSource = @"#version 450
//#extension GL_KHR_vulkan_glsl : enable
//const vec4 QuadInfos[4] =
//{
// vec4(-1, 1, 0, 1),
// vec4(1, 1, 1, 1),
// vec4(-1, -1, 0, 1),
// vec4(1, -1, 1, 1),
//};
//void main()
//{
// gl_Position = QuadInfos[gl_VertexIndex];
//}";
//vertexByteCode = ShaderTestBase.CompileToBytecode(vertexSource, ShaderStages.Vertex, true, true);
}
{
var const0f = new Constant(0.0f);
var const1f = new Constant(1.0f);
var redColor = new ConstantComposite(SpirvTypeBase.Vec4, const0f, const1f, const0f, const1f);
var v = new Variable(SpirvTypeBase.Vec4.MakePointer(StorageClass.Output()), StorageClass.Output(), null, "fsout_Color0")
{
Location = 0
};
var fragmentShaderMain = new Function(Spv.FunctionControl.Enumerant.None, new TypeFunction(SpirvTypeBase.Void), "main")
.SetUp(_ => _
.ThenLabel()
.ThenStore(v, redColor, null)
.ThenReturn()
);
var reflection = new ShaderReflection()
.WithCapability(Capability.Shader())
.WithExtInstImport("GLSL.std.450")
.WithMemoryModel(AddressingModel.Logical(), MemoryModel.GLSL450())
.WithEntryPoint(ExecutionModel.Fragment(), fragmentShaderMain, "main")
.WithExecutionMode(fragmentShaderMain, ExecutionMode.OriginUpperLeft());
var shader = reflection
.BuildShader();
framentByteCode = shader
.Build();
Console.WriteLine("-----------------------");
Node node = reflection.EntryPointInstructions.First().Value;
while (node != null)
{
Console.WriteLine($".Then(new {node})");
node = node.GetNext();
}
// var fragmentSource = @"#version 450
//layout(location = 0) out vec4 fsout_Color0;
//void main()
//{
// fsout_Color0 = vec4(0,1,0,1);
//}";
// framentByteCode = ShaderTestBase.CompileToBytecode(fragmentSource, ShaderStages.Fragment, true, true);
}
{
var glsl = Veldrid.SPIRV.SpirvCompilation.CompileVertexFragment(vertexByteCode, framentByteCode,
CrossCompileTarget.GLSL);
Console.WriteLine(glsl.VertexShader);
Console.WriteLine(glsl.FragmentShader);
}
var shaders = ResourceFactory.CreateFromSpirv(
new ShaderDescription(ShaderStages.Vertex, vertexByteCode, "main"),
new ShaderDescription(ShaderStages.Fragment, framentByteCode, "main"));
var readRenderTargetPixel = RenderQuad(shaders);
Assert.AreEqual(new RgbaByte(0, 255, 0, 255), readRenderTargetPixel);
}
/// <summary>
/// Приводит дерево к типу TypeStruct
/// </summary>
/// <param name="root">Корневой элемент</param>
/// <param name="root_name">Имя родителя</param>
/// <returns></returns>
private TypeStruct[] GetTypesStruct(Tree root, string root_name)
{
if (root_name != "type" && root_name != "var" && root_name != "const")
return null;
if (root == null)
return null;
Tree start_cursor = GetElementCursor(root, root_name);
if (start_cursor == null)
return null;
if (!start_cursor.HasChild())
return null;
TypeStruct[] types = new TypeStruct[start_cursor.GetChildCount()];
for (int i = 0; i < types.Length; i++)
{
Tree cursor = start_cursor.GetChildById(i);
string type_str = cursor.command;
if (cursor.HasChild())
cursor = cursor.GetChildById(0);
while (cursor.parent.command != root_name)
{
cursor.enters_count++;
if (cursor.enters_count == 1)
type_str += " " + cursor.command;
else if (cursor.type == "record")
type_str += " end;";
if (cursor.HasChild() && cursor.enters_count == 1)
cursor = cursor.GetChildById(0);
else if (cursor.next == null)
cursor = cursor.parent;
else
cursor = cursor.next;
}
if (cursor.type == "record")
type_str += " end;";
int j = 0;
if (root_name == "type" || root_name == "const")
while (type_str[j] != '=')
j++;
else if (root_name == "var")
while (type_str[j] != ':')
j++;
while (type_str.EndsWith(";"))
type_str = type_str.Remove(type_str.Length - 1);
string[] replace = new string[] { "\t", "\n", "\r" };
for (int k = 0; k < replace.Length; k++)
type_str = type_str.Replace(replace[k], " ");
while (type_str.IndexOf(" ") > -1)
type_str = type_str.Replace(" ", " ");
types[i] = new TypeStruct();
types[i].name = type_str.Remove(j).Trim();
types[i].type = type_str.Remove(0, j + 1).Trim();
}
return types;
}
public void TestPermutation(TypeStruct fieldSet)
{
var(shaderInstructions, shaders) = CompileShaderForFieldSet(fieldSet);
var shaderReflection = new ShaderReflection(shaderInstructions);
var structure = shaderReflection.Structures.Where(_ => _.DebugName == fieldSet.DebugName).First();
CompareStructureLayout(structure, fieldSet);
var bufferSize = structure.SizeInBytes;
bufferSize = SpirvUtils.RoundUp(bufferSize, 16);
var buffer = ResourceFactory.CreateBuffer(new BufferDescription(bufferSize, BufferUsage.UniformBuffer));
Disposables.Add(buffer);
var bytes = new byte[bufferSize];
var counter = 1;
var hash = 0;
PopulateBuffer(bytes, 0, structure, ref counter, ref hash);
GraphicsDevice.UpdateBuffer(buffer, 0, bytes);
//structure.EvaluateLayout();
//var hlsl = SpirvCompilation.CompileVertexFragment(vertex.SpirvBytes, fragment.SpirvBytes, CrossCompileTarget.HLSL, new CrossCompileOptions());
//var glsl = SpirvCompilation.CompileVertexFragment(vertex.SpirvBytes, fragment.SpirvBytes, CrossCompileTarget.GLSL, new CrossCompileOptions());
//var msl = SpirvCompilation.CompileVertexFragment(vertex.SpirvBytes, fragment.SpirvBytes, CrossCompileTarget.MSL, new CrossCompileOptions());
//var essl = SpirvCompilation.CompileVertexFragment(vertex.SpirvBytes, fragment.SpirvBytes, CrossCompileTarget.ESSL, new CrossCompileOptions());
var layout = ResourceFactory.CreateResourceLayout(new ResourceLayoutDescription(
new ResourceLayoutElementDescription("ModelBuffer", ResourceKind.UniformBuffer, ShaderStages.Vertex)));
Disposables.Add(layout);
var resourceSet = ResourceFactory.CreateResourceSet(new ResourceSetDescription(layout, buffer));
Disposables.Add(resourceSet);
var pd = new GraphicsPipelineDescription(
BlendStateDescription.SingleOverrideBlend,
DepthStencilStateDescription.Disabled,
RasterizerStateDescription.Default,
PrimitiveTopology.PointList,
new ShaderSetDescription(new[] { new VertexLayoutDescription(new VertexElementDescription[] { }) },
shaders),
new[] { layout },
Framebuffer.OutputDescription);
var pipeline = ResourceFactory.CreateGraphicsPipeline(pd);
Disposables.Add(pipeline);
CommandList.Begin();
CommandList.SetFramebuffer(Framebuffer);
CommandList.SetPipeline(pipeline);
CommandList.SetGraphicsResourceSet(0, resourceSet);
CommandList.Draw(1);
CommandList.End();
GraphicsDevice.SubmitCommands(CommandList);
GraphicsDevice.WaitForIdle();
var expected = new RgbaByte((byte)(hash % 256), (byte)(hash / 256 % 256), (byte)(hash / 65536 % 256),
(byte)(hash / 16777216 % 256));
var actual = ReadRenderTargetPixel();
Assert.AreEqual(expected, actual);
}
public VertexShaderTemplate(TypeStruct fields)
{
_fields = fields;
}
public static TypeStruct Of(int structIndex)
{
var st = new TypeStruct();
st.structIndex = structIndex;
return st;
}
