C# Palette.Load方法代码示例

        // headerStart seems to be chunkStart + 0x20 and I don't know why.
        public void Load(EndianBinaryReader stream, long headerStart, int imageIndex = 0)
        {
            Format = (TextureFormats)stream.ReadByte();
            AlphaSetting = stream.ReadByte();
            Width = stream.ReadUInt16();
            Height = stream.ReadUInt16();
            WrapS = (WrapModes)stream.ReadByte();
            WrapT = (WrapModes)stream.ReadByte();
            byte unknown1 = stream.ReadByte();
            PaletteFormat = (PaletteFormats)stream.ReadByte();
            PaletteCount = stream.ReadUInt16();
            int paletteDataOffset = stream.ReadInt32();
            BorderColor = new Color32(stream.ReadByte(), stream.ReadByte(), stream.ReadByte(), stream.ReadByte());
            MinFilter = (FilterMode)stream.ReadByte();
            MagFilter = (FilterMode)stream.ReadByte();
            short unknown2 = stream.ReadInt16();
            MipMapCount = stream.ReadByte();
            byte unknown3 = stream.ReadByte();
            LodBias = stream.ReadUInt16();

            int imageDataOffset = stream.ReadInt32();

            // Load the Palette data
            stream.BaseStream.Position = headerStart + paletteDataOffset + (0x20 * imageIndex);
            m_imagePalette = new Palette();
            m_imagePalette.Load(stream, PaletteCount);

            // Now load and decode image data into an ARGB array.
            stream.BaseStream.Position = headerStart + imageDataOffset + (0x20 * imageIndex);
            m_rgbaImageData = DecodeData(stream, Width, Height, Format, m_imagePalette, PaletteFormat);
        }

        /// <summary>
        /// Loads a BTI file from a byte array. BTI files have two ways of being stored,
        /// both externally in their own file (simple), and embedded within another 
        /// file (complex). If you're loading from an isolated file, simply pass the
        /// entire file to data and zero for the other two parameters.
        /// 
        /// However, embedded files are more complicated. An embedded file stores the
        /// data in the following format: [bti header][bti header][bti header][bti data]
        /// [bti data][bti data]. The embedded bti files store their offsets relative not
        /// to the start of the first bti header, but to themselves.
        /// 
        /// To handle this, pass the offset into the byte[] that the header is at for 
        /// <paramref name="mainOffset"/> and then pass (btiHeaderIndex * FileHeader.Size)
        /// for <paramref name="dataOffset"/>. This load function will resolve the offsets
        /// for loading.
        /// </summary>
        /// <param name="data">Array holding entire BTI file.</param>
        /// <param name="mainOffset">Offset from start of array to BTI file.</param>
        /// <param name="dataOffset">Additional offset required by embedded BTI files.</param>
        public void Load(byte[] data, uint mainOffset, uint dataOffset)
        {
            _header = new FileHeader();
            _header.Load(data, mainOffset);

            //Copy our public settings out of the header and into the BinaryTextureImage instance.
            Format = _header.Format;
            Width = _header.Width;
            Height = _header.Height;
            WrapS = _header.WrapS;
            WrapT = _header.WrapT;
            MinFilter = _header.FilterSettingMin;
            MagFilter = _header.FilterSettingMag;

            //Grab the palette data
            _imagePalette = new Palette();
            _imagePalette.Load(data, _header.PaletteEntryCount, dataOffset + _header.PaletteDataOffset);

            //Now lets load a copy of the image data out of the file.
            _argbImageData = DecodeData(data, Width, Height, dataOffset + _header.ImageDataOffset, Format, _imagePalette, _header.PaletteFormat);
        }