X-Git-Url: https://de.git.xonotic.org/?p=xonotic%2Fnetradiant.git;a=blobdiff_plain;f=radiant%2Fmap.cpp;h=a5ac53f899e63e2a27e863482a12091851efd4ce;hp=d83f42cdbc512d0385680934214122b5a97d393f;hb=HEAD;hpb=c750e332cb2e6eb13a779db83d1123d3c1de698e diff --git a/radiant/map.cpp b/radiant/map.cpp index d83f42cd..c783e035 100644 --- a/radiant/map.cpp +++ b/radiant/map.cpp @@ -27,7 +27,7 @@ #include "imap.h" -MapModules &ReferenceAPI_getMapModules(); +MapModules& ReferenceAPI_getMapModules(); #include "iselection.h" #include "iundo.h" @@ -86,358 +86,332 @@ MapModules &ReferenceAPI_getMapModules(); #include "autosave.h" #include "brushmodule.h" #include "brush.h" +#include "patch.h" bool g_writeMapComments = true; -class NameObserver { - UniqueNames &m_names; - CopiedString m_name; +class NameObserver +{ +UniqueNames& m_names; +CopiedString m_name; - void construct() - { - if (!empty()) { - //globalOutputStream() << "construct " << makeQuoted(c_str()) << "\n"; - m_names.insert(name_read(c_str())); - } - } +void construct(){ + if ( !empty() ) { + //globalOutputStream() << "construct " << makeQuoted(c_str()) << "\n"; + m_names.insert( name_read( c_str() ) ); + } +} - void destroy() - { - if (!empty()) { - //globalOutputStream() << "destroy " << makeQuoted(c_str()) << "\n"; - m_names.erase(name_read(c_str())); - } - } +void destroy(){ + if ( !empty() ) { + //globalOutputStream() << "destroy " << makeQuoted(c_str()) << "\n"; + m_names.erase( name_read( c_str() ) ); + } +} - NameObserver &operator=(const NameObserver &other); +NameObserver& operator=( const NameObserver& other ); public: - NameObserver(UniqueNames &names) : m_names(names) - { - construct(); - } - - NameObserver(const NameObserver &other) : m_names(other.m_names), m_name(other.m_name) - { - construct(); - } - - ~NameObserver() - { - destroy(); - } - - bool empty() const - { - return string_empty(c_str()); - } - - const char *c_str() const - { - return m_name.c_str(); - } - - void nameChanged(const char *name) - { - destroy(); - m_name = name; - construct(); - } - - typedef MemberCaller NameChangedCaller; +NameObserver( UniqueNames& names ) : m_names( names ){ + construct(); +} +NameObserver( const NameObserver& other ) : m_names( other.m_names ), m_name( other.m_name ){ + construct(); +} + +~NameObserver(){ + destroy(); +} + +bool empty() const { + return string_empty( c_str() ); +} + +const char* c_str() const { + return m_name.c_str(); +} + +void nameChanged( const char* name ){ + destroy(); + m_name = name; + construct(); +} + +typedef MemberCaller NameChangedCaller; }; -class BasicNamespace : public Namespace { - typedef std::map Names; - Names m_names; - UniqueNames m_uniqueNames; +class BasicNamespace : public Namespace +{ +typedef std::map Names; +Names m_names; +UniqueNames m_uniqueNames; public: - ~BasicNamespace() - { - ASSERT_MESSAGE(m_names.empty(), "namespace: names still registered at shutdown"); - } - - void attach(const NameCallback &setName, const NameCallbackCallback &attachObserver) - { - std::pair result = m_names.insert(Names::value_type(setName, m_uniqueNames)); - ASSERT_MESSAGE(result.second, "cannot attach name"); - attachObserver(NameObserver::NameChangedCaller((*result.first).second)); - //globalOutputStream() << "attach: " << reinterpret_cast(setName) << "\n"; - } - - void detach(const NameCallback &setName, const NameCallbackCallback &detachObserver) - { - Names::iterator i = m_names.find(setName); - ASSERT_MESSAGE(i != m_names.end(), "cannot detach name"); - //globalOutputStream() << "detach: " << reinterpret_cast(setName) << "\n"; - detachObserver(NameObserver::NameChangedCaller((*i).second)); - m_names.erase(i); - } - - void makeUnique(const char *name, const NameCallback &setName) const - { - char buffer[1024]; - name_write(buffer, m_uniqueNames.make_unique(name_read(name))); - setName(buffer); - } - - void mergeNames(const BasicNamespace &other) const - { - typedef std::list SetNameCallbacks; - typedef std::map NameGroups; - NameGroups groups; - - UniqueNames uniqueNames(other.m_uniqueNames); - - for (Names::const_iterator i = m_names.begin(); i != m_names.end(); ++i) { - groups[(*i).second.c_str()].push_back((*i).first); - } - - for (NameGroups::iterator i = groups.begin(); i != groups.end(); ++i) { - name_t uniqueName(uniqueNames.make_unique(name_read((*i).first.c_str()))); - uniqueNames.insert(uniqueName); - - char buffer[1024]; - name_write(buffer, uniqueName); - - //globalOutputStream() << "renaming " << makeQuoted((*i).first.c_str()) << " to " << makeQuoted(buffer) << "\n"; - - SetNameCallbacks &setNameCallbacks = (*i).second; - - for (SetNameCallbacks::const_iterator j = setNameCallbacks.begin(); j != setNameCallbacks.end(); ++j) { - (*j)(buffer); - } - } - } +~BasicNamespace(){ + ASSERT_MESSAGE( m_names.empty(), "namespace: names still registered at shutdown" ); +} + +void attach( const NameCallback& setName, const NameCallbackCallback& attachObserver ){ + std::pair result = m_names.insert( Names::value_type( setName, m_uniqueNames ) ); + ASSERT_MESSAGE( result.second, "cannot attach name" ); + attachObserver( NameObserver::NameChangedCaller( ( *result.first ).second ) ); + //globalOutputStream() << "attach: " << reinterpret_cast(setName) << "\n"; +} + +void detach( const NameCallback& setName, const NameCallbackCallback& detachObserver ){ + Names::iterator i = m_names.find( setName ); + ASSERT_MESSAGE( i != m_names.end(), "cannot detach name" ); + //globalOutputStream() << "detach: " << reinterpret_cast(setName) << "\n"; + detachObserver( NameObserver::NameChangedCaller( ( *i ).second ) ); + m_names.erase( i ); +} + +void makeUnique( const char* name, const NameCallback& setName ) const { + char buffer[1024]; + name_write( buffer, m_uniqueNames.make_unique( name_read( name ) ) ); + setName( buffer ); +} + +void mergeNames( const BasicNamespace& other ) const { + typedef std::list SetNameCallbacks; + typedef std::map NameGroups; + NameGroups groups; + + UniqueNames uniqueNames( other.m_uniqueNames ); + + for ( Names::const_iterator i = m_names.begin(); i != m_names.end(); ++i ) + { + groups[( *i ).second.c_str()].push_back( ( *i ).first ); + } + + for ( NameGroups::iterator i = groups.begin(); i != groups.end(); ++i ) + { + name_t uniqueName( uniqueNames.make_unique( name_read( ( *i ).first.c_str() ) ) ); + uniqueNames.insert( uniqueName ); + + char buffer[1024]; + name_write( buffer, uniqueName ); + + //globalOutputStream() << "renaming " << makeQuoted((*i).first.c_str()) << " to " << makeQuoted(buffer) << "\n"; + + SetNameCallbacks& setNameCallbacks = ( *i ).second; + + for ( SetNameCallbacks::const_iterator j = setNameCallbacks.begin(); j != setNameCallbacks.end(); ++j ) + { + ( *j )( buffer ); + } + } +} }; BasicNamespace g_defaultNamespace; BasicNamespace g_cloneNamespace; -class NamespaceAPI { - Namespace *m_namespace; +class NamespaceAPI +{ +Namespace* m_namespace; public: - typedef Namespace Type; +typedef Namespace Type; - STRING_CONSTANT(Name, "*"); +STRING_CONSTANT( Name, "*" ); - NamespaceAPI() - { - m_namespace = &g_defaultNamespace; - } +NamespaceAPI(){ + m_namespace = &g_defaultNamespace; +} - Namespace *getTable() - { - return m_namespace; - } +Namespace* getTable(){ + return m_namespace; +} }; typedef SingletonModule NamespaceModule; typedef Static StaticNamespaceModule; -StaticRegisterModule staticRegisterDefaultNamespace(StaticNamespaceModule::instance()); +StaticRegisterModule staticRegisterDefaultNamespace( StaticNamespaceModule::instance() ); -std::list g_cloned; +std::list g_cloned; -inline Namespaced *Node_getNamespaced(scene::Node &node) -{ - return NodeTypeCast::cast(node); +inline Namespaced* Node_getNamespaced( scene::Node& node ){ + return NodeTypeCast::cast( node ); } -void Node_gatherNamespaced(scene::Node &node) -{ - Namespaced *namespaced = Node_getNamespaced(node); - if (namespaced != 0) { - g_cloned.push_back(namespaced); - } +void Node_gatherNamespaced( scene::Node& node ){ + Namespaced* namespaced = Node_getNamespaced( node ); + if ( namespaced != 0 ) { + g_cloned.push_back( namespaced ); + } } -class GatherNamespaced : public scene::Traversable::Walker { +class GatherNamespaced : public scene::Traversable::Walker +{ public: - bool pre(scene::Node &node) const - { - Node_gatherNamespaced(node); - return true; - } +bool pre( scene::Node& node ) const { + Node_gatherNamespaced( node ); + return true; +} }; -void Map_gatherNamespaced(scene::Node &root) -{ - Node_traverseSubgraph(root, GatherNamespaced()); +void Map_gatherNamespaced( scene::Node& root ){ + Node_traverseSubgraph( root, GatherNamespaced() ); } -void Map_mergeClonedNames() -{ - for (std::list::const_iterator i = g_cloned.begin(); i != g_cloned.end(); ++i) { - (*i)->setNamespace(g_cloneNamespace); - } - g_cloneNamespace.mergeNames(g_defaultNamespace); - for (std::list::const_iterator i = g_cloned.begin(); i != g_cloned.end(); ++i) { - (*i)->setNamespace(g_defaultNamespace); - } +void Map_mergeClonedNames(){ + for ( std::list::const_iterator i = g_cloned.begin(); i != g_cloned.end(); ++i ) + { + ( *i )->setNamespace( g_cloneNamespace ); + } + g_cloneNamespace.mergeNames( g_defaultNamespace ); + for ( std::list::const_iterator i = g_cloned.begin(); i != g_cloned.end(); ++i ) + { + ( *i )->setNamespace( g_defaultNamespace ); + } - g_cloned.clear(); + g_cloned.clear(); } -class WorldNode { - scene::Node *m_node; +class WorldNode +{ +scene::Node* m_node; public: - WorldNode() - : m_node(0) - { - } - - void set(scene::Node *node) - { - if (m_node != 0) { - m_node->DecRef(); - } - m_node = node; - if (m_node != 0) { - m_node->IncRef(); - } - } - - scene::Node *get() const - { - return m_node; - } +WorldNode() + : m_node( 0 ){ +} + +void set( scene::Node* node ){ + if ( m_node != 0 ) { + m_node->DecRef(); + } + m_node = node; + if ( m_node != 0 ) { + m_node->IncRef(); + } +} + +scene::Node* get() const { + return m_node; +} }; class Map; +void Map_SetValid( Map& map, bool valid ); -void Map_SetValid(Map &map, bool valid); - -void Map_UpdateTitle(const Map &map); +void Map_UpdateTitle( const Map& map ); -void Map_SetWorldspawn(Map &map, scene::Node *node); +void Map_SetWorldspawn( Map& map, scene::Node* node ); -class Map : public ModuleObserver { +class Map : public ModuleObserver +{ public: - CopiedString m_name; - Resource *m_resource; - bool m_valid; +CopiedString m_name; +Resource* m_resource; +bool m_valid; - bool m_modified; +bool m_modified; - void ( *m_modified_changed )(const Map &); +void ( *m_modified_changed )( const Map& ); - Signal0 m_mapValidCallbacks; +Signal0 m_mapValidCallbacks; - WorldNode m_world_node; // "classname" "worldspawn" ! +WorldNode m_world_node; // "classname" "worldspawn" ! - Map() : m_resource(0), m_valid(false), m_modified_changed(Map_UpdateTitle) - { - } +Map() : m_resource( 0 ), m_valid( false ), m_modified_changed( Map_UpdateTitle ){ +} - void realise() - { - if (m_resource != 0) { - if (Map_Unnamed(*this)) { - g_map.m_resource->setNode(NewMapRoot("").get_pointer()); - MapFile *map = Node_getMapFile(*g_map.m_resource->getNode()); - if (map != 0) { - map->save(); - } - } else { - m_resource->load(); - } +void realise(){ + if ( m_resource != 0 ) { + if ( Map_Unnamed( *this ) ) { + g_map.m_resource->setNode( NewMapRoot( "" ).get_pointer() ); + MapFile* map = Node_getMapFile( *g_map.m_resource->getNode() ); + if ( map != 0 ) { + map->save(); + } + } + else + { + m_resource->load(); + } - GlobalSceneGraph().insert_root(*m_resource->getNode()); + GlobalSceneGraph().insert_root( *m_resource->getNode() ); - AutoSave_clear(); + AutoSave_clear(); - Map_SetValid(g_map, true); - } - } + Map_SetValid( g_map, true ); + } +} - void unrealise() - { - if (m_resource != 0) { - Map_SetValid(g_map, false); - Map_SetWorldspawn(g_map, 0); +void unrealise(){ + if ( m_resource != 0 ) { + Map_SetValid( g_map, false ); + Map_SetWorldspawn( g_map, 0 ); - GlobalUndoSystem().clear(); + GlobalUndoSystem().clear(); - GlobalSceneGraph().erase_root(); - } - } + GlobalSceneGraph().erase_root(); + } +} }; Map g_map; -Map *g_currentMap = 0; +Map* g_currentMap = 0; -void Map_addValidCallback(Map &map, const SignalHandler &handler) -{ - map.m_mapValidCallbacks.connectLast(handler); +void Map_addValidCallback( Map& map, const SignalHandler& handler ){ + map.m_mapValidCallbacks.connectLast( handler ); } -bool Map_Valid(const Map &map) -{ - return map.m_valid; +bool Map_Valid( const Map& map ){ + return map.m_valid; } -void Map_SetValid(Map &map, bool valid) -{ - map.m_valid = valid; - map.m_mapValidCallbacks(); +void Map_SetValid( Map& map, bool valid ){ + map.m_valid = valid; + map.m_mapValidCallbacks(); } -const char *Map_Name(const Map &map) -{ - return map.m_name.c_str(); +const char* Map_Name( const Map& map ){ + return map.m_name.c_str(); } -bool Map_Unnamed(const Map &map) -{ - return string_equal(Map_Name(map), "unnamed.map"); +bool Map_Unnamed( const Map& map ){ + return string_equal( Map_Name( map ), "unnamed.map" ); } -inline const MapFormat &MapFormat_forFile(const char *filename) -{ - const char *moduleName = findModuleName(GetFileTypeRegistry(), MapFormat::Name(), path_get_extension(filename)); - MapFormat *format = Radiant_getMapModules().findModule(moduleName); - ASSERT_MESSAGE(format != 0, "map format not found for file " << makeQuoted(filename)); - return *format; +inline const MapFormat& MapFormat_forFile( const char* filename ){ + const char* moduleName = findModuleName( GetFileTypeRegistry(), MapFormat::Name(), path_get_extension( filename ) ); + MapFormat* format = Radiant_getMapModules().findModule( moduleName ); + ASSERT_MESSAGE( format != 0, "map format not found for file " << makeQuoted( filename ) ); + return *format; } -const MapFormat &Map_getFormat(const Map &map) -{ - return MapFormat_forFile(Map_Name(map)); +const MapFormat& Map_getFormat( const Map& map ){ + return MapFormat_forFile( Map_Name( map ) ); } -bool Map_Modified(const Map &map) -{ - return map.m_modified; +bool Map_Modified( const Map& map ){ + return map.m_modified; } -void Map_SetModified(Map &map, bool modified) -{ - if (map.m_modified ^ modified) { - map.m_modified = modified; +void Map_SetModified( Map& map, bool modified ){ + if ( map.m_modified ^ modified ) { + map.m_modified = modified; - map.m_modified_changed(map); - } + map.m_modified_changed( map ); + } } -void Map_UpdateTitle(const Map &map) -{ - Sys_SetTitle(map.m_name.c_str(), Map_Modified(map)); +void Map_UpdateTitle( const Map& map ){ + Sys_SetTitle( map.m_name.c_str(), Map_Modified( map ) ); } -scene::Node *Map_GetWorldspawn(const Map &map) -{ - return map.m_world_node.get(); +scene::Node* Map_GetWorldspawn( const Map& map ){ + return map.m_world_node.get(); } -void Map_SetWorldspawn(Map &map, scene::Node *node) -{ - map.m_world_node.set(node); +void Map_SetWorldspawn( Map& map, scene::Node* node ){ + map.m_world_node.set( node ); } @@ -446,9 +420,9 @@ void Map_SetWorldspawn(Map &map, scene::Node *node) float g_MaxWorldCoord = 64 * 1024; float g_MinWorldCoord = -64 * 1024; -void AddRegionBrushes(void); +void AddRegionBrushes( void ); -void RemoveRegionBrushes(void); +void RemoveRegionBrushes( void ); /* @@ -457,68 +431,65 @@ void RemoveRegionBrushes(void); free all map elements, reinitialize the structures that depend on them ================ */ -void Map_Free() -{ - Pointfile_Clear(); +void Map_Free(){ + Pointfile_Clear(); - g_map.m_resource->detach(g_map); - GlobalReferenceCache().release(g_map.m_name.c_str()); - g_map.m_resource = 0; + g_map.m_resource->detach( g_map ); + GlobalReferenceCache().release( g_map.m_name.c_str() ); + g_map.m_resource = 0; - FlushReferences(); + FlushReferences(); - g_currentMap = 0; - Brush_unlatchPreferences(); + g_currentMap = 0; + Brush_unlatchPreferences(); } -class EntityFindByClassname : public scene::Graph::Walker { - const char *m_name; - Entity *&m_entity; +class EntityFindByClassname : public scene::Graph::Walker +{ +const char* m_name; +Entity*& m_entity; public: - EntityFindByClassname(const char *name, Entity *&entity) : m_name(name), m_entity(entity) - { - m_entity = 0; - } - - bool pre(const scene::Path &path, scene::Instance &instance) const - { - if (m_entity == 0) { - Entity *entity = Node_getEntity(path.top()); - if (entity != 0 - && string_equal(m_name, entity->getKeyValue("classname"))) { - m_entity = entity; - } - } - return true; - } -}; +EntityFindByClassname( const char* name, Entity*& entity ) : m_name( name ), m_entity( entity ){ + m_entity = 0; +} -Entity *Scene_FindEntityByClass(const char *name) -{ - Entity *entity; - GlobalSceneGraph().traverse(EntityFindByClassname(name, entity)); - return entity; +bool pre( const scene::Path& path, scene::Instance& instance ) const { + if ( m_entity == 0 ) { + Entity* entity = Node_getEntity( path.top() ); + if ( entity != 0 + && string_equal( m_name, entity->getKeyValue( "classname" ) ) ) { + m_entity = entity; + } + } + return true; } +}; -Entity *Scene_FindPlayerStart() -{ - typedef const char *StaticString; - StaticString strings[] = { - "info_player_start", - "info_player_deathmatch", - "team_CTF_redplayer", - "team_CTF_blueplayer", - "team_CTF_redspawn", - "team_CTF_bluespawn", - }; - typedef const StaticString *StaticStringIterator; - for (StaticStringIterator i = strings, end = strings + (sizeof(strings) / sizeof(StaticString)); i != end; ++i) { - Entity *entity = Scene_FindEntityByClass(*i); - if (entity != 0) { - return entity; - } - } - return 0; +Entity* Scene_FindEntityByClass( const char* name ){ + Entity* entity; + GlobalSceneGraph().traverse( EntityFindByClassname( name, entity ) ); + return entity; +} + +Entity *Scene_FindPlayerStart(){ + typedef const char* StaticString; + StaticString strings[] = { + "info_player_start", + "info_player_deathmatch", + "team_CTF_redplayer", + "team_CTF_blueplayer", + "team_CTF_redspawn", + "team_CTF_bluespawn", + }; + typedef const StaticString* StaticStringIterator; + for ( StaticStringIterator i = strings, end = strings + ( sizeof( strings ) / sizeof( StaticString ) ); i != end; ++i ) + { + Entity* entity = Scene_FindEntityByClass( *i ); + if ( entity != 0 ) { + return entity; + } + } + return 0; } // @@ -526,469 +497,616 @@ Entity *Scene_FindPlayerStart() // -void FocusViews(const Vector3 &point, float angle) -{ - CamWnd &camwnd = *g_pParentWnd->GetCamWnd(); - Camera_setOrigin(camwnd, point); - Vector3 angles(Camera_getAngles(camwnd)); - angles[CAMERA_PITCH] = 0; - angles[CAMERA_YAW] = angle; - Camera_setAngles(camwnd, angles); +void FocusViews( const Vector3& point, float angle ){ + CamWnd& camwnd = *g_pParentWnd->GetCamWnd(); + Camera_setOrigin( camwnd, point ); + Vector3 angles( Camera_getAngles( camwnd ) ); + angles[CAMERA_PITCH] = 0; + angles[CAMERA_YAW] = angle; + Camera_setAngles( camwnd, angles ); - XYWnd *xywnd = g_pParentWnd->GetXYWnd(); - xywnd->SetOrigin(point); + XYWnd* xywnd = g_pParentWnd->GetXYWnd(); + xywnd->SetOrigin( point ); } #include "stringio.h" -void Map_StartPosition() -{ - Entity *entity = Scene_FindPlayerStart(); +void Map_StartPosition(){ + Entity* entity = Scene_FindPlayerStart(); - if (entity) { - Vector3 origin; - string_parse_vector3(entity->getKeyValue("origin"), origin); - FocusViews(origin, string_read_float(entity->getKeyValue("angle"))); - } else { - FocusViews(g_vector3_identity, 0); - } + if ( entity ) { + Vector3 origin; + string_parse_vector3( entity->getKeyValue( "origin" ), origin ); + FocusViews( origin, string_read_float( entity->getKeyValue( "angle" ) ) ); + } + else + { + FocusViews( g_vector3_identity, 0 ); + } } -inline bool node_is_worldspawn(scene::Node &node) -{ - Entity *entity = Node_getEntity(node); - return entity != 0 && string_equal(entity->getKeyValue("classname"), "worldspawn"); +inline bool node_is_worldspawn( scene::Node& node ){ + Entity* entity = Node_getEntity( node ); + return entity != 0 && string_equal( entity->getKeyValue( "classname" ), "worldspawn" ); } // use first worldspawn -class entity_updateworldspawn : public scene::Traversable::Walker { +class entity_updateworldspawn : public scene::Traversable::Walker +{ public: - bool pre(scene::Node &node) const - { - if (node_is_worldspawn(node)) { - if (Map_GetWorldspawn(g_map) == 0) { - Map_SetWorldspawn(g_map, &node); - } - } - return false; - } +bool pre( scene::Node& node ) const { + if ( node_is_worldspawn( node ) ) { + if ( Map_GetWorldspawn( g_map ) == 0 ) { + Map_SetWorldspawn( g_map, &node ); + } + } + return false; +} }; -scene::Node *Map_FindWorldspawn(Map &map) -{ - Map_SetWorldspawn(map, 0); +scene::Node* Map_FindWorldspawn( Map& map ){ + Map_SetWorldspawn( map, 0 ); - Node_getTraversable(GlobalSceneGraph().root())->traverse(entity_updateworldspawn()); + Node_getTraversable( GlobalSceneGraph().root() )->traverse( entity_updateworldspawn() ); - return Map_GetWorldspawn(map); + return Map_GetWorldspawn( map ); } -class CollectAllWalker : public scene::Traversable::Walker { - scene::Node &m_root; - UnsortedNodeSet &m_nodes; +class CollectAllWalker : public scene::Traversable::Walker +{ +scene::Node& m_root; +UnsortedNodeSet& m_nodes; public: - CollectAllWalker(scene::Node &root, UnsortedNodeSet &nodes) : m_root(root), m_nodes(nodes) - { - } - - bool pre(scene::Node &node) const - { - m_nodes.insert(NodeSmartReference(node)); - Node_getTraversable(m_root)->erase(node); - return false; - } +CollectAllWalker( scene::Node& root, UnsortedNodeSet& nodes ) : m_root( root ), m_nodes( nodes ){ +} + +bool pre( scene::Node& node ) const { + m_nodes.insert( NodeSmartReference( node ) ); + Node_getTraversable( m_root )->erase( node ); + return false; +} }; -void Node_insertChildFirst(scene::Node &parent, scene::Node &child) -{ - UnsortedNodeSet nodes; - Node_getTraversable(parent)->traverse(CollectAllWalker(parent, nodes)); - Node_getTraversable(parent)->insert(child); +void Node_insertChildFirst( scene::Node& parent, scene::Node& child ){ + UnsortedNodeSet nodes; + Node_getTraversable( parent )->traverse( CollectAllWalker( parent, nodes ) ); + Node_getTraversable( parent )->insert( child ); - for (UnsortedNodeSet::iterator i = nodes.begin(); i != nodes.end(); ++i) { - Node_getTraversable(parent)->insert((*i)); - } + for ( UnsortedNodeSet::iterator i = nodes.begin(); i != nodes.end(); ++i ) + { + Node_getTraversable( parent )->insert( ( *i ) ); + } } -scene::Node &createWorldspawn() -{ - NodeSmartReference worldspawn( - GlobalEntityCreator().createEntity(GlobalEntityClassManager().findOrInsert("worldspawn", true))); - Node_insertChildFirst(GlobalSceneGraph().root(), worldspawn); - return worldspawn; +scene::Node& createWorldspawn(){ + NodeSmartReference worldspawn( GlobalEntityCreator().createEntity( GlobalEntityClassManager().findOrInsert( "worldspawn", true ) ) ); + Node_insertChildFirst( GlobalSceneGraph().root(), worldspawn ); + return worldspawn; } -void Map_UpdateWorldspawn(Map &map) -{ - if (Map_FindWorldspawn(map) == 0) { - Map_SetWorldspawn(map, &createWorldspawn()); - } +void Map_UpdateWorldspawn( Map& map ){ + if ( Map_FindWorldspawn( map ) == 0 ) { + Map_SetWorldspawn( map, &createWorldspawn() ); + } } -scene::Node &Map_FindOrInsertWorldspawn(Map &map) +scene::Node& Map_FindOrInsertWorldspawn( Map& map ){ + Map_UpdateWorldspawn( map ); + return *Map_GetWorldspawn( map ); +} + + +class MapMergeAll : public scene::Traversable::Walker { - Map_UpdateWorldspawn(map); - return *Map_GetWorldspawn(map); +mutable scene::Path m_path; +public: +MapMergeAll( const scene::Path& root ) + : m_path( root ){ +} + +bool pre( scene::Node& node ) const { + Node_getTraversable( m_path.top() )->insert( node ); + m_path.push( makeReference( node ) ); + selectPath( m_path, true ); + return false; } +void post( scene::Node& node ) const { + m_path.pop(); +} +}; -class MapMergeAll : public scene::Traversable::Walker { - mutable scene::Path m_path; +class MapMergeEntities : public scene::Traversable::Walker +{ +mutable scene::Path m_path; public: - MapMergeAll(const scene::Path &root) - : m_path(root) - { - } - - bool pre(scene::Node &node) const - { - Node_getTraversable(m_path.top())->insert(node); - m_path.push(makeReference(node)); - selectPath(m_path, true); - return false; - } - - void post(scene::Node &node) const - { - m_path.pop(); - } +MapMergeEntities( const scene::Path& root ) + : m_path( root ){ +} + +bool pre( scene::Node& node ) const { + if ( node_is_worldspawn( node ) ) { + scene::Node* world_node = Map_FindWorldspawn( g_map ); + if ( world_node == 0 ) { + Map_SetWorldspawn( g_map, &node ); + Node_getTraversable( m_path.top().get() )->insert( node ); + m_path.push( makeReference( node ) ); + Node_getTraversable( node )->traverse( SelectChildren( m_path ) ); + } + else + { + m_path.push( makeReference( *world_node ) ); + Node_getTraversable( node )->traverse( MapMergeAll( m_path ) ); + } + } + else + { + Node_getTraversable( m_path.top() )->insert( node ); + m_path.push( makeReference( node ) ); + if ( node_is_group( node ) ) { + Node_getTraversable( node )->traverse( SelectChildren( m_path ) ); + } + else + { + selectPath( m_path, true ); + } + } + return false; +} + +void post( scene::Node& node ) const { + m_path.pop(); +} }; -class MapMergeEntities : public scene::Traversable::Walker { - mutable scene::Path m_path; +class BasicContainer : public scene::Node::Symbiot +{ +class TypeCasts +{ +NodeTypeCastTable m_casts; public: - MapMergeEntities(const scene::Path &root) - : m_path(root) - { - } - - bool pre(scene::Node &node) const - { - if (node_is_worldspawn(node)) { - scene::Node *world_node = Map_FindWorldspawn(g_map); - if (world_node == 0) { - Map_SetWorldspawn(g_map, &node); - Node_getTraversable(m_path.top().get())->insert(node); - m_path.push(makeReference(node)); - Node_getTraversable(node)->traverse(SelectChildren(m_path)); - } else { - m_path.push(makeReference(*world_node)); - Node_getTraversable(node)->traverse(MapMergeAll(m_path)); - } - } else { - Node_getTraversable(m_path.top())->insert(node); - m_path.push(makeReference(node)); - if (node_is_group(node)) { - Node_getTraversable(node)->traverse(SelectChildren(m_path)); - } else { - selectPath(m_path, true); - } - } - return false; - } - - void post(scene::Node &node) const - { - m_path.pop(); - } +TypeCasts(){ + NodeContainedCast::install( m_casts ); +} + +NodeTypeCastTable& get(){ + return m_casts; +} }; -class BasicContainer : public scene::Node::Symbiot { - class TypeCasts { - NodeTypeCastTable m_casts; - public: - TypeCasts() - { - NodeContainedCast::install(m_casts); - } - - NodeTypeCastTable &get() - { - return m_casts; - } - }; - - scene::Node m_node; - TraversableNodeSet m_traverse; +scene::Node m_node; +TraversableNodeSet m_traverse; public: - typedef LazyStatic StaticTypeCasts; +typedef LazyStatic StaticTypeCasts; - scene::Traversable &get(NullType) - { - return m_traverse; - } +scene::Traversable& get( NullType){ + return m_traverse; +} - BasicContainer() : m_node(this, this, StaticTypeCasts::instance().get()) - { - } +BasicContainer() : m_node( this, this, StaticTypeCasts::instance().get() ){ +} - void release() - { - delete this; - } +void release(){ + delete this; +} - scene::Node &node() - { - return m_node; - } +scene::Node& node(){ + return m_node; +} }; /// Merges the map graph rooted at \p node into the global scene-graph. -void MergeMap(scene::Node &node) -{ - Node_getTraversable(node)->traverse(MapMergeEntities(scene::Path(makeReference(GlobalSceneGraph().root())))); +void MergeMap( scene::Node& node ){ + Node_getTraversable( node )->traverse( MapMergeEntities( scene::Path( makeReference( GlobalSceneGraph().root() ) ) ) ); } -void Map_ImportSelected(TextInputStream &in, const MapFormat &format) -{ - NodeSmartReference node((new BasicContainer)->node()); - format.readGraph(node, in, GlobalEntityCreator()); - Map_gatherNamespaced(node); - Map_mergeClonedNames(); - MergeMap(node); +void Map_ImportSelected( TextInputStream& in, const MapFormat& format ){ + NodeSmartReference node( ( new BasicContainer )->node() ); + format.readGraph( node, in, GlobalEntityCreator() ); + Map_gatherNamespaced( node ); + Map_mergeClonedNames(); + MergeMap( node ); } -inline scene::Cloneable *Node_getCloneable(scene::Node &node) -{ - return NodeTypeCast::cast(node); +inline scene::Cloneable* Node_getCloneable( scene::Node& node ){ + return NodeTypeCast::cast( node ); } -inline scene::Node &node_clone(scene::Node &node) -{ - scene::Cloneable *cloneable = Node_getCloneable(node); - if (cloneable != 0) { - return cloneable->clone(); - } +inline scene::Node& node_clone( scene::Node& node ){ + scene::Cloneable* cloneable = Node_getCloneable( node ); + if ( cloneable != 0 ) { + return cloneable->clone(); + } - return (new scene::NullNode)->node(); + return ( new scene::NullNode )->node(); } -class CloneAll : public scene::Traversable::Walker { - mutable scene::Path m_path; +class CloneAll : public scene::Traversable::Walker +{ +mutable scene::Path m_path; public: - CloneAll(scene::Node &root) - : m_path(makeReference(root)) - { - } - - bool pre(scene::Node &node) const - { - if (node.isRoot()) { - return false; - } - - m_path.push(makeReference(node_clone(node))); - m_path.top().get().IncRef(); - - return true; - } - - void post(scene::Node &node) const - { - if (node.isRoot()) { - return; - } - - Node_getTraversable(m_path.parent())->insert(m_path.top()); - - m_path.top().get().DecRef(); - m_path.pop(); - } +CloneAll( scene::Node& root ) + : m_path( makeReference( root ) ){ +} + +bool pre( scene::Node& node ) const { + if ( node.isRoot() ) { + return false; + } + + m_path.push( makeReference( node_clone( node ) ) ); + m_path.top().get().IncRef(); + + return true; +} + +void post( scene::Node& node ) const { + if ( node.isRoot() ) { + return; + } + + Node_getTraversable( m_path.parent() )->insert( m_path.top() ); + + m_path.top().get().DecRef(); + m_path.pop(); +} }; -scene::Node &Node_Clone(scene::Node &node) +scene::Node& Node_Clone( scene::Node& node ){ + scene::Node& clone = node_clone( node ); + scene::Traversable* traversable = Node_getTraversable( node ); + if ( traversable != 0 ) { + traversable->traverse( CloneAll( clone ) ); + } + return clone; +} + +bool Node_instanceSelected( scene::Node& node ); + +class CloneAllSelected : public scene::Traversable::Walker { - scene::Node &clone = node_clone(node); - scene::Traversable *traversable = Node_getTraversable(node); - if (traversable != 0) { - traversable->traverse(CloneAll(clone)); - } - return clone; +mutable scene::Path m_path; +public: +CloneAllSelected( scene::Node& root ) + : m_path( makeReference( root ) ){ +} +bool pre( scene::Node& node ) const { + if ( node.isRoot() ) { + return false; + } + + if( Node_instanceSelected( node ) ){ + m_path.push( makeReference( node_clone( node ) ) ); + m_path.top().get().IncRef(); + } + + return true; +} +void post( scene::Node& node ) const { + if ( node.isRoot() ) { + return; + } + + if( Node_instanceSelected( node ) ){ + Node_getTraversable( m_path.parent() )->insert( m_path.top() ); + + m_path.top().get().DecRef(); + m_path.pop(); + } +} +}; + +scene::Node& Node_Clone_Selected( scene::Node& node ){ + scene::Node& clone = node_clone( node ); + scene::Traversable* traversable = Node_getTraversable( node ); + if ( traversable != 0 ) { + traversable->traverse( CloneAllSelected( clone ) ); + } + return clone; } typedef std::map EntityBreakdown; -class EntityBreakdownWalker : public scene::Graph::Walker { - EntityBreakdown &m_entitymap; +class EntityBreakdownWalker : public scene::Graph::Walker +{ +EntityBreakdown& m_entitymap; public: - EntityBreakdownWalker(EntityBreakdown &entitymap) - : m_entitymap(entitymap) - { - } - - bool pre(const scene::Path &path, scene::Instance &instance) const - { - Entity *entity = Node_getEntity(path.top()); - if (entity != 0) { - const EntityClass &eclass = entity->getEntityClass(); - if (m_entitymap.find(eclass.name()) == m_entitymap.end()) { - m_entitymap[eclass.name()] = 1; - } else { ++m_entitymap[eclass.name()]; } - } - return true; - } +EntityBreakdownWalker( EntityBreakdown& entitymap ) + : m_entitymap( entitymap ){ +} + +bool pre( const scene::Path& path, scene::Instance& instance ) const { + Entity* entity = Node_getEntity( path.top() ); + if ( entity != 0 ) { + const EntityClass& eclass = entity->getEntityClass(); + if ( m_entitymap.find( eclass.name() ) == m_entitymap.end() ) { + m_entitymap[eclass.name()] = 1; + } else + { + ++m_entitymap[eclass.name()]; + } + } + return true; +} }; -void Scene_EntityBreakdown(EntityBreakdown &entitymap) +void Scene_EntityBreakdown( EntityBreakdown& entitymap ){ + GlobalSceneGraph().traverse( EntityBreakdownWalker( entitymap ) ); +} + +class CountStuffWalker : public scene::Graph::Walker { - GlobalSceneGraph().traverse(EntityBreakdownWalker(entitymap)); +int& m_patches; +int& m_ents_ingame; +int& m_groupents; +int& m_groupents_ingame; +public: +CountStuffWalker( int& patches, int& ents_ingame, int& groupents, int& groupents_ingame ) + : m_patches( patches ), m_ents_ingame( ents_ingame ), m_groupents( groupents ), m_groupents_ingame( groupents_ingame ){ +} +bool pre( const scene::Path& path, scene::Instance& instance ) const { + Patch* patch = Node_getPatch( path.top() ); + if( patch != 0 ){ + ++m_patches; + } + Entity* entity = Node_getEntity( path.top() ); + if ( entity != 0 ){ + if( entity->isContainer() ){ + ++m_groupents; + if( !string_equal_nocase( "func_group", entity->getKeyValue( "classname" ) ) && + !string_equal_nocase( "_decal", entity->getKeyValue( "classname" ) ) ){ + ++m_groupents_ingame; + ++m_ents_ingame; + } + return true; + } + if( !string_equal_nocase_n( "light", entity->getKeyValue( "classname" ), 5 ) && + !string_equal_nocase( "misc_model", entity->getKeyValue( "classname" ) ) ){ + ++m_ents_ingame; + } + } + return true; +} +}; + +void Scene_CountStuff( int& patches, int& ents_ingame, int& groupents, int& groupents_ingame ){ + GlobalSceneGraph().traverse( CountStuffWalker( patches, ents_ingame, groupents, groupents_ingame ) ); } +WindowPosition g_posMapInfoWnd( c_default_window_pos ); -WindowPosition g_posMapInfoWnd(c_default_window_pos); +void DoMapInfo(){ + ModalDialog dialog; + ui::Widget w_brushes{ui::null}; + ui::Widget w_patches{ui::null}; + ui::Widget w_ents{ui::null}; + ui::Widget w_ents_ingame{ui::null}; + ui::Widget w_groupents{ui::null}; + ui::Widget w_groupents_ingame{ui::null}; -void DoMapInfo() -{ - ModalDialog dialog; - ui::Entry brushes_entry{ui::null}; - ui::Entry entities_entry{ui::null}; - ui::ListStore EntityBreakdownWalker{ui::null}; - - ui::Window window = MainFrame_getWindow().create_dialog_window("Map Info", G_CALLBACK(dialog_delete_callback), - &dialog); - - window_set_position(window, g_posMapInfoWnd); - - { - auto vbox = create_dialog_vbox(4, 4); - window.add(vbox); - - { - auto hbox = create_dialog_hbox(4); - vbox.pack_start(hbox, FALSE, TRUE, 0); - - { - auto table = create_dialog_table(2, 2, 4, 4); - hbox.pack_start(table, TRUE, TRUE, 0); - - { - auto entry = ui::Entry(ui::New); - entry.show(); - table.attach(entry, {1, 2, 0, 1}, {GTK_EXPAND | GTK_FILL, 0}); - gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE); - - brushes_entry = entry; - } - { - auto entry = ui::Entry(ui::New); - entry.show(); - table.attach(entry, {1, 2, 1, 2}, {GTK_EXPAND | GTK_FILL, 0}); - gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE); - - entities_entry = entry; - } - { - ui::Widget label = ui::Label("Total Brushes"); - label.show(); + ui::ListStore EntityBreakdownWalker{ui::null}; + + ui::Window window = MainFrame_getWindow().create_dialog_window("Map Info", G_CALLBACK(dialog_delete_callback ), &dialog ); + + window_set_position( window, g_posMapInfoWnd ); + + { + auto vbox = create_dialog_vbox( 4, 4 ); + window.add(vbox); + + { + auto hbox = create_dialog_hbox( 4 ); + vbox.pack_start( hbox, FALSE, FALSE, 0 ); + + { + auto table = create_dialog_table( 3, 4, 4, 4 ); + hbox.pack_start( table, TRUE, TRUE, 0 ); + + { + auto label = ui::Label( "Total Brushes:" ); + label.show(); table.attach(label, {0, 1, 0, 1}, {GTK_FILL, 0}); - gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); - } - { - ui::Widget label = ui::Label("Total Entities"); - label.show(); - table.attach(label, {0, 1, 1, 2}, {GTK_FILL, 0}); - gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); - } - } - { - auto vbox2 = create_dialog_vbox(4); - hbox.pack_start(vbox2, FALSE, FALSE, 0); - - { - auto button = create_dialog_button("Close", G_CALLBACK(dialog_button_ok), &dialog); - vbox2.pack_start(button, FALSE, FALSE, 0); - } - } - } - { - ui::Widget label = ui::Label("Entity breakdown"); - label.show(); - vbox.pack_start(label, FALSE, TRUE, 0); - gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); - } - { - auto scr = create_scrolled_window(ui::Policy::NEVER, ui::Policy::AUTOMATIC, 4); - vbox.pack_start(scr, TRUE, TRUE, 0); - - { - auto store = ui::ListStore::from(gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING)); - - auto view = ui::TreeView(ui::TreeModel::from(store._handle)); - gtk_tree_view_set_headers_clickable(view, TRUE); - - { - auto renderer = ui::CellRendererText(ui::New); - auto column = ui::TreeViewColumn("Entity", renderer, {{"text", 0}}); - gtk_tree_view_append_column(view, column); - gtk_tree_view_column_set_sort_column_id(column, 0); - } - - { - auto renderer = ui::CellRendererText(ui::New); - auto column = ui::TreeViewColumn("Count", renderer, {{"text", 1}}); - gtk_tree_view_append_column(view, column); - gtk_tree_view_column_set_sort_column_id(column, 1); - } - - view.show(); - - scr.add(view); - - EntityBreakdownWalker = store; - } - } - } - - // Initialize fields - - { - EntityBreakdown entitymap; - Scene_EntityBreakdown(entitymap); - - for (EntityBreakdown::iterator i = entitymap.begin(); i != entitymap.end(); ++i) { - char tmp[16]; - sprintf(tmp, "%u", Unsigned((*i).second)); - EntityBreakdownWalker.append(0, (*i).first.c_str(), 1, tmp); - } - } - - EntityBreakdownWalker.unref(); - - char tmp[16]; - sprintf(tmp, "%u", Unsigned(g_brushCount.get())); - brushes_entry.text(tmp); - sprintf(tmp, "%u", Unsigned(g_entityCount.get())); - entities_entry.text(tmp); - - modal_dialog_show(window, dialog); - - // save before exit - window_get_position(window, g_posMapInfoWnd); + gtk_misc_set_alignment( GTK_MISC( label ), 0.0, 0.5 ); + } + { + auto label = ui::Label( "" ); + label.show(); + table.attach(label, {1, 2, 0, 1}, {GTK_FILL | GTK_EXPAND, 0}, {3, 0}); + w_brushes = label; + } + { + auto label = ui::Label( "Total Patches" ); + label.show(); + table.attach(label, {2, 3, 0, 1}, {GTK_FILL, 0}); + gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 ); + } + { + auto label = ui::Label( "" ); + label.show(); + table.attach(label, {3, 4, 0, 1}, {GTK_FILL, 0}, {3, 0}); + gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 ); + w_patches = label; + } + { + auto label = ui::Label( "Total Entities:" ); + label.show(); + table.attach(label, {0, 1, 1, 2}, {GTK_FILL, 0}); + gtk_misc_set_alignment( GTK_MISC( label ), 0.0, 0.5 ); + } + { + auto label = ui::Label( "" ); + label.show(); + table.attach(label, {1, 2, 1, 2}, {GTK_FILL | GTK_EXPAND, 0}, {3, 0}); + gtk_misc_set_alignment( GTK_MISC( label ), 0.0, 0.5 ); + w_ents = label; + } + { + auto label = ui::Label( "Ingame Entities:" ); + label.show(); + table.attach(label, {2, 3, 1, 2}, {GTK_FILL, 0}); + gtk_misc_set_alignment( GTK_MISC( label ), 0.0, 0.5 ); + } + { + auto label = ui::Label( "" ); + label.show(); + table.attach(label, {3, 4, 1, 2}, {GTK_FILL | GTK_EXPAND, 0 }, {3, 0}); + gtk_misc_set_alignment( GTK_MISC( label ), 0.0, 0.5 ); + w_ents_ingame = label; + } + { + auto label = ui::Label( "Group Entities:" ); + label.show(); + table.attach(label, {0, 1, 2, 3}, {GTK_FILL, 0}); + gtk_misc_set_alignment( GTK_MISC( label ), 0.0, 0.5 ); + } + { + auto label = ui::Label( "" ); + label.show(); + table.attach(label, {1, 2, 2, 3}, {GTK_FILL | GTK_EXPAND, 0}, {3, 0}); + gtk_misc_set_alignment( GTK_MISC( label ), 0.0, 0.5 ); + w_groupents = label; + } + { + auto label = ui::Label( "Ingame Group Entities:" ); + label.show(); + table.attach(label, {2, 3, 2, 3}, {GTK_FILL, 0}); + gtk_misc_set_alignment( GTK_MISC( label ), 0.0, 0.5 ); + } + { + auto label = ui::Label( "" ); + label.show(); + table.attach(label, {3, 4, 2, 3}, {GTK_FILL | GTK_EXPAND, 0}, {3, 0}); + gtk_misc_set_alignment( GTK_MISC( label ), 0.0, 0.5 ); + w_groupents_ingame = label; + } + + } + { + auto vbox2 = create_dialog_vbox( 4 ); + hbox.pack_start( vbox2, FALSE, FALSE, 0 ); + + { + auto button = create_dialog_button( "Close", G_CALLBACK( dialog_button_ok ), &dialog ); + vbox2.pack_start( button, FALSE, FALSE, 0 ); + } + } + } + { + ui::Widget label = ui::Label( "*** Entity breakdown ***" ); + label.show(); + vbox.pack_start( label, FALSE, TRUE, 0 ); + gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 ); + } + { + auto scr = create_scrolled_window( ui::Policy::NEVER, ui::Policy::AUTOMATIC, 4 ); + vbox.pack_start( scr, TRUE, TRUE, 0 ); + + { + auto store = ui::ListStore::from(gtk_list_store_new( 2, G_TYPE_STRING, G_TYPE_UINT )); + + auto view = ui::TreeView(ui::TreeModel::from(store._handle)); + gtk_tree_view_set_headers_clickable(view, TRUE ); + + { + auto renderer = ui::CellRendererText(ui::New); + auto column = ui::TreeViewColumn( "Entity", renderer, {{"text", 0}} ); + gtk_tree_view_append_column(view, column ); + gtk_tree_view_column_set_sort_column_id( column, 0 ); + } + + { + auto renderer = ui::CellRendererText(ui::New); + auto column = ui::TreeViewColumn( "Count", renderer, {{"text", 1}} ); + gtk_tree_view_append_column(view, column ); + gtk_tree_view_column_set_sort_column_id( column, 1 ); + } + + view.show(); + + scr.add(view); + + EntityBreakdownWalker = store; + } + } + } + + // Initialize fields + + { + EntityBreakdown entitymap; + Scene_EntityBreakdown( entitymap ); + + for ( EntityBreakdown::iterator i = entitymap.begin(); i != entitymap.end(); ++i ) + { + EntityBreakdownWalker.append(0, (*i).first.c_str(), 1, Unsigned( ( *i ).second )); + } + } + + EntityBreakdownWalker.unref(); + + int n_patches = 0; + int n_ents_ingame = 0; + int n_groupents = 0; + int n_groupents_ingame = 0; + Scene_CountStuff( n_patches, n_ents_ingame, n_groupents, n_groupents_ingame ); + //globalOutputStream() << n_patches << n_ents_ingame << n_groupents << n_groupents_ingame << "\n"; + + char *markup; + + markup = g_markup_printf_escaped( "%u ", Unsigned( g_brushCount.get() ) ); + gtk_label_set_markup( GTK_LABEL( w_brushes ), markup ); + g_free( markup ); + + markup = g_markup_printf_escaped( "%i ", n_patches ); + gtk_label_set_markup( GTK_LABEL( w_patches ), markup ); + g_free( markup ); + + markup = g_markup_printf_escaped( "%u ", Unsigned( g_entityCount.get() ) ); + gtk_label_set_markup( GTK_LABEL( w_ents ), markup ); + g_free( markup ); + + markup = g_markup_printf_escaped( "%i ", n_ents_ingame ); + gtk_label_set_markup( GTK_LABEL( w_ents_ingame ), markup ); + g_free( markup ); + + markup = g_markup_printf_escaped( "%i ", n_groupents ); + gtk_label_set_markup( GTK_LABEL( w_groupents ), markup ); + g_free( markup ); + + markup = g_markup_printf_escaped( "%i ", n_groupents_ingame ); + gtk_label_set_markup( GTK_LABEL( w_groupents_ingame ), markup ); + g_free( markup ); + + + modal_dialog_show( window, dialog ); + + // save before exit + window_get_position( window, g_posMapInfoWnd ); window.destroy(); } -class ScopeTimer { - Timer m_timer; - const char *m_message; + +class ScopeTimer +{ +Timer m_timer; +const char* m_message; public: - ScopeTimer(const char *message) - : m_message(message) - { - m_timer.start(); - } - - ~ScopeTimer() - { - double elapsed_time = m_timer.elapsed_msec() / 1000.f; - globalOutputStream() << m_message << " timer: " << FloatFormat(elapsed_time, 5, 2) << " second(s) elapsed\n"; - } +ScopeTimer( const char* message ) + : m_message( message ){ + m_timer.start(); +} + +~ScopeTimer(){ + double elapsed_time = m_timer.elapsed_msec() / 1000.f; + globalOutputStream() << m_message << " timer: " << FloatFormat( elapsed_time, 5, 2 ) << " second(s) elapsed\n"; +} }; CopiedString g_strLastMapFolder = ""; @@ -999,309 +1117,309 @@ CopiedString g_strLastMapFolder = ""; ================ */ -void Map_LoadFile(const char *filename) +void Map_LoadFile( const char *filename ){ + g_map.m_name = filename; + + // refresh VFS to apply new pak filtering based on mapname + // needed for daemon DPK VFS + VFS_Refresh(); + + globalOutputStream() << "Loading map from " << filename << "\n"; + ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Loading Map" ); + + MRU_AddFile( filename ); + g_strLastMapFolder = g_path_get_dirname( filename ); + + bool switch_format = false; + + { + ScopeTimer timer( "map load" ); + + const MapFormat* format = NULL; + const char* moduleName = findModuleName( &GlobalFiletypes(), MapFormat::Name(), path_get_extension( filename ) ); + if ( string_not_empty( moduleName ) ) { + format = ReferenceAPI_getMapModules().findModule( moduleName ); + } + + for ( int i = 0; i < Brush_toggleFormatCount(); ++i ) + { + if ( i ) { + Map_Free(); + } + Brush_toggleFormat( i ); + Map_UpdateTitle( g_map ); + + g_map.m_resource = GlobalReferenceCache().capture( g_map.m_name.c_str() ); + if ( format ) { + format->wrongFormat = false; + } + g_map.m_resource->attach( g_map ); + if ( format ) { + if ( !format->wrongFormat ) { + break; + } + switch_format = !switch_format; + } + } + + Node_getTraversable( GlobalSceneGraph().root() )->traverse( entity_updateworldspawn() ); + } + + globalOutputStream() << "--- LoadMapFile ---\n"; + globalOutputStream() << g_map.m_name.c_str() << "\n"; + + globalOutputStream() << Unsigned( g_brushCount.get() ) << " primitive\n"; + globalOutputStream() << Unsigned( g_entityCount.get() ) << " entities\n"; + + //GlobalEntityCreator().printStatistics(); + + // + // move the view to a start position + // + Map_StartPosition(); + + g_currentMap = &g_map; + + Brush_switchFormat( switch_format ); +} + +class Excluder { - globalOutputStream() << "Loading map from " << filename << "\n"; - ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Loading Map"); - - MRU_AddFile(filename); - g_strLastMapFolder = g_path_get_dirname(filename); - - { - ScopeTimer timer("map load"); - - const MapFormat *format = NULL; - const char *moduleName = findModuleName(&GlobalFiletypes(), MapFormat::Name(), path_get_extension(filename)); - if (string_not_empty(moduleName)) { - format = ReferenceAPI_getMapModules().findModule(moduleName); - } - - for (int i = 0; i < Brush_toggleFormatCount(); ++i) { - if (i) { - Map_Free(); - } - Brush_toggleFormat(i); - g_map.m_name = filename; - Map_UpdateTitle(g_map); - g_map.m_resource = GlobalReferenceCache().capture(g_map.m_name.c_str()); - if (format) { - format->wrongFormat = false; - } - g_map.m_resource->attach(g_map); - if (format) { - if (!format->wrongFormat) { - break; - } - } - } - - Node_getTraversable(GlobalSceneGraph().root())->traverse(entity_updateworldspawn()); - } - - globalOutputStream() << "--- LoadMapFile ---\n"; - globalOutputStream() << g_map.m_name.c_str() << "\n"; - - globalOutputStream() << Unsigned(g_brushCount.get()) << " primitive\n"; - globalOutputStream() << Unsigned(g_entityCount.get()) << " entities\n"; - - //GlobalEntityCreator().printStatistics(); - - // - // move the view to a start position - // - Map_StartPosition(); - - g_currentMap = &g_map; - - // refresh VFS to apply new pak filtering based on mapname - // needed for daemon DPK VFS - VFS_Refresh(); -} - -class Excluder { public: - virtual bool excluded(scene::Node &node) const = 0; +virtual bool excluded( scene::Node& node ) const = 0; }; -class ExcludeWalker : public scene::Traversable::Walker { - const scene::Traversable::Walker &m_walker; - const Excluder *m_exclude; - mutable bool m_skip; +class ExcludeWalker : public scene::Traversable::Walker +{ +const scene::Traversable::Walker& m_walker; +const Excluder* m_exclude; +mutable bool m_skip; public: - ExcludeWalker(const scene::Traversable::Walker &walker, const Excluder &exclude) - : m_walker(walker), m_exclude(&exclude), m_skip(false) - { - } - - bool pre(scene::Node &node) const - { - if (m_exclude->excluded(node) || node.isRoot()) { - m_skip = true; - return false; - } else { - m_walker.pre(node); - } - return true; - } - - void post(scene::Node &node) const - { - if (m_skip) { - m_skip = false; - } else { - m_walker.post(node); - } - } +ExcludeWalker( const scene::Traversable::Walker& walker, const Excluder& exclude ) + : m_walker( walker ), m_exclude( &exclude ), m_skip( false ){ +} + +bool pre( scene::Node& node ) const { + if ( m_exclude->excluded( node ) || node.isRoot() ) { + m_skip = true; + return false; + } + else + { + m_walker.pre( node ); + } + return true; +} + +void post( scene::Node& node ) const { + if ( m_skip ) { + m_skip = false; + } + else + { + m_walker.post( node ); + } +} }; -class AnyInstanceSelected : public scene::Instantiable::Visitor { - bool &m_selected; +class AnyInstanceSelected : public scene::Instantiable::Visitor +{ +bool& m_selected; public: - AnyInstanceSelected(bool &selected) : m_selected(selected) - { - m_selected = false; - } - - void visit(scene::Instance &instance) const - { - Selectable *selectable = Instance_getSelectable(instance); - if (selectable != 0 - && selectable->isSelected()) { - m_selected = true; - } - } +AnyInstanceSelected( bool& selected ) : m_selected( selected ){ + m_selected = false; +} + +void visit( scene::Instance& instance ) const { + Selectable* selectable = Instance_getSelectable( instance ); + if ( selectable != 0 + && selectable->isSelected() ) { + m_selected = true; + } +} }; -bool Node_instanceSelected(scene::Node &node) -{ - scene::Instantiable *instantiable = Node_getInstantiable(node); - ASSERT_NOTNULL(instantiable); - bool selected; - instantiable->forEachInstance(AnyInstanceSelected(selected)); - return selected; +bool Node_instanceSelected( scene::Node& node ){ + scene::Instantiable* instantiable = Node_getInstantiable( node ); + ASSERT_NOTNULL( instantiable ); + bool selected; + instantiable->forEachInstance( AnyInstanceSelected( selected ) ); + return selected; } -class SelectedDescendantWalker : public scene::Traversable::Walker { - bool &m_selected; +class SelectedDescendantWalker : public scene::Traversable::Walker +{ +bool& m_selected; public: - SelectedDescendantWalker(bool &selected) : m_selected(selected) - { - m_selected = false; - } - - bool pre(scene::Node &node) const - { - if (node.isRoot()) { - return false; - } - - if (Node_instanceSelected(node)) { - m_selected = true; - } - - return true; - } +SelectedDescendantWalker( bool& selected ) : m_selected( selected ){ + m_selected = false; +} + +bool pre( scene::Node& node ) const { + if ( node.isRoot() ) { + return false; + } + + if ( Node_instanceSelected( node ) ) { + m_selected = true; + } + + return true; +} }; -bool Node_selectedDescendant(scene::Node &node) -{ - bool selected; - Node_traverseSubgraph(node, SelectedDescendantWalker(selected)); - return selected; +bool Node_selectedDescendant( scene::Node& node ){ + bool selected; + Node_traverseSubgraph( node, SelectedDescendantWalker( selected ) ); + return selected; } -class SelectionExcluder : public Excluder { +class SelectionExcluder : public Excluder +{ public: - bool excluded(scene::Node &node) const - { - return !Node_selectedDescendant(node); - } +bool excluded( scene::Node& node ) const { + return !Node_selectedDescendant( node ); +} }; -class IncludeSelectedWalker : public scene::Traversable::Walker { - const scene::Traversable::Walker &m_walker; - mutable std::size_t m_selected; - mutable bool m_skip; +class IncludeSelectedWalker : public scene::Traversable::Walker +{ +const scene::Traversable::Walker& m_walker; +mutable std::size_t m_selected; +mutable bool m_skip; - bool selectedParent() const - { - return m_selected != 0; - } +bool selectedParent() const { + return m_selected != 0; +} public: - IncludeSelectedWalker(const scene::Traversable::Walker &walker) - : m_walker(walker), m_selected(0), m_skip(false) - { - } - - bool pre(scene::Node &node) const - { - // include node if: - // node is not a 'root' AND ( node is selected OR any child of node is selected OR any parent of node is selected ) - if (!node.isRoot() && (Node_selectedDescendant(node) || selectedParent())) { - if (Node_instanceSelected(node)) { - ++m_selected; - } - m_walker.pre(node); - return true; - } else { - m_skip = true; - return false; - } - } - - void post(scene::Node &node) const - { - if (m_skip) { - m_skip = false; - } else { - if (Node_instanceSelected(node)) { - --m_selected; - } - m_walker.post(node); - } - } +IncludeSelectedWalker( const scene::Traversable::Walker& walker ) + : m_walker( walker ), m_selected( 0 ), m_skip( false ){ +} + +bool pre( scene::Node& node ) const { + // include node if: + // node is not a 'root' AND ( node is selected OR any child of node is selected OR any parent of node is selected ) + if ( !node.isRoot() && ( Node_selectedDescendant( node ) || selectedParent() ) ) { + if ( Node_instanceSelected( node ) ) { + ++m_selected; + } + m_walker.pre( node ); + return true; + } + else + { + m_skip = true; + return false; + } +} + +void post( scene::Node& node ) const { + if ( m_skip ) { + m_skip = false; + } + else + { + if ( Node_instanceSelected( node ) ) { + --m_selected; + } + m_walker.post( node ); + } +} }; -void Map_Traverse_Selected(scene::Node &root, const scene::Traversable::Walker &walker) -{ - scene::Traversable *traversable = Node_getTraversable(root); - if (traversable != 0) { +void Map_Traverse_Selected( scene::Node& root, const scene::Traversable::Walker& walker ){ + scene::Traversable* traversable = Node_getTraversable( root ); + if ( traversable != 0 ) { #if 0 - traversable->traverse( ExcludeWalker( walker, SelectionExcluder() ) ); + traversable->traverse( ExcludeWalker( walker, SelectionExcluder() ) ); #else - traversable->traverse(IncludeSelectedWalker(walker)); + traversable->traverse( IncludeSelectedWalker( walker ) ); #endif - } + } } -void Map_ExportSelected(TextOutputStream &out, const MapFormat &format) -{ - format.writeGraph(GlobalSceneGraph().root(), Map_Traverse_Selected, out, g_writeMapComments); +void Map_ExportSelected( TextOutputStream& out, const MapFormat& format ){ + format.writeGraph( GlobalSceneGraph().root(), Map_Traverse_Selected, out, g_writeMapComments ); } -void Map_Traverse(scene::Node &root, const scene::Traversable::Walker &walker) -{ - scene::Traversable *traversable = Node_getTraversable(root); - if (traversable != 0) { - traversable->traverse(walker); - } +void Map_Traverse( scene::Node& root, const scene::Traversable::Walker& walker ){ + scene::Traversable* traversable = Node_getTraversable( root ); + if ( traversable != 0 ) { + traversable->traverse( walker ); + } } -class RegionExcluder : public Excluder { +class RegionExcluder : public Excluder +{ public: - bool excluded(scene::Node &node) const - { - return node.excluded(); - } +bool excluded( scene::Node& node ) const { + return node.excluded(); +} }; -void Map_Traverse_Region(scene::Node &root, const scene::Traversable::Walker &walker) -{ - scene::Traversable *traversable = Node_getTraversable(root); - if (traversable != 0) { - traversable->traverse(ExcludeWalker(walker, RegionExcluder())); - } +void Map_Traverse_Region( scene::Node& root, const scene::Traversable::Walker& walker ){ + scene::Traversable* traversable = Node_getTraversable( root ); + if ( traversable != 0 ) { + traversable->traverse( ExcludeWalker( walker, RegionExcluder() ) ); + } } -bool Map_SaveRegion(const char *filename) -{ - AddRegionBrushes(); +bool Map_SaveRegion( const char *filename ){ + AddRegionBrushes(); - bool success = MapResource_saveFile(MapFormat_forFile(filename), GlobalSceneGraph().root(), Map_Traverse_Region, - filename); + bool success = MapResource_saveFile( MapFormat_forFile( filename ), GlobalSceneGraph().root(), Map_Traverse_Region, filename ); - RemoveRegionBrushes(); + RemoveRegionBrushes(); - return success; + return success; } -void Map_RenameAbsolute(const char *absolute) -{ - Resource *resource = GlobalReferenceCache().capture(absolute); - NodeSmartReference clone(NewMapRoot(path_make_relative(absolute, GlobalFileSystem().findRoot(absolute)))); - resource->setNode(clone.get_pointer()); +void Map_RenameAbsolute( const char* absolute ){ + Resource* resource = GlobalReferenceCache().capture( absolute ); + NodeSmartReference clone( NewMapRoot( path_make_relative( absolute, GlobalFileSystem().findRoot( absolute ) ) ) ); + resource->setNode( clone.get_pointer() ); - { - //ScopeTimer timer("clone subgraph"); - Node_getTraversable(GlobalSceneGraph().root())->traverse(CloneAll(clone)); - } + { + //ScopeTimer timer("clone subgraph"); + Node_getTraversable( GlobalSceneGraph().root() )->traverse( CloneAll( clone ) ); + } - g_map.m_resource->detach(g_map); - GlobalReferenceCache().release(g_map.m_name.c_str()); + g_map.m_resource->detach( g_map ); + GlobalReferenceCache().release( g_map.m_name.c_str() ); - g_map.m_resource = resource; + g_map.m_resource = resource; - g_map.m_name = absolute; - Map_UpdateTitle(g_map); + g_map.m_name = absolute; + Map_UpdateTitle( g_map ); - g_map.m_resource->attach(g_map); - // refresh VFS to apply new pak filtering based on mapname - // needed for daemon DPK VFS - VFS_Refresh(); + g_map.m_resource->attach( g_map ); + // refresh VFS to apply new pak filtering based on mapname + // needed for daemon DPK VFS + VFS_Refresh(); } -void Map_Rename(const char *filename) -{ - if (!string_equal(g_map.m_name.c_str(), filename)) { - ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Saving Map"); +void Map_Rename( const char* filename ){ + if ( !string_equal( g_map.m_name.c_str(), filename ) ) { + ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Saving Map" ); - Map_RenameAbsolute(filename); + Map_RenameAbsolute( filename ); - SceneChangeNotify(); - } else { - SaveReferences(); - } + SceneChangeNotify(); + } + else + { + SaveReferences(); + } } -bool Map_Save() -{ - Pointfile_Clear(); +bool Map_Save(){ + Pointfile_Clear(); - ScopeTimer timer("map save"); - SaveReferences(); - return true; // assume success.. + ScopeTimer timer( "map save" ); + SaveReferences(); + return true; // assume success.. } /* @@ -1310,55 +1428,54 @@ bool Map_Save() =========== */ -void Map_New() -{ - //globalOutputStream() << "Map_New\n"; +void Map_New(){ + //globalOutputStream() << "Map_New\n"; - g_map.m_name = "unnamed.map"; - Map_UpdateTitle(g_map); + g_map.m_name = "unnamed.map"; + Map_UpdateTitle( g_map ); - { - g_map.m_resource = GlobalReferenceCache().capture(g_map.m_name.c_str()); + { + g_map.m_resource = GlobalReferenceCache().capture( g_map.m_name.c_str() ); // ASSERT_MESSAGE(g_map.m_resource->getNode() == 0, "bleh"); - g_map.m_resource->attach(g_map); + g_map.m_resource->attach( g_map ); - SceneChangeNotify(); - } + SceneChangeNotify(); + } - FocusViews(g_vector3_identity, 0); + FocusViews( g_vector3_identity, 0 ); - g_currentMap = &g_map; + g_currentMap = &g_map; - // restart VFS to apply new pak filtering based on mapname - // needed for daemon DPK VFS - VFS_Restart(); + // restart VFS to apply new pak filtering based on mapname + // needed for daemon DPK VFS + VFS_Restart(); } -extern void ConstructRegionBrushes(scene::Node *brushes[6], const Vector3 ®ion_mins, const Vector3 ®ion_maxs); +extern void ConstructRegionBrushes( scene::Node * brushes[6], const Vector3 ®ion_mins, const Vector3 ®ion_maxs ); -void ConstructRegionStartpoint(scene::Node *startpoint, const Vector3 ®ion_mins, const Vector3 ®ion_maxs) -{ - /*! +void ConstructRegionStartpoint( scene::Node* startpoint, const Vector3& region_mins, const Vector3& region_maxs ){ + /*! \todo we need to make sure that the player start IS inside the region and bail out if it's not the compiler will refuse to compile a map with a player_start somewhere in empty space.. for now, let's just print an error */ - Vector3 vOrig(Camera_getOrigin(*g_pParentWnd->GetCamWnd())); + Vector3 vOrig( Camera_getOrigin( *g_pParentWnd->GetCamWnd() ) ); - for (int i = 0; i < 3; i++) { - if (vOrig[i] > region_maxs[i] || vOrig[i] < region_mins[i]) { - globalErrorStream() << "Camera is NOT in the region, it's likely that the region won't compile correctly\n"; - break; - } - } + for ( int i = 0 ; i < 3 ; i++ ) + { + if ( vOrig[i] > region_maxs[i] || vOrig[i] < region_mins[i] ) { + globalErrorStream() << "Camera is NOT in the region, it's likely that the region won't compile correctly\n"; + break; + } + } - // write the info_playerstart - char sTmp[1024]; - sprintf(sTmp, "%d %d %d", (int) vOrig[0], (int) vOrig[1], (int) vOrig[2]); - Node_getEntity(*startpoint)->setKeyValue("origin", sTmp); - sprintf(sTmp, "%d", (int) Camera_getAngles(*g_pParentWnd->GetCamWnd())[CAMERA_YAW]); - Node_getEntity(*startpoint)->setKeyValue("angle", sTmp); + // write the info_playerstart + char sTmp[1024]; + sprintf( sTmp, "%d %d %d", (int)vOrig[0], (int)vOrig[1], (int)vOrig[2] ); + Node_getEntity( *startpoint )->setKeyValue( "origin", sTmp ); + sprintf( sTmp, "%d", (int)Camera_getAngles( *g_pParentWnd->GetCamWnd() )[CAMERA_YAW] ); + Node_getEntity( *startpoint )->setKeyValue( "angle", sTmp ); } /* @@ -1368,12 +1485,22 @@ void ConstructRegionStartpoint(scene::Node *startpoint, const Vector3 ®ion_mi =========================================================== */ -bool region_active; -Vector3 region_mins(g_MinWorldCoord, g_MinWorldCoord, g_MinWorldCoord); -Vector3 region_maxs(g_MaxWorldCoord, g_MaxWorldCoord, g_MaxWorldCoord); +bool region_active = false; + +ConstReferenceCaller &), PropertyImpl::Export> g_region_caller( region_active ); + +ToggleItem g_region_item( g_region_caller ); -scene::Node *region_sides[6]; -scene::Node *region_startpoint = 0; +/*void Map_ToggleRegion(){ + region_active = !region_active; + g_region_item.update(); +}*/ + +Vector3 region_mins( g_MinWorldCoord, g_MinWorldCoord, g_MinWorldCoord ); +Vector3 region_maxs( g_MaxWorldCoord, g_MaxWorldCoord, g_MaxWorldCoord ); + +scene::Node* region_sides[6]; +scene::Node* region_startpoint = 0; /* =========== @@ -1384,116 +1511,106 @@ scene::Node *region_startpoint = 0; with the new implementation we should be able to append them in a temporary manner to the data we pass to the map module =========== */ -void AddRegionBrushes(void) -{ - int i; +void AddRegionBrushes( void ){ + int i; - for (i = 0; i < 6; i++) { - region_sides[i] = &GlobalBrushCreator().createBrush(); - Node_getTraversable(Map_FindOrInsertWorldspawn(g_map))->insert(NodeSmartReference(*region_sides[i])); - } + for ( i = 0; i < 6; i++ ) + { + region_sides[i] = &GlobalBrushCreator().createBrush(); + Node_getTraversable( Map_FindOrInsertWorldspawn( g_map ) )->insert( NodeSmartReference( *region_sides[i] ) ); + } - region_startpoint = &GlobalEntityCreator().createEntity( - GlobalEntityClassManager().findOrInsert("info_player_start", false)); + region_startpoint = &GlobalEntityCreator().createEntity( GlobalEntityClassManager().findOrInsert( "info_player_start", false ) ); - ConstructRegionBrushes(region_sides, region_mins, region_maxs); - ConstructRegionStartpoint(region_startpoint, region_mins, region_maxs); + ConstructRegionBrushes( region_sides, region_mins, region_maxs ); + ConstructRegionStartpoint( region_startpoint, region_mins, region_maxs ); - Node_getTraversable(GlobalSceneGraph().root())->insert(NodeSmartReference(*region_startpoint)); + Node_getTraversable( GlobalSceneGraph().root() )->insert( NodeSmartReference( *region_startpoint ) ); } -void RemoveRegionBrushes(void) -{ - for (std::size_t i = 0; i < 6; i++) { - Node_getTraversable(*Map_GetWorldspawn(g_map))->erase(*region_sides[i]); - } - Node_getTraversable(GlobalSceneGraph().root())->erase(*region_startpoint); +void RemoveRegionBrushes( void ){ + for ( std::size_t i = 0; i < 6; i++ ) + { + Node_getTraversable( *Map_GetWorldspawn( g_map ) )->erase( *region_sides[i] ); + } + Node_getTraversable( GlobalSceneGraph().root() )->erase( *region_startpoint ); } -inline void exclude_node(scene::Node &node, bool exclude) -{ - exclude - ? node.enable(scene::Node::eExcluded) - : node.disable(scene::Node::eExcluded); +inline void exclude_node( scene::Node& node, bool exclude ){ + exclude + ? node.enable( scene::Node::eExcluded ) + : node.disable( scene::Node::eExcluded ); } -class ExcludeAllWalker : public scene::Graph::Walker { - bool m_exclude; +class ExcludeAllWalker : public scene::Graph::Walker +{ +bool m_exclude; public: - ExcludeAllWalker(bool exclude) - : m_exclude(exclude) - { - } +ExcludeAllWalker( bool exclude ) + : m_exclude( exclude ){ +} - bool pre(const scene::Path &path, scene::Instance &instance) const - { - exclude_node(path.top(), m_exclude); +bool pre( const scene::Path& path, scene::Instance& instance ) const { + exclude_node( path.top(), m_exclude ); - return true; - } + return true; +} }; -void Scene_Exclude_All(bool exclude) -{ - GlobalSceneGraph().traverse(ExcludeAllWalker(exclude)); +void Scene_Exclude_All( bool exclude ){ + GlobalSceneGraph().traverse( ExcludeAllWalker( exclude ) ); } -bool Instance_isSelected(const scene::Instance &instance) -{ - const Selectable *selectable = Instance_getSelectable(instance); - return selectable != 0 && selectable->isSelected(); +bool Instance_isSelected( const scene::Instance& instance ){ + const Selectable* selectable = Instance_getSelectable( instance ); + return selectable != 0 && selectable->isSelected(); } -class ExcludeSelectedWalker : public scene::Graph::Walker { - bool m_exclude; +class ExcludeSelectedWalker : public scene::Graph::Walker +{ +bool m_exclude; public: - ExcludeSelectedWalker(bool exclude) - : m_exclude(exclude) - { - } - - bool pre(const scene::Path &path, scene::Instance &instance) const - { - exclude_node(path.top(), - (instance.isSelected() || instance.childSelected() || instance.parentSelected()) == m_exclude); - return true; - } +ExcludeSelectedWalker( bool exclude ) + : m_exclude( exclude ){ +} + +bool pre( const scene::Path& path, scene::Instance& instance ) const { + exclude_node( path.top(), ( instance.isSelected() || instance.childSelected() || instance.parentSelected() ) == m_exclude ); + return true; +} }; -void Scene_Exclude_Selected(bool exclude) -{ - GlobalSceneGraph().traverse(ExcludeSelectedWalker(exclude)); +void Scene_Exclude_Selected( bool exclude ){ + GlobalSceneGraph().traverse( ExcludeSelectedWalker( exclude ) ); } -class ExcludeRegionedWalker : public scene::Graph::Walker { - bool m_exclude; +class ExcludeRegionedWalker : public scene::Graph::Walker +{ +bool m_exclude; public: - ExcludeRegionedWalker(bool exclude) - : m_exclude(exclude) - { - } - - bool pre(const scene::Path &path, scene::Instance &instance) const - { - exclude_node( - path.top(), - !( - ( - aabb_intersects_aabb( - instance.worldAABB(), - aabb_for_minmax(region_mins, region_maxs) - ) != 0 - ) ^ m_exclude - ) - ); - - return true; - } +ExcludeRegionedWalker( bool exclude ) + : m_exclude( exclude ){ +} + +bool pre( const scene::Path& path, scene::Instance& instance ) const { + exclude_node( + path.top(), + !( + ( + aabb_intersects_aabb( + instance.worldAABB(), + aabb_for_minmax( region_mins, region_maxs ) + ) != 0 + ) ^ m_exclude + ) + ); + + return true; +} }; -void Scene_Exclude_Region(bool exclude) -{ - GlobalSceneGraph().traverse(ExcludeRegionedWalker(exclude)); +void Scene_Exclude_Region( bool exclude ){ + GlobalSceneGraph().traverse( ExcludeRegionedWalker( exclude ) ); } /* @@ -1503,25 +1620,25 @@ void Scene_Exclude_Region(bool exclude) Other filtering options may still be on =========== */ -void Map_RegionOff() -{ - region_active = false; +void Map_RegionOff(){ + region_active = false; + g_region_item.update(); - region_maxs[0] = g_MaxWorldCoord - 64; - region_mins[0] = g_MinWorldCoord + 64; - region_maxs[1] = g_MaxWorldCoord - 64; - region_mins[1] = g_MinWorldCoord + 64; - region_maxs[2] = g_MaxWorldCoord - 64; - region_mins[2] = g_MinWorldCoord + 64; + region_maxs[0] = g_MaxWorldCoord - 64; + region_mins[0] = g_MinWorldCoord + 64; + region_maxs[1] = g_MaxWorldCoord - 64; + region_mins[1] = g_MinWorldCoord + 64; + region_maxs[2] = g_MaxWorldCoord - 64; + region_mins[2] = g_MinWorldCoord + 64; - Scene_Exclude_All(false); + Scene_Exclude_All( false ); } -void Map_ApplyRegion(void) -{ - region_active = true; +void Map_ApplyRegion( void ){ + region_active = true; + g_region_item.update(); - Scene_Exclude_Region(false); + Scene_Exclude_Region( false ); } @@ -1530,19 +1647,19 @@ void Map_ApplyRegion(void) Map_RegionSelectedBrushes ======================== */ -void Map_RegionSelectedBrushes(void) -{ - Map_RegionOff(); +void Map_RegionSelectedBrushes( void ){ + Map_RegionOff(); - if (GlobalSelectionSystem().countSelected() != 0 - && GlobalSelectionSystem().Mode() == SelectionSystem::ePrimitive) { - region_active = true; - Select_GetBounds(region_mins, region_maxs); + if ( GlobalSelectionSystem().countSelected() != 0 + && GlobalSelectionSystem().Mode() == SelectionSystem::ePrimitive ) { + region_active = true; + g_region_item.update(); + Select_GetBounds( region_mins, region_maxs ); - Scene_Exclude_Selected(false); + Scene_Exclude_Selected( false ); - GlobalSelectionSystem().setSelectedAll(false); - } + GlobalSelectionSystem().setSelectedAll( false ); + } } @@ -1551,30 +1668,28 @@ void Map_RegionSelectedBrushes(void) Map_RegionXY =========== */ -void Map_RegionXY(float x_min, float y_min, float x_max, float y_max) -{ - Map_RegionOff(); +void Map_RegionXY( float x_min, float y_min, float x_max, float y_max ){ + Map_RegionOff(); - region_mins[0] = x_min; - region_maxs[0] = x_max; - region_mins[1] = y_min; - region_maxs[1] = y_max; - region_mins[2] = g_MinWorldCoord + 64; - region_maxs[2] = g_MaxWorldCoord - 64; + region_mins[0] = x_min; + region_maxs[0] = x_max; + region_mins[1] = y_min; + region_maxs[1] = y_max; + region_mins[2] = g_MinWorldCoord + 64; + region_maxs[2] = g_MaxWorldCoord - 64; - Map_ApplyRegion(); + Map_ApplyRegion(); } -void Map_RegionBounds(const AABB &bounds) -{ - Map_RegionOff(); +void Map_RegionBounds( const AABB& bounds ){ + Map_RegionOff(); - region_mins = vector3_subtracted(bounds.origin, bounds.extents); - region_maxs = vector3_added(bounds.origin, bounds.extents); + region_mins = vector3_subtracted( bounds.origin, bounds.extents ); + region_maxs = vector3_added( bounds.origin, bounds.extents ); - deleteSelection(); + deleteSelection(); - Map_ApplyRegion(); + Map_ApplyRegion(); } /* @@ -1582,12 +1697,11 @@ void Map_RegionBounds(const AABB &bounds) Map_RegionBrush =========== */ -void Map_RegionBrush(void) -{ - if (GlobalSelectionSystem().countSelected() != 0) { - scene::Instance &instance = GlobalSelectionSystem().ultimateSelected(); - Map_RegionBounds(instance.worldAABB()); - } +void Map_RegionBrush( void ){ + if ( GlobalSelectionSystem().countSelected() != 0 ) { + scene::Instance& instance = GlobalSelectionSystem().ultimateSelected(); + Map_RegionBounds( instance.worldAABB() ); + } } // @@ -1595,127 +1709,126 @@ void Map_RegionBrush(void) //Map_ImportFile //================ // -bool Map_ImportFile(const char *filename) -{ - ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Loading Map"); - - g_strLastMapFolder = g_path_get_dirname(filename); - - bool success = false; - - if (extension_equal(path_get_extension(filename), "bsp")) { - goto tryDecompile; - } - - { - const MapFormat *format = NULL; - const char *moduleName = findModuleName(&GlobalFiletypes(), MapFormat::Name(), path_get_extension(filename)); - if (string_not_empty(moduleName)) { - format = ReferenceAPI_getMapModules().findModule(moduleName); - } - - if (format) { - format->wrongFormat = false; - } - Resource *resource = GlobalReferenceCache().capture(filename); - resource->refresh(); // avoid loading old version if map has changed on disk since last import - if (!resource->load()) { - GlobalReferenceCache().release(filename); - goto tryDecompile; - } - if (format) { - if (format->wrongFormat) { - GlobalReferenceCache().release(filename); - goto tryDecompile; - } - } - NodeSmartReference clone(NewMapRoot("")); - Node_getTraversable(*resource->getNode())->traverse(CloneAll(clone)); - Map_gatherNamespaced(clone); - Map_mergeClonedNames(); - MergeMap(clone); - success = true; - GlobalReferenceCache().release(filename); - } - - SceneChangeNotify(); - - return success; - - tryDecompile: - - const char *type = GlobalRadiant().getGameDescriptionKeyValue("q3map2_type"); - int n = string_length(path_get_extension(filename)); - if (n && (extension_equal(path_get_extension(filename), "bsp") || - extension_equal(path_get_extension(filename), "map"))) { - StringBuffer output; - output.push_string(AppPath_get()); - output.push_string("q3map2."); - output.push_string(RADIANT_EXECUTABLE); - output.push_string(" -v -game "); - output.push_string((type && *type) ? type : "quake3"); - output.push_string(" -fs_basepath \""); - output.push_string(EnginePath_get()); - output.push_string("\" -fs_homepath \""); - output.push_string(g_qeglobals.m_userEnginePath.c_str()); - output.push_string("\""); - - // extra pakpaths - for (int i = 0; i < g_pakPathCount; i++) { - if (g_strcmp0(g_strPakPath[i].c_str(), "")) { - output.push_string(" -fs_pakpath \""); - output.push_string(g_strPakPath[i].c_str()); - output.push_string("\""); - } - } - - // extra switches - if (g_disableEnginePath) { - output.push_string(" -fs_nobasepath "); - } - - if (g_disableHomePath) { - output.push_string(" -fs_nohomepath "); - } - - output.push_string(" -fs_game "); - output.push_string(gamename_get()); - output.push_string(" -convert -format "); - output.push_string(Brush::m_type == eBrushTypeQuake3BP ? "map_bp" : "map"); - if (extension_equal(path_get_extension(filename), "map")) { - output.push_string(" -readmap "); - } - output.push_string(" \""); - output.push_string(filename); - output.push_string("\""); - - // run - Q_Exec(NULL, output.c_str(), NULL, false, true); - - // rebuild filename as "filenamewithoutext_converted.map" - output.clear(); - output.push_range(filename, filename + string_length(filename) - (n + 1)); - output.push_string("_converted.map"); - filename = output.c_str(); - - // open - Resource *resource = GlobalReferenceCache().capture(filename); - resource->refresh(); // avoid loading old version if map has changed on disk since last import - if (!resource->load()) { - GlobalReferenceCache().release(filename); - goto tryDecompile; - } - NodeSmartReference clone(NewMapRoot("")); - Node_getTraversable(*resource->getNode())->traverse(CloneAll(clone)); - Map_gatherNamespaced(clone); - Map_mergeClonedNames(); - MergeMap(clone); - success = true; - GlobalReferenceCache().release(filename); - } - - SceneChangeNotify(); - return success; +bool Map_ImportFile( const char* filename ){ + ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Loading Map" ); + + g_strLastMapFolder = g_path_get_dirname( filename ); + + bool success = false; + + if ( extension_equal( path_get_extension( filename ), "bsp" ) ) { + goto tryDecompile; + } + + { + const MapFormat* format = NULL; + const char* moduleName = findModuleName( &GlobalFiletypes(), MapFormat::Name(), path_get_extension( filename ) ); + if ( string_not_empty( moduleName ) ) { + format = ReferenceAPI_getMapModules().findModule( moduleName ); + } + + if ( format ) { + format->wrongFormat = false; + } + Resource* resource = GlobalReferenceCache().capture( filename ); + resource->refresh(); // avoid loading old version if map has changed on disk since last import + if ( !resource->load() ) { + GlobalReferenceCache().release( filename ); + goto tryDecompile; + } + if ( format ) { + if ( format->wrongFormat ) { + GlobalReferenceCache().release( filename ); + goto tryDecompile; + } + } + NodeSmartReference clone( NewMapRoot( "" ) ); + Node_getTraversable( *resource->getNode() )->traverse( CloneAll( clone ) ); + Map_gatherNamespaced( clone ); + Map_mergeClonedNames(); + MergeMap( clone ); + success = true; + GlobalReferenceCache().release( filename ); + } + + SceneChangeNotify(); + + return success; + +tryDecompile: + + const char *type = GlobalRadiant().getGameDescriptionKeyValue( "q3map2_type" ); + int n = string_length( path_get_extension( filename ) ); + if ( n && ( extension_equal( path_get_extension( filename ), "bsp" ) || extension_equal( path_get_extension( filename ), "map" ) ) ) { + std::string output; + output += AppPath_get(); + output += "q3map2"; + output += GDEF_OS_EXE_EXT; + + output += " -v -game "; + output += ( type && *type ) ? type : "quake3"; + output += " -fs_basepath \""; + output += EnginePath_get(); + output += "\" -fs_homepath \""; + output += g_qeglobals.m_userEnginePath.c_str(); + output += "\""; + + // extra pakpaths + for ( int i = 0; i < g_pakPathCount; i++ ) { + if ( g_strcmp0( g_strPakPath[i].c_str(), "") ) { + output += " -fs_pakpath \""; + output += g_strPakPath[i].c_str(); + output += "\""; + } + } + + // extra switches + if ( g_disableEnginePath ) { + output += " -fs_nobasepath "; + } + + if ( g_disableHomePath ) { + output += " -fs_nohomepath "; + } + + output += " -fs_game "; + output += gamename_get(); + output += " -convert -format "; + output += Brush::m_type == eBrushTypeQuake3BP ? "map_bp" : "map"; + if ( extension_equal( path_get_extension( filename ), "map" ) ) { + output += " -readmap "; + } + output += " \""; + output += filename; + output += "\""; + + // run + Q_Exec( NULL, output.c_str(), NULL, false, true ); + + // rebuild filename as "filenamewithoutext_converted.map" + output = ""; + output.append( filename, string_length( filename ) - ( n + 1 ) ); + output += "_converted.map"; + filename = output.c_str(); + + // open + Resource* resource = GlobalReferenceCache().capture( filename ); + resource->refresh(); // avoid loading old version if map has changed on disk since last import + if ( !resource->load() ) { + GlobalReferenceCache().release( filename ); + goto tryDecompile; + } + NodeSmartReference clone( NewMapRoot( "" ) ); + Node_getTraversable( *resource->getNode() )->traverse( CloneAll( clone ) ); + Map_gatherNamespaced( clone ); + Map_mergeClonedNames(); + MergeMap( clone ); + success = true; + GlobalReferenceCache().release( filename ); + } + + SceneChangeNotify(); + return success; } /* @@ -1723,16 +1836,15 @@ bool Map_ImportFile(const char *filename) Map_SaveFile =========== */ -bool Map_SaveFile(const char *filename) -{ - ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Saving Map"); - bool success = MapResource_saveFile(MapFormat_forFile(filename), GlobalSceneGraph().root(), Map_Traverse, filename); - if (success) { - // refresh VFS to apply new pak filtering based on mapname - // needed for daemon DPK VFS - VFS_Refresh(); - } - return success; +bool Map_SaveFile( const char* filename ){ + ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Saving Map" ); + bool success = MapResource_saveFile( MapFormat_forFile( filename ), GlobalSceneGraph().root(), Map_Traverse, filename ); + if ( success ) { + // refresh VFS to apply new pak filtering based on mapname + // needed for daemon DPK VFS + VFS_Refresh(); + } + return success; } // @@ -1742,622 +1854,603 @@ bool Map_SaveFile(const char *filename) // // Saves selected world brushes and whole entities with partial/full selections // -bool Map_SaveSelected(const char *filename) -{ - return MapResource_saveFile(MapFormat_forFile(filename), GlobalSceneGraph().root(), Map_Traverse_Selected, - filename); +bool Map_SaveSelected( const char* filename ){ + return MapResource_saveFile( MapFormat_forFile( filename ), GlobalSceneGraph().root(), Map_Traverse_Selected, filename ); } - -class ParentSelectedBrushesToEntityWalker : public scene::Graph::Walker { - scene::Node &m_parent; -public: - ParentSelectedBrushesToEntityWalker(scene::Node &parent) : m_parent(parent) - { - } - - bool pre(const scene::Path &path, scene::Instance &instance) const - { - if (path.top().get_pointer() != &m_parent - && Node_isPrimitive(path.top())) { - Selectable *selectable = Instance_getSelectable(instance); - if (selectable != 0 - && selectable->isSelected() - && path.size() > 1) { - return false; - } - } - return true; - } - - void post(const scene::Path &path, scene::Instance &instance) const - { - if (path.top().get_pointer() != &m_parent - && Node_isPrimitive(path.top())) { - Selectable *selectable = Instance_getSelectable(instance); - if (selectable != 0 - && selectable->isSelected() - && path.size() > 1) { - scene::Node &parent = path.parent(); - if (&parent != &m_parent) { - NodeSmartReference node(path.top().get()); - Node_getTraversable(parent)->erase(node); - Node_getTraversable(m_parent)->insert(node); - } - } - } - } -}; - -void Scene_parentSelectedBrushesToEntity(scene::Graph &graph, scene::Node &parent) +class ParentSelectedBrushesToEntityWalker : public scene::Graph::Walker { - graph.traverse(ParentSelectedBrushesToEntityWalker(parent)); -} + scene::Node& m_parent; + mutable bool m_emptyOldParent; -class CountSelectedBrushes : public scene::Graph::Walker { - std::size_t &m_count; - mutable std::size_t m_depth; public: - CountSelectedBrushes(std::size_t &count) : m_count(count), m_depth(0) - { - m_count = 0; - } - - bool pre(const scene::Path &path, scene::Instance &instance) const - { - if (++m_depth != 1 && path.top().get().isRoot()) { - return false; - } - Selectable *selectable = Instance_getSelectable(instance); - if (selectable != 0 - && selectable->isSelected() - && Node_isPrimitive(path.top())) { - ++m_count; - } - return true; - } - - void post(const scene::Path &path, scene::Instance &instance) const - { - --m_depth; - } -}; - -std::size_t Scene_countSelectedBrushes(scene::Graph &graph) -{ - std::size_t count; - graph.traverse(CountSelectedBrushes(count)); - return count; +ParentSelectedBrushesToEntityWalker( scene::Node& parent ) : m_parent( parent ), m_emptyOldParent( false ){ +} + +bool pre( const scene::Path& path, scene::Instance& instance ) const { + if ( path.top().get_pointer() != &m_parent && ( Node_isPrimitive( path.top() ) || m_emptyOldParent ) ) { + Selectable* selectable = Instance_getSelectable( instance ); + if ( selectable && selectable->isSelected() && path.size() > 1 ) { + return false; + } + } + return true; +} + +void post( const scene::Path& path, scene::Instance& instance ) const { + if ( path.top().get_pointer() == &m_parent ) + return; + + if ( Node_isPrimitive( path.top() ) ){ + m_emptyOldParent = false; + Selectable* selectable = Instance_getSelectable( instance ); + + if ( selectable && selectable->isSelected() && path.size() > 1 ){ + scene::Node& parent = path.parent(); + if ( &parent != &m_parent ){ + NodeSmartReference node( path.top().get() ); + scene::Traversable* traversable_parent = Node_getTraversable( parent ); + traversable_parent->erase( node ); + Node_getTraversable( m_parent )->insert( node ); + if ( traversable_parent->empty() ) + m_emptyOldParent = true; + } + } + } + else if ( m_emptyOldParent ){ + m_emptyOldParent = false; + // delete empty entities + Entity* entity = Node_getEntity( path.top() ); + if ( entity != 0 && path.top().get_pointer() != Map_FindWorldspawn( g_map ) && Node_getTraversable( path.top() )->empty() ) { + Path_deleteTop( path ); + } + } } - -enum ENodeType { - eNodeUnknown, - eNodeMap, - eNodeEntity, - eNodePrimitive, }; -const char *nodetype_get_name(ENodeType type) -{ - if (type == eNodeMap) { - return "map"; - } - if (type == eNodeEntity) { - return "entity"; - } - if (type == eNodePrimitive) { - return "primitive"; - } - return "unknown"; -} - -ENodeType node_get_nodetype(scene::Node &node) -{ - if (Node_isEntity(node)) { - return eNodeEntity; - } - if (Node_isPrimitive(node)) { - return eNodePrimitive; - } - return eNodeUnknown; +void Scene_parentSelectedBrushesToEntity( scene::Graph& graph, scene::Node& parent ){ + graph.traverse( ParentSelectedBrushesToEntityWalker( parent ) ); } -bool contains_entity(scene::Node &node) +class CountSelectedBrushes : public scene::Graph::Walker { - return Node_getTraversable(node) != 0 && !Node_isBrush(node) && !Node_isPatch(node) && !Node_isEntity(node); +std::size_t& m_count; +mutable std::size_t m_depth; +public: +CountSelectedBrushes( std::size_t& count ) : m_count( count ), m_depth( 0 ){ + m_count = 0; } -bool contains_primitive(scene::Node &node) -{ - return Node_isEntity(node) && Node_getTraversable(node) != 0 && Node_getEntity(node)->isContainer(); +bool pre( const scene::Path& path, scene::Instance& instance ) const { + if ( ++m_depth != 1 && path.top().get().isRoot() ) { + return false; + } + Selectable* selectable = Instance_getSelectable( instance ); + if ( selectable != 0 + && selectable->isSelected() + && Node_isPrimitive( path.top() ) ) { + ++m_count; + } + return true; } -ENodeType node_get_contains(scene::Node &node) -{ - if (contains_entity(node)) { - return eNodeEntity; - } - if (contains_primitive(node)) { - return eNodePrimitive; - } - return eNodeUnknown; +void post( const scene::Path& path, scene::Instance& instance ) const { + --m_depth; } +}; -void Path_parent(const scene::Path &parent, const scene::Path &child) -{ - ENodeType contains = node_get_contains(parent.top()); - ENodeType type = node_get_nodetype(child.top()); - - if (contains != eNodeUnknown && contains == type) { - NodeSmartReference node(child.top().get()); - Path_deleteTop(child); - Node_getTraversable(parent.top())->insert(node); - SceneChangeNotify(); - } else { - globalErrorStream() << "failed - " << nodetype_get_name(type) << " cannot be parented to " - << nodetype_get_name(contains) << " container.\n"; - } +std::size_t Scene_countSelectedBrushes( scene::Graph& graph ){ + std::size_t count; + graph.traverse( CountSelectedBrushes( count ) ); + return count; } -void Scene_parentSelected() +enum ENodeType { - UndoableCommand undo("parentSelected"); + eNodeUnknown, + eNodeMap, + eNodeEntity, + eNodePrimitive, +}; - if (GlobalSelectionSystem().countSelected() > 1) { - class ParentSelectedBrushesToEntityWalker : public SelectionSystem::Visitor { - const scene::Path &m_parent; - public: - ParentSelectedBrushesToEntityWalker(const scene::Path &parent) : m_parent(parent) - { - } +const char* nodetype_get_name( ENodeType type ){ + if ( type == eNodeMap ) { + return "map"; + } + if ( type == eNodeEntity ) { + return "entity"; + } + if ( type == eNodePrimitive ) { + return "primitive"; + } + return "unknown"; +} + +ENodeType node_get_nodetype( scene::Node& node ){ + if ( Node_isEntity( node ) ) { + return eNodeEntity; + } + if ( Node_isPrimitive( node ) ) { + return eNodePrimitive; + } + return eNodeUnknown; +} + +bool contains_entity( scene::Node& node ){ + return Node_getTraversable( node ) != 0 && !Node_isBrush( node ) && !Node_isPatch( node ) && !Node_isEntity( node ); +} + +bool contains_primitive( scene::Node& node ){ + return Node_isEntity( node ) && Node_getTraversable( node ) != 0 && Node_getEntity( node )->isContainer(); +} + +ENodeType node_get_contains( scene::Node& node ){ + if ( contains_entity( node ) ) { + return eNodeEntity; + } + if ( contains_primitive( node ) ) { + return eNodePrimitive; + } + return eNodeUnknown; +} + +void Path_parent( const scene::Path& parent, const scene::Path& child ){ + ENodeType contains = node_get_contains( parent.top() ); + ENodeType type = node_get_nodetype( child.top() ); + + if ( contains != eNodeUnknown && contains == type ) { + NodeSmartReference node( child.top().get() ); + Path_deleteTop( child ); + Node_getTraversable( parent.top() )->insert( node ); + SceneChangeNotify(); + } + else + { + globalErrorStream() << "failed - " << nodetype_get_name( type ) << " cannot be parented to " << nodetype_get_name( contains ) << " container.\n"; + } +} + +void Scene_parentSelected(){ + UndoableCommand undo( "parentSelected" ); + + if ( GlobalSelectionSystem().countSelected() > 1 ) { + class ParentSelectedBrushesToEntityWalker : public SelectionSystem::Visitor + { + const scene::Path& m_parent; +public: + ParentSelectedBrushesToEntityWalker( const scene::Path& parent ) : m_parent( parent ){ + } - void visit(scene::Instance &instance) const - { - if (&m_parent != &instance.path()) { - Path_parent(m_parent, instance.path()); - } - } - }; + void visit( scene::Instance& instance ) const { + if ( &m_parent != &instance.path() ) { + Path_parent( m_parent, instance.path() ); + } + } + }; - ParentSelectedBrushesToEntityWalker visitor(GlobalSelectionSystem().ultimateSelected().path()); - GlobalSelectionSystem().foreachSelected(visitor); - } else { - globalOutputStream() << "failed - did not find two selected nodes.\n"; - } + ParentSelectedBrushesToEntityWalker visitor( GlobalSelectionSystem().ultimateSelected().path() ); + GlobalSelectionSystem().foreachSelected( visitor ); + } + else + { + globalOutputStream() << "failed - did not find two selected nodes.\n"; + } } -void NewMap() -{ - if (ConfirmModified("New Map")) { - Map_RegionOff(); - Map_Free(); - Map_New(); - } +void NewMap(){ + if ( ConfirmModified( "New Map" ) ) { + Map_RegionOff(); + Map_Free(); + Map_New(); + } } CopiedString g_mapsPath; -const char *getMapsPath() -{ - return g_mapsPath.c_str(); +const char* getMapsPath(){ + return g_mapsPath.c_str(); } -const char *getLastMapFolderPath() -{ - if (g_strLastMapFolder.empty()) { - GlobalPreferenceSystem().registerPreference("LastMapFolder", make_property_string(g_strLastMapFolder)); - if (g_strLastMapFolder.empty()) { - StringOutputStream buffer(1024); - buffer << getMapsPath(); - if (!file_readable(buffer.c_str())) { - buffer.clear(); - buffer << g_qeglobals.m_userGamePath.c_str() << "/"; - } - g_strLastMapFolder = buffer.c_str(); - } - } - return g_strLastMapFolder.c_str(); -} - -const char *map_open(const char *title) -{ - return MainFrame_getWindow().file_dialog(TRUE, title, getLastMapFolderPath(), MapFormat::Name(), true, false, false); +const char* getLastMapFolderPath(){ + if (g_strLastMapFolder.empty()) { + GlobalPreferenceSystem().registerPreference( "LastMapFolder", make_property_string( g_strLastMapFolder ) ); + if (g_strLastMapFolder.empty()) { + StringOutputStream buffer( 1024 ); + buffer << getMapsPath(); + if ( !file_readable( buffer.c_str() ) ) { + buffer.clear(); + buffer << g_qeglobals.m_userGamePath.c_str() << "/"; + } + g_strLastMapFolder = buffer.c_str(); + } + } + return g_strLastMapFolder.c_str(); } -const char *map_import(const char *title) -{ - return MainFrame_getWindow().file_dialog(TRUE, title, getLastMapFolderPath(), MapFormat::Name(), false, true, false); +const char* map_open( const char* title ){ + return MainFrame_getWindow().file_dialog( TRUE, title, getLastMapFolderPath(), MapFormat::Name(), true, false, false ); } -const char *map_save(const char *title) -{ - return MainFrame_getWindow().file_dialog(FALSE, title, getLastMapFolderPath(), MapFormat::Name(), false, false, true); +const char* map_import( const char* title ){ + return MainFrame_getWindow().file_dialog( TRUE, title, getLastMapFolderPath(), MapFormat::Name(), false, true, false ); } -void OpenMap() -{ - if (!ConfirmModified("Open Map")) { - return; - } +const char* map_save( const char* title ){ + return MainFrame_getWindow().file_dialog( FALSE, title, getLastMapFolderPath(), MapFormat::Name(), false, false, true ); +} - const char *filename = map_open("Open Map"); +void OpenMap(){ + if ( !ConfirmModified( "Open Map" ) ) { + return; + } - if (filename != NULL) { - MRU_AddFile(filename); - Map_RegionOff(); - Map_Free(); - Map_LoadFile(filename); - } + const char* filename = map_open( "Open Map" ); + + if ( filename != NULL ) { + MRU_AddFile( filename ); + Map_RegionOff(); + Map_Free(); + Map_LoadFile( filename ); + } } -void ImportMap() -{ - const char *filename = map_import("Import Map"); +void ImportMap(){ + const char* filename = map_import( "Import Map" ); - if (filename != NULL) { - UndoableCommand undo("mapImport"); - Map_ImportFile(filename); - } + if ( filename != NULL ) { + UndoableCommand undo( "mapImport" ); + Map_ImportFile( filename ); + } } -bool Map_SaveAs() -{ - const char *filename = map_save("Save Map"); +bool Map_SaveAs(){ + const char* filename = map_save( "Save Map" ); - if (filename != NULL) { - g_strLastMapFolder = g_path_get_dirname(filename); - MRU_AddFile(filename); - Map_Rename(filename); - return Map_Save(); - } - return false; + if ( filename != NULL ) { + g_strLastMapFolder = g_path_get_dirname( filename ); + MRU_AddFile( filename ); + Map_Rename( filename ); + return Map_Save(); + } + return false; } -void SaveMapAs() -{ - Map_SaveAs(); +void SaveMapAs(){ + Map_SaveAs(); } -void SaveMap() -{ - if (Map_Unnamed(g_map)) { - SaveMapAs(); - } else if (Map_Modified(g_map)) { - Map_Save(); - } +void SaveMap(){ + if ( Map_Unnamed( g_map ) ) { + SaveMapAs(); + } + else if ( Map_Modified( g_map ) ) { + Map_Save(); + MRU_AddFile( g_map.m_name.c_str() ); //add on saving, but not opening via cmd line: spoils the list + } } -void ExportMap() -{ - const char *filename = map_save("Export Selection"); +void ExportMap(){ + const char* filename = map_save( "Export Selection" ); - if (filename != NULL) { - g_strLastMapFolder = g_path_get_dirname(filename); - Map_SaveSelected(filename); - } + if ( filename != NULL ) { + g_strLastMapFolder = g_path_get_dirname( filename ); + Map_SaveSelected( filename ); + } } -void SaveRegion() -{ - const char *filename = map_save("Export Region"); +void SaveRegion(){ + const char* filename = map_save( "Export Region" ); - if (filename != NULL) { - g_strLastMapFolder = g_path_get_dirname(filename); - Map_SaveRegion(filename); - } + if ( filename != NULL ) { + g_strLastMapFolder = g_path_get_dirname( filename ); + Map_SaveRegion( filename ); + } } -void RegionOff() -{ - Map_RegionOff(); - SceneChangeNotify(); +void RegionOff(){ + Map_RegionOff(); + SceneChangeNotify(); } -void RegionXY() -{ - Map_RegionXY( - g_pParentWnd->GetXYWnd()->GetOrigin()[0] - - 0.5f * g_pParentWnd->GetXYWnd()->Width() / g_pParentWnd->GetXYWnd()->Scale(), - g_pParentWnd->GetXYWnd()->GetOrigin()[1] - - 0.5f * g_pParentWnd->GetXYWnd()->Height() / g_pParentWnd->GetXYWnd()->Scale(), - g_pParentWnd->GetXYWnd()->GetOrigin()[0] + - 0.5f * g_pParentWnd->GetXYWnd()->Width() / g_pParentWnd->GetXYWnd()->Scale(), - g_pParentWnd->GetXYWnd()->GetOrigin()[1] + - 0.5f * g_pParentWnd->GetXYWnd()->Height() / g_pParentWnd->GetXYWnd()->Scale() - ); - SceneChangeNotify(); -} - -void RegionBrush() -{ - Map_RegionBrush(); - SceneChangeNotify(); +void RegionXY(){ + Map_RegionXY( + g_pParentWnd->GetXYWnd()->GetOrigin()[0] - 0.5f * g_pParentWnd->GetXYWnd()->Width() / g_pParentWnd->GetXYWnd()->Scale(), + g_pParentWnd->GetXYWnd()->GetOrigin()[1] - 0.5f * g_pParentWnd->GetXYWnd()->Height() / g_pParentWnd->GetXYWnd()->Scale(), + g_pParentWnd->GetXYWnd()->GetOrigin()[0] + 0.5f * g_pParentWnd->GetXYWnd()->Width() / g_pParentWnd->GetXYWnd()->Scale(), + g_pParentWnd->GetXYWnd()->GetOrigin()[1] + 0.5f * g_pParentWnd->GetXYWnd()->Height() / g_pParentWnd->GetXYWnd()->Scale() + ); + SceneChangeNotify(); } -void RegionSelected() -{ - Map_RegionSelectedBrushes(); - SceneChangeNotify(); +void RegionBrush(){ + Map_RegionBrush(); + SceneChangeNotify(); } +void RegionSelected(){ + Map_RegionSelectedBrushes(); + SceneChangeNotify(); +} + + + + -class BrushFindByIndexWalker : public scene::Traversable::Walker { - mutable std::size_t m_index; - scene::Path &m_path; +class BrushFindByIndexWalker : public scene::Traversable::Walker +{ +mutable std::size_t m_index; +scene::Path& m_path; public: - BrushFindByIndexWalker(std::size_t index, scene::Path &path) - : m_index(index), m_path(path) - { - } - - bool pre(scene::Node &node) const - { - if (Node_isPrimitive(node) && m_index-- == 0) { - m_path.push(makeReference(node)); - } - return false; - } +BrushFindByIndexWalker( std::size_t index, scene::Path& path ) + : m_index( index ), m_path( path ){ +} + +bool pre( scene::Node& node ) const { + if ( Node_isPrimitive( node ) && m_index-- == 0 ) { + m_path.push( makeReference( node ) ); + } + return false; +} }; -class EntityFindByIndexWalker : public scene::Traversable::Walker { - mutable std::size_t m_index; - scene::Path &m_path; +class EntityFindByIndexWalker : public scene::Traversable::Walker +{ +mutable std::size_t m_index; +scene::Path& m_path; public: - EntityFindByIndexWalker(std::size_t index, scene::Path &path) - : m_index(index), m_path(path) - { - } - - bool pre(scene::Node &node) const - { - if (Node_isEntity(node) && m_index-- == 0) { - m_path.push(makeReference(node)); - } - return false; - } +EntityFindByIndexWalker( std::size_t index, scene::Path& path ) + : m_index( index ), m_path( path ){ +} + +bool pre( scene::Node& node ) const { + if ( Node_isEntity( node ) && m_index-- == 0 ) { + m_path.push( makeReference( node ) ); + } + return false; +} }; -void Scene_FindEntityBrush(std::size_t entity, std::size_t brush, scene::Path &path) -{ - path.push(makeReference(GlobalSceneGraph().root())); - { - Node_getTraversable(path.top())->traverse(EntityFindByIndexWalker(entity, path)); - } - if (path.size() == 2) { - scene::Traversable *traversable = Node_getTraversable(path.top()); - if (traversable != 0) { - traversable->traverse(BrushFindByIndexWalker(brush, path)); - } - } -} - -inline bool Node_hasChildren(scene::Node &node) -{ - scene::Traversable *traversable = Node_getTraversable(node); - return traversable != 0 && !traversable->empty(); +void Scene_FindEntityBrush( std::size_t entity, std::size_t brush, scene::Path& path ){ + path.push( makeReference( GlobalSceneGraph().root() ) ); + { + Node_getTraversable( path.top() )->traverse( EntityFindByIndexWalker( entity, path ) ); + } + if ( path.size() == 2 ) { + scene::Traversable* traversable = Node_getTraversable( path.top() ); + if ( traversable != 0 ) { + traversable->traverse( BrushFindByIndexWalker( brush, path ) ); + } + } } -void SelectBrush(int entitynum, int brushnum) +inline bool Node_hasChildren( scene::Node& node ){ + scene::Traversable* traversable = Node_getTraversable( node ); + return traversable != 0 && !traversable->empty(); +} + +void SelectBrush( int entitynum, int brushnum ){ + scene::Path path; + Scene_FindEntityBrush( entitynum, brushnum, path ); + if ( path.size() == 3 || ( path.size() == 2 && !Node_hasChildren( path.top() ) ) ) { + scene::Instance* instance = GlobalSceneGraph().find( path ); + ASSERT_MESSAGE( instance != 0, "SelectBrush: path not found in scenegraph" ); + Selectable* selectable = Instance_getSelectable( *instance ); + ASSERT_MESSAGE( selectable != 0, "SelectBrush: path not selectable" ); + selectable->setSelected( true ); + g_pParentWnd->GetXYWnd()->PositionView( instance->worldAABB().origin ); + } +} + + +class BrushFindIndexWalker : public scene::Traversable::Walker { - scene::Path path; - Scene_FindEntityBrush(entitynum, brushnum, path); - if (path.size() == 3 || (path.size() == 2 && !Node_hasChildren(path.top()))) { - scene::Instance *instance = GlobalSceneGraph().find(path); - ASSERT_MESSAGE(instance != 0, "SelectBrush: path not found in scenegraph"); - Selectable *selectable = Instance_getSelectable(*instance); - ASSERT_MESSAGE(selectable != 0, "SelectBrush: path not selectable"); - selectable->setSelected(true); - g_pParentWnd->GetXYWnd()->PositionView(instance->worldAABB().origin); - } -} - - -class BrushFindIndexWalker : public scene::Graph::Walker { - mutable const scene::Node *m_node; - std::size_t &m_count; +mutable const scene::Node* m_node; +std::size_t& m_count; public: - BrushFindIndexWalker(const scene::Node &node, std::size_t &count) - : m_node(&node), m_count(count) - { - } - - bool pre(const scene::Path &path, scene::Instance &instance) const - { - if (Node_isPrimitive(path.top())) { - if (m_node == path.top().get_pointer()) { - m_node = 0; - } - if (m_node) { - ++m_count; - } - } - return true; - } -}; +BrushFindIndexWalker( const scene::Node& node, std::size_t& count ) + : m_node( &node ), m_count( count ){ +} -class EntityFindIndexWalker : public scene::Graph::Walker { - mutable const scene::Node *m_node; - std::size_t &m_count; -public: - EntityFindIndexWalker(const scene::Node &node, std::size_t &count) - : m_node(&node), m_count(count) - { - } - - bool pre(const scene::Path &path, scene::Instance &instance) const - { - if (Node_isEntity(path.top())) { - if (m_node == path.top().get_pointer()) { - m_node = 0; - } - if (m_node) { - ++m_count; - } - } - return true; - } +bool pre( scene::Node& node ) const { + if ( Node_isPrimitive( node ) ) { + if ( m_node == &node ) { + m_node = 0; + } + if ( m_node ) { + ++m_count; + } + } + return true; +} }; -static void GetSelectionIndex(int *ent, int *brush) +class EntityFindIndexWalker : public scene::Traversable::Walker { - std::size_t count_brush = 0; - std::size_t count_entity = 0; - if (GlobalSelectionSystem().countSelected() != 0) { - const scene::Path &path = GlobalSelectionSystem().ultimateSelected().path(); +mutable const scene::Node* m_node; +std::size_t& m_count; +public: +EntityFindIndexWalker( const scene::Node& node, std::size_t& count ) + : m_node( &node ), m_count( count ){ +} - GlobalSceneGraph().traverse(BrushFindIndexWalker(path.top(), count_brush)); - GlobalSceneGraph().traverse(EntityFindIndexWalker(path.parent(), count_entity)); - } - *brush = int(count_brush); - *ent = int(count_entity); +bool pre( scene::Node& node ) const { + if ( Node_isEntity( node ) ) { + if ( m_node == &node ) { + m_node = 0; + } + if ( m_node ) { + ++m_count; + } + } + return true; } +}; -void DoFind() -{ - ModalDialog dialog; - ui::Entry entity{ui::null}; - ui::Entry brush{ui::null}; - - ui::Window window = MainFrame_getWindow().create_dialog_window("Find Brush", G_CALLBACK(dialog_delete_callback), - &dialog); - - auto accel = ui::AccelGroup(ui::New); - window.add_accel_group(accel); - - { - auto vbox = create_dialog_vbox(4, 4); - window.add(vbox); - { - auto table = create_dialog_table(2, 2, 4, 4); - vbox.pack_start(table, TRUE, TRUE, 0); - { - ui::Widget label = ui::Label("Entity number"); - label.show(); +static void GetSelectionIndex( int *ent, int *brush ){ + std::size_t count_brush = 0; + std::size_t count_entity = 0; + if ( GlobalSelectionSystem().countSelected() != 0 ) { + const scene::Path& path = GlobalSelectionSystem().ultimateSelected().path(); + + { + scene::Traversable* traversable = Node_getTraversable( path.parent() ); + if ( traversable != 0 && path.size() == 3 ) { + traversable->traverse( BrushFindIndexWalker( path.top(), count_brush ) ); + } + } + + { + scene::Traversable* traversable = Node_getTraversable( GlobalSceneGraph().root() ); + if ( traversable != 0 ) { + if( path.size() == 3 ){ + traversable->traverse( EntityFindIndexWalker( path.parent(), count_entity ) ); + } + else if ( path.size() == 2 ){ + traversable->traverse( EntityFindIndexWalker( path.top(), count_entity ) ); + } + } + } + } + *brush = int(count_brush); + *ent = int(count_entity); +} + +void DoFind(){ + ModalDialog dialog; + ui::Entry entity{ui::null}; + ui::Entry brush{ui::null}; + + ui::Window window = MainFrame_getWindow().create_dialog_window("Find Brush", G_CALLBACK(dialog_delete_callback ), &dialog ); + + auto accel = ui::AccelGroup(ui::New); + window.add_accel_group( accel ); + + { + auto vbox = create_dialog_vbox( 4, 4 ); + window.add(vbox); + { + auto table = create_dialog_table( 2, 2, 4, 4 ); + vbox.pack_start( table, TRUE, TRUE, 0 ); + { + ui::Widget label = ui::Label( "Entity number" ); + label.show(); (table).attach(label, {0, 1, 0, 1}, {0, 0}); - } - { - ui::Widget label = ui::Label("Brush number"); - label.show(); + } + { + ui::Widget label = ui::Label( "Brush number" ); + label.show(); (table).attach(label, {0, 1, 1, 2}, {0, 0}); - } - { - auto entry = ui::Entry(ui::New); - entry.show(); + } + { + auto entry = ui::Entry(ui::New); + entry.show(); table.attach(entry, {1, 2, 0, 1}, {GTK_EXPAND | GTK_FILL, 0}); - gtk_widget_grab_focus(entry); - entity = entry; - } - { - auto entry = ui::Entry(ui::New); - entry.show(); + gtk_widget_grab_focus( entry ); + entity = entry; + } + { + auto entry = ui::Entry(ui::New); + entry.show(); table.attach(entry, {1, 2, 1, 2}, {GTK_EXPAND | GTK_FILL, 0}); - brush = entry; - } - } - { - auto hbox = create_dialog_hbox(4); - vbox.pack_start(hbox, TRUE, TRUE, 0); - { - auto button = create_dialog_button("Find", G_CALLBACK(dialog_button_ok), &dialog); - hbox.pack_start(button, FALSE, FALSE, 0); - widget_make_default(button); - gtk_widget_add_accelerator(button, "clicked", accel, GDK_KEY_Return, (GdkModifierType) 0, - (GtkAccelFlags) 0); - } - { - auto button = create_dialog_button("Close", G_CALLBACK(dialog_button_cancel), &dialog); - hbox.pack_start(button, FALSE, FALSE, 0); - gtk_widget_add_accelerator(button, "clicked", accel, GDK_KEY_Escape, (GdkModifierType) 0, - (GtkAccelFlags) 0); - } - } - } - - // Initialize dialog - char buf[16]; - int ent, br; - - GetSelectionIndex(&ent, &br); - sprintf(buf, "%i", ent); - entity.text(buf); - sprintf(buf, "%i", br); - brush.text(buf); - - if (modal_dialog_show(window, dialog) == eIDOK) { - const char *entstr = gtk_entry_get_text(entity); - const char *brushstr = gtk_entry_get_text(brush); - SelectBrush(atoi(entstr), atoi(brushstr)); - } + brush = entry; + } + } + { + auto hbox = create_dialog_hbox( 4 ); + vbox.pack_start( hbox, TRUE, TRUE, 0 ); + { + auto button = create_dialog_button( "Find", G_CALLBACK( dialog_button_ok ), &dialog ); + hbox.pack_start( button, FALSE, FALSE, 0 ); + widget_make_default( button ); + gtk_widget_add_accelerator( button , "clicked", accel, GDK_KEY_Return, (GdkModifierType)0, (GtkAccelFlags)0 ); + } + { + auto button = create_dialog_button( "Close", G_CALLBACK( dialog_button_cancel ), &dialog ); + hbox.pack_start( button, FALSE, FALSE, 0 ); + gtk_widget_add_accelerator( button , "clicked", accel, GDK_KEY_Escape, (GdkModifierType)0, (GtkAccelFlags)0 ); + } + } + } + + // Initialize dialog + char buf[16]; + int ent, br; + + GetSelectionIndex( &ent, &br ); + sprintf( buf, "%i", ent ); + entity.text(buf); + sprintf( buf, "%i", br ); + brush.text(buf); + + if ( modal_dialog_show( window, dialog ) == eIDOK ) { + const char *entstr = gtk_entry_get_text( entity ); + const char *brushstr = gtk_entry_get_text( brush ); + SelectBrush( atoi( entstr ), atoi( brushstr ) ); + } window.destroy(); } -void Map_constructPreferences(PreferencesPage &page) -{ - page.appendCheckBox("", "Load last map at startup", g_bLoadLastMap); - page.appendCheckBox("", "Add entity and brush number comments on map write", g_writeMapComments); +void Map_constructPreferences( PreferencesPage& page ){ + page.appendCheckBox( "", "Load last map at startup", g_bLoadLastMap ); + page.appendCheckBox( "", "Add entity and brush number comments on map write", g_writeMapComments ); } -class MapEntityClasses : public ModuleObserver { - std::size_t m_unrealised; +class MapEntityClasses : public ModuleObserver +{ +std::size_t m_unrealised; public: - MapEntityClasses() : m_unrealised(1) - { - } - - void realise() - { - if (--m_unrealised == 0) { - if (g_map.m_resource != 0) { - ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Loading Map"); - g_map.m_resource->realise(); - } - } - } - - void unrealise() - { - if (++m_unrealised == 1) { - if (g_map.m_resource != 0) { - g_map.m_resource->flush(); - g_map.m_resource->unrealise(); - } - } - } +MapEntityClasses() : m_unrealised( 1 ){ +} + +void realise(){ + if ( --m_unrealised == 0 ) { + if ( g_map.m_resource != 0 ) { + ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Loading Map" ); + g_map.m_resource->realise(); + } + } +} + +void unrealise(){ + if ( ++m_unrealised == 1 ) { + if ( g_map.m_resource != 0 ) { + g_map.m_resource->flush(); + g_map.m_resource->unrealise(); + } + } +} }; MapEntityClasses g_MapEntityClasses; -class MapModuleObserver : public ModuleObserver { - std::size_t m_unrealised; +class MapModuleObserver : public ModuleObserver +{ +std::size_t m_unrealised; public: - MapModuleObserver() : m_unrealised(1) - { - } - - void realise() - { - if (--m_unrealised == 0) { - ASSERT_MESSAGE(!string_empty(g_qeglobals.m_userGamePath.c_str()), - "maps_directory: user-game-path is empty"); - StringOutputStream buffer(256); - buffer << g_qeglobals.m_userGamePath.c_str() << "maps/"; - Q_mkdir(buffer.c_str()); - g_mapsPath = buffer.c_str(); - } - } - - void unrealise() - { - if (++m_unrealised == 1) { - g_mapsPath = ""; - } - } +MapModuleObserver() : m_unrealised( 1 ){ +} + +void realise(){ + if ( --m_unrealised == 0 ) { + ASSERT_MESSAGE( !string_empty( g_qeglobals.m_userGamePath.c_str() ), "maps_directory: user-game-path is empty" ); + StringOutputStream buffer( 256 ); + buffer << g_qeglobals.m_userGamePath.c_str() << "maps/"; + Q_mkdir( buffer.c_str() ); + g_mapsPath = buffer.c_str(); + } +} + +void unrealise(){ + if ( ++m_unrealised == 1 ) { + g_mapsPath = ""; + } +} }; MapModuleObserver g_MapModuleObserver; @@ -2365,27 +2458,25 @@ MapModuleObserver g_MapModuleObserver; CopiedString g_strLastMap; bool g_bLoadLastMap = false; -void Map_Construct() -{ - GlobalCommands_insert("RegionOff", makeCallbackF(RegionOff)); - GlobalCommands_insert("RegionSetXY", makeCallbackF(RegionXY)); - GlobalCommands_insert("RegionSetBrush", makeCallbackF(RegionBrush)); - GlobalCommands_insert("RegionSetSelection", makeCallbackF(RegionSelected), - Accelerator('R', (GdkModifierType) (GDK_SHIFT_MASK | GDK_CONTROL_MASK))); +void Map_Construct(){ + GlobalCommands_insert( "RegionOff", makeCallbackF(RegionOff) ); + GlobalCommands_insert( "RegionSetXY", makeCallbackF(RegionXY) ); + GlobalCommands_insert( "RegionSetBrush", makeCallbackF(RegionBrush) ); + //GlobalCommands_insert( "RegionSetSelection", makeCallbackF(RegionSelected), Accelerator( 'R', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) ); + GlobalToggles_insert( "RegionSetSelection", makeCallbackF(RegionSelected), ToggleItem::AddCallbackCaller( g_region_item ), Accelerator( 'R', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) ); - GlobalPreferenceSystem().registerPreference("LastMap", make_property_string(g_strLastMap)); - GlobalPreferenceSystem().registerPreference("LoadLastMap", make_property_string(g_bLoadLastMap)); - GlobalPreferenceSystem().registerPreference("MapInfoDlg", make_property(g_posMapInfoWnd)); - GlobalPreferenceSystem().registerPreference("WriteMapComments", make_property_string(g_writeMapComments)); + GlobalPreferenceSystem().registerPreference( "LastMap", make_property_string( g_strLastMap ) ); + GlobalPreferenceSystem().registerPreference( "LoadLastMap", make_property_string( g_bLoadLastMap ) ); + GlobalPreferenceSystem().registerPreference( "MapInfoDlg", make_property( g_posMapInfoWnd ) ); + GlobalPreferenceSystem().registerPreference( "WriteMapComments", make_property_string( g_writeMapComments ) ); - PreferencesDialog_addSettingsPreferences(makeCallbackF(Map_constructPreferences)); + PreferencesDialog_addSettingsPreferences( makeCallbackF(Map_constructPreferences) ); - GlobalEntityClassManager().attach(g_MapEntityClasses); - Radiant_attachHomePathsObserver(g_MapModuleObserver); + GlobalEntityClassManager().attach( g_MapEntityClasses ); + Radiant_attachHomePathsObserver( g_MapModuleObserver ); } -void Map_Destroy() -{ - Radiant_detachHomePathsObserver(g_MapModuleObserver); - GlobalEntityClassManager().detach(g_MapEntityClasses); +void Map_Destroy(){ + Radiant_detachHomePathsObserver( g_MapModuleObserver ); + GlobalEntityClassManager().detach( g_MapEntityClasses ); }