/// <summary> /// Comparison function for sorting sprites by size. /// </summary> static int CompareSpriteSizes(ArrangedSprite a, ArrangedSprite b) { var aSize = a.Height * 1024 + a.Width; var bSize = b.Height * 1024 + b.Width; return(bSize.CompareTo(aSize)); }
/// <summary> /// Comparison function for sorting sprites by size. /// </summary> static int CompareSpriteSizes(ArrangedSprite p_a, ArrangedSprite p_b) { int l_aSize = p_a.Height * 1024 + p_a.Width; int l_bSize = p_b.Height * 1024 + p_b.Width; return(l_bSize.CompareTo(l_aSize)); }
/// <summary> /// Packs a list of sprites into a single big texture, /// recording where each one was stored. /// </summary> public static PixelBitmapContent <Color> PackSprites(IList <BitmapContent> sourceSprites, ICollection <Rectangle> outputSprites, bool isCompressed, ContentProcessorContext context) { if (sourceSprites.Count == 0) { throw new InvalidContentException("There are no sprites to pack"); } // Build up a list of all the sprites needing to be arranged. var sprites = new List <ArrangedSprite>(); for (var i = 0; i < sourceSprites.Count; i++) { var sprite = new ArrangedSprite(); // Include a single pixel padding around each sprite, to avoid filtering problems if the sprite is scaled or rotated. sprite.Width = sourceSprites[i].Width + 2; sprite.Height = sourceSprites[i].Height + 2; sprite.Index = i; sprites.Add(sprite); } // Sort so the largest sprites get arranged first. sprites.Sort(CompareSpriteSizes); // Work out how big the output bitmap should be. var outputWidth = GuessOutputWidth(sprites); var outputHeight = 0; var totalSpriteSize = 0; // Choose positions for each sprite, one at a time. for (var i = 0; i < sprites.Count; i++) { PositionSprite(sprites, i, outputWidth); outputHeight = Math.Max(outputHeight, sprites[i].Y + sprites[i].Height); totalSpriteSize += sprites[i].Width * sprites[i].Height; } // DXT compression requires texture sizes to be a multiple of 4 if (isCompressed) { outputHeight = (outputHeight + 3) & ~3; } // sort the sprites back into index order. sprites.Sort(CompareSpriteIndices); context.Logger.LogImportantMessage( "\nPacked {0} sprites into a {1}x{2} sheet, {3}% efficiency", sprites.Count, outputWidth, outputHeight, totalSpriteSize * 100 / outputWidth / outputHeight); return(CopySpritesToOutput(sprites, sourceSprites, outputSprites, outputWidth, outputHeight)); }
/// <summary> /// Packs a list of sprites into a single big texture, /// recording where each one was stored. /// </summary> public static BitmapContent PackSprites(IList <BitmapContent> aSourceSprites, ICollection <Rectangle> aOutputSprites, ContentProcessorContext aContext) { if (aSourceSprites.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> sprites = new List <ArrangedSprite>(); for (int i = 0; i < aSourceSprites.Count; i++) { ArrangedSprite sprite = new ArrangedSprite(); // Include a single pixel padding around each sprite, to avoid // filtering problems if the sprite is scaled or rotated. sprite.Width = aSourceSprites[i].Width + 2; sprite.Height = aSourceSprites[i].Height + 2; sprite.Index = i; sprites.Add(sprite); } // Sort so the largest sprites get arranged first. sprites.Sort(CompareSpriteSizes); // Work out how big the output bitmap should be. int outputWidth = GuessOutputWidth(sprites); int outputHeight = 0; int totalSpriteSize = 0; // Choose positions for each sprite, one at a time. for (int i = 0; i < sprites.Count; i++) { PositionSprite(sprites, i, outputWidth); outputHeight = Math.Max(outputHeight, sprites[i].Y + sprites[i].Height); totalSpriteSize += sprites[i].Width * sprites[i].Height; } // Sort the sprites back into index order. sprites.Sort(CompareSpriteIndices); aContext.Logger.LogImportantMessage( "Packed {0} sprites into a {1}x{2} sheet, {3}% efficiency", sprites.Count, outputWidth, outputHeight, totalSpriteSize * 100 / outputWidth / outputHeight); return(CopySpritesToOutput(sprites, aSourceSprites, aOutputSprites, outputWidth, outputHeight)); }
/// <summary> /// Packs a list of sprites into a single big texture, /// recording where each one was stored. /// </summary> public static BitmapContent PackSprites(IList<BitmapContent> sourceSprites, ICollection<Rectangle> outputSprites, ContentProcessorContext context) { if (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> sprites = new List<ArrangedSprite>(); for (int i = 0; i < sourceSprites.Count; i++) { ArrangedSprite sprite = new ArrangedSprite(); // Include a single pixel padding around each sprite, to avoid // filtering problems if the sprite is scaled or rotated. sprite.Width = sourceSprites[i].Width + 2; sprite.Height = sourceSprites[i].Height + 2; sprite.Index = i; sprites.Add(sprite); } // Sort so the largest sprites get arranged first. sprites.Sort(CompareSpriteSizes); // Work out how big the output bitmap should be. int outputWidth = GuessOutputWidth(sprites); int outputHeight = 0; int totalSpriteSize = 0; // Choose positions for each sprite, one at a time. for (int i = 0; i < sprites.Count; i++) { PositionSprite(sprites, i, outputWidth); outputHeight = Math.Max(outputHeight, sprites[i].Y + sprites[i].Height); totalSpriteSize += sprites[i].Width * sprites[i].Height; } // Sort the sprites back into index order. sprites.Sort(CompareSpriteIndices); context.Logger.LogImportantMessage( "Packed {0} sprites into a {1}x{2} sheet, {3}% efficiency", sprites.Count, outputWidth, outputHeight, totalSpriteSize * 100 / outputWidth / outputHeight); return CopySpritesToOutput(sprites, sourceSprites, outputSprites, outputWidth, outputHeight); }
/// <summary> /// Packs a list of sprites into a single big texture, /// recording where each one was stored. /// </summary> public static PixelBitmapContent<Color> packSprites( IList<BitmapContent> sourceSprites, ICollection<Rectangle> outputSprites, bool isCompressed, ContentProcessorContext context ) { if( sourceSprites.Count == 0 ) throw new InvalidContentException( "There are no sprites to pack" ); // Build up a list of all the sprites needing to be arranged. var sprites = new List<ArrangedSprite>(); for( var i = 0; i < sourceSprites.Count; i++ ) { var sprite = new ArrangedSprite(); // Include a single pixel padding around each sprite, to avoid filtering problems if the sprite is scaled or rotated. sprite.width = sourceSprites[i].Width + 2; sprite.height = sourceSprites[i].Height + 2; sprite.index = i; sprites.Add( sprite ); } // Sort so the largest sprites get arranged first. sprites.Sort( compareSpriteSizes ); // Work out how big the output bitmap should be. var outputWidth = guessOutputWidth( sprites ); var outputHeight = 0; var totalSpriteSize = 0; // Choose positions for each sprite, one at a time. for( var i = 0; i < sprites.Count; i++ ) { positionSprite( sprites, i, outputWidth ); outputHeight = Math.Max( outputHeight, sprites[i].y + sprites[i].height ); totalSpriteSize += sprites[i].width * sprites[i].height; } // DXT compression requires texture sizes to be a multiple of 4 if( isCompressed ) outputHeight = (outputHeight + 3) & ~3; // sort the sprites back into index order. sprites.Sort( compareSpriteIndices ); context.Logger.LogImportantMessage( "\nPacked {0} sprites into a {1}x{2} sheet, {3}% efficiency", sprites.Count, outputWidth, outputHeight, totalSpriteSize * 100 / outputWidth / outputHeight ); return copySpritesToOutput( sprites, sourceSprites, outputSprites, outputWidth, outputHeight ); }
/// <summary> /// Packs a list of sprites into a single big texture, /// recording where each one was stored. /// </summary> public static Texture2D PackSprites(GraphicsDevice graphics, IList <Texture2D> sourceSprites, ICollection <Rectangle> outputSprites) { if (sourceSprites.Count == 0) { throw new InvalidDataException("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 < 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 = sourceSprites[i].Width + 2; l_sprite.Height = 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); Console.WriteLine("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(graphics, l_sprites, sourceSprites, outputSprites, l_outputWidth, l_outputHeight)); }
/// <summary> /// Packs a list of sprites into a single big texture, /// recording where each one was stored. /// </summary> public static Image PackSprites(IList <Sprite> sourceSprites, ICollection <Rectangle> outputSprites) { // Build up a list of all the sprites needing to be arranged. List <ArrangedSprite> sprites = new List <ArrangedSprite>(); for (int i = 0; i < sourceSprites.Count; i++) { ArrangedSprite sprite = new ArrangedSprite(); // Include a single pixel padding around each sprite, to avoid // filtering problems if the sprite is scaled or rotated. sprite.Width = sourceSprites[i].Image.Width + 2; sprite.Height = sourceSprites[i].Image.Height + 2; sprite.Index = i; sprites.Add(sprite); } // Sort so the largest sprites get arranged first. sprites.Sort(CompareSpriteSizes); // Work out how big the output bitmap should be. int outputWidth = GuessOutputWidth(sprites); int outputHeight = 0; int totalSpriteSize = 0; // Choose positions for each sprite, one at a time. for (int i = 0; i < sprites.Count; i++) { PositionSprite(sprites, i, outputWidth); outputHeight = Math.Max(outputHeight, sprites[i].Y + sprites[i].Height); totalSpriteSize += sprites[i].Width * sprites[i].Height; } // Sort the sprites back into index order. sprites.Sort(CompareSpriteIndices); return(CopySpritesToOutput(sprites, sourceSprites, outputSprites, outputWidth, outputHeight)); }
/// <summary> /// Comparison function for sorting sprites by size. /// </summary> static int CompareSpriteSizes(ArrangedSprite a, ArrangedSprite b) { int aSize = a.Height * 1024 + a.Width; int bSize = b.Height * 1024 + b.Width; return bSize.CompareTo(aSize); }
/// <summary> /// Comparison function for sorting sprites by their original indices. /// </summary> static int CompareSpriteIndices(ArrangedSprite a, ArrangedSprite b) { return a.Index.CompareTo(b.Index); }
/// <summary> /// Comparison function for sorting sprites by size. /// </summary> static int compareSpriteSizes( ArrangedSprite a, ArrangedSprite b ) { var aSize = a.height * 1024 + a.width; var bSize = b.height * 1024 + b.width; return bSize.CompareTo( aSize ); }
/// <summary> /// Comparison function for sorting sprites by their original indices. /// </summary> static int CompareSpriteIndices(ArrangedSprite a, ArrangedSprite b) { return(a.Index.CompareTo(b.Index)); }
/// <summary> /// Comparison function for sorting sprites by size. /// </summary> static int CompareSpriteSizes(ArrangedSprite p_a, ArrangedSprite p_b) { int l_aSize = p_a.Height * 1024 + p_a.Width; int l_bSize = p_b.Height * 1024 + p_b.Width; return l_bSize.CompareTo(l_aSize); }
/// <summary> /// Comparison function for sorting sprites by their original indices. /// </summary> static int CompareSpriteIndices(ArrangedSprite p_a, ArrangedSprite p_b) { return p_a.Index.CompareTo(p_b.Index); }
/// <summary> /// Comparison function for sorting sprites by their original indices. /// </summary> static int CompareSpriteIndices(ArrangedSprite p_a, ArrangedSprite p_b) { return(p_a.Index.CompareTo(p_b.Index)); }
/// <summary> /// Comparison function for sorting sprites by their original indices. /// </summary> static int CompareSpriteIndices(ArrangedSprite aA, ArrangedSprite aB) { return(aA.Index.CompareTo(aB.Index)); }