From 952c5c128f9efaea89d41d882c4ea3ade7df4591 Mon Sep 17 00:00:00 2001 From: zakk Date: Fri, 26 Aug 2005 04:48:05 +0000 Subject: Itsa me, quake3io! git-svn-id: svn://svn.icculus.org/quake3/trunk@2 edf5b092-35ff-0310-97b2-ce42778d08ea --- q3map/fog.c | 554 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 554 insertions(+) create mode 100755 q3map/fog.c (limited to 'q3map/fog.c') diff --git a/q3map/fog.c b/q3map/fog.c new file mode 100755 index 0000000..cf4060a --- /dev/null +++ b/q3map/fog.c @@ -0,0 +1,554 @@ +/* +=========================================================================== +Copyright (C) 1999-2005 Id Software, Inc. + +This file is part of Quake III Arena source code. + +Quake III Arena source code 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. + +Quake III Arena source code 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 Foobar; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +=========================================================================== +*/ +#include "qbsp.h" + + +int c_fogFragment; +int c_fogPatchFragments; + +/* +==================== +DrawSurfToMesh +==================== +*/ +mesh_t *DrawSurfToMesh( mapDrawSurface_t *ds ) { + mesh_t *m; + + m = malloc( sizeof( *m ) ); + m->width = ds->patchWidth; + m->height = ds->patchHeight; + m->verts = malloc( sizeof(m->verts[0]) * m->width * m->height ); + memcpy( m->verts, ds->verts, sizeof(m->verts[0]) * m->width * m->height ); + + return m; +} + + +/* +==================== +SplitMeshByPlane +==================== +*/ +void SplitMeshByPlane( mesh_t *in, vec3_t normal, float dist, mesh_t **front, mesh_t **back ) { + int w, h, split; + float d[MAX_PATCH_SIZE][MAX_PATCH_SIZE]; + drawVert_t *dv, *v1, *v2; + int c_front, c_back, c_on; + mesh_t *f, *b; + int i; + float frac; + int frontAprox, backAprox; + + for ( i = 0 ; i < 2 ; i++ ) { + dv = in->verts; + c_front = 0; + c_back = 0; + c_on = 0; + for ( h = 0 ; h < in->height ; h++ ) { + for ( w = 0 ; w < in->width ; w++, dv++ ) { + d[h][w] = DotProduct( dv->xyz, normal ) - dist; + if ( d[h][w] > ON_EPSILON ) { + c_front++; + } else if ( d[h][w] < -ON_EPSILON ) { + c_back++; + } else { + c_on++; + } + } + } + + *front = NULL; + *back = NULL; + + if ( !c_front ) { + *back = in; + return; + } + if ( !c_back ) { + *front = in; + return; + } + + // find a split point + split = -1; + for ( w = 0 ; w < in->width -1 ; w++ ) { + if ( ( d[0][w] < 0 ) != ( d[0][w+1] < 0 ) ) { + if ( split == -1 ) { + split = w; + break; + } + } + } + + if ( split == -1 ) { + if ( i == 1 ) { + qprintf( "No crossing points in patch\n"); + *front = in; + return; + } + + in = TransposeMesh( in ); + InvertMesh( in ); + continue; + } + + // make sure the split point stays the same for all other rows + for ( h = 1 ; h < in->height ; h++ ) { + for ( w = 0 ; w < in->width -1 ; w++ ) { + if ( ( d[h][w] < 0 ) != ( d[h][w+1] < 0 ) ) { + if ( w != split ) { + _printf( "multiple crossing points for patch -- can't clip\n"); + *front = in; + return; + } + } + } + if ( ( d[h][split] < 0 ) == ( d[h][split+1] < 0 ) ) { + _printf( "differing crossing points for patch -- can't clip\n"); + *front = in; + return; + } + } + + break; + } + + + // create two new meshes + f = malloc( sizeof( *f ) ); + f->width = split + 2; + if ( ! (f->width & 1) ) { + f->width++; + frontAprox = 1; + } else { + frontAprox = 0; + } + if ( f->width > MAX_PATCH_SIZE ) { + Error( "MAX_PATCH_SIZE after split"); + } + f->height = in->height; + f->verts = malloc( sizeof(f->verts[0]) * f->width * f->height ); + + b = malloc( sizeof( *b ) ); + b->width = in->width - split; + if ( ! (b->width & 1) ) { + b->width++; + backAprox = 1; + } else { + backAprox = 0; + } + if ( b->width > MAX_PATCH_SIZE ) { + Error( "MAX_PATCH_SIZE after split"); + } + b->height = in->height; + b->verts = malloc( sizeof(b->verts[0]) * b->width * b->height ); + + if ( d[0][0] > 0 ) { + *front = f; + *back = b; + } else { + *front = b; + *back = f; + } + + // distribute the points + for ( w = 0 ; w < in->width ; w++ ) { + for ( h = 0 ; h < in->height ; h++ ) { + if ( w <= split ) { + f->verts[ h * f->width + w ] = in->verts[ h * in->width + w ]; + } else { + b->verts[ h * b->width + w - split + backAprox ] = in->verts[ h * in->width + w ]; + } + } + } + + // clip the crossing line + for ( h = 0 ; h < in->height ; h++ ) { + dv = &f->verts[ h * f->width + split + 1 ]; + v1 = &in->verts[ h * in->width + split ]; + v2 = &in->verts[ h * in->width + split + 1 ]; + frac = d[h][split] / ( d[h][split] - d[h][split+1] ); + for ( i = 0 ; i < 10 ; i++ ) { + dv->xyz[i] = v1->xyz[i] + frac * ( v2->xyz[i] - v1->xyz[i] ); + } + dv->xyz[10] = 0;//set all 4 colors to 0 + if ( frontAprox ) { + f->verts[ h * f->width + split + 2 ] = *dv; + } + b->verts[ h * b->width ] = *dv; + if ( backAprox ) { + b->verts[ h * b->width + 1 ] = *dv; + } + } + + /* +PrintMesh( in ); +_printf("\n"); +PrintMesh( f ); +_printf("\n"); +PrintMesh( b ); +_printf("\n"); + */ + + FreeMesh( in ); +} + + +/* +==================== +ChopPatchByBrush +==================== +*/ +qboolean ChopPatchByBrush( mapDrawSurface_t *ds, bspbrush_t *b ) { + int i, j; + side_t *s; + plane_t *plane; + mesh_t *outside[MAX_BRUSH_SIDES]; + int numOutside; + mesh_t *m, *front, *back; + mapDrawSurface_t *newds; + + m = DrawSurfToMesh( ds ); + numOutside = 0; + + // only split by the top and bottom planes to avoid + // some messy patch clipping issues + + for ( i = 4 ; i <= 5 ; i++ ) { + s = &b->sides[ i ]; + plane = &mapplanes[ s->planenum ]; + + SplitMeshByPlane( m, plane->normal, plane->dist, &front, &back ); + + if ( !back ) { + // nothing actually contained inside + for ( j = 0 ; j < numOutside ; j++ ) { + FreeMesh( outside[j] ); + } + return qfalse; + } + m = back; + + if ( front ) { + if ( numOutside == MAX_BRUSH_SIDES ) { + Error( "MAX_BRUSH_SIDES" ); + } + outside[ numOutside ] = front; + numOutside++; + } + } + + // all of outside fragments become seperate drawsurfs + c_fogPatchFragments += numOutside; + for ( i = 0 ; i < numOutside ; i++ ) { + newds = DrawSurfaceForMesh( outside[ i ] ); + newds->shaderInfo = ds->shaderInfo; + FreeMesh( outside[ i ] ); + } + + // replace ds with m + ds->patchWidth = m->width; + ds->patchHeight = m->height; + ds->numVerts = m->width * m->height; + free( ds->verts ); + ds->verts = malloc( ds->numVerts * sizeof( *ds->verts ) ); + memcpy( ds->verts, m->verts, ds->numVerts * sizeof( *ds->verts ) ); + + FreeMesh( m ); + + return qtrue; +} + +//=============================================================================== + +/* +==================== +WindingFromDrawSurf +==================== +*/ +winding_t *WindingFromDrawSurf( mapDrawSurface_t *ds ) { + winding_t *w; + int i; + + w = AllocWinding( ds->numVerts ); + w->numpoints = ds->numVerts; + for ( i = 0 ; i < ds->numVerts ; i++ ) { + VectorCopy( ds->verts[i].xyz, w->p[i] ); + } + return w; +} + +/* +==================== +ChopFaceByBrush + +There may be a fragment contained in the brush +==================== +*/ +qboolean ChopFaceByBrush( mapDrawSurface_t *ds, bspbrush_t *b ) { + int i, j; + side_t *s; + plane_t *plane; + winding_t *w; + winding_t *front, *back; + winding_t *outside[MAX_BRUSH_SIDES]; + int numOutside; + mapDrawSurface_t *newds; + drawVert_t *dv; + shaderInfo_t *si; + float mins[2]; + + // brush primitive : + // axis base + vec3_t texX,texY; + vec_t x,y; + + w = WindingFromDrawSurf( ds ); + numOutside = 0; + + for ( i = 0 ; i < b->numsides ; i++ ) { + s = &b->sides[ i ]; + if ( s->backSide ) { + continue; + } + plane = &mapplanes[ s->planenum ]; + + // handle coplanar outfacing (don't fog) + if ( ds->side->planenum == s->planenum ) { + return qfalse; + } + + // handle coplanar infacing (keep inside) + if ( ( ds->side->planenum ^ 1 ) == s->planenum ) { + continue; + } + + // general case + ClipWindingEpsilon( w, plane->normal, plane->dist, ON_EPSILON, + &front, &back ); + FreeWinding( w ); + if ( !back ) { + // nothing actually contained inside + for ( j = 0 ; j < numOutside ; j++ ) { + FreeWinding( outside[j] ); + } + return qfalse; + } + if ( front ) { + if ( numOutside == MAX_BRUSH_SIDES ) { + Error( "MAX_BRUSH_SIDES" ); + } + outside[ numOutside ] = front; + numOutside++; + } + w = back; + } + + // all of outside fragments become seperate drawsurfs + // linked to the same side + c_fogFragment += numOutside; + s = ds->side; + + for ( i = 0 ; i < numOutside ; i++ ) { + newds = DrawSurfaceForSide( ds->mapBrush, s, outside[i] ); + FreeWinding( outside[i] ); + } + + + // replace ds->verts with the verts for w + ds->numVerts = w->numpoints; + free( ds->verts ); + + ds->verts = malloc( ds->numVerts * sizeof( *ds->verts ) ); + memset( ds->verts, 0, ds->numVerts * sizeof( *ds->verts ) ); + + si = s->shaderInfo; + + mins[0] = 9999; + mins[1] = 9999; + + // compute s/t coordinates from brush primitive texture matrix + // compute axis base + ComputeAxisBase( mapplanes[s->planenum].normal, texX, texY ); + + for ( j = 0 ; j < w->numpoints ; j++ ) { + dv = ds->verts + j; + VectorCopy( w->p[j], dv->xyz ); + + if (g_bBrushPrimit==BPRIMIT_OLDBRUSHES) + { + // calculate texture s/t + dv->st[0] = s->vecs[0][3] + DotProduct( s->vecs[0], dv->xyz ); + dv->st[1] = s->vecs[1][3] + DotProduct( s->vecs[1], dv->xyz ); + dv->st[0] /= si->width; + dv->st[1] /= si->height; + } + else + { + // calculate texture s/t from brush primitive texture matrix + x = DotProduct( dv->xyz, texX ); + y = DotProduct( dv->xyz, texY ); + dv->st[0]=s->texMat[0][0]*x+s->texMat[0][1]*y+s->texMat[0][2]; + dv->st[1]=s->texMat[1][0]*x+s->texMat[1][1]*y+s->texMat[1][2]; + } + + if ( dv->st[0] < mins[0] ) { + mins[0] = dv->st[0]; + } + if ( dv->st[1] < mins[1] ) { + mins[1] = dv->st[1]; + } + + // copy normal + VectorCopy ( mapplanes[s->planenum].normal, dv->normal ); + } + + // adjust the texture coordinates to be as close to 0 as possible + if ( !si->globalTexture ) { + mins[0] = floor( mins[0] ); + mins[1] = floor( mins[1] ); + for ( i = 0 ; i < w->numpoints ; i++ ) { + dv = ds->verts + i; + dv->st[0] -= mins[0]; + dv->st[1] -= mins[1]; + } + } + + return qtrue; +} + +//=============================================================================== + + +/* +===================== +FogDrawSurfs + +Call after the surface list has been pruned, +before tjunction fixing +before lightmap allocation +===================== +*/ +void FogDrawSurfs( void ) { + int i, j, k; + mapDrawSurface_t *ds; + bspbrush_t *b; + vec3_t mins, maxs; + int c_fogged; + int numBaseDrawSurfs; + dfog_t *fog; + + qprintf("----- FogDrawsurfs -----\n"); + + c_fogged = 0; + c_fogFragment = 0; + + // find all fog brushes + for ( b = entities[0].brushes ; b ; b = b->next ) { + if ( !(b->contents & CONTENTS_FOG) ) { + continue; + } + + if ( numFogs == MAX_MAP_FOGS ) { + Error( "MAX_MAP_FOGS" ); + } + fog = &dfogs[numFogs]; + numFogs++; + fog->brushNum = b->outputNumber; + + // find a side with a valid shaderInfo + // non-axial fog columns may have bevel planes that need to be skipped + for ( i = 0 ; i < b->numsides ; i++ ) { + if ( b->sides[i].shaderInfo && (b->sides[i].shaderInfo->contents & CONTENTS_FOG) ) { + strcpy( fog->shader, b->sides[i].shaderInfo->shader ); + break; + } + } + if ( i == b->numsides ) { + continue; // shouldn't happen + } + + fog->visibleSide = -1; + + // clip each surface into this, but don't clip any of + // the resulting fragments to the same brush + numBaseDrawSurfs = numMapDrawSurfs; + for ( i = 0 ; i < numBaseDrawSurfs ; i++ ) { + ds = &mapDrawSurfs[i]; + + // bound the drawsurf + ClearBounds( mins, maxs ); + for ( j = 0 ; j < ds->numVerts ; j++ ) { + AddPointToBounds( ds->verts[j].xyz, mins, maxs ); + } + + // check against the fog brush + for ( k = 0 ; k < 3 ; k++ ) { + if ( mins[k] > b->maxs[k] ) { + break; + } + if ( maxs[k] < b->mins[k] ) { + break; + } + } + if ( k < 3 ) { + continue; // bboxes don't intersect + } + + if ( ds->mapBrush == b ) { + int s; + + s = ds->side - b->sides; + if ( s <= 6 ) { // not one of the reversed inside faces + // this is a visible fog plane + if ( fog->visibleSide != -1 ) { + _printf( "WARNING: fog brush %i has multiple visible sides\n", b->brushnum ); + } + fog->visibleSide = s; + } + } + + if ( ds->miscModel ) { + // we could write splitting code for trimodels if we wanted to... + c_fogged++; + ds->fogNum = numFogs - 1; + } else if ( ds->patch ) { + if ( ChopPatchByBrush( ds, b ) ) { + c_fogged++; + ds->fogNum = numFogs - 1; + } + } else { + if ( ChopFaceByBrush( ds, b ) ) { + c_fogged++; + ds->fogNum = numFogs - 1; + } + } + } + } + + // split the drawsurfs by the fog brushes + + qprintf( "%5i fogs\n", numFogs ); + qprintf( "%5i fog polygon fragments\n", c_fogFragment ); + qprintf( "%5i fog patch fragments\n", c_fogPatchFragments ); + qprintf( "%5i fogged drawsurfs\n", c_fogged ); +} -- cgit v1.2.3