worldspawn/src/eclass_doom3.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 "eclass_doom3.h"

#include "debugging/debugging.h"

#include <map>

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

#include "generic/callback.h"
#include "string/string.h"
#include "eclasslib.h"
#include "os/path.h"
#include "os/dir.h"
#include "stream/stringstream.h"
#include "moduleobservers.h"
#include "stringio.h"

class RawString {
const char *m_value;
public:
RawString(const char *value) : m_value(value)
{
}

const char *c_str() const
{
	return m_value;
}
};

inline bool operator<(const RawString &self, const RawString &other)
{
	return string_less_nocase(self.c_str(), other.c_str());
}

typedef std::map<RawString, EntityClass *> EntityClasses;
EntityClasses g_EntityClassDoom3_classes;
EntityClass *g_EntityClassDoom3_bad = 0;


void EntityClassDoom3_clear()
{
	for (EntityClasses::iterator i = g_EntityClassDoom3_classes.begin(); i != g_EntityClassDoom3_classes.end(); ++i) {
		(*i).second->free((*i).second);
	}
	g_EntityClassDoom3_classes.clear();
}

// entityClass will be inserted only if another of the same name does not already exist.
// if entityClass was inserted, the same object is returned, otherwise the already-existing object is returned.
EntityClass *EntityClassDoom3_insertUnique(EntityClass *entityClass)
{
	return (*g_EntityClassDoom3_classes.insert(
			EntityClasses::value_type(entityClass->name(), entityClass)).first).second;
}

void EntityClassDoom3_forEach(EntityClassVisitor &visitor)
{
	for (EntityClasses::iterator i = g_EntityClassDoom3_classes.begin(); i != g_EntityClassDoom3_classes.end(); ++i) {
		visitor.visit((*i).second);
	}
}

inline void printParseError(const char *message)
{
	globalErrorStream() << message;
}

#define PARSE_RETURN_FALSE_IF_FAIL(expression) do { if (!( expression)) { printParseError(FILE_LINE "\nparse failed: " #expression "\n"); return false; } } while (0)

bool EntityClassDoom3_parseToken(Tokeniser &tokeniser)
{
	const char *token = tokeniser.getToken();
	PARSE_RETURN_FALSE_IF_FAIL(token != 0);
	return true;
}

bool EntityClassDoom3_parseToken(Tokeniser &tokeniser, const char *string)
{
	const char *token = tokeniser.getToken();
	PARSE_RETURN_FALSE_IF_FAIL(token != 0);
	return string_equal(token, string);
}

bool EntityClassDoom3_parseString(Tokeniser &tokeniser, const char *&s)
{
	const char *token = tokeniser.getToken();
	PARSE_RETURN_FALSE_IF_FAIL(token != 0);
	s = token;
	return true;
}

bool EntityClassDoom3_parseString(Tokeniser &tokeniser, CopiedString &s)
{
	const char *token = tokeniser.getToken();
	PARSE_RETURN_FALSE_IF_FAIL(token != 0);
	s = token;
	return true;
}

bool EntityClassDoom3_parseString(Tokeniser &tokeniser, StringOutputStream &s)
{
	const char *token = tokeniser.getToken();
	PARSE_RETURN_FALSE_IF_FAIL(token != 0);
	s << token;
	return true;
}

bool EntityClassDoom3_parseUnknown(Tokeniser &tokeniser)
{
	//const char* name =
	PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));

	//globalOutputStream() << "parsing unknown block " << makeQuoted(name) << "\n";

	PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, "{"));
	tokeniser.nextLine();

	std::size_t depth = 1;
	for (;;) {
		const char *token;
		PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, token));
		if (string_equal(token, "}")) {
			if (--depth == 0) {
				tokeniser.nextLine();
				break;
			}
		} else if (string_equal(token, "{")) {
			++depth;
		}
		tokeniser.nextLine();
	}
	return true;
}


class Model {
public:
bool m_resolved;
CopiedString m_mesh;
CopiedString m_skin;
CopiedString m_parent;
typedef std::map<CopiedString, CopiedString> Anims;
Anims m_anims;

Model() : m_resolved(false)
{
}
};

typedef std::map<CopiedString, Model> Models;

Models g_models;

void Model_resolveInheritance(const char *name, Model &model)
{
	if (model.m_resolved == false) {
		model.m_resolved = true;

		if (!string_empty(model.m_parent.c_str())) {
			Models::iterator i = g_models.find(model.m_parent);
			if (i == g_models.end()) {
				globalErrorStream() << "model " << name << " inherits unknown model " << model.m_parent.c_str() << "\n";
			} else {
				Model_resolveInheritance((*i).first.c_str(), (*i).second);
				model.m_mesh = (*i).second.m_mesh;
				model.m_skin = (*i).second.m_skin;
			}
		}
	}
}

bool EntityClassDoom3_parseModel(Tokeniser &tokeniser)
{
	const char *name;
	PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, name));

	Model &model = g_models[name];

	PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, "{"));
	tokeniser.nextLine();

	for (;;) {
		const char *parameter;
		PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, parameter));
		if (string_equal(parameter, "}")) {
			tokeniser.nextLine();
			break;
		} else if (string_equal(parameter, "inherit")) {
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, model.m_parent));
			tokeniser.nextLine();
		} else if (string_equal(parameter, "remove")) {
			//const char* remove =
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
			tokeniser.nextLine();
		} else if (string_equal(parameter, "mesh")) {
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, model.m_mesh));
			tokeniser.nextLine();
		} else if (string_equal(parameter, "skin")) {
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, model.m_skin));
			tokeniser.nextLine();
		} else if (string_equal(parameter, "offset")) {
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, "("));
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, ")"));
			tokeniser.nextLine();
		} else if (string_equal(parameter, "channel")) {
			//const char* channelName =
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, "("));
			for (;;) {
				const char *end;
				PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, end));
				if (string_equal(end, ")")) {
					tokeniser.nextLine();
					break;
				}
			}
		} else if (string_equal(parameter, "anim")) {
			CopiedString animName;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, animName));
			const char *animFile;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, animFile));
			model.m_anims.insert(Model::Anims::value_type(animName, animFile));

			const char *token;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, token));

			while (string_equal(token, ",")) {
				PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, animFile));
				PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, token));
			}

			if (string_equal(token, "{")) {
				for (;;) {
					const char *end;
					PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, end));
					if (string_equal(end, "}")) {
						tokeniser.nextLine();
						break;
					}
					tokeniser.nextLine();
				}
			} else {
				tokeniser.ungetToken();
			}
		} else {
			globalErrorStream() << "unknown model parameter: " << makeQuoted(parameter) << "\n";
			return false;
		}
		tokeniser.nextLine();
	}
	return true;
}

inline bool char_isSpaceOrTab(char c)
{
	return c == ' ' || c == '\t';
}

inline bool char_isNotSpaceOrTab(char c)
{
	return !char_isSpaceOrTab(c);
}

template<typename Predicate>
inline const char *string_find_if(const char *string, Predicate predicate)
{
	for (; *string != 0; ++string) {
		if (predicate(*string)) {
			return string;
		}
	}
	return string;
}

inline const char *string_findFirstSpaceOrTab(const char *string)
{
	return string_find_if(string, char_isSpaceOrTab);
}

inline const char *string_findFirstNonSpaceOrTab(const char *string)
{
	return string_find_if(string, char_isNotSpaceOrTab);
}


static bool EntityClass_parse(EntityClass &entityClass, Tokeniser &tokeniser)
{
	PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, entityClass.m_name));

	PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, "{"));
	tokeniser.nextLine();

	StringOutputStream usage(256);
	StringOutputStream description(256);
	CopiedString *currentDescription = 0;
	StringOutputStream *currentString = 0;

	for (;;) {
		const char *key;
		PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, key));

		const char *last = string_findFirstSpaceOrTab(key);
		CopiedString first(StringRange(key, last));

		if (!string_empty(last)) {
			last = string_findFirstNonSpaceOrTab(last);
		}

		if (currentString != 0 && string_equal(key, "\\")) {
			tokeniser.nextLine();
			*currentString << " ";
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, *currentString));
			continue;
		}

		if (currentDescription != 0) {
			*currentDescription = description.c_str();
			description.clear();
			currentDescription = 0;
		}
		currentString = 0;

		if (string_equal(key, "}")) {
			tokeniser.nextLine();
			break;
		} else if (string_equal(key, "model")) {
			const char *token;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, token));
			entityClass.fixedsize = true;
			StringOutputStream buffer(256);
			buffer << PathCleaned(token);
			entityClass.m_modelpath = buffer.c_str();
		} else if (string_equal(key, "editor_color")) {
			const char *value;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, value));
			if (!string_empty(value)) {
				entityClass.colorSpecified = true;
				bool success = string_parse_vector3(value, entityClass.color);
				ASSERT_MESSAGE(success, "editor_color: parse error");
			}
		} else if (string_equal(key, "editor_ragdoll")) {
			//bool ragdoll = atoi(tokeniser.getToken()) != 0;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
		} else if (string_equal(key, "editor_mins")) {
			entityClass.sizeSpecified = true;
			const char *value;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, value));
			if (!string_empty(value) && !string_equal(value, "?")) {
				entityClass.fixedsize = true;
				bool success = string_parse_vector3(value, entityClass.mins);
				ASSERT_MESSAGE(success, "editor_mins: parse error");
			}
		} else if (string_equal(key, "editor_maxs")) {
			entityClass.sizeSpecified = true;
			const char *value;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, value));
			if (!string_empty(value) && !string_equal(value, "?")) {
				entityClass.fixedsize = true;
				bool success = string_parse_vector3(value, entityClass.maxs);
				ASSERT_MESSAGE(success, "editor_maxs: parse error");
			}
		} else if (string_equal(key, "editor_usage")) {
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, usage));
			currentString = &usage;
		} else if (string_equal_n(key, "editor_usage", 12)) {
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, usage));
			currentString = &usage;
		} else if (string_equal(key, "editor_rotatable")
		           || string_equal(key, "editor_showangle")
		           || string_equal(key, "editor_showangles") // typo? in prey movables.def
		           || string_equal(key, "editor_mover")
		           || string_equal(key, "editor_model")
		           || string_equal(key, "editor_material")
		           || string_equal(key, "editor_combatnode")
		           || (!string_empty(last) && string_equal(first.c_str(), "editor_gui"))
		           || string_equal_n(key, "editor_copy", 11)) {
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
		} else if (!string_empty(last) &&
		           (string_equal(first.c_str(), "editor_var") || string_equal(first.c_str(), "editor_string"))) {
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
			attribute.m_type = "string";
			currentDescription = &attribute.m_description;
			currentString = &description;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
		} else if (!string_empty(last) && string_equal(first.c_str(), "editor_float")) {
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
			attribute.m_type = "string";
			currentDescription = &attribute.m_description;
			currentString = &description;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
		} else if (!string_empty(last) && string_equal(first.c_str(), "editor_snd")) {
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
			attribute.m_type = "sound";
			currentDescription = &attribute.m_description;
			currentString = &description;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
		} else if (!string_empty(last) && string_equal(first.c_str(), "editor_bool")) {
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
			attribute.m_type = "boolean";
			currentDescription = &attribute.m_description;
			currentString = &description;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
		} else if (!string_empty(last) && string_equal(first.c_str(), "editor_int")) {
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
			attribute.m_type = "integer";
			currentDescription = &attribute.m_description;
			currentString = &description;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
		} else if (!string_empty(last) && string_equal(first.c_str(), "editor_model")) {
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
			attribute.m_type = "model";
			currentDescription = &attribute.m_description;
			currentString = &description;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
		} else if (!string_empty(last) && string_equal(first.c_str(), "editor_color")) {
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
			attribute.m_type = "color";
			currentDescription = &attribute.m_description;
			currentString = &description;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
		} else if (!string_empty(last) &&
		           (string_equal(first.c_str(), "editor_material") || string_equal(first.c_str(), "editor_mat"))) {
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
			attribute.m_type = "shader";
			currentDescription = &attribute.m_description;
			currentString = &description;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
		} else if (string_equal(key, "inherit")) {
			entityClass.inheritanceResolved = false;
			ASSERT_MESSAGE(entityClass.m_parent.empty(), "only one 'inherit' supported per entityDef");
			const char *token;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, token));
			entityClass.m_parent.push_back(token);
		}
		// begin quake4-specific keys
		else if (string_equal(key, "editor_targetonsel")) {
			//const char* value =
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
		} else if (string_equal(key, "editor_menu")) {
			//const char* value =
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
		} else if (string_equal(key, "editor_ignore")) {
			//const char* value =
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
		}
		// end quake4-specific keys
		// begin ignore prey (unknown/unused?) entity keys
		else if (string_equal(key, "editor_light")
		         || string_equal(key, "editor_def def_debrisspawner")
		         || string_equal(key, "editor_def def_drop")
		         || string_equal(key, "editor_def def_guihand")
		         || string_equal(key, "editor_def def_mine")) {
			//const char* value =
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
		}
		// end ignore prey entity keys
		else {
			CopiedString tmp(key);
			if (string_equal_n(key, "editor_", 7)) {
				globalErrorStream() << "unsupported editor key " << makeQuoted(key);
			}
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, key).second;
			attribute.m_type = "string";
			const char *value;
			PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, value));
			if (string_equal(value, "}")) { // hack for quake4 powerups.def bug
				globalErrorStream() << "entityDef " << makeQuoted(entityClass.m_name.c_str()) << " key "
				                    << makeQuoted(tmp.c_str()) << " has no value\n";
				break;
			} else {
				attribute.m_value = value;
			}
		}
		tokeniser.nextLine();
	}

	entityClass.m_comments = usage.c_str();

	if (string_equal(entityClass.m_name.c_str(), "light")) {
		{
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "light_radius").second;
			attribute.m_type = "vector3";
			attribute.m_value = "300 300 300";
		}
		{
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "light_center").second;
			attribute.m_type = "vector3";
		}
		{
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "noshadows").second;
			attribute.m_type = "boolean";
			attribute.m_value = "0";
		}
		{
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "nospecular").second;
			attribute.m_type = "boolean";
			attribute.m_value = "0";
		}
		{
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "nodiffuse").second;
			attribute.m_type = "boolean";
			attribute.m_value = "0";
		}
		{
			EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "falloff").second;
			attribute.m_type = "real";
		}
	}

	return true;
}

bool EntityClassDoom3_parseEntityDef(Tokeniser &tokeniser)
{
	EntityClass *entityClass = Eclass_Alloc();
	entityClass->free = &Eclass_Free;

	if (!EntityClass_parse(*entityClass, tokeniser)) {
		eclass_capture_state(entityClass); // finish constructing the entity so that it can be destroyed cleanly.
		entityClass->free(entityClass);
		return false;
	}

	EntityClass *inserted = EntityClassDoom3_insertUnique(entityClass);
	if (inserted != entityClass) {
		globalErrorStream() << "entityDef " << entityClass->name()
		                    << " is already defined, second definition ignored\n";
		eclass_capture_state(entityClass); // finish constructing the entity so that it can be destroyed cleanly.
		entityClass->free(entityClass);
	}
	return true;
}

bool EntityClassDoom3_parseBlock(Tokeniser &tokeniser, const char *blockType)
{
	if (string_equal(blockType, "entityDef")) {
		return EntityClassDoom3_parseEntityDef(tokeniser);
	} else if (string_equal(blockType, "model")) {
		return EntityClassDoom3_parseModel(tokeniser);
	} else {
		return EntityClassDoom3_parseUnknown(tokeniser);
	}
}

bool EntityClassDoom3_parse(TextInputStream &inputStream, const char *filename)
{
	Tokeniser &tokeniser = GlobalScriptLibrary().m_pfnNewScriptTokeniser(inputStream);

	tokeniser.nextLine();

	for (;;) {
		const char *blockType = tokeniser.getToken();
		if (blockType == 0) {
			return true;
		}
		CopiedString tmp(blockType);
		if (!EntityClassDoom3_parseBlock(tokeniser, tmp.c_str())) {
			globalErrorStream() << GlobalFileSystem().findFile(filename) << filename << ":"
			                    << (unsigned int) tokeniser.getLine() << ": " << tmp.c_str()
			                    << " parse failed, skipping rest of file\n";
			return false;
		}
	}

	tokeniser.release();
}


void EntityClassDoom3_loadFile(const char *filename)
{
	globalOutputStream() << "parsing entity classes from " << makeQuoted(filename) << "\n";

	StringOutputStream fullname(256);
	fullname << "def/" << filename;

	ArchiveTextFile *file = GlobalFileSystem().openTextFile(fullname.c_str());
	if (file != 0) {
		EntityClassDoom3_parse(file->getInputStream(), fullname.c_str());
		file->release();
	}
}

EntityClass *EntityClassDoom3_findOrInsert(const char *name, bool has_brushes)
{
	ASSERT_NOTNULL(name);

	if (string_empty(name)) {
		return g_EntityClassDoom3_bad;
	}

	EntityClasses::iterator i = g_EntityClassDoom3_classes.find(name);
	if (i != g_EntityClassDoom3_classes.end()
	    //&& string_equal((*i).first, name)
	    ) {
		return (*i).second;
	}

	EntityClass *e = EntityClass_Create_Default(name, has_brushes);
	EntityClass *inserted = EntityClassDoom3_insertUnique(e);
	ASSERT_MESSAGE(inserted == e, "");
	return inserted;
}

const ListAttributeType *EntityClassDoom3_findListType(const char *name)
{
	return 0;
}


void EntityClass_resolveInheritance(EntityClass *derivedClass)
{
	if (derivedClass->inheritanceResolved == false) {
		derivedClass->inheritanceResolved = true;
		EntityClasses::iterator i = g_EntityClassDoom3_classes.find(derivedClass->m_parent.front().c_str());
		if (i == g_EntityClassDoom3_classes.end()) {
			globalErrorStream() << "failed to find entityDef " << makeQuoted(derivedClass->m_parent.front().c_str())
			                    << " inherited by " << makeQuoted(derivedClass->m_name.c_str()) << "\n";
		} else {
			EntityClass *parentClass = (*i).second;
			EntityClass_resolveInheritance(parentClass);
			if (!derivedClass->colorSpecified) {
				derivedClass->colorSpecified = parentClass->colorSpecified;
				derivedClass->color = parentClass->color;
			}
			if (!derivedClass->sizeSpecified) {
				derivedClass->sizeSpecified = parentClass->sizeSpecified;
				derivedClass->mins = parentClass->mins;
				derivedClass->maxs = parentClass->maxs;
				derivedClass->fixedsize = parentClass->fixedsize;
			}

			for (EntityClassAttributes::iterator j = parentClass->m_attributes.begin();
			     j != parentClass->m_attributes.end(); ++j) {
				EntityClass_insertAttribute(*derivedClass, (*j).first.c_str(), (*j).second);
			}
		}
	}
}

class EntityClassDoom3 : public ModuleObserver {
std::size_t m_unrealised;
ModuleObservers m_observers;
public:
EntityClassDoom3() : m_unrealised(2)
{
}

void realise()
{
	if (--m_unrealised == 0) {
		globalOutputStream() << "searching vfs directory " << makeQuoted("def") << " for *.def\n";
		GlobalFileSystem().forEachFile("def/", "def", makeCallbackF(EntityClassDoom3_loadFile));

		{
			for (Models::iterator i = g_models.begin(); i != g_models.end(); ++i) {
				Model_resolveInheritance((*i).first.c_str(), (*i).second);
			}
		}
		{
			for (EntityClasses::iterator i = g_EntityClassDoom3_classes.begin();
			     i != g_EntityClassDoom3_classes.end(); ++i) {
				EntityClass_resolveInheritance((*i).second);
				if (!string_empty((*i).second->m_modelpath.c_str())) {
					Models::iterator j = g_models.find((*i).second->m_modelpath);
					if (j != g_models.end()) {
						(*i).second->m_modelpath = (*j).second.m_mesh;
						(*i).second->m_skin = (*j).second.m_skin;
					}
				}
				eclass_capture_state((*i).second);

				StringOutputStream usage(256);

				usage << "-------- NOTES --------\n";

				if (!string_empty((*i).second->m_comments.c_str())) {
					usage << (*i).second->m_comments.c_str() << "\n";
				}

				usage << "\n-------- KEYS --------\n";

				for (EntityClassAttributes::iterator j = (*i).second->m_attributes.begin();
				     j != (*i).second->m_attributes.end(); ++j) {
					const char *name = EntityClassAttributePair_getName(*j);
					const char *description = EntityClassAttributePair_getDescription(*j);
					if (!string_equal(name, description)) {
						usage << EntityClassAttributePair_getName(*j) << " : "
						      << EntityClassAttributePair_getDescription(*j) << "\n";
					}
				}

				(*i).second->m_comments = usage.c_str();
			}
		}

		m_observers.realise();
	}
}

void unrealise()
{
	if (++m_unrealised == 1) {
		m_observers.unrealise();
		EntityClassDoom3_clear();
	}
}

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

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

EntityClassDoom3 g_EntityClassDoom3;

void EntityClassDoom3_attach(ModuleObserver &observer)
{
	g_EntityClassDoom3.attach(observer);
}

void EntityClassDoom3_detach(ModuleObserver &observer)
{
	g_EntityClassDoom3.detach(observer);
}

void EntityClassDoom3_realise()
{
	g_EntityClassDoom3.realise();
}

void EntityClassDoom3_unrealise()
{
	g_EntityClassDoom3.unrealise();
}

void EntityClassDoom3_construct()
{
	GlobalFileSystem().attach(g_EntityClassDoom3);

	// start by creating the default unknown eclass
	g_EntityClassDoom3_bad = EClass_Create("UNKNOWN_CLASS", Vector3(0.0f, 0.5f, 0.0f), "");

	EntityClassDoom3_realise();
}

void EntityClassDoom3_destroy()
{
	EntityClassDoom3_unrealise();

	g_EntityClassDoom3_bad->free(g_EntityClassDoom3_bad);

	GlobalFileSystem().detach(g_EntityClassDoom3);
}

class EntityClassDoom3Dependencies : public GlobalFileSystemModuleRef, public GlobalShaderCacheModuleRef {
};

class EntityClassDoom3API {
EntityClassManager m_eclassmanager;
public:
typedef EntityClassManager Type;

STRING_CONSTANT(Name, "doom3");

EntityClassDoom3API()
{
	EntityClassDoom3_construct();

	m_eclassmanager.findOrInsert = &EntityClassDoom3_findOrInsert;
	m_eclassmanager.findListType = &EntityClassDoom3_findListType;
	m_eclassmanager.forEach = &EntityClassDoom3_forEach;
	m_eclassmanager.attach = &EntityClassDoom3_attach;
	m_eclassmanager.detach = &EntityClassDoom3_detach;
	m_eclassmanager.realise = &EntityClassDoom3_realise;
	m_eclassmanager.unrealise = &EntityClassDoom3_unrealise;
}

~EntityClassDoom3API()
{
	EntityClassDoom3_destroy();
}

EntityClassManager *getTable()
{
	return &m_eclassmanager;
}
};

#include "modulesystem/singletonmodule.h"
#include "modulesystem/moduleregistry.h"

typedef SingletonModule<EntityClassDoom3API, EntityClassDoom3Dependencies> EntityClassDoom3Module;
typedef Static<EntityClassDoom3Module> StaticEntityClassDoom3Module;
StaticRegisterModule staticRegisterEntityClassDoom3(StaticEntityClassDoom3Module::instance());