blob: 1d65538fbcbaa5b88bd89b1592e023a7d49a3214 (
plain) (
tree)
|
|
/*
* The Mana World
* Copyright 2004 The Mana World Development Team
*
* This file is part of The Mana World.
*
* The Mana World is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* any later version.
*
* The Mana World is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with The Mana World; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id$
*/
#include "../log.h"
#include "image.h"
#include "resourcemanager.h"
#include <iostream>
#ifdef WIN32
#include <direct.h>
#else
#include <unistd.h>
#endif
ResourceEntry::ResourceEntry():
resource(NULL)
{
}
ResourceManager *ResourceManager::instance = NULL;
ResourceManager::ResourceManager()
{
}
ResourceManager::~ResourceManager()
{
// Create our resource iterator.
std::map<std::string, ResourceEntry>::iterator iter = resources.begin();
int danglingResources = 0;
int danglingReferences = 0;
// Iterate through and release references until objects are deleted.
while (iter != resources.end()) {
Resource *res = iter->second.resource;
danglingResources++;
danglingReferences++;
while (!res->decRef()) {
danglingReferences++;
}
iter++;
}
resources.clear();
#ifdef __DEBUG
std::cout << "ResourceManager::~ResourceManager() cleaned up " <<
danglingReferences << " references to " << danglingResources <<
" resources\n";
#endif
}
Resource* ResourceManager::create(const E_RESOURCE_TYPE &type,
const std::string &idPath)
{
// Check if the id exists, and return the value if it does.
std::map<std::string, ResourceEntry>::iterator resIter =
resources.find(idPath);
if (resIter != resources.end() && resIter->second.resource) {
resIter->second.resource->incRef();
return resIter->second.resource;
}
// Attempt to load the object if it doesn't exist.
// The filePath string.
std::string filePath = "";
// Retrieve the current path for this program.
char programPath[260];
getcwd(programPath, 260);
// Set the filePath variable to the appropriate value
// this is only if we're not using a packed file.
#ifdef WIN32
// Flip all of the idPath '/' to '\'
unsigned int begPos = 0;
unsigned int endPos = idPath.find("/");
std::strstream result;
// Loop through and replace all the characters.
while (endPos != std::string::npos) {
result << idPath.substr(begPos, endPos - begPos);
result << "\\";
begPos = endPos + 1;
endPos = (unsigned int)idPath.find("/");
}
filePath = std::string(programPath) + std::string("\\data\\") +
std::string(result.str());
#else
filePath = std::string(programPath) + std::string("/data/") + idPath;
#endif
Resource *resource = NULL;
// Create an object of the specified type.
switch (type)
{
case MAP:
warning("Map resource not supported.");
break;
case MUSIC:
warning("Music resource not supported.");
break;
case IMAGE:
// Attempt to create and load our image object.
resource = reinterpret_cast<Resource*>(Image::load(filePath));
break;
case SCRIPT:
warning("Script resource not supported.");
break;
case TILESET:
warning("Tileset resource not supported.");
break;
case SOUND_EFFECT:
warning("Sound FX resource not supported.");
break;
default:
warning("Unknown resource type");
break;
}
if (resource) {
resource->incRef();
// Create the resource entry for this object.
ResourceEntry entry;
entry.filePath = filePath;
entry.resource = resource;
resources[idPath] = entry;
}
// Return NULL if the object could not be created.
return resource;
}
Image *ResourceManager::createImage(const std::string &idPath)
{
return (Image*)create(IMAGE, idPath);
}
ResourceManager* ResourceManager::getInstance()
{
// Create a new instance if necessary.
if (instance == NULL) instance = new ResourceManager();
return instance;
}
void ResourceManager::deleteInstance()
{
if (instance != NULL) {
delete instance;
instance = NULL;
}
}
|