gtkradiant/radiant/eclass_xml.cpp

611 lines
16 KiB
C++
Raw Normal View History

/*
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
*/
///\file
///\brief EntityClass plugin that supports the .ent xml entity-definition format.
///
/// the .ent xml format expresses entity-definitions.
///
/// <!-- defines an entity which cannot have brushes grouped with it -->
/// <point name="[name of entity type]" colour="[RGB floating-point colour shown in editor]"
/// box="[minXYZ maxXYZ floating point bounding-box]" model="[model path]">
/// <!-- attribute definitions go here -->
/// </point>
///
/// <!-- defines an entity which can have brushes grouped with it -->
/// <group name="[name of entity type]" colour="[RGB floating-point colour shown in editor]">
/// <!-- attribute definitions go here -->
/// </group>
///
///
/// the attributes of an entity type are defined like this:
///
/// <[name of attribute type]
/// key="[entity key name]"
/// name="[name shown in gui]"
/// value="[default entity key value]"
/// >[comment text shown in gui]</[name of attribute type]>
///
/// each attribute type has a specialised attribute-editor GUI
///
/// currently-supported attribute types:
///
/// string a string
/// array an array of strings - value is a semi-colon-delimited string
/// integer an integer value
/// boolean an integer - shows as a checkbox - true = non-zero
/// integer2 two integer values
/// integer3 three integer values
/// real3 three floating-point values
/// angle specialisation of real - Yaw angle
/// direction specialisation of real - Yaw angle, -1 = down, -2 = up
/// angles specialisation of real3 - Pitch Yaw Roll
/// color specialisation of real3 - RGB floating-point colour
/// target a string that uniquely identifies an entity or group of entities
/// targetname a string that uniquely identifies an entity or group of entities
/// sound the VFS path to a sound file
/// texture the VFS path to a texture file or a shader name
/// model the VFS path to a model file
/// skin the VFS path to a skin file
///
///
/// flag attributes define a flag in the "spawnflags" key:
///
/// <flag
/// key="[flag name]"
/// name="[name shown in gui]"
/// bit="[bit-index in spawnflags]"
/// >[comment text shown in gui]<flag>
///
/// the default value for a flag bit is always 0.
///
///
/// List attributes have a set of valid values.
/// Create new list attribute types like this:
///
/// <list name="[name of list attribute type]">
/// <item name="[first name shown in menu]" value="[entity key value]"/>
/// <item name="[second name shown in menu]" value="[entity key value]"/>
/// </list>
///
/// these can then be used as attribute types.
///
///
/// An attribute definition should specify a default value that corresponds
/// with the default value given by the game. If the default value is not
/// specified in the attribute definition, it is assumed to be an empty string.
///
/// If the currently-selected entity in Radiant does not specify a value for
/// the key of an attribute, the default value from the attribute-definition
/// will be displayed in the attribute-editor and used when visualising the
/// entity in the preview windows. E.g. the Doom3 "light" entity has a
/// "light_radius" key. Light entities without a "light_radius" key are
/// displayed in Doom3 with a radius of 300. The default value for the
/// "light_radius" attribute definition should be specified as "300 300 300".
///
#include "eclass_xml.h"
#include "ieclass.h"
#include "irender.h"
#include "ifilesystem.h"
#include "iarchive.h"
#include "xml/xmlparser.h"
#include "generic/object.h"
#include "generic/reference.h"
#include "stream/stringstream.h"
#include "stream/textfilestream.h"
#include "os/path.h"
#include "eclasslib.h"
#include "modulesystem/moduleregistry.h"
#include "stringio.h"
#define PARSE_ERROR(elementName, name) makeQuoted(elementName) << " is not a valid child of " << makeQuoted(name)
class IgnoreBreaks
{
public:
const char* m_first;
const char* m_last;
IgnoreBreaks(const char* first, const char* last) : m_first(first), m_last(last)
{
}
};
template<typename TextOutputStreamType>
TextOutputStreamType& ostream_write(TextOutputStreamType& ostream, const IgnoreBreaks& ignoreBreaks)
{
for(const char* i = ignoreBreaks.m_first; i != ignoreBreaks.m_last; ++i)
{
if(*i != '\n')
{
ostream << *i;
}
}
return ostream;
}
namespace
{
class TreeXMLImporter : public TextOutputStream
{
public:
virtual TreeXMLImporter& pushElement(const XMLElement& element) = 0;
virtual void popElement(const char* name) = 0;
};
template<typename Type>
class Storage
{
char m_storage[sizeof(Type)];
public:
Type& get()
{
return *reinterpret_cast<Type*>(m_storage);
}
const Type& get() const
{
return *reinterpret_cast<const Type*>(m_storage);
}
};
class BreakImporter : public TreeXMLImporter
{
public:
BreakImporter(StringOutputStream& comment)
{
comment << '\n';
}
static const char* name()
{
return "n";
}
TreeXMLImporter& pushElement(const XMLElement& element)
{
ERROR_MESSAGE(PARSE_ERROR(element.name(), name()));
return *this;
}
void popElement(const char* elementName)
{
ERROR_MESSAGE(PARSE_ERROR(elementName, name()));
}
std::size_t write(const char* data, std::size_t length)
{
return length;
}
};
class AttributeImporter : public TreeXMLImporter
{
StringOutputStream& m_comment;
public:
AttributeImporter(StringOutputStream& comment, EntityClass* entityClass, const XMLElement& element) : m_comment(comment)
{
const char* type = element.name();
const char* key = element.attribute("key");
const char* name = element.attribute("name");
const char* value = element.attribute("value");
ASSERT_MESSAGE(!string_empty(key), "key attribute not specified");
ASSERT_MESSAGE(!string_empty(name), "name attribute not specified");
if(string_equal(type, "flag"))
{
std::size_t bit = atoi(element.attribute("bit"));
ASSERT_MESSAGE(bit < MAX_FLAGS, "invalid flag bit");
ASSERT_MESSAGE(string_empty(entityClass->flagnames[bit]), "non-unique flag bit");
strcpy(entityClass->flagnames[bit], key);
}
m_comment << key;
m_comment << " : ";
EntityClass_insertAttribute(*entityClass, key, EntityClassAttribute(type, name, value));
}
~AttributeImporter()
{
}
TreeXMLImporter& pushElement(const XMLElement& element)
{
ERROR_MESSAGE(PARSE_ERROR(element.name(), "attribute"));
return *this;
}
void popElement(const char* elementName)
{
ERROR_MESSAGE(PARSE_ERROR(elementName, "attribute"));
}
std::size_t write(const char* data, std::size_t length)
{
return m_comment.write(data, length);
}
};
bool attributeSupported(const char* name)
{
return string_equal(name, "real")
|| string_equal(name, "integer")
|| string_equal(name, "boolean")
|| string_equal(name, "string")
|| string_equal(name, "array")
|| string_equal(name, "flag")
|| string_equal(name, "real3")
|| string_equal(name, "integer3")
|| string_equal(name, "direction")
|| string_equal(name, "angle")
|| string_equal(name, "angles")
|| string_equal(name, "color")
|| string_equal(name, "target")
|| string_equal(name, "targetname")
|| string_equal(name, "sound")
|| string_equal(name, "texture")
|| string_equal(name, "model")
|| string_equal(name, "skin")
|| string_equal(name, "integer2");
}
typedef std::map<CopiedString, ListAttributeType> ListAttributeTypes;
bool listAttributeSupported(ListAttributeTypes& listTypes, const char* name)
{
return listTypes.find(name) != listTypes.end();
}
class ClassImporter : public TreeXMLImporter
{
EntityClassCollector& m_collector;
EntityClass* m_eclass;
StringOutputStream m_comment;
Storage<AttributeImporter> m_attribute;
ListAttributeTypes& m_listTypes;
public:
ClassImporter(EntityClassCollector& collector, ListAttributeTypes& listTypes, const XMLElement& element) : m_collector(collector), m_listTypes(listTypes)
{
m_eclass = Eclass_Alloc();
m_eclass->free = &Eclass_Free;
const char* name = element.attribute("name");
ASSERT_MESSAGE(!string_empty(name), "name attribute not specified for class");
m_eclass->m_name = name;
const char* color = element.attribute("color");
ASSERT_MESSAGE(!string_empty(name), "color attribute not specified for class " << name);
string_parse_vector3(color, m_eclass->color);
eclass_capture_state(m_eclass);
const char* model = element.attribute("model");
if(!string_empty(model))
{
StringOutputStream buffer(256);
buffer << PathCleaned(model);
m_eclass->m_modelpath = buffer.c_str();
}
const char* type = element.name();
if(string_equal(type, "point"))
{
const char* box = element.attribute("box");
ASSERT_MESSAGE(!string_empty(box), "box attribute not found for class " << name);
m_eclass->fixedsize = true;
string_parse_vector(box, &m_eclass->mins.x(), &m_eclass->mins.x() + 6);
}
}
~ClassImporter()
{
m_eclass->m_comments = m_comment.c_str();
m_collector.insert(m_eclass);
for(ListAttributeTypes::iterator i = m_listTypes.begin(); i != m_listTypes.end(); ++i)
{
m_collector.insert((*i).first.c_str(), (*i).second);
}
}
static const char* name()
{
return "class";
}
TreeXMLImporter& pushElement(const XMLElement& element)
{
if(attributeSupported(element.name()) || listAttributeSupported(m_listTypes, element.name()))
{
constructor(m_attribute.get(), makeReference(m_comment), m_eclass, element);
return m_attribute.get();
}
else
{
ERROR_MESSAGE(PARSE_ERROR(element.name(), name()));
return *this;
}
}
void popElement(const char* elementName)
{
if(attributeSupported(elementName) || listAttributeSupported(m_listTypes, elementName))
{
destructor(m_attribute.get());
}
else
{
ERROR_MESSAGE(PARSE_ERROR(elementName, name()));
}
}
std::size_t write(const char* data, std::size_t length)
{
return m_comment.write(data, length);
}
};
class ItemImporter : public TreeXMLImporter
{
public:
ItemImporter(ListAttributeType& list, const XMLElement& element)
{
const char* name = element.attribute("name");
const char* value = element.attribute("value");
list.push_back(name, value);
}
TreeXMLImporter& pushElement(const XMLElement& element)
{
ERROR_MESSAGE(PARSE_ERROR(element.name(), "item"));
return *this;
}
void popElement(const char* elementName)
{
ERROR_MESSAGE(PARSE_ERROR(elementName, "item"));
}
std::size_t write(const char* data, std::size_t length)
{
return length;
}
};
bool isItem(const char* name)
{
return string_equal(name, "item");
}
class ListAttributeImporter : public TreeXMLImporter
{
ListAttributeType* m_listType;
Storage<ItemImporter> m_item;
public:
ListAttributeImporter(ListAttributeTypes& listTypes, const XMLElement& element)
{
const char* name = element.attribute("name");
m_listType = &listTypes[name];
}
TreeXMLImporter& pushElement(const XMLElement& element)
{
if(isItem(element.name()))
{
constructor(m_item.get(), makeReference(*m_listType), element);
return m_item.get();
}
else
{
ERROR_MESSAGE(PARSE_ERROR(element.name(), "list"));
return *this;
}
}
void popElement(const char* elementName)
{
if(isItem(elementName))
{
destructor(m_item.get());
}
else
{
ERROR_MESSAGE(PARSE_ERROR(elementName, "list"));
}
}
std::size_t write(const char* data, std::size_t length)
{
return length;
}
};
bool classSupported(const char* name)
{
return string_equal(name, "group")
|| string_equal(name, "point");
}
bool listSupported(const char* name)
{
return string_equal(name, "list");
}
class ClassesImporter : public TreeXMLImporter
{
EntityClassCollector& m_collector;
Storage<ClassImporter> m_class;
Storage<ListAttributeImporter> m_list;
ListAttributeTypes m_listTypes;
public:
ClassesImporter(EntityClassCollector& collector) : m_collector(collector)
{
}
static const char* name()
{
return "classes";
}
TreeXMLImporter& pushElement(const XMLElement& element)
{
if(classSupported(element.name()))
{
constructor(m_class.get(), makeReference(m_collector), makeReference(m_listTypes), element);
return m_class.get();
}
else if(listSupported(element.name()))
{
constructor(m_list.get(), makeReference(m_listTypes), element);
return m_list.get();
}
else
{
ERROR_MESSAGE(PARSE_ERROR(element.name(), name()));
return *this;
}
}
void popElement(const char* elementName)
{
if(classSupported(elementName))
{
destructor(m_class.get());
}
else if(listSupported(elementName))
{
destructor(m_list.get());
}
else
{
ERROR_MESSAGE(PARSE_ERROR(elementName, name()));
}
}
std::size_t write(const char* data, std::size_t length)
{
return length;
}
};
class EclassXMLImporter : public TreeXMLImporter
{
EntityClassCollector& m_collector;
Storage<ClassesImporter> m_classes;
public:
EclassXMLImporter(EntityClassCollector& collector) : m_collector(collector)
{
}
static const char* name()
{
return "classes";
}
TreeXMLImporter& pushElement(const XMLElement& element)
{
if(string_equal(element.name(), ClassesImporter::name()))
{
constructor(m_classes.get(), makeReference(m_collector));
return m_classes.get();
}
else
{
ERROR_MESSAGE(PARSE_ERROR(element.name(), name()));
return *this;
}
}
void popElement(const char* elementName)
{
if(string_equal(elementName, ClassesImporter::name()))
{
destructor(m_classes.get());
}
else
{
ERROR_MESSAGE(PARSE_ERROR(elementName, name()));
}
}
std::size_t write(const char* data, std::size_t length)
{
return length;
}
};
class TreeXMLImporterStack : public XMLImporter
{
std::vector< Reference<TreeXMLImporter> > m_importers;
public:
TreeXMLImporterStack(TreeXMLImporter& importer)
{
m_importers.push_back(makeReference(importer));
}
void pushElement(const XMLElement& element)
{
m_importers.push_back(makeReference(m_importers.back().get().pushElement(element)));
}
void popElement(const char* name)
{
m_importers.pop_back();
m_importers.back().get().popElement(name);
}
std::size_t write(const char* buffer, std::size_t length)
{
return m_importers.back().get().write(buffer, length);
}
};
const char* GetExtension()
{
return "ent";
}
void ScanFile(EntityClassCollector& collector, const char *filename)
{
TextFileInputStream inputFile(filename);
if(!inputFile.failed())
{
XMLStreamParser parser(inputFile);
EclassXMLImporter importer(collector);
TreeXMLImporterStack stack(importer);
parser.exportXML(stack);
}
}
}
#include "modulesystem/singletonmodule.h"
class EntityClassXMLDependencies : public GlobalFileSystemModuleRef, public GlobalShaderCacheModuleRef
{
};
class EclassXMLAPI
{
EntityClassScanner m_eclassxml;
public:
typedef EntityClassScanner Type;
STRING_CONSTANT(Name, "xml");
EclassXMLAPI()
{
m_eclassxml.scanFile = &ScanFile;
m_eclassxml.getExtension = &GetExtension;
}
EntityClassScanner* getTable()
{
return &m_eclassxml;
}
};
typedef SingletonModule<EclassXMLAPI, EntityClassXMLDependencies> EclassXMLModule;
typedef Static<EclassXMLModule> StaticEclassXMLModule;
StaticRegisterModule staticRegisterEclassXML(StaticEclassXMLModule::instance());