netradiant-custom/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 ){
	name = StringStream( PathCleaned( token ) );
}

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 ){
		ArchiveTextFile* file = GlobalFileSystem().openTextFile( StringStream<64>( "skins/", name ) );
		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 MemberCaller1<GlobalSkins, 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 final : 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 final : 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();
}