MercuryTextureManager.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryTextureManager.h"
#include "MercuryDisplay.h"
#include "MercuryLog.h"
#include "MercuryUtil.h"
#include "MercuryFiles.h"

#define     MC_TEXTURESTATS     1
#define     MC_LOADTEXTURE      2
#define     MC_UNREGISTER       3
#define     MC_LOADTEXTURERAW   4


TextureID::~TextureID()
{
    unsigned int num = m_textures.size();
    for (unsigned int i = 0; i < num; ++i)
        m_textures[i] = NULL;
    DISPLAY->DeleteTextures(1, &m_ID);
}

TextureID::TextureID(const MString& path, bool loadPending)
{
    m_ID = 0;
    m_path = path;
    m_loadPending = loadPending;
}

bool TextureID::RemoveTexturePtr(const MercuryTexture* texture)
{
    unsigned int i;
    for( i = 0; i < m_textures.size(); i++ )
        if( m_textures[i] == texture )
        {
            m_textures[i] = NULL;
            m_textures.remove(i);
            return true;
        }
    return false;
}

void TextureID::UpdateTextureData(MercuryTexture* texture)
{
    DISPLAY->UpdateTextureData(texture, m_ID);
}

MercuryTextureManager::MercuryTextureManager()
{
    MercuryMessageHandler::MercuryMessageHandler();
    m_textureCount = 0;

    MercuryMessageHandler::RegisterMessage( MC_TEXTURESTATS, "RenderStats" );
    MercuryMessageHandler::RegisterMessage( MC_LOADTEXTURE, "LoadTexture" );
    MercuryMessageHandler::RegisterMessage( MC_UNREGISTER, "UnregisterTexture" );
    MercuryMessageHandler::RegisterMessage( MC_LOADTEXTURERAW, "LoadTextureRaw" );
}

MercuryTextureManager::~MercuryTextureManager()
{
    MLockPtr< map<MString, TextureID*> > textureMap(m_textureMap, m_mtxMap);
    for(map<MString, TextureID*>::iterator it = textureMap->begin();
        it != textureMap->end(); ++it)
            SAFE_DELETE(it->second);
}

void MercuryTextureManager::Message( int Message, PStack & data, const MString & name )
{
    switch ( Message ) 
    {
    case MC_TEXTURESTATS:
        {
            PStack stats;
            stats.PushItemBack( PSElement ((int)(UniqueTextureCount())) );
            stats.PushItemBack( PSElement ((int)(TextureCount())) );
            MESSAGEMAN->PostSystemMessage( "TextureStats", stats, 0 );
        }
        break;
    case MC_LOADTEXTURE:
        {
            MString path = data.PeekItem(0).GetValueS();
            MercuryTexture* t = (MercuryTexture*)data.PeekItem(1).GetValueV();

            if (!path.empty())
            {
                ThreadLoadData* tld = new ThreadLoadData(path,t);
                if (!TryFromExisting(tld))
                    MLockPtr< MDeque<ThreadLoadData*> >(m_loadQueue, m_mtxLoadQueue)->push_front(tld);
            }
        }
        break;
    case MC_UNREGISTER:
        {
            MString path = data.PeekItem(0).GetValueS();
            MercuryTexture* t = (MercuryTexture*)data.PeekItem(1).GetValueV();
            Remove(path, t);
        }
        break;
    case MC_LOADTEXTURERAW:
        {
            MString path = data.PeekItem(0).GetValueS();
            MercuryTexture* t = (MercuryTexture*)data.PeekItem(1).GetValueV();
            RawImageData* imagedata = (RawImageData*)data.PeekItem(2).GetValueV();

            if (!path.empty())
            {
                ThreadLoadData* tld = new ThreadLoadData(path,t,imagedata);
                if (!TryFromExisting(tld))
                    MLockPtr< MDeque<ThreadLoadData*> >(m_loadQueue, m_mtxLoadQueue)->push_front(tld);
            }
        }
        break;
    }
}

bool MercuryTextureManager::TryFromExisting(ThreadLoadData* tld)
{
    TextureID* tid = FindTexture(tld->path);
    if (tid)
    {
        tid->m_textures.push_back(tld->texture);
        ++m_textureCount;

        PStack data;
        data.PushItemBack(PSElement((void*)tld->texture));
        data.PushItemBack(PSElement(&(tid->m_attrs)));
        MESSAGEMAN->PostSystemMessage("GetTextureID", data);

        SAFE_DELETE(tld);
        return true;
    }
    return false;
}

void* TheadFunctCaller(void* x)
{
    MercuryTextureManager* y = (MercuryTextureManager*)x;
    y->ThreadLoop();
    return 0;
}

void MercuryTextureManager::CreateThread()
{
#if !defined( NO_THREADS )
    m_thread.Create(TheadFunctCaller, this);
#endif
}

void MercuryTextureManager::Update( const float dTime )
{
#if defined( NO_THREADS )
    ProcessLoadQueue();
#endif
    ProcessFinalizeQueue();
}

RawImageData * MercuryTextureManager::LoadDyn( const MString & sFullName, MString & sShortName )
{
    if( sFullName.length() < 7 )
        return NULL;
    MVector< MString > vSplit;
    SplitStrings( sFullName.substr( 7 ), vSplit, ",", " ", 1, 1 );
    if( vSplit.size() != 4 )
    {
        LOG.Warn( "ERROR: Dynamic Textures MUST be reated in the following form: (Name),(Width),(Height),(bitmode=0|1)" );
        return NULL;
    }
    RawImageData * k = new RawImageData;
    k->attrs.m_ColorByteType = atoi(vSplit[3].c_str())?RGBA_FLOAT:RGBA;
    k->attrs.m_height = k->attrs.m_height_original = atoi( vSplit[2].c_str() );
    k->attrs.m_width = k->attrs.m_width_original = atoi( vSplit[1].c_str() );
//  k->attrs.m_isDynamic = true; //XXX FIX ME
    k->attrs.m_ID = 0;

    //don't even try to fill the data
    k->data = 0;
    sShortName = vSplit[0];
    return k;
}

RawImageData * MercuryTextureManager::LoadDynShadow( const MString & sFullName, MString & sShortName )
{
    //ERROR feature not implemented....this should never be called
    //Crash the program, so that anyone with a debugger can find this location
    *((unsigned int*)(NULL)) = 1;


    if( sFullName.length() < 13 )
        return NULL;
    MVector< MString > vSplit;
    SplitStrings( sFullName.substr( 13 ), vSplit, ",", " ", 1, 1 );
    if( vSplit.size() != 4 )
    {
        LOG.Warn( "ERROR: Dynamic Textures MUST be reated in the following form: (Name),(Width),(Height),(bitmode=0|1)" );
        return NULL;
    }
    RawImageData * k = new RawImageData;
    k->attrs.m_ColorByteType = DEPTH_COMPONENT24;
    k->attrs.m_height = k->attrs.m_height_original = atoi( vSplit[2].c_str() );
    k->attrs.m_width = k->attrs.m_width_original = atoi( vSplit[1].c_str() );
//  k->attrs.m_isDynamicShadow = true; //XXX FIX ME
    k->attrs.m_ID = 0;

    //don't even try to fill the data
    k->data = 0;
    sShortName = vSplit[0];
    return k;
}

RawImageData * MercuryTextureManager::LoadDynCube( const MString & sFullName, MString & sShortName )
{
    if( sFullName.length() < 8 )
        return NULL;
    MVector< MString > vSplit;
    SplitStrings( sFullName.substr( 8 ), vSplit, ",", " ", 1, 1 );
    if( vSplit.size() != 4 )
    {
        LOG.Warn( "ERROR: Dynamic Textures MUST be reated in the following form: (Name),(Width),(Height),(bitmode=0|1)" );
        return NULL;
    }
    RawImageData * k = new RawImageData;
    k->attrs.m_ColorByteType = atoi(vSplit[3].c_str())?RGBA_FLOAT:RGBA;
    k->attrs.m_height = k->attrs.m_height_original = atoi( vSplit[2].c_str() );
    k->attrs.m_width = k->attrs.m_width_original = atoi( vSplit[1].c_str() );
//  k->attrs.m_isDynamic = true; //XXX FIX ME
    k->attrs.m_ID = 0;
//  k->attrs.m_mapping = CUBE; //XXX FIX ME

    //don't even try to fill the data
    k->data = 0;
    sShortName = vSplit[0];
    return k;
}

//The cobe map raw image data has the data of each of 6 raw faces stuck together onto 1 data array.....
RawImageData *MercuryTextureManager::LoadCube( const MString & sFullName, MString & sShortName )
{
    unsigned int strLen = sFullName.size();
    unsigned int i = 0, j = 0, c = 0;

    MString cubeStr[6];

    RawImageData *pCubeRaw[6];

    //appendedRaw has the width and height of a regular face...but the data is really that of 6 raw faces stuck together
    RawImageData *pFinalRaw;

    //skip until we find a CUBETEX:
    while (c < strLen && sFullName[c] != ':')
        c++;
    c++;

    //for each of the six cube faces
    for (i = 0; i < 6 && c < strLen; i++)
    {
        j = 0;

        //all of the stuff until the next "," is a path for a cube face
        while (c < strLen && sFullName[c] != ',')
        {
            cubeStr[i] += sFullName[c++];
            j++;
        }

        LOG.Log(cubeStr[i]);
        //getch();

        //skip the actual comma
        c++;
    }

    //if there weren't 6 faces after all, then something is wrong....
    if (i < 6)
    {
        LOG.Warn( "ERROR: Cube Textures MUST be treated in the following form: minusXpath, plusXpath, minusYpath, plusYpath, minusZpath, plusZpath" );
        return NULL;
    }

    //now we need the data.......
    for (i = 0; i < 6; i++)
        pCubeRaw[i] = ImageLoader(cubeStr[i]);

    //if any data is missing, then barf
    for (i = 0; i < 6; i++)
    {
        if (pCubeRaw[i]->data == 0)
        {
            //kill the faces
            for (j = 0; j < 6; j++)
            {
                SAFE_DELETE (pCubeRaw[i]->data);
                SAFE_DELETE (pCubeRaw[i]);
            }

            //barf
            LOG.Warn( (MString)("ERROR: cube face \"") + cubeStr[i] + "\" is not loading properly, cube map aborted ()\n" );
            return NULL;
        }
    }
    
    //if the attrs do not match up, then barf
    for (i = 2; i < 6; i++)
    {
        if (pCubeRaw[i]->attrs.m_width  != pCubeRaw[i-1]->attrs.m_width ||
            pCubeRaw[i]->attrs.m_height != pCubeRaw[i-1]->attrs.m_height||
            pCubeRaw[i]->attrs.m_ColorByteType != pCubeRaw[i]->attrs.m_ColorByteType)
        {
            //kill the faces
            for (j = 0; j < 6; j++)
            {
                SAFE_DELETE (pCubeRaw[i]->data);
                SAFE_DELETE (pCubeRaw[i]);
            }

            //barf
            LOG.Warn( (MString)("ERROR: cube faces have inconsistent data\n") );
            return NULL;
        }
    }

    //holy hell, if we got this far, then we must have a damn good cube map
    //load up the actual data
    pFinalRaw = new RawImageData();
    pFinalRaw->attrs = pCubeRaw[0]->attrs;
//  pFinalRaw->attrs.m_mapping = CUBE; //XXX FIX ME
    pFinalRaw->attrs.m_ID = 0;
    unsigned int faceLength  = pFinalRaw->attrs.m_width * pFinalRaw->attrs.m_height * ColorBytesToSize(pFinalRaw->attrs.m_ColorByteType);
    unsigned int totalLength = 6*faceLength;
    pFinalRaw->data = new unsigned char [totalLength];

printf ("pData = %lu\nfaceLength = %lu\ntotalLength = %lu\nfinished newing CubeMap data\n", pFinalRaw->data, faceLength, totalLength);

    c = 0;
    for (i = 0; i < 6; i++)
    {
        for (j = 0; j < faceLength; j++)
        {
            pFinalRaw->data[c++] = pCubeRaw[i]->data[j];
        }
    }

    //kill the faces
    for (i = 0; i < 6; i++)
    {
        SAFE_DELETE (pCubeRaw[i]->data);
        SAFE_DELETE (pCubeRaw[i]);
    }

LOG.Log("done with cube map raw image loading");
//getch();

    return pFinalRaw;
}

MercuryTexture* MercuryTextureManager::CreateTexture(const MString& path)
{
    MercuryTexture* texture = new MercuryTexture;
    texture->Init();
    texture->SetPath(path);
    texture->SendLoadMessage();
    return texture;
}

TextureID* MercuryTextureManager::RegisterNewTexture(const MercuryTexture* t, RawImageData* d, const MString& path)
{
    //Keep this around, we may actually need to lock the entire time if we operate on
    //data contained in the map. But it should be safe since the only other thread that
    //does anything only adds new TextureIDs to the map.
//  MLockPtr< map<MString, TextureID*> > tMap(m_textureMap, m_mtxMap);

    //If we find a TextureID, assume we can use it (threaded load can add them).
    //Otherwise make a new one.
    TextureID* tid = FindTexture(path);
    if (!tid)
    {
        tid = new TextureID(path);
        MLockPtr< map<MString, TextureID*> >(m_textureMap, m_mtxMap)->operator[](tid->m_path) = tid;  //Map insertion
    }

    tid = FindTexture(path);
    ASSERT(tid);
    tid->m_loadPending = false;
    d->CorrectSize();
    DISPLAY->CreateCache(d, tid->m_ID);
    d->attrs.m_ID = tid->m_ID;
    tid->m_attrs = d->attrs;

    SAFE_DELETE(d);

    return tid;
}

void MercuryTextureManager::ThreadLoop()
{
    while(true)
    {
        ProcessLoadQueue();
        Sleep(10);
    }
}

void MercuryTextureManager::ProcessLoadQueue()
{
    /*  This is run from a seperate thread than Update() so accessed
        data needs to be protected. */

    MDeque<ThreadLoadData*> loadQueue;
    MLockPtr< MDeque<ThreadLoadData*> >* loadQueueTmp = new MLockPtr< MDeque<ThreadLoadData*> >(m_loadQueue, m_mtxLoadQueue);

    //make a copy of the m_loadQueue and empty it so its
    //not locked for the duration of this function
    if ((*loadQueueTmp)->empty())
    {
        SAFE_DELETE(loadQueueTmp);
        return;
    }
    else
    {
        while (!(*loadQueueTmp)->empty())
        {
            loadQueue.push_back((*loadQueueTmp)->front());
            (*loadQueueTmp)->pop_front();
        }
        SAFE_DELETE(loadQueueTmp);
    }

    while (!loadQueue.empty())
    {
        ThreadLoadData* tld = loadQueue.front();
        loadQueue.pop_front();

        const TextureID* tid = FindTexture(tld->path);
        if (!tid)
        {
            //Load some data then queue it
            LOG.Log("Loading texture data from " + tld->path + " (loadQueue).");

            if (!tld->d)
            {
                RawImageData* d = ImageLoader(tld->path);
                if (!d)
                    return; //Don't do anything

                tld->d = d;
            }

            /*  create a new TextureID and put it in the map so that
                we don't try to load the same image data in the future */
            TextureID* tid = new TextureID(tld->path, true);
            MLockPtr< map<MString, TextureID*> >(m_textureMap, m_mtxMap)->operator[](tid->m_path) = tid;  //Map insertion
        }
        else
        {
            //If the texture is found we don't want to follow the pointer later
            tld->d = NULL; 
        }
        //Queue in order what we have (from FindTexture or newly loaded data)
        MLockPtr< MDeque<ThreadLoadData*> >(m_finalizeLoadQueue, m_mtxFinalize)->push_back(tld);
    }
}

void MercuryTextureManager::ProcessFinalizeQueue()
{
    TextureID* tid = NULL;

    MLockPtr< MDeque<ThreadLoadData*> > finalizeQueue(m_finalizeLoadQueue, m_mtxFinalize);

    while(!finalizeQueue->empty())
    {
        tid = NULL;

        //Process things in order (very important)
        ThreadLoadData* tld = finalizeQueue->front();
        finalizeQueue->pop_front();

        if (!tld->d)
        {
            //Texture exists somewhere, find it and use it
            tid = FindTexture(tld->path);
//          TryFromExisting(tld);
//          return;
        }
        else
        {
            LOG.Log("Texture cache for " + tld->path + " not found, generating cache (finalizeQueue).");
            tid = RegisterNewTexture(tld->texture, tld->d, tld->path);
        }

        tid->m_textures.push_back(tld->texture);
        ++m_textureCount;

        PStack data;
        data.PushItemBack(PSElement((void*)tld->texture));
        data.PushItemBack(PSElement(&(tid->m_attrs)));
        MESSAGEMAN->PostSystemMessage("GetTextureID", data);

        SAFE_DELETE(tld);
    }
}


void MercuryTextureManager::Remove(MercuryTexture* texture)
{
    if (texture->GetID() <= 0)
        return;

    MDequeIterator<MercuryTexture*> i;

    TextureID* tmp = FindTexture(texture);
    if (tmp)
    {
        if(tmp->RemoveTexturePtr(texture))
            --m_textureCount;
    
        if (tmp->m_textures.empty())
        {
            MLockPtr< map<MString, TextureID*> >  textureMap(m_textureMap, m_mtxMap);
            textureMap->erase(texture->GetName());
        }
    }
}

void MercuryTextureManager::Remove(const MString& path, const MercuryTexture* texture)
{
//  if (texture->GetID() <= 0)
//      return;

    MDequeIterator<MercuryTexture*> i;

    TextureID* tmp = FindTexture(path);
    if (tmp)
    {
        if(tmp->RemoveTexturePtr(texture))
            --m_textureCount;
    
        if (tmp->m_textures.empty())
        {
            MLockPtr< map<MString, TextureID*> >  textureMap(m_textureMap, m_mtxMap);
            SAFE_DELETE(tmp);
            textureMap->erase(path);
        }
    }
}

TextureID* MercuryTextureManager::FindTexture(const MString& path) const
{
    MString name = path;

    TextureID* tID = NULL;
    MLockPtr< map<MString, TextureID*> >  textureMap(m_textureMap, m_mtxMap);
    map<MString, TextureID*>::const_iterator i = textureMap->find(name);

    if (i != textureMap->end())
        tID = (i->second);

    return tID;
}

void MercuryTextureManager::UpdateTexture(MercuryTexture* texture)
{
    TextureID* tmp = FindTexture(texture);
    if (!tmp)
    {
        LOG.Log("Texture " + texture->GetPath() + " not found, can not update.");
        return;
    }
    tmp->UpdateTextureData(texture);
}

bool MercuryTextureManager::IsTexture(const MercuryTexture* texture)
{
    if (!FindTexture(texture))
        return false;
    return true;
}

RawImageData* MercuryTextureManager::ImageLoader(const MString& path)
{
LOG.Log("about to load texture: " + path);

    if(path.length() > 7 && path.substr( 0, 7 ) == "DYNTEX:" )
    {
        MString sDiscardName;
        return LoadDyn( path, sDiscardName );
    }
    else if(path.length() > 8 && path.substr( 0, 8 ) == "CUBETEX:" )
    {
LOG.Log("WE've GOT A CUBE TEX");

        MString sDiscardName;
        return LoadCube( path, sDiscardName );

    }
    else if(path.length() > 8 && path.substr(0, 8) == "DYNCUBE:" )
    {
        MString sDiscardName;
        return LoadDynCube( path, sDiscardName );
    }
    else if(path.length() > 13 && path.substr(0, 13) == "DYNTEXSHADOW:" )
    {
LOG.Log("WE've GOT A DYN TEX SHADOW");
        MString sDiscardName;
        return LoadDynShadow( path, sDiscardName);
    }

    if (path.empty())
        return NULL;

    MercuryFile * f = FILEMAN.Open( path );
    if (!f)
    {
        LOG.Warn("Could not open " + path);
        return false;
    }

    RawImageData* raw = IMAGEREADERREGISTER.Decode( f );

    SAFE_DELETE(f);

    if( !raw )
        return NULL;

    return raw;
}

void MercuryImageReaderRegister::CheckInit()
{
    if( !bInit )
    {
        bInit = true;
        m_hDecoders = new MHash< ImageDecoder >;
    }
}

void MercuryImageReaderRegister::AddDecoder( ImageDecoder p, const char * sFingerPrint )
{
    CheckInit();
    MString sFP( sFingerPrint, 3 );
    (*m_hDecoders)[sFP] = p;
}

RawImageData * MercuryImageReaderRegister::Decode( MercuryFile * f )
{
    if( !m_hDecoders )
    {
        FAIL( "ERROR: There are no image loaders dynamically included.  Cannot operate." );
        return NULL;
    }
    char fingerprint[4];
    f->Read( fingerprint, 3 );
    MString sFP( fingerprint, 3 );

    f->Seek( 0 );
    if( m_hDecoders->get( sFP ) )
    {
        return (*m_hDecoders)[sFP](f);
    }
    else
        return NULL;
}

MercuryImageReaderRegister IMAGEREADERREGISTER;

/* 
 * Copyright (c) 2005-2006, Joshua Allen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by