public static ConstantTable Parse(BytecodeReader ctabReader)
{
var result = new ConstantTable();
var ctabSize = ctabReader.ReadUInt32();
var creatorOffset = ctabReader.ReadInt32();
result.MajorVersion = ctabReader.ReadByte();
result.MinorVersion = ctabReader.ReadByte();
var shaderType = (ShaderType)ctabReader.ReadUInt16();
var numConstants = ctabReader.ReadInt32();
var constantInfoOffset = ctabReader.ReadInt32();
var shaderFlags = (ShaderFlags)ctabReader.ReadUInt32();
var shaderModelOffset = ctabReader.ReadInt32();
for (int i = 0; i < numConstants; i++)
{
var decReader = ctabReader.CopyAtOffset(constantInfoOffset + i * 20);
ConstantDeclaration declaration = ConstantDeclaration.Parse(ctabReader, decReader);
result.ConstantDeclarations.Add(declaration);
}
var shaderModelReader = ctabReader.CopyAtOffset(shaderModelOffset);
result.VersionString = shaderModelReader.ReadString();
var creatorReader = ctabReader.CopyAtOffset(creatorOffset);
result.Creator = creatorReader.ReadString();
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);
}
public static Sfi0Chunk Parse(BytecodeReader reader)
{
var flags = reader.ReadInt32();
Debug.Assert(flags == 1 || flags == 2); // TODO: Unknown
var result = new Sfi0Chunk();
if (flags == 1)
{
result.RequiresDoublePrecisionFloatingPoint = true;
}
return(result);
}
public static Sfi0Chunk Parse(BytecodeReader reader, uint chunkSize)
{
var flags = (ShaderRequiresFlags)reader.ReadInt32();
var result = new Sfi0Chunk();
result.Flags = flags;
Debug.Assert(chunkSize == 8,
$"Unexpected Sfi0 Chunk Size");
Debug.Assert(!int.TryParse(flags.ToString(), out _),
$"Unexpected SfiFlags {Convert.ToString((int)flags, 2)} {flags}");
var unknown0 = reader.ReadUInt32();
Debug.Assert(unknown0 == 0, "Sfi0 unknown value");
return(result);
}
protected void ParseInstance(BytecodeReader reader, uint chunkSize)
{
Version = ShaderVersion.ParseShex(reader);
var sizeInUint32 = reader.ReadUInt32();
var dxilMagic = reader.ReadUInt32();
DxilVersion = reader.ReadUInt32();
var bitcodeOffset = reader.ReadUInt32();
Debug.Assert(bitcodeOffset == 16, "Unexpected bitcode offset found");
var bitcodeLength = reader.ReadInt32();
var bitcodeReader = reader.CopyAtCurrentPosition();
Bitcode = bitcodeReader.ReadBytes(bitcodeLength);
}