gtkradiant/radiant/eclass_def.cpp

/*
Copyright (C) 1999-2006 Id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.

This file is part of GtkRadiant.

GtkRadiant is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

GtkRadiant is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include "eclass_def.h"

#include "iscriplib.h"
#include "ifilesystem.h"
#include "iarchive.h"

#include "eclasslib.h"
#include "stream/stringstream.h"
#include "stream/textfilestream.h"
#include "modulesystem/moduleregistry.h"
#include "os/path.h"

const char* EClass_GetExtension()
{
  return "def";
}
void Eclass_ScanFile (EntityClassCollector& collector, const char *filename);


#include "modulesystem/singletonmodule.h"

class EntityClassDefDependencies : public GlobalShaderCacheModuleRef, public GlobalScripLibModuleRef
{
};

class EclassDefAPI
{
  EntityClassScanner m_eclassdef;
public:
  typedef EntityClassScanner Type;
  STRING_CONSTANT(Name, "def");

  EclassDefAPI()
  {
    m_eclassdef.scanFile = &Eclass_ScanFile;
    m_eclassdef.getExtension = &EClass_GetExtension;
  }
  EntityClassScanner* getTable()
  {
    return &m_eclassdef;
  }
};

typedef SingletonModule<EclassDefAPI, EntityClassDefDependencies> EclassDefModule;
typedef Static<EclassDefModule> StaticEclassDefModule;
StaticRegisterModule staticRegisterEclassDef(StaticEclassDefModule::instance());


#include "string/string.h"

#include <stdlib.h>


char		com_token[1024];
bool	com_eof;

/*
==============
COM_Parse

Parse a token out of a string
==============
*/
const char *COM_Parse (const char *data)
{
	int		c;
	int		len;

	len = 0;
	com_token[0] = 0;
	
	if (!data)
		return 0;
		
// skip whitespace
skipwhite:
	while ( (c = *data) <= ' ')
	{
		if (c == 0)
		{
			com_eof = true;
			return 0;			// end of file;
		}
		data++;
	}
	
// skip // comments
	if (c=='/' && data[1] == '/')
	{
		while (*data && *data != '\n')
			data++;
		goto skipwhite;
	}
	

// handle quoted strings specially
	if (c == '\"')
	{
		data++;
		do
		{
			c = *data++;
			if (c=='\"')
			{
				com_token[len] = 0;
				return data;
			}
			com_token[len] = c;
			len++;
		} while (1);
	}

// parse single characters
	if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
	{
		com_token[len] = c;
		len++;
		com_token[len] = 0;
		return data+1;
	}

// parse a regular word
	do
	{
		com_token[len] = c;
		data++;
		len++;
		c = *data;
	if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
			break;
	} while (c>32);
	
	com_token[len] = 0;
	return data;
}

const char* Get_COM_Token()
{
  return com_token;
}


const char *debugname;

void setSpecialLoad(EntityClass *e, const char* pWhat, CopiedString& p)
{
  // Hydra: removed some amazingly bad cstring usage, whoever wrote that
  // needs to be taken out and shot.

  const char *pText = 0;
  const char *where = 0;

  where = strstr(e->comments(),pWhat);
  if (!where)
    return;

  pText = where + strlen(pWhat);
  if (*pText == '\"')
    pText++;

  where = strchr(pText,'\"');
  if (where)
  {
    p = StringRange(pText, where);
  }
  else
  {
    p = pText;
  }
}

#include "eclasslib.h"

/*

the classname, color triple, and bounding box are parsed out of comments
A ? size means take the exact brush size.

/ *QUAKED <classname> (0 0 0) ?
/ *QUAKED <classname> (0 0 0) (-8 -8 -8) (8 8 8)

Flag names can follow the size description:

/ *QUAKED func_door (0 .5 .8) ? START_OPEN STONE_SOUND DOOR_DONT_LINK GOLD_KEY SILVER_KEY

*/

EntityClass *Eclass_InitFromText (const char *text)
{
	EntityClass* e = Eclass_Alloc();
  e->free = &Eclass_Free;

  // grab the name
	text = COM_Parse (text);
	e->m_name = Get_COM_Token();
	debugname = e->name();

  {
    // grab the color, reformat as texture name
    int r = sscanf (text," (%f %f %f)", &e->color[0], &e->color[1], &e->color[2]);
    if (r != 3)
		  return e;
	  eclass_capture_state(e);
  }

	while (*text != ')')
  {
    if (!*text) {
			return 0;
    }
		text++;
	}
	text++;
	
  // get the size	
	text = COM_Parse (text);
	if (Get_COM_Token()[0] == '(')
	{	// parse the size as two vectors
		e->fixedsize = true;
		int r = sscanf (text,"%f %f %f) (%f %f %f)", &e->mins[0], &e->mins[1], &e->mins[2],
			&e->maxs[0], &e->maxs[1], &e->maxs[2]);
    if (r != 6) {
			return 0;
    }

		for (int i=0 ; i<2 ; i++)
		{
			while (*text != ')')
			{
        if (!*text) {
					return 0;
        }
				text++;
			}
			text++;
		}
	}
	
	char	parms[256];
  // get the flags
  {
    // copy to the first /n
	  char* p = parms;
	  while (*text && *text != '\n')
		  *p++ = *text++;
	  *p = 0;
	  text++;
  }
	
  {
    // any remaining words are parm flags
	  const char* p = parms;
	  for (std::size_t i=0 ; i<MAX_FLAGS ; i++)
	  {
		  p = COM_Parse (p);
		  if (!p)
			  break;
		  strcpy (e->flagnames[i], Get_COM_Token());
	  }
  }

	e->m_comments = text;

  setSpecialLoad(e, "model=", e->m_modelpath);
  StringOutputStream buffer(string_length(e->m_modelpath.c_str()));
  buffer << PathCleaned(e->m_modelpath.c_str());
  e->m_modelpath = buffer.c_str();

  if(!e->fixedsize)
  {
    EntityClass_insertAttribute(*e, "angle", EntityClassAttribute("direction", "Direction", "0"));
  }
  else
  {
    EntityClass_insertAttribute(*e, "angle", EntityClassAttribute("angle", "Yaw Angle", "0"));
  }
  EntityClass_insertAttribute(*e, "model", EntityClassAttribute("model", "Model"));
  EntityClass_insertAttribute(*e, "noise", EntityClassAttribute("sound", "Sound"));

  return e;
}

void Eclass_ScanFile (EntityClassCollector& collector, const char *filename)
{
	EntityClass	*e;
	
  TextFileInputStream inputFile(filename);
  if(inputFile.failed())
  {
    globalErrorStream() << "ScanFile: " << filename << " not found\n";
    return;
  }
  globalOutputStream() << "ScanFile: " << filename << "\n";

  enum EParserState
  {
    eParseDefault,
    eParseSolidus,
    eParseComment,
    eParseQuakeED,
    eParseEntityClass,
    eParseEntityClassEnd,
  } state = eParseDefault;
  const char* quakeEd = "QUAKED";
  const char* p = 0;
  StringBuffer buffer;
  SingleCharacterInputStream<TextFileInputStream> bufferedInput(inputFile);
  for(;;)
  {
    char c;
    if(!bufferedInput.readChar(c))
    {
      break;
    }

    switch(state)
    {
    case eParseDefault:
      if(c == '/')
      {
        state = eParseSolidus;
      }
      break;
    case eParseSolidus:
      if(c == '/')
      {
        state = eParseComment;
      }
      else if(c == '*')
      {
        p = quakeEd;
        state = eParseQuakeED;
      }
      break;
    case eParseComment:
      if(c == '\n')
      {
        state = eParseDefault;
      }
      break;
    case eParseQuakeED:
      if(c == *p)
      {
        if(*(++p) == '\0')
        {
          state = eParseEntityClass;
        }
      }
      else
      {
        state = eParseDefault;
      }
      break;
    case eParseEntityClass:
      if(c == '*')
      {
        state = eParseEntityClassEnd;
      }
      else
      {
        buffer.push_back(c);
      }
      break;
    case eParseEntityClassEnd:
      if(c == '/')
      {
        e = Eclass_InitFromText(buffer.c_str());
        state = eParseDefault;
        if (e)
          collector.insert(e);
        else
          globalErrorStream() << "Error parsing: " << debugname << " in " << filename << "\n";

        buffer.clear();
        state = eParseDefault;
      }
      else
      {
        buffer.push_back('*');
        buffer.push_back(c);
        state = eParseEntityClass;
      }
      break;
    }
  }
}