void PreviewToggleCommand::clean() {
// Release all previewed images
if (m_sl) {
int i, fidsCount = m_fids.size();
for (i = 0; i < fidsCount; ++i) {
const TFrameId &fid = m_fids[i];
int status = m_sl->getFrameStatus(fid);
if (status & TXshSimpleLevel::CleanupPreview) {
// Preview images are not just invalidated, but *unbound* from the IM.
// This is currently done hard here - should be skipped to m_sl,
// though...
ImageManager *im = ImageManager::instance();
im->unbind(m_sl->getImageId(fid, TXshSimpleLevel::CleanupPreview));
IconGenerator::instance()->remove(m_sl.getPointer(), fid);
m_sl->setFrameStatus(fid, status & ~TXshSimpleLevel::CleanupPreview);
}
}
}
m_sl = TXshSimpleLevelP();
m_fids.clear();
}
/**
* Se actualizan las imagenes nuevas y las viejas.
*/
void Console::UpdatesImage()
{
ImageManager* iManager = ImageManager::GetInstance();
pListUpdate listUpdate= iManager->UpdateImages();
tVecStr* removeList= listUpdate.first;
tVecStr* addList= listUpdate.second;
if (removeList->size()!=0)
{
cout<< MSG_DELETED_DIRECTORIES;
}
for(unsigned int i=0;i<removeList->size(); i++)
{
std::cout<< "\t" << CIRCLE << (*removeList)[i]<<"\n";
}
if (addList->size()!=0)
{
cout<< MSG_ADDED_DIRECTORIES;
}
for(unsigned int i=0;i<addList->size(); i++)
{
std::cout<< "\t" << CIRCLE << (*addList)[i]<<"\n";
}
std::cout << "\n";
delete addList;
delete removeList;
}
void Image::setBitmap(std::string const & imagePath)
{
ImageManager *imageManager;
imageManager = ImageManager::getInstance();
this->bitmap = imageManager->load(imagePath);
}
void GameOver::init()
{
ImageManager* im = Locator::getImageManager();
_texture = im->getTexture(IMAGES_PATH"gameover.png");
assert(_texture != NULL);
_sprite.setTexture(*_texture, true);
}
/** \brief Initialize textures and sprites
*
* \return void
*
*/
void SplashScreen::init()
{
ImageManager* im = Locator::getImageManager();
_splashTexture = im->getTexture(IMAGES_PATH"splashscreen.png");
assert(_splashTexture != NULL);
_splash.setTexture(*_splashTexture, true);
}
void SkImageManager::LoadResources(const RuntimeScene & scene, const ImageManager & imageMgr)
{
UnloadAllImages();
while(m_needToBeLoaded.size() > 0)
{
if(imageMgr.HasImage(m_needToBeLoaded.front()))
{
m_images[m_needToBeLoaded.front()] = imageMgr.GetSFMLTexture(m_needToBeLoaded.front());
}
m_needToBeLoaded.pop();
}
}
TEST(ImageManager, NotifiesRequestorImmediatelyIfDependenciesAreSatisfied) {
ImageManager imageManager;
StubImageRequestor requestor;
bool notified = false;
requestor.imagesAvailable = [&] (ImageMap) {
notified = true;
};
uint64_t imageCorrelationID = 0;
imageManager.addImage(makeMutable<style::Image::Impl>("one", PremultipliedImage({ 16, 16 }), 2));
imageManager.getImages(requestor, std::make_pair(std::set<std::string> {"one"}, imageCorrelationID));
ASSERT_TRUE(notified);
}
Carte::Carte(ImageManager &IM, std::string adr1, std::string adr2, std::string adr3,int w,int h)
{
//hb = new Hitbox(IM,adr);
Iinf.SetImage(*(IM.GetImage(adr1)));
Isup.SetImage(*(IM.GetImage(adr2)));
hitbox.SetImage(*(IM.GetImage(adr3)));
Iinf.Resize(w,h);
Isup.Resize(w,h);
hitbox.Resize(w,h);
}
TEST(ImageManager, NotifiesRequestorWhenSpriteIsLoaded) {
ImageManager imageManager;
StubImageRequestor requestor;
bool notified = false;
requestor.imagesAvailable = [&] (ImageMap) {
notified = true;
};
uint64_t imageCorrelationID = 0;
imageManager.getImages(requestor, std::make_pair(std::set<std::string> {"one"}, imageCorrelationID));
ASSERT_FALSE(notified);
imageManager.setLoaded(true);
ASSERT_TRUE(notified);
}
TEST(ImageManager, Updates) {
ImageManager imageManager;
PremultipliedImage imageA({ 16, 12 });
imageA.fill(255);
imageManager.addImage(makeMutable<style::Image::Impl>("one", std::move(imageA), 1));
auto a = *imageManager.getPattern("one");
EXPECT_EQ(1, a.tl()[0]);
EXPECT_EQ(1, a.tl()[1]);
EXPECT_EQ(17, a.br()[0]);
EXPECT_EQ(13, a.br()[1]);
EXPECT_EQ(16, a.displaySize()[0]);
EXPECT_EQ(12, a.displaySize()[1]);
EXPECT_EQ(1.0f, a.pixelRatio);
test::checkImage("test/fixtures/image_manager/updates_before", imageManager.getAtlasImage());
PremultipliedImage imageB({ 5, 5 });
imageA.fill(200);
imageManager.updateImage(makeMutable<style::Image::Impl>("one", std::move(imageB), 1));
auto b = *imageManager.getPattern("one");
EXPECT_EQ(1, b.tl()[0]);
EXPECT_EQ(1, b.tl()[1]);
EXPECT_EQ(6, b.br()[0]);
EXPECT_EQ(6, b.br()[1]);
EXPECT_EQ(5, b.displaySize()[0]);
EXPECT_EQ(5, b.displaySize()[1]);
EXPECT_EQ(1.0f, b.pixelRatio);
test::checkImage("test/fixtures/image_manager/updates_after", imageManager.getAtlasImage());
}
void UserInterface::initInterface(Screen newScreen, ImageManager& imageManager)
{
// Clearing the previous UI elements
elements.clear();
// Updating the screenstate
screenState = newScreen;
// Populating the screen based on the input
switch(newScreen)
{
case Screen::TITLE:
elements["exitButton"] = InterfaceElement(resolution.x - 150, resolution.y - 50,"exit",font,10,10);
elements["exitButton"].sprite.setTexture(imageManager.getTexture("button"));
elements["startButton"] = InterfaceElement(50,resolution.y - 50,"start",font,10,10);
elements["startButton"].sprite.setTexture(imageManager.getTexture("button"));
elements["titleText"] = InterfaceElement(resolution.x / 2 - 150, 50, "BoulderDash",font,0,0);
backgroundSprite.setTexture(imageManager.getTexture("titleBG"));
break;
case Screen::PLAY:
elements["livesText"] = InterfaceElement(0,0,"",font,64,0,true);
elements["livesText"].headerText.setColor(sf::Color::Transparent);
elements["diamondsText"] = InterfaceElement(0,0,"",font,64,0,true);
elements["diamondsText"].headerText.setColor(sf::Color::Transparent);
backgroundSprite.setTexture(sf::Texture());
break;
case Screen::GAMEOVER:
elements["endText"] = InterfaceElement(resolution.x / 2 - 150, 50, "Game Over",font,0,0);
backgroundSprite.setTexture(imageManager.getTexture("endBG"));
break;
case Screen::WIN:
elements["winText"] = InterfaceElement(resolution.x / 2 - 150, 50, "Congratulations!",font,0,0);
elements["winText"].headerText.setColor(sf::Color::Green);
backgroundSprite.setTexture(imageManager.getTexture("titleBG"));
}
}
/////////////////////LEVEL SELECT/////////////////////
LevelPlaySelect::LevelPlaySelect(ImageManager& imageManager, SDL_Renderer& renderer)
:LevelSelect(imageManager,renderer,_("Select Level")),
levelInfoRender(imageManager,renderer,getDataPath(),*fontText,themeTextColor){
//Load the play button if needed.
playButtonImage=imageManager.loadTexture(getDataPath()+"gfx/playbutton.png", renderer);
//Create the gui.
createGUI(imageManager,renderer, true);
//Show level list
refresh(imageManager,renderer);
}
TileMap::TileMap(string sourceFile, ImageManager &ImageManager_)
{
//Load the XML source file.
string str = "Data/Arenas/";
str = str + sourceFile;
TiXmlDocument ArenaDocument(str.c_str());
if(!ArenaDocument.LoadFile())
{
cerr<<"Error while loading "<<sourceFile<<endl;
cerr<<ArenaDocument.ErrorDesc()<<endl;
}
TiXmlHandle ArenaHandle(&ArenaDocument);
//Load the tile set.
TiXmlNode* TileSetNode = ArenaHandle.FirstChild("Arena").FirstChild("TileSet").ToNode();
TiXmlElement* TileElement = NULL;
while(TileSetNode->IterateChildren("Tile", TileElement) != NULL)
{
TileElement = TileSetNode->IterateChildren("Tile", TileElement)->ToElement();
str = "Data/Tiles/";
str = str + TileElement->Attribute("file");
TileSet.push_back(Tile(ImageManager_.Get(str)));
TileSet.back().sourceFile = str;
if(strcmp(TileElement->Attribute("isBlockingCharacters"),"true") == 0)
{
TileSet.back().blocksCharacters = true;
}
else
TileSet.back().blocksCharacters = false;
if(strcmp(TileElement->Attribute("isBlockingSpells"), "true") == 0)
TileSet.back().blocksSpells = true;
else
TileSet.back().blocksSpells = false;
}
//Load the tile map.
TiXmlNode* MapNode = ArenaHandle.FirstChildElement("Arena").FirstChild("Map").ToNode();
TiXmlElement* Line = NULL;
string tileLine;
int temp;
while(MapNode->IterateChildren("Line", Line) != NULL)
{
Line = MapNode->IterateChildren("Line", Line)->ToElement();
tileLine = Line->Attribute("TileLine");
Tiles.push_back(vector<int>(tileLine.size()));
for(int i=0; i<tileLine.size(); i++)
{
temp = tileLine.c_str()[i] - '0';
Tiles.back()[i] = temp;
}
}
}
void CameraTestToggleCommand::clean() {
// Release all previewed images
if (m_sl) {
int i, fidsCount = m_fids.size();
for (i = 0; i < fidsCount; ++i) {
const TFrameId &fid = m_fids[i];
int status = m_sl->getFrameStatus(fid);
if (status & TXshSimpleLevel::CleanupPreview) {
ImageManager *im = ImageManager::instance();
im->unbind(m_sl->getImageId(fid, TXshSimpleLevel::CleanupPreview));
IconGenerator::instance()->remove(m_sl.getPointer(), fid);
m_sl->setFrameStatus(fid, status & ~TXshSimpleLevel::CleanupPreview);
}
}
}
m_sl = TXshSimpleLevelP();
m_fids.clear();
}
TEST(ImageManager, AddRemove) {
FixtureLog log;
ImageManager imageManager;
imageManager.addImage(makeMutable<style::Image::Impl>("one", PremultipliedImage({ 16, 16 }), 2));
imageManager.addImage(makeMutable<style::Image::Impl>("two", PremultipliedImage({ 16, 16 }), 2));
imageManager.addImage(makeMutable<style::Image::Impl>("three", PremultipliedImage({ 16, 16 }), 2));
imageManager.removeImage("one");
imageManager.removeImage("two");
EXPECT_NE(nullptr, imageManager.getImage("three"));
EXPECT_EQ(nullptr, imageManager.getImage("two"));
EXPECT_EQ(nullptr, imageManager.getImage("four"));
}
bool Map::getTileset(const ImageManager& img){
tileset = img.getImagePtr(handle);
//tileset->SetSmooth(false);
if(tileset == NULL) return false;
for(int i=0;i<mWidth*mHeight;i++){
grid[i].img.SetImage(*tileset);
int y = i / mWidth;
int x = i - (y*mWidth);
grid[i].img.SetX((float) x*16);
grid[i].img.SetY((float) y*16);
y = grid[i].tileId / 9;
x = grid[i].tileId - (y * 9) - 1;
y = y * 16 + 2 + y;
x = x * 16 + 2 + x;
grid[i].img.SetSubRect(sf::IntRect(x,y,x+16,y+16));
}
return true;
}
TEST(ImageManager, RemoveReleasesBinPackRect) {
FixtureLog log;
ImageManager imageManager;
imageManager.addImage(makeMutable<style::Image::Impl>("big", PremultipliedImage({ 32, 32 }), 1));
EXPECT_TRUE(imageManager.getImage("big"));
imageManager.removeImage("big");
imageManager.addImage(makeMutable<style::Image::Impl>("big", PremultipliedImage({ 32, 32 }), 1));
EXPECT_TRUE(imageManager.getImage("big"));
EXPECT_TRUE(log.empty());
}
irr::video::ITexture* ImageManager::GetFieldTexture(int code, int player) {
if(code == 0)
return NULL;
ScopedLock lk(mutex);
int fieldcode = code + player;
auto tit = tSpellFields.find(fieldcode);
if(tit == tSpellFields.end()) {
irr::video::ITexture* rt = 0;
rt = driver->addRenderTargetTexture(core::dimension2d<u32>(512,512));
driver->setRenderTarget(rt, false, false, video::SColor(0,0,0,255));
ITexture *texture = imageManager.GetTextureField(code);
if(texture)
driver->draw2DImage(texture, irr::core::rect<s32>(0,0,512,512),player == 0 ? irr::core::rect<s32>(0,256,512,512) : irr::core::rect<s32>(0,0,512,256));
driver->setRenderTarget(0, false, false, 0);
tSpellFields[fieldcode] = rt;
return rt;
}
if(tit->second)
return tit->second;
return NULL;
}
fcn::Image* GuiImageLoader::load(const std::string& filename, bool convertToDisplayFormat) {
ImageManager* imgManager = ImageManager::instance();
if(imgManager->exists(filename)) {
return new GuiImage(imgManager->get(filename));
}
// load demanded image
ImagePtr tmpimg = imgManager->load(filename);
if(tmpimg->getWidth() >= ATLAS_SIZE || tmpimg->getHeight() >= ATLAS_SIZE) {
return new GuiImage(tmpimg);
}
// look for a place for an image of given size
AtlasBlock* block = m_atlasbook->getBlock(tmpimg->getWidth(), tmpimg->getHeight());
// if it can't fit, we need to add new 'page'
if(block->page >= m_atlases.size()) {
m_atlases.push_back(imgManager->loadBlank(ATLAS_SIZE, ATLAS_SIZE));
// because we gonna update texture on-the fly (via TexSubImage)
// we cant really use compressed texture
RenderBackend* rb = RenderBackend::instance();
bool prev = rb->isImageCompressingEnabled();
rb->setImageCompressingEnabled(false);
m_atlases[block->page]->forceLoadInternal();
rb->setImageCompressingEnabled(prev);
}
// update atlas page with given image
m_atlases[block->page]->copySubimage(block->left, block->top, tmpimg);
// we dont really need this image anymore
tmpimg->free();
imgManager->remove(tmpimg);
// create shared image and return it
ImagePtr img = imgManager->create(filename);
Rect region(block->left, block->top, block->getWidth(), block->getHeight());
img->useSharedImage(m_atlases[block->page], region);
return new GuiImage(img);
}
TEST(ImageManager, Basic) {
FixtureLog log;
ImageManager imageManager;
auto images = parseSprite(util::read_file("test/fixtures/annotations/emerald.png"),
util::read_file("test/fixtures/annotations/emerald.json"));
for (auto& image : images) {
imageManager.addImage(image->baseImpl);
}
auto metro = *imageManager.getPattern("metro");
EXPECT_EQ(1, metro.tl()[0]);
EXPECT_EQ(1, metro.tl()[1]);
EXPECT_EQ(19, metro.br()[0]);
EXPECT_EQ(19, metro.br()[1]);
EXPECT_EQ(18, metro.displaySize()[0]);
EXPECT_EQ(18, metro.displaySize()[1]);
EXPECT_EQ(1.0f, metro.pixelRatio);
EXPECT_EQ(imageManager.getPixelSize(), imageManager.getAtlasImage().size);
test::checkImage("test/fixtures/image_manager/basic", imageManager.getAtlasImage());
}
void ToolbarButton::updateImageSize(ImageManager& im){
imageSize = (sf::Vector2f)(*im.getImage(filename)).getSize();
}
void TileMap::clear(ImageManager& ImageManager_)
{
for(int i=0; i<TileSet.size(); i++)
ImageManager_.release(TileSet[i].sourceFile);
}
PreGameView::PreGameView(void)
{
ImageManager* imgMgr = ImageManager::get();
this->image = imgMgr->getImage("Images/pregame.bmp");
}
bool Teleportation::clear(ImageManager& ImageManager_)
{
return ImageManager_.release("Data/Spells/SpeedBuff.png");
}
namespace ygo {
ImageManager imageManager;
bool ImageManager::Initial() {
tCover[0] = driver->getTexture("textures/cover.jpg");
tCover[1] = driver->getTexture("textures/cover2.jpg");
tUnknown = driver->getTexture("textures/unknown.jpg");
tAct = driver->getTexture("textures/act.png");
tAttack = driver->getTexture("textures/attack.png");
tChain = driver->getTexture("textures/chain.png");
tNegated = driver->getTexture("textures/negated.png");
tNumber = driver->getTexture("textures/number.png");
tLPBar = driver->getTexture("textures/lp.png");
tLPFrame = driver->getTexture("textures/lpf.png");
tMask = driver->getTexture("textures/mask.png");
tEquip = driver->getTexture("textures/equip.png");
tTarget = driver->getTexture("textures/target.png");
tLim = driver->getTexture("textures/lim.png");
tHand[0] = driver->getTexture("textures/f1.jpg");
tHand[1] = driver->getTexture("textures/f2.jpg");
tHand[2] = driver->getTexture("textures/f3.jpg");
tBackGround = driver->getTexture("textures/bg.jpg");
tBackGround2 = driver->getTexture("textures/bg2.jpg");
tField = driver->getTexture("textures/field2.png");
tFieldTransparent = driver->getTexture("textures/field-transparent.png");
for (int i = 0; i < 4; ++i)
tAvatar[i] = NULL;
return true;
}
void ImageManager::SetDevice(irr::IrrlichtDevice* dev) {
device = dev;
driver = dev->getVideoDriver();
}
void ImageManager::ClearTexture() {
ScopedLock lk(mutex);
for(auto tit = tMap.begin(); tit != tMap.end(); ++tit) {
if(tit->second)
driver->removeTexture(tit->second);
}
for(auto tit = tThumb.begin(); tit != tThumb.end(); ++tit) {
if(tit->second)
driver->removeTexture(tit->second);
}
tMap.clear();
tThumb.clear();
}
void ImageManager::RemoveTexture(int code) {
ScopedLock lk(mutex);
auto tit = tMap.find(code);
if(tit != tMap.end()) {
if(tit->second)
driver->removeTexture(tit->second);
tMap.erase(tit);
}
}
irr::video::ITexture* ImageManager::GetTexture(int code) {
if(code == 0)
return tUnknown;
ScopedLock lk(mutex);
auto tit = tMap.find(code);
if(tit == tMap.end()) {
char file[256];
sprintf(file, "pics/%d.jpg", code);
irr::video::ITexture* img = driver->getTexture(file);
if(img == NULL) {
tMap[code] = NULL;
return tUnknown;
} else {
tMap[code] = img;
return img;
}
}
if(tit->second)
return tit->second;
else
return tUnknown;
}
irr::video::ITexture* ImageManager::GetTextureThumb(int code) {
if(code == 0)
return tUnknown;
ScopedLock lk(mutex);
auto tit = tThumb.find(code);
if(tit == tThumb.end()) {
char file[256];
sprintf(file, "pics/thumbnail/%d.jpg", code);
irr::video::ITexture* img = driver->getTexture(file);
if(img == NULL) {
tThumb[code] = NULL;
return GetTexture(code);
} else {
tThumb[code] = img;
return img;
}
}
if(tit->second)
return tit->second;
else
return GetTexture(code);
}
irr::video::ITexture* ImageManager::GetTextureField(int code) {
if(code == 0)
return NULL;
ScopedLock lk(mutex);
auto tit = tFields.find(code);
if(tit == tFields.end()) {
char file[256];
sprintf(file, "pics/field/%d.png", code);
irr::video::ITexture* img = driver->getTexture(file);
if(img == NULL) {
printf(file, "pics/field/%d.jpg", code);
img = driver->getTexture(file);
if (img == NULL) {
tFields[code] = NULL;
return NULL;
}
else {
tFields[code] = img;
return img;
}
} else {
tFields[code] = img;
return img;
}
}
if(tit->second)
return tit->second;
else
return NULL;
}
irr::video::ITexture* ImageManager::GetFieldTexture(int code, int player) {
if(code == 0)
return NULL;
ScopedLock lk(mutex);
int fieldcode = code + player;
auto tit = tSpellFields.find(fieldcode);
if(tit == tSpellFields.end()) {
irr::video::ITexture* rt = 0;
rt = driver->addRenderTargetTexture(core::dimension2d<u32>(512,512));
driver->setRenderTarget(rt, false, false, video::SColor(0,0,0,255));
ITexture *texture = imageManager.GetTextureField(code);
if(texture)
driver->draw2DImage(texture, irr::core::rect<s32>(0,0,512,512),player == 0 ? irr::core::rect<s32>(0,256,512,512) : irr::core::rect<s32>(0,0,512,256));
driver->setRenderTarget(0, false, false, 0);
tSpellFields[fieldcode] = rt;
return rt;
}
if(tit->second)
return tit->second;
return NULL;
}
void ImageManager::LoadSleeve(int player, wchar_t* site, wchar_t* dir)
{
TextureData *sleeve = new TextureData;
sleeve->type = SLEEVE;
sleeve->player = player;
std::wcstombs(sleeve->hostname, site, 256);
std::wcstombs(sleeve->filename, dir, 256);
if(player == 0)
std::wcstombs(sleeve->fakename, L"cover0.jpg", 256);
else
std::wcstombs(sleeve->fakename, L"cover1.jpg", 256);
pendingTextures.push_back(sleeve);
}
void ImageManager::LoadPendingTextures()
{
while (!pendingTextures.empty())
{
TextureData *textureData(pendingTextures.back());
pendingTextures.pop_back();
ITexture *texture = DownloadTexture(textureData);
if (texture)
ApplyTexture(textureData, texture);
delete textureData;
}
}
ITexture* ImageManager::DownloadTexture(TextureData *textureData)
{
sf::Http::Request request(textureData->filename, sf::Http::Request::Get);
sf::Http http(textureData->hostname);
sf::Http::Response response = http.sendRequest(request);
if (response.getStatus() == sf::Http::Response::Ok)
{
std::string *body = new std::string(response.getBody());
void *memory = (void *)body->c_str();
IReadFile *f = device->getFileSystem()->createMemoryReadFile(memory, body->size(), textureData->fakename, false);
ITexture *texture = driver->getTexture(f);
return texture;
}
return NULL;
}
void ImageManager::ApplyTexture(TextureData *textureData, ITexture *texture)
{
switch (textureData->type)
{
case SLEEVE:
if (textureData->player >= 0 && textureData->player < 2)
tCover[textureData->player] = texture;
break;
case AVATAR:
if (textureData->player >= 0 && textureData->player < 4)
tAvatar[textureData->player] = texture;
break;
}
}
}
Teleportation::Teleportation(Vector2f Position, ImageManager& ImageManager_)
{
this->SetImage(*ImageManager_.Get("Data/Spells/SpeedBuff.png"));
this->SetPosition(Position);
timeLeft = 50;
}
bool Map::loadMapArt(const ImageManager& img){
tileset = img.getImagePtr(handle);
if(tileset == NULL) return false;
mapArt.SetImage(*tileset);
}
void Carte::set_Map(ImageManager & IM,std::string adr){
Iinf.SetImage(*(IM.GetImage(adr)));
}
TEST(ImageManager, Missing) {
ImageManager imageManager;
EXPECT_FALSE(imageManager.getImage("doesnotexist"));
}
void enemy::show_baddies(ImageManager &i, Setup &s)
{
i.drawenemies(xycoords.vx, xycoords.vy, s);
}
