예제 #1
0
        /// <summary>
        /// Automatically generates a TSA-compliant image from a 256(or fewer)-color image
        /// </summary>
        /// <param name="width">Width of the TSA (in tiles)</param>
        /// <param name="height">Height of the TSA (in tiles)</param>
        /// <param name="image">The bitmap to convert</param>
        /// <param name="paletteAmount">the maximum amount of 16-color palettes</param>
        /// <param name="checkRedundantTiles">whether or not to add all tiles found to the tileset</param>
        public TSA_Image(
            int width, int height,
            GBA.Bitmap image,
            int paletteAmount,
            bool checkRedundantTiles)
        {
            Width  = width * 8;
            Height = height * 8;

            if (image.Width != Width || image.Height != Height)
            {
                throw new Exception("Image given has invalid dimensions.\n" +
                                    "It must be " + Width + "x" + Height + " pixels.");
            }

            if (image.Colors.Count <= 16)
            {   // No need to run TSA-ifier code
                Palettes = Palette.Split(image.Colors, paletteAmount);

                Graphics = new Tileset(new Image(image));

                Tiling = TSA_Array.GetBasicTSA(width, height);
            }
            else
            {
                using (FormLoading loading = new FormLoading())
                { // Run the image TSA-ifier
                    loading.Show();

                    int    tileAmount  = width * height;
                    byte[] bytes       = image.ToBytes();
                    int[]  colorTotals = new int[image.Colors.Count];
                    int[,] colorAmounts = new int[image.Colors.Count, tileAmount];

                    loading.SetLoading("Checking colors...", 2);

                    int index;
                    int tile = 0;
                    for (int tileY = 0; tileY < height; tileY++)
                    {
                        for (int tileX = 0; tileX < width; tileX++)
                        {
                            index = tileX * 8 + tileY * 8 * Width;
                            for (int y = 0; y < 8; y++)
                            {
                                for (int x = 0; x < 8; x++)
                                {
                                    colorTotals[bytes[index]]++;
                                    colorAmounts[bytes[index], tile]++;
                                }
                                index += Width - 8;
                            }
                            tile++;
                        } // first we take a look at which colors are most present (in all, and per tile)
                    }
                    loading.SetPercent(7);

                    List <int> colors = new List <int>();
                    for (int i = 0; i < colorTotals.Length; i++)
                    {
                        index = 0;
                        while (index < colors.Count && colorTotals[i] > colors[index])
                        {
                            index++;
                        }

                        if (index < colors.Count)
                        {
                            colors.Insert(index, i);
                        }
                        else
                        {
                            colors.Add(i);
                        }

                        if (colors.Count > paletteAmount * 15)
                        {
                            colors.RemoveAt(0);
                        }
                    } // then we create a list of indices to colors with only the most used colors

                    loading.SetPercent(9);

                    Palettes = new Palette[paletteAmount];
                    for (int i = 0; i < paletteAmount; i++)
                    {
                        Palettes[i] = new GBA.Palette(16);
                        Palettes[i].Add(new GBA.Color(0x0000));
                    } // we create our palettes, forcing the 1st color to be black on each palette

                    loading.SetLoading("Asserting tile palettes...", 10);

                    byte[]    tilePalettes = new byte[tileAmount];
                    int[]     certainty    = new int[tileAmount];
                    GBA.Color color;
                    int       amount;
                    for (int i = colors.Count - 1; i >= 0; i--)
                    {
                        color = image.Colors[colors[i]];
                        tile  = 0;

                        while (tile < tilePalettes.Length)
                        {
                            amount = colorAmounts[colors[i], tile];

                            if (Palettes[tilePalettes[tile]].Contains(color))
                            {
                                certainty[tile] += amount;
                            }
                            else
                            {
                                if (Palettes[tilePalettes[tile]].IsFull)
                                {
                                    if (certainty[tile] < amount)
                                    {
                                        tilePalettes[tile]++;
                                        tilePalettes[tile] %= (byte)Palettes.Length;
                                        certainty[tile]     = 0;
                                        i++; break;
                                    }
                                    else
                                    {
                                        certainty[tile] -= amount;
                                    }
                                }
                                else if (amount != 0)
                                {
                                    Palettes[tilePalettes[tile]].Add(color);
                                    certainty[tile] += amount;
                                }
                            }
                            tile++;
                        }
                        loading.SetPercent(10 + (50 - 50 * ((float)i / (float)(colors.Count))));
                    } // and we do a loop going from  most used color to least used, setting tilePalettes and filling said palettes

                    amount = 0;
                    for (int p = 0; p < Palettes.Length; p++)
                    {
                        Palettes[p].Sort(delegate(GBA.Color first, GBA.Color second)
                        {
                            return((first.GetValueR() + first.GetValueG() + first.GetValueB())
                                   - (second.GetValueR() + second.GetValueG() + second.GetValueB()));
                        });
                        for (int i = Palettes[p].Count; i < 16; i++)
                        {
                            Palettes[p].Add(new Color(0x0000));
                        }
                    }

                    loading.SetMessage("Creating TSA information...");

                    Graphics = new Tileset(width * height);
                    Tiling   = new TSA_Array(width, height);
                    int pixel;
                    tile = 0;
                    byte HI_nibble;
                    byte LO_nibble;
                    Tile currentTile;
                    Tuple <int, bool, bool> current;
                    for (int tileY = 0; tileY < height; tileY++)
                    {
                        for (int tileX = 0; tileX < width; tileX++)
                        {
                            index = (Palettes[tilePalettes[tile]].IsFull) ? tilePalettes[tile] : 0;
                            bytes = new byte[GBA.Tile.LENGTH];

                            for (int y = 0; y < 8; y++)
                            {
                                for (int x = 0; x < 4; x++)
                                {
                                    color     = image.GetColor(tileX * 8 + x * 2, tileY * 8 + y);
                                    pixel     = GBA.Color.GetNearest(Palettes[index], color);
                                    LO_nibble = (pixel == -1) ? (byte)0x00 : (byte)(pixel);

                                    color     = image.GetColor(tileX * 8 + x * 2 + 1, tileY * 8 + y);
                                    pixel     = GBA.Color.GetNearest(Palettes[index], color);
                                    HI_nibble = (pixel == -1) ? (byte)0x00 : (byte)(pixel);

                                    bytes[x + y * 4] = (byte)((HI_nibble << 4) | LO_nibble);
                                }
                            }

                            currentTile = new Tile(bytes);

                            if (checkRedundantTiles)
                            {
                                if (currentTile.IsEmpty())
                                {
                                    current = Tuple.Create(0, false, false);
                                }
                                else
                                {
                                    current = Graphics.FindMatch(currentTile);

                                    if (current == null)
                                    {
                                        current = Tuple.Create(Graphics.Count, false, false);
                                        Graphics.Add(currentTile);
                                    }
                                }
                            }
                            else
                            {
                                current = Tuple.Create(Graphics.Count, false, false);
                                Graphics.Add(currentTile);
                            }
                            // try {
                            Tiling[tileX, tileY] = new TSA(
                                (UInt16)current.Item1,
                                tilePalettes[tile],
                                current.Item2,
                                current.Item3);
                            // } catch { }

                            loading.SetPercent(60 + 40 * ((float)tile / (float)tileAmount));
                            tile++;
                        }
                    }
                }
            }
        }
예제 #2
0
        /// <summary>
        /// Creates a Palette from a palette file (if its an image file, must be 16 pixels in width)
        /// </summary>
        public Palette(string filepath, int maximum = MAX)
        {
            Colors = new List <Color>(maximum);

            if (filepath.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ||
                filepath.EndsWith(".gif", StringComparison.OrdinalIgnoreCase) ||
                filepath.EndsWith(".bmp", StringComparison.OrdinalIgnoreCase))
            {
                Bitmap source;
                try
                {
                    source = new GBA.Bitmap(filepath);
                }
                catch { throw new Exception("Could not open palette file:\n" + filepath); }

                bool  addEveryPixel = (source.Width == 16);
                int   index         = 0;
                Color color;
                for (int y = 0; y < source.Height; y++)
                {
                    for (int x = 0; x < source.Width; x++)
                    {
                        color = source.GetColor(x, y);
                        if (!addEveryPixel && this.Contains(color))
                        {
                            continue;
                        }
                        else
                        {
                            if (this.IsFull)
                            {
                                throw new Exception("This palette cannot hold more than " + maximum + " colors.");
                            }
                            else
                            {
                                this.Colors.Add(color);
                                index++;
                            }
                        }
                    }
                }
            }
            else if (filepath.EndsWith(".pal", StringComparison.OrdinalIgnoreCase))
            {
                byte[] palette = File.ReadAllBytes(filepath);

                if (palette[0] == 0x43 &&
                    palette[1] == 0x4C &&
                    palette[2] == 0x52 &&
                    palette[3] == 0x58) // 'CLRX' is the header for usenti .pal files
                {
                    string[] file = File.ReadAllLines(filepath);
                    int      channelBits;
                    int      colorAmount;

                    int parse  = 5;
                    int length = 0;

                    while (parse + length < file[0].Length && file[0][parse + length] != ' ')
                    {
                        length++;
                    }
                    channelBits = int.Parse(file[0].Substring(parse, length));

                    parse += length + 1;
                    length = 0;

                    while (parse + length < file[0].Length && file[0][parse + length] != ' ')
                    {
                        length++;
                    }
                    colorAmount = int.Parse(file[0].Substring(parse, length));

                    uint    color  = 0x00000000;
                    Palette colors = new Palette(colorAmount);
                    for (int i = 0; i < (colorAmount / 4); i++)
                    {
                        parse  = 0;
                        length = 0;

                        for (int j = 0; j < 4; j++)
                        {
                            while (parse + length < file[1 + i].Length &&
                                   file[1 + i][parse + length] != ' ')
                            {
                                length++;
                            }

                            color = Util.HexToInt(file[1 + i].Substring(parse, length));
                            colors.Add(new Color(color));

                            parse += length + 1;
                            length = 0;
                        }
                    }
                    palette = colors.ToBytes(false);
                }
                else if (palette.Length != maximum * 2)
                {
                    throw new Exception(
                              "Cannot load palette, the file given is of invalid length.\n" +
                              "It should be " + maximum * 2 + " bytes long.");
                }


                byte[] buffer = new byte[2];
                for (int i = 0; i < palette.Length / 2; i++)
                {
                    buffer[0] = palette[i * 2 + 1];
                    buffer[1] = palette[i * 2];
                    Colors.Add(new Color(buffer));
                }
            }
            else
            {
                throw new Exception("Invalid filetype given to load palette.");
            }
        }