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