Exemple #1
0
        internal static DebugShaderVariable Parse(DebugBytecodeReader reader,
                                                  DebugBytecodeReader variableReader, DebugShaderVersion target, bool isFirst)
        {
            uint nameOffset = variableReader.ReadUInt32("nameOffset");
            var  nameReader = reader.CopyAtOffset("nameReader", variableReader, (int)nameOffset);
            var  name       = nameReader.ReadString("name");

            var  startOffset = variableReader.ReadUInt32("startOffset");
            uint size        = variableReader.ReadUInt32("size");
            var  flags       = variableReader.ReadEnum32 <ShaderVariableFlags>("flags");

            var typeOffset = variableReader.ReadUInt32("typeOffset");
            var typeReader = reader.CopyAtOffset("typeReader", variableReader, (int)typeOffset);
            var shaderType = DebugShaderType.Parse(reader, typeReader, target, 2, isFirst, startOffset);

            var           defaultValueOffset = variableReader.ReadUInt32("defaultValueOffset");
            List <Number> defaultValue       = null;

            if (defaultValueOffset != 0)
            {
                defaultValue = new List <Number>();
                var defaultValueReader = reader.CopyAtOffset("defaultValueReader", variableReader, (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($"defaultValue{i}", 4)));
                }
            }


            var result = new DebugShaderVariable
            {
                DefaultValue = defaultValue,
                Member       = new DebugShaderTypeMember(0)
                {
                    Name   = name,
                    Offset = startOffset,
                    Type   = shaderType
                },
                BaseType = name,
                Size     = size,
                Flags    = flags
            };

            if (target.MajorVersion >= 5 || target.ProgramType == ProgramType.LibraryShader)
            {
                result.StartTexture = variableReader.ReadInt32("startTexture");
                result.TextureSize  = variableReader.ReadInt32("textureSize");
                result.StartSampler = variableReader.ReadInt32("startSampler");
                result.SamplerSize  = variableReader.ReadInt32("samplerSize");
            }

            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 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);
        }