random_racer/src/ResourceManager.cpp

Go to the documentation of this file.

#ifdef __linux__
    #define __USE_BSD
    #define __USE_POSIX
#endif

#include <sys/stat.h>
#include <sys/types.h>

#include <vrs/image/image.h>
#include <vrs/io/objectloader.h>
#include <vrs/opengl/imagecubemaptexturegl.h>
#include <vrs/opengl/imagetexture2dgl.h>
#include <vrs/sg/scenething.h>
#include <vrs/io/threedsreader.h>

#include "ResourceManager.h"


using namespace VRS;

namespace random_racer
{

SO<ResourceManager> ResourceManager::s_instance = NULL;

ResourceManager::ResourceManager()
{
    // TODO: Windows build
    // initialize the home dir path
    char* home = getenv("HOME");
    VRS_Error(home != NULL, "There is no Home Variabel");
    
    m_homeDir = std::string(home);
#ifdef __APPLE__
    m_homeDir += "/Library/Application Support/Random Racer";
#elif defined(__linux__)
    m_homeDir += "/.random_racer";
#endif
    
    struct stat statusBuffer;
    if(lstat(m_homeDir.c_str(), &statusBuffer) < 0)
    {
        // if there is no dir, create one
        VRS_Error( mkdir(m_homeDir.c_str(), 0755) == 0, "Cant create Dir");
    }
    else
    {
        VRS_Error((statusBuffer.st_mode & S_IFDIR) == S_IFDIR, "Is not a Dir");
    }
    
    // initialize the data path
    m_fileDir = "";
}

ResourceManager::~ResourceManager()
{
}

void
ResourceManager::setArgv(const std::string& p_argv)
{
    if(p_argv.rfind("RandomRacer.app/Contents/MacOS") != std::string::npos)
        m_fileDir = p_argv.substr(0,p_argv.rfind("MacOS")) + "Resources/";
    else
    {
        struct stat statusBuffer;
        if(stat("data", &statusBuffer) < 0)
        {
            VRS_Error(stat("../data", &statusBuffer) == 0,"Cant find data Dir");
            m_fileDir = "../data/";
        }
        else
            m_fileDir = "data/";
    }
}

SO<ResourceManager>
ResourceManager::get()
{
    if(s_instance == NULL)
        s_instance = new ResourceManager();

    return s_instance;
}

SO<Image>
ResourceManager::loadImage(const std::string& p_imageName)
{
    SO<Image> image;
    ResourceContainer containerObject;

    if(m_resourceRegistry.contains(p_imageName))
    {
        VRS_Error(m_resourceRegistry.getValue(p_imageName).type == ImageType,
                    "Key(Image) already exists");
        
        containerObject = m_resourceRegistry.getValue(p_imageName);
        image = VRS_GuardedCast(Image, containerObject.sharedObject);
    }
    else
    {
        image = VRS_GuardedLoadObject(Image, m_fileDir + p_imageName);

        containerObject.type = ImageType;
        containerObject.sharedObject = image;

        m_resourceRegistry.insert(p_imageName, containerObject);
    }
    return image;
}

SO<ImageTexture2DGL>
ResourceManager::loadTexture2D(const std::string& p_imageName, 
                               bool p_pow2, bool p_noException)
{
    SO<ImageTexture2DGL> texture;
    ResourceContainer containerObject;

    if(m_resourceRegistry.contains(p_imageName))
    {
        VRS_Error(m_resourceRegistry.getValue(p_imageName).type == TextureType,
                    "Key(Texture) already exists");

        containerObject = m_resourceRegistry.getValue(p_imageName);
        texture = VRS_GuardedCast(ImageTexture2DGL,
                                    containerObject.sharedObject);
    }
    else
    {
        SO<Image> image;
        
        if(p_noException)
            image = VRS_LOAD_OBJECT(Image, m_fileDir + p_imageName); 
        else
            image = VRS_GuardedLoadObject(Image, m_fileDir + p_imageName);

        if(image != NULL)
        {
            if(p_pow2)
                texture = new ImageTexture2DGL(image->copyToPow2());
            else
                texture = new ImageTexture2DGL(image);        

            containerObject.type = TextureType;
            containerObject.sharedObject = texture;

            m_resourceRegistry.insert(p_imageName, containerObject);
        }
        else
            texture = NULL;
    }
    return texture;
}

SO<Font>
ResourceManager::loadFont(const std::string& p_fontName, Font::FontType 
                                                                    p_fontType)
{
    SO<Font> font;
    ResourceContainer containerObject;

    if(m_resourceRegistry.contains(p_fontName))
    {
        VRS_Error(m_resourceRegistry.getValue(p_fontName).type == FontType,
                    "Key(Font) already exists");

        containerObject = m_resourceRegistry.getValue(p_fontName);
        font = VRS_GuardedCast(Font, containerObject.sharedObject);
    }
    else
    {
        font = Font::createFont(m_fileDir + p_fontName, p_fontType);
        
        containerObject.type = FontType;
        containerObject.sharedObject = font;

        m_resourceRegistry.insert(p_fontName, containerObject);
    }
    return font;
}

SO<ImageCubeMapTextureGL> 
ResourceManager::loadCubeTexture(const std::string& p_imageName, const 
                                                        std::string& p_format)
{
    SO<ImageCubeMapTextureGL> cubeTexture;
    ResourceContainer containerObject;
    
    if(m_resourceRegistry.contains(p_imageName))
    {
        VRS_Error(m_resourceRegistry.getValue(p_imageName).type == CubeType,
                    "Key(Cube) already exists");

        containerObject = m_resourceRegistry.getValue(p_imageName);
        cubeTexture = VRS_GuardedCast(ImageCubeMapTextureGL,
                                                containerObject.sharedObject);
    }
    else
    {
        SO<Image> front, back, left, right, bottom, top;
        
        front = VRS_GuardedLoadObject(Image, m_fileDir + p_imageName + 
                                                        "_front" + p_format);
        back = VRS_GuardedLoadObject(Image, m_fileDir + p_imageName + 
                                                        "_back" + p_format);
        left = VRS_GuardedLoadObject(Image, m_fileDir + p_imageName + 
                                                        "_left" + p_format);
        right = VRS_GuardedLoadObject(Image, m_fileDir + p_imageName + 
                                                        "_right" + p_format);
        bottom = VRS_GuardedLoadObject(Image, m_fileDir + p_imageName + 
                                                        "_bottom" + p_format);
        top = VRS_GuardedLoadObject(Image, m_fileDir + p_imageName + 
                                                        "_top" + p_format);
        
        cubeTexture = new ImageCubeMapTextureGL(right, left, top, bottom, front, 
                                                                        back);

        containerObject.type = CubeType;
        containerObject.sharedObject = cubeTexture;

        m_resourceRegistry.insert(p_imageName, containerObject);
    }
    return cubeTexture;
}

std::string
ResourceManager::getPathOfFile(const std::string& p_fileName)
{  
    return m_homeDir +"/"+ p_fileName;
}

SO<SceneThing> 
ResourceManager::load3ds(const std::string& p_fileName)
{
    ThreeDSReader::setTextureMode(ThreeDSReader::TRY_TEXTURES);
    ThreeDSReader::setReadMode(ThreeDSReader::READ_SCENE);
    ThreeDSReader::setOptimizations(ThreeDSReader::NO_OPTIMIZATIONS);
    ThreeDSReader::setMetaInfo(true);
    
    SO<SceneThing> modelThing = new SceneThing();
    
    modelThing = VRS_LOAD_OBJECT(SceneThing, m_fileDir + p_fileName);
     
    return modelThing;
}

bool
ResourceManager::freeResource(const std::string& p_name)
{
    if(m_resourceRegistry.contains(p_name))
        return m_resourceRegistry.erase(p_name);
    else
        return false;
}

void
ResourceManager::freeAllResources()
{
    m_resourceRegistry.clear();
}

} // namespace random_racer

---