]> icculus.org git repositories - divverent/netradiant.git/blob - radiant/eclass_fgd.cpp
new args -meta and -patchmeta to -convert with .map file argument
[divverent/netradiant.git] / radiant / eclass_fgd.cpp
1 /*
2 Copyright (C) 2001-2006, William Joseph.
3 All Rights Reserved.
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_fgd.h"
23
24 #include "debugging/debugging.h"
25
26 #include <map>
27
28 #include "ifilesystem.h"
29 #include "iscriplib.h"
30 #include "qerplugin.h"
31
32 #include "string/string.h"
33 #include "eclasslib.h"
34 #include "os/path.h"
35 #include "os/dir.h"
36 #include "stream/stringstream.h"
37 #include "moduleobservers.h"
38 #include "stringio.h"
39 #include "stream/textfilestream.h"
40
41 namespace
42 {
43   typedef std::map<const char*, EntityClass*, RawStringLessNoCase> EntityClasses;
44   EntityClasses g_EntityClassFGD_classes;
45   typedef std::map<const char*, EntityClass*, RawStringLess> BaseClasses;
46   BaseClasses g_EntityClassFGD_bases;
47   EntityClass   *g_EntityClassFGD_bad = 0;
48   typedef std::map<CopiedString, ListAttributeType> ListAttributeTypes;
49   ListAttributeTypes g_listTypesFGD;
50 }
51
52
53 void EntityClassFGD_clear()
54 {
55   for(BaseClasses::iterator i = g_EntityClassFGD_bases.begin(); i != g_EntityClassFGD_bases.end(); ++i)
56   {
57     (*i).second->free((*i).second);
58   }
59   g_EntityClassFGD_bases.clear();
60   g_listTypesFGD.clear();
61 }
62
63 EntityClass* EntityClassFGD_insertUniqueBase(EntityClass* entityClass)
64 {
65   std::pair<BaseClasses::iterator, bool> result = g_EntityClassFGD_bases.insert(BaseClasses::value_type(entityClass->name(), entityClass));
66   if(!result.second)
67   {
68     globalErrorStream() << "duplicate base class: " << makeQuoted(entityClass->name()) << "\n";
69     //eclass_capture_state(entityClass);
70     //entityClass->free(entityClass);
71   }
72   return (*result.first).second;
73 }
74
75 EntityClass* EntityClassFGD_insertUnique(EntityClass* entityClass)
76 {
77   EntityClassFGD_insertUniqueBase(entityClass);
78   std::pair<EntityClasses::iterator, bool> result = g_EntityClassFGD_classes.insert(EntityClasses::value_type(entityClass->name(), entityClass));
79   if(!result.second)
80   {
81     globalErrorStream() << "duplicate entity class: " << makeQuoted(entityClass->name()) << "\n";
82     eclass_capture_state(entityClass);
83     entityClass->free(entityClass);
84   }
85   return (*result.first).second;
86 }
87
88 void EntityClassFGD_forEach(EntityClassVisitor& visitor)
89 {
90   for(EntityClasses::iterator i = g_EntityClassFGD_classes.begin(); i != g_EntityClassFGD_classes.end(); ++i)
91   {
92     visitor.visit((*i).second);
93   }
94 }
95
96 inline bool EntityClassFGD_parseToken(Tokeniser& tokeniser, const char* token)
97 {
98   return string_equal(tokeniser.getToken(), token);
99 }
100
101 #define PARSE_ERROR "error parsing entity class definition"
102
103 void EntityClassFGD_parseSplitString(Tokeniser& tokeniser, CopiedString& string)
104 {
105   StringOutputStream buffer(256);
106   for(;;)
107   {
108     buffer << tokeniser.getToken();
109     if(!string_equal(tokeniser.getToken(), "+"))
110     {
111       tokeniser.ungetToken();
112       string = buffer.c_str();
113       return;
114     }
115   }
116 }
117
118 void EntityClassFGD_parseClass(Tokeniser& tokeniser, bool fixedsize, bool isBase)
119 {
120   EntityClass* entityClass = Eclass_Alloc();
121   entityClass->free = &Eclass_Free;
122   entityClass->fixedsize = fixedsize;
123   entityClass->inheritanceResolved = false;
124   entityClass->mins = Vector3(-8, -8, -8);
125   entityClass->maxs = Vector3(8, 8, 8);
126
127   for(;;)
128   {
129     const char* property = tokeniser.getToken();
130     if(string_equal(property, "="))
131     {
132       break;
133     }
134     else if(string_equal(property, "base"))
135     {
136       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
137       for(;;)
138       {
139         const char* base = tokeniser.getToken();
140         if(string_equal(base, ")"))
141         {
142           break;
143         }
144         else if(!string_equal(base, ","))
145         {
146           entityClass->m_parent.push_back(base);
147         }
148       }
149     }
150     else if(string_equal(property, "size"))
151     {
152       entityClass->sizeSpecified = true;
153       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
154       Tokeniser_getFloat(tokeniser, entityClass->mins.x());
155       Tokeniser_getFloat(tokeniser, entityClass->mins.y());
156       Tokeniser_getFloat(tokeniser, entityClass->mins.z());
157       const char* token = tokeniser.getToken();
158       if(string_equal(token, ","))
159       {
160         Tokeniser_getFloat(tokeniser, entityClass->maxs.x());
161         Tokeniser_getFloat(tokeniser, entityClass->maxs.y());
162         Tokeniser_getFloat(tokeniser, entityClass->maxs.z());
163         ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ")"), PARSE_ERROR);
164       }
165       else
166       {
167         entityClass->maxs = entityClass->mins;
168         vector3_negate(entityClass->mins);
169         ASSERT_MESSAGE(string_equal(token, ")"), "");
170       }
171     }
172     else if(string_equal(property, "color"))
173     {
174       entityClass->colorSpecified = true;
175       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
176       Tokeniser_getFloat(tokeniser, entityClass->color.x());
177       entityClass->color.x() /= 256.0;
178       Tokeniser_getFloat(tokeniser, entityClass->color.y());
179       entityClass->color.y() /= 256.0;
180       Tokeniser_getFloat(tokeniser, entityClass->color.z());
181       entityClass->color.z() /= 256.0;
182       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ")"), PARSE_ERROR);
183     }
184     else if(string_equal(property, "iconsprite"))
185     {
186       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
187       StringOutputStream buffer(256);
188       buffer << PathCleaned(tokeniser.getToken());
189       entityClass->m_modelpath = buffer.c_str();
190       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ")"), PARSE_ERROR);
191     }
192     else if(string_equal(property, "sprite")
193       || string_equal(property, "decal")
194       // hl2 below
195       || string_equal(property, "overlay")
196       || string_equal(property, "light")
197       || string_equal(property, "keyframe")
198       || string_equal(property, "animator")
199       || string_equal(property, "quadbounds"))
200     {
201       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
202       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ")"), PARSE_ERROR);
203     }
204     // hl2 below
205     else if(string_equal(property, "sphere")
206       || string_equal(property, "sweptplayerhull")
207       || string_equal(property, "studio")
208       || string_equal(property, "studioprop")
209       || string_equal(property, "lightprop")
210       || string_equal(property, "lightcone")
211       || string_equal(property, "sidelist"))
212     {
213       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
214       if(string_equal(tokeniser.getToken(), ")"))
215       {
216         tokeniser.ungetToken();
217       }
218       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ")"), PARSE_ERROR);
219     }
220     else if(string_equal(property, "line")
221       || string_equal(property, "cylinder"))
222     {
223       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
224       //const char* r =
225       tokeniser.getToken();
226       //const char* g =
227       tokeniser.getToken();
228       //const char* b =
229       tokeniser.getToken();
230       for(;;)
231       {
232         if(string_equal(tokeniser.getToken(), ")"))
233         {
234           tokeniser.ungetToken();
235           break;
236         }
237         //const char* name =
238         tokeniser.getToken();
239       }
240       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ")"), PARSE_ERROR);
241     }
242     else if(string_equal(property, "wirebox"))
243     {
244       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
245       //const char* mins =
246       tokeniser.getToken();
247       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ","), PARSE_ERROR);
248       //const char* maxs =
249       tokeniser.getToken();
250       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ")"), PARSE_ERROR);
251     }
252     else if(string_equal(property, "halfgridsnap"))
253     {
254     }
255     else
256     {
257       ERROR_MESSAGE(PARSE_ERROR);
258     }
259   }
260
261   entityClass->m_name = tokeniser.getToken();
262
263   if(!isBase)
264   {
265     ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ":"), PARSE_ERROR);
266
267     EntityClassFGD_parseSplitString(tokeniser, entityClass->m_comments);
268   }
269
270   tokeniser.nextLine();
271
272   ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "["), PARSE_ERROR);
273
274   tokeniser.nextLine();
275
276   for(;;)
277   {
278     CopiedString key = tokeniser.getToken();
279     if(string_equal(key.c_str(), "]"))
280     {
281       tokeniser.nextLine();
282       break;
283     }
284
285     if(string_equal_nocase(key.c_str(), "input")
286       || string_equal_nocase(key.c_str(), "output"))
287     {
288       const char* name = tokeniser.getToken();
289       if(!string_equal(name, "("))
290       {
291         ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
292         //const char* type =
293         tokeniser.getToken();
294         ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ")"), PARSE_ERROR);
295         const char* descriptionSeparator = tokeniser.getToken();
296         if(string_equal(descriptionSeparator, ":"))
297         {
298           CopiedString description;
299           EntityClassFGD_parseSplitString(tokeniser, description);
300         }
301         else
302         {
303           tokeniser.ungetToken();
304         }
305         tokeniser.nextLine();
306         continue;
307       }
308     }
309
310     ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
311     CopiedString type = tokeniser.getToken();
312     ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ")"), PARSE_ERROR);
313
314     if(string_equal_nocase(type.c_str(), "flags"))
315     {
316       EntityClassAttribute attribute;
317
318       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "="), PARSE_ERROR);
319       tokeniser.nextLine();
320       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "["), PARSE_ERROR);
321       tokeniser.nextLine();
322       for(;;)
323       {
324         const char* flag = tokeniser.getToken();
325         if(string_equal(flag, "]"))
326         {
327           tokeniser.nextLine();
328           break;
329         }
330         else
331         {
332           ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ":"), PARSE_ERROR);
333           //const char* name =
334           tokeniser.getToken();
335           {
336             const char* defaultSeparator = tokeniser.getToken();
337             if(string_equal(defaultSeparator, ":"))
338             {
339               tokeniser.getToken();
340               {
341                 const char* descriptionSeparator = tokeniser.getToken();
342                 if(string_equal(descriptionSeparator, ":"))
343                 {
344                   EntityClassFGD_parseSplitString(tokeniser, attribute.m_description);
345                 }
346                 else
347                 {
348                   tokeniser.ungetToken();
349                 }
350               }
351             }
352             else
353             {
354               tokeniser.ungetToken();
355             }
356           }
357         }
358         tokeniser.nextLine();
359       }
360       EntityClass_insertAttribute(*entityClass, key.c_str(), attribute);
361     }
362     else if(string_equal_nocase(type.c_str(), "choices"))
363     {
364       EntityClassAttribute attribute;
365
366       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ":"), PARSE_ERROR);
367       attribute.m_name = tokeniser.getToken();
368       const char* valueSeparator = tokeniser.getToken();
369       if(string_equal(valueSeparator, ":"))
370       {
371         const char* value = tokeniser.getToken();
372         if(!string_equal(value, ":"))
373         {
374           attribute.m_value = value;
375         }
376         else
377         {
378           tokeniser.ungetToken();
379         }
380         {
381           const char* descriptionSeparator = tokeniser.getToken();
382           if(string_equal(descriptionSeparator, ":"))
383           {
384             EntityClassFGD_parseSplitString(tokeniser, attribute.m_description);
385           }
386           else
387           {
388             tokeniser.ungetToken();
389           }
390         }
391       }
392       else
393       {
394         tokeniser.ungetToken();
395       }
396       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "="), PARSE_ERROR);
397       tokeniser.nextLine();
398       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "["), PARSE_ERROR);
399       tokeniser.nextLine();
400
401       StringOutputStream listTypeName(64);
402       listTypeName << entityClass->m_name.c_str() << "_" << attribute.m_name.c_str();
403       attribute.m_type = listTypeName.c_str();
404
405       ListAttributeType& listType = g_listTypesFGD[listTypeName.c_str()];
406
407       for(;;)
408       {
409         const char* value = tokeniser.getToken();
410         if(string_equal(value, "]"))
411         {
412           tokeniser.nextLine();
413           break;
414         }
415         else
416         {
417           CopiedString tmp(value);
418           ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ":"), PARSE_ERROR);
419           const char* name = tokeniser.getToken();
420           listType.push_back(name, tmp.c_str());
421         }
422         tokeniser.nextLine();
423       }
424
425       for(ListAttributeType::const_iterator i = listType.begin(); i != listType.end(); ++i)
426       {
427         if(string_equal(attribute.m_value.c_str(), (*i).first.c_str()))
428         {
429           attribute.m_value = (*i).second.c_str();
430         }
431       }
432
433       EntityClass_insertAttribute(*entityClass, key.c_str(), attribute);
434     }
435     else if(string_equal_nocase(type.c_str(), "decal"))
436     {
437     }
438     else if(string_equal_nocase(type.c_str(), "string")
439       || string_equal_nocase(type.c_str(), "integer")
440       || string_equal_nocase(type.c_str(), "studio")
441       || string_equal_nocase(type.c_str(), "sprite")
442       || string_equal_nocase(type.c_str(), "color255")
443       || string_equal_nocase(type.c_str(), "target_source")
444       || string_equal_nocase(type.c_str(), "target_destination")
445       || string_equal_nocase(type.c_str(), "sound")
446       // hl2 below
447       || string_equal_nocase(type.c_str(), "angle")
448       || string_equal_nocase(type.c_str(), "origin")
449       || string_equal_nocase(type.c_str(), "float")
450       || string_equal_nocase(type.c_str(), "node_dest")
451       || string_equal_nocase(type.c_str(), "filterclass")
452       || string_equal_nocase(type.c_str(), "vector")
453       || string_equal_nocase(type.c_str(), "sidelist")
454       || string_equal_nocase(type.c_str(), "material")
455       || string_equal_nocase(type.c_str(), "vecline")
456       || string_equal_nocase(type.c_str(), "axis")
457       || string_equal_nocase(type.c_str(), "npcclass")
458       || string_equal_nocase(type.c_str(), "target_name_or_class")
459       || string_equal_nocase(type.c_str(), "pointentityclass")
460       || string_equal_nocase(type.c_str(), "scene"))
461     {
462       if(!string_equal(tokeniser.getToken(), "readonly"))
463       {
464         tokeniser.ungetToken();
465       }
466
467       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ":"), PARSE_ERROR);
468       const char* attributeType = "string";
469       if(string_equal_nocase(type.c_str(), "studio"))
470       {
471         attributeType = "model";
472       }
473
474       EntityClassAttribute attribute;
475       attribute.m_type = attributeType;
476       attribute.m_name = tokeniser.getToken();
477
478       const char* defaultSeparator = tokeniser.getToken();
479       if(string_equal(defaultSeparator, ":"))
480       {
481         const char* value = tokeniser.getToken();
482         if(!string_equal(value, ":"))
483         {
484           attribute.m_value = value;
485         }
486         else
487         {
488           tokeniser.ungetToken();
489         }
490
491         {
492           const char* descriptionSeparator = tokeniser.getToken();
493           if(string_equal(descriptionSeparator, ":"))
494           {
495             EntityClassFGD_parseSplitString(tokeniser, attribute.m_description);
496           }
497           else
498           {
499             tokeniser.ungetToken();
500           }
501         }
502       }
503       else
504       {
505         tokeniser.ungetToken();
506       }
507       EntityClass_insertAttribute(*entityClass, key.c_str(), attribute);
508     }
509     else
510     {
511       ERROR_MESSAGE("unknown key type: " << makeQuoted(type.c_str()));
512     }
513     tokeniser.nextLine();
514   }
515
516   if(isBase)
517   {
518     EntityClassFGD_insertUniqueBase(entityClass);
519   }
520   else
521   {
522     EntityClassFGD_insertUnique(entityClass);
523   }
524 }
525
526 void EntityClassFGD_loadFile(const char* filename);
527
528 void EntityClassFGD_parse(TextInputStream& inputStream, const char* path)
529 {
530   Tokeniser& tokeniser = GlobalScriptLibrary().m_pfnNewScriptTokeniser(inputStream);
531
532   tokeniser.nextLine();
533
534   for(;;)
535   {
536     const char* blockType = tokeniser.getToken();
537     if(blockType == 0)
538     {
539       break;
540     }
541     if(string_equal(blockType, "@SolidClass"))
542     {
543       EntityClassFGD_parseClass(tokeniser, false, false);
544     }
545     else if(string_equal(blockType, "@BaseClass"))
546     {
547       EntityClassFGD_parseClass(tokeniser, false, true);
548     }
549     else if(string_equal(blockType, "@PointClass")
550       // hl2 below
551       || string_equal(blockType, "@KeyFrameClass")
552       || string_equal(blockType, "@MoveClass")
553       || string_equal(blockType, "@FilterClass")
554       || string_equal(blockType, "@NPCClass"))
555     {
556       EntityClassFGD_parseClass(tokeniser, true, false);
557     }
558     // hl2 below
559     else if(string_equal(blockType, "@include"))
560     {
561       StringOutputStream includePath(256);
562       includePath << StringRange(path, path_get_filename_start(path));
563       includePath << tokeniser.getToken();
564       EntityClassFGD_loadFile(includePath.c_str());
565     }
566     else if(string_equal(blockType, "@mapsize"))
567     {
568       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, "("), PARSE_ERROR);
569       //const char* min =
570       tokeniser.getToken();
571       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ","), PARSE_ERROR);
572       //const char* max =
573       tokeniser.getToken();
574       ASSERT_MESSAGE(EntityClassFGD_parseToken(tokeniser, ")"), PARSE_ERROR);
575     }
576     else
577     {
578       ERROR_MESSAGE("unknown block type: " << makeQuoted(blockType));
579     }
580   }
581
582   tokeniser.release();
583 }
584
585
586 void EntityClassFGD_loadFile(const char* filename)
587 {
588         TextFileInputStream file(filename);
589   if(!file.failed())
590   {
591     globalOutputStream() << "parsing entity classes from " << makeQuoted(filename) << "\n";
592
593     EntityClassFGD_parse(file, filename);
594   }
595 }
596
597 EntityClass* EntityClassFGD_findOrInsert(const char *name, bool has_brushes)
598 {
599         ASSERT_NOTNULL(name);
600
601   if(string_empty(name))
602   {
603     return g_EntityClassFGD_bad;
604   }
605
606   EntityClasses::iterator i = g_EntityClassFGD_classes.find(name);
607   if(i != g_EntityClassFGD_classes.end()
608     //&& string_equal((*i).first, name)
609     )
610   {
611     return (*i).second;
612   }
613
614         EntityClass* e = EntityClass_Create_Default(name, has_brushes);
615         return EntityClassFGD_insertUnique(e);
616 }
617
618 const ListAttributeType* EntityClassFGD_findListType(const char *name)
619 {
620   ListAttributeTypes::iterator i = g_listTypesFGD.find(name);
621   if(i != g_listTypesFGD.end())
622   {
623     return &(*i).second;
624   }
625   return 0;
626
627 }
628
629
630 void EntityClassFGD_resolveInheritance(EntityClass* derivedClass)
631 {
632   if(derivedClass->inheritanceResolved == false)
633   {
634     derivedClass->inheritanceResolved = true;
635     for(StringList::iterator j = derivedClass->m_parent.begin(); j != derivedClass->m_parent.end(); ++j)
636     {
637       BaseClasses::iterator i = g_EntityClassFGD_bases.find((*j).c_str());
638       if(i == g_EntityClassFGD_bases.end())
639       {
640         globalErrorStream() << "failed to find entityDef " << makeQuoted((*j).c_str()) << " inherited by "  << makeQuoted(derivedClass->m_name.c_str()) << "\n";
641       }
642       else
643       {
644         EntityClass* parentClass = (*i).second;
645         EntityClassFGD_resolveInheritance(parentClass);
646         if(!derivedClass->colorSpecified)
647         {
648           derivedClass->colorSpecified = parentClass->colorSpecified;
649           derivedClass->color = parentClass->color;
650         }
651         if(!derivedClass->sizeSpecified)
652         {
653           derivedClass->sizeSpecified = parentClass->sizeSpecified;
654           derivedClass->mins = parentClass->mins;
655           derivedClass->maxs = parentClass->maxs;
656         }
657
658         for(EntityClassAttributes::iterator k = parentClass->m_attributes.begin(); k != parentClass->m_attributes.end(); ++k)
659         {
660           EntityClass_insertAttribute(*derivedClass, (*k).first.c_str(), (*k).second);
661         }
662       }
663     }
664   }
665 }
666
667 class EntityClassFGD : public ModuleObserver
668 {
669   std::size_t m_unrealised;
670   ModuleObservers m_observers;
671 public:
672   EntityClassFGD() : m_unrealised(3)
673   {
674   }
675   void realise()
676   {
677     if(--m_unrealised == 0)
678     {
679       StringOutputStream filename(256);
680       filename << GlobalRadiant().getGameToolsPath() << GlobalRadiant().getGameName() << "/halflife.fgd";
681       EntityClassFGD_loadFile(filename.c_str());
682
683       {
684         for(EntityClasses::iterator i = g_EntityClassFGD_classes.begin(); i != g_EntityClassFGD_classes.end(); ++i)
685         {
686           EntityClassFGD_resolveInheritance((*i).second);
687           if((*i).second->fixedsize && string_empty((*i).second->m_modelpath.c_str()))
688           {
689             if(!(*i).second->sizeSpecified)
690             {
691               globalErrorStream() << "size not specified for entity class: " << makeQuoted((*i).second->m_name.c_str()) << '\n';
692             }
693             if(!(*i).second->colorSpecified)
694             {
695               globalErrorStream() << "color not specified for entity class: " << makeQuoted((*i).second->m_name.c_str()) << '\n';
696             }
697           }
698         }
699       }
700       {
701         for(BaseClasses::iterator i = g_EntityClassFGD_bases.begin(); i != g_EntityClassFGD_bases.end(); ++i)
702         {
703           eclass_capture_state((*i).second);
704         }
705       }
706
707       m_observers.realise();
708     }
709   }
710   void unrealise()
711   {
712     if(++m_unrealised == 1)
713     {
714       m_observers.unrealise();
715       EntityClassFGD_clear();
716     }
717   }
718   void attach(ModuleObserver& observer)
719   {
720     m_observers.attach(observer);
721   }
722   void detach(ModuleObserver& observer)
723   {
724     m_observers.detach(observer);
725   }
726 };
727
728 EntityClassFGD g_EntityClassFGD;
729
730 void EntityClassFGD_attach(ModuleObserver& observer)
731 {
732   g_EntityClassFGD.attach(observer);
733 }
734 void EntityClassFGD_detach(ModuleObserver& observer)
735 {
736   g_EntityClassFGD.detach(observer);
737 }
738
739 void EntityClassFGD_realise()
740 {
741   g_EntityClassFGD.realise();
742 }
743 void EntityClassFGD_unrealise()
744 {
745   g_EntityClassFGD.unrealise();
746 }
747
748 void EntityClassFGD_construct()
749 {
750   // start by creating the default unknown eclass
751   g_EntityClassFGD_bad = EClass_Create("UNKNOWN_CLASS", Vector3(0.0f, 0.5f, 0.0f), "");
752
753   EntityClassFGD_realise();
754 }
755
756 void EntityClassFGD_destroy()
757 {
758   EntityClassFGD_unrealise();
759
760   g_EntityClassFGD_bad->free(g_EntityClassFGD_bad);
761 }
762
763 class EntityClassFGDDependencies : public GlobalFileSystemModuleRef, public GlobalShaderCacheModuleRef, public GlobalRadiantModuleRef
764 {
765 };
766
767 class EntityClassFGDAPI
768 {
769   EntityClassManager m_eclassmanager;
770 public:
771   typedef EntityClassManager Type;
772   STRING_CONSTANT(Name, "halflife");
773
774   EntityClassFGDAPI()
775   {
776     EntityClassFGD_construct();
777
778     m_eclassmanager.findOrInsert = &EntityClassFGD_findOrInsert;
779     m_eclassmanager.findListType = &EntityClassFGD_findListType;
780     m_eclassmanager.forEach = &EntityClassFGD_forEach;
781     m_eclassmanager.attach = &EntityClassFGD_attach;
782     m_eclassmanager.detach = &EntityClassFGD_detach;
783     m_eclassmanager.realise = &EntityClassFGD_realise;
784     m_eclassmanager.unrealise = &EntityClassFGD_unrealise;
785
786     GlobalRadiant().attachGameToolsPathObserver(g_EntityClassFGD);
787     GlobalRadiant().attachGameNameObserver(g_EntityClassFGD);
788   }
789   ~EntityClassFGDAPI()
790   {
791     GlobalRadiant().detachGameNameObserver(g_EntityClassFGD);
792     GlobalRadiant().detachGameToolsPathObserver(g_EntityClassFGD);
793
794     EntityClassFGD_destroy();
795   }
796   EntityClassManager* getTable()
797   {
798     return &m_eclassmanager;
799   }
800 };
801
802 #include "modulesystem/singletonmodule.h"
803 #include "modulesystem/moduleregistry.h"
804
805 typedef SingletonModule<EntityClassFGDAPI, EntityClassFGDDependencies> EntityClassFGDModule;
806 typedef Static<EntityClassFGDModule> StaticEntityClassFGDModule;
807 StaticRegisterModule staticRegisterEntityClassFGD(StaticEntityClassFGDModule::instance());