automatically run the decompiler when specifying a BSP file in Import...
[divverent/netradiant.git] / plugins / mapq3 / plugin.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 "plugin.h"
23
24 #include "iscriplib.h"
25 #include "ibrush.h"
26 #include "ipatch.h"
27 #include "ifiletypes.h"
28 #include "ieclass.h"
29 #include "qerplugin.h"
30
31 #include "scenelib.h"
32 #include "string/string.h"
33 #include "stringio.h"
34 #include "generic/constant.h"
35
36 #include "modulesystem/singletonmodule.h"
37
38 #include "parse.h"
39 #include "write.h"
40
41
42 class MapDoom3Dependencies :
43   public GlobalRadiantModuleRef,
44   public GlobalFiletypesModuleRef,
45   public GlobalScripLibModuleRef,
46   public GlobalEntityClassManagerModuleRef,
47   public GlobalSceneGraphModuleRef,
48   public GlobalBrushModuleRef
49 {
50   PatchModuleRef m_patchDef2Doom3Module;
51   PatchModuleRef m_patchDoom3Module;
52 public:
53   MapDoom3Dependencies() :
54     GlobalEntityClassManagerModuleRef(GlobalRadiant().getRequiredGameDescriptionKeyValue("entityclass")),
55     GlobalBrushModuleRef(GlobalRadiant().getRequiredGameDescriptionKeyValue("brushtypes")),
56     m_patchDef2Doom3Module("def2doom3"),
57     m_patchDoom3Module("doom3")
58   {
59   }
60   BrushCreator& getBrushDoom3()
61   {
62     return GlobalBrushModule::getTable();
63   }
64   PatchCreator& getPatchDoom3()
65   {
66     return *m_patchDoom3Module.getTable();
67   }
68   PatchCreator& getPatchDef2Doom3()
69   {
70     return *m_patchDef2Doom3Module.getTable();
71   }
72 };
73
74 class MapDoom3API : public TypeSystemRef, public MapFormat, public PrimitiveParser
75 {
76   MapDoom3Dependencies& m_dependencies;
77 public:
78   typedef MapFormat Type;
79   STRING_CONSTANT(Name, "mapdoom3");
80   INTEGER_CONSTANT(MapVersion, 2);
81
82   MapDoom3API(MapDoom3Dependencies& dependencies) : m_dependencies(dependencies)
83   {
84     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("doom3 maps", "*.map"));
85     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("doom3 region", "*.reg"));
86   }
87   MapFormat* getTable()
88   {
89     return this;
90   }
91
92   scene::Node& parsePrimitive(Tokeniser& tokeniser) const
93   {
94     const char* primitive = tokeniser.getToken();
95     if(primitive != 0)
96     {
97       if(string_equal(primitive, "patchDef3"))
98       {
99         return m_dependencies.getPatchDoom3().createPatch();
100       }
101       else if(string_equal(primitive, "patchDef2"))
102       {
103         return m_dependencies.getPatchDef2Doom3().createPatch();
104       }
105       else if(string_equal(primitive, "brushDef3"))
106       {
107         return m_dependencies.getBrushDoom3().createBrush();
108       }
109     }
110
111     Tokeniser_unexpectedError(tokeniser, primitive, "#doom3-primitive");
112     return g_nullNode;
113   }
114   void readGraph(scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable) const
115   {
116     Tokeniser& tokeniser = GlobalScripLibModule::getTable().m_pfnNewSimpleTokeniser(inputStream);
117     tokeniser.nextLine();
118     if(!Tokeniser_parseToken(tokeniser, "Version"))
119     {
120       return;
121     }
122     std::size_t version;
123     if(!Tokeniser_getSize(tokeniser, version))
124     {
125       return;
126     }
127     if(version != MapVersion())
128     {
129       globalErrorStream() << "Doom 3 map version " << MapVersion() << " supported, version is " << Unsigned(version) << "\n";
130       return;
131     }
132     tokeniser.nextLine();
133     Map_Read(root, tokeniser, entityTable, *this);
134     tokeniser.release();
135   }
136   void writeGraph(scene::Node& root, GraphTraversalFunc traverse, TextOutputStream& outputStream) const
137   {
138     TokenWriter& writer = GlobalScripLibModule::getTable().m_pfnNewSimpleTokenWriter(outputStream);
139     writer.writeToken("Version");
140     writer.writeInteger(MapVersion());
141     writer.nextLine();
142     Map_Write(root, traverse, writer, false);
143     writer.release();
144   }
145 };
146
147 typedef SingletonModule<
148   MapDoom3API,
149   MapDoom3Dependencies,
150   DependenciesAPIConstructor<MapDoom3API, MapDoom3Dependencies>
151 >
152 MapDoom3Module;
153
154 MapDoom3Module g_MapDoom3Module;
155
156
157 class MapQuake4API : public TypeSystemRef, public MapFormat, public PrimitiveParser
158 {
159   MapDoom3Dependencies& m_dependencies;
160 public:
161   typedef MapFormat Type;
162   STRING_CONSTANT(Name, "mapquake4");
163   INTEGER_CONSTANT(MapVersion, 3);
164
165   MapQuake4API(MapDoom3Dependencies& dependencies) : m_dependencies(dependencies)
166   {
167     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake4 maps", "*.map"));
168     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake4 region", "*.reg"));
169   }
170   MapFormat* getTable()
171   {
172     return this;
173   }
174
175   scene::Node& parsePrimitive(Tokeniser& tokeniser) const
176   {
177     const char* primitive = tokeniser.getToken();
178     if(primitive != 0)
179     {
180       if(string_equal(primitive, "patchDef3"))
181       {
182         return m_dependencies.getPatchDoom3().createPatch();
183       }
184       else if(string_equal(primitive, "patchDef2"))
185       {
186         return m_dependencies.getPatchDef2Doom3().createPatch();
187       }
188       else if(string_equal(primitive, "brushDef3"))
189       {
190         return m_dependencies.getBrushDoom3().createBrush();
191       }
192     }
193
194     Tokeniser_unexpectedError(tokeniser, primitive, "#quake4-primitive");
195     return g_nullNode;
196   }
197   void readGraph(scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable) const
198   {
199     Tokeniser& tokeniser = GlobalScripLibModule::getTable().m_pfnNewSimpleTokeniser(inputStream);
200     tokeniser.nextLine();
201     if(!Tokeniser_parseToken(tokeniser, "Version"))
202     {
203       return;
204     }
205     std::size_t version;
206     if(!Tokeniser_getSize(tokeniser, version))
207     {
208       return;
209     }
210     if(version != MapVersion())
211     {
212       globalErrorStream() << "Quake 4 map version " << MapVersion() << " supported, version is " << Unsigned(version) << "\n";
213       return;
214     }
215     tokeniser.nextLine();
216     Map_Read(root, tokeniser, entityTable, *this);
217     tokeniser.release();
218   }
219   void writeGraph(scene::Node& root, GraphTraversalFunc traverse, TextOutputStream& outputStream) const
220   {
221     TokenWriter& writer = GlobalScripLibModule::getTable().m_pfnNewSimpleTokenWriter(outputStream);
222     writer.writeToken("Version");
223     writer.writeInteger(MapVersion());
224     writer.nextLine();
225     Map_Write(root, traverse, writer, false);
226     writer.release();
227   }
228 };
229
230 typedef SingletonModule<
231   MapQuake4API,
232   MapDoom3Dependencies,
233   DependenciesAPIConstructor<MapQuake4API, MapDoom3Dependencies>
234 >
235 MapQuake4Module;
236
237 MapQuake4Module g_MapQuake4Module;
238
239
240 class MapDependencies : 
241   public GlobalRadiantModuleRef,
242   public GlobalBrushModuleRef,
243   public GlobalPatchModuleRef,
244   public GlobalFiletypesModuleRef,
245   public GlobalScripLibModuleRef,
246   public GlobalEntityClassManagerModuleRef,
247   public GlobalSceneGraphModuleRef
248 {
249 public:
250   MapDependencies() :
251     GlobalBrushModuleRef(GlobalRadiant().getRequiredGameDescriptionKeyValue("brushtypes")),
252     GlobalPatchModuleRef(GlobalRadiant().getRequiredGameDescriptionKeyValue("patchtypes")),
253     GlobalEntityClassManagerModuleRef(GlobalRadiant().getRequiredGameDescriptionKeyValue("entityclass"))
254   {
255   }
256 };
257
258 class MapQ3API : public TypeSystemRef, public MapFormat, public PrimitiveParser
259 {
260   mutable bool detectedFormat;
261 public:
262   typedef MapFormat Type;
263   STRING_CONSTANT(Name, "mapq3");
264
265   MapQ3API()
266   {
267     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake3 maps", "*.map", true, true, true));
268     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake3 region", "*.reg", true, true, true));
269     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake3 compiled maps", "*.bsp", false, true, false));
270   }
271   MapFormat* getTable()
272   {
273     return this;
274   }
275
276   scene::Node& parsePrimitive(Tokeniser& tokeniser) const
277   {
278     const char* primitive = tokeniser.getToken();
279     if(primitive != 0)
280     {
281       if(string_equal(primitive, "patchDef2"))
282       {
283         return GlobalPatchModule::getTable().createPatch();
284       }
285       if(GlobalBrushModule::getTable().useAlternativeTextureProjection())
286       {
287         if(string_equal(primitive, "brushDef"))
288         {
289           detectedFormat = true;
290           return GlobalBrushModule::getTable().createBrush();
291         }
292         else if(!detectedFormat && string_equal(primitive, "("))
293         {
294           detectedFormat = true;
295           wrongFormat = true;
296           Tokeniser_unexpectedError(tokeniser, primitive, "#quake3-switch-to-texdef");
297           return g_nullNode;
298         }
299       }
300       else
301       {
302         if(string_equal(primitive, "("))
303         {
304           detectedFormat = true;
305           tokeniser.ungetToken(); // (
306           return GlobalBrushModule::getTable().createBrush();
307         }
308         else if(!detectedFormat && string_equal(primitive, "("))
309         {
310           detectedFormat = true;
311           wrongFormat = true;
312           Tokeniser_unexpectedError(tokeniser, primitive, "#quake3-switch-to-brush-primitives");
313           return g_nullNode;
314         }
315       }
316     }
317
318     Tokeniser_unexpectedError(tokeniser, primitive, "#quake3-primitive");
319     return g_nullNode;
320   }
321
322   void readGraph(scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable) const
323   {
324     detectedFormat = false;
325     wrongFormat = false;
326     Tokeniser& tokeniser = GlobalScripLibModule::getTable().m_pfnNewSimpleTokeniser(inputStream);
327     Map_Read(root, tokeniser, entityTable, *this);
328     tokeniser.release();
329   }
330   void writeGraph(scene::Node& root, GraphTraversalFunc traverse, TextOutputStream& outputStream) const
331   {
332     TokenWriter& writer = GlobalScripLibModule::getTable().m_pfnNewSimpleTokenWriter(outputStream);
333     Map_Write(root, traverse, writer, false);
334     writer.release();
335   }
336 };
337
338 typedef SingletonModule<MapQ3API, MapDependencies> MapQ3Module;
339
340 MapQ3Module g_MapQ3Module;
341
342
343 class MapQ1API : public TypeSystemRef, public MapFormat, public PrimitiveParser
344 {
345 public:
346   typedef MapFormat Type;
347   STRING_CONSTANT(Name, "mapq1");
348
349   MapQ1API()
350   {
351     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake maps", "*.map"));
352     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake region", "*.reg"));
353   }
354   MapFormat* getTable()
355   {
356     return this;
357   }
358
359   scene::Node& parsePrimitive(Tokeniser& tokeniser) const
360   {
361     const char* primitive = tokeniser.getToken();
362     if(primitive != 0)
363     {
364       if(string_equal(primitive, "("))
365       {
366         tokeniser.ungetToken(); // (
367         return GlobalBrushModule::getTable().createBrush();
368       }
369     }
370
371     Tokeniser_unexpectedError(tokeniser, primitive, "#quake-primitive");
372     return g_nullNode;
373   }
374   void readGraph(scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable) const
375   {
376     Tokeniser& tokeniser = GlobalScripLibModule::getTable().m_pfnNewSimpleTokeniser(inputStream);
377     Map_Read(root, tokeniser, entityTable, *this);
378     tokeniser.release();
379   }
380   void writeGraph(scene::Node& root, GraphTraversalFunc traverse, TextOutputStream& outputStream) const
381   {
382     TokenWriter& writer = GlobalScripLibModule::getTable().m_pfnNewSimpleTokenWriter(outputStream);
383     Map_Write(root, traverse, writer, true);
384     writer.release();
385   }
386 };
387
388 typedef SingletonModule<MapQ1API, MapDependencies> MapQ1Module;
389
390 MapQ1Module g_MapQ1Module;
391
392
393 class MapHalfLifeAPI : public TypeSystemRef, public MapFormat, public PrimitiveParser
394 {
395 public:
396   typedef MapFormat Type;
397   STRING_CONSTANT(Name, "maphl");
398
399   MapHalfLifeAPI()
400   {
401     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("half-life maps", "*.map"));
402     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("half-life region", "*.reg"));
403   }
404   MapFormat* getTable()
405   {
406     return this;
407   }
408
409   scene::Node& parsePrimitive(Tokeniser& tokeniser) const
410   {
411     const char* primitive = tokeniser.getToken();
412     if(primitive != 0)
413     {
414       if(string_equal(primitive, "("))
415       {
416         tokeniser.ungetToken(); // (
417         return GlobalBrushModule::getTable().createBrush();
418       }
419     }
420
421     Tokeniser_unexpectedError(tokeniser, primitive, "#halflife-primitive");
422     return g_nullNode;
423   }
424   void readGraph(scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable) const
425   {
426     Tokeniser& tokeniser = GlobalScripLibModule::getTable().m_pfnNewSimpleTokeniser(inputStream);
427     Map_Read(root, tokeniser, entityTable, *this);
428     tokeniser.release();
429   }
430   void writeGraph(scene::Node& root, GraphTraversalFunc traverse, TextOutputStream& outputStream) const
431   {
432     TokenWriter& writer = GlobalScripLibModule::getTable().m_pfnNewSimpleTokenWriter(outputStream);
433     Map_Write(root, traverse, writer, true);
434     writer.release();
435   }
436 };
437
438 typedef SingletonModule<MapHalfLifeAPI, MapDependencies> MapHalfLifeModule;
439
440 MapHalfLifeModule g_MapHalfLifeModule;
441
442
443 class MapQ2API : public TypeSystemRef, public MapFormat, public PrimitiveParser
444 {
445 public:
446   typedef MapFormat Type;
447   STRING_CONSTANT(Name, "mapq2");
448
449   MapQ2API()
450   {
451     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake2 maps", "*.map"));
452     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake2 region", "*.reg"));
453   }
454   MapFormat* getTable()
455   {
456     return this;
457   }
458   scene::Node& parsePrimitive(Tokeniser& tokeniser) const
459   {
460     const char* primitive = tokeniser.getToken();
461     if(primitive != 0)
462     {
463       if(string_equal(primitive, "("))
464       {
465         tokeniser.ungetToken(); // (
466         return GlobalBrushModule::getTable().createBrush();
467       }
468     }
469
470     Tokeniser_unexpectedError(tokeniser, primitive, "#quake2-primitive");
471     return g_nullNode;
472   }
473   void readGraph(scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable) const
474   {
475     Tokeniser& tokeniser = GlobalScripLibModule::getTable().m_pfnNewSimpleTokeniser(inputStream);
476     Map_Read(root, tokeniser, entityTable, *this);
477     tokeniser.release();
478   }
479   void writeGraph(scene::Node& root, GraphTraversalFunc traverse, TextOutputStream& outputStream) const
480   {
481     TokenWriter& writer = GlobalScripLibModule::getTable().m_pfnNewSimpleTokenWriter(outputStream);
482     Map_Write(root, traverse, writer, true);
483     writer.release();
484   }
485 };
486
487 typedef SingletonModule<MapQ2API, MapDependencies> MapQ2Module;
488
489 MapQ2Module g_MapQ2Module;
490
491
492
493 #define PARSE_ERROR "error parsing VMF"
494
495 inline void parseToken(Tokeniser& tokeniser, const char* token)
496 {
497   ASSERT_MESSAGE(Tokeniser_parseToken(tokeniser, token), "error parsing vmf: token not found: " << makeQuoted(token));
498 }
499
500 #include "generic/arrayrange.h"
501
502 class VMFBlock;
503 typedef ArrayConstRange<VMFBlock> VMFBlockArrayRange;
504
505
506 class VMFBlock
507 {
508 public:
509   const char* m_name;
510   VMFBlockArrayRange m_children;
511   typedef const VMFBlock Value;
512
513   VMFBlock(const char* name, VMFBlockArrayRange children = VMFBlockArrayRange(0, 0)) : m_name(name), m_children(children)
514   {
515   }
516   const char* name() const
517   {
518     return m_name;
519   }
520   typedef Value* const_iterator;
521   const_iterator begin() const
522   {
523     return m_children.first;
524   }
525   const_iterator end() const
526   {
527     return m_children.last;
528   }
529 };
530
531 const VMFBlock c_vmfNormals("normals");
532 const VMFBlock c_vmfDistances("distances");
533 const VMFBlock c_vmfOffsets("offsets");
534 const VMFBlock c_vmfOffsetNormals("offset_normals");
535 const VMFBlock c_vmfAlphas("alphas");
536 const VMFBlock c_vmfTriangleTags("triangle_tags");
537 const VMFBlock c_vmfAllowedVerts("allowed_verts");
538 const VMFBlock c_vmfDispInfoChildren[] = { c_vmfNormals, c_vmfDistances, c_vmfOffsets, c_vmfOffsetNormals, c_vmfAlphas, c_vmfTriangleTags, c_vmfAllowedVerts };
539 const VMFBlock c_vmfDispInfo("dispinfo", ARRAY_RANGE(c_vmfDispInfoChildren));
540 const VMFBlock c_vmfSideChildren[] = { c_vmfDispInfo };
541 const VMFBlock c_vmfSide("side", ARRAY_RANGE(c_vmfSideChildren));
542 const VMFBlock c_vmfEditor("editor");
543 const VMFBlock c_vmfVersionInfo("versioninfo");
544 const VMFBlock c_vmfViewSettings("viewsettings");
545 const VMFBlock c_vmfCordon("cordon");
546 const VMFBlock c_vmfGroupChildren[] = { c_vmfEditor };
547 const VMFBlock c_vmfGroup("group", ARRAY_RANGE(c_vmfGroupChildren));
548 const VMFBlock c_vmfCamera("camera");
549 const VMFBlock c_vmfCamerasChildren[] = { c_vmfCamera };
550 const VMFBlock c_vmfCameras("cameras", ARRAY_RANGE(c_vmfCamerasChildren));
551 VMFBlock c_vmfVisGroup("visgroup");
552 VMFBlock c_vmfVisGroups("visgroups", VMFBlockArrayRange(&c_vmfVisGroup, &c_vmfVisGroup+1));
553 const VMFBlock c_vmfSolidChildren[] = { c_vmfSide, c_vmfEditor };
554 const VMFBlock c_vmfSolid("solid", ARRAY_RANGE(c_vmfSolidChildren));
555 const VMFBlock c_vmfConnections("connections");
556 const VMFBlock c_vmfEntityChildren[] = { c_vmfEditor, c_vmfSolid, c_vmfGroup, c_vmfConnections };
557 const VMFBlock c_vmfEntity("entity", ARRAY_RANGE(c_vmfEntityChildren));
558 const VMFBlock c_vmfWorldChildren[] = { c_vmfEditor, c_vmfSolid, c_vmfGroup };
559 const VMFBlock c_vmfWorld("world", ARRAY_RANGE(c_vmfWorldChildren));
560 const VMFBlock c_vmfRootChildren[] = { c_vmfVersionInfo, c_vmfViewSettings, c_vmfVisGroups, c_vmfWorld, c_vmfEntity, c_vmfCameras, c_vmfCordon };
561 const VMFBlock c_vmfRoot("", ARRAY_RANGE(c_vmfRootChildren));
562
563 class VMFInit
564 {
565 public:
566   VMFInit()
567   {
568     c_vmfVisGroup.m_children = VMFBlockArrayRange(&c_vmfVisGroup, &c_vmfVisGroup+1);
569   }
570 };
571
572 VMFInit g_VMFInit;
573
574 int g_vmf_entities;
575 int g_vmf_brushes;
576
577 inline VMFBlock::const_iterator VMFBlock_find(const VMFBlock& block, const char* name)
578 {
579   for(VMFBlock::const_iterator i = block.begin(); i != block.end(); ++i)
580   {
581     if(string_equal(name, (*i).name()))
582     {
583       return i;
584     }
585   }
586   return block.end();
587 }
588
589 void VMF_parseBlock(Tokeniser& tokeniser, const VMFBlock& block)
590 {
591   for(;;)
592   {
593     const char* key = tokeniser.getToken();
594     if(key == 0 || string_equal(key, "}"))
595     {
596       tokeniser.ungetToken();
597       break;
598     }
599     CopiedString tmp(key);
600     tokeniser.nextLine();
601     const char* value = tokeniser.getToken();
602     tokeniser.nextLine();
603     if(string_equal(value, "{"))
604     {
605       VMFBlock::const_iterator i = VMFBlock_find(block, tmp.c_str());
606       ASSERT_MESSAGE(i != block.end(), "error parsing vmf block " << makeQuoted(block.name()) << ": unknown block: " << makeQuoted(tmp.c_str()));
607       if(string_equal(tmp.c_str(), "solid"))
608       {
609         ++g_vmf_brushes;
610       }
611       else if(string_equal(tmp.c_str(), "entity") || string_equal(tmp.c_str(), "world"))
612       {
613         ++g_vmf_entities;
614       }
615       VMF_parseBlock(tokeniser, *i);
616       parseToken(tokeniser, "}");
617       tokeniser.nextLine();
618     }
619     else
620     {
621       // was a pair
622     }
623   }
624 }
625
626 void VMF_Read(scene::Node& root, Tokeniser& tokeniser, EntityCreator& entityTable)
627 {
628   g_vmf_entities = g_vmf_brushes = 0;
629   VMF_parseBlock(tokeniser, c_vmfRoot);
630   globalOutputStream() << g_vmf_entities << " entities\n";
631   globalOutputStream() << g_vmf_brushes << " brushes\n";
632 }
633
634 class MapVMFAPI : public TypeSystemRef, public MapFormat
635 {
636 public:
637   typedef MapFormat Type;
638   STRING_CONSTANT(Name, "mapvmf");
639
640   MapVMFAPI()
641   {
642     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("vmf maps", "*.vmf"));
643     GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("vmf region", "*.reg"));
644   }
645   MapFormat* getTable()
646   {
647     return this;
648   }
649
650   void readGraph(scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable) const
651   {
652     Tokeniser& tokeniser = GlobalScripLibModule::getTable().m_pfnNewSimpleTokeniser(inputStream);
653     VMF_Read(root, tokeniser, entityTable);
654     tokeniser.release();
655   }
656   void writeGraph(scene::Node& root, GraphTraversalFunc traverse, TextOutputStream& outputStream) const
657   {
658   }
659 };
660
661 typedef SingletonModule<MapVMFAPI, MapDependencies> MapVMFModule;
662
663 MapVMFModule g_MapVMFModule;
664
665
666
667 extern "C" void RADIANT_DLLEXPORT Radiant_RegisterModules(ModuleServer& server)
668 {
669   initialiseModule(server);
670
671   g_MapDoom3Module.selfRegister();
672   g_MapQuake4Module.selfRegister();
673   g_MapQ3Module.selfRegister();
674   g_MapQ1Module.selfRegister();
675   g_MapQ2Module.selfRegister();
676   g_MapHalfLifeModule.selfRegister();
677   g_MapVMFModule.selfRegister();
678 }