Esempio n. 1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="output"></param>
        public void Save(Stream output)
        {
            using (var bw = new BinaryWriterX(output, true))
            {
                // Updates
                Header.Width  = (short)Texture.Width;
                Header.Height = (short)Texture.Height;

                // Header
                bw.WriteType(Header);
                bw.WriteAlignment();
                bw.WriteString(FileName, Encoding.ASCII, false);
                bw.WriteAlignment();

                // Setup
                if (Header.Format == ImageFormat.Palette_8)
                {
                    var settings = new PaletteImageSettings(Formats[ImageFormat.RGBA8888], PaletteFormats[ImageFormat.Palette_8], Header.Width, Header.Height);
                    var data     = Common.Save(Texture, Palette, settings);

                    bw.Write(data.indexData);
                    bw.Write(data.paletteData);
                }
                else
                {
                    var settings = new ImageSettings(Formats[ImageFormat.RGBA8888], Header.Width, Header.Height);
                    var data     = Common.Save(Texture, settings);

                    bw.Write(data);
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="input"></param>
        public GXT(Stream input)
        {
            using (var br = new BinaryReaderX(input, true))
            {
                // Header
                Header = br.ReadType <FileHeader>();

                // Setup
                var paletteDataLength = 256 * 4;

                // Image
                var texture = br.ReadBytes(Header.ImageDataSize);

                // Palette
                var palette = br.ReadBytes(paletteDataLength);

                var settings = new PaletteImageSettings(Formats[ImageFormat.RGBA8888], PaletteFormats[ImageFormat.Palette_8], Header.Width, Header.Height);
                var data     = Common.Load(texture, palette, settings);
                Texture    = data.image;
                Palette    = data.palette;
                FormatName = PaletteFormats[ImageFormat.Palette_8].FormatName;

                //if (Header.Format == ImageFormat.Palette_8)
                //{
                //}
                //else
                //{
                //    var settings = new ImageSettings(Formats[ImageFormat.RGBA8888], Header.Width, Header.Height);
                //    Texture = Common.Load(texture, settings);
                //    FormatName = Formats[ImageFormat.RGBA8888].FormatName;
                //}
            }
        }
Esempio n. 3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="input"></param>
        public BTX(Stream input)
        {
            using (var br = new BinaryReaderX(input, true))
            {
                // Header
                Header = br.ReadType <FileHeader>();
                br.SeekAlignment();
                FileName = br.ReadCStringASCII();

                // Setup
                var dataLength        = Header.Width * Header.Height;
                var paletteDataLength = Header.ColorCount * 4;

                // Image
                br.BaseStream.Position = Header.ImageOffset;
                var texture = br.ReadBytes(dataLength);

                // Palette
                if (Header.Format == ImageFormat.Palette_8)
                {
                    br.BaseStream.Position = Header.PaletteOffset;
                    var palette = br.ReadBytes(paletteDataLength);

                    var settings = new PaletteImageSettings(Formats[ImageFormat.RGBA8888], PaletteFormats[ImageFormat.Palette_8], Header.Width, Header.Height);
                    var data     = Common.Load(texture, palette, settings);
                    Texture    = data.image;
                    Palette    = data.palette;
                    FormatName = PaletteFormats[ImageFormat.Palette_8].FormatName;
                }
                else
                {
                    var settings = new ImageSettings(Formats[ImageFormat.RGBA8888], Header.Width, Header.Height);
                    Texture    = Common.Load(texture, settings);
                    FormatName = Formats[ImageFormat.RGBA8888].FormatName;
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Converts a given Bitmap, modified by given settings, in binary data
        /// </summary>
        /// <param name="bmp">The bitmap, which will be converted.</param>
        /// <param name="palette">The list containing all colors of the palette to use.</param>
        /// <param name="settings">The settings determining the final binary data output.</param>
        /// <returns><see cref="Tuple"/> containing 2 byte arrays</returns>
        public static (byte[] indexData, byte[] paletteData) Save(Bitmap bmp, IList <Color> palette, PaletteImageSettings settings)
        {
            var indeces = new List <IndexData>();
            var points  = GetPointSequence(settings); // Swizzle

            foreach (var point in points)
            {
                var x = Clamp(point.X, 0, bmp.Width);
                var y = Clamp(point.Y, 0, bmp.Height);

                var color = bmp.GetPixel(x, y);
                var index = settings.PaletteFormat.RetrieveIndex(color, palette);

                indeces.Add(index);
            }

            return(settings.PaletteFormat.SaveIndices(indeces), settings.Format.Save(palette));
        }
Esempio n. 5
0
        /// <summary>
        /// Loads the binary data with given settings as an image.
        /// </summary>
        /// <param name="bytes">Bytearray containing the binary image data.</param>
        /// <param name="paletteBytes">Bytearray containing the binary palette data.</param>
        /// <param name="settings">The settings determining the final image output.</param>
        /// <returns>Bitmap</returns>
        public static (Bitmap image, IList <Color> palette) Load(byte[] bytes, byte[] paletteBytes, PaletteImageSettings settings)
        {
            int width = settings.Width, height = settings.Height;
            var paletteFormat = settings.PaletteFormat;

            var points  = GetPointSequence(settings);
            var indeces = paletteFormat.LoadIndeces(bytes);
            var palette = settings.Format.Load(paletteBytes).ToList();

            var bmp  = new Bitmap(width, height);
            var data = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

            unsafe
            {
                var imagePtr = (int *)data.Scan0;
                if (imagePtr == null)
                {
                    throw new ArgumentNullException(nameof(imagePtr));
                }
                foreach (var(point, indexData) in points.Zip(indeces, Tuple.Create))
                {
                    int x = point.X, y = point.Y;
                    if (0 > x || x >= width || 0 > y || y >= height)
                    {
                        continue;
                    }

                    imagePtr[data.Stride * y / 4 + x] = paletteFormat.RetrieveColor(indexData, palette).ToArgb();
                }
            }
            bmp.UnlockBits(data);

            return(bmp, palette);
        }