1 /*
2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include "eclass.h"
23
24 #include "debugging/debugging.h"
25
26 #include <map>
27
28 #include "ifilesystem.h"
29
30 #include "string/string.h"
31 #include "eclasslib.h"
32 #include "os/path.h"
33 #include "os/dir.h"
34 #include "stream/stringstream.h"
35 #include "moduleobservers.h"
36
37 #include "cmdlib.h"
38
39 #include "preferences.h"
40 #include "mainframe.h"
41
42
43 namespace
44 {
45 typedef std::map<const char*, EntityClass*, RawStringLessNoCase> EntityClasses;
46 EntityClasses g_entityClasses;
47 EntityClass *eclass_bad = 0;
48 char eclass_directory[1024];
49 typedef std::map<CopiedString, ListAttributeType> ListAttributeTypes;
50 ListAttributeTypes g_listTypes;
51 }
52
53 EClassModules& EntityClassManager_getEClassModules();
54
55 /*!
56 implementation of the EClass manager API
57 */
58
CleanEntityList(EntityClasses & entityClasses)59 void CleanEntityList( EntityClasses& entityClasses ){
60 for ( EntityClasses::iterator i = entityClasses.begin(); i != entityClasses.end(); ++i )
61 {
62 ( *i ).second->free( ( *i ).second );
63 }
64 entityClasses.clear();
65 }
66
Eclass_Clear()67 void Eclass_Clear(){
68 CleanEntityList( g_entityClasses );
69 g_listTypes.clear();
70 }
71
EClass_InsertSortedList(EntityClasses & entityClasses,EntityClass * entityClass)72 EntityClass* EClass_InsertSortedList( EntityClasses& entityClasses, EntityClass *entityClass ){
73 std::pair<EntityClasses::iterator, bool> result = entityClasses.insert( EntityClasses::value_type( entityClass->name(), entityClass ) );
74 if ( !result.second ) {
75 entityClass->free( entityClass );
76 }
77 return ( *result.first ).second;
78 }
79
Eclass_InsertAlphabetized(EntityClass * e)80 EntityClass* Eclass_InsertAlphabetized( EntityClass *e ){
81 return EClass_InsertSortedList( g_entityClasses, e );
82 }
83
Eclass_forEach(EntityClassVisitor & visitor)84 void Eclass_forEach( EntityClassVisitor& visitor ){
85 for ( EntityClasses::iterator i = g_entityClasses.begin(); i != g_entityClasses.end(); ++i )
86 {
87 visitor.visit( ( *i ).second );
88 }
89 }
90
91
92 class RadiantEclassCollector : public EntityClassCollector
93 {
94 public:
insert(EntityClass * eclass)95 void insert( EntityClass* eclass ){
96 Eclass_InsertAlphabetized( eclass );
97 }
insert(const char * name,const ListAttributeType & list)98 void insert( const char* name, const ListAttributeType& list ){
99 g_listTypes.insert( ListAttributeTypes::value_type( name, list ) );
100 }
101 };
102
103 RadiantEclassCollector g_collector;
104
EntityClass_findListType(const char * name)105 const ListAttributeType* EntityClass_findListType( const char* name ){
106 ListAttributeTypes::iterator i = g_listTypes.find( name );
107 if ( i != g_listTypes.end() ) {
108 return &( *i ).second;
109 }
110 return 0;
111 }
112
113
114 class EntityClassFilterMode
115 {
116 public:
117 bool filter_mp_sp;
118 const char* mp_ignore_prefix;
119 const char* sp_ignore_prefix;
120
EntityClassFilterMode()121 EntityClassFilterMode() :
122 filter_mp_sp( !string_empty( g_pGameDescription->getKeyValue( "eclass_filter_gamemode" ) ) ),
123 mp_ignore_prefix( g_pGameDescription->getKeyValue( "eclass_sp_prefix" ) ),
124 sp_ignore_prefix( g_pGameDescription->getKeyValue( "eclass_mp_prefix" ) ){
125 if ( string_empty( mp_ignore_prefix ) ) {
126 mp_ignore_prefix = "sp_";
127 }
128 if ( string_empty( sp_ignore_prefix ) ) {
129 sp_ignore_prefix = "mp_";
130 }
131 }
132 };
133
134 class EntityClassesLoadFile
135 {
136 const EntityClassScanner& scanner;
137 const char* m_directory;
138 public:
EntityClassesLoadFile(const EntityClassScanner & scanner,const char * directory)139 EntityClassesLoadFile( const EntityClassScanner& scanner, const char* directory ) : scanner( scanner ), m_directory( directory ){
140 }
operator ()(const char * name) const141 void operator()( const char* name ) const {
142 EntityClassFilterMode filterMode;
143
144 if ( filterMode.filter_mp_sp ) {
145 if ( string_empty( GlobalRadiant().getGameMode() ) || string_equal( GlobalRadiant().getGameMode(), "sp" ) ) {
146 if ( string_equal_n( name, filterMode.sp_ignore_prefix, strlen( filterMode.sp_ignore_prefix ) ) ) {
147 globalOutputStream() << "Ignoring '" << name << "'\n";
148 return;
149 }
150 }
151 else
152 {
153 if ( string_equal_n( name, filterMode.mp_ignore_prefix, strlen( filterMode.mp_ignore_prefix ) ) ) {
154 globalOutputStream() << "Ignoring '" << name << "'\n";
155 return;
156 }
157 }
158 }
159
160 // for a given name, we grab the first .def in the vfs
161 // this allows to override baseq3/scripts/entities.def for instance
162 StringOutputStream relPath( 256 );
163 relPath << m_directory << name;
164
165 scanner.scanFile( g_collector, relPath.c_str() );
166 }
167 };
168
169 struct PathLess
170 {
operator ()PathLess171 bool operator()( const CopiedString& path, const CopiedString& other ) const {
172 return path_less( path.c_str(), other.c_str() );
173 }
174 };
175
176 typedef std::map<CopiedString, const char*, PathLess> Paths;
177
178 class PathsInsert
179 {
180 Paths& m_paths;
181 const char* m_directory;
182 public:
PathsInsert(Paths & paths,const char * directory)183 PathsInsert( Paths& paths, const char* directory ) : m_paths( paths ), m_directory( directory ){
184 }
operator ()(const char * name) const185 void operator()( const char* name ) const {
186 m_paths.insert( Paths::value_type( name, m_directory ) );
187 }
188 };
189
190
EntityClassQuake3_constructDirectory(const char * directory,const char * extension,Paths & paths)191 void EntityClassQuake3_constructDirectory( const char* directory, const char* extension, Paths& paths ){
192 globalOutputStream() << "EntityClass: searching " << makeQuoted( directory ) << " for *." << extension << '\n';
193 Directory_forEach( directory, matchFileExtension( extension, PathsInsert( paths, directory ) ) );
194 }
195
196
EntityClassQuake3_Construct()197 void EntityClassQuake3_Construct(){
198 StringOutputStream baseDirectory( 256 );
199 StringOutputStream gameDirectory( 256 );
200 const char* basegame = GlobalRadiant().getRequiredGameDescriptionKeyValue( "basegame" );
201 const char* gamename = GlobalRadiant().getGameName();
202 baseDirectory << GlobalRadiant().getGameToolsPath() << basegame << '/';
203 gameDirectory << GlobalRadiant().getGameToolsPath() << gamename << '/';
204
205 class LoadEntityDefinitionsVisitor : public EClassModules::Visitor
206 {
207 const char* baseDirectory;
208 const char* gameDirectory;
209 public:
210 LoadEntityDefinitionsVisitor( const char* baseDirectory, const char* gameDirectory )
211 : baseDirectory( baseDirectory ), gameDirectory( gameDirectory ){
212 }
213 void visit( const char* name, const EntityClassScanner& table ) const {
214 Paths paths;
215 EntityClassQuake3_constructDirectory( baseDirectory, table.getExtension(), paths );
216 if ( !string_equal( baseDirectory, gameDirectory ) ) {
217 EntityClassQuake3_constructDirectory( gameDirectory, table.getExtension(), paths );
218 }
219
220 for ( Paths::iterator i = paths.begin(); i != paths.end(); ++i )
221 {
222 EntityClassesLoadFile( table, ( *i ).second ) ( ( *i ).first.c_str() );
223 }
224 }
225 };
226
227 EntityClassManager_getEClassModules().foreachModule( LoadEntityDefinitionsVisitor( baseDirectory.c_str(), gameDirectory.c_str() ) );
228 }
229
Eclass_ForName(const char * name,bool has_brushes)230 EntityClass *Eclass_ForName( const char *name, bool has_brushes ){
231 ASSERT_NOTNULL( name );
232
233 if ( string_empty( name ) ) {
234 return eclass_bad;
235 }
236
237 EntityClasses::iterator i = g_entityClasses.find( name );
238 if ( i != g_entityClasses.end() && string_equal( ( *i ).first, name ) ) {
239 return ( *i ).second;
240 }
241
242 EntityClass* e = EntityClass_Create_Default( name, has_brushes );
243 return Eclass_InsertAlphabetized( e );
244 }
245
246 class EntityClassQuake3 : public ModuleObserver
247 {
248 std::size_t m_unrealised;
249 ModuleObservers m_observers;
250 public:
EntityClassQuake3()251 EntityClassQuake3() : m_unrealised( 4 ){
252 }
realise()253 void realise(){
254 if ( --m_unrealised == 0 ) {
255 //globalOutputStream() << "Entity Classes: realise\n";
256 EntityClassQuake3_Construct();
257 m_observers.realise();
258 }
259 }
unrealise()260 void unrealise(){
261 if ( ++m_unrealised == 1 ) {
262 m_observers.unrealise();
263 //globalOutputStream() << "Entity Classes: unrealise\n";
264 Eclass_Clear();
265 }
266 }
attach(ModuleObserver & observer)267 void attach( ModuleObserver& observer ){
268 m_observers.attach( observer );
269 }
detach(ModuleObserver & observer)270 void detach( ModuleObserver& observer ){
271 m_observers.detach( observer );
272 }
273 };
274
275 EntityClassQuake3 g_EntityClassQuake3;
276
EntityClass_attach(ModuleObserver & observer)277 void EntityClass_attach( ModuleObserver& observer ){
278 g_EntityClassQuake3.attach( observer );
279 }
EntityClass_detach(ModuleObserver & observer)280 void EntityClass_detach( ModuleObserver& observer ){
281 g_EntityClassQuake3.detach( observer );
282 }
283
EntityClass_realise()284 void EntityClass_realise(){
285 g_EntityClassQuake3.realise();
286 }
EntityClass_unrealise()287 void EntityClass_unrealise(){
288 g_EntityClassQuake3.unrealise();
289 }
290
EntityClassQuake3_construct()291 void EntityClassQuake3_construct(){
292 // start by creating the default unknown eclass
293 eclass_bad = EClass_Create( "UNKNOWN_CLASS", Vector3( 0.0f, 0.5f, 0.0f ), "" );
294
295 EntityClass_realise();
296 }
297
EntityClassQuake3_destroy()298 void EntityClassQuake3_destroy(){
299 EntityClass_unrealise();
300
301 eclass_bad->free( eclass_bad );
302 }
303
304 #include "modulesystem/modulesmap.h"
305
306 class EntityClassQuake3Dependencies :
307 public GlobalRadiantModuleRef,
308 public GlobalFileSystemModuleRef,
309 public GlobalShaderCacheModuleRef
310 {
311 EClassModulesRef m_eclass_modules;
312 public:
EntityClassQuake3Dependencies()313 EntityClassQuake3Dependencies() :
314 m_eclass_modules( GlobalRadiant().getRequiredGameDescriptionKeyValue( "entityclasstype" ) ){
315 }
getEClassModules()316 EClassModules& getEClassModules(){
317 return m_eclass_modules.get();
318 }
319 };
320
321 class EclassManagerAPI
322 {
323 EntityClassManager m_eclassmanager;
324 public:
325 typedef EntityClassManager Type;
326 STRING_CONSTANT( Name, "quake3" );
327
EclassManagerAPI()328 EclassManagerAPI(){
329 EntityClassQuake3_construct();
330
331 m_eclassmanager.findOrInsert = &Eclass_ForName;
332 m_eclassmanager.findListType = &EntityClass_findListType;
333 m_eclassmanager.forEach = &Eclass_forEach;
334 m_eclassmanager.attach = &EntityClass_attach;
335 m_eclassmanager.detach = &EntityClass_detach;
336 m_eclassmanager.realise = &EntityClass_realise;
337 m_eclassmanager.unrealise = &EntityClass_unrealise;
338
339 GlobalRadiant().attachGameToolsPathObserver( g_EntityClassQuake3 );
340 GlobalRadiant().attachGameModeObserver( g_EntityClassQuake3 );
341 GlobalRadiant().attachGameNameObserver( g_EntityClassQuake3 );
342 }
~EclassManagerAPI()343 ~EclassManagerAPI(){
344 GlobalRadiant().detachGameNameObserver( g_EntityClassQuake3 );
345 GlobalRadiant().detachGameModeObserver( g_EntityClassQuake3 );
346 GlobalRadiant().detachGameToolsPathObserver( g_EntityClassQuake3 );
347
348 EntityClassQuake3_destroy();
349 }
getTable()350 EntityClassManager* getTable(){
351 return &m_eclassmanager;
352 }
353 };
354
355 #include "modulesystem/singletonmodule.h"
356 #include "modulesystem/moduleregistry.h"
357
358 typedef SingletonModule<EclassManagerAPI, EntityClassQuake3Dependencies> EclassManagerModule;
359 typedef Static<EclassManagerModule> StaticEclassManagerModule;
360 StaticRegisterModule staticRegisterEclassManager( StaticEclassManagerModule::instance() );
361
EntityClassManager_getEClassModules()362 EClassModules& EntityClassManager_getEClassModules(){
363 return StaticEclassManagerModule::instance().getDependencies().getEClassModules();
364 }
365