コード例 #1
0
        public static DebugConstantType Parse(DebugBytecodeReader reader, DebugBytecodeReader typeReader)
        {
            var result = new DebugConstantType();

            result.ParameterClass = typeReader.ReadEnum16 <ParameterClass>("ParameterClass");
            result.ParameterType  = typeReader.ReadEnum16 <ParameterType>("ParameterType");
            result.Rows           = typeReader.ReadUInt16("Rows");
            result.Columns        = typeReader.ReadUInt16("Columns");
            result.Elements       = typeReader.ReadUInt16("Elements");
            result.MemberCount    = typeReader.ReadUInt16("Members");
            var memberInfoOffset = typeReader.ReadUInt32("MemberInfoOffset");

            if (memberInfoOffset != 0)
            {
                var memberInfoReader = reader.CopyAtOffset("MemberReader", typeReader, (int)memberInfoOffset);
                for (int i = 0; i < result.MemberCount; i++)
                {
                    var nameOffset = memberInfoReader.ReadUInt32($"Member{i}NameOffset");
                    var nameReader = reader.CopyAtOffset($"Member{i}NameReader", memberInfoReader, (int)nameOffset);
                    nameReader.ReadString("Name");
                    var typeOffset       = memberInfoReader.ReadUInt32($"Member{i}TypeOffset");
                    var memberTypeReader = reader.CopyAtOffset($"Member{i}TypeReader", memberInfoReader, (int)typeOffset);
                    result.Members.Add(DebugConstantType.Parse(reader, memberTypeReader));
                }
            }
            return(result);
        }
コード例 #2
0
        public static DebugShaderModel Parse(DebugBytecodeReader reader)
        {
            var result = new DebugShaderModel();

            result.MinorVersion = reader.ReadByte("MinorVersion");
            result.MajorVersion = reader.ReadByte("MajorVersion");
            result.Type         = reader.ReadEnum16 <ShaderType>("ShaderType");
            while (true)
            {
                var    token  = reader.PeakUint32();
                Opcode opcode = (Opcode)(token & 0xffff);
                if (opcode == Opcode.Comment && result.ReadCommentToken(reader))
                {
                    continue;
                }
                reader.AddIndent($"T{result.Tokens.Count}");

                var         indent      = reader.LocalMembers.OfType <DebugIndent>().Last();
                IDebugToken instruction = result.ReadInstruction(reader);
                result.Tokens.Add(instruction);
                indent.Name += $" {instruction.Opcode} {string.Join(" ", instruction.Operands)}";
                reader.RemoveIndent();
                if (instruction.Opcode == Opcode.End)
                {
                    break;
                }
            }
            return(result);
        }
コード例 #3
0
        public static DebugConstantDeclaration Parse(DebugBytecodeReader reader, DebugBytecodeReader decReader)
        {
            var result     = new DebugConstantDeclaration();
            var nameOffset = decReader.ReadUInt32("NameOffset");

            result.RegisterSet   = decReader.ReadEnum16 <RegisterSet>("RegisterSet");
            result.RegisterIndex = decReader.ReadUInt16("RegisterIndex");
            result.RegisterCount = decReader.ReadUInt16("RegisterCount");
            decReader.ReadUInt16("Reserved");
            var typeInfoOffset     = decReader.ReadUInt32("TypeInfoOffset");
            var defaultValueOffset = decReader.ReadUInt32("DefaultValueOffset");

            var nameReader = reader.CopyAtOffset("NameReader", decReader, (int)nameOffset);

            result.Name = nameReader.ReadString("Name");

            var typeReader = reader.CopyAtOffset("TypeReader", decReader, (int)typeInfoOffset);

            result.Type = DebugConstantType.Parse(reader, typeReader);

            if (defaultValueOffset != 0)
            {
                //Note: thre are corrisponding def instructions. TODO: check that they are the same
                var defaultValueReader = reader.CopyAtOffset("DefaultValueReader", decReader, (int)defaultValueOffset);
                var elementCount       = result.Type.GetSize() / 4;
                for (int i = 0; i < elementCount; i++)
                {
                    result.DefaultValue.Add(defaultValueReader.ReadSingle($"DefaultValue {i}"));
                }
            }

            return(result);
        }
コード例 #4
0
        public static DebugRuntimeConstantMapping Parse(DebugBytecodeReader reader)
        {
            var result = new DebugRuntimeConstantMapping();

            result.ConstantDescription = reader.ReadEnum16 <RuntimeConstantDescription>("ConstantDescription");
            result.TargetReg           = reader.ReadUInt16("TargetReg");
            return(result);
        }
コード例 #5
0
        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);
        }