map_hl.c File Reference

#include "qbsp.h"
#include "l_bsp_hl.h"
#include "aas_map.h"

Include dependency graph for map_hl.c:

Go to the source code of this file.

Defines
#define	HLCONTENTS
Functions
void	HL_BSPBrushToMapBrush (bspbrush_t *bspbrush, entity_t *mapent)
bspbrush_t *	HL_CreateBrushes_r (bspbrush_t *brush, int nodenum)
bspbrush_t *	HL_CreateBrushesFromBSP (int modelnum)
void	HL_CreateMapBrushes (entity_t *mapent, int modelnum)
float	HL_FaceOnWinding (hl_dface_t *face, winding_t *winding)
void	HL_FixContentsTextures (bspbrush_t *brushlist)
void	HL_LoadMapFromBSP (char *filename, int offset, int length)
bspbrush_t *	HL_MergeBrushes (bspbrush_t *brushlist, int modelnum)
void	HL_ResetMapLoading (void)
int	HL_SolidTree_r (int nodenum)
void	HL_SplitBrush (bspbrush_t *brush, int planenum, int nodenum, bspbrush_t **front, bspbrush_t **back)
bspbrush_t *	HL_SplitBrushWithFace (bspbrush_t *brush, hl_dface_t *face)
bspbrush_t *	HL_TextureBrushes (bspbrush_t *brushlist, int modelnum)
int	HL_TextureContents (char *name)
Variables
int	hl_numbrushes
int	hl_numclipbrushes

---

Define Documentation

#define HLCONTENTS

Definition at line 31 of file map_hl.c.

---

Function Documentation

void HL_BSPBrushToMapBrush (  bspbrush_t *  bspbrush, entity_t *  mapent )

Definition at line 945 of file map_hl.c. References AAS_CreateMapBrushes(), AddBrushBevels(), mapbrush_s::brushnum, brushsides, bspbrush_t, mapbrush_s::contents, side_s::contents, mapbrush_s::entitynum, Error(), entity_t::firstbrush, side_s::flags, hl_numclipbrushes, i, mapbrush_s::leafnum, MakeBrushWindings(), mapbrush_t, mapbrushes, mapent, entity_t::numbrushes, nummapbrushes, nummapbrushsides, bspbrush_s::numsides, mapbrush_s::numsides, mapbrush_s::original_sides, side_s::planenum, bspbrush_s::side, side_t, bspbrush_s::sides, side_s::surf, side_s::texinfo, and side_s::winding. Referenced by HL_CreateMapBrushes(). { mapbrush_t *mapbrush; side_t *side; int i, besttexinfo; if (nummapbrushes >= MAX_MAPFILE_BRUSHES) Error ("nummapbrushes == MAX_MAPFILE_BRUSHES"); mapbrush = &mapbrushes[nummapbrushes]; mapbrush->original_sides = &brushsides[nummapbrushsides]; mapbrush->entitynum = mapent - entities; mapbrush->brushnum = nummapbrushes - mapent->firstbrush; mapbrush->leafnum = -1; mapbrush->numsides = 0; besttexinfo = TEXINFO_NODE; for (i = 0; i < bspbrush->numsides; i++) { if (!bspbrush->sides[i].winding) continue; // if (nummapbrushsides >= MAX_MAPFILE_BRUSHSIDES) Error ("MAX_MAPFILE_BRUSHSIDES"); side = &brushsides[nummapbrushsides]; //the contents of the bsp brush is stored in the side variable side->contents = bspbrush->side; side->surf = 0; side->planenum = bspbrush->sides[i].planenum; side->texinfo = bspbrush->sides[i].texinfo; if (side->texinfo != TEXINFO_NODE) { //this brush side is textured side->flags |= SFL_TEXTURED; besttexinfo = side->texinfo; } //end if // nummapbrushsides++; mapbrush->numsides++; } //end for // if (besttexinfo == TEXINFO_NODE) { mapbrush->numsides = 0; hl_numclipbrushes++; return; } //end if //set the texinfo for all the brush sides without texture for (i = 0; i < mapbrush->numsides; i++) { if (mapbrush->original_sides[i].texinfo == TEXINFO_NODE) { mapbrush->original_sides[i].texinfo = besttexinfo; } //end if } //end for //contents of the brush mapbrush->contents = bspbrush->side; // if (create_aas) { //create the AAS brushes from this brush, add brush bevels AAS_CreateMapBrushes(mapbrush, mapent, true); return; } //end if //create windings for sides and bounds for brush MakeBrushWindings(mapbrush); //add brush bevels AddBrushBevels(mapbrush); //a new brush has been created nummapbrushes++; mapent->numbrushes++; } //end of the function HL_BSPBrushToMapBrush

Here is the call graph for this function:

bspbrush_t* HL_CreateBrushes_r (  bspbrush_t *  brush, int  nodenum )

Definition at line 342 of file map_hl.c. References bspbrush_t, hl_dleaf_t::contents, Error(), FindFloatPlane(), FreeBrush(), HL_CONTENTS_CLIP, HL_CONTENTS_CURRENT_0, HL_CONTENTS_CURRENT_180, HL_CONTENTS_CURRENT_270, HL_CONTENTS_CURRENT_90, HL_CONTENTS_CURRENT_DOWN, HL_CONTENTS_CURRENT_UP, HL_CONTENTS_EMPTY, HL_CONTENTS_LAVA, HL_CONTENTS_ORIGIN, HL_CONTENTS_SKY, HL_CONTENTS_SLIME, HL_CONTENTS_SOLID, HL_CONTENTS_TRANSLUCENT, HL_CONTENTS_WATER, hl_dleafs, hl_dnodes, hl_dplanes, hl_numbrushes, HL_SplitBrush(), Log_Print(), bspbrush_s::next, hl_dnode_t::planenum, qprintf(), and bspbrush_s::side. Referenced by HL_CreateBrushesFromBSP(). { int planenum; bspbrush_t *front, *back; hl_dleaf_t *leaf; //if it is a leaf if (nodenum < 0) { leaf = &hl_dleafs[(-nodenum) - 1]; if (leaf->contents != HL_CONTENTS_EMPTY) { #ifdef HL_PRINT qprintf("\r%5i", ++hl_numbrushes); #endif //HL_PRINT } //end if switch(leaf->contents) { case HL_CONTENTS_EMPTY: { FreeBrush(brush); return NULL; } //end case case HL_CONTENTS_SOLID: #ifdef HLCONTENTS case HL_CONTENTS_CLIP: #endif //HLCONTENTS case HL_CONTENTS_SKY: #ifdef HLCONTENTS case HL_CONTENTS_TRANSLUCENT: #endif //HLCONTENTS { brush->side = CONTENTS_SOLID; return brush; } //end case case HL_CONTENTS_WATER: { brush->side = CONTENTS_WATER; return brush; } //end case case HL_CONTENTS_SLIME: { brush->side = CONTENTS_SLIME; return brush; } //end case case HL_CONTENTS_LAVA: { brush->side = CONTENTS_LAVA; return brush; } //end case #ifdef HLCONTENTS //these contents should not be found in the BSP case HL_CONTENTS_ORIGIN: case HL_CONTENTS_CURRENT_0: case HL_CONTENTS_CURRENT_90: case HL_CONTENTS_CURRENT_180: case HL_CONTENTS_CURRENT_270: case HL_CONTENTS_CURRENT_UP: case HL_CONTENTS_CURRENT_DOWN: { Error("HL_CreateBrushes_r: found contents %d in Half-Life BSP", leaf->contents); return NULL; } //end case #endif //HLCONTENTS default: { Error("HL_CreateBrushes_r: unknown contents %d in Half-Life BSP", leaf->contents); return NULL; } //end default } //end switch return NULL; } //end if //if the rest of the tree is solid /*if (HL_SolidTree_r(nodenum)) { brush->side = CONTENTS_SOLID; return brush; } //end if*/ // planenum = hl_dnodes[nodenum].planenum; planenum = FindFloatPlane(hl_dplanes[planenum].normal, hl_dplanes[planenum].dist); //split the brush with the node plane HL_SplitBrush(brush, planenum, nodenum, &front, &back); //free the original brush FreeBrush(brush); //every node must split the brush in two if (!front || !back) { Log_Print("HL_CreateBrushes_r: WARNING node not splitting brush\n"); //return NULL; } //end if //create brushes recursively if (front) front = HL_CreateBrushes_r(front, hl_dnodes[nodenum].children[0]); if (back) back = HL_CreateBrushes_r(back, hl_dnodes[nodenum].children[1]); //link the brushes if possible and return them if (front) { for (brush = front; brush->next; brush = brush->next); brush->next = back; return front; } //end if else { return back; } //end else } //end of the function HL_CreateBrushes_r

Here is the call graph for this function:

bspbrush_t* HL_CreateBrushesFromBSP (  int  modelnum  )

Definition at line 454 of file map_hl.c. References AddPointToBounds(), BrushFromBounds(), bspbrush_t, hl_dmodel_t::headnode, HL_CreateBrushes_r(), hl_dmodels, hl_dnodes, hl_numbrushes, i, Log_Print(), map_maxs, map_mins, bspbrush_s::maxs, hl_dnode_t::maxs, bspbrush_s::mins, hl_dnode_t::mins, qprintf(), vec3_t, and VectorCopy. Referenced by HL_CreateMapBrushes(). { bspbrush_t *brushlist; bspbrush_t *brush; hl_dnode_t *headnode; vec3_t mins, maxs; int i; // headnode = &hl_dnodes[hl_dmodels[modelnum].headnode[0]]; //get the mins and maxs of the world VectorCopy(headnode->mins, mins); VectorCopy(headnode->maxs, maxs); //enlarge these mins and maxs for (i = 0; i < 3; i++) { mins[i] -= 8; maxs[i] += 8; } //end for //NOTE: have to add the BSP tree mins and maxs to the MAP mins and maxs AddPointToBounds(mins, map_mins, map_maxs); AddPointToBounds(maxs, map_mins, map_maxs); // if (!modelnum) { Log_Print("brush 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]); } //end if //create one huge brush containing the whole world brush = BrushFromBounds(mins, maxs); VectorCopy(mins, brush->mins); VectorCopy(maxs, brush->maxs); // #ifdef HL_PRINT qprintf("creating Half-Life brushes\n"); qprintf("%5d brushes", hl_numbrushes = 0); #endif //HL_PRINT //create the brushes brushlist = HL_CreateBrushes_r(brush, hl_dmodels[modelnum].headnode[0]); // #ifdef HL_PRINT qprintf("\n"); #endif //HL_PRINT //now we've got a list with brushes! return brushlist; } //end of the function HL_CreateBrushesFromBSP

Here is the call graph for this function:

void HL_CreateMapBrushes (  entity_t *  mapent, int  modelnum )

Definition at line 1022 of file map_hl.c. References bspbrush_t, FreeBrush(), HL_BSPBrushToMapBrush(), HL_CreateBrushesFromBSP(), HL_FixContentsTextures(), HL_MergeBrushes(), HL_TextureBrushes(), i, mapent, bspbrush_s::next, and qprintf(). Referenced by HL_LoadMapFromBSP(). { bspbrush_t *brushlist, *brush, *nextbrush; int i; //create brushes from the model BSP tree brushlist = HL_CreateBrushesFromBSP(modelnum); //texture the brushes and split them when necesary brushlist = HL_TextureBrushes(brushlist, modelnum); //fix the contents textures of all brushes HL_FixContentsTextures(brushlist); // if (!nobrushmerge) { brushlist = HL_MergeBrushes(brushlist, modelnum); //brushlist = HL_MergeBrushes(brushlist, modelnum); } //end if // if (!modelnum) qprintf("converting brushes to map brushes\n"); if (!modelnum) qprintf("%5d brushes", i = 0); for (brush = brushlist; brush; brush = nextbrush) { nextbrush = brush->next; HL_BSPBrushToMapBrush(brush, mapent); brush->next = NULL; FreeBrush(brush); if (!modelnum) qprintf("\r%5d", ++i); } //end for if (!modelnum) qprintf("\n"); } //end of the function HL_CreateMapBrushes

Here is the call graph for this function:

float HL_FaceOnWinding (  hl_dface_t *  face, winding_t *  winding )

Definition at line 578 of file map_hl.c. References abs(), ChopWindingInPlace(), CopyWinding(), CrossProduct(), hl_dplane_t::dist, DotProduct, hl_dface_t::firstedge, FreeWinding(), hl_dedges, hl_dplanes, hl_dsurfedges, hl_dvertexes, i, memcpy(), hl_dplane_t::normal, hl_dface_t::numedges, hl_dface_t::planenum, hl_dvertex_t::point, hl_dface_t::side, hl_dedge_t::v, v1, v2, vec3_t, vec_t, VectorNegate, VectorNormalize(), VectorSubtract, w, and WindingArea(). Referenced by HL_TextureBrushes(). { int i, edgenum, side; float dist, area; hl_dplane_t plane; vec_t *v1, *v2; vec3_t normal, edgevec; winding_t *w; // w = CopyWinding(winding); memcpy(&plane, &hl_dplanes[face->planenum], sizeof(hl_dplane_t)); //check on which side of the plane the face is if (face->side) { VectorNegate(plane.normal, plane.normal); plane.dist = -plane.dist; } //end if for (i = 0; i < face->numedges && w; i++) { //get the first and second vertex of the edge edgenum = hl_dsurfedges[face->firstedge + i]; side = edgenum > 0; //if the face plane is flipped v1 = hl_dvertexes[hl_dedges[abs(edgenum)].v[side]].point; v2 = hl_dvertexes[hl_dedges[abs(edgenum)].v[!side]].point; //create a plane through the edge vector, orthogonal to the face plane //and with the normal vector pointing out of the face VectorSubtract(v1, v2, edgevec); CrossProduct(edgevec, plane.normal, normal); VectorNormalize(normal); dist = DotProduct(normal, v1); // ChopWindingInPlace(&w, normal, dist, 0.9); //CLIP_EPSILON } //end for if (w) { area = WindingArea(w); FreeWinding(w); return area; } //end if return 0; } //end of the function HL_FaceOnWinding

Here is the call graph for this function:

void HL_FixContentsTextures (  bspbrush_t *  brushlist  )

Definition at line 883 of file map_hl.c. References bspbrush_t, CONTENTS_SLIME, CONTENTS_WATER, HL_TextureContents(), i, Log_Print(), map_texinfo, bspbrush_s::next, bspbrush_s::numsides, bspbrush_s::side, bspbrush_s::sides, side_s::texinfo, and texture. Referenced by HL_CreateMapBrushes(). { int i, texinfonum; bspbrush_t *brush; for (brush = brushlist; brush; brush = brush->next) { //only fix the textures of water, slime and lava brushes if (brush->side != CONTENTS_WATER && brush->side != CONTENTS_SLIME && brush->side != CONTENTS_LAVA) continue; // for (i = 0; i < brush->numsides; i++) { texinfonum = brush->sides[i].texinfo; if (HL_TextureContents(map_texinfo[texinfonum].texture) == brush->side) break; } //end for //if no specific contents texture was found if (i >= brush->numsides) { texinfonum = -1; for (i = 0; i < map_numtexinfo; i++) { if (HL_TextureContents(map_texinfo[i].texture) == brush->side) { texinfonum = i; break; } //end if } //end for } //end if // if (texinfonum >= 0) { //give all the brush sides this contents texture for (i = 0; i < brush->numsides; i++) { brush->sides[i].texinfo = texinfonum; } //end for } //end if else Log_Print("brush contents %d with wrong textures\n", brush->side); // } //end for /* for (brush = brushlist; brush; brush = brush->next) { //give all the brush sides this contents texture for (i = 0; i < brush->numsides; i++) { if (HL_TextureContents(map_texinfo[texinfonum].texture) != brush->side) { Error("brush contents %d with wrong contents textures %s\n", brush->side, HL_TextureContents(map_texinfo[texinfonum].texture)); } //end if } //end for } //end for*/ } //end of the function HL_FixContentsTextures

Here is the call graph for this function:

void HL_LoadMapFromBSP (  char *  filename, int  offset, int  length )

Definition at line 1067 of file map_hl.c. References atoi, ClearBounds(), entities, entity_t::firstbrush, HL_CreateMapBrushes(), HL_LoadBSPFile(), hl_numclipbrushes, HL_ParseEntities(), i, length(), loadedmaptype, Log_Print(), map_maxs, map_mins, entity_t::numbrushes, nummapbrushes, offset, qprintf(), strcmp(), and ValueForKey(). Referenced by LoadMapFromBSP(). { int i, modelnum; char *model, *classname; Log_Print("-- HL_LoadMapFromBSP --\n"); //loaded map type loadedmaptype = MAPTYPE_HALFLIFE; // qprintf("loading map from %s at %d\n", filename, offset); //load the Half-Life BSP file HL_LoadBSPFile(filename, offset, length); // hl_numclipbrushes = 0; //parse the entities from the BSP HL_ParseEntities(); //clear the map mins and maxs ClearBounds(map_mins, map_maxs); // qprintf("creating Half-Life brushes\n"); if (lessbrushes) qprintf("creating minimum number of brushes\n"); else qprintf("placing textures correctly\n"); // for (i = 0; i < num_entities; i++) { entities[i].firstbrush = nummapbrushes; entities[i].numbrushes = 0; // classname = ValueForKey(&entities[i], "classname"); if (classname && !strcmp(classname, "worldspawn")) { modelnum = 0; } //end if else { // model = ValueForKey(&entities[i], "model"); if (!model || *model != '*') continue; model++; modelnum = atoi(model); } //end else //create map brushes for the entity HL_CreateMapBrushes(&entities[i], modelnum); } //end for // qprintf("%5d map brushes\n", nummapbrushes); qprintf("%5d clip brushes\n", hl_numclipbrushes); } //end of the function HL_LoadMapFromBSP

Here is the call graph for this function:

bspbrush_t* HL_MergeBrushes (  bspbrush_t *  brushlist, int  modelnum )

Definition at line 507 of file map_hl.c. References bspbrush_t, FreeBrush(), bspbrush_s::next, qprintf(), bspbrush_s::side, and TryMergeBrushes(). Referenced by HL_CreateMapBrushes(). { int nummerges, merged; bspbrush_t *b1, *b2, *tail, *newbrush, *newbrushlist; bspbrush_t *lastb2; if (!brushlist) return NULL; if (!modelnum) qprintf("%5d brushes merged", nummerges = 0); do { for (tail = brushlist; tail; tail = tail->next) { if (!tail->next) break; } //end for merged = 0; newbrushlist = NULL; for (b1 = brushlist; b1; b1 = brushlist) { lastb2 = b1; for (b2 = b1->next; b2; b2 = b2->next) { //can't merge brushes with different contents if (b1->side != b2->side) newbrush = NULL; else newbrush = TryMergeBrushes(b1, b2); //if a merged brush is created if (newbrush) { //copy the brush contents newbrush->side = b1->side; //add the new brush to the end of the list tail->next = newbrush; //remove the second brush from the list lastb2->next = b2->next; //remove the first brush from the list brushlist = brushlist->next; //free the merged brushes FreeBrush(b1); FreeBrush(b2); //get a new tail brush for (tail = brushlist; tail; tail = tail->next) { if (!tail->next) break; } //end for merged++; if (!modelnum) qprintf("\r%5d", nummerges++); break; } //end if lastb2 = b2; } //end for //if b1 can't be merged with any of the other brushes if (!b2) { brushlist = brushlist->next; //keep b1 b1->next = newbrushlist; newbrushlist = b1; } //end else } //end for brushlist = newbrushlist; } while(merged); if (!modelnum) qprintf("\n"); return newbrushlist; } //end of the function HL_MergeBrushes

Here is the call graph for this function:

void HL_ResetMapLoading (  void   )

Definition at line 1058 of file map_hl.c. { } //end of the function HL_ResetMapLoading

int HL_SolidTree_r (  int  nodenum  )

Definition at line 291 of file map_hl.c. References hl_dleaf_t::contents, HL_CONTENTS_CLIP, HL_CONTENTS_CURRENT_0, HL_CONTENTS_CURRENT_180, HL_CONTENTS_CURRENT_270, HL_CONTENTS_CURRENT_90, HL_CONTENTS_CURRENT_DOWN, HL_CONTENTS_CURRENT_UP, HL_CONTENTS_EMPTY, HL_CONTENTS_LAVA, HL_CONTENTS_ORIGIN, HL_CONTENTS_SKY, HL_CONTENTS_SLIME, HL_CONTENTS_SOLID, HL_CONTENTS_TRANSLUCENT, HL_CONTENTS_WATER, hl_dleafs, and hl_dnodes. { if (nodenum < 0) { switch(hl_dleafs[(-nodenum) - 1].contents) { case HL_CONTENTS_EMPTY: { return false; } //end case case HL_CONTENTS_SOLID: #ifdef HLCONTENTS case HL_CONTENTS_CLIP: #endif //HLCONTENTS case HL_CONTENTS_SKY: #ifdef HLCONTENTS case HL_CONTENTS_TRANSLUCENT: #endif //HLCONTENTS { return true; } //end case case HL_CONTENTS_WATER: case HL_CONTENTS_SLIME: case HL_CONTENTS_LAVA: #ifdef HLCONTENTS //these contents should not be found in the BSP case HL_CONTENTS_ORIGIN: case HL_CONTENTS_CURRENT_0: case HL_CONTENTS_CURRENT_90: case HL_CONTENTS_CURRENT_180: case HL_CONTENTS_CURRENT_270: case HL_CONTENTS_CURRENT_UP: case HL_CONTENTS_CURRENT_DOWN: #endif //HLCONTENTS default: { return false; } //end default } //end switch return false; } //end if if (!HL_SolidTree_r(hl_dnodes[nodenum].children[0])) return false; if (!HL_SolidTree_r(hl_dnodes[nodenum].children[1])) return false; return true; } //end of the function HL_SolidTree_r

void HL_SplitBrush (  bspbrush_t *  brush, int  planenum, int  nodenum, bspbrush_t **  front, bspbrush_t **  back )

Definition at line 90 of file map_hl.c. References AllocBrush(), b, BaseWindingForPlane(), BoundBrush(), BrushMostlyOnSide(), BrushVolume(), bspbrush_t, ChopWindingInPlace(), ClipWindingEpsilon(), CopyBrush(), CopyWinding(), d, plane_t::dist, DotProduct, side_s::flags, FreeBrush(), FreeWinding(), i, j, Log_Print(), mapplanes, bspbrush_s::maxs, bspbrush_s::mins, plane_t::normal, winding_t::numpoints, bspbrush_s::numsides, bspbrush_s::original, winding_t::p, side_s::planenum, s, side_t, bspbrush_s::sides, side_s::surf, side_s::texinfo, v1, vec_t, w, side_s::winding, WindingIsHuge(), and WindingIsTiny(). Referenced by HL_CreateBrushes_r(). { bspbrush_t *b[2]; int i, j; winding_t *w, *cw[2], *midwinding; plane_t *plane, *plane2; side_t *s, *cs; float d, d_front, d_back; *front = *back = NULL; plane = &mapplanes[planenum]; // check all points d_front = d_back = 0; for (i=0 ; i<brush->numsides ; i++) { w = brush->sides[i].winding; if (!w) continue; for (j=0 ; j<w->numpoints ; j++) { d = DotProduct (w->p[j], plane->normal) - plane->dist; if (d > 0 && d > d_front) d_front = d; if (d < 0 && d < d_back) d_back = d; } //end for } //end for if (d_front < 0.1) // PLANESIDE_EPSILON) { // only on back *back = CopyBrush (brush); Log_Print("HL_SplitBrush: only on back\n"); return; } //end if if (d_back > -0.1) // PLANESIDE_EPSILON) { // only on front *front = CopyBrush (brush); Log_Print("HL_SplitBrush: only on front\n"); return; } //end if // create a new winding from the split plane w = BaseWindingForPlane (plane->normal, plane->dist); for (i = 0; i < brush->numsides && w; i++) { plane2 = &mapplanes[brush->sides[i].planenum ^ 1]; ChopWindingInPlace(&w, plane2->normal, plane2->dist, 0); // PLANESIDE_EPSILON); } //end for if (!w || WindingIsTiny(w)) { // the brush isn't really split int side; Log_Print("HL_SplitBrush: no split winding\n"); side = BrushMostlyOnSide (brush, plane); if (side == PSIDE_FRONT) *front = CopyBrush (brush); if (side == PSIDE_BACK) *back = CopyBrush (brush); return; } if (WindingIsHuge(w)) { Log_Print("HL_SplitBrush: WARNING huge split winding\n"); } //end of midwinding = w; // split it for real for (i = 0; i < 2; i++) { b[i] = AllocBrush (brush->numsides+1); b[i]->original = brush->original; } //end for // split all the current windings for (i=0 ; i<brush->numsides ; i++) { s = &brush->sides[i]; w = s->winding; if (!w) continue; ClipWindingEpsilon (w, plane->normal, plane->dist, 0 /*PLANESIDE_EPSILON*/, &cw[0], &cw[1]); for (j=0 ; j<2 ; j++) { if (!cw[j]) continue; #if 0 if (WindingIsTiny (cw[j])) { FreeWinding (cw[j]); continue; } #endif cs = &b[j]->sides[b[j]->numsides]; b[j]->numsides++; *cs = *s; // cs->planenum = s->planenum; // cs->texinfo = s->texinfo; // cs->visible = s->visible; // cs->original = s->original; cs->winding = cw[j]; cs->flags &= ~SFL_TESTED; } //end for } //end for // see if we have valid polygons on both sides for (i=0 ; i<2 ; i++) { BoundBrush (b[i]); for (j=0 ; j<3 ; j++) { if (b[i]->mins[j] < -4096 || b[i]->maxs[j] > 4096) { Log_Print("HL_SplitBrush: bogus brush after clip\n"); break; } //end if } //end for if (b[i]->numsides < 3 || j < 3) { FreeBrush (b[i]); b[i] = NULL; Log_Print("HL_SplitBrush: numsides < 3\n"); } //end if } //end for if ( !(b[0] && b[1]) ) { if (!b[0] && !b[1]) Log_Print("HL_SplitBrush: split removed brush\n"); else Log_Print("HL_SplitBrush: split not on both sides\n"); if (b[0]) { FreeBrush (b[0]); *front = CopyBrush (brush); } //end if if (b[1]) { FreeBrush (b[1]); *back = CopyBrush (brush); } //end if return; } //end if // add the midwinding to both sides for (i = 0; i < 2; i++) { cs = &b[i]->sides[b[i]->numsides]; b[i]->numsides++; cs->planenum = planenum^i^1; cs->texinfo = 0; //store the node number in the surf to find the texinfo later on cs->surf = nodenum; // cs->flags &= ~SFL_VISIBLE; cs->flags &= ~SFL_TESTED; if (i==0) cs->winding = CopyWinding (midwinding); else cs->winding = midwinding; } //end for { vec_t v1; int i; for (i=0 ; i<2 ; i++) { v1 = BrushVolume (b[i]); if (v1 < 1) { FreeBrush (b[i]); b[i] = NULL; Log_Print("HL_SplitBrush: tiny volume after clip\n"); } //end if } //end for } //*/ *front = b[0]; *back = b[1]; } //end of the function HL_SplitBrush

Here is the call graph for this function:

bspbrush_t* HL_SplitBrushWithFace (  bspbrush_t *  brush, hl_dface_t *  face )

Definition at line 629 of file map_hl.c. References abs(), bspbrush_t, CrossProduct(), hl_dplane_t::dist, DotProduct, FindFloatPlane(), hl_dface_t::firstedge, FreeBrush(), FreeBrushList(), hl_dedges, hl_dplanes, hl_dsurfedges, hl_dvertexes, i, Log_Print(), memcpy(), bspbrush_s::next, hl_dplane_t::normal, hl_dface_t::numedges, hl_dface_t::planenum, hl_dvertex_t::point, bspbrush_s::side, hl_dface_t::side, SplitBrush(), hl_dedge_t::v, v1, v2, vec3_t, vec_t, VectorNegate, VectorNormalize(), and VectorSubtract. Referenced by HL_TextureBrushes(). { int i, edgenum, side, planenum, splits; float dist; hl_dplane_t plane; vec_t *v1, *v2; vec3_t normal, edgevec; bspbrush_t *front, *back, *brushlist; memcpy(&plane, &hl_dplanes[face->planenum], sizeof(hl_dplane_t)); //check on which side of the plane the face is if (face->side) { VectorNegate(plane.normal, plane.normal); plane.dist = -plane.dist; } //end if splits = 0; brushlist = NULL; for (i = 0; i < face->numedges; i++) { //get the first and second vertex of the edge edgenum = hl_dsurfedges[face->firstedge + i]; side = edgenum > 0; //if the face plane is flipped v1 = hl_dvertexes[hl_dedges[abs(edgenum)].v[side]].point; v2 = hl_dvertexes[hl_dedges[abs(edgenum)].v[!side]].point; //create a plane through the edge vector, orthogonal to the face plane //and with the normal vector pointing out of the face VectorSubtract(v1, v2, edgevec); CrossProduct(edgevec, plane.normal, normal); VectorNormalize(normal); dist = DotProduct(normal, v1); // planenum = FindFloatPlane(normal, dist); //split the current brush SplitBrush(brush, planenum, &front, &back); //if there is a back brush just put it in the list if (back) { //copy the brush contents back->side = brush->side; // back->next = brushlist; brushlist = back; splits++; } //end if if (!front) { Log_Print("HL_SplitBrushWithFace: no new brush\n"); FreeBrushList(brushlist); return NULL; } //end if //copy the brush contents front->side = brush->side; //continue splitting the front brush brush = front; } //end for if (!splits) { FreeBrush(front); return NULL; } //end if front->next = brushlist; brushlist = front; return brushlist; } //end of the function HL_SplitBrushWithFace

Here is the call graph for this function:

bspbrush_t* HL_TextureBrushes (  bspbrush_t *  brushlist, int  modelnum )

Definition at line 701 of file map_hl.c. References bspbrush_t, byte, hl_dmiptexlump_t::dataofs, hl_texinfo_s::flags, map_texinfo_t::flags, side_s::flags, FreeBrush(), hl_dfaces, hl_dnodes, HL_FaceOnWinding(), hl_miptex_t, HL_SplitBrushWithFace(), hl_texinfo, i, Log_Write(), map_numtexinfo, map_texinfo, memcpy(), hl_texinfo_s::miptex, n, hl_miptex_s::name, bspbrush_s::next, map_texinfo_t::nexttexinfo, numbrushes, bspbrush_s::numsides, hl_dnode_t::planenum, hl_dface_t::planenum, qprintf(), side_t, bspbrush_s::sides, strcpy(), side_s::surf, side_s::texinfo, hl_dface_t::texinfo, texture, map_texinfo_t::value, vec_t, vecs, hl_texinfo_s::vecs, map_texinfo_t::vecs, VectorLength(), and side_s::winding. Referenced by HL_CreateMapBrushes(). { float area, largestarea; int i, n, texinfonum, sn, numbrushes, ofs; int bestfacenum, sidenodenum; side_t *side; hl_dmiptexlump_t *miptexlump; hl_miptex_t *miptex; bspbrush_t *brush, *nextbrush, *prevbrush, *newbrushes, *brushlistend; vec_t defaultvec[4] = {1, 0, 0, 0}; if (!modelnum) qprintf("texturing brushes\n"); if (!modelnum) qprintf("%5d brushes", numbrushes = 0); //get a pointer to the last brush in the list for (brushlistend = brushlist; brushlistend; brushlistend = brushlistend->next) { if (!brushlistend->