worldspawn/plugins/entity/skincache.cpp

/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant 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
   (at your option) any later version.

   GtkRadiant 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 GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "skincache.h"

#include "ifilesystem.h"
#include "iscriplib.h"
#include "iarchive.h"
#include "modelskin.h"

#include <map>

#include "stream/stringstream.h"
#include "generic/callback.h"
#include "container/cache.h"
#include "container/hashfunc.h"
#include "os/path.h"
#include "moduleobservers.h"
#include "modulesystem/singletonmodule.h"
#include "stringio.h"

void parseShaderName(CopiedString &name, const char *token)
{
    StringOutputStream cleaned(256);
    cleaned << PathCleaned(token);
    name = cleaned.c_str();
}

class Doom3ModelSkin {
    typedef std::map<CopiedString, CopiedString> Remaps;
    Remaps m_remaps;
public:
    bool parseTokens(Tokeniser &tokeniser)
    {
        RETURN_FALSE_IF_FAIL(Tokeniser_parseToken(tokeniser, "{"));
        tokeniser.nextLine();
        for (;;) {
            const char *token = tokeniser.getToken();
            if (token == 0) {
                return false;
            }
            if (string_equal(token, "}")) {
                tokeniser.nextLine();
                return true;
            } else if (string_equal(token, "model")) {
                //const char* model =
                tokeniser.getToken();
            } else {
                CopiedString from, to;
                parseShaderName(from, token);

                tokeniser.nextLine(); // hack to handle badly formed skins

                parseShaderName(to, tokeniser.getToken());

                if (!string_equal(from.c_str(), to.c_str())) {
                    m_remaps.insert(Remaps::value_type(from, to));
                }
            }
            tokeniser.nextLine();
        }
    }

    const char *getRemap(const char *name) const
    {
        Remaps::const_iterator i = m_remaps.find(name);
        if (i != m_remaps.end()) {
            return (*i).second.c_str();
        }
        return "";
    }

    void forEachRemap(const SkinRemapCallback &callback) const
    {
        for (Remaps::const_iterator i = m_remaps.begin(); i != m_remaps.end(); ++i) {
            callback(SkinRemap((*i).first.c_str(), (*i).second.c_str()));
        }
    }
};

class GlobalSkins {
public:
    typedef std::map<CopiedString, Doom3ModelSkin> SkinMap;
    SkinMap m_skins;
    Doom3ModelSkin g_nullSkin;

    Doom3ModelSkin &getSkin(const char *name)
    {
        SkinMap::iterator i = m_skins.find(name);
        if (i != m_skins.end()) {
            return (*i).second;
        }

        return g_nullSkin;
    }

    bool parseTokens(Tokeniser &tokeniser)
    {
        tokeniser.nextLine();
        for (;;) {
            const char *token = tokeniser.getToken();
            if (token == 0) {
                // end of token stream
                return true;
            }
            if (!string_equal(token, "skin")) {
                Tokeniser_unexpectedError(tokeniser, token, "skin");
                return false;
            }
            const char *other = tokeniser.getToken();
            if (other == 0) {
                Tokeniser_unexpectedError(tokeniser, token, "#string");
                return false;
            }
            CopiedString name;
            parseShaderName(name, other);
            Doom3ModelSkin &skin = m_skins[name];
            RETURN_FALSE_IF_FAIL(skin.parseTokens(tokeniser));
        }
    }

    void parseFile(const char *name)
    {
        StringOutputStream relativeName(64);
        relativeName << "skins/" << name;
        ArchiveTextFile *file = GlobalFileSystem().openTextFile(relativeName.c_str());
        if (file != 0) {
            globalOutputStream() << "parsing skins from " << makeQuoted(name) << "\n";
            {
                Tokeniser &tokeniser = GlobalScriptLibrary().m_pfnNewSimpleTokeniser(file->getInputStream());
                parseTokens(tokeniser);
                tokeniser.release();
            }
            file->release();
        } else {
            globalErrorStream() << "failed to open " << makeQuoted(name) << "\n";
        }
    }

    typedef MemberCaller<GlobalSkins, void(const char *), &GlobalSkins::parseFile> ParseFileCaller;

    void construct()
    {
        GlobalFileSystem().forEachFile("skins/", "skin", ParseFileCaller(*this));
    }

    void destroy()
    {
        m_skins.clear();
    }

    void realise()
    {
        construct();
    }

    void unrealise()
    {
        destroy();
    }
};

GlobalSkins g_skins;


class Doom3ModelSkinCacheElement : public ModelSkin {
    ModuleObservers m_observers;
    Doom3ModelSkin *m_skin;
public:
    Doom3ModelSkinCacheElement() : m_skin(0)
    {
    }

    void attach(ModuleObserver &observer)
    {
        m_observers.attach(observer);
        if (realised()) {
            observer.realise();
        }
    }

    void detach(ModuleObserver &observer)
    {
        if (realised()) {
            observer.unrealise();
        }
        m_observers.detach(observer);
    }

    bool realised() const
    {
        return m_skin != 0;
    }

    void realise(const char *name)
    {
        ASSERT_MESSAGE(!realised(), "Doom3ModelSkinCacheElement::realise: already realised");
        m_skin = &g_skins.getSkin(name);
        m_observers.realise();
    }

    void unrealise()
    {
        ASSERT_MESSAGE(realised(), "Doom3ModelSkinCacheElement::unrealise: not realised");
        m_observers.unrealise();
        m_skin = 0;
    }

    const char *getRemap(const char *name) const
    {
        ASSERT_MESSAGE(realised(), "Doom3ModelSkinCacheElement::getRemap: not realised");
        return m_skin->getRemap(name);
    }

    void forEachRemap(const SkinRemapCallback &callback) const
    {
        ASSERT_MESSAGE(realised(), "Doom3ModelSkinCacheElement::forEachRemap: not realised");
        m_skin->forEachRemap(callback);
    }
};

class Doom3ModelSkinCache : public ModelSkinCache, public ModuleObserver {
    class CreateDoom3ModelSkin {
        Doom3ModelSkinCache &m_cache;
    public:
        explicit CreateDoom3ModelSkin(Doom3ModelSkinCache &cache)
                : m_cache(cache)
        {
        }

        Doom3ModelSkinCacheElement *construct(const CopiedString &name)
        {
            Doom3ModelSkinCacheElement *skin = new Doom3ModelSkinCacheElement;
            if (m_cache.realised()) {
                skin->realise(name.c_str());
            }
            return skin;
        }

        void destroy(Doom3ModelSkinCacheElement *skin)
        {
            if (m_cache.realised()) {
                skin->unrealise();
            }
            delete skin;
        }
    };

    typedef HashedCache<CopiedString, Doom3ModelSkinCacheElement, HashString, std::equal_to<CopiedString>, CreateDoom3ModelSkin> Cache;
    Cache m_cache;
    bool m_realised;

public:
    typedef ModelSkinCache Type;

    STRING_CONSTANT(Name, "*");

    ModelSkinCache *getTable()
    {
        return this;
    }

    Doom3ModelSkinCache() : m_cache(CreateDoom3ModelSkin(*this)), m_realised(false)
    {
        GlobalFileSystem().attach(*this);
    }

    ~Doom3ModelSkinCache()
    {
        GlobalFileSystem().detach(*this);
    }

    ModelSkin &capture(const char *name)
    {
        return *m_cache.capture(name);
    }

    void release(const char *name)
    {
        m_cache.release(name);
    }

    bool realised() const
    {
        return m_realised;
    }

    void realise()
    {
        g_skins.realise();
        m_realised = true;
        for (Cache::iterator i = m_cache.begin(); i != m_cache.end(); ++i) {
            (*i).value->realise((*i).key.c_str());
        }
    }

    void unrealise()
    {
        m_realised = false;
        for (Cache::iterator i = m_cache.begin(); i != m_cache.end(); ++i) {
            (*i).value->unrealise();
        }
        g_skins.unrealise();
    }
};

class Doom3ModelSkinCacheDependencies : public GlobalFileSystemModuleRef, public GlobalScripLibModuleRef {
};

typedef SingletonModule<Doom3ModelSkinCache, Doom3ModelSkinCacheDependencies> Doom3ModelSkinCacheModule;

Doom3ModelSkinCacheModule g_Doom3ModelSkinCacheModule;

void Doom3ModelSkinCacheModule_selfRegister(ModuleServer &server)
{
    g_Doom3ModelSkinCacheModule.selfRegister();
}