mirror of
https://github.com/UberGames/lilium-voyager.git
synced 2024-12-14 22:20:58 +00:00
554 lines
12 KiB
C
554 lines
12 KiB
C
/*
|
|
===========================================================================
|
|
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 );
|
|
}
|