public static DebugEffectType Parse(DebugBytecodeReader reader, DebugBytecodeReader typeReader, DebugShaderVersion version)
{
var result = new DebugEffectType();
var typeNameOffset = result.TypeNameOffset = typeReader.ReadUInt32("TypeNameOffset");
var nameReader = reader.CopyAtOffset("NameReader", typeReader, (int)typeNameOffset);
result.TypeName = nameReader.ReadString("TypeName");
result.EffectVariableType = typeReader.ReadEnum32 <EffectVariableType>("EffectVariableType");
result.ElementCount = typeReader.ReadUInt32("ElementCount");
result.UnpackedSize = typeReader.ReadUInt32("UnpackedSize");
result.Stride = typeReader.ReadUInt32("Stride");
result.PackedSize = typeReader.ReadUInt32("PackedSize");
if (result.EffectVariableType == EffectVariableType.Numeric)
{
var type = result.PackedType = typeReader.ReadUInt32("PackedType");
var numericType = result.NumericType = EffectNumericType.Parse(type);
switch (numericType.NumericLayout)
{
case EffectNumericLayout.Scalar:
result.VariableClass = ShaderVariableClass.Scalar;
break;
case EffectNumericLayout.Vector:
result.VariableClass = ShaderVariableClass.Vector;
break;
case EffectNumericLayout.Matrix:
result.VariableClass = type.DecodeValue(14, 14) == 1 ?
ShaderVariableClass.MatrixColumns :
ShaderVariableClass.MatrixRows;
break;
}
switch (numericType.ScalarType)
{
case EffectScalarType.Float:
result.ObjectType = EffectObjectType.Float;
break;
case EffectScalarType.Int:
result.ObjectType = EffectObjectType.Int;
break;
case EffectScalarType.UInt:
result.ObjectType = EffectObjectType.UInt;
break;
case EffectScalarType.Bool:
result.ObjectType = EffectObjectType.Bool;
break;
}
}
else if (result.EffectVariableType == EffectVariableType.Object)
{
var type = result.PackedType = typeReader.ReadUInt32("PackedType");
result.VariableClass = ShaderVariableClass.Object;
result.ObjectType = (EffectObjectType)type;
}
else if (result.EffectVariableType == EffectVariableType.Struct)
{
result.ObjectType = EffectObjectType.Void;
result.VariableClass = ShaderVariableClass.Struct;
result.MemberCount = typeReader.ReadUInt32("MemberCount");
for (int i = 0; i < result.MemberCount; i++)
{
typeReader.AddIndent($"Member {i}");
result.Members.Add(DebugEffectMember.Parse(reader, typeReader, version));
typeReader.RemoveIndent();
}
if (version.MajorVersion == 5)
{
result.BaseClassType = typeReader.ReadUInt32("BaseClassType");
result.InterfaceCount = typeReader.ReadUInt32("InterfaceCount");
for (int i = 0; i < result.InterfaceCount; i++)
{
var interfaceOffset = typeReader.ReadUInt32($"InterfaceOffset{i}");
var interfaceReader = reader.CopyAtOffset($"Interface{i}", typeReader, (int)interfaceOffset);
result.InterfaceTypes.Add(DebugEffectType.Parse(reader, interfaceReader, version));
}
}
}
else if (result.EffectVariableType == EffectVariableType.Interface)
{
result.VariableClass = ShaderVariableClass.InterfaceClass;
result.ObjectType = EffectObjectType.Interface;
}
return(result);
}
public static DebugBytecodeChunk Parse(DebugBytecodeReader reader, uint chunkSize)
{
var size = chunkSize / sizeof(uint);
var magic = reader.PeekUInt32Ahead(8);
if (magic == "DXIL".ToFourCc())
{
return(Dxil.DebugDxilReflectionChunk.Parse(reader, chunkSize));
}
var result = new DebugStatisticsChunk
{
InstructionCount = reader.ReadUInt32("InstructionCount"),
TempRegisterCount = reader.ReadUInt32("TempRegisterCount"),
DefineCount = reader.ReadUInt32("DefineCount"),
DeclarationCount = reader.ReadUInt32("DeclarationCount"),
FloatInstructionCount = reader.ReadUInt32("FloatInstructionCount"),
IntInstructionCount = reader.ReadUInt32("IntInstructionCount"),
UIntInstructionCount = reader.ReadUInt32("UIntInstructionCount"),
StaticFlowControlCount = reader.ReadUInt32("StaticFlowControlCount"),
DynamicFlowControlCount = reader.ReadUInt32("DynamicFlowControlCount"),
MacroInstructionCount = reader.ReadUInt32("MacroInstructionCount"), // Guessed
TempArrayCount = reader.ReadUInt32("TempArrayCount"),
ArrayInstructionCount = reader.ReadUInt32("ArrayInstructionCount"),
CutInstructionCount = reader.ReadUInt32("CutInstructionCount"),
EmitInstructionCount = reader.ReadUInt32("EmitInstructionCount"),
TextureNormalInstructions = reader.ReadUInt32("TextureNormalInstructions"),
TextureLoadInstructions = reader.ReadUInt32("TextureLoadInstructions"),
TextureCompInstructions = reader.ReadUInt32("TextureCompInstructions"),
TextureBiasInstructions = reader.ReadUInt32("TextureBiasInstructions"),
TextureGradientInstructions = reader.ReadUInt32("TextureGradientInstructions"),
MovInstructionCount = reader.ReadUInt32("MovInstructionCount"),
MovCInstructionCount = reader.ReadUInt32("MovCInstructionCount"),
ConversionInstructionCount = reader.ReadUInt32("ConversionInstructionCount")
};
//TODO
var unknown0 = reader.ReadUInt32("StatisticsChunkUnknown0");
result.InputPrimitive = (Primitive)reader.ReadUInt32("InputPrimitive");
result.GeometryShaderOutputTopology = reader.ReadEnum32 <PrimitiveTopology>("GeometryShaderOutputTopology");
result.GeometryShaderMaxOutputVertexCount = reader.ReadUInt32("GeometryShaderMaxOutputVertexCount");
var unknown1 = reader.ReadUInt32("StatisticsChunkUnknown1");
//if (unknown1 == 0 || unknown1 == 1 || unknown1 == 3) throw new System.Exception($"unknown1 is {unknown1}");
//TODO: CheckAccessFullyMapped textures have large unknown1
//Texture_Texture2D, Texture_Texture2DArray, Texture_TextureCube, Texture_TextureCubeArray
var unknown2 = reader.ReadUInt32("StatisticsChunkUnknown2");
//if (unknown2 != 0 && unknown2 != 2) throw new System.Exception($"unknown2 is {unknown2}");
result.IsSampleFrequencyShader = (reader.ReadUInt32("IsSampleFrequencyShader") == 1);
// DX10 stat size
if (size == 29)
{
return(result);
}
result.GeometryShaderInstanceCount = reader.ReadUInt32("GeometryShaderInstanceCount");
result.ControlPoints = reader.ReadUInt32("ControlPoints");
result.HullShaderOutputPrimitive = reader.ReadEnum32 <TessellatorOutputPrimitive>("HullShaderOutputPrimitive");
result.HullShaderPartitioning = reader.ReadEnum32 <TessellatorPartitioning>("HullShaderPartitioning");
result.TessellatorDomain = reader.ReadEnum32 <TessellatorDomain>("TessellatorDomain");
result.BarrierInstructions = reader.ReadUInt32("BarrierInstructions");
result.InterlockedInstructions = reader.ReadUInt32("InterlockedInstructions");
result.TextureStoreInstructions = reader.ReadUInt32("TextureStoreInstructions");
// DX11 stat size.
if (size == 37)
{
return(result);
}
throw new ParseException("Unhandled stat size: " + chunkSize);
}
public static List <Number> ReadParameterValue(this DebugParameter parameter, DebugBytecodeReader valueReader)
{
var result = new List <Number>();
if (parameter.ParameterClass == ParameterClass.Object)
{
var defaultValueCount = parameter.GetSize() / 4;
var data = valueReader.ReadBytes("ParameterValue", (int)defaultValueCount * 4);
result.Add(new Number(data));
}
else
{
var defaultValueCount = parameter.GetSize() / 4;
var data = valueReader.ReadBytes("ParameterValue", (int)defaultValueCount * 4);
for (int i = 0; i < defaultValueCount; i++)
{
result.Add(Number.FromByteArray(data, i * 4));
}
}
return(result);
}
public static DebugSignatureParameterDescription Parse(DebugBytecodeReader reader, DebugBytecodeReader parameterReader,
ChunkType chunkType, SignatureElementSize size, ProgramType programType)
{
uint stream = 0;
if (size == SignatureElementSize._7 || size == SignatureElementSize._8)
{
stream = parameterReader.ReadUInt32("Stream");
}
uint nameOffset = parameterReader.ReadUInt32("NameOffset");
var nameReader = reader.CopyAtOffset("NameReader", parameterReader, (int)nameOffset);
var result = new DebugSignatureParameterDescription
{
SemanticName = nameReader.ReadString("SemanticName"),
SemanticIndex = parameterReader.ReadUInt32("SemanticIndex"),
SystemValueType = parameterReader.ReadEnum32 <Name>("SystemValueType"),
ComponentType = parameterReader.ReadEnum32 <RegisterComponentType>("ComponentType"),
Register = parameterReader.ReadUInt32("Register"),
Stream = stream,
};
result.Mask = parameterReader.ReadEnum8 <ComponentMask>("Mask");
result.ReadWriteMask = parameterReader.ReadEnum8 <ComponentMask>("ReadWriteMask");
parameterReader.ReadUInt16("MaskPadding");
if (size == SignatureElementSize._8)
{
MinPrecision minPrecision = parameterReader.ReadEnum32 <MinPrecision>("MinPrecision");
result.MinPrecision = minPrecision;
}
// This is my guesswork, but it works so far...
if (chunkType == ChunkType.Osg5 ||
chunkType == ChunkType.Osgn ||
chunkType == ChunkType.Osg1 ||
(chunkType == ChunkType.Pcsg && programType == ProgramType.HullShader))
{
result.ReadWriteMask = (ComponentMask)(ComponentMask.All - result.ReadWriteMask);
}
// Vertex and pixel shaders need special handling for SystemValueType in the output signature.
if ((programType == ProgramType.PixelShader || programType == ProgramType.VertexShader) &&
(chunkType == ChunkType.Osg5 || chunkType == ChunkType.Osgn || chunkType == ChunkType.Osg1))
{
if (result.Register == 0xffffffff)
{
switch (result.SemanticName.ToUpper())
{
case "SV_DEPTH":
result.SystemValueType = Name.Depth;
break;
case "SV_COVERAGE":
result.SystemValueType = Name.Coverage;
break;
case "SV_DEPTHGREATEREQUAL":
result.SystemValueType = Name.DepthGreaterEqual;
break;
case "SV_DEPTHLESSEQUAL":
result.SystemValueType = Name.DepthLessEqual;
break;
case "SV_STENCILREF":
result.SystemValueType = Name.StencilRef;
break;
}
}
else if (programType == ProgramType.PixelShader)
{
result.SystemValueType = Name.Target;
}
}
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 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 DebugInputOutputSignatureChunk Parse(DebugBytecodeReader reader, ChunkType chunkType,
ProgramType programType)
{
DebugInputOutputSignatureChunk result;
switch (chunkType)
{
case ChunkType.Isgn:
case ChunkType.Isg1:
result = new DebugInputSignatureChunk();
break;
case ChunkType.Osgn:
case ChunkType.Osg1:
case ChunkType.Osg5:
result = new DebugOutputSignatureChunk();
break;
case ChunkType.Pcsg:
result = new DebugPatchConstantSignatureChunk();
break;
default:
throw new ArgumentOutOfRangeException("chunkType", "Unrecognised chunk type: " + chunkType);
}
var chunkReader = reader.CopyAtCurrentPosition("ChunkReader", reader);
var elementCount = chunkReader.ReadUInt32("ElementCount");
var uniqueKey = chunkReader.ReadUInt32("UniqueKey");
SignatureElementSize elementSize;
switch (chunkType)
{
case ChunkType.Isgn:
case ChunkType.Osgn:
case ChunkType.Pcsg:
elementSize = SignatureElementSize._6;
break;
case ChunkType.Osg5:
elementSize = SignatureElementSize._7;
break;
case ChunkType.Osg1:
case ChunkType.Isg1:
elementSize = SignatureElementSize._8;
break;
default:
throw new ArgumentOutOfRangeException("chunkType", "Unrecognised chunk type: " + chunkType);
}
for (int i = 0; i < elementCount; i++)
{
result.Parameters.Add(DebugSignatureParameterDescription.Parse(reader, chunkReader, chunkType, elementSize,
programType));
}
return(result);
}
public static DebugResourceDefinitionChunk Parse(DebugBytecodeReader reader)
{
var headerReader = reader.CopyAtCurrentPosition("RDefHeader", reader);
uint constantBufferCount = headerReader.ReadUInt32("constantBufferCount");
uint constantBufferOffset = headerReader.ReadUInt32("constantBufferOffset");
uint resourceBindingCount = headerReader.ReadUInt32("resourceBindingCount");
uint resourceBindingOffset = headerReader.ReadUInt32("resourceBindingOffset");
var target = DebugShaderVersion.ParseRdef(headerReader);
var flags = headerReader.ReadEnum32 <ShaderFlags>("flags");
var creatorOffset = headerReader.ReadUInt32("creatorOffset");
var creatorReader = reader.CopyAtOffset("CreatorString", headerReader, (int)creatorOffset);
var creator = creatorReader.ReadString("creator");
var result = new DebugResourceDefinitionChunk
{
Target = target,
Flags = flags,
Creator = creator
};
if (target.MajorVersion == 5 || target.ProgramType == ProgramType.LibraryShader)
{
var isVersion5_1 = target.MajorVersion == 5 && target.MinorVersion == 1;
if (isVersion5_1)
{
var unknown0 = headerReader.ReadUInt32("unkRdefHeader");
}
else
{
string rd11 = headerReader.ReadUInt32("rd11").ToFourCcString();
if (rd11 != "RD11")
{
throw new ParseException("Expected RD11.");
}
}
var unkStride1 = headerReader.ReadUInt32("unkStride1"); // TODO
var constantBufferStride = headerReader.ReadUInt32("constantBufferStride");
var resourceBindingStride = headerReader.ReadUInt32("resourceBindingStride");
//Shader Variable Stride?
var unkStride2 = headerReader.ReadUInt32("unkStride2");
var unkStride3 = headerReader.ReadUInt32("unkStride3");
//Shader Type Member Stride?
var unkStride4 = headerReader.ReadUInt32("unkStride4");
Debug.Assert(unkStride1 == 60, $"unkStride1 is {unkStride1}");
Debug.Assert(constantBufferStride == 24, $"constantBufferStride is {constantBufferStride}");
Debug.Assert(resourceBindingStride == CalculateResourceBindingStride(target),
$"resourceBindingStride is {resourceBindingStride}");
Debug.Assert(unkStride2 == 40, $"unkStride2 is {unkStride2}");
Debug.Assert(unkStride3 == 36, $"unkStride3 is {unkStride3}");
Debug.Assert(unkStride4 == 12, $"unkStride4 is {unkStride4}");
result.InterfaceSlotCount = headerReader.ReadUInt32("InterfaceSlotCount");
}
var resourceBindingReader = reader.CopyAtOffset("ResourceBindings", headerReader, (int)resourceBindingOffset);
for (int i = 0; i < resourceBindingCount; i++)
{
result.ResourceBindings.Add(DebugResourceBinding.Parse(reader, resourceBindingReader, target));
}
var constantBufferReader = reader.CopyAtOffset("ContantBuffers", headerReader, (int)constantBufferOffset);
constantBufferReader.Indent++;
for (int i = 0; i < constantBufferCount; i++)
{
result.ConstantBuffers.Add(DebugConstantBuffer.Parse(reader, constantBufferReader, result.Target));
}
return(result);
}
public new static DebugEffectVariableAssignment Parse(DebugBytecodeReader reader, DebugBytecodeReader assignmentReader)
{
var result = new DebugEffectVariableAssignment();
result.Value = assignmentReader.ReadString("Value");
return(result);
}
public static DebugGeometryShaderOutputPrimitiveTopologyDeclarationToken Parse(DebugBytecodeReader reader)
{
var token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
reader.AddNote("PriomitiveTopology", token0.DecodeValue <PrimitiveTopology>(11, 17));
return(new DebugGeometryShaderOutputPrimitiveTopologyDeclarationToken
{
PrimitiveTopology = token0.DecodeValue <PrimitiveTopology>(11, 17)
});
}
public new static DebugEffectExpressionAssignment Parse(DebugBytecodeReader reader, DebugBytecodeReader assignmentReader)
{
var result = new DebugEffectExpressionAssignment();
var shaderSize = assignmentReader.ReadUInt32("ShaderSize");
if (shaderSize != 0)
{
result.Shader = DebugBytecodeContainer.Parse(assignmentReader.CopyAtCurrentPosition("ExpressionReader", assignmentReader));
}
return(result);
}
public static DebugDeclarationToken Parse(DebugBytecodeReader reader, OpcodeType opcodeType, DebugShaderVersion version)
{
switch (opcodeType)
{
case OpcodeType.DclGlobalFlags:
return(DebugGlobalFlagsDeclarationToken.Parse(reader));
case OpcodeType.DclResource:
return(DebugResourceDeclarationToken.Parse(reader, version));
case OpcodeType.DclSampler:
return(DebugSamplerDeclarationToken.Parse(reader, version));
case OpcodeType.DclInput:
case OpcodeType.DclInputSgv:
case OpcodeType.DclInputSiv:
case OpcodeType.DclInputPs:
case OpcodeType.DclInputPsSgv:
case OpcodeType.DclInputPsSiv:
return(DebugInputRegisterDeclarationToken.Parse(reader));
case OpcodeType.DclOutput:
case OpcodeType.DclOutputSgv:
case OpcodeType.DclOutputSiv:
return(DebugOutputRegisterDeclarationToken.Parse(reader));
case OpcodeType.DclIndexRange:
return(DebugIndexingRangeDeclarationToken.Parse(reader));
case OpcodeType.DclTemps:
return(DebugTempRegisterDeclarationToken.Parse(reader));
case OpcodeType.DclIndexableTemp:
return(DebugIndexableTempRegisterDeclarationToken.Parse(reader));
case OpcodeType.DclConstantBuffer:
return(DebugConstantBufferDeclarationToken.Parse(reader, version));
case OpcodeType.DclGsInputPrimitive:
return(DebugGeometryShaderInputPrimitiveDeclarationToken.Parse(reader));
case OpcodeType.DclGsOutputPrimitiveTopology:
return(DebugGeometryShaderOutputPrimitiveTopologyDeclarationToken.Parse(reader));
case OpcodeType.DclMaxOutputVertexCount:
return(DebugGeometryShaderMaxOutputVertexCountDeclarationToken.Parse(reader));
case OpcodeType.DclGsInstanceCount:
return(DebugGeometryShaderInstanceCountDeclarationToken.Parse(reader));
case OpcodeType.DclInputControlPointCount:
case OpcodeType.DclOutputControlPointCount:
return(DebugControlPointCountDeclarationToken.Parse(reader));
case OpcodeType.DclTessDomain:
return(DebugTessellatorDomainDeclarationToken.Parse(reader));
case OpcodeType.DclTessPartitioning:
return(DebugTessellatorPartitioningDeclarationToken.Parse(reader));
case OpcodeType.DclTessOutputPrimitive:
return(DebugTessellatorOutputPrimitiveDeclarationToken.Parse(reader));
case OpcodeType.DclHsMaxTessFactor:
return(DebugHullShaderMaxTessFactorDeclarationToken.Parse(reader));
case OpcodeType.DclHsForkPhaseInstanceCount:
return(DebugHullShaderForkPhaseInstanceCountDeclarationToken.Parse(reader));
case OpcodeType.DclFunctionBody:
return(DebugFunctionBodyDeclarationToken.Parse(reader));
case OpcodeType.DclFunctionTable:
return(DebugFunctionTableDeclarationToken.Parse(reader));
case OpcodeType.DclInterface:
return(DebugInterfaceDeclarationToken.Parse(reader));
case OpcodeType.DclThreadGroup:
return(DebugThreadGroupDeclarationToken.Parse(reader));
case OpcodeType.DclUnorderedAccessViewTyped:
return(DebugTypedUnorderedAccessViewDeclarationToken.Parse(reader, version));
case OpcodeType.DclUnorderedAccessViewRaw:
return(DebugRawUnorderedAccessViewDeclarationToken.Parse(reader, version));
case OpcodeType.DclUnorderedAccessViewStructured:
return(DebugStructuredUnorderedAccessViewDeclarationToken.Parse(reader, version));
case OpcodeType.DclThreadGroupSharedMemoryRaw:
return(DebugRawThreadGroupSharedMemoryDeclarationToken.Parse(reader));
case OpcodeType.DclThreadGroupSharedMemoryStructured:
return(DebugStructuredThreadGroupSharedMemoryDeclarationToken.Parse(reader));
case OpcodeType.DclResourceRaw:
return(DebugRawShaderResourceViewDeclarationToken.Parse(reader, version));
case OpcodeType.DclResourceStructured:
return(DebugStructuredShaderResourceViewDeclarationToken.Parse(reader, version));
case OpcodeType.DclStream:
return(DebugStreamDeclarationToken.Parse(reader));
default:
throw new ParseException("OpcodeType '" + opcodeType + "' is not supported.");
}
}
public static DebugShaderType Parse(DebugBytecodeReader reader, DebugBytecodeReader typeReader, DebugShaderVersion target,
int indent, bool isFirst, uint parentOffset)
{
var result = new DebugShaderType(indent, isFirst)
{
VariableClass = typeReader.ReadEnum16 <ShaderVariableClass>("VariableClass"),
VariableType = typeReader.ReadEnum16 <ShaderVariableType>("VariableType"),
Rows = typeReader.ReadUInt16("Rows"),
Columns = typeReader.ReadUInt16("Columns"),
ElementCount = typeReader.ReadUInt16("ElementCount")
};
var memberCount = typeReader.ReadUInt16("memberCount");
var memberOffset = typeReader.ReadUInt32("memberOffset");
if (target.MajorVersion >= 5)
{
var subTypeOffset = typeReader.ReadInt32("subTypeOffset"); // Guessing
if (subTypeOffset != 0)
{
var parentInterfaceReader = reader.CopyAtOffset("subtypeReader", typeReader, (int)subTypeOffset);
result.SubType = DebugShaderType.Parse(reader, parentInterfaceReader, target,
indent + 4, true, parentOffset);
}
var baseClassOffset = typeReader.ReadUInt32("baseClassOffset");
if (baseClassOffset != 0)
{
var baseClassReader = reader.CopyAtOffset("baseClassReader", typeReader, (int)baseClassOffset);
result.BaseClass = DebugShaderType.Parse(reader, baseClassReader, target,
indent + 4, true, parentOffset);
}
result.NumberOfInterfaces = typeReader.ReadUInt32("NumberOfInterfaces");
var interfaceSectionOffset = typeReader.ReadUInt32("InterfaceSectionOffset");
if (interfaceSectionOffset != 0)
{
var interfaceSectionReader = reader.CopyAtOffset("interfaceSectionReader", typeReader, (int)interfaceSectionOffset);
for (int i = 0; i < result.NumberOfInterfaces; i++)
{
var interfaceTypeOffset = interfaceSectionReader.ReadUInt32($"UnkInterface{i}");
var interfaceReader = reader.CopyAtOffset($"InterfaceReader {i}", typeReader, (int)interfaceTypeOffset);
result.Interfaces.Add(DebugShaderType.Parse(reader, interfaceReader,
target, indent + 4, i == 0, parentOffset));
}
}
var parentNameOffset = typeReader.ReadUInt32("parentNameOffset");
if (parentNameOffset > 0)
{
var parentNameReader = reader.CopyAtOffset("parentNameOffset", typeReader, (int)parentNameOffset);
result.BaseTypeName = parentNameReader.ReadString("BaseTypeName");
}
}
if (memberCount > 0)
{
var memberReader = reader.CopyAtOffset("memberReader", typeReader, (int)memberOffset);
for (int i = 0; i < memberCount; i++)
{
memberReader.AddIndent($"Member {i}");
result.Members.Add(DebugShaderTypeMember.Parse(reader, memberReader, target, indent + 4, i == 0,
parentOffset));
memberReader.RemoveIndent();
}
}
if (target.ProgramType == ProgramType.LibraryShader && target.MajorVersion == 4)
{
var unk1 = typeReader.ReadUInt32("Unk1");
var unk2 = typeReader.ReadUInt32("Unk2");
var unk3 = typeReader.ReadUInt32("Unk3");
var unk4 = typeReader.ReadUInt32("Unk4");
var typeNameOffset = typeReader.ReadUInt32("typeNameoffset");
var typeNameReader = reader.CopyAtOffset("TypeNameReader", typeReader, (int)typeNameOffset);
typeNameReader.ReadString("TypeName");
Debug.Assert(unk1 == 0, $"ShaderType.Unk1={unk1}");
Debug.Assert(unk2 == 0, $"ShaderType.Unk2={unk2}");
Debug.Assert(unk3 == 0, $"ShaderType.Unk3={unk3}");
Debug.Assert(unk4 == 0, $"ShaderType.Unk4={unk4}");
}
return(result);
}
public static DebugOperand Parse(DebugBytecodeReader reader, OpcodeType parentType)
{
uint token0 = reader.ReadUInt32("operandToken");
if (token0 == 0)
{
return(null);
}
var member = reader.LocalMembers.Last();
var operand = new DebugOperand(parentType);
var numComponents = token0.DecodeValue <OperandNumComponents>(0, 1);
reader.AddNote("numComponents", numComponents);
switch (numComponents)
{
case OperandNumComponents.Zero:
{
operand.NumComponents = 0;
break;
}
case OperandNumComponents.One:
{
operand.NumComponents = 1;
break;
}
case OperandNumComponents.Four:
{
operand.NumComponents = 4;
operand.SelectionMode = token0.DecodeValue <Operand4ComponentSelectionMode>(2, 3);
member.AddNote("SelectionMode", operand.SelectionMode);
switch (operand.SelectionMode)
{
case Operand4ComponentSelectionMode.Mask:
{
operand.ComponentMask = token0.DecodeValue <ComponentMask>(4, 7);
member.AddNote("ComponentMask", operand.ComponentMask);
break;
}
case Operand4ComponentSelectionMode.Swizzle:
{
var swizzle = token0.DecodeValue(4, 11);
Func <uint, byte, Operand4ComponentName> swizzleDecoder = (s, i) =>
(Operand4ComponentName)((s >> (i * 2)) & 3);
operand.Swizzles[0] = swizzleDecoder(swizzle, 0);
operand.Swizzles[1] = swizzleDecoder(swizzle, 1);
operand.Swizzles[2] = swizzleDecoder(swizzle, 2);
operand.Swizzles[3] = swizzleDecoder(swizzle, 3);
member.AddNote("Swizzles[0]", operand.Swizzles[0]);
member.AddNote("Swizzles[1]", operand.Swizzles[1]);
member.AddNote("Swizzles[2]", operand.Swizzles[2]);
member.AddNote("Swizzles[3]", operand.Swizzles[3]);
break;
}
case Operand4ComponentSelectionMode.Select1:
{
var swizzle = token0.DecodeValue <Operand4ComponentName>(4, 5);
operand.Swizzles[0] = operand.Swizzles[1] = operand.Swizzles[2] = operand.Swizzles[3] = swizzle;
member.AddNote("Swizzles[0]", operand.Swizzles[0]);
member.AddNote("Swizzles[1]", operand.Swizzles[1]);
member.AddNote("Swizzles[2]", operand.Swizzles[2]);
member.AddNote("Swizzles[3]", operand.Swizzles[3]);
break;
}
default:
{
throw new ParseException("Unrecognized selection method: " + operand.SelectionMode);
}
}
break;
}
case OperandNumComponents.N:
{
throw new ParseException("OperandNumComponents.N is not currently supported.");
}
}
operand.OperandType = token0.DecodeValue <OperandType>(12, 19);
member.AddNote("OperandType", operand.OperandType);
operand.IndexDimension = token0.DecodeValue <OperandIndexDimension>(20, 21);
member.AddNote("IndexDimension", operand.IndexDimension);
operand.IsExtended = token0.DecodeValue(31, 31) == 1;
member.AddNote("IsExtended", operand.IsExtended);
if (operand.IsExtended)
{
ReadExtendedOperand(operand, reader);
}
Func <uint, byte, OperandIndexRepresentation> indexRepresentationDecoder = (t, i) =>
(OperandIndexRepresentation)t.DecodeValue((byte)(22 + (i * 3)), (byte)(22 + (i * 3) + 2));
for (byte i = 0; i < (byte)operand.IndexDimension; i++)
{
operand.Indices[i] = new DebugOperandIndex();
var indexRepresentation = indexRepresentationDecoder(token0, i);
operand.Indices[i].Representation = indexRepresentation;
member.AddNote($"Indices[{i}].Representation", operand.Indices[i].Representation);
switch (indexRepresentation)
{
case OperandIndexRepresentation.Immediate32:
operand.Indices[i].Value = reader.ReadUInt32($"Indices[{i}].Value");
break;
case OperandIndexRepresentation.Immediate64:
operand.Indices[i].Value = reader.ReadUInt64($"Indices[{i}].Value");
goto default;
case OperandIndexRepresentation.Relative:
operand.Indices[i].Register = Parse(reader, parentType);
break;
case OperandIndexRepresentation.Immediate32PlusRelative:
operand.Indices[i].Value = reader.ReadUInt32($"Indices[{i}].Value");
goto case OperandIndexRepresentation.Relative;
case OperandIndexRepresentation.Immediate64PlusRelative:
operand.Indices[i].Value = reader.ReadUInt64($"Indices[{i}].Value");
goto case OperandIndexRepresentation.Relative;
default:
throw new ParseException("Unrecognised index representation: " + indexRepresentation);
}
}
var numberType = parentType.GetNumberType();
switch (operand.OperandType)
{
case OperandType.Immediate32:
{
var immediateValues = new DebugNumber4();
for (var i = 0; i < operand.NumComponents; i++)
{
immediateValues.SetNumber(i, DebugNumber.Parse(reader));
}
operand.ImmediateValues = immediateValues;
break;
}
case OperandType.Immediate64:
{
var immediateValues = new DebugNumber4();
for (var i = 0; i < operand.NumComponents; i++)
{
immediateValues.SetDouble(i, reader.ReadDouble($"ImmediateValues[{i}]"));
}
operand.ImmediateValues = immediateValues;
break;
}
}
return(operand);
}
public static DebugEffectChunk Parse(DebugBytecodeReader reader, uint size)
{
var headerReader = reader.CopyAtCurrentPosition("Header", reader);
var result = new DebugEffectChunk();
result.Size = size;
var header = result.Header = DebugEffectHeader.Parse(headerReader);
var bodyOffset = header.Version.MajorVersion < 5 ?
0x4C : 0x60;
var footerOffset = (int)(result.Header.FooterOffset + bodyOffset);
var bodyReader = reader.CopyAtOffset("Body", reader, (int)bodyOffset);
var dummyReader = bodyReader.CopyAtCurrentPosition("DummyReader", bodyReader);
dummyReader.ReadUInt32("Zero");
var footerReader = reader.CopyAtOffset("Footer", reader, footerOffset);
var version = header.Version;
for (int i = 0; i < header.ConstantBuffers; i++)
{
footerReader.AddIndent($"ConstantBuffer {i}");
result.LocalBuffers.Add(DebugEffectBuffer.Parse(bodyReader, footerReader, version, false));
footerReader.RemoveIndent();
}
for (int i = 0; i < header.ObjectCount; i++)
{
footerReader.AddIndent($"Variable {i}");
result.LocalVariables.Add(DebugEffectObjectVariable.Parse(bodyReader, footerReader, version, false));
footerReader.RemoveIndent();
}
for (int i = 0; i < header.SharedConstantBuffers; i++)
{
footerReader.AddIndent($"SharedConstantBuffer {i}");
result.SharedBuffers.Add(DebugEffectBuffer.Parse(bodyReader, footerReader, version, true));
footerReader.RemoveIndent();
}
for (int i = 0; i < header.SharedObjectCount; i++)
{
footerReader.AddIndent($"SharedVariable {i}");
result.SharedVariables.Add(DebugEffectObjectVariable.Parse(bodyReader, footerReader, version, true));
footerReader.RemoveIndent();
}
if (header.Version.MajorVersion >= 5)
{
for (int i = 0; i < header.InterfaceVariableCount; i++)
{
footerReader.AddIndent($"Interface {i}");
result.InterfaceVariables.Add(DebugEffectInterfaceVariable.Parse(bodyReader, footerReader, version));
footerReader.RemoveIndent();
}
for (int i = 0; i < header.GroupCount; i++)
{
footerReader.AddIndent($"Group {i}");
result.Groups.Add(DebugEffectGroup.Parse(bodyReader, footerReader, header.Version));
footerReader.RemoveIndent();
}
}
else
{
for (int i = 0; i < header.Techniques; i++)
{
footerReader.AddIndent($"Technique {i}");
result.Techniques.Add(DebugEffectTechnique.Parse(bodyReader, footerReader, header.Version));
footerReader.RemoveIndent();
}
}
return(result);
}
public static DebugUnknown1Mapping Parse(DebugBytecodeReader reader)
{
var result = new DebugUnknown1Mapping();
return(result);
}
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);
}
public static DebugLevel9ShaderChunk Parse(DebugBytecodeReader chunkContentReader, uint chunkSize)
{
var result = new DebugLevel9ShaderChunk();
uint chunkSize2 = chunkContentReader.ReadUInt32("chunkSize2");
result.Version = DebugShaderVersion.ParseAon9(chunkContentReader);
uint shaderSize = chunkContentReader.ReadUInt32("shaderSize");
var shaderOffset = chunkContentReader.ReadUInt32("shaderOffset");
var cbMappingCount = chunkContentReader.ReadUInt16("cbMappingCount");
var cbMappingOffset = chunkContentReader.ReadUInt16("cbMappingOffset");
var loopRegisterMappingCount = chunkContentReader.ReadUInt16("loopRegisterMappingCount");
var loopRegisterMappingOffset = chunkContentReader.ReadUInt16("loopRegisterMappingOffset");
var unk0MappingCount = chunkContentReader.ReadUInt16("unk0MappingCount");
var unk0MappingOffset = chunkContentReader.ReadUInt16("unk0MappingOffset");
var samplerMappingCount = chunkContentReader.ReadUInt16("samplerMappingCount");
var samplerMappingOffset = chunkContentReader.ReadUInt16("samplerMappingOffset");
var runtimeConstantMappingCount = chunkContentReader.ReadUInt16("runtimeConstantMappingCount");
var runtimeConstantMappingOffset = chunkContentReader.ReadUInt16("runtimeConstantMappingOffset");
if (cbMappingCount > 0)
{
var mappingReader = chunkContentReader.CopyAtOffset("mappingReader", chunkContentReader, cbMappingOffset);
for (int i = 0; i < cbMappingCount; i++)
{
result.ConstantBufferMappings.Add(DebugConstantBufferMapping.Parse(mappingReader));
}
}
if (loopRegisterMappingCount > 0)
{
var mappingReader = chunkContentReader.CopyAtOffset("mappingReader", chunkContentReader, loopRegisterMappingOffset);
for (int i = 0; i < loopRegisterMappingCount; i++)
{
result.LoopRegisterMappings.Add(DebugLoopRegisterMapping.Parse(mappingReader));
}
}
if (unk0MappingCount > 0)
{
var mappingReader = chunkContentReader.CopyAtOffset("mappingReader", chunkContentReader, unk0MappingOffset);
for (int i = 0; i < unk0MappingCount; i++)
{
result.Unknown0Mappings.Add(DebugUnknown1Mapping.Parse(mappingReader));
}
}
if (samplerMappingCount > 0)
{
var mappingReader = chunkContentReader.CopyAtOffset("mappingReader", chunkContentReader, samplerMappingOffset);
for (int i = 0; i < samplerMappingCount; i++)
{
result.SamplerMappings.Add(DebugSamplerMapping.Parse(mappingReader));
}
// FXC dissassembly sorts sampler mappings
result.SamplerMappings = result.SamplerMappings
.OrderBy(s => s.TargetSampler)
.ToList();
}
if (runtimeConstantMappingCount > 0)
{
var mappingReader = chunkContentReader.CopyAtOffset("mappingReader", chunkContentReader, runtimeConstantMappingOffset);
for (int i = 0; i < runtimeConstantMappingCount; i++)
{
result.RuntimeConstantMappings.Add(DebugRuntimeConstantMapping.Parse(mappingReader));
}
}
var shaderChunkReader = chunkContentReader.CopyAtOffset("shaderChunkReader", chunkContentReader, (int)shaderOffset);
var byteCode = shaderChunkReader.ReadBytes("bytecode", (int)shaderSize);
return(result);
}
public new static DebugEffectInlineShader5Assignment Parse(DebugBytecodeReader reader, DebugBytecodeReader variableReader)
{
var result = new DebugEffectInlineShader5Assignment();
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("InterfaceBindinfOffset");
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($"SODecl{i}"));
}
}
var interfaceReader = reader.CopyAtOffset("InterfaceReader", variableReader, (int)interfaceBindingOffset);
for (int i = 0; i < interfaceBindingCount; i++)
{
result.InterfaceBindings.Add(DebugEffectInterfaceInitializer.Parse(reader, interfaceReader));
}
return(result);
}
static void Main(string[] args)
{
var options = new Options();
for (int i = 0; i < args.Length; i++)
{
switch (args[i])
{
case "-O":
if (args.Length <= i + 1)
{
Console.Error.WriteLine("No output path specified");
return;
}
options.DestPath = args[i + 1];
i += 1;
break;
case "-a":
options.Mode = DecompileMode.Dissassemble;
break;
case "-d":
options.Mode = DecompileMode.Debug;
break;
case "-h":
options.Mode = DecompileMode.DebugHtml;
break;
default:
options.SourcePath = args[i];
break;
}
}
if (string.IsNullOrEmpty(options.SourcePath))
{
Console.Error.WriteLine("No source path specified");
Environment.Exit(1);
}
byte[] data = null;
try
{
data = File.ReadAllBytes(options.SourcePath);
}
catch (Exception ex)
{
Console.Error.WriteLine("Error reading source");
Console.Error.WriteLine(ex);
Environment.Exit(1);
}
var programType = GetProgramType(data);
using (var sw = GetStream(options))
{
if (programType == ProgramType.Unknown)
{
Console.Error.WriteLine($"Unable to identify shader object format");
Environment.Exit(1);
}
else if (programType == ProgramType.DXBC)
{
if (options.Mode == DecompileMode.Dissassemble)
{
var container = new BytecodeContainer(data);
sw.Write(container.ToString());
}
else if (options.Mode == DecompileMode.Decompile)
{
var hlsl = HLSLDecompiler.Decompile(data);
sw.Write(hlsl);
}
else if (options.Mode == DecompileMode.Debug)
{
sw.WriteLine(string.Join(" ", args));
var shaderBytecode = DebugBytecodeContainer.Parse(data);
var result = shaderBytecode.Dump();
sw.Write(result);
}
else if (options.Mode == DecompileMode.DebugHtml)
{
var shaderBytecode = DebugBytecodeContainer.Parse(data);
var result = shaderBytecode.DumpHTML();
sw.Write(result);
}
}
else if (programType == ProgramType.DX9)
{
if (options.Mode == DecompileMode.Dissassemble)
{
var disasm = DXDecompiler.DX9Shader.AsmWriter.Disassemble(data);
sw.Write(disasm);
}
else if (options.Mode == DecompileMode.Decompile)
{
var hlsl = DXDecompiler.DX9Shader.HlslWriter.Decompile(data);
sw.Write(hlsl);
}
else if (options.Mode == DecompileMode.Debug)
{
sw.WriteLine(string.Join(" ", args));
var shaderType = (DXDecompiler.DX9Shader.ShaderType)BitConverter.ToUInt16(data, 2);
if (shaderType == DXDecompiler.DX9Shader.ShaderType.Effect)
{
var reader = new DebugBytecodeReader(data, 0, data.Length);
string error = "";
try
{
reader.ReadByte("minorVersion");
reader.ReadByte("majorVersion");
reader.ReadUInt16("shaderType");
DebugEffectChunk.Parse(reader, (uint)(data.Length - 4));
}
catch (Exception ex)
{
error = ex.ToString();
}
var dump = reader.DumpStructure();
if (!string.IsNullOrEmpty(error))
{
dump += "\n" + error;
}
sw.Write(dump);
}
else
{
var reader = new DebugBytecodeReader(data, 0, data.Length);
string error = "";
try
{
DebugShaderModel.Parse(reader);
}
catch (Exception ex)
{
error = ex.ToString();
}
var dump = reader.DumpStructure();
if (!string.IsNullOrEmpty(error))
{
dump += "\n" + error;
}
sw.Write(dump);
}
}
else if (options.Mode == DecompileMode.DebugHtml)
{
var shaderType = (DXDecompiler.DX9Shader.ShaderType)BitConverter.ToUInt16(data, 2);
if (shaderType == DXDecompiler.DX9Shader.ShaderType.Effect)
{
var reader = new DebugBytecodeReader(data, 0, data.Length);
string error = "";
try
{
reader.ReadByte("minorVersion");
reader.ReadByte("majorVersion");
reader.ReadUInt16("shaderType");
DebugEffectChunk.Parse(reader, (uint)(data.Length - 4));
}
catch (Exception ex)
{
error = ex.ToString();
}
var dump = reader.DumpHtml();
if (!string.IsNullOrEmpty(error))
{
dump += "\n" + error;
}
sw.Write(dump);
}
else
{
var reader = new DebugBytecodeReader(data, 0, data.Length);
string error = "";
try
{
DebugShaderModel.Parse(reader);
}
catch (Exception ex)
{
error = ex.ToString();
}
var dump = reader.DumpHtml();
if (!string.IsNullOrEmpty(error))
{
dump += "\n" + error;
}
sw.Write(dump);
}
}
}
}
}
public static DebugEffectObjectVariable Parse(DebugBytecodeReader reader, DebugBytecodeReader variableReader,
DebugShaderVersion version, bool isShared = false)
{
var result = new DebugEffectObjectVariable();
var nameOffset = result.NameOffset = variableReader.ReadUInt32("NameOffset");
var nameReader = reader.CopyAtOffset("NameReader", variableReader, (int)nameOffset);
result.Name = nameReader.ReadString("Name");
result.TypeOffset = variableReader.ReadUInt32("TypeOffset");
var typeReader = reader.CopyAtOffset("TypeReader", variableReader, (int)result.TypeOffset);
result.Type = DebugEffectType.Parse(reader, typeReader, version);
var semanticOffset = result.SemanticOffset = variableReader.ReadUInt32("SemanticOffset");
if (semanticOffset != 0)
{
var semanticReader = reader.CopyAtOffset("SemanticReader", variableReader, (int)semanticOffset);
result.Semantic = semanticReader.ReadString("Semantic");
}
else
{
result.Semantic = "";
}
result.BufferOffset = variableReader.ReadUInt32("BufferOffset");
if (isShared)
{
return(result);
}
// Initializer data
if (result.Type.ObjectType == EffectObjectType.String)
{
for (int i = 0; i < result.ElementCount; i++)
{
var stringValueOffset = variableReader.ReadUInt32($"StringValueOffset{i}");
var stringValueReader = reader.CopyAtOffset($"StringValueReader{i}", variableReader, (int)stringValueOffset);
result.Strings.Add(stringValueReader.ReadString($"StringValue{i}"));
}
}
if (IfHasAssignments(result.Type))
{
for (int i = 0; i < result.ElementCount; i++)
{
var assignmentCount = variableReader.ReadUInt32($"AssignmentCount{i}");
var assignments = new List <DebugEffectAssignment>();
result.Assignments.Add(assignments);
for (int j = 0; j < assignmentCount; j++)
{
variableReader.AddIndent($"Assignment {i}");
assignments.Add(DebugEffectAssignment.Parse(reader, variableReader));
variableReader.RemoveIndent();
}
}
}
if (result.Type.ObjectType == EffectObjectType.GeometryShaderWithStream)
{
for (int i = 0; i < result.ElementCount; i++)
{
variableReader.AddIndent($"GSSOInitializer {i}");
result.GSSOInitializers.Add(DebugEffectGSSOInitializer.Parse(reader, variableReader));
variableReader.RemoveIndent();
}
}
else if (IsShader5(result.Type))
{
for (int i = 0; i < result.ElementCount; i++)
{
variableReader.AddIndent($"ShaderData5 {i}");
result.ShaderData5.Add(DebugEffectShaderData5.Parse(reader, variableReader));
variableReader.RemoveIndent();
}
}
else if (IsShader(result.Type))
{
for (int i = 0; i < result.ElementCount; i++)
{
variableReader.AddIndent($"ShaderData {i}");
result.ShaderData.Add(DebugEffectShaderData.Parse(reader, variableReader));
variableReader.RemoveIndent();
}
}
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 DebugInstructionToken Parse(DebugBytecodeReader reader, DebugOpcodeHeader header)
{
var instructionToken = new DebugInstructionToken();
// Advance to next token.
var instructionEnd = reader.CurrentPosition + (header.Length * sizeof(uint));
var token0 = reader.ReadUInt32("token0");
DebugOpcodeHeader.AddNotes(reader, token0);
if (header.OpcodeType == OpcodeType.Sync)
{
instructionToken.SyncFlags = token0.DecodeValue <SyncFlags>(11, 14);
reader.AddNote("SyncFlags", instructionToken.SyncFlags);
}
else
{
instructionToken.ResInfoReturnType = token0.DecodeValue <ResInfoReturnType>(11, 12);
instructionToken.Saturate = (token0.DecodeValue(13, 13) == 1);
instructionToken.TestBoolean = token0.DecodeValue <InstructionTestBoolean>(18, 18);
instructionToken.PreciseValueMask = token0.DecodeValue <ComponentMask>(19, 22);
reader.AddNote("ResInfoReturnType", instructionToken.ResInfoReturnType);
reader.AddNote("Saturate", instructionToken.Saturate);
reader.AddNote("TestBoolean", instructionToken.TestBoolean);
reader.AddNote("PreciseValueMask", instructionToken.PreciseValueMask);
}
bool extended = header.IsExtended;
while (extended)
{
uint extendedToken = reader.ReadUInt32("extendedToken");
var extendedType = extendedToken.DecodeValue <InstructionTokenExtendedType>(0, 5);
reader.AddNote("extendedType", extendedType);
instructionToken.ExtendedTypes.Add(extendedType);
extended = (extendedToken.DecodeValue(31, 31) == 1);
reader.AddNote("extended", extended);
switch (extendedType)
{
case InstructionTokenExtendedType.SampleControls:
instructionToken.SampleOffsets[0] = extendedToken.DecodeSigned4BitValue(09, 12);
instructionToken.SampleOffsets[1] = extendedToken.DecodeSigned4BitValue(13, 16);
instructionToken.SampleOffsets[2] = extendedToken.DecodeSigned4BitValue(17, 20);
reader.AddNote("SampleOffsets[0]", instructionToken.SampleOffsets[0]);
reader.AddNote("SampleOffsets[1]", instructionToken.SampleOffsets[1]);
reader.AddNote("SampleOffsets[2]", instructionToken.SampleOffsets[2]);
break;
case InstructionTokenExtendedType.ResourceDim:
instructionToken.ResourceTarget = extendedToken.DecodeValue <ResourceDimension>(6, 10);
instructionToken.ResourceStride = extendedToken.DecodeValue <ushort>(11, 22);
reader.AddNote("ResourceTarget", instructionToken.ResourceTarget);
reader.AddNote("ResourceStride", instructionToken.ResourceStride);
break;
case InstructionTokenExtendedType.ResourceReturnType:
instructionToken.ResourceReturnTypes[0] = extendedToken.DecodeValue <ResourceReturnType>(06, 09);
instructionToken.ResourceReturnTypes[1] = extendedToken.DecodeValue <ResourceReturnType>(10, 13);
instructionToken.ResourceReturnTypes[2] = extendedToken.DecodeValue <ResourceReturnType>(14, 17);
instructionToken.ResourceReturnTypes[3] = extendedToken.DecodeValue <ResourceReturnType>(18, 21);
reader.AddNote("ResourceReturnTypes[0]", instructionToken.ResourceReturnTypes[0]);
reader.AddNote("ResourceReturnTypes[1]", instructionToken.ResourceReturnTypes[1]);
reader.AddNote("ResourceReturnTypes[2]", instructionToken.ResourceReturnTypes[2]);
reader.AddNote("ResourceReturnTypes[3]", instructionToken.ResourceReturnTypes[3]);
break;
default:
throw new ParseException("Unrecognised extended type: " + extendedType);
}
}
if (header.OpcodeType == OpcodeType.InterfaceCall)
{
instructionToken.FunctionIndex = reader.ReadUInt32("FunctionIndex");
}
while (reader.CurrentPosition < instructionEnd)
{
reader.AddIndent($"Operand{instructionToken.Operands.Count}");
var operand = DebugOperand.Parse(reader, header.OpcodeType);
if (operand != null)
{
instructionToken.Operands.Add(operand);
}
reader.RemoveIndent();
}
return(instructionToken);
}
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);
}
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);
}
