ImageAtlas.c File Reference

#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "ImageAtlas.h"
#include "Log.h"

Go to the source code of this file.

Macros
#define	_Class   _ImageAtlas

Functions
Class *	_ImageAtlas (void)
static AtlasImage *	addImage (ImageAtlas *self, Image *image)
static AtlasImage *	addImageWithName (ImageAtlas *self, const char *name, Image *image)
static AtlasImage *	addImageWithResourceName (ImageAtlas *self, const char *name, float pixelDensity)
static int	compareImages (const void *a, const void *b)
	Sorts AtlasImages tallest first, then widest, so that shelf rows waste the least.
static bool	compile (ImageAtlas *self)
static void	dealloc (Object *self)
static AtlasImage *	imageWithName (const ImageAtlas *self, const char *name)
static ImageAtlas *	init (ImageAtlas *self)
static void	initialize (Class *clazz)
static bool	pack (AtlasImage **images, SDL_Rect *rects, size_t count, int size)
	Lays out the sorted images in shelves on a square of the given size, writing their rects to rects rather than to the images, so that a failed attempt leaves them untouched.
static void	renderDeviceWillReset (ImageAtlas *self)
static Texture *	texture (ImageAtlas *self, RenderDevice *device)

Macro Definition Documentation

_Class

#define _Class   _ImageAtlas

Definition at line 27 of file ImageAtlas.c.

Function Documentation

_ImageAtlas()

Class * _ImageAtlas

(

void

)

Definition at line 324 of file ImageAtlas.c.

                         {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "ImageAtlas",
      .superclass = _Object(),
      .instanceSize = sizeof(ImageAtlas),
      .interfaceSize = sizeof(ImageAtlasInterface),
      .initialize = initialize,
    });
  });
 
  return clazz;
}

addImage()

static AtlasImage * addImage ( ImageAtlas *  self, Image *  image  )

static

Definition at line 59 of file ImageAtlas.c.

                                                            {
 
  assert(image);
  assert(!$((Object *) image, isKindOfClass, _AtlasImage()));
 
  AtlasImage *atlasImage = $(alloc(AtlasImage), initWithImage, self, image);
  assert(atlasImage);
 
  $(self->images, addObject, atlasImage);
  release(atlasImage);
 
  return atlasImage;
}

addImageWithName()

static AtlasImage * addImageWithName ( ImageAtlas *  self, const char *  name, Image *  image  )

static

Definition at line 96 of file ImageAtlas.c.

                                                                                      {
 
  assert(name);
 
  AtlasImage *atlasImage = $(self, addImage, image);
 
  $(self->names, setObjectForKeyPath, atlasImage, name);
  self->generation++;
 
  return atlasImage;
}

addImageWithResourceName()

static AtlasImage * addImageWithResourceName ( ImageAtlas *  self, const char *  name, float  pixelDensity  )

static

Definition at line 77 of file ImageAtlas.c.

                                                                                                    {
 
  AtlasImage *atlasImage = NULL;
 
  Image *image = $$(Image, imageWithResourceName, name, pixelDensity);
  if (image) {
    atlasImage = $(self, addImage, image);
    release(image);
  } else {
    MVC_LogError("Image %s not found\n", name);
  }
 
  return atlasImage;
}

compareImages()

static int compareImages ( const void *  a, const void *  b  )

static

Sorts AtlasImages tallest first, then widest, so that shelf rows waste the least.

Definition at line 122 of file ImageAtlas.c.

                                                       {
 
  const SDL_Surface *sa = (*(const AtlasImage **) a)->image.surface;
  const SDL_Surface *sb = (*(const AtlasImage **) b)->image.surface;
 
  if (sb->h != sa->h) {
    return sb->h - sa->h;
  }
 
  return sb->w - sa->w;
}

compile()

static bool compile ( ImageAtlas *  self )

static

Definition at line 170 of file ImageAtlas.c.

                                      {
 
  self->generation++;
 
  const size_t count = self->images->count;
  if (count == 0) {
    return true;
  }
 
  AtlasImage **images = calloc(count, sizeof(AtlasImage *));
  assert(images);
 
  SDL_Rect *rects = calloc(count, sizeof(SDL_Rect));
  assert(rects);
 
  size_t area = 0;
  int size = 1;
 
  for (size_t i = 0; i < count; i++) {
    images[i] = $(self->images, objectAtIndex, i);
 
    const SDL_Surface *surface = images[i]->image.surface;
    area += (size_t) surface->w * (size_t) surface->h;
    size = max(size, max(surface->w, surface->h));
  }
 
  qsort(images, count, sizeof(AtlasImage *), compareImages);
 
  size = max(size, (int) ceil(sqrt((double) area)));
 
  int sheetSize = 1;
  while (sheetSize < size) {
    sheetSize <<= 1;
  }
 
  bool packed = false;
  while (sheetSize <= self->maxSize) {
    if (pack(images, rects, count, sheetSize)) {
      packed = true;
      break;
    }
    sheetSize <<= 1;
  }
 
  if (packed) {
 
    for (size_t i = 0; i < count; i++) {
      images[i]->rect = rects[i];
    }
 
    SDL_Surface *sheet = SDL_CreateSurface(sheetSize, sheetSize, SDL_PIXELFORMAT_RGBA32);
    assert(sheet);
 
    SDL_FillSurfaceRect(sheet, NULL, 0);
 
    for (size_t i = 0; i < count; i++) {
 
      const AtlasImage *image = images[i];
      const SDL_Surface *surface = image->image.surface;
      const size_t pitch = surface->w * SDL_BYTESPERPIXEL(surface->format);
 
      for (int y = 0; y < surface->h; y++) {
        memcpy((Uint8 *) sheet->pixels + (image->rect.y + y) * sheet->pitch + image->rect.x * SDL_BYTESPERPIXEL(sheet->format),
               (const Uint8 *) surface->pixels + y * surface->pitch,
               pitch);
      }
    }
 
    release(self->image);
    self->image = $$(Image, imageWithSurface, sheet);
    assert(self->image);
 
    SDL_DestroySurface(sheet);
 
    self->texture = release(self->texture);
 
  } else {
    MVC_LogError("%zu images (%zu texels) do not fit within %dx%d\n", count, area, self->maxSize, self->maxSize);
  }
 
  free(rects);
  free(images);
 
  return packed;
}

dealloc()

static void dealloc ( Object *  self )

static

See also

Object::dealloc(Object *)

Definition at line 34 of file ImageAtlas.c.

                                  {
 
  ImageAtlas *this = (ImageAtlas *) self;
 
  // An AtlasImage retained elsewhere (by an ImageView, say) outlives this atlas: sever its
  // back-pointer so that it degrades to drawing nothing rather than dereferencing freed memory
  for (size_t i = 0; i < this->images->count; i++) {
    AtlasImage *image = $(this->images, objectAtIndex, i);
    image->atlas = NULL;
  }
 
  release(this->texture);
  release(this->image);
  release(this->images);
  release(this->names);
 
  super(Object, self, dealloc);
}

imageWithName()

static AtlasImage * imageWithName ( const ImageAtlas *  self, const char *  name  )

static

Definition at line 112 of file ImageAtlas.c.

                                                                           {
 
  assert(name);
 
  return $(self->names, objectForKeyPath, name);
}

init()

static ImageAtlas * init ( ImageAtlas *  self )

static

Definition at line 260 of file ImageAtlas.c.

                                          {
 
  self = (ImageAtlas *) super(Object, self, init);
  if (self) {
 
    self->images = $$(Array, array);
    assert(self->images);
 
    self->names = $$(Dictionary, dictionary);
    assert(self->names);
 
    self->maxSize = IMAGE_ATLAS_MAX_SIZE;
  }
 
  return self;
}

initialize()

static void initialize ( Class *  clazz )

static

See also

Class::initialize(Class *)

Definition at line 306 of file ImageAtlas.c.

                                     {
 
  ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
 
  ((ImageAtlasInterface *) clazz->interface)->addImage = addImage;
  ((ImageAtlasInterface *) clazz->interface)->addImageWithName = addImageWithName;
  ((ImageAtlasInterface *) clazz->interface)->addImageWithResourceName = addImageWithResourceName;
  ((ImageAtlasInterface *) clazz->interface)->compile = compile;
  ((ImageAtlasInterface *) clazz->interface)->imageWithName = imageWithName;
  ((ImageAtlasInterface *) clazz->interface)->init = init;
  ((ImageAtlasInterface *) clazz->interface)->renderDeviceWillReset = renderDeviceWillReset;
  ((ImageAtlasInterface *) clazz->interface)->texture = texture;
}

pack()

static bool pack ( AtlasImage **  images, SDL_Rect *  rects, size_t  count, int  size  )

static

Lays out the sorted images in shelves on a square of the given size, writing their rects to rects rather than to the images, so that a failed attempt leaves them untouched.

Returns

true if every image fit, false otherwise.

Definition at line 139 of file ImageAtlas.c.

                                                                               {
 
  int x = 0, y = 0, row = 0;
 
  for (size_t i = 0; i < count; i++) {
 
    const SDL_Surface *surface = images[i]->image.surface;
 
    if (x + surface->w > size) {
      x = 0;
      y += row;
      row = 0;
    }
 
    if (y + surface->h > size) {
      return false;
    }
 
    rects[i] = MakeRect(x, y, surface->w, surface->h);
 
    x += surface->w;
    row = max(row, surface->h);
  }
 
  return true;
}

renderDeviceWillReset()

static void renderDeviceWillReset ( ImageAtlas *  self )

static

Definition at line 281 of file ImageAtlas.c.

                                                    {
  self->texture = release(self->texture);
}

texture()

static Texture * texture ( ImageAtlas *  self, RenderDevice *  device  )

static

Definition at line 289 of file ImageAtlas.c.

                                                                {
 
  assert(device);
 
  if (self->texture == NULL && self->image) {
    self->texture = $(device, createTextureFromSurface, self->image->surface, SDL_GPU_TEXTUREUSAGE_SAMPLER, false);
    assert(self->texture);
  }
 
  return self->texture;
}