/// <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));
}
