public static DebugStateBlob Parse(DebugBytecodeReader reader, DebugBytecodeReader blobReader)
{
var result = new DebugStateBlob();
result.TechniqueIndex = blobReader.ReadUInt32("TechniqueIndex");
result.PassIndex = blobReader.ReadUInt32("PassIndex");
result.SamplerStateIndex = blobReader.ReadUInt32("SamplerStateIndex");
result.AssignmentIndex = blobReader.ReadUInt32("AssignmentIndex");
result.BlobType = blobReader.ReadEnum32 <StateBlobType>("BlobType");
if (result.BlobType == StateBlobType.Shader)
{
result.ShaderSize = blobReader.ReadUInt32("BlobSize");
var startPosition = blobReader._reader.BaseStream.Position;
var shaderReader = blobReader.CopyAtCurrentPosition("ShaderReader", blobReader);
result.Shader = DebugShaderModel.Parse(shaderReader);
blobReader._reader.BaseStream.Position = startPosition + result.ShaderSize;
}
if (result.BlobType == StateBlobType.Variable)
{
result.VariableName = blobReader.TryReadString("VariableName");
}
else if (result.BlobType == StateBlobType.IndexShader)
{
result.ShaderSize = blobReader.ReadUInt32("BlobSize");
var startPosition = blobReader._reader.BaseStream.Position;
var variableSize = blobReader.ReadUInt32("VariableNameSize");
var variableData = blobReader.ReadBytes("VariableData", (int)variableSize);
result.VariableName = Encoding.UTF8.GetString(variableData, 0, variableData.Length - 1);
var shaderReader = blobReader.CopyAtCurrentPosition("ShaderReader", blobReader);
result.Shader = DebugShaderModel.Parse(shaderReader);
blobReader._reader.BaseStream.Position = startPosition + result.ShaderSize;
}
return(result);
}
} = new byte[4]; // Array for GS Stream Out Index
public static DebugPipelineStateValidationChunk Parse(DebugBytecodeReader reader, uint chunkSize)
{
var result = new DebugPipelineStateValidationChunk();
result.Reader = reader.CopyAtCurrentPosition("DebugPipelineStateValidationChunk", reader);
return(result);
}
public static DebugConstantTable Parse(DebugBytecodeReader reader)
{
var result = new DebugConstantTable();
var ctabReader = reader.CopyAtCurrentPosition("CTabReader", reader);
var ctabSize = ctabReader.ReadUInt32("CtabSize");
var creatorOffset = ctabReader.ReadInt32("CreatorPosition");
var minorVersion = ctabReader.ReadByte("MinorVersion");
var majorVersion = ctabReader.ReadByte("MajorVersion");
var shaderType = ctabReader.ReadEnum16 <ShaderType>("ShaderType");
var numConstants = ctabReader.ReadInt32("NumConstants");
var constantInfoOffset = ctabReader.ReadInt32("ConstantInfoOffset");
var shaderFlags = ctabReader.ReadEnum32 <ShaderFlags>("ShaderFlags");
var shaderModelOffset = ctabReader.ReadInt32("ShaderModelOffset");
for (int i = 0; i < numConstants; i++)
{
var decReader = ctabReader.CopyAtOffset($"Declaration {i}", ctabReader, constantInfoOffset + i * 20);
DebugConstantDeclaration declaration = DebugConstantDeclaration.Parse(ctabReader, decReader);
result.ConstantDeclarations.Add(declaration);
}
var shaderModelReader = ctabReader.CopyAtOffset("ShaderModelReader", ctabReader, shaderModelOffset);
var shaderModel = shaderModelReader.ReadString("ShaderModel");
var creatorReader = ctabReader.CopyAtOffset("CreaterReader", ctabReader, creatorOffset);
var creatorString = creatorReader.ReadString("CreatorString");
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 DebugLibfChunk Parse(DebugBytecodeReader reader, uint chunkSize)
{
var result = new DebugLibfChunk();
var chunkReader = reader.CopyAtCurrentPosition("LibfChunkReader", reader);
result.LibraryContainer = new DebugBytecodeContainer(chunkReader);
return(result);
}
public static DebugBytecodeChunk Parse(DebugBytecodeReader reader, uint chunkSize)
{
//TODO: Merge Ctab parsing with DX9 Ctab
var result = new DebugCtabChunk();
var chunkReader = reader.CopyAtCurrentPosition("ChunkReader", reader, (int)chunkSize);
result.ConstantTable = DebugConstantTable.Parse(chunkReader);
return(result);
}
public static DebugBytecodeChunk Parse(DebugBytecodeReader reader, uint chunkSize, DebugBytecodeContainer container)
{
var result = new DebugFxlcChunk();
var chunkReader = reader.CopyAtCurrentPosition("FxlcChunkReader", reader);
result.Fxlc = DebugFxlc.Parse(chunkReader, chunkSize);
var padding = chunkReader.ReadUInt32("Padding");
Debug.Assert(padding == 0xFFFF);
return(result);
}
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);
}
protected void ParseInstance(DebugBytecodeReader reader, uint chunkSize)
{
Version = DebugShaderVersion.ParseShex(reader);
var sizeInUint32 = reader.ReadUInt32("SizeInUint32");
var dxilMagic = reader.ReadUInt32("DxilMagic");
DxilVersion = reader.ReadUInt32("DxilVersion");
var bitcodeOffset = reader.ReadUInt32("BitcodeOffset");
var bitcodeLength = reader.ReadInt32("BitcodeLength");
var bitcodeReader = reader.CopyAtCurrentPosition("BitcodeReader", reader);
Bitcode = bitcodeReader.ReadBytes("Bitcode", bitcodeLength);
}
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 DebugLibraryParameterSignatureChunk Parse(DebugBytecodeReader reader, uint chunkSize)
{
var result = new DebugLibraryParameterSignatureChunk();
var chunkReader = reader.CopyAtCurrentPosition("LibraryParameterSignatureChunkReader", reader);
var parameterCount = chunkReader.ReadUInt32("ParameterCount");
var parameterOffset = chunkReader.ReadUInt32("ParameterOffset");
for (int i = 0; i < parameterCount; i++)
{
var parameterReader = chunkReader.CopyAtOffset($"ParameterReader{i}", chunkReader, (int)parameterOffset + 12 * 4 * i);
result.Parameters.Add(DebugLibraryParameterDescription.Parse(reader, parameterReader));
}
return(result);
}
public static DebugEffectChunk Parse(DebugBytecodeReader reader, uint length)
{
var result = new DebugEffectChunk();
var footerOffset = reader.ReadUInt32("footerOffset");
var bodyReader = reader.CopyAtCurrentPosition("BodyReader", reader);
var dummyReader = bodyReader.CopyAtCurrentPosition("Dummy", bodyReader);
dummyReader.ReadUInt32("Zero");
var footerReader = bodyReader.CopyAtOffset("FooterReader", reader, (int)footerOffset);
var variableCount = result.VariableCount = footerReader.ReadUInt32("VariableCount");
var techniqueCount = result.TechniqueCount = footerReader.ReadUInt32("TechniqueCount");
result.PassCount = footerReader.ReadUInt32("PassCount");
result.ShaderCount = footerReader.ReadUInt32("ShaderCount");
for (int i = 0; i < variableCount; i++)
{
footerReader.AddIndent($"Variable {i}");
result.Variables.Add(DebugVariable.Parse(bodyReader, footerReader));
footerReader.RemoveIndent();
}
for (int i = 0; i < techniqueCount; i++)
{
footerReader.AddIndent($"Technique {i}");
result.Techniques.Add(DebugTechnique.Parse(bodyReader, footerReader));
footerReader.RemoveIndent();
}
result.VariableBlobCount = footerReader.ReadUInt32("VariableBlobCount");
result.StateBlobCount = footerReader.ReadUInt32("StateBlobCount");
for (int i = 0; i < result.VariableBlobCount; i++)
{
footerReader.AddIndent($"VariableBlob {i}");
result.VariableBlobs.Add(DebugBinaryData.Parse(bodyReader, footerReader));
footerReader.RemoveIndent();
}
for (int i = 0; i < result.StateBlobCount; i++)
{
footerReader.AddIndent($"StateBlob {i}");
result.StateBlobs.Add(DebugStateBlob.Parse(bodyReader, footerReader));
footerReader.RemoveIndent();
}
return(result);
}
public static DebugCli4Chunk Parse(DebugBytecodeReader reader, uint chunkSize)
{
var result = new DebugCli4Chunk();
var chunkReader = reader.CopyAtCurrentPosition("ChunkReader", reader);
var count = chunkReader.ReadUInt32("Count");
for (int i = 0; i < count; i++)
{
chunkReader.AddIndent($"Number {i}");
var info = chunkReader.Members.Last();
var number = DebugNumber.Parse(chunkReader);
result.Numbers.Add(number);
info.AddNote("Int", number.Int.ToString());
info.AddNote("Uint", number.UInt.ToString());
info.AddNote("Float", number.Float.ToString());
chunkReader.RemoveIndent();
}
return(result);
}
public static DebugBinaryData Parse(DebugBytecodeReader reader, DebugBytecodeReader blobReader)
{
var result = new DebugBinaryData();
result.Index = blobReader.ReadUInt32("Index");
result.Size = blobReader.ReadUInt32("Size");
var startPosition = blobReader._reader.BaseStream.Position;
var header = blobReader.PeakUint32();
var shaderType = (ShaderType)(header >> 16);
var paddedSize = result.Size + (result.Size % 4 == 0 ? 0 : 4 - result.Size % 4);
if (shaderType == ShaderType.Pixel || shaderType == ShaderType.Vertex || shaderType == ShaderType.Expression)
{
var shaderReader = blobReader.CopyAtCurrentPosition("ShaderReader", blobReader);
result.Shader = DebugShaderModel.Parse(shaderReader);
}
else if (result.Size > 0)
{
blobReader.ReadBytes("Value", (int)paddedSize);
}
blobReader._reader.BaseStream.Position = startPosition + paddedSize;
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 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 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);
}