示例#1
0
        // ---- METHODS ------------------------------------------------------------------------------------------------

        void IResData.Load(BfshaFileLoader loader)
        {
            long uniformArrayOffset = loader.ReadInt64();

            UniformDict = loader.LoadDict();
            long defaultOffset = loader.ReadInt64();

            Index = loader.ReadByte();
            Type  = loader.ReadEnum <BlockType>(true);
            Size  = loader.ReadUInt16();
            ushort uniformCount = loader.ReadUInt16();
            ushort padding      = loader.ReadUInt16();

            Uniforms = loader.LoadList <UniformVar>(uniformCount, uniformArrayOffset);
        }
示例#2
0
        void IResData.Load(BfshaFileLoader loader)
        {
            long sourceProgramOffset = loader.ReadInt64();
            long padding             = loader.ReadInt64();
            long binaryProgramOffset = loader.ReadInt64();
            long parentOffset        = loader.ReadInt64();

            loader.Seek(32);

            if (sourceProgramOffset != 0)
            {
                SourceProgram = loader.Load <ShaderProgram>(sourceProgramOffset);
                SourceProgram.ParentShaderVariation = this;
            }
            if (binaryProgramOffset != 0)
            {
                BinaryProgram = loader.Load <ShaderProgram>(binaryProgramOffset);
                BinaryProgram.ParentShaderVariation = this;
            }
        }
示例#3
0
        void IResData.Load(BfshaFileLoader loader)
        {
            Strings.Clear();
            loader.Seek(-0x14, System.IO.SeekOrigin.Current);
            uint Signature   = loader.ReadUInt32();
            uint blockOffset = loader.ReadUInt32();
            long BlockSize   = loader.ReadInt64();
            uint StringCount = loader.ReadUInt32();

            for (int i = 0; i < StringCount + 1; i++)
            {
                ushort size = loader.ReadUInt16();
                Strings.Add(loader.ReadString(BinaryStringFormat.ZeroTerminated));
                loader.Align(2);
            }
        }
        // ---- METHODS ------------------------------------------------------------------------------------------------

        void IResData.Load(BfshaFileLoader loader)
        {
            ShaderInputDictionary     = loader.LoadDict();
            ShaderOutputDictionary    = loader.LoadDict();
            ShaderSamplerDictionary   = loader.LoadDict();
            ShaderConstantsDictionary = loader.LoadDict();
            ShaderUnknownDictionary   = loader.LoadDict();
            Unknown1  = loader.ReadInt32();
            Unknown2  = loader.ReadInt32();
            Unknown3  = loader.ReadInt32();
            Unknown4  = loader.ReadInt32();
            Unknown5  = loader.ReadInt32();
            Unknown6  = loader.ReadInt32();
            Unknown7  = loader.ReadInt32();
            Unknown8  = loader.ReadInt32();
            Unknown9  = loader.ReadInt32();
            Unknown10 = loader.ReadInt32();
            Unknown11 = loader.ReadInt32();
            loader.ReadInt64(); //padding

            foreach (var key in ShaderInputDictionary)
            {
                Console.WriteLine($"Input: {key}");
            }
            foreach (var key in ShaderOutputDictionary)
            {
                Console.WriteLine($"Output: {key}");
            }
            foreach (var key in ShaderSamplerDictionary)
            {
                Console.WriteLine($"Sampler: {key}");
            }
            foreach (var key in ShaderConstantsDictionary)
            {
                Console.WriteLine($"Constant: {key}");
            }
            foreach (var key in ShaderUnknownDictionary)
            {
                Console.WriteLine($"Unknown: {key}");
            }
        }
        void IResData.Load(BfshaFileLoader loader)
        {
            ShaderVariations = new List <ShaderVariation>();
            StringTable      = new StringTable();

            loader.CheckSignature(_signature);
            uint padding = loader.ReadUInt32();

            SetVersionInfo(loader.ReadUInt32());
            ByteOrder         = loader.ReadEnum <ByteOrder>(false);
            Alignment         = loader.ReadByte();
            TargetAddressSize = loader.ReadByte(); //Thanks MasterF0X for pointing out the layout of the these
            uint   OffsetToFileName      = loader.ReadUInt32();
            ushort flag                  = loader.ReadUInt16();
            ushort blockOffset           = loader.ReadUInt16();
            uint   RelocationTableOffset = loader.ReadUInt32();
            uint   sizFile               = loader.ReadUInt32();

            loader.Seek(64); //Padding

            if (OffsetToFileName != 0)
            {
                using (loader.TemporarySeek(OffsetToFileName, SeekOrigin.Begin))
                {
                    Name = loader.ReadString(BinaryStringFormat.ZeroTerminated);
                }
            }

            //GRSC Section
            loader.CheckSignature(_grscSignature);
            loader.Seek(12); //Block header
            Unknown  = loader.ReadUInt16();
            Unknown2 = loader.ReadUInt16();
            Unknown3 = loader.ReadByte();
            Unknown4 = loader.ReadUInt32();
            uint VariationCount = loader.ReadUInt32();

            ShaderVariations = loader.LoadList <ShaderVariation>((int)VariationCount);
            loader.ReadInt64();
            Unknown5 = loader.ReadUInt64();
        }
示例#6
0
        void IResData.Load(BfshaFileLoader loader)
        {
            Name = loader.LoadString();
            long staticOptionArrayOffset = loader.ReadOffset();

            StaticOptionDict = loader.LoadDict();
            long dynamicOptionArrayOffset = loader.ReadOffset();

            DynamiOptionDict = loader.LoadDict();
            long attribArrayOffset = loader.ReadOffset();

            AttributeDict = loader.LoadDict();
            long samplerArrayOffset = loader.ReadOffset();

            SamplersDict = loader.LoadDict();

            if (loader.BfshaFile.VersionMinor >= 8)
            {
                loader.ReadInt64();
                loader.ReadInt64();
            }

            long uniformBlockArrayOffset = loader.ReadOffset();

            UniformBlockDict = loader.LoadDict();
            long uniformArrayOffset = loader.ReadOffset();

            if (loader.BfshaFile.VersionMinor >= 7)
            {
                loader.ReadInt64();
                loader.ReadInt64();
                loader.ReadInt64();
            }

            long shaderProgramArrayOffset = loader.ReadOffset();
            long tableOffset         = loader.ReadOffset();
            long shaderArchiveOffset = loader.ReadOffset();
            long shaderInfoOffset    = loader.ReadOffset();
            long shaderFileOffset    = loader.ReadOffset();

            loader.ReadUInt64();

            if (loader.BfshaFile.VersionMinor >= 7)
            {
                //padding
                loader.ReadInt64();
                loader.ReadInt64();
            }

            loader.ReadUInt64();
            loader.ReadUInt64();

            uint uniformCount = loader.ReadUInt32();

            if (loader.BfshaFile.VersionMinor <= 7)
            {
                loader.ReadUInt32();
            }
            int    defaultProgramIndex = loader.ReadInt32();
            ushort staticOptionCount   = loader.ReadUInt16();
            ushort dynamicOptionCount  = loader.ReadUInt16();
            ushort shaderProgramCount  = loader.ReadUInt16();
            byte   staticKeyLength     = loader.ReadByte();
            byte   dynamicKeyLength    = loader.ReadByte();
            byte   attribCount         = loader.ReadByte();
            byte   samplerCount        = loader.ReadByte();

            if (loader.BfshaFile.VersionMinor >= 8)
            {
                byte imageCount = loader.ReadByte();
            }

            byte uniformBlockCount = loader.ReadByte();

            loader.ReadBytes(5);

            if (loader.BfshaFile.VersionMinor >= 7)
            {
                loader.ReadBytes(6);
            }

            System.Console.WriteLine($"shaderFileOffset " + shaderFileOffset);
            System.Console.WriteLine($"Sampler " + samplerCount);
            System.Console.WriteLine($"attribCount " + attribCount);
            System.Console.WriteLine($"dynamicOptionCount " + dynamicOptionCount);
            System.Console.WriteLine($"staticOptionArrayOffset " + staticOptionArrayOffset);
            System.Console.WriteLine($"staticOptionCount " + staticOptionCount);

            if (loader.BfshaFile.VersionMinor >= 8)
            {
                loader.ReadBytes(7);
            }
            if (loader.BfshaFile.VersionMinor < 7)
            {
                loader.ReadBytes(4);
            }

            System.Console.WriteLine($"end pos " + loader.Position);

            int BnshSize = 0;

            if (shaderFileOffset != 0)
            {
                //Go into the bnsh file and get the file size
                using (loader.TemporarySeek(shaderFileOffset + 0x1C, System.IO.SeekOrigin.Begin))
                {
                    BnshSize = (int)loader.ReadUInt32();
                }
            }

            byte[] BinaryShaderData = loader.LoadCustom(() => loader.ReadBytes(BnshSize), shaderFileOffset);
            BnshFile = new BnshFile(new System.IO.MemoryStream(BinaryShaderData));

            StaticOptions = loader.LoadList <ShaderOption>(staticOptionCount, staticOptionArrayOffset);
            DynamiOptions = loader.LoadList <ShaderOption>(dynamicOptionCount, dynamicOptionArrayOffset);
            Attributes    = loader.LoadList <Attribute>(attribCount, attribArrayOffset);
            Samplers      = loader.LoadList <Sampler>(samplerCount, samplerArrayOffset);
            UniformBlocks = loader.LoadList <UniformBlock>(uniformBlockCount, uniformBlockArrayOffset);
            UniformVars   = loader.LoadList <UniformVar>((int)uniformCount, uniformArrayOffset);
        }