]> de.git.xonotic.org Git - xonotic/netradiant.git/blobdiff - plugins/entity/entity.cpp
Revert partially (auto) "reformat code! now the code is only ugly on the *inside*"
[xonotic/netradiant.git] / plugins / entity / entity.cpp
index 65452a7048fdb3cd1522e70dafe4ba6a33440659..dfd2a6408c4aa878cf062e357976b9aa8bd71fda 100644 (file)
 #include "doom3group.h"
 
 
+
 EGameType g_gameType;
 
-inline scene::Node &entity_for_eclass(EntityClass *eclass)
-{
-    if ((string_compare_nocase_n(eclass->name(), "misc_", 5) == 0 &&
-         string_equal_nocase(eclass->name() + string_length(eclass->name()) - 5,
-                             "model")) // misc_*model (also misc_model) // TODO make classname_* wrapper functions for this
-        || classname_equal(eclass->name(), "model_static")) {
-        return New_MiscModel(eclass);
-    } else if (classname_equal(eclass->name(), "light")
-               || classname_equal(eclass->name(), "lightJunior")) {
-        return New_Light(eclass);
-    }
-    if (!eclass->fixedsize) {
-        if (g_gameType == eGameTypeDoom3) {
-            return New_Doom3Group(eclass);
-        } else {
-            return New_Group(eclass);
-        }
-    } else if (!string_empty(eclass->modelpath())) {
-        return New_EclassModel(eclass);
-    } else {
-        return New_GenericEntity(eclass);
-    }
+inline scene::Node& entity_for_eclass( EntityClass* eclass ){
+       if ( ( string_compare_nocase_n( eclass->name(), "misc_", 5 ) == 0 && string_equal_nocase( eclass->name() + string_length( eclass->name() ) - 5, "model" ) ) // misc_*model (also misc_model) // TODO make classname_* wrapper functions for this
+                || classname_equal( eclass->name(), "model_static" ) ) {
+               return New_MiscModel( eclass );
+       }
+       else if ( classname_equal( eclass->name(), "light" )
+                         || classname_equal( eclass->name(), "lightJunior" ) ) {
+               return New_Light( eclass );
+       }
+       if ( !eclass->fixedsize ) {
+               if ( g_gameType == eGameTypeDoom3 ) {
+                       return New_Doom3Group( eclass );
+               }
+               else
+               {
+                       return New_Group( eclass );
+               }
+       }
+       else if ( !string_empty( eclass->modelpath() ) ) {
+               return New_EclassModel( eclass );
+       }
+       else
+       {
+               return New_GenericEntity( eclass );
+       }
 }
 
-void Entity_setName(Entity &entity, const char *name)
-{
-    entity.setKeyValue("name", name);
+void Entity_setName( Entity& entity, const char* name ){
+       entity.setKeyValue( "name", name );
 }
+typedef ReferenceCaller<Entity, void(const char*), Entity_setName> EntitySetNameCaller;
 
-typedef ReferenceCaller<Entity, void(const char *), Entity_setName> EntitySetNameCaller;
-
-inline Namespaced *Node_getNamespaced(scene::Node &node)
-{
-    return NodeTypeCast<Namespaced>::cast(node);
+inline Namespaced* Node_getNamespaced( scene::Node& node ){
+       return NodeTypeCast<Namespaced>::cast( node );
 }
 
-inline scene::Node &node_for_eclass(EntityClass *eclass)
-{
-    scene::Node &node = entity_for_eclass(eclass);
-    Node_getEntity(node)->setKeyValue("classname", eclass->name());
-
-    if (g_gameType == eGameTypeDoom3
-        && string_not_empty(eclass->name())
-        && !string_equal(eclass->name(), "worldspawn")
-        && !string_equal(eclass->name(), "UNKNOWN_CLASS")) {
-        char buffer[1024];
-        strcpy(buffer, eclass->name());
-        strcat(buffer, "_1");
-        GlobalNamespace().makeUnique(buffer, EntitySetNameCaller(*Node_getEntity(node)));
-    }
-
-    Namespaced *namespaced = Node_getNamespaced(node);
-    if (namespaced != 0) {
-        namespaced->setNamespace(GlobalNamespace());
-    }
-
-    return node;
+inline scene::Node& node_for_eclass( EntityClass* eclass ){
+       scene::Node& node = entity_for_eclass( eclass );
+       Node_getEntity( node )->setKeyValue( "classname", eclass->name() );
+
+       if ( g_gameType == eGameTypeDoom3
+                && string_not_empty( eclass->name() )
+                && !string_equal( eclass->name(), "worldspawn" )
+                && !string_equal( eclass->name(), "UNKNOWN_CLASS" ) ) {
+               char buffer[1024];
+               strcpy( buffer, eclass->name() );
+               strcat( buffer, "_1" );
+               GlobalNamespace().makeUnique( buffer, EntitySetNameCaller( *Node_getEntity( node ) ) );
+       }
+
+       Namespaced* namespaced = Node_getNamespaced( node );
+       if ( namespaced != 0 ) {
+               namespaced->setNamespace( GlobalNamespace() );
+       }
+
+       return node;
 }
 
 EntityCreator::KeyValueChangedFunc EntityKeyValues::m_entityKeyValueChanged = 0;
 EntityCreator::KeyValueChangedFunc KeyValue::m_entityKeyValueChanged = 0;
-Counter *EntityKeyValues::m_counter = 0;
+CounterEntityKeyValues::m_counter = 0;
 
 bool g_showNames = true;
 bool g_showAngles = true;
 bool g_newLightDraw = true;
 bool g_lightRadii = false;
 
-class ConnectEntities {
+class ConnectEntities
+{
 public:
-    Entity *m_e1;
-    Entity *m_e2;
-    int m_index;
-
-    ConnectEntities(Entity *e1, Entity *e2, int index) : m_e1(e1), m_e2(e2), m_index(index)
-    {
-    }
-
-    const char *keyname()
-    {
-        StringOutputStream key(16);
-        if (m_index <= 0) {
-            return "target";
-        }
-        if (m_index == 1) {
-            return "killtarget";
-        }
-        key << "target" << m_index;
-        return key.c_str();
-    }
-
-    void connect(const char *name)
-    {
-        m_e1->setKeyValue(keyname(), name);
-        m_e2->setKeyValue("targetname", name);
-    }
-
-    typedef MemberCaller<ConnectEntities, void(const char *), &ConnectEntities::connect> ConnectCaller;
+Entity* m_e1;
+Entity* m_e2;
+int m_index;
+ConnectEntities( Entity* e1, Entity* e2, int index ) : m_e1( e1 ), m_e2( e2 ), m_index( index ){
+}
+const char *keyname(){
+       StringOutputStream key( 16 );
+       if ( m_index <= 0 ) {
+               return "target";
+       }
+       if ( m_index == 1 ) {
+               return "killtarget";
+       }
+       key << "target" << m_index;
+       return key.c_str();
+}
+void connect( const char* name ){
+       m_e1->setKeyValue( keyname(), name );
+       m_e2->setKeyValue( "targetname", name );
+}
+typedef MemberCaller<ConnectEntities, void(const char*), &ConnectEntities::connect> ConnectCaller;
 };
 
-inline Entity *ScenePath_getEntity(const scene::Path &path)
-{
-    Entity *entity = Node_getEntity(path.top());
-    if (entity == 0) {
-        entity = Node_getEntity(path.parent());
-    }
-    return entity;
+inline Entity* ScenePath_getEntity( const scene::Path& path ){
+       Entity* entity = Node_getEntity( path.top() );
+       if ( entity == 0 ) {
+               entity = Node_getEntity( path.parent() );
+       }
+       return entity;
 }
 
-class Quake3EntityCreator : public EntityCreator {
+class Quake3EntityCreator : public EntityCreator
+{
 public:
-    scene::Node &createEntity(EntityClass *eclass)
-    {
-        return node_for_eclass(eclass);
-    }
-
-    void setKeyValueChangedFunc(KeyValueChangedFunc func)
-    {
-        EntityKeyValues::setKeyValueChangedFunc(func);
-    }
-
-    void setCounter(Counter *counter)
-    {
-        EntityKeyValues::setCounter(counter);
-    }
-
-    void connectEntities(const scene::Path &path, const scene::Path &targetPath, int index)
-    {
-        Entity *e1 = ScenePath_getEntity(path);
-        Entity *e2 = ScenePath_getEntity(targetPath);
-
-        if (e1 == 0 || e2 == 0) {
-            globalErrorStream() << "entityConnectSelected: both of the selected instances must be an entity\n";
-            return;
-        }
-
-        if (e1 == e2) {
-            globalErrorStream()
-                    << "entityConnectSelected: the selected instances must not both be from the same entity\n";
-            return;
-        }
-
-
-        UndoableCommand undo("entityConnectSelected");
-
-        if (g_gameType == eGameTypeDoom3) {
-            StringOutputStream key(16);
-            if (index >= 0) {
-                key << "target";
-                if (index != 0) {
-                    key << index;
-                }
-                e1->setKeyValue(key.c_str(), e2->getKeyValue("name"));
-                key.clear();
-            } else {
-                for (unsigned int i = 0;; ++i) {
-                    key << "target";
-                    if (i != 0) {
-                        key << i;
-                    }
-                    const char *value = e1->getKeyValue(key.c_str());
-                    if (string_empty(value)) {
-                        e1->setKeyValue(key.c_str(), e2->getKeyValue("name"));
-                        break;
-                    }
-                    key.clear();
-                }
-            }
-        } else {
-            ConnectEntities connector(e1, e2, index);
-            const char *value = e2->getKeyValue("targetname");
-            if (!string_empty(value)) {
-                connector.connect(value);
-            } else {
-                const char *type = e2->getKeyValue("classname");
-                if (string_empty(type)) {
-                    type = "t";
-                }
-                StringOutputStream key(64);
-                key << type << "1";
-                GlobalNamespace().makeUnique(key.c_str(), ConnectEntities::ConnectCaller(connector));
-            }
-        }
-
-        SceneChangeNotify();
-    }
-
-    void setLightRadii(bool lightRadii)
-    {
-        g_lightRadii = lightRadii;
-    }
-
-    bool getLightRadii() const
-    {
-        return g_lightRadii;
-    }
-
-    void setShowNames(bool showNames)
-    {
-        g_showNames = showNames;
-    }
-
-    bool getShowNames()
-    {
-        return g_showNames;
-    }
-
-    void setShowAngles(bool showAngles)
-    {
-        g_showAngles = showAngles;
-    }
-
-    bool getShowAngles()
-    {
-        return g_showAngles;
-    }
-
-    void printStatistics() const
-    {
-        StringPool_analyse(EntityKeyValues::getPool());
-    }
+scene::Node& createEntity( EntityClass* eclass ){
+       return node_for_eclass( eclass );
+}
+void setKeyValueChangedFunc( KeyValueChangedFunc func ){
+       EntityKeyValues::setKeyValueChangedFunc( func );
+}
+void setCounter( Counter* counter ){
+       EntityKeyValues::setCounter( counter );
+}
+void connectEntities( const scene::Path& path, const scene::Path& targetPath, int index ){
+       Entity* e1 = ScenePath_getEntity( path );
+       Entity* e2 = ScenePath_getEntity( targetPath );
+
+       if ( e1 == 0 || e2 == 0 ) {
+               globalErrorStream() << "entityConnectSelected: both of the selected instances must be an entity\n";
+               return;
+       }
+
+       if ( e1 == e2 ) {
+               globalErrorStream() << "entityConnectSelected: the selected instances must not both be from the same entity\n";
+               return;
+       }
+
+
+       UndoableCommand undo( "entityConnectSelected" );
+
+       if ( g_gameType == eGameTypeDoom3 ) {
+               StringOutputStream key( 16 );
+               if ( index >= 0 ) {
+                       key << "target";
+                       if ( index != 0 ) {
+                               key << index;
+                       }
+                       e1->setKeyValue( key.c_str(), e2->getKeyValue( "name" ) );
+                       key.clear();
+               }
+               else
+               {
+                       for ( unsigned int i = 0; ; ++i )
+                       {
+                               key << "target";
+                               if ( i != 0 ) {
+                                       key << i;
+                               }
+                               const char* value = e1->getKeyValue( key.c_str() );
+                               if ( string_empty( value ) ) {
+                                       e1->setKeyValue( key.c_str(), e2->getKeyValue( "name" ) );
+                                       break;
+                               }
+                               key.clear();
+                       }
+               }
+       }
+       else
+       {
+               ConnectEntities connector( e1, e2, index );
+               const char* value = e2->getKeyValue( "targetname" );
+               if ( !string_empty( value ) ) {
+                       connector.connect( value );
+               }
+               else
+               {
+                       const char* type = e2->getKeyValue( "classname" );
+                       if ( string_empty( type ) ) {
+                               type = "t";
+                       }
+                       StringOutputStream key( 64 );
+                       key << type << "1";
+                       GlobalNamespace().makeUnique( key.c_str(), ConnectEntities::ConnectCaller( connector ) );
+               }
+       }
+
+       SceneChangeNotify();
+}
+void setLightRadii( bool lightRadii ){
+       g_lightRadii = lightRadii;
+}
+bool getLightRadii() const {
+       return g_lightRadii;
+}
+void setShowNames( bool showNames ){
+       g_showNames = showNames;
+}
+bool getShowNames(){
+       return g_showNames;
+}
+void setShowAngles( bool showAngles ){
+       g_showAngles = showAngles;
+}
+bool getShowAngles(){
+       return g_showAngles;
+}
+
+void printStatistics() const {
+       StringPool_analyse( EntityKeyValues::getPool() );
+}
 };
 
 Quake3EntityCreator g_Quake3EntityCreator;
 
-EntityCreator &GetEntityCreator()
-{
-    return g_Quake3EntityCreator;
+EntityCreator& GetEntityCreator(){
+       return g_Quake3EntityCreator;
 }
 
 
-class filter_entity_classname : public EntityFilter {
-    const char *m_classname;
+
+class filter_entity_classname : public EntityFilter
+{
+const char* m_classname;
 public:
-    filter_entity_classname(const char *classname) : m_classname(classname)
-    {
-    }
-
-    bool filter(const Entity &entity) const
-    {
-        return string_equal(entity.getKeyValue("classname"), m_classname);
-    }
+filter_entity_classname( const char* classname ) : m_classname( classname ){
+}
+bool filter( const Entity& entity ) const {
+       return string_equal( entity.getKeyValue( "classname" ), m_classname );
+}
 };
 
-class filter_entity_classgroup : public EntityFilter {
-    const char *m_classgroup;
-    std::size_t m_length;
+class filter_entity_classgroup : public EntityFilter
+{
+const char* m_classgroup;
+std::size_t m_length;
 public:
-    filter_entity_classgroup(const char *classgroup) : m_classgroup(classgroup), m_length(string_length(m_classgroup))
-    {
-    }
-
-    bool filter(const Entity &entity) const
-    {
-        return string_equal_n(entity.getKeyValue("classname"), m_classgroup, m_length);
-    }
+filter_entity_classgroup( const char* classgroup ) : m_classgroup( classgroup ), m_length( string_length( m_classgroup ) ){
+}
+bool filter( const Entity& entity ) const {
+       return string_equal_n( entity.getKeyValue( "classname" ), m_classgroup, m_length );
+}
 };
 
-filter_entity_classname g_filter_entity_world("worldspawn");
-filter_entity_classname g_filter_entity_func_group("func_group");
-filter_entity_classname g_filter_entity_light("light");
-filter_entity_classname g_filter_entity_misc_model("misc_model");
-filter_entity_classname g_filter_entity_misc_gamemodel("misc_gamemodel");
-filter_entity_classgroup g_filter_entity_trigger("trigger_");
-filter_entity_classgroup g_filter_entity_path("path_");
+filter_entity_classname g_filter_entity_world( "worldspawn" );
+filter_entity_classname g_filter_entity_func_group( "func_group" );
+filter_entity_classname g_filter_entity_light( "light" );
+filter_entity_classname g_filter_entity_misc_model( "misc_model" );
+filter_entity_classname g_filter_entity_misc_gamemodel( "misc_gamemodel" );
+filter_entity_classgroup g_filter_entity_trigger( "trigger_" );
+filter_entity_classgroup g_filter_entity_path( "path_" );
 
-class filter_entity_doom3model : public EntityFilter {
+class filter_entity_doom3model : public EntityFilter
+{
 public:
-    bool filter(const Entity &entity) const
-    {
-        return string_equal(entity.getKeyValue("classname"), "func_static")
-               && !string_equal(entity.getKeyValue("model"), entity.getKeyValue("name"));
-    }
+bool filter( const Entity& entity ) const {
+       return string_equal( entity.getKeyValue( "classname" ), "func_static" )
+                  && !string_equal( entity.getKeyValue( "model" ), entity.getKeyValue( "name" ) );
+}
 };
 
 filter_entity_doom3model g_filter_entity_doom3model;
 
 
-void Entity_InitFilters()
-{
-    add_entity_filter(g_filter_entity_world, EXCLUDE_WORLD);
-    add_entity_filter(g_filter_entity_func_group, EXCLUDE_WORLD);
-    add_entity_filter(g_filter_entity_world, EXCLUDE_ENT, true);
-    add_entity_filter(g_filter_entity_trigger, EXCLUDE_TRIGGERS);
-    add_entity_filter(g_filter_entity_misc_model, EXCLUDE_MODELS);
-    add_entity_filter(g_filter_entity_misc_gamemodel, EXCLUDE_MODELS);
-    add_entity_filter(g_filter_entity_doom3model, EXCLUDE_MODELS);
-    add_entity_filter(g_filter_entity_light, EXCLUDE_LIGHTS);
-    add_entity_filter(g_filter_entity_path, EXCLUDE_PATHS);
+void Entity_InitFilters(){
+       add_entity_filter( g_filter_entity_world, EXCLUDE_WORLD );
+       add_entity_filter( g_filter_entity_func_group, EXCLUDE_WORLD );
+       add_entity_filter( g_filter_entity_world, EXCLUDE_ENT, true );
+       add_entity_filter( g_filter_entity_trigger, EXCLUDE_TRIGGERS );
+       add_entity_filter( g_filter_entity_misc_model, EXCLUDE_MODELS );
+       add_entity_filter( g_filter_entity_misc_gamemodel, EXCLUDE_MODELS );
+       add_entity_filter( g_filter_entity_doom3model, EXCLUDE_MODELS );
+       add_entity_filter( g_filter_entity_light, EXCLUDE_LIGHTS );
+       add_entity_filter( g_filter_entity_path, EXCLUDE_PATHS );
 }
 
 
 #include "preferencesystem.h"
 
-void Entity_Construct(EGameType gameType)
-{
-    g_gameType = gameType;
-    if (g_gameType == eGameTypeDoom3) {
-        g_targetable_nameKey = "name";
-
-        Static<KeyIsName>::instance().m_keyIsName = keyIsNameDoom3;
-        Static<KeyIsName>::instance().m_nameKey = "name";
-    } else {
-        Static<KeyIsName>::instance().m_keyIsName = keyIsNameQuake3;
-        Static<KeyIsName>::instance().m_nameKey = "targetname";
-    }
-
-    GlobalPreferenceSystem().registerPreference("SI_ShowNames", make_property_string(g_showNames));
-    GlobalPreferenceSystem().registerPreference("SI_ShowAngles", make_property_string(g_showAngles));
-    GlobalPreferenceSystem().registerPreference("NewLightStyle", make_property_string(g_newLightDraw));
-    GlobalPreferenceSystem().registerPreference("LightRadiuses", make_property_string(g_lightRadii));
-
-    Entity_InitFilters();
-    LightType lightType = LIGHTTYPE_DEFAULT;
-    if (g_gameType == eGameTypeRTCW) {
-        lightType = LIGHTTYPE_RTCW;
-    } else if (g_gameType == eGameTypeDoom3) {
-        lightType = LIGHTTYPE_DOOM3;
-    }
-    Light_Construct(lightType);
-    MiscModel_construct();
-    Doom3Group_construct();
-
-    RenderablePivot::StaticShader::instance() = GlobalShaderCache().capture("$PIVOT");
-
-    GlobalShaderCache().attachRenderable(StaticRenderableConnectionLines::instance());
+void Entity_Construct( EGameType gameType ){
+       g_gameType = gameType;
+       if ( g_gameType == eGameTypeDoom3 ) {
+               g_targetable_nameKey = "name";
+
+               Static<KeyIsName>::instance().m_keyIsName = keyIsNameDoom3;
+               Static<KeyIsName>::instance().m_nameKey = "name";
+       }
+       else
+       {
+               Static<KeyIsName>::instance().m_keyIsName = keyIsNameQuake3;
+               Static<KeyIsName>::instance().m_nameKey = "targetname";
+       }
+
+       GlobalPreferenceSystem().registerPreference( "SI_ShowNames", make_property_string( g_showNames ) );
+       GlobalPreferenceSystem().registerPreference( "SI_ShowAngles", make_property_string( g_showAngles ) );
+       GlobalPreferenceSystem().registerPreference( "NewLightStyle", make_property_string( g_newLightDraw ) );
+       GlobalPreferenceSystem().registerPreference( "LightRadiuses", make_property_string( g_lightRadii ) );
+
+       Entity_InitFilters();
+       LightType lightType = LIGHTTYPE_DEFAULT;
+       if ( g_gameType == eGameTypeRTCW ) {
+               lightType = LIGHTTYPE_RTCW;
+       }
+       else if ( g_gameType == eGameTypeDoom3 ) {
+               lightType = LIGHTTYPE_DOOM3;
+       }
+       Light_Construct( lightType );
+       MiscModel_construct();
+       Doom3Group_construct();
+
+       RenderablePivot::StaticShader::instance() = GlobalShaderCache().capture( "$PIVOT" );
+
+       GlobalShaderCache().attachRenderable( StaticRenderableConnectionLines::instance() );
 }
 
-void Entity_Destroy()
-{
-    GlobalShaderCache().detachRenderable(StaticRenderableConnectionLines::instance());
+void Entity_Destroy(){
+       GlobalShaderCache().detachRenderable( StaticRenderableConnectionLines::instance() );
 
-    GlobalShaderCache().release("$PIVOT");
+       GlobalShaderCache().release( "$PIVOT" );
 
-    Doom3Group_destroy();
-    MiscModel_destroy();
-    Light_Destroy();
+       Doom3Group_destroy();
+       MiscModel_destroy();
+       Light_Destroy();
 }