internal static DebugEffectInterfaceVariable Parse(DebugBytecodeReader reader, DebugBytecodeReader variableReader, DebugShaderVersion version)
{
var result = new DebugEffectInterfaceVariable();
var nameOffset = result.NameOffset = variableReader.ReadUInt32("NameOffset");
var nameReader = reader.CopyAtOffset("NameReader", variableReader, (int)nameOffset);
result.Name = nameReader.ReadString("Name");
var typeOffset = result.TypeOffset = variableReader.ReadUInt32("TypeOffset");
var typeReader = reader.CopyAtOffset("TypeReader", variableReader, (int)typeOffset);
result.Type = DebugEffectType.Parse(reader, typeReader, version);
//Pointer to InterfaceInitializer
result.DefaultValueOffset = variableReader.ReadUInt32("DefaultValueOffset");
var initializerReader = reader.CopyAtOffset("InitializerReader", variableReader, (int)result.DefaultValueOffset);
var instanceNameOffset = result.InstanceNameOffset = initializerReader.ReadUInt32("InstanceNameOffset");
var instanceNameReader = reader.CopyAtOffset("InstanceNameReader", variableReader, (int)instanceNameOffset);
result.InstanceName = instanceNameReader.ReadString("InstanceName");
result.Flags = variableReader.ReadUInt32("Flags");
result.AnnotationCount = variableReader.ReadUInt32("AnnotationCount");
for (int i = 0; i < result.AnnotationCount; i++)
{
variableReader.AddIndent($"Annotation {i}");
result.Annotations.Add(DebugEffectAnnotation.Parse(reader, variableReader, version));
variableReader.RemoveIndent();
}
return(result);
}
public static DebugConstantDeclaration Parse(DebugBytecodeReader reader, DebugBytecodeReader decReader)
{
var result = new DebugConstantDeclaration();
var nameOffset = decReader.ReadUInt32("NameOffset");
result.RegisterSet = decReader.ReadEnum16 <RegisterSet>("RegisterSet");
result.RegisterIndex = decReader.ReadUInt16("RegisterIndex");
result.RegisterCount = decReader.ReadUInt16("RegisterCount");
decReader.ReadUInt16("Reserved");
var typeInfoOffset = decReader.ReadUInt32("TypeInfoOffset");
var defaultValueOffset = decReader.ReadUInt32("DefaultValueOffset");
var nameReader = reader.CopyAtOffset("NameReader", decReader, (int)nameOffset);
result.Name = nameReader.ReadString("Name");
var typeReader = reader.CopyAtOffset("TypeReader", decReader, (int)typeInfoOffset);
result.Type = DebugConstantType.Parse(reader, typeReader);
if (defaultValueOffset != 0)
{
//Note: thre are corrisponding def instructions. TODO: check that they are the same
var defaultValueReader = reader.CopyAtOffset("DefaultValueReader", decReader, (int)defaultValueOffset);
var elementCount = result.Type.GetSize() / 4;
for (int i = 0; i < elementCount; i++)
{
result.DefaultValue.Add(defaultValueReader.ReadSingle($"DefaultValue {i}"));
}
}
return(result);
}
public static DebugEffectMember Parse(DebugBytecodeReader reader, DebugBytecodeReader memberReader, DebugShaderVersion version)
{
var result = new DebugEffectMember();
var nameOffset = result.NameOffset = memberReader.ReadUInt32("NameOffset");
var nameReader = reader.CopyAtOffset("NameReader", memberReader, (int)nameOffset);
result.Name = nameReader.ReadString("Name");
result.SemanticNameOffset = memberReader.ReadUInt32("SemanticNameOffset");
if (result.SemanticNameOffset != 0)
{
var semanticNameReader = reader.CopyAtOffset("SemanticNameReader", memberReader, (int)result.SemanticNameOffset);
result.Semantic = semanticNameReader.ReadString("Semantic");
}
else
{
result.Semantic = "";
}
result.BufferOffset = memberReader.ReadUInt32("BufferOffset");
result.TypeOffset = memberReader.ReadUInt32("TypeOffset");
var typeReader = reader.CopyAtOffset("TypeReader", memberReader, (int)result.TypeOffset);
result.Type = DebugEffectType.Parse(reader, typeReader, version);
return(result);
}
public static DebugEffectAnnotation Parse(DebugBytecodeReader reader, DebugBytecodeReader annotationReader, DebugShaderVersion version)
{
var result = new DebugEffectAnnotation();
var nameOffset = result.NameOffset = annotationReader.ReadUInt32("NameOffset");
var nameReader = reader.CopyAtOffset("NameReader", reader, (int)nameOffset);
result.Name = nameReader.ReadString("Name");
var typeOffset = result.TypeOffset = annotationReader.ReadUInt32("TypeOffset");
var typeReader = reader.CopyAtOffset("TypeReader", annotationReader, (int)typeOffset);
result.Type = DebugEffectType.Parse(reader, typeReader, version);
//Note: Points to 27 and "foo" in Texture2D tex<int bla=27;string blu="foo";>;
/// Value format and stride depends on Type
var valueOffset = result.ValueOffset = annotationReader.ReadUInt32("ValueOffset");
var defaultValueReader = reader.CopyAtOffset("DefaultValueReader", annotationReader, (int)valueOffset);
if (result.Type.EffectVariableType == EffectVariableType.Numeric)
{
for (int i = 0; i < result.Type.PackedSize / 4; i++)
{
result.DefaultNumericValue.Add(DebugNumber.Parse(defaultValueReader));
}
}
else
{
for (int i = 0; i < result.ElementCount; i++)
{
result.DefaultStringValue.Add(defaultValueReader.ReadString($"DefaultValueString{i}"));
}
}
return(result);
}
public static DebugResourceBinding Parse(DebugBytecodeReader reader, DebugBytecodeReader resourceBindingReader, DebugShaderVersion target)
{
uint nameOffset = resourceBindingReader.ReadUInt32("nameOffset");
var nameReader = reader.CopyAtOffset("nameReader", resourceBindingReader, (int)nameOffset);
var result = new DebugResourceBinding
{
Name = nameReader.ReadString("Name"),
Type = (ShaderInputType)resourceBindingReader.ReadUInt32("Type"),
ReturnType = (ResourceReturnType)resourceBindingReader.ReadUInt32("ReturnType"),
Dimension = (ShaderResourceViewDimension)resourceBindingReader.ReadUInt32("Dimension"),
NumSamples = resourceBindingReader.ReadUInt32("NumSamples"),
BindPoint = resourceBindingReader.ReadUInt32("BindPoint"),
BindCount = resourceBindingReader.ReadUInt32("BindCount"),
Flags = (ShaderInputFlags)resourceBindingReader.ReadUInt32("Flags")
};
if (target.MajorVersion == 5 && target.MinorVersion == 1)
{
result.SpaceIndex = resourceBindingReader.ReadUInt32("SpaceIndex");
result.ID = resourceBindingReader.ReadUInt32("ID");
}
else
{
result.ID = result.BindPoint;
}
return(result);
}
public static DebugEffectGroup Parse(DebugBytecodeReader reader, DebugBytecodeReader groupReader, DebugShaderVersion version)
{
var result = new DebugEffectGroup();
result.NameOffset = groupReader.ReadUInt32("NameOffset");
result.TechniqueCount = groupReader.ReadUInt32("TechniqueCount");
result.AnnotationCount = groupReader.ReadUInt32("AnnotationCount");
if (result.NameOffset != 0)
{
var nameReader = reader.CopyAtOffset("NameReader", groupReader, (int)result.NameOffset);
result.Name = nameReader.ReadString("Name");
}
else
{
result.Name = "";
}
for (int i = 0; i < result.TechniqueCount; i++)
{
groupReader.AddIndent($"Technique {i}");
result.Techniques.Add(DebugEffectTechnique.Parse(reader, groupReader, version));
groupReader.RemoveIndent();
}
for (int i = 0; i < result.AnnotationCount; i++)
{
groupReader.AddIndent($"Annotation {i}");
result.Annotations.Add(DebugEffectAnnotation.Parse(reader, groupReader, version));
groupReader.RemoveIndent();
}
return(result);
}
public static DebugFxlcToken Parse(DebugBytecodeReader reader)
{
var result = new DebugFxlcToken();
var token = reader.ReadUInt32($"Token");
var tokenComponentCount = token.DecodeValue(0, 2);
result.Type = (FxlcOpcode)token.DecodeValue(20, 30);
result.IsScalarInstruction = token.DecodeValue <bool>(31, 31);
Debug.Assert(Enum.IsDefined(typeof(FxlcOpcode), result.Type),
$"Unknown FxlcTokenType {result.Type}");
Debug.Assert(token.DecodeValue(3, 19) == 0,
$"Unexpected data in FxlcToken bits 3-19 {token.DecodeValue(3, 19)}");
reader.AddNote("Token", result.Type);
reader.AddNote("TokenComponentCount", tokenComponentCount);
reader.AddNote("IsScalarInstruction", result.IsScalarInstruction);
var operandCount = result.OperandCount = reader.ReadUInt32("OperandCount");
for (int i = 0; i < operandCount; i++)
{
var isScalarOp = i == 0 && result.IsScalarInstruction;
result.Operands.Add(DebugFxlcOperand.Parse(reader, tokenComponentCount, isScalarOp));
}
// destination operand
result.Operands.Insert(0, DebugFxlcOperand.Parse(reader, tokenComponentCount, false));
return(result);
}
public static DebugInterfaceDeclarationToken Parse(DebugBytecodeReader reader)
{
uint token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
reader.AddNote("DynamicallyIndex", token0.DecodeValue(11, 11) == 1);
var result = new DebugInterfaceDeclarationToken
{
DynamicallyIndexed = (token0.DecodeValue(11, 11) == 1),
Identifier = reader.ReadUInt32("Identifier"),
ExpectedFunctionTableLength = reader.ReadUInt32("ExpectedFunctionTableLength")
};
uint token3 = reader.ReadUInt32("token3");
result.TableLength = token3.DecodeValue <ushort>(00, 15);
result.ArrayLength = token3.DecodeValue <ushort>(16, 31);
reader.AddNote("TableLength", result.TableLength);
reader.AddNote("ArrayLength", result.ArrayLength);
for (int i = 0; i < result.TableLength; i++)
{
result.FunctionTableIdentifiers.Add(reader.ReadUInt32($"FunctionTableIdentifiers[{i}]"));
}
return(result);
}
public static DebugFxlcToken Parse(DebugBytecodeReader reader)
{
var result = new DebugFxlcToken();
var token = reader.ReadUInt32($"Token");
var tokenComponentCount = token.DecodeValue(0, 2);
result.Type = (FxlcOpcode)token.DecodeValue(20, 30);
var singleFirstComponent = token.DecodeValue(31, 31);
Debug.Assert(Enum.IsDefined(typeof(FxlcOpcode), result.Type),
$"Unknown FxlcTokenType {result.Type}");
Debug.Assert(token.DecodeValue(3, 19) == 0,
$"Unexpected data in FxlcToken bits 3-19 {token.DecodeValue(3, 19)}");
var info = reader.Members.Last();
info.AddNote("Token", result.Type.ToString());
info.AddNote("TokenComponentCount", tokenComponentCount.ToString());
info.AddNote("SingleFirstComponent", singleFirstComponent.ToString());
var operandCount = result.OperandCount = reader.ReadUInt32("OperandCount");
for (int i = 0; i < operandCount; i++)
{
var componentCount = i == 0 && singleFirstComponent == 1 ?
1 : tokenComponentCount;
result.Operands.Add(DebugFxlcOperand.Parse(reader, componentCount));
}
// destination operand
result.Operands.Insert(0, DebugFxlcOperand.Parse(reader, tokenComponentCount));
return(result);
}
public static DebugEffectTechnique Parse(DebugBytecodeReader reader,
DebugBytecodeReader techniqueReader, DebugShaderVersion version)
{
var result = new DebugEffectTechnique(version);
var nameOffset = result.NameOffset = techniqueReader.ReadUInt32("NameOffset");
var nameReader = reader.CopyAtOffset("NameReader", techniqueReader, (int)nameOffset);
result.Name = nameReader.ReadString("Name");
result.PassCount = techniqueReader.ReadUInt32("PassCount");
result.AnnotationCount = techniqueReader.ReadUInt32("AnnotationCount");
for (int i = 0; i < result.AnnotationCount; i++)
{
techniqueReader.AddIndent("Annotation");
result.Annotations.Add(DebugEffectAnnotation.Parse(reader, techniqueReader, version));
techniqueReader.RemoveIndent();
}
for (int i = 0; i < result.PassCount; i++)
{
techniqueReader.AddIndent($"Pass {i}");
result.Passes.Add(DebugEffectPass.Parse(reader, techniqueReader, version));
techniqueReader.RemoveIndent();
}
return(result);
}
public static DebugInterfaceSlot Parse(DebugBytecodeReader reader, DebugBytecodeReader interfaceSlotReader)
{
var slotSpan = interfaceSlotReader.ReadUInt32("slotSpan");
var count = interfaceSlotReader.ReadUInt32("count");
var typeIDsOffset = interfaceSlotReader.ReadUInt32("typeIDsOffset");
var typeIDsReader = reader.CopyAtOffset("typeIDsReader", interfaceSlotReader, (int)typeIDsOffset);
var tableIDsOffset = interfaceSlotReader.ReadUInt32("tableIDsOffset");
var tableIDsReader = reader.CopyAtOffset("tableIDsReader", interfaceSlotReader, (int)tableIDsOffset);
var result = new DebugInterfaceSlot
{
SlotSpan = slotSpan
};
for (int i = 0; i < count; i++)
{
result.TypeIDs.Add(typeIDsReader.ReadUInt16($"TypeIDs[{i}]"));
result.TableIDs.Add(tableIDsReader.ReadUInt32($"TableIDs[{i}]"));
}
return(result);
}
public static DebugDSInfo Parse(DebugBytecodeReader reader)
{
return(new DebugDSInfo()
{
InputControlPointCount = reader.ReadUInt32("InputControlPointCount"),
OutputPositionPresent = reader.ReadByte("OutputPositionPresent"),
TessellatorDomain = reader.ReadUInt32("TessellatorDomain"),
});
}
internal static DebugShaderVariable Parse(DebugBytecodeReader reader,
DebugBytecodeReader variableReader, DebugShaderVersion target, bool isFirst)
{
uint nameOffset = variableReader.ReadUInt32("nameOffset");
var nameReader = reader.CopyAtOffset("nameReader", variableReader, (int)nameOffset);
var name = nameReader.ReadString("name");
var startOffset = variableReader.ReadUInt32("startOffset");
uint size = variableReader.ReadUInt32("size");
var flags = variableReader.ReadEnum32 <ShaderVariableFlags>("flags");
var typeOffset = variableReader.ReadUInt32("typeOffset");
var typeReader = reader.CopyAtOffset("typeReader", variableReader, (int)typeOffset);
var shaderType = DebugShaderType.Parse(reader, typeReader, target, 2, isFirst, startOffset);
var defaultValueOffset = variableReader.ReadUInt32("defaultValueOffset");
List <Number> defaultValue = null;
if (defaultValueOffset != 0)
{
defaultValue = new List <Number>();
var defaultValueReader = reader.CopyAtOffset("defaultValueReader", variableReader, (int)defaultValueOffset);
if (size % 4 != 0)
{
throw new ParseException("Can only deal with 4-byte default values at the moment.");
}
for (int i = 0; i < size; i += 4)
{
defaultValue.Add(new Number(defaultValueReader.ReadBytes($"defaultValue{i}", 4)));
}
}
var result = new DebugShaderVariable
{
DefaultValue = defaultValue,
Member = new DebugShaderTypeMember(0)
{
Name = name,
Offset = startOffset,
Type = shaderType
},
BaseType = name,
Size = size,
Flags = flags
};
if (target.MajorVersion >= 5 || target.ProgramType == ProgramType.LibraryShader)
{
result.StartTexture = variableReader.ReadInt32("startTexture");
result.TextureSize = variableReader.ReadInt32("textureSize");
result.StartSampler = variableReader.ReadInt32("startSampler");
result.SamplerSize = variableReader.ReadInt32("samplerSize");
}
return(result);
}
public static DebugHSInfo Parse(DebugBytecodeReader reader)
{
return(new DebugHSInfo()
{
InputControlPointCount = reader.ReadUInt32("InputControlPointCount"),
OutputControlPointCount = reader.ReadUInt32("OutputControlPointCount"),
TessellatorDomain = reader.ReadUInt32("TessellatorDomain"),
TessellatorOutputPrimitive = reader.ReadUInt32("TessellatorOutputPrimitive"),
});
}
public static DebugGeometryShaderInstanceCountDeclarationToken Parse(DebugBytecodeReader reader)
{
var token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
return(new DebugGeometryShaderInstanceCountDeclarationToken
{
InstanceCount = reader.ReadUInt32("InstanceCount")
});
}
public static DebugFunctionBodyDeclarationToken Parse(DebugBytecodeReader reader)
{
var token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
return(new DebugFunctionBodyDeclarationToken
{
Identifier = reader.ReadUInt32("Identifier")
});
}
public static DebugGSInfo Parse(DebugBytecodeReader reader)
{
return(new DebugGSInfo()
{
InputPrimitive = reader.ReadUInt32("InputPrimitive"),
OutputTopology = reader.ReadUInt32("OutputTopology"),
OutputStreamMask = reader.ReadUInt32("OutputStreamMask"),
OutputPositionPresent = reader.ReadByte("OutputPositionPresent")
});
}
public static DebugTempRegisterDeclarationToken Parse(DebugBytecodeReader reader)
{
var token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
return(new DebugTempRegisterDeclarationToken
{
TempCount = reader.ReadUInt32("TempCount")
});
}
public static DebugControlPointCountDeclarationToken Parse(DebugBytecodeReader reader)
{
var token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
return(new DebugControlPointCountDeclarationToken
{
ControlPointCount = reader.ReadUInt32("ControlPointCount")
});
}
public new static DebugEffectConstantIndexAssignment Parse(DebugBytecodeReader reader, DebugBytecodeReader assignmentReader)
{
var result = new DebugEffectConstantIndexAssignment();
var arrayNameOffset = result.ArrayNameOffset = assignmentReader.ReadUInt32("ArrayNameOffset");
var arrayNameReader = reader.CopyAtOffset("ArrayNameReader", assignmentReader, (int)arrayNameOffset);
result.ArrayName = arrayNameReader.ReadString("ArrayName");
result.Index = assignmentReader.ReadUInt32("Index");
return(result);
}
public static DebugGeometryShaderMaxOutputVertexCountDeclarationToken Parse(DebugBytecodeReader reader)
{
var token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
return(new DebugGeometryShaderMaxOutputVertexCountDeclarationToken
{
MaxPrimitives = reader.ReadUInt32("MaxPrimitives")
});
}
public static DebugEffectAssignment Parse(DebugBytecodeReader reader, DebugBytecodeReader annotationReader)
{
//MemberType type, such as AddressV or Filter
var memberType = (EffectAssignmentType)annotationReader.ReadUInt32("MemberType");
// $"EffectStateAnnotationType is {memberType}");
//MemberIndex is 1 for BlendEnable[1] = TRUE;
var memberIndex = annotationReader.ReadUInt32("MemberIndex");
var assignmentType = (EffectCompilerAssignmentType)annotationReader.ReadUInt32("AssignmentType");
var valueOffset = annotationReader.ReadUInt32("ValueOffset");
var typeSpecificReader = reader.CopyAtOffset("TypeSpecificReader", annotationReader, (int)valueOffset);
DebugEffectAssignment result;
switch (assignmentType)
{
case EffectCompilerAssignmentType.Constant:
result = DebugEffectConstantAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.Variable:
result = DebugEffectVariableAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.ConstantIndex:
result = DebugEffectConstantIndexAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.VariableIndex:
result = DebugEffectVariableIndexAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.ExpressionIndex:
result = DebugEffectExpressionIndexAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.Expression:
result = DebugEffectExpressionAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.InlineShader:
result = DebugEffectInlineShaderAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.InlineShader5:
result = DebugEffectInlineShader5Assignment.Parse(reader, typeSpecificReader);
break;
default:
throw new ParseException($"Unsupported EffectCompilerAssignmentType {assignmentType}");
}
result.MemberType = memberType;
result.MemberIndex = memberIndex;
result.AssignmentType = assignmentType;
result.ValueOffset = valueOffset;
return(result);
}
public static DebugMSInfo Parse(DebugBytecodeReader reader)
{
return(new DebugMSInfo()
{
GroupSharedBytesUsed = reader.ReadUInt32("GroupSharedBytesUsed"),
GroupSharedBytesDependentOnViewID = reader.ReadUInt32("GroupSharedBytesDependentOnViewID"),
PayloadSizeInBytes = reader.ReadUInt32("PayloadSizeInBytes"),
MaxOutputVertices = reader.ReadUInt16("MaxOutputVertices"),
MaxOutputPrimitives = reader.ReadUInt16("MaxOutputPrimitives"),
});
}
public static DebugIndexableTempRegisterDeclarationToken Parse(DebugBytecodeReader reader)
{
var token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
return(new DebugIndexableTempRegisterDeclarationToken
{
RegisterIndex = reader.ReadUInt32("RegisterIndex"),
RegisterCount = reader.ReadUInt32("RegisterCount"),
NumComponents = reader.ReadUInt32("NumComponents")
});
}
public new static DebugEffectConstantAssignment Parse(DebugBytecodeReader reader, DebugBytecodeReader assignmentReader)
{
var result = new DebugEffectConstantAssignment();
var assignmentCount = assignmentReader.ReadUInt32("AssignmentCount");
for (int i = 0; i < assignmentCount; i++)
{
result.Types.Add((EffectScalarType)assignmentReader.ReadUInt32($"Type{i}"));
result.Values.Add(DebugNumber.Parse(assignmentReader));
}
return(result);
}
internal void UpdateVersion(DebugShaderVersion version)
{
if (Reader == null)
{
return;
}
Reader.ReadUInt32("Unknown");
switch (version.ProgramType)
{
case ProgramType.VertexShader:
Info = DebugVSInfo.Parse(Reader);
break;
case ProgramType.HullShader:
Info = DebugHSInfo.Parse(Reader);
break;
case ProgramType.DomainShader:
Info = DebugDSInfo.Parse(Reader);
break;
case ProgramType.GeometryShader:
Info = DebugGSInfo.Parse(Reader);
break;
case ProgramType.PixelShader:
Info = DebugPSInfo.Parse(Reader);
break;
default:
Reader.ReadBytes("Unknown", 32);
break;
}
if (Info != null && Info.StructSize < DebugValidationInfo.UnionSize)
{
Reader.ReadBytes("Padding", DebugValidationInfo.UnionSize - Info.StructSize);
}
MinimumExpectedWaveLaneCount = Reader.ReadUInt32("MinimumExpectedWaveLaneCount");
MaximumExpectedWaveLaneCount = Reader.ReadUInt32("MaximumExpectedWaveLaneCount");
if (ChunkSize > 20)
{
Reader.ReadEnum8 <PSVShaderKind>("ShaderStage");
UsesViewID = Reader.ReadByte("UsesViewID");
GSMaxVertexCount = Reader.ReadByte("MaxVertexCount");
SigInputElements = Reader.ReadByte("SigInputElements");
SigOutputElements = Reader.ReadByte("SigOutputElements");
SigPatchConstOrPrimElements = Reader.ReadByte("SigPatchConstOrPrimElements");
SigInputVectors = Reader.ReadByte("SigInputVectors");
SigOutputVectors = Reader.ReadBytes("SigOutputVectors", 4);
}
Reader = null;
}
public static DebugStructuredThreadGroupSharedMemoryDeclarationToken Parse(DebugBytecodeReader reader)
{
var token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
return(new DebugStructuredThreadGroupSharedMemoryDeclarationToken
{
Operand = DebugOperand.Parse(reader, token0.DecodeValue <OpcodeType>(0, 10)),
StructByteStride = reader.ReadUInt32("StructByteStride"),
StructCount = reader.ReadUInt32("StructCount")
});
}
public DebugConstantStructMember Parse(DebugBytecodeReader reader, DebugBytecodeReader memberReader)
{
var result = new DebugConstantStructMember();
var nameOffset = memberReader.ReadUInt32("NameOffset");
var nameReader = reader.CopyAtOffset("NameReader", memberReader, (int)nameOffset);
result.Name = Name;
var typeOffset = memberReader.ReadUInt32("TypeOffset");
var typeReader = reader.CopyAtOffset("TypeREader", memberReader, (int)typeOffset);
result.Type = DebugConstantType.Parse(reader, typeReader);
return(result);
}
public static DebugThreadGroupDeclarationToken Parse(DebugBytecodeReader reader)
{
var token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
var result = new DebugThreadGroupDeclarationToken();
result.Dimensions[0] = reader.ReadUInt32("Dimensions[0]");
result.Dimensions[1] = reader.ReadUInt32("Dimensions[1]");
result.Dimensions[2] = reader.ReadUInt32("Dimensions[2]");
return(result);
}
public static DebugEffectInterfaceInitializer Parse(DebugBytecodeReader reader, DebugBytecodeReader initializerReader)
{
var nameOffset = initializerReader.ReadUInt32("NameOffset");
var index = initializerReader.ReadUInt32("Index");
var nameReader = reader.CopyAtOffset("NameReader", initializerReader, (int)nameOffset);
var name = nameReader.ReadString("Name");
return(new DebugEffectInterfaceInitializer()
{
Name = name,
Index = index
});
}
