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