quick/netradiant-custom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

indent classes, align by spaces

Browse Source
This commit is contained in:
Garux
2021-03-24 00:25:15 +03:00
parent 5b1b9b5e6c
commit 2222100316
450 changed files with 42485 additions and 42239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
plugins/mapxml/plugin.cpp
View File

@@ -41,45 +41,45 @@ class MapXMLDependencies :
public GlobalEntityClassManagerModuleRef,
public GlobalSceneGraphModuleRef
{
PatchModuleRef m_patchDef2Doom3Module;
PatchModuleRef m_patchDoom3Module;
PatchModuleRef m_patchDef2Doom3Module;
PatchModuleRef m_patchDoom3Module;
public:
MapXMLDependencies() :
GlobalBrushModuleRef( GlobalRadiant().getRequiredGameDescriptionKeyValue( "brushtypes" ) ),
GlobalEntityClassManagerModuleRef( GlobalRadiant().getRequiredGameDescriptionKeyValue( "entityclass" ) ),
m_patchDef2Doom3Module( "def2doom3" ),
m_patchDoom3Module( "doom3" ){
}
BrushCreator& getBrushDoom3(){
return GlobalBrushModule::getTable();
}
PatchCreator& getPatchDoom3(){
return *m_patchDoom3Module.getTable();
}
PatchCreator& getPatchDef2Doom3(){
return *m_patchDef2Doom3Module.getTable();
}
MapXMLDependencies() :
GlobalBrushModuleRef( GlobalRadiant().getRequiredGameDescriptionKeyValue( "brushtypes" ) ),
GlobalEntityClassManagerModuleRef( GlobalRadiant().getRequiredGameDescriptionKeyValue( "entityclass" ) ),
m_patchDef2Doom3Module( "def2doom3" ),
m_patchDoom3Module( "doom3" ){
}
BrushCreator& getBrushDoom3(){
return GlobalBrushModule::getTable();
}
PatchCreator& getPatchDoom3(){
return *m_patchDoom3Module.getTable();
}
PatchCreator& getPatchDef2Doom3(){
return *m_patchDef2Doom3Module.getTable();
}
};
class MapXMLAPI final : public TypeSystemRef, public MapFormat
{
public:
typedef MapFormat Type;
STRING_CONSTANT( Name, "xmldoom3" );
typedef MapFormat Type;
STRING_CONSTANT( Name, "xmldoom3" );
MapXMLAPI(){
GlobalFiletypesModule::getTable().addType( Type::Name(), Name(), filetype_t( "xml doom3 maps", "*.xmap" ) );
}
MapFormat* getTable(){
return this;
}
MapXMLAPI(){
GlobalFiletypesModule::getTable().addType( Type::Name(), Name(), filetype_t( "xml doom3 maps", "*.xmap" ) );
}
MapFormat* getTable(){
return this;
}
void readGraph( scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable ) const {
Map_Read( root, inputStream, entityTable );
}
void writeGraph( scene::Node& root, GraphTraversalFunc traverse, TextOutputStream& outputStream ) const {
Map_Write( root, traverse, outputStream );
}
void readGraph( scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable ) const {
Map_Read( root, inputStream, entityTable );
}
void writeGraph( scene::Node& root, GraphTraversalFunc traverse, TextOutputStream& outputStream ) const {
Map_Write( root, traverse, outputStream );
}
};
typedef SingletonModule<MapXMLAPI, MapXMLDependencies> MapXMLModule;

250
plugins/mapxml/xmlparse.cpp
View File

@@ -63,172 +63,172 @@ scene::Node& createPrimitive( const char* name ){
class TreeXMLImporter : public XMLImporter
{
public:
virtual TreeXMLImporter& child() = 0;
virtual TreeXMLImporter& child() = 0;
};
class SubPrimitiveImporter : public TreeXMLImporter
{
XMLImporter* m_importer;
XMLImporter* m_importer;
public:
SubPrimitiveImporter( XMLImporter* importer ) : m_importer( importer ){
}
void pushElement( const XMLElement& element ){
m_importer->pushElement( element );
}
void popElement( const char* name ){
m_importer->popElement( name );
}
std::size_t write( const char* buffer, std::size_t length ){
return m_importer->write( buffer, length );
}
SubPrimitiveImporter& child(){
return *this;
}
SubPrimitiveImporter( XMLImporter* importer ) : m_importer( importer ){
}
void pushElement( const XMLElement& element ){
m_importer->pushElement( element );
}
void popElement( const char* name ){
m_importer->popElement( name );
}
std::size_t write( const char* buffer, std::size_t length ){
return m_importer->write( buffer, length );
}
SubPrimitiveImporter& child(){
return *this;
}
};
class PrimitiveImporter : public TreeXMLImporter
{
scene::Node& m_parent;
XMLImporter* m_importer;
char m_child[sizeof( SubPrimitiveImporter )];
scene::Node& m_parent;
XMLImporter* m_importer;
char m_child[sizeof( SubPrimitiveImporter )];
SubPrimitiveImporter& subprimitive(){
return *reinterpret_cast<SubPrimitiveImporter*>( m_child );
}
SubPrimitiveImporter& subprimitive(){
return *reinterpret_cast<SubPrimitiveImporter*>( m_child );
}
public:
PrimitiveImporter( scene::Node& parent ) : m_parent( parent ), m_importer( 0 ){
}
void pushElement( const XMLElement& element ){
if ( string_equal( element.name(), "epair" ) ) {
ASSERT_MESSAGE( string_equal( element.name(), "epair" ), PARSE_ERROR );
Node_getEntity( m_parent )->setKeyValue( element.attribute( "key" ), element.attribute( "value" ) );
PrimitiveImporter( scene::Node& parent ) : m_parent( parent ), m_importer( 0 ){
}
else
{
NodeSmartReference node( createPrimitive( element.name() ) );
void pushElement( const XMLElement& element ){
if ( string_equal( element.name(), "epair" ) ) {
ASSERT_MESSAGE( string_equal( element.name(), "epair" ), PARSE_ERROR );
Node_getEntity( m_parent )->setKeyValue( element.attribute( "key" ), element.attribute( "value" ) );
}
else
{
NodeSmartReference node( createPrimitive( element.name() ) );
m_importer = Node_getXMLImporter( node );
m_importer = Node_getXMLImporter( node );
constructor( subprimitive(), m_importer );
constructor( subprimitive(), m_importer );
m_importer->pushElement( element );
m_importer->pushElement( element );
Node_getTraversable( m_parent )->insert( node );
Node_getTraversable( m_parent )->insert( node );
}
}
}
void popElement( const char* name ){
if ( string_equal( name, "epair" ) ) {
}
else
{
m_importer->popElement( name );
void popElement( const char* name ){
if ( string_equal( name, "epair" ) ) {
}
else
{
m_importer->popElement( name );
destructor( subprimitive() );
m_importer = 0;
destructor( subprimitive() );
m_importer = 0;
}
}
std::size_t write( const char* buffer, std::size_t length ){
return m_importer->write( buffer, length );
}
TreeXMLImporter& child(){
return subprimitive();
}
}
std::size_t write( const char* buffer, std::size_t length ){
return m_importer->write( buffer, length );
}
TreeXMLImporter& child(){
return subprimitive();
}
};
class EntityImporter : public TreeXMLImporter
{
scene::Node& m_parent;
char m_node[sizeof( NodeSmartReference )];
char m_child[sizeof( PrimitiveImporter )];
EntityCreator& m_entityTable;
scene::Node& m_parent;
char m_node[sizeof( NodeSmartReference )];
char m_child[sizeof( PrimitiveImporter )];
EntityCreator& m_entityTable;
NodeSmartReference& node(){
return *reinterpret_cast<NodeSmartReference*>( m_node );
}
PrimitiveImporter& primitive(){
return *reinterpret_cast<PrimitiveImporter*>( m_child );
}
NodeSmartReference& node(){
return *reinterpret_cast<NodeSmartReference*>( m_node );
}
PrimitiveImporter& primitive(){
return *reinterpret_cast<PrimitiveImporter*>( m_child );
}
public:
EntityImporter( scene::Node& parent, EntityCreator& entityTable ) : m_parent( parent ), m_entityTable( entityTable ){
}
void pushElement( const XMLElement& element ){
ASSERT_MESSAGE( string_equal( element.name(), "entity" ), PARSE_ERROR );
constructor( node(), NodeSmartReference( m_entityTable.createEntity( GlobalEntityClassManager().findOrInsert( "", true ) ) ) );
constructor( primitive(), makeReference( node().get() ) );
}
void popElement( const char* name ){
ASSERT_MESSAGE( string_equal( name, "entity" ), PARSE_ERROR );
NodeSmartReference entity( m_entityTable.createEntity( GlobalEntityClassManager().findOrInsert( Node_getEntity( node() )->getKeyValue( "classname" ), node_is_group( node() ) ) ) );
{
EntityCopyingVisitor visitor( *Node_getEntity( entity ) );
Node_getEntity( node() )->forEachKeyValue( visitor );
EntityImporter( scene::Node& parent, EntityCreator& entityTable ) : m_parent( parent ), m_entityTable( entityTable ){
}
if ( Node_getTraversable( entity ) != 0 && !Node_getEntity( entity )->getEntityClass().fixedsize ) {
parentBrushes( node(), entity );
void pushElement( const XMLElement& element ){
ASSERT_MESSAGE( string_equal( element.name(), "entity" ), PARSE_ERROR );
constructor( node(), NodeSmartReference( m_entityTable.createEntity( GlobalEntityClassManager().findOrInsert( "", true ) ) ) );
constructor( primitive(), makeReference( node().get() ) );
}
void popElement( const char* name ){
ASSERT_MESSAGE( string_equal( name, "entity" ), PARSE_ERROR );
NodeSmartReference entity( m_entityTable.createEntity( GlobalEntityClassManager().findOrInsert( Node_getEntity( node() )->getKeyValue( "classname" ), node_is_group( node() ) ) ) );
Node_getTraversable( m_parent )->insert( entity );
{
EntityCopyingVisitor visitor( *Node_getEntity( entity ) );
Node_getEntity( node() )->forEachKeyValue( visitor );
}
destructor( primitive() );
destructor( node() );
}
std::size_t write( const char* buffer, std::size_t length ){
return length;
}
TreeXMLImporter& child(){
return primitive();
}
if ( Node_getTraversable( entity ) != 0 && !Node_getEntity( entity )->getEntityClass().fixedsize ) {
parentBrushes( node(), entity );
}
Node_getTraversable( m_parent )->insert( entity );
destructor( primitive() );
destructor( node() );
}
std::size_t write( const char* buffer, std::size_t length ){
return length;
}
TreeXMLImporter& child(){
return primitive();
}
};
class MapDoom3Importer : public TreeXMLImporter
{
scene::Node& m_root;
char m_child[sizeof( EntityImporter )];
EntityCreator& m_entityTable;
scene::Node& m_root;
char m_child[sizeof( EntityImporter )];
EntityCreator& m_entityTable;
EntityImporter& getEntity(){
return *reinterpret_cast<EntityImporter*>( m_child );
}
EntityImporter& getEntity(){
return *reinterpret_cast<EntityImporter*>( m_child );
}
public:
MapDoom3Importer( scene::Node& root, EntityCreator& entityTable ) : m_root( root ), m_entityTable( entityTable ){
}
void pushElement( const XMLElement& element ){
ASSERT_MESSAGE( string_equal( element.name(), "mapdoom3" ), PARSE_ERROR );
constructor( getEntity(), makeReference( m_root ), makeReference( m_entityTable ) );
}
void popElement( const char* name ){
ASSERT_MESSAGE( string_equal( name, "mapdoom3" ), PARSE_ERROR );
destructor( getEntity() );
}
std::size_t write( const char* data, std::size_t length ){
return length;
}
TreeXMLImporter& child(){
return getEntity();
}
MapDoom3Importer( scene::Node& root, EntityCreator& entityTable ) : m_root( root ), m_entityTable( entityTable ){
}
void pushElement( const XMLElement& element ){
ASSERT_MESSAGE( string_equal( element.name(), "mapdoom3" ), PARSE_ERROR );
constructor( getEntity(), makeReference( m_root ), makeReference( m_entityTable ) );
}
void popElement( const char* name ){
ASSERT_MESSAGE( string_equal( name, "mapdoom3" ), PARSE_ERROR );
destructor( getEntity() );
}
std::size_t write( const char* data, std::size_t length ){
return length;
}
TreeXMLImporter& child(){
return getEntity();
}
};
class TreeXMLImporterStack : public XMLImporter
{
std::vector< Reference<TreeXMLImporter> > m_importers;
std::vector< Reference<TreeXMLImporter> > m_importers;
public:
TreeXMLImporterStack( TreeXMLImporter& importer ){
m_importers.push_back( makeReference( importer ) );
}
void pushElement( const XMLElement& element ){
m_importers.back().get().pushElement( element );
m_importers.push_back( makeReference( m_importers.back().get().child() ) );
}
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.end() - 2 ) ).get().write( buffer, length );
}
TreeXMLImporterStack( TreeXMLImporter& importer ){
m_importers.push_back( makeReference( importer ) );
}
void pushElement( const XMLElement& element ){
m_importers.back().get().pushElement( element );
m_importers.push_back( makeReference( m_importers.back().get().child() ) );
}
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.end() - 2 ) ).get().write( buffer, length );
}
};

48
plugins/mapxml/xmlwrite.cpp
View File

@@ -36,36 +36,36 @@ inline XMLExporter* Node_getXMLExporter( scene::Node& node ){
class write_all : public scene::Traversable::Walker
{
XMLImporter& m_importer;
XMLImporter& m_importer;
public:
write_all( XMLImporter& importer ) : m_importer( importer ){
}
bool pre( scene::Node& node ) const {
Entity* entity = Node_getEntity( node );
if ( entity != 0 ) {
m_importer.write( "\n", 1 );
StaticElement element( "entity" );
m_importer.pushElement( element );
entity_export exporter( *entity );
exporter.exportXML( m_importer );
write_all( XMLImporter& importer ) : m_importer( importer ){
}
else
{
XMLExporter* exporter = Node_getXMLExporter( node );
if ( exporter != 0 ) {
bool pre( scene::Node& node ) const {
Entity* entity = Node_getEntity( node );
if ( entity != 0 ) {
m_importer.write( "\n", 1 );
exporter->exportXML( m_importer );
StaticElement element( "entity" );
m_importer.pushElement( element );
entity_export exporter( *entity );
exporter.exportXML( m_importer );
}
else
{
XMLExporter* exporter = Node_getXMLExporter( node );
if ( exporter != 0 ) {
m_importer.write( "\n", 1 );
exporter->exportXML( m_importer );
m_importer.write( "\n", 1 );
}
}
return true;
}
void post( scene::Node& node ) const {
if ( Node_getEntity( node ) != 0 ) {
m_importer.write( "\n", 1 );
m_importer.popElement( "entity" );
}
}
return true;
}
void post( scene::Node& node ) const {
if ( Node_getEntity( node ) != 0 ) {
m_importer.write( "\n", 1 );
m_importer.popElement( "entity" );
}
}
};
void Map_Write( scene::Node& root, GraphTraversalFunc traverse, TextOutputStream& out ){