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, "brushDef"))
 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 }