310 lines
6.7 KiB
C
310 lines
6.7 KiB
C
/*
|
|
trace.c
|
|
|
|
(description)
|
|
|
|
Copyright (C) 2002 Colin Thompson
|
|
|
|
This program 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.
|
|
|
|
This program 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 this program; if not, write to:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
static const char rcsid[] =
|
|
"$Id$";
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
#ifdef HAVE_IO_H
|
|
# include <io.h>
|
|
#endif
|
|
#ifdef HAVE_STRING_H
|
|
# include <string.h>
|
|
#endif
|
|
#ifdef HAVE_STRINGS_H
|
|
# include <strings.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "QF/bspfile.h"
|
|
#include "QF/dstring.h"
|
|
#include "QF/idparse.h"
|
|
#include "QF/mathlib.h"
|
|
#include "QF/qtypes.h"
|
|
#include "QF/quakefs.h"
|
|
#include "QF/sys.h"
|
|
|
|
#include "light.h"
|
|
#include "threads.h"
|
|
#include "entities.h"
|
|
#include "options.h"
|
|
|
|
entity_t entities[MAX_MAP_ENTITIES];
|
|
int num_entities;
|
|
|
|
/*
|
|
ENTITY FILE PARSING
|
|
|
|
If a light has a targetname, generate a unique style in the 32-63 range
|
|
*/
|
|
|
|
int numlighttargets;
|
|
char lighttargets[32][64];
|
|
|
|
|
|
int
|
|
LightStyleForTargetname (char *targetname, qboolean alloc)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < numlighttargets; i++)
|
|
if (!strcmp (lighttargets[i], targetname))
|
|
return 32 + i;
|
|
|
|
if (!alloc)
|
|
return -1;
|
|
|
|
strcpy (lighttargets[i], targetname);
|
|
numlighttargets++;
|
|
return numlighttargets - 1 + 32;
|
|
}
|
|
|
|
void
|
|
MatchTargets (void)
|
|
{
|
|
int i, j;
|
|
|
|
for (i = 0; i < num_entities; i++) {
|
|
if (!entities[i].target[0])
|
|
continue;
|
|
|
|
for (j = 0; j < num_entities; j++)
|
|
if (!strcmp (entities[j].targetname, entities[i].target)) {
|
|
entities[i].targetent = &entities[j];
|
|
break;
|
|
}
|
|
if (j == num_entities) {
|
|
printf ("WARNING: entity at (%i,%i,%i) (%s) has unmatched "
|
|
"target\n",
|
|
(int) entities[i].origin[0], (int) entities[i].origin[1],
|
|
(int) entities[i].origin[2], entities[i].classname);
|
|
continue;
|
|
}
|
|
// set the style on the source ent for switchable lights
|
|
if (entities[j].style) {
|
|
char s[16];
|
|
|
|
entities[i].style = entities[j].style;
|
|
sprintf (s, "%i", entities[i].style);
|
|
SetKeyValue (&entities[i], "style", s);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
LoadEntities (void)
|
|
{
|
|
const char *data;
|
|
char key[64];
|
|
double vec[3];
|
|
entity_t *entity;
|
|
epair_t *epair;
|
|
int i;
|
|
|
|
data = bsp->entdata;
|
|
|
|
// start parsing
|
|
num_entities = 0;
|
|
|
|
// go through all the entities
|
|
while (1) {
|
|
// parse the opening brace
|
|
data = COM_Parse (data);
|
|
if (!data)
|
|
break;
|
|
if (com_token[0] != '{')
|
|
fprintf (stderr, "LoadEntities: found %s when expecting {",
|
|
com_token);
|
|
|
|
if (num_entities == MAX_MAP_ENTITIES)
|
|
fprintf (stderr, "LoadEntities: MAX_MAP_ENTITIES");
|
|
entity = &entities[num_entities];
|
|
num_entities++;
|
|
|
|
// go through all the keys in this entity
|
|
while (1) {
|
|
int c;
|
|
|
|
// parse key
|
|
data = COM_Parse (data);
|
|
if (!data)
|
|
fprintf (stderr, "LoadEntities: EOF without closing brace");
|
|
if (!strcmp (com_token, "}"))
|
|
break;
|
|
strcpy (key, com_token);
|
|
|
|
// parse value
|
|
data = COM_Parse (data);
|
|
if (!data)
|
|
fprintf (stderr, "LoadEntities: EOF without closing brace");
|
|
c = com_token[0];
|
|
if (c == '}')
|
|
fprintf (stderr, "LoadEntities: closing brace without data");
|
|
|
|
epair = malloc (sizeof (epair_t));
|
|
memset (epair, 0, sizeof (epair));
|
|
strcpy (epair->key, key);
|
|
strcpy (epair->value, com_token);
|
|
epair->next = entity->epairs;
|
|
entity->epairs = epair;
|
|
|
|
if (!strcmp (key, "classname"))
|
|
strcpy (entity->classname, com_token);
|
|
else if (!strcmp (key, "target"))
|
|
strcpy (entity->target, com_token);
|
|
else if (!strcmp (key, "targetname"))
|
|
strcpy (entity->targetname, com_token);
|
|
else if (!strcmp (key, "origin")) {
|
|
// scan into doubles, then assign
|
|
// which makes it vec_t size independent
|
|
if (sscanf (com_token, "%lf %lf %lf",
|
|
&vec[0], &vec[1], &vec[2]) != 3)
|
|
fprintf (stderr, "LoadEntities: not 3 values for origin");
|
|
for (i = 0; i < 3; i++)
|
|
entity->origin[i] = vec[i];
|
|
} else if (!strncmp (key, "light", 5) || !strcmp (key, "_light")) {
|
|
entity->light = atof(com_token);
|
|
} else if (!strcmp (key, "style")) {
|
|
entity->style = atof (com_token);
|
|
if ((unsigned) entity->style > 254)
|
|
fprintf (stderr, "Bad light style %i (must be 0-254)",
|
|
entity->style);
|
|
} else if (!strcmp (key, "angle")) {
|
|
entity->angle = atof(com_token);
|
|
}
|
|
}
|
|
|
|
// all fields have been parsed
|
|
if (!strncmp (entity->classname, "light", 5) && !entity->light)
|
|
entity->light = DEFAULTLIGHTLEVEL;
|
|
|
|
if (!strcmp (entity->classname, "light")) {
|
|
if (entity->targetname[0] && !entity->style) {
|
|
char s[16];
|
|
|
|
entity->style = LightStyleForTargetname (entity->targetname,
|
|
true);
|
|
sprintf (s, "%i", entity->style);
|
|
SetKeyValue (entity, "style", s);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (options.verbosity >= 0)
|
|
printf ("%d entities read\n", num_entities);
|
|
|
|
MatchTargets ();
|
|
}
|
|
|
|
char *
|
|
ValueForKey (entity_t *ent, char *key)
|
|
{
|
|
epair_t *ep;
|
|
|
|
for (ep = ent->epairs; ep; ep = ep->next)
|
|
if (!strcmp (ep->key, key))
|
|
return ep->value;
|
|
return "";
|
|
}
|
|
|
|
void
|
|
SetKeyValue (entity_t *ent, char *key, char *value)
|
|
{
|
|
epair_t *ep;
|
|
|
|
for (ep = ent->epairs; ep; ep = ep->next)
|
|
if (!strcmp (ep->key, key)) {
|
|
strcpy (ep->value, value);
|
|
return;
|
|
}
|
|
ep = malloc (sizeof (*ep));
|
|
ep->next = ent->epairs;
|
|
ent->epairs = ep;
|
|
strcpy (ep->key, key);
|
|
strcpy (ep->value, value);
|
|
}
|
|
|
|
float
|
|
FloatForKey (entity_t *ent, char *key)
|
|
{
|
|
char *k;
|
|
|
|
k = ValueForKey (ent, key);
|
|
return atof (k);
|
|
}
|
|
|
|
void
|
|
GetVectorForKey (entity_t *ent, char *key, vec3_t vec)
|
|
{
|
|
char *k;
|
|
|
|
k = ValueForKey (ent, key);
|
|
sscanf (k, "%f %f %f", &vec[0], &vec[1], &vec[2]);
|
|
}
|
|
|
|
void
|
|
WriteEntitiesToString (void)
|
|
{
|
|
char *buf, *end;
|
|
char line[128];
|
|
epair_t *ep;
|
|
int i;
|
|
|
|
buf = bsp->entdata;
|
|
end = buf;
|
|
*end = 0;
|
|
|
|
if (options.verbosity >= 0)
|
|
printf ("%i switchable light styles\n", numlighttargets);
|
|
|
|
for (i = 0; i < num_entities; i++) {
|
|
ep = entities[i].epairs;
|
|
if (!ep)
|
|
continue; // ent got removed
|
|
|
|
strcat (end, "{\n");
|
|
end += 2;
|
|
|
|
for (ep = entities[i].epairs; ep; ep = ep->next) {
|
|
sprintf (line, "\"%s\" \"%s\"\n", ep->key, ep->value);
|
|
strcat (end, line);
|
|
end += strlen (line);
|
|
}
|
|
strcat (end, "}\n");
|
|
end += 2;
|
|
|
|
if (end > buf + MAX_MAP_ENTSTRING)
|
|
fprintf (stderr, "Entity text too long");
|
|
}
|
|
bsp->entdatasize = end - buf + 1;
|
|
}
|