public void UpdateConfigCollision()
        {
            try
            {
                if (CollisionMaskA != null)
                {
                    CollisionMaskA.Dispose();
                }
                if (CollisionMaskB != null)
                {
                    CollisionMaskB.Dispose();
                }
                if (CollectiveImage != null)
                {
                    CollectiveImage.Dispose();
                }

                CollisionMaskA  = new Classes.Rendering.GIF(DrawCollisionMaskA());
                CollisionMaskB  = new Classes.Rendering.GIF(DrawCollisionMaskB());
                CollectiveImage = new Classes.Rendering.GIF(CreateCollectiveImage());
            }
            catch (Exception ex)
            {
                throw new Events.TileConfigException("Unable to load Tileconfig.bin!" + Environment.NewLine + "Full Exception Details: " + ex.Message);
            }
        }
        private static void DrawIndexedTile(ref Classes.Rendering.GIF InputImage, ref Bitmap ExportBitmap, int TileIndex, int x, int y)
        {
            var tileBitmap = InputImage.GetBitmapIndexed(GetSection(TileIndex, InputImage.Width));
            var bitmapData = tileBitmap.LockBits(new Rectangle(0, 0, 16, 16), ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);

            byte[][] CurrentTileData = GetTileColors(bitmapData);

            for (int h = 0; h < 16; h++)
            {
                for (int w = 0; w < 16; w++)
                {
                    int indexColor = CurrentTileData[h][w];
                    SetPixel(ExportBitmap, x + w, y + h, indexColor);
                }
            }
            tileBitmap.UnlockBits(bitmapData);



            byte[][] GetTileColors(BitmapData _bitmapData)
            {
                byte[][] output = new byte[16][];
                for (int h = 0; h < 16; h++)
                {
                    output[h] = new byte[16];
                    for (int w = 0; w < 16; w++)
                    {
                        output[h][w] = GetIndexedPixel(w, h, _bitmapData);
                    }
                }
                return(output);
            }

            Rectangle GetSection(int index, int base_width)
            {
                int _columns = base_width / 16;

                int _posX = (index % _columns) * 16;
                int _posY = (index / _columns) * 16;

                return(new Rectangle(_posX, _posY, 16, 16));
            }

            unsafe Byte GetIndexedPixel(int _x, int _y, BitmapData bmd)
            {
                byte *p      = (byte *)bmd.Scan0.ToPointer();
                int   offset = _y * bmd.Stride + _x;

                return(p[offset]);
            }

            void SetPixel(Bitmap bmp, int _x, int _y, int paletteEntry)
            {
                BitmapData data = bmp.LockBits(new Rectangle(new System.Drawing.Point(_x, _y), new System.Drawing.Size(1, 1)), System.Drawing.Imaging.ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
                byte       b    = Marshal.ReadByte(data.Scan0);

                Marshal.WriteByte(data.Scan0, (byte)(b & 0xf | (paletteEntry)));
                bmp.UnlockBits(data);
            }
        }
        public static Classes.Rendering.GIF Import(string filename)
        {
            Classes.Rendering.GIF InputImage = new Classes.Rendering.GIF(filename);
            int lastIndex = -1;

            try
            {
                int tilesPerRow = 1;

                int columns = InputImage.Width / 16;
                int rows    = InputImage.Height / 16;

                int maxTiles = columns * rows;
                int tileSize = 16;

                int imageWidth  = tileSize * tilesPerRow;
                int imageHeight = (maxTiles / tilesPerRow) * tileSize;

                Bitmap bitmap = new Bitmap(imageWidth, imageHeight);

                int row = 0;
                using (Graphics g = Graphics.FromImage(bitmap))
                {
                    for (int tileIndex = 0; tileIndex < maxTiles - 1;)
                    {
                        for (int col = 0; col < tilesPerRow;)
                        {
                            if (tileIndex > maxTiles - 1)
                            {
                                break;
                            }
                            else
                            {
                                DrawTile(g, ref InputImage, tileIndex, col * tileSize, row * tileSize);
                                tileIndex++;
                                lastIndex = tileIndex;
                            }
                            col++;
                        }
                        row++;
                    }
                }
                return(new Rendering.GIF(bitmap));
            }
            catch (Exception ex)
            {
                System.Windows.MessageBox.Show("[" + lastIndex + "]" + ex.Message);
                return(null);
            }
        }
        public static void ExportIndexed(Classes.Rendering.GIF InputImage, string filename, int tilesPerRow)
        {
            int lastIndex = -1;

            try
            {
                int columns = InputImage.Width / 16;
                int rows    = InputImage.Height / 16;


                int maxTiles = columns * rows;
                int tileSize = 16;

                int imageWidth  = tileSize * tilesPerRow;
                int imageHeight = (maxTiles / tilesPerRow) * tileSize;

                Bitmap bitmap = new Bitmap(imageWidth, imageHeight, System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
                {
                    Palette = InputImage.GetPalette()
                };

                int row = 0;
                for (int tileIndex = 0; tileIndex < maxTiles - 1;)
                {
                    for (int col = 0; col < tilesPerRow;)
                    {
                        if (tileIndex > maxTiles - 1)
                        {
                            break;
                        }
                        else
                        {
                            DrawIndexedTile(ref InputImage, ref bitmap, tileIndex, col * 16, row * 16);
                            tileIndex++;
                            lastIndex = tileIndex;
                        }
                        col++;
                    }
                    row++;
                }

                bitmap.Save(filename);
                bitmap.Dispose();
            }
            catch (Exception ex)
            {
                System.Windows.MessageBox.Show("[" + lastIndex + "]" + ex.Message);
            }
        }
        private static void DrawTile(Graphics Graphics, ref Classes.Rendering.GIF InputImage, int TileIndex, int x, int y)
        {
            var tileBitmap = InputImage.GetBitmap(GetSection(TileIndex, InputImage.Width));

            Graphics.DrawImage(tileBitmap, x, y);


            Rectangle GetSection(int index, int base_width)
            {
                int _columns = base_width / 16;

                int _posX = (index % _columns) * 16;
                int _posY = (index / _columns) * 16;

                return(new Rectangle(_posX, _posY, 16, 16));
            }
        }
        public void Save(bool saveAs = false)
        {
            int columns = GenerationsLib.WPF.IntergerPrompt.ShowDialog("Enter Column Amount...", "Enter the Amount of Columns You wish this Exported Sheet to Have", 1);

            System.Windows.Forms.SaveFileDialog save = new System.Windows.Forms.SaveFileDialog
            {
                Filter           = "Exported Tiles|*.gif",
                DefaultExt       = "gif",
                InitialDirectory = ManiacEditor.Methods.Solution.SolutionPaths.SceneFile_Source.SourceDirectory,
                RestoreDirectory = false,
                FileName         = "16x16Tiles_Exported"
            };
            if (save.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                var bitmap = GenerateBitmap();
                Classes.Rendering.GIF ExportableFile = new Classes.Rendering.GIF(bitmap);
                Classes.Scene.EditorTiles.Export(ExportableFile, save.FileName, columns);
            }
        }
        private List <System.Windows.Media.Imaging.BitmapSource> GetCurrentTileImages(Classes.Rendering.GIF Image)
        {
            List <System.Windows.Media.Imaging.BitmapSource> TilesList = new List <System.Windows.Media.Imaging.BitmapSource>();

            if (Image != null)
            {
                int columns = Image.Width / 16;
                int rows    = Image.Height / 16;

                int maxTiles = columns * rows;

                for (int i = 0; i < maxTiles; i++)
                {
                    TilesList.Add(Image.GetImageSource(new System.Drawing.Rectangle(0, 16 * i, 16, 16), false, false));
                }
            }
            return(TilesList);
        }
 public void TilesReload(Classes.Rendering.GIF Image)
 {
     TileList.Clear();
     TileList = GetCurrentTileImages(Image);
     UpdateList();
 }
 private void CreateDefaultTiles()
 {
     IDImage         = new Classes.Rendering.GIF(Environment.CurrentDirectory + "\\Resources\\Tile Overlays\\" + "16x16Tiles_ID.gif");
     InternalImage   = new Classes.Rendering.GIF(Environment.CurrentDirectory + "\\Resources\\Tile Overlays\\" + "16x16Tiles_Edit.gif");
     CollectiveImage = new Classes.Rendering.GIF(CreateCollectiveImage());
 }
 public EditorTiles(string StageDirectory, string PaletteDataPath = null)
 {
     BaseImage = new Classes.Rendering.GIF(Path.Combine(StageDirectory, "16x16Tiles.gif"), PaletteDataPath);
     CreateDefaultTiles();
 }
 public EditorTiles()
 {
     BaseImage  = new Classes.Rendering.GIF(Path.Combine(Environment.CurrentDirectory, "16x16Tiles_ID.gif"));
     TileConfig = new RSDKv5.Tileconfig();
     CreateDefaultTiles();
 }