tr_bsp.c File Reference

#include "tr_local.h"

Include dependency graph for tr_bsp.c:

Go to the source code of this file.

Defines
#define	LIGHTMAP_SIZE   128
Functions
void	HSVtoRGB (float h, float s, float v, float rgb[3])
void	ParseFace (dsurface_t *ds, drawVert_t *verts, msurface_t *surf, int *indexes)
void	ParseFlare (dsurface_t *ds, drawVert_t *verts, msurface_t *surf, int *indexes)
void	ParseMesh (dsurface_t *ds, drawVert_t *verts, msurface_t *surf)
void	ParseTriSurf (dsurface_t *ds, drawVert_t *verts, msurface_t *surf, int *indexes)
void	R_ColorShiftLightingBytes (byte in[4], byte out[4])
void	R_FixSharedVertexLodError (void)
void	R_FixSharedVertexLodError_r (int start, srfGridMesh_t *grid1)
qboolean	R_GetEntityToken (char *buffer, int size)
void	R_LoadEntities (lump_t *l)
void	R_LoadFogs (lump_t *l, lump_t *brushesLump, lump_t *sidesLump)
void	R_LoadLightGrid (lump_t *l)
void	R_LoadLightmaps (lump_t *l)
void	R_LoadMarksurfaces (lump_t *l)
void	R_LoadNodesAndLeafs (lump_t *nodeLump, lump_t *leafLump)
void	R_LoadPlanes (lump_t *l)
void	R_LoadShaders (lump_t *l)
void	R_LoadSubmodels (lump_t *l)
void	R_LoadSurfaces (lump_t *surfs, lump_t *verts, lump_t *indexLump)
void	R_LoadVisibility (lump_t *l)
int	R_MergedHeightPoints (srfGridMesh_t *grid, int offset)
int	R_MergedWidthPoints (srfGridMesh_t *grid, int offset)
void	R_MovePatchSurfacesToHunk (void)
void	R_SetParent (mnode_t *node, mnode_t *parent)
void	R_StitchAllPatches (void)
int	R_StitchPatches (int grid1num, int grid2num)
int	R_TryStitchingPatch (int grid1num)
void	RE_LoadWorldMap (const char *name)
void	RE_SetWorldVisData (const byte *vis)
shader_t *	ShaderForShaderNum (int shaderNum, int lightmapNum)
Variables
int	c_gridVerts
int	c_subdivisions
byte *	fileBase
world_t	s_worldData

---

Define Documentation

#define LIGHTMAP_SIZE   128

Definition at line 134 of file tr_bsp.c. Referenced by R_LoadLightmaps(), VL_FacetsForPatch(), VL_FixLightmapEdges(), VL_LightmapMatrixFromPoints(), VL_LightSurfaceWithVolume(), VL_SmoothenLightmapEdges(), VS_FacetsForPatch(), VS_FixLightmapEdges(), VS_LightmapMatrixFromPoints(), VS_LightSurfaceWithVolume(), and VS_SmoothenLightmapEdges().

---

Function Documentation

void HSVtoRGB (  float  h, float  s, float  v, float  rgb[3] )  [static]

Definition at line 44 of file tr_bsp.c. References f, floor(), h(), i, p, q, s, t, and v. Referenced by R_LoadLightmaps(). { int i; float f; float p, q, t; h *= 5; i = floor( h ); f = h - i; p = v * ( 1 - s ); q = v * ( 1 - s * f ); t = v * ( 1 - s * ( 1 - f ) ); switch ( i ) { case 0: rgb[0] = v; rgb[1] = t; rgb[2] = p; break; case 1: rgb[0] = q; rgb[1] = v; rgb[2] = p; break; case 2: rgb[0] = p; rgb[1] = v; rgb[2] = t; break; case 3: rgb[0] = p; rgb[1] = q; rgb[2] = v; break; case 4: rgb[0] = t; rgb[1] = p; rgb[2] = v; break; case 5: rgb[0] = v; rgb[1] = p; rgb[2] = q; break; } }

Here is the call graph for this function:

void ParseFace (  dsurface_t *  ds, drawVert_t *  verts, msurface_t *  surf, int *  indexes )  [static]

Definition at line 303 of file tr_bsp.c. References byte, msurface_s::data, trGlobals_t::defaultShader, cplane_s::dist, DotProduct, dsurface_t::firstIndex, dsurface_t::firstVert, msurface_s::fogIndex, dsurface_t::fogNum, h_low, refimport_t::Hunk_Alloc, i, cvar_s::integer, shader_s::isSky, j, dsurface_t::lightmapNum, dsurface_t::lightmapVecs, LittleFloat(), LittleLong(), msurface_t, cplane_s::normal, dsurface_t::numIndexes, srfSurfaceFace_t::numIndices, srfSurfaceFace_t::numPoints, dsurface_t::numVerts, srfSurfaceFace_t::ofsIndices, srfSurfaceFace_t::plane, PlaneTypeForNormal, srfSurfaceFace_t::points, PRINT_WARNING, R_ColorShiftLightingBytes(), r_singleShader, ri, SetPlaneSignbits(), msurface_s::shader, ShaderForShaderNum(), dsurface_t::shaderNum, srfSurfaceFace_t::surfaceType, surfaceType_t, tr, and cplane_s::type. Referenced by R_LoadSurfaces(). { int i, j; srfSurfaceFace_t *cv; int numPoints, numIndexes; int lightmapNum; int sfaceSize, ofsIndexes; lightmapNum = LittleLong( ds->lightmapNum ); // get fog volume surf->fogIndex = LittleLong( ds->fogNum ) + 1; // get shader value surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapNum ); if ( r_singleShader->integer && !surf->shader->isSky ) { surf->shader = tr.defaultShader; } numPoints = LittleLong( ds->numVerts ); if (numPoints > MAX_FACE_POINTS) { ri.Printf( PRINT_WARNING, "WARNING: MAX_FACE_POINTS exceeded: %i\n", numPoints); numPoints = MAX_FACE_POINTS; surf->shader = tr.defaultShader; } numIndexes = LittleLong( ds->numIndexes ); // create the srfSurfaceFace_t sfaceSize = ( int ) &((srfSurfaceFace_t *)0)->points[numPoints]; ofsIndexes = sfaceSize; sfaceSize += sizeof( int ) * numIndexes; cv = ri.Hunk_Alloc( sfaceSize, h_low ); cv->surfaceType = SF_FACE; cv->numPoints = numPoints; cv->numIndices = numIndexes; cv->ofsIndices = ofsIndexes; verts += LittleLong( ds->firstVert ); for ( i = 0 ; i < numPoints ; i++ ) { for ( j = 0 ; j < 3 ; j++ ) { cv->points[i][j] = LittleFloat( verts[i].xyz[j] ); } for ( j = 0 ; j < 2 ; j++ ) { cv->points[i][3+j] = LittleFloat( verts[i].st[j] ); cv->points[i][5+j] = LittleFloat( verts[i].lightmap[j] ); } R_ColorShiftLightingBytes( verts[i].color, (byte *)&cv->points[i][7] ); } indexes += LittleLong( ds->firstIndex ); for ( i = 0 ; i < numIndexes ; i++ ) { ((int *)((byte *)cv + cv->ofsIndices ))[i] = LittleLong( indexes[ i ] ); } // take the plane information from the lightmap vector for ( i = 0 ; i < 3 ; i++ ) { cv->plane.normal[i] = LittleFloat( ds->lightmapVecs[2][i] ); } cv->plane.dist = DotProduct( cv->points[0], cv->plane.normal ); SetPlaneSignbits( &cv->plane ); cv->plane.type = PlaneTypeForNormal( cv->plane.normal ); surf->data = (surfaceType_t *)cv; }

Here is the call graph for this function:

void ParseFlare (  dsurface_t *  ds, drawVert_t *  verts, msurface_t *  surf, int *  indexes )  [static]

Definition at line 501 of file tr_bsp.c. References msurface_s::data, trGlobals_t::defaultShader, msurface_s::fogIndex, dsurface_t::fogNum, h_low, refimport_t::Hunk_Alloc, i, cvar_s::integer, shader_s::isSky, LIGHTMAP_BY_VERTEX, dsurface_t::lightmapOrigin, dsurface_t::lightmapVecs, LittleFloat(), LittleLong(), msurface_t, r_singleShader, ri, msurface_s::shader, ShaderForShaderNum(), dsurface_t::shaderNum, srfFlare_t, surfaceType_t, and tr. Referenced by R_LoadSurfaces(). { srfFlare_t *flare; int i; // get fog volume surf->fogIndex = LittleLong( ds->fogNum ) + 1; // get shader surf->shader = ShaderForShaderNum( ds->shaderNum, LIGHTMAP_BY_VERTEX ); if ( r_singleShader->integer && !surf->shader->isSky ) { surf->shader = tr.defaultShader; } flare = ri.Hunk_Alloc( sizeof( *flare ), h_low ); flare->surfaceType = SF_FLARE; surf->data = (surfaceType_t *)flare; for ( i = 0 ; i < 3 ; i++ ) { flare->origin[i] = LittleFloat( ds->lightmapOrigin[i] ); flare->color[i] = LittleFloat( ds->lightmapVecs[0][i] ); flare->normal[i] = LittleFloat( ds->lightmapVecs[2][i] ); } }

Here is the call graph for this function:

void ParseMesh (  dsurface_t *  ds, drawVert_t *  verts, msurface_t *  surf )  [static]

Definition at line 375 of file tr_bsp.c. References msurface_s::data, trGlobals_t::defaultShader, f, dsurface_t::firstVert, msurface_s::fogIndex, dsurface_t::fogNum, height, i, cvar_s::integer, shader_s::isSky, j, drawVert_t::lightmap, dsurface_t::lightmapNum, dsurface_t::lightmapVecs, LittleFloat(), LittleLong(), srfGridMesh_s::lodOrigin, srfGridMesh_s::lodRadius, MAX_PATCH_SIZE, msurface_t, drawVert_t::normal, dsurface_t::patchHeight, dsurface_t::patchWidth, points, R_ColorShiftLightingBytes(), r_singleShader, R_SubdividePatchToGrid(), s_worldData, msurface_s::shader, ShaderForShaderNum(), dsurface_t::shaderNum, world_t::shaders, srfGridMesh_t, drawVert_t::st, dshader_t::surfaceFlags, surfaceType_t, tr, vec3_t, VectorAdd, VectorLength(), VectorScale, VectorSubtract, width, and drawVert_t::xyz. Referenced by R_LoadSurfaces(). { srfGridMesh_t *grid; int i, j; int width, height, numPoints; MAC_STATIC drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE]; int lightmapNum; vec3_t bounds[2]; vec3_t tmpVec; static surfaceType_t skipData = SF_SKIP; lightmapNum = LittleLong( ds->lightmapNum ); // get fog volume surf->fogIndex = LittleLong( ds->fogNum ) + 1; // get shader value surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapNum ); if ( r_singleShader->integer && !surf->shader->isSky ) { surf->shader = tr.defaultShader; } // we may have a nodraw surface, because they might still need to // be around for movement clipping if ( s_worldData.shaders[ LittleLong( ds->shaderNum ) ].surfaceFlags & SURF_NODRAW ) { surf->data = &skipData; return; } width = LittleLong( ds->patchWidth ); height = LittleLong( ds->patchHeight ); verts += LittleLong( ds->firstVert ); numPoints = width * height; for ( i = 0 ; i < numPoints ; i++ ) { for ( j = 0 ; j < 3 ; j++ ) { points[i].xyz[j] = LittleFloat( verts[i].xyz[j] ); points[i].normal[j] = LittleFloat( verts[i].normal[j] ); } for ( j = 0 ; j < 2 ; j++ ) { points[i].st[j] = LittleFloat( verts[i].st[j] ); points[i].lightmap[j] = LittleFloat( verts[i].lightmap[j] ); } R_ColorShiftLightingBytes( verts[i].color, points[i].color ); } // pre-tesseleate grid = R_SubdividePatchToGrid( width, height, points ); surf->data = (surfaceType_t *)grid; // copy the level of detail origin, which is the center // of the group of all curves that must subdivide the same // to avoid cracking for ( i = 0 ; i < 3 ; i++ ) { bounds[0][i] = LittleFloat( ds->lightmapVecs[0][i] ); bounds[1][i] = LittleFloat( ds->lightmapVecs[1][i] ); } VectorAdd( bounds[0], bounds[1], bounds[1] ); VectorScale( bounds[1], 0.5f, grid->lodOrigin ); VectorSubtract( bounds[0], grid->lodOrigin, tmpVec ); grid->lodRadius = VectorLength( tmpVec ); }

Here is the call graph for this function:

void ParseTriSurf (  dsurface_t *  ds, drawVert_t *  verts, msurface_t *  surf, int *  indexes )  [static]

Definition at line 442 of file tr_bsp.c. References AddPointToBounds(), ClearBounds(), drawVert_t::color, msurface_s::data, trGlobals_t::defaultShader, ERR_DROP, dsurface_t::firstIndex, dsurface_t::firstVert, msurface_s::fogIndex, dsurface_t::fogNum, h_low, refimport_t::Hunk_Alloc, i, cvar_s::integer, shader_s::isSky, j, drawVert_t::lightmap, LIGHTMAP_BY_VERTEX, LittleFloat(), LittleLong(), msurface_t, drawVert_t::normal, dsurface_t::numIndexes, dsurface_t::numVerts, R_ColorShiftLightingBytes(), r_singleShader, ri, msurface_s::shader, ShaderForShaderNum(), dsurface_t::shaderNum, drawVert_t::st, surfaceType_t, tr, and drawVert_t::xyz. Referenced by R_LoadSurfaces(). { srfTriangles_t *tri; int i, j; int numVerts, numIndexes; // get fog volume surf->fogIndex = LittleLong( ds->fogNum ) + 1; // get shader surf->shader = ShaderForShaderNum( ds->shaderNum, LIGHTMAP_BY_VERTEX ); if ( r_singleShader->integer && !surf->shader->isSky ) { surf->shader = tr.defaultShader; } numVerts = LittleLong( ds->numVerts ); numIndexes = LittleLong( ds->numIndexes ); tri = ri.Hunk_Alloc( sizeof( *tri ) + numVerts * sizeof( tri->verts[0] ) + numIndexes * sizeof( tri->indexes[0] ), h_low ); tri->surfaceType = SF_TRIANGLES; tri->numVerts = numVerts; tri->numIndexes = numIndexes; tri->verts = (drawVert_t *)(tri + 1); tri->indexes = (int *)(tri->verts + tri->numVerts ); surf->data = (surfaceType_t *)tri; // copy vertexes ClearBounds( tri->bounds[0], tri->bounds[1] ); verts += LittleLong( ds->firstVert ); for ( i = 0 ; i < numVerts ; i++ ) { for ( j = 0 ; j < 3 ; j++ ) { tri->verts[i].xyz[j] = LittleFloat( verts[i].xyz[j] ); tri->verts[i].normal[j] = LittleFloat( verts[i].normal[j] ); } AddPointToBounds( tri->verts[i].xyz, tri->bounds[0], tri->bounds[1] ); for ( j = 0 ; j < 2 ; j++ ) { tri->verts[i].st[j] = LittleFloat( verts[i].st[j] ); tri->verts[i].lightmap[j] = LittleFloat( verts[i].lightmap[j] ); } R_ColorShiftLightingBytes( verts[i].color, tri->verts[i].color ); } // copy indexes indexes += LittleLong( ds->firstIndex ); for ( i = 0 ; i < numIndexes ; i++ ) { tri->indexes[i] = LittleLong( indexes[i] ); if ( tri->indexes[i] < 0 || tri->indexes[i] >= numVerts ) { ri.Error( ERR_DROP, "Bad index in triangle surface" ); } } }

Here is the call graph for this function:

void R_ColorShiftLightingBytes (  byte  in[4], byte  out[4] )  [static]

Definition at line 100 of file tr_bsp.c. References b, byte, g(), in, cvar_s::integer, max, trGlobals_t::overbrightBits, r, r_mapOverBrightBits, shift, and tr. Referenced by ParseFace(), ParseMesh(), ParseTriSurf(), R_LoadLightGrid(), and R_LoadLightmaps(). { int shift, r, g, b; // shift the color data based on overbright range shift = r_mapOverBrightBits->integer - tr.overbrightBits; // shift the data based on overbright range r = in[0] << shift; g = in[1] << shift; b = in[2] << shift; // normalize by color instead of saturating to white if ( ( r | g | b ) > 255 ) { int max; max = r > g ? r : g; max = max > b ? max : b; r = r * 255 / max; g = g * 255 / max; b = b * 255 / max; } out[0] = r; out[1] = g; out[2] = b; out[3] = in[3]; }

Here is the call graph for this function:

void R_FixSharedVertexLodError (  void   )

Definition at line 690 of file tr_bsp.c. References msurface_s::data, i, srfGridMesh_s::lodFixed, world_t::numsurfaces, R_FixSharedVertexLodError_r(), s_worldData, srfGridMesh_t, world_t::surfaces, and srfGridMesh_s::surfaceType. Referenced by R_LoadSurfaces(). { int i; srfGridMesh_t *grid1; for ( i = 0; i < s_worldData.numsurfaces; i++ ) { // grid1 = (srfGridMesh_t *) s_worldData.surfaces[i].data; // if this surface is not a grid if ( grid1->surfaceType != SF_GRID ) continue; // if ( grid1->lodFixed ) continue; // grid1->lodFixed = 2; // recursively fix other patches in the same LOD group R_FixSharedVertexLodError_r( i + 1, grid1); } }

Here is the call graph for this function:

void R_FixSharedVertexLodError_r (  int  start, srfGridMesh_t *  grid1 )

Definition at line 578 of file tr_bsp.c. References msurface_s::data, fabs(), srfGridMesh_s::height, srfGridMesh_s::heightLodError, j, k, l, srfGridMesh_s::lodFixed, srfGridMesh_s::lodOrigin, srfGridMesh_s::lodRadius, m, n, world_t::numsurfaces, R_MergedHeightPoints(), R_MergedWidthPoints(), s_worldData, srfGridMesh_t, world_t::surfaces, srfGridMesh_s::surfaceType, srfGridMesh_s::verts, srfGridMesh_s::width, srfGridMesh_s::widthLodError, and drawVert_t::xyz. Referenced by R_FixSharedVertexLodError(). { int j, k, l, m, n, offset1, offset2, touch; srfGridMesh_t *grid2; for ( j = start; j < s_worldData.numsurfaces; j++ ) { // grid2 = (srfGridMesh_t *) s_worldData.surfaces[j].data; // if this surface is not a grid if ( grid2->surfaceType != SF_GRID ) continue; // if the LOD errors are already fixed for this patch if ( grid2->lodFixed == 2 ) continue; // grids in the same LOD group should have the exact same lod radius if ( grid1->lodRadius != grid2->lodRadius ) continue; // grids in the same LOD group should have the exact same lod origin if ( grid1->lodOrigin[0] != grid2->lodOrigin[0] ) continue; if ( grid1->lodOrigin[1] != grid2->lodOrigin[1] ) continue; if ( grid1->lodOrigin[2] != grid2->lodOrigin[2] ) continue; // touch = qfalse; for (n = 0; n < 2; n++) { // if (n) offset1 = (grid1->height-1) * grid1->width; else offset1 = 0; if (R_MergedWidthPoints(grid1, offset1)) continue; for (k = 1; k < grid1->width-1; k++) { for (m = 0; m < 2; m++) { if (m) offset2 = (grid2->height-1) * grid2->width; else offset2 = 0; if (R_MergedWidthPoints(grid2, offset2)) continue; for ( l = 1; l < grid2->width-1; l++) { // if ( fabs(grid1->verts[k + offset1].xyz[0] - grid2->verts[l + offset2].xyz[0]) > .1) continue; if ( fabs(grid1->verts[k + offset1].xyz[1] - grid2->verts[l + offset2].xyz[1]) > .1) continue; if ( fabs(grid1->verts[k + offset1].xyz[2] - grid2->verts[l + offset2].xyz[2]) > .1) continue; // ok the points are equal and should have the same lod error grid2->widthLodError[l] = grid1->widthLodError[k]; touch = qtrue; } } for (m = 0; m < 2; m++) { if (m) offset2 = grid2->width-1; else offset2 = 0; if (R_MergedHeightPoints(grid2, offset2)) continue; for ( l = 1; l < grid2->height-1; l++) { // if ( fabs(grid1->verts[k + offset1].xyz[0] - grid2->verts[grid2->width * l + offset2].xyz[0]) > .1) continue; if ( fabs(grid1->verts[k + offset1].xyz[1] - grid2->verts[grid2->width * l + offset2].xyz[1]) > .1) continue; if ( fabs(grid1->verts[k + offset1].xyz[2] - grid2->verts[grid2->width * l + offset2].xyz[2]) > .1) continue; // ok the points are equal and should have the same lod error grid2->heightLodError[l] = grid1->widthLodError[k]; touch = qtrue; } } } } for (n = 0; n < 2; n++) { // if (n) offset1 = grid1->width-1; else offset1 = 0; if (R_MergedHeightPoints(grid1, offset1)) continue; for (k = 1; k < grid1->height-1; k++) { for (m = 0; m < 2; m++) { if (m) offset2 = (grid2->height-1) * grid2->width; else offset2 = 0; if (R_MergedWidthPoints(grid2, offset2)) continue; for ( l = 1; l < grid2->width-1; l++) { // if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[0] - grid2->verts[l + offset2].xyz[0]) > .1) continue; if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[1] - grid2->verts[l + offset2].xyz[1]) > .1) continue; if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[2] - grid2->verts[l + offset2].xyz[2]) > .1) continue; // ok the points are equal and should have the same lod error grid2->widthLodError[l] = grid1->heightLodError[k]; touch = qtrue; } } for (m = 0; m < 2; m++) { if (m) offset2 = grid2->width-1; else offset2 = 0; if (R_MergedHeightPoints(grid2, offset2)) continue; for ( l = 1; l < grid2->height-1; l++) { // if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[0] - grid2->verts[grid2->width * l + offset2].xyz[0]) > .1) continue; if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[1] - grid2->verts[grid2->width * l + offset2].xyz[1]) > .1) continue; if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[2] - grid2->verts[grid2->width * l + offset2].xyz[2]) > .1) continue; // ok the points are equal and should have the same lod error grid2->heightLodError[l] = grid1->heightLodError[k]; touch = qtrue; } } } } if (touch) { grid2->lodFixed = 2; R_FixSharedVertexLodError_r ( start, grid2 ); //NOTE: this would be correct but makes things really slow //grid2->lodFixed = 1; } } }

Here is the call graph for this function:

qboolean R_GetEntityToken (  char *  buffer, int  size )

Definition at line 1769 of file tr_bsp.c. References buffer, COM_Parse(), world_t::entityParsePoint, world_t::entityString, Q_strncpyz(), qboolean, s, and s_worldData. { const char *s; s = COM_Parse( &s_worldData.entityParsePoint ); Q_strncpyz( buffer, s, size ); if ( !s_worldData.entityParsePoint || !s[0] ) { s_worldData.entityParsePoint = s_worldData.entityString; return qfalse; } else { return qtrue; } }

Here is the call graph for this function:

void R_LoadEntities (  lump_t *  l  )

Definition at line 1689 of file tr_bsp.c. References COM_ParseExt(), world_t::entityParsePoint, world_t::entityString, fileBase, lump_t::filelen, lump_t::fileofs, h_low, refimport_t::Hunk_Alloc, cvar_s::integer, l, world_t::lightGridSize, p, PRINT_WARNING, Q_stricmp(), Q_strncmp(), Q_strncpyz(), qtrue, R_RemapShader(), r_vertexLight, ri, s, sscanf(), strchr(), strcpy(), strlen(), token, value, and w. Referenced by RE_LoadWorldMap(). { char *p, *token, *s; char keyname[MAX_TOKEN_CHARS]; char value[MAX_TOKEN_CHARS]; world_t *w; w = &s_worldData; w->lightGridSize[0] = 64; w->lightGridSize[1] = 64; w->lightGridSize[2] = 128; p = (char *)(fileBase + l->fileofs); // store for reference by the cgame w->entityString = ri.Hunk_Alloc( l->filelen + 1, h_low ); strcpy( w->entityString, p ); w->entityParsePoint = w->entityString; token = COM_ParseExt( &p, qtrue ); if (!*token || *token != '{') { return; } // only parse the world spawn while ( 1 ) { // parse key token = COM_ParseExt( &p, qtrue ); if ( !*token || *token == '}' ) { break; } Q_strncpyz(keyname, token, sizeof(keyname)); // parse value token = COM_ParseExt( &p, qtrue ); if ( !*token || *token == '}' ) { break; } Q_strncpyz(value, token, sizeof(value)); // check for remapping of shaders for vertex lighting s = "vertexremapshader"; if (!Q_strncmp(keyname, s, strlen(s)) ) { s = strchr(value, ';'); if (!s) { ri.Printf( PRINT_WARNING, "WARNING: no semi colon in vertexshaderremap '%s'\n", value ); break; } *s++ = 0; if (r_vertexLight->integer) { R_RemapShader(value, s, "0"); } continue; } // check for remapping of shaders s = "remapshader"; if (!Q_strncmp(keyname, s, strlen(s)) ) { s = strchr(value, ';'); if (!s) { ri.Printf( PRINT_WARNING, "WARNING: no semi colon in shaderremap '%s'\n", value ); break; } *s++ = 0; R_RemapShader(value, s, "0"); continue; } // check for a different grid size if (!Q_stricmp(keyname, "gridsize")) { sscanf(value, "%f %f %f", &w->lightGridSize[0], &w->lightGridSize[1], &w->lightGridSize[2] ); continue; } } }

Here is the call graph for this function:

void R_LoadFogs (  lump_t *  l, lump_t *  brushesLump, lump_t *  sidesLump )  [static]

Definition at line 1529 of file tr_bsp.c. References dfog_t::brushNum, fogParms_t::color, ColorBytes4(), count, d, fogParms_t::depthForOpaque, cplane_s::dist, ERR_DROP, fileBase, lump_t::filelen, lump_t::fileofs, dbrush_t::firstSide, shader_s::fogParms, world_t::fogs, h_low, refimport_t::Hunk_Alloc, i, trGlobals_t::identityLight, l, LIGHTMAP_NONE, LittleLong(), world_t::name, cplane_s::normal, world_t::numfogs, world_t::planes, qtrue, R_FindShader(), ri, s_worldData, dfog_t::shader, shader_t, tr, vec3_origin, VectorSubtract, and dfog_t::visibleSide. Referenced by RE_LoadWorldMap(). { int i; fog_t *out; dfog_t *fogs; dbrush_t *brushes, *brush; dbrushside_t *sides; int count, brushesCount, sidesCount; int sideNum; int planeNum; shader_t *shader; float d; int firstSide; fogs = (void *)(fileBase + l->fileofs); if (l->filelen % sizeof(*fogs)) { ri.Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name); } count = l->filelen / sizeof(*fogs); // create fog strucutres for them s_worldData.numfogs = count + 1; s_worldData.fogs = ri.Hunk_Alloc ( s_worldData.numfogs*sizeof(*out), h_low); out = s_worldData.fogs + 1; if ( !count ) { return; } brushes = (void *)(fileBase + brushesLump->fileofs); if (brushesLump->filelen % sizeof(*brushes)) { ri.Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name); } brushesCount = brushesLump->filelen / sizeof(*brushes); sides = (void *)(fileBase + sidesLump->fileofs); if (sidesLump->filelen % sizeof(*sides)) { ri.Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name); } sidesCount = sidesLump->filelen / sizeof(*sides); for ( i=0 ; i<count ; i++, fogs++) { out->originalBrushNumber = LittleLong( fogs->brushNum ); if ( (unsigned)out->originalBrushNumber >= brushesCount ) { ri.Error( ERR_DROP, "fog brushNumber out of range" ); } brush = brushes + out->originalBrushNumber; firstSide = LittleLong( brush->firstSide ); if ( (unsigned)firstSide > sidesCount - 6 ) { ri.Error( ERR_DROP, "fog brush sideNumber out of range" ); } // brushes are always sorted with the axial sides first sideNum = firstSide + 0; planeNum = LittleLong( sides[ sideNum ].planeNum ); out->bounds[0][0] = -s_worldData.planes[ planeNum ].dist; sideNum = firstSide + 1; planeNum = LittleLong( sides[ sideNum ].planeNum ); out->bounds[1][0] = s_worldData.planes[ planeNum ].dist; sideNum = firstSide + 2; planeNum = LittleLong( sides[ sideNum ].planeNum ); out->bounds[0][1] = -s_worldData.planes[ planeNum ].dist; sideNum = firstSide + 3; planeNum = LittleLong( sides[ sideNum ].planeNum ); out->bounds[1][1] = s_worldData.planes[ planeNum ].dist; sideNum = firstSide + 4; planeNum = LittleLong( sides[ sideNum ].planeNum ); out->bounds[0][2] = -s_worldData.planes[ planeNum ].dist; sideNum = firstSide + 5; planeNum = LittleLong( sides[ sideNum ].planeNum ); out->bounds[1][2] = s_worldData.planes[ planeNum ].dist; // get information from the shader for fog parameters shader =