BrashMonkeyContentPipelineExtension.SpritePacker.PackSprites C# (CSharp) Method

        public static BitmapContent PackSprites(IList<BitmapContent> p_sourceSprites, ICollection<Rectangle> p_outputSprites, ContentProcessorContext p_context)
        {
            if (p_sourceSprites.Count == 0) {
                throw new InvalidContentException("There are no sprites to arrange");
            }

            // Build up a list of all the sprites needing to be arranged.
            List<ArrangedSprite> l_sprites = new List<ArrangedSprite>();

            for (int i = 0; i < p_sourceSprites.Count; i++) {
                ArrangedSprite l_sprite = new ArrangedSprite();

                // Include a single pixel padding around each sprite, to avoid
                // filtering problems if the sprite is scaled or rotated.
                l_sprite.Width = p_sourceSprites[i].Width + 2;
                l_sprite.Height = p_sourceSprites[i].Height + 2;

                l_sprite.Index = i;

                l_sprites.Add(l_sprite);
            }

            // Sort so the largest sprites get arranged first.
            l_sprites.Sort(CompareSpriteSizes);

            // Work out how big the output bitmap should be.
            int l_outputWidth = GuessOutputWidth(l_sprites);
            int l_outputHeight = 0;
            int l_totalSpriteSize = 0;

            // Choose positions for each sprite, one at a time.
            for (int i = 0; i < l_sprites.Count; i++) {
                PositionSprite(l_sprites, i, l_outputWidth);

                l_outputHeight = Math.Max(l_outputHeight, l_sprites[i].Y + l_sprites[i].Height);

                l_totalSpriteSize += l_sprites[i].Width * l_sprites[i].Height;
            }

            // Sort the sprites back into index order.
            l_sprites.Sort(CompareSpriteIndices);

            p_context.Logger.LogImportantMessage(
                "Packed {0} sprites into a {1}x{2} sheet, {3}% efficiency",
                l_sprites.Count, l_outputWidth, l_outputHeight,
                l_totalSpriteSize * 100 / l_outputWidth / l_outputHeight);

            return CopySpritesToOutput(l_sprites, p_sourceSprites, p_outputSprites, l_outputWidth, l_outputHeight);
        }

        /// <summary>
        /// Convert sprites into sprite sheet object
        /// (Basically from XNA SpriteSheetSample project)
        /// </summary>
        public SpriterShadowData BuildSpriteSheet(XDocument p_input, ContentManager content, GraphicsDevice graphics)
        {
            SpriterShadowData l_return = new SpriterShadowData();

            l_return.Rectangles = new List <List <Rectangle> >();
            l_return.Textures   = new List <Texture2D>();
            l_return.XML        = p_input;

            String l_fileName = (new List <XElement>(l_return.XML.Root.Descendants("File")))[0].Attribute("path").Value;

            //List<String> l_failedFiles = new List<String>();

            foreach (XElement l_folder in l_return.XML.Root.Descendants("folder"))
            {
                List <Texture2D> l_sourceSprites = new List <Texture2D>();


                List <Rectangle> l_outputRectangles = new List <Rectangle>();
                List <int>       l_removedTextures  = new List <int>();

                foreach (XElement l_file in l_folder.Descendants("file"))
                {
                    string textureFileName = (l_fileName + @"\" + l_file.Attribute("name").Value);


                    if (!File.Exists(textureFileName))
                    {
                        int l_fileId;
                        GetAttributeInt32(l_file, "id", out l_fileId);
                        l_removedTextures.Add(l_fileId);

                        //l_failedFiles.Add(l_textureReference.Filename);
                    }
                    else
                    {
                        Texture2D texture =
                            content.Load <Texture2D>(textureFileName.Substring(textureFileName.IndexOf('\\') + 1));
                        l_sourceSprites.Add(texture);
                    }
                }

                // Pack all the sprites onto a single texture.
                Texture2D l_packedSprites = SpritePacker.PackSprites(graphics, l_sourceSprites, l_outputRectangles);


                // Add dummy rectangles for removed textures
                foreach (var l_fileId in l_removedTextures)
                {
                    //if (l_fileId <= l_outputRectangles.Count) {
                    l_outputRectangles.Insert(l_fileId, Rectangle.Empty);
                    //} else {
//                        l_outputRectangles.Add(Rectangle.Empty);
                    //}
                }

                //  Add the data to the return type
                l_return.Rectangles.Add(l_outputRectangles);
                l_return.Textures.Add(l_packedSprites);
            }

            //if (l_failedFiles.Count > 0) {
            //    String l_error = "";
            //    foreach (String l_fail in l_failedFiles) {
            //        l_error += l_fail + ", ";
            //    }

            //    throw new Exception("Files are missing", new Exception(l_error));
            //}

            return(l_return);
        }