public static InterfacesChunk Parse(BytecodeReader reader, uint sizeInBytes)
{
var headerReader = reader.CopyAtCurrentPosition();
var result = new InterfacesChunk();
var classInstanceCount = headerReader.ReadUInt32();
var classTypeCount = headerReader.ReadUInt32();
var interfaceSlotRecordCount = headerReader.ReadUInt32();
// Will be same as interfaceSlotRecordCount unless there are interface arrays.
result.InterfaceSlotCount = headerReader.ReadUInt32();
// Think this is offset to start of interface slot info, but we
// don't need it because it is also contained in the InterfaceSlot class
var typeIDsOffset = headerReader.ReadUInt32();
var classTypeOffset = headerReader.ReadUInt32();
var availableClassReader = reader.CopyAtOffset((int)classTypeOffset);
var interfaceSlotOffset = headerReader.ReadUInt32();
var interfaceSlotReader = reader.CopyAtOffset((int)interfaceSlotOffset);
var unknown1 = headerReader.ReadUInt32();
Debug.Assert(unknown1.ToFourCcString() == "OSGN");
var unknown2 = headerReader.ReadUInt16();
Debug.Assert(unknown2 == 32);
var unknown3 = headerReader.ReadUInt16();
Debug.Assert(unknown3 == 16);
for (uint i = 0; i < classTypeCount; i++)
{
var classType = ClassType.Parse(reader, availableClassReader);
classType.ID = i; // Really??
result.AvailableClassTypes.Add(classType);
}
for (uint i = 0; i < classInstanceCount; i++)
{
var classInstance = ClassInstance.Parse(reader, availableClassReader);
result.AvailableClassInstances.Add(classInstance);
}
uint startSlot = 0;
for (uint i = 0; i < interfaceSlotRecordCount; i++)
{
var interfaceSlot = InterfaceSlot.Parse(reader, interfaceSlotReader);
interfaceSlot.StartSlot = startSlot; // Really??
result.InterfaceSlots.Add(interfaceSlot);
startSlot += interfaceSlot.SlotSpan;
}
return(result);
}
///// <summary>
///// Gets the corresponding interface slot for a variable that represents an interface pointer.
///// </summary>
//public List<uint> InterfaceSlots { get; private set; }
public static ShaderVariable Parse(BytecodeReader reader,
BytecodeReader variableReader, ShaderVersion target,
bool isFirst)
{
uint nameOffset = variableReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
var startOffset = variableReader.ReadUInt32();
uint size = variableReader.ReadUInt32();
var flags = (ShaderVariableFlags)variableReader.ReadUInt32();
var typeOffset = variableReader.ReadUInt32();
var typeReader = reader.CopyAtOffset((int)typeOffset);
var shaderType = ShaderType.Parse(reader, typeReader, target, 2, isFirst, startOffset);
var defaultValueOffset = variableReader.ReadUInt32();
List <Number> defaultValue = null;
if (defaultValueOffset != 0)
{
defaultValue = new List <Number>();
var defaultValueReader = reader.CopyAtOffset((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(4)));
}
}
var name = nameReader.ReadString();
var result = new ShaderVariable
{
DefaultValue = defaultValue,
Member = new ShaderTypeMember(0)
{
Name = name,
Offset = startOffset,
Type = shaderType
},
BaseType = name,
Size = size,
Flags = flags
};
if (target.MajorVersion >= 5)
{
result.StartTexture = variableReader.ReadInt32();
result.TextureSize = variableReader.ReadInt32();
result.StartSampler = variableReader.ReadInt32();
result.SamplerSize = variableReader.ReadInt32();
}
return(result);
}
internal static EffectNumericVariable Parse(BytecodeReader reader, BytecodeReader variableReader, ShaderVersion version, bool isShared)
{
var result = new EffectNumericVariable();
var nameOffset = variableReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
result.Name = nameReader.ReadString();
var typeOffset = variableReader.ReadUInt32();
var typeReader = reader.CopyAtOffset((int)typeOffset);
result.Type = EffectType.Parse(reader, typeReader, version);
var semanticOffset = result.SemanticOffset = variableReader.ReadUInt32();
if (semanticOffset != 0)
{
var semanticReader = reader.CopyAtOffset((int)semanticOffset);
result.Semantic = semanticReader.ReadString();
}
else
{
result.Semantic = "";
}
result.BufferOffset = variableReader.ReadUInt32();
var defaultValueOffset = variableReader.ReadUInt32();
List <Number> defaultValue = null;
var size = result.Type.PackedSize;
if (defaultValueOffset != 0)
{
defaultValue = new List <Number>();
var defaultValueReader = reader.CopyAtOffset((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(4)));
}
}
result.DefaultValue = defaultValue;
if (!isShared)
{
result.ExplicitBindPoint = variableReader.ReadUInt32();
}
var annotationCount = variableReader.ReadUInt32();
for (int i = 0; i < annotationCount; i++)
{
result.Annotations.Add(EffectAnnotation.Parse(reader, variableReader, version));
}
return(result);
}
public static StructMember Parse(BytecodeReader reader, BytecodeReader memberReader)
{
var result = new StructMember();
var nameOffset = memberReader.ReadUInt32();
var typeOffset = memberReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
result.Name = nameReader.ReadString();
var typeReader = reader.CopyAtOffset((int)typeOffset);
result.Type = ConstantType.Parse(reader, typeReader);
return(result);
}
public new static EffectVariableIndexAssignment Parse(BytecodeReader reader, BytecodeReader assignmentReader)
{
var result = new EffectVariableIndexAssignment();
var arrayNameOffset = assignmentReader.ReadUInt32();
var arrayNameReader = reader.CopyAtOffset((int)arrayNameOffset);
result.ArrayName = arrayNameReader.ReadString();
var variableNameOffset = assignmentReader.ReadUInt32();
var variableNameReader = reader.CopyAtOffset((int)variableNameOffset);
result.VariableName = variableNameReader.ReadString();
return(result);
}
public static Annotation Parse(BytecodeReader reader, BytecodeReader variableReader)
{
var result = new Annotation();
var parameterOffset = variableReader.ReadUInt32();
var valueOffset = variableReader.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 EffectChunk Parse(BytecodeReader reader, uint size)
{
var headerReader = reader.CopyAtCurrentPosition();
var result = new EffectChunk();
var header = result.Header = EffectHeader.Parse(headerReader);
var bodyOffset = header.Version.MajorVersion < 5 ?
0x4C : 0x60;
var footerOffset = (int)(result.Header.FooterOffset + bodyOffset);
var bodyReader = reader.CopyAtOffset((int)bodyOffset);
var footerReader = reader.CopyAtOffset(footerOffset);
var version = header.Version;
for (int i = 0; i < header.ConstantBuffers; i++)
{
result.LocalBuffers.Add(EffectBuffer.Parse(bodyReader, footerReader, version, false));
}
for (int i = 0; i < header.ObjectCount; i++)
{
result.LocalVariables.Add(EffectObjectVariable.Parse(bodyReader, footerReader, version, false));
}
for (int i = 0; i < header.SharedConstantBuffers; i++)
{
result.SharedBuffers.Add(EffectBuffer.Parse(bodyReader, footerReader, version, true));
}
for (int i = 0; i < header.SharedObjectCount; i++)
{
result.SharedVariables.Add(EffectObjectVariable.Parse(bodyReader, footerReader, version, true));
}
if (header.Version.MajorVersion >= 5)
{
for (int i = 0; i < header.InterfaceVariableCount; i++)
{
result.InterfaceVariables.Add(EffectInterfaceVariable.Parse(bodyReader, footerReader, version));
}
for (int i = 0; i < header.GroupCount; i++)
{
result.Groups.Add(EffectGroup.Parse(bodyReader, footerReader, header.Version));
}
}
else
{
for (int i = 0; i < header.Techniques; i++)
{
result.Techniques.Add(EffectTechnique.Parse(bodyReader, footerReader, header.Version));
}
}
return(result);
}
public static RootParameter Parse(BytecodeReader reader, BytecodeReader paramReader, RootSignatureVersion version)
{
var type = (RootParameterType)paramReader.ReadUInt32();
var visibility = (ShaderVisibility)paramReader.ReadUInt32();
var bodyOffset = paramReader.ReadUInt32();
var bodyReader = reader.CopyAtOffset((int)bodyOffset);
RootParameter result;
switch (type)
{
case RootParameterType.DescriptorTable:
result = RootDescriptorTable.Parse(reader, bodyReader, version);
break;
case RootParameterType._32BitConstants:
result = RootConstants.Parse(bodyReader);
break;
case RootParameterType.Srv:
case RootParameterType.Uav:
case RootParameterType.Cbv:
result = RootDescriptor.Parse(bodyReader, version);
break;
default:
throw new InvalidOperationException($"Can't parse Root Parameter of type {type}");
}
result.ParameterType = type;
result.ShaderVisibility = visibility;
return(result);
}
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);
}
}
}
public static EffectGroup Parse(BytecodeReader reader, BytecodeReader groupReader, ShaderVersion version)
{
var result = new EffectGroup();
var nameOffset = groupReader.ReadUInt32();
if (nameOffset != 0)
{
var nameReader = reader.CopyAtOffset((int)nameOffset);
result.Name = nameReader.ReadString();
}
else
{
result.Name = "";
}
var techniqueCount = groupReader.ReadUInt32();
for (int i = 0; i < techniqueCount; i++)
{
result.Techniques.Add(EffectTechnique.Parse(reader, groupReader, version));
}
var annotationCount = groupReader.ReadUInt32();
for (int i = 0; i < annotationCount; i++)
{
result.Annotations.Add(EffectAnnotation.Parse(reader, groupReader, version));
}
return(result);
}
public static ResourceBinding Parse(BytecodeReader reader, BytecodeReader resourceBindingReader, ShaderVersion target)
{
uint nameOffset = resourceBindingReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
var result = new ResourceBinding
{
Name = nameReader.ReadString(),
Type = (ShaderInputType)resourceBindingReader.ReadUInt32(),
ReturnType = (ResourceReturnType)resourceBindingReader.ReadUInt32(),
Dimension = (ShaderResourceViewDimension)resourceBindingReader.ReadUInt32(),
NumSamples = resourceBindingReader.ReadUInt32(),
BindPoint = resourceBindingReader.ReadUInt32(),
BindCount = resourceBindingReader.ReadUInt32(),
Flags = (ShaderInputFlags)resourceBindingReader.ReadUInt32()
};
if (target.MajorVersion == 5 && target.MinorVersion == 1)
{
result.m_IsSM51 = true;
result.SpaceIndex = resourceBindingReader.ReadUInt32();
result.ID = resourceBindingReader.ReadUInt32();
}
else
{
result.ID = result.BindPoint;
}
return(result);
}
public static InterfacesChunk Parse(BytecodeReader reader, uint sizeInBytes)
{
var headerReader = reader.CopyAtCurrentPosition();
var result = new InterfacesChunk();
var classInstanceCount = headerReader.ReadUInt32();
var classTypeCount = headerReader.ReadUInt32();
var interfaceSlotRecordCount = headerReader.ReadUInt32();
// Will be same as interfaceSlotRecordCount unless there are interface arrays.
result.InterfaceSlotCount = headerReader.ReadUInt32();
headerReader.ReadUInt32(); // Think this is offset to start of interface slot info, but we don't need it.
var classTypeOffset = headerReader.ReadUInt32();
var availableClassReader = reader.CopyAtOffset((int)classTypeOffset);
var interfaceSlotOffset = headerReader.ReadUInt32();
var interfaceSlotReader = reader.CopyAtOffset((int)interfaceSlotOffset);
for (uint i = 0; i < classTypeCount; i++)
{
var classType = ClassType.Parse(reader, availableClassReader);
classType.ID = i; // Really??
result.AvailableClassTypes.Add(classType);
}
for (uint i = 0; i < classInstanceCount; i++)
{
var classInstance = ClassInstance.Parse(reader, availableClassReader);
result.AvailableClassInstances.Add(classInstance);
}
uint startSlot = 0;
for (uint i = 0; i < interfaceSlotRecordCount; i++)
{
var interfaceSlot = InterfaceSlot.Parse(reader, interfaceSlotReader);
interfaceSlot.StartSlot = startSlot; // Really??
result.InterfaceSlots.Add(interfaceSlot);
startSlot += interfaceSlot.SlotSpan;
}
return(result);
}
public new static EffectInlineShaderAssignment Parse(BytecodeReader reader, BytecodeReader assignmentReader)
{
var result = new EffectInlineShaderAssignment();
var shaderOffset = assignmentReader.ReadUInt32();
var SODeclOffset = assignmentReader.ReadUInt32();
var shaderReader = reader.CopyAtOffset((int)shaderOffset);
var shaderSize = shaderReader.ReadUInt32();
if (shaderSize != 0)
{
result.Shader = BytecodeContainer.Parse(shaderReader.ReadBytes((int)shaderSize));
}
var SODeclReader = reader.CopyAtOffset((int)SODeclOffset);
result.SODecl = SODeclReader.ReadString();
return(result);
}
public new static EffectExpressionIndexAssignment Parse(BytecodeReader reader, BytecodeReader assignmentReader)
{
var result = new EffectExpressionIndexAssignment();
var arrayNameOffset = assignmentReader.ReadUInt32();
var arrayNameReader = reader.CopyAtOffset((int)arrayNameOffset);
result.ArrayName = arrayNameReader.ReadString();
var shaderOffset = assignmentReader.ReadUInt32();
var shaderReader = reader.CopyAtOffset((int)shaderOffset);
var shaderSize = shaderReader.ReadUInt32();
if (shaderSize != 0)
{
result.Shader = BytecodeContainer.Parse(shaderReader.ReadBytes((int)shaderSize));
}
return(result);
}
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 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 EffectAssignment Parse(BytecodeReader reader, BytecodeReader annotationReader)
{
//MemberType type, such as AddressV or Filter
var memberType = (EffectAssignmentType)annotationReader.ReadUInt32();
// $"EffectStateAnnotationType is {memberType}");
//MemberIndex is 1 for BlendEnable[1] = TRUE;
var memberIndex = annotationReader.ReadUInt32();
var assignmentType = (EffectCompilerAssignmentType)annotationReader.ReadUInt32();
var valueOffset = annotationReader.ReadUInt32();
var typeSpecificReader = reader.CopyAtOffset((int)valueOffset);
EffectAssignment result;
switch (assignmentType)
{
case EffectCompilerAssignmentType.Constant:
result = EffectConstantAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.Variable:
result = EffectVariableAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.ConstantIndex:
result = EffectConstantIndexAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.VariableIndex:
result = EffectVariableIndexAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.ExpressionIndex:
result = EffectExpressionIndexAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.Expression:
result = EffectExpressionAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.InlineShader:
result = EffectInlineShaderAssignment.Parse(reader, typeSpecificReader);
break;
case EffectCompilerAssignmentType.InlineShader5:
result = EffectInlineShader5Assignment.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 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 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 new static RootDescriptorTable Parse(BytecodeReader reader, BytecodeReader tableReader, RootSignatureVersion version)
{
var result = new RootDescriptorTable();
var numDescriptorRanges = tableReader.ReadUInt32();
var descriptorRangesOffset = tableReader.ReadUInt32();
var rangeReader = reader.CopyAtOffset((int)descriptorRangesOffset);
for (int i = 0; i < numDescriptorRanges; i++)
{
result.DescriptorRanges.Add(DescriptorRange.Parse(rangeReader, version));
}
return(result);
}
public static EffectInterfaceInitializer Parse(BytecodeReader reader, BytecodeReader initializerReader)
{
var nameOffset = initializerReader.ReadUInt32();
var index = initializerReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
var name = nameReader.ReadString();
return(new EffectInterfaceInitializer()
{
Name = name,
Index = index
});
}
public static EffectShaderData Parse(BytecodeReader reader, BytecodeReader variableReader)
{
var result = new EffectShaderData();
var shaderOffset = variableReader.ReadUInt32();
var bytecodeReader = reader.CopyAtOffset((int)shaderOffset);
var shaderSize = bytecodeReader.ReadUInt32();
if (shaderSize != 0)
{
result.Shader = BytecodeContainer.Parse(bytecodeReader.ReadBytes((int)shaderSize));
}
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 ClassType Parse(BytecodeReader reader, BytecodeReader classTypeReader)
{
var nameOffset = classTypeReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
return(new ClassType
{
Name = nameReader.ReadString(),
ID = classTypeReader.ReadUInt16(),
ConstantBufferStride = classTypeReader.ReadUInt16(),
Texture = classTypeReader.ReadUInt16(),
Sampler = classTypeReader.ReadUInt16()
});
}
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 ClassInstance Parse(BytecodeReader reader, BytecodeReader classInstanceReader)
{
var nameOffset = classInstanceReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
var name = nameReader.ReadString();
return(new ClassInstance
{
Name = name,
Type = classInstanceReader.ReadUInt16(),
ElementCount = classInstanceReader.ReadUInt16(),
ConstantBuffer = classInstanceReader.ReadUInt16(),
ConstantBufferOffset = classInstanceReader.ReadUInt16(),
Texture = classInstanceReader.ReadUInt16(),
Sampler = classInstanceReader.ReadUInt16(),
});
}
public static ResourceBinding Parse(BytecodeReader reader, BytecodeReader resourceBindingReader)
{
uint nameOffset = resourceBindingReader.ReadUInt32();
var nameReader = reader.CopyAtOffset((int)nameOffset);
return(new ResourceBinding
{
Name = nameReader.ReadString(),
Type = (ShaderInputType)resourceBindingReader.ReadUInt32(),
ReturnType = (ResourceReturnType)resourceBindingReader.ReadUInt32(),
Dimension = (ShaderResourceViewDimension)resourceBindingReader.ReadUInt32(),
NumSamples = resourceBindingReader.ReadUInt32(),
BindPoint = resourceBindingReader.ReadUInt32(),
BindCount = resourceBindingReader.ReadUInt32(),
Flags = (ShaderInputFlags)resourceBindingReader.ReadUInt32()
});
}
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 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 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);
}
