public static Assignment Parse(BytecodeReader reader, BytecodeReader shaderReader)
{
var result = new Assignment();
result.Type = (StateType)shaderReader.ReadUInt32();
result.ArrayIndex = shaderReader.ReadUInt32();
var parameterOffset = shaderReader.ReadUInt32();
var valueOffset = shaderReader.ReadUInt32();
var parameterReader = reader.CopyAtOffset((int)parameterOffset);
result.Parameter = Parameter.Parse(reader, parameterReader);
var valueReader = reader.CopyAtOffset((int)valueOffset);
result.Value = result.Parameter.ReadParameterValue(valueReader);
return(result);
}
public static ConstantPool ReadConstantPool(BytecodeReader reader, ushort constantPoolCount)
{
// TODO: check if long and double constants reading right
ConstantPool constantPool = new ConstantPool();
int a = 0;
var tagDictionary = new Dictionary <int, Action>();
tagDictionary.Add(1, () =>
{
ushort length = reader.ReadUShort();
String value = reader.ReadString(length);
constantPool.AddConstantUtf8(new ConstantUtf8(length, value));
});
tagDictionary.Add(3, () => constantPool.AddConstantInteger(reader.ReadInt()));
tagDictionary.Add(4, () => constantPool.AddConstantFloat(reader.ReadFloat()));
tagDictionary.Add(5, () => constantPool.AddConstantLong(reader.ReadLong()));
tagDictionary.Add(6, () => constantPool.AddConstantDouble(reader.ReadDouble()));
tagDictionary.Add(7, () => constantPool.AddConstantClass(new ConstantClass(reader.ReadUShort())));
tagDictionary.Add(8, () => constantPool.AddConstantString(new ConstantString(reader.ReadUShort())));
tagDictionary.Add(9, () => constantPool.AddConstantFieldRef(new ConstantFieldRef(reader.ReadUShort(), reader.ReadUShort())));
tagDictionary.Add(10, () => constantPool.AddConstantMethodRef(new ConstantMethodRef(reader.ReadUShort(), reader.ReadUShort())));
tagDictionary.Add(11, () => constantPool.AddConstantInterfaceMethodRef(new ConstantInterfaceMethodRef(reader.ReadUShort(), reader.ReadUShort())));
tagDictionary.Add(12, () => constantPool.AddConstantNameAndType(new ConstantNameAndType(reader.ReadUShort(), reader.ReadUShort())));
tagDictionary.Add(15, () => constantPool.AddConstantMethodHandle(new ConstantMethodHandle(reader.ReadByte(), reader.ReadUShort())));
tagDictionary.Add(16, () => constantPool.AddConstantMethodType(new ConstantMethodType(reader.ReadUShort())));
tagDictionary.Add(18, () => constantPool.AddConstantInvokeDynamic(new ConstantInvokeDynamic(reader.ReadUShort(), reader.ReadUShort())));
tagDictionary.Add(19, () => constantPool.AddConstantModule(new ConstantModule(reader.ReadUShort())));
tagDictionary.Add(20, () => constantPool.AddConstantPackage(new ConstantPackage(reader.ReadUShort())));
Action createConstant;
for (int i = 0; i < constantPoolCount; i++)
{
if (tagDictionary.TryGetValue(reader.ReadByte(), out createConstant))
{
createConstant.Invoke();
}
else
{
throw new KeyNotFoundException("Constant type not recognized");
}
}
return(constantPool);
}
public static TypedUnorderedAccessViewDeclarationToken Parse(BytecodeReader reader, ShaderVersion version)
{
var token0 = reader.ReadUInt32();
var result = new TypedUnorderedAccessViewDeclarationToken
{
ResourceDimension = token0.DecodeValue <ResourceDimension>(11, 15),
Coherency = token0.DecodeValue <UnorderedAccessViewCoherency>(16, 16),
IsRasterOrderedAccess = token0.DecodeValue <bool>(17, 17),
Operand = Operand.Parse(reader, token0.DecodeValue <OpcodeType>(0, 10)),
ReturnType = ResourceReturnTypeToken.Parse(reader)
};
if (version.IsSM51)
{
result.SpaceIndex = reader.ReadUInt32();
}
return(result);
}
public static SignatureParameterDescription Parse(BytecodeReader reader, BytecodeReader parameterReader,
ChunkType chunkType, SignatureElementSize size)
{
uint stream = 0;
if (size == SignatureElementSize._7 || size == SignatureElementSize._8)
{
stream = parameterReader.ReadUInt32();
}
uint nameOffset = parameterReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
var result = new SignatureParameterDescription
{
SemanticName = nameReader.ReadString(),
SemanticIndex = parameterReader.ReadUInt32(),
SystemValueType = (Name)parameterReader.ReadUInt32(),
ComponentType = (RegisterComponentType)parameterReader.ReadUInt32(),
Register = parameterReader.ReadUInt32(),
Stream = stream,
};
uint mask = parameterReader.ReadUInt32();
result.Mask = mask.DecodeValue <ComponentMask>(0, 7);
result.ReadWriteMask = mask.DecodeValue <ComponentMask>(8, 15);
if (size == SignatureElementSize._8)
{
MinPrecision minPrecision = (MinPrecision)parameterReader.ReadUInt32();
result.MinPrecision = minPrecision;
}
// This is my guesswork, but it works so far...
if (chunkType == ChunkType.Osg5 ||
chunkType == ChunkType.Osgn ||
chunkType == ChunkType.Osg1)
{
result.ReadWriteMask = (ComponentMask)(ComponentMask.All - result.ReadWriteMask);
}
return(result);
}
public static StaticSampler Parse(BytecodeReader reader)
{
return(new StaticSampler()
{
Filter = (Filter)reader.ReadUInt32(),
AddressU = (TextureAddressMode)reader.ReadUInt32(),
AddressV = (TextureAddressMode)reader.ReadUInt32(),
AddressW = (TextureAddressMode)reader.ReadUInt32(),
MipLODBias = reader.ReadSingle(),
MaxAnisotropy = reader.ReadUInt32(),
ComparisonFunc = (ComparisonFunc)reader.ReadUInt32(),
BorderColor = (StaticBorderColor)reader.ReadUInt32(),
MinLOD = reader.ReadSingle(),
MaxLOD = reader.ReadSingle(),
ShaderRegister = reader.ReadUInt32(),
RegisterSpace = reader.ReadUInt32(),
ShaderVisibility = (ShaderVisibility)reader.ReadUInt32(),
});
}
public static EffectGSSOInitializer Parse(BytecodeReader reader, BytecodeReader variableReader)
{
var result = new EffectGSSOInitializer();
var shaderOffset = variableReader.ReadUInt32();
var SODeclOffset = variableReader.ReadUInt32();
var bytecodeReader = reader.CopyAtOffset((int)shaderOffset);
var shaderSize = bytecodeReader.ReadUInt32();
if (shaderSize != 0)
{
result.Shader = BytecodeContainer.Parse(bytecodeReader.ReadBytes((int)shaderSize));
}
var declReader = reader.CopyAtOffset((int)SODeclOffset);
result.SODecl = declReader.ReadString();
return(result);
}
public static InputRegisterDeclarationToken Parse(BytecodeReader reader)
{
uint token0 = reader.ReadUInt32();
var opcodeType = token0.DecodeValue <OpcodeType>(0, 10);
InputRegisterDeclarationToken result;
switch (opcodeType)
{
case OpcodeType.DclInput:
case OpcodeType.DclInputSgv:
case OpcodeType.DclInputSiv:
result = new InputRegisterDeclarationToken();
break;
case OpcodeType.DclInputPs:
case OpcodeType.DclInputPsSgv:
case OpcodeType.DclInputPsSiv:
result = new PixelShaderInputRegisterDeclarationToken
{
InterpolationMode = token0.DecodeValue <InterpolationMode>(11, 14)
};
break;
default:
throw new ParseException("Unrecognised opcode type: " + opcodeType);
}
result.Operand = Operand.Parse(reader, opcodeType);
switch (opcodeType)
{
case OpcodeType.DclInputSgv:
case OpcodeType.DclInputSiv:
case OpcodeType.DclInputPsSgv:
case OpcodeType.DclInputPsSiv:
result.SystemValueName = NameToken.Parse(reader);
break;
}
return(result);
}
public static Pass Parse(BytecodeReader reader, BytecodeReader variableReader)
{
var result = new Pass();
var nameOffset = variableReader.ReadUInt32();
var annotationCount = variableReader.ReadUInt32();
var assignmentCount = variableReader.ReadUInt32();
for (int i = 0; i < annotationCount; i++)
{
result.Annotations.Add(Annotation.Parse(reader, variableReader));
}
for (int i = 0; i < assignmentCount; i++)
{
result.Assignments.Add(Assignment.Parse(reader, variableReader));
}
var nameReader = reader.CopyAtOffset((int)nameOffset);
result.Name = nameReader.TryReadString();
return(result);
}
public static OutputRegisterDeclarationToken Parse(BytecodeReader reader)
{
uint token0 = reader.ReadUInt32();
var opcodeType = token0.DecodeValue <OpcodeType>(0, 10);
var result = new OutputRegisterDeclarationToken
{
Operand = Operand.Parse(reader, opcodeType)
};
switch (opcodeType)
{
case OpcodeType.DclOutputSgv:
case OpcodeType.DclOutputSiv:
result.SystemValueName = NameToken.Parse(reader);
break;
}
return(result);
}
public static EffectTechnique Parse(BytecodeReader reader, BytecodeReader techniqueReader, ShaderVersion version)
{
var result = new EffectTechnique(version);
var nameOffset = techniqueReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
result.Name = nameReader.ReadString();
var passCount = techniqueReader.ReadUInt32();
var annotationCount = techniqueReader.ReadUInt32();
for (int i = 0; i < annotationCount; i++)
{
result.Annotations.Add(EffectAnnotation.Parse(reader, techniqueReader, version));
}
for (int i = 0; i < passCount; i++)
{
result.Passes.Add(EffectPass.Parse(reader, techniqueReader, version));
}
return(result);
}
public static Technique Parse(BytecodeReader reader, BytecodeReader variableReader)
{
var result = new Technique();
var nameOffset = variableReader.ReadUInt32();
var annotationCount = variableReader.ReadUInt32();
var passCount = variableReader.ReadUInt32();
for (int i = 0; i < annotationCount; i++)
{
result.Annotations.Add(Annotation.Parse(reader, variableReader));
}
for (int i = 0; i < passCount; i++)
{
result.Passes.Add(Pass.Parse(reader, variableReader));
}
var nameReader = reader.CopyAtOffset((int)nameOffset);
result.Name = nameReader.TryReadString();
return(result);
}
public static EffectPass Parse(BytecodeReader reader, BytecodeReader passReader, ShaderVersion version)
{
var result = new EffectPass();
var nameOffset = passReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
result.Name = nameReader.ReadString();
var assignmentCount = passReader.ReadUInt32();
var annotationCount = passReader.ReadUInt32();
for (int i = 0; i < annotationCount; i++)
{
result.Annotations.Add(EffectAnnotation.Parse(reader, passReader, version));
}
for (int i = 0; i < assignmentCount; i++)
{
result.Assignments.Add(EffectAssignment.Parse(reader, passReader));
}
return(result);
}
public static Parameter Parse(BytecodeReader reader, BytecodeReader variableReader)
{
var result = new Parameter();
result.ParameterType = (ParameterType)variableReader.ReadUInt32();
result.ParameterClass = (ParameterClass)variableReader.ReadUInt32();
var nameOffset = variableReader.ReadUInt32();
var semanticOffset = variableReader.ReadUInt32();
if (result.ParameterClass == ParameterClass.Scalar ||
result.ParameterClass == ParameterClass.Vector ||
result.ParameterClass == ParameterClass.MatrixRows ||
result.ParameterClass == ParameterClass.MatrixColumns)
{
result.ElementCount = variableReader.ReadUInt32();
result.Rows = variableReader.ReadUInt32();
result.Columns = variableReader.ReadUInt32();
}
if (result.ParameterClass == ParameterClass.Struct)
{
result.ElementCount = variableReader.ReadUInt32();
result.StructMemberCount = variableReader.ReadUInt32();
for (int i = 0; i < result.StructMemberCount; i++)
{
result.StructMembers.Add(Parameter.Parse(reader, variableReader));
}
}
if (result.ParameterClass == ParameterClass.Object)
{
result.ElementCount = variableReader.ReadUInt32();
}
var nameReader = reader.CopyAtOffset((int)nameOffset);
result.Name = nameReader.TryReadString();
var semanticReader = reader.CopyAtOffset((int)semanticOffset);
result.Semantic = semanticReader.TryReadString();
return(result);
}
public BytecodeContainer(byte[] rawBytes)
{
_rawBytes = rawBytes;
Chunks = new List <BytecodeChunk>();
var reader = new BytecodeReader(rawBytes, 0, rawBytes.Length);
Header = BytecodeContainerHeader.Parse(reader);
for (uint i = 0; i < Header.ChunkCount; i++)
{
uint chunkOffset = reader.ReadUInt32();
var chunkReader = reader.CopyAtOffset((int)chunkOffset);
var chunk = BytecodeChunk.ParseChunk(chunkReader, this);
if (chunk != null)
{
Chunks.Add(chunk);
}
}
}
public static ClassInstance Parse(BytecodeReader reader, BytecodeReader classInstanceReader)
{
var nameOffset = classInstanceReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
var name = nameReader.ReadString();
var type = classInstanceReader.ReadUInt16();
var unknown = classInstanceReader.ReadUInt16();
Debug.Assert(unknown == 1); // Unknown, perhaps the class instance type?
return(new ClassInstance
{
Name = name,
Type = type,
ConstantBuffer = classInstanceReader.ReadUInt16(),
ConstantBufferOffset = classInstanceReader.ReadUInt16(),
Texture = classInstanceReader.ReadUInt16(),
Sampler = classInstanceReader.ReadUInt16()
});
}
public static ShaderTypeMember Parse(BytecodeReader reader, BytecodeReader memberReader, ShaderVersion target,
int indent, bool isFirst, uint parentOffset)
{
var nameOffset = memberReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
var name = nameReader.ReadString();
var memberTypeOffset = memberReader.ReadUInt32();
var offset = memberReader.ReadUInt32();
var memberTypeReader = reader.CopyAtOffset((int)memberTypeOffset);
var memberType = ShaderType.Parse(reader, memberTypeReader, target, indent, isFirst, parentOffset + offset);
return(new ShaderTypeMember(parentOffset)
{
Name = name,
Type = memberType,
Offset = offset
});
}
public static BytecodeContainerHeader Parse(BytecodeReader reader)
{
var fourCc = reader.ReadUInt32();
if (fourCc != "DXBC".ToFourCc())
throw new ParseException("Invalid FourCC");
var uniqueKey = new uint[4];
uniqueKey[0] = reader.ReadUInt32();
uniqueKey[1] = reader.ReadUInt32();
uniqueKey[2] = reader.ReadUInt32();
uniqueKey[3] = reader.ReadUInt32();
return new BytecodeContainerHeader
{
FourCc = fourCc,
UniqueKey = uniqueKey,
One = reader.ReadUInt32(),
TotalSize = reader.ReadUInt32(),
ChunkCount = reader.ReadUInt32()
};
}
public static ShaderVersion ParseFX(BytecodeReader reader)
{
uint target = reader.ReadUInt16();
var programTypeValue = reader.ReadUInt16();
ProgramType programType = ParseRdefProgramType(programTypeValue);
byte majorVersion;
byte minorVersion;
switch (target)
{
case 0x1001:
majorVersion = 4;
minorVersion = 0;
break;
case 0x1011:
majorVersion = 4;
minorVersion = 1;
break;
case 0x2001:
majorVersion = 5;
minorVersion = 0;
break;
case 0x0901:
majorVersion = 2;
minorVersion = 0;
break;
default:
throw new ParseException(string.Format("Unknown program version: 0x{0:X}", target));
}
return(new ShaderVersion
{
MajorVersion = majorVersion,
MinorVersion = minorVersion,
ProgramType = programType
});
}
public static ConstantType Parse(BytecodeReader reader, BytecodeReader typeReader)
{
var result = new ConstantType();
result.ParameterClass = (ParameterClass)typeReader.ReadUInt16();
result.ParameterType = (ParameterType)typeReader.ReadUInt16();
result.Rows = typeReader.ReadUInt16();
result.Columns = typeReader.ReadUInt16();
result.Elements = typeReader.ReadUInt16();
var memberCount = typeReader.ReadUInt16();
var memberInfoOffset = typeReader.ReadUInt32();
if (memberCount != 0)
{
var memberReader = reader.CopyAtOffset((int)memberInfoOffset);
for (int i = 0; i < memberCount; i++)
{
result.Members.Add(ConstantMember.Parse(reader, memberReader));
}
}
return(result);
}
public static List <Number> ReadParameterValue(this Parameter parameter, BytecodeReader valueReader)
{
var result = new List <Number>();
if (parameter.ParameterClass == ParameterClass.Object)
{
var elementCount = parameter.ElementCount == 0 ? 1 : parameter.ElementCount;
for (int i = 0; i < elementCount; i++)
{
result.Add(Number.Parse(valueReader));
}
}
else
{
var defaultValueCount = parameter.GetSize() / 4;
for (int i = 0; i < defaultValueCount; i++)
{
result.Add(Number.Parse(valueReader));
}
}
return(result);
}
public static CustomDataToken Parse(BytecodeReader reader, uint token0)
{
var customDataClass = token0.DecodeValue <CustomDataClass>(11, 31);
CustomDataToken token;
switch (customDataClass)
{
case CustomDataClass.DclImmediateConstantBuffer:
token = ImmediateConstantBufferDeclarationToken.Parse(reader);
break;
case CustomDataClass.ShaderMessage:
token = ShaderMessageDeclarationToken.Parse(reader);
break;
default:
throw new ParseException("Unknown custom data class: " + customDataClass);
}
token.CustomDataClass = customDataClass;
return(token);
}
public BytecodeContainer(byte[] rawBytes)
{
_rawBytes = rawBytes;
Chunks = new List <BytecodeChunk>();
var reader = new BytecodeReader(rawBytes, 0, rawBytes.Length);
var magicNumber = BitConverter.ToUInt32(rawBytes, 0);
if (magicNumber == 0xFEFF2001)
{
Chunks.Add(EffectChunk.Parse(reader, (uint)rawBytes.Length));
return;
}
Header = BytecodeContainerHeader.Parse(reader);
for (uint i = 0; i < Header.ChunkCount; i++)
{
uint chunkOffset = reader.ReadUInt32();
var chunkReader = reader.CopyAtOffset((int)chunkOffset);
var chunk = BytecodeChunk.ParseChunk(chunkReader, this);
if (chunk != null)
{
Chunks.Add(chunk);
}
}
foreach (var chunk in Chunks.OfType <InputOutputSignatureChunk>())
{
chunk.UpdateVersion(Version);
}
foreach (var chunk in Chunks.OfType <Sfi0Chunk>())
{
chunk.UpdateVersion(Version);
}
foreach (var chunk in Chunks.OfType <PipelineStateValidationChunk>())
{
chunk.UpdateVersion(Version);
}
}
public static InterfaceDeclarationToken Parse(BytecodeReader reader)
{
uint token0 = reader.ReadUInt32();
var result = new InterfaceDeclarationToken
{
DynamicallyIndexed = (token0.DecodeValue(11, 11) == 1),
Identifier = reader.ReadUInt32(),
ExpectedFunctionTableLength = reader.ReadUInt32()
};
uint token3 = reader.ReadUInt32();
result.TableLength = token3.DecodeValue <ushort>(00, 15);
result.ArrayLength = token3.DecodeValue <ushort>(16, 31);
for (int i = 0; i < result.TableLength; i++)
{
result.FunctionTableIdentifiers.Add(reader.ReadUInt32());
}
return(result);
}
public static void DumpUnknownBytecodes(StreamWriter writer)
{
foreach (byte b in _unknownBytecodes.Keys)
{
writer.WriteLine(b.ToString("X2"));
var occurrences = _unknownBytecodes[b];
foreach (var occurrence in occurrences)
{
var function = occurrence.Function;
writer.Write(" ");
WriteFunctionName(writer, function);
var bytes = occurrence.SubsequentBytes;
int skip = 0;
if (b == 0x0E)
{
skip = DumpNextBytecodes(writer, function, bytes, 4, 1);
}
writer.WriteLine($" {BytecodeReader.DumpBytes(bytes, skip, 32)}");
}
}
}
public static ShaderModel Parse(BytecodeReader reader)
{
var result = new ShaderModel();
result.MinorVersion = reader.ReadByte();
result.MajorVersion = reader.ReadByte();
result.Type = (ShaderType)reader.ReadUInt16();
while (true)
{
var instruction = result.ReadInstruction(reader);
if (instruction == null)
{
continue;
}
result.Tokens.Add(instruction);
if (instruction.Opcode == Opcode.End)
{
break;
}
}
return(result);
}
public new static EffectInlineShader5Assignment Parse(BytecodeReader reader, BytecodeReader variableReader)
{
var result = new EffectInlineShader5Assignment();
var shaderOffset = variableReader.ReadUInt32();
result.SODeclsOffset[0] = variableReader.ReadUInt32();
result.SODeclsOffset[1] = variableReader.ReadUInt32();
result.SODeclsOffset[2] = variableReader.ReadUInt32();
result.SODeclsOffset[3] = variableReader.ReadUInt32();
var SoDeclsCount = result.SODeclsCount = variableReader.ReadUInt32();
result.RasterizedStream = variableReader.ReadUInt32();
var interfaceBindingCount = variableReader.ReadUInt32();
var interfaceBindingOffset = variableReader.ReadUInt32();
var shaderReader = reader.CopyAtOffset((int)shaderOffset);
var shaderSize = shaderReader.ReadUInt32();
if (shaderSize != 0)
{
result.Shader = BytecodeContainer.Parse(shaderReader.ReadBytes((int)shaderSize));
}
for (int i = 0; i < 4; i++)
{
var offset = result.SODeclsOffset[i];
if (offset != 0)
{
var soDeclReader = reader.CopyAtOffset((int)offset);
result.SODecls.Add(soDeclReader.ReadString());
}
}
var interfaceReader = reader.CopyAtOffset((int)interfaceBindingOffset);
for (int i = 0; i < interfaceBindingCount; i++)
{
result.InterfaceBindings.Add(EffectInterfaceInitializer.Parse(reader, interfaceReader));
}
return(result);
}
public static EffectBuffer Parse(BytecodeReader reader, BytecodeReader bufferReader, ShaderVersion version, bool isShared)
{
var result = new EffectBuffer();
var nameOffset = result.NameOffset = bufferReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
result.Name = nameReader.ReadString();
result.BufferSize = bufferReader.ReadUInt32();
result.BufferType = (ConstantBufferType)bufferReader.ReadUInt32();
result.VariableCount = bufferReader.ReadUInt32();
result.RegisterNumber = bufferReader.ReadUInt32();
if (!isShared)
{
var unknown0 = bufferReader.ReadUInt32();
//TODO: Unknown0
//Debug.Assert(result.Unknown0 == 0, $"EffectBuffer.Unknown0: {result.Unknown0}");
}
for (int i = 0; i < result.VariableCount; i++)
{
result.Variables.Add(EffectNumericVariable.Parse(reader, bufferReader, version, isShared));
}
return(result);
}
public static FxlcOperand Parse(BytecodeReader reader, uint componentCount, bool isScalarOp)
{
var result = new FxlcOperand()
{
IsArray = reader.ReadUInt32(),
OpType = (FxlcOperandType)reader.ReadUInt32(),
OpIndex = reader.ReadUInt32(),
};
result.ComponentCount = isScalarOp && result.OpType != FxlcOperandType.Literal ? 1 : componentCount;
Debug.Assert(Enum.IsDefined(typeof(FxlcOperandType), result.OpType),
$"Unexpected FxlcOperandType OpType {result.OpType}");
if (result.IsArray == 1)
{
result.ArrayType = (FxlcOperandType)reader.ReadUInt32();
result.ArrayIndex = reader.ReadUInt32();
Debug.Assert(Enum.IsDefined(typeof(FxlcOperandType), result.ArrayType),
$"Unexpected FxlcOperandType ArrayType {result.ArrayType}");
}
return(result);
}
public static LibHeaderChunk Parse(BytecodeReader reader, uint chunkSize)
{
var chunkReader = reader.CopyAtCurrentPosition();
var result = new LibHeaderChunk();
//multiple creator strings?
var unknown1 = chunkReader.ReadUInt32();
Debug.Assert(unknown1 == 1, $"LibraryHeader.unknown1 is {unknown1}");
var creatorStringOffset = chunkReader.ReadUInt32();
//guessing flags, library chunk never seems to flags set.
var unknown0 = chunkReader.ReadUInt32();
Debug.Assert(unknown0 == 0, "Unexpected value for LibHeaderChunk.Unknown0");
var functionCount = chunkReader.ReadUInt32();
//Contains function strings and function flags
var functionInfoOffset = chunkReader.ReadUInt32();
var creatorStringReader = chunkReader.CopyAtOffset((int)creatorStringOffset);
result.CreatorString = creatorStringReader.ReadString();
var functionInfoReader = reader.CopyAtOffset((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();
var functionNameOffset = functionInfoReader.ReadUInt32();
var functionNameReader = reader.CopyAtOffset((int)functionNameOffset);
var name = functionNameReader.ReadString();
result.FunctionDescs.Add(new LibraryDesc(name, mode));
}
return(result);
}
public static StateBlob Parse(BytecodeReader reader, BytecodeReader shaderReader)
{
var result = new StateBlob();
result.TechniqueIndex = shaderReader.ReadUInt32();
result.PassIndex = shaderReader.ReadUInt32();
result.SamplerStateIndex = shaderReader.ReadUInt32();
result.AssignmentIndex = shaderReader.ReadUInt32();
result.BlobType = (StateBlobType)shaderReader.ReadUInt32();
var dataReader = shaderReader.CopyAtCurrentPosition();
var blobSize = shaderReader.ReadUInt32();
var paddedSize = blobSize + (blobSize % 4 == 0 ? 0 : 4 - blobSize % 4);
//Seak ahead
var data = shaderReader.ReadBytes((int)paddedSize);
if (result.BlobType == StateBlobType.Shader)
{
result.Shader = ShaderReader.ReadShader(data);
}
else if (result.BlobType == StateBlobType.Variable)
{
result.VariableName = dataReader.TryReadString();
}
else if (result.BlobType == StateBlobType.IndexShader)
{
var _blobSize = dataReader.ReadUInt32();
var variableSize = dataReader.ReadUInt32();
result.VariableName = dataReader.ReadString();
if (variableSize > (result.VariableName.Length + 1))
{
var paddingCount = variableSize - (result.VariableName.Length + 1);
var padding = dataReader.ReadBytes((int)paddingCount);
}
result.Shader = result.Shader = ShaderModel.Parse(dataReader);
}
return(result);
}
