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