AtlasManager Class Reference

#include <atlasmanager.h>

Public Member Functions
	AtlasManager ()

Static Public Member Functions
static AtlasResource *	loadTextureAtlas (const std::string &name, const StringVect &files)
static AtlasResource *	loadEmptyAtlas (const std::string &name, const StringVect &files)
static void	injectToResources (const AtlasResource *const resource)
static void	moveToDeleted (AtlasResource *const resource)

Static Private Member Functions
static void	loadImages (const StringVect &files, std::vector< Image * > &images)
static void	loadEmptyImages (const StringVect &files, std::vector< Image * > &images)
static void	emptySort (const std::string &name, std::vector< TextureAtlas * > &atlases, const std::vector< Image * > &images)
static void	simpleSort (const std::string &name, std::vector< TextureAtlas * > &atlases, const std::vector< Image * > &images, int size)
static void	createSDLAtlas (TextureAtlas *const atlas)
static void	convertAtlas (TextureAtlas *const atlas)
static void	convertEmptyAtlas (TextureAtlas *const atlas)

Detailed Description

Definition at line 36 of file atlasmanager.h.

Constructor & Destructor Documentation

AtlasManager()

AtlasManager::AtlasManager

(

)

Definition at line 57 of file atlasmanager.cpp.

{
}

Member Function Documentation

convertAtlas()

void AtlasManager::convertAtlas ( TextureAtlas *const  atlas )

staticprivate

Definition at line 450 of file atlasmanager.cpp.

{
 // no check for null pointer in atlas because it was in caller
 // convert surface to OpemGL image
 Image *const oldImage = atlas->atlasImage;
 
 if (oldImage->mSDLSurface != nullptr)
 {
 atlas->atlasImage = imageHelper->loadSurface(
 atlas->atlasImage->mSDLSurface);
 oldImage->decRef();
 }
 
 Image *const image = atlas->atlasImage;
 if (image == nullptr)
 return;
 
 image->mIdPath = atlas->name;
#ifdef DEBUG_IMAGES
 logger->log("set name %p, %s", static_cast<void*>(image),
 image->mIdPath.c_str());
#endif // DEBUG_IMAGES
 
 image->incRef();
 
 FOR_EACH (STD_VECTOR<AtlasItem*>::iterator, it, atlas->items)
 {
 AtlasItem *const item = *it;
 // delete SDL Image
 delete item->image;
 // store OpenGL image
 item->image = image->getSubImage(item->x, item->y,
 item->width, item->height);
 Image *const image2 = item->image;
 if (image2 != nullptr)
 {
 image2->mIdPath = item->name;
#ifdef DEBUG_IMAGES
 logger->log("set name %p, %s", static_cast<void*>(image2),
 image2->mIdPath.c_str());
#endif // DEBUG_IMAGES
 
 image2->incRef();
 }
 }
}

References TextureAtlas::atlasImage, FOR_EACH, AtlasItem::height, AtlasItem::image, imageHelper, TextureAtlas::items, ImageHelper::loadSurface(), Logger::log(), logger, AtlasItem::name, TextureAtlas::name, AtlasItem::width, AtlasItem::x, and AtlasItem::y.

Referenced by loadTextureAtlas().

convertEmptyAtlas()

void AtlasManager::convertEmptyAtlas ( TextureAtlas *const  atlas )

staticprivate

Definition at line 403 of file atlasmanager.cpp.

{
 // no check for null pointer in atlas because it was in caller
 // convert surface to OpemGL image
 Image *const oldImage = atlas->atlasImage;
 
 if (oldImage->mSDLSurface != nullptr)
 {
 atlas->atlasImage = imageHelper->loadSurface(
 atlas->atlasImage->mSDLSurface);
 oldImage->decRef();
 }
 
 Image *const image = atlas->atlasImage;
 if (image == nullptr)
 return;
 
 image->mIdPath = atlas->name;
#ifdef DEBUG_IMAGES
 logger->log("set name %p, %s", static_cast<void*>(image),
 image->mIdPath.c_str());
#endif // DEBUG_IMAGES
 
 image->incRef();
 
 FOR_EACH (STD_VECTOR<AtlasItem*>::iterator, it, atlas->items)
 {
 AtlasItem *const item = *it;
 // delete SDL Image
 delete item->image;
 // store OpenGL image
 item->image = image->getSubImage(item->x, item->y,
 item->width, item->height);
 Image *const image2 = item->image;
 if (image2 != nullptr)
 {
 image2->mIdPath = item->name;
#ifdef DEBUG_IMAGES
 logger->log("set empty name %p, %s", static_cast<void*>(image2),
 image2->mIdPath.c_str());
#endif // DEBUG_IMAGES
 
 image2->incRef();
 }
 }
}

References TextureAtlas::atlasImage, FOR_EACH, AtlasItem::height, AtlasItem::image, imageHelper, TextureAtlas::items, ImageHelper::loadSurface(), Logger::log(), logger, AtlasItem::name, TextureAtlas::name, AtlasItem::width, AtlasItem::x, and AtlasItem::y.

Referenced by loadEmptyAtlas().

createSDLAtlas()

void AtlasManager::createSDLAtlas ( TextureAtlas *const  atlas )

staticprivate

< Surface is in system memory

Definition at line 314 of file atlasmanager.cpp.

{
 BLOCK_START("AtlasManager::createSDLAtlas")
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
 const uint32_t rmask = 0xff000000U;
 const uint32_t gmask = 0x00ff0000U;
 const uint32_t bmask = 0x0000ff00U;
 const uint32_t amask = 0x000000ffU;
#else // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
 const uint32_t rmask = 0x000000ffU;
 const uint32_t gmask = 0x0000ff00U;
 const uint32_t bmask = 0x00ff0000U;
 const uint32_t amask = 0xff000000U;
#endif // SDL_BYTEORDER == SDL_BIG_ENDIAN
 
 // do not create atlas based on only one image
 if (atlas->items.size() == 1)
 {
 logger->log("Skip atlas creation because only one image in atlas.");
 BLOCK_END("AtlasManager::createSDLAtlas")
 return;
 }
 
 // using only power of two sizes.
 atlas->width = powerOfTwo(atlas->width);
 atlas->height = powerOfTwo(atlas->height);
 
 const int width = atlas->width;
 const int height = atlas->height;
 BLOCK_START("AtlasManager::createSDLAtlas create surface")
 // temp SDL surface for atlas
 SDL_Surface *const surface = MSDL_CreateRGBSurface(SDL_SWSURFACE,
 width, height, 32U, rmask, gmask, bmask, amask);
 if (surface == nullptr)
 {
 reportAlways("Error creating surface for atlas. Size: %dx%d",
 width,
 height)
 BLOCK_END("AtlasManager::createSDLAtlas")
 return;
 }
 BLOCK_END("AtlasManager::createSDLAtlas create surface")
 
#ifdef OPENGLERRORS
 logger->log("OpenGL debug: creating atlase %dx%d", width, height);
#endif // OPENGLERRORS
 
 Image *image = imageHelper->loadSurface(surface);
 // free SDL atlas surface
 MSDL_FreeSurface(surface);
 if (image == nullptr)
 {
 reportAlways("Error converting surface to texture. Size: %dx%d",
 width,
 height)
 return;
 }
 
 // drawing SDL images to surface
 FOR_EACH (STD_VECTOR<AtlasItem*>::iterator, it, atlas->items)
 {
 AtlasItem *const item = *it;
 imageHelper->copySurfaceToImage(image, item->x, item->y,
 item->image->mSDLSurface);
#ifdef OPENGLERRORS
 logger->log("OpenGL debug: put atlas image %s (size %dx%d),"
 " into %d,%d to %d,%d",
 item->name.c_str(),
 item->image->mSDLSurface->w,
 item->image->mSDLSurface->h,
 item->x,
 item->y,
 item->x + item->image->mSDLSurface->w - 1,
 item->y + item->image->mSDLSurface->h - 1);
 if (item->x >= width)
 logger->log("OpenGL error: start x position outside of atlas");
 if (item->y >= height)
 logger->log("OpenGL error: start y position outside of atlas");
 if (item->x + item->image->mSDLSurface->w - 1 >= width)
 logger->log("OpenGL error: end x position outside of atlas");
 if (item->y + item->image->mSDLSurface->h - 1 >= height)
 logger->log("OpenGL error: end y position outside of atlas");
#endif // OPENGLERRORS
 }
 atlas->atlasImage = image;
 BLOCK_END("AtlasManager::createSDLAtlas")
}

References TextureAtlas::atlasImage, BLOCK_END, BLOCK_START, ImageHelper::copySurfaceToImage(), FOR_EACH, TextureAtlas::height, AtlasItem::image, imageHelper, TextureAtlas::items, ImageHelper::loadSurface(), Logger::log(), logger, MSDL_CreateRGBSurface, MSDL_FreeSurface, AtlasItem::name, powerOfTwo(), reportAlways, TextureAtlas::width, AtlasItem::x, and AtlasItem::y.

Referenced by loadTextureAtlas().

emptySort()

void AtlasManager::emptySort ( const std::string &  name, std::vector< TextureAtlas * > &  atlases, const std::vector< Image * > &  images  )

staticprivate

Definition at line 276 of file atlasmanager.cpp.

{
 BLOCK_START("AtlasManager::simpleSort")
 TextureAtlas *atlas = new TextureAtlas;
 STD_VECTOR<Image*>::const_iterator it = images.begin();
 const STD_VECTOR<Image*>::const_iterator it_end = images.end();
 for (it = images.begin(); it != it_end; ++ it)
 {
 const Image *const img = *it;
 if (img != nullptr)
 {
 atlas->name = std::string("atlas_").append(name).append(
 "_").append(img->mIdPath);
 break;
 }
 }
 
 for (it = images.begin(); it != it_end; ++ it)
 {
 Image *const img = *it;
 if (img != nullptr)
 {
 AtlasItem *const item = new AtlasItem(img);
 item->name = img->mIdPath;
 item->x = 0;
 item->y = 0;
 atlas->items.push_back(item);
 }
 }
 if (!atlas->items.empty())
 atlases.push_back(atlas);
 else
 delete atlas;
 BLOCK_END("AtlasManager::simpleSort")
}

References BLOCK_END, BLOCK_START, TextureAtlas::items, AtlasItem::name, TextureAtlas::name, AtlasItem::x, and AtlasItem::y.

Referenced by loadEmptyAtlas().

injectToResources()

void AtlasManager::injectToResources ( const AtlasResource *const  resource )

static

Definition at line 497 of file atlasmanager.cpp.

{
 if (resource == nullptr)
 return;
 FOR_EACH (STD_VECTOR<TextureAtlas*>::const_iterator,
 it, resource->atlases)
 {
 // add each atlas image to resources
 TextureAtlas *const atlas = *it;
 if (atlas != nullptr)
 {
 Image *const image = atlas->atlasImage;
 if (image != nullptr)
 ResourceManager::addResource(atlas->name, image);
 FOR_EACH (STD_VECTOR<AtlasItem*>::iterator, it2, atlas->items)
 {
 AtlasItem *const item = *it2;
 if (item == nullptr)
 continue;
 // add each atlas sub image to resources
 ResourceManager::addResource(item->name, item->image);
 }
 }
 }
}

References ResourceManager::addResource(), AtlasResource::atlases, TextureAtlas::atlasImage, FOR_EACH, AtlasItem::image, TextureAtlas::items, AtlasItem::name, and TextureAtlas::name.

Referenced by AtlasResource::incRef().

loadEmptyAtlas()

AtlasResource * AtlasManager::loadEmptyAtlas ( const std::string &  name, const StringVect &  files  )

static

Definition at line 97 of file atlasmanager.cpp.

{
 STD_VECTOR<TextureAtlas*> atlases;
 STD_VECTOR<Image*> images;
 AtlasResource *resource = new AtlasResource;
 
 loadEmptyImages(files, images);
 
 // sorting images on atlases.
 emptySort(name, atlases, images);
 
 FOR_EACH (STD_VECTOR<TextureAtlas*>::iterator, it, atlases)
 {
 TextureAtlas *const atlas = *it;
 if (atlas == nullptr)
 continue;
 
 atlas->atlasImage = new Image(0,
 1024, 1024,
 1024, 1024);
 // convert SDL images to OpenGL
 convertEmptyAtlas(atlas);
 
 resource->atlases.push_back(atlas);
 }
 
 BLOCK_END("AtlasManager::loadTextureAtlas")
 return resource;
}

References AtlasResource::atlases, TextureAtlas::atlasImage, BLOCK_END, convertEmptyAtlas(), emptySort(), FOR_EACH, ParticleType::Image, and loadEmptyImages().

Referenced by EmptyAtlasLoader::load().

loadEmptyImages()

void AtlasManager::loadEmptyImages ( const StringVect &  files, std::vector< Image * > &  images  )

staticprivate

Definition at line 178 of file atlasmanager.cpp.

{
 BLOCK_START("AtlasManager::loadEmptyImages")
 
 FOR_EACH (StringVectCIter, it, files)
 {
 const std::string str = *it;
 // check is image with same name already in cache
 // and if yes, move it to deleted set
 Resource *const res = ResourceManager::getTempResource(str);
 if (res != nullptr)
 {
 // increase counter because in moveToDeleted it will be decreased.
 res->incRef();
 ResourceManager::moveToDeleted(res);
 }
 
 Image *const image = new Image(0,
 2048, 2048,
 2048, 2048);
 image->mIdPath = str;
 images.push_back(image);
 }
 BLOCK_END("AtlasManager::loadEmptyImages")
}

References BLOCK_END, BLOCK_START, FOR_EACH, ResourceManager::getTempResource(), ParticleType::Image, Resource::incRef(), and ResourceManager::moveToDeleted().

Referenced by loadEmptyAtlas().

loadImages()

void AtlasManager::loadImages ( const StringVect &  files, std::vector< Image * > &  images  )

staticprivate

Definition at line 128 of file atlasmanager.cpp.

{
 BLOCK_START("AtlasManager::loadImages")
 
 FOR_EACH (StringVectCIter, it, files)
 {
 const std::string str = *it;
 // check is image with same name already in cache
 // and if yes, move it to deleted set
 Resource *const res = ResourceManager::getTempResource(str);
 if (res != nullptr)
 {
 // increase counter because in moveToDeleted it will be decreased.
 res->incRef();
 ResourceManager::moveToDeleted(res);
 }
 
 std::string path = str;
 const size_t p = path.find('|');
 Dye *d = nullptr;
 if (p != std::string::npos)
 {
 d = new Dye(path.substr(p + 1));
 path = path.substr(0, p);
 }
 
 SDL_RWops *const rw = VirtFs::rwopsOpenRead(path);
 if (rw != nullptr)
 {
 Image *const image = d != nullptr ?
 surfaceImageHelper->load(rw, *d)
 : surfaceImageHelper->load(rw);
 
 if (image != nullptr)
 {
 image->mIdPath = str;
#ifdef DEBUG_IMAGES
 logger->log("set name %p, %s", static_cast<void*>(image),
 image->mIdPath.c_str());
#endif // DEBUG_IMAGES
 
 images.push_back(image);
 }
 }
 delete d;
 }
 BLOCK_END("AtlasManager::loadImages")
}

References BLOCK_END, BLOCK_START, FOR_EACH, ResourceManager::getTempResource(), Resource::incRef(), ImageHelper::load(), Logger::log(), logger, ResourceManager::moveToDeleted(), VirtFs::rwopsOpenRead(), and surfaceImageHelper.

Referenced by loadTextureAtlas().

loadTextureAtlas()

AtlasResource * AtlasManager::loadTextureAtlas ( const std::string &  name, const StringVect &  files  )

static

Definition at line 61 of file atlasmanager.cpp.

{
 BLOCK_START("AtlasManager::loadTextureAtlas")
 STD_VECTOR<TextureAtlas*> atlases;
 STD_VECTOR<Image*> images;
 AtlasResource *resource = new AtlasResource;
 
 loadImages(files, images);
 int maxSize = OpenGLImageHelper::getTextureSize();
#if !defined(ANDROID) && !defined(__APPLE__)
 int sz = settings.textureSize;
 if (maxSize > sz)
 maxSize = sz;
#endif // !defined(ANDROID) && !defined(__APPLE__)
 
 // sorting images on atlases.
 simpleSort(name, atlases, images, maxSize);
 
 FOR_EACH (STD_VECTOR<TextureAtlas*>::iterator, it, atlases)
 {
 TextureAtlas *const atlas = *it;
 if (atlas == nullptr)
 continue;
 
 createSDLAtlas(atlas);
 if (atlas->atlasImage == nullptr)
 continue;
 convertAtlas(atlas);
 resource->atlases.push_back(atlas);
 }
 
 BLOCK_END("AtlasManager::loadTextureAtlas")
 return resource;
}

References AtlasResource::atlases, TextureAtlas::atlasImage, BLOCK_END, BLOCK_START, convertAtlas(), createSDLAtlas(), FOR_EACH, OpenGLImageHelper::getTextureSize(), loadImages(), settings, simpleSort(), and Settings::textureSize.

Referenced by AtlasLoader::load().

moveToDeleted()

void AtlasManager::moveToDeleted ( AtlasResource *const  resource )

static

Definition at line 523 of file atlasmanager.cpp.

{
 if (resource == nullptr)
 return;
 FOR_EACH (STD_VECTOR<TextureAtlas*>::iterator, it, resource->atlases)
 {
 // move each atlas image to deleted
 TextureAtlas *const atlas = *it;
 if (atlas != nullptr)
 {
 Image *const image = atlas->atlasImage;
 if (image != nullptr)
 {
 // move each atlas image to deleted
 ResourceManager::moveToDeleted(image);
 }
 FOR_EACH (STD_VECTOR<AtlasItem*>::iterator, it2, atlas->items)
 {
 AtlasItem *const item = *it2;
 if (item != nullptr)
 {
 Image *const image2 = item->image;
 if (image2 != nullptr)
 {
 // move each atlas sub image to deleted
 ResourceManager::moveToDeleted(image2);
 }
 }
 }
 }
 }
}

References AtlasResource::atlases, TextureAtlas::atlasImage, FOR_EACH, AtlasItem::image, TextureAtlas::items, and ResourceManager::moveToDeleted().

Referenced by AtlasResource::decRef().

simpleSort()

void AtlasManager::simpleSort ( const std::string &  name, std::vector< TextureAtlas * > &  atlases, const std::vector< Image * > &  images, int  size  )

staticprivate

Definition at line 205 of file atlasmanager.cpp.

{
 BLOCK_START("AtlasManager::simpleSort")
 int x = 0;
 int y = 0;
 int tempHeight = 0;
 TextureAtlas *atlas = new TextureAtlas;
 STD_VECTOR<Image*>::const_iterator it = images.begin();
 const STD_VECTOR<Image*>::const_iterator it_end = images.end();
 for (it = images.begin(); it != it_end; ++ it)
 {
 const Image *const img = *it;
 if (img != nullptr)
 {
 atlas->name = std::string("atlas_").append(name).append(
 "_").append(img->mIdPath);
 break;
 }
 }
 
 for (it = images.begin(); it != it_end; ++ it)
 {
 Image *const img = *it;
 if (img != nullptr)
 {
 AtlasItem *const item = new AtlasItem(img);
 item->name = img->mIdPath;
 // start next line
 if (x + img->mBounds.w > size)
 {
 x = 0;
 y += tempHeight;
 tempHeight = 0;
 }
 
 // can't put image with this height
 if (y + img->mBounds.h > size)
 {
 x = 0;
 y = 0;
 atlases.push_back(atlas);
 atlas = new TextureAtlas;
 atlas->name = std::string("atlas_").append(name).append(
 "_").append(img->mIdPath);
 }
 
 if (img->mBounds.h > tempHeight)
 tempHeight = img->mBounds.h;
 
 item->x = x;
 item->y = y;
 atlas->items.push_back(item);
 
 // continue put textures in line
 x += img->mBounds.w;
 if (x > atlas->width)
 atlas->width = x;
 if (y + img->mBounds.h > atlas->height)
 atlas->height = y + img->mBounds.h;
 }
 }
 if (!atlas->items.empty())
 atlases.push_back(atlas);
 else
 delete atlas;
 BLOCK_END("AtlasManager::simpleSort")
}

References BLOCK_END, BLOCK_START, TextureAtlas::height, TextureAtlas::items, AtlasItem::name, TextureAtlas::name, EmoteDB::size(), TextureAtlas::width, x, AtlasItem::x, y, and AtlasItem::y.

Referenced by loadTextureAtlas().

---

The documentation for this class was generated from the following files:

• src/resources/atlas/atlasmanager.h (986a3bf)
• src/resources/atlas/atlasmanager.cpp (986a3bf)