-/*\r
-Copyright (C) 1999-2007 id Software, Inc. and contributors.\r
-For a list of contributors, see the accompanying CONTRIBUTORS file.\r
-\r
-This file is part of GtkRadiant.\r
-\r
-GtkRadiant is free software; you can redistribute it and/or modify\r
-it under the terms of the GNU General Public License as published by\r
-the Free Software Foundation; either version 2 of the License, or\r
-(at your option) any later version.\r
-\r
-GtkRadiant is distributed in the hope that it will be useful,\r
-but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
-GNU General Public License for more details.\r
-\r
-You should have received a copy of the GNU General Public License\r
-along with GtkRadiant; if not, write to the Free Software\r
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\r
-*/\r
-// map.c\r
-\r
-#include "qbsp.h"\r
-\r
-extern qboolean onlyents;\r
-\r
-int nummapbrushes;\r
-mapbrush_t mapbrushes[MAX_MAP_BRUSHES];\r
-\r
-int nummapbrushsides;\r
-side_t brushsides[MAX_MAP_SIDES];\r
-brush_texture_t side_brushtextures[MAX_MAP_SIDES];\r
-\r
-int nummapplanes;\r
-plane_t mapplanes[MAX_MAP_PLANES];\r
-\r
-#define PLANE_HASHES 1024\r
-plane_t *planehash[PLANE_HASHES];\r
-\r
-vec3_t map_mins, map_maxs;\r
-\r
-// undefine to make plane finding use linear sort\r
-#define USE_HASHING\r
-\r
-void TestExpandBrushes (void);\r
-\r
-int c_boxbevels;\r
-int c_edgebevels;\r
-\r
-int c_areaportals;\r
-\r
-int c_clipbrushes;\r
-\r
-/*\r
-=============================================================================\r
-\r
-PLANE FINDING\r
-\r
-=============================================================================\r
-*/\r
-\r
-\r
-/*\r
-=================\r
-PlaneTypeForNormal\r
-=================\r
-*/\r
-int PlaneTypeForNormal (vec3_t normal)\r
-{\r
- vec_t ax, ay, az;\r
- \r
-// NOTE: should these have an epsilon around 1.0? \r
- if (normal[0] == 1.0 || normal[0] == -1.0)\r
- return PLANE_X;\r
- if (normal[1] == 1.0 || normal[1] == -1.0)\r
- return PLANE_Y;\r
- if (normal[2] == 1.0 || normal[2] == -1.0)\r
- return PLANE_Z;\r
- \r
- ax = fabs(normal[0]);\r
- ay = fabs(normal[1]);\r
- az = fabs(normal[2]);\r
- \r
- if (ax >= ay && ax >= az)\r
- return PLANE_ANYX;\r
- if (ay >= ax && ay >= az)\r
- return PLANE_ANYY;\r
- return PLANE_ANYZ;\r
-}\r
-\r
-/*\r
-================\r
-PlaneEqual\r
-================\r
-*/\r
-#define NORMAL_EPSILON 0.00001\r
-#define DIST_EPSILON 0.01\r
-qboolean PlaneEqual (plane_t *p, vec3_t normal, vec_t dist)\r
-{\r
-#if 1\r
- if (\r
- fabs(p->normal[0] - normal[0]) < NORMAL_EPSILON\r
- && fabs(p->normal[1] - normal[1]) < NORMAL_EPSILON\r
- && fabs(p->normal[2] - normal[2]) < NORMAL_EPSILON\r
- && fabs(p->dist - dist) < DIST_EPSILON )\r
- return true;\r
-#else\r
- if (p->normal[0] == normal[0]\r
- && p->normal[1] == normal[1]\r
- && p->normal[2] == normal[2]\r
- && p->dist == dist)\r
- return true;\r
-#endif\r
- return false;\r
-}\r
-\r
-/*\r
-================\r
-AddPlaneToHash\r
-================\r
-*/\r
-void AddPlaneToHash (plane_t *p)\r
-{\r
- int hash;\r
-\r
- hash = (int)fabs(p->dist) / 8;\r
- hash &= (PLANE_HASHES-1);\r
-\r
- p->hash_chain = planehash[hash];\r
- planehash[hash] = p;\r
-}\r
-\r
-/*\r
-================\r
-CreateNewFloatPlane\r
-================\r
-*/\r
-int CreateNewFloatPlane (vec3_t normal, vec_t dist)\r
-{\r
- plane_t *p, temp;\r
-\r
- if (VectorLength(normal) < 0.5)\r
- Error ("FloatPlane: bad normal");\r
- // create a new plane\r
- if (nummapplanes+2 > MAX_MAP_PLANES)\r
- Error ("MAX_MAP_PLANES");\r
-\r
- p = &mapplanes[nummapplanes];\r
- VectorCopy (normal, p->normal);\r
- p->dist = dist;\r
- p->type = (p+1)->type = PlaneTypeForNormal (p->normal);\r
-\r
- VectorSubtract (vec3_origin, normal, (p+1)->normal);\r
- (p+1)->dist = -dist;\r
-\r
- nummapplanes += 2;\r
-\r
- // allways put axial planes facing positive first\r
- if (p->type < 3)\r
- {\r
- if (p->normal[0] < 0 || p->normal[1] < 0 || p->normal[2] < 0)\r
- {\r
- // flip order\r
- temp = *p;\r
- *p = *(p+1);\r
- *(p+1) = temp;\r
-\r
- AddPlaneToHash (p);\r
- AddPlaneToHash (p+1);\r
- return nummapplanes - 1;\r
- }\r
- }\r
-\r
- AddPlaneToHash (p);\r
- AddPlaneToHash (p+1);\r
- return nummapplanes - 2;\r
-}\r
-\r
-/*\r
-==============\r
-SnapVector\r
-==============\r
-*/\r
-void SnapVector (vec3_t normal)\r
-{\r
- int i;\r
-\r
- for (i=0 ; i<3 ; i++)\r
- {\r
- if ( fabs(normal[i] - 1) < NORMAL_EPSILON )\r
- {\r
- VectorClear (normal);\r
- normal[i] = 1;\r
- break;\r
- }\r
- if ( fabs(normal[i] - -1) < NORMAL_EPSILON )\r
- {\r
- VectorClear (normal);\r
- normal[i] = -1;\r
- break;\r
- }\r
- }\r
-}\r
-\r
-/*\r
-==============\r
-SnapPlane\r
-==============\r
-*/\r
-void SnapPlane (vec3_t normal, vec_t *dist)\r
-{\r
- SnapVector (normal);\r
-\r
- if (fabs(*dist-Q_rint(*dist)) < DIST_EPSILON)\r
- *dist = Q_rint(*dist);\r
-}\r
-\r
-/*\r
-=============\r
-FindFloatPlane\r
-\r
-=============\r
-*/\r
-#ifndef USE_HASHING\r
-int FindFloatPlane (vec3_t normal, vec_t dist)\r
-{\r
- int i;\r
- plane_t *p;\r
-\r
- SnapPlane (normal, &dist);\r
- for (i=0, p=mapplanes ; i<nummapplanes ; i++, p++)\r
- {\r
- if (PlaneEqual (p, normal, dist))\r
- return i;\r
- }\r
-\r
- return CreateNewFloatPlane (normal, dist);\r
-}\r
-#else\r
-int FindFloatPlane (vec3_t normal, vec_t dist)\r
-{\r
- int i;\r
- plane_t *p;\r
- int hash, h;\r
-\r
- SnapPlane (normal, &dist);\r
- hash = (int)fabs(dist) / 8;\r
- hash &= (PLANE_HASHES-1);\r
-\r
- // search the border bins as well\r
- for (i=-1 ; i<=1 ; i++)\r
- {\r
- h = (hash+i)&(PLANE_HASHES-1);\r
- for (p = planehash[h] ; p ; p=p->hash_chain)\r
- {\r
- if (PlaneEqual (p, normal, dist))\r
- return p-mapplanes;\r
- }\r
- }\r
-\r
- return CreateNewFloatPlane (normal, dist);\r
-}\r
-#endif\r
-\r
-/*\r
-================\r
-PlaneFromPoints\r
-================\r
-*/\r
-int PlaneFromPoints (int *p0, int *p1, int *p2)\r
-{\r
- vec3_t t1, t2, normal;\r
- vec_t dist;\r
-\r
- VectorSubtract (p0, p1, t1);\r
- VectorSubtract (p2, p1, t2);\r
- CrossProduct (t1, t2, normal);\r
- VectorNormalize (normal, normal);\r
-\r
- dist = DotProduct (p0, normal);\r
-\r
- return FindFloatPlane (normal, dist);\r
-}\r
-\r
-\r
-//====================================================================\r
-\r
-\r
-/*\r
-===========\r
-BrushContents\r
-===========\r
-*/\r
-int BrushContents (mapbrush_t *b)\r
-{\r
- int contents;\r
- side_t *s;\r
- int i;\r
- int trans;\r
-\r
- s = &b->original_sides[0];\r
- contents = s->contents;\r
- trans = texinfo[s->texinfo].flags;\r
- for (i=1 ; i<b->numsides ; i++, s++)\r
- {\r
- s = &b->original_sides[i];\r
- trans |= texinfo[s->texinfo].flags;\r
- if (s->contents != contents)\r
- {\r
- Sys_Printf ("Entity %i, Brush %i: mixed face contents\n"\r
- , b->entitynum, b->brushnum);\r
- break;\r
- }\r
- }\r
-\r
- // if any side is translucent, mark the contents\r
- // and change solid to window\r
- if ( trans & (SURF_TRANS33|SURF_TRANS66) )\r
- {\r
- contents |= CONTENTS_TRANSLUCENT;\r
- if (contents & CONTENTS_SOLID)\r
- {\r
- contents &= ~CONTENTS_SOLID;\r
- contents |= CONTENTS_WINDOW;\r
- }\r
- }\r
-\r
- return contents;\r
-}\r
-\r
-\r
-//============================================================================\r
-\r
-/*\r
-=================\r
-AddBrushBevels\r
-\r
-Adds any additional planes necessary to allow the brush to be expanded\r
-against axial bounding boxes\r
-=================\r
-*/\r
-void AddBrushBevels (mapbrush_t *b)\r
-{\r
- int axis, dir;\r
- int i, j, k, l, order;\r
- side_t sidetemp;\r
- brush_texture_t tdtemp;\r
- side_t *s, *s2;\r
- vec3_t normal;\r
- float dist;\r
- winding_t *w, *w2;\r
- vec3_t vec, vec2;\r
- float d;\r
-\r
- //\r
- // add the axial planes\r
- //\r
- order = 0;\r
- for (axis=0 ; axis <3 ; axis++)\r
- {\r
- for (dir=-1 ; dir <= 1 ; dir+=2, order++)\r
- {\r
- // see if the plane is allready present\r
- for (i=0, s=b->original_sides ; i<b->numsides ; i++,s++)\r
- {\r
- if (mapplanes[s->planenum].normal[axis] == dir)\r
- break;\r
- }\r
-\r
- if (i == b->numsides)\r
- { // add a new side\r
- if (nummapbrushsides == MAX_MAP_BRUSHSIDES)\r
- Error ("MAX_MAP_BRUSHSIDES");\r
- nummapbrushsides++;\r
- b->numsides++;\r
- VectorClear (normal);\r
- normal[axis] = dir;\r
- if (dir == 1)\r
- dist = b->maxs[axis];\r
- else\r
- dist = -b->mins[axis];\r
- s->planenum = FindFloatPlane (normal, dist);\r
- s->texinfo = b->original_sides[0].texinfo;\r
- s->contents = b->original_sides[0].contents;\r
- s->bevel = true;\r
- c_boxbevels++;\r
- }\r
-\r
- // if the plane is not in it canonical order, swap it\r
- if (i != order)\r
- {\r
- sidetemp = b->original_sides[order];\r
- b->original_sides[order] = b->original_sides[i];\r
- b->original_sides[i] = sidetemp;\r
-\r
- j = b->original_sides - brushsides;\r
- tdtemp = side_brushtextures[j+order];\r
- side_brushtextures[j+order] = side_brushtextures[j+i];\r
- side_brushtextures[j+i] = tdtemp;\r
- }\r
- }\r
- }\r
-\r
- //\r
- // add the edge bevels\r
- //\r
- if (b->numsides == 6)\r
- return; // pure axial\r
-\r
- // test the non-axial plane edges\r
- for (i=6 ; i<b->numsides ; i++)\r
- {\r
- s = b->original_sides + i;\r
- w = s->winding;\r
- if (!w)\r
- continue;\r
- for (j=0 ; j<w->numpoints ; j++)\r
- {\r
- k = (j+1)%w->numpoints;\r
- VectorSubtract (w->p[j], w->p[k], vec);\r
- if (VectorNormalize (vec, vec) < 0.5)\r
- continue;\r
- SnapVector (vec);\r
- for (k=0 ; k<3 ; k++)\r
- if ( vec[k] == -1 || vec[k] == 1)\r
- break; // axial\r
- if (k != 3)\r
- continue; // only test non-axial edges\r
-\r
- // try the six possible slanted axials from this edge\r
- for (axis=0 ; axis <3 ; axis++)\r
- {\r
- for (dir=-1 ; dir <= 1 ; dir+=2)\r
- {\r
- // construct a plane\r
- VectorClear (vec2);\r
- vec2[axis] = dir;\r
- CrossProduct (vec, vec2, normal);\r
- if (VectorNormalize (normal, normal) < 0.5)\r
- continue;\r
- dist = DotProduct (w->p[j], normal);\r
-\r
- // if all the points on all the sides are\r
- // behind this plane, it is a proper edge bevel\r
- for (k=0 ; k<b->numsides ; k++)\r
- {\r
- // if this plane has allready been used, skip it\r
- if (PlaneEqual (&mapplanes[b->original_sides[k].planenum]\r
- , normal, dist) )\r
- break;\r
-\r
- w2 = b->original_sides[k].winding;\r
- if (!w2)\r
- continue;\r
- for (l=0 ; l<w2->numpoints ; l++)\r
- {\r
- d = DotProduct (w2->p[l], normal) - dist;\r
- if (d > 0.1)\r
- break; // point in front\r
- }\r
- if (l != w2->numpoints)\r
- break;\r
- }\r
-\r
- if (k != b->numsides)\r
- continue; // wasn't part of the outer hull\r
- // add this plane\r
- if (nummapbrushsides == MAX_MAP_BRUSHSIDES)\r
- Error ("MAX_MAP_BRUSHSIDES");\r
- nummapbrushsides++;\r
- s2 = &b->original_sides[b->numsides];\r
- s2->planenum = FindFloatPlane (normal, dist);\r
- s2->texinfo = b->original_sides[0].texinfo;\r
- s2->contents = b->original_sides[0].contents;\r
- s2->bevel = true;\r
- c_edgebevels++;\r
- b->numsides++;\r
- }\r
- }\r
- }\r
- }\r
-}\r
-\r
-\r
-/*\r
-================\r
-MakeBrushWindings\r
-\r
-makes basewindigs for sides and mins / maxs for the brush\r
-================\r
-*/\r
-qboolean MakeBrushWindings (mapbrush_t *ob)\r
-{\r
- int i, j;\r
- winding_t *w;\r
- side_t *side;\r
- plane_t *plane;\r
-\r
- ClearBounds (ob->mins, ob->maxs);\r
-\r
- for (i=0 ; i<ob->numsides ; i++)\r
- {\r
- plane = &mapplanes[ob->original_sides[i].planenum];\r
- w = BaseWindingForPlane (plane->normal, plane->dist);\r
- for (j=0 ; j<ob->numsides && w; j++)\r
- {\r
- if (i == j)\r
- continue;\r
- if (ob->original_sides[j].bevel)\r
- continue;\r
- plane = &mapplanes[ob->original_sides[j].planenum^1];\r
- ChopWindingInPlace (&w, plane->normal, plane->dist, 0); //CLIP_EPSILON);\r
- }\r
-\r
- side = &ob->original_sides[i];\r
- side->winding = w;\r
- if (w)\r
- {\r
- side->visible = true;\r
- for (j=0 ; j<w->numpoints ; j++)\r
- AddPointToBounds (w->p[j], ob->mins, ob->maxs);\r
- }\r
- }\r
-\r
- for (i=0 ; i<3 ; i++)\r
- {\r
- if (ob->mins[0] < -4096 || ob->maxs[0] > 4096)\r
- Sys_Printf ("entity %i, brush %i: bounds out of range\n", ob->entitynum, ob->brushnum);\r
- if (ob->mins[0] > 4096 || ob->maxs[0] < -4096)\r
- Sys_Printf ("entity %i, brush %i: no visible sides on brush\n", ob->entitynum, ob->brushnum);\r
- }\r
-\r
- return true;\r
-}\r
-\r
-\r
-/*\r
-=================\r
-ParseBrush\r
-=================\r
-*/\r
-void ParseBrush (entity_t *mapent)\r
-{\r
- mapbrush_t *b;\r
- int i,j, k;\r
- int mt;\r
- side_t *side, *s2;\r
- int planenum;\r
- brush_texture_t td;\r
- int planepts[3][3];\r
-\r
- if (nummapbrushes == MAX_MAP_BRUSHES)\r
- Error ("nummapbrushes == MAX_MAP_BRUSHES");\r
-\r
- b = &mapbrushes[nummapbrushes];\r
- b->original_sides = &brushsides[nummapbrushsides];\r
- b->entitynum = num_entities-1;\r
- b->brushnum = nummapbrushes - mapent->firstbrush;\r
-\r
- do\r
- {\r
- if (!GetToken (true))\r
- break;\r
- if (!strcmp (token, "}") )\r
- break;\r
-\r
- if (nummapbrushsides == MAX_MAP_BRUSHSIDES)\r
- Error ("MAX_MAP_BRUSHSIDES");\r
- side = &brushsides[nummapbrushsides];\r
-\r
- // read the three point plane definition\r
- for (i=0 ; i<3 ; i++)\r
- {\r
- if (i != 0)\r
- GetToken (true);\r
- if (strcmp (token, "(") )\r
- Error ("parsing brush");\r
- \r
- for (j=0 ; j<3 ; j++)\r
- {\r
- GetToken (false);\r
- planepts[i][j] = atoi(token);\r
- }\r
- \r
- GetToken (false);\r
- if (strcmp (token, ")") )\r
- Error ("parsing brush");\r
- \r
- }\r
-\r
-\r
- //\r
- // read the texturedef\r
- //\r
- GetToken (false);\r
- strcpy (td.name, token);\r
-\r
- GetToken (false);\r
- td.shift[0] = atoi(token);\r
- GetToken (false);\r
- td.shift[1] = atoi(token);\r
- GetToken (false);\r
- td.rotate = atoi(token); \r
- GetToken (false);\r
- td.scale[0] = atof(token);\r
- GetToken (false);\r
- td.scale[1] = atof(token);\r
-\r
- // find default flags and values\r
- mt = FindMiptex (td.name);\r
- td.flags = textureref[mt].flags;\r
- td.value = textureref[mt].value;\r
- side->contents = textureref[mt].contents;\r
- side->surf = td.flags = textureref[mt].flags;\r
-\r
- if (TokenAvailable())\r
- {\r
- GetToken (false);\r
- side->contents = atoi(token);\r
- GetToken (false);\r
- side->surf = td.flags = atoi(token);\r
- GetToken (false);\r
- td.value = atoi(token);\r
- }\r
-\r
- // translucent objects are automatically classified as detail\r
- if (side->surf & (SURF_TRANS33|SURF_TRANS66) )\r
- side->contents |= CONTENTS_DETAIL;\r
- if (side->contents & (CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP) )\r
- side->contents |= CONTENTS_DETAIL;\r
- if (fulldetail)\r
- side->contents &= ~CONTENTS_DETAIL;\r
- if (!(side->contents & ((LAST_VISIBLE_CONTENTS-1) \r
- | CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_MIST) ) )\r
- side->contents |= CONTENTS_SOLID;\r
-\r
- // hints and skips are never detail, and have no content\r
- if (side->surf & (SURF_HINT|SURF_SKIP) )\r
- {\r
- side->contents = 0;\r
- side->surf &= ~CONTENTS_DETAIL;\r
- }\r
-\r
-\r
- //\r
- // find the plane number\r
- //\r
- planenum = PlaneFromPoints (planepts[0], planepts[1], planepts[2]);\r
- if (planenum == -1)\r
- {\r
- Sys_Printf ("Entity %i, Brush %i: plane with no normal\n"\r
- , b->entitynum, b->brushnum);\r
- continue;\r
- }\r
-\r
- //\r
- // see if the plane has been used already\r
- //\r
- for (k=0 ; k<b->numsides ; k++)\r
- {\r
- s2 = b->original_sides + k;\r
- if (s2->planenum == planenum)\r
- {\r
- Sys_Printf ("Entity %i, Brush %i: duplicate plane\n"\r
- , b->entitynum, b->brushnum);\r
- break;\r
- }\r
- if ( s2->planenum == (planenum^1) )\r
- {\r
- Sys_Printf ("Entity %i, Brush %i: mirrored plane\n"\r
- , b->entitynum, b->brushnum);\r
- break;\r
- }\r
- }\r
- if (k != b->numsides)\r
- continue; // duplicated\r
-\r
- //\r
- // keep this side\r
- //\r
-\r
- side = b->original_sides + b->numsides;\r
- side->planenum = planenum;\r
- side->texinfo = TexinfoForBrushTexture (&mapplanes[planenum],\r
- &td, vec3_origin);\r
-\r
- // save the td off in case there is an origin brush and we\r
- // have to recalculate the texinfo\r
- side_brushtextures[nummapbrushsides] = td;\r
-\r
- nummapbrushsides++;\r
- b->numsides++;\r
- } while (1);\r
-\r
- // get the content for the entire brush\r
- b->contents = BrushContents (b);\r
-\r
- // allow detail brushes to be removed \r
- if (nodetail && (b->contents & CONTENTS_DETAIL) )\r
- {\r
- b->numsides = 0;\r
- return;\r
- }\r
-\r
- // allow water brushes to be removed\r
- if (nowater && (b->contents & (CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_WATER)) )\r
- {\r
- b->numsides = 0;\r
- return;\r
- }\r
-\r
- // create windings for sides and bounds for brush\r
- MakeBrushWindings (b);\r
-\r
- // brushes that will not be visible at all will never be\r
- // used as bsp splitters\r
- if (b->contents & (CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP) )\r
- {\r
- c_clipbrushes++;\r
- for (i=0 ; i<b->numsides ; i++)\r
- b->original_sides[i].texinfo = TEXINFO_NODE;\r
- }\r
-\r
- //\r
- // origin brushes are removed, but they set\r
- // the rotation origin for the rest of the brushes\r
- // in the entity. After the entire entity is parsed,\r
- // the planenums and texinfos will be adjusted for\r
- // the origin brush\r
- //\r
- if (b->contents & CONTENTS_ORIGIN)\r
- {\r
- char string[32];\r
- vec3_t origin;\r
-\r
- if (num_entities == 1)\r
- {\r
- Error ("Entity %i, Brush %i: origin brushes not allowed in world"\r
- , b->entitynum, b->brushnum);\r
- return;\r
- }\r
-\r
- VectorAdd (b->mins, b->maxs, origin);\r
- VectorScale (origin, 0.5, origin);\r
-\r
- sprintf (string, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);\r
- SetKeyValue (&entities[b->entitynum], "origin", string);\r
-\r
- VectorCopy (origin, entities[b->entitynum].origin);\r
-\r
- // don't keep this brush\r
- b->numsides = 0;\r
-\r
- return;\r
- }\r
-\r
- AddBrushBevels (b);\r
-\r
- nummapbrushes++;\r
- mapent->numbrushes++; \r
-}\r
-\r
-/*\r
-================\r
-MoveBrushesToWorld\r
-\r
-Takes all of the brushes from the current entity and\r
-adds them to the world's brush list.\r
-\r
-Used by func_group and func_areaportal\r
-================\r
-*/\r
-void MoveBrushesToWorld (entity_t *mapent)\r
-{\r
- int newbrushes;\r
- int worldbrushes;\r
- mapbrush_t *temp;\r
- int i;\r
-\r
- // this is pretty gross, because the brushes are expected to be\r
- // in linear order for each entity\r
-\r
- newbrushes = mapent->numbrushes;\r
- worldbrushes = entities[0].numbrushes;\r
-\r
- temp = malloc(newbrushes*sizeof(mapbrush_t));\r
- memcpy (temp, mapbrushes + mapent->firstbrush, newbrushes*sizeof(mapbrush_t));\r
-\r
-#if 0 // let them keep their original brush numbers\r
- for (i=0 ; i<newbrushes ; i++)\r
- temp[i].entitynum = 0;\r
-#endif\r
-\r
- // make space to move the brushes (overlapped copy)\r
- memmove (mapbrushes + worldbrushes + newbrushes,\r
- mapbrushes + worldbrushes,\r
- sizeof(mapbrush_t) * (nummapbrushes - worldbrushes - newbrushes) );\r
-\r
- // copy the new brushes down\r
- memcpy (mapbrushes + worldbrushes, temp, sizeof(mapbrush_t) * newbrushes);\r
-\r
- // fix up indexes\r
- entities[0].numbrushes += newbrushes;\r
- for (i=1 ; i<num_entities ; i++)\r
- entities[i].firstbrush += newbrushes;\r
- free (temp);\r
-\r
- mapent->numbrushes = 0;\r
-}\r
-\r
-/*\r
-================\r
-ParseMapEntity\r
-================\r
-*/\r
-qboolean ParseMapEntity (void)\r
-{\r
- entity_t *mapent;\r
- epair_t *e;\r
- side_t *s;\r
- int i, j;\r
- int startbrush, startsides;\r
- vec_t newdist;\r
- mapbrush_t *b;\r
-\r
- if (!GetToken (true))\r
- return false;\r
-\r
- if (strcmp (token, "{") )\r
- Error ("ParseEntity: { not found");\r
- \r
- if (num_entities == MAX_MAP_ENTITIES)\r
- Error ("num_entities == MAX_MAP_ENTITIES");\r
-\r
- startbrush = nummapbrushes;\r
- startsides = nummapbrushsides;\r
-\r
- mapent = &entities[num_entities];\r
- num_entities++;\r
- memset (mapent, 0, sizeof(*mapent));\r
- mapent->firstbrush = nummapbrushes;\r
- mapent->numbrushes = 0;\r
-// mapent->portalareas[0] = -1;\r
-// mapent->portalareas[1] = -1;\r
-\r
- do\r
- {\r
- if (!GetToken (true))\r
- Error ("ParseEntity: EOF without closing brace");\r
- if (!strcmp (token, "}") )\r
- break;\r
- if (!strcmp (token, "{") )\r
- ParseBrush (mapent);\r
- else\r
- {\r
- e = ParseEpair ();\r
- e->next = mapent->epairs;\r
- mapent->epairs = e;\r
- }\r
- } while (1);\r
-\r
- GetVectorForKey (mapent, "origin", mapent->origin);\r
-\r
- //\r
- // if there was an origin brush, offset all of the planes and texinfo\r
- //\r
- if (mapent->origin[0] || mapent->origin[1] || mapent->origin[2])\r
- {\r
- for (i=0 ; i<mapent->numbrushes ; i++)\r
- {\r
- b = &mapbrushes[mapent->firstbrush + i];\r
- for (j=0 ; j<b->numsides ; j++)\r
- {\r
- s = &b->original_sides[j];\r
- newdist = mapplanes[s->planenum].dist -\r
- DotProduct (mapplanes[s->planenum].normal, mapent->origin);\r
- s->planenum = FindFloatPlane (mapplanes[s->planenum].normal, newdist);\r
- s->texinfo = TexinfoForBrushTexture (&mapplanes[s->planenum],\r
- &side_brushtextures[s-brushsides], mapent->origin);\r
- }\r
- MakeBrushWindings (b);\r
- }\r
- }\r
-\r
- // group entities are just for editor convenience\r
- // toss all brushes into the world entity\r
- if (!strcmp ("func_group", ValueForKey (mapent, "classname")))\r
- {\r
- MoveBrushesToWorld (mapent);\r
- mapent->numbrushes = 0;\r
- return true;\r
- }\r
-\r
- // areaportal entities move their brushes, but don't eliminate\r
- // the entity\r
- if (!strcmp ("func_areaportal", ValueForKey (mapent, "classname")))\r
- {\r
- char str[128];\r
-\r
- if (mapent->numbrushes != 1)\r
- Error ("Entity %i: func_areaportal can only be a single brush", num_entities-1);\r
-\r
- b = &mapbrushes[nummapbrushes-1];\r
- b->contents = CONTENTS_AREAPORTAL;\r
- c_areaportals++;\r
- mapent->areaportalnum = c_areaportals;\r
- // set the portal number as "style"\r
- sprintf (str, "%i", c_areaportals);\r
- SetKeyValue (mapent, "style", str);\r
- MoveBrushesToWorld (mapent);\r
- return true;\r
- }\r
-\r
- return true;\r
-}\r
-\r
-//===================================================================\r
-\r
-/*\r
-================\r
-LoadMapFile\r
-================\r
-*/\r
-void LoadMapFile (char *filename)\r
-{ \r
- int i;\r
-\r
- Sys_FPrintf( SYS_VRB, "--- LoadMapFile ---\n");\r
-\r
- LoadScriptFile (filename);\r
-\r
- nummapbrushsides = 0;\r
- num_entities = 0;\r
- \r
- while (ParseMapEntity ())\r
- {\r
- }\r
-\r
- ClearBounds (map_mins, map_maxs);\r
- for (i=0 ; i<entities[0].numbrushes ; i++)\r
- {\r
- if (mapbrushes[i].mins[0] > 4096)\r
- continue; // no valid points\r
- AddPointToBounds (mapbrushes[i].mins, map_mins, map_maxs);\r
- AddPointToBounds (mapbrushes[i].maxs, map_mins, map_maxs);\r
- }\r
-\r
- Sys_FPrintf( SYS_VRB, "%5i brushes\n", nummapbrushes);\r
- Sys_FPrintf( SYS_VRB, "%5i clipbrushes\n", c_clipbrushes);\r
- Sys_FPrintf( SYS_VRB, "%5i total sides\n", nummapbrushsides);\r
- Sys_FPrintf( SYS_VRB, "%5i boxbevels\n", c_boxbevels);\r
- Sys_FPrintf( SYS_VRB, "%5i edgebevels\n", c_edgebevels);\r
- Sys_FPrintf( SYS_VRB, "%5i entities\n", num_entities);\r
- Sys_FPrintf( SYS_VRB, "%5i planes\n", nummapplanes);\r
- Sys_FPrintf( SYS_VRB, "%5i areaportals\n", c_areaportals);\r
- Sys_FPrintf( SYS_VRB, "size: %5.0f,%5.0f,%5.0f to %5.0f,%5.0f,%5.0f\n", map_mins[0],map_mins[1],map_mins[2],\r
- map_maxs[0],map_maxs[1],map_maxs[2]);\r
-\r
-// TestExpandBrushes ();\r
-}\r
-\r
-\r
-//====================================================================\r
-\r
-\r
-/*\r
-================\r
-TestExpandBrushes\r
-\r
-Expands all the brush planes and saves a new map out\r
-================\r
-*/\r
-void TestExpandBrushes (void)\r
-{\r
- FILE *f;\r
- side_t *s;\r
- int i, j, bn;\r
- winding_t *w;\r
- char *name = "expanded.map";\r
- mapbrush_t *brush;\r
- vec_t dist;\r
-\r
- Sys_Printf ("writing %s\n", name);\r
- f = fopen (name, "wb");\r
- if (!f)\r
- Error ("Can't write %s\b", name);\r
-\r
- fprintf (f, "{\n\"classname\" \"worldspawn\"\n");\r
-\r
- for (bn=0 ; bn<nummapbrushes ; bn++)\r
- {\r
- brush = &mapbrushes[bn];\r
- fprintf (f, "{\n");\r
- for (i=0 ; i<brush->numsides ; i++)\r
- {\r
- s = brush->original_sides + i;\r
- dist = mapplanes[s->planenum].dist;\r
- for (j=0 ; j<3 ; j++)\r
- dist += fabs( 16 * mapplanes[s->planenum].normal[j] );\r
-\r
- w = BaseWindingForPlane (mapplanes[s->planenum].normal, dist);\r
-\r
- fprintf (f,"( %i %i %i ) ", (int)w->p[0][0], (int)w->p[0][1], (int)w->p[0][2]);\r
- fprintf (f,"( %i %i %i ) ", (int)w->p[1][0], (int)w->p[1][1], (int)w->p[1][2]);\r
- fprintf (f,"( %i %i %i ) ", (int)w->p[2][0], (int)w->p[2][1], (int)w->p[2][2]);\r
-\r
- fprintf (f, "%s 0 0 0 1 1\n", texinfo[s->texinfo].texture);\r
- FreeWinding (w);\r
- }\r
- fprintf (f, "}\n");\r
- }\r
- fprintf (f, "}\n");\r
-\r
- fclose (f);\r
-\r
- Error ("can't proceed after expanding brushes");\r
-}\r
+/*
+ Copyright (C) 1999-2007 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
+ */
+// map.c
+
+#include "qbsp.h"
+
+extern qboolean onlyents;
+
+int nummapbrushes;
+mapbrush_t mapbrushes[MAX_MAP_BRUSHES];
+
+int nummapbrushsides;
+side_t brushsides[MAX_MAP_SIDES];
+brush_texture_t side_brushtextures[MAX_MAP_SIDES];
+
+int nummapplanes;
+plane_t mapplanes[MAX_MAP_PLANES];
+
+#define PLANE_HASHES 1024
+plane_t *planehash[PLANE_HASHES];
+
+vec3_t map_mins, map_maxs;
+
+// undefine to make plane finding use linear sort
+#define USE_HASHING
+
+void TestExpandBrushes( void );
+
+int c_boxbevels;
+int c_edgebevels;
+
+int c_areaportals;
+
+int c_clipbrushes;
+
+/*
+ =============================================================================
+
+ PLANE FINDING
+
+ =============================================================================
+ */
+
+
+/*
+ =================
+ PlaneTypeForNormal
+ =================
+ */
+int PlaneTypeForNormal( vec3_t normal ){
+ vec_t ax, ay, az;
+
+// NOTE: should these have an epsilon around 1.0?
+ if ( normal[0] == 1.0 || normal[0] == -1.0 ) {
+ return PLANE_X;
+ }
+ if ( normal[1] == 1.0 || normal[1] == -1.0 ) {
+ return PLANE_Y;
+ }
+ if ( normal[2] == 1.0 || normal[2] == -1.0 ) {
+ return PLANE_Z;
+ }
+
+ ax = fabs( normal[0] );
+ ay = fabs( normal[1] );
+ az = fabs( normal[2] );
+
+ if ( ax >= ay && ax >= az ) {
+ return PLANE_ANYX;
+ }
+ if ( ay >= ax && ay >= az ) {
+ return PLANE_ANYY;
+ }
+ return PLANE_ANYZ;
+}
+
+/*
+ ================
+ PlaneEqual
+ ================
+ */
+#define NORMAL_EPSILON 0.00001
+#define DIST_EPSILON 0.01
+qboolean PlaneEqual( plane_t *p, vec3_t normal, vec_t dist ){
+#if 1
+ if (
+ fabs( p->normal[0] - normal[0] ) < NORMAL_EPSILON
+ && fabs( p->normal[1] - normal[1] ) < NORMAL_EPSILON
+ && fabs( p->normal[2] - normal[2] ) < NORMAL_EPSILON
+ && fabs( p->dist - dist ) < DIST_EPSILON ) {
+ return true;
+ }
+#else
+ if ( p->normal[0] == normal[0]
+ && p->normal[1] == normal[1]
+ && p->normal[2] == normal[2]
+ && p->dist == dist ) {
+ return true;
+ }
+#endif
+ return false;
+}
+
+/*
+ ================
+ AddPlaneToHash
+ ================
+ */
+void AddPlaneToHash( plane_t *p ){
+ int hash;
+
+ hash = (int)fabs( p->dist ) / 8;
+ hash &= ( PLANE_HASHES - 1 );
+
+ p->hash_chain = planehash[hash];
+ planehash[hash] = p;
+}
+
+/*
+ ================
+ CreateNewFloatPlane
+ ================
+ */
+int CreateNewFloatPlane( vec3_t normal, vec_t dist ){
+ plane_t *p, temp;
+
+ if ( VectorLength( normal ) < 0.5 ) {
+ Error( "FloatPlane: bad normal" );
+ }
+ // create a new plane
+ if ( nummapplanes + 2 > MAX_MAP_PLANES ) {
+ Error( "MAX_MAP_PLANES" );
+ }
+
+ p = &mapplanes[nummapplanes];
+ VectorCopy( normal, p->normal );
+ p->dist = dist;
+ p->type = ( p + 1 )->type = PlaneTypeForNormal( p->normal );
+
+ VectorSubtract( vec3_origin, normal, ( p + 1 )->normal );
+ ( p + 1 )->dist = -dist;
+
+ nummapplanes += 2;
+
+ // allways put axial planes facing positive first
+ if ( p->type < 3 ) {
+ if ( p->normal[0] < 0 || p->normal[1] < 0 || p->normal[2] < 0 ) {
+ // flip order
+ temp = *p;
+ *p = *( p + 1 );
+ *( p + 1 ) = temp;
+
+ AddPlaneToHash( p );
+ AddPlaneToHash( p + 1 );
+ return nummapplanes - 1;
+ }
+ }
+
+ AddPlaneToHash( p );
+ AddPlaneToHash( p + 1 );
+ return nummapplanes - 2;
+}
+
+/*
+ ==============
+ SnapVector
+ ==============
+ */
+void SnapVector( vec3_t normal ){
+ int i;
+
+ for ( i = 0 ; i < 3 ; i++ )
+ {
+ if ( fabs( normal[i] - 1 ) < NORMAL_EPSILON ) {
+ VectorClear( normal );
+ normal[i] = 1;
+ break;
+ }
+ if ( fabs( normal[i] - -1 ) < NORMAL_EPSILON ) {
+ VectorClear( normal );
+ normal[i] = -1;
+ break;
+ }
+ }
+}
+
+/*
+ ==============
+ SnapPlane
+ ==============
+ */
+void SnapPlane( vec3_t normal, vec_t *dist ){
+ SnapVector( normal );
+
+ if ( fabs( *dist - Q_rint( *dist ) ) < DIST_EPSILON ) {
+ *dist = Q_rint( *dist );
+ }
+}
+
+/*
+ =============
+ FindFloatPlane
+
+ =============
+ */
+#ifndef USE_HASHING
+int FindFloatPlane( vec3_t normal, vec_t dist ){
+ int i;
+ plane_t *p;
+
+ SnapPlane( normal, &dist );
+ for ( i = 0, p = mapplanes ; i < nummapplanes ; i++, p++ )
+ {
+ if ( PlaneEqual( p, normal, dist ) ) {
+ return i;
+ }
+ }
+
+ return CreateNewFloatPlane( normal, dist );
+}
+#else
+int FindFloatPlane( vec3_t normal, vec_t dist ){
+ int i;
+ plane_t *p;
+ int hash, h;
+
+ SnapPlane( normal, &dist );
+ hash = (int)fabs( dist ) / 8;
+ hash &= ( PLANE_HASHES - 1 );
+
+ // search the border bins as well
+ for ( i = -1 ; i <= 1 ; i++ )
+ {
+ h = ( hash + i ) & ( PLANE_HASHES - 1 );
+ for ( p = planehash[h] ; p ; p = p->hash_chain )
+ {
+ if ( PlaneEqual( p, normal, dist ) ) {
+ return p - mapplanes;
+ }
+ }
+ }
+
+ return CreateNewFloatPlane( normal, dist );
+}
+#endif
+
+/*
+ ================
+ PlaneFromPoints
+ ================
+ */
+int PlaneFromPoints( int *p0, int *p1, int *p2 ){
+ vec3_t t1, t2, normal;
+ vec_t dist;
+
+ VectorSubtract( p0, p1, t1 );
+ VectorSubtract( p2, p1, t2 );
+ CrossProduct( t1, t2, normal );
+ VectorNormalize( normal, normal );
+
+ dist = DotProduct( p0, normal );
+
+ return FindFloatPlane( normal, dist );
+}
+
+
+//====================================================================
+
+
+/*
+ ===========
+ BrushContents
+ ===========
+ */
+int BrushContents( mapbrush_t *b ){
+ int contents;
+ side_t *s;
+ int i;
+ int trans;
+
+ s = &b->original_sides[0];
+ contents = s->contents;
+ trans = texinfo[s->texinfo].flags;
+ for ( i = 1 ; i < b->numsides ; i++, s++ )
+ {
+ s = &b->original_sides[i];
+ trans |= texinfo[s->texinfo].flags;
+ if ( s->contents != contents ) {
+ Sys_Printf( "Entity %i, Brush %i: mixed face contents\n"
+ , b->entitynum, b->brushnum );
+ break;
+ }
+ }
+
+ // if any side is translucent, mark the contents
+ // and change solid to window
+ if ( trans & ( SURF_TRANS33 | SURF_TRANS66 ) ) {
+ contents |= CONTENTS_TRANSLUCENT;
+ if ( contents & CONTENTS_SOLID ) {
+ contents &= ~CONTENTS_SOLID;
+ contents |= CONTENTS_WINDOW;
+ }
+ }
+
+ return contents;
+}
+
+
+//============================================================================
+
+/*
+ =================
+ AddBrushBevels
+
+ Adds any additional planes necessary to allow the brush to be expanded
+ against axial bounding boxes
+ =================
+ */
+void AddBrushBevels( mapbrush_t *b ){
+ int axis, dir;
+ int i, j, k, l, order;
+ side_t sidetemp;
+ brush_texture_t tdtemp;
+ side_t *s, *s2;
+ vec3_t normal;
+ float dist;
+ winding_t *w, *w2;
+ vec3_t vec, vec2;
+ float d;
+
+ //
+ // add the axial planes
+ //
+ order = 0;
+ for ( axis = 0 ; axis < 3 ; axis++ )
+ {
+ for ( dir = -1 ; dir <= 1 ; dir += 2, order++ )
+ {
+ // see if the plane is allready present
+ for ( i = 0, s = b->original_sides ; i < b->numsides ; i++,s++ )
+ {
+ if ( mapplanes[s->planenum].normal[axis] == dir ) {
+ break;
+ }
+ }
+
+ if ( i == b->numsides ) { // add a new side
+ if ( nummapbrushsides == MAX_MAP_BRUSHSIDES ) {
+ Error( "MAX_MAP_BRUSHSIDES" );
+ }
+ nummapbrushsides++;
+ b->numsides++;
+ VectorClear( normal );
+ normal[axis] = dir;
+ if ( dir == 1 ) {
+ dist = b->maxs[axis];
+ }
+ else{
+ dist = -b->mins[axis];
+ }
+ s->planenum = FindFloatPlane( normal, dist );
+ s->texinfo = b->original_sides[0].texinfo;
+ s->contents = b->original_sides[0].contents;
+ s->bevel = true;
+ c_boxbevels++;
+ }
+
+ // if the plane is not in it canonical order, swap it
+ if ( i != order ) {
+ sidetemp = b->original_sides[order];
+ b->original_sides[order] = b->original_sides[i];
+ b->original_sides[i] = sidetemp;
+
+ j = b->original_sides - brushsides;
+ tdtemp = side_brushtextures[j + order];
+ side_brushtextures[j + order] = side_brushtextures[j + i];
+ side_brushtextures[j + i] = tdtemp;
+ }
+ }
+ }
+
+ //
+ // add the edge bevels
+ //
+ if ( b->numsides == 6 ) {
+ return; // pure axial
+
+ }
+ // test the non-axial plane edges
+ for ( i = 6 ; i < b->numsides ; i++ )
+ {
+ s = b->original_sides + i;
+ w = s->winding;
+ if ( !w ) {
+ continue;
+ }
+ for ( j = 0 ; j < w->numpoints ; j++ )
+ {
+ k = ( j + 1 ) % w->numpoints;
+ VectorSubtract( w->p[j], w->p[k], vec );
+ if ( VectorNormalize( vec, vec ) < 0.5 ) {
+ continue;
+ }
+ SnapVector( vec );
+ for ( k = 0 ; k < 3 ; k++ )
+ if ( vec[k] == -1 || vec[k] == 1 ) {
+ break;
+ } // axial
+ if ( k != 3 ) {
+ continue; // only test non-axial edges
+
+ }
+ // try the six possible slanted axials from this edge
+ for ( axis = 0 ; axis < 3 ; axis++ )
+ {
+ for ( dir = -1 ; dir <= 1 ; dir += 2 )
+ {
+ // construct a plane
+ VectorClear( vec2 );
+ vec2[axis] = dir;
+ CrossProduct( vec, vec2, normal );
+ if ( VectorNormalize( normal, normal ) < 0.5 ) {
+ continue;
+ }
+ dist = DotProduct( w->p[j], normal );
+
+ // if all the points on all the sides are
+ // behind this plane, it is a proper edge bevel
+ for ( k = 0 ; k < b->numsides ; k++ )
+ {
+ // if this plane has allready been used, skip it
+ if ( PlaneEqual( &mapplanes[b->original_sides[k].planenum]
+ , normal, dist ) ) {
+ break;
+ }
+
+ w2 = b->original_sides[k].winding;
+ if ( !w2 ) {
+ continue;
+ }
+ for ( l = 0 ; l < w2->numpoints ; l++ )
+ {
+ d = DotProduct( w2->p[l], normal ) - dist;
+ if ( d > 0.1 ) {
+ break; // point in front
+ }
+ }
+ if ( l != w2->numpoints ) {
+ break;
+ }
+ }
+
+ if ( k != b->numsides ) {
+ continue; // wasn't part of the outer hull
+ }
+ // add this plane
+ if ( nummapbrushsides == MAX_MAP_BRUSHSIDES ) {
+ Error( "MAX_MAP_BRUSHSIDES" );
+ }
+ nummapbrushsides++;
+ s2 = &b->original_sides[b->numsides];
+ s2->planenum = FindFloatPlane( normal, dist );
+ s2->texinfo = b->original_sides[0].texinfo;
+ s2->contents = b->original_sides[0].contents;
+ s2->bevel = true;
+ c_edgebevels++;
+ b->numsides++;
+ }
+ }
+ }
+ }
+}
+
+
+/*
+ ================
+ MakeBrushWindings
+
+ makes basewindigs for sides and mins / maxs for the brush
+ ================
+ */
+qboolean MakeBrushWindings( mapbrush_t *ob ){
+ int i, j;
+ winding_t *w;
+ side_t *side;
+ plane_t *plane;
+
+ ClearBounds( ob->mins, ob->maxs );
+
+ for ( i = 0 ; i < ob->numsides ; i++ )
+ {
+ plane = &mapplanes[ob->original_sides[i].planenum];
+ w = BaseWindingForPlane( plane->normal, plane->dist );
+ for ( j = 0 ; j < ob->numsides && w; j++ )
+ {
+ if ( i == j ) {
+ continue;
+ }
+ if ( ob->original_sides[j].bevel ) {
+ continue;
+ }
+ plane = &mapplanes[ob->original_sides[j].planenum ^ 1];
+ ChopWindingInPlace( &w, plane->normal, plane->dist, 0 ); //CLIP_EPSILON);
+ }
+
+ side = &ob->original_sides[i];
+ side->winding = w;
+ if ( w ) {
+ side->visible = true;
+ for ( j = 0 ; j < w->numpoints ; j++ )
+ AddPointToBounds( w->p[j], ob->mins, ob->maxs );
+ }
+ }
+
+ for ( i = 0 ; i < 3 ; i++ )
+ {
+ if ( ob->mins[0] < -4096 || ob->maxs[0] > 4096 ) {
+ Sys_Printf( "entity %i, brush %i: bounds out of range\n", ob->entitynum, ob->brushnum );
+ }
+ if ( ob->mins[0] > 4096 || ob->maxs[0] < -4096 ) {
+ Sys_Printf( "entity %i, brush %i: no visible sides on brush\n", ob->entitynum, ob->brushnum );
+ }
+ }
+
+ return true;
+}
+
+
+/*
+ =================
+ ParseBrush
+ =================
+ */
+void ParseBrush( entity_t *mapent ){
+ mapbrush_t *b;
+ int i,j, k;
+ int mt;
+ side_t *side, *s2;
+ int planenum;
+ brush_texture_t td;
+ int planepts[3][3];
+
+ if ( nummapbrushes == MAX_MAP_BRUSHES ) {
+ Error( "nummapbrushes == MAX_MAP_BRUSHES" );
+ }
+
+ b = &mapbrushes[nummapbrushes];
+ b->original_sides = &brushsides[nummapbrushsides];
+ b->entitynum = num_entities - 1;
+ b->brushnum = nummapbrushes - mapent->firstbrush;
+
+ do
+ {
+ if ( !GetToken( true ) ) {
+ break;
+ }
+ if ( !strcmp( token, "}" ) ) {
+ break;
+ }
+
+ if ( nummapbrushsides == MAX_MAP_BRUSHSIDES ) {
+ Error( "MAX_MAP_BRUSHSIDES" );
+ }
+ side = &brushsides[nummapbrushsides];
+
+ // read the three point plane definition
+ for ( i = 0 ; i < 3 ; i++ )
+ {
+ if ( i != 0 ) {
+ GetToken( true );
+ }
+ if ( strcmp( token, "(" ) ) {
+ Error( "parsing brush" );
+ }
+
+ for ( j = 0 ; j < 3 ; j++ )
+ {
+ GetToken( false );
+ planepts[i][j] = atoi( token );
+ }
+
+ GetToken( false );
+ if ( strcmp( token, ")" ) ) {
+ Error( "parsing brush" );
+ }
+
+ }
+
+
+ //
+ // read the texturedef
+ //
+ GetToken( false );
+ strcpy( td.name, token );
+
+ GetToken( false );
+ td.shift[0] = atoi( token );
+ GetToken( false );
+ td.shift[1] = atoi( token );
+ GetToken( false );
+ td.rotate = atoi( token );
+ GetToken( false );
+ td.scale[0] = atof( token );
+ GetToken( false );
+ td.scale[1] = atof( token );
+
+ // find default flags and values
+ mt = FindMiptex( td.name );
+ td.flags = textureref[mt].flags;
+ td.value = textureref[mt].value;
+ side->contents = textureref[mt].contents;
+ side->surf = td.flags = textureref[mt].flags;
+
+ if ( TokenAvailable() ) {
+ GetToken( false );
+ side->contents = atoi( token );
+ GetToken( false );
+ side->surf = td.flags = atoi( token );
+ GetToken( false );
+ td.value = atoi( token );
+ }
+
+ // translucent objects are automatically classified as detail
+ if ( side->surf & ( SURF_TRANS33 | SURF_TRANS66 ) ) {
+ side->contents |= CONTENTS_DETAIL;
+ }
+ if ( side->contents & ( CONTENTS_PLAYERCLIP | CONTENTS_MONSTERCLIP ) ) {
+ side->contents |= CONTENTS_DETAIL;
+ }
+ if ( fulldetail ) {
+ side->contents &= ~CONTENTS_DETAIL;
+ }
+ if ( !( side->contents & ( ( LAST_VISIBLE_CONTENTS - 1 )
+ | CONTENTS_PLAYERCLIP | CONTENTS_MONSTERCLIP | CONTENTS_MIST ) ) ) {
+ side->contents |= CONTENTS_SOLID;
+ }
+
+ // hints and skips are never detail, and have no content
+ if ( side->surf & ( SURF_HINT | SURF_SKIP ) ) {
+ side->contents = 0;
+ side->surf &= ~CONTENTS_DETAIL;
+ }
+
+
+ //
+ // find the plane number
+ //
+ planenum = PlaneFromPoints( planepts[0], planepts[1], planepts[2] );
+ if ( planenum == -1 ) {
+ Sys_Printf( "Entity %i, Brush %i: plane with no normal\n"
+ , b->entitynum, b->brushnum );
+ continue;
+ }
+
+ //
+ // see if the plane has been used already
+ //
+ for ( k = 0 ; k < b->numsides ; k++ )
+ {
+ s2 = b->original_sides + k;
+ if ( s2->planenum == planenum ) {
+ Sys_Printf( "Entity %i, Brush %i: duplicate plane\n"
+ , b->entitynum, b->brushnum );
+ break;
+ }
+ if ( s2->planenum == ( planenum ^ 1 ) ) {
+ Sys_Printf( "Entity %i, Brush %i: mirrored plane\n"
+ , b->entitynum, b->brushnum );
+ break;
+ }
+ }
+ if ( k != b->numsides ) {
+ continue; // duplicated
+
+ }
+ //
+ // keep this side
+ //
+
+ side = b->original_sides + b->numsides;
+ side->planenum = planenum;
+ side->texinfo = TexinfoForBrushTexture( &mapplanes[planenum],
+ &td, vec3_origin );
+
+ // save the td off in case there is an origin brush and we
+ // have to recalculate the texinfo
+ side_brushtextures[nummapbrushsides] = td;
+
+ nummapbrushsides++;
+ b->numsides++;
+ } while ( 1 );
+
+ // get the content for the entire brush
+ b->contents = BrushContents( b );
+
+ // allow detail brushes to be removed
+ if ( nodetail && ( b->contents & CONTENTS_DETAIL ) ) {
+ b->numsides = 0;
+ return;
+ }
+
+ // allow water brushes to be removed
+ if ( nowater && ( b->contents & ( CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_WATER ) ) ) {
+ b->numsides = 0;
+ return;
+ }
+
+ // create windings for sides and bounds for brush
+ MakeBrushWindings( b );
+
+ // brushes that will not be visible at all will never be
+ // used as bsp splitters
+ if ( b->contents & ( CONTENTS_PLAYERCLIP | CONTENTS_MONSTERCLIP ) ) {
+ c_clipbrushes++;
+ for ( i = 0 ; i < b->numsides ; i++ )
+ b->original_sides[i].texinfo = TEXINFO_NODE;
+ }
+
+ //
+ // origin brushes are removed, but they set
+ // the rotation origin for the rest of the brushes
+ // in the entity. After the entire entity is parsed,
+ // the planenums and texinfos will be adjusted for
+ // the origin brush
+ //
+ if ( b->contents & CONTENTS_ORIGIN ) {
+ char string[32];
+ vec3_t origin;
+
+ if ( num_entities == 1 ) {
+ Error( "Entity %i, Brush %i: origin brushes not allowed in world"
+ , b->entitynum, b->brushnum );
+ return;
+ }
+
+ VectorAdd( b->mins, b->maxs, origin );
+ VectorScale( origin, 0.5, origin );
+
+ sprintf( string, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2] );
+ SetKeyValue( &entities[b->entitynum], "origin", string );
+
+ VectorCopy( origin, entities[b->entitynum].origin );
+
+ // don't keep this brush
+ b->numsides = 0;
+
+ return;
+ }
+
+ AddBrushBevels( b );
+
+ nummapbrushes++;
+ mapent->numbrushes++;
+}
+
+/*
+ ================
+ MoveBrushesToWorld
+
+ Takes all of the brushes from the current entity and
+ adds them to the world's brush list.
+
+ Used by func_group and func_areaportal
+ ================
+ */
+void MoveBrushesToWorld( entity_t *mapent ){
+ int newbrushes;
+ int worldbrushes;
+ mapbrush_t *temp;
+ int i;
+
+ // this is pretty gross, because the brushes are expected to be
+ // in linear order for each entity
+
+ newbrushes = mapent->numbrushes;
+ worldbrushes = entities[0].numbrushes;
+
+ temp = malloc( newbrushes * sizeof( mapbrush_t ) );
+ memcpy( temp, mapbrushes + mapent->firstbrush, newbrushes * sizeof( mapbrush_t ) );
+
+#if 0 // let them keep their original brush numbers
+ for ( i = 0 ; i < newbrushes ; i++ )
+ temp[i].entitynum = 0;
+#endif
+
+ // make space to move the brushes (overlapped copy)
+ memmove( mapbrushes + worldbrushes + newbrushes,
+ mapbrushes + worldbrushes,
+ sizeof( mapbrush_t ) * ( nummapbrushes - worldbrushes - newbrushes ) );
+
+ // copy the new brushes down
+ memcpy( mapbrushes + worldbrushes, temp, sizeof( mapbrush_t ) * newbrushes );
+
+ // fix up indexes
+ entities[0].numbrushes += newbrushes;
+ for ( i = 1 ; i < num_entities ; i++ )
+ entities[i].firstbrush += newbrushes;
+ free( temp );
+
+ mapent->numbrushes = 0;
+}
+
+/*
+ ================
+ ParseMapEntity
+ ================
+ */
+qboolean ParseMapEntity( void ){
+ entity_t *mapent;
+ epair_t *e;
+ side_t *s;
+ int i, j;
+ int startbrush, startsides;
+ vec_t newdist;
+ mapbrush_t *b;
+
+ if ( !GetToken( true ) ) {
+ return false;
+ }
+
+ if ( strcmp( token, "{" ) ) {
+ Error( "ParseEntity: { not found" );
+ }
+
+ if ( num_entities == MAX_MAP_ENTITIES ) {
+ Error( "num_entities == MAX_MAP_ENTITIES" );
+ }
+
+ startbrush = nummapbrushes;
+ startsides = nummapbrushsides;
+
+ mapent = &entities[num_entities];
+ num_entities++;
+ memset( mapent, 0, sizeof( *mapent ) );
+ mapent->firstbrush = nummapbrushes;
+ mapent->numbrushes = 0;
+// mapent->portalareas[0] = -1;
+// mapent->portalareas[1] = -1;
+
+ do
+ {
+ if ( !GetToken( true ) ) {
+ Error( "ParseEntity: EOF without closing brace" );
+ }
+ if ( !strcmp( token, "}" ) ) {
+ break;
+ }
+ if ( !strcmp( token, "{" ) ) {
+ ParseBrush( mapent );
+ }
+ else
+ {
+ e = ParseEpair();
+ e->next = mapent->epairs;
+ mapent->epairs = e;
+ }
+ } while ( 1 );
+
+ GetVectorForKey( mapent, "origin", mapent->origin );
+
+ //
+ // if there was an origin brush, offset all of the planes and texinfo
+ //
+ if ( mapent->origin[0] || mapent->origin[1] || mapent->origin[2] ) {
+ for ( i = 0 ; i < mapent->numbrushes ; i++ )
+ {
+ b = &mapbrushes[mapent->firstbrush + i];
+ for ( j = 0 ; j < b->numsides ; j++ )
+ {
+ s = &b->original_sides[j];
+ newdist = mapplanes[s->planenum].dist -
+ DotProduct( mapplanes[s->planenum].normal, mapent->origin );
+ s->planenum = FindFloatPlane( mapplanes[s->planenum].normal, newdist );
+ s->texinfo = TexinfoForBrushTexture( &mapplanes[s->planenum],
+ &side_brushtextures[s - brushsides], mapent->origin );
+ }
+ MakeBrushWindings( b );
+ }
+ }
+
+ // group entities are just for editor convenience
+ // toss all brushes into the world entity
+ if ( !strcmp( "func_group", ValueForKey( mapent, "classname" ) ) ) {
+ MoveBrushesToWorld( mapent );
+ mapent->numbrushes = 0;
+ return true;
+ }
+
+ // areaportal entities move their brushes, but don't eliminate
+ // the entity
+ if ( !strcmp( "func_areaportal", ValueForKey( mapent, "classname" ) ) ) {
+ char str[128];
+
+ if ( mapent->numbrushes != 1 ) {
+ Error( "Entity %i: func_areaportal can only be a single brush", num_entities - 1 );
+ }
+
+ b = &mapbrushes[nummapbrushes - 1];
+ b->contents = CONTENTS_AREAPORTAL;
+ c_areaportals++;
+ mapent->areaportalnum = c_areaportals;
+ // set the portal number as "style"
+ sprintf( str, "%i", c_areaportals );
+ SetKeyValue( mapent, "style", str );
+ MoveBrushesToWorld( mapent );
+ return true;
+ }
+
+ return true;
+}
+
+//===================================================================
+
+/*
+ ================
+ LoadMapFile
+ ================
+ */
+void LoadMapFile( char *filename ){
+ int i;
+
+ Sys_FPrintf( SYS_VRB, "--- LoadMapFile ---\n" );
+
+ LoadScriptFile( filename );
+
+ nummapbrushsides = 0;
+ num_entities = 0;
+
+ while ( ParseMapEntity() )
+ {
+ }
+
+ ClearBounds( map_mins, map_maxs );
+ for ( i = 0 ; i < entities[0].numbrushes ; i++ )
+ {
+ if ( mapbrushes[i].mins[0] > 4096 ) {
+ continue; // no valid points
+ }
+ AddPointToBounds( mapbrushes[i].mins, map_mins, map_maxs );
+ AddPointToBounds( mapbrushes[i].maxs, map_mins, map_maxs );
+ }
+
+ Sys_FPrintf( SYS_VRB, "%5i brushes\n", nummapbrushes );
+ Sys_FPrintf( SYS_VRB, "%5i clipbrushes\n", c_clipbrushes );
+ Sys_FPrintf( SYS_VRB, "%5i total sides\n", nummapbrushsides );
+ Sys_FPrintf( SYS_VRB, "%5i boxbevels\n", c_boxbevels );
+ Sys_FPrintf( SYS_VRB, "%5i edgebevels\n", c_edgebevels );
+ Sys_FPrintf( SYS_VRB, "%5i entities\n", num_entities );
+ Sys_FPrintf( SYS_VRB, "%5i planes\n", nummapplanes );
+ Sys_FPrintf( SYS_VRB, "%5i areaportals\n", c_areaportals );
+ Sys_FPrintf( SYS_VRB, "size: %5.0f,%5.0f,%5.0f to %5.0f,%5.0f,%5.0f\n", map_mins[0],map_mins[1],map_mins[2],
+ map_maxs[0],map_maxs[1],map_maxs[2] );
+
+// TestExpandBrushes ();
+}
+
+
+//====================================================================
+
+
+/*
+ ================
+ TestExpandBrushes
+
+ Expands all the brush planes and saves a new map out
+ ================
+ */
+void TestExpandBrushes( void ){
+ FILE *f;
+ side_t *s;
+ int i, j, bn;
+ winding_t *w;
+ char *name = "expanded.map";
+ mapbrush_t *brush;
+ vec_t dist;
+
+ Sys_Printf( "writing %s\n", name );
+ f = fopen( name, "wb" );
+ if ( !f ) {
+ Error( "Can't write %s\b", name );
+ }
+
+ fprintf( f, "{\n\"classname\" \"worldspawn\"\n" );
+
+ for ( bn = 0 ; bn < nummapbrushes ; bn++ )
+ {
+ brush = &mapbrushes[bn];
+ fprintf( f, "{\n" );
+ for ( i = 0 ; i < brush->numsides ; i++ )
+ {
+ s = brush->original_sides + i;
+ dist = mapplanes[s->planenum].dist;
+ for ( j = 0 ; j < 3 ; j++ )
+ dist += fabs( 16 * mapplanes[s->planenum].normal[j] );
+
+ w = BaseWindingForPlane( mapplanes[s->planenum].normal, dist );
+
+ fprintf( f,"( %i %i %i ) ", (int)w->p[0][0], (int)w->p[0][1], (int)w->p[0][2] );
+ fprintf( f,"( %i %i %i ) ", (int)w->p[1][0], (int)w->p[1][1], (int)w->p[1][2] );
+ fprintf( f,"( %i %i %i ) ", (int)w->p[2][0], (int)w->p[2][1], (int)w->p[2][2] );
+
+ fprintf( f, "%s 0 0 0 1 1\n", texinfo[s->texinfo].texture );
+ FreeWinding( w );
+ }
+ fprintf( f, "}\n" );
+ }
+ fprintf( f, "}\n" );
+
+ fclose( f );
+
+ Error( "can't proceed after expanding brushes" );
+}
projects / xonotic / netradiant.git / blobdiff