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 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 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 DebugLibraryParameterDescription Parse(DebugBytecodeReader reader, DebugBytecodeReader paramReader) { var nameOffset = paramReader.ReadUInt32("NameOffset"); var semanticNameOffset = paramReader.ReadUInt32("SemanticNameOffset"); var result = new DebugLibraryParameterDescription() { VariableType = paramReader.ReadEnum32 <ShaderVariableType>("VariableType"), VariableClass = paramReader.ReadEnum32 <ShaderVariableClass>("VariableClass"), Rows = paramReader.ReadUInt32("Rows"), Column = paramReader.ReadUInt32("Column"), InterpolationMode = paramReader.ReadEnum32 <InterpolationMode>("InterpolationMode"), Flags = paramReader.ReadEnum32 <ParameterFlags>("Flags"), FirstInRegister = paramReader.ReadUInt32("FirstInRegister"), FirstInComponent = paramReader.ReadUInt32("FirstInComponent"), FirstOutRegister = paramReader.ReadUInt32("FirstOutRegister"), FirstOutComponent = paramReader.ReadUInt32("FirstOutComponent"), }; var nameReader = reader.CopyAtOffset("NameReader", paramReader, (int)nameOffset); result.Name = nameReader.ReadString("Name"); if (semanticNameOffset != 0) { var semanticNameReader = reader.CopyAtOffset("SemanticNameReader", paramReader, (int)semanticNameOffset); result.SemanticName = semanticNameReader.ReadString("SemanticName"); } else { result.SemanticName = ""; } 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 DebugLibHeaderChunk Parse(DebugBytecodeReader reader, uint chunkSize) { var chunkReader = reader.CopyAtCurrentPosition("chunkReader", reader); var result = new DebugLibHeaderChunk(); var unknown1 = chunkReader.ReadUInt32("LibHeader.Unknown1"); var creatorStringOffset = chunkReader.ReadUInt32("CreatorStringOffset"); result.Flags = chunkReader.ReadUInt32("Flags"); var functionCount = chunkReader.ReadUInt32("functionCount"); var functionInfoOffset = chunkReader.ReadUInt32("functionInfoOffset"); var creatorStringReader = chunkReader.CopyAtOffset("creatorStringReader", chunkReader, (int)creatorStringOffset); result.CreatorString = creatorStringReader.ReadString("CreatorString"); var functionInfoReader = reader.CopyAtOffset("functionInfoReader", chunkReader, (int)functionInfoOffset); for (int i = 0; i < functionCount; i++) { // is 0 for lib_4_0, lib_4_1, lib_5_0 // is 1 for lib_4_0_level_9_1_vs_only, lib_4_0_level_9_3_vs_only // is 2 for lib_4_0_level_9_1_ps_only, lib_4_0_level_9_3_ps_only // is 3 for lib_4_0_level_9_1, lib_4_0_level_9_3 var mode = (ProfileMode)functionInfoReader.ReadUInt32("mode"); var functionNameOffset = functionInfoReader.ReadUInt32("functionNameOffset"); var functionNameReader = reader.CopyAtOffset("functionNameReader", reader, (int)functionNameOffset); var name = functionNameReader.ReadString("name"); result.FunctionDescs.Add(new LibraryDesc(name, mode)); } 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 DebugConstantType Parse(DebugBytecodeReader reader, DebugBytecodeReader typeReader) { var result = new DebugConstantType(); result.ParameterClass = typeReader.ReadEnum16 <ParameterClass>("ParameterClass"); result.ParameterType = typeReader.ReadEnum16 <ParameterType>("ParameterType"); result.Rows = typeReader.ReadUInt16("Rows"); result.Columns = typeReader.ReadUInt16("Columns"); result.Elements = typeReader.ReadUInt16("Elements"); result.MemberCount = typeReader.ReadUInt16("Members"); var memberInfoOffset = typeReader.ReadUInt32("MemberInfoOffset"); if (memberInfoOffset != 0) { var memberInfoReader = reader.CopyAtOffset("MemberReader", typeReader, (int)memberInfoOffset); for (int i = 0; i < result.MemberCount; i++) { var nameOffset = memberInfoReader.ReadUInt32($"Member{i}NameOffset"); var nameReader = reader.CopyAtOffset($"Member{i}NameReader", memberInfoReader, (int)nameOffset); nameReader.ReadString("Name"); var typeOffset = memberInfoReader.ReadUInt32($"Member{i}TypeOffset"); var memberTypeReader = reader.CopyAtOffset($"Member{i}TypeReader", memberInfoReader, (int)typeOffset); result.Members.Add(DebugConstantType.Parse(reader, memberTypeReader)); } } return(result); }
public static DebugConstantBuffer Parse( DebugBytecodeReader reader, DebugBytecodeReader constantBufferReader, DebugShaderVersion target) { uint nameOffset = constantBufferReader.ReadUInt32("nameOffset"); var nameReader = reader.CopyAtOffset("nameReader", constantBufferReader, (int)nameOffset); var name = nameReader.ReadString("name"); uint variableCount = constantBufferReader.ReadUInt32("variableCount"); uint variableOffset = constantBufferReader.ReadUInt32("variableOffset"); var result = new DebugConstantBuffer { Name = name }; var variableReader = reader.CopyAtOffset("variableReader", constantBufferReader, (int)variableOffset); for (int i = 0; i < variableCount; i++) { variableReader.AddIndent($"Variable {i}"); result.Variables.Add(DebugShaderVariable.Parse(reader, variableReader, target, i == 0)); variableReader.RemoveIndent(); } result.Size = constantBufferReader.ReadUInt32("size"); result.Flags = (ConstantBufferFlags)constantBufferReader.ReadUInt32("Flags"); result.BufferType = (ConstantBufferType)constantBufferReader.ReadUInt32("BufferType"); return(result); }
internal static DebugEffectNumericVariable Parse(DebugBytecodeReader reader, DebugBytecodeReader variableReader, DebugShaderVersion version, bool isShared) { var result = new DebugEffectNumericVariable(); 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); var semanticOffset = result.SemanticOffset = variableReader.ReadUInt32("SemeanticOffset"); if (semanticOffset != 0) { var semanticReader = reader.CopyAtOffset("SemanticReader", variableReader, (int)semanticOffset); result.Semantic = semanticReader.ReadString("Semantic"); } else { result.Semantic = ""; } result.BufferOffset = variableReader.ReadUInt32("BufferOffset"); var defaultValueOffset = result.DefaultValueOffset = variableReader.ReadUInt32("DefaultValueOffset"); List <Number> defaultValue = null; var size = result.Type.PackedSize; 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("Number", 4))); } } result.DefaultValue = defaultValue; if (!isShared) { result.ExplicitBindPoint = variableReader.ReadUInt32("ExplicitBindPoint"); //TODO: Unknown1 //Debug.Assert(result.Unknown1 == 0, $"EffectBufferVariable.Unknown1 {result.Unknown1}"); } 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); }
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 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 new static DebugEffectVariableIndexAssignment Parse(DebugBytecodeReader reader, DebugBytecodeReader assignmentReader) { var result = new DebugEffectVariableIndexAssignment(); var arrayNameOffset = result.ArrayNameOffset = assignmentReader.ReadUInt32("ArrayNameOffset"); var arrayNameReader = reader.CopyAtOffset("ArrayNameReader", assignmentReader, (int)arrayNameOffset); result.ArrayName = arrayNameReader.ReadString("ArrayName"); var variableNameOffset = result.VariableNameOffset = assignmentReader.ReadUInt32("VariableNameOffset"); var variableNameReader = reader.CopyAtOffset("VariableNameReader", assignmentReader, (int)variableNameOffset); result.VariableName = variableNameReader.ReadString("VariableName"); return(result); }
public static DebugInterfacesChunk Parse(DebugBytecodeReader reader, uint sizeInBytes) { var headerReader = reader.CopyAtCurrentPosition("InterfaceHeaderReader", reader); var result = new DebugInterfacesChunk(); var classInstanceCount = headerReader.ReadUInt32("classInstanceCount"); var classTypeCount = headerReader.ReadUInt32("classTypeCount"); var interfaceSlotRecordCount = headerReader.ReadUInt32("interfaceSlotRecordCount"); // Will be same as interfaceSlotRecordCount unless there are interface arrays. result.InterfaceSlotCount = headerReader.ReadUInt32("InterfaceSlotCount"); headerReader.ReadUInt32("Think this is offset to start of interface slot info, but we don't need it."); // Think this is offset to start of interface slot info, but we don't need it. var classTypeOffset = headerReader.ReadUInt32("classTypeOffset"); var availableClassReader = reader.CopyAtOffset("availableClassReader", headerReader, (int)classTypeOffset); var interfaceSlotOffset = headerReader.ReadUInt32("interfaceSlotOffset"); var interfaceSlotReader = reader.CopyAtOffset("interfaceSlotReader", headerReader, (int)interfaceSlotOffset); var unknown1 = headerReader.ReadBytes("InterfaceChunkUnknown1", 4); var unknown2 = headerReader.ReadUInt16("InterfaceChunkUnknown2"); var unknown3 = headerReader.ReadUInt16("InterfaceChunkUnknown3"); for (uint i = 0; i < classTypeCount; i++) { var classType = DebugClassType.Parse(reader, availableClassReader); classType.ID = i; // Really?? result.AvailableClassTypes.Add(classType); } for (uint i = 0; i < classInstanceCount; i++) { var classInstance = DebugClassInstance.Parse(reader, availableClassReader); result.AvailableClassInstances.Add(classInstance); } uint startSlot = 0; for (uint i = 0; i < interfaceSlotRecordCount; i++) { var interfaceSlot = DebugInterfaceSlot.Parse(reader, interfaceSlotReader); interfaceSlot.StartSlot = startSlot; // Really?? result.InterfaceSlots.Add(interfaceSlot); startSlot += interfaceSlot.SlotSpan; } return(result); }
public static DebugEffectBuffer Parse(DebugBytecodeReader reader, DebugBytecodeReader bufferReader, DebugShaderVersion version, bool isShared) { var result = new DebugEffectBuffer(); var nameOffset = result.NameOffset = bufferReader.ReadUInt32("NameOffset"); var nameReader = reader.CopyAtOffset("NameReader", bufferReader, (int)nameOffset); result.Name = nameReader.ReadString("Name"); result.BufferSize = bufferReader.ReadUInt32("BufferSize"); result.BufferType = (ConstantBufferType)bufferReader.ReadUInt32("BufferType"); result.VariableCount = bufferReader.ReadUInt32("VariableCount"); result.RegisterNumber = bufferReader.ReadUInt32("RegisterNumber"); if (!isShared) { result.Unknown0 = bufferReader.ReadUInt32("Unknown0"); } //TODO: Unknown0 //Debug.Assert(result.Unknown0 == 0, $"EffectBuffer.Unknown0: {result.Unknown0}"); for (int i = 0; i < result.VariableCount; i++) { bufferReader.AddIndent($"BufferVariable {i}"); result.Variables.Add(DebugEffectNumericVariable.Parse(reader, bufferReader, version, isShared)); bufferReader.RemoveIndent(); } 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 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 DebugAnnotation Parse(DebugBytecodeReader reader, DebugBytecodeReader annotationReader) { var result = new DebugAnnotation(); result.ParameterOffset = annotationReader.ReadUInt32("ParameterOffset"); result.ValueOffset = annotationReader.ReadUInt32("ValueOffset"); var parameterReader = reader.CopyAtOffset("AnnotationType", annotationReader, (int)result.ParameterOffset); result.Parameter = DebugParameter.Parse(reader, parameterReader); var valueReader = reader.CopyAtOffset("ValueReader", annotationReader, (int)result.ValueOffset); result.Values = result.Parameter.ReadParameterValue(valueReader); return(result); }
public new static DebugEffectInlineShaderAssignment Parse(DebugBytecodeReader reader, DebugBytecodeReader assignmentReader) { var result = new DebugEffectInlineShaderAssignment(); var shaderOffset = result.ShaderOffset = assignmentReader.ReadUInt32("ShaderOffset"); var SODeclOffset = result.SODeclOffset = assignmentReader.ReadUInt32("DODeclOffset"); var shaderReader = reader.CopyAtOffset("ShaderReader", assignmentReader, (int)shaderOffset); var shaderSize = shaderReader.ReadUInt32("ShaderSize"); if (shaderSize != 0) { result.Shader = BytecodeContainer.Parse(shaderReader.ReadBytes("Shader", (int)shaderSize)); } var SODeclReader = reader.CopyAtOffset("SODeclReader", assignmentReader, (int)SODeclOffset); result.SODecl = SODeclReader.ReadString("SODecl"); return(result); }
public new static DebugEffectExpressionIndexAssignment Parse(DebugBytecodeReader reader, DebugBytecodeReader assignmentReader) { var result = new DebugEffectExpressionIndexAssignment(); var arrayNameOffset = result.ArrayNameOffset = assignmentReader.ReadUInt32("ArrayNameOffset"); var arrayNameReader = reader.CopyAtOffset("ArrayNameReader", assignmentReader, (int)arrayNameOffset); result.ArrayName = arrayNameReader.ReadString("ArrayName"); var shaderOffset = result.ShaderOffset = assignmentReader.ReadUInt32("ShaderOffset"); var shaderReader = reader.CopyAtOffset("ShaderReader", assignmentReader, (int)shaderOffset); var shaderSize = result.ShaderSize = shaderReader.ReadUInt32("ShaderSize"); if (shaderSize != 0) { result.Shader = DebugBytecodeContainer.Parse(shaderReader.CopyAtCurrentPosition("ExpressionIndexReader", shaderReader)); } return(result); }
public static DebugAssignment Parse(DebugBytecodeReader reader, DebugBytecodeReader assignmentReader) { var result = new DebugAssignment(); result.Type = assignmentReader.ReadEnum32 <StateType>("Type"); result.ArrayIndex = assignmentReader.ReadUInt32("ArrayIndex"); result.TypeOffset = assignmentReader.ReadUInt32("TypeOffset"); result.ValueOffset = assignmentReader.ReadUInt32("ValueOffset"); var variableReader = reader.CopyAtOffset("AssignmentTypeReader", assignmentReader, (int)result.TypeOffset); result.Parameter = DebugParameter.Parse(reader, variableReader); var valueReader = reader.CopyAtOffset("ValueReader", assignmentReader, (int)result.ValueOffset); result.Value = result.Parameter.ReadParameterValue(valueReader); return(result); }
public static DebugEffectGSSOInitializer Parse(DebugBytecodeReader reader, DebugBytecodeReader variableReader) { var result = new DebugEffectGSSOInitializer(); var shaderOffset = result.ShaderOffset = variableReader.ReadUInt32("ShaderOffset"); var SODeclOffset = result.SODeclOffset = variableReader.ReadUInt32("SODeclOffset"); var bytecodeReader = reader.CopyAtOffset("BytecodeReader", variableReader, (int)shaderOffset); var shaderSize = bytecodeReader.ReadUInt32("ShaderSize"); if (shaderSize != 0) { result.Shader = BytecodeContainer.Parse(bytecodeReader.ReadBytes("Shader", (int)shaderSize)); } var declReader = reader.CopyAtOffset("DeclReader", variableReader, (int)SODeclOffset); result.SODecl = declReader.ReadString("SODecl"); return(result); }
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 DebugParameter Parse(DebugBytecodeReader reader, DebugBytecodeReader variableReader) { var result = new DebugParameter(); result.ParameterType = variableReader.ReadEnum32 <ParameterType>("ParameterType"); result.ParameterClass = variableReader.ReadEnum32 <ParameterClass>("ParameterClass"); result.NameOffset = variableReader.ReadUInt32("NameOffset"); var nameReader = reader.CopyAtOffset("NameReader", variableReader, (int)result.NameOffset); result.Name = nameReader.TryReadString("Name"); result.SemanticOffset = variableReader.ReadUInt32("SemanticOffset"); var semanticReader = reader.CopyAtOffset("SemanticReader", variableReader, (int)result.SemanticOffset); result.Semantic = semanticReader.TryReadString("Semantic"); if (result.ParameterClass == ParameterClass.Scalar || result.ParameterClass == ParameterClass.Vector || result.ParameterClass == ParameterClass.MatrixRows || result.ParameterClass == ParameterClass.MatrixColumns) { result.Elements = variableReader.ReadUInt32("ElementCount"); result.Rows = variableReader.ReadUInt32("Rows"); result.Columns = variableReader.ReadUInt32("Columns"); } if (result.ParameterClass == ParameterClass.Struct) { result.Elements = variableReader.ReadUInt32("ElementCount"); result.StructMemberCount = variableReader.ReadUInt32("StructMemberCount"); for (int i = 0; i < result.StructMemberCount; i++) { result.StructMembers.Add(DebugParameter.Parse(reader, variableReader)); } } if (result.ParameterClass == ParameterClass.Object) { result.Elements = variableReader.ReadUInt32("Elements"); } return(result); }
public static DebugShaderTypeMember Parse(DebugBytecodeReader reader, DebugBytecodeReader memberReader, DebugShaderVersion target, int indent, bool isFirst, uint parentOffset) { var nameOffset = memberReader.ReadUInt32("nameOffset"); var nameReader = reader.CopyAtOffset("nameReader", memberReader, (int)nameOffset); var name = nameReader.ReadString("name"); var memberTypeOffset = memberReader.ReadUInt32("memberTypeOffset"); var offset = memberReader.ReadUInt32("offset"); var memberTypeReader = reader.CopyAtOffset("memberTypeReader", memberReader, (int)memberTypeOffset); var memberType = DebugShaderType.Parse(reader, memberTypeReader, target, indent, isFirst, parentOffset + offset); return(new DebugShaderTypeMember(parentOffset) { Name = name, Type = memberType, Offset = offset }); }
public static DebugEffectShaderData5 Parse(DebugBytecodeReader reader, DebugBytecodeReader variableReader) { var result = new DebugEffectShaderData5(); var shaderOffset = result.ShaderOffset = variableReader.ReadUInt32("ShaderOffset"); result.SODeclsOffset[0] = variableReader.ReadUInt32("SODeclsOffset0"); result.SODeclsOffset[1] = variableReader.ReadUInt32("SODeclsOffset1"); result.SODeclsOffset[2] = variableReader.ReadUInt32("SODeclsOffset2"); result.SODeclsOffset[3] = variableReader.ReadUInt32("SODeclsOffset3"); var SoDeclsCount = result.SODeclsCount = variableReader.ReadUInt32("SoDeclsCount"); result.RasterizedStream = variableReader.ReadUInt32("RasterizedStream"); var interfaceBindingCount = result.InterfaceBindingCount = variableReader.ReadUInt32("InterfaceBindingCount"); var interfaceBindingOffset = result.InterfaceBindingOffset = variableReader.ReadUInt32("InterfaceBindingOffset"); var shaderReader = reader.CopyAtOffset("ShaderReader", variableReader, (int)shaderOffset); var shaderSize = shaderReader.ReadUInt32("ShaderSize"); if (shaderSize != 0) { result.Shader = BytecodeContainer.Parse(shaderReader.ReadBytes("Shader", (int)shaderSize)); } for (int i = 0; i < 4; i++) { var offset = result.SODeclsOffset[i]; if (offset != 0) { var soDeclReader = reader.CopyAtOffset("SODeclReader", variableReader, (int)offset); result.SODecls.Add(soDeclReader.ReadString("SODecls")); } } var interfaceReader = reader.CopyAtOffset("InterfaceReader", variableReader, (int)interfaceBindingOffset); for (int i = 0; i < interfaceBindingCount; i++) { result.InterfaceBindings.Add(DebugEffectInterfaceInitializer.Parse(reader, interfaceReader)); } 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 }); }
public static DebugEffectShaderData Parse(DebugBytecodeReader reader, DebugBytecodeReader variableReader) { var result = new DebugEffectShaderData(); var shaderOffset = result.ShaderOffset = variableReader.ReadUInt32("ShaderOffset"); var bytecodeReader = reader.CopyAtOffset("BytecodeReader", variableReader, (int)shaderOffset); var shaderSize = bytecodeReader.ReadUInt32("ShaderSize"); if (shaderSize != 0) { result.Shader = BytecodeContainer.Parse(bytecodeReader.ReadBytes("Shader", (int)shaderSize)); } return(result); }
public static DebugClassType Parse(DebugBytecodeReader reader, DebugBytecodeReader classTypeReader) { var nameOffset = classTypeReader.ReadUInt32("nameOffset"); var nameReader = reader.CopyAtOffset("nameReader", classTypeReader, (int)nameOffset); return(new DebugClassType { Name = nameReader.ReadString("Name"), ID = classTypeReader.ReadUInt16("ID"), ConstantBufferStride = classTypeReader.ReadUInt16("ConstantBufferStride"), Texture = classTypeReader.ReadUInt16("Texture"), Sampler = classTypeReader.ReadUInt16("Sampler") }); }