plugins/eclassfgd/plugin.cpp

   1 /*
   2 Copyright (C) 1999-2007 id Software, Inc. and contributors.
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 //#define FGD_VERBOSE // define this for extra info in the log.
  23
  24 #include "plugin.h"
  25
  26 /*! \file plugin.cpp
  27     \brief .fgd entity description format
  28
  29     FGD loading code by Dominic Clifton - Hydra (Hydra@Hydras-World.com)
  30
  31     Overview
  32     ========
  33
  34     This module loads .fgd files, fgd files are split into classes:
  35
  36       base classes
  37       point classes (aka fixed size entities)
  38       solid classes (aka brush entity)
  39
  40     This program first scans each file, building up a list structures
  41     in memory that contain the information for all the classes found
  42     in the file.
  43
  44     Then the program looks at each of the non-base classes in the list
  45     and build the eclass_t structure from each one.
  46
  47     Classes can request information in other classes.
  48
  49     Solid/Base and Point/Base classes can have the same names as other
  50     classes but there can be only one of each solid/point/base class with
  51     the same name,
  52
  53     e.g.:
  54
  55     this is NOT allowed:
  56
  57       @solidclass = "a"
  58       @solidclass = "a"
  59
  60     this is NOT allowed:
  61
  62       @pointclass = "a"
  63       @solidclass = "a"
  64
  65     this IS allowed:
  66
  67       @solidclass = "a"
  68       @baseclass = "a"
  69
  70     Version History
  71     ===============
  72
  73     v0.1 - 13/March/2002
  74       - Initial version.
  75
  76     v0.2 - 16/March/2002
  77       - sets e->skinpath when it finds an iconsprite(<filename>) token.
  78
  79     v0.3 - 21/March/2002
  80       - Core now supports > 8 spawnflags, changes reflected here too.
  81       - FIXED: mins/maxs were backwards when only w,h,d were in the FGD
  82         (as opposed to the actual mins/maxs being in the .def file)
  83       - Made sure all PointClass entities were fixed size entities
  84         and gave them a default bounding box size if a size() setting
  85         was not in the FGD file.
  86       - Removed the string check for classes requesting another class
  87         with the same name, adjusted Find_Class() so that it can search
  88         for baseclasses only,  this fixes the problem with PointClass "light"
  89         requesting the BaseClass "light".
  90
  91     v0.4 - 25/March/2002
  92       - bleh, It turns out that non-baseclasses can request non-baseclasses
  93         so now I've changed Find_Class() so that it can ignore a specific class
  94         (i.e. the one that's asking for others, so that classes can't request
  95         themselves but they can request other classes of any kind with the
  96         same name).
  97       - made all spawnflag comments appear in one place, rather than being scattered
  98         all over the comments if a requested class also had some spawnflags
  99
 100     v0.5 - 6/April/2002
 101       - not using skinpath for sprites anymore, apprently we can code a model
 102         module to display sprites and model files.
 103       - model() tags are now supported.
 104
 105     ToDo
 106     ====
 107
 108     * add support for setting the eclass_t's modelpath.
 109       (not useful for CS, but very useful for HL).
 110
 111     * need to implement usage for e->skinpath in the core.
 112
 113     * cleanup some areas now that GetTokenExtra() is available
 114       (some parts were written prior to it's creation).
 115
 116     * Import the comments between each BaseClass's main [ ] set.
 117       (unfortunatly they're // cstyle comments, which GetToken skips over)
 118       But still ignore comments OUTSIDE the main [ ] set.
 119
 120 */
 121
 122 _QERScripLibTable g_ScripLibTable;
 123 _EClassManagerTable g_EClassManagerTable;
 124 _QERFuncTable_1 g_FuncTable;
 125 _QERFileSystemTable g_FileSystemTable;
 126
 127 // forward declare
 128 void Eclass_ScanFile (char *filename);
 129
 130 const char* EClass_GetExtension()
 131 {
 132   return "fgd";
 133 }
 134
 135 CSynapseServer* g_pSynapseServer = NULL;
 136 CSynapseClientFGD g_SynapseClient;
 137
 138 #if __GNUC__ >= 4
 139 #pragma GCC visibility push(default)
 140 #endif
 141 extern "C" CSynapseClient* SYNAPSE_DLL_EXPORT Synapse_EnumerateInterfaces( const char *version, CSynapseServer *pServer ) {
 142 #if __GNUC__ >= 4
 143 #pragma GCC visibility pop
 144 #endif
 145   if (strcmp(version, SYNAPSE_VERSION))
 146   {
 147     Syn_Printf("ERROR: synapse API version mismatch: should be '" SYNAPSE_VERSION "', got '%s'\n", version);
 148     return NULL;
 149   }
 150   g_pSynapseServer = pServer;
 151   g_pSynapseServer->IncRef();
 152   Set_Syn_Printf(g_pSynapseServer->Get_Syn_Printf());
 153
 154   g_SynapseClient.AddAPI(ECLASS_MAJOR, "fgd", sizeof(_EClassTable));
 155   g_SynapseClient.AddAPI(SCRIPLIB_MAJOR, NULL, sizeof(g_ScripLibTable), SYN_REQUIRE, &g_ScripLibTable);
 156   g_SynapseClient.AddAPI(RADIANT_MAJOR, NULL, sizeof(g_FuncTable), SYN_REQUIRE, &g_FuncTable);
 157   g_SynapseClient.AddAPI(ECLASSMANAGER_MAJOR, NULL, sizeof(g_EClassManagerTable), SYN_REQUIRE, &g_EClassManagerTable);
 158
 159   // Needs a 'default' option for this minor because we certainly don't load anything from wad files :)
 160   g_SynapseClient.AddAPI(VFS_MAJOR, "wad", sizeof(g_FileSystemTable), SYN_REQUIRE, &g_FileSystemTable);
 161
 162   return &g_SynapseClient;
 163 }
 164
 165 bool CSynapseClientFGD::RequestAPI(APIDescriptor_t *pAPI)
 166 {
 167   if (!strcmp(pAPI->major_name, ECLASS_MAJOR))
 168   {
 169     _EClassTable* pTable= static_cast<_EClassTable*>(pAPI->mpTable);
 170
 171     pTable->m_pfnGetExtension = &EClass_GetExtension;
 172     pTable->m_pfnScanFile = &Eclass_ScanFile;
 173
 174     return true;
 175   }
 176
 177   Syn_Printf("ERROR: RequestAPI( '%s' ) not found in '%s'\n", pAPI->major_name, GetInfo());
 178   return false;
 179 }
 180
 181 #include "version.h"
 182
 183 const char* CSynapseClientFGD::GetInfo()
 184 {
 185   return ".fgd eclass module built " __DATE__ " " RADIANT_VERSION;
 186 }
 187
 188 // ------------------------------------------------------------------------------------------------
 189
 190 #define CLASS_NOCLASS     0
 191 #define CLASS_BASECLASS   1
 192 #define CLASS_POINTCLASS  2
 193 #define CLASS_SOLIDCLASS  3
 194
 195 char *classnames[] = {"NOT DEFINED","BaseClass","PointClass","SolidClass"};
 196
 197 #define OPTION_NOOPTION   0
 198 #define OPTION_STRING     1
 199 #define OPTION_CHOICES    2
 200 #define OPTION_INTEGER    3
 201 #define OPTION_FLAGS      4
 202
 203 char *optionnames[] = {"NOT DEFINED","String","Choices","Integer","Flags"};
 204
 205 typedef struct choice_s {
 206   int value;
 207   char *name;
 208 } choice_t;
 209
 210 typedef struct option_s {
 211   int optiontype;
 212   char *optioninfo;
 213   char *epairname;
 214   char *optiondefault;
 215   GSList *choices; // list of choices_t
 216 } option_t;
 217
 218 typedef struct class_s {
 219   int classtype; // see CLASS_* above.
 220   char *classname;
 221   GSList *l_baselist; // when building the eclass_t, other class_s's with these names are required.
 222   char *description;
 223
 224   GSList *l_optionlist; // when building the eclass_t, other class_s's with these names are required.
 225
 226   bool gotsize; // if set then boundingbox is valid.
 227   vec3_t boundingbox[2]; // mins, maxs
 228
 229   bool gotcolor; // if set then color is valid.
 230   vec3_t color; // R,G,B, loaded as 0-255
 231
 232   char *model; // relative path + filename to a model (.spr/.mdl) file, or NULL
 233 } class_t;
 234
 235 /*
 236 ===========================================================
 237 utility functions
 238
 239 ===========================================================
 240 */
 241 char *strlower (char *start)
 242 {
 243         char    *in;
 244         in = start;
 245         while (*in)
 246         {
 247                 *in = tolower(*in);
 248                 in++;
 249         }
 250         return start;
 251 }
 252
 253 char *addstr(char *dest,char *source)
 254 {
 255   if (dest)
 256                 {
 257     char *ptr;
 258     int len = strlen(dest);
 259     ptr = (char *) malloc (len + strlen(source) + 1);
 260     strcpy(ptr,dest);
 261     strcpy(ptr+len,source);
 262     free(dest);
 263     dest = ptr;
 264   }
 265   else
 266                         {
 267     dest = strdup(source);
 268                         }
 269   return(dest);
 270 }
 271
 272 int getindex(unsigned int a)
 273 {
 274   unsigned int count = 0;
 275   unsigned int b = 0;
 276   for (;b != a;count++)
 277   {
 278     b = (1<<count);
 279     if (count > a)
 280       return -1;
 281   }
 282   return (count);
 283 }
 284
 285 void ClearGSList (GSList* lst)
 286 {
 287   GSList *p = lst;
 288   while (p)
 289   {
 290     free (p->data);
 291     p = g_slist_remove (p, p->data);
 292                 }
 293 }
 294
 295 /*!
 296 free a choice_t structure and it's contents
 297 */
 298 void Free_Choice(choice_t *p)
 299 {
 300   if (p->name) free(p->name);
 301   free (p);
 302
 303 }
 304
 305 /*
 306 ===========================================================
 307 Main functions
 308
 309 ===========================================================
 310 */
 311
 312 /*!
 313 free an option_t structure and it's contents
 314 */
 315 void Free_Option(option_t *p)
 316 {
 317   if (p->epairname) free(p->epairname);
 318   if (p->optiondefault) free(p->optiondefault);
 319   if (p->optioninfo) free(p->optioninfo);
 320   GSList *l = p->choices;
 321   while (l)
 322         {
 323     Free_Choice ((choice_t *)l->data);
 324     l = g_slist_remove (l, l->data);
 325         }
 326   free (p);
 327 }
 328
 329 /*!
 330 free a class_t structure and it's contents
 331 */
 332 void Free_Class(class_t *p)
 333 {
 334   GSList *l = p->l_optionlist;
 335   while (l)
 336   {
 337     Free_Option ((option_t *)l->data);
 338     l = g_slist_remove (l, l->data);
 339         }
 340
 341   if (p->classname) free(p->classname);
 342   free (p);
 343 }
 344
 345 /*!
 346 find a class in the list
 347 */
 348 class_t *Find_Class(GSList *l,char *classname, class_t *ignore)
 349 {
 350   for (GSList *clst = l; clst != NULL; clst = clst->next)
 351                 {
 352     class_t *c = (class_t *)clst->data;
 353
 354     if (c == ignore)
 355       continue;
 356
 357     // NOTE: to speed up we could make all the classnames lower-case when they're initialised.
 358     if (!stricmp(c->classname,classname))
 359                         {
 360       return c;
 361                         }
 362
 363                 }
 364   return NULL;
 365 }
 366
 367 /*!
 368 Import as much as possible from a class_t into an eclass_t
 369 Note: this is somewhat recursive, as a class can require a class that requires a class and so on..
 370 */
 371 void EClass_ImportFromClass(eclass_t *e, GSList *l_classes, class_t *bc)
 372 {
 373   char  color[128];
 374
 375   // We allocate 16k here, but only the memory actually used is kept allocated.
 376   // this is just used for building the final comments string.
 377   // Note: if the FGD file contains comments that are >16k (per entity) then
 378   // radiant will crash upon loading such a file as the eclass_t will become
 379   // corrupted.
 380   // FIXME: we could add some length checking when building "newcomments", but
 381   // that'd slow it down a bit.
 382   char newcomments[16384] = "";
 383
 384   //Note: we override the values already in e.
 385   //and we do it in such a way that the items that appear last in the l_baselist
 386   //represent the final values.
 387
 388   if (bc->description)
 389         {
 390     sprintf(newcomments,"%s\n",bc->description);
 391     e->comments = addstr(e->comments,newcomments);
 392     newcomments[0] = 0; // so we don't add them twice.
 393         }
 394
 395
 396   // import from other classes if required.
 397
 398   if (bc->l_baselist)
 399   {
 400     // this class requires other base classes.
 401
 402     for (GSList *bclst = bc->l_baselist; bclst != NULL; bclst = bclst->next)
 403     {
 404       char *requestedclass = (char *)bclst->data;
 405
 406 //      class_t *rbc = Find_Class(l_classes, requestedclass, true);
 407       class_t *rbc = Find_Class(l_classes, requestedclass, bc);
 408
 409       // make sure we don't request ourself!
 410       if (rbc == bc)
 411       {
 412         Sys_Printf ("WARNING: baseclass '%s' tried to request itself!\n", bclst->data);
 413       }
 414                   else
 415       {
 416         if (!rbc)
 417         {
 418           Sys_Printf ("WARNING: could not find the requested baseclass '%s' when building '%s'\n", requestedclass,bc->classname);
 419         }
 420         else
 421         {
 422           // call ourself!
 423           EClass_ImportFromClass(e, l_classes, rbc);
 424         }
 425         }
 426     }
 427   }
 428   // SIZE
 429   if (bc->gotsize)
 430   {
 431     e->fixedsize = true;
 432     memcpy(e->mins,bc->boundingbox[0],sizeof( vec3_t ));
 433     memcpy(e->maxs,bc->boundingbox[1],sizeof( vec3_t ));
 434   }
 435 /*
 436   // Hydra: apparently, this would be bad.
 437
 438   if (bc->sprite)
 439   {
 440     // Hydra - NOTE: e->skinpath is not currently used by the editor but the code
 441     // to set it is used by both this eclass_t loader and the .DEF eclass_t loader.
 442     // TODO: implement using e->skinpath.
 443     if (e->skinpath)
 444       free (e->skinpath);
 445
 446     e->skinpath = strdup(bc->sprite);
 447   }
 448 */
 449
 450   // MODEL
 451   if (bc->model)
 452   {
 453     if (e->modelpath)
 454       free (e->modelpath);
 455
 456     e->modelpath = strdup(bc->model);
 457   }
 458
 459   // COLOR
 460   if (bc->gotcolor)
 461   {
 462     memcpy(e->color,bc->color,sizeof( vec3_t ));
 463     sprintf (color, "(%f %f %f)", e->color[0], e->color[1], e->color[2]);
 464         e->texdef.SetName(color);
 465   }
 466
 467   // SPAWNFLAGS and COMMENTS
 468   if (bc->l_optionlist)
 469   {
 470     for (GSList *optlst = bc->l_optionlist; optlst != NULL; optlst = optlst->next)
 471     {
 472       option_t *opt = (option_t*) optlst->data;
 473
 474       if (opt->optiontype != OPTION_FLAGS)
 475       {
 476         // add some info to the comments.
 477         if (opt->optioninfo)
 478         {
 479           sprintf(newcomments+strlen(newcomments),"%s '%s' %s%s\n",
 480             opt->epairname,
 481             opt->optioninfo ? opt->optioninfo : "",
 482             opt->optiondefault ? ", Default: " : "",
 483             opt->optiondefault ? opt->optiondefault : "");
 484         }
 485         else
 486         {
 487           sprintf(newcomments+strlen(newcomments),"%s %s%s\n",
 488             opt->epairname,
 489             opt->optiondefault ? ", Default: " : "",
 490             opt->optiondefault ? opt->optiondefault : "");
 491         }
 492       }
 493
 494       GSList *choicelst;
 495       switch(opt->optiontype)
 496       {
 497         case OPTION_FLAGS :
 498           // grab the flags.
 499           for (choicelst = opt->choices; choicelst != NULL; choicelst = choicelst->next)
 500           {
 501             choice_t *choice = (choice_t*) choicelst->data;
 502
 503             int index = getindex(choice->value);
 504             index--;
 505             if (index < MAX_FLAGS)
 506             {
 507               strcpy(e->flagnames[index],choice->name);
 508             }
 509             else
 510                   {
 511               Sys_Printf ("WARNING: baseclass '%s' has a spawnflag out of range, ignored!\n", bc->classname);
 512             }
 513           }
 514                             break;
 515         case OPTION_CHOICES :
 516           strcat(newcomments,"  Choices:\n");
 517           for (choicelst = opt->choices; choicelst != NULL; choicelst = choicelst->next)
 518           {
 519             choice_t *choice = (choice_t*) choicelst->data;
 520             sprintf(newcomments+strlen(newcomments),"  %5d - %s\n",choice->value,choice->name);
 521           }
 522           break;
 523       }
 524     }
 525         }
 526
 527   // name
 528   if (e->name) free(e->name);
 529   e->name = strdup(bc->classname);
 530
 531   // fixed size initialisation
 532   if (bc->classtype == CLASS_POINTCLASS)
 533   {
 534     e->fixedsize = true;
 535     // some point classes dont seem to have size()'s in the fgd, so set up a default here..
 536     if ((e->mins[0] == 0) && (e->mins[1] == 0) && (e->mins[2] == 0) &&
 537         (e->maxs[0] == 0) && (e->maxs[1] == 0) && (e->maxs[2] == 0))
 538   {
 539       e->mins[0] = -8;
 540       e->mins[1] = -8;
 541       e->mins[2] = -8;
 542       e->maxs[0] = 8;
 543       e->maxs[1] = 8;
 544       e->maxs[2] = 8;
 545   }
 546
 547     if (e->texdef.GetName() == NULL)
 548     {
 549       // no color specified for this entity in the fgd file
 550       // set one now
 551       // Note: if this eclass_t is not fully built, then this may be
 552       // overridden with the correct color.
 553
 554       e->color[0] = 1;
 555       e->color[1] = 0.5; // how about a nice bright pink, mmm, nice! :)
 556       e->color[2] = 1;
 557
 558       sprintf (color, "(%f %f %f)", e->color[0], e->color[1], e->color[2]);
 559         e->texdef.SetName(color);
 560     }
 561   }
 562
 563   // COMMENTS
 564   if (newcomments[0])
 565   {
 566     e->comments = addstr(e->comments,newcomments);
 567   }
 568 }
 569
 570 /*!
 571 create the eclass_t structures and add to the global list.
 572 */
 573 void Create_EClasses(GSList *l_classes)
 574 {
 575   int count = 0;
 576   // loop through the loaded structures finding all the non BaseClasses
 577   for (GSList *clst = l_classes; clst != NULL; clst = clst->next)
 578   {
 579     class_t *c = (class_t *)clst->data;
 580
 581     if (c->classtype == CLASS_BASECLASS) // not looking for these.
 582       continue;
 583
 584     eclass_t *e = (eclass_t *) malloc( sizeof( eclass_s ));
 585     memset(e,0,sizeof( eclass_s ));
 586
 587     EClass_ImportFromClass(e, l_classes, c );
 588
 589     // radiant will crash if this is null, and it still could be at this point.
 590     if (!e->comments)
 591     {
 592       e->comments=strdup("No description available, check documentation\n");
 593     }
 594
 595     // dump the spawnflags to the end of the comments.
 596     int i;
 597     bool havespawnflags;
 598
 599     havespawnflags = false;
 600     for (i = 0 ; i < MAX_FLAGS ; i++)
 601     {
 602       if (*e->flagnames[i]) havespawnflags = true;
 603     }
 604
 605     if (havespawnflags)
 606     {
 607       char spawnline[80];
 608       e->comments = addstr(e->comments,"Spawnflags\n");
 609       for (i = 0 ; i < MAX_FLAGS ; i++)
 610       {
 611         if (*e->flagnames[i])
 612         {
 613           sprintf(spawnline,"  %d - %s\n", 1<<i, e->flagnames[i]);
 614           e->comments = addstr(e->comments,spawnline);
 615         }
 616       }
 617     }
 618
 619     Eclass_InsertAlphabetized (e);
 620     count ++;
 621     // Hydra: ttimo, I don't think this code is required...
 622                 // single ?
 623                 *Get_Eclass_E() = e;
 624     Set_Eclass_Found(true);
 625                 if ( Get_Parsing_Single() )
 626                         break;
 627   }
 628
 629   Sys_Printf ("FGD Loaded %d entities.\n", count);
 630 }
 631
 632 void Eclass_ScanFile (char *filename)
 633 {
 634         int             size;
 635         char    *data;
 636         char    temp[1024];
 637   GSList *l_classes = NULL;
 638         char  token_debug[1024]; //++Hydra FIXME: cleanup this.
 639   bool done = false;
 640   int len,classtype;
 641
 642   char *token = Token();
 643
 644         QE_ConvertDOSToUnixName( temp, filename );
 645
 646         size = vfsLoadFullPathFile (filename, (void**)&data);
 647   if (size <= 0)
 648   {
 649     Sys_FPrintf (SYS_ERR, "Eclass_ScanFile: %s not found\n", filename);
 650     return;
 651   }
 652         Sys_Printf ("ScanFile: %s\n", temp);
 653
 654   // start parsing the file
 655   StartTokenParsing(data);
 656
 657   // build a list of base classes first
 658
 659   while (!done)
 660                 {
 661     // find an @ sign.
 662     do
 663     {
 664       if (!GetToken(true))
 665       {
 666         done = true;
 667         break;
 668       }
 669     } while (token[0] != '@');
 670
 671     strcpy(temp,token+1); // skip the @
 672
 673     classtype = CLASS_NOCLASS;
 674     if (!stricmp(temp,"BaseClass")) classtype = CLASS_BASECLASS;
 675     if (!stricmp(temp,"PointClass")) classtype = CLASS_POINTCLASS;
 676     if (!stricmp(temp,"SolidClass")) classtype = CLASS_SOLIDCLASS;
 677
 678     if (classtype)
 679     {
 680       class_t *newclass = (class_t *) malloc( sizeof(class_s) );
 681       memset( newclass, 0, sizeof(class_s) );
 682       newclass->classtype = classtype;
 683
 684       while (1)
 685       {
 686         GetTokenExtra(false,"(",false); // option or =
 687         strcpy(token_debug,token);
 688
 689         if (!strcmp(token,"="))
 690         {
 691           UnGetToken();
 692           break;
 693         }
 694                         else
 695         {
 696           strlower(token);
 697           if (!strcmp(token,"base"))
 698           {
 699             GetTokenExtra(false,"(",true); // (
 700
 701             if (!strcmp(token,"("))
 702             {
 703               while (GetTokenExtra(false,",)",false)) // option) or option,
 704               {
 705                 newclass->l_baselist = g_slist_append (newclass->l_baselist, strdup(token));
 706
 707                 GetTokenExtra(false,",)",true); // , or )
 708                 if (!strcmp(token,")"))
 709                   break;
 710
 711               }
 712             }
 713           }
 714           else if (!strcmp(token,"size"))
 715           {
 716             // parse (w h d) or (x y z, x y z)
 717
 718             GetTokenExtra(false,"(",true); // (
 719             if (!strcmp(token,"("))
 720             {
 721               int sizedone = false;
 722               float w,h,d;
 723               GetToken(false);
 724               w = atof(token);
 725               GetToken(false);
 726               h = atof(token);
 727               GetToken(false); // number) or number ,
 728               strcpy(temp,token);
 729               len = strlen(temp);
 730               if (temp[len-1] == ')') sizedone = true;
 731               temp[len-1] = 0;
 732               d = atof(temp);
 733               if (sizedone)
 734               {
 735                 // only one set of cordinates supplied, change the W,H,D to mins/maxs
 736                 newclass->boundingbox[0][0] = 0 - (w / 2);
 737                 newclass->boundingbox[1][0] = w / 2;
 738                 newclass->boundingbox[0][1] = 0 - (h / 2);
 739                 newclass->boundingbox[1][1] = h / 2;
 740                 newclass->boundingbox[0][2] = 0 - (d / 2);
 741                 newclass->boundingbox[1][2] = d / 2;
 742                 newclass->gotsize = true;
 743               }
 744               else
 745               {
 746                 newclass->boundingbox[0][0] = w;
 747                 newclass->boundingbox[0][1] = h;
 748                 newclass->boundingbox[0][2] = d;
 749                 GetToken(false);
 750                 newclass->boundingbox[1][0] = atof(token);
 751                 GetToken(false);
 752                 newclass->boundingbox[1][1] = atof(token);
 753 /*
 754                 GetToken(false); // "number)" or "number )"
 755                 strcpy(temp,token);
 756                 len = strlen(temp);
 757                 if (temp[len-1] == ')')
 758                   temp[len-1] = 0;
 759                 else
 760                   GetToken(false); // )
 761                 newclass->boundingbox[1][2] = atof(temp);
 762 */
 763                 GetTokenExtra(false,")",false); // number
 764                 newclass->boundingbox[1][2] = atof(token);
 765                 newclass->gotsize = true;
 766                 GetTokenExtra(false,")",true); // )
 767               }
 768             }
 769           }
 770           else if (!strcmp(token,"color"))
 771           {
 772             GetTokenExtra(false,"(",true); // (
 773             if (!strcmp(token,"("))
 774             {
 775               // get the color values (0-255) and normalize them if required.
 776               GetToken(false);
 777               newclass->color[0] = atof(token);
 778               if (newclass->color[0] > 1)
 779                 newclass->color[0]/=255;
 780               GetToken(false);
 781               newclass->color[1] = atof(token);
 782               if (newclass->color[1] > 1)
 783                 newclass->color[1]/=255;
 784               GetToken(false);
 785               strcpy(temp,token);
 786               len = strlen(temp);
 787               if (temp[len-1] == ')') temp[len-1] = 0;
 788               newclass->color[2] = atof(temp);
 789               if (newclass->color[2] > 1)
 790                 newclass->color[2]/=255;
 791               newclass->gotcolor = true;
 792             }
 793           }
 794           else if (!strcmp(token,"iconsprite"))
 795           {
 796             GetTokenExtra(false,"(",true); // (
 797             if (!strcmp(token,"("))
 798             {
 799               GetTokenExtra(false,")",false); // filename)
 800               // the model plugins will handle sprites too.
 801               // newclass->sprite = strdup(token);
 802               newclass->model = strdup(token);
 803               GetTokenExtra(false,")",true); // )
 804             }
 805           }
 806           else if (!strcmp(token,"model"))
 807           {
 808             GetTokenExtra(false,"(",true); // (
 809             if (!strcmp(token,"("))
 810             {
 811               GetTokenExtra(false,")",false); // filename)
 812               newclass->model = strdup(token);
 813               GetTokenExtra(false,")",true); // )
 814             }
 815           }
 816           else
 817           {
 818             // Unsupported
 819             GetToken(false); // skip it.
 820           }
 821
 822         }
 823       }
 824
 825       GetToken(false); // =
 826       strcpy(token_debug,token);
 827       if (!strcmp(token,"="))
 828       {
 829         GetToken(false);
 830         newclass->classname = strdup(token);
 831       }
 832
 833       // Get the description
 834       if (newclass->classtype != CLASS_BASECLASS)
 835       {
 836         GetToken(false);
 837         if (!strcmp(token,":"))
 838         {
 839           GetToken(false);
 840           newclass->description = strdup(token);
 841         } else UnGetToken(); // no description
 842       }
 843
 844       // now build the option list.
 845       GetToken(true); // [ or []
 846
 847       if (strcmp(token,"[]"))  // got some options ?
 848       {
 849         if (!strcmp(token,"["))
 850         {
 851           // yup
 852           bool optioncomplete = false;
 853           option_t *newoption;
 854
 855           while (1)
 856           {
 857             GetToken(true);
 858             if (!strcmp(token,"]"))
 859               break; // no more options
 860
 861             // parse the data and build the option_t
 862
 863             strcpy(temp,token);
 864             len = strlen(temp);
 865             char *ptr = strchr(temp,'(');
 866
 867             if (!ptr)
 868                                       break;
 869
 870             newoption = (option_t *) malloc ( sizeof( option_s ));
 871             memset( newoption, 0, sizeof( option_s ));
 872
 873             *ptr++ = 0;
 874             newoption->epairname = strdup(temp);
 875
 876             len = strlen(ptr);
 877             if (ptr[len-1] != ')')
 878               break;
 879
 880             ptr[len-1] = 0;
 881             strlower(ptr);
 882             if (!strcmp(ptr,"integer"))
 883             {
 884               newoption->optiontype = OPTION_INTEGER;
 885             }
 886             else if (!strcmp(ptr,"choices"))
 887             {
 888               newoption->optiontype = OPTION_CHOICES;
 889             }
 890             else if (!strcmp(ptr,"flags"))
 891             {
 892               newoption->optiontype = OPTION_FLAGS;
 893             }
 894             else // string
 895             {
 896               newoption->optiontype = OPTION_STRING;
 897             }
 898
 899             switch (newoption->optiontype)
 900             {
 901               case OPTION_STRING :
 902               case OPTION_INTEGER :
 903                 if (!TokenAvailable())
 904                 {
 905                   optioncomplete = true;
 906                                 break;
 907                 }
 908                 GetToken(false); // :
 909                 strcpy(token_debug,token);
 910                 if ((token[0] == ':') && (strlen(token) > 1))
 911                 {
 912                   newoption->optioninfo = strdup(token+1);
 913                 }
 914                 else
 915                 {
 916                   GetToken(false);
 917                   newoption->optioninfo = strdup(token);
 918                 }
 919                 if (TokenAvailable()) // default value ?
 920                 {
 921                   GetToken(false);
 922                   if (!strcmp(token,":"))
 923                   {
 924                     if (GetToken(false))
 925                     {
 926                       newoption->optiondefault = strdup(token);
 927                       optioncomplete = true;
 928                     }
 929                   }
 930                 }
 931                 else
 932                 {
 933                   optioncomplete = true;
 934                 }
 935                 break;
 936
 937               case OPTION_CHOICES :
 938                 GetTokenExtra(false,":",true); // : or :"something like this" (bah!)
 939                 strcpy(token_debug,token);
 940                 if ((token[0] == ':') && (strlen(token) > 1))
 941                 {
 942                   if (token[1] == '\"')
 943                   {
 944                     strcpy(temp,token+2);
 945                     while (1)
 946                     {
 947                       if (!GetToken(false))
 948                         break;
 949                       strcat(temp," ");
 950                       strcat(temp,token);
 951                       len = strlen(temp);
 952                       if (temp[len-1] == '\"')
 953                       {
 954                         temp[len-1] = 0;
 955                         break;
 956                       }
 957                     }
 958                   }
 959                   newoption->optioninfo = strdup(temp);
 960                 }
 961                 else
 962                 {
 963                   GetToken(false);
 964                   newoption->optioninfo = strdup(token);
 965                 }
 966                 GetToken(false); // : or =
 967                 strcpy(token_debug,token);
 968                 if (!strcmp(token,":"))
 969                 {
 970                   GetToken(false);
 971                   newoption->optiondefault = strdup(token);
 972                 }
 973                 else
 974                 {
 975                   UnGetToken();
 976                 }
 977                 // And Follow on...
 978               case OPTION_FLAGS :
 979                 GetToken(false); // : or =
 980                 strcpy(token_debug,token);
 981                 if (strcmp(token,"=")) // missing ?
 982                   break;
 983
 984                 GetToken(true); // [
 985                 strcpy(token_debug,token);
 986                 if (strcmp(token,"[")) // missing ?
 987                   break;
 988
 989                 choice_t *newchoice;
 990                 while (1)
 991                 {
 992                   GetTokenExtra(true,":",true); // "]" or "number", or "number:"
 993                   strcpy(token_debug,token);
 994                   if (!strcmp(token,"]")) // no more ?
 995                   {
 996                     optioncomplete = true;
 997                     break;
 998                   }
 999                   strcpy(temp,token);
1000                   len = strlen(temp);
1001                   if (temp[len-1] == ':')
1002                   {
1003                     temp[len-1] = 0;
1004                   }
1005                   else
1006                   {
1007                     GetToken(false); // :
1008                     if (strcmp(token,":")) // missing ?
1009                       break;
1010                   }
1011                   if (!TokenAvailable())
1012                     break;
1013                   GetToken(false); // the name
1014
1015                   newchoice = (choice_t *) malloc ( sizeof( choice_s ));
1016                   memset( newchoice, 0, sizeof( choice_s ));
1017
1018                   newchoice->value = atoi(temp);
1019                   newchoice->name = strdup(token);
1020
1021                   newoption->choices = g_slist_append(newoption->choices, newchoice);
1022
1023                   // ignore any remaining tokens on the line
1024                   while (TokenAvailable()) GetToken(false);
1025
1026                   // and it we found a "]" on the end of the line, put it back in the queue.
1027                   if (!strcmp(token,"]")) UnGetToken();
1028                 }
1029                                 break;
1030
1031             }
1032
1033             // add option to the newclass
1034
1035             if (optioncomplete)
1036             {
1037               if (newoption)
1038               {
1039                 // add it to the list.
1040                 newclass->l_optionlist = g_slist_append(newclass->l_optionlist, newoption);
1041               }
1042             }
1043             else
1044             {
1045               Sys_Printf ("%WARNING: Parse error occured in '%s - %s'\n",classnames[newclass->classtype],newclass->classname);
1046               Free_Option(newoption);
1047             }
1048
1049           }
1050         }
1051         else
1052         {
1053           UnGetToken(); // shouldn't get here.
1054         }
1055       }
1056
1057       // add it to our list.
1058       l_classes = g_slist_append (l_classes, newclass);
1059
1060     }
1061   }
1062
1063   // finished with the file now.
1064   g_free(data);
1065
1066   Sys_Printf ("FGD scan complete, building entities...\n");
1067
1068   // Once we get here we should have a few (!) lists in memory that we
1069   // can extract all the information required to build a the eclass_t structures.
1070
1071   Create_EClasses(l_classes);
1072
1073   // Free everything
1074
1075   GSList *p = l_classes;
1076   while (p)
1077   {
1078     class_t *tmpclass = (class_t *)p->data;
1079
1080 #ifdef FGD_VERBOSE
1081     // DEBUG: dump the info...
1082     Sys_Printf ("%s: %s (", classnames[tmpclass->classtype],tmpclass->classname);
1083     for (GSList *tmp = tmpclass->l_baselist; tmp != NULL; tmp = tmp->next)
1084     {
1085       if (tmp != tmpclass->l_baselist)
1086       {
1087         Sys_Printf (", ");
1088       }
1089       Sys_Printf ("%s", (char *)tmp->data);
1090     }
1091     if (tmpclass->gotsize)
1092     {
1093       sprintf(temp,"(%.0f %.0f %.0f) - (%.0f %.0f %.0f)",tmpclass->boundingbox[0][0],
1094         tmpclass->boundingbox[0][1],
1095         tmpclass->boundingbox[0][2],
1096         tmpclass->boundingbox[1][0],
1097         tmpclass->boundingbox[1][1],
1098         tmpclass->boundingbox[1][2]);
1099     } else strcpy(temp,"No Size");
1100     Sys_Printf (") '%s' Size: %s",tmpclass->description ? tmpclass->description : "No description",temp);
1101     if (tmpclass->gotcolor)
1102     {
1103       sprintf(temp,"(%d %d %d)",tmpclass->color[0],
1104         tmpclass->color[1],
1105         tmpclass->color[2]);
1106     } else strcpy(temp,"No Color");
1107     Sys_Printf (" Color: %s Options:\n",temp);
1108     if (!tmpclass->l_optionlist)
1109     {
1110       Sys_Printf ("  No Options\n");
1111     }
1112     else
1113     {
1114       option_t *tmpoption;
1115       int count;
1116       GSList *olst;
1117       for (olst = tmpclass->l_optionlist, count = 1; olst != NULL; olst = olst->next, count ++)
1118       {
1119         tmpoption = (option_t *)olst->data;
1120         Sys_Printf ("  %d, Type: %s, EPair: %s\n", count,optionnames[tmpoption->optiontype], tmpoption->epairname );
1121
1122         choice_t *tmpchoice;
1123         GSList *clst;
1124         int ccount;
1125         for (clst = tmpoption->choices, ccount = 1; clst != NULL; clst = clst->next, ccount ++)
1126         {
1127           tmpchoice = (choice_t *)clst->data;
1128           Sys_Printf ("    %d, Value: %d, Name: %s\n", ccount, tmpchoice->value, tmpchoice->name);
1129         }
1130       }
1131     }
1132
1133 #endif
1134
1135     // free the baselist.
1136     ClearGSList(tmpclass->l_baselist);
1137     Free_Class (tmpclass);
1138     p = g_slist_remove (p, p->data);
1139                 }
1140
1141 }