map.c File Reference

#include "qbsp.h"

Include dependency graph for map.c:

Go to the source code of this file.

Defines
#define	DIST_EPSILON   0.01
#define	NORMAL_EPSILON   0.00001
#define	PLANE_HASHES   1024
#define	USE_HASHING
Functions
void	AddBackSides (void)
void	AddBrushBevels (void)
void	AddPlaneToHash (plane_t *p)
void	AdjustBrushesForOrigin (entity_t *ent)
int	CreateNewFloatPlane (vec3_t normal, vec_t dist)
int	FindFloatPlane (vec3_t normal, vec_t dist)
bspbrush_t *	FinishBrush (void)
void	LoadMapFile (char *filename)
int	MapPlaneFromPoints (vec3_t p0, vec3_t p1, vec3_t p2)
void	MoveBrushesToWorld (entity_t *mapent)
void	ParseBrush (void)
qboolean	ParseMapEntity (void)
void	ParseRawBrush ()
void	ParseTerrain (void)
qboolean	PlaneEqual (plane_t *p, vec3_t normal, vec_t dist)
void	QuakeTextureVecs (plane_t *plane, vec_t shift[2], vec_t rotate, vec_t scale[2], vec_t mappingVecs[2][4])
qboolean	RemoveDuplicateBrushPlanes (bspbrush_t *b)
void	SetBrushContents (bspbrush_t *b)
void	SetTerrainTextures (void)
void	SnapPlane (vec3_t normal, vec_t *dist)
void	SnapVector (vec3_t normal)
void	TestExpandBrushes (void)
void	TextureAxisFromPlane (plane_t *pln, vec3_t xv, vec3_t yv)
Variables
vec3_t	baseaxis [18]
bspbrush_t *	buildBrush
int	c_areaportals
int	c_boxbevels
int	c_detail
int	c_edgebevels
int	c_structural
int	entitySourceBrushes
vec3_t	map_maxs
vec3_t	map_mins
entity_t *	mapent
char	mapIndexedShaders [MAX_MAP_BRUSHSIDES][MAX_QPATH]
plane_t	mapplanes [MAX_MAP_PLANES]
int	numMapIndexedShaders
int	numMapPatches
int	nummapplanes
plane_t *	planehash [PLANE_HASHES]

---

Define Documentation

#define DIST_EPSILON   0.01

Definition at line 84 of file map.c.

#define NORMAL_EPSILON   0.00001

Definition at line 83 of file map.c.

#define PLANE_HASHES   1024

Definition at line 33 of file map.c.

#define USE_HASHING

Definition at line 32 of file map.c.

---

Function Documentation

void AddBackSides (  void   )

Definition at line 518 of file map.c. Referenced by FinishBrush(). { /* bspbrush_t *b; int i, originalSides; side_t *s; side_t *newSide; b = buildBrush; originalSides = b->numsides; for ( i = 0 ; i < originalSides ; i++ ) { s = &b->sides[i]; if ( !s->shaderInfo ) { continue; } if ( !(s->shaderInfo->contents & CONTENTS_FOG) ) { continue; } // duplicate the up-facing side if ( mapplanes[ s->planenum ].normal[2] == 1 ) { newSide = &b->sides[ b->numsides ]; b->numsides++; *newSide = *s; newSide->backSide = qtrue; newSide->planenum = s->planenum ^ 1; // opposite side } } */ }

void AddBrushBevels (  void   )

Definition at line 370 of file map.c. References side_s::bevel, buildBrush, c_boxbevels, c_edgebevels, side_s::contents, bspbrush_s::contents, CrossProduct(), d, DotProduct, Error(), FindFloatPlane(), i, j, k, l, mapplanes, bspbrush_s::maxs, memset(), bspbrush_s::mins, plane_t::normal, winding_t::numpoints, bspbrush_s::numsides, order, winding_t::p, PlaneEqual(), side_s::planenum, s, side_t, bspbrush_s::sides, SnapVector, vec3_t, VectorClear, VectorNormalize(), VectorSubtract, w, and side_s::winding. Referenced by AAS_CreateCurveBrushes(), AAS_CreateMapBrushes(), AAS_PositionFuncRotatingBrush(), FinishBrush(), HL_BSPBrushToMapBrush(), Q1_BSPBrushToMapBrush(), and Q2_ParseBrush(). { int axis, dir; int i, order; side_t sidetemp; side_t *s; vec3_t normal; float dist; // // 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=buildBrush->sides ; i < buildBrush->numsides ; i++,s++ ) { if (mapplanes[s->planenum].normal[axis] == dir) break; } if (i == buildBrush->numsides ) { // add a new side if ( buildBrush->numsides == MAX_BUILD_SIDES ) { Error( "MAX_BUILD_SIDES" ); } memset( s, 0, sizeof( *s ) ); buildBrush->numsides++; VectorClear (normal); normal[axis] = dir; if (dir == 1) dist = buildBrush->maxs[axis]; else dist = -buildBrush->mins[axis]; s->planenum = FindFloatPlane (normal, dist); s->contents = buildBrush->sides[0].contents; s->bevel = qtrue; c_boxbevels++; } // if the plane is not in it canonical order, swap it if (i != order) { sidetemp = buildBrush->sides[order]; buildBrush->sides[order] = buildBrush->sides[i]; buildBrush->sides[i] = sidetemp; } } } // // add the edge bevels // if ( buildBrush->numsides == 6 ) { return; // pure axial } else { int j, k, l; float d; winding_t *w, *w2; side_t *s2; vec3_t vec, vec2; // test the non-axial plane edges // this code tends to cause some problems... for (i=6 ; i<buildBrush->numsides ; i++) { s = buildBrush->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 < buildBrush->numsides ; k++) { // if this plane has allready been used, skip it if (PlaneEqual (&mapplanes[buildBrush->sides[k].planenum] , normal, dist) ) break; w2 = buildBrush->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 != buildBrush->numsides) continue; // wasn't part of the outer hull // add this plane if ( buildBrush->numsides == MAX_BUILD_SIDES ) { Error( "MAX_BUILD_SIDES" ); } s2 = &buildBrush->sides[buildBrush->numsides]; buildBrush->numsides++; memset( s2, 0, sizeof( *s2 ) ); s2->planenum = FindFloatPlane (normal, dist); s2->contents = buildBrush->sides[0].contents; s2->bevel = qtrue; c_edgebevels++; } } } } } }

Here is the call graph for this function:

void AddPlaneToHash (  plane_t *  p  )

Definition at line 109 of file map.c. References plane_t::dist, fabs(), p, PLANE_HASHES, and planehash. Referenced by CreateNewFloatPlane(). { int hash; hash = (int)fabs(p->dist) / 8; hash &= (PLANE_HASHES-1); p->hash_chain = planehash[hash]; planehash[hash] = p; }

Here is the call graph for this function:

void AdjustBrushesForOrigin (  entity_t *  ent  )

Definition at line 1027 of file map.c. References b, entity_t::brushes, bspbrush_t, CreateBrushWindings(), plane_t::dist, DotProduct, FindFloatPlane(), mesh_t::height, i, mapplanes, parseMesh_s::mesh, parseMesh_s::next, bspbrush_s::next, bspbrush_s::numsides, entity_t::origin, p, parseMesh_t, entity_t::patches, side_s::planenum, s, side_t, bspbrush_s::sides, vec_t, VectorSubtract, mesh_t::verts, mesh_t::width, and drawVert_t::xyz. Referenced by ParseMapEntity(). { bspbrush_t *b; int i; side_t *s; vec_t newdist; parseMesh_t *p; for ( b = ent->brushes ; b ; b = b->next ) { for (i=0 ; i<b->numsides ; i++) { s = &b->sides[i]; newdist = mapplanes[s->planenum].dist - DotProduct (mapplanes[s->planenum].normal, ent->origin); s->planenum = FindFloatPlane (mapplanes[s->planenum].normal, newdist); } CreateBrushWindings(b); } for ( p = ent->patches ; p ; p = p->next ) { for ( i = 0 ; i < p->mesh.width*p->mesh.height ; i++ ) { VectorSubtract( p->mesh.verts[i].xyz, ent->origin, p->mesh.verts[i].xyz ); } } }

Here is the call graph for this function:

int CreateNewFloatPlane (  vec3_t  normal, vec_t  dist )

Definition at line 125 of file map.c. References _printf(), AddPlaneToHash(), plane_t::dist, Error(), mapplanes, plane_t::normal, nummapplanes, p, PlaneTypeForNormal, plane_t::type, vec3_origin, VectorCopy, VectorLength(), and VectorSubtract. Referenced by FindFloatPlane(). { plane_t *p, temp; if (VectorLength(normal) < 0.5) { _printf( "FloatPlane: bad normal\n"); return -1; } // 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; }

Here is the call graph for this function:

int FindFloatPlane (  vec3_t  normal, vec_t  dist )

Definition at line 231 of file map.c. References CreateNewFloatPlane(), fabs(), h(), i, mapplaneusers, p, PLANE_HASHES, PlaneEqual(), planehash, and SnapPlane(). Referenced by AAS_CreateCurveBrushes(), AAS_ExpandMapBrush(), AAS_FixMapBrush(), AAS_LadderSubdivideArea_r(), AAS_PositionBrush(), AAS_SubdivideArea_r(), AAS_TestSplitPlane(), AAS_TransformPlane(), AddBrushBevels(), AdjustBrushesForOrigin(), BrushFromBounds(), DPlanes2MapPlanes(), EmitBrushes(), EmitTerrainVerts(), EmitTerrainVerts2(), HL_CreateBrushes_r(), HL_SplitBrushWithFace(), MakeBspBrushList(), MapPlaneFromPoints(), PlaneFromPoints(), Q1_CreateBrushes_r(), Q1_SplitBrushWithFace(), Q2_BSPBrushToMapBrush(), Q2_ParseMapEntity(), Q3_BSPBrushToMapBrush(), Q3_DPlanes2MapPlanes(), SelectSplitPlaneNum(), Sin_BSPBrushToMapBrush(), and WriteMapBrush(). { 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); }

Here is the call graph for this function:

bspbrush_t* FinishBrush (  void   )

Definition at line 557 of file map.c. References _printf(), AddBackSides(), AddBrushBevels(), b, entity_t::brushes, bspbrush_s::brushnum, bspbrush_t, buildBrush, c_detail, bspbrush_s::contents, CONTENTS_PLAYERCLIP, CopyBrush(), CreateBrushWindings(), bspbrush_s::detail, entities, bspbrush_s::entitynum, entitySourceBrushes, mapent, bspbrush_s::maxs, bspbrush_s::mins, bspbrush_s::next, num_entities, bspbrush_s::original, SetKeyValue(), sprintf(), string(), vec3_t, VectorAdd, VectorCopy, and VectorScale. Referenced by MakeBrushFromTriangle(), and ParseBrush(). { bspbrush_t *b; // liquids may need to have extra sides created for back sides AddBackSides(); // create windings for sides and bounds for brush if ( !CreateBrushWindings( buildBrush ) ) { // don't keep this brush return NULL; } // brushes that will not be visible at all are forced to be detail if ( buildBrush->contents & (CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP) ) { buildBrush->detail = qtrue; c_detail++; } // // 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 ( buildBrush->contents & CONTENTS_ORIGIN ) { char string[32]; vec3_t origin; if (num_entities == 1) { _printf ("Entity %i, Brush %i: origin brushes not allowed in world\n" , num_entities - 1, entitySourceBrushes); return NULL; } VectorAdd (buildBrush->mins, buildBrush->maxs, origin); VectorScale (origin, 0.5, origin); sprintf (string, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]); SetKeyValue (&entities[num_entities - 1], "origin", string); VectorCopy (origin, entities[num_entities - 1].origin); // don't keep this brush return NULL; } if ( buildBrush->contents & CONTENTS_AREAPORTAL ) { if (num_entities != 1) { _printf ("Entity %i, Brush %i: areaportals only allowed in world\n" , num_entities - 1, entitySourceBrushes); return NULL; } } AddBrushBevels (); // keep it b = CopyBrush( buildBrush ); b->entitynum = num_entities-1; b->brushnum = entitySourceBrushes; b->original = b; b->next = mapent->brushes; mapent->brushes = b; return b; }

Here is the call graph for this function:

void LoadMapFile (  char *  filename  )

Definition at line 1161 of file map.c. References _printf(), AddPointToBounds(), AllocBrush(), b, entity_t::brushes, bspbrush_t, buildBrush, c_areaportals, c_boxbevels, c_detail, c_edgebevels, ClearBounds(), CountBrushList(), entities, g_bBrushPrimit, LoadScriptFile(), map_maxs, map_mins, MAX_BUILD_SIDES, bspbrush_s::maxs, bspbrush_s::mins, bspbrush_s::next, num_entities, numMapDrawSurfs, numMapPatches, nummapplanes, ParseMapEntity(), qprintf(), TestExpandBrushes(), and WriteBspBrushMap(). Referenced by main(), OnlyEnts(), and OnlyTextures(). { bspbrush_t *b; qprintf ("--- LoadMapFile ---\n"); _printf ("Loading map file %s\n", filename); LoadScriptFile (filename); num_entities = 0; numMapDrawSurfs = 0; c_detail = 0; g_bBrushPrimit = BPRIMIT_UNDEFINED; // allocate a very large temporary brush for building // the brushes as they are loaded buildBrush = AllocBrush( MAX_BUILD_SIDES ); while (ParseMapEntity ()) { } ClearBounds (map_mins, map_maxs); for ( b = entities[0].brushes ; b ; b=b->next ) { AddPointToBounds( b->mins, map_mins, map_maxs ); AddPointToBounds( b->maxs, map_mins, map_maxs ); } qprintf ("%5i total world brushes\n", CountBrushList( entities[0].brushes ) ); qprintf ("%5i detail brushes\n", c_detail ); qprintf ("%5i patches\n", numMapPatches); qprintf ("%5i boxbevels\n", c_boxbevels); qprintf ("%5i edgebevels\n", c_edgebevels); qprintf ("%5i entities\n", num_entities); qprintf ("%5i planes\n", nummapplanes); qprintf ("%5i areaportals\n", c_areaportals); qprintf ("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]); if ( fakemap ) { WriteBspBrushMap ("fakemap.map", entities[0].brushes ); } if ( testExpand ) { TestExpandBrushes (); } }

Here is the call graph for this function:

int MapPlaneFromPoints (  vec3_t  p0, vec3_t  p1, vec3_t  p2 )

Definition at line 261 of file map.c. References CrossProduct(), DotProduct, FindFloatPlane(), p2, vec3_t, vec_t, VectorNormalize(), and VectorSubtract. Referenced by AddBrushSide(), and ParseRawBrush(). { 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); }

Here is the call graph for this function:

void MoveBrushesToWorld (  entity_t *  mapent  )

Definition at line 995 of file map.c. References b, entity_t::brushes, bspbrush_t, entities, mapent, bspbrush_s::next, next, parseMesh_t, entity_t::patches, and pm. Referenced by ParseMapEntity(). { bspbrush_t *b, *next; parseMesh_t *pm; // move brushes for ( b = mapent->brushes ; b ; b = next ) { next = b->next; b->next = entities[0].brushes; entities[0].brushes = b; } mapent->brushes = NULL; // move patches if ( mapent->patches ) { for ( pm = mapent->patches ; pm->next ; pm = pm->next ) { } pm->next = entities[0].patches; entities[0].patches = mapent->patches; mapent->patches = NULL; } }

void ParseBrush (  void   )

Definition at line 948 of file map.c. References b, bspbrush_s::brushnum, bspbrush_t, buildBrush, bspbrush_s::contents, CONTENTS_LAVA, CONTENTS_SLIME, bspbrush_s::entitynum, FinishBrush(), FreeBrush(), nodetail, nowater, num_entities, ParseRawBrush(), bspbrush_s::portalareas, RemoveDuplicateBrushPlanes(), and SetBrushContents(). Referenced by ParseMapEntity(). { bspbrush_t *b; ParseRawBrush(); buildBrush->portalareas[0] = -1; buildBrush->portalareas[1] = -1; buildBrush->entitynum = num_entities-1; buildBrush->brushnum = entitySourceBrushes; // if there are mirrored planes, the entire brush is invalid if ( !RemoveDuplicateBrushPlanes( buildBrush ) ) { return; } // get the content for the entire brush SetBrushContents( buildBrush ); // allow detail brushes to be removed if (nodetail && (buildBrush->contents & CONTENTS_DETAIL) ) { FreeBrush( buildBrush ); return; } // allow water brushes to be removed if (nowater && (buildBrush->contents & (CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_WATER)) ) { FreeBrush( buildBrush ); return; } b = FinishBrush( ); if ( !b ) { return; } }

Here is the call graph for this function:

qboolean ParseMapEntity (  void   )

Definition at line 1057 of file map.c. References AdjustBrushesForOrigin(), e, entities, entitySourceBrushes, epair_t, entity_t::epairs, Error(), g_bBrushPrimit, GetToken(), GetVectorForKey(), mapent, memset(), MoveBrushesToWorld(), epair_s::next, num_entities, numMapPatches, entity_t::origin, ParseBrush(), ParseEpair(), ParsePatch(), ParseTerrain(), qboolean, qtrue, scriptline, SetTerrainTextures(), strcmp(), UnGetToken(), and ValueForKey(). Referenced by LoadMapFile(). { epair_t *e; if (!GetToken (qtrue)) return qfalse; if (strcmp (token, "{") ) { Error ("ParseEntity: { not found, found %s on line %d - last entity was at: <%4.2f, %4.2f, %4.2f>...", token, scriptline, entities[num_entities].origin[0], entities[num_entities].origin[1], entities[num_entities].origin[2]); } if (num_entities == MAX_MAP_ENTITIES) Error ("num_entities == MAX_MAP_ENTITIES"); entitySourceBrushes = 0; mapent = &entities[num_entities]; num_entities++; memset (mapent, 0, sizeof(*mapent)); do { if (!GetToken (qtrue)) Error ("ParseEntity: EOF without closing brace"); if (!strcmp (token, "}") ) break; if (!strcmp (token, "{") ) { // parse a brush or patch if (!GetToken (qtrue)) break; if ( !strcmp( token, "patchDef2" ) ) { numMapPatches++; ParsePatch(); } else if ( !strcmp( token, "terrainDef" ) ) { ParseTerrain(); } else if ( !strcmp( token, "brushDef" ) ) { if (g_bBrushPrimit==BPRIMIT_OLDBRUSHES) Error("old brush format not allowed in new brush format map"); g_bBrushPrimit=BPRIMIT_NEWBRUSHES; // parse brush primitive ParseBrush(); } else { if (g_bBrushPrimit==BPRIMIT_NEWBRUSHES) Error("new brush format not allowed in old brush format map"); g_bBrushPrimit=BPRIMIT_OLDBRUSHES; // parse old brush format UnGetToken(); ParseBrush(); } entitySourceBrushes++; } else { // parse a key / value pair 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 // for all the brushes in the entity if (mapent->origin[0] || mapent->origin[1] || mapent->origin[2]) { AdjustBrushesForOrigin( mapent ); } // group_info entities are just for editor grouping // ignored // FIXME: leak! if (!strcmp("group_info", ValueForKey (mapent, "classname"))) { num_entities--; return qtrue; } // group entities are just for editor convenience // toss all brushes into the world entity if (!strcmp ("func_group", ValueForKey (mapent, "classname"))) { if ( !strcmp ("1", ValueForKey (mapent, "terrain"))) { SetTerrainTextures(); } MoveBrushesToWorld (mapent); num_entities--; return qtrue; } return qtrue; }

Here is the call graph for this function:

void ParseRawBrush (   )

Definition at line 759 of file map.c. References atof(), atoi, buildBrush, shaderInfo_s::contents, bspbrush_s::detail, Error(), g_bBrushPrimit, GetToken(), mapIndexedShaders, MapPlaneFromPoints(), mapplanes, MatchToken(), memset(), name, numMapIndexedShaders, bspbrush_s::numsides, Parse1DMatrix(), Parse2DMatrix(), qfalse, qtrue, QuakeTextureVecs(), shaderInfo_t, ShaderInfoForShader(), shift, side_t, bspbrush_s::sides, sprintf(), strcmp(), strcpy(), shaderInfo_s::surfaceFlags, TokenAvailable(), UnGetToken(), shaderInfo_s::value, vec3_t, and vec_t. Referenced by ParseBrush(). { side_t *side; vec3_t planepts[3]; int planenum; shaderInfo_t *si; // old brushes vec_t shift[2]; vec_t rotate; vec_t scale[2]; char name[MAX_QPATH]; char shader[MAX_QPATH]; int flags; buildBrush->numsides = 0; buildBrush->detail = qfalse; if (g_bBrushPrimit==BPRIMIT_NEWBRUSHES) MatchToken( "{" ); do { if (!GetToken (qtrue)) break; if (!strcmp (token, "}") ) break; //Timo : brush primitive : here we may have to jump over brush epairs ( only used in editor ) if (g_bBrushPrimit==BPRIMIT_NEWBRUSHES) { do { if (strcmp (token, "(") ) GetToken( qfalse ); else break; GetToken( qtrue ); } while (1); } UnGetToken(); if ( buildBrush->numsides == MAX_BUILD_SIDES ) { Error( "MAX_BUILD_SIDES" ); } side = &buildBrush->sides[ buildBrush->numsides ]; memset( side, 0, sizeof( *side ) ); buildBrush->numsides++; // read the three point plane definition Parse1DMatrix( 3, planepts[0] ); Parse1DMatrix( 3, planepts[1] ); Parse1DMatrix( 3, planepts[2] ); if (g_bBrushPrimit==BPRIMIT_NEWBRUSHES) // read the texture matrix Parse2DMatrix( 2, 3, (float *)side->texMat ); // read the texturedef GetToken (qfalse); strcpy (name, token); // save the shader name for retexturing if ( numMapIndexedShaders == MAX_MAP_BRUSHSIDES ) { Error( "MAX_MAP_BRUSHSIDES" ); } strcpy( mapIndexedShaders[numMapIndexedShaders], name ); numMapIndexedShaders++; if (g_bBrushPrimit==BPRIMIT_OLDBRUSHES) { GetToken (qfalse); shift[0] = atoi(token); GetToken (qfalse); shift[1] = atoi(token); GetToken (qfalse); rotate = atoi(token); GetToken (qfalse); scale[0] = atof(token); GetToken (qfalse); scale[1] = atof(token); } // find default flags and values sprintf( shader, "textures/%s", name ); si = ShaderInfoForShader( shader ); side->shaderInfo = si; side->surfaceFlags = si->surfaceFlags; side->value = si->value; side->contents = si->contents; // allow override of default flags and values // in Q3, the only thing you can override is DETAIL if (TokenAvailable()) { GetToken (qfalse); // side->contents = atoi(token); flags = atoi(token); if ( flags & CONTENTS_DETAIL ) { side->contents |= CONTENTS_DETAIL; } GetToken (qfalse); // td.flags = atoi(token); GetToken (qfalse); // td.value = atoi(token); } // find the plane number planenum = MapPlaneFromPoints (planepts[0], planepts[1], planepts[2]); side->planenum = planenum; if (g_bBrushPrimit==BPRIMIT_OLDBRUSHES) // get the texture mapping for this texturedef / plane combination QuakeTextureVecs(